

**Présentation d'une nouvelle expérience de console pour AWS WAF**

Vous pouvez désormais utiliser l'expérience mise à jour pour accéder aux AWS WAF fonctionnalités n'importe où dans la console. Pour plus de détails, consultez la section [Utilisation de la console](https://docs.aws.amazon.com/waf/latest/developerguide/working-with-console.html). 

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# AWS WAF JavaScript intégrations
<a name="waf-javascript-api"></a>

Cette section explique comment utiliser les AWS WAF JavaScript intégrations.

Vous pouvez utiliser l' JavaScript intégration APIs pour implémenter des intégrations AWS WAF d'applications dans vos navigateurs et autres appareils qui s'exécutent JavaScript. 

Les puzzles CAPTCHA et les défis silencieux ne peuvent être exécutés que lorsque les navigateurs accèdent à des points de terminaison HTTPS. Les clients du navigateur doivent fonctionner dans des contextes sécurisés pour acquérir des jetons. 
+ Cette menace APIs intelligente vous permet de gérer l'autorisation des jetons par le biais d'un défi de navigateur silencieux côté client et d'inclure les jetons dans les demandes que vous envoyez à vos ressources protégées. 
+ L'API d'intégration CAPTCHA renforce la menace APIs intelligente et vous permet de personnaliser l'emplacement et les caractéristiques du puzzle CAPTCHA dans vos applications clientes. Cette API exploite la menace intelligente pour acquérir des AWS WAF jetons APIs à utiliser sur la page une fois que l'utilisateur final a réussi à résoudre le casse-tête CAPTCHA. 

En utilisant ces intégrations, vous vous assurez que les appels de procédure à distance de votre client contiennent un jeton valide. Lorsque ces intégrations APIs sont en place sur les pages de votre application, vous pouvez implémenter des règles d'atténuation dans votre pack de protection (ACL Web), telles que le blocage des demandes qui ne contiennent pas de jeton valide. Vous pouvez également implémenter des règles qui imposent l'utilisation des jetons que vos applications clientes obtiennent, en utilisant les CAPTCHA actions Challenge ou de vos règles. 

**Exemple de mise en œuvre d'une menace intelligente APIs**  
La liste suivante présente les composants de base d'une implémentation typique de la menace intelligente APIs dans une page d'application Web. 

```
<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>
```

**Exemple d'implémentation de l'API CAPTCHA JavaScript**  
L'API d'intégration CAPTCHA vous permet de personnaliser l'expérience de puzzle CAPTCHA de vos utilisateurs finaux. L'intégration CAPTCHA tire parti de l'intégration JavaScript intelligente des menaces, pour la vérification du navigateur et la gestion des jetons, et ajoute une fonction pour configurer et afficher le puzzle CAPTCHA. 

La liste suivante présente les composants de base d'une implémentation typique de l' JavaScript API CAPTCHA dans une page d'application Web. 

```
<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**
+ [Fournir des domaines à utiliser dans les jetons](waf-js-challenge-api-set-token-domain.md)
+ [Utilisation de l' JavaScript API avec des politiques de sécurité du contenu](waf-javascript-api-csp.md)
+ [Utilisation de l' JavaScript API de gestion intelligente des menaces](waf-js-challenge-api.md)
+ [Utilisation de l'API CAPTCHA JavaScript](waf-js-captcha-api.md)

# Fournir des domaines à utiliser dans les jetons
<a name="waf-js-challenge-api-set-token-domain"></a>

Cette section explique comment fournir des domaines supplémentaires pour les jetons.

Par défaut, lors de AWS WAF la création d'un jeton, celui-ci utilise le domaine hôte de la ressource associée au pack de protection (ACL Web). Vous pouvez fournir des domaines supplémentaires pour les jetons AWS WAF créés pour le JavaScript APIs. Pour ce faire, configurez la variable `window.awsWafCookieDomainList` globale avec un ou plusieurs domaines de jetons. 

Lors AWS WAF de la création d'un jeton, il utilise le domaine le plus approprié et le plus court parmi la combinaison des domaines `window.awsWafCookieDomainList` et du domaine hôte de la ressource associée au pack de protection (ACL Web). 

Exemples de paramètres : 

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

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

Vous ne pouvez pas utiliser de suffixes publics dans cette liste. Par exemple, vous ne pouvez pas utiliser `gov.au` ou `co.uk` comme domaines symboliques dans la liste.

Les domaines que vous spécifiez dans cette liste doivent être compatibles avec vos autres domaines et configurations de domaines : 
+ Les domaines doivent être ceux qui AWS WAF seront acceptés, en fonction du domaine hôte protégé et de la liste de domaines de jetons configurée pour le pack de protection (ACL Web). Pour de plus amples informations, veuillez consulter [AWS WAF configuration de la liste de domaines de jetons du pack de protection (ACL Web)](waf-tokens-domains.md#waf-tokens-domain-lists). 
+ Si vous utilisez l'API JavaScript CAPTCHA, au moins un domaine de votre clé d'API CAPTCHA doit correspondre exactement à l'un des domaines de jetons `window.awsWafCookieDomainList` ou il doit être le domaine apex de l'un de ces domaines de jetons. 

  Par exemple, pour le domaine de jeton`mySubdomain.myApex.com`, la clé `mySubdomain.myApex.com` d'API correspond exactement et la clé d'API `myApex.com` est le domaine apex. L'une ou l'autre des clés correspond au domaine du jeton. 

  Pour plus d'informations sur les clés d'API, consultez[Gestion des clés d'API pour l'API JS CAPTCHA](waf-js-captcha-api-key.md). 

Si vous utilisez le groupe de règles `AWSManagedRulesACFPRuleSet` géré, vous pouvez configurer un domaine qui correspond à celui indiqué dans le chemin de création de compte que vous avez indiqué dans la configuration du groupe de règles. Pour en savoir plus sur cette configuration, consultez [Ajouter le groupe de règles géré par l'ACFP à votre ACL Web](waf-acfp-rg-using.md).

Si vous utilisez le groupe de règles `AWSManagedRulesATPRuleSet` géré, vous pouvez configurer un domaine qui correspond à celui indiqué dans le chemin de connexion que vous avez indiqué pour la configuration du groupe de règles. Pour en savoir plus sur cette configuration, consultez [Ajouter le groupe de règles géré par ATP à votre pack de protection (ACL Web)](waf-atp-rg-using.md).

# Utilisation de l' JavaScript API avec des politiques de sécurité du contenu
<a name="waf-javascript-api-csp"></a>

Cette section fournit un exemple de configuration pour autoriser le domaine AWS WAF apex à être répertorié.

Si vous appliquez des politiques de sécurité du contenu (CSP) à vos ressources, pour que votre JavaScript implémentation fonctionne, vous devez autoriser le domaine AWS WAF apex sur la liste. `awswaf.com` Ils JavaScript SDKs font des appels à différents AWS WAF points de terminaison, donc allowlisting ce domaine fournit les autorisations dont ils SDKs ont besoin pour fonctionner.

Voici un exemple de configuration permettant d'autoriser le domaine AWS WAF apex à être répertorié : 

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

Si vous essayez d'utiliser le JavaScript SDKs avec des ressources qui utilisent le CSP et que vous n'avez pas autorisé le AWS WAF domaine dans la liste, vous recevrez des erreurs du type suivant : 

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

# Utilisation de l' JavaScript API de gestion intelligente des menaces
<a name="waf-js-challenge-api"></a>

Cette section fournit des instructions relatives à l'utilisation de l' JavaScript API de menace intelligente dans votre application cliente.

La menace intelligente APIs fournit des opérations permettant d'exécuter des défis silencieux contre le navigateur de l'utilisateur et de gérer les AWS WAF jetons qui prouvent le succès des réponses aux défis et aux CAPTCHA. 

Implémentez l' JavaScript intégration d'abord dans un environnement de test, puis en production. Pour obtenir des conseils supplémentaires sur le codage, consultez les sections suivantes. 

 

**Pour utiliser la menace intelligente APIs**

1. **Installez le APIs** 

   Si vous utilisez l'API CAPTCHA, vous pouvez ignorer cette étape. Lorsque vous installez l'API CAPTCHA, le script installe automatiquement la menace intelligente. APIs

   1. Connectez-vous à la AWS WAF console AWS Management Console et ouvrez-la sur [https://console.aws.amazon.com/wafv2/homev2](https://console.aws.amazon.com/wafv2/homev2). 

   1. Dans le panneau de navigation, choisissez **Intégration d'applications**. Sur la page **d'intégration des applications**, vous pouvez voir les options sous forme d'onglets. 

   1. Sélectionnez **Intégration intelligente des menaces**

   1. Dans l'onglet, sélectionnez le pack de protection (ACL Web) que vous souhaitez intégrer. La liste des packs de protection (ACL Web) inclut uniquement les packs de protection (Web ACLs) qui utilisent le groupe de règles `AWSManagedRulesACFPRuleSet` `AWSManagedRulesATPRuleSet` géré, le groupe de règles géré ou le niveau de protection ciblé du groupe de règles `AWSManagedRulesBotControlRuleSet` géré. 

   1. Ouvrez le volet **JavaScript SDK** et copiez la balise de script à utiliser dans votre intégration. 

   1. Dans le code de page de votre application, dans la `<head>` section, insérez la balise de script que vous avez copiée pour le pack de protection (ACL Web). Cette inclusion permet à votre application cliente de récupérer automatiquement un jeton en arrière-plan lors du chargement de la page. 

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

      Cette `<script>` liste est configurée avec l'`defer`attribut, mais vous pouvez modifier le paramètre `async` si vous souhaitez un comportement différent pour votre page. 

1. **(Facultatif) Ajoutez une configuration de domaine pour les jetons du client** : par défaut, AWS WAF lors de la création d'un jeton, celui-ci utilise le domaine hôte de la ressource associée au pack de protection (ACL Web). Pour fournir des domaines supplémentaires pour le JavaScript APIs, suivez les instructions sur[Fournir des domaines à utiliser dans les jetons](waf-js-challenge-api-set-token-domain.md). 

1. **Codez votre intégration intelligente des menaces** : écrivez votre code pour vous assurer que la récupération des jetons est terminée avant que le client n'envoie ses demandes à vos points de terminaison protégés. Si vous utilisez déjà l'`fetch`API pour effectuer votre appel, vous pouvez remplacer le `fetch` wrapper AWS WAF d'intégration. Si vous n'utilisez pas l'`fetch`API, vous pouvez utiliser l'`getToken`opération AWS WAF d'intégration à la place. Pour obtenir des conseils de codage, consultez les sections suivantes. 

1. **Ajoutez la vérification par jeton dans votre pack de protection (ACL Web)** : ajoutez au moins une règle à votre pack de protection (ACL Web) qui vérifie la validité d'un jeton de défi dans les requêtes Web envoyées par votre client. Vous pouvez utiliser des groupes de règles qui vérifient et surveillent les jetons de défi, comme le niveau cible du groupe de règles géré par Bot Control, et vous pouvez utiliser l'action de Challenge règle pour vérifier, comme décrit dans[CAPTCHAet Challenge dans AWS WAF](waf-captcha-and-challenge.md). 

   Les ajouts au pack de protection (ACL Web) vérifient que les demandes adressées à vos points de terminaison protégés incluent le jeton que vous avez acquis lors de l'intégration de votre client. Les demandes qui incluent un jeton valide et non expiré passent l'Challengeinspection et ne constituent pas un autre défi silencieux pour votre client. 

1. **(Facultatif) Bloquer les demandes pour lesquelles il manque des jetons** — Si vous utilisez le APIs groupe de règles géré par l'ACFP, le groupe de règles géré ATP ou les règles ciblées du groupe de règles Bot Control, ces règles ne bloquent pas les demandes contenant des jetons manquants. Pour bloquer les demandes auxquelles il manque des jetons, suivez les instructions sur[Blocage des demandes dont le AWS WAF jeton n'est pas valide](waf-tokens-block-missing-tokens.md). 

**Topics**
+ [Spécification de l'API de menace intelligente](waf-js-challenge-api-specification.md)
+ [Comment utiliser le `fetch` wrapper d'intégration](waf-js-challenge-api-fetch-wrapper.md)
+ [Comment utiliser l'intégration `getToken`](waf-js-challenge-api-get-token.md)

# Spécification de l'API de menace intelligente
<a name="waf-js-challenge-api-specification"></a>

Cette section répertorie les spécifications relatives aux méthodes et aux propriétés de l'atténuation intelligente des menaces JavaScript APIs. Utilisez-les APIs pour les intégrations intelligentes des menaces et des CAPTCHA.

**`AwsWafIntegration.fetch()`**  
Envoie la `fetch` requête HTTP au serveur à l'aide de l'implémentation AWS WAF d'intégration. 

**`AwsWafIntegration.getToken()`**  
Récupère le AWS WAF jeton stocké et le stocke dans un cookie sur la page en cours avec un nom `aws-waf-token` et une valeur définie sur la valeur du jeton. 

**`AwsWafIntegration.hasToken()`**  
Renvoie une valeur booléenne indiquant si le `aws-waf-token` cookie contient actuellement un jeton non expiré. 

Si vous utilisez également l'intégration CAPTCHA, consultez les spécifications correspondantes à l'adresse. [Spécification de l'API CAPTCHA JavaScript](waf-js-captcha-api-specification.md)

# Comment utiliser le `fetch` wrapper d'intégration
<a name="waf-js-challenge-api-fetch-wrapper"></a>

Cette section fournit des instructions pour utiliser le `fetch` wrapper d'intégration.

Vous pouvez utiliser le AWS WAF `fetch` wrapper en modifiant vos `fetch` appels habituels à l'`fetch`API sous l'espace de `AwsWafIntegration` noms. Le AWS WAF wrapper prend en charge les mêmes options que l'appel d' JavaScript `fetch`API standard et ajoute la gestion des jetons pour l'intégration. Cette approche est généralement la méthode la plus simple pour intégrer votre application. 

**Avant l'implémentation du wrapper**  
La liste d'exemples suivante montre le code standard avant d'implémenter le `AwsWafIntegration` `fetch` wrapper.

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

**Après l'implémentation du wrapper**  
La liste suivante montre le même code avec l'implémentation du `AwsWafIntegration` `fetch` wrapper.

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

# Comment utiliser l'intégration `getToken`
<a name="waf-js-challenge-api-get-token"></a>

Cette section explique comment utiliser cette `getToken` opération.

AWS WAF nécessite que vos demandes adressées aux points de terminaison protégés incluent le cookie nommé `aws-waf-token` avec la valeur de votre jeton actuel. 

L'`getToken`opération est un appel d'API asynchrone qui récupère le AWS WAF jeton et le stocke dans un cookie sur la page en cours avec un nom `aws-waf-token` et une valeur définie sur la valeur du jeton. Vous pouvez utiliser ce cookie symbolique selon vos besoins sur votre page. 

Lorsque vous appelez`getToken`, il effectue les opérations suivantes : 
+ Si un jeton non expiré est déjà disponible, l'appel le renvoie immédiatement.
+ Dans le cas contraire, l'appel récupère un nouveau jeton auprès du fournisseur de jetons, en attendant jusqu'à 2 secondes que le flux de travail d'acquisition de jetons soit terminé avant l'expiration du délai imparti. Si l'opération expire, elle génère une erreur que votre code d'appel doit gérer. 

L'`getToken`opération est accompagnée d'une `hasToken` opération qui indique si le `aws-waf-token` cookie contient actuellement un jeton non expiré. 

`AwsWafIntegration.getToken()`récupère un jeton valide et le stocke sous forme de cookie. La plupart des appels clients joignent automatiquement ce cookie, mais ce n'est pas le cas pour certains. Par exemple, les appels passés entre des domaines hôtes ne joignent pas le cookie. Dans les détails de mise en œuvre qui suivent, nous montrons comment travailler avec les deux types d'appels clients. 

**`getToken`Implémentation de base, pour les appels qui joignent le `aws-waf-token` cookie**  
L'exemple de liste suivant montre le code standard pour implémenter l'`getToken`opération avec une demande de connexion.

```
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
	}
