CloudAcademia
IT

Cybersecurity · Modulo 09 · Attacchi DDoS: che cosa sono e come difendersi

Laboratorio: limitare la frequenza delle richieste di un server web sottoposto a un'inondazione simulata

Laboratorio50 minIntermedioMarkdown

Viene mostrato il Markdown grezzo: non è stato possibile caricare il visualizzatore.

## Obiettivo
Avvii un piccolo server web, lo inondi di richieste da due container «bot» su una rete isolata e osservi un utente normale restare bloccato. Individui gli attaccanti nel log di accesso. Poi attivi la limitazione della frequenza, ripeti l'inondazione e vedi le richieste in eccesso rifiutate con lo stato HTTP 429, mentre l'utente normale viene servito a piena velocità.

## Obiettivi
- Misurare la latenza normale di un server web (riferimento di base, baseline) e la sua latenza sotto inondazione.
- Rilevare l'inondazione contando le richieste per indirizzo del client e per codice di stato nel log di accesso.
- Abilitare in nginx la limitazione della frequenza (`limit_req`) e il limite di connessioni (`limit_conn`) e ricaricare la configurazione senza interruzioni.
- Dimostrare che il limite rifiuta l'inondazione (stato 429) ma continua a servire un client normale (stato 200).
- Leggere l'impostazione dei SYN cookie dell'host e di un container e spiegare a che cosa serve.

## Prerequisiti
- Un computer Linux con **Podman 4 o successivo** in esecuzione in modalità **rootless** (come utente normale; non ti serve mai `sudo`) e con il backend di rete netavark. Verificato con Podman 5.8.7 su Fedora con kernel 7.2. Controlla con `podman info --format '{{.Host.NetworkBackend}}'`: deve stampare `netavark`.
- Accesso a Internet una sola volta, per scaricare le immagini nginx e Alpine Linux (alcune decine di MB in totale) e due piccoli pacchetti (circa 8 MB). Dopodiché nulla nel laboratorio richiede Internet.
- Circa 400 MB di spazio libero su disco e almeno 2 core di CPU.
- La [lezione](lesson.it.md) di questo modulo. Le tecniche per Podman sono quelle del [laboratorio sulla sicurezza di rete](../06-network-security/lab.it.md): reti `--internal`, immagini con versione fissata, container rootless.

> [!WARNING]
> **Autorizzazione ed etica.** Inondare di traffico un sistema che non possiedi, o per il quale non hai un'autorizzazione scritta esplicita a eseguire verifiche, è illegale nella maggior parte dei paesi e danneggia altre persone anche se lo definisci un test. In questo laboratorio l'«attacco» avviene solo tra quattro container che crei tu, su una rete creata con `--internal` (nulla esce dal tuo computer). Il carico è modesto e limitato nel tempo (15 secondi) e dal numero di worker. Non puntare mai gli strumenti di questo laboratorio contro nient'altro, nemmeno contro il tuo stesso server presso un fornitore di hosting, senza aver letto prima le regole del fornitore sui test di carico.

