Criar e visualizar regras de política de segurança do Cloud Armor

Cada regra de política de segurança do Google Cloud Armor tem uma prioridade, uma condição de correspondência e uma ação. O Cloud Armor executa a ação da regra de maior prioridade que corresponde a uma solicitação. As regras com prioridade menor do que a regra de correspondência de maior prioridade não são avaliadas, mesmo que tenham as mesmas condições de correspondência.

Cada regra de política de segurança aceita dois tipos de condições de correspondência:

• Uma condição de correspondência básica contém listas de endereços IP ou de intervalos de endereços IP. As condições básicas de correspondência são definidas usando a flag --src-ip-ranges ao criar uma regra com a CLI do Google Cloud.
• Uma condição de correspondência avançada contém uma expressão com até cinco subexpressões que podem corresponder a diversos atributos de uma solicitação recebida. As condições de correspondência avançada são definidas usando a flag --expression ao criar uma regra com a CLI do Google Cloud.

Nesta página, descrevemos como criar e visualizar regras de políticas de segurança e fornecemos a referência para a linguagem de regras personalizadas do Cloud Armor, usada para escrever expressões em condições de correspondência avançadas. A linguagem de regras personalizadas do Cloud Armor é um subconjunto da Common Expression Language (CEL).

As expressões escritas na linguagem de regras personalizadas do Cloud Armor precisam de dois componentes:

• O atributo: os dados a serem inspecionados
• A operação: como usar os dados

Por exemplo, a expressão a seguir usa os atributos origin.ip e 198.51.100.0/24 na operação inIpRange. Nesse caso, a expressão retornará true se origin.ip estiver dentro do intervalo de endereços IP de 198.51.100.0/24.

inIpRange(origin.ip, '198.51.100.0/24')

Mesmo que a expressão do exemplo anterior corresponda apenas ao endereço IP do cliente, ao usá-la em uma regra de política de segurança do Cloud Armor, essa regra seria considerada em uma condição de correspondência avançada pela perspectiva de cotas. Para mais informações, consulte Cotas e limites do Cloud Armor.

Criar regras de política de segurança

Siga as etapas nesta seção para adicionar regras a uma política de segurança do Cloud Armor.

Console

1. No console do Google Cloud , acesse a página Políticas do Cloud Armor.

   Acessar as políticas do Cloud Armor

2. Clique no nome da política de segurança para abrir a página Detalhes da política e, em seguida, clique na guia Regras.

3. Clique em Adicionar regra.

4. Opcional: digite uma descrição para o caso.

5. Selecione o modo:

   • Modo básico: permite ou nega tráfego com base em endereços IP ou intervalos de IP.
   • Modo avançado: permite ou nega tráfego com base em expressões de regra.

6. No campo Correspondência, especifique as condições para aplicar a regra.

   • Modo básico: insira de 1 a 10 intervalos de endereços IP para que correspondam à regra. Você pode adicionar até 10 intervalos de endereços IP. Consulte os limites em Cotas e limites do Cloud Armor.

   • Modo avançado:

     • Criador de condições de correspondência (pré-lançamento): use o criador visual para criar expressões sem escrever código CEL bruto. Combine e agrupe condições e aplique transformações de string. Consulte Usar o criador de condições de correspondência.
     • Editor de condições de correspondência: insira uma expressão a ser avaliada em relação às solicitações recebidas. Para mais informações, consulte Operações e Atributos.

7. Na lista Ação, selecione Permitir ou Negar.

8. Se você estiver configurando uma regra de negação, selecione um código de resposta na lista Código de resposta.

9. Para ativar o modo de visualização da regra, selecione Ativar.

10. No campo Prioridade, insira um número inteiro de 0 a 2.147.483.646. O Cloud Armor avalia as regras em ordem de prioridade, de 0 (mais alta) a 2.147.483.647 (mais baixa). A regra padrão tem uma prioridade de 2.147.483.647.

11. Clique em Adicionar.

gcloud

Use o comando gcloud compute security-policies rules create PRIORITY. Substitua PRIORITY pela prioridade da regra na política:

gcloud compute security-policies rules create PRIORITY \
    --security-policy POLICY_NAME \
    --description DESCRIPTION \
    --src-ip-ranges IP_RANGES | --expression EXPRESSION \
    --action=[ allow | deny-403 | deny-404 | deny-502 ] \
    --preview

Por exemplo, o comando a seguir adiciona uma regra com prioridade 1.000 para bloquear o tráfego dos intervalos de endereços IP 192.0.2.0/24 e 198.51.100.0/24:

gcloud compute security-policies rules create 1000 \
    --security-policy my-policy \
    --description "block traffic from 192.0.2.0/24 and 198.51.100.0/24" \
    --src-ip-ranges "192.0.2.0/24","198.51.100.0/24" \
    --action "deny-403"

Use a flag --expression para especificar uma condição. O comando a seguir adiciona uma regra para permitir o tráfego do endereço IP 1.2.3.4 que contém a string example no cabeçalho User-Agent:

gcloud compute security-policies rules create 1000 \
    --security-policy my-policy \
    --expression "inIpRange(origin.ip, '1.2.3.4/32') && has(request.headers['user-agent']) && request.headers['user-agent'].contains('example')" \
    --action allow \
    --description "Block User-Agent 'example'"

O comando a seguir adiciona uma regra para bloquear solicitações se o cookie da solicitação contiver um valor específico:

gcloud compute security-policies rules create 1000 \
    --security-policy my-policy \
    --expression "has(request.headers['cookie']) && request.headers['cookie'].contains('80=SomeValue')" \
    --action deny-403 \
    --description "Cookie Block"

O comando a seguir adiciona uma regra para bloquear solicitações da região AU:

gcloud compute security-policies rules create 1000 \
    --security-policy my-policy \
    --expression "origin.region_code == 'AU'" \
    --action deny-403 \
    --description "AU block"

O comando a seguir adiciona uma regra para bloquear solicitações da região AU e não no intervalo de IP especificado:

gcloud compute security-policies rules create 1000 \
    --security-policy my-policy \
    --expression "origin.region_code == \"AU\" && !inIpRange(origin.ip, '1.2.3.0/24')" \
    --action deny-403 \
    --description "country and IP block"

