

**Ti presentiamo una nuova esperienza di console per AWS WAF**

Ora puoi utilizzare l'esperienza aggiornata per accedere alle AWS WAF funzionalità da qualsiasi punto della console. Per ulteriori dettagli, consulta [Lavorare con la console](https://docs.aws.amazon.com/waf/latest/developerguide/working-with-console.html). 

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

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

Questa sezione spiega come utilizzare le AWS WAF JavaScript integrazioni.

Puoi utilizzare l' JavaScript integrazione APIs per implementare integrazioni di AWS WAF applicazioni nei tuoi browser e in altri dispositivi che eseguono. JavaScript 

I puzzle CAPTCHA e le sfide silenziose possono essere eseguiti solo quando i browser accedono agli endpoint HTTPS. I browser client devono funzionare in contesti sicuri per acquisire i token. 
+ Questa minaccia intelligente APIs consente di gestire l'autorizzazione dei token mediante una sfida silenziosa sul browser lato client e di includere i token nelle richieste inviate alle risorse protette. 
+ L'API di integrazione CAPTCHA si aggiunge alla minaccia APIs intelligente e consente di personalizzare il posizionamento e le caratteristiche del puzzle CAPTCHA nelle applicazioni client. Questa API sfrutta la minaccia intelligente APIs per acquisire AWS WAF token da utilizzare nella pagina dopo che l'utente finale ha completato con successo il puzzle CAPTCHA. 

Utilizzando queste integrazioni, ti assicuri che le chiamate di procedura remota del tuo client contengano un token valido. Quando queste integrazioni APIs sono presenti nelle pagine dell'applicazione, è possibile implementare regole di mitigazione nel pacchetto di protezione (Web ACL), ad esempio bloccare le richieste che non contengono un token valido. Puoi anche implementare regole che impongono l'uso dei token ottenuti dalle tue applicazioni client, utilizzando le CAPTCHA azioni Challenge o nelle tue regole. 

