CloudAcademia
FR

Cybersécurité · Module 06 · Sécurité réseau : pare-feu et segmentation

Lab : segmenter un réseau avec un pare-feu à refus par défaut

Lab75 minIntermédiaireMarkdown

Affichage du Markdown brut : le moteur de rendu n'a pas pu être chargé.

## Objectif
Vous construisez trois zones réseau (un « Internet », une DMZ et une zone interne) reliées par un conteneur pare-feu. Vous scannez depuis l'extérieur alors que tout est ouvert, vous appliquez une politique nftables à refus par défaut qui n'autorise que deux flux, vous scannez de nouveau, vous lisez les compteurs et le journal des abandons du pare-feu, puis vous prouvez par des tests que chaque flux indésirable est bloqué.

## Objectifs
- Construire trois zones isolées et les faire passer par un seul pare-feu.
- Scanner le réseau depuis l'extérieur avec `nmap` et lire les résultats `open`, `closed` et `filtered`.
- Écrire un jeu de règles à états et à refus par défaut qui n'autorise que Internet vers web (TCP 80) et web vers base de données (TCP 5432).
- Lire les compteurs de règles et le journal des abandons du pare-feu pour confirmer que le trafic bloqué l'a été par vos règles.
- Vérifier la politique avec un tableau de tests positifs et négatifs, et montrer pourquoi l'ordre des règles compte.

## Prérequis
- Une machine Linux avec **Podman 4 ou ultérieur** exécuté **sans privilèges root** (*rootless*, en tant qu'utilisateur normal ; vous n'avez jamais besoin de `sudo`) et le moteur réseau netavark. Testé avec Podman 5.8.7 sur Fedora avec le noyau 7.2. Vérifiez avec `podman info --format '{{.Host.NetworkBackend}}'` : la commande doit afficher `netavark`.
- Un accès à Internet une seule fois, pour télécharger l'image Alpine Linux (environ 8 Mo) et quelques paquets (environ 40 Mo au total). Ensuite, plus rien dans le lab n'a besoin d'Internet.
- Environ 400 Mo d'espace disque libre.
- La [leçon](lesson.fr.md) de ce module, et [Réseaux 08 — Couche transport : TCP, UDP et ports](../../networking/08-tcp-udp/README.fr.md). Les techniques de conteneurs sont celles du [lab Réseau cloud](../../cloud-computing/06-cloud-networking/lab.fr.md) ; ici, vous vous concentrez sur les zones, le refus par défaut, la journalisation et la vérification.

> [!WARNING]
> **Autorisation et éthique.** Le scan de ports est une technique d'attaque lorsqu'il vise des systèmes que vous ne contrôlez pas, et il peut être illégal. Dans ce lab, vous ne scannez que les trois conteneurs que vous créez vous-même, sur des réseaux créés avec `--internal` (rien ne quitte votre machine). Ne dirigez jamais `nmap` vers un système qui ne vous appartient pas ou que vous n'avez pas l'autorisation écrite explicite de tester. Scanner votre propre lab isolé pour vérifier votre propre pare-feu est l'usage défensif de cet outil.

