CloudAcademia
IT

Cybersecurity · Modulo 06 · Sicurezza di rete: firewall e segmentazione

Laboratorio: segmentare una rete con un firewall a rifiuto predefinito

Laboratorio75 minIntermedioMarkdown

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

## Obiettivo
Costruisci tre zone di rete (una «Internet», una DMZ e una zona interna) collegate da un unico container firewall. Esegui una scansione dall'esterno mentre tutto è aperto, applichi una policy nftables a rifiuto predefinito che consente solo due flussi, ripeti la scansione, leggi i contatori e il log degli scarti del firewall e dimostri con dei test che ogni flusso indesiderato è bloccato.

## Obiettivi
- Costruire tre zone isolate e instradarle attraverso un unico firewall.
- Eseguire la scansione della rete dall'esterno con `nmap` e interpretare i risultati `open`, `closed` e `filtered`.
- Scrivere un insieme di regole con stato e a rifiuto predefinito che consenta solo Internet verso web (TCP 80) e web verso database (TCP 5432).
- Leggere i contatori delle regole e il log degli scarti del firewall per confermare che il traffico bloccato lo è stato dalle tue regole.
- Verificare la policy con una tabella di test positivi e negativi e mostrare perché l'ordine delle regole è importante.

## 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 l'immagine Alpine Linux (circa 8 MB) e alcuni pacchetti (circa 40 MB in totale). Dopodiché nulla nel laboratorio richiede Internet.
- Circa 400 MB di spazio libero su disco.
- La [lezione](lesson.it.md) di questo modulo e [Networking 08 — Livello di trasporto: TCP, UDP e porte](../../networking/08-tcp-udp/README.it.md). Le tecniche per i container sono quelle del [laboratorio sul networking nel cloud](../../cloud-computing/06-cloud-networking/lab.it.md); qui ti concentri su zone, rifiuto predefinito, registrazione e verifica.

> [!WARNING]
> **Autorizzazione ed etica.** La scansione delle porte è una tecnica di attacco quando è diretta a sistemi che non controlli, e può essere illegale. In questo laboratorio esegui la scansione solo dei tre container che crei tu, su reti create con `--internal` (nulla esce dal tuo computer). Non puntare mai `nmap` contro un sistema che non possiedi o per il quale non hai un'autorizzazione scritta esplicita a eseguire verifiche. Eseguire la scansione del proprio laboratorio isolato per controllare il proprio firewall è l'uso difensivo dello strumento.

## 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="netsec-lab-architecture-it-title netsec-lab-architecture-it-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="it">
<title id="netsec-lab-architecture-it-title">Architettura del laboratorio: tre zone e un firewall con rifiuto predefinito</title>
<desc id="netsec-lab-architecture-it-desc">Tre reti Podman interne convergono in un container firewall, lab-netsec-fw, con le interfacce net0 203.0.113.254, dmz0 10.40.2.254 e int0 10.40.3.254. La rete internet 203.0.113.0/24 contiene lab-netsec-client all&#x27;indirizzo 203.0.113.10, il client esterno con nmap, nc e curl e una route verso 10.40.0.0/16 tramite 203.0.113.254. La rete dmz 10.40.2.0/24 contiene lab-netsec-web all&#x27;indirizzo 10.40.2.10, un server web in ascolto su tcp 80, 8080 e 22, con route predefinita tramite 10.40.2.254. La rete interna 10.40.3.0/24 contiene lab-netsec-db all&#x27;indirizzo 10.40.3.10, un servizio simile a un database su tcp 5432 e 22, con route predefinita tramite 10.40.3.254. Il firewall applica la tabella nftables inet lab_fw sull&#x27;hook forward con policy drop: la regola 1 accetta il traffico established e related, la regola 2 accetta le nuove connessioni da net0 a dmz0 su tcp 80, la regola 3 accetta le nuove connessioni da dmz0 a int0 su tcp 5432 e la regola 4 registra nel gruppo nflog 1 e poi scarta tutto il resto.</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 esterno: 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">Server web della 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">Servizio simile a un database</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="347.5" y="526" width="485" 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">Le tre reti Podman sono --internal: nulla lascia il tuo computer</text></g>
</svg></figure>

*Figura 1. Un unico container firewall collega tre zone. Alla fine solo i due flussi presenti nel suo elenco di regole possono attraversarlo.*