**Esempio di implementazione di una minaccia intelligente APIs**  
L'elenco seguente mostra i componenti di base di un'implementazione tipica della minaccia intelligente APIs in una pagina di applicazione 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>
```

**Esempio di implementazione dell'API CAPTCHA JavaScript**  
L'API di integrazione CAPTCHA ti consente di personalizzare l'esperienza con i puzzle CAPTCHA degli utenti finali. L'integrazione CAPTCHA sfrutta l'integrazione JavaScript intelligente delle minacce, per la verifica del browser e la gestione dei token, e aggiunge una funzione per la configurazione e il rendering del puzzle CAPTCHA. 

L'elenco seguente mostra i componenti di base di un'implementazione tipica dell'API JavaScript CAPTCHA in una pagina di applicazione 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**
+ [Fornire domini da utilizzare nei token](waf-js-challenge-api-set-token-domain.md)
+ [Utilizzo dell' JavaScript API con politiche di sicurezza dei contenuti](waf-javascript-api-csp.md)
+ [Utilizzo dell' JavaScript API per le minacce intelligenti](waf-js-challenge-api.md)
+ [Utilizzo dell'API CAPTCHA JavaScript](waf-js-captcha-api.md)

# Fornire domini da utilizzare nei token
<a name="waf-js-challenge-api-set-token-domain"></a>

Questa sezione spiega come fornire domini aggiuntivi per i token.

Per impostazione predefinita, quando AWS WAF crea un token, utilizza il dominio host della risorsa associata al protection pack (web ACL). È possibile fornire domini aggiuntivi per i token AWS WAF creati per. JavaScript APIs Per fare ciò, configura la variabile globale`window.awsWafCookieDomainList`, con uno o più domini token. 

Quando AWS WAF crea un token, utilizza il dominio più appropriato e più breve tra la combinazione dei domini in `window.awsWafCookieDomainList` e del dominio host della risorsa associata al protection pack (ACL web). 

Impostazioni di esempio: 

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

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

Non puoi usare suffissi pubblici in questo elenco. Ad esempio, non puoi utilizzare `gov.au` or `co.uk` come domini token nell'elenco.

I domini specificati in questo elenco devono essere compatibili con gli altri domini e configurazioni di dominio: 
+ I domini devono essere accettabili, in base al dominio host protetto e all'elenco di domini token configurato per il pacchetto di protezione (Web ACL). AWS WAF Per ulteriori informazioni, consulta [AWS WAF configurazione dell'elenco di domini con token protection pack (Web ACL)](waf-tokens-domains.md#waf-tokens-domain-lists). 
+ Se utilizzi l'API JavaScript CAPTCHA, almeno un dominio nella tua chiave API CAPTCHA deve corrispondere esattamente a uno dei domini token di `window.awsWafCookieDomainList` o deve essere il dominio apex di uno di quei domini token. 

  Ad esempio, per il dominio token`mySubdomain.myApex.com`, la chiave API corrisponde esattamente e la chiave API `mySubdomain.myApex.com` è il dominio apex. `myApex.com` Entrambe le chiavi corrispondono al dominio del token. 

  Per ulteriori informazioni sulle chiavi API, consulta[Gestione delle chiavi API per l'API JS CAPTCHA](waf-js-captcha-api-key.md). 

Se utilizzi il gruppo di regole `AWSManagedRulesACFPRuleSet` gestito, potresti configurare un dominio che corrisponda a quello nel percorso di creazione dell'account che hai fornito per la configurazione del gruppo di regole. Per ulteriori informazioni su questa configurazione, consulta [Aggiungere il gruppo di regole gestite ACFP all'ACL Web](waf-acfp-rg-using.md).

Se utilizzi il gruppo di regole `AWSManagedRulesATPRuleSet` gestito, potresti configurare un dominio che corrisponda a quello nel percorso di accesso che hai fornito alla configurazione del gruppo di regole. Per ulteriori informazioni su questa configurazione, consulta [Aggiungere il gruppo di regole gestite ATP al pacchetto di protezione (Web ACL)](waf-atp-rg-using.md).

# Utilizzo dell' JavaScript API con politiche di sicurezza dei contenuti
<a name="waf-javascript-api-csp"></a>

Questa sezione fornisce un esempio di configurazione per inserire nella lista consentita il dominio AWS WAF apex.

Se applichi politiche di sicurezza dei contenuti (CSP) alle tue risorse, affinché JavaScript l'implementazione funzioni, devi inserire nella lista consentita il dominio apex. AWS WAF `awswaf.com` JavaScript SDKs Effettua chiamate a diversi AWS WAF endpoint, quindi Allowlist questo dominio fornisce le autorizzazioni necessarie per funzionare. SDKs 

Di seguito viene mostrato un esempio di configurazione per inserire nella lista consentita il dominio apex: AWS WAF 

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

Se provi a utilizzare il JavaScript SDKs con risorse che utilizzano CSP e non hai inserito il AWS WAF dominio nella lista consentita, riceverai errori come i seguenti: 

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

# Utilizzo dell' JavaScript API per le minacce intelligenti
<a name="waf-js-challenge-api"></a>

Questa sezione fornisce istruzioni per l'utilizzo dell' JavaScript API per le minacce intelligenti nell'applicazione client.

La minaccia intelligente APIs fornisce operazioni per eseguire sfide silenziose contro il browser dell'utente e per gestire i AWS WAF token che forniscono la prova dell'avvenuta sfida e le risposte CAPTCHA. 

Implementa l' JavaScript integrazione prima in un ambiente di test, poi in produzione. Per ulteriori indicazioni sulla codifica, consulta le sezioni seguenti. 

 

**Per usare la minaccia intelligente APIs**

1. **Installa il APIs** 

   Se utilizzi l'API CAPTCHA, puoi saltare questo passaggio. Quando installi l'API CAPTCHA, lo script installa automaticamente la minaccia intelligente. APIs

   1. [Accedi Console di gestione AWS e apri la AWS WAF console all'indirizzo homev2. https://console.aws.amazon.com/wafv2/](https://console.aws.amazon.com/wafv2/homev2) 

   1. Nel riquadro di navigazione, scegliere **Application integration (Integrazione di applicazioni)**. Nella pagina di **integrazione dell'applicazione**, puoi vedere le opzioni a schede. 

   1. Seleziona Integrazione **intelligente** delle minacce

   1. Nella scheda, seleziona il pacchetto di protezione (Web ACL) con cui desideri effettuare l'integrazione. L'elenco dei pacchetti di protezione (Web ACL) include solo i pacchetti di protezione (Web ACLs) che utilizzano il gruppo di regole `AWSManagedRulesACFPRuleSet` gestito, il gruppo di regole `AWSManagedRulesATPRuleSet` gestito o il livello di protezione mirato del gruppo di regole `AWSManagedRulesBotControlRuleSet` gestito. 

   1. Apri il riquadro **JavaScript SDK** e copia il tag dello script da utilizzare nella tua integrazione. 

   1. Nel codice della pagina dell'applicazione, nella `<head>` sezione, inserisci il tag script che hai copiato per il protection pack (web ACL). Questa inclusione fa sì che l'applicazione client recuperi automaticamente un token in background al caricamento della pagina. 

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

      Questo `<script>` elenco è configurato con l'`defer`attributo, ma puoi modificare l'impostazione `async` se desideri un comportamento diverso per la tua pagina. 

1. **(Facoltativo) Aggiungi la configurazione del dominio per i token del client**: per impostazione predefinita, quando AWS WAF crea un token, utilizza il dominio host della risorsa associata al pacchetto di protezione (ACL web). Per fornire domini aggiuntivi per il JavaScript APIs, segui le istruzioni all'indirizzo. [Fornire domini da utilizzare nei token](waf-js-challenge-api-set-token-domain.md) 

1. **Codifica la tua integrazione intelligente contro le minacce**: scrivi il codice per assicurarti che il recupero dei token venga completato prima che il client invii le sue richieste agli endpoint protetti. Se stai già utilizzando l'`fetch`API per effettuare la chiamata, puoi sostituire il wrapper di integrazione. AWS WAF `fetch` Se non utilizzi l'`fetch`API, puoi invece utilizzare l'operazione di AWS WAF integrazione`getToken`. Per indicazioni sulla codifica, consulta le seguenti sezioni. 

1. **Aggiungi la verifica tramite token nel tuo pacchetto di protezione (Web ACL)**: aggiungi almeno una regola al tuo pacchetto di protezione (Web ACL) per verificare la presenza di un token di sfida valido nelle richieste Web inviate dal client. Puoi utilizzare gruppi di regole che controllano e monitorano i token di sfida, come il livello mirato del gruppo di regole gestito da Bot Control, e puoi utilizzare l'azione delle Challenge regole per verificare, come descritto in. [CAPTCHAe Challenge in AWS WAF](waf-captcha-and-challenge.md) 

   Le aggiunte al pacchetto di protezione (Web ACL) verificano che le richieste agli endpoint protetti includano il token che hai acquisito nell'integrazione con il client. Le richieste che includono un token valido e non scaduto superano l'Challengeispezione e non inviano un'altra contestazione silenziosa al cliente. 

1. **(Facoltativo) Blocca le richieste APIs con token mancanti**: se utilizzi il gruppo di regole gestite ACFP, il gruppo di regole gestito ATP o le regole mirate del gruppo di regole Bot Control, queste regole non bloccano le richieste che contengono token mancanti. Per bloccare le richieste che contengono token mancanti, segui le istruzioni riportate all'indirizzo. [Bloccare le richieste che non hanno un AWS WAF token valido](waf-tokens-block-missing-tokens.md) 

**Topics**
+ [Specifiche dell'API per le minacce intelligenti](waf-js-challenge-api-specification.md)
+ [Come usare il `fetch` wrapper di integrazione](waf-js-challenge-api-fetch-wrapper.md)
+ [Come usare l'integrazione `getToken`](waf-js-challenge-api-get-token.md)

# Specifiche dell'API per le minacce intelligenti
<a name="waf-js-challenge-api-specification"></a>

Questa sezione elenca le specifiche dei metodi e delle proprietà della JavaScript APIs mitigazione intelligente delle minacce. Utilizzali APIs per le integrazioni intelligenti di minacce e CAPTCHA.

**`AwsWafIntegration.fetch()`**  
Invia la `fetch` richiesta HTTP al server utilizzando l'implementazione dell' AWS WAF integrazione. 

**`AwsWafIntegration.getToken()`**  
Recupera il AWS WAF token memorizzato e lo memorizza in un cookie nella pagina corrente con il nome `aws-waf-token` e il valore impostato sul valore del token. 

**`AwsWafIntegration.hasToken()`**  
Restituisce un valore booleano che indica se il `aws-waf-token` cookie contiene attualmente un token non scaduto. 

Se utilizzi anche l'integrazione CAPTCHA, consulta le relative specifiche all'indirizzo. [Specifiche dell'API CAPTCHA JavaScript](waf-js-captcha-api-specification.md)

# Come usare il `fetch` wrapper di integrazione
<a name="waf-js-challenge-api-fetch-wrapper"></a>

Questa sezione fornisce istruzioni per l'uso del wrapper di integrazione`fetch`.

È possibile utilizzare il AWS WAF `fetch` wrapper modificando le normali `fetch` chiamate all'`fetch`API nel namespace. `AwsWafIntegration` Il AWS WAF wrapper supporta tutte le stesse opzioni della chiamata JavaScript `fetch` API standard e aggiunge la gestione dei token per l'integrazione. Questo approccio è generalmente il modo più semplice per integrare l'applicazione. 

**Prima dell'implementazione del wrapper**  
L'elenco di esempio seguente mostra il codice standard prima di implementare il `AwsWafIntegration` `fetch` wrapper.

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

**Dopo l'implementazione del wrapper**  
L'elenco seguente mostra lo stesso codice con l'implementazione del `AwsWafIntegration` `fetch` wrapper.

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

# Come usare l'integrazione `getToken`
<a name="waf-js-challenge-api-get-token"></a>

Questa sezione spiega come utilizzare l'`getToken`operazione.

AWS WAF richiede che le richieste agli endpoint protetti includano il cookie denominato `aws-waf-token` con il valore del token corrente. 

L'`getToken`operazione è una chiamata API asincrona che recupera il AWS WAF token e lo memorizza in un cookie nella pagina corrente con il nome `aws-waf-token` e il valore impostato sul valore del token. Puoi utilizzare questo cookie token in base alle tue esigenze nella tua pagina. 

Quando chiami`getToken`, esegue le seguenti operazioni: 
+ Se un token non scaduto è già disponibile, la chiamata lo restituisce immediatamente.
+ In caso contrario, la chiamata recupera un nuovo token dal fornitore del token e attende il completamento del flusso di lavoro di acquisizione del token fino a 2 secondi prima che scada il timeout. Se l'operazione scade, viene generato un errore, che deve essere gestito dal codice di chiamata. 

L'`getToken`operazione è accompagnata da un'`hasToken`operazione che indica se il `aws-waf-token` cookie contiene attualmente un token non scaduto. 

`AwsWafIntegration.getToken()`recupera un token valido e lo memorizza come cookie. La maggior parte delle chiamate client allega automaticamente questo cookie, ma alcune no. Ad esempio, le chiamate effettuate tra domini host non allegano il cookie. Nei dettagli di implementazione che seguono, mostriamo come lavorare con entrambi i tipi di chiamate client. 

**`getToken`Implementazione di base, per le chiamate che allegano il `aws-waf-token` cookie**  
L'elenco di esempio seguente mostra il codice standard per l'implementazione dell'`getToken`operazione con una richiesta di accesso.

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

**Invia il modulo solo dopo che il token è disponibile da `getToken`**  
L'elenco seguente mostra come registrare un listener di eventi per intercettare gli invii di moduli fino a quando non sarà disponibile un token valido per l'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>
```