## Architecture
<figure class="diagram" style="--dg-w: 1180px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 1180 560" width="1180" height="560" role="img" aria-labelledby="netsec-lab-architecture-fr-title netsec-lab-architecture-fr-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="fr">
<title id="netsec-lab-architecture-fr-title">Architecture du lab : trois zones et un pare-feu à refus par défaut</title>
<desc id="netsec-lab-architecture-fr-desc">Trois réseaux Podman internes se rejoignent dans un conteneur pare-feu, lab-netsec-fw, qui a les interfaces net0 203.0.113.254, dmz0 10.40.2.254 et int0 10.40.3.254. Le réseau internet 203.0.113.0/24 contient lab-netsec-client en 203.0.113.10, le client externe avec nmap, nc et curl et une route vers 10.40.0.0/16 via 203.0.113.254. Le réseau dmz 10.40.2.0/24 contient lab-netsec-web en 10.40.2.10, un serveur web à l&#x27;écoute sur tcp 80, 8080 et 22, avec une route par défaut via 10.40.2.254. Le réseau interne 10.40.3.0/24 contient lab-netsec-db en 10.40.3.10, un service de type base de données sur tcp 5432 et 22, avec une route par défaut via 10.40.3.254. Le pare-feu applique la table nftables inet lab_fw sur le hook forward avec policy drop : la règle 1 accepte le trafic established et related, la règle 2 accepte les nouvelles connexions de net0 vers dmz0 sur tcp 80, la règle 3 accepte les nouvelles connexions de dmz0 vers int0 sur tcp 5432, et la règle 4 journalise dans le groupe nflog 1 puis rejette tout le reste.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="1179" height="559" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l1"><rect class="dg-tint" x="20" y="150" width="300" height="230" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 163) scale(0.7500)" fill="none" stroke="#0369a1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17.5 19H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z"/></g>
<text x="62" y="177" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">lab-netsec-internet · 203.0.113.0/24</text></g>
<g class="dg-l4"><rect class="dg-tint" x="820" y="20" width="340" height="230" rx="16" fill="#fbf4f0" stroke="#e7b39e" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(836 33) scale(0.7500)" fill="none" stroke="#c2410c" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"/><path d="M12 9v4"/><path d="M12 17h.01"/></g>
<text x="862" y="47" font-size="13" class="dg-ink" fill="#c2410c" font-weight="700">lab-netsec-dmz · 10.40.2.0/24</text></g>
<g class="dg-l2"><rect class="dg-tint" x="820" y="290" width="340" height="230" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(836 303) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="4" y="11" width="16" height="10" rx="2"/><path d="M8 11V7a4 4 0 0 1 8 0v4"/></g>
<text x="862" y="317" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">lab-netsec-internal · 10.40.3.0/24</text></g>
<g class="dg-l1"><path class="dg-stroke" d="M300 265H430" stroke="#0369a1" stroke-width="3.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l4"><path class="dg-stroke" d="M740 140H840" stroke="#c2410c" stroke-width="3.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l2"><path class="dg-stroke" d="M740 410H840" stroke="#15803d" stroke-width="3.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<rect class="dg-card" x="40" y="200" width="260" height="150" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(56 216) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g></g>
<g class="dg-l1"><text x="98" y="237" font-size="14" class="dg-ink" fill="#0369a1" font-weight="700">lab-netsec-client</text></g>
<text x="58" y="268" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 203.0.113.10/24</text>
<text x="58" y="288" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">route 10.40.0.0/16 via .254</text>
<text x="58" y="308" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Client externe : nmap, nc, curl</text>
<rect class="dg-card" x="430" y="80" width="310" height="400" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l3"><g class="dg-icon" transform="translate(446 96) scale(1.2500)" fill="none" stroke="#b45309" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"/></g></g>
<g class="dg-l3"><text x="488" y="117" font-size="15" class="dg-ink" fill="#b45309" font-weight="700">lab-netsec-fw</text></g>
<text x="448" y="148" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">net0  203.0.113.254</text>
<text x="448" y="168" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">dmz0  10.40.2.254</text>
<text x="448" y="188" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">int0  10.40.3.254</text>
<text x="448" y="248" font-size="12" class="dg-muted" fill="#5c5c68" font-weight="700">table inet lab_fw · hook forward</text>
<text x="448" y="268" font-size="12.5" class="dg-ink" fill="#b91c1c" font-weight="700" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">policy drop</text>
<rect class="dg-tint" x="444" y="294" width="282" height="32" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="454" y="315" font-size="12" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">1 established,related  accept</text>
<rect class="dg-tint" x="444" y="334" width="282" height="32" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="454" y="355" font-size="12" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">2 net0 → dmz0  tcp 80  accept</text>
<rect class="dg-tint" x="444" y="374" width="282" height="32" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="454" y="395" font-size="12" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">3 dmz0 → int0  tcp 5432  accept</text>
<rect class="dg-tint" x="444" y="414" width="282" height="32" rx="8" fill="#f9eded" stroke="#e3a4a4"/>
<text x="454" y="435" font-size="12" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">4 log group 1, then drop</text>
<rect class="dg-card" x="840" y="66" width="300" height="150" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(856 82) scale(1.2500)" fill="none" stroke="#c2410c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="2" rx="2"/><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6 6h.01"/><path d="M6 18h.01"/></g></g>
<g class="dg-l4"><text x="898" y="103" font-size="14" class="dg-ink" fill="#c2410c" font-weight="700">lab-netsec-web</text></g>
<text x="858" y="134" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.40.2.10/24 · tcp 80 8080 22</text>
<text x="858" y="154" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">default via 10.40.2.254</text>
<text x="858" y="174" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Serveur web de la DMZ</text>
<rect class="dg-card" x="840" y="336" width="300" height="150" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(856 352) scale(1.2500)" fill="none" stroke="#15803d" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><ellipse cx="12" cy="5" rx="9" ry="3"/><path d="M3 5V19A9 3 0 0 0 21 19V5"/><path d="M3 12A9 3 0 0 0 21 12"/></g></g>
<g class="dg-l2"><text x="898" y="373" font-size="14" class="dg-ink" fill="#15803d" font-weight="700">lab-netsec-db</text></g>
<text x="858" y="404" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.40.3.10/24 · tcp 5432 22</text>
<text x="858" y="424" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">default via 10.40.3.254</text>
<text x="858" y="444" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Service de type base de données</text>
<g class="dg-l1"><rect class="dg-bg-plain" x="342.58" y="253" width="44.84" height="24" rx="12" fill="#ffffff"/><text x="365" y="269.5" font-size="11" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">net0</text></g>
<g class="dg-l4"><rect class="dg-bg-plain" x="767.58" y="128" width="44.84" height="24" rx="12" fill="#ffffff"/><text x="790" y="144.5" font-size="11" class="dg-ink" fill="#c2410c" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">dmz0</text></g>
<g class="dg-l2"><rect class="dg-bg-plain" x="767.58" y="398" width="44.84" height="24" rx="12" fill="#ffffff"/><text x="790" y="414.5" font-size="11" class="dg-ink" fill="#15803d" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">int0</text></g>
<g class="dg-l1"><rect class="dg-tint" x="322.5" y="526" width="535" height="26" rx="13" fill="#e6f0f6" stroke="#8ebcd5" stroke-width="1.2"/><text x="590" y="543.5" font-size="12" class="dg-ink" fill="#0369a1" font-weight="700" text-anchor="middle">Les trois réseaux Podman sont --internal : rien ne quitte votre machine</text></g>
</svg></figure>

*Figure 1. Un conteneur pare-feu relie trois zones. À la fin, seuls les deux flux de sa liste de règles peuvent le traverser.*

| Conteneur | Réseau et adresse | Rôle |
|---|---|---|
| `lab-netsec-client` | `lab-netsec-internet`, `203.0.113.10` | L'extérieur : un visiteur, ou un attaquant, avec `nmap`, `nc` et `curl` |
| `lab-netsec-web` | `lab-netsec-dmz`, `10.40.2.10` | Le serveur web public (TCP 80), plus deux services qui **ne** devraient **pas** être publics : TCP 8080 et une fausse bannière SSH sur TCP 22 |
| `lab-netsec-db` | `lab-netsec-internal`, `10.40.3.10` | Un service d'écoute de type base de données sur TCP 5432 (il répond `lab-db ready`) et une fausse bannière SSH sur TCP 22 |
| `lab-netsec-fw` | `203.0.113.254`, `10.40.2.254`, `10.40.3.254` | Le routeur et pare-feu entre les zones |

> [!NOTE]
> Les services « SSH » et « base de données » sont de minuscules services d'écoute `nc` qui affichent une ligne. Cela suffit pour qu'un scan les trouve et pour qu'ils acceptent ou refusent des connexions, ce dont ce lab a besoin. Sur un vrai réseau, le serveur web aurait aussi besoin d'une adresse publique (ou traduite) ; ici, le client le joint simplement en passant par le pare-feu.

Podman exécute une commande dans un conteneur avec `podman exec lab-netsec-<nom> <commande>`. Le lab l'utilise en permanence : chaque commande est donc écrite en entier.

## Étapes

### Étape 1 — Vérifier vos outils et créer un dossier de travail (3 min)
Assurez-vous que Podman s'exécute sans privilèges root avec netavark, et qu'il ne reste rien d'une tentative précédente.

```bash
podman --version
podman info --format '{{.Host.NetworkBackend}} rootless={{.Host.Security.Rootless}}'
podman ps -a --filter name=lab-netsec --format '{{.Names}}'
podman network ls --filter name=lab-netsec --format '{{.Name}}'
mkdir -p ~/netsec-lab && cd ~/netsec-lab
```