| Container | Rete e indirizzo | Ruolo |
|---|---|---|
| `lab-netsec-client` | `lab-netsec-internet`, `203.0.113.10` | L'esterno: un visitatore, o un attaccante, con `nmap`, `nc` e `curl` |
| `lab-netsec-web` | `lab-netsec-dmz`, `10.40.2.10` | Il server web pubblico (TCP 80), più due servizi che **non** dovrebbero essere pubblici: TCP 8080 e un finto banner SSH su TCP 22 |
| `lab-netsec-db` | `lab-netsec-internal`, `10.40.3.10` | Un listener simile a un database su TCP 5432 (risponde `lab-db ready`) e un finto banner SSH su TCP 22 |
| `lab-netsec-fw` | `203.0.113.254`, `10.40.2.254`, `10.40.3.254` | Il router e firewall tra le zone |

> [!NOTE]
> I servizi «SSH» e «database» sono minuscoli listener `nc` che stampano una riga. Bastano per essere individuati da una scansione e per accettare o rifiutare connessioni, ed è tutto ciò che serve a questo laboratorio. In una rete reale il server web avrebbe anche bisogno di un indirizzo pubblico (o tradotto); qui il client lo raggiunge semplicemente attraverso il firewall.

Podman esegue un comando in un container con `podman exec lab-netsec-<nome> <comando>`. Il laboratorio lo usa di continuo, quindi ogni comando è riportato per esteso.

## 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-netsec --format '{{.Names}}'
podman network ls --filter name=lab-netsec --format '{{.Name}}'
mkdir -p ~/netsec-lab && cd ~/netsec-lab
```

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

I due comandi `ls` non stampano nulla. Se elencano nomi che iniziano con `lab-netsec-`, esegui prima la [Pulizia](#pulizia). Tutti i file e i comandi che seguono presuppongono che ti trovi in `~/netsec-lab`.

### Passo 2 — Costruisci l'immagine degli strumenti (5 min)
Alpine Linux è minuscola ma non include nessuno degli strumenti che ti servono. Costruisci un'unica immagine con `nftables` (il firewall di Linux), `nmap` (lo scanner), `tcpdump` (per leggere il log del firewall), `curl`, il comando `ip` completo e `busybox-extras` (un piccolo server web). Il tag è fissato ad Alpine 3.20, così ottieni gli stessi risultati degli output riportati.

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

Output atteso (la parte finale della build, poi le versioni; le versioni dei pacchetti possono differire leggermente):
```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
```

### Passo 3 — Crea le tre zone (3 min)
Ogni rete Podman è una zona: un bridge con un proprio intervallo di indirizzi. `--internal` significa che Podman non aggiunge alcuna route verso il mondo esterno né NAT verso il tuo host, quindi nulla nel laboratorio può uscire dal tuo computer e nulla può passare da una zona all'altra se non attraverso il firewall che costruisci. «Internet» usa un intervallo di documentazione ([RFC 5737](https://www.rfc-editor.org/rfc/rfc5737)); la DMZ e la zona interna usano intervalli privati ([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}}'
```

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

### Passo 4 — Avvia il firewall (4 min)
Il container firewall ha un'interfaccia in ciascuna zona, con l'ultimo indirizzo utilizzabile (`.254`) di ogni intervallo. `interface_name` assegna alle interfacce nomi leggibili: `net0`, `dmz0` e `int0`. `--cap-add NET_ADMIN` gli permette di modificare le proprie regole del firewall e `--sysctl net.ipv4.ip_forward=1` lo trasforma in un router. `sleep infinity` lo mantiene in esecuzione.

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

Output atteso (l'ID del container, l'ordine delle interfacce, i numeri `@if` e gli indirizzi `fe80::` variano):
```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
```

L'ultimo comando, `nft list ruleset`, **non stampa nulla**: il firewall non ha ancora regole, quindi inoltra tutto. Ricordalo: è il tuo punto di partenza.

### Passo 5 — Avvia i tre host (6 min)
Ogni host si unisce a una zona. Una rete interna non fornisce ai container alcuna route predefinita, quindi ogni host aggiunge una route verso il firewall: il server web e il database lo usano come gateway predefinito e il client gli invia l'intervallo `10.40.0.0/16`. `NET_ADMIN` serve solo per `ip route add`.

Il server web esegue il server web BusyBox `httpd` su TCP 80 e 8080 e un listener `nc` su TCP 22 che stampa un finto banner SSH. Il database esegue due listener `nc`: TCP 22 (lo stesso banner) e TCP 5432, che risponde `lab-db ready`. Rappresentano servizi che esistono sulle macchine reali e che non dovrebbero essere raggiungibili da ovunque.

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