**Allegare il token quando il client non allega il cookie per impostazione predefinita `aws-waf-token`**  
`AwsWafIntegration.getToken()`recupera un token valido e lo memorizza come cookie, ma non tutte le chiamate client associano questo cookie per impostazione predefinita. Ad esempio, le chiamate effettuate tra domini host non allegano il cookie. 

Il `fetch` wrapper gestisce questi casi automaticamente, ma se non riesci a utilizzare il `fetch` wrapper, puoi gestirlo utilizzando un'intestazione personalizzata. `x-aws-waf-token` AWS WAF legge i token da questa intestazione, oltre a leggerli dal cookie. `aws-waf-token` Il codice seguente mostra un esempio di impostazione dell'intestazione. 

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

Per impostazione predefinita, accetta AWS WAF solo token che contengono lo stesso dominio del dominio host richiesto. Qualsiasi token interdominio richiede le voci corrispondenti nell'elenco dei domini del token Protection Pack (Web ACL). Per ulteriori informazioni, consulta [AWS WAF configurazione dell'elenco di domini con token protection pack (Web ACL)](waf-tokens-domains.md#waf-tokens-domain-lists). 

[Per ulteriori informazioni sull'uso dei token tra domini, consulta aws-samples/ -. aws-waf-bot-control api-protection-with-captcha](https://github.com/aws-samples/aws-waf-bot-control-api-protection-with-captcha)

# Utilizzo dell'API CAPTCHA JavaScript
<a name="waf-js-captcha-api"></a>

Questa sezione fornisce istruzioni per l'utilizzo dell'API di integrazione CAPTCHA.

L' JavaScript API CAPTCHA ti consente di configurare il puzzle CAPTCHA e posizionarlo dove vuoi nell'applicazione client. Questa API sfrutta le funzionalità della minaccia intelligente JavaScript APIs per acquisire e utilizzare i AWS WAF token dopo che un utente finale ha completato con successo un puzzle CAPTCHA. 

Implementa l' JavaScript integrazione prima in un ambiente di test, poi in produzione. Per ulteriori indicazioni sulla codifica, consulta le sezioni seguenti. 

**Per utilizzare l'API di integrazione CAPTCHA**

1. **Installa l'API**

   1. Accedi a Console di gestione AWS e apri la AWS WAF console all'indirizzo [https://console.aws.amazon.com/wafv2/homev2](https://console.aws.amazon.com/wafv2/homev2). 

   1. Nel riquadro di navigazione, scegliere **Application integration (Integrazione di applicazioni)**. Nella pagina di **integrazione dell'applicazione**, puoi vedere le opzioni a schede. 

   1. Seleziona Integrazione **CAPTCHA**.

   1. Copia il tag dello script di JavaScript integrazione elencato per utilizzarlo nella tua integrazione.

   1. Nel codice della pagina dell'applicazione, nella `<head>` sezione, inserisci il tag script che hai copiato. Questa inclusione rende il puzzle CAPTCHA disponibile per la configurazione e l'uso. 

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

      Questo `<script>` elenco è configurato con l'`defer`attributo, ma puoi modificare l'impostazione `async` se desideri un comportamento diverso per la tua pagina. 

      Lo script CAPTCHA carica automaticamente anche lo script di integrazione intelligente delle minacce se non è già presente. Lo script di integrazione intelligente delle minacce consente all'applicazione client di recuperare automaticamente un token in background al caricamento della pagina e fornisce altre funzionalità di gestione dei token necessarie per l'utilizzo dell'API CAPTCHA. 

1. **(Facoltativo) Aggiungi la configurazione del dominio per i token del client**: per impostazione predefinita, quando AWS WAF crea un token, utilizza il dominio host della risorsa associata al protection pack (Web ACL). Per fornire domini aggiuntivi per il JavaScript APIs, segui le istruzioni all'indirizzo. [Fornire domini da utilizzare nei token](waf-js-challenge-api-set-token-domain.md) 

1. **Ottieni la chiave API crittografata per il client**: l'API CAPTCHA richiede una chiave API crittografata che contenga un elenco di domini client validi. AWS WAF utilizza questa chiave per verificare che il dominio client che stai utilizzando con l'integrazione sia approvato per l'uso di CAPTCHA. AWS WAF Per generare la tua chiave API, segui le istruzioni all'indirizzo. [Gestione delle chiavi API per l'API JS CAPTCHA](waf-js-captcha-api-key.md)

1. **Codifica l'implementazione del widget CAPTCHA**: implementa la chiamata `renderCaptcha()` API nella tua pagina, nel luogo in cui desideri utilizzarla. Per informazioni sulla configurazione e l'uso di questa funzione, consulta le seguenti sezioni e. [Specifiche dell'API CAPTCHA JavaScript](waf-js-captcha-api-specification.md) [Come renderizzare il puzzle CAPTCHA](waf-js-captcha-api-render.md) 

   L'implementazione CAPTCHA si integra con l'integrazione intelligente delle minacce per la gestione dei token e APIs per l'esecuzione di chiamate di recupero che utilizzano i token. AWS WAF Per indicazioni sull'utilizzo di questi, consulta. APIs [Utilizzo dell' JavaScript API per le minacce intelligenti](waf-js-challenge-api.md)

1. **Aggiungi la verifica tramite token nel tuo pacchetto di protezione (Web ACL)**: aggiungi almeno una regola al tuo pacchetto di protezione (Web ACL) per verificare la presenza di un token CAPTCHA valido nelle richieste Web inviate dal client. È possibile utilizzare l'azione della CAPTCHA regola per verificare, come descritto in. [CAPTCHAe Challenge in AWS WAF](waf-captcha-and-challenge.md) 

   Le aggiunte al pacchetto di protezione (Web ACL) verificano che le richieste che arrivano agli endpoint protetti includano il token che hai acquisito nell'integrazione del client. Le richieste che includono un token CAPTCHA valido e non scaduto superano l'ispezione delle CAPTCHA regole e non presentano all'utente finale un altro puzzle CAPTCHA. 

Dopo aver implementato l' JavaScript API, puoi esaminare le CloudWatch metriche relative ai tentativi e alle soluzioni dei puzzle CAPTCHA. Per i dettagli sulle metriche e sulle dimensioni, consulta. [Metriche e dimensioni dell'account](waf-metrics.md#waf-metrics-account)

**Topics**
+ [Specifiche dell'API CAPTCHA JavaScript](waf-js-captcha-api-specification.md)
+ [Come renderizzare il puzzle CAPTCHA](waf-js-captcha-api-render.md)
+ [Gestione di una risposta CAPTCHA da AWS WAF](waf-js-captcha-api-conditional.md)
+ [Gestione delle chiavi API per l'API JS CAPTCHA](waf-js-captcha-api-key.md)

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

Questa sezione elenca le specifiche dei metodi e delle proprietà del CAPTCHA. JavaScript APIs Usa il CAPTCHA JavaScript APIs per eseguire puzzle CAPTCHA personalizzati nelle tue applicazioni client. 

Questa API si basa sulla minaccia intelligente APIs, che utilizzi per configurare e gestire l'acquisizione e l'utilizzo dei token. AWS WAF Vedi[Specifiche dell'API per le minacce intelligenti](waf-js-challenge-api-specification.md).

**`AwsWafCaptcha.renderCaptcha(container, configuration)`**  
Presenta un puzzle AWS WAF CAPTCHA all'utente finale e, in caso di successo, aggiorna il token client con la convalida CAPTCHA. Questo è disponibile solo con l'integrazione CAPTCHA. Utilizzate questa chiamata insieme alla minaccia intelligente APIs per gestire il recupero dei token e fornire il token nelle chiamate. `fetch` Vedi la minaccia APIs intelligente su. [Specifiche dell'API per le minacce intelligenti](waf-js-challenge-api-specification.md)  
A differenza del CAPTCHA interstitial che AWS WAF invia, il puzzle CAPTCHA reso con questo metodo visualizza il puzzle immediatamente, senza una schermata iniziale del titolo.     
**`container`**  
L'`Element`oggetto per l'elemento contenitore di destinazione sulla pagina. Questo viene in genere recuperato chiamando `document.getElementById()` o`document.querySelector()`.  
Obbligatorio: sì  
Tipo: `Element`  
**configurazione**  
Un oggetto contenente le impostazioni di configurazione CAPTCHA, come segue: ****    
**`apiKey`**   
La chiave API crittografata che abilita le autorizzazioni per il dominio del client. Usa la AWS WAF console per generare le tue chiavi API per i domini dei tuoi clienti. Puoi utilizzare una chiave per un massimo di cinque domini. Per informazioni, consulta [Gestione delle chiavi API per l'API JS CAPTCHA](waf-js-captcha-api-key.md).   
Obbligatorio: sì  
Tipo: `string`  
**`onSuccess: (wafToken: string) => void;`**   
Chiamato con un AWS WAF token valido quando l'utente finale completa con successo un puzzle CAPTCHA. Utilizza il token nelle richieste inviate agli endpoint che proteggi con un pacchetto di AWS WAF protezione (Web ACL). Il token fornisce la prova e l'ora dell'ultimo completamento riuscito del puzzle.   
Obbligatorio: sì  
**`onError?: (error: CaptchaError) => void;`**   
Chiamato con un oggetto error quando si verifica un errore durante l'operazione CAPTCHA.   
Obbligatorio: no  
**`CaptchaError`definizione della classe** — Il `onError` gestore fornisce un tipo di errore con la seguente definizione di classe.   

```
CaptchaError extends Error {
    kind: "internal_error" | "network_error" | "token_error" | "client_error";
    statusCode?: number;
}
```
+ `kind`— Il tipo di errore restituito. 
+ `statusCode`— Il codice di stato HTTP, se disponibile. Viene utilizzato da `network_error` se l'errore è dovuto a un errore HTTP.  
**`onLoad?: () => void;`**   
Chiamato quando viene caricato un nuovo puzzle CAPTCHA.  
Obbligatorio: no  
**`onPuzzleTimeout?: () => void;`**   
Chiamato quando un puzzle CAPTCHA non viene completato prima della scadenza.  
Obbligatorio: no  
**`onPuzzleCorrect?: () => void;`**   
Chiamato quando viene fornita una risposta corretta a un puzzle CAPTCHA.  
Obbligatorio: no  
**`onPuzzleIncorrect?: () => void;`**   
Chiamato quando viene fornita una risposta errata a un puzzle CAPTCHA.  
Obbligatorio: no  
**`defaultLocale`**   
La localizzazione predefinita da usare per il puzzle CAPTCHA. Le istruzioni scritte per i puzzle CAPTCHA sono disponibili in arabo (ar-SA), cinese semplificato (zh-CN), olandese (nl-NL), inglese (en-US), francese (fr-FR), tedesco (de-DE), italiano (it-IT), giapponese (ja-JP), portoghese brasiliano (pt-BR), spagnolo (es-ES) e turco (tr-TR). Le istruzioni audio sono disponibili per tutte le lingue scritte tranne il cinese e il giapponese, che per impostazione predefinita è l'inglese. Per cambiare la lingua predefinita, fornisci la lingua internazionale e il codice locale, ad esempio`ar-SA`.  
Predefinita: la lingua attualmente in uso nel browser dell'utente finale  
Obbligatorio: no  
Tipo: `string`  
**`disableLanguageSelector`**   
Se impostato su`true`, il puzzle CAPTCHA nasconde il selettore della lingua.   
Impostazione predefinita: `false`  
Obbligatorio: no  
Tipo: `boolean`  
**`dynamicWidth`**   
Se impostato su`true`, il puzzle CAPTCHA cambia larghezza per compatibilità con la larghezza della finestra del browser.   
Impostazione predefinita: `false`  
Obbligatorio: no  
Tipo: `boolean`  
**`skipTitle`**   
**Se impostato su`true`, il puzzle CAPTCHA non visualizza il titolo del puzzle Risolvi il puzzle.**   
Impostazione predefinita: `false`  
Obbligatorio: no  
Tipo: `boolean`

# Come renderizzare il puzzle CAPTCHA
<a name="waf-js-captcha-api-render"></a>

Questa sezione fornisce un esempio `renderCaptcha` di implementazione.

È possibile utilizzare la AWS WAF `renderCaptcha` chiamata dove si desidera nell'interfaccia client. La chiamata recupera un puzzle CAPTCHA da AWS WAF, lo esegue il rendering e invia i risultati per la verifica. AWS WAF Quando effettui la chiamata, fornisci la configurazione di rendering del puzzle e i callback che desideri eseguire quando gli utenti finali completano il puzzle. Per informazioni dettagliate sulle opzioni, consultate la sezione precedente,. [Specifiche dell'API CAPTCHA JavaScript](waf-js-captcha-api-specification.md)

Utilizzate questa chiamata insieme alla funzionalità di gestione dei token dell'integrazione intelligente delle minacce. APIs Questa chiamata fornisce al cliente un token che verifica il completamento con successo del puzzle CAPTCHA. Utilizzate l'integrazione intelligente delle minacce APIs per gestire il token e per fornire il token nelle chiamate del cliente agli endpoint protetti con pacchetti di AWS WAF protezione (web). ACLs Per informazioni sulla minaccia intelligente APIs, consulta[Utilizzo dell' JavaScript API per le minacce intelligenti](waf-js-challenge-api.md).

**Implementazione di esempio**  
L'elenco di esempio seguente mostra un'implementazione CAPTCHA standard, incluso il posizionamento dell'URL di AWS WAF integrazione nella `<head>` sezione. 

Questo elenco configura la `renderCaptcha` funzione con un callback di successo che utilizza il `AwsWafIntegration.fetch` wrapper dell'integrazione intelligente delle minacce. APIs Per informazioni su questa funzione, vedere. [Come usare il `fetch` wrapper di integrazione](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>
```

**Impostazioni di configurazione di esempio**  
L'elenco di esempio seguente mostra le opzioni `renderCaptcha` con impostazioni non predefinite per la larghezza e il titolo. 

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

Per informazioni complete sulle opzioni di configurazione, vedere[Specifiche dell'API CAPTCHA JavaScript](waf-js-captcha-api-specification.md).

# Gestione di una risposta CAPTCHA da AWS WAF
<a name="waf-js-captcha-api-conditional"></a>

Questa sezione fornisce un esempio di gestione di una risposta CAPTCHA.

Una AWS WAF regola con un'CAPTCHAazione termina la valutazione di una richiesta web corrispondente se la richiesta non ha un token con un timestamp CAPTCHA valido. Se la richiesta è una `GET` text/html chiamata, l'CAPTCHAazione invia al client un messaggio interstiziale con un puzzle CAPTCHA. Quando non integri l' JavaScript API CAPTCHA, l'interstitial esegue il puzzle e, se l'utente finale lo risolve con successo, invia nuovamente la richiesta automaticamente. 

Quando integri l' JavaScript API CAPTCHA e personalizzi la gestione del CAPTCHA, devi rilevare la risposta CAPTCHA di terminazione, fornire il CAPTCHA personalizzato e, se l'utente finale risolve con successo il puzzle, inviare nuovamente la richiesta web del cliente. 

L'esempio di codice seguente mostra come eseguire tale operazione. 

**Nota**  
La risposta AWS WAF CAPTCHA all'azione ha un codice di stato HTTP 405, che utilizziamo per riconoscere la risposta in questo codice. CAPTCHA Se l'endpoint protetto utilizza un codice di stato HTTP 405 per comunicare qualsiasi altro tipo di risposta per la stessa chiamata, questo codice di esempio genererà anche un puzzle CAPTCHA per quelle risposte. 

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

# Gestione delle chiavi API per l'API JS CAPTCHA
<a name="waf-js-captcha-api-key"></a>

Questa sezione fornisce istruzioni per la generazione e l'eliminazione delle chiavi API.

Per integrare AWS WAF CAPTCHA in un'applicazione client con l' JavaScript API, sono necessari il tag di integrazione JavaScript API e la chiave API crittografata per il dominio client in cui desideri eseguire il puzzle CAPTCHA. 

L'integrazione dell'applicazione CAPTCHA JavaScript utilizza le chiavi API crittografate per verificare che il dominio dell'applicazione client sia autorizzato a utilizzare l'API CAPTCHA. AWS WAF Quando richiami l'API CAPTCHA dal tuo JavaScript client, fornisci una chiave API con un elenco di domini che include un dominio per il client corrente. Puoi elencare fino a 5 domini in un'unica chiave crittografata. 

**Requisiti delle chiavi API**  
La chiave API che utilizzi nell'integrazione CAPTCHA deve contenere un dominio applicabile al client in cui utilizzi la chiave. 
+ Se specifichi una `window.awsWafCookieDomainList` nell'integrazione intelligente delle minacce del tuo client, almeno un dominio nella tua chiave API deve corrispondere esattamente a uno dei domini token in `window.awsWafCookieDomainList` o deve essere il dominio apex di uno di quei domini token. 

  Ad esempio, per il dominio token`mySubdomain.myApex.com`, la chiave `mySubdomain.myApex.com` API corrisponde esattamente e la chiave API `myApex.com` è il dominio apex. Entrambe le chiavi corrispondono al dominio del token. 

  Per informazioni sull'impostazione dell'elenco dei domini dei token, vedere[Fornire domini da utilizzare nei token](waf-js-challenge-api-set-token-domain.md).
+ Altrimenti, il dominio corrente deve essere contenuto nella chiave API. Il dominio corrente è il dominio che puoi vedere nella barra degli indirizzi del browser. 

I domini che utilizzi devono essere accettati, in base al dominio host protetto e all'elenco di domini token configurato per l'ACL web. AWS WAF Per ulteriori informazioni, consulta [AWS WAF configurazione dell'elenco di domini con token protection pack (Web ACL)](waf-tokens-domains.md#waf-tokens-domain-lists).

**Come scegliere la regione per la tua chiave API**  
AWS WAF può generare chiavi API CAPTCHA in qualsiasi regione in cui AWS WAF sia disponibile. 

Come regola generale, è necessario utilizzare la stessa regione per la chiave API CAPTCHA utilizzata per il pacchetto di protezione (Web ACL). Se ti aspetti un pubblico globale per un pacchetto di protezione regionale (ACL web), tuttavia, puoi ottenere un tag di JavaScript integrazione CAPTCHA con ambito e una chiave API con ambito a CloudFront, CloudFront e utilizzarli con un pacchetto di protezione regionale (ACL web). Questo approccio consente ai clienti di caricare un puzzle CAPTCHA dalla regione più vicina a loro, il che riduce la latenza. 

Le chiavi API CAPTCHA destinate a regioni diverse da quelle non CloudFront sono supportate per l'uso in più regioni. Possono essere utilizzate solo nella regione a cui sono destinate. 

**Per generare una chiave API per i domini dei tuoi clienti**  
Per ottenere l'URL di integrazione e generare e recuperare le chiavi API tramite la console. 

1. Accedi a Console di gestione AWS e apri la AWS WAF console all'indirizzo [https://console.aws.amazon.com/wafv2/homev2](https://console.aws.amazon.com/wafv2/homev2). 

1. Nel riquadro di navigazione, scegliere **Application integration (Integrazione di applicazioni)**. 

1. Nel riquadro, contenente i **protection pack (web ACLs) abilitati per l'integrazione delle applicazioni**, seleziona la regione che desideri utilizzare per la tua chiave API. Puoi anche selezionare la regione nel riquadro delle **chiavi API** della scheda di **integrazione CAPTCHA**.

1. Scegli la scheda Integrazione **CAPTCHA**. Questa scheda fornisce il tag di JavaScript integrazione CAPTCHA, che puoi utilizzare nella tua integrazione, e l'elenco delle chiavi API. Entrambi si riferiscono alla regione selezionata.

1. Nel riquadro **Chiavi API**, scegli **Genera chiave**. Viene visualizzata la finestra di dialogo per la generazione delle chiavi. 

1. Inserisci i domini client che desideri includere nella chiave. Puoi inserire fino a 5. Quando hai finito, scegli **Genera chiave**. L'interfaccia torna alla scheda di integrazione CAPTCHA, dove è elencata la tua nuova chiave. 

   Una volta creata, una chiave API è immutabile. Se devi apportare modifiche a una chiave, genera una nuova chiave e usala al suo posto. 

1. (Facoltativo) Copia la chiave appena generata per utilizzarla nella tua integrazione. 

Puoi anche usare il REST APIs o uno dei linguaggi specifici AWS SDKs per questo lavoro. [Le chiamate API REST sono [APIKeyCreate](https://docs.aws.amazon.com/waf/latest/APIReference/API_CreateAPIKey.html) e List. APIKeys](https://docs.aws.amazon.com/waf/latest/APIReference/API_ListAPIKeys.html) 

**Come eliminare una chiave API**  
Per eliminare una chiave API, è necessario utilizzare l'API REST o una delle lingue specifiche AWS SDKs. La chiamata all'API REST è [Delete APIKey](https://docs.aws.amazon.com/waf/latest/APIReference/API_DeleteAPIKey.html). Non puoi utilizzare la console per eliminare una chiave. 

Dopo aver eliminato una chiave, possono essere necessarie fino a 24 ore prima che non AWS WAF venga consentita l'utilizzo della chiave in tutte le aree geografiche. 