O comando a seguir adiciona uma regra para bloquear solicitações com um URI que corresponda a uma expressão regular:

gcloud compute security-policies rules create 1000 \
    --security-policy my-policy \
    --expression "request.path.matches('/example_path/')" \
    --action deny-502 \
    --description "regex block"

O comando a seguir adiciona uma regra para bloquear solicitações se o valor decodificado em Base64 do cabeçalho user-id contiver um valor específico:

gcloud compute security-policies rules create 1000 \
    --security-policy my-policy \
    --expression "has(request.headers['user-id']) && request.headers['user-id'].base64Decode().contains('myValue')" \
    --action deny-403 \
    --description "country and IP block"

O comando a seguir adiciona uma regra que usa um conjunto de expressões pré-configuradas do conjunto de regras principais (CRS, na sigla em inglês) 4.22 do OWASP para mitigar ataques de injeção de SQL (SQLi):

gcloud compute security-policies rules create 1000 \
    --security-policy my-policy \
    --expression "evaluatePreconfiguredWaf('sqli-v422-stable')" \
    --action deny-403

Usar o criador de condições de correspondência

Visualizar

Este produto ou recurso está sujeito aos Termos das Soluções Pré-GA na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os produtos e recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

O criador de condições de correspondência é uma interface visual no console do Google Cloud que ajuda a criar expressões de regra complexas do Cloud Armor sem escrever código da Common Expression Language (CEL). Em vez de escrever código, use a UI estruturada do criador para combinar condições e lógica de grupo, o que pode ajudar a evitar erros de sintaxe e visualizar melhor a estrutura da regra. O criador aceita listas simples e lógica aninhada com até cinco níveis de expressões. Use essa ferramenta ao configurar regras para ajudar a proteger back-ends multicloud ou implantações híbridas, em que pode ser necessário inspecionar atributos de solicitação específicos antes de rotear o tráfego.

Recursos do criador de condições de correspondência

O criador de condições de correspondência inclui os seguintes recursos:

• Lógica e aninhamento: combine várias condições usando os operadores AND e OR. O builder permite agrupar e aninhar até cinco expressões.
• Transformações de string: para atributos baseados em string (como request.path ou request.headers), aplique transformações para normalizar os dados antes da avaliação. As transformações compatíveis incluem:
  • Letras minúsculas e maiúsculas
  • Decodificação Base 64
  • Decodificação de URL e Decodificação de URL (Unicode)
  • Conversão de UTF-8 em Unicode
• Análise bidirecional: alterne entre o criador de condições de correspondência visual e o editor de condições de correspondência de texto bruto. A interface analisa automaticamente o código CEL bruto em blocos visuais.
• Suporte a funções: o builder oferece controles UI para expressões baseadas em funções, como regras de WAF pré-configuradas, grupos de endereços e inteligência contra ameaças.

Limitações

O criador de condições de correspondência é a interface padrão para a criação de regras avançadas. Se uma expressão tiver uma lógica incompatível (como macros desconhecidas), o criador será desativado. Nesses casos, use o texto bruto no editor de condições de correspondência para editar a regra.

Além disso, a disponibilidade de determinadas expressões no builder depende do nível do Google Cloud Armor Enterprise do seu projeto e do tipo de política de segurança.

Exemplos de expressões

Veja a seguir expressões de exemplo. Para mais informações sobre operações e atributos compatíveis, consulte Operações e Atributos.

Se a regra ou expressão usar códigos de país ou região ISO 3166-1 alfa-2, o Cloud Armor vai tratar cada código de maneira independente. As regras e expressões do Cloud Armor usam esses códigos para permitir ou negar solicitações.

• A expressão a seguir corresponde a solicitações do endereço IP 1.2.3.4 que contêm a string example no cabeçalho User-Agent:

  inIpRange(origin.ip, '1.2.3.4/32') && has(request.headers['user-agent']) && request.headers['user-agent'].contains('example')
  

  Como alternativa, faça a correspondência com o intervalo de endereços IP de um cabeçalho de endereço IP do cliente personalizado usando o atributo origin.user_ip:

  inIpRange(origin.user_ip, '1.2.3.4/32') && has(request.headers['user-agent']) && request.headers['user-agent'].contains('example')
  

• A expressão a seguir corresponde a solicitações que têm um cookie com um valor específico:

  has(request.headers['cookie']) && request.headers['cookie'].contains('cookie_name=cookie_value')
  

• A expressão a seguir corresponde a solicitações da região AU:

  origin.region_code == 'AU'
  

• A expressão a seguir corresponde a solicitações da região AU que não estão no intervalo de IP especificado:

  origin.region_code == "AU" && !inIpRange(origin.ip, '1.2.3.0/24')
  

• A expressão a seguir corresponde a solicitações com um caminho de variável numerada para um arquivo específico caso o URI corresponda a uma expressão regular:

  request.path.matches('/path/[0-9]+/target_file.html')
  

• A expressão a seguir faz a correspondência com solicitações se o valor decodificado em Base64 do cabeçalho user-id contiver um valor específico:

  has(request.headers['user-id']) && request.headers['user-id'].base64Decode().contains('myValue')
  

• A expressão a seguir usa um conjunto de expressões pré-configuradas do conjunto de regras OWASP CRS 4.22 para corresponder a ataques SQLi:

  evaluatePreconfiguredWaf('sqli-v422-stable')
  

Travessia e normalização de caminhos

Normalize o conteúdo nas regras baseadas em caminho para gerenciar as regras de codificação e travessia de caminho e criar regras generalizadas que evitem a capitalização ou a codificação específica de conteúdo.

Ao escrever regras que usam startsWith, endsWith ou contains para corresponder a request.path, use lower e urlDecode para normalizar o caminho antes da correspondência. Isso ajuda a evitar desvios que usam codificação de URL ou variações de maiúsculas e minúsculas.

Por exemplo, para bloquear o acesso ao diretório /admin, use a seguinte expressão:

request.path.lower().urlDecode().startsWith('/admin')

Essa regra bloqueia solicitações de /admin, /Admin, /a%64min e outras variações.

Ao escrever regras que usam matches para corresponder a request.path, considere o caractere de barra invertida (\) na expressão regular.

Por exemplo, para bloquear o acesso ao diretório /admin, use a seguinte expressão para bloquear desvios que usam o caractere de barra invertida (\):

