

**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à.

# 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)