```

**Soumettre le formulaire uniquement une fois que le jeton sera disponible auprès de `getToken`**  
La liste suivante indique comment enregistrer un écouteur d'événements pour intercepter les soumissions de formulaires jusqu'à ce qu'un jeton valide soit disponible pour utilisation. 

```
<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>
```

**Joindre le jeton lorsque votre client n'attache pas le `aws-waf-token` cookie par défaut**  
`AwsWafIntegration.getToken()`récupère un jeton valide et le stocke sous forme de cookie, mais tous les appels clients ne joignent pas ce cookie par défaut. Par exemple, les appels passés entre des domaines hôtes ne joignent pas le cookie. 

Le `fetch` wrapper gère ces cas automatiquement, mais si vous n'êtes pas en mesure d'utiliser le `fetch` wrapper, vous pouvez le faire en utilisant un en-tête personnalisé`x-aws-waf-token`. AWS WAF lit les jetons depuis cet en-tête, en plus de les lire depuis le `aws-waf-token` cookie. Le code suivant montre un exemple de définition de l'en-tête. 

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

Par défaut, AWS WAF n'accepte que les jetons contenant le même domaine que le domaine hôte demandé. Tous les jetons interdomaines nécessitent des entrées correspondantes dans la liste des domaines des jetons du pack de protection (ACL Web). Pour de plus amples informations, veuillez consulter [AWS WAF configuration de la liste de domaines de jetons du pack de protection (ACL Web)](waf-tokens-domains.md#waf-tokens-domain-lists). 

Pour plus d'informations sur l'utilisation de jetons entre domaines, consultez [aws-waf-bot-controlaws-samples/](https://github.com/aws-samples/aws-waf-bot-control-api-protection-with-captcha) -. api-protection-with-captcha

# Utilisation de l'API CAPTCHA JavaScript
<a name="waf-js-captcha-api"></a>

Cette section fournit des instructions pour utiliser l'API d'intégration CAPTCHA.

L' JavaScript API CAPTCHA vous permet de configurer le puzzle CAPTCHA et de le placer où vous le souhaitez dans votre application cliente. Cette API exploite les fonctionnalités de la menace intelligente JavaScript APIs pour acquérir et utiliser des AWS WAF jetons une fois qu'un utilisateur final a réussi à résoudre un casse-tête CAPTCHA. 

Implémentez l' JavaScript intégration d'abord dans un environnement de test, puis en production. Pour obtenir des conseils supplémentaires sur le codage, consultez les sections suivantes. 

**Pour utiliser l'API d'intégration CAPTCHA**

1. **Installation de l'API**

   1. Connectez-vous à la AWS WAF console AWS Management Console et ouvrez-la sur [https://console.aws.amazon.com/wafv2/homev2](https://console.aws.amazon.com/wafv2/homev2). 

   1. Dans le panneau de navigation, choisissez **Intégration d'applications**. Sur la page **d'intégration des applications**, vous pouvez voir les options sous forme d'onglets. 

   1. Sélectionnez l'**intégration CAPTCHA**.

   1. Copiez la balise de script JavaScript d'intégration répertoriée pour l'utiliser dans votre intégration.

   1. Dans le code de page de votre application, dans la `<head>` section, insérez la balise de script que vous avez copiée. Cette inclusion rend le puzzle CAPTCHA disponible pour la configuration et l'utilisation. 

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

      Cette `<script>` liste est configurée avec l'`defer`attribut, mais vous pouvez modifier le paramètre `async` si vous souhaitez un comportement différent pour votre page. 

      Le script CAPTCHA charge également automatiquement le script d'intégration intelligente des menaces s'il n'est pas déjà présent. Le script intelligent d'intégration des menaces permet à votre application cliente de récupérer automatiquement un jeton en arrière-plan lors du chargement de la page et fournit d'autres fonctionnalités de gestion des jetons dont vous avez besoin pour utiliser l'API CAPTCHA. 

1. **(Facultatif) Ajoutez une configuration de domaine pour les jetons du client** : par défaut, AWS WAF lors de la création d'un jeton, celui-ci utilise le domaine hôte de la ressource associée au pack de protection (ACL Web). Pour fournir des domaines supplémentaires pour le JavaScript APIs, suivez les instructions sur[Fournir des domaines à utiliser dans les jetons](waf-js-challenge-api-set-token-domain.md). 

1. **Obtenir la clé d'API cryptée pour le client** — L'API CAPTCHA nécessite une clé d'API cryptée contenant une liste de domaines clients valides. AWS WAF utilise cette clé pour vérifier que le domaine client que vous utilisez avec l'intégration est approuvé pour utiliser le AWS WAF CAPTCHA. Pour générer votre clé d'API, suivez les instructions sur[Gestion des clés d'API pour l'API JS CAPTCHA](waf-js-captcha-api-key.md).

1. **Codez l'implémentation de votre widget CAPTCHA** : implémentez l'appel d'`renderCaptcha()`API sur votre page, à l'endroit où vous souhaitez l'utiliser. Pour plus d'informations sur la configuration et l'utilisation de cette fonction, consultez les sections suivantes, [Spécification de l'API CAPTCHA JavaScript](waf-js-captcha-api-specification.md) et[Comment afficher le casse-tête CAPTCHA](waf-js-captcha-api-render.md). 

   L'implémentation du CAPTCHA s'intègre à l'intégration intelligente des menaces APIs pour la gestion des jetons et pour exécuter des appels de récupération utilisant les jetons. AWS WAF Pour obtenir des conseils sur leur utilisation APIs, voir[Utilisation de l' JavaScript API de gestion intelligente des menaces](waf-js-challenge-api.md).

1. **Ajoutez la vérification par jeton dans votre pack de protection (ACL Web)** : ajoutez au moins une règle à votre pack de protection (ACL Web) qui vérifie la validité d'un jeton CAPTCHA dans les requêtes Web envoyées par votre client. Vous pouvez utiliser l'action de la CAPTCHA règle pour vérifier, comme décrit dans[CAPTCHAet Challenge dans AWS WAF](waf-captcha-and-challenge.md). 

   Les ajouts au pack de protection (ACL Web) vérifient que les demandes envoyées à vos points de terminaison protégés incluent le jeton que vous avez acquis lors de l'intégration de votre client. Les demandes qui incluent un jeton CAPTCHA valide et non expiré passent l'inspection des CAPTCHA règles et ne présentent aucun autre casse-tête CAPTCHA à votre utilisateur final. 

Après avoir implémenté l' JavaScript API, vous pouvez consulter les CloudWatch statistiques relatives aux tentatives et aux solutions de casse-tête CAPTCHA. Pour les statistiques et les détails relatifs aux dimensions, voir[Mesures et dimensions du compte](waf-metrics.md#waf-metrics-account).

**Topics**
+ [Spécification de l'API CAPTCHA JavaScript](waf-js-captcha-api-specification.md)
+ [Comment afficher le casse-tête CAPTCHA](waf-js-captcha-api-render.md)
+ [Gestion d'une réponse CAPTCHA depuis AWS WAF](waf-js-captcha-api-conditional.md)
+ [Gestion des clés d'API pour l'API JS CAPTCHA](waf-js-captcha-api-key.md)

# Spécification de l'API CAPTCHA JavaScript
<a name="waf-js-captcha-api-specification"></a>

Cette section répertorie les spécifications des méthodes et des propriétés du CAPTCHA JavaScript APIs. Utilisez le CAPTCHA JavaScript APIs pour exécuter des puzzles CAPTCHA personnalisés dans vos applications clientes. 

Cette API s'appuie sur la menace intelligente APIs, que vous utilisez pour configurer et gérer l'acquisition et l'utilisation de AWS WAF jetons. Voir[Spécification de l'API de menace intelligente](waf-js-challenge-api-specification.md).

**`AwsWafCaptcha.renderCaptcha(container, configuration)`**  
Présente un casse-tête AWS WAF CAPTCHA à l'utilisateur final et, en cas de succès, met à jour le jeton client avec la validation CAPTCHA. Ceci n'est disponible qu'avec l'intégration CAPTCHA. Utilisez cet appel ainsi que la menace intelligente APIs pour gérer la récupération des jetons et pour fournir le jeton dans vos `fetch` appels. Découvrez la menace intelligente APIs sur[Spécification de l'API de menace intelligente](waf-js-challenge-api-specification.md).  
Contrairement à l'interstitiel CAPTCHA qui AWS WAF envoie, le puzzle CAPTCHA rendu par cette méthode affiche le puzzle immédiatement, sans écran de titre initial.     
**`container`**  
L'`Element`objet de l'élément conteneur cible sur la page. Ceci est généralement récupéré en appelant `document.getElementById()` ou`document.querySelector()`.  
Obligatoire : oui  
Type : `Element`  
**configuration**  
Un objet contenant les paramètres de configuration CAPTCHA, comme suit : ****    
**`apiKey`**   
La clé API cryptée qui autorise les autorisations pour le domaine du client. Utilisez la AWS WAF console pour générer vos clés d'API pour les domaines de vos clients. Vous pouvez utiliser une clé pour un maximum de cinq domaines. Pour plus d'informations, consultez [Gestion des clés d'API pour l'API JS CAPTCHA](waf-js-captcha-api-key.md).   
Obligatoire : oui  
Type : `string`  
**`onSuccess: (wafToken: string) => void;`**   
Appelé avec un AWS WAF jeton valide lorsque l'utilisateur final termine avec succès un casse-tête CAPTCHA. Utilisez le jeton dans les demandes que vous envoyez aux points de terminaison que vous protégez à l'aide d'un pack de AWS WAF protection (ACL Web). Le jeton fournit la preuve et l'horodatage de la dernière réalisation réussie du puzzle.   
Obligatoire : oui  
**`onError?: (error: CaptchaError) => void;`**   
Appelé avec un objet d'erreur lorsqu'une erreur survient lors de l'opération CAPTCHA.   
Obligatoire : non  
**`CaptchaError`définition de classe** — Le `onError` gestionnaire fournit un type d'erreur avec la définition de classe suivante.   

```
CaptchaError extends Error {
    kind: "internal_error" | "network_error" | "token_error" | "client_error";
    statusCode?: number;
}
```
+ `kind`— Le type d'erreur renvoyé. 
+ `statusCode`— Le code d'état HTTP, s'il est disponible. Ceci est utilisé `network_error` si l'erreur est due à une erreur HTTP.  
**`onLoad?: () => void;`**   
Appelé lors du chargement d'un nouveau casse-tête CAPTCHA.  
Obligatoire : non  
**`onPuzzleTimeout?: () => void;`**   
Appelé lorsqu'un casse-tête CAPTCHA n'est pas terminé avant son expiration.  
Obligatoire : non  
**`onPuzzleCorrect?: () => void;`**   
Appelé lorsqu'une réponse correcte est fournie à un casse-tête CAPTCHA.  
Obligatoire : non  
**`onPuzzleIncorrect?: () => void;`**   
Appelé lorsqu'une réponse incorrecte est fournie à un casse-tête CAPTCHA.  
Obligatoire : non  
**`defaultLocale`**   
La localisation par défaut à utiliser pour le puzzle CAPTCHA. Les instructions écrites pour les puzzles CAPTCHA sont disponibles en arabe (ar-SA), chinois simplifié (zh-CN), néerlandais (nl-NL), anglais (en-US), français (fr-FR), allemand (de-DE), italien (it-IT), japonais (ja-JP), portugais brésilien (pT-BR), espagnol (es-ES) et turc (tr-TR). Les instructions audio sont disponibles pour toutes les langues écrites, à l'exception du chinois et du japonais, qui sont par défaut l'anglais. Pour modifier la langue par défaut, fournissez la langue internationale et le code local, par exemple,`ar-SA`.  
Par défaut : langue actuellement utilisée dans le navigateur de l'utilisateur final  
Obligatoire : non  
Type : `string`  
**`disableLanguageSelector`**   
S'il est défini sur`true`, le casse-tête CAPTCHA masque le sélecteur de langue.   
Par défaut: `false`  
Obligatoire : non  
Type : `boolean`  
**`dynamicWidth`**   
S'il est défini sur`true`, le puzzle CAPTCHA change de largeur pour être compatible avec la largeur de la fenêtre du navigateur.   
Par défaut: `false`  
Obligatoire : non  
Type : `boolean`  
**`skipTitle`**   
S'il est défini sur`true`, le casse-tête CAPTCHA n'affiche pas le titre du puzzle intitulé **Résoudre le** puzzle.   
Par défaut: `false`  
Obligatoire : non  
Type : `boolean`

# Comment afficher le casse-tête CAPTCHA
<a name="waf-js-captcha-api-render"></a>

Cette section fournit un exemple de `renderCaptcha` mise en œuvre.

Vous pouvez utiliser l' AWS WAF `renderCaptcha`appel où vous le souhaitez dans votre interface client. L'appel permet de récupérer un casse-tête CAPTCHA AWS WAF, de le restituer et d'envoyer les résultats à des fins de vérification. AWS WAF Lorsque vous passez l'appel, vous indiquez la configuration du rendu du puzzle et les rappels que vous souhaitez exécuter lorsque vos utilisateurs finaux auront terminé le puzzle. Pour plus de détails sur les options, reportez-vous à la section précédente,[Spécification de l'API CAPTCHA JavaScript](waf-js-captcha-api-specification.md).

Utilisez cet appel conjointement avec la fonctionnalité de gestion des jetons de l'intégration intelligente des menaces APIs. Cet appel fournit à votre client un jeton qui vérifie la réussite du casse-tête CAPTCHA. Utilisez l'intégration intelligente des menaces APIs pour gérer le jeton et pour fournir le jeton dans les appels de votre client aux points de terminaison protégés par des packs de AWS WAF protection (Web ACLs). Pour plus d'informations sur la menace intelligente APIs, consultez[Utilisation de l' JavaScript API de gestion intelligente des menaces](waf-js-challenge-api.md).

**Exemples d’implémentation**  
La liste d'exemples suivante montre une implémentation CAPTCHA standard, y compris le placement de l'URL d' AWS WAF intégration dans la `<head>` section. 

Cette liste configure la `renderCaptcha` fonction avec un rappel de réussite qui utilise le `AwsWafIntegration.fetch` wrapper de l'intégration intelligente des menaces. APIs Pour plus d'informations sur cette fonction, consultez[Comment utiliser le `fetch` wrapper d'intégration](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>
```