request.path.matches(r'^/\\*admin')

Combine isso com urlDecode para lidar com a codificação de URL e as omissões do caractere de barra invertida (\):

request.path.urlDecode().matches(r'^/\\*admin')

Ver regras da política de segurança

As seções a seguir descrevem como listar as regras configuradas em uma política de segurança e visualizar as regras de WAF pré-configuradas disponíveis.

Listar as regras em uma política de segurança

Siga as etapas nesta seção para listar as regras em uma política de segurança do Cloud Armor.

Console

1. No console do Google Cloud , acesse a página Políticas do Cloud Armor.

   Acessar as políticas do Cloud Armor

2. Clique no nome da política de segurança específica. A página Detalhes da política mostra as regras da política na guia Regras.

gcloud

Use o seguinte comando gcloud para listar todas as regras em uma política de segurança:

gcloud compute security-policies describe NAME

Use o seguinte comando gcloud para listar todas as regras em uma única política de segurança em uma região especificada, junto com uma descrição da política:

gcloud compute security-policies describe NAME \
  --region REGION

Use o seguinte comando gcloud para descrever uma regra:

gcloud compute security-policies rules describe PRIORITY \
    --security-policy POLICY_NAME

Por exemplo, o comando a seguir descreve a regra com prioridade 1.000 na política de segurança my-policy:

gcloud compute security-policies rules describe 1000 \
    --security-policy my-policy

Saída:

action: deny(403)
description: block traffic from 192.0.2.0/24 and 198.51.100.0/24
kind: compute#securityPolicyRule
match:
  srcIpRanges:
  - '192.0.2.0/24'
  - '198.51.100.0/24'
preview: false
priority: 1000

Para ver mais informações, consulte gcloud compute security-policies describe.

Listar regras pré-configuradas disponíveis

Além das regras que você configura, o Cloud Armor oferece regras pré-configuradas que podem ser usadas nas suas políticas de segurança. É possível listar regras pré-configuradas para ver as assinaturas e as regras de proteção de aplicativos predefinidas, como o Conjunto de regras principais do OWASP (CRS, na sigla em inglês) fornecido pelo Cloud Armor. Essas regras contêm assinaturas integradas que o Cloud Armor avalia em relação às solicitações recebidas. Adicione essas regras pré-configuradas a regras novas ou atuais usando a linguagem de regras personalizadas. Recomendamos que você use a versão mais recente da regra do CRS sempre que possível.

gcloud

1. Execute o comando gcloud compute security-policies list-preconfigured-expression-sets:

   gcloud compute security-policies list-preconfigured-expression-sets
   

   O exemplo a seguir mostra o formato de saída do comando:

   EXPRESSION_SET
   expression-set-1
      RULE_ID                SENSITIVITY
      expression-set-1-id-1  sensitivity-value-1
      expression-set-1-id-2  sensitivity-value-2
   expression-set-2
      alias-1
      RULE_ID                SENSITIVITY
      expression-set-2-id-1  sensitivity-value-1
      expression-set-2-id-2  sensitivity-value-2
   

   O exemplo a seguir inclui uma amostra da saída real do comando. A saída real inclui todas as regras listadas em Como ajustar as regras de WAF do Cloud Armor.

   gcloud compute security-policies list-preconfigured-expression-sets
   

   EXPRESSION_SET
   sqli-canary
       RULE_ID                          SENSITIVITY
       owasp-crs-v042200-id942120-sqli  2
       …
   xss-canary
       RULE_ID                         SENSITIVITY
       owasp-crs-v042200-id941110-xss  1
       owasp-crs-v042200-id941120-xss  2
   …
   sourceiplist-fastly
   sourceiplist-cloudflare
   sourceiplist-imperva
   

Operações

A referência a seguir descreve os operadores que podem ser usados com atributos (representados por x, y e k) para definir expressões de regra.

Operações	Expressões	Descrição
Igualdade	x == y	Retornará true se x for igual a y.
Igualdade, literal de string	x == "foo"	Retorna true se x for igual ao literal de string constante fornecido.
Igualdade, literal de string bruta	x == R"fo'o"	Retorna true se x for igual à literal de string bruta fornecida que não interpreta sequências de escape. As literais de string bruta são convenientes para expressar strings que precisam usar caracteres de sequência de escape.
NOT lógico	!x	Retorna true se o valor booleano x for false ou retorna false se o valor booleano x for true.
Desigualdade	x != y	Retorna true se x não for igual a y.
Concatenação	x + y	Vai retornar a string concatenada xy.
AND lógico	x && y	Retorna true se x e y forem true.
OR lógico	x || y	Retorna true se x, y ou ambos forem true.
Contém a substring	x.contains(y)	Retorna true se a string x contiver a substring y.
Começa com a substring	x.startsWith(y)	Retorna true se a string x começar com a substring y.
Termina com a substring	x.endsWith(y)	Retorna true se a string x terminar com a substring y.
Correspondência de expressão regular	x.matches(y)	Retorna true se a string x corresponder parcialmente ao padrão RE2 especificado y. O padrão RE2 é compilado usando a opção RE2::Latin1 que desativa os recursos Unicode.
Endereço IP dentro do intervalo	inIpRange(x, y)	Retorna true se o endereço IP x estiver dentro do intervalo de IP y.
Letras minúsculas	x.lower()	Retorna o valor em minúsculas da string x.
Letras maiúsculas	x.upper()	Retorna o valor em maiúsculas da string x.
Valor decodificado em Base64	x.base64Decode()	Retorna o valor de x decodificado em Base64. O sublinhado (_) e o hífen (-) são substituídos primeiro pela barra (/) e pelo sinal de adição (+), respectivamente. Retorna "" (string vazia) se x não for um valor base64 válido.
Valor do mapa de atalhos	m['k']	Vai retornar o valor na chave k no mapa string a string m se k estiver disponível, caso contrário, vai retornar um erro. A abordagem recomendada é verificar a disponibilidade usando "has(m['k'])==true".
Verificar a disponibilidade de chaves em um mapa	has(m['k'])	Retorna true se a chave k estiver disponível no mapa m.
Converter para número inteiro	int(x)	Converte o resultado da string de x em um tipo int. Ele pode ser usado para fazer uma comparação de números inteiros usando operadores aritméticos padrão, como > e <=. Isso funciona apenas para valores que precisam ser inteiros.
Comprimento	size(x)	Retorna o comprimento da string x.
Decodificar URL	x.urlDecode()	Retorna o valor decodificado de URL de x. As sequências de caracteres no formato %## são substituídas por equivalentes não ASCII, e + é substituído por um espaço. As codificações inválidas retornam no estado em que se encontram.
Decodificar URL (Unicode)	x.urlDecodeUni()	Retorna o valor decodificado de URL de x. Além de urlDecode() e também processa sequências de caracteres Unicode no formato %u###. As codificações inválidas retornam no estado em que se encontram.
Converter utf8 em Unicode	x.utf8ToUnicode()	Retorna a representação Unicode de letras minúsculas de um x codificado em UTF-8.
Existe	m.exists(k, expr)	Retorna true se pelo menos uma entrada no mapa m satisfizer expr, em que k representa a chave de cada entrada do mapa. Observação: esse operador só funciona quando request.body ou request.params existe na expressão da regra.
Existe um	m.exists_one(k, expr)	Retorna true se exatamente uma entrada no mapa m satisfizer expr, em que k representa a chave de cada entrada do mapa. Observação: esse operador só funciona quando request.body ou request.params existe na expressão da regra.
Todos	m.all(k, expr)	Retorna true se todas as entradas no mapa m satisfizerem expr, em que k representa a chave de cada entrada do mapa. Observação: esse operador só funciona quando request.body ou request.params existe na expressão da regra.
Filtro	m.filter(k, expr)	Retorna um mapa que contém apenas as entradas do mapa m em que a entrada satisfaz expr, em que k representa a chave de cada entrada do mapa. Observação: esse operador só funciona quando request.body ou request.params existe na expressão da regra.
Mapa	m.map(k, expr)	Retorna uma lista que contém o resultado da avaliação de expr para cada chave no mapa m, em que k representa a chave de cada entrada do mapa. Observação: esse operador só funciona quando request.body ou request.params existe na expressão da regra.

