

**Apresentando uma nova experiência de console para AWS WAF**

Agora você pode usar a experiência atualizada para acessar a AWS WAF funcionalidade em qualquer lugar do console. Para obter mais detalhes, consulte [Trabalhando com o console](https://docs.aws.amazon.com/waf/latest/developerguide/working-with-console.html). 

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Uso de tokens na mitigação AWS WAF inteligente de ameaças
<a name="waf-tokens"></a>

Esta seção explica o que AWS WAF os tokens fazem.

AWS WAF os tokens são parte integrante das proteções aprimoradas oferecidas pela mitigação AWS WAF inteligente de ameaças. Um token, às vezes chamado de impressão digital, é uma coleção de informações sobre uma única sessão de cliente que o cliente armazena e fornece com cada solicitação da web enviada. AWS WAF usa tokens para identificar e separar sessões maliciosas de clientes de sessões legítimas, mesmo quando ambas se originam de um único endereço IP. O uso de tokens impõe custos insignificantes para usuários legítimos, mas caros em grande escala para botnets. 

AWS WAF usa tokens para oferecer suporte à funcionalidade de desafio do navegador e do usuário final, que é fornecida pela integração do aplicativo SDKs e pelas ações Challenge de regras CAPTCHA e. Além disso, os tokens habilitam recursos dos grupos de regras gerenciados de controle de AWS WAF bots e prevenção de invasão de contas.

AWS WAF cria, atualiza e criptografa tokens para clientes que respondem com sucesso a desafios silenciosos e quebra-cabeças de CAPTCHA. Quando um cliente com um token envia uma solicitação da web, ele inclui o token criptografado, AWS WAF decodifica o token e verifica seu conteúdo. 

**Topics**
+ [Como AWS WAF usa tokens](waf-tokens-usage.md)
+ [AWS WAF características do token](waf-tokens-details.md)
+ [Definindo a expiração do carimbo de data/hora e os tempos de imunidade do token em AWS WAF](waf-tokens-immunity-times.md)
+ [Especificando domínios de token e listas de domínios em AWS WAF](waf-tokens-domains.md)
+ [Tipos de rótulos simbólicos em AWS WAF](waf-tokens-labeling.md)
+ [Bloqueio de solicitações que não têm um AWS WAF token válido](waf-tokens-block-missing-tokens.md)
+ [Configuração necessária para balanceadores de carga de aplicativos que são origens CloudFront](waf-tokens-with-alb-and-cf.md)

# Como AWS WAF usa tokens
<a name="waf-tokens-usage"></a>

Esta seção explica como AWS WAF usa tokens.

AWS WAF usa tokens para registrar e verificar os seguintes tipos de validação da sessão do cliente: 
+ **CAPTCHA**: os quebra-cabeças CAPTCHA ajudam a distinguir bots de usuários humanos. Um CAPTCHA é executado somente pela ação de regra CAPTCHA. Após a conclusão bem-sucedida do quebra-cabeça, o script do CAPTCHA atualiza o timestamp do CAPTCHA do token. Para saber mais, consulte [CAPTCHAe Challenge em AWS WAF](waf-captcha-and-challenge.md).
+ **Desafio**: os desafios são executados silenciosamente para ajudar a distinguir as sessões regulares dos clientes das sessões de bots e para tornar a operação dos bots mais dispendiosa. Quando o desafio é concluído com sucesso, o script do desafio adquire automaticamente um novo token, AWS WAF se necessário, e então atualiza a data e hora do desafio do token. 

  AWS WAF executa desafios nas seguintes situações: 
  + **Integração de aplicativos SDKs** — A integração de aplicativos é SDKs executada dentro das sessões do aplicativo cliente e ajuda a garantir que as tentativas de login só sejam permitidas após o cliente ter respondido com sucesso a um desafio. Para obter mais informações, consulte [Integrações de aplicativos clientes em AWS WAF](waf-application-integration.md).
  + **Ação de regra Challenge**: para mais informações, consulte [CAPTCHAe Challenge em AWS WAF](waf-captcha-and-challenge.md).
  + **CAPTCHA**: quando um intersticial CAPTCHA é executada, se o cliente ainda não tiver um token, o script executa automaticamente um desafio primeiro, para verificar a sessão do cliente e inicializar o token. 

Os tokens são exigidos por muitas das regras dos grupos de regras de regras AWS gerenciadas de ameaças inteligentes. As regras usam tokens para fazer coisas como distinguir entre clientes no nível da sessão, determinar as características do navegador e entender o nível de interatividade humana na página da web do aplicativo. Esses grupos de regras invocam o gerenciamento de AWS WAF tokens, que aplica a rotulagem de tokens que os grupos de regras então inspecionam. 
+ **AWS WAF Controle de fraudes na criação de contas e prevenção de fraudes (ACFP)** — As regras do ACFP exigem solicitações na web com tokens válidos. Para saber mais sobre as regras, consulte [AWS WAF Grupo de regras de prevenção de fraudes (ACFP) para criação de contas de controle de fraudes](aws-managed-rule-groups-acfp.md).
+ **AWS WAF Controle de fraudes e prevenção de aquisição de contas (ATP)** — As regras da ATP que evitam sessões de alto volume e longa duração com clientes exigem solicitações da web que tenham um token válido com um timestamp de desafio não expirado. Para obter mais informações, consulte [AWS WAF Grupo de regras de prevenção de aquisição de contas (ATP) de controle de fraudes](aws-managed-rule-groups-atp.md).
+ **AWS WAF Controle de bots** — As regras específicas desse grupo de regras limitam o número de solicitações da web que um cliente pode enviar sem um token válido e usam o rastreamento de sessão de token para monitoramento e gerenciamento em nível de sessão. Conforme necessário, as regras aplicam as ações de regra Challenge e CAPTCHApara impor a aquisição de tokens e o comportamento válido do cliente. Para saber mais, consulte [AWS WAF Grupo de regras do Bot Control](aws-managed-rule-groups-bot.md).

# AWS WAF características do token
<a name="waf-tokens-details"></a>

Cada token tem as seguintes características: 
+ O token é armazenado em um cookie chamado `aws-waf-token`.
+ O token é criptografado.
+ O token imprime a sessão do cliente com um identificador granular fixo que contém as seguintes informações: 
  + O timestamp da última resposta bem-sucedida do cliente a um desafio silencioso. 
  + O timestamp da última resposta bem-sucedida do usuário final a um CAPTCHA. Isso só está presente se você usar CAPTCHA em suas proteções. 
  + Informações adicionais sobre o cliente e o comportamento do cliente que podem ajudar a separar seus clientes legítimos do tráfego indesejado. As informações incluem vários identificadores de clientes e sinais do lado do cliente que podem ser usados para detectar atividades automatizadas. As informações coletadas não são exclusivas e não podem ser mapeadas para um ser humano individual. 
    + Todos os tokens incluem dados da interrogação do navegador do cliente, como indicações de automação e inconsistências nas configurações do navegador. Essas informações são recuperadas pelos scripts que são executados pela Challenge ação e pelo aplicativo SDKs cliente. Os scripts interrogam ativamente o navegador e colocam os resultados no token. 
    + Além disso, quando você implementa um SDK de integração de aplicativos clientes, o token inclui informações coletadas passivamente sobre a interatividade do usuário final com a página do aplicativo. A interatividade inclui movimentos do mouse, pressionamentos de teclas e interações com qualquer formulário HTML presente na página. Essas informações ajudam o AWS WAF a detectar o nível de interatividade humana no cliente, para desafiar usuários que não parecem ser humanos. Para obter informações sobre integrações do lado do cliente, consulte [Integrações de aplicativos clientes em AWS WAF](waf-application-integration.md).

Por motivos de segurança, AWS não fornece uma descrição completa do conteúdo dos AWS WAF tokens nem informações detalhadas sobre o processo de criptografia do token. 

# Definindo a expiração do carimbo de data/hora e os tempos de imunidade do token em AWS WAF
<a name="waf-tokens-immunity-times"></a>

Esta seção explica como os timestamps de desafios e CAPTCHA expiram.

AWS WAF usa tempos de imunidade de desafio e CAPTCHA para controlar a frequência com que uma única sessão de cliente pode receber um desafio ou CAPTCHA. Depois que um usuário final responde com sucesso a um CAPTCHA, o tempo de imunidade do CAPTCHA determina por quanto tempo o usuário final permanece imune à apresentação de outro CAPTCHA. Da mesma forma, o tempo de imunidade ao desafio determina por quanto tempo uma sessão de cliente permanece imune a ser desafiada novamente após responder com sucesso a um desafio. 

**Como funcionam os tempos de imunidade AWS WAF simbólica**

AWS WAF registra uma resposta bem-sucedida a um desafio ou CAPTCHA atualizando o timestamp correspondente dentro do token. Ao AWS WAF inspecionar o token em busca de desafio ou CAPTCHA, ele subtrai o timestamp da hora atual. Se o resultado for maior que o tempo de imunidade configurado, o timestamp expirará. 

**Aspectos configuráveis dos tempos de imunidade de AWS WAF tokens**

Você pode configurar os tempos de imunidade a desafio e CAPTCHA no pacote de proteção (ACL da Web) e também em qualquer regra que use a ação da regra CAPTCHA ou Challenge. 
+ A configuração padrão de pacote de proteção (ACL da Web) para ambos os tempos de imunidade é de 300 segundos. 
+ Você pode especificar o tempo de imunidade para qualquer regra que use a ação CAPTCHA ou Challenge. Se você não especificar o tempo de imunidade para a regra, ela herdará a configuração do pacote de proteção (ACL da Web). 
+ Para uma regra em um grupo de regras que usa a ação CAPTCHA ou Challenge, se você não especificar o tempo de imunidade para a regra, ela herdará a configuração de cada pacote de proteção (ACL da Web) em que você usa o grupo de regras.
+ A integração do aplicativo SDKs usa o tempo de imunidade ao desafio do pacote de proteção (web ACL). 
+ O valor mínimo do tempo limite do desafio de imunidade é 300 segundos. O valor mínimo do tempo limite do CAPTCHA de imunidade é 60 segundos. O valor máximo para ambos os tempos de imunidade é de 259.200 segundos ou três dias. 

Você pode usar o pacote de proteção (ACL da Web) e as configurações de tempo de imunidade de nível da regra para ajustar a ação CAPTCHA, Challenge ou o comportamento de gerenciamento de desafios do SDK. Por exemplo, você pode configurar regras que controlam o acesso a dados altamente confidenciais com baixos tempos de imunidade e, em seguida, definir tempos de imunidade mais altos em seu pacote de proteção (Web ACL) para suas outras regras e SDKs para herdar. 

Em particular para o CAPTCHA, resolver um quebra-cabeça pode degradar a experiência do seu cliente no site, portanto, ajustar o tempo de imunidade do CAPTCHA pode ajudá-lo a mitigar o impacto na experiência do cliente e, ao mesmo tempo, fornecer as proteções desejadas. 

Para obter informações adicionais sobre como ajustar os tempos de imunidade para o uso das ações de regra Challenge e CAPTCHA, consulte [Práticas recomendadas para usar as ações CAPTCHA e Challenge](waf-captcha-and-challenge-best-practices.md).

# Onde definir os tempos de imunidade do AWS WAF token
<a name="waf-tokens-immunity-times-setting"></a>

Você pode definir os tempos de imunidade no pacote de proteção (ACL da Web) e nas regras que usam as ações de regra Challenge e CAPTCHA. 

Para obter informações gerais sobre o gerenciamento de um pacote de proteção (ACL da Web) e suas regras, consulte [Visualizando métricas de tráfego da web em AWS WAF](web-acl-working-with.md).

**Onde definir o tempo de imunidade para um pacote de proteção (ACL da Web)**
+ **Console**: ao editar o pacote de proteção (ACL da Web) na guia **Regras**, edite e altere as configurações nos painéis **Configuração de CAPTCHA do pacote de proteção (ACL da Web)** e **Configuração de desafio do pacote de proteção (ACL da Web)**. No console, você pode configurar o CAPTCHA do pacote de proteção (ACL da Web) e os tempos de imunidade a desafios somente depois de criar o pacote de proteção (ACL da Web).
+ **Fora do console**: o tipo de dados do pacote de proteção (ACL da Web) tem parâmetros de configuração de CAPTCHA e desafio que você pode configurar e fornecer às suas operações de criação e atualização no pacote de proteção (ACL da Web). 

**Onde definir o tempo de imunidade para uma regra**
+ **Console**: ao criar ou editar uma regra e especificar a ação CAPTCHA ou Challenge, você pode modificar a configuração do tempo de imunidade da regra. 
+ **Fora do console**: o tipo de dados da regra tem parâmetros de configuração de CAPTCHA e desafio, que você pode configurar ao definir a regra. 

# Especificando domínios de token e listas de domínios em AWS WAF
<a name="waf-tokens-domains"></a>

Esta seção explica como configurar os domínios que são AWS WAF usados em tokens e que são aceitos em tokens.

Ao AWS WAF criar um token para um cliente, ele o configura com um domínio de token. Quando o AWS WAF inspeciona um token em uma solicitação da Web, ele rejeitará o token como inválido se o domínio não corresponder a nenhum dos domínios considerados válidos para o pacote de proteção (ACL da Web). 

Por padrão, AWS WAF só aceita tokens cuja configuração de domínio corresponda exatamente ao domínio host do recurso associado ao pacote de proteção (Web ACL). Esse é o valor do cabeçalho `Host` na solicitação da web. Em um navegador, você pode encontrar esse domínio na JavaScript `window.location.hostname` propriedade e no endereço que o usuário vê na barra de endereço. 

Você também pode especificar domínios de token aceitáveis na configuração do pacote de proteção (ACL da Web), conforme descrito na próxima seção. Nesse caso, AWS WAF aceita correspondências exatas com o cabeçalho do host e correspondências com domínios na lista de domínios do token.

Você pode especificar domínios de token AWS WAF a serem usados ao definir o domínio e ao avaliar um token em um pacote de proteção (Web ACL). Os domínios que você especifica não podem ser sufixos públicos, como `gov.au`. Para os domínios que você não pode usar, consulte a lista [https://publicsuffix.org/list/public_suffix_list.dat](https://publicsuffix.org/list/public_suffix_list.dat) em [Lista pública de sufixos](https://publicsuffix.org/list/).

## AWS WAF configuração da lista de domínios de token do pacote de proteção (web ACL)
<a name="waf-tokens-domain-lists"></a>

Você pode configurar um pacote de proteção (web ACL) para compartilhar tokens em vários recursos protegidos fornecendo uma lista de domínios de tokens com os domínios adicionais que você AWS WAF deseja aceitar. Com uma lista de domínios de token, AWS WAF ainda aceita o domínio host do recurso. Além disso, ele aceita todos os domínios da lista de domínios de tokens, incluindo seus subdomínios prefixados. 

Por exemplo, uma especificação de domínio `example.com` na sua lista de domínios de tokens corresponde a `example.com` (de `http://example.com/`), `api.example.com`, (de `http://api.example.com/`) e `www.example.com` (de `http://www.example.com/`). Não corresponde a `example.api.com`, (de `http://example.api.com/`) ou `apiexample.com` (de `http://apiexample.com/`).

Você pode configurar a lista de domínios de tokens no pacote de proteção (ACL da Web) ao criá-lo ou editá-lo. Para obter informações gerais sobre como gerenciar um pacote de proteção (ACL da Web), consulte [Visualizando métricas de tráfego da web em AWS WAF](web-acl-working-with.md).

## AWS WAF configurações de domínio de token
<a name="waf-tokens-domain-in-token"></a>

AWS WAF cria tokens a pedido dos scripts de desafio, que são executados pela integração do aplicativo SDKs Challenge e pelas ações da CAPTCHA regra. 

O domínio AWS WAF definido em um token é determinado pelo tipo de script de desafio que o está solicitando e por qualquer configuração adicional de domínio de token fornecida por você. AWS WAF define o domínio no token para a configuração mais curta e geral que ele pode encontrar na configuração.
+ **JavaScript SDK** — Você pode configurar o JavaScript SDK com uma especificação de domínio de token, que pode incluir um ou mais domínios. Os domínios que você configura devem ser domínios que AWS WAF serão aceitos, com base no domínio do host protegido e na lista de domínios de token do pacote de proteção (web ACL). 

  Quando AWS WAF emite um token para o cliente, ele define o domínio do token como um que corresponda ao domínio do host e seja o mais curto, entre o domínio do host e os domínios na sua lista configurada. Por exemplo, se o domínio do host for `api.example.com` e a lista de domínios do token tiver`example.com`, AWS WAF use `example.com` o token, porque ele corresponde ao domínio do host e é mais curto. Se você não fornecer uma lista de domínios de token na configuração da JavaScript API, AWS WAF defina o domínio como o domínio host do recurso protegido.

  Para obter mais informações, consulte [Fornecimento de domínios para uso nos tokens](waf-js-challenge-api-set-token-domain.md). 
+ **SDK móvel**: no código do seu aplicativo, você deve configurar o SDK móvel com uma propriedade de domínio de token. Essa propriedade deve ser um domínio que o AWS WAF aceite, com base no domínio do host protegido e na lista de domínios de tokens do pacote de proteção (ACL da Web). 

  Ao AWS WAF emitir um token para o cliente, ele usa essa propriedade como domínio do token. AWS WAF não usa o domínio host nos tokens que ele emite para o cliente SDK móvel. 

  Para saber mais, consulte a configuração `WAFConfiguration` de `domainName` em [AWS WAF especificação de SDK móvel](waf-mobile-sdk-specification.md). 
+ **Challengeação** — Se você especificar uma lista de domínios de token no pacote de proteção (Web ACL), AWS WAF definirá o domínio de token como aquele que corresponda ao domínio do host e seja o mais curto, entre o domínio do host e os domínios da lista. Por exemplo, se o domínio do host for `api.example.com` e a lista de domínios do token tiver`example.com`, AWS WAF use `example.com` o token, porque ele corresponde ao domínio do host e é mais curto. Se você não fornecer uma lista de domínios de token no pacote de proteção (Web ACL), AWS WAF defina o domínio como o domínio host do recurso protegido. 

# Tipos de rótulos simbólicos em AWS WAF
<a name="waf-tokens-labeling"></a>

Esta seção descreve os rótulos que o gerenciamento de AWS WAF tokens adiciona às solicitações da web. Para obter informações gerais sobre rótulos, consulte [Rotulagem de solicitações da Web em AWS WAF](waf-labels.md).

Quando você usa qualquer um dos grupos de regras gerenciados por AWS WAF bots ou controle de fraudes, os grupos de regras usam o gerenciamento de AWS WAF tokens para inspecionar os tokens de solicitação da web e aplicar a rotulagem de tokens às solicitações. Para obter informações sobre os grupos de regras gerenciadas, consulte [AWS WAF Grupo de regras de prevenção de fraudes (ACFP) para criação de contas de controle de fraudes](aws-managed-rule-groups-acfp.md), [AWS WAF Grupo de regras de prevenção de aquisição de contas (ATP) de controle de fraudes](aws-managed-rule-groups-atp.md) e [AWS WAF Grupo de regras do Bot Control](aws-managed-rule-groups-bot.md).

**nota**  
AWS WAF aplica rótulos de token somente quando você usa um desses grupos de regras gerenciadas de mitigação inteligente de ameaças. 

O gerenciamento de token pode adicionar os rótulos apresentados a seguir às solicitações da Web.

**Rótulo de sessão do cliente**  
O rótulo `awswaf:managed:token:id:identifier` contém um identificador exclusivo que o gerenciamento de AWS WAF tokens usa para identificar a sessão do cliente. O identificador pode ser alterado se o cliente adquirir um novo token, por exemplo, após descartar o token que estava usando. 

**nota**  
AWS WAF não relata CloudWatch métricas da Amazon para esse rótulo.

**Impressão digital do navegador**  
O rótulo `awswaf:managed:token:fingerprint:fingerprint-identifier` contém um identificador robusto de impressão digital do navegador que o gerenciamento de AWS WAF tokens calcula a partir de vários sinais do navegador do cliente. Esse identificador permanece o mesmo em várias tentativas de obtenção de tokens. O identificador de impressão digital não é específico de um único cliente.

**nota**  
AWS WAF não relata CloudWatch métricas da Amazon para esse rótulo.

**Rótulos de status do token: prefixos de namespace para os rótulos**  
Os rótulos de status do token informam sobre o status do token e sobre as informações de desafio e de CAPTCHA que ele contém. 

Cada rótulo de status do token começa com um dos seguintes prefixos de namespace: 
+ `awswaf:managed:token:`: usado para relatar o status geral do token e para informar o status das informações de desafio do token. 
+ `awswaf:managed:captcha:`: usado para relatar o status das informações de CAPTCHA do token. 

**Rótulos de status do token: nomes de rótulos**  
Na sequência do prefixo, o restante do rótulo fornece informações detalhadas sobre o status do token: 
+ `accepted`: o token de solicitação está presente e contém o seguinte: 
  + Uma solução de desafio ou de CAPTCHA válida.
  + Um carimbo de data/hora de desafio ou de CAPTCHA não expirado.
  + Uma especificação de domínio válida para o pacote de proteção (ACL da Web). 

  Exemplo: o rótulo `awswaf:managed:token:accepted` indica que o token de solicitações da Web tem uma solução de desafio válida, um carimbo de data/hora de desafio não expirado e um domínio válido.
+ `rejected`: o token de solicitação está presente, mas não atende aos critérios de aceitação. 

  Em conjunto com o rótulo rejeitado, o gerenciamento de token adiciona um namespace e um nome de rótulo personalizado para indicar o motivo. 
  + `rejected:not_solved`: a solução de desafio ou de CAPTCHA está ausente no token. 
  + `rejected:expired`: o timestamp de desafio ou de CAPTCHA do token expirou, de acordo com os tempos de imunidade de token configurados do pacote de proteção (ACL da Web). 
  + `rejected:domain_mismatch`: o domínio do token não corresponde à configuração de domínio do token do pacote de proteção (ACL da Web). 
  + `rejected:invalid`— não AWS WAF consegui ler o token indicado. 

  Exemplo: os rótulos `awswaf:managed:captcha:rejected` e `awswaf:managed:captcha:rejected:expired` juntos indicam que a solicitação não tinha uma solução de CAPTCHA válida porque o timestamp do CAPTCHA no token excedeu o tempo de imunidade de token de CAPTCHA configurado no pacote de proteção (ACL da Web).
+ `absent`: a solicitação não tem o token ou o gerenciador de token não conseguiu realizar a leitura dele. 

  Exemplo: o rótulo `awswaf:managed:captcha:absent` indica que a solicitação não tem o token. 

# Bloqueio de solicitações que não têm um AWS WAF token válido
<a name="waf-tokens-block-missing-tokens"></a>

Esta seção explica como bloquear solicitações de login que não têm seus tokens ao usar o SDK AWS WAF móvel.

Quando você usa os grupos de regras AWS gerenciadas de ameaças inteligentes`AWSManagedRulesACFPRuleSet`, e `AWSManagedRulesATPRuleSet``AWSManagedRulesBotControlRuleSet`, os grupos de regras invocam o gerenciamento de AWS WAF tokens para avaliar o status do token de solicitação da web e rotular as solicitações adequadamente. 

**nota**  
A rotulagem de token é aplicada somente às solicitações da web que você avalia usando um desses grupos de regras gerenciadas.

Para obter informações sobre a rotulagem que o gerenciamento de token aplica, consulte a seção anterior, [Tipos de rótulos simbólicos em AWS WAF](waf-tokens-labeling.md). 

Os grupos de regras gerenciadas de mitigação de ameaças inteligentes, então, lidam com os requisitos de token da seguinte forma:
+ A regra `AllRequests` de `AWSManagedRulesACFPRuleSet` está configurada para executar a ação Challenge em todas as solicitações, bloqueando efetivamente qualquer uma que não tenha o rótulo de token `accepted`. 
+ O `AWSManagedRulesATPRuleSet` bloqueia as solicitações que têm o rótulo de token `rejected`, mas não bloqueia as solicitações com o rótulo de token `absent`. 
+ O nível de proteção direcionada do `AWSManagedRulesBotControlRuleSet` desafia os clientes depois que eles enviam cinco solicitações sem um rótulo de token `accepted`. Ele não bloqueia uma solicitação individual que não tenha um token válido. O nível de proteção comum do grupo de regras não gerencia os requisitos de token. 

Para obter detalhes adicionais sobre os grupos de regras de ameaças inteligentes, consulte [AWS WAF Grupo de regras de prevenção de fraudes (ACFP) para criação de contas de controle de fraudes](aws-managed-rule-groups-acfp.md), [AWS WAF Grupo de regras de prevenção de aquisição de contas (ATP) de controle de fraudes](aws-managed-rule-groups-atp.md) e [AWS WAF Grupo de regras do Bot Control](aws-managed-rule-groups-bot.md). 

**Para bloquear solicitações sem tokens ao usar o grupo de regras gerenciadas do Controle de Bots ou do ATP**  
Com os grupos de regras do Controle de Bots e do ATP, é possível que uma solicitação sem um token válido saia da avaliação do grupo de regras e continue sendo avaliada pelo pacote de proteção (ACL da Web). 

Para bloquear todas as solicitações sem token ou cujo token foi rejeitado, adicione uma regra a ser executada imediatamente após o grupo de regras gerenciadas para capturar e bloquear solicitações que o grupo de regras não processa para você. 

O exemplo a seguir é uma listagem JSON para um pacote de proteção (ACL da Web) que usa o grupo de regras gerenciadas do ATP. O pacote de proteção (ACL da Web) tem uma regra adicional para capturar o rótulo `awswaf:managed:token:absent` e processá-lo. A regra restringe sua avaliação às solicitações da web que vão para o endpoint de login, de acordo com o escopo do grupo de regras do ATP. A regra adicionada está listada em negrito. 

```
{
  "Name": "exampleWebACL",
  "Id": "55555555-6666-7777-8888-999999999999",
  "ARN": "arn:aws:wafv2:us-east-1:111111111111:regional/webacl/exampleWebACL/55555555-4444-3333-2222-111111111111",
  "DefaultAction": {
    "Allow": {}
  },
  "Description": "",
  "Rules": [
    {
      "Name": "AWS-AWSManagedRulesATPRuleSet",
      "Priority": 1,
      "Statement": {
        "ManagedRuleGroupStatement": {
          "VendorName": "AWS",
          "Name": "AWSManagedRulesATPRuleSet",
          "ManagedRuleGroupConfigs": [
            {
              "AWSManagedRulesATPRuleSet": {
                "LoginPath": "/web/login",
                "RequestInspection": {
                  "PayloadType": "JSON",
                  "UsernameField": {
                    "Identifier": "/form/username"
                  },
                  "PasswordField": {
                    "Identifier": "/form/password"
                  }
                },
                "ResponseInspection": {
                  "StatusCode": {
                    "SuccessCodes": [
                      200
                    ],
                    "FailureCodes": [
                      401,
                      403,
                      500
                    ]
                  }
                }
              }  
            }
          ]
        }
      },
      "OverrideAction": {
        "None": {}
      },
      "VisibilityConfig": {
        "SampledRequestsEnabled": true,
        "CloudWatchMetricsEnabled": true,
        "MetricName": "AWS-AWSManagedRulesATPRuleSet"
      }
    },
    {
      "Name": "RequireTokenForLogins",
      "Priority": 2,
      "Statement": {
        "AndStatement": {
          "Statements": [
            {
              "Statement": {
                "LabelMatchStatement": {
                  "Scope": "LABEL",
                  "Key": "awswaf:managed:token:absent"
                }
              }
            },
            {
              "ByteMatchStatement": {
                "SearchString": "/web/login",
                "FieldToMatch": {
                  "UriPath": {}
                },
                "TextTransformations": [
                  {
                    "Priority": 0,
                    "Type": "NONE"
                 }
                ],
                "PositionalConstraint": "STARTS_WITH"
              }
            },
            {
              "ByteMatchStatement": {
                "SearchString": "POST",
                "FieldToMatch": {
                  "Method": {}
                },
                "TextTransformations": [
                  {
                    "Priority": 0,
                    "Type": "NONE"
                  }
                ],
                "PositionalConstraint": "EXACTLY"
              }
            }
          ]
        }
      },
      "Action": {
        "Block": {}
      },
      "VisibilityConfig": {
        "SampledRequestsEnabled": true,
        "CloudWatchMetricsEnabled": true,
        "MetricName": "RequireTokenForLogins"
      } 
    }
  ],
  "VisibilityConfig": {
    "SampledRequestsEnabled": true,
    "CloudWatchMetricsEnabled": true,
    "MetricName": "exampleWebACL"
  },
  "Capacity": 51,
  "ManagedByFirewallManager": false,
  "RetrofittedByFirewallManager": false,
  "LabelNamespace": "awswaf:111111111111:webacl:exampleWebACL:"
}
```

# Configuração necessária para balanceadores de carga de aplicativos que são origens CloudFront
<a name="waf-tokens-with-alb-and-cf"></a>

Leia esta seção se você associar seu pacote de proteção (web ACL) a um Application Load Balancer e implantar o Application Load Balancer como origem de uma distribuição. CloudFront 

Com essa arquitetura, você precisa fornecer a seguinte configuração adicional para que as informações do token sejam tratadas corretamente.
+ Configure CloudFront para encaminhar o `aws-waf-token` cookie para o Application Load Balancer. Por padrão, CloudFront remove os cookies da solicitação da web antes de encaminhá-la para a origem. Para manter o cookie de token com a solicitação da web, configure o comportamento CloudFront do cache para incluir apenas o cookie de token ou todos os cookies. Para obter informações sobre como fazer isso, consulte Armazenamento em [cache de conteúdo com base em cookies no](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/Cookies.html) *Amazon CloudFront Developer Guide*.
+ Configure AWS WAF para que ele reconheça o domínio da CloudFront distribuição como um domínio de token válido. Por padrão, CloudFront define o `Host` cabeçalho como a origem do Application Load Balancer e a AWS WAF usa como o domínio do recurso protegido. O navegador do cliente, no entanto, vê a CloudFront distribuição como o domínio do host, e os tokens gerados para o cliente usam o CloudFront domínio como o domínio do token. Sem nenhuma configuração adicional, ao AWS WAF verificar o domínio do recurso protegido em relação ao domínio do token, haverá uma incompatibilidade. Para corrigir isso, adicione o nome do domínio de CloudFront distribuição à lista de domínios do token na configuração do pacote de proteção (Web ACL). Para obter informações sobre como fazer isso, consulte [AWS WAF configuração da lista de domínios de token do pacote de proteção (web ACL)](waf-tokens-domains.md#waf-tokens-domain-lists).