**Exemples de paramètres de configuration**  
L'exemple de liste suivant montre les `renderCaptcha` paramètres autres que ceux par défaut pour les options de largeur et de titre. 

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

Pour obtenir des informations complètes sur les options de configuration, consultez[Spécification de l'API CAPTCHA JavaScript](waf-js-captcha-api-specification.md).

# Gestion d'une réponse CAPTCHA depuis AWS WAF
<a name="waf-js-captcha-api-conditional"></a>

Cette section fournit un exemple de gestion d'une réponse CAPTCHA.

Une AWS WAF règle comportant une CAPTCHA action met fin à l'évaluation d'une requête Web correspondante si celle-ci ne contient pas de jeton avec un horodatage CAPTCHA valide. Si la demande est un `GET` text/html appel, l'CAPTCHAaction fournit alors au client un interstitiel avec un casse-tête CAPTCHA. Lorsque vous n'intégrez pas l' JavaScript API CAPTCHA, l'interstitiel exécute le puzzle et, si l'utilisateur final le résout avec succès, soumet automatiquement à nouveau la demande. 

Lorsque vous intégrez l' JavaScript API CAPTCHA et que vous personnalisez votre gestion des CAPTCHA, vous devez détecter la réponse CAPTCHA finale, fournir votre CAPTCHA personnalisé, puis si l'utilisateur final résout le casse-tête avec succès, soumettre à nouveau la demande Web du client. 

L'exemple de code suivant montre comment procéder : 

**Note**  
La réponse à l' AWS WAF CAPTCHAaction possède un code d'état HTTP 405, que nous utilisons pour reconnaître la CAPTCHA réponse dans ce code. Si votre point de terminaison protégé utilise un code d'état HTTP 405 pour communiquer tout autre type de réponse pour le même appel, cet exemple de code affichera également un casse-tête CAPTCHA pour ces réponses. 

```
<!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>
```

# Gestion des clés d'API pour l'API JS CAPTCHA
<a name="waf-js-captcha-api-key"></a>

Cette section fournit des instructions pour générer et supprimer des clés d'API.

Pour intégrer le AWS WAF CAPTCHA dans une application cliente avec l' JavaScript API, vous avez besoin de la balise d'intégration d' JavaScript API et de la clé d'API cryptée pour le domaine client dans lequel vous souhaitez exécuter votre puzzle CAPTCHA. 

L'intégration de l'application CAPTCHA JavaScript utilise les clés d'API cryptées pour vérifier que le domaine de l'application client est autorisé à utiliser l'API AWS WAF CAPTCHA. Lorsque vous appelez l'API CAPTCHA depuis votre JavaScript client, vous fournissez une clé d'API avec une liste de domaines qui inclut un domaine pour le client actuel. Vous pouvez répertorier jusqu'à 5 domaines dans une seule clé cryptée. 

**Exigences clés de l'API**  
La clé d'API que vous utilisez dans votre intégration CAPTCHA doit contenir un domaine qui s'applique au client sur lequel vous utilisez la clé. 
+ Si vous spécifiez un `window.awsWafCookieDomainList` dans l'intégration intelligente des menaces de votre client, au moins un domaine de votre clé d'API doit correspondre exactement à l'un des domaines de jetons `window.awsWafCookieDomainList` ou doit être le domaine apex de l'un de ces domaines de jetons. 

  Par exemple, pour le domaine de jeton`mySubdomain.myApex.com`, la clé `mySubdomain.myApex.com` d'API correspond exactement et la clé d'API `myApex.com` est le domaine apex. L'une ou l'autre des clés correspond au domaine du jeton. 

  Pour plus d'informations sur le paramétrage de la liste des domaines de jetons, consultez[Fournir des domaines à utiliser dans les jetons](waf-js-challenge-api-set-token-domain.md).
+ Dans le cas contraire, le domaine actuel doit être contenu dans la clé d'API. Le domaine actuel est celui que vous pouvez voir dans la barre d'adresse du navigateur. 

Les domaines que vous utilisez doivent être ceux qui AWS WAF seront acceptés, en fonction du domaine hôte protégé et de la liste de domaines de jetons configurée pour l'ACL Web. Pour de plus amples informations, veuillez consulter [AWS WAF configuration de la liste de domaines de jetons du pack de protection (ACL Web)](waf-tokens-domains.md#waf-tokens-domain-lists).

**Comment choisir la région pour votre clé d'API**  
AWS WAF peut générer des clés d'API CAPTCHA dans toutes les régions où elles AWS WAF sont disponibles. 

En règle générale, vous devez utiliser la même région pour votre clé d'API CAPTCHA que celle que vous utilisez pour votre pack de protection (ACL Web). Toutefois, si vous vous attendez à ce qu'un pack de protection régional (ACL Web) attire un public mondial, vous pouvez obtenir une balise d' JavaScript intégration CAPTCHA limitée CloudFront et une clé d'API limitée CloudFront, et les utiliser avec un pack de protection régional (ACL Web). Cette approche permet aux clients de charger un casse-tête CAPTCHA depuis la région la plus proche d'eux, ce qui réduit le temps de latence. 

Les clés d'API CAPTCHA qui sont limitées à des régions autres que ne CloudFront sont pas prises en charge pour une utilisation dans plusieurs régions. Ils ne peuvent être utilisés que dans la région à laquelle ils sont destinés. 

**Pour générer une clé d'API pour les domaines de vos clients**  
Pour obtenir l'URL d'intégration et générer et récupérer les clés d'API via la console. 

1. Connectez-vous à la AWS WAF console AWS Management Console et ouvrez-la sur [https://console.aws.amazon.com/wafv2/homev2](https://console.aws.amazon.com/wafv2/homev2). 

1. Dans le panneau de navigation, choisissez **Intégration d'applications**. 

1. Dans le volet des **packs de protection (Web ACLs) activés pour l'intégration des applications**, sélectionnez la région que vous souhaitez utiliser pour votre clé d'API. Vous pouvez également sélectionner la région dans le volet des **clés d'API** de l'onglet d'**intégration CAPTCHA**.

1. Choisissez l'onglet Intégration **CAPTCHA**. Cet onglet fournit la balise d' JavaScript intégration CAPTCHA, que vous pouvez utiliser dans votre intégration, ainsi que la liste des clés d'API. Les deux sont limités à la région sélectionnée.

1. Dans le volet **des clés d'API**, choisissez **Generate key**. Le dialogue de génération de clés apparaît. 

1. Entrez les domaines clients que vous souhaitez inclure dans la clé. Vous pouvez saisir jusqu'à 5. Lorsque vous avez terminé, choisissez **Generate key**. L'interface revient à l'onglet d'intégration CAPTCHA, où votre nouvelle clé est répertoriée. 

   Une fois créée, une clé d'API est immuable. Si vous devez apporter des modifications à une clé, générez une nouvelle clé et utilisez-la à la place. 

1. (Facultatif) Copiez la clé nouvellement générée pour l'utiliser dans votre intégration. 

Vous pouvez également utiliser le REST APIs ou l'un des langages spécifiques AWS SDKs pour ce travail. Les appels d'API REST sont [Create APIKey](https://docs.aws.amazon.com/waf/latest/APIReference/API_CreateAPIKey.html) et [List APIKeys](https://docs.aws.amazon.com/waf/latest/APIReference/API_ListAPIKeys.html). 

**Pour supprimer une clé d’API**  
Pour supprimer une clé d'API, vous devez utiliser l'API REST ou l'une des langues spécifiques AWS SDKs. L'appel de l'API REST est [Delete APIKey](https://docs.aws.amazon.com/waf/latest/APIReference/API_DeleteAPIKey.html). Vous ne pouvez pas utiliser la console pour supprimer une clé. 

Une fois que vous avez supprimé une clé, cela peut prendre jusqu' AWS WAF à 24 heures pour interdire son utilisation dans toutes les régions. 