Observação: a precedência dos operadores lógicos da CEL é NOT, AND e OR. Use parênteses para substituir essa ordem. Para mais informações, consulte Sintaxe.

Observação: os operadores de iteração de mapa (m.exists, m.exists_one, m.all, m.filter e m.map) só funcionam quando request.body ou request.params existem na expressão de regra.

Atributos

Os atributos representam informações de uma solicitação recebida, como o endereço IP do cliente ou o caminho do URL solicitado.

Campo	Tipo	Descrição do campo
origin.ip	string	O endereço IP do cliente que iniciou a solicitação.
origin.user_ip	string	O endereço IP do cliente de origem, incluído em HTTP-HEADER por um proxy upstream. Antes de usar esse atributo, configure a opção userIpRequestHeaders[] no campo advancedOptionsConfig da política de segurança para corresponder a uma origem como True-Client-IP, X-Forwarded-For ou X-Real-IP. Para mais informações, consulte Visão geral dos endereços IP do usuário. Se você não configurar a opção userIpRequestHeaders[], se o cabeçalho configurado contiver valores de endereço IP inválidos ou se o cabeçalho configurado não estiver presente, origin.user_ip assumirá origin.ip como padrão. Para obter mais informações, confira a referência do recurso securityPolicy.
origin.tls_ja4_fingerprint	string	Impressão digital TLS/SSL JA4 se o cliente se conectar usando HTTPS, HTTP/2 ou HTTP/3. Se não estiver disponível, uma string vazia será retornada.
origin.tls_ja3_fingerprint	string	Impressão digital TLS/SSL JA3 se o cliente se conectar usando HTTPS, HTTP/2 ou HTTP/3. Se não estiver disponível, uma string vazia será retornada.
request.headers	mapa	Um mapa com cada string dos cabeçalhos da solicitação HTTP. Se um cabeçalho tiver vários valores, o valor correspondente nesse mapa será uma única string que contém todos os valores, separados por vírgulas. As chaves deste mapa ficam todas em minúsculas. Os balanceadores de carga de aplicativo externos inspecionam todos os cabeçalhos aceitos, e as mesmas limitações de cabeçalho se aplicam. Use has() para verificar a disponibilidade, como has(request.headers['header-key']) && request.headers['header-key'] != 'header-value'. É possível iterar sobre o mapa para verificar as chaves e os valores. No entanto, só é possível usar operadores de iteração de mapa (exists(), exists_one(), all(), filter() e map()) em request.headers em combinação com request.body ou request.params na mesma expressão, por exemplo, request.body && request.headers.exists(k, k.lower().startsWith('header-prefix')).
request.body	string	Representa o corpo da solicitação como uma string bruta. Ele pode representar dados de qualquer Content-Type. Ele armazena o conteúdo como uma string sem nenhuma análise automática.
request.params	mapa	Um mapa de pares de chave-valor que são anexados ao URL ou incluídos no corpo das solicitações. Solicitação de URI: name1=value1&name2=value2 Corpo da solicitação JSON com Content-Type: application/json: { "username": "johndoe", "email": "[e-mail]" } Corpo da solicitação POST do GraphQL com Content-Type: application/graphql: { Username: "exampleUser", query: "/* other fields */" } Corpo da solicitação POST do formulário com Content-Type: application/x-www-form-urlencoded: "username=exampleUser&email=johndoe%40example.com"
request.method	string	O método de solicitação HTTP.
request.path	string	O caminho do URL HTTP solicitado. Ao escrever regras que correspondam a request.path, recomendamos que você normalize o caminho para facilitar a correspondência de sintaxe em caso de codificação de URL, variações de maiúsculas e minúsculas ou barras invertidas. Para mais informações e exemplos, consulte Travessia e normalização de caminho.
request.scheme	string	O esquema de URL HTTP, como http ou https. Os valores deste atributo ficam todos em minúsculas.
request.query	string	A consulta de URL HTTP no formato name1=value&name2=value2, conforme aparece na primeira linha da solicitação HTTP. Nenhuma decodificação é executada.
origin.region_code	string	O código do país em Unicode associado ao IP do cliente, como US. Se você estiver criando uma regra ou expressão que usa códigos de país ou região ISO 3166-1 Alfa 2, o Google Cloud Armor tratará cada código de maneira independente. As regras e expressões do Cloud Armor usam explicitamente esses códigos de região para permitir ou negar solicitações.
origin.asn	integer	O número de sistema autônomo (ASN, na sigla em inglês) associado ao endereço IP do cliente. O ASN globalmente exclusivo é determinado com base no operador de rede que aceita os prefixos de endereço IP que contêm o endereço IP do cliente.