## Architettura
<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-it-title ddos-lab-architecture-it-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="it">
<title id="ddos-lab-architecture-it-title">Architettura del laboratorio: un server web, due bot e un utente normale su una rete isolata</title>
<desc id="ddos-lab-architecture-it-desc">Una rete interna Podman, lab-ddos-net, 10.60.0.0/24. Il container del server web lab-ddos-web è a 10.60.0.10, tcp 80, esegue nginx 1.31.6-alpine con un limite di CPU di 0,5 e un limite di memoria di 128 MB, e serve /report.html, una pagina che nginx comprime con gzip livello 9 a ogni richiesta. Il suo limits.conf parte vuoto e in seguito viene riempito con limit_req di 5 richieste al secondo con un burst di 10, limit_conn di 10 per indirizzo e stato 429 se il limite è superato. Due container bot, lab-ddos-bot1 a 10.60.0.20 e lab-ddos-bot2 a 10.60.0.21, eseguono ciascuno hey per 15 secondi con 25 worker concorrenti e inviano un flood di richieste al server web su linee rosse spesse. Un container utente normale, lab-ddos-user a 10.60.0.30, invia una richiesta normale con curl su una linea verde sottile. A sinistra, una scheda della cartella ~/ddos-lab sul tuo host elenca nginx.conf, conf/limits.conf e www/report.html, montati in sola lettura nel container web. Una nota dice che la rete è interna: nulla esce dalla tua macchina.</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 sul tuo host</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">montati in sola lettura nel container 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 livello 9 a ogni richiesta</text>
<text x="498" y="250" font-size="12" class="dg-muted" fill="#5c5c68" font-weight="700">limits.conf: prima disattivato, poi attivato</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 per indirizzo</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">stato 429 se superato</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="824.2" y="138" width="51.6" 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">flood</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: una richiesta 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="804.04" y="328" width="91.92" 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 richiesta</text></g>
<g class="dg-l1"><rect class="dg-tint" x="423" y="516" width="334" 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">Rete interna: nulla esce dalla tua macchina</text></g>
</svg></figure>

*Figura 1. Due bot e un utente normale condividono un unico piccolo server web. All'inizio nulla limita i bot; più avanti lo fa `limits.conf`.*