Output atteso (prima i tre ID dei container; i tempi variano):
```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
```

Controlla le route e le porte su cui è in ascolto ciascun server:

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

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

Ora conosci la **realtà**: il server web è in ascolto sulle porte 80, 8080 e 22; il database sulle porte 5432 e 22. Nel passo successivo scoprirai che cosa vede un estraneo.

### Passo 6 — Situazione di partenza: tutto è aperto e una scansione lo mostra (10 min)
Con l'inoltro attivo e nessuna regola, il firewall lascia passare tutto. Verificalo dal client esterno, poi esegui la scansione. Prima due richieste ordinarie:

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

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

Il client su «Internet» ha comunicato **direttamente con il database**. È la rete piatta della storia iniziale della lezione. Ora esegui la scansione di entrambi i server dal 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
```

Che cosa significano le opzioni:
- `-n` salta la risoluzione dei nomi; `-p 1-1024,5432,8080` esegue la scansione delle porte note più le due aggiuntive.
- `-sT` è una **scansione connect** TCP: completa l'handshake TCP con la normale chiamata `connect()`. Non richiede privilegi speciali, ed è per questo che funziona in un container rootless (la scansione SYN più rapida, `-sS`, richiede socket raw e qui fallisce).
- `-Pn` salta il rilevamento «l'host è attivo?», che in questo container richiederebbe anch'esso socket raw. Ogni sonda viene trattata come una sonda di porta.
- `--reason` mostra il motivo per cui è stato stabilito ciascuno stato; `--max-retries 1 -T4` rende la scansione abbastanza rapida per un laboratorio.

Output atteso (i valori di latenza e la data variano):
```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
```

Leggi il risultato. Il client esterno vede **cinque porte aperte su due host**, compreso il database che non dovrebbe mai essere raggiungibile, e i servizi «SSH» e 8080 che nessuno intendeva pubblicare. Le altre porte sono `closed`: l'host ha risposto a ogni sonda con un rifiuto (`conn-refused`), ed è per questo che la scansione è durata 0,08 secondi. La scansione ha appena costruito un inventario della superficie di attacco. Annota le porte aperte: le confronterai con la scansione successiva.

> [!NOTE]
> I nomi dei servizi (`ssh`, `postgresql`, `http-proxy`) sono ipotesi basate sul numero di porta, non su ciò che risponde. `nmap` associa le porte ai nomi in base a una tabella. I servizi finti di questo laboratorio non ingannerebbero una scansione delle versioni, che richiede i file di script di `nmap` non inclusi in questa piccola immagine.

### Passo 7 — Applica la policy a rifiuto predefinito (10 min)
Ora scrivi la policy dell'esempio pratico della lezione. Inseriscila in un file, poi caricala nel firewall. Leggila prima di caricarla.

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

Che cosa fa ciascuna parte:
- Le prime due righe rendono il file sicuro da ricaricare: creano la tabella se non esiste, poi la eliminano, in modo che ogni caricamento parta da una tabella pulita.
- `table inet` si applica a IPv4 e IPv6. `chain forward` con `hook forward` filtra il traffico che **attraversa** il firewall; è il percorso tra le zone.
- `policy drop` è il rifiuto predefinito: un pacchetto che non corrisponde ad alcun `accept` viene scartato.
- `ct state invalid drop` scarta i pacchetti che non appartengono ad alcuna connessione valida.
- `ct state established,related ... accept` è la parte con stato: le **risposte** alle connessioni consentite non richiedono una regola propria. Viene per prima perché corrisponde alla maggior parte dei pacchetti.
- Le due regole `ct state new ... accept` sono gli **unici** nuovi flussi consentiti. Ciascuna indica le interfacce, la destinazione esatta (e l'origine per la seconda regola) e la porta. La parola chiave `counter` conta i pacchetti di ciascuna regola.
- `limit ... log group 1` scrive un record dei pacchetti scartati sul canale **nflog** numero 1 del kernel, al massimo 5 al secondo (dopo una raffica di 10), in modo che una scansione non possa inondare il log. Le regole prive di verdetto, come `log`, lasciano proseguire il pacchetto verso la regola successiva.
- L'ultima regola conta e scarta tutto il resto (anche la policy scarterebbe, ma una regola esplicita ti offre un contatore).

`podman exec -i ... nft -f -` legge il file dallo standard input, quindi resta sul tuo computer. Il caricamento non stampa nulla. Output atteso del comando `list` (a questo punto tutti i contatori sono a zero):
```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]
> Una normale regola `log` (senza `group`) scrive nel log del kernel, che si legge con `dmesg` o `journalctl -k`. In un container quel log non è disponibile: in questa prova `dmesg` all'interno del container è fallito con «Operation not permitted» e, per impostazione predefinita, il kernel registra solo dal namespace di rete dell'host stesso. Il canale `nflog` funziona senza alcun permesso speciale e `tcpdump` può leggerlo, quindi il laboratorio lo usa. Se la tua configurazione è diversa, i contatori del Passo 9 dimostrano comunque che cosa è stato scartato.