Observação: as políticas de segurança de borda são compatíveis com a filtragem baseada apenas em origin.asn, origin.ip, origin.region_code, request.headers, request.method, request.path, request.query e request.scheme.

Atributos do reCAPTCHA

Nesta seção, listamos os atributos aplicáveis somente a tokens reCAPTCHA ou cookies de isenção do reCAPTCHA. Uma subexpressão com base nesses atributos retornará false se o token do reCAPTCHA ou o cookie de isenção a ser avaliado não estiver disponível ou for inválido por um dos seguintes motivos:

• O token é mal desenvolvido e não pode ser decodificado.
• O token contém atributos inválidos. Por exemplo, o token foi gerado usando uma chave do reCAPTCHA que não corresponde às chaves do reCAPTCHA associadas à regra.
• O token expirou.

Atributos de cookies de isenção

Campo	Tipo	Descrição do campo
token.recaptcha_exemption.valid	bool	Presença de um cookie de isenção reCAPTCHA válido.

Atributos de token de ação

Campo	Tipo	Descrição do campo
token.recaptcha_action.score	float	A pontuação de um token de ação reCAPTCHA. Uma pontuação válida varia de 0.0 a 1.0, sendo 0.0 um usuário muito ilegítimo e 1.0 muito legítimo.
token.recaptcha_action.captcha_status	string	O status do CAPTCHA de um token de ação reCAPTCHA. Um status válido é NONE, PASS ou FAIL, em que NONE se refere a quando não há desafios envolvidos durante o teste reCAPTCHA, de modo que o captcha esteja ausente no token de ação.
token.recaptcha_action.action	string	O nome da ação (até 100 caracteres) de um token de ação do reCAPTCHA. Consulte Nomes de ação.
token.recaptcha_action.valid	bool	A presença de um token de ação reCAPTCHA válido.

Atributos do token de sessão

Campo	Tipo	Descrição do campo
token.recaptcha_session.score	float	A pontuação de um token de sessão reCAPTCHA. Uma pontuação válida varia de 0.0 a 1.0, sendo 0.0 um usuário muito ilegítimo e 1.0 muito legítimo.
token.recaptcha_session.valid	bool	A presença de um token de sessão reCAPTCHA válido.

Exemplos de expressões

Para cada uma dessas expressões, a ação executada depende de a expressão estar incluída em uma regra de negação ou permissão.

Permitir ou negar acesso com base em um intervalo de endereços IP em IPv4 ou IPv6

• A expressão a seguir corresponde às solicitações do intervalo de endereços IP 198.51.100.0/24:

  inIpRange(origin.ip, '198.51.100.0/24')
  

• A expressão a seguir corresponde às solicitações do intervalo de endereços IP 2001:db8::/32:

  inIpRange(origin.ip, '2001:db8::/32')
  

Permitir ou negar acesso com base em um intervalo de endereços IP do cliente personalizados protegido por um proxy upstream

Se você tiver configurado o operador origin.user_ip, poderá fazer a correspondência com base nos valores de cabeçalho que foram especificados no campo advancedOptionsConfig.userIpRequestHeaders[].

• A seguinte expressão faz a correspondência com solicitações originadas do intervalo de endereços IP 192.0.2.0/24:

  inIpRange(origin.user_ip, '192.0.2.0/24')
  

• A seguinte expressão faz a correspondência com solicitações originadas do intervalo de endereços IP 2001:db8::/32:

  inIpRange(origin.user_ip, '2001:db8::/32')
  

Permitir ou negar tráfego com um cookie específico

• A expressão a seguir corresponde a solicitações que têm um cookie contendo 80=BLAH:

  has(request.headers['cookie']) && request.headers['cookie'].contains('80=BLAH')
  

Permitir ou negar tráfego com um cabeçalho referer não vazio

• A expressão a seguir corresponde a solicitações que têm um cabeçalho referer não vazio:

  has(request.headers['referer']) && request.headers['referer'] != ""
  

Permitir ou negar tráfego com base no cabeçalho do host

É possível permitir ou negar o tráfego com base no valor do cabeçalho Host na solicitação.

• A expressão a seguir corresponde a solicitações para um URL específico usando ==:

  request.headers['host'].lower() == 'test.example.com'
  

• A expressão a seguir corresponde a solicitações para um URL específico usando endsWith:

  request.headers['host'].lower().endsWith('.example.com')
  

• A expressão a seguir corresponde a solicitações para um URL específico usando contains:

  request.headers['host'].lower().contains('test.example.com')
  

Observação: use == quando quiser corresponder exatamente a um host específico e contains quando o host contiver uma substring específica. Use contains com cuidado, porque pode gerar correspondências não intencionais. Para mais informações, consulte Operações.

• A expressão a seguir corresponde a solicitações para vários domínios usando contains:

  request.headers['host'].lower().contains('test.example.com') || request.headers['host'].lower().contains('test22.example.com')
  

• A expressão a seguir corresponde a solicitações de um domínio e seus subdomínios usando matches:

  request.headers['host'].matches('(?i:(?:sub\.)?test\.example\.com)')
  

Permitir ou negar o tráfego de uma região específica

Se o aplicativo da web ainda não estiver disponível na região AU, todas as solicitações dessa região deverão ser bloqueadas.

• Em uma regra de negação, use a seguinte expressão, que corresponde a solicitações da região AU:

  origin.region_code == 'AU'
  

Como alternativa, se o aplicativo da Web estiver disponível apenas na região AU, as solicitações de todas as outras regiões precisarão ser bloqueadas.

• Em uma regra de negação, use a seguinte expressão, que corresponde a solicitações de todas as regiões diferentes da região AU:

  origin.region_code != 'AU'
  