| Container | Indirizzo | Ruolo |
|---|---|---|
| `lab-ddos-web` | `10.60.0.10`, TCP 80 | nginx, limitato a mezza CPU e 128 MB, che serve `/report.html` |
| `lab-ddos-bot1` | `10.60.0.20` | Un «bot»: inonda il server web con `hey` |
| `lab-ddos-bot2` | `10.60.0.21` | Un secondo bot (così l'attacco proviene da più di un indirizzo) |
| `lab-ddos-user` | `10.60.0.30` | Un utente normale: alcune richieste `curl` |

**Perché questa pagina è «costosa».** nginx serve un piccolo file statico quasi senza costi, e nessun laboratorio così piccolo potrebbe inondarlo. Perciò `/report.html` è un grande file di testo (circa 900 KB) che nginx deve **comprimere con gzip a ogni richiesta**, impegnando tempo di processore reale. Il container web può usare solo mezza CPU e nginx esegue un solo processo worker. Ne risulta una capacità del server di circa 20 richieste al secondo, facile da superare in un laboratorio, che rappresenta qualsiasi pagina costosa da generare (una ricerca, un report, un'interrogazione al database).

> [!NOTE]
> Un solo indirizzo che inonda un server è, a rigore, un attacco DoS. Il laboratorio usa due container bot per mostrare che i limiti si applicano per indirizzo e per farti riflettere su che cosa accadrebbe con migliaia di indirizzi. Le conclusioni sono le stesse.

## Passaggi

### Passo 1 — Verifica gli strumenti e crea una cartella di lavoro (3 min)
Assicurati che Podman sia in modalità rootless e usi netavark, e che non sia rimasto nulla di un tentativo precedente.

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

Output atteso (la tua versione può differire):
```text
podman version 5.8.7
netavark rootless=true
```

I due comandi `ls` non stampano nulla. Se elencano nomi che iniziano con `lab-ddos-`, esegui prima la [Pulizia](#pulizia). Tutti i comandi che seguono presuppongono che ti trovi in `~/ddos-lab`. Se apri un nuovo terminale, esegui di nuovo `cd ~/ddos-lab`.

### Passo 2 — Costruisci l'immagine degli strumenti (4 min)
I bot e l'utente hanno bisogno di due strumenti: `curl` (una singola richiesta, con la misurazione dei tempi) e `hey` (un generatore di carico HTTP: molte richieste contemporanee, con un riepilogo). Alpine Linux include entrambi. Il tag è fissato ad 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)-"'
```

Output atteso (l'ID dell'immagine e le versioni dei pacchetti possono differire leggermente):
```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 costruzione usa la tua rete normale una sola volta, per scaricare i pacchetti. I container del laboratorio non avranno alcuna rete esterna.

### Passo 3 — Scrivi i file del server web (5 min)
nginx ha bisogno di tre file, conservati sul tuo host e montati nel container. Ecco a che cosa serve ciascuno:

- `www/report.html` è la pagina costosa: 150.000 righe di numeri.
- `nginx.conf` è l'intera configurazione del server. Attiva gzip al livello 9 (la parte costosa), invia il log di accesso allo standard output così da poterlo leggere con `podman logs`, e **definisce** due contatori per indirizzo del client (`limit_req_zone`, `limit_conn_zone`). Definirli non limita ancora nulla.
- `conf/limits.conf` è incluso dal blocco server. Per ora è vuoto. Nel Passo 8 vi inserirai i limiti.

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

Output atteso:
```text
  150000  938895 www/report.html
```

Il file ha 150.000 righe e 938.895 byte (circa 0,9 MB). `rate=5r/s` è il limite che attiverai più avanti: cinque richieste al secondo per indirizzo del client.

### Passo 4 — Crea la rete isolata e i quattro container (5 min)
Una rete Podman costituisce l'intero laboratorio. `--internal` significa che Podman non aggiunge alcuna route verso il mondo esterno né alcun NAT verso il tuo host, quindi nulla può uscire dal tuo computer. `10.60.0.0/24` è un intervallo privato ([RFC 1918](https://www.rfc-editor.org/rfc/rfc1918)).

Il container web riceve `--cpus 0.5` e `--memory 128m`: può usare al massimo mezza CPU, quindi è facile da sovraccaricare e non può mai danneggiare il tuo computer. `:ro,Z` monta i file in sola lettura (l'etichetta `Z` li rende leggibili sui sistemi con SELinux, come Fedora, e non ha effetto altrove). Il tag dell'immagine è fissato a una versione esatta. Gli altri tre container eseguono semplicemente `sleep infinity`; i comandi vengono eseguiti al loro interno con `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
```

Output atteso (i quattro ID lunghi dei container variano; la prima esecuzione scarica l'immagine 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
```

Ora verifica l'isolamento. Il container utente ha una sola route, verso la sola rete del laboratorio, e una connessione a un indirizzo esterno (`192.0.2.1` è un indirizzo di documentazione, [RFC 5737](https://www.rfc-editor.org/rfc/rfc5737)) fallisce subito perché non esiste alcuna 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: $?"
```

Output atteso:
```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
```

Il codice di uscita 7 significa «connessione non riuscita». Gli strumenti d'attacco non riescono a raggiungere nulla se non il server web.

### Passo 5 — Riferimento di base: quanto è veloce il server quando nessuno lo attacca? (5 min)
Prima di un attacco devi sapere che aspetto abbia la normalità. Questo è il tuo **riferimento di base (baseline)**. Prima una richiesta dell'utente normale, con la misurazione dei tempi (`--compressed` richiede gzip, come fa ogni browser, quindi il server svolge il lavoro costoso). Poi 30 richieste, una dopo l'altra (`-c 1` significa una alla volta), con `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]+\]'
```

Output atteso (i tempi variano; conta l'ordine di grandezza):
```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
```

Come leggerlo: `status=200` significa «OK». Una richiesta richiede da 30 a 50 millisecondi (ms), a causa della compressione. Tutte le 30 hanno ottenuto `[200]`. Il server gestisce circa **18 richieste al secondo** quando un solo client le invia una alla volta, ed è la sua capacità approssimativa. Annota il riferimento di base: **circa 0,03 secondi per un utente normale**.

### Passo 6 — Inonda il server e osserva che cosa vede un utente normale (8 min)
Ora l'«attacco». Ogni bot esegue `hey` per 15 secondi (`-z 15s`) con 25 worker (`-c 25`), e ogni worker tenta 20 richieste al secondo (`-q 20`): circa 500 richieste al secondo per bot, 1.000 in totale, contro un server che riesce a rispondere a circa 18. I due comandi `hey` vengono eseguiti in background (`&`). Tre secondi dopo, l'utente normale richiede una volta la stessa pagina. `wait` si blocca finché i bot non terminano. La tua shell può stampare righe di job come `[1] 12345`; sono innocue.

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

Output atteso (richiede circa 20 secondi; **i numeri variano, il quadro no**):
```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
```

Leggi con attenzione:

- L'utente normale ha richiesto la pagina una sola volta e **ha atteso circa 15 secondi** (nella tua esecuzione: molti secondi, non millisecondi) una risposta che prima richiedeva 0,03 secondi. Nulla è stato violato e nessun dato è andato perso, eppure il servizio è di fatto fuori uso. Questa è una negazione del servizio.
- Ogni bot ha tentato migliaia di richieste, ma il server ne ha completate in totale solo circa 300 in 15 secondi, cioè la sua capacità. Le altre sono finite in coda o sono scadute.
- Un bot ha ottenuto la maggior parte delle risposte (qui `bot2`: 285 contro 26). Quale dei due varia; nginx non le ripartisce in modo equo. È normale.

### Passo 7 — Rilevalo: leggi il log di accesso (5 min)
Il log di accesso è il tuo primo strumento di rilevamento. nginx scrive una riga per ogni richiesta **completata** sul suo standard output, e `podman logs` la mostra. Questo comando conserva in un file le righe delle richieste reali (`GET`) e le conta: la prima colonna è l'indirizzo del client, la nona è lo stato 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
```

Output atteso (i conteggi variano leggermente):
```text
343
    285 10.60.0.21 200
     32 10.60.0.30 200
     26 10.60.0.20 200
```

Il programma `awk` stampa indirizzo e stato per ogni riga, `sort | uniq -c` conta le coppie uguali e `sort -rn` mette in cima le più numerose. Lettura della tabella:

- I due indirizzi `10.60.0.20` e `10.60.0.21` sono i **principali mittenti** (top talker) tra i client che sono riusciti a passare, e in realtà hanno tentato molto di più. L'utente normale `10.60.0.30` compare con le 32 richieste del riferimento di base e con l'unica richiesta che ha dovuto attendere.
- Nota un limite di questo metodo: **il log elenca solo le richieste che il server ha completato**. Il sovraccarico ha fatto sì che il server ne evadesse meno, non di più, quindi il log sottostima l'attacco. Un rilevamento reale richiede anche contatori a livello di rete (pacchetti e connessioni al secondo), carico, latenza e tasso di errore provenienti dal monitoraggio. Nel log, il segnale è che pochi indirizzi generano la maggior parte del traffico.

### Passo 8 — Attiva la limitazione della frequenza e ricarica (5 min)
Ora la difesa. Il file `conf/limits.conf` riceve quattro righe:

- `limit_req zone=perip burst=10 nodelay;` applica il contatore `perip`: ogni indirizzo client può effettuare **5 richieste al secondo** (definite in `nginx.conf`) e può superare il limite di una **raffica (burst)** di 10 richieste aggiuntive. `nodelay` serve la raffica subito anziché rallentarla. Le richieste oltre tale soglia vengono rifiutate.
- `limit_req_status 429;` imposta come stato HTTP del rifiuto `429 Too Many Requests` (il valore predefinito è 503).
- `limit_conn connperip 10;` consente a ciascun indirizzo al massimo **10 connessioni con una richiesta in corso** contemporaneamente. Serve quando ogni richiesta richiede molto tempo per essere servita (un database lento, un caricamento di grandi dimensioni). nginx inizia a contare una richiesta solo dopo che le sue intestazioni sono arrivate per intero.
- `limit_conn_status 429;` assegna lo stesso stato.

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

Output atteso (la riga `notice` mostra l'ora del tuo ricaricamento):
```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` verifica prima la configurazione (fallo sempre) e `nginx -s reload` fa avviare a nginx nuovi worker con le nuove regole e ritirare i vecchi senza interrompere le connessioni. Se la verifica fallisce, non viene ricaricato nulla e le vecchie regole restano attive.

### Passo 9 — Inonda di nuovo, con il limite attivo (8 min)
Lo stesso attacco, gli stessi comandi. Questa volta l'utente normale effettua la richiesta tre volte, a un secondo di distanza, come una persona che ricarica una pagina.

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

Output atteso (i conteggi variano di poco; il quadro no):
```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
```

Confronta con il Passo 6:

| | Passo 6: nessun limite | Passo 9: con il limite |
|---|---|---|
| Attesa dell'utente normale | circa 15 secondi | circa 0,03 secondi, come nel riferimento di base |
| Risposte ricevute da ciascun bot | un bot alcune centinaia, l'altro quasi nessuna | circa 85 ciascuno |
| Rifiuti (stato 429) | nessuno | circa 6.400 per bot |
| Tempo medio per richiesta del bot | secondi | circa 0,02 secondi |

Due cose da notare. Primo, l'**utente normale viene servito a velocità normale**: il limite è per indirizzo e l'indirizzo dell'utente è ben al di sotto. Secondo, ogni bot ha ottenuto solo circa 85 risposte. Non è un caso: `10 + 5 × 15 = 85`, la raffica più 5 richieste al secondo per 15 secondi. Tutto il resto è stato rifiutato con una minuscola risposta `429` che costa quasi nulla da produrre, ed è per questo che il server torna libero.

### Passo 10 — Rilevalo e dimostralo nel log (4 min)
La stessa analisi del log del Passo 7, ora solo sulle righe scritte dopo l'istantanea del Passo 7 (`tail -n +N` stampa dalla riga N in poi). Poi osserva una richiesta rifiutata e il log degli errori di nginx.

```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'
```

Output atteso (i conteggi variano):
```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
```

Ora il log racconta chiaramente la vicenda: 13.121 richieste in 15 secondi, quasi tutte `429` provenienti da due indirizzi, e l'utente normale con tre `200`. Questo è il segnale che un sistema di rilevamento userebbe. Altre due osservazioni:

- Il numero di righe `limiting requests` nel log degli errori (12.952) è uguale al numero di 429 nel log di accesso (6.388 + 6.564 = 12.952): ogni rifiuto viene registrato. In un sistema reale genereresti un avviso in presenza di un numero elevato di 429 provenienti dagli stessi indirizzi e potresti fornire quegli indirizzi a un firewall o al fornitore.
- `limit_conn` non è mai intervenuto. Qui nginx serve ogni richiesta in una sola rapida raffica, quindi un indirizzo non ha mai più di una richiesta in corso, e quelle rifiutate ricevono risposta subito. `limit_conn` è utile quando le richieste restano in corso a lungo, e non è una difesa contro gli attacchi lenti che non terminano mai le proprie intestazioni (vedi la sfida).

### Passo 11 — Leggi l'impostazione dei SYN cookie (4 min)
I limiti visti finora riguardano gli HTTP flood (livello 7). Contro un SYN flood (livello 4, vedi la lezione) il kernel Linux dispone di una propria difesa, i SYN cookie. Ti limiti a **leggere** l'impostazione, sia sul tuo computer sia all'interno del container web, insieme ai contatori del kernel. Non devi modificare nulla, e un SYN flood richiede pacchetti raw, che questo laboratorio deliberatamente non usa.

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

Output atteso:
```text
1
1
SyncookiesSent 0
SyncookiesRecv 0
SyncookiesFailed 0
ListenOverflows 0
ListenDrops 0
```

Come leggerlo:

- I valori di `net.ipv4.tcp_syncookies` significano: `0` cookie disattivati, `1` cookie **solo quando la coda delle connessioni semiaperte va in overflow** (il valore predefinito abituale), `2` cookie sempre attivi. In entrambi i casi vedi `1`: il tuo sistema è protetto dai SYN flood già nella configurazione di fabbrica. Il container ha una propria copia dell'impostazione, nel proprio network namespace, e parte con lo stesso valore.
- I contatori dell'ultimo comando sono la registrazione del kernel stesso per la rete del container: `SyncookiesSent` conta i cookie inviati, mentre `ListenOverflows` e `ListenDrops` contano i tentativi di connessione persi perché la coda era piena. Sono tutti `0`: l'HTTP flood ha aperto connessioni complete, non ha riempito la coda delle connessioni semiaperte, quindi i SYN cookie non hanno mai dovuto intervenire. Questo è il senso della classificazione: la difesa giusta dipende dalla classe di attacco, e l'impostazione dei SYN cookie non avrebbe salvato il server da questa inondazione, mentre il limite di frequenza sì.

> [!NOTE]
> I tuoi contatori potrebbero non essere esattamente zero se qualcos'altro sul tuo computer ha usato la rete del container. Il significato è lo stesso: crescono solo quando una coda di connessioni semiaperte va in overflow.

## Verifica
Controlla questi risultati; ciascuno deve essere confermato nella tua esecuzione:

| Controllo | Risultato atteso |
|---|---|
| Riferimento di base (Passo 5) | La richiesta normale risponde `200` in decine di millisecondi |
| Inondazione senza limite (Passo 6) | L'utente normale ha atteso diversi secondi, non millisecondi |
| Log di accesso (Passo 7) | I due indirizzi dei bot generano la maggior parte delle righe |
| Inondazione con limite (Passo 9) | L'utente normale ha ottenuto `200` in circa 0,03 s; i bot hanno ricevuto per lo più `429` e circa 85 `200` ciascuno |
| Log di accesso (Passo 10) | Righe `429` solo per i due indirizzi dei bot; `200` per `10.60.0.30` |
| SYN cookie (Passo 11) | `net.ipv4.tcp_syncookies` è `1` sull'host e nel container |

Esegui quest'ultimo test per dimostrare di nuovo che l'utente normale viene servito mentre i limiti sono attivi:

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

Output atteso:
```text
200
200
200
```

## Risoluzione dei problemi
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| `Error: ... cpu ... controller` oppure `--cpus` non è supportato all'avvio di `lab-ddos-web` | Il controller della CPU non è delegato al tuo utente (sistemi meno recenti o cgroup v1) | Rimuovi `--cpus 0.5` e rendi la pagina più pesante: `seq 1 600000 > www/report.html`. L'effetto dell'inondazione nel Passo 6 può essere minore; usa `-c 50` nel comando dei bot |
| `podman run` fallisce con `permission denied` sui file montati | Etichetta SELinux o percorso errato | Verifica di trovarti in `~/ddos-lab` e che i file esistano; mantieni i flag `:Z`; non montare file che si trovano fuori dalla tua home |
| Il Passo 6 non mostra alcun rallentamento per l'utente normale (circa 0,03 s) | Il server è più veloce del previsto, oppure l'inondazione non è partita | Verifica che `flood1-bot1.txt` contenga righe `[200]` e nessun errore; usa una pagina più grande (`seq 1 600000`) oppure `-c 50` |
| `hey: not found` oppure `curl: not found` | Hai eseguito il comando sul tuo host o nel container nginx | Anteponi `podman exec lab-ddos-user` (oppure `-bot1`, `-bot2`), che dispongono dell'immagine degli strumenti |
| Dopo il ricaricamento tutte le risposte sono ancora `200` (Passo 9) | `limits.conf` non è stato aggiornato oppure il ricaricamento non è riuscito | `podman exec lab-ddos-web cat /etc/nginx/lab/limits.conf` mostra il file che vede nginx; esegui `nginx -t` e leggi la riga di cui si lamenta |
| `nginx -t` indica `unknown directive` oppure `invalid parameter` | Un errore di battitura in `limits.conf` | Confrontalo con il testo del Passo 8; nginx mantiene le vecchie regole finché la verifica non riesce |
| Anche l'utente normale riceve `429` | L'utente ha effettuato più di 5 richieste al secondo più la raffica | Attendi alcuni secondi e riprova, lentamente. È la regola che funziona: un limite può colpire anche utenti reali molto veloci, o che condividono un indirizzo |
| `Error: ... name "lab-ddos-web" is already in use` | Esiste un container di un tentativo precedente | Esegui la [Pulizia](#pulizia), poi ricomincia |
| I conteggi nelle tue tabelle differiscono da questa pagina | Tempi, velocità della CPU e scheduling differiscono su ogni macchina | Confronta il *quadro*: secondi contro millisecondi, e migliaia di `429` contro circa 85 `200` per bot |

## Sfida (facoltativa)
Senza istruzioni passo passo, prova una o più di queste attività, poi ripristina i file del Passo 8:

1. **Un attacco lento.** Gli attacchi in stile Slowloris aprono una connessione e inviano molto lentamente l'intestazione di una richiesta, senza mai completarla. Da `lab-ddos-bot1`, usa `nc` per aprire una connessione verso `10.60.0.10` sulla porta 80 e invia solo la prima riga di una richiesta, poi attendi. Quale impostazione di nginx chiude infine una connessione di questo tipo (cerca `client_header_timeout` nella documentazione di nginx)? Perché `limit_conn` non la vede?
2. **Un limite globale.** Aggiungi un secondo contatore basato su `$server_name` con una frequenza di 30 richieste al secondo e applicalo a `/report.html`. Che cosa accade ora all'utente normale durante un'inondazione? Che cosa ti insegna questo sui limiti per indirizzo contro una botnet di migliaia di indirizzi?
3. **Pagine meno costose.** Memorizza nella cache la pagina compressa: cerca `gzip_static` o `proxy_cache` nella documentazione di nginx e misura come cambia la capacità del server nel riferimento di base. A quale livello della figura delle difese della lezione corrisponde?

## Pulizia
Rimuovi ogni risorsa creata dal laboratorio. `-t 0` evita l'attesa di 10 secondi per i container che ignorano il segnale di arresto.

```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}}'
```

Gli ultimi due comandi non stampano nulla quando tutto è stato rimosso. Le immagini scaricate `docker.io/library/nginx:1.31.6-alpine` e `alpine:3.20.10` restano nel tuo archivio di immagini (sono condivise con altri lavori); rimuovile con `podman rmi` se vuoi recuperare lo spazio.

## Cosa hai imparato
- Un'inondazione non deve essere enorme per fare danni: un server con una capacità limitata ha trasformato un insieme di richieste dall'aspetto innocuo in un'attesa di 15 secondi per un utente normale.
- Un riferimento di base di latenza e traffico normali ti dice subito che qualcosa non va, e il log di accesso, conteggiato per indirizzo e per stato, mostra chi ne è responsabile.
- Una limitazione della frequenza per indirizzo (`limit_req`, stato 429) rifiuta l'eccesso a basso costo, mantiene il server reattivo e lascia passare gli utenti normali; le richieste rifiutate costano quasi nulla da evadere.
- L'aritmetica di un limite è prevedibile: raffica più frequenza per tempo, qui `10 + 5 × 15 = 85` risposte per bot. Contro migliaia di indirizzi la somma è elevata, quindi servono anche livelli a monte.
- I SYN cookie proteggono da una classe diversa (esaurimento di stato): l'impostazione è `1` per impostazione predefinita su Linux e qui non ha avuto rilevanza perché l'inondazione era un HTTP flood.