Affichage du Markdown brut : le moteur de rendu n'a pas pu être chargé.
## Objectif
Vous démarrez un petit serveur web, l'inondez depuis deux conteneurs « bots » sur un réseau isolé et observez un utilisateur normal rester bloqué. Vous identifiez les attaquants dans le journal d'accès. Ensuite, vous activez la limitation de débit, répétez l'inondation, et constatez que les requêtes en excès sont refusées avec le statut HTTP 429 tandis que l'utilisateur normal est servi à pleine vitesse.
## Objectifs
- Mesurer la latence normale d'un serveur web (niveau de référence) et sa latence sous inondation.
- Détecter l'inondation en comptant les requêtes par adresse cliente et par code de statut dans le journal d'accès.
- Activer la limitation de débit (`limit_req`) et la limitation de connexions (`limit_conn`) de nginx, et la recharger sans interruption de service.
- Montrer que la limite refuse l'inondation (statut 429) tout en servant un client normal (statut 200).
- Lire le paramètre SYN cookies de l'hôte et d'un conteneur, et expliquer son rôle.
## Prérequis
- Une machine Linux avec **Podman 4 ou version ultérieure** 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 les images nginx et Alpine Linux (quelques dizaines de Mo au total) et deux petits paquets (environ 8 Mo). Ensuite, plus rien dans le lab n'a besoin d'Internet.
- Environ 400 Mo d'espace disque libre et au moins 2 cœurs de processeur.
- La [leçon](lesson.fr.md) de ce module. Les techniques Podman sont celles du [lab Sécurité réseau](../06-network-security/lab.fr.md) : réseaux `--internal`, images épinglées, conteneurs sans privilèges root.
> [!WARNING]
> **Autorisation et éthique.** Inonder un système qui ne vous appartient pas ou que vous n'avez pas été expressément autorisé par écrit à tester est illégal dans la plupart des pays, et nuit à autrui même si vous parlez de test. Dans ce lab, l'« attaque » ne s'exécute qu'entre quatre conteneurs que vous créez vous-même, sur un réseau créé avec `--internal` (rien ne quitte votre machine). La charge est modeste et plafonnée par la durée (15 secondes) et par le nombre de workers. Ne dirigez jamais les outils de ce lab vers autre chose, pas même votre propre serveur chez un hébergeur, sans avoir d'abord lu les règles de l'hébergeur sur les tests de charge.
## 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="ddos-lab-architecture-fr-title ddos-lab-architecture-fr-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="fr">
<title id="ddos-lab-architecture-fr-title">Architecture du TP : un serveur web, deux bots et un utilisateur normal sur un réseau isolé</title>
<desc id="ddos-lab-architecture-fr-desc">Un réseau interne Podman, lab-ddos-net, 10.60.0.0/24. Le conteneur du serveur web lab-ddos-web est en 10.60.0.10, tcp 80, exécute nginx 1.31.6-alpine avec une limite de CPU de 0,5 et une limite de mémoire de 128 Mo, et sert /report.html, une page que nginx compresse en gzip niveau 9 à chaque requête. Son limits.conf est d'abord vide, puis rempli avec limit_req à 5 requêtes par seconde avec un burst de 10, limit_conn à 10 par adresse et le statut 429 en cas de dépassement. Deux conteneurs bot, lab-ddos-bot1 en 10.60.0.20 et lab-ddos-bot2 en 10.60.0.21, exécutent chacun hey pendant 15 secondes avec 25 travailleurs simultanés et envoient une inondation de requêtes au serveur web par des traits rouges épais. Un conteneur d'utilisateur normal, lab-ddos-user en 10.60.0.30, envoie une requête normale avec curl par un trait vert fin. À gauche, une carte du dossier ~/ddos-lab de votre hôte liste nginx.conf, conf/limits.conf et www/report.html, montés en lecture seule dans le conteneur web. Une note indique que le réseau est interne : rien ne quitte votre machine.</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="300" y="20" width="860" height="470" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(316 33) 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="342" y="47" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">lab-ddos-net · 10.60.0.0/24 · --internal</text></g>
<rect class="dg-card" x="20" y="130" width="240" height="150" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l3"><g class="dg-icon" transform="translate(36 146) scale(1.2500)" fill="none" stroke="#b45309" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"/><path d="M14 2v4a2 2 0 0 0 2 2h4"/><path d="M10 9H8"/><path d="M16 13H8"/><path d="M16 17H8"/></g></g>
<g class="dg-l3"><text x="78" y="167" font-size="14" class="dg-ink" fill="#b45309" font-weight="700">~/ddos-lab sur votre hôte</text></g>
<text x="38" y="198" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">nginx.conf</text>
<text x="38" y="218" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">conf/limits.conf</text>
<text x="38" y="238" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">www/report.html</text>
<g class="dg-l3"><path class="dg-stroke" d="M260 205H460" stroke="#b45309" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="7 6"/></g>
<g class="dg-l3"><path class="dg-stroke" d="M471 199l8 6-8 6" stroke="#b45309" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<text x="20" y="308" font-size="11.5" class="dg-muted" fill="#5c5c68" font-weight="500">montés en lecture seule dans le conteneur web</text>
<rect class="dg-card" x="480" y="80" width="320" height="280" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(496 96) 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="538" y="117" font-size="15" class="dg-ink" fill="#c2410c" font-weight="700">lab-ddos-web</text></g>
<text x="498" y="148" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.60.0.10/24 · tcp 80</text>
<text x="498" y="168" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">nginx 1.31.6-alpine</text>
<text x="498" y="188" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">--cpus 0.5 · --memory 128m</text>
<text x="498" y="208" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">/report.html : gzip niveau 9 à chaque requête</text>
<text x="498" y="250" font-size="12" class="dg-muted" fill="#5c5c68" font-weight="700">limits.conf : d'abord désactivé, puis activé</text>
<rect class="dg-tint" x="494" y="262" width="292" height="24" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="504" y="278.5" font-size="11.5" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">limit_req 5r/s, burst 10</text>
<rect class="dg-tint" x="494" y="292" width="292" height="24" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="504" y="308.5" font-size="11.5" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">limit_conn 10 par adresse</text>
<rect class="dg-tint" x="494" y="322" width="292" height="24" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="504" y="338.5" font-size="11.5" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">statut 429 en cas de dépassement</text>
<rect class="dg-card" x="900" y="60" width="240" height="94" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-warn"><g class="dg-icon" transform="translate(916 76) scale(1.2500)" fill="none" stroke="#b91c1c" 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-warn"><text x="958" y="97" font-size="13.5" class="dg-ink" fill="#b91c1c" font-weight="700">lab-ddos-bot1</text></g>
<text x="918" y="128" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.60.0.20/24</text>
<text x="918" y="148" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">hey -z 15s -c 25 -q 20</text>
<rect class="dg-card" x="900" y="170" width="240" height="94" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-warn"><g class="dg-icon" transform="translate(916 186) scale(1.2500)" fill="none" stroke="#b91c1c" 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-warn"><text x="958" y="207" font-size="13.5" class="dg-ink" fill="#b91c1c" font-weight="700">lab-ddos-bot2</text></g>
<text x="918" y="238" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.60.0.21/24</text>
<text x="918" y="258" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">hey -z 15s -c 25 -q 20</text>
<g class="dg-warn"><path class="dg-stroke" d="M900 107H850V135H810" stroke="#b91c1c" stroke-width="6" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><path class="dg-stroke" d="M900 217H850V165H810" stroke="#b91c1c" stroke-width="6" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><path class="dg-stroke" d="M811 129l-8 6 8 6" stroke="#b91c1c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><path class="dg-stroke" d="M811 159l-8 6 8 6" stroke="#b91c1c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><rect class="dg-bg-plain" x="807.4" y="138" width="85.2" height="24" rx="12" fill="#ffffff"/><text x="850" y="154.5" font-size="12" class="dg-ink" fill="#b91c1c" font-weight="600" text-anchor="middle">inondation</text></g>
<rect class="dg-card" x="900" y="330" width="240" height="94" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(916 346) scale(1.2500)" fill="none" stroke="#15803d" 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-l2"><text x="958" y="367" font-size="13.5" class="dg-ink" fill="#15803d" font-weight="700">lab-ddos-user</text></g>
<text x="918" y="398" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.60.0.30/24</text>
<text x="918" y="418" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">curl : une requête normale</text>
<g class="dg-l2"><path class="dg-stroke" d="M900 377H850V300H810" stroke="#15803d" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l2"><path class="dg-stroke" d="M811 294l-8 6 8 6" stroke="#15803d" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l2"><rect class="dg-bg-plain" x="810.76" y="328" width="78.48" height="24" rx="12" fill="#ffffff"/><text x="850" y="344.5" font-size="12" class="dg-ink" fill="#15803d" font-weight="600" text-anchor="middle">1 requête</text></g>
<g class="dg-l1"><rect class="dg-tint" x="416" y="516" width="348" height="26" rx="13" fill="#e6f0f6" stroke="#8ebcd5" stroke-width="1.2"/><text x="590" y="533.5" font-size="12" class="dg-ink" fill="#0369a1" font-weight="700" text-anchor="middle">Réseau interne : rien ne quitte votre machine</text></g>
</svg></figure>
*Figure 1. Deux bots et un utilisateur normal se partagent un petit serveur web. Au début, rien ne limite les bots ; plus tard, `limits.conf` le fait.*
| Conteneur | Adresse | Rôle |
|---|---|---|
| `lab-ddos-web` | `10.60.0.10`, TCP 80 | nginx, limité à un demi-CPU et 128 Mo, qui sert `/report.html` |
| `lab-ddos-bot1` | `10.60.0.20` | Un « bot » : inonde le serveur web avec `hey` |
| `lab-ddos-bot2` | `10.60.0.21` | Un second bot (pour que l'attaque provienne de plus d'une adresse) |
| `lab-ddos-user` | `10.60.0.30` | Un utilisateur normal : quelques requêtes `curl` |
**Pourquoi cette page est « coûteuse ».** nginx sert un petit fichier statique presque gratuitement, et aucun petit lab ne pourrait l'inonder. `/report.html` est donc un gros fichier texte (environ 900 Ko) que nginx doit **compresser avec gzip à chaque requête**, ce qui consomme réellement du temps de processeur. Le conteneur web ne peut utiliser qu'un demi-CPU, et nginx exécute un seul processus worker. Le serveur a ainsi une capacité d'environ 20 requêtes par seconde, facile à dépasser dans un lab, et qui représente n'importe quelle page coûteuse à produire (une recherche, un rapport, une requête de base de données).
> [!NOTE]
> Une seule adresse qui inonde un serveur est, à strictement parler, une attaque DoS. Le lab utilise deux conteneurs bots pour montrer que les limites s'appliquent par adresse, et pour vous faire réfléchir à ce qui se passe avec des milliers. Les conclusions sont les mêmes.
## Étapes
### Étape 1 — Vérifier vos outils et créer un dossier de travail (3 min)
Assurez-vous que Podman fonctionne sans privilèges root et utilise 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-ddos --format '{{.Names}}'
podman network ls --filter name=lab-ddos --format '{{.Name}}'
mkdir -p ~/ddos-lab && cd ~/ddos-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-ddos-`, exécutez d'abord le [Nettoyage](#nettoyage). Toutes les commandes qui suivent supposent que vous êtes dans `~/ddos-lab`. Si vous ouvrez un nouveau terminal, exécutez de nouveau `cd ~/ddos-lab`.
### Étape 2 — Construire l'image des outils (4 min)
Les bots et l'utilisateur ont besoin de deux outils : `curl` (une requête, avec mesure du temps) et `hey` (un générateur de charge HTTP : de nombreuses requêtes à la fois, avec un récapitulatif). Alpine Linux fournit les deux. L'étiquette est épinglée sur Alpine 3.20.10.
```bash
cat > Containerfile <<'EOT'
FROM docker.io/library/alpine:3.20.10
RUN apk add --no-cache hey curl
EOT
podman build -t lab-ddos-tools:1 . 2>&1 | tail -4
podman run --rm lab-ddos-tools:1 sh -c 'cat /etc/alpine-release; apk list -I 2>/dev/null | grep -E "^(hey|curl)-"'
```
Sortie attendue (l'identifiant de l'image et les versions des paquets peuvent différer légèrement) :
```text
COMMIT lab-ddos-tools:1
--> 5b5d9cc480f1
Successfully tagged localhost/lab-ddos-tools:1
5b5d9cc480f1dd3f292ce2e615536cf0b39fcbd2c72460b0be3b8fc2e8c51b88
3.20.10
curl-8.14.1-r2 x86_64 {curl} (curl) [installed]
hey-0.1.4-r26 x86_64 {hey} (Apache-2.0) [installed]
```
La construction utilise une fois votre réseau normal, pour télécharger les paquets. Les conteneurs du lab n'auront aucun accès réseau extérieur.
### Étape 3 — Écrire les fichiers du serveur web (5 min)
nginx a besoin de trois fichiers, conservés sur votre hôte et montés dans le conteneur. Voici le rôle de chacun :
- `www/report.html` est la page coûteuse : 150 000 lignes de nombres.
- `nginx.conf` est la configuration complète du serveur. Il active gzip au niveau 9 (la partie coûteuse), envoie le journal d'accès vers la sortie standard afin que vous puissiez le lire avec `podman logs`, et **définit** deux compteurs par adresse cliente (`limit_req_zone`, `limit_conn_zone`). Les définir ne limite encore rien.
- `conf/limits.conf` est inclus par le bloc server. Il est vide pour l'instant. À l'Étape 8, vous y placez les limites.
```bash
mkdir -p conf www
seq 1 150000 > www/report.html
echo '# no limits yet' > conf/limits.conf
cat > nginx.conf <<'EOT'
worker_processes 1;
error_log /dev/stderr notice;
pid /tmp/nginx.pid;
events {
worker_connections 1024;
}
http {
include /etc/nginx/mime.types;
access_log /dev/stdout;
# An "expensive" page: nginx compresses it on every request, which costs CPU.
gzip on;
gzip_comp_level 9;
# Two counters, one per client address. They do nothing until limits.conf uses them.
limit_req_zone $binary_remote_addr zone=perip:1m rate=5r/s;
limit_conn_zone $binary_remote_addr zone=connperip:1m;
server {
listen 80;
root /usr/share/nginx/html;
location /report.html {
alias /srv/www/report.html;
}
include /etc/nginx/lab/limits.conf;
}
}
EOT
wc -lc www/report.html
```
Sortie attendue :
```text
150000 938895 www/report.html
```
Le fichier compte 150 000 lignes et 938 895 octets (environ 0,9 Mo). `rate=5r/s` est la limite que vous activerez plus tard : cinq requêtes par seconde et par adresse cliente.
### Étape 4 — Créer le réseau isolé et les quatre conteneurs (5 min)
Un seul réseau Podman constitue tout le lab. `--internal` signifie que Podman n'ajoute aucune route vers l'extérieur et aucun NAT vers votre hôte : rien ne peut donc quitter votre machine. `10.60.0.0/24` est une plage privée ([RFC 1918](https://www.rfc-editor.org/rfc/rfc1918)).
Le conteneur web reçoit `--cpus 0.5` et `--memory 128m` : il peut utiliser au plus un demi-CPU, il est donc facile à surcharger et ne peut jamais nuire à votre machine. `:ro,Z` monte les fichiers en lecture seule (l'étiquette `Z` les rend lisibles sur les systèmes avec SELinux, comme Fedora, et n'a aucun effet ailleurs). L'étiquette de l'image est épinglée sur une version exacte. Les trois autres conteneurs exécutent simplement `sleep infinity` ; vous y lancez des commandes avec `podman exec`.
```bash
podman network create --internal --subnet 10.60.0.0/24 lab-ddos-net
podman network inspect lab-ddos-net --format '{{.Name}} subnet={{(index .Subnets 0).Subnet}} internal={{.Internal}}'
podman run -d --name lab-ddos-web --network lab-ddos-net:ip=10.60.0.10 --cpus 0.5 --memory 128m \
-v ~/ddos-lab/nginx.conf:/etc/nginx/nginx.conf:ro,Z \
-v ~/ddos-lab/conf:/etc/nginx/lab:ro,Z \
-v ~/ddos-lab/www:/srv/www:ro,Z \
docker.io/library/nginx:1.31.6-alpine
podman run -d --name lab-ddos-bot1 --network lab-ddos-net:ip=10.60.0.20 lab-ddos-tools:1 sleep infinity
podman run -d --name lab-ddos-bot2 --network lab-ddos-net:ip=10.60.0.21 lab-ddos-tools:1 sleep infinity
podman run -d --name lab-ddos-user --network lab-ddos-net:ip=10.60.0.30 lab-ddos-tools:1 sleep infinity
podman ps --filter name=lab-ddos --format 'table {{.Names}}\t{{.Status}}'
podman exec lab-ddos-web nginx -v
```
Sortie attendue (les quatre longs identifiants de conteneurs varient ; la première exécution télécharge l'image nginx) :
```text
lab-ddos-net
lab-ddos-net subnet=10.60.0.0/24 internal=true
e296e3434133eb65348ff7d7faddaf2d1ef80540dde41d434314abaab37b7fb4
8dbf7b4179c98cbd8c67e41f33c93215f78b912f4e397d48016d7a14a584be7d
1c262b3347113f409267c40260d01089054015daad18efbe960669ee88773df1
24f0c870b1f753edee63a94317a8c675d407a974608211a5982aca0caed2af03
NAMES STATUS
lab-ddos-web Up Less than a second
lab-ddos-bot1 Up Less than a second
lab-ddos-bot2 Up Less than a second
lab-ddos-user Up Less than a second
nginx version: nginx/1.31.6
```
Vérifiez maintenant l'isolation. Le conteneur utilisateur n'a qu'une seule route, vers le réseau du lab uniquement, et une connexion vers une adresse extérieure (`192.0.2.1` est une adresse de documentation, [RFC 5737](https://www.rfc-editor.org/rfc/rfc5737)) échoue aussitôt faute de route :
```bash
podman exec lab-ddos-user ip route
podman exec lab-ddos-user curl -sS -m 3 -o /dev/null http://192.0.2.1/ ; echo "curl exit code: $?"
```
Sortie attendue :
```text
10.60.0.0/24 dev eth0 scope link src 10.60.0.30
curl: (7) Failed to connect to 192.0.2.1 port 80 after 0 ms: Could not connect to server
curl exit code: 7
```
Le code de sortie 7 signifie « échec de connexion ». Les outils d'attaque ne peuvent atteindre que le serveur web.
### Étape 5 — Niveau de référence : quelle est la vitesse du serveur quand personne n'attaque ? (5 min)
Avant une attaque, vous devez savoir à quoi ressemble la normale. C'est votre **niveau de référence (baseline)**. D'abord une requête de l'utilisateur normal, avec sa mesure de temps (`--compressed` demande gzip, comme le fait tout navigateur, afin que le serveur effectue le travail coûteux). Ensuite 30 requêtes, l'une après l'autre (`-c 1` signifie une à la fois), avec `hey`.
```bash
podman exec lab-ddos-user curl -sS --compressed -m 5 -o /dev/null -w 'status=%{http_code} time=%{time_total}s\n' http://10.60.0.10/report.html
podman exec lab-ddos-user hey -n 30 -c 1 http://10.60.0.10/report.html 2>&1 | grep -E 'Total:|Average:|Slowest:|Requests/sec|^ \[[0-9]+\]'
```
Sortie attendue (les temps varient ; c'est l'ordre de grandeur qui compte) :
```text
status=200 time=0.030266s
Total: 1.6079 secs
Slowest: 0.1015 secs
Average: 0.0536 secs
Requests/sec: 18.6580
[200] 30 responses
```
Comment lire ce résultat : `status=200` signifie « OK ». Une requête prend environ 30 à 50 millisecondes (ms), à cause de la compression. Les 30 ont reçu `[200]`. Le serveur traite environ **18 requêtes par seconde** lorsqu'un client demande une page à la fois, ce qui correspond approximativement à sa capacité. Notez le niveau de référence : **environ 0,03 seconde pour un utilisateur normal**.
### Étape 6 — Inonder le serveur et voir ce que perçoit un utilisateur normal (8 min)
Voici maintenant l'« attaque ». Chaque bot exécute `hey` pendant 15 secondes (`-z 15s`) avec 25 workers (`-c 25`), et chaque worker tente 20 requêtes par seconde (`-q 20`) : environ 500 requêtes par seconde par bot, 1 000 au total, face à un serveur qui peut en traiter environ 18. Les deux commandes `hey` s'exécutent en arrière-plan (`&`). Trois secondes plus tard, l'utilisateur normal demande une fois la même page. `wait` bloque jusqu'à la fin des bots. Votre shell peut afficher des lignes de tâches comme `[1] 12345` ; elles sont sans danger.
```bash
for b in bot1 bot2; do
podman exec lab-ddos-$b hey -z 15s -c 25 -q 20 http://10.60.0.10/report.html > flood1-$b.txt 2>&1 &
done
sleep 3
podman exec lab-ddos-user curl -sS --compressed -m 60 -o /dev/null -w 'status=%{http_code} time=%{time_total}s\n' http://10.60.0.10/report.html
wait
for b in bot1 bot2; do echo "== $b"; grep -E 'Total:|Average:|Requests/sec|^ \[[0-9]+\]' flood1-$b.txt; done
```
Sortie attendue (elle prend environ 20 secondes ; **les chiffres varient, le tableau d'ensemble non**) :
```text
status=200 time=14.640884s
== bot1
Total: 17.6109 secs
Average: 16.4463 secs
Requests/sec: 1.4764
[200] 26 responses
== bot2
Total: 16.5475 secs
Average: 1.3776 secs
Requests/sec: 17.2232
[200] 285 responses
```
Lisez attentivement :
- L'utilisateur normal a demandé la page une fois et a **attendu environ 15 secondes** (dans votre exécution : de nombreuses secondes, pas des millisecondes) une réponse qui prenait 0,03 seconde auparavant. Rien n'a été piraté et aucune donnée n'a été perdue, et pourtant le service est de fait hors service. C'est un déni de service.
- Chaque bot a tenté des milliers de requêtes, mais le serveur n'en a traité qu'environ 300 au total en 15 secondes, soit sa capacité. Les autres se sont mises en file d'attente ou ont expiré.
- Un bot a obtenu la plupart des réponses (ici `bot2` : 285 contre 26). Lequel varie ; nginx ne partage pas équitablement. C'est normal.
### Étape 7 — La détecter : lire le journal d'accès (5 min)
Le journal d'accès est votre premier outil de détection. nginx écrit une ligne par requête **terminée** sur sa sortie standard, et `podman logs` l'affiche. Cette commande conserve dans un fichier les lignes des vraies requêtes (`GET`) et les compte : la première colonne est l'adresse cliente, la neuvième le statut HTTP.
```bash
podman logs lab-ddos-web 2>&1 | awk '$6=="\"GET"' > access-all.txt
wc -l < access-all.txt
awk '{print $1, $9}' access-all.txt | sort | uniq -c | sort -rn
```
Sortie attendue (les comptes varient légèrement) :
```text
343
285 10.60.0.21 200
32 10.60.0.30 200
26 10.60.0.20 200
```
Le programme `awk` affiche l'adresse et le statut de chaque ligne, `sort | uniq -c` compte les paires identiques, et `sort -rn` place les plus grosses en haut. Lecture du tableau :
- Les deux adresses `10.60.0.20` et `10.60.0.21` sont les **plus gros émetteurs** parmi les clients qui ont réussi à passer, et en réalité elles ont tenté bien davantage. L'utilisateur normal `10.60.0.30` apparaît avec les 32 requêtes du niveau de référence et l'unique requête qui a attendu.
- Remarquez une limite de cette méthode : **le journal ne liste que les requêtes que le serveur a terminées**. La surcharge a fait répondre le serveur à moins de requêtes, pas à plus : le journal sous-estime donc l'attaque. Une vraie détection exige aussi des compteurs au niveau réseau (paquets et connexions par seconde), la charge, la latence et le taux d'erreurs issus de la supervision. Dans le journal, le signal est que quelques adresses représentent l'essentiel du trafic.
### Étape 8 — Activer la limitation de débit et recharger (5 min)
Place à la défense. Le fichier `conf/limits.conf` reçoit quatre lignes :
- `limit_req zone=perip burst=10 nodelay;` applique le compteur `perip` : chaque adresse cliente peut effectuer **5 requêtes par seconde** (défini dans `nginx.conf`), et peut dépasser cette valeur d'une **rafale (burst)** de 10 requêtes supplémentaires. `nodelay` sert la rafale immédiatement au lieu de la ralentir. Les requêtes au-delà sont refusées.
- `limit_req_status 429;` fait du refus le statut HTTP `429 Too Many Requests` (la valeur par défaut est 503).
- `limit_conn connperip 10;` autorise chaque adresse à avoir au plus **10 connexions avec une requête en cours** simultanément. Cela aide quand chaque requête met longtemps à être servie (base de données lente, gros envoi). nginx ne commence à compter une requête qu'une fois ses en-têtes entièrement arrivés.
- `limit_conn_status 429;` lui donne le même statut.
```bash
cat > conf/limits.conf <<'EOT'
# At most 5 requests per second per client address, with a burst of 10 extra requests
limit_req zone=perip burst=10 nodelay;
limit_req_status 429;
# At most 10 simultaneous connections per client address
limit_conn connperip 10;
limit_conn_status 429;
EOT
podman exec lab-ddos-web nginx -t
podman exec lab-ddos-web nginx -s reload
```
Sortie attendue (la ligne `notice` indique l'heure de votre rechargement) :
```text
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
2026/11/07 20:08:04 [notice] 28#28: signal process started
```
`nginx -t` teste d'abord la configuration (faites-le toujours), et `nginx -s reload` fait démarrer de nouveaux workers nginx avec les nouvelles règles et retirer les anciens sans couper les connexions. Si le test échoue, rien n'est rechargé et les anciennes règles restent actives.
### Étape 9 — Inonder de nouveau, avec la limite activée (8 min)
La même attaque, les mêmes commandes. Cette fois, l'utilisateur normal demande trois fois, à une seconde d'intervalle, comme une personne qui recharge une page.
```bash
for b in bot1 bot2; do
podman exec lab-ddos-$b hey -z 15s -c 25 -q 20 http://10.60.0.10/report.html > flood2-$b.txt 2>&1 &
done
sleep 3
for i in 1 2 3; do
podman exec lab-ddos-user curl -sS --compressed -m 60 -o /dev/null -w 'status=%{http_code} time=%{time_total}s\n' http://10.60.0.10/report.html
sleep 1
done
wait
for b in bot1 bot2; do echo "== $b"; grep -E 'Total:|Average:|Requests/sec|^ \[[0-9]+\]' flood2-$b.txt; done
```
Sortie attendue (les comptes varient de quelques unités ; le tableau d'ensemble non) :
```text
status=200 time=0.030948s
status=200 time=0.029585s
status=200 time=0.029022s
== bot1
Total: 15.0048 secs
Average: 0.0193 secs
Requests/sec: 431.1286
[200] 81 responses
[429] 6388 responses
== bot2
Total: 15.0118 secs
Average: 0.0201 secs
Requests/sec: 442.9185
[200] 85 responses
[429] 6564 responses
```
Comparez avec l'Étape 6 :
| | Étape 6 : sans limite | Étape 9 : avec limite |
|---|---|---|
| Attente de l'utilisateur normal | environ 15 secondes | environ 0,03 seconde, comme au niveau de référence |
| Réponses reçues par chaque bot | un bot quelques centaines, l'autre presque aucune | environ 85 chacun |
| Refus (statut 429) | aucun | environ 6 400 par bot |
| Temps moyen par requête de bot | des secondes | environ 0,02 seconde |
Deux choses à remarquer. Premièrement, **l'utilisateur normal est servi à vitesse normale** : la limite est par adresse, et l'adresse de l'utilisateur est très en dessous. Deuxièmement, chaque bot n'a obtenu qu'environ 85 réponses. Ce n'est pas un hasard : `10 + 5 × 15 = 85`, la rafale plus 5 requêtes par seconde pendant 15 secondes. Tout le reste a été refusé par une minuscule réponse `429` qui ne coûte presque rien à produire, ce qui explique que le serveur soit de nouveau disponible.
### Étape 10 — Détecter et le prouver dans le journal (4 min)
La même analyse de journal qu'à l'Étape 7, mais uniquement sur les lignes écrites depuis l'instantané de l'Étape 7 (`tail -n +N` affiche à partir de la ligne N). Examinez ensuite une requête refusée et le journal d'erreurs de nginx lui-même.
```bash
podman logs lab-ddos-web 2>&1 | awk '$6=="\"GET"' | tail -n +$(( $(wc -l < access-all.txt) + 1 )) > access-flood2.txt
wc -l < access-flood2.txt
awk '{print $1, $9}' access-flood2.txt | sort | uniq -c | sort -rn
grep ' 429 ' access-flood2.txt | head -1
podman logs lab-ddos-web 2>&1 | grep 'limiting requests' | head -1
podman logs lab-ddos-web 2>&1 | grep -c 'limiting requests'
```
Sortie attendue (les comptes varient) :
```text
13121
6564 10.60.0.21 429
6388 10.60.0.20 429
85 10.60.0.21 200
81 10.60.0.20 200
3 10.60.0.30 200
10.60.0.21 - - [07/Nov/2026:20:08:05 +0000] "GET /report.html HTTP/1.1" 429 169 "-" "hey/0.0.1"
2026/11/07 20:08:05 [error] 29#29: *54 limiting requests, excess: 10.815 by zone "perip", client: 10.60.0.21, server: , request: "GET /report.html HTTP/1.1", host: "10.60.0.10"
12952
```
Le journal raconte maintenant clairement l'histoire : 13 121 requêtes en 15 secondes, presque toutes des `429` provenant de deux adresses, et l'utilisateur normal avec trois `200`. C'est le signal qu'utiliserait un système de détection. Deux autres observations :
- Le nombre de lignes `limiting requests` dans le journal d'erreurs (12 952) est égal au nombre de 429 dans le journal d'accès (6 388 + 6 564 = 12 952) : chaque refus est enregistré. Dans un système réel, vous déclencheriez une alerte sur un nombre élevé de 429 pour les mêmes adresses, et pourriez transmettre ces adresses à un pare-feu ou au fournisseur.
- `limit_conn` ne s'est jamais déclenché. nginx sert ici chaque requête en une seule courte rafale, donc une adresse n'a jamais plus d'une requête en cours, et les requêtes refusées reçoivent une réponse immédiate. `limit_conn` est utile quand les requêtes restent longtemps en cours, et ce n'est pas une défense contre les attaques lentes qui ne terminent jamais leurs en-têtes (voir le défi).
### Étape 11 — Lire le paramètre SYN cookies (4 min)
Les limites vues jusqu'ici concernent les inondations HTTP (couche 7). Contre une inondation SYN (couche 4, voir la leçon), le noyau Linux dispose de sa propre défense, les SYN cookies. Vous ne faites que **lire** le paramètre, à la fois sur votre machine et dans le conteneur web, ainsi que les compteurs du noyau. Vous n'avez rien à modifier, et une inondation SYN exige des paquets bruts, que ce lab n'utilise volontairement pas.
```bash
cat /proc/sys/net/ipv4/tcp_syncookies
podman exec lab-ddos-web cat /proc/sys/net/ipv4/tcp_syncookies
podman exec lab-ddos-web awk '/^TcpExt:/ { if (!h) { split($0, n); h = 1 } else { split($0, v); for (i = 2; i <= NF; i++) if (n[i] ~ /^(SyncookiesSent|SyncookiesRecv|SyncookiesFailed|ListenOverflows|ListenDrops)$/) print n[i], v[i] } }' /proc/net/netstat
```
Sortie attendue :
```text
1
1
SyncookiesSent 0
SyncookiesRecv 0
SyncookiesFailed 0
ListenOverflows 0
ListenDrops 0
```
Comment lire ce résultat :
- Les valeurs de `net.ipv4.tcp_syncookies` signifient : `0` cookies désactivés, `1` cookies **uniquement lorsque la file d'attente semi-ouverte déborde** (la valeur par défaut habituelle), `2` cookies toujours actifs. Vous voyez `1` aux deux endroits : votre système est protégé contre les inondations SYN d'office. Le conteneur possède sa propre copie du paramètre, dans son propre espace de noms réseau, et il démarre avec la même valeur.
- Les compteurs de la dernière commande sont l'enregistrement du noyau pour le réseau du conteneur : `SyncookiesSent` compte les cookies envoyés, et `ListenOverflows` et `ListenDrops` comptent les tentatives de connexion perdues parce que la file d'attente était pleine. Ils valent tous `0` : l'inondation HTTP a ouvert des connexions complètes, elle n'a pas rempli la file d'attente semi-ouverte, et les SYN cookies n'ont donc jamais eu à intervenir. C'est tout l'intérêt de la classification : la bonne défense dépend de la classe d'attaque, et un paramètre SYN cookies n'aurait pas sauvé le serveur de cette inondation, alors que la limite de débit l'a fait.
> [!NOTE]
> Vos compteurs peuvent ne pas être exactement à zéro si autre chose sur votre machine a utilisé le réseau du conteneur. La signification est la même : ils n'augmentent que lorsqu'une file d'attente semi-ouverte déborde.
## Vérification
Vérifiez ces résultats ; chacun doit se confirmer dans votre exécution :
| Contrôle | Résultat attendu |
|---|---|
| Niveau de référence (Étape 5) | Une requête normale reçoit `200` en quelques dizaines de millisecondes |
| Inondation sans limite (Étape 6) | L'utilisateur normal a attendu plusieurs secondes, pas des millisecondes |
| Journal d'accès (Étape 7) | Les deux adresses de bots représentent la plupart des lignes |
| Inondation avec limite (Étape 9) | L'utilisateur normal a reçu `200` en environ 0,03 s ; les bots ont reçu surtout des `429` et environ 85 `200` chacun |
| Journal d'accès (Étape 10) | Des lignes `429` pour les deux adresses de bots uniquement ; `200` pour `10.60.0.30` |
| SYN cookies (Étape 11) | `net.ipv4.tcp_syncookies` vaut `1` sur l'hôte et dans le conteneur |
Exécutez ce dernier test pour prouver de nouveau que l'utilisateur normal est servi tant que les limites sont actives :
```bash
for i in 1 2 3; do podman exec lab-ddos-user curl -sS --compressed -m 5 -o /dev/null -w '%{http_code}\n' http://10.60.0.10/report.html; done
```
Sortie attendue :
```text
200
200
200
```
## Dépannage
| Symptôme | Cause probable | Solution |
|---|---|---|
| `Error: ... cpu ... controller` ou `--cpus` n'est pas pris en charge au démarrage de `lab-ddos-web` | Le contrôleur CPU n'est pas délégué à votre utilisateur (systèmes anciens ou cgroup v1) | Supprimez `--cpus 0.5` et alourdissez la page : `seq 1 600000 > www/report.html`. L'effet de l'inondation à l'Étape 6 peut être plus faible ; utilisez `-c 50` dans la commande des bots |
| `podman run` échoue avec `permission denied` sur les fichiers montés | Étiquette SELinux ou chemin incorrect | Vérifiez que vous êtes dans `~/ddos-lab` et que les fichiers existent ; conservez les options `:Z` ; ne montez pas de fichiers situés hors de votre dossier personnel |
| L'Étape 6 ne montre aucun ralentissement pour l'utilisateur normal (environ 0,03 s) | Le serveur est plus rapide que prévu, ou l'inondation n'a pas démarré | Vérifiez que `flood1-bot1.txt` contient des lignes `[200]` et aucune erreur ; utilisez une page plus grosse (`seq 1 600000`) ou `-c 50` |
| `hey: not found` ou `curl: not found` | Vous avez exécuté la commande sur votre hôte ou dans le conteneur nginx | Préfixez avec `podman exec lab-ddos-user` (ou `-bot1`, `-bot2`), qui disposent de l'image des outils |
| Après le rechargement, toutes les réponses restent `200` (Étape 9) | `limits.conf` n'a pas été mis à jour ou le rechargement a échoué | `podman exec lab-ddos-web cat /etc/nginx/lab/limits.conf` affiche le fichier que voit nginx ; exécutez `nginx -t` et lisez la ligne dont il se plaint |
| `nginx -t` indique `unknown directive` ou `invalid parameter` | Une faute de frappe dans `limits.conf` | Comparez-le avec le texte de l'Étape 8 ; nginx conserve les anciennes règles tant que le test n'est pas réussi |
| L'utilisateur normal reçoit aussi `429` | L'utilisateur a demandé plus de 5 fois par seconde, rafale comprise | Attendez quelques secondes et redemandez, lentement. C'est la règle qui fonctionne : une limite peut aussi toucher de vrais utilisateurs très rapides, ou qui partagent une adresse |
| `Error: ... name "lab-ddos-web" is already in use` | Un conteneur d'une tentative précédente existe | Exécutez le [Nettoyage](#nettoyage), puis recommencez |
| Les comptes de vos tableaux diffèrent de cette page | Le temps, la vitesse du processeur et l'ordonnancement diffèrent sur chaque machine | Comparez le *tableau d'ensemble* : des secondes contre des millisecondes, et des milliers de `429` contre environ 85 `200` par bot |
## Défi (facultatif)
Sans aide pas à pas, essayez l'un ou plusieurs de ces défis, puis restaurez les fichiers de l'Étape 8 :
1. **Une attaque lente.** Les attaques de type Slowloris ouvrent une connexion et envoient un en-tête de requête très lentement, sans jamais le terminer. Depuis `lab-ddos-bot1`, utilisez `nc` pour ouvrir une connexion vers `10.60.0.10` port 80 et n'envoyer que la première ligne d'une requête, puis attendez. Quel paramètre nginx finit par fermer une telle connexion (cherchez `client_header_timeout` dans la documentation de nginx) ? Pourquoi `limit_conn` ne la voit-il pas ?
2. **Une limite globale.** Ajoutez un second compteur indexé sur `$server_name` avec un débit de 30 requêtes par seconde, et appliquez-le à `/report.html`. Que devient l'utilisateur normal pendant une inondation, maintenant ? Que vous enseigne cela sur les limites par adresse face à un botnet de milliers d'adresses ?
3. **Des pages moins coûteuses.** Mettez en cache la page compressée : cherchez `gzip_static` ou `proxy_cache` dans la documentation de nginx, et mesurez comment la capacité du serveur change au niveau de référence. À quelle couche de la figure de défense de la leçon cela correspond-il ?
## Nettoyage
Supprimez toutes les ressources créées par le lab. `-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-ddos-web lab-ddos-bot1 lab-ddos-bot2 lab-ddos-user
podman network rm lab-ddos-net
podman rmi lab-ddos-tools:1
cd ~ && rm -rf ~/ddos-lab
podman ps -a --filter name=lab-ddos --format '{{.Names}}'
podman network ls --filter name=lab-ddos --format '{{.Name}}'
```
Les deux dernières commandes n'affichent rien lorsque tout a disparu. Les images téléchargées `docker.io/library/nginx:1.31.6-alpine` et `alpine:3.20.10` restent dans votre stockage d'images (elles sont partagées avec d'autres travaux) ; supprimez-les avec `podman rmi` si vous voulez récupérer l'espace.
## Ce que vous avez appris
- Une inondation n'a pas besoin d'être énorme pour nuire : un serveur de capacité limitée a transformé un ensemble de requêtes d'apparence anodine en une attente de 15 secondes pour un utilisateur normal.
- Un niveau de référence de la latence et du trafic normaux vous indique aussitôt que quelque chose ne va pas, et le journal d'accès, compté par adresse et par statut, montre qui est responsable.
- Une limitation de débit par adresse (`limit_req`, statut 429) refuse l'excédent à peu de frais, garde le serveur réactif et laisse passer les utilisateurs normaux ; les requêtes refusées ne coûtent presque rien à traiter.
- L'arithmétique d'une limite est prévisible : rafale plus débit multiplié par la durée, ici `10 + 5 × 15 = 85` réponses par bot. Face à des milliers d'adresses, la somme est grande : il faut donc aussi des couches en amont.
- Les SYN cookies protègent contre une autre classe (l'épuisement d'états) : le paramètre vaut `1` par défaut sous Linux, et il n'a pas joué ici parce que l'inondation était une inondation HTTP.