Os códigos de região são baseados nos códigos ISO 3166-1 alpha 2. Em alguns casos, uma região corresponde a um país, mas nem sempre é o caso. Por exemplo, o código US inclui todos os estados dos Estados Unidos, um distrito e seis áreas remotas.

Permitir ou negar o tráfego de um ASN específico

Se o aplicativo da Web precisar ser bloqueado para clientes atendidos por um operador de rede específico, use o número ASN do operador de rede para bloquear.

• Em uma regra de negação, use a seguinte expressão, que corresponde às solicitações de um ASN específico:

  origin.asn == 123
  

Como alternativa, se o aplicativo da Web estiver apenas disponível para os clientes por trás de um operador de rede específico, as solicitações de todos os outros operadores de rede precisarão ser bloqueadas.

• Em uma regra de negação, use a seguinte expressão, que corresponde a todos os outros operadores de rede diferentes daquele que você está permitindo.

  origin.asn != 123
  

Várias expressões

Para incluir várias condições em apenas uma regra, combine várias subexpressões.

• No exemplo a seguir, solicitações de 1.2.3.0/24 (como seus testadores alfa) na região AU correspondem à seguinte expressão:

  origin.region_code == "AU" && inIpRange(origin.ip, '1.2.3.0/24')
  

• A expressão a seguir corresponde a solicitações de 1.2.3.4 em que um user agent contém a string WordPress:

  inIpRange(origin.ip, '1.2.3.4/32') &&
  has(request.headers['user-agent']) && request.headers['user-agent'].contains('WordPress')
  

Permitir ou negar tráfego para um URI de solicitação que corresponda a uma expressão regular

• A expressão a seguir corresponde a solicitações que contêm a string /example_path/ no URI:

  request.path.matches('/example_path/')
  

• A expressão a seguir corresponde a solicitações que têm Chrome no campo de cabeçalho User-Agent:

  request.headers['user-agent'].matches('Chrome')
  

• A expressão a seguir mostra uma correspondência que não diferencia maiúsculas de minúsculas para o cabeçalho User-Agent que contém wordpress; corresponde a User-Agent:WordPress/605.1.15, User-Agent:wordPress e outras variações de wordpress:

  request.headers['user-agent'].matches('(?i:wordpress)')
  

Permitir ou negar tráfego que contém um valor decodificado em Base64 específico

• A expressão a seguir corresponde a solicitações que têm um valor decodificado em Base64 de myValue para o cabeçalho user-id:

  has(request.headers['user-id']) && request.headers['user-id'].base64Decode().contains('myValue')
  

Permitir ou negar tráfego que contenha um valor de string de um comprimento específico

• A expressão a seguir corresponde a solicitações que têm um comprimento de URL maior que 10 caracteres:

  size(request.path) > 10
  

• A expressão a seguir corresponde a solicitações que têm um comprimento de cabeçalho x-data maior ou igual a 1.024 caracteres:

  size(request.headers['x-data']) >= 1024
  

Permitir ou negar tráfego que tenha o valor zero content-length no corpo HTTP

• A expressão a seguir corresponde a solicitações que têm um content-length zero no corpo do HTTP:

  int(request.headers["content-length"]) == 0
  

Permitir ou negar tráfego que tenha um valor codificado de URL específico

• A expressão a seguir corresponde a solicitações que têm um valor de cookie contendo %3c:

  has(request.headers['cookie']) && request.headers['cookie'].urlDecode().contains('<')
  

Permitir ou negar o tráfego que contém um valor específico codificado de uma string Unicode

• A expressão a seguir corresponde a pedidos com um valor de cookie igual a Match%2BValue ou Match%u002BValue:

  has(request.headers['cookie']) && request.headers['cookie'].urlDecodeUni() == 'Match+Value'
  

Permitir ou negar tráfego que contenha uma string Unicode específica de um texto UTF-8

• A expressão a seguir corresponde a pedidos com um valor de cookie igual a ¬:

  has(request.headers['cookie']) && request.headers['cookie'].utf8ToUnicode() == '%u00ac'
  

Permitir ou negar tráfego com base em uma impressão digital JA4 conhecida

• A expressão a seguir corresponde a solicitações com uma impressão digital JA4 igual a t13d1516h2_8daaf6152771_b186095e22b6:

  origin.tls_ja4_fingerprint == 't13d1516h2_8daaf6152771_b186095e22b6'
  

Permitir ou negar tráfego com base em uma lista de impressões digitais JA4

• A expressão a seguir corresponde a solicitações com uma impressão digital JA4 igual a qualquer uma das seguintes impressões digitais JA4:

  • t00d0000h0_000000000000_000000000000
  • t13d1516h2_8daaf6152771_b186095e22b6

  origin.tls_ja4_fingerprint == 't00d0000h0_000000000000_000000000000' || origin.tls_ja4_fingerprint == 't13d1516h2_8daaf6152771_b186095e22b6'
  

Permitir ou negar tráfego com base no conteúdo do corpo da solicitação

• A expressão a seguir corresponde a solicitações POST que contêm malicious-value no corpo da solicitação:

  request.method == 'POST' && request.body.contains('malicious-value')
  

• A expressão a seguir corresponde a solicitações que começam com <!DOCTYPE html>:

  request.body.startsWith('<!DOCTYPE html>')
  

• A expressão a seguir corresponde a solicitações em que o corpo corresponde à expressão regular \w+@\w+.com:

  request.body.matches('\w+@\w+.com')
  

Permitir ou negar tráfego com base em parâmetros de solicitação

• A expressão a seguir corresponde a solicitações que não contêm um parâmetro chamado category:

  !has(request.params.category)
  

• A expressão a seguir corresponde a solicitações em que o parâmetro category é electronics:

  request.params.category == 'electronics'
  

• A expressão a seguir corresponde a solicitações em que todos os valores de parâmetro não estão vazios:

  request.params.all(k, request.params[k] != '')
  

• A expressão a seguir corresponde a solicitações em que qualquer parâmetro contém a string admin:

  request.params.exists(k, request.params[k].contains('admin'))
  

• A expressão a seguir corresponde a solicitações em que exatamente um nome de parâmetro contém admin:

  request.params.exists_one(k, k.contains('admin'))
  

• A expressão a seguir corresponde a solicitações em que pelo menos um nome de parâmetro contém id:

  size(request.params.filter(k, k.contains('id'))) > 0
  

