

**Presentamos una nueva experiencia de consola para AWS WAF**

Ahora puede usar la experiencia actualizada para acceder a las AWS WAF funciones desde cualquier parte de la consola. Para obtener más información, consulte [Trabajar con la consola](https://docs.aws.amazon.com/waf/latest/developerguide/working-with-console.html). 

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

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

En esta sección se explica cómo utilizar las AWS WAF JavaScript integraciones.

Puede usar la JavaScript integración APIs para implementar integraciones de AWS WAF aplicaciones en sus navegadores y otros dispositivos que se ejecuten. JavaScript 

Los rompecabezas de CAPTCHA y los desafíos silenciosos solo se pueden ejecutar cuando los navegadores acceden a los puntos de conexión HTTPS. Los clientes del navegador deben ejecutarse en contextos seguros para poder adquirir los tókenes. 
+ La amenaza inteligente le APIs permite gestionar la autorización de los tokens mediante un desafío silencioso desde el lado del navegador desde el lado del cliente e incluir los tokens en las solicitudes que envía a sus recursos protegidos. 
+ La API de integración de CAPTCHA se suma a la amenaza APIs inteligente y le permite personalizar la ubicación y las características del rompecabezas del CAPTCHA en las aplicaciones de sus clientes. Esta API aprovecha la amenaza inteligente APIs para adquirir AWS WAF fichas para utilizarlas en la página una vez que el usuario final haya completado correctamente el rompecabezas del CAPTCHA. 

Al utilizar estas integraciones, se asegura de que las llamadas a procedimientos remotos de su cliente contengan un token válido. Cuando estas integraciones APIs estén implementadas en las páginas de su aplicación, podrá implementar reglas atenuantes en su paquete de protección (ACL web), como bloquear las solicitudes que no contengan un token válido. También puede implementar reglas que impongan el uso de los tokens que obtienen las aplicaciones cliente utilizando las acciones Challenge o CAPTCHA en sus reglas. 

**Ejemplo de implementación de una amenaza inteligente APIs**  
La siguiente lista muestra los componentes básicos de una implementación típica de la amenaza inteligente APIs en una página de aplicaciones 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>
```

**Ejemplo de implementación de la API CAPTCHA JavaScript**  
La API de integración de CAPTCHA le permite personalizar la experiencia de los usuarios finales con los rompecabezas de CAPTCHA. La integración con CAPTCHA aprovecha la integración JavaScript inteligente de amenazas para la verificación del navegador y la gestión de los tokens, y añade una función para configurar y renderizar el rompecabezas del CAPTCHA. 

La siguiente lista muestra los componentes básicos de una implementación típica de la API CAPTCHA JavaScript en una página de aplicación 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**
+ [Suministro de dominios para su uso en los tokens](waf-js-challenge-api-set-token-domain.md)
+ [Uso de la JavaScript API con políticas de seguridad de contenido](waf-javascript-api-csp.md)
+ [Uso de la JavaScript API de amenazas inteligentes](waf-js-challenge-api.md)
+ [Uso de la API CAPTCHA JavaScript](waf-js-captcha-api.md)

# Suministro de dominios para su uso en los tokens
<a name="waf-js-challenge-api-set-token-domain"></a>

En esta sección se explica cómo proporcionar dominios adicionales para los tókenes.

De forma predeterminada, cuando AWS WAF crea un token, utiliza el dominio host del recurso asociado al paquete de protección (ACL web). Puede proporcionar dominios adicionales para los tokens que AWS WAF crea para el JavaScript APIs. Para ello, configure la `window.awsWafCookieDomainList` variable global con uno o más dominios de token. 

Al AWS WAF crear un token, utiliza el dominio más adecuado y más corto de entre la combinación de los dominios del recurso `window.awsWafCookieDomainList` y el dominio host del recurso asociado al paquete de protección (ACL web). 

Ejemplo de configuración: 

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

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

No puede usar sufijos públicos en esta lista. Por ejemplo, no puede usar `gov.au` o `co.uk` como dominios de token en la lista.

Los dominios que especifique en esta lista deben ser compatibles con los demás dominios y configuraciones de dominio: 
+ Los dominios deben ser los que AWS WAF acepten, según el dominio host protegido y la lista de dominios token configurada para el paquete de protección (ACL web). Para obtener más información, consulte [AWS WAF configuración de la lista de dominios simbólicos del paquete de protección (ACL web)](waf-tokens-domains.md#waf-tokens-domain-lists). 
+ Si utilizas la API de JavaScript CAPTCHA, al menos un dominio de tu clave de API de CAPTCHA debe coincidir exactamente con uno de los dominios de token `window.awsWafCookieDomainList` o debe ser el dominio principal de uno de esos dominios de token. 

  Por ejemplo, para el dominio de token `mySubdomain.myApex.com`, la clave de API `mySubdomain.myApex.com` coincide exactamente y la clave de API `myApex.com` es el dominio de ápex. Cualquiera de las claves coincide con el dominio de token. 

  Para obtener más información sobre las claves de API, consulte [Administración de las claves de API para la API de JS CAPTCHA](waf-js-captcha-api-key.md). 

Si usa el grupo de reglas administradas de `AWSManagedRulesACFPRuleSet`, puede configurar un dominio que coincida con el de la ruta de creación de cuentas que proporcionó a la configuración del grupo de reglas. Para obtener más información acerca de esta configuración, consulte [Adición del grupo de reglas administradas por ACFP a la nueva ACL web](waf-acfp-rg-using.md).

Si usa el grupo de reglas administradas de `AWSManagedRulesATPRuleSet`, debería un dominio que coincida con el de la ruta de regustri que proporcionó en la configuración del grupo de reglas. Para obtener más información acerca de esta configuración, consulte [Adición del grupo de reglas administradas por ATP al paquete de protección (ACL web)](waf-atp-rg-using.md).

# Uso de la JavaScript API con políticas de seguridad de contenido
<a name="waf-javascript-api-csp"></a>

En esta sección se proporciona un ejemplo de configuración para incluir en la lista de permisos el dominio de AWS WAF Apex.

Si aplica políticas de seguridad de contenido (CSP) a sus recursos, para que la JavaScript implementación funcione, debe incluir en la lista de permisos el dominio apex. AWS WAF `awswaf.com` JavaScript SDKs Hacen llamadas a distintos AWS WAF puntos de conexión, por lo que permitir incluir este dominio en la lista proporciona los permisos necesarios para funcionar. SDKs 

A continuación se muestra un ejemplo de configuración para incluir en la lista de permisos el AWS WAF dominio de Apex: 

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

Si intentas usarlo JavaScript SDKs con recursos que usan CSP y no has incluido el AWS WAF dominio en la lista de permitidos, recibirás errores como los siguientes: 

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

# Uso de la JavaScript API de amenazas inteligentes
<a name="waf-js-challenge-api"></a>

En esta sección se proporcionan instrucciones para usar la JavaScript API de amenazas inteligentes en su aplicación cliente.

La amenaza inteligente APIs proporciona operaciones para ejecutar desafíos silenciosos contra el navegador del usuario y gestionar los AWS WAF símbolos que demuestran que el desafío ha respondido satisfactoriamente y mediante CAPTCHA. 

Implemente la JavaScript integración primero en un entorno de prueba y, después, en producción. Para obtener más información sobre la guía de codificación, consulta las secciones siguientes. 

 

**Para utilizar la amenaza inteligente APIs**

1. **Instale el APIs** 

   Si utiliza la API de CAPTCHA, puede omitir este paso. Al instalar la API CAPTCHA, el script instala automáticamente la amenaza inteligente. APIs

   1. [Inicie sesión Consola de administración de AWS y abra la AWS WAF consola en homev2. https://console.aws.amazon.com/wafv2/](https://console.aws.amazon.com/wafv2/homev2) 

   1. En el panel de navegación, elija **Integración de la aplicación**. En la página **Integración de aplicaciones**, puede ver las opciones agrupadas en pestañas. 

   1. Seleccione **Integración de amenazas inteligentes**

   1. En la pestaña, seleccione el paquete de protección (ACL web) con el que desea realizar la integración. La lista de paquetes de protección (ACL web) incluye solo los paquetes de protección (web ACLs) que utilizan el grupo de reglas `AWSManagedRulesACFPRuleSet` `AWSManagedRulesATPRuleSet` administrado, el grupo de reglas administrado o el nivel de protección objetivo del grupo de reglas `AWSManagedRulesBotControlRuleSet` administrado. 

   1. Abra el panel **JavaScript SDK** y copie la etiqueta del script para usarla en la integración. 

   1. En el código de la página de la aplicación, en la sección `<head>`, inserte la etiqueta de script que copió para el paquete de protección (ACL web). Esta inclusión hace que la aplicación cliente recupere automáticamente un token en segundo plano al cargar la página. 

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

      Esta lista de `<script>` está configurada con el atributo `defer`, pero puede cambiarlo por otro `async` si desea un comportamiento diferente para su página. 

1. **(Opcional) Agrega una configuración de dominio para los tokens del cliente**: de forma predeterminada, cuando AWS WAF crea un token, utiliza el dominio host del recurso asociado al paquete de protección (ACL web). Para proporcionar dominios adicionales para el JavaScript APIs, sigue las instrucciones que aparecen en[Suministro de dominios para su uso en los tokens](waf-js-challenge-api-set-token-domain.md). 

1. **Codifique su integración de amenazas inteligentes**: escriba el código para asegurarse de que la recuperación del token se complete antes de que el cliente envíe sus solicitudes a los puntos de conexión protegidos. Si ya utiliza la API `fetch` para realizar la llamada, puede sustituirla por el contenedor `fetch` de integración de AWS WAF . Si no usas la `fetch` API, puedes usar la `getToken` operación de AWS WAF integración en su lugar. Para obtener orientación sobre el código, consulte las siguientes secciones: 

1. **Agregue la verificación mediante token a su paquete de protección (ACL web)**: agregue al menos una regla a su paquete de protección (ACL web) que compruebe si hay un token de desafío válido en las solicitudes web que envíe su cliente. Puede utilizar grupos de reglas que comprueben y supervisen los tokens de desafío, como el nivel objetivo del grupo de reglas administradas de control de bots, y puede utilizar la acción de regla Challenge para comprobarlos, tal y como se describe en [CAPTCHAy Challenge en AWS WAF](waf-captcha-and-challenge.md). 

   Las incorporaciones de paquetes de protección (ACL web) comprueban que las solicitudes a sus puntos de conexión protegidos incluyan el token que adquirió en la integración del cliente. Las solicitudes que incluyan un token válido y vigente pasan la inspección de Challenge y no envían otro desafío silencioso a su cliente. 

1. **(Opcional) Bloquee las solicitudes a las que les falten tokens**: si las usa APIs con el grupo de reglas administrado por la ACFP, el grupo de reglas administrado por la ATP o las reglas específicas del grupo de reglas del control de bots, estas reglas no bloquean las solicitudes a las que les faltan tokens. Para bloquear las solicitudes a las que les faltan tokens, siga las instrucciones que se indican en [Bloquear solicitudes que no tienen un AWS WAF token válido](waf-tokens-block-missing-tokens.md). 

**Topics**
+ [Especificación de la API de amenazas inteligentes](waf-js-challenge-api-specification.md)
+ [Cómo utilizar el contenedor `fetch` de integración](waf-js-challenge-api-fetch-wrapper.md)
+ [Cómo utilizar la integración de `getToken`](waf-js-challenge-api-get-token.md)

# Especificación de la API de amenazas inteligentes
<a name="waf-js-challenge-api-specification"></a>

En esta sección se enumeran las especificaciones de los métodos y propiedades de la mitigación inteligente de amenazas JavaScript APIs. Úselos APIs para integraciones inteligentes de amenazas y CAPTCHA.

**`AwsWafIntegration.fetch()`**  
Envía la `fetch` solicitud HTTP al servidor mediante la implementación de integración. AWS WAF 

**`AwsWafIntegration.getToken()`**  
Recupera el AWS WAF token almacenado y lo almacena en una cookie en la página actual con su nombre `aws-waf-token` y el valor establecido en el valor del token. 

**`AwsWafIntegration.hasToken()`**  
Devuelve un booleano que indica si la cookie `aws-waf-token` contiene actualmente un token vigente. 

Si también utiliza la integración de CAPTCHA, consulte las especificaciones correspondientes en [Especificación de la API CAPTCHA JavaScript](waf-js-captcha-api-specification.md).

# Cómo utilizar el contenedor `fetch` de integración
<a name="waf-js-challenge-api-fetch-wrapper"></a>

En esta sección se incluyen las instrucciones para utilizar el contenedor `fetch` de integración.

Puedes usar el AWS WAF `fetch` contenedor cambiando tus `fetch` llamadas normales a la `fetch` API en el espacio de `AwsWafIntegration` nombres. El AWS WAF contenedor admite todas las mismas opciones que la llamada a la JavaScript `fetch` API estándar y añade la gestión de los tokens para la integración. Por lo general, este enfoque es la forma más sencilla de integrar su aplicación. 

**Antes de la implementación del contenedor**  
La siguiente lista de ejemplos muestra el código estándar antes de implementar el contenedor `AwsWafIntegration` `fetch`.

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

**Después de la implementación del contenedor**  
La siguiente lista muestra el mismo código con la implementación del contenedor `AwsWafIntegration` `fetch`.

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

# Cómo utilizar la integración de `getToken`
<a name="waf-js-challenge-api-get-token"></a>

En esta sección, se explica cómo usar la operación `getToken`.

AWS WAF requiere que sus solicitudes a los puntos finales protegidos incluyan la cookie nombrada `aws-waf-token` con el valor de su token actual. 

La operación de `getToken` es una llamada a la API asíncrona que recupera el token de AWS WAF y lo almacena en una cookie en la página actual con el nombre `aws-waf-token`, y el valor establecido al valor del token. Puede usar esta cookie de token en su página según sea necesario. 

Cuando se llama a `getToken`, hace lo siguiente: 
+ Si un token vigente ya está disponible, la llamada lo devuelve inmediatamente.
+ De lo contrario, la llamada recupera un nuevo token del proveedor de tokens y espera hasta 2 segundos a que se complete el flujo de trabajo de adquisición del token antes de que se agote el tiempo de espera. Si se agota el tiempo de espera de la operación, se generará un error que deberá gestionar su código de llamada. 

La operación `getToken` viene acompañada de una operación `hasToken` que indica si la cookie `aws-waf-token` contiene actualmente un token que no ha caducado. 

`AwsWafIntegration.getToken()` recupera un token válido y lo almacena como una cookie. La mayoría de las llamadas de los clientes adjuntan automáticamente esta cookie, pero algunas no. Por ejemplo, las llamadas realizadas entre dominios host no adjuntan la cookie. En los detalles de implementación que aparecen a continuación, mostramos cómo trabajar con ambos tipos de llamadas de clientes. 

**Implementación `getToken` básica para llamadas que adjuntan la cookie `aws-waf-token`**  
La siguiente lista de ejemplos muestra el código estándar para implementar la operación `getToken` con una solicitud de inicio de sesión.

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

**Envío del formulario solo después de que el token esté disponible en `getToken`**  
La siguiente lista muestra cómo registrar un oyente de eventos para interceptar los envíos de formularios hasta que haya un token válido disponible para su uso. 

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

**Cómo adjuntar el token cuando el cliente no adjunta la cookie `aws-waf-token` de forma predeterminada**  
`AwsWafIntegration.getToken()` recupera un token válido y lo almacena como una cookie, pero no todas las llamadas de los clientes adjuntan esta cookie de forma predeterminada. Por ejemplo, las llamadas realizadas entre dominios host no adjuntan la cookie. 

El `fetch` contenedor maneja estos casos automáticamente, pero si no puedes usar el `fetch` contenedor, puedes hacerlo usando un encabezado personalizado. `x-aws-waf-token` AWS WAF lee los símbolos de este encabezado, además de leerlos de la `aws-waf-token` cookie. En el siguiente código, se muestra un ejemplo de cómo configurar el encabezado. 

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

De forma predeterminada, AWS WAF solo acepta los tokens que contienen el mismo dominio que el dominio anfitrión solicitado. Cualquier token que abarque varios dominios requiere las entradas correspondientes en la lista de dominios del token de paquete de protección (ACL web). Para obtener más información, consulte [AWS WAF configuración de la lista de dominios simbólicos del paquete de protección (ACL web)](waf-tokens-domains.md#waf-tokens-domain-lists). 

Para obtener información adicional sobre el uso de los tokens entre dominios, consulte [aws-waf-bot-controlaws-samples/](https://github.com/aws-samples/aws-waf-bot-control-api-protection-with-captcha) -. api-protection-with-captcha

# Uso de la API CAPTCHA JavaScript
<a name="waf-js-captcha-api"></a>

En esta sección se incluyen instrucciones para utilizar la API de integración de CAPTCHA.

La JavaScript API de CAPTCHA le permite configurar el rompecabezas de CAPTCHA y colocarlo donde desee en su aplicación cliente. Esta API aprovecha las características de la amenaza inteligente JavaScript APIs para adquirir y utilizar los AWS WAF tokens una vez que el usuario final haya completado satisfactoriamente un rompecabezas de CAPTCHA. 

Implemente la JavaScript integración primero en un entorno de prueba y, después, en producción. Para obtener más información sobre la guía de codificación, consulta las secciones siguientes. 

**Uso de la API de integración de CAPTCHA**

1. **Instalación de la API**

   1. Inicie sesión Consola de administración de AWS y abra la AWS WAF consola en [https://console.aws.amazon.com/wafv2/homev2](https://console.aws.amazon.com/wafv2/homev2). 

   1. En el panel de navegación, elija **Integración de la aplicación**. En la página **Integración de aplicaciones**, puede ver las opciones agrupadas en pestañas. 

   1. Seleccione la **Integración de CAPTCHA**.

   1. Copia la etiqueta del script de JavaScript integración que aparece en la lista para utilizarla en tu integración.

   1. En el código de la página de la aplicación, en la sección `<head>`, inserte la etiqueta de script que copió. Esta inclusión hace que el rompecabezas de CAPTCHA esté disponible para su configuración y uso. 

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

      Esta lista de `<script>` está configurada con el atributo `defer`, pero puede cambiarlo por otro `async` si desea un comportamiento diferente para su página. 

      El script de CAPTCHA también carga automáticamente el script de integración de amenazas inteligentes si aún no está presente. El script de integración de amenazas inteligentes hace que la aplicación cliente recupere automáticamente un token en segundo plano al cargar la página y proporciona otras funciones de administración de tokens que necesita para usar la API de CAPTCHA. 

1. **(Opcional) Agregue una configuración de dominio para los tokens del cliente**: de forma predeterminada, cuando AWS WAF crea un token, utiliza el dominio host del recurso asociado al paquete de protección (ACL web). Para proporcionar dominios adicionales para el JavaScript APIs, sigue las instrucciones que aparecen en[Suministro de dominios para su uso en los tokens](waf-js-challenge-api-set-token-domain.md). 

1. **Obtenga la clave de API cifrada del cliente**: la API de CAPTCHA requiere una clave de API cifrada que contenga una lista de dominios de cliente válidos. AWS WAF usa esta clave para comprobar que el dominio de cliente que utilizas con la integración está aprobado para usar AWS WAF CAPTCHA. Para generar su clave de API, siga las instrucciones que se indican en [Administración de las claves de API para la API de JS CAPTCHA](waf-js-captcha-api-key.md).

1. **Codifique la implementación del widget de CAPTCHA**: implemente la llamada a la API `renderCaptcha()` en su página, en la ubicación en la que quiera usarla. Para obtener información acerca de cómo configurar y usar esta función, consulte las siguientes secciones, [Especificación de la API CAPTCHA JavaScript](waf-js-captcha-api-specification.md) y [Cómo renderizar el rompecabezas de CAPTCHA](waf-js-captcha-api-render.md). 

   La implementación del CAPTCHA se integra con la integración inteligente de amenazas APIs para gestionar los tokens y ejecutar llamadas de búsqueda que utilizan los tokens. AWS WAF Para obtener orientación sobre su uso, consulte. APIs [Uso de la JavaScript API de amenazas inteligentes](waf-js-challenge-api.md)

1. **Agregue la verificación mediante token a su paquete de protección (ACL web)**: agregue al menos una regla a su paquete de protección (ACL web) que compruebe si hay un token de CAPTCHA válido en las solicitudes web que envíe su cliente. Puede utilizar la acción de regla CAPTCHA para realizar la comprobación, tal y como se describe en [CAPTCHAy Challenge en AWS WAF](waf-captcha-and-challenge.md). 

   Las incorporaciones de los paquetes de protección (ACL web) comprueban que las solicitudes que van a sus puntos de conexión protegidos incluyen el token que adquirió en la integración con el cliente. Las solicitudes que incluyen un token de CAPTCHA válido y vigente pasan la inspección de acción de regla CAPTCHA y no presentan al usuario final otro rompecabezas de CAPTCHA. 

Una vez que hayas implementado la JavaScript API, puedes revisar las CloudWatch métricas de los intentos y las soluciones de los acertijos del CAPTCHA. Para obtener información acerca de las métricas y las dimensiones, consulte [Métricas y dimensiones de la cuenta](waf-metrics.md#waf-metrics-account).

**Topics**
+ [Especificación de la API CAPTCHA JavaScript](waf-js-captcha-api-specification.md)
+ [Cómo renderizar el rompecabezas de CAPTCHA](waf-js-captcha-api-render.md)
+ [Gestión de una respuesta CAPTCHA de AWS WAF](waf-js-captcha-api-conditional.md)
+ [Administración de las claves de API para la API de JS CAPTCHA](waf-js-captcha-api-key.md)

# Especificación de la API CAPTCHA JavaScript
<a name="waf-js-captcha-api-specification"></a>

En esta sección se enumeran las especificaciones de los métodos y propiedades del CAPTCHA. JavaScript APIs Utilice el CAPTCHA JavaScript APIs para ejecutar rompecabezas CAPTCHA personalizados en sus aplicaciones cliente. 

Esta API se basa en la amenaza inteligente APIs, que se utiliza para configurar y gestionar la adquisición y el uso de los AWS WAF tokens. Consulte [Especificación de la API de amenazas inteligentes](waf-js-challenge-api-specification.md).

**`AwsWafCaptcha.renderCaptcha(container, configuration)`**  
Presenta un rompecabezas de AWS WAF CAPTCHA al usuario final y, en caso de éxito, actualiza el token del cliente con la validación del CAPTCHA. Esto solo está disponible con la integración de CAPTCHA. Utilice esta llamada junto con la amenaza inteligente APIs para gestionar la recuperación del token e incluir el token en sus llamadas. `fetch` Vea la amenaza inteligente APIs en[Especificación de la API de amenazas inteligentes](waf-js-challenge-api-specification.md).  
A diferencia del CAPTCHA intersticial que se AWS WAF envía, el puzle CAPTCHA renderizado con este método muestra el puzle inmediatamente, sin pantalla de título inicial.     
**`container`**  
El objeto `Element` para el elemento contenedor objetivo de la página. Por lo general, se recupera llamando a `document.getElementById()` o `document.querySelector()`.  
Obligatorio: sí  
Tipo: `Element`  
**configuración**  
Un objeto que contiene los ajustes de configuración de CAPTCHA, de la siguiente manera****:    
**`apiKey`**   
La clave de API cifrada que habilita los permisos para el dominio del cliente. Utilice la consola AWS WAF para generar las claves de API para los dominios de los clientes. Puede utilizar una clave para hasta cinco dominios. Para obtener información, consulte [Administración de las claves de API para la API de JS CAPTCHA](waf-js-captcha-api-key.md).   
Obligatorio: sí  
Tipo: `string`  
**`onSuccess: (wafToken: string) => void;`**   
Se llama con un AWS WAF token válido cuando el usuario final completa correctamente un rompecabezas de CAPTCHA. Utilice el token en las solicitudes que envíe a los puntos finales que proteja con un paquete de AWS WAF protección (ACL web). El token proporciona la prueba y la marca de tiempo de la última vez que se ha completado con éxito el rompecabezas.   
Obligatorio: sí  
**`onError?: (error: CaptchaError) => void;`**   
Se llama con un objeto de error cuando se produce un error durante la operación de CAPTCHA.   
Obligatorio: no  
**Definición de clase `CaptchaError`**: el controlador `onError` proporciona un tipo de error con la siguiente definición de clase.   

```
CaptchaError extends Error {
    kind: "internal_error" | "network_error" | "token_error" | "client_error";
    statusCode?: number;
}
```
+ `kind`: el tipo de error devuelto. 
+ `statusCode`: el código de estado HTTP, si está disponible. Lo utiliza `network_error` si el error se debe a un error HTTP.  
**`onLoad?: () => void;`**   
Se llama cuando se carga un nuevo rompecabezas de CAPTCHA.  
Obligatorio: no  
**`onPuzzleTimeout?: () => void;`**   
Se llama cuando un rompecabezas de CAPTCHA no se completa antes de que caduque.  
Obligatorio: no  
**`onPuzzleCorrect?: () => void;`**   
Se llama cuando se proporciona una respuesta correcta a un rompecabezas de CAPTCHA.  
Obligatorio: no  
**`onPuzzleIncorrect?: () => void;`**   
Se llama cuando se proporciona una respuesta incorrecta a un rompecabezas de CAPTCHA.  
Obligatorio: no  
**`defaultLocale`**   
La configuración regional predeterminada que se utilizará en el rompecabezas de CAPTCHA. Las instrucciones escritas para los rompecabezas de CAPTCHA están disponibles en árabe (ar-SA), chino simplificado (zh-CN), holandés (nl-NL), inglés (en-US), francés (fr-FR), alemán (de-DE), italiano (it-IT), japonés (ja-JP), portugués brasileño (pt-BR), español (es-ES) y turco (tr-TR). Las instrucciones de audio están disponibles en todos los idiomas escritos, excepto en chino y japonés, que por defecto están en inglés. Para cambiar el idioma predeterminado, proporcione el idioma internacional y el código de configuración regional, por ejemplo, `ar-SA`.  
Predeterminado: el idioma que se utiliza actualmente en el navegador del usuario final  
Obligatorio: no  
Tipo: `string`  
**`disableLanguageSelector`**   
Si se establece en `true`, el rompecabezas de CAPTCHA oculta el selector de idioma.   
Valor predeterminado: `false`  
Obligatorio: no  
Tipo: `boolean`  
**`dynamicWidth`**   
Si se establece en `true`, el rompecabezas de CAPTCHA cambia de ancho para que sea compatible con el ancho de la ventana del navegador.   
Valor predeterminado: `false`  
Obligatorio: no  
Tipo: `boolean`  
**`skipTitle`**   
Si se establece en `true`, el rompecabezas de CAPTCHA no mostrará el título del rompecabezas **Resuelva el rompecabezas**.   
Valor predeterminado: `false`  
Obligatorio: no  
Tipo: `boolean`

# Cómo renderizar el rompecabezas de CAPTCHA
<a name="waf-js-captcha-api-render"></a>

En esta sección se incluye un ejemplo de la implementación de `renderCaptcha`.

Puede usar la AWS WAF `renderCaptcha` llamada donde desee en la interfaz de cliente. La llamada recupera un acertijo de CAPTCHA AWS WAF, lo renderiza y envía los resultados para su verificación. AWS WAF Al realizar la llamada, proporciona la configuración de renderización del rompecabezas y las devoluciones de llamadas que desea ejecutar cuando los usuarios finales completen el rompecabezas. Para obtener detalles sobre las opciones, consulte la sección anterior, [Especificación de la API CAPTCHA JavaScript](waf-js-captcha-api-specification.md).

Utilice esta llamada junto con la funcionalidad de administración de tokens de la integración inteligente de amenazas. APIs Esta llamada proporciona a su cliente un token que verifica que ha completado correctamente el rompecabezas de CAPTCHA. Utilice la integración inteligente contra amenazas APIs para gestionar el token y proporcionarlo en las llamadas de sus clientes a los puntos finales que están protegidos con paquetes de AWS WAF protección (web ACLs). Para obtener información sobre la amenaza inteligente APIs, consulte[Uso de la JavaScript API de amenazas inteligentes](waf-js-challenge-api.md).

**Despliegue de ejemplo**  
La siguiente lista de ejemplos muestra una implementación de CAPTCHA estándar, incluida la ubicación de la URL de AWS WAF integración en la `<head>` sección. 

Esta lista configura la `renderCaptcha` función con una llamada de respuesta correcta que utiliza el `AwsWafIntegration.fetch` contenedor de la integración de amenazas inteligentes. APIs Para obtener información acerca de esta función, consulte [Cómo utilizar el contenedor `fetch` de integración](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>
```

**Ejemplo de configuración**  
En la siguiente lista de ejemplos, se muestra la configuración no predeterminada de `renderCaptcha` para las opciones de ancho y título. 

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

Para obtener información completa acerca de las opciones de configuración, consulte [Especificación de la API CAPTCHA JavaScript](waf-js-captcha-api-specification.md).

# Gestión de una respuesta CAPTCHA de AWS WAF
<a name="waf-js-captcha-api-conditional"></a>

En esta sección se incluye un ejemplo de cómo administrar una respuesta de CAPTCHA.

Una AWS WAF regla con una CAPTCHA acción finaliza la evaluación de una solicitud web coincidente si la solicitud no tiene un token con una marca de tiempo de CAPTCHA válida. Si la solicitud es una `GET` text/html llamada, la CAPTCHA acción presenta al cliente un intersticial con un acertijo de CAPTCHA. Si no integras la JavaScript API de CAPTCHA, el intersticial resuelve el rompecabezas y, si el usuario final lo resuelve correctamente, vuelve a enviar la solicitud automáticamente. 

Al integrar la JavaScript API de CAPTCHA y personalizar el manejo del CAPTCHA, es necesario detectar la respuesta de CAPTCHA que termina, entregar el CAPTCHA personalizado y, a continuación, si el usuario final resuelve el acertijo con éxito, volver a enviar la solicitud web del cliente. 

El siguiente ejemplo de código muestra cómo hacerlo. 

**nota**  
La respuesta de AWS WAF CAPTCHA acción tiene un código de estado HTTP 405, que utilizamos para reconocer la respuesta en este código. CAPTCHA Si su punto de conexión protegido utiliza un código de estado HTTP 405 para comunicar cualquier otro tipo de respuesta para la misma llamada, este código de ejemplo también renderizará un rompecabezas de CAPTCHA para esas respuestas. 

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

# Administración de las claves de API para la API de JS CAPTCHA
<a name="waf-js-captcha-api-key"></a>

En esta sección, se proporcionan instrucciones para generar y eliminar claves de API.

Para integrar AWS WAF CAPTCHA en una aplicación cliente con la JavaScript API, necesitas la etiqueta de integración de la JavaScript API y la clave de API cifrada del dominio del cliente en el que quieres ejecutar el rompecabezas de CAPTCHA. 

La integración de la aplicación CAPTCHA JavaScript utiliza las claves de API cifradas para comprobar que el dominio de la aplicación cliente tiene permiso para utilizar la API de CAPTCHA. AWS WAF Cuando llamas a la API de CAPTCHA desde tu JavaScript cliente, proporcionas una clave de API con una lista de dominios que incluye un dominio para el cliente actual. Puede enumerar hasta 5 dominios en una sola clave cifrada. 

**Requisitos de la clave de API**  
La clave de API que utilices en su integración de CAPTCHA debe contener un dominio que se aplique al cliente en el que utilice la clave. 
+ Si especifica una `window.awsWafCookieDomainList` en la integración de amenazas inteligentes del cliente, al menos un dominio de la clave de API debe coincidir exactamente con uno de los dominios de token en `window.awsWafCookieDomainList` o debe ser el dominio de ápex de uno de esos dominios de token. 

  Por ejemplo, para el dominio de token `mySubdomain.myApex.com`, la clave de API `mySubdomain.myApex.com` coincide exactamente y la clave de API `myApex.com` es el dominio de ápex. Cualquiera de las claves coincide con el dominio de token. 

  Para obtener información sobre la configuración de la lista de dominios de tokens, consulte [Suministro de dominios para su uso en los tokens](waf-js-challenge-api-set-token-domain.md).
+ De lo contrario, el dominio actual debe estar incluido en la clave de API. El dominio actual es el dominio que puede ver en la barra de direcciones del navegador. 

Los dominios que utilices deben ser los que AWS WAF acepten, según el dominio host protegido y la lista de dominios simbólicos configurada para la ACL web. Para obtener más información, consulte [AWS WAF configuración de la lista de dominios simbólicos del paquete de protección (ACL web)](waf-tokens-domains.md#waf-tokens-domain-lists).

**Cómo elegir la región para la clave de API**  
AWS WAF puede generar claves de API de CAPTCHA en cualquier región en la que estén AWS WAF disponibles. 

Como regla general, debería usar la misma región para su clave de API de CAPTCHA que usa para su paquete de protección (ACL web). Sin embargo, si espera que un paquete de protección regional (ACL web) llegue a todo el mundo, puede obtener una etiqueta de JavaScript integración CAPTCHA específica CloudFront y una clave de API específica CloudFront, y utilizarlas con un paquete de protección regional (ACL web). Este enfoque permite a los clientes cargar una prueba CAPTCHA desde la región más cercana a ellos, lo que reduce la latencia. 

Las claves de API de CAPTCHA que están dirigidas a otras regiones no se admiten para su uso en CloudFront varias regiones. Solo se pueden usar en la región que las abarquen. 

**Cómo generar una clave de API para los dominios de sus clientes**  
Para obtener la URL de integración y generar y recuperar las claves de API a través de la consola. 

1. [Inicie sesión en la AWS WAF consola Consola de administración de AWS y ábrala en homev2. https://console.aws.amazon.com/wafv2/](https://console.aws.amazon.com/wafv2/homev2) 

1. En el panel de navegación, elija **Integración de la aplicación**. 

1. En el panel de **paquetes de protección (web ACLs) que están habilitados para la integración de aplicaciones**, seleccione la región que desee usar como clave de API. También puede seleccionar la región en el panel de **claves de API** de la pestaña de **integración con CAPTCHA**.

1. Seleccione la pestaña **Integración de CAPTCHA**. Esta pestaña proporciona la etiqueta de JavaScript integración CAPTCHA, que puede usar en la integración, y la lista de claves de API. Ambos los abarca la región seleccionada.

1. En el panel de **Claves de API**, seleccione **Generar claves**. Aparecerá el cuadro de diálogo de generación de claves. 

1. Introduzca los dominios de cliente que desee incluir en la clave. Puede especificar una máximo de 5. Cuando haya terminado, elija **Generar clave**. La interfaz vuelve a la pestaña de integración de CAPTCHA, donde aparece la nueva clave. 

   Una vez creada, la clave de API es inmutable. Si necesita realizar cambios en una clave, genere una nueva clave y úsela en su lugar. 

1. (Opcional) Copia la clave recién generada para usarla en la integración. 

También puedes usar el REST APIs o uno de los idiomas específicos para este trabajo AWS SDKs . [Las llamadas a la API REST son [Create APIKey y List](https://docs.aws.amazon.com/waf/latest/APIReference/API_CreateAPIKey.html). APIKeys](https://docs.aws.amazon.com/waf/latest/APIReference/API_ListAPIKeys.html) 

**Eliminación de una clave de API**  
Para eliminar una clave de API, debes usar la API REST o uno de los idiomas específicos AWS SDKs. La llamada a la API REST es [Eliminar APIKey](https://docs.aws.amazon.com/waf/latest/APIReference/API_DeleteAPIKey.html). No puede utilizar la consola para eliminar una clave. 

Después de eliminar una clave, pueden pasar hasta 24 horas AWS WAF hasta que no se permita su uso en todas las regiones. 