### Passo 8 — Ripeti la scansione e confronta (8 min)
Ripeti **esattamente** la stessa scansione, poi prova i due flussi che hai consentito:

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

Output atteso (ora la scansione dura diversi secondi: le sonde scartate non ricevono risposta, quindi `nmap` le attende. I tempi variano):
```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
```

Confrontalo con il Passo 6:

| | Prima (tutto aperto) | Dopo (rifiuto predefinito) |
|---|---|---|
| Server web, porta 80 | `open` | `open` (consentita) |
| Server web, porte 22 e 8080 | `open` | `filtered` |
| Database, porte 22 e 5432 | `open` | `filtered` |
| Altre porte | `closed` (rifiutate) | `filtered` (nessuna risposta) |
| Durata della scansione | 0,08 s | diversi secondi |

La superficie di attacco vista dall'esterno si è ridotta da cinque porte aperte a una. Osserva anche il **cambiamento del termine**: `closed` significa «l'host ha rifiutato», `filtered` significa «non è tornato nulla», che è l'aspetto di uno **scarto** (drop). Il database non è più nemmeno un bersaglio visibile: tutte le 1026 porte sono filtrate. Il server web serve ancora la porta 80 e il secondo flusso consentito funziona: il server web ha raggiunto il database.

> [!NOTE]
> La riga «Host is up, received user-set» è `nmap` che ripete ciò che gli hai indicato (`-Pn`): presumere che l'host sia attivo. Non dimostra che l'host abbia risposto. Senza `-Pn`, `nmap` tenterebbe prima il rilevamento dell'host: in questo container fallirebbe con «Couldn't open a raw socket» e, contro un firewall reale che scarta i ping, segnalerebbe erroneamente «Host seems down».

