**Wir stellen vor: ein neues Konsolenerlebnis für AWS WAF**

Sie können das aktualisierte Erlebnis jetzt verwenden, um überall in der Konsole auf AWS WAF Funktionen zuzugreifen. Weitere Informationen finden Sie unter [Arbeiten mit der Konsole](https://docs.aws.amazon.com/waf/latest/developerguide/working-with-console.html). 

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Integrationen von Client-Anwendungen in AWS WAF
<a name="waf-application-integration"></a>

In diesem Abschnitt wird erklärt, wie Sie die intelligente Bedrohungsintegration APIs und die JavaScript CAPTCHA-Integrations-API mit Ihren Funktionen verwenden können. AWS WAF 

Verwenden Sie die AWS WAF Client-Anwendungsintegration APIs , um clientseitige Schutzmaßnahmen mit Ihren AWS serverseitigen Schutzpaketen (Web-ACL) zu verknüpfen. So können Sie sicherstellen, dass es sich bei den Client-Anwendungen, die Webanfragen an Ihre geschützten Ressourcen senden, um die vorgesehenen Clients handelt und dass es sich bei Ihren Endbenutzern um Menschen handelt. 

Verwenden Sie die Client-Integrationen, um Browser-Herausforderungen und CAPTCHA-Rätsel im Hintergrund zu bewältigen, Tokens mit dem Nachweis erfolgreicher Browser- und Endbenutzerantworten zu erhalten und diese Token in Anfragen an Ihre geschützten Endgeräte aufzunehmen. Allgemeine Informationen AWS WAF zu Tokens finden Sie unter. [Verwendung von Token bei der AWS WAF intelligenten Bedrohungsabwehr](waf-tokens.md) 

Kombinieren Sie Ihre Client-Integrationen mit Schutzpaketen (Web ACL), die gültige Token für den Zugriff auf Ihre Ressourcen erfordern. Sie können Regelgruppen verwenden, die Challenge-Token prüfen und überwachen, wie sie im nächsten Abschnitt unter aufgeführt sind[Intelligente Bedrohungsintegration und AWS verwaltete Regeln](waf-application-integration-with-AMRs.md), und Sie können die Aktionen CAPTCHA und Challenge Regeln zur Überprüfung verwenden, wie unter beschrieben. [CAPTCHAund Challenge in AWS WAF](waf-captcha-and-challenge.md) 

AWS WAF bietet zwei Integrationsebenen für JavaScript Anwendungen und eine für mobile Anwendungen: 
+ **Intelligente Integration von Bedrohungen** — Verifizierung der Client-Anwendung und Bereitstellung von AWS Token-Erfassung und -Verwaltung. Dies ähnelt der Funktionalität, die durch die AWS WAF Challenge Regelaktion bereitgestellt wird. Diese Funktionalität integriert Ihre Client-Anwendung vollständig in die `AWSManagedRulesACFPRuleSet` verwaltete Regelgruppe, die `AWSManagedRulesATPRuleSet` verwaltete Regelgruppe und die Zielschutzebene der `AWSManagedRulesBotControlRuleSet` verwalteten Regelgruppe. 

  Die intelligente Bedrohungsintegration stellt APIs mithilfe der AWS WAF Silent Browser Challenge sicher, dass Anmeldeversuche und andere Aufrufe Ihrer geschützten Ressource erst zulässig sind, nachdem der Client ein gültiges Token erworben hat. APIs Sie verwalten die Token-Autorisierung für Ihre Client-Anwendungssitzungen und sammeln Informationen über den Client, um festzustellen, ob er von einem Bot oder von einem Menschen betrieben wird. 
**Anmerkung**  
Dies ist für JavaScript und für mobile Android- und iOS-Anwendungen verfügbar. 
+ **CAPTCHA-Integration** — Verifizieren Sie Endbenutzer mit einem maßgeschneiderten CAPTCHA-Puzzle, das Sie in Ihrer Anwendung verwalten. Dies ähnelt der Funktionalität, die durch die AWS WAF CAPTCHA Regelaktion bereitgestellt wird, bietet jedoch zusätzliche Kontrolle über die Platzierung und das Verhalten der Rätsel. 

  Diese Integration nutzt die JavaScript intelligente Bedrohungsintegration, um Herausforderungen im Hintergrund auszuführen und AWS WAF Tokens auf der Kundenseite bereitzustellen. 
**Anmerkung**  
Dies ist für JavaScript Anwendungen verfügbar. 

**Topics**
+ [Intelligente Bedrohungsintegration und AWS verwaltete Regeln](waf-application-integration-with-AMRs.md)
+ [Zugreifen auf die Integration der AWS WAF Client-Anwendung APIs](waf-application-integration-location-in-console.md)
+ [AWS WAF JavaScript Integrationen](waf-javascript-api.md)
+ [AWS WAF Integration mobiler Anwendungen](waf-mobile-sdk.md)

# Intelligente Bedrohungsintegration und AWS verwaltete Regeln
<a name="waf-application-integration-with-AMRs"></a>

In diesem Abschnitt wird erklärt, wie die intelligente Bedrohungsintegration mit den Regelgruppen für AWS verwaltete Regeln APIs funktioniert.

Die intelligente Bedrohungsintegration APIs arbeitet mit Schutzpaketen (Web ACLs) zusammen, die die Regelgruppen für intelligente Bedrohungen verwenden, um die volle Funktionalität dieser erweiterten verwalteten Regelgruppen zu ermöglichen. 
+ AWS WAF Verwaltete Regelgruppe `AWSManagedRulesACFPRuleSet` zur Erstellung von Fraud Control-Konten zur Betrugsprävention (ACFP). 

  Betrug bei der Kontoerstellung ist eine illegale Online-Aktivität, bei der ein Angreifer ungültige Konten in Ihrer Anwendung erstellt, um beispielsweise Anmeldeboni zu erhalten oder sich als jemand auszugeben. Die verwaltete ACFP-Regelgruppe bietet Regeln zum Blockieren, Kennzeichnen und Verwalten von Anfragen, die Teil betrügerischer Kontoerstellungsversuche sein könnten. Sie APIs ermöglichen eine fein abgestimmte Überprüfung des Client-Browsers und Informationen zur Benutzerinteraktivität, anhand derer die ACFP-Regeln gültigen Client-Verkehr von bösartigem Datenverkehr trennen.

  Weitere Informationen erhalten Sie unter [AWS WAF Regelgruppe Betrugsprävention (ACFP) zur Kontoerstellung bei der Betrugsbekämpfung](aws-managed-rule-groups-acfp.md) und [AWS WAF Einrichtung von Konten bei der Betrugsbekämpfung und Betrugsprävention (ACFP)](waf-acfp.md).
+ AWS WAF Von Fraud Control verwaltete Regelgruppe zur Verhinderung von Kontoübernahmen (ATP). `AWSManagedRulesATPRuleSet` 

  Kontoübernahmen sind eine illegale Online-Aktivität, bei der sich ein Angreifer unbefugten Zugriff auf das Konto einer anderen Person verschafft. Die von ATP verwaltete Regelgruppe bietet Regeln zum Blockieren, Kennzeichnen und Verwalten von Anfragen, die Teil böswilliger Kontoübernahmeversuche sein könnten. Sie APIs ermöglichen eine fein abgestimmte Client-Überprüfung und Verhaltensaggregation, anhand derer die ATP-Regeln gültigen Client-Verkehr von bösartigem Datenverkehr trennen.

  Weitere Informationen erhalten Sie unter [AWS WAF Regelgruppe zur Verhinderung von Kontoübernahmen (ATP) zur Betrugsbekämpfung](aws-managed-rule-groups-atp.md) und [AWS WAF Verhinderung von Kontoübernahmen bei der Betrugsbekämpfung (ATP)](waf-atp.md).
+ Gezielte Schutzstufe der von AWS WAF Bot Control verwalteten Regelgruppe. `AWSManagedRulesBotControlRuleSet` 

  Die Palette der Bots reicht von selbstidentifizierenden und nützlichen Bots, wie die meisten Suchmaschinen und Crawler, bis hin zu bösartigen Bots, die Ihre Website angreifen und sich nicht selbst identifizieren. Die verwaltete Regelgruppe von Bot Control bietet Regeln zur Überwachung, Kennzeichnung und Verwaltung der Bot-Aktivitäten in Ihrem Web-Traffic. Wenn Sie die gezielte Schutzstufe dieser Regelgruppe verwenden, verwenden die gezielten Regeln die von ihnen APIs bereitgestellten Client-Sitzungsinformationen, um böswillige Bots besser erkennen zu können. 

  Weitere Informationen erhalten Sie unter [AWS WAF Regelgruppe „Bot-Kontrolle“](aws-managed-rule-groups-bot.md) und [AWS WAF Bot-Steuerung](waf-bot-control.md).

Informationen zum Hinzufügen einer dieser verwalteten Regelgruppen zu Ihrem Schutzpaket (Web-ACL) finden Sie in den Verfahren [Hinzufügen der verwalteten ACFP-Regelgruppe zu Ihrer Web-ACL](waf-acfp-rg-using.md)[Hinzufügen der von ATP verwalteten Regelgruppe zu Ihrem Protection Pack (Web-ACL)](waf-atp-rg-using.md), und[Hinzufügen der von AWS WAF Bot Control verwalteten Regelgruppe zu Ihrer Web-ACL](waf-bot-control-rg-using.md).

**Anmerkung**  
Die verwalteten Regelgruppen blockieren derzeit keine Anfragen, denen Token fehlen. Um Anfragen zu blockieren, bei denen Token fehlen, folgen Sie nach der Implementierung Ihrer Anwendungsintegration APIs den Anweisungen unter[Anfragen blockieren, die kein gültiges AWS WAF Token haben](waf-tokens-block-missing-tokens.md). 

# Zugreifen auf die Integration der AWS WAF Client-Anwendung APIs
<a name="waf-application-integration-location-in-console"></a>

In diesem Abschnitt wird erklärt, wo die Anwendungsintegration APIs in der AWS WAF Konsole zu finden ist.

Die JavaScript Integration APIs ist allgemein verfügbar, und Sie können sie für Ihre Browser und andere Geräte verwenden, die ausgeführt werden JavaScript. 

AWS WAF bietet maßgeschneiderte intelligente Bedrohungsintegration SDKs für mobile Android- und iOS-Apps. 
+ Für Android-Apps und TV-Apps SDKs funktionieren sie für Android-API-Version 23 (Android-Version 6) und höher. Informationen zu Android-Versionen finden Sie in den [Versionshinweisen zur SDK-Plattform](https://developer.android.com/tools/releases/platforms).
+ Für mobile iOS-Apps SDKs funktionieren sie für iOS-Version 13 und höher. Informationen zu iOS-Versionen findest du in den [Versionshinweisen zu iOS und iPadOS](https://developer.apple.com/documentation/ios-ipados-release-notes).
+ Apple TV-Apps SDKs funktionieren für tvOS Version 14 oder höher. Informationen zu tvOS-Versionen finden Sie in den [tvOS-Versionshinweisen](https://developer.apple.com/documentation/tvos-release-notes).

**So greifen Sie über die Konsole auf die Integration APIs zu**

1. Melden Sie sich bei [https://console.aws.amazon.com/wafv2/homev2](https://console.aws.amazon.com/wafv2/homev2) an AWS-Managementkonsole und öffnen Sie die AWS WAF Konsole. 

1. Wählen Sie im Navigationsbereich **Anwendungsintegration** und dann die Registerkarte aus, an der Sie interessiert sind.
   + Die **intelligente Bedrohungsintegration** ist für JavaScript mobile Anwendungen verfügbar. 

     Die Registerkarte enthält Folgendes:
     + Eine Liste der Schutzpakete (Web ACLs), die für die Integration intelligenter Bedrohungsanwendungen aktiviert sind. Die Liste enthält jedes Schutzpaket (Web-ACL), das die `AWSManagedRulesACFPRuleSet` verwaltete Regelgruppe, die `AWSManagedRulesATPRuleSet` verwaltete Regelgruppe oder die gezielte Schutzebene der `AWSManagedRulesBotControlRuleSet` verwalteten Regelgruppe verwendet. Wenn Sie die intelligente Bedrohung implementieren APIs, verwenden Sie die Integrations-URL für das Schutzpaket (Web-ACL), in das Sie integrieren möchten.
     + Die APIs , auf die Sie Zugriff haben. Die JavaScript APIs sind immer verfügbar. Für den Zugriff auf das Handy wenden Sie SDKs sich an den Support unter [Kontakt AWS](https://aws.amazon.com/contact-us).
   + Die **CAPTCHA-Integration** ist für JavaScript Anwendungen verfügbar. 

     Die Registerkarte enthält Folgendes: 
     + Die Integrations-URL zur Verwendung in Ihrer Integration. 
     + Die API-Schlüssel, die Sie für Ihre Client-Anwendungsdomänen erstellt haben. Ihre Verwendung der CAPTCHA-API erfordert einen verschlüsselten API-Schlüssel, der Kunden das Recht gibt, von ihren Domains aus auf AWS WAF CAPTCHA zuzugreifen. Verwenden Sie für jeden Client, mit dem Sie eine Integration durchführen, einen API-Schlüssel, der die Domain des Kunden enthält. Weitere Informationen zu diesen Anforderungen und zur Verwaltung dieser Schlüssel finden Sie unter[Verwaltung von API-Schlüsseln für die JS-CAPTCHA-API](waf-js-captcha-api-key.md).

# AWS WAF JavaScript Integrationen
<a name="waf-javascript-api"></a>

In diesem Abschnitt wird erklärt, wie die AWS WAF JavaScript Integrationen verwendet werden.

Sie können die JavaScript Integration verwenden APIs , um AWS WAF Anwendungsintegrationen in Ihren Browsern und anderen Geräten zu implementieren, die ausgeführt werden. JavaScript 

CAPTCHA-Rätsel und stille Herausforderungen können nur ausgeführt werden, wenn Browser auf HTTPS-Endpunkte zugreifen. Browser-Clients müssen in sicheren Kontexten ausgeführt werden, um Token zu erhalten. 
+ Die intelligente Bedrohung ermöglicht APIs es Ihnen, die Token-Autorisierung durch eine stille clientseitige Browser-Abfrage zu verwalten und die Token in die Anfragen aufzunehmen, die Sie an Ihre geschützten Ressourcen senden. 
+ Die CAPTCHA-Integrations-API ergänzt die intelligente Bedrohung und ermöglicht es Ihnen APIs, die Platzierung und die Eigenschaften des CAPTCHA-Puzzles in Ihren Client-Anwendungen anzupassen. Diese API nutzt die intelligente Bedrohung, um AWS WAF Token für die Verwendung auf der Seite APIs zu erwerben, nachdem der Endbenutzer das CAPTCHA-Puzzle erfolgreich gelöst hat. 

Durch die Verwendung dieser Integrationen stellen Sie sicher, dass die Remote-Prozedur-Aufrufe Ihres Clients ein gültiges Token enthalten. Wenn diese Integrationen auf den Seiten Ihrer Anwendung vorhanden APIs sind, können Sie in Ihrem Schutzpaket (Web-ACL) Regeln zur Risikominderung implementieren, z. B. das Blockieren von Anfragen, die kein gültiges Token enthalten. Sie können auch Regeln implementieren, die die Verwendung der Token, die Ihre Client-Anwendungen erhalten, erzwingen, indem Sie die CAPTCHA Aktionen Challenge oder in Ihren Regeln verwenden. 

**Beispiel für die Implementierung einer intelligenten Bedrohung APIs**  
Die folgende Liste zeigt die grundlegenden Komponenten einer typischen Implementierung der intelligenten Bedrohung auf APIs einer Webanwendungsseite. 

```
<head>
<script type="text/javascript" src="protection pack (web ACL) integration URL/challenge.js" defer></script>
</head>
<script>
const login_response = await AwsWafIntegration.fetch(login_url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: login_body
  });
</script>
```

**Beispiel für eine Implementierung der CAPTCHA-API JavaScript**  
Mit der CAPTCHA-Integrations-API können Sie das CAPTCHA-Puzzle-Erlebnis Ihrer Endbenutzer individuell anpassen. Die CAPTCHA-Integration nutzt die JavaScript intelligente Bedrohungsintegration für die Browserverifizierung und die Tokenverwaltung und fügt eine Funktion zur Konfiguration und Darstellung des CAPTCHA-Puzzles hinzu. 

Die folgende Liste zeigt die grundlegenden Komponenten einer typischen Implementierung der JavaScript CAPTCHA-API auf einer Webanwendungsseite. 

```
<head>
    <script type="text/javascript" src="<Integration URL>/jsapi.js" defer></script>
</head>

<script type="text/javascript">
    function showMyCaptcha() {
        var container = document.querySelector("#my-captcha-container");
        
        AwsWafCaptcha.renderCaptcha(container, {
            apiKey: "...API key goes here...",
            onSuccess: captchaExampleSuccessFunction,
            onError: captchaExampleErrorFunction,
            ...other configuration parameters as needed...
        });
    }
    
    function captchaExampleSuccessFunction(wafToken) {
        // Use WAF token to access protected resources
        AwsWafIntegration.fetch("...WAF-protected URL...", {
            method: "POST",
            ...
        });
    }
    
    function captchaExampleErrorFunction(error) {
        /* Do something with the error */
    }
</script>

<div id="my-captcha-container">
    <!-- The contents of this container will be replaced by the captcha widget -->
</div>
```

**Topics**
+ [Bereitstellung von Domains zur Verwendung in den Tokens](waf-js-challenge-api-set-token-domain.md)
+ [Verwenden der JavaScript API mit Inhaltssicherheitsrichtlinien](waf-javascript-api-csp.md)
+ [Verwendung der Intelligent Threat JavaScript API](waf-js-challenge-api.md)
+ [Verwenden der CAPTCHA-API JavaScript](waf-js-captcha-api.md)

# Bereitstellung von Domains zur Verwendung in den Tokens
<a name="waf-js-challenge-api-set-token-domain"></a>

In diesem Abschnitt wird erklärt, wie zusätzliche Domänen für Token bereitgestellt werden.

Bei der Erstellung eines AWS WAF Tokens wird standardmäßig die Hostdomäne der Ressource verwendet, die dem Schutzpaket (Web-ACL) zugeordnet ist. Sie können zusätzliche Domänen für die Token bereitstellen, die für den AWS WAF erstellt JavaScript APIs werden. Konfigurieren Sie dazu die globale Variable `window.awsWafCookieDomainList` mit einer oder mehreren Tokendomänen. 

Bei AWS WAF der Erstellung eines Tokens wird die geeignetste, kürzeste Domain aus der Kombination der Domänen in `window.awsWafCookieDomainList` und der Hostdomäne der Ressource verwendet, die dem Protection Pack (Web-ACL) zugeordnet ist. 

Beispieleinstellungen: 

```
window.awsWafCookieDomainList = ['.aws.amazon.com']
```

```
window.awsWafCookieDomainList = ['.aws.amazon.com', 'abc.aws.amazon.com']
```

Sie können in dieser Liste keine öffentlichen Suffixe verwenden. Beispielsweise können Sie `gov.au` oder nicht `co.uk` als Tokendomänen in der Liste verwenden.

Die Domänen, die Sie in dieser Liste angeben, müssen mit Ihren anderen Domänen und Domänenkonfigurationen kompatibel sein: 
+ Bei den Domains muss es sich um solche handeln, die auf der geschützten Host-Domain und der Token-Domainliste basieren, die für das Protection Pack (Web-ACL) konfiguriert ist. AWS WAF Weitere Informationen finden Sie unter [AWS WAF Konfiguration der Token-Domänenliste für das Protection Pack (Web-ACL)](waf-tokens-domains.md#waf-tokens-domain-lists). 
+ Wenn Sie die JavaScript CAPTCHA-API verwenden, muss mindestens eine Domain in Ihrem CAPTCHA-API-Schlüssel exakt mit einer der Token-Domains in übereinstimmen `window.awsWafCookieDomainList` oder es muss sich um die Apex-Domain einer dieser Token-Domains handeln. 

  Für die Token-Domain `mySubdomain.myApex.com` stimmt der API-Schlüssel beispielsweise exakt überein und der API-Schlüssel `mySubdomain.myApex.com` entspricht der Apex-Domain. `myApex.com` Jeder Schlüssel entspricht der Token-Domain. 

  Weitere Informationen zu den API-Schlüsseln finden Sie unter[Verwaltung von API-Schlüsseln für die JS-CAPTCHA-API](waf-js-captcha-api-key.md). 

Wenn Sie die `AWSManagedRulesACFPRuleSet` verwaltete Regelgruppe verwenden, können Sie eine Domäne konfigurieren, die mit der Domäne im Kontoerstellungspfad übereinstimmt, den Sie für die Regelgruppenkonfiguration angegeben haben. Weitere Informationen zu dieser Konfiguration finden Sie unter [Hinzufügen der verwalteten ACFP-Regelgruppe zu Ihrer Web-ACL](waf-acfp-rg-using.md).

Wenn Sie die `AWSManagedRulesATPRuleSet` verwaltete Regelgruppe verwenden, können Sie eine Domäne konfigurieren, die mit der Domäne im Anmeldepfad übereinstimmt, die Sie für die Regelgruppenkonfiguration angegeben haben. Weitere Informationen zu dieser Konfiguration finden Sie unter [Hinzufügen der von ATP verwalteten Regelgruppe zu Ihrem Protection Pack (Web-ACL)](waf-atp-rg-using.md).

# Verwenden der JavaScript API mit Inhaltssicherheitsrichtlinien
<a name="waf-javascript-api-csp"></a>

Dieser Abschnitt enthält eine Beispielkonfiguration für die Zulassungsliste der AWS WAF Apex-Domain.

Wenn Sie Inhaltssicherheitsrichtlinien (CSP) auf Ihre Ressourcen anwenden, müssen Sie die Apex-Domain auf eine Zulassungsliste setzen, damit Ihre JavaScript Implementierung funktioniert. AWS WAF `awswaf.com` JavaScript SDKs Sie richten Aufrufe an verschiedene AWS WAF Endpunkte, sodass diese Domain auf eine Zulassungsliste gesetzt wird, um die Berechtigungen zu erhalten, die für den Betrieb erforderlich sind. SDKs 

Im Folgenden wird eine Beispielkonfiguration für die Zulassungsliste für die Apex-Domäne gezeigt: AWS WAF 

```
connect-src 'self' https://*.awswaf.com;
script-src 'self' https://*.awswaf.com;
script-src-elem 'self' https://*.awswaf.com;
```

Wenn Sie versuchen, die JavaScript SDKs mit Ressourcen zu verwenden, die CSP verwenden, und Sie die AWS WAF Domain nicht auf die Zulassungsliste gesetzt haben, erhalten Sie Fehlermeldungen wie die folgenden: 

```
Refused to load the script ...awswaf.com/<> because it violates the following Content Security Policy directive: “script-src ‘self’
```

# Verwendung der Intelligent Threat JavaScript API
<a name="waf-js-challenge-api"></a>

Dieser Abschnitt enthält Anweisungen zur Verwendung der Intelligent Threat JavaScript API in Ihrer Client-Anwendung.

Die intelligenten Bedrohungen APIs bieten Operationen für die Ausführung von Anfragen im Hintergrund gegen den Browser des Benutzers und für den Umgang mit AWS WAF Tokens, die den Nachweis erfolgreicher Abfragen und CAPTCHA-Antworten liefern. 

Implementieren Sie die JavaScript Integration zunächst in einer Testumgebung und dann in der Produktion. Weitere Anleitungen zur Codierung finden Sie in den folgenden Abschnitten. 

 

**Um die intelligente Bedrohung zu nutzen APIs**

1. **Installieren Sie das APIs** 

   Wenn Sie die CAPTCHA-API verwenden, können Sie diesen Schritt überspringen. Wenn Sie die CAPTCHA-API installieren, installiert das Skript automatisch die intelligente Bedrohung. APIs

   1. [Melden Sie sich bei homev2 an AWS-Managementkonsole und öffnen Sie die AWS WAF Konsole. https://console.aws.amazon.com/wafv2/](https://console.aws.amazon.com/wafv2/homev2) 

   1. Wählen Sie im Navigationsbereich **Application integration** (Anwendungsintegration) aus. Auf der Seite **zur Anwendungsintegration** finden Sie Optionen in Registerkarten. 

   1. Wählen Sie **Intelligente Bedrohungsintegration**

   1. Wählen Sie auf der Registerkarte das Schutzpaket (Web-ACL) aus, in das Sie integrieren möchten. Die Liste der Schutzpakete (Web-ACL) enthält nur Schutzpakete (Web ACLs), die die `AWSManagedRulesACFPRuleSet` verwaltete Regelgruppe, die `AWSManagedRulesATPRuleSet` verwaltete Regelgruppe oder die gezielte Schutzstufe der `AWSManagedRulesBotControlRuleSet` verwalteten Regelgruppe verwenden. 

   1. Öffnen Sie den **JavaScript SDK-Bereich** und kopieren Sie das Skript-Tag zur Verwendung in Ihrer Integration. 

   1. Fügen Sie im Seitencode Ihrer Anwendung im `<head>` Abschnitt das Skript-Tag ein, das Sie für das Protection Pack (Web-ACL) kopiert haben. Diese Einbeziehung bewirkt, dass Ihre Clientanwendung beim Laden der Seite automatisch ein Token im Hintergrund abruft. 

      ```
      <head>
          <script type="text/javascript" src="protection pack (web ACL) integration URL/challenge.js” defer></script>
      <head>
      ```

      Diese `<script>`-Auflistung wird mit dem `defer`-Attribut konfiguriert, doch Sie können die Einstellung in `async` ändern, wenn sich die Seite auf andere Weise verhalten soll. 

1. **(Optional) Fügen Sie die Domänenkonfiguration für die Token des Clients** hinzu — Beim AWS WAF Erstellen eines Tokens wird standardmäßig die Hostdomäne der Ressource verwendet, die dem Protection Pack (Web-ACL) zugeordnet ist. Folgen Sie den Anweisungen unter JavaScript APIs, um zusätzliche Domänen für bereitzustellen[Bereitstellung von Domains zur Verwendung in den Tokens](waf-js-challenge-api-set-token-domain.md). 

1. **Codieren Sie Ihre intelligente Bedrohungsintegration** — Verfassen Sie Ihren Code, um sicherzustellen, dass der Token-Abruf abgeschlossen ist, bevor der Client seine Anfragen an Ihre geschützten Endgeräte sendet. Wenn Sie für den Aufruf bereits die `fetch`-API verwenden, können Sie den `fetch`-Wrapper der AWS WAF -Integration ersetzen. Wenn Sie die `fetch` API nicht verwenden, können Sie stattdessen den AWS WAF `getToken` Integrationsvorgang verwenden. In den folgenden Abschnitten finden Sie weitere Code-Anweisungen. 

1. **Fügen Sie Ihrem Schutzpaket (Web-ACL) eine Token-Verifizierung** hinzu — Fügen Sie Ihrem Schutzpaket (Web-ACL) mindestens eine Regel hinzu, die in den Webanfragen, die Ihr Client sendet, nach einem gültigen Challenge-Token sucht. Sie können Regelgruppen verwenden, die Challenge-Token überprüfen und überwachen, z. B. die Zielebene der verwalteten Regelgruppe von Bot Control, und Sie können die Challenge Regelaktion zur Überprüfung verwenden, wie unter beschrieben[CAPTCHAund Challenge in AWS WAF](waf-captcha-and-challenge.md). 

   Die Ergänzungen des Protection Packs (Web-ACL) stellen sicher, dass Anfragen an Ihre geschützten Endgeräte das Token enthalten, das Sie in Ihrer Client-Integration erworben haben. Anfragen, die ein gültiges, noch nicht abgelaufenes Token enthalten, bestehen die Challenge Prüfung und stellen keine weitere unbemerkte Aufforderung an Ihren Kunden dar. 

1. **(Optional) Blockieren von Anfragen, bei denen Token fehlen** — Wenn Sie die APIs mit der von ACFP verwalteten Regelgruppe, die von ATP verwaltete Regelgruppe oder die gezielten Regeln der Bot Control-Regelgruppe verwenden, blockieren diese Regeln keine Anfragen, bei denen Token fehlen. Folgen Sie den Anweisungen unter, um Anfragen zu blockieren, bei [Anfragen blockieren, die kein gültiges AWS WAF Token haben](waf-tokens-block-missing-tokens.md) denen Token fehlen. 

**Topics**
+ [API-Spezifikation für intelligente Bedrohungen](waf-js-challenge-api-specification.md)
+ [Wie benutzt man den Integration `fetch` Wrapper](waf-js-challenge-api-fetch-wrapper.md)
+ [Wie benutzt man die Integration `getToken`](waf-js-challenge-api-get-token.md)

# API-Spezifikation für intelligente Bedrohungen
<a name="waf-js-challenge-api-specification"></a>

In diesem Abschnitt sind die Spezifikationen für die Methoden und Eigenschaften der intelligenten Bedrohungsabwehr JavaScript APIs aufgeführt. Verwenden Sie diese APIs für intelligente Bedrohungs- und CAPTCHA-Integrationen.

**`AwsWafIntegration.fetch()`**  
Sendet die `fetch` HTTP-Anfrage mithilfe der Integrationsimplementierung an den AWS WAF Server. 

**`AwsWafIntegration.getToken()`**  
Ruft das gespeicherte AWS WAF Token ab und speichert es in einem Cookie auf der aktuellen Seite mit dem Namen `aws-waf-token` und dem auf den Tokenwert gesetzten Wert. 

**`AwsWafIntegration.hasToken()`**  
Gibt einen booleschen Wert zurück, der angibt, ob das `aws-waf-token` Cookie derzeit ein nicht abgelaufenes Token enthält. 

Wenn Sie auch die CAPTCHA-Integration verwenden, finden Sie die entsprechende Spezifikation unter. [JavaScript CAPTCHA-API-Spezifikation](waf-js-captcha-api-specification.md)

# Wie benutzt man den Integration `fetch` Wrapper
<a name="waf-js-challenge-api-fetch-wrapper"></a>

Dieser Abschnitt enthält Anweisungen zur Verwendung des `fetch` Integrations-Wrappers.

Sie verwenden den AWS WAF `fetch`-Wrapper, indem Sie Ihre regulären `fetch`-Aufrufe in die `fetch`-API unter dem `AwsWafIntegration`-Namespace ändern. Der AWS WAF Wrapper unterstützt dieselben Optionen wie der JavaScript `fetch` Standard-API-Aufruf und fügt die Token-Behandlung für die Integration hinzu. Dieser Ansatz ist im Allgemeinen die einfachste Möglichkeit, Ihre Anwendung zu integrieren. 

**Vor der Wrapper-Implementierung**  
Die folgende Beispielliste zeigt Standardcode vor der Implementierung des `AwsWafIntegration`-`fetch`-Wrapper.

```
const login_response = await fetch(login_url, {
	    method: 'POST',
	    headers: {
	      'Content-Type': 'application/json'
	    },
	    body: login_body
	  });
```

**Nach der Wrapper-Implementierung**  
Die folgende Auflistung zeigt den gleichen Code wie bei der Implementierung des `AwsWafIntegration`-`fetch`-Wrapper.

```
const login_response = await AwsWafIntegration.fetch(login_url, {
	    method: 'POST',
	    headers: {
	      'Content-Type': 'application/json'
	    },
	    body: login_body
	  });
```

# Wie benutzt man die Integration `getToken`
<a name="waf-js-challenge-api-get-token"></a>

In diesem Abschnitt wird erklärt, wie die `getToken` Operation verwendet wird.

AWS WAF erfordert, dass Ihre Anfragen an geschützte Endpunkte das Cookie enthalten, das `aws-waf-token` mit dem Wert Ihres aktuellen Tokens benannt ist. 

Bei der `getToken` Operation handelt es sich um einen asynchronen API-Aufruf, der das AWS WAF Token abruft und es in einem Cookie auf der aktuellen Seite speichert`aws-waf-token`, wobei der Name und der Wert auf den Tokenwert gesetzt sind. Sie können dieses Token-Cookie nach Bedarf auf Ihrer Seite verwenden. 

Wenn Sie `getToken` aufrufen, geschieht Folgendes: 
+ Wenn ein nicht abgelaufenes Token bereits verfügbar ist, gibt der Aufruf es sofort zurück.
+ Andernfalls wird ein neues Token aus dem -Token-Anbieter aufgerufen. Wird der Workflow für den Token-Erwerb nicht innerhalb von 2 Sekunden abgeschlossen, tritt eine Zeitüberschreitung ein. Wenn die Zeitüberschreitung eingetreten ist, wird ein Fehler ausgelöst, der von Ihrem Aufrufcode behoben werden muss. 

Der `getToken`-Betrieb verfügt über den begleitenden `hasToken`-Betrieb, der angibt, ob das `aws-waf-token`-Cookie derzeit ein nicht abgelaufenes Token enthält. 

`AwsWafIntegration.getToken()`ruft ein gültiges Token ab und speichert es als Cookie. Bei den meisten Client-Aufrufen wird dieses Cookie automatisch angehängt, bei einigen jedoch nicht. Bei Aufrufen über Host-Domains hinweg wird das Cookie beispielsweise nicht angehängt. In den folgenden Implementierungsdetails zeigen wir, wie Sie mit beiden Arten von Client-Aufrufen arbeiten können. 

**Grundlegende `getToken` Implementierung für Aufrufe, die das `aws-waf-token` Cookie anhängen**  
Die folgende Beispielliste zeigt Standardcode für die Implementierung des `getToken` Vorgangs mit einer Anmeldeanforderung.

```
const login_response = await AwsWafIntegration.getToken()
	    .catch(e => {
	        // Implement error handling logic for your use case
	    })
	    // The getToken call returns the token, and doesn't typically require special handling
	    .then(token => {
	        return loginToMyPage()
	    })
	
	async function loginToMyPage() {
	    // Your existing login code
	}
```

**Senden Sie das Formular erst ab, wenn das Token unter `getToken` verfügbar ist.**  
Die folgende Auflistung zeigt, wie Sie einen Ereignis-Listener registrieren, um Formularübermittlungen abzufangen, bis ein gültiges Token zur Verwendung verfügbar ist. 

```
<body>
	  <h1>Login</h1>
	  <p></p>
	  <form id="login-form" action="/web/login" method="POST" enctype="application/x-www-form-urlencoded">
	    <label for="input_username">USERNAME</label>
	    <input type="text" name="input_username" id="input_username"><br>
	    <label for="input_password">PASSWORD</label>
	    <input type="password" name="input_password" id="input_password"><br>
	    <button type="submit">Submit<button>
	  </form>
	
	<script>
	  const form = document.querySelector("#login-form");
	
	  // Register an event listener to intercept form submissions
	  form.addEventListener("submit", (e) => {
	      // Submit the form only after a token is available 
	      if (!AwsWafIntegration.hasToken()) {
	          e.preventDefault();
	          AwsWafIntegration.getToken().then(() => {
	              e.target.submit();
	          }, (reason) => { console.log("Error:"+reason) });
	        }
	    });
	</script>
	</body>
```

**Anhängen des Tokens, wenn Ihr Client das `aws-waf-token` Cookie nicht standardmäßig anhängt**  
`AwsWafIntegration.getToken()`ruft ein gültiges Token ab und speichert es als Cookie, aber nicht alle Client-Aufrufe hängen dieses Cookie standardmäßig an. Beispielsweise hängen Aufrufe über Hostdomänen hinweg das Cookie nicht an. 

Der `fetch` Wrapper behandelt diese Fälle automatisch, aber wenn Sie den `fetch` Wrapper nicht verwenden können, können Sie dies mithilfe eines benutzerdefinierten `x-aws-waf-token` Headers handhaben. AWS WAF liest Token aus diesem Header und liest sie zusätzlich aus dem `aws-waf-token` Cookie. Der folgende Code zeigt ein Beispiel für das Setzen des Headers. 

```
const token = await AwsWafIntegration.getToken();
const result = await fetch('/url', {
    headers: {
        'x-aws-waf-token': token,
    },
});
```

Akzeptiert standardmäßig AWS WAF nur Token, die dieselbe Domain wie die angeforderte Host-Domain enthalten. Für alle domänenübergreifenden Token sind entsprechende Einträge in der Token-Domainliste des Protection Packs (Web ACL) erforderlich. Weitere Informationen finden Sie unter [AWS WAF Konfiguration der Token-Domänenliste für das Protection Pack (Web-ACL)](waf-tokens-domains.md#waf-tokens-domain-lists). 

Weitere Informationen zur domänenübergreifenden Verwendung von Token finden Sie unter [aws-waf-bot-controlaws-samples/](https://github.com/aws-samples/aws-waf-bot-control-api-protection-with-captcha) -. api-protection-with-captcha

# Verwenden der CAPTCHA-API JavaScript
<a name="waf-js-captcha-api"></a>

Dieser Abschnitt enthält Anweisungen zur Verwendung der CAPTCHA-Integrations-API.

Mit der JavaScript CAPTCHA-API können Sie das CAPTCHA-Puzzle konfigurieren und an der gewünschten Stelle in Ihrer Client-Anwendung platzieren. Diese API nutzt die Funktionen der intelligenten Bedrohung, um AWS WAF Token JavaScript APIs zu erwerben und zu verwenden, nachdem ein Endbenutzer ein CAPTCHA-Puzzle erfolgreich gelöst hat. 

Implementieren Sie die JavaScript Integration zunächst in einer Testumgebung und dann in der Produktion. Weitere Anleitungen zur Codierung finden Sie in den folgenden Abschnitten. 

**Um die CAPTCHA-Integrations-API zu verwenden**

1. **Installieren Sie die API**

   1. Melden Sie sich bei [https://console.aws.amazon.com/wafv2/homev2](https://console.aws.amazon.com/wafv2/homev2) an AWS-Managementkonsole und öffnen Sie die AWS WAF Konsole. 

   1. Wählen Sie im Navigationsbereich **Application integration** (Anwendungsintegration) aus. Auf der Seite **zur Anwendungsintegration** finden Sie Optionen in Registerkarten. 

   1. Wählen Sie **CAPTCHA-Integration** aus.

   1. Kopieren Sie das aufgelistete JavaScript Integrationsskript-Tag zur Verwendung in Ihrer Integration.

   1. Fügen Sie im Code Ihrer Anwendungsseite im `<head>` Abschnitt das Skript-Tag ein, das Sie kopiert haben. Durch diese Aufnahme steht das CAPTCHA-Puzzle zur Konfiguration und Verwendung zur Verfügung. 

      ```
      <head>
          <script type="text/javascript" src="integrationURL/jsapi.js" defer></script>
      </head>
      ```

      Diese `<script>`-Auflistung wird mit dem `defer`-Attribut konfiguriert, doch Sie können die Einstellung in `async` ändern, wenn sich die Seite auf andere Weise verhalten soll. 

      Das CAPTCHA-Skript lädt auch automatisch das intelligente Threat-Integrationsskript, falls es noch nicht vorhanden ist. Das Skript zur intelligenten Bedrohungsintegration veranlasst Ihre Client-Anwendung, beim Laden der Seite automatisch ein Token im Hintergrund abzurufen, und bietet weitere Funktionen zur Tokenverwaltung, die Sie für die Verwendung der CAPTCHA-API benötigen. 

1. **(Optional) Fügen Sie die Domänenkonfiguration für die Token des Clients** hinzu — Standardmäßig AWS WAF wird bei der Erstellung eines Tokens die Hostdomäne der Ressource verwendet, die dem Protection Pack (Web-ACL) zugeordnet ist. Folgen Sie den Anweisungen unter JavaScript APIs, um zusätzliche Domänen für bereitzustellen[Bereitstellung von Domains zur Verwendung in den Tokens](waf-js-challenge-api-set-token-domain.md). 

1. **Holen Sie sich den verschlüsselten API-Schlüssel für den Client** — Die CAPTCHA-API benötigt einen verschlüsselten API-Schlüssel, der eine Liste gültiger Kundendomänen enthält. AWS WAF verwendet diesen Schlüssel, um zu überprüfen, ob die Client-Domain, die Sie mit der Integration verwenden, für die Verwendung AWS WAF von CAPTCHA zugelassen ist. Folgen Sie den Anweisungen unter, um Ihren API-Schlüssel zu generieren. [Verwaltung von API-Schlüsseln für die JS-CAPTCHA-API](waf-js-captcha-api-key.md)

1. **Codieren Sie Ihre CAPTCHA-Widget-Implementierung** — Implementieren Sie den `renderCaptcha()` API-Aufruf auf Ihrer Seite an der Stelle, an der Sie ihn verwenden möchten. Informationen zur Konfiguration und Verwendung dieser Funktion finden Sie in den folgenden Abschnitten und. [JavaScript CAPTCHA-API-Spezifikation](waf-js-captcha-api-specification.md) [Wie rendert man das CAPTCHA-Puzzle](waf-js-captcha-api-render.md) 

   Die CAPTCHA-Implementierung integriert sich in die intelligente Bedrohungsintegration APIs für die Tokenverwaltung und die Ausführung von Abruf-Aufrufen, die die Token verwenden. AWS WAF Anleitungen zu deren APIs Verwendung finden Sie unter. [Verwendung der Intelligent Threat JavaScript API](waf-js-challenge-api.md)

1. **Fügen Sie Ihrem Schutzpaket (Web-ACL) eine Token-Verifizierung** hinzu — Fügen Sie Ihrem Schutzpaket (Web-ACL) mindestens eine Regel hinzu, die überprüft, ob in den von Ihrem Client gesendeten Webanfragen ein gültiges CAPTCHA-Token vorhanden ist. Sie können die CAPTCHA Regelaktion zur Überprüfung verwenden, wie unter beschrieben. [CAPTCHAund Challenge in AWS WAF](waf-captcha-and-challenge.md) 

   Die Ergänzungen des Protection Packs (Web-ACL) stellen sicher, dass Anfragen, die an Ihre geschützten Endgeräte gesendet werden, das Token enthalten, das Sie in Ihrer Client-Integration erworben haben. Anfragen, die ein gültiges, noch nicht abgelaufenes CAPTCHA-Token enthalten, bestehen die Prüfung der CAPTCHA Regelaktion und stellen Ihren Endbenutzer nicht vor ein weiteres CAPTCHA-Rätsel. 

Nachdem Sie die JavaScript API implementiert haben, können Sie die CloudWatch Metriken für CAPTCHA-Rätselversuche und -lösungen überprüfen. Einzelheiten zu Metriken und Dimensionen finden Sie unter. [Kennzahlen und Dimensionen Ihres Kontos](waf-metrics.md#waf-metrics-account)

**Topics**
+ [JavaScript CAPTCHA-API-Spezifikation](waf-js-captcha-api-specification.md)
+ [Wie rendert man das CAPTCHA-Puzzle](waf-js-captcha-api-render.md)
+ [Umgang mit einer CAPTCHA-Antwort von AWS WAF](waf-js-captcha-api-conditional.md)
+ [Verwaltung von API-Schlüsseln für die JS-CAPTCHA-API](waf-js-captcha-api-key.md)

# JavaScript CAPTCHA-API-Spezifikation
<a name="waf-js-captcha-api-specification"></a>

In diesem Abschnitt sind die Spezifikationen für die Methoden und Eigenschaften des CAPTCHA aufgeführt. JavaScript APIs Verwenden Sie das CAPTCHA, JavaScript APIs um benutzerdefinierte CAPTCHA-Rätsel in Ihren Client-Anwendungen auszuführen. 

Diese API basiert auf der intelligenten Bedrohung APIs, mit der Sie die Erfassung und Verwendung von AWS WAF Token konfigurieren und verwalten. Siehe[API-Spezifikation für intelligente Bedrohungen](waf-js-challenge-api-specification.md).

**`AwsWafCaptcha.renderCaptcha(container, configuration)`**  
Präsentiert dem Endbenutzer ein AWS WAF CAPTCHA-Puzzle und aktualisiert bei Erfolg das Client-Token mit der CAPTCHA-Validierung. Dies ist nur mit der CAPTCHA-Integration verfügbar. Verwenden Sie diesen Anruf zusammen mit der intelligenten Bedrohung APIs , um den Token-Abruf zu verwalten und das Token in Ihren Anrufen bereitzustellen. `fetch` Die intelligente Bedrohung finden Sie APIs unter. [API-Spezifikation für intelligente Bedrohungen](waf-js-challenge-api-specification.md)  
Im Gegensatz zum CAPTCHA-Interstitial, das AWS WAF gesendet wird, zeigt das mit dieser Methode gerenderte CAPTCHA-Puzzle das Rätsel sofort an, ohne dass ein anfänglicher Titelbildschirm angezeigt wird.     
**`container`**  
Das `Element` Objekt für das Zielcontainerelement auf der Seite. Dies wird üblicherweise durch Aufrufen von `document.getElementById()` oder abgerufen`document.querySelector()`.  
Erforderlich: Ja  
Typ: `Element`  
**Konfiguration**  
Ein Objekt, das CAPTCHA-Konfigurationseinstellungen wie folgt enthält: ****    
**`apiKey`**   
Der verschlüsselte API-Schlüssel, der Berechtigungen für die Domäne des Kunden aktiviert. Verwenden Sie die AWS WAF Konsole, um Ihre API-Schlüssel für Ihre Kundendomänen zu generieren. Sie können einen Schlüssel für bis zu fünf Domains verwenden. Weitere Informationen finden Sie unter [Verwaltung von API-Schlüsseln für die JS-CAPTCHA-API](waf-js-captcha-api-key.md).   
Erforderlich: Ja  
Typ: `string`  
**`onSuccess: (wafToken: string) => void;`**   
Wird mit einem gültigen AWS WAF Token aufgerufen, wenn der Endbenutzer ein CAPTCHA-Rätsel erfolgreich gelöst hat. Verwenden Sie das Token in den Anfragen, die Sie an die Endgeräte senden, die Sie mit einem AWS WAF Schutzpaket (Web-ACL) schützen. Das Token liefert den Nachweis und den Zeitstempel für die letzte erfolgreiche Lösung des Rätsels.   
Erforderlich: Ja  
**`onError?: (error: CaptchaError) => void;`**   
Wird mit einem Fehlerobjekt aufgerufen, wenn während der CAPTCHA-Operation ein Fehler auftritt.   
Erforderlich: Nein  
**`CaptchaError`Klassendefinition** — Der `onError` Handler liefert einen Fehlertyp mit der folgenden Klassendefinition.   

```
CaptchaError extends Error {
    kind: "internal_error" | "network_error" | "token_error" | "client_error";
    statusCode?: number;
}
```
+ `kind`— Die Art des zurückgegebenen Fehlers. 
+ `statusCode`— Der HTTP-Statuscode, falls verfügbar. Dieser wird verwendet, `network_error` wenn der Fehler auf einen HTTP-Fehler zurückzuführen ist.  
**`onLoad?: () => void;`**   
Wird aufgerufen, wenn ein neues CAPTCHA-Rätsel geladen wird.  
Erforderlich: Nein  
**`onPuzzleTimeout?: () => void;`**   
Wird aufgerufen, wenn ein CAPTCHA-Rätsel nicht gelöst wird, bevor es abläuft.  
Erforderlich: Nein  
**`onPuzzleCorrect?: () => void;`**   
Wird aufgerufen, wenn eine richtige Antwort auf ein CAPTCHA-Rätsel gegeben wurde.  
Erforderlich: Nein  
**`onPuzzleIncorrect?: () => void;`**   
Wird aufgerufen, wenn eine falsche Antwort auf ein CAPTCHA-Rätsel gegeben wird.  
Erforderlich: Nein  
**`defaultLocale`**   
Das Standard-Gebietsschema, das für das CAPTCHA-Rätsel verwendet werden soll. Die schriftlichen Anweisungen für CAPTCHA-Rätsel sind in Arabisch (ar-SA), vereinfachtem Chinesisch (zh-CN), Niederländisch (nl-NL), Englisch (en-US), Französisch (fr-FR), Deutsch (de-DE), Italienisch (it-IT), Japanisch (ja-JP), Portugiesisch (pt-BR), Spanisch (es-ES) und Türkisch (tr-TR) verfügbar. Audioanweisungen sind für alle Schriftsprachen verfügbar, mit Ausnahme von Chinesisch und Japanisch, für die standardmäßig Englisch verwendet wird. Um die Standardsprache zu ändern, geben Sie die internationale Sprache und den Ländercode an, `ar-SA` z. B.  
Standard: Die Sprache, die derzeit im Browser des Endbenutzers verwendet wird  
Erforderlich: Nein  
Typ: `string`  
**`disableLanguageSelector`**   
Wenn auf gesetzt`true`, verbirgt das CAPTCHA-Puzzle die Sprachauswahl.   
Standard: `false`  
Erforderlich: Nein  
Typ: `boolean`  
**`dynamicWidth`**   
Wenn auf gesetzt`true`, ändert das CAPTCHA-Puzzle aus Gründen der Kompatibilität mit der Breite des Browserfensters seine Breite.   
Standard: `false`  
Erforderlich: Nein  
Typ: `boolean`  
**`skipTitle`**   
**Wenn diese Option auf gesetzt ist`true`, zeigt das CAPTCHA-Puzzle nicht die Überschrift Löse das Rätsel an.**   
Standard: `false`  
Erforderlich: Nein  
Typ: `boolean`

# Wie rendert man das CAPTCHA-Puzzle
<a name="waf-js-captcha-api-render"></a>

Dieser Abschnitt enthält eine `renderCaptcha` Beispielimplementierung.

Sie können den AWS WAF `renderCaptcha` Aufruf an der gewünschten Stelle in Ihrer Client-Schnittstelle verwenden. Der Aufruf ruft ein CAPTCHA-Puzzle ab AWS WAF, rendert es und sendet die Ergebnisse zur Überprüfung an. AWS WAF Wenn Sie den Aufruf tätigen, geben Sie die Konfiguration für das Rendern von Rätseln und die Callbacks an, die Sie ausführen möchten, wenn Ihre Endbenutzer das Rätsel gelöst haben. Einzelheiten zu den Optionen finden Sie im vorherigen Abschnitt,[JavaScript CAPTCHA-API-Spezifikation](waf-js-captcha-api-specification.md).

Verwenden Sie diesen Aufruf in Verbindung mit der Token-Management-Funktionalität der Intelligent Threat Integration APIs. Durch diesen Aufruf erhält Ihr Kunde ein Token, das den erfolgreichen Abschluss des CAPTCHA-Rätsels bestätigt. Verwenden Sie die intelligente Bedrohungsintegration APIs , um das Token zu verwalten und das Token in den Aufrufen Ihres Kunden an die Endgeräte bereitzustellen, die mit AWS WAF Schutzpaketen geschützt sind (Web). ACLs Informationen zur intelligenten Bedrohung finden Sie APIs unter[Verwendung der Intelligent Threat JavaScript API](waf-js-challenge-api.md).

**Beispielimplementierung**  
Die folgende Beispielliste zeigt eine standardmäßige CAPTCHA-Implementierung, einschließlich der Platzierung der AWS WAF Integrations-URL im `<head>` Abschnitt. 

In dieser Auflistung wird die `renderCaptcha` Funktion mit einem erfolgreichen Callback konfiguriert, der den `AwsWafIntegration.fetch` Wrapper der Intelligent Threat Integration verwendet. APIs Hinweise zu dieser Funktion finden Sie unter. [Wie benutzt man den Integration `fetch` Wrapper](waf-js-challenge-api-fetch-wrapper.md)

```
<head>
    <script type="text/javascript" src="<Integration URL>/jsapi.js" defer></script>
</head>

<script type="text/javascript">
    function showMyCaptcha() {
        var container = document.querySelector("#my-captcha-container");
        
        AwsWafCaptcha.renderCaptcha(container, {
            apiKey: "...API key goes here...",
            onSuccess: captchaExampleSuccessFunction,
            onError: captchaExampleErrorFunction,
            ...other configuration parameters as needed...
        });
    }
    
    function captchaExampleSuccessFunction(wafToken) {
        // Captcha completed. wafToken contains a valid WAF token. Store it for
        // use later or call AwsWafIntegration.fetch() to use it easily.
        // It will expire after a time, so calling AwsWafIntegration.getToken()
        // again is advised if the token is needed later on, outside of using the
        // fetch wrapper.
        
        // Use WAF token to access protected resources
        AwsWafIntegration.fetch("...WAF-protected URL...", {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
            },
            body: "{ ... }" /* body content */
        });
    }
    
    function captchaExampleErrorFunction(error) {
        /* Do something with the error */
    }
</script>

<div id="my-captcha-container">
    <!-- The contents of this container will be replaced by the captcha widget -->
</div>
```

**Beispiel für Konfigurationseinstellungen**  
Die folgende Beispielliste zeigt die Optionen `renderCaptcha` mit nicht standardmäßigen Einstellungen für die Breite und den Titel. 

```
        AwsWafCaptcha.renderCaptcha(container, {
            apiKey: "...API key goes here...",
            onSuccess: captchaExampleSuccessFunction,
            onError: captchaExampleErrorFunction,
            dynamicWidth: true, 
            skipTitle: true
        });
```

Vollständige Informationen zu den Konfigurationsoptionen finden Sie unter[JavaScript CAPTCHA-API-Spezifikation](waf-js-captcha-api-specification.md).

# Umgang mit einer CAPTCHA-Antwort von AWS WAF
<a name="waf-js-captcha-api-conditional"></a>

Dieser Abschnitt enthält ein Beispiel für den Umgang mit einer CAPTCHA-Antwort.

Eine AWS WAF Regel mit einer CAPTCHA Aktion beendet die Auswertung einer passenden Webanfrage, wenn die Anfrage kein Token mit einem gültigen CAPTCHA-Zeitstempel hat. Handelt es sich bei der Anfrage um einen `GET` text/html Anruf, wird dem Client durch die CAPTCHA Aktion ein Interstitial mit einem CAPTCHA-Rätsel angezeigt. Wenn Sie die JavaScript CAPTCHA-API nicht integrieren, führt das Interstitial das Rätsel aus. Wenn der Endbenutzer es erfolgreich löst, wird die Anfrage automatisch erneut gesendet. 

Wenn Sie die JavaScript CAPTCHA-API integrieren und Ihre CAPTCHA-Handhabung anpassen, müssen Sie die abschließende CAPTCHA-Antwort erkennen, Ihr benutzerdefiniertes CAPTCHA bereitstellen und dann, wenn der Endbenutzer das Rätsel erfolgreich löst, die Webanfrage des Kunden erneut einreichen. 

Das folgende Codebeispiel veranschaulicht, wie dazu vorgegangen wird. 

**Anmerkung**  
Die AWS WAF CAPTCHA Aktionsantwort hat den Statuscode HTTP 405, anhand dessen wir die Antwort in diesem Code erkennen. CAPTCHA Wenn Ihr geschützter Endpunkt einen HTTP 405-Statuscode verwendet, um eine andere Art von Antwort für denselben Anruf zu übermitteln, wird mit diesem Beispielcode auch für diese Antworten ein CAPTCHA-Rätsel erstellt. 

```
<!DOCTYPE html>
<html>
<head>
    <script type="text/javascript" src="<Integration URL>/jsapi.js" defer></script>
</head>
<body>
    <div id="my-captcha-box"></div>
    <div id="my-output-box"></div>

    <script type="text/javascript">
    async function loadData() {
        // Attempt to fetch a resource that's configured to trigger a CAPTCHA
        // action if the rule matches. The CAPTCHA response has status=HTTP 405.
        const result = await AwsWafIntegration.fetch("/protected-resource");

        // If the action was CAPTCHA, render the CAPTCHA and return

        // NOTE: If the endpoint you're calling in the fetch call responds with HTTP 405
        // as an expected response status code, then this check won't be able to tell the
        // difference between that and the CAPTCHA rule action response.

        if (result.status === 405) {
            const container = document.querySelector("#my-captcha-box");
            AwsWafCaptcha.renderCaptcha(container, {
                apiKey: "...API key goes here...",
                onSuccess() {
                    // Try loading again, now that there is a valid CAPTCHA token
                    loadData();
                },
            });
            return;
        }

        const container = document.querySelector("#my-output-box");
        const response = await result.text();
        container.innerHTML = response;
    }

    window.addEventListener("load", () => {
        loadData();
    });
    </script>
</body>
</html>
```

# Verwaltung von API-Schlüsseln für die JS-CAPTCHA-API
<a name="waf-js-captcha-api-key"></a>

Dieser Abschnitt enthält Anweisungen zum Generieren und Löschen von API-Schlüsseln.

Um AWS WAF CAPTCHA mit der JavaScript API in eine Client-Anwendung zu integrieren, benötigen Sie das API-Integrations-Tag und den verschlüsselten JavaScript API-Schlüssel für die Client-Domain, in der Sie Ihr CAPTCHA-Puzzle ausführen möchten. 

Die CAPTCHA-Anwendungsintegration für JavaScript verwendet die verschlüsselten API-Schlüssel, um zu überprüfen, ob die Domäne der Client-Anwendung berechtigt ist, die CAPTCHA-API zu verwenden. AWS WAF Wenn Sie die CAPTCHA-API von Ihrem JavaScript Client aus aufrufen, geben Sie einen API-Schlüssel mit einer Domainliste an, die eine Domain für den aktuellen Client enthält. Sie können bis zu 5 Domains in einem einzigen verschlüsselten Schlüssel auflisten. 

**Anforderungen an API-Schlüssel**  
Der API-Schlüssel, den Sie in Ihrer CAPTCHA-Integration verwenden, muss eine Domain enthalten, die für den Client gilt, auf dem Sie den Schlüssel verwenden. 
+ Wenn Sie `window.awsWafCookieDomainList` in der intelligenten Bedrohungsintegration Ihres Kunden eine angeben, muss mindestens eine Domain in Ihrem API-Schlüssel exakt mit einer der Token-Domains in übereinstimmen `window.awsWafCookieDomainList` oder es muss sich um die Apex-Domain einer dieser Token-Domains handeln. 

  Für die Token-Domain `mySubdomain.myApex.com` entspricht der API-Schlüssel `mySubdomain.myApex.com` beispielsweise exakt und der API-Schlüssel `myApex.com` der Apex-Domain. Jeder Schlüssel entspricht der Token-Domain. 

  Hinweise zur Einstellung der Tokendomänenliste finden Sie unter[Bereitstellung von Domains zur Verwendung in den Tokens](waf-js-challenge-api-set-token-domain.md).
+ Andernfalls muss die aktuelle Domain im API-Schlüssel enthalten sein. Die aktuelle Domain ist die Domain, die Sie in der Adressleiste des Browsers sehen können. 

Basierend auf der geschützten Host-Domain und der Token-Domainliste, die für die Web-ACL konfiguriert ist, müssen die verwendeten Domains akzeptiert werden. AWS WAF Weitere Informationen finden Sie unter [AWS WAF Konfiguration der Token-Domänenliste für das Protection Pack (Web-ACL)](waf-tokens-domains.md#waf-tokens-domain-lists).

**Wie wählen Sie die Region für Ihren API-Schlüssel**  
AWS WAF kann CAPTCHA-API-Schlüssel in jeder Region generieren, in der sie verfügbar AWS WAF sind. 

In der Regel sollten Sie für Ihren CAPTCHA-API-Schlüssel dieselbe Region verwenden wie für Ihr Schutzpaket (Web-ACL). Wenn Sie jedoch erwarten, dass ein regionales Schutzpaket (Web-ACL) von einem globalen Publikum verwendet wird, können Sie ein JavaScript CAPTCHA-Integrations-Tag mit Gültigkeitsbereich CloudFront und einen API-Schlüssel mit Gültigkeitsbereich abrufen und diese zusammen mit einem regionalen Schutzpaket (Web-ACL) verwenden. CloudFront Dieser Ansatz ermöglicht es Kunden, ein CAPTCHA-Puzzle aus der Region zu laden, die ihnen am nächsten ist, wodurch die Latenz reduziert wird. 

CAPTCHA-API-Schlüssel, die auf andere Regionen beschränkt sind, werden nicht für die Verwendung in CloudFront mehreren Regionen unterstützt. Sie können nur in der Region verwendet werden, auf die sie beschränkt sind. 

**Um einen API-Schlüssel für Ihre Kundendomänen zu generieren**  
Um die Integrations-URL abzurufen und die API-Schlüssel über die Konsole zu generieren und abzurufen. 

1. Melden Sie sich bei [https://console.aws.amazon.com/wafv2/homev2](https://console.aws.amazon.com/wafv2/homev2) an AWS-Managementkonsole und öffnen Sie die AWS WAF Konsole. 

1. Wählen Sie im Navigationsbereich **Application integration** (Anwendungsintegration) aus. 

1. Wählen Sie im Bereich **Schutzpakete (Web ACLs), die für die Anwendungsintegration aktiviert sind**, die Region aus, die Sie für Ihren API-Schlüssel verwenden möchten. Sie können die Region auch im Bereich **API-Schlüssel** auf der Registerkarte **CAPTCHA-Integration** auswählen.

1. Wählen Sie den Tab **CAPTCHA-Integration**. Auf dieser Registerkarte finden Sie das JavaScript CAPTCHA-Integrations-Tag, das Sie in Ihrer Integration verwenden können, sowie die Liste der API-Schlüssel. Beide sind auf die ausgewählte Region beschränkt.

1. Wählen Sie im Bereich **API-Schlüssel** die Option Schlüssel **generieren** aus. Der Dialog zur Schlüsselgenerierung wird angezeigt. 

1. Geben Sie die Client-Domänen ein, die Sie in den Schlüssel aufnehmen möchten. Sie können bis zu 5 eingeben. Wenn Sie fertig sind, wählen Sie **Schlüssel generieren**. Die Benutzeroberfläche kehrt zur Registerkarte CAPTCHA-Integration zurück, auf der Ihr neuer Schlüssel aufgeführt ist. 

   Einmal erstellt, ist ein API-Schlüssel unveränderlich. Wenn Sie Änderungen an einem Schlüssel vornehmen müssen, generieren Sie einen neuen Schlüssel und verwenden Sie ihn stattdessen. 

1. (Optional) Kopieren Sie den neu generierten Schlüssel zur Verwendung in Ihrer Integration. 

Sie können AWS SDKs für diese Arbeit auch den REST APIs oder eine der sprachspezifischen Sprachen verwenden. [Die REST-API-Aufrufe lauten [Create APIKey und List](https://docs.aws.amazon.com/waf/latest/APIReference/API_CreateAPIKey.html). APIKeys](https://docs.aws.amazon.com/waf/latest/APIReference/API_ListAPIKeys.html) 

**So löschen Sie einen API-Schlüssel**  
Um einen API-Schlüssel zu löschen, müssen Sie die REST-API oder eine der sprachspezifischen APIs verwenden AWS SDKs. Der REST-API-Aufruf lautet [Delete APIKey](https://docs.aws.amazon.com/waf/latest/APIReference/API_DeleteAPIKey.html). Sie können die Konsole nicht verwenden, um einen Schlüssel zu löschen. 

Nachdem Sie einen Schlüssel gelöscht haben, kann es bis zu 24 Stunden dauern, AWS WAF bis die Verwendung des Schlüssels in allen Regionen nicht mehr zulässig ist. 

# AWS WAF Integration mobiler Anwendungen
<a name="waf-mobile-sdk"></a>

In diesem Abschnitt wird das Thema der Verwendung von AWS WAF Mobiltelefonen SDKs zur Implementierung AWS WAF intelligenter Bedrohungsintegration SDKs für Android- und iOS-Mobil- und TV-Apps vorgestellt. TV-Apps SDKs sind mit den wichtigsten Smart-TV-Plattformen kompatibel, darunter Android TV und Apple TV.
+ Für Android-Apps und TV-Apps SDKs funktionieren sie für Android-API-Version 23 (Android-Version 6) und höher. Informationen zu Android-Versionen finden Sie in den [Versionshinweisen zur SDK-Plattform](https://developer.android.com/tools/releases/platforms).
+ Für mobile iOS-Apps SDKs funktionieren sie für iOS-Version 13 und höher. Informationen zu iOS-Versionen findest du in den [Versionshinweisen zu iOS und iPadOS](https://developer.apple.com/documentation/ios-ipados-release-notes).
+ Apple TV-Apps SDKs funktionieren für tvOS Version 14 oder höher. Informationen zu tvOS-Versionen finden Sie in den [tvOS-Versionshinweisen](https://developer.apple.com/documentation/tvos-release-notes).

Mit dem AWS WAF SDK für Mobilgeräte können Sie die Token-Autorisierung verwalten und die Tokens in die Anfragen aufnehmen, die Sie an Ihre geschützten Ressourcen senden. Durch die Verwendung von stellen Sie sicher SDKs, dass diese Remote-Prozedur-Aufrufe durch Ihren Client ein gültiges Token enthalten. Wenn diese Integration auf den Seiten Ihrer Anwendung eingerichtet ist, können Sie außerdem Regeln zur Risikominderung in Ihrem Schutzpaket (Web-ACL) implementieren, z. B. das Blockieren von Anfragen, die kein gültiges Token enthalten.

Wenden Sie sich für den Zugriff auf das Handy SDKs an den Support unter [Kontakt AWS](https://aws.amazon.com/contact-us).

**Anmerkung**  
Die AWS WAF Mobiltelefone SDKs sind nicht für die CAPTCHA-Anpassung verfügbar.

Der grundlegende Ansatz für die Verwendung des SDK besteht darin, mithilfe eines Konfigurationsobjekts einen Token-Anbieter zu erstellen und dann den Token-Anbieter zum Abrufen von Tokens zu verwenden. AWS WAF Standardmäßig schließt der Token-Anbieter die abgerufenen Token in die Webanforderungen an Ihre geschützte Ressource ein. 

Im Folgenden finden Sie eine unvollständige Auflistung einer SDK-Implementierung, die die Hauptkomponenten zeigt. Weitere detaillierte Beispiele finden Sie unter [Codebeispiele für das AWS WAF mobile SDK](waf-mobile-sdk-coding-examples.md).

------
#### [ iOS ]

```
let url: URL = URL(string: "protection pack (web ACL) integration URL")!
	let configuration = WAFConfiguration(applicationIntegrationUrl: url, domainName: "Domain name")
	let tokenProvider = WAFTokenProvider(configuration)
	let token = tokenProvider.getToken()
```

------
#### [ Android ]

```
URL applicationIntegrationURL = new URL("protection pack (web ACL) integration URL");
	String domainName = "Domain name";
	WAFConfiguration configuration = WAFConfiguration.builder().applicationIntegrationURL(applicationIntegrationURL).domainName(domainName).build();
	WAFTokenProvider tokenProvider = new WAFTokenProvider(Application context, configuration);
	WAFToken token = tokenProvider.getToken();
```

------

# Installation des SDK AWS WAF für Mobilgeräte
<a name="waf-mobile-sdk-installing"></a>

Dieser Abschnitt enthält Anweisungen zur Installation des SDK für AWS WAF Mobilgeräte.

Für den Zugriff auf das Handy wenden Sie SDKs sich an den Support unter [Kontakt AWS](https://aws.amazon.com/contact-us).

Implementieren Sie das SDK für Mobilgeräte zuerst in einer Testumgebung und dann in der Produktion.

**Um das SDK für AWS WAF Mobilgeräte zu installieren**

1. Melden Sie sich bei [https://console.aws.amazon.com/wafv2/homev2](https://console.aws.amazon.com/wafv2/homev2) an AWS-Managementkonsole und öffnen Sie die AWS WAF Konsole. 

1. Wählen Sie im Navigationsbereich **Application integration** (Anwendungsintegration) aus. 

1. Gehen Sie auf der Registerkarte **Intelligente Bedrohungsintegrationen** wie folgt vor: 

   1. Suchen Sie im Bereich **Schutzpakete (Web ACLs), die für die Anwendungsintegration aktiviert sind**, das Schutzpaket (Web-ACL), in das Sie integrieren möchten. Kopieren und speichern Sie die Integrations-URL des Protection Packs (Web-ACL) zur Verwendung in Ihrer Implementierung. Sie können diese URL auch über den API-Aufruf `GetWebACL` abrufen.

   1. Wählen Sie den Typ und die Version des Mobilgeräts und dann die Option **Download** (Herunterladen) aus. Sie können eine beliebige Version wählen, wir empfehlen jedoch, die neueste Version zu verwenden. AWS WAF lädt die `zip` Datei für Ihr Gerät an Ihren Standard-Download-Speicherort herunter.

1. Entpacken Sie die Datei in Ihrer App-Entwicklungsumgebung an einem Speicherort Ihrer Wahl. Suchen und öffnen Sie im Verzeichnis der ZIP-Datei die `README`-Datei. Folgen Sie den Anweisungen in der `README` Datei, um das AWS WAF mobile SDK zur Verwendung in Ihrem mobilen App-Code zu installieren. 

1. Programmieren Sie Ihre App gemäß den Anweisungen in den folgenden Abschnitten.

# AWS WAF SDK-Spezifikation für Mobilgeräte
<a name="waf-mobile-sdk-specification"></a>

In diesem Abschnitt werden die SDK-Objekte, -Operationen und -Konfigurationseinstellungen für die neueste verfügbare Version des SDK für AWS WAF Mobilgeräte aufgeführt. Ausführliche Informationen darüber, wie der Token-Anbieter und die Operationen für die verschiedenen Kombinationen von Konfigurationseinstellungen funktionieren, finden Sie unter [So funktioniert das SDK AWS WAF für Mobilgeräte](waf-mobile-sdk-how-it-works.md). 

**`WAFToken`**  
Enthält ein AWS WAF Token.    
**`getValue()`**  
Ruft die `String`-Darstellung des `WAFToken` auf. 

**`WAFTokenProvider`**  
Verwaltet Token in Ihrer mobilen App. Implementieren Sie dies mit einem `WAFConfiguration`-Objekt.    
**`getToken()`**  
Wenn die Hintergrundaktualisierung aktiviert ist, wird das zwischengespeicherte Token zurückgegeben. Wenn die Aktualisierung im Hintergrund deaktiviert ist, wird ein synchroner, blockierender Aufruf AWS WAF zum Abrufen eines neuen Tokens ausgeführt.   
**`loadTokenIntoProvider(WAFToken)`**  
Lädt das angegebene Token in das `WAFTokenProvider` und ersetzt dabei alle Token, die der Anbieter verwaltet hat. Der Token-Anbieter übernimmt den Besitz des neuen Tokens und kümmert sich um dessen zukünftige Aktualisierung. Dieser Vorgang aktualisiert auch das Token im Cookie-Speicher, sofern `setTokenCookie` es im aktiviert ist`WAFConfiguration`.  
**`onTokenReady(WAFTokenResultCallback)`**  
Dadurch wird der Token-Anbieter angewiesen, das Token zu aktualisieren und das bereitgestellte Callback aufzurufen, wenn ein aktives Token bereit ist. Der Token-Anbieter ruft das Callback in einem Hintergrund-Thread auf, wenn das Token zwischengespeichert und bereit ist. Rufen Sie dies auf, wenn Ihre App zum ersten Mal geladen wird und wenn sie wieder in einen aktiven Zustand zurückversetzt wird. Weitere Informationen zum Zurückversetzen in einen aktiven Zustand finden Sie unter [Abrufen eines Tokens nach App-Inaktivität](waf-mobile-sdk-how-it-works.md#waf-mobile-sdk-how-back-from-inactive).   
Für Android- oder iOS-Apps können Sie `WAFTokenResultCallback` auf die Operation festlegen, die der Token-Anbieter ausführen soll, wenn ein angefordertes Token bereit ist. Bei Ihrer Implementierung von `WAFTokenResultCallback` müssen die Parameter `WAFToken` und `SdkError` übernommen werden. Für iOS-Apps können Sie alternativ eine Inline-Funktion erstellen.   
**`storeTokenInCookieStorage(WAFToken)`**  
Weist den `WAFTokenProvider` an, das angegebene AWS WAF Token im Cookie-Manager des SDK zu speichern. Standardmäßig wird das Token dem Cookie-Speicher nur hinzugefügt, wenn es zum ersten Mal abgerufen und aktualisiert wird. Wenn die Anwendung den gemeinsamen Cookie-Speicher aus irgendeinem Grund löscht, fügt das SDK das AWS WAF Token erst bei der nächsten Aktualisierung automatisch wieder hinzu. 

**`WAFConfiguration`**  
Enthält die Konfiguration für die Implementierung des `WAFTokenProvider`. Wenn Sie dies implementieren, geben Sie die Integrations-URL Ihres Schutzpakets (Web-ACL), den Domainnamen, der im Token verwendet werden soll, und alle nicht standardmäßigen Einstellungen an, die der Token-Anbieter verwenden soll.   
In der folgenden Liste sind die Konfigurationseinstellungen aufgeführt, die Sie im `WAFConfiguration`-Objekt verwalten.    
**`applicationIntegrationUrl`**   
Die URL der Anwendungsintegration. Rufen Sie dies von der AWS WAF Konsole oder über den `getWebACL` API-Aufruf ab.  
Erforderlich: Ja  
Typ: App-spezifische URL. Informationen zu iOS finden Sie unter [iOS URL](https://developer.apple.com/documentation/foundation/url) (iOS-URL). Informationen zu Android finden Sie unter [java.net URL](https://docs.oracle.com/javase/7/docs/api/java/net/URL.html) (java.net-URL).   
**`backgroundRefreshEnabled`**   
Gibt an, ob der Token-Anbieter das Token im Hintergrund aktualisieren soll. Wenn Sie dies festlegen, aktualisiert der Token-Anbieter im Hintergrund Ihre Token gemäß den Konfigurationseinstellungen, die die Aktivitäten zur automatischen Token-Aktualisierung regeln.   
Erforderlich: Nein  
Typ: `Boolean`  
Standardwert: `TRUE`  
**`domainName`**   
Die im Token zu verwendende Domain, die bei der Token-Erfassung und Speicherung von Cookies verwendet wird. Zum Beispiel `example.com` oder `aws.amazon.com`. Dies ist normalerweise die Hostdomäne Ihrer Ressource, die dem Protection Pack (Web-ACL) zugeordnet ist, an das Sie Webanfragen senden werden. Bei der verwalteten ACFP-Regelgruppe handelt `AWSManagedRulesACFPRuleSet` es sich in der Regel um eine einzelne Domäne, die mit der Domäne im Kontoerstellungspfad übereinstimmt, den Sie in der Regelgruppenkonfiguration angegeben haben. Bei der von ATP verwalteten Regelgruppe `AWSManagedRulesATPRuleSet` handelt es sich in der Regel um eine einzelne Domäne, die der Domäne in dem Anmeldepfad entspricht, den Sie in der Regelgruppenkonfiguration angegeben haben.   
Öffentliche Suffixe sind nicht zulässig. Beispielsweise können Sie `gov.au` oder nicht `co.uk` als Token-Domain verwenden.  
Basierend auf der geschützten Host-Domain und der Token-Domainliste des Protection Packs (Web-ACL) muss es sich um eine Domain handeln, die akzeptiert AWS WAF wird. Weitere Informationen finden Sie unter [AWS WAF Konfiguration der Token-Domänenliste für das Protection Pack (Web-ACL)](waf-tokens-domains.md#waf-tokens-domain-lists).  
Erforderlich: Ja  
Typ: `String`   
**`maxErrorTokenRefreshDelayMsec`**   
Maximale Wartezeit in Millisekunden, bevor eine Token-Aktualisierung nach einem fehlgeschlagenen Versuch wiederholt wird. Für jede automatische Wiederholung eines fehlgeschlagenen Versuchs wird ein exponentieller Backoff bis zur angegebenen Eingabeverzögerungszeit hinzugefügt. Dieser Wert wird verwendet, nachdem der Token-Abruf fehlgeschlagen ist und `maxRetryCount`-mal erneut versucht wurde.   
Erforderlich: Nein  
Typ: `Integer`  
Standardwert: `5000` (5 Sekunden)  
Zulässiger Mindestwert: `1` (1 Millisekunde)  
Zulässiger Höchstwert: `30000` (30 Sekunden)  
**`maxRetryCount`**   
Die maximale Anzahl von Wiederholungen, die mit exponentiellem Backoff ausgeführt werden sollen, wenn ein Token angefordert wird.   
Erforderlich: Nein  
Typ: `Integer`  
Standardwert: `Infinity`  
Zulässiger Mindestwert: `0`  
Zulässiger Höchstwert: `100`  
**`setTokenCookie`**   
Gibt an, ob der Cookie-Manager des SDK ein Token-Cookie zu Anfragen und anderen Bereichen hinzufügen soll.   
Mit einem `TRUE` Wert:   
+ Der Cookie-Manager fügt allen Anfragen, deren Pfad unter dem in angegebenen Pfad liegt, ein Token-Cookie hinzu`tokenCookiePath`. 
+ Der `WAFTokenProvider` Vorgang `loadTokenIntoProvider()` aktualisiert das Token im Cookie-Speicher und lädt es zusätzlich in den Token-Anbieter.
Erforderlich: Nein  
Typ: `Boolean`  
Standardwert: `TRUE`  
**`tokenCookiePath`**   
Wird verwendet wenn `setTokenCookie` `TRUE` ist. Gibt den obersten Pfad an, auf dem der Cookie-Manager des SDK ein Token-Cookie hinzufügen soll. Der Manager fügt allen Anforderungen, die Sie an diesen Pfad und an alle untergeordneten Pfade senden, ein Token-Cookie hinzu.   
Wenn Sie hierfür beispielsweise `/web/login` festlegen, schließt der Manager das Token-Cookie für alles ein, was an `/web/login` und sämtliche untergeordneten Pfade, etwa `/web/login/help`, gesendet wird. Nicht enthalten ist das Token für Anforderungen, die an andere Pfade gesendet werden, etwa `/`, `/web` oder `/web/order`.   
Erforderlich: Nein  
Typ: `String`  
Standardwert: `/`  
**`tokenRefreshDelaySec`**   
Wird für die Hintergrundaktualisierung verwendet. Die maximale Zeitspanne in Sekunden zwischen den Hintergrundaktualisierungen des Tokens wird angezeigt.  
Erforderlich: Nein  
Typ: `Integer`  
Standardwert: `88`  
Zulässiger Mindestwert: `88`  
Zulässiger Höchstwert: `300` (5 Minuten)

## AWS WAF SDK-Fehler für Mobilgeräte
<a name="waf-mobile-sdk-errors"></a>

In diesem Abschnitt werden die möglichen Fehler für die aktuelle AWS WAF mobile SDK-Version aufgeführt.

**`SdkError`**  
Der Fehlertyp, der zurückgegeben wurde, wenn ein Token nicht abgerufen werden konnte. Das Android- und das iOS-SDK haben dieselben Fehlertypen.  
Das SDK AWS WAF für Mobilgeräte weist die folgenden Fehlertypen auf:    
**`invalidChallenge`**  
Dieser Fehler wird zurückgegeben, wenn der Token-Server ungültige Challenge-Daten zurückgibt oder der Antwort-Blob von einem Angreifer mutiert wurde.  
**`errorInvokingGetChallengeEndpoint`**  
Dieser Fehler wird zurückgegeben, wenn der Token-Server einen fehlgeschlagenen Antwortcode an den Client zurücksendet oder wenn ein Netzwerkfehler auftritt.  
**`invalidVerifyChallengeResponse`**  
Dieser Fehler wird zurückgegeben, wenn beim Abrufen der `aws-waf-token` Bestätigungsantwort des AWS WAF Servers ein Fehler auftritt oder wenn die Serverantwort manipuliert wurde.  
**`errorInvokingVerifyEndpoint`**  
Dieser Fehler wird zurückgegeben, wenn der Client eine schlechte Antwort vom AWS WAF Server erhält oder wenn bei der Überprüfung der gelösten Anfrage ein Netzwerkfehler aufgetreten ist.  
**`internalError`**  
Dieser Fehler wird bei allen anderen Fehlern zurückgegeben, die im SDK selbst auftreten können.

**`socketTimeoutException`**  
Dieser Fehler wird häufig zurückgegeben, wenn beim Abrufen von Token Netzwerkfehler auftreten.  
Dieser Fehler kann folgende Ursachen haben:  
+ Niedrige Netzwerkbandbreite: Bestätigen Sie Ihre Netzwerkverbindungseinstellungen
+ Mutierte URL für die Anwendungsintegration: Stellen Sie sicher, dass die Integrations-URL nicht an die auf der AWS WAF Konsole angezeigte URL angepasst wurde

# So funktioniert das SDK AWS WAF für Mobilgeräte
<a name="waf-mobile-sdk-how-it-works"></a>

In diesem Abschnitt wird erklärt, wie die Klassen, Eigenschaften und Operationen des AWS WAF mobilen SDK zusammenarbeiten.

Das Handy SDKs bietet Ihnen einen konfigurierbaren Token-Anbieter, den Sie zum Abrufen und Verwenden von Token verwenden können. Der Token-Anbieter überprüft, ob die von Ihnen zugelassenen Anforderungen von legitimen Kunden stammen. Wenn Sie Anfragen an die AWS Ressourcen senden, mit denen Sie sich schützen AWS WAF, fügen Sie das Token in ein Cookie ein, um die Anfrage zu validieren. Sie können das Token-Cookie manuell bearbeiten oder die Bearbeitung dem Token-Anbieter überlassen.

In diesem Abschnitt werden die Interaktionen zwischen den Klassen, Eigenschaften und Methoden behandelt, die im mobilen SDK enthalten sind. Informationen zur SDK-Spezifikation finden Sie unter [AWS WAF SDK-Spezifikation für Mobilgeräte](waf-mobile-sdk-specification.md). 

## Abrufen und Caching von Token
<a name="waf-mobile-sdk-how-token-basics"></a>

Wenn Sie die Instance des Token-Anbieters in Ihrer mobilen App erstellen, konfigurieren Sie, wie Sie Token und den Abruf von Token verwalten möchten. In erster Linie müssen Sie festlegen, wie gültige, nicht abgelaufene Token für die Verwendung in den Webanforderungen Ihrer App gepflegt werden sollen:
+ **Hintergrundaktualisierung aktiviert**: Das ist die Standardeinstellung. Der Token-Anbieter aktualisiert das Token automatisch im Hintergrund und speichert es im Cache. Bei aktivierter Hintergrundaktualisierung wird das zwischengespeicherte Token abgerufen, wenn Sie `getToken()` aufrufen. 

  Der Token-Anbieter führt die Token-Aktualisierung in konfigurierbaren Intervallen durch, sodass ein nicht abgelaufenes Token immer im Cache verfügbar ist, während die Anwendung aktiv ist. Die Hintergrundaktualisierung wird angehalten, während sich Ihre Anwendung in einem inaktiven Zustand befindet. Weitere Informationen hierzu finden Sie unter [Abrufen eines Tokens nach App-Inaktivität](#waf-mobile-sdk-how-back-from-inactive).
+ **Hintergrundaktualisierung deaktiviert**: Sie können die Hintergrundaktualisierung von Token deaktivieren und Token nur bei Bedarf abrufen. Bei Bedarf abgerufene Token werden nicht zwischengespeichert und Sie können mehrere abrufen, falls gewünscht. Jedes Token ist unabhängig von anderen abgerufenen Token und verfügt jeweils über einen eigenen Zeitstempel, der zur Berechnung des Ablaufs verwendet wird.

  Sie haben die folgenden Möglichkeiten für den Token-Abruf, wenn die Hintergrundaktualisierung deaktiviert ist: 
  + **`getToken()`**— Wenn Sie bei deaktivierter Aktualisierung im Hintergrund aufrufen`getToken()`, ruft der Aufruf synchron ein neues Token von ab. AWS WAF Dies ist ein potenziell blockierender Anruf, der sich auf die Reaktionsfähigkeit der App auswirken kann, wenn Sie ihn im Haupt-Thread aufrufen. 
  + **`onTokenReady(WAFTokenResultCallback)`**: Bei diesem Aufruf wird asynchron ein neues Token abgerufen. Das bereitgestellte Ergebnis-Callback wird dann in einem Hintergrund-Thread aufgerufen, wenn ein Token bereit ist. 

### Wiederholen fehlgeschlagener Token-Abrufe durch den Token-Anbieter
<a name="waf-mobile-sdk-how-token-retrieval-retries"></a>

Der Token-Anbieter wiederholt den Token-Abruf automatisch erneut, wenn er fehlgeschlagen ist. Wiederholungen werden zunächst mit exponentiellem Backoff mit einer Wartezeit von 100 ms durchgeführt. Hinweise zu exponentiellen Wiederholungen finden Sie unter [Fehlerwiederholungen](https://docs.aws.amazon.com/general/latest/gr/api-retries.html) und exponentielles Backoff in. AWS

Wenn die Anzahl der Wiederholungen die konfigurierte `maxRetryCount` erreicht, stellt der Token-Anbieter die Versuche entweder ein oder versucht es ab sofort alle `maxErrorTokenRefreshDelayMsec` Millisekunden, abhängig von der Art des Token-Abrufs: 
+ **`onTokenReady()`**: Der Token-Anbieter wartet ab sofort `maxErrorTokenRefreshDelayMsec` Millisekunden zwischen den einzelnen Versuchen und versucht weiterhin, das Token abzurufen. 
+ **Hintergrundaktualisierung**: Der Token-Anbieter wartet ab sofort `maxErrorTokenRefreshDelayMsec` Millisekunden zwischen den einzelnen Versuchen und versucht weiterhin, das Token abzurufen. 
+ **On-Demand-`getToken()`-Aufrufe, wenn die Hintergrundaktualisierung deaktiviert ist**: Der Token-Anbieter versucht nicht mehr, ein Token abzurufen, und gibt den Wert des vorherigen Tokens oder einen Nullwert zurück, wenn kein vorheriges Token vorhanden ist. 

## Szenarien für den Abruf und die Wiederholung von Token
<a name="waf-mobile-sdk-how-token-retrieval-retry-scenarios"></a>

Wenn der Token-Anbieter versucht, ein Token abzurufen, kann dies zu automatischen Wiederholungen führen, je nachdem, wo der Token-Abruf im Token-Akquisitionsablauf fehlschlägt. In diesem Abschnitt sind die möglichen Stellen aufgeführt, an denen möglicherweise eine automatische Wiederholung angezeigt wird.
+ **Abrufen oder Verifizieren der AWS WAF Challenge über /inputs oder /verify:**
  + Wenn eine Anfrage zum Abrufen und Überprüfen einer Anfrage AWS WAF gestellt wird und fehlschlägt, kann dies zu einer automatischen Wiederholung führen.
  + Möglicherweise stellen Sie hier automatische Wiederholungen zusammen mit einem `socketTimeoutException` Fehler fest. Dies kann mehrere Ursachen haben, darunter:
    + Niedrige Netzwerkbandbreite: Bestätigen Sie Ihre Netzwerkverbindungseinstellungen
    + Mutierte URL für die Anwendungsintegration: Stellen Sie sicher, dass die Integrations-URL nicht an die auf der AWS WAF Konsole angezeigte URL angepasst wurde
  + Die Anzahl der automatischen Wiederholungen ist mit der Funktion konfigurierbar `maxRetryCount()`
+ **Das Token aktualisieren:**
  + Wenn eine Anforderung zur Aktualisierung des Tokens über den Token-Handler gestellt wird, kann dies zu einer automatischen Wiederholung führen.
  + Die Anzahl der automatischen Wiederholungen ist hier mit der `maxRetryCount()` Funktion konfigurierbar.

Eine Konfiguration ohne automatische Wiederholungen ist per Einstellung möglich. `maxRetryCount(0)`

## Token-Immunitätszeit und Aktualisierung im Hintergrund
<a name="waf-mobile-sdk-how-token-immunity"></a>

Die Token-Immunitätszeit, die Sie in der Web-ACL konfigurieren, ist unabhängig vom Token-Aktualisierungsintervall, das Sie im SDK für AWS WAF Mobilgeräte festgelegt haben. Wenn Sie die Aktualisierung im Hintergrund aktivieren, aktualisiert das SDK das Token in dem von Ihnen angegebenen `tokenRefreshDelaySec()` Intervall. Dies kann dazu führen, dass mehrere gültige Token gleichzeitig existieren, abhängig von Ihrer konfigurierten Immunitätszeit.

Um zu verhindern, dass mehrere gültige Token vorhanden sind, können Sie die Aktualisierung im Hintergrund deaktivieren und die `getToken()` Funktion verwenden, um den Token-Lebenszyklus in Ihrer mobilen App zu verwalten.

## Abrufen eines Tokens nach App-Inaktivität
<a name="waf-mobile-sdk-how-back-from-inactive"></a>

Die Hintergrundaktualisierung wird nur durchgeführt, während Ihre App für Ihren App-Typ als aktiv gilt: 
+ **iOS**: Die Hintergrundaktualisierung wird durchgeführt, wenn sich die App im Vordergrund befindet.
+ **Android**: Die Hintergrundaktualisierung wird durchgeführt, wenn die App nicht geschlossen wird, unabhängig davon, ob sie sich im Vordergrund oder im Hintergrund befindet.

Wenn Ihre App in einem Zustand verbleibt, der die Hintergrundaktualisierung länger als die konfigurierten `tokenRefreshDelaySec` Sekunden nicht unterstützt, unterbricht der Token-Anbieter die Hintergrundaktualisierung. Wenn beispielsweise für eine iOS-App die `tokenRefreshDelaySec` 300 beträgt und die App geschlossen wird oder länger als 300 Sekunden in den Hintergrund versetzt wird, aktualisiert der Token-Anbieter das Token nicht mehr. Wenn die App in einen aktiven Zustand zurückkehrt, startet der Token-Anbieter die Hintergrundaktualisierung automatisch neu. 

Wenn Ihre App wieder in einen aktiven Zustand zurückkehrt, rufen Sie `onTokenReady()` auf, um benachrichtigt zu werden, wenn der Token-Anbieter ein neues Token abgerufen und zwischengespeichert hat. Rufen Sie nicht einfach an`getToken()`, da der Cache möglicherweise noch kein aktuelles, gültiges Token enthält. 

## URL zur Anwendungsintegration
<a name="waf-mobile-sdk-application-integration-url"></a>

Die URL zur Integration der AWS WAF mobilen SDK-Anwendung verweist auf eine Web-ACL, die Sie für die Anwendungsintegration aktiviert haben. Diese URL leitet Anfragen an den richtigen Backend-Server weiter und ordnet sie Ihrem Kunden zu. Sie dient nicht als strenge Sicherheitskontrolle, sodass die Offenlegung einer Integrations-URL kein Sicherheitsrisiko darstellt.

Sie können die angegebene Integrations-URL technisch ändern und trotzdem ein Token erhalten. Wir empfehlen dies jedoch nicht, da Sie möglicherweise den Überblick über die Anzahl der Problemlösungen verlieren oder `socketTimeoutException` Fehler beim Abrufen von Token auftreten könnten.

## Abhängigkeiten
<a name="waf-mobile-sdk-dependencies"></a>

Jedes herunterladbare SDK für AWS WAF Mobilgeräte enthält eine README-Datei, in der die Abhängigkeiten für die jeweilige Version des SDK aufgeführt sind. Die Abhängigkeiten für Ihre Version des SDK für Mobilgeräte finden Sie in der README-Datei.

## Verschleierung/ (ProGuard nur Android-SDK)
<a name="waf-mobile-sdk-obfuscation"></a>

Wenn Sie ein Produkt wie Verschleierung oder Minimierung verwenden, müssen Sie möglicherweise bestimmte Namespaces ausschließen ProGuard, um sicherzustellen, dass das SDK für Mobilgeräte ordnungsgemäß funktioniert. Die Liste der Namespaces und Ausschlussregeln finden Sie in der README-Datei für Ihre Version des SDK für Mobilgeräte.

# Codebeispiele für das AWS WAF mobile SDK
<a name="waf-mobile-sdk-coding-examples"></a>

Dieser Abschnitt enthält Beispiele für die Verwendung des SDK für Mobilgeräte. 

## Initialisieren des Token-Anbieters und Abrufen von Token
<a name="waf-mobile-sdk-coding-basic"></a>

Sie initiieren die Instance des Token-Anbieters mit einem Konfigurationsobjekt. Dann können Sie Token mit den verfügbaren Operationen abrufen. Im Folgenden finden Sie die grundlegenden Benutzeroberflächenkomponenten des erforderlichen Codes.

------
#### [ iOS ]

```
let url: URL = URL(string: "protection pack (web ACL) integration URL")!
let configuration = WAFConfiguration(applicationIntegrationUrl: url, domainName: "Domain name")
let tokenProvider = WAFTokenProvider(configuration)

//onTokenReady can be add as an observer for UIApplication.willEnterForegroundNotification
self.tokenProvider.onTokenReady() { token, error in
	if let token = token {
	//token available
	}

	if let error = error {
	//error occurred after exhausting all retries
	}
}

//getToken()
let token = tokenProvider.getToken()
```

------
#### [ Android ]

Java-Beispiel:

```
String applicationIntegrationURL = "protection pack (web ACL) integration URL";
//Or
URL applicationIntegrationURL = new URL("protection pack (web ACL) integration URL");

String domainName = "Domain name";

WAFConfiguration configuration = WAFConfiguration.builder().applicationIntegrationURL(applicationIntegrationURL).domainName(domainName).build();
WAFTokenProvider tokenProvider = new WAFTokenProvider(Application context, configuration);

// implement a token result callback
WAFTokenResultCallback callback = (wafToken, error) -> {
	if (wafToken != null) {
	// token available
	} else {  
	// error occurred in token refresh  
	}
};

// Add this callback to application creation or activity creation where token will be used
tokenProvider.onTokenReady(callback);

// Once you have token in token result callback
// if background refresh is enabled you can call getToken() from same tokenprovider object
// if background refresh is disabled you can directly call getToken()(blocking call) for new token
WAFToken token = tokenProvider.getToken();
```

Kotlin-Beispiel:

```
import com.amazonaws.waf.mobilesdk.token.WAFConfiguration
import com.amazonaws.waf.mobilesdk.token.WAFTokenProvider

private lateinit var wafConfiguration: WAFConfiguration
private lateinit var wafTokenProvider: WAFTokenProvider

private val WAF_INTEGRATION_URL = "protection pack (web ACL) integration URL"
private val WAF_DOMAIN_NAME = "Domain name"

fun initWaf() {
	// Initialize the tokenprovider instance
	val applicationIntegrationURL = URL(WAF_INTEGRATION_URL)
	wafConfiguration =
		WAFConfiguration.builder().applicationIntegrationURL(applicationIntegrationURL)
			.domainName(WAF_DOMAIN_NAME).backgroundRefreshEnabled(true).build()
	wafTokenProvider = WAFTokenProvider(getApplication(), wafConfiguration)
	
		// getToken from tokenprovider object
		println("WAF: "+ wafTokenProvider.token.value)
	
		// implement callback for where token will be used
		wafTokenProvider.onTokenReady {
			wafToken, sdkError ->
		run {
			println("WAF Token:" + wafToken.value)
		}
	}
}
```

------

## Zulassen, dass das SDK das Token-Cookie in Ihren HTTP-Anforderungen bereitstellt
<a name="waf-mobile-sdk-coding-auto-token-cookie"></a>

Wenn `setTokenCookie` `TRUE` ist, stellt der Token-Anbieter das Token-Cookie in Ihren Webanforderungen an allen Standorten unter dem Pfad bereit, der in `tokenCookiePath` angegeben wurde. Standardmäßig ist `setTokenCookie` `TRUE` und `tokenCookiePath` ist `/`. 

Sie schränken den Umfang der Anforderungen, die ein Token-Cookie enthalten, ein, indem Sie den Token-Cookie-Pfad angeben, zum Beispiel `/web/login`. Wenn Sie dies tun, stellen Sie sicher, dass Ihre AWS WAF Regeln in den Anfragen, die Sie an andere Pfade senden, nicht nach Tokens suchen. Wenn Sie die `AWSManagedRulesACFPRuleSet` Regelgruppe verwenden, konfigurieren Sie die Pfade zur Kontoregistrierung und Kontoerstellung, und die Regelgruppe sucht in Anfragen, die an diese Pfade gesendet werden, nach Tokens. Weitere Informationen finden Sie unter [Hinzufügen der verwalteten ACFP-Regelgruppe zu Ihrer Web-ACL](waf-acfp-rg-using.md). Wenn Sie die `AWSManagedRulesATPRuleSet` Regelgruppe verwenden, konfigurieren Sie auf ähnliche Weise den Anmeldepfad, und die Regelgruppe sucht in Anfragen, die an diesen Pfad gesendet werden, nach Tokens. Weitere Informationen finden Sie unter [Hinzufügen der von ATP verwalteten Regelgruppe zu Ihrem Protection Pack (Web-ACL)](waf-atp-rg-using.md). 

------
#### [ iOS ]

Wenn `setTokenCookie` ja`TRUE`, speichert der Token-Anbieter das AWS WAF Token in einer `HTTPCookieStorage.shared` und nimmt das Cookie automatisch in Anfragen an die Domain auf, in der Sie angegeben haben`WAFConfiguration`.

```
let request = URLRequest(url: URL(string: domainEndpointUrl)!)
//The token cookie is set automatically as cookie header
let task = URLSession.shared.dataTask(with: request) { data, urlResponse, error  in
}.resume()
```

------
#### [ Android ]

In `setTokenCookie` diesem `TRUE` Fall speichert der Token-Anbieter das AWS WAF Token in einer `CookieHandler` Instanz, die für die gesamte Anwendung gemeinsam genutzt wird. Der Token-Anbieter schließt das Cookie automatisch in Anforderungen an die Domäne ein, die Sie in der `WAFConfiguration` angegeben haben.

Java-Beispiel:

```
URL url = new URL("Domain name");
//The token cookie is set automatically as cookie header
HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
connection.getResponseCode();
```

Kotlin-Beispiel:

```
val url = URL("Domain name")
//The token cookie is set automatically as cookie header
val connection = (url.openConnection() as HttpsURLConnection)
connection.responseCode
```

Wenn Sie die `CookieHandler`-Standard-Instance bereits initialisiert haben, nutzt der Token-Anbieter diese zur Verwaltung von Cookies. Wenn nicht, initialisiert der Token-Anbieter eine neue `CookieManager` Instanz mit dem AWS WAF Token `CookiePolicy.ACCEPT_ORIGINAL_SERVER` und legt diese neue Instanz dann als Standardinstanz in `CookieHandler` fest.

Der folgende Code zeigt, wie das SDK den Cookie-Manager und den Cookie-Handler initialisiert, wenn diese in Ihrer App nicht verfügbar sind. 

Java-Beispiel:

```
CookieManager cookieManager = (CookieManager) CookieHandler.getDefault();
if (cookieManager == null) {
	// Cookie manager is initialized with CookiePolicy.ACCEPT_ORIGINAL_SERVER
	cookieManager = new CookieManager();
	CookieHandler.setDefault(cookieManager);
}
```

Kotlin-Beispiel:

```
var cookieManager = CookieHandler.getDefault() as? CookieManager
if (cookieManager == null) {
	// Cookie manager is initialized with CookiePolicy.ACCEPT_ORIGINAL_SERVER
	cookieManager = CookieManager()
	CookieHandler.setDefault(cookieManager)
}
```

------

## Manuelles Bereitstellen des Token-Cookies in Ihren HTTP–Anforderungen
<a name="waf-mobile-sdk-coding-manual-token-cookie"></a>

Wenn Sie `setTokenCookie` auf `FALSE` festlegen, müssen Sie das Token-Cookie manuell als Cookie-HTTP-Anforderungsheader in den Anforderungen an Ihren geschützten Endpunkt bereitstellen. Der folgende Code veranschaulicht, wie dazu vorgegangen wird.

------
#### [ iOS ]

```
var request = URLRequest(url: wafProtectedEndpoint)
request.setValue("aws-waf-token=token from token provider", forHTTPHeaderField: "Cookie")
request.httpShouldHandleCookies = true
URLSession.shared.dataTask(with: request) { data, response, error in }
```

------
#### [ Android ]

Java-Beispiel:

```
URL url = new URL("Domain name");
HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
String wafTokenCookie = "aws-waf-token=token from token provider";
connection.setRequestProperty("Cookie", wafTokenCookie);
connection.getInputStream();
```

Kotlin-Beispiel:

```
val url = URL("Domain name")
val connection = (url.openConnection() as HttpsURLConnection)
val wafTokenCookie = "aws-waf-token=token from token provider"
connection.setRequestProperty("Cookie", wafTokenCookie)
connection.inputStream
```

------