Sécurité renforcée du trafic web sortant : Secure Web Proxy sur Google Cloud Platform

GCP Secure Web Proxy est un service entièrement managé qui offre un accès sécurisé et fiable à Internet et aux applications SaaS depuis vos réseaux Virtual Private Cloud (VPC). Il aide les organisations à appliquer leurs politiques de sécurité, à se protéger contre les menaces web et à gagner en visibilité sur leur trafic web.

Avantages et fonctionnalités clés de GCP Secure Web Proxy face aux autres services proxy :

• Sécurité : le service propose un filtrage d'URL qui permet d'appliquer des politiques de contrôle d'accès basées sur des catégories d'URL. Il peut inspecter le trafic TLS afin d'appliquer des politiques de sécurité, comme la détection de logiciels malveillants ou le filtrage de contenu. Il s'intègre également à Google Cloud Threat Intelligence pour vous protéger des sites malveillants connus et des attaques de phishing.
• Contrôle d'accès granulaire : les politiques Secure Web Proxy (SWP) permettent de créer des règles qui définissent la circulation du trafic web sortant depuis vos ressources Google Cloud vers Internet. Elles peuvent restreindre le trafic en fonction de sa source, de sa destination, de son type ou d'une combinaison de ces critères.
• Visibilité et supervision : Secure Web Proxy s'intègre à Cloud Logging et Cloud Monitoring, ce qui simplifie la collecte et l'analyse des journaux et métriques de votre trafic web sortant.
• Évolutivité et fiabilité : entièrement managé, GCP Secure Web Proxy s'adapte automatiquement à votre trafic et garantit haute disponibilité et performances.
• Gain de temps opérationnel : Secure Web Proxy ne nécessite ni VM à provisionner et configurer, ni mises à jour logicielles pour rester sécurisé, et offre une mise à l'échelle élastique. Une fois la politique initiale définie, une instance régionale Secure Web Proxy fonctionne immédiatement.
• Maîtrise des coûts : le service est facturé à l'usage : vous ne payez que pour les ressources consommées, sans engagement préalable.

Dans cette configuration, les instances Secure Web Proxy sont déployées dans le VPC HUB et les workloads dans le VPC Spoke. Toutes les requêtes sortantes sont acheminées vers le Secure Web Proxy via le peering VPC.

Vue d'ensemble de l'architecture Hub and Spoke utilisée en exemple

Étape 1 : définir les variables d'environnement nécessaires.

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"

Étape 2 : créer le réseau Hub et son sous-réseau.

# 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

Étape 3 : créer un sous-réseau proxy pour Secure Web Proxy. La taille recommandée est /23, soit 512 adresses proxy-only, car la connectivité Secure Web Proxy s'appuie sur un pool d'adresses IP réservées à cet usage.

Ce pool attribue des adresses IP uniques côté sortie de chaque proxy pour les échanges avec Cloud NAT et les destinations du réseau VPC. Veillez à ce que la plage proxy ne chevauche pas d'autres réseaux.

# 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

Étape 4 : créer le réseau Spoke et ses sous-réseaux.

# 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

Étape 5 : supprimer la route Internet par défaut du VPC Spoke afin que tout le trafic sortant transite par le VPC Hub.

# 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

Étape 6 : créer une instance Compute Engine de test dans le réseau 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"

Étape 7 : créer un peering VPC entre les réseaux Hub et 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

Étape 8 : la passerelle Secure Web Proxy gère le trafic TLS, et un certificat est nécessaire. C'est ce certificat qui sert au client pour s'authentifier auprès du proxy. Créez un certificat SSL puis importez-le dans le 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

Étape 9 : créer une politique Secure Web Proxy.

Secure Web Proxy propose également un service d'inspection TLS qui permet d'intercepter le trafic TLS, d'analyser la requête chiffrée et d'appliquer des politiques de sécurité. Consultez la présentation de l'inspection TLS pour des exemples de configuration.

#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

Étape 10 : créer une instance de passerelle Secure Web Proxy à partir de la politique définie à l'étape précédente.

# 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

Une passerelle Cloud NAT est créée pour assurer l'accès Internet lors du provisionnement d'une instance Secure Web Proxy. Seuls les endpoints Secure Web Proxy de la même région et du même réseau peuvent accéder à cette passerelle Cloud NAT. Aucun autre endpoint, qu'il s'agisse d'une instance de machine virtuelle (VM) ou d'un nœud Google Kubernetes Engine (GKE), ne peut acheminer du trafic via cette passerelle.

Étape 11 : connectez-vous en SSH à l'instance de test du réseau Spoke pour valider les requêtes sortantes. Comme la politique Secure Web Gateway Proxy ne contient aucune règle, l'ensemble du trafic sortant est refusé par défaut.

#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

Résultats obtenus depuis l'instance de test

Étape 12 : créer des règles Secure Web Proxy pour autoriser ou refuser le trafic sortant conformément à l'architecture de référence.

Une règle Secure Web Proxy (SWP) est une instruction qui détermine la manière dont le proxy traite le trafic web sortant.

L'exemple de politique autorise les connexions sortantes selon le nom d'hôte. Consultez le langage CEL matcher pour la liste complète des attributs et opérateurs.

#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

Résultats obtenus depuis l'instance de test

Ces résultats montrent que la passerelle Secure Web Proxy n'autorise les connexions sortantes que vers les noms d'hôte définis dans les règles, et bloque celles vers tous les autres domaines.