Sicurezza avanzata per il traffico web in uscita con Secure Web Proxy su Google Cloud

GCP Secure Web Proxy è un servizio completamente gestito che offre un modo sicuro e affidabile per accedere a Internet e alle applicazioni SaaS dalle reti Virtual Private Cloud (VPC). Aiuta le organizzazioni ad applicare policy di sicurezza, a difendersi dalle minacce web e ad avere visibilità sul traffico web.

Vantaggi e caratteristiche principali di GCP Secure Web Proxy rispetto ad altri servizi proxy:

• Sicurezza: il servizio offre il filtraggio degli URL, che consente di applicare policy di controllo degli accessi basate sulle categorie di URL. Può ispezionare il traffico TLS, permettendole di applicare policy di sicurezza come la ricerca di malware o il filtraggio dei contenuti. Si integra inoltre con Google Cloud Threat Intelligence per proteggere da siti malevoli noti e attacchi di phishing.
• Controllo granulare degli accessi: le policy di Secure Web Proxy (SWP) permettono di creare regole che definiscono come il traffico web in uscita scorre dalle risorse Google Cloud verso Internet. Le policy possono limitare il traffico in base all'origine, alla destinazione, al tipo di traffico o a una combinazione di questi fattori.
• Visibilità e monitoraggio: Secure Web Proxy si integra con Cloud Logging e Cloud Monitoring, così potrà raccogliere e analizzare facilmente log e metriche del traffico web in uscita.
• Scalabilità e affidabilità: GCP Secure Web Proxy è un servizio completamente gestito che scala automaticamente in base al traffico, garantendo elevata disponibilità e prestazioni costanti.
• Risparmio di tempo operativo: Secure Web Proxy non richiede VM da configurare né aggiornamenti software per mantenere la sicurezza, e offre scalabilità elastica. Dopo la configurazione iniziale delle policy, un'istanza regionale di Secure Web Proxy è subito operativa.
• Convenienza economica: il servizio è proposto con tariffazione pay-as-you-go: paga solo le risorse che utilizza, senza alcun impegno iniziale.

In questa configurazione le istanze Secure Web Proxy sono distribuite nell'Hub VPC, mentre i workloads sono distribuiti nello Spoke VPC. Tutte le richieste in uscita vengono inoltrate a Secure Web Proxy tramite VPC peering.

Architettura di alto livello dell'esempio Hub and Spoke

Passo 1: imposti le variabili d'ambiente necessarie.

export PROJECT_ID="your-project-id"
export REGION="your-region"
export HUB_VPC="hub"
export HUB_SUBNET="hub-subnet"
export HUB_SWP_SUBNET="swp-subnet" #proxy only subnet
export SPOKE_VPC="spoke"
export SPOKE_GCE_SUBNET="spoke-gce-subnet"
export SWP_CERT_NAME="swp-certificate"
export SWP_POLICY_NAME="swp-policy"

Passo 2: crei la rete Hub e la relativa subnet.

# Create a Hub custom Network
gcloud compute networks create $HUB_VPC \
   --project=$PROJECT_ID \
   --subnet-mode=custom

# Create the Hub nework subnet
gcloud compute networks subnets create $HUB_SUBNET \
   --project=$PROJECT_ID \
   --network=$HUB_VPC \
   --role="ACTIVE" \
   --purpose="PRIVATE" \
   --range=10.220.0.0/23 --region=$REGION

Passo 3: crei una subnet proxy per Secure Web Proxy. La dimensione consigliata è /23, ovvero 512 indirizzi proxy-only, perché la connettività di Secure Web Proxy si basa su un pool di indirizzi IP riservati al servizio.

Questo pool assegna indirizzi IP univoci sul lato in uscita di ciascun proxy per l'interazione con Cloud NAT e con le destinazioni nella rete VPC. Verifichi che l'intervallo del proxy non si sovrapponga ad altre reti.

# Create proxy only subnet for SWP.
gcloud compute networks subnets create $HUB_SWP_SUBNET \
   --project=$PROJECT_ID \
   --network=$HUB_VPC \
   --role="ACTIVE" \
   --purpose="REGIONAL_MANAGED_PROXY" \
   --range=192.168.0.0/23 --region=$REGION

Passo 4: crei la rete Spoke e le relative subnet.

# Create a Spoke custom Network and its subnet
gcloud compute networks create $SPOKE_VPC \
   --project=$PROJECT_ID \
   --subnet-mode=custom

gcloud compute networks subnets create $SPOKE_GCE_SUBNET \
   --project=$PROJECT_ID \
     --network=$SPOKE_VPC \
   --range=10.240.0.0/23 --region=$REGION

Passo 5: elimini la rotta Internet predefinita dello Spoke VPC: in questo modo tutto il traffico in uscita verrà instradato attraverso l'Hub VPC.

# Get the Default Route internet and the delete the rule
ROUTE_NAME=$(gcloud compute routes list --filter="network: $SPOKE_VPC AND nextHopGateway:default-internet-gateway" --format="value(name)")

gcloud compute routes delete $ROUTE_NAME --quiet

Passo 6: crei un'istanza Compute Engine di test nella rete Spoke.

# Create VM
gcloud compute instances create spoke-vm \
  --zone=${REGION}-a \
  --machine-type=e2-medium \
  --network-interface=stack-type=IPV4_ONLY,subnet=${SPOKE_GCE_SUBNET},no-address \
  --project=$PROJECT_ID

# Allow ssh via IAP
gcloud compute firewall-rules create allow-ssh-ingress \
  --project=$PROJECT_ID \
  --direction=INGRESS \
  --priority=1000 \
  --network=$SPOKE_VPC \
  --action=ALLOW \
  --rules=tcp:22 \
  --source-ranges="35.235.240.0/20"