Sortie attendue (votre version peut différer) :
```text
podman version 5.8.7
netavark rootless=true
```

Les deux commandes `ls` n'affichent rien. Si elles listent des noms `lab-netsec-`, exécutez d'abord le [Nettoyage](#nettoyage). Tous les fichiers et commandes qui suivent supposent que vous êtes dans `~/netsec-lab`.

### Étape 2 — Construire l'image d'outils (5 min)
Alpine Linux est minuscule mais ne contient aucun des outils dont vous avez besoin. Vous construisez une image avec `nftables` (le pare-feu Linux), `nmap` (le scanner), `tcpdump` (pour lire le journal du pare-feu), `curl`, la commande `ip` complète et `busybox-extras` (un petit serveur web). L'étiquette est figée sur Alpine 3.20, ce qui vous donne les mêmes résultats que les sorties ci-dessous.

```bash
cat > Containerfile <<'EOT'
FROM docker.io/library/alpine:3.20.10
RUN apk add --no-cache nftables nmap curl iproute2 busybox-extras tcpdump
EOT
podman build -t lab-netsec-tools:1 .
podman run --rm lab-netsec-tools:1 sh -c 'nft --version; nmap --version | head -1; tcpdump --version 2>&1 | head -1; cat /etc/alpine-release'
```

Sortie attendue (la fin de la construction, puis les versions ; les versions des paquets peuvent différer légèrement) :
```text
OK: 47 MiB in 49 packages
COMMIT lab-netsec-tools:1
Successfully tagged localhost/lab-netsec-tools:1
nftables v1.0.9 (Old Doc Yak #3)
Nmap version 7.95 ( https://nmap.org )
tcpdump version 4.99.4
3.20.10
```

### Étape 3 — Créer les trois zones (3 min)
Chaque réseau Podman est une zone : un pont avec sa propre plage d'adresses. `--internal` signifie que Podman n'ajoute aucune route vers le monde extérieur et aucune NAT vers votre hôte : rien dans le lab ne peut donc quitter votre machine, et rien ne peut passer d'une zone à l'autre autrement que par le pare-feu que vous construisez. L'« Internet » utilise une plage de documentation ([RFC 5737](https://www.rfc-editor.org/rfc/rfc5737)) ; la DMZ et la zone interne utilisent des plages privées ([RFC 1918](https://www.rfc-editor.org/rfc/rfc1918)).

```bash
podman network create --internal --subnet 203.0.113.0/24 lab-netsec-internet
podman network create --internal --subnet 10.40.2.0/24 lab-netsec-dmz
podman network create --internal --subnet 10.40.3.0/24 lab-netsec-internal
podman network inspect lab-netsec-internet lab-netsec-dmz lab-netsec-internal \
  --format '{{.Name}} subnet={{(index .Subnets 0).Subnet}} internal={{.Internal}}'
```

Sortie attendue :
```text
lab-netsec-internet
lab-netsec-dmz
lab-netsec-internal
lab-netsec-internet subnet=203.0.113.0/24 internal=true
lab-netsec-dmz subnet=10.40.2.0/24 internal=true
lab-netsec-internal subnet=10.40.3.0/24 internal=true
```

### Étape 4 — Démarrer le pare-feu (4 min)
Le conteneur pare-feu a une interface dans chaque zone, avec la dernière adresse utilisable (`.254`) de chaque plage. `interface_name` donne aux interfaces des noms lisibles : `net0`, `dmz0` et `int0`. `--cap-add NET_ADMIN` lui permet de modifier ses propres règles de pare-feu, et `--sysctl net.ipv4.ip_forward=1` en fait un routeur. `sleep infinity` le maintient en fonctionnement.

```bash
podman run -d --name lab-netsec-fw \
  --network lab-netsec-internet:ip=203.0.113.254,interface_name=net0 \
  --network lab-netsec-dmz:ip=10.40.2.254,interface_name=dmz0 \
  --network lab-netsec-internal:ip=10.40.3.254,interface_name=int0 \
  --cap-add NET_ADMIN --sysctl net.ipv4.ip_forward=1 \
  lab-netsec-tools:1 sleep infinity
podman exec lab-netsec-fw ip -br addr
podman exec lab-netsec-fw sysctl net.ipv4.ip_forward
podman exec lab-netsec-fw nft list ruleset
```

Sortie attendue (l'identifiant du conteneur, l'ordre des interfaces, les numéros `@if` et les adresses `fe80::` varient) :
```text
0864d79130acc3d47b16a11b13019e9c56a6e87d68de7908d9aed6cf13f1fd69
lo               UNKNOWN        127.0.0.1/8 ::1/128 
int0@if4         UP             10.40.3.254/24 fe80::3813:93ff:fe04:a0c8/64 
dmz0@if6         UP             10.40.2.254/24 fe80::58f6:56ff:fe7b:1dba/64 
net0@if8         UP             203.0.113.254/24 fe80::6c81:b4ff:feb7:80d7/64 
net.ipv4.ip_forward = 1
```

La dernière commande, `nft list ruleset`, n'affiche **rien** : le pare-feu n'a pas encore de règles, il transfère donc tout. Retenez-le : c'est votre point de départ.

### Étape 5 — Démarrer les trois hôtes (6 min)
Chaque hôte rejoint une zone. Un réseau interne ne donne aucune route par défaut au conteneur : chaque hôte ajoute donc une route vers le pare-feu. Le serveur web et la base de données l'utilisent comme passerelle par défaut, et le client lui envoie la plage `10.40.0.0/16`. `NET_ADMIN` n'est nécessaire que pour `ip route add`.

Le serveur web exécute le serveur web BusyBox `httpd` sur TCP 80 et 8080, ainsi qu'un service d'écoute `nc` sur TCP 22 qui affiche une fausse bannière SSH. La base de données exécute deux services d'écoute `nc` : TCP 22 (la même bannière) et TCP 5432, qui répond `lab-db ready`. Ils représentent des services qui existent sur de vraies machines et qui ne devraient pas être joignables de partout.

```bash
I=lab-netsec-tools:1
podman run -d --name lab-netsec-web --network lab-netsec-dmz:ip=10.40.2.10 --cap-add NET_ADMIN $I \
  sh -c 'ip route add default via 10.40.2.254; mkdir -p /www; echo "hello from the DMZ web server" > /www/index.html; httpd -p 80 -h /www; httpd -p 8080 -h /www; exec nc -lk -p 22 -e echo SSH-2.0-lab-fake'
podman run -d --name lab-netsec-db --network lab-netsec-internal:ip=10.40.3.10 --cap-add NET_ADMIN $I \
  sh -c 'ip route add default via 10.40.3.254; nc -lk -p 22 -e echo SSH-2.0-lab-fake & exec nc -lk -p 5432 -e echo lab-db ready'
podman run -d --name lab-netsec-client --network lab-netsec-internet:ip=203.0.113.10 --cap-add NET_ADMIN $I \
  sh -c 'ip route add 10.40.0.0/16 via 203.0.113.254; exec sleep infinity'
podman ps --filter name=lab-netsec --format 'table {{.Names}}\t{{.Status}}'
```

Sortie attendue (trois identifiants de conteneur d'abord ; les durées varient) :
```text
NAMES              STATUS
lab-netsec-fw      Up 3 seconds
lab-netsec-web     Up 2 seconds
lab-netsec-db      Up 2 seconds
lab-netsec-client  Up 2 seconds
```

Vérifiez les routes et les ports sur lesquels chaque serveur écoute :

```bash
podman exec lab-netsec-client ip route
podman exec lab-netsec-web netstat -tln
podman exec lab-netsec-db netstat -tln
```

Sortie attendue :
```text
10.40.0.0/16 via 203.0.113.254 dev eth0 
203.0.113.0/24 dev eth0 proto kernel scope link src 203.0.113.10 
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       
tcp        0      0 :::80                   :::*                    LISTEN      
tcp        0      0 :::22                   :::*                    LISTEN      
tcp        0      0 :::8080                 :::*                    LISTEN      
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       
tcp        0      0 :::22                   :::*                    LISTEN      
tcp        0      0 :::5432                 :::*                    LISTEN      
```

Vous connaissez maintenant la **vérité** : le serveur web écoute sur 80, 8080 et 22 ; la base de données sur 5432 et 22. À l'étape suivante, vous découvrez ce que voit un inconnu.

### Étape 6 — Référence : tout est ouvert, et un scan le montre (10 min)
Le transfert étant activé et aucune règle n'existant, le pare-feu laisse tout passer. Testez depuis le client extérieur, puis scannez. D'abord, deux requêtes ordinaires :

```bash
podman exec lab-netsec-client curl -sS -m 3 http://10.40.2.10
podman exec lab-netsec-client nc -w 2 10.40.3.10 5432
podman exec lab-netsec-client nc -w 2 -z -v 10.40.3.10 22
```

Sortie attendue :
```text
hello from the DMZ web server
lab-db ready
10.40.3.10 (10.40.3.10:22) open
```

Le client sur l'« Internet » a parlé **directement à la base de données**. C'est le réseau à plat de l'histoire d'ouverture de la leçon. Scannez maintenant les deux serveurs depuis le client :

```bash
podman exec lab-netsec-client nmap -n -Pn -sT --reason --max-retries 1 -T4 -p 1-1024,5432,8080 10.40.2.10 10.40.3.10
```

Signification des options :
- `-n` désactive la résolution de noms ; `-p 1-1024,5432,8080` scanne les ports bien connus plus les deux ports supplémentaires.
- `-sT` est un **scan par connexion TCP** : il termine la poignée de main TCP avec l'appel normal `connect()`. Il ne demande aucun privilège particulier, ce qui explique qu'il fonctionne dans un conteneur sans privilèges root (le scan SYN, plus rapide, `-sS`, a besoin de sockets bruts et échoue ici).
- `-Pn` désactive la découverte « l'hôte est-il actif ? », qui aurait elle aussi besoin de sockets bruts dans ce conteneur. Chaque sonde est traitée comme une sonde de port.
- `--reason` indique pourquoi chaque état a été décidé ; `--max-retries 1 -T4` rend le scan assez rapide pour un lab.

Sortie attendue (les valeurs de latence et la date varient) :
```text
Starting Nmap 7.95 ( https://nmap.org ) at 2026-11-07 19:38 UTC
Nmap scan report for 10.40.2.10
Host is up, received user-set (0.00028s latency).
Not shown: 1023 closed tcp ports (conn-refused)
PORT     STATE SERVICE    REASON
22/tcp   open  ssh        syn-ack
80/tcp   open  http       syn-ack
8080/tcp open  http-proxy syn-ack

Nmap scan report for 10.40.3.10
Host is up, received user-set (0.00030s latency).
Not shown: 1024 closed tcp ports (conn-refused)
PORT     STATE SERVICE    REASON
22/tcp   open  ssh        syn-ack
5432/tcp open  postgresql syn-ack

Nmap done: 2 IP addresses (2 hosts up) scanned in 0.08 seconds
```

Lisez-la. Le client extérieur voit **cinq ports ouverts sur deux hôtes**, dont la base de données qui ne devrait jamais être joignable, ainsi que les services « SSH » et 8080 que personne n'avait l'intention de publier. Les autres ports sont `closed` : l'hôte a répondu à chaque sonde par un refus (`conn-refused`), ce qui explique que le scan ait duré 0,08 seconde. Le scan vient de dresser un inventaire de la surface d'attaque. Notez les ports ouverts : vous les comparerez avec le scan suivant.

> [!NOTE]
> Les noms de service (`ssh`, `postgresql`, `http-proxy`) sont des suppositions déduites du numéro de port, et non de ce qui répond. `nmap` associe les ports à des noms à partir d'une table. Les faux services de ce lab ne tromperaient pas un scan de versions, qui nécessite les fichiers de scripts de `nmap` que cette petite image n'inclut pas.

### Étape 7 — Appliquer la politique à refus par défaut (10 min)
Vous écrivez maintenant la politique de l'exemple concret de la leçon. Placez-la dans un fichier, puis chargez-la dans le pare-feu. Lisez-la avant de la charger.

```bash
cat > fw.nft <<'EOT'
table inet lab_fw
delete table inet lab_fw
table inet lab_fw {
  chain forward {
    type filter hook forward priority 0; policy drop;
    ct state invalid drop
    ct state established,related counter accept comment "return traffic"
    iifname "net0" oifname "dmz0" ip daddr 10.40.2.10 tcp dport 80 ct state new counter accept comment "internet to web: 80"
    iifname "dmz0" oifname "int0" ip saddr 10.40.2.10 ip daddr 10.40.3.10 tcp dport 5432 ct state new counter accept comment "web to db: 5432"
    limit rate 5/second burst 10 packets log group 1 prefix "lab-netsec DROP: "
    counter drop comment "default deny"
  }
}
EOT
podman exec -i lab-netsec-fw nft -f - < fw.nft
podman exec lab-netsec-fw nft list chain inet lab_fw forward
```

Ce que fait chaque partie :
- Les deux premières lignes permettent de recharger le fichier sans risque : elles créent la table si elle n'existe pas, puis la suppriment, de sorte que chaque chargement part d'une table propre.
- `table inet` s'applique à IPv4 et à IPv6. `chain forward` avec `hook forward` filtre le trafic qui **traverse** le pare-feu ; c'est le chemin entre les zones.
- `policy drop` est le refus par défaut : un paquet qui ne correspond à aucun `accept` est abandonné.
- `ct state invalid drop` abandonne les paquets qui n'appartiennent à aucune connexion valide.
- `ct state established,related ... accept` est la partie à états : les **réponses** aux connexions autorisées n'ont pas besoin de règle propre. Elle vient en premier parce qu'elle correspond à la plupart des paquets.
- Les deux règles `ct state new ... accept` sont les **seuls** nouveaux flux autorisés. Chacune nomme les interfaces, la destination exacte (et la source pour la seconde règle) et le port. Le mot-clé `counter` compte les paquets de chaque règle.
- `limit ... log group 1` écrit un enregistrement des paquets abandonnés dans le canal **nflog** numéro 1 du noyau, à raison d'au plus 5 par seconde (après une rafale de 10), afin qu'un scan ne puisse pas inonder le journal. Les règles sans verdict, comme `log`, laissent le paquet passer à la règle suivante.
- La dernière règle compte et abandonne tout le reste (la politique abandonnerait aussi, mais une règle explicite vous donne un compteur).

`podman exec -i ... nft -f -` lit le fichier sur l'entrée standard : il reste donc sur votre machine. Le chargement n'affiche rien. Sortie attendue de la commande `list` (tous les compteurs sont à zéro à ce stade) :
```text
table inet lab_fw {
	chain forward {
		type filter hook forward priority filter; policy drop;
		ct state invalid drop
		ct state established,related counter packets 0 bytes 0 accept comment "return traffic"
		iifname "net0" oifname "dmz0" ip daddr 10.40.2.10 tcp dport 80 ct state new counter packets 0 bytes 0 accept comment "internet to web: 80"
		iifname "dmz0" oifname "int0" ip saddr 10.40.2.10 ip daddr 10.40.3.10 tcp dport 5432 ct state new counter packets 0 bytes 0 accept comment "web to db: 5432"
		limit rate 5/second burst 10 packets log prefix "lab-netsec DROP: " group 1
		counter packets 0 bytes 0 drop comment "default deny"
	}
}
```

> [!NOTE]
> Une règle `log` simple (sans `group`) écrit dans le journal du noyau, que l'on lit avec `dmesg` ou `journalctl -k`. Dans un conteneur, ce journal n'est pas disponible : lors de ce test, `dmesg` à l'intérieur du conteneur a échoué avec « Operation not permitted », et par défaut le noyau ne journalise que depuis l'espace de noms réseau de l'hôte lui-même. Le canal `nflog` fonctionne sans aucune permission particulière et `tcpdump` peut le lire : le lab l'utilise donc. Si votre configuration diffère, les compteurs de l'étape 9 prouvent quand même ce qui a été abandonné.

### Étape 8 — Scanner de nouveau et comparer (8 min)
Répétez **exactement** le même scan, puis essayez les deux flux que vous avez autorisés :

```bash
podman exec lab-netsec-client nmap -n -Pn -sT --reason --max-retries 1 -T4 -p 1-1024,5432,8080 10.40.2.10 10.40.3.10
podman exec lab-netsec-client curl -sS -m 3 http://10.40.2.10
podman exec lab-netsec-web nc -w 2 10.40.3.10 5432
```

Sortie attendue (le scan prend maintenant plusieurs secondes : les sondes abandonnées ne reçoivent aucune réponse, et `nmap` les attend. Les durées varient) :
```text
Starting Nmap 7.95 ( https://nmap.org ) at 2026-11-07 19:38 UTC
Nmap scan report for 10.40.2.10
Host is up, received user-set (0.00020s latency).
Not shown: 1025 filtered tcp ports (no-response)
PORT   STATE SERVICE REASON
80/tcp open  http    syn-ack

Nmap scan report for 10.40.3.10
Host is up, received user-set.
All 1026 scanned ports on 10.40.3.10 are in ignored states.
Not shown: 1026 filtered tcp ports (no-response)

Nmap done: 2 IP addresses (2 hosts up) scanned in 7.14 seconds

hello from the DMZ web server
lab-db ready
```

Comparez avec l'étape 6 :

| | Avant (tout est ouvert) | Après (refus par défaut) |
|---|---|---|
| Serveur web, port 80 | `open` | `open` (autorisé) |
| Serveur web, ports 22 et 8080 | `open` | `filtered` |
| Base de données, ports 22 et 5432 | `open` | `filtered` |
| Autres ports | `closed` (refusé) | `filtered` (aucune réponse) |
| Durée du scan | 0,08 s | plusieurs secondes |

La surface d'attaque vue de l'extérieur est passée de cinq ports ouverts à un seul. Remarquez aussi le **changement de mot** : `closed` signifie « l'hôte a refusé », `filtered` signifie « rien n'est revenu », ce qui correspond à l'aspect d'un **abandon** (*drop*). La base de données n'est même plus une cible visible : ses 1026 ports sont filtrés. Le serveur web sert toujours le port 80, et le second flux autorisé fonctionne : le serveur web a bien joint la base de données.

> [!NOTE]
> La ligne « Host is up, received user-set » est `nmap` qui répète ce que vous lui avez dit (`-Pn`) : supposer que l'hôte est actif. Elle ne prouve pas que l'hôte a répondu. Sans `-Pn`, `nmap` tenterait d'abord une découverte d'hôtes : dans ce conteneur, elle échoue avec « Couldn't open a raw socket », et face à un vrai pare-feu qui abandonne les pings, elle signalerait à tort « Host seems down ».

Observez maintenant la politique depuis la **DMZ**, là où se tiendrait un attaquant qui aurait pris le contrôle du serveur web. Scannez la base de données et le client « Internet » depuis le serveur web :

```bash
podman exec lab-netsec-web nmap -n -Pn -sT --max-retries 1 -T4 -p 22,80,443,5432,8080 10.40.3.10 203.0.113.10
```

Sortie attendue :
```text
Starting Nmap 7.95 ( https://nmap.org ) at 2026-11-07 19:38 UTC
Nmap scan report for 10.40.3.10
Host is up (0.000095s latency).

PORT     STATE    SERVICE
22/tcp   filtered ssh
80/tcp   filtered http
443/tcp  filtered https
5432/tcp open     postgresql
8080/tcp filtered http-proxy

Nmap scan report for 203.0.113.10
Host is up.

PORT     STATE    SERVICE
22/tcp   filtered ssh
80/tcp   filtered http
443/tcp  filtered https
5432/tcp filtered postgresql
8080/tcp filtered http-proxy

Nmap done: 2 IP addresses (2 hosts up) scanned in 1.23 seconds
```

Depuis la DMZ, la base de données montre **un** port ouvert (5432, le flux autorisé), et le client « Internet » n'en montre aucun : le serveur web ne peut pas ouvrir de connexions vers l'extérieur (**filtrage sortant**). Si le serveur web est pris, l'attaquant peut parler au port de la base de données et à rien d'autre. Scanner depuis chaque zone est la manière de tester les règles internes, qu'un scan de périmètre ne peut pas voir.

### Étape 9 — Lire le journal et les compteurs (12 min)
Les scans et les tests ne prouvent pas que les paquets ont été bloqués **par vos règles**. Les compteurs et le journal le prouvent. Réinitialisez d'abord les compteurs, afin que les chiffres ci-dessous ne proviennent que de cette étape. Lancez ensuite en arrière-plan une capture sur le canal nflog du pare-feu, écrivant dans un fichier à l'intérieur du conteneur pare-feu. Elle s'arrête d'elle-même au bout de 60 secondes.

```bash
podman exec lab-netsec-fw nft reset rules chain inet lab_fw forward > /dev/null
podman exec -d lab-netsec-fw sh -c 'timeout 60 tcpdump -n -l -q -i nflog:1 > /tmp/drops.log 2>&1'
sleep 1
```

`nflog:1` est l'interface de capture du groupe de journalisation 1, le `group 1` de la règle. `-n` désactive les résolutions de noms et `-q` affiche une ligne courte par paquet. Essayez maintenant cinq flux qui ne doivent **pas** fonctionner. Chaque `nc -z` teste seulement si la connexion s'ouvre ; `-w 2` abandonne au bout de 2 secondes.

```bash
podman exec lab-netsec-client nc -w 2 -z -v 10.40.3.10 5432; echo rc=$?
podman exec lab-netsec-client nc -w 2 -z -v 10.40.2.10 22; echo rc=$?
podman exec lab-netsec-web nc -w 2 -z -v 10.40.3.10 22; echo rc=$?
podman exec lab-netsec-db nc -w 2 -z -v 10.40.2.10 80; echo rc=$?
podman exec lab-netsec-web nc -w 2 -z -v 203.0.113.10 80; echo rc=$?
```

Les cinq tests sont : Internet vers la **base de données** (5432), Internet vers le port **SSH** du serveur web, serveur web vers le port **SSH** de la base de données, base de données vers le serveur web (une connexion initiée de l'intérieur), et serveur web vers l'« Internet » (trafic sortant). Sortie attendue (chaque délai d'attente dure environ 2 secondes, cinq fois) :
```text
nc: 10.40.3.10 (10.40.3.10:5432): Operation timed out
rc=1
nc: 10.40.2.10 (10.40.2.10:22): Operation timed out
rc=1
nc: 10.40.3.10 (10.40.3.10:22): Operation timed out
rc=1
nc: 10.40.2.10 (10.40.2.10:80): Operation timed out
rc=1
nc: 203.0.113.10 (203.0.113.10:80): Operation timed out
rc=1
```

Les cinq **expirent** (il n'y a aucun refus) : le pare-feu abandonne le paquet et ne dit rien. Lisez maintenant le journal des abandons et les compteurs :

```bash
sleep 3
podman exec lab-netsec-fw cat /tmp/drops.log
podman exec lab-netsec-fw nft list chain inet lab_fw forward | tail -6
```

Sortie attendue (les horodatages et les ports source varient) :
```text
tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on nflog:1, link-type NFLOG (Linux netfilter log messages), snapshot length 262144 bytes
19:38:34.206451 IP 203.0.113.10.45915 > 10.40.3.10.5432: tcp 0
19:38:35.231427 IP 203.0.113.10.45915 > 10.40.3.10.5432: tcp 0
19:38:36.254469 IP 203.0.113.10.34173 > 10.40.2.10.22: tcp 0
19:38:37.278435 IP 203.0.113.10.34173 > 10.40.2.10.22: tcp 0
19:38:38.366492 IP 10.40.2.10.35221 > 10.40.3.10.22: tcp 0
19:38:39.391417 IP 10.40.2.10.35221 > 10.40.3.10.22: tcp 0
19:38:40.414413 IP 10.40.3.10.41825 > 10.40.2.10.80: tcp 0
19:38:41.438422 IP 10.40.3.10.41825 > 10.40.2.10.80: tcp 0
19:38:42.526436 IP 10.40.2.10.33531 > 203.0.113.10.80: tcp 0
19:38:43.550426 IP 10.40.2.10.33531 > 203.0.113.10.80: tcp 0

		iifname "net0" oifname "dmz0" ip daddr 10.40.2.10 tcp dport 80 ct state new counter packets 0 bytes 0 accept comment "internet to web: 80"
		iifname "dmz0" oifname "int0" ip saddr 10.40.2.10 ip daddr 10.40.3.10 tcp dport 5432 ct state new counter packets 0 bytes 0 accept comment "web to db: 5432"
		limit rate 5/second burst 10 packets log prefix "lab-netsec DROP: " group 1
		counter packets 10 bytes 600 drop comment "default deny"
	}
}
```

Lisez les preuves :
- Le journal contient **dix lignes de paquets, en cinq paires** (`tcpdump` n'affiche son résumé « packets captured » qu'à la fin de la capture, après les 60 secondes). Chaque paire est une tentative de connexion bloquée : un TCP SYN (le premier paquet d'une connexion ; `tcp 0` signifie sans données) envoyé deux fois, parce que l'émetteur a réessayé après environ une seconde. Les paires correspondent à vos cinq tests, de la source à la destination et au port.
- Le compteur `default deny` indique **10 paquets, 600 octets** : ce sont les mêmes dix paquets (60 octets chacun). Les deux règles `accept` pour les nouvelles connexions indiquent **0** : aucun des flux bloqués ne s'est donc glissé par erreur à travers une règle d'autorisation.
- Comme le journal et le compteur concordent, vous savez que chaque blocage provient du refus par défaut et non d'une faute de frappe ou d'une route manquante.

Vos nombres peuvent différer de quelques paquets si vos délais d'attente ou vos nouvelles tentatives diffèrent, mais le journal et le compteur doivent concorder entre eux.

> [!NOTE]
> `tcpdump` n'affiche pas ici le texte du `prefix` de la règle de journalisation. Dans une configuration de production, un démon de journalisation tel que `ulogd` stocke les enregistrements nflog, avec leur préfixe, dans un fichier ou sur un serveur de journaux. Les lire avec `tcpdump` suffit pour le lab.

### Étape 10 — Ordre des règles : où placer une nouvelle règle (8 min)
Supposons que l'équipe web vous demande de publier aussi le service du port 8080. Vous ajoutez la règle de la manière évidente, avec `nft add rule`, qui **ajoute** la règle à la fin de la chaîne.

```bash
podman exec lab-netsec-fw nft add rule inet lab_fw forward iifname net0 oifname dmz0 ip daddr 10.40.2.10 tcp dport 8080 ct state new counter accept comment '"internet to web: 8080 (added)"'
podman exec lab-netsec-client nc -w 2 -z -v 10.40.2.10 8080; echo rc=$?
podman exec lab-netsec-fw nft -a list chain inet lab_fw forward | tail -5
```

Sortie attendue :
```text
nc: 10.40.2.10 (10.40.2.10:8080): Operation timed out
rc=1
		limit rate 5/second burst 10 packets log prefix "lab-netsec DROP: " group 1 # handle 6
		counter packets 12 bytes 720 drop comment "default deny" # handle 7
		iifname "net0" oifname "dmz0" ip daddr 10.40.2.10 tcp dport 8080 ct state new counter packets 0 bytes 0 accept comment "internet to web: 8080 (added)" # handle 8
	}
}
```

La règle existe, et le port **ne s'ouvre toujours pas**. La nouvelle règle (handle 8) se trouve **après** le `drop` (handle 7) : le paquet est donc abandonné avant de pouvoir correspondre, et le compteur de la nouvelle règle reste à 0. L'option `-a` affiche le **handle** de chaque règle, son numéro permanent. Supprimez la règle inutile et insérez-en une nouvelle **avant** la règle de journalisation, à la position du handle 6 :

```bash
podman exec lab-netsec-fw nft delete rule inet lab_fw forward handle 8
podman exec lab-netsec-fw nft insert rule inet lab_fw forward position 6 iifname net0 oifname dmz0 ip daddr 10.40.2.10 tcp dport 8080 ct state new counter accept comment '"internet to web: 8080 (inserted)"'
podman exec lab-netsec-client nc -w 2 -z -v 10.40.2.10 8080; echo rc=$?
podman exec lab-netsec-fw nft list chain inet lab_fw forward | grep 8080
```

Sortie attendue (les numéros de handle que vous tapez doivent correspondre à votre propre liste `nft -a`) :
```text
10.40.2.10 (10.40.2.10:8080) open
rc=0
		iifname "net0" oifname "dmz0" ip daddr 10.40.2.10 tcp dport 8080 ct state new counter packets 1 bytes 60 accept comment "internet to web: 8080 (inserted)"
```

Le port est maintenant ouvert et le compteur de la règle indique la connexion unique. C'est exactement l'exposition que la politique à refus par défaut supprimait : c'est donc le bon moment pour l'annuler en rechargeant la politique d'origine, ce qui supprime et recrée toute la table.

```bash
podman exec -i lab-netsec-fw nft -f - < fw.nft
```

Le chargement n'affiche rien, et la table retrouve les cinq règles de l'étape 7.

> [!TIP]
> En situation réelle, conservez le fichier de règles sous gestion de versions et **rechargez le fichier** au lieu de saisir des règles une à une. Le fichier reste alors la référence, un relecteur peut lire la modification, et vous ne pouvez pas laisser une règle de test oubliée dans le pare-feu.

## Vérification
La politique est correcte lorsque chaque test positif réussit et que chaque test négatif est bloqué. Écrivez les contrôles dans un script. `t` exécute un test : il utilise `nc` depuis un conteneur vers une destination et un port, et compare le résultat à ce que vous attendez.

```bash
cat > check.sh <<'EOT'
#!/bin/sh
# usage: ./check.sh (run from ~/netsec-lab); prints PASS or FAIL for every flow in the policy
pass=0; fail=0
t() {  # t <expected: open|blocked> <from-container> <dst-ip> <port>
  if podman exec "lab-netsec-$2" nc -w 2 -z "$3" "$4" >/dev/null 2>&1; then got=open; else got=blocked; fi
  if [ "$got" = "$1" ]; then r=PASS; pass=$((pass+1)); else r=FAIL; fail=$((fail+1)); fi
  printf '%s  %-7s -> %-12s :%-5s expected %-7s got %s\n' "$r" "$2" "$3" "$4" "$1" "$got"
}
t open    client 10.40.2.10 80
t blocked client 10.40.2.10 22
t blocked client 10.40.2.10 8080
t blocked client 10.40.3.10 5432
t blocked client 10.40.3.10 22
t open    web    10.40.3.10 5432
t blocked web    10.40.3.10 22
t blocked web    203.0.113.10 80
t blocked db     10.40.2.10 80
echo "passed=$pass failed=$fail"
[ "$fail" -eq 0 ]
EOT
chmod +x check.sh
./check.sh; echo rc=$?
```

Sortie attendue (l'exécution prend environ 15 secondes, car chaque test bloqué attend 2 secondes) :
```text
PASS  client  -> 10.40.2.10   :80    expected open    got open
PASS  client  -> 10.40.2.10   :22    expected blocked got blocked
PASS  client  -> 10.40.2.10   :8080  expected blocked got blocked
PASS  client  -> 10.40.3.10   :5432  expected blocked got blocked
PASS  client  -> 10.40.3.10   :22    expected blocked got blocked
PASS  web     -> 10.40.3.10   :5432  expected open    got open
PASS  web     -> 10.40.3.10   :22    expected blocked got blocked
PASS  web     -> 203.0.113.10 :80    expected blocked got blocked
PASS  db      -> 10.40.2.10   :80    expected blocked got blocked
passed=9 failed=0
rc=0
```

Critères de réussite :
- Les neuf lignes indiquent `PASS` et le script se termine avec `rc=0`. Les deux lignes `open` sont vos deux flux autorisés ; les sept lignes `blocked` sont les tests négatifs.
- `podman exec lab-netsec-fw nft list chain inet lab_fw forward` n'affiche que les cinq règles de l'étape 7 (aucune règle 8080), avec des compteurs non nuls sur les deux règles d'acceptation et sur l'abandon.
- Un scan depuis le client (étape 8) ne montre que le port 80 ouvert sur `10.40.2.10` et rien d'ouvert sur `10.40.3.10`.

> [!NOTE]
> Ce script considère « la connexion a échoué » comme « bloquée ». Un refus et un délai d'attente dépassé comptent tous deux. Dans ce lab, c'est acceptable, car les services testés sont à l'écoute : un échec signifie donc que le pare-feu a abandonné le paquet. Sur un vrai réseau, rappelez-vous la différence : un refus signifie que le paquet est arrivé, un délai d'attente signifie que quelque chose l'a abandonné.

## Dépannage
| Symptôme | Cause probable | Correction |
|---|---|---|
| `nmap` affiche « Couldn't open a raw socket » | Vous avez utilisé `-sS` ou omis `-Pn` : les deux nécessitent des sockets bruts, que le conteneur sans privilèges root n'a pas | Utilisez `-sT -Pn` comme dans le lab |
| Tout expire depuis le client, même le port 80, avant que vous ne chargiez la moindre règle | Une route manque : le client a besoin de `10.40.0.0/16 via 203.0.113.254`, les serveurs ont besoin de leur route par défaut | Comparez `podman exec lab-netsec-client ip route` avec l'étape 5. Recréez le conteneur auquel il manque la route |
| Le port 80 est bloqué après le chargement de la politique | Les noms d'interface ou les adresses de la règle ne correspondent pas, ou le fichier a été modifié | `nft list chain inet lab_fw forward` : si le compteur `internet to web` est à 0 alors que le compteur d'abandon augmente, la règle ne correspond pas. Vérifiez `net0`, `dmz0` et `10.40.2.10` |
| Le journal des abandons (`/tmp/drops.log`) est vide mais le compteur d'abandon augmente | La capture ne tournait pas au moment du test, ou la règle de journalisation manque, ou le groupe de journalisation diffère | Lancez d'abord la capture (étape 9) et testez pendant ses 60 secondes. Vérifiez que la règle indique `group 1` |
| `Error: No such file or directory` au chargement des règles | Le binaire `nft` ne peut pas créer la table : le conteneur n'a pas `NET_ADMIN`, ou le fichier contient une faute de frappe | Vérifiez le `--cap-add NET_ADMIN` du `podman run` de l'étape 4. Lisez le numéro de ligne affiché avec l'erreur |
| `the container name "lab-netsec-fw" is already in use` | Un conteneur d'une tentative précédente est resté | Exécutez le [Nettoyage](#nettoyage), puis recommencez |
| Une nouvelle règle n'ouvre pas le port | La règle a été ajoutée après l'abandon final | Listez avec `nft -a`, supprimez par handle et `insert ... position <handle>` avant la règle de journalisation (étape 10) |

## Défi (facultatif)
Étendez la politique sans aide pas à pas :
1. Le serveur web doit télécharger des mises à jour. Démarrez un petit serveur web dans le conteneur client sur TCP 8000 (`httpd -p 8000` avec un dossier de votre choix), et écrivez la règle **la plus étroite** qui permette à `lab-netsec-web` (et à lui seul) d'ouvrir des connexions vers `203.0.113.10` sur TCP 8000. Prouvez avec `./check.sh` (ajoutez le test) et un scan que rien d'autre n'a été ouvert.
2. Ajoutez un quatrième hôte dans la zone interne, `lab-netsec-admin` en `10.40.3.20`, qui peut ouvrir des connexions vers le serveur web sur TCP 22, et personne d'autre. Où placez-vous la règle, et quel test prouve que la base de données ne peut pas faire de même ?
3. Transformez la règle orientée Internet en **rejet** (*reject*) plutôt qu'en abandon (`reject with tcp reset`) pour un seul port, et comparez la façon dont un scan le signale avec `filtered`.

## Nettoyage
Supprimez tous les conteneurs, les réseaux et l'image créés par ce lab, puis le dossier. `-t 0` évite l'attente de 10 secondes pour les conteneurs qui ignorent le signal d'arrêt.

```bash
podman rm -f -t 0 lab-netsec-client lab-netsec-web lab-netsec-db lab-netsec-fw
podman network rm lab-netsec-internet lab-netsec-dmz lab-netsec-internal
podman rmi lab-netsec-tools:1
cd ~ && rm -rf ~/netsec-lab
podman ps -a --filter name=lab-netsec --format '{{.Names}}'
podman network ls --filter name=lab-netsec --format '{{.Name}}'
```

Les deux dernières commandes n'affichent rien lorsque le nettoyage est terminé. L'image de base Alpine reste dans le stockage de Podman (environ 8 Mo) ; supprimez-la avec `podman rmi docker.io/library/alpine:3.20.10` si aucun autre lab n'en a besoin.

## Ce que vous avez appris
- Scanner depuis l'extérieur montre la surface d'attaque réelle ; scanner depuis chaque zone teste aussi les règles internes.
- Un jeu de règles à états et à refus par défaut n'a besoin de règles que pour les flux que vous voulez : ici, deux règles de nouvelle connexion et une règle `established` ont suffi.
- `closed` signifie refusé et `filtered` signifie abandonné : les abandons d'un pare-feu ressemblent à du silence.
- Le filtrage sortant et le confinement par la DMZ font qu'un serveur web pris peut joindre un seul port de la base de données et rien d'autre.
- Les compteurs de règles et le journal des abandons doivent concorder ; ensemble, ils prouvent qu'un flux a été bloqué par votre politique.
- L'ordre des règles compte : une règle placée après l'abandon final ne correspond jamais. Conservez les règles dans un fichier et rechargez le fichier.