Ora osserva la policy dalla **DMZ**, dove si troverebbe un attaccante che ha preso il controllo del server web. Esegui la scansione del database e del client «Internet» dal server 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
```

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

Dalla DMZ il database mostra **una** porta aperta (la 5432, il flusso consentito) e il client «Internet» non ne mostra alcuna: il server web non può aprire connessioni verso l'esterno (**filtraggio in uscita**). Se il server web viene compromesso, l'attaccante può comunicare con la porta del database e con nient'altro. Eseguire la scansione da ciascuna zona è il modo per verificare le regole interne, che una scansione dal perimetro non può vedere.

### Passo 9 — Leggi il log e i contatori (12 min)
Scansioni e test non dimostrano che i pacchetti siano stati bloccati **dalle tue regole**. Lo dimostrano i contatori e il log. Azzera prima i contatori, in modo che i numeri riportati di seguito derivino solo da questo passo. Poi avvia in background una cattura sul canale nflog del firewall, con scrittura su un file all'interno del container firewall. Si interrompe da sola dopo 60 secondi.

```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` è l'interfaccia di cattura per il gruppo di log 1, il `group 1` della regola. `-n` salta la risoluzione dei nomi e `-q` stampa una riga breve per ogni pacchetto. Ora prova cinque flussi che **non** devono funzionare. Ogni `nc -z` verifica soltanto se la connessione si apre; `-w 2` rinuncia dopo 2 secondi.

```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=$?
```

I cinque test sono: da Internet al **database** (5432), da Internet alla porta **SSH** del server web, dal server web alla porta **SSH** del database, dal database al server web (una connessione avviata dall'interno) e dal server web a «Internet» (traffico in uscita). Output atteso (ogni timeout dura circa 2 secondi, per cinque volte):
```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
```

Tutti e cinque vanno in **timeout** (non c'è alcun rifiuto): il firewall scarta il pacchetto e non comunica nulla. Ora leggi il log degli scarti e i contatori:

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

Output atteso (le marche temporali e le porte di origine variano):
```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"
	}
}
```

Leggi le prove:
- Il log contiene **dieci righe di pacchetti, in cinque coppie** (`tcpdump` stampa il riepilogo «packets captured» solo al termine della cattura, dopo i 60 secondi). Ogni coppia è un tentativo di connessione bloccato: un TCP SYN (il primo pacchetto di una connessione; `tcp 0` indica assenza di dati) inviato due volte, perché il mittente ha ritentato dopo circa un secondo. Le coppie corrispondono ai tuoi cinque test, per origine, destinazione e porta.
- Il contatore `default deny` mostra **10 pacchetti, 600 byte**: gli stessi dieci pacchetti (60 byte ciascuno). Le due regole `accept` per le nuove connessioni mostrano **0**, quindi nessuno dei flussi bloccati è sfuggito per errore a una regola di autorizzazione.
- Poiché il log e il contatore concordano, sai che ogni blocco deriva dal rifiuto predefinito e non da un errore di battitura o da una route mancante.

I tuoi conteggi possono differire di qualche pacchetto se i tuoi timeout o i tentativi differiscono, ma il log e il contatore devono concordare tra loro.

> [!NOTE]
> `tcpdump` qui non stampa il testo del `prefix` della regola di registrazione. In un'installazione di produzione un demone di log come `ulogd` memorizza i record nflog, con il prefisso, in un file o su un server di log. Leggerli con `tcpdump` è sufficiente per il laboratorio.

### Passo 10 — Ordine delle regole: dove va una nuova regola (8 min)
Supponi che il gruppo web ti chieda di pubblicare anche il servizio sulla porta 8080. Aggiungi la regola nel modo più ovvio, con `nft add rule`, che **accoda** la regola alla fine della chain.

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

Output atteso:
```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 regola esiste e la porta **continua a non aprirsi**. La nuova regola (handle 8) si trova **dopo** il `drop` (handle 7), quindi il pacchetto viene scartato prima di poter corrispondere e il contatore della nuova regola resta a 0. L'opzione `-a` mostra l'**handle** di ciascuna regola, il suo numero permanente. Elimina la regola inutile e inserisci una nuova regola **prima** della regola di registrazione, nella posizione dell'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
```

Output atteso (gli handle che digiti devono corrispondere al tuo elenco `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)"
```

Ora la porta è aperta e il contatore della regola mostra l'unica connessione. È esattamente l'esposizione che la policy a rifiuto predefinito stava eliminando, quindi è il momento giusto per annullarla: ricarica la policy originale, che elimina e ricrea l'intera tabella.

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

Il caricamento non stampa nulla e la tabella torna alle cinque regole del Passo 7.

> [!TIP]
> Nella pratica, conserva il file delle regole sotto controllo di versione e **ricarica il file** anziché digitare singole regole. Così il file è sempre la fonte di verità, un revisore può leggere la modifica e non puoi lasciare nel firewall una regola di prova dimenticata.

## Verifica
La policy è corretta quando ogni test positivo viene superato e ogni test negativo è bloccato. Scrivi i controlli in uno script. `t` esegue un test: usa `nc` da un container verso una destinazione e una porta e confronta il risultato con quello atteso.

```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=$?
```

Output atteso (l'esecuzione dura circa 15 secondi, perché ogni test bloccato attende 2 secondi):
```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
```

Criteri di superamento:
- Tutte e nove le righe riportano `PASS` e lo script termina con `rc=0`. Le due righe `open` sono i tuoi due flussi consentiti; le sette righe `blocked` sono i test negativi.
- `podman exec lab-netsec-fw nft list chain inet lab_fw forward` mostra solo le cinque regole del Passo 7 (nessuna regola per la 8080), con contatori diversi da zero sulle due regole accept e sullo scarto.
- Una scansione dal client (Passo 8) mostra solo la porta 80 aperta su `10.40.2.10` e nulla di aperto su `10.40.3.10`.

> [!NOTE]
> Questo script considera «la connessione è fallita» equivalente a «bloccata». Un rifiuto e un timeout contano entrambi. In questo laboratorio va bene, perché i servizi che verifichi sono in ascolto, quindi un fallimento significa che il firewall ha scartato il pacchetto. In una rete reale, ricorda la differenza: un rifiuto significa che il pacchetto è arrivato, un timeout significa che qualcosa lo ha scartato.

## Risoluzione dei problemi
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| `nmap` stampa «Couldn't open a raw socket» | Hai usato `-sS` o hai omesso `-Pn`: entrambi richiedono socket raw, che il container rootless non ha | Usa `-sT -Pn` come nel laboratorio |
| Tutto va in timeout dal client, anche la porta 80, prima di caricare qualsiasi regola | Manca una route: il client ha bisogno di `10.40.0.0/16 via 203.0.113.254`, i server della loro route predefinita | Confronta `podman exec lab-netsec-client ip route` con il Passo 5. Ricrea il container privo della route |
| La porta 80 è bloccata dopo aver caricato la policy | I nomi delle interfacce o gli indirizzi nella regola non corrispondono, oppure il file è stato modificato | `nft list chain inet lab_fw forward`: se il contatore `internet to web` è 0 mentre quello dello scarto cresce, la regola non corrisponde. Controlla `net0`, `dmz0` e `10.40.2.10` |
| Il log degli scarti (`/tmp/drops.log`) è vuoto ma il contatore dello scarto cresce | La cattura non era in esecuzione durante il test, oppure manca la regola di registrazione, oppure il gruppo di log è diverso | Avvia prima la cattura (Passo 9) ed esegui i test entro i suoi 60 secondi. Controlla che la regola riporti `group 1` |
| `Error: No such file or directory` quando carichi le regole | Il binario `nft` non riesce a creare la tabella: il container non dispone di `NET_ADMIN`, oppure c'è un errore di battitura nel file | Controlla il `--cap-add NET_ADMIN` del `podman run` del Passo 4. Leggi il numero di riga stampato con l'errore |
| `the container name "lab-netsec-fw" is already in use` | È rimasto un container di un tentativo precedente | Esegui la [Pulizia](#pulizia), poi ricomincia |
| Una nuova regola non apre la porta | La regola è stata accodata dopo lo scarto finale | Elenca con `nft -a`, elimina tramite handle e usa `insert ... position <handle>` prima della regola di registrazione (Passo 10) |

## Sfida (facoltativa)
Estendi la policy senza istruzioni passo per passo:
1. Il server web deve scaricare aggiornamenti. Avvia un piccolo server web nel container client su TCP 8000 (`httpd -p 8000` con una cartella a tua scelta) e scrivi la regola **più restrittiva** che consenta a `lab-netsec-web` (e solo a lui) di aprire connessioni verso `203.0.113.10` su TCP 8000. Dimostra con `./check.sh` (aggiungi il test) e con una scansione che nient'altro è stato aperto.
2. Aggiungi un quarto host nella zona interna, `lab-netsec-admin` a `10.40.3.20`, che possa aprire connessioni verso il server web su TCP 22, e nessun altro. Dove inserisci la regola e quale test dimostra che il database non può fare lo stesso?
3. Trasforma la regola rivolta a Internet in un **reject** anziché in un drop (`reject with tcp reset`) per una singola porta e confronta il modo in cui una scansione la riporta rispetto a `filtered`.

## Pulizia
Rimuovi tutti i container, le reti e l'immagine creati da questo laboratorio, poi la cartella. `-t 0` evita l'attesa di 10 secondi per i container che ignorano il segnale di arresto.

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

Gli ultimi due comandi non stampano nulla quando la pulizia è completa. L'immagine di base Alpine resta nello storage di Podman (circa 8 MB); rimuovila con `podman rmi docker.io/library/alpine:3.20.10` se nessun altro laboratorio ne ha bisogno.

## Cosa hai imparato
- La scansione dall'esterno mostra la reale superficie di attacco; la scansione da ciascuna zona verifica anche le regole interne.
- Un insieme di regole con stato e a rifiuto predefinito richiede regole solo per i flussi desiderati: qui sono bastate due regole per le nuove connessioni e una regola `established`.
- `closed` significa rifiutata e `filtered` significa scartata: gli scarti di un firewall hanno l'aspetto del silenzio.
- Il filtraggio in uscita e il contenimento della DMZ fanno sì che un server web compromesso possa raggiungere una sola porta del database e nient'altro.
- I contatori delle regole e il log degli scarti devono concordare; insieme dimostrano che un flusso è stato bloccato dalla tua policy.
- L'ordine delle regole è importante: una regola posta dopo lo scarto finale non corrisponde mai. Conserva le regole in un file e ricarica il file.