• A expressão a seguir corresponde a solicitações em que os valores de parâmetro incluem a string admin:

  request.params.map(k, request.params[k]).contains('admin')
  

Permitir ou negar tráfego com base em dados estruturados no corpo da solicitação

• A expressão a seguir corresponde a solicitações em que o campo password em um corpo de solicitação JSON contém 123:

  has(request.params.password) && request.params.password.contains('123')
  

• A expressão a seguir corresponde a solicitações em que o campo city nos dados do formulário é NewYork:

  has(request.params.city) && request.params.city == 'NewYork'
  

• A expressão a seguir corresponde a solicitações em que o campo newsletter aninhado é true:

  has(request.params.preferences) && has(request.params.preferences.newsletter) && request.params.preferences.newsletter == true
  

• A expressão a seguir corresponde a solicitações em que o campo name do primeiro elemento na matriz friends é johndoe:

  request.params['friends'][0]['name'] == 'johndoe'
  

Regras de WAF pré-configuradas

As regras de WAF pré-configuradas usam assinaturas estáticas pré-configuradas, expressões regulares ou ambas para corresponder ao corpo da solicitação HTTP, cabeçalhos da solicitação HTTP e parâmetros de consulta. As regras de WAF pré-configuradas disponíveis são baseadas no conjunto de regras principais do OWASP versão 4.22. O Cloud Armor fornece várias regras de WAF pré-configuradas predefinidas. Confira uma lista completa de regras de WAF pré-configuradas em Visão geral das regras de WAF pré-configuradas do Google Cloud Armor.

Para listar todas as regras de WAF pré-configuradas disponíveis, consulte Listar regras de WAF pré-configuradas disponíveis.

Para mais informações sobre regras de WAF pré-configuradas, consulte o caso de uso Reduzir ataques de camada do aplicativo usando regras de WAF pré-configuradas.

Nomes das regras de WAF pré-configuradas

Os nomes das regras de WAF pré-configurados têm o formato <attack category>-<OWASP CRS version>-<version field>. A categoria de ataque especifica os tipos de ataques contra os quais você quer se proteger, como xss (scripting em vários locais) ou sqli (injeção de SQL).

Os campos de versão compatíveis são stable e canary. Adições e modificações nas regras são lançadas primeiro na versão canary. Quando as adições e modificações são consideradas seguras e estáveis, elas são promovidas à versão stable.

IDs de membros da regra de WAF pré-configurada

Uma regra de WAF pré-configurada contém várias expressões, cada uma com sua assinatura. Por exemplo, a regra de WAF pré-configurada xss-v422-stable inclui uma expressão chamada owasp-crs-v042200-id941100-xss, que corresponde ao ID da regra id941100 para a versão 4.22. É possível usar as assinaturas para excluir o uso de expressões específicas, o que é útil se uma expressão específica acionar constantemente um falso positivo. Confira mais informações na solução de problemas de falsos positivos.

Para informações sobre o conjunto de regras principais e ajuste em diferentes níveis de sensibilidade, consulte Como ajustar as regras de WAF do Cloud Armor.

Operador para regras WAF pré-configuradas

Expressões	Descrição
evaluatePreconfiguredWaf(string, MAP<string, dyn>)	Retorna true se qualquer uma das assinaturas WAF dentro do conjunto de regras WAF especificado retornar true. O primeiro argumento é o nome do conjunto de regras de WAF, como xss-v422-stable. O segundo (opcional) é um mapa em que a chave é uma string, e o valor é digitado dinamicamente, dependendo da chave. O objetivo desse argumento é ajustar as assinaturas de WAF que são avaliadas. As chaves aceitas incluem: sensitivity: corresponde ao nível de paranoia do conjunto de regras principais do OWASP, que tem quatro níveis, variando de 1 a 4. O valor dela é um número inteiro com um intervalo válido de 0 a 4. 0 é reservado como um valor válido quando usado em combinação com opt_in_rule_ids (descrito posteriormente). Ao especificar uma sensibilidade de x (x >= 1), todas as assinaturas de WAF associadas com um valor de sensibilidade de 1 a x são avaliadas. Quando omitido, o valor 4 é usado como o valor da sensibilidade. opt_out_rule_ids: assinaturas de WAF (representadas por IDs de regra) para serem desativadas na avaliação, em que o conjunto base é determinado pelo valor da sensibilidade. O valor dela é uma lista de strings. O número máximo de IDs de regras permitidos é 128. opt_in_rule_ids: assinaturas de WAF (representadas por IDs de regra) a serem ativadas para avaliação, em que o conjunto básico está vazio. O valor dela é uma lista de strings. O número máximo de IDs de regras permitidos é 128. Ao usar esse atributo, é necessário especificar um sensitivity de 0. As chaves opt_out_rule_ids e opt_in_rule_ids são mutuamente exclusivas. Você pode usar opt_in_rule_ids se quiser revisar e ativar manualmente novas assinaturas WAF que forem adicionadas mais tarde em um conjunto de regras existente.
evaluatePreconfiguredWaf(string, LIST)	Atenção: evaluatePreconfiguredExpr() foi descontinuado. Recomendamos usar evaluatePreconfiguredWaf() em vez disso. Retorna true se qualquer uma das expressões dentro da regra de WAF pré-configurada especificada retornar true. O primeiro argumento é o nome da regra de WAF pré-configurada, como xss-stable. O segundo argumento (opcional) é uma lista de strings de IDs separados por vírgulas que precisam ser excluídos da avaliação. A lista de exclusão é útil quando um membro específico da regra de WAF pré-configurada aciona um falso positivo.

Exemplos de regras de WAF pré-configuradas

• A expressão a seguir usa a regra de WAF pré-configurada xss-v422-stable para mitigar ataques XSS:

  evaluatePreconfiguredWaf('xss-v422-stable')
  

• A expressão a seguir usa todas as expressões da regra de WAF pré-configurada xss-v422-stable, exceto os IDs de membro 941100 e 941110:

  evaluatePreconfiguredWaf('xss-v422-stable', {'opt_out_rule_ids': ['owasp-crs-v042200-id941100-xss',
  'owasp-crs-v042200-id941110-xss']})
  

• A expressão a seguir usa uma regra de WAF pré-configurada para mitigar ataques SQLi do intervalo de endereços IP 198.51.100.0/24:

  inIpRange(origin.ip, '198.51.100.0/24') && evaluatePreconfiguredWaf('sqli-v422-stable')
  

• A expressão a seguir usa a regra de WAF pré-configurada xss-v422-stable para mitigar ataques XSS em solicitações para example.com, excluindo caminhos que começam com /login/api/:

  request.headers['host'].lower() == 'example.com' && !request.path.startswith('/login/api/') && evaluatePreconfiguredWaf('xss-v422-stable')
  

Regras gerenciadas

As regras gerenciadas do Google Cloud Armor protegem seus apps da Web e endpoints de API com assinaturas de segurança atualizadas automaticamente. As regras gerenciadas são fornecidas pela Thales Imperva e se integram diretamente ao Cloud Armor, simplificando suas operações de segurança. As regras gerenciadas eliminam a necessidade de atualizações manuais de assinatura e reduzem o desvio de configuração, permitindo que sua equipe de segurança se concentre no desenvolvimento e nas operações.

Operador para regras gerenciadas

Expressões

Descrição

evaluateManagedRules(string, MAP<string, dyn>)

Retorna true se qualquer uma das assinaturas dentro das regras gerenciadas especificadas retornar true. O primeiro argumento é o nome totalmente qualificado da categoria, como google:xss:stable ou google:sqli:canary. O segundo argumento (opcional) é um mapa em que a chave é uma string, e o valor é digitado dinamicamente, dependendo da chave. As chaves aceitas incluem: opt_in_rule_ids: uma lista de IDs de regras do conjunto de regras correspondente que são as únicas regras avaliadas. Por exemplo, evaluateManagedRules('google:xss:canary', {'opt_in_rule_ids': ['google-xss-8057544707029182464']}). opt_out_rule_ids: uma lista de IDs de regra do conjunto de regras correspondente que são excluídos da avaliação. Por exemplo, evaluateManagedRules('google:xss:canary', {'opt_out_rule_ids': ['google-xss-8057544707029182464']}).

Exemplos de regras gerenciadas

• A expressão a seguir usa as regras gerenciadas de injeção de SQL (sqli) estáveis para ajudar a evitar ataques de SQLi:

  evaluateManagedRules('google:sqli:stable')
  

• A expressão a seguir usa as regras gerenciadas estáveis xss somente se a solicitação tiver o host example.com:

  request.headers['host'].lower() == 'example.com' && evaluateManagedRules('google:xss:stable')
  

Outros operadores

Expressões	Descrição
evaluateThreatIntelligence(string) evaluateThreatIntelligence(string, LIST) evaluateThreatIntelligence(string, string, LIST)	Retorna true se o endereço IP do cliente corresponder a qualquer um dos intervalos de IP na lista de IPs especificada, a menos que seja explicitamente excluído com a lista de exclusão. O primeiro argumento é o nome do feed do Google Threat Intelligence, como iplist-known-malicious-ips. Se o segundo argumento for uma string (opcional), ele vai determinar de onde o endereço IP será extraído. Ele pode ser origin.ip, origin.user_ip ou um nome de cabeçalho específico. Se o segundo ou terceiro argumento (opcional) for uma lista de strings separadas por vírgulas, em que cada string é um endereço IP ou um intervalo CIDR, ele será excluído da avaliação. A lista de exclusão é útil quando um feed contém um endereço IP que aciona um falso positivo. Observação: é necessário configurar a opção userIpRequestHeaders[] no campo advancedOptionsConfig da política de segurança ao usar origin.user_ip.
evaluateAddressGroup(string, string) evaluateAddressGroup(string, string, LIST) evaluateOrganizationAddressGroup(string, string) evaluateOrganizationAddressGroup(string, string, LIST)	Retorna true se o endereço IP do cliente corresponder a qualquer um dos intervalos de IP no grupo de endereços especificado, a menos que seja explicitamente excluído com a lista de exclusão. O primeiro argumento é o nome do grupo de endereços. O segundo argumento determina de onde o endereço IP é extraído e pode ser origin.ip, origin.user_ip ou um nome de cabeçalho específico. O terceiro argumento (opcional) é uma lista separada por vírgulas de strings, em que cada string é um endereço IP ou um intervalo CIDR, que será excluído da avaliação. A lista de exclusão é útil quando um grupo de endereços contém um endereço IP que aciona um falso positivo. Observação: é necessário configurar a opção userIpRequestHeaders[] no campo advancedOptionsConfig da política de segurança ao usar origin.user_ip.
evaluateAdaptiveProtection(string)	Retorna true se a solicitação corresponder à assinatura de ataque produzida pela Proteção adaptativa do Google Cloud Armor. O argumento é o ID de um alerta específico gerado pela Proteção adaptativa ao detectar um ataque.
evaluateAdaptiveProtectionAutoDeploy()	Retorna true se a solicitação for de um endereço IP de grande impacto que corresponda à assinatura de um ataque em andamento detectado pela Proteção Adaptativa.

Exemplos

• A expressão a seguir corresponde à solicitação recebida comparada ao feed do Google Threat Intelligence iplist-known-malicious-ips para proteção contra a lista conhecida de IPs mal-intencionados:

  evaluateThreatIntelligence('iplist-known-malicious-ips')
  

• A expressão a seguir corresponde à solicitação recebida comparada ao feed do Google Threat Intelligence iplist-known-malicious-ips para proteção contra a lista conhecida de IPs mal-intencionados, exceto os IPs em 203.0.113.0/24:

  evaluateThreatIntelligence('iplist-known-malicious-ips', ['203.0.113.0/24'])
  

• A expressão a seguir corresponde ao cabeçalho da solicitação personalizado para IP do usuário comparado ao grupo de endereços chamado my-own-list-of-bad-ips:

  evaluateAddressGroup('my-own-list-of-bad-ips', origin.user_ip)
  

A seguir

• Criar e visualizar políticas de segurança do Cloud Armor
• Gerenciar políticas de segurança do Cloud Armor
• Gerenciar regras de política de segurança do Cloud Armor
• Ajustar regras de WAF pré-configuradas para o Cloud Armor
• Resolver problemas do Cloud Armor
• Cotas e limites