Passo 7: crei il VPC peering tra le reti Hub e Spoke.

# Hub to spoke
gcloud compute networks peerings create hub-to-spoke \
   --project=$PROJECT_ID \
   --network=$HUB_VPC --peer-network=$SPOKE_VPC \
   --auto-create-routes

# Spoke to Hub
gcloud compute networks peerings create spoke-to-hub \
   --project=$PROJECT_ID \
   --network=$SPOKE_VPC --peer-network=$HUB_VPC \
   --auto-create-routes

Passo 8: il Secure Web Proxy Gateway gestirà il traffico TLS e occorre fornire un certificato. Si tratta del certificato che il client utilizza per autenticarsi con il proxy. Crei un certificato SSL e lo carichi nel certificate manager.

#create the certificate
openssl req -x509 -newkey rsa:2048 \
  -keyout key.pem \
  -out cert.pem -days 365 \
  -subj '/CN=demo.swp.local' -nodes -addext \
  "subjectAltName=DNS:demo.swp.local"

#upload the certificate
gcloud certificate-manager certificates create $SWP_CERT_NAME \
   --certificate-file=cert.pem \
   --private-key-file=key.pem \
   --location=$REGION

Passo 9: crei una policy per Secure Web Proxy.

Secure Web Proxy offre anche un servizio di ispezione TLS che consente di intercettare il traffico TLS, ispezionare la richiesta cifrata e applicare le policy di sicurezza. Per esempi di configurazione consulti la panoramica dell'ispezione TLS.

#Sample policy without enable TLS inspection.
cat << EOF > swp-policy.yaml
description: Secure Web Proxy policy
name: projects/$PROJECT_ID/locations/$REGION/gatewaySecurityPolicies/$SWP_POLICY_NAME
EOF

gcloud network-security gateway-security-policies import $SWP_POLICY_NAME \
  --source=swp-policy.yaml \
  --location=$REGION

Passo 10: crei un'istanza del gateway Secure Web Proxy con la policy creata al passo precedente.

# Create config file
cat << EOF > swp-gateway.yaml
name: projects/$PROJECT_ID/locations/REGION/gateways/swp-gateway
type: SECURE_WEB_GATEWAY
ports: [443]
certificateUrls: ["projects/$PROJECT_ID/locations/$REGION/certificates/$SWP_CERT_NAME"]
gatewaySecurityPolicy: projects/$PROJECT_ID/locations/$REGION/gatewaySecurityPolicies/$SWP_POLICY_NAME
network: projects/$PROJECT_ID/global/networks/$HUB_VPC
subnetwork: projects/$PROJECT_ID/regions/$REGION/subnetworks/$HUB_SUBNET
scope: basic-scope
EOF

gcloud network-services gateways import swp-gateway-instance \
    --source=swp-gateway.yaml \
    --location=$REGION

Al provisioning di un'istanza Secure Web Proxy viene creato un gateway Cloud NAT per abilitare l'accesso a Internet. Solo gli endpoint Secure Web Proxy della stessa regione e rete possono accedere al gateway Cloud NAT. Nessun altro endpoint, come istanze di macchine virtuali (VM) o nodi Google Kubernetes Engine (GKE), è autorizzato a instradare traffico attraverso il gateway.

Passo 11: si colleghi via SSH all'istanza di test nella rete Spoke per validare le richieste in uscita. La policy del Secure Web Gateway Proxy non contiene regole, quindi tutto il traffico in uscita sarà negato per impostazione predefinita.

#sample commands
#replace $SWP_HOST_IP with the IP address of the SWP Gateway IP
$export https_proxy=https://$SWP_HOST_IP
$curl -s -I --proxy-insecure https://www.example.com

Risultati dall'istanza di test

Passo 12: crei le regole Secure Web Proxy per consentire e negare il traffico in uscita in base all'architettura di riferimento.

Una regola Secure Web Proxy (SWP) è un'istruzione che definisce come il proxy gestisce il traffico web in uscita.

La policy di esempio consente la connessione in uscita in base all'hostname. Per l'elenco completo di attributi e operatori consulti il CEL matcher language.

#allow www.example.com,The rule with the lowest numeric value assigned has the highest logical priority and is evaluated prior to rules with lower logical priorities.
cat << EOF > allow-example-com.yaml
name: projects/$PROJECT_ID/locations/$REGION/gatewaySecurityPolicies/$SWP_POLICY_NAME/rules/allow-example-com
description: Allow example.com
enabled: true
priority: 1000
basicProfile: ALLOW
sessionMatcher: host() == 'www.example.com'
EOF

gcloud network-security gateway-security-policies rules import allow-example-com \
    --source=allow-example-com.yaml \
    --location=$REGION \
    --gateway-security-policy=$SWP_POLICY_NAME

#allow www.doit.com
cat << EOF > allow-doit-com.yaml
name: projects/$PROJECT_ID/locations/$REGION/gatewaySecurityPolicies/$SWP_POLICY_NAME/rules/allow-example-com
description: Allow example.com
enabled: true
priority: 999
basicProfile: ALLOW
sessionMatcher: host() == 'www.doit.com'
EOF

gcloud network-security gateway-security-policies rules import allow-doit-com \
    --source=allow-doit-com.yaml \
    --location=$REGION \
    --gateway-security-policy=$SWP_POLICY_NAME

Risultati dall'istanza di test

Dai risultati dei test si nota che il Secure Web Proxy Gateway consente le connessioni in uscita esclusivamente verso gli hostname autorizzati nelle regole, mentre quelle verso altri domini vengono bloccate.