Viene mostrato il Markdown grezzo: non è stato possibile caricare il visualizzatore.
## Obiettivo
Catturi la tua query del Domain Name System (DNS) e la tua richiesta dell'Hypertext Transfer Protocol (HTTP), poi smonti ogni pacchetto livello per livello. Alla fine saprai indicare gli header Ethernet, Internet Protocol (IP), Transmission Control Protocol (TCP) e HTTP in una cattura reale e dire a quale livello del modello Open Systems Interconnection (OSI) appartiene ciascuno.
## Obiettivi
- Catturare il tuo traffico con Wireshark, o con `tcpdump` come alternativa.
- Identificare gli header Ethernet, IP, User Datagram Protocol (UDP) o TCP e applicativi in un frame catturato.
- Associare ogni campo di header che vedi al rispettivo livello OSI e alla sua unità dati di protocollo (PDU, protocol data unit).
- Descrivere l'incapsulamento e il decapsulamento a partire da dati reali, compresi i campi di demultiplazione (EtherType, Protocol di IP, porta).
- Trovare la maximum segment size (MSS) di TCP in un segmento SYN e spiegare perché vale 1460 byte su Ethernet standard.
## Prerequisiti
- Un computer tuo o che amministri, con Linux, macOS o Windows 10/11, collegato via Ethernet o Wi-Fi.
- **Wireshark 4.0 o successivo** ([wireshark.org](https://www.wireshark.org/)). Su Windows, il programma di installazione installa anche Npcap, il driver di cattura.
- Alternativa per Linux e macOS: **tcpdump 4.99 o successivo** (verifica con `tcpdump --version`). macOS lo include.
- **curl 7.68 o successivo**. Su Windows 10/11, `curl.exe` è integrato.
- Uno strumento di interrogazione DNS: `dig` (BIND 9) su Linux e macOS, oppure `nslookup` su Windows.
- Il permesso di catturare pacchetti: diritti di amministratore, oppure appartenenza al gruppo `wireshark` su Linux (Passo 2).
- Lezione: [Il modello OSI: come comunicano le reti](lesson.it.md), in particolare l'esempio pratico.
> [!WARNING]
> **Autorizzazione ed etica.** Cattura solo il traffico del tuo computer e di una rete tua o che hai il permesso esplicito di monitorare. Catturare il traffico di altre persone senza autorizzazione può essere reato e violare i regolamenti aziendali o scolastici, anche su una rete Wi-Fi condivisa. Su una rete di lavoro o di scuola, controlla prima la policy di uso accettabile, oppure svolgi il laboratorio a casa. I file di cattura possono contenere dati privati (per esempio i nomi DNS che altre applicazioni interrogano). Non condividerli ed eliminali nella sezione Pulizia.
>
> **Costo:** gratuito. Usi solo strumenti open source e invii pochi kilobyte di traffico.
## Architettura
<figure class="diagram" style="--dg-w: 900px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 900 420" width="900" height="420" role="img" aria-labelledby="osi-lab-architecture-it-title osi-lab-architecture-it-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="it">
<title id="osi-lab-architecture-it-title">Architettura del laboratorio: cosa catturi e dove</title>
<desc id="osi-lab-architecture-it-desc">Il tuo computer, 192.0.2.10, esegue dig e curl al livello 7. Le richieste scendono lungo lo stack di rete del sistema operativo (livello 4 TCP o UDP, livello 3 IP, livello 2 Ethernet) fino all'interfaccia di rete, il punto di cattura di Wireshark e tcpdump. Da lì i frame vanno al router, il gateway predefinito 192.0.2.1, che li inoltra al resolver DNS 198.51.100.53 sulla porta UDP 53 e al server web di example.com 203.0.113.80 sulla porta TCP 80.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="899" height="419" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<rect class="dg-panel" x="24" y="24" width="384" height="372" rx="14" fill="#f0f0ec"/>
<g class="dg-icon-neutral" transform="translate(44 40) scale(1.2500)" fill="none" stroke="#17171c" 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>
<text x="86" y="56" font-size="16" class="dg-text" fill="#17171c" font-weight="700">Il tuo computer</text>
<text x="86" y="76" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">192.0.2.10</text>
<g class="dg-l7"><rect class="dg-tint" x="42" y="100" width="348" height="64" rx="12" fill="#f3eefc" stroke="#c5a9f0" stroke-width="1.2"/>
<g class="dg-icon" transform="translate(58 118) scale(1.1667)" fill="none" stroke="#6d28d9" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect x="2" y="4" width="20" height="16" rx="2"/><path d="M2 9h20"/><path d="M6 6.5h.01"/><path d="M9 6.5h.01"/></g>
<text x="98" y="128" font-size="15" class="dg-ink" fill="#6d28d9" font-weight="700">Applicazioni</text>
<text x="98" y="148" font-size="13" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">dig · curl</text>
</g>
<g class="dg-l7"><rect class="dg-solid" x="328" y="118" width="46" height="28" rx="14" fill="#6d28d9"/><text x="351.0" y="137" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">L7</text></g>
<path class="dg-line" d="M216.0 168V186M210.0 175l6-7 6 7M210.0 179l6 7 6-7" stroke="#cfcfc8" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<rect class="dg-card" x="42" y="190" width="348" height="92" rx="12" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-icon-neutral" transform="translate(58 204) scale(1.0833)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="16" height="16" x="4" y="4" rx="2"/><rect width="6" height="6" x="9" y="9" rx="1"/><path d="M15 2v2"/><path d="M15 20v2"/><path d="M2 15h2"/><path d="M2 9h2"/><path d="M20 15h2"/><path d="M20 9h2"/><path d="M9 2v2"/><path d="M9 20v2"/></g>
<text x="96" y="222" font-size="14.5" class="dg-text" fill="#17171c" font-weight="700">Stack di rete del sistema operativo</text>
<g class="dg-l4"><rect class="dg-solid" x="52" y="240" width="104" height="28" rx="14" fill="#c2410c"/><text x="104.0" y="259" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">L4 · TCP/UDP</text></g>
<g class="dg-l3"><rect class="dg-solid" x="164" y="240" width="104" height="28" rx="14" fill="#b45309"/><text x="216.0" y="259" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">L3 · IP</text></g>
<g class="dg-l2"><rect class="dg-solid" x="276" y="240" width="104" height="28" rx="14" fill="#15803d"/><text x="328.0" y="259" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">L2 · Ethernet</text></g>
<path class="dg-line" d="M216.0 286V304M210.0 293l6-7 6 7M210.0 297l6 7 6-7" stroke="#cfcfc8" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<g class="dg-l1"><rect class="dg-tint" x="42" y="308" width="348" height="70" rx="12" fill="#ebf3f7" stroke="#9ac3d9" stroke-width="1.2"/>
<g class="dg-icon" transform="translate(58 318) scale(1.0833)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="m15 20 3-3h2a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h2l3 3z"/><path d="M6 8v1"/><path d="M10 8v1"/><path d="M14 8v1"/><path d="M18 8v1"/></g>
<text x="96" y="336" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">Interfaccia di rete</text>
</g>
<g class="dg-l6"><rect class="dg-solid" x="56" y="346" width="320" height="24" rx="12" fill="#a21caf"/>
<g class="dg-icon-on" transform="translate(66 350) scale(0.6667)" fill="none" stroke="#ffffff" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="8"/><path d="m21 21-4.3-4.3"/></g>
<text x="88" y="362.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="600">Punto di cattura: Wireshark · tcpdump</text>
</g>
<rect class="dg-card" x="436" y="168" width="186" height="68" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(452 184) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6.01 18H6"/><path d="M10.01 18H10"/><path d="M15 10v4"/><path d="M17.84 7.17a4 4 0 0 0-5.66 0"/><path d="M20.66 4.34a8 8 0 0 0-11.31 0"/></g>
<text x="492" y="198" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Router</text>
<text x="492" y="217" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500">Gateway predefinito</text>
<text x="529.0" y="258" font-size="13" class="dg-text" fill="#17171c" font-weight="500" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">192.0.2.1</text>
<rect class="dg-card" x="664" y="60" width="212" height="100" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(680 76) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/></g>
<text x="720" y="90" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Resolver DNS</text>
<text x="720" y="109" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500"></text>
<text x="680" y="140" font-size="13" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">198.51.100.53</text>
<g class="dg-l4"><rect class="dg-solid" x="790" y="124" width="70" height="28" rx="14" fill="#c2410c"/><text x="825.0" y="143" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">UDP 53</text></g>
<rect class="dg-card" x="664" y="262" width="212" height="100" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(680 278) scale(1.2500)" fill="none" stroke="#17171c" 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>
<text x="720" y="292" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Server web</text>
<text x="720" y="311" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500">example.com</text>
<text x="680" y="342" font-size="13" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">203.0.113.80</text>
<g class="dg-l4"><rect class="dg-solid" x="790" y="326" width="70" height="28" rx="14" fill="#c2410c"/><text x="825.0" y="345" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">TCP 80</text></g>
<path class="dg-line" d="M390 343H422V202.0H436" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M622 202.0H643V110.0H664" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M643 202.0V312.0H664" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M427 196.0l7 6-7 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M655 104.0l7 6-7 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M655 306.0l7 6-7 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<circle class="dg-solid dg-l6" cx="390" cy="343" r="5" fill="#a21caf"/>
</svg></figure>
*Figura 1. Che cosa catturi e dove. Il punto di cattura è la tua interfaccia di rete, quindi vedi tutti gli header che il tuo computer invia e riceve.*
Wireshark e `tcpdump` copiano ogni frame al suo passaggio sulla tua interfaccia di rete. Vedi il frame completo con tutti gli header, esattamente come il tuo computer lo invia o lo riceve.
> [!NOTE]
> Gli indirizzi di questo laboratorio sono valori di documentazione, gli stessi usati dalla lezione: indirizzi IP dalla RFC 5737 e indirizzi Media Access Control (MAC) dal blocco di documentazione della RFC 7042 (`00:00:5e:00:53:xx`). **I tuoi valori reali saranno diversi.** Il tuo computer ha probabilmente un indirizzo privato come `192.168.1.x`, e `example.com` si risolve in indirizzi pubblici reali. Annota i tuoi valori man mano.
## Passaggi
### Passo 1 — Trova interfaccia, indirizzi e MTU
Devi sapere quale interfaccia trasporta il tuo traffico prima di catturare su di essa. Ti servono anche i tuoi indirizzi IP e MAC e il tuo gateway, per riconoscerli nella cattura. La maximum transmission unit (MTU) ti permette di prevedere l'MSS prima di vederlo.
Su Linux:
```bash
ip -4 route show default
ip link show <interface>
resolvectl dns
```
`<interface>` è il nome che compare dopo `dev` nell'output del primo comando (per esempio `enp3s0` o `wlp2s0`). Se `resolvectl` non è disponibile, esegui invece `cat /etc/resolv.conf`.
Output atteso:
```text
default via 192.0.2.1 dev enp3s0 proto dhcp src 192.0.2.10 metric 100
2: enp3s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP mode DEFAULT group default qlen 1000
link/ether 00:00:5e:00:53:10 brd ff:ff:ff:ff:ff:ff
Global:
Link 2 (enp3s0): 198.51.100.53
```
Su macOS e Windows, usa invece questi comandi:
| Informazione | macOS | Windows (Prompt dei comandi) |
|---|---|---|
| Interfaccia e gateway | `route -n get default` (righe `gateway:` e `interface:`) | `ipconfig /all` (`Default Gateway`) |
| Il tuo indirizzo MAC e la MTU | `ifconfig <interface>` (righe `ether` e `mtu`) | `ipconfig /all` (`Physical Address`); `netsh interface ipv4 show subinterfaces` (MTU) |
| Server DNS | `scutil --dns \| grep nameserver` | `ipconfig /all` (`DNS Servers`) |
Annota: il nome dell'interfaccia, il tuo indirizzo IPv4, il tuo indirizzo MAC, l'indirizzo IP del gateway, l'indirizzo di un server DNS IPv4 e la MTU. Con una MTU di 1500, la lezione prevede un MSS di 1500 − 20 (IPv4) − 20 (TCP) = 1460 byte.
> [!NOTE]
> Windows mostra gli indirizzi MAC con i trattini (`00-00-5E-00-53-10`). Wireshark mostra lo stesso indirizzo con i due punti.
### Passo 2 — Prepara una cartella e il permesso di cattura
Catturare pacchetti richiede privilegi speciali perché una cattura può vedere tutto il traffico dell'interfaccia. Concediti solo il permesso che ti serve e tieni i file del laboratorio in un'unica cartella, così la pulizia è semplice.
```bash
mkdir -p ~/osi-lab
cd ~/osi-lab
```
Output atteso: nessuno. I comandi riescono in silenzio.
Poi configura il permesso di cattura per il tuo sistema:
- **Linux, Wireshark:** se Wireshark non elenca nessuna interfaccia o dice che non hai il permesso, aggiungiti al gruppo `wireshark` (su Debian e Ubuntu, esegui prima `sudo dpkg-reconfigure wireshark-common` e rispondi **Yes**). Poi esci dalla sessione e rientra.
```bash
sudo usermod -aG wireshark "$USER"
```
Ricordati di averlo fatto: la Pulizia lo annulla.
- **Linux e macOS, tcpdump:** esegui `tcpdump` con `sudo` nel Passo 3. Non serve nessuna configurazione.
- **macOS, Wireshark:** accetta il componente **ChmodBPF** quando il programma di installazione lo propone.
- **Windows, Wireshark:** assicurati che Npcap sia stato installato con Wireshark.
> [!TIP]
> Non eseguire mai l'intera applicazione grafica di Wireshark come root o amministratore. Wireshark contiene molto codice per l'analisi dei protocolli, ed eseguirlo con tutti i privilegi aumenta i danni che un pacchetto malevolo potrebbe causare. La configurazione basata sul gruppo dà solo al piccolo helper di cattura (`dumpcap`) i diritti di cui ha bisogno.
Verifica l'appartenenza al gruppo su Linux (dopo essere rientrato):
```bash
id -nG
```
Output atteso (il tuo elenco sarà diverso, ma deve includere `wireshark`):
```text
learner wheel wireshark
```
### Passo 3 — Avvia la cattura
Vuoi solo due tipi di traffico: DNS (porta UDP 53) e HTTP in chiaro (porta TCP 80). Un **filtro di cattura** dice al motore di cattura di tenere solo quei pacchetti, così il file resta piccolo e contiene il minor numero possibile di dati estranei.
**Wireshark:** apri Wireshark. Nella schermata di benvenuto, scrivi questo nella casella del filtro di cattura ("…using this filter"), poi fai doppio clic sulla tua interfaccia del Passo 1:
```text
tcp port 80 or udp port 53
```
Risultato atteso: si apre l'elenco dei pacchetti, vuoto oppure con qualche pacchetto DNS di altre applicazioni. La barra di stato mostra il nome dell'interfaccia e un contatore di pacchetti.
**tcpdump (Linux e macOS):** esegui questo in un terminale e lascialo in esecuzione.
```bash
cd ~/osi-lab
sudo tcpdump -i <interface> -nn -Z "$USER" -w osi-lab.pcap 'tcp port 80 or udp port 53'
```
- `<interface>` è il nome dell'interfaccia del Passo 1.
- `-nn` stampa indirizzi e numeri di porta invece dei nomi.
- `-Z "$USER"` fa rinunciare a `tcpdump` ai privilegi di root e scrivere il file come te, così puoi leggerlo ed eliminarlo senza `sudo`.
- `-w osi-lab.pcap` scrive i pacchetti grezzi in un file invece di stamparli.
Output atteso:
```text
tcpdump: listening on enp3s0, link-type EN10MB (Ethernet), snapshot length 262144 bytes
```
`EN10MB (Ethernet)` significa che ogni pacchetto catturato inizia con un header Ethernet. Lo vedrai anche sul Wi-Fi: in modalità normale (non monitor), il sistema operativo passa alla cattura i frame Wi-Fi come frame Ethernet.
### Passo 4 — Genera traffico DNS e HTTP
Ora crei il traffico che analizzerai. Interroghi il DNS direttamente sul tuo resolver, in modo che la query attraversi la rete invece di ricevere risposta da una cache locale. Poi scarichi una pagina via HTTP in chiaro: con HTTP Secure (HTTPS), la cifratura ti nasconderebbe il livello HTTP. L'opzione `-4` forza IPv4 in modo che i tuoi risultati coincidano con quelli della lezione.
Apri un **secondo** terminale ed esegui:
```bash
dig @<dns-server> example.com A +short
curl -4 -s -o /dev/null -w '%{http_code} %{remote_ip}\n' http://example.com/
```
- `<dns-server>` è l'indirizzo del server DNS IPv4 del Passo 1.
- `-o /dev/null` scarta il corpo della pagina; `-w` stampa il codice di stato HTTP e l'indirizzo IP del server.
Su Windows, esegui invece questo nel Prompt dei comandi:
```bat
nslookup example.com <dns-server>
curl.exe -4 -s -o NUL -w "%{http_code} %{remote_ip}\n" http://example.com/
```
Output atteso (Linux e macOS; gli indirizzi reali sono diversi e potresti vederne più di uno):
```text
203.0.113.80
200 203.0.113.80
```
`200` significa che il server web ha risposto correttamente alla richiesta.
### Passo 5 — Ferma la cattura ed elenca i pacchetti
Ferma la cattura in modo che il file sia completo, poi ottieni una panoramica prima di zoomare sui singoli pacchetti.
**Wireshark:** fai clic sul quadrato rosso (**Stop**), poi su **File → Save As** e salva come `~/osi-lab/osi-lab.pcapng`. Scrivi `dns || http || tcp.port == 80` nella barra del filtro di visualizzazione e premi Invio.
**tcpdump:** premi **Ctrl+C** nel primo terminale, poi rileggi il file. Non serve `sudo` per leggerlo.
```bash
tcpdump -nn -r osi-lab.pcap
```
Output atteso (abbreviato; orari, indirizzi e numeri di sequenza sono diversi):
```text
reading from file osi-lab.pcap, link-type EN10MB (Ethernet), snapshot length 262144
10:15:02.120000 IP 192.0.2.10.41000 > 198.51.100.53.53: 6699+ [1au] A? example.com. (40)
10:15:02.135000 IP 198.51.100.53.53 > 192.0.2.10.41000: 6699 1/0/1 A 203.0.113.80 (56)
10:15:02.150000 IP 192.0.2.10.50514 > 203.0.113.80.80: Flags [S], seq 1000000, win 64240, options [mss 1460,sackOK,TS val 1000 ecr 0,nop,wscale 7], length 0
10:15:02.165000 IP 203.0.113.80.80 > 192.0.2.10.50514: Flags [S.], seq 2000000, ack 1000001, win 65535, options [mss 1460,sackOK,TS val 5000 ecr 1000,nop,wscale 10], length 0
10:15:02.180000 IP 192.0.2.10.50514 > 203.0.113.80.80: Flags [.], ack 1, win 502, options [nop,nop,TS val 1001 ecr 5000], length 0
10:15:02.195000 IP 192.0.2.10.50514 > 203.0.113.80.80: Flags [P.], seq 1:75, ack 1, win 502, options [nop,nop,TS val 1001 ecr 5000], length 74: HTTP: GET / HTTP/1.1
10:15:02.210000 IP 203.0.113.80.80 > 192.0.2.10.50514: Flags [P.], seq 1:79, ack 75, win 1050, options [nop,nop,TS val 5010 ecr 1001], length 78: HTTP: HTTP/1.1 200 OK
```
Dovresti riconoscere la storia: una domanda e una risposta DNS, il three-way handshake di TCP (`[S]`, `[S.]`, `[.]`), la richiesta HTTP e la risposta HTTP. Seguono altri pacchetti (il resto della pagina e la chiusura della connessione). Potresti anche vedere pacchetti DNS dello stesso `curl` e di altre applicazioni.
### Passo 6 — Analizza la query DNS
Il DNS è il pacchetto più semplice della cattura: un datagramma UDP che trasporta una domanda. Usalo per esercitarti a leggere i livelli dall'esterno verso l'interno.
**Wireshark:** filtra su `dns`, poi fai clic sulla prima query (`Standard query … A example.com`). Il riquadro dei dettagli del pacchetto mostra una riga per livello:
```text
Frame 1: 82 bytes on wire (656 bits), 82 bytes captured (656 bits) on interface enp3s0, id 0
Ethernet II, Src: 00:00:5e:00:53:10, Dst: 00:00:5e:00:53:01
Internet Protocol Version 4, Src: 192.0.2.10, Dst: 198.51.100.53
User Datagram Protocol, Src Port: 41000, Dst Port: 53
Domain Name System (query)
```
Wireshark può aggiungere il nome del produttore davanti a ogni indirizzo MAC. Espandi ogni riga con la freccia e trova: il **Type** di Ethernet, il **Protocol** e il **Time to Live** (TTL) di IP e la **Destination Port** di UDP.
**tcpdump:** aggiungi `-e` per stampare l'header Ethernet e `-v` per stampare i dettagli dell'header IP.
```bash
tcpdump -nn -e -v -r osi-lab.pcap 'udp port 53'
```
Output atteso (mostrato il primo pacchetto):
```text
10:15:02.120000 00:00:5e:00:53:10 > 00:00:5e:00:53:01, ethertype IPv4 (0x0800), length 82: (tos 0x0, ttl 64, id 4242, offset 0, flags [DF], proto UDP (17), length 68)
192.0.2.10.41000 > 198.51.100.53.53: 6699+ [1au] A? example.com. (40)
```
Leggilo livello per livello:
| Livello | Che cosa vedi | Significato |
|---|---|---|
| L2 Collegamento dati | `00:00:5e:00:53:10 > 00:00:5e:00:53:01`, `ethertype IPv4 (0x0800)` | Il tuo indirizzo MAC invia all'indirizzo MAC del gateway. L'EtherType `0x0800` dice "il payload è IPv4". |
| L3 Rete | `192.0.2.10 > 198.51.100.53`, `ttl 64`, `proto UDP (17)` | Gli indirizzi IP identificano i due host da un estremo all'altro. Il protocollo `17` dice "il payload è UDP". |
| L4 Trasporto | `.41000 > .53` | Una porta sorgente casuale dalla tua parte; la porta 53 è DNS. La PDU è un **datagramma**. |
| L7 Applicazione | `A? example.com.` | La domanda DNS vera e propria: "qual è l'indirizzo IPv4 di example.com?" |
Controlla l'indirizzo MAC di destinazione: è quello del tuo gateway, anche se il server DNS può trovarsi su un'altra rete. Se il tuo server DNS è il router di casa, gateway e server DNS sono lo stesso dispositivo.
> [!NOTE]
> `length 82` è il frame senza la frame check sequence (FCS) da 4 byte. La maggior parte delle schede di rete verifica e rimuove la FCS prima che la cattura veda il frame, perciò le catture di solito non la mostrano.
### Passo 7 — Leggi l'MSS nell'handshake TCP
Nella lezione hai calcolato che 1460 byte di dati applicativi stanno in un segmento TCP su un collegamento con MTU di 1500 byte. TCP annuncia quel numero nell'**opzione MSS** del segmento SYN (synchronize, sincronizzazione), il primo pacchetto dell'handshake. Ora lo vedi sul cavo.
**Wireshark:** applica questo filtro di visualizzazione, poi fai clic sul primo pacchetto (il tuo SYN, inviato dal tuo indirizzo IP):
```text
tcp.flags.syn == 1
```
Espandi **Transmission Control Protocol → Options**. Risultato atteso:
```text
TCP Option - Maximum segment size: 1460 bytes
```
Puoi anche filtrare direttamente sul valore con `tcp.options.mss_val == 1460`.
**tcpdump:**
```bash
tcpdump -nn -e -v -r osi-lab.pcap 'tcp[tcpflags] & tcp-syn != 0'
```
Il filtro tiene i segmenti con il flag SYN impostato: il tuo SYN e il SYN-ACK del server. Output atteso:
```text
10:15:02.150000 00:00:5e:00:53:10 > 00:00:5e:00:53:01, ethertype IPv4 (0x0800), length 74: (tos 0x0, ttl 64, id 4244, offset 0, flags [DF], proto TCP (6), length 60)
192.0.2.10.50514 > 203.0.113.80.80: Flags [S], cksum 0x42da (correct), seq 1000000, win 64240, options [mss 1460,sackOK,TS val 1000 ecr 0,nop,wscale 7], length 0
10:15:02.165000 00:00:5e:00:53:01 > 00:00:5e:00:53:10, ethertype IPv4 (0x0800), length 74: (tos 0x0, ttl 64, id 4245, offset 0, flags [DF], proto TCP (6), length 60)
203.0.113.80.80 > 192.0.2.10.50514: Flags [S.], cksum 0xa590 (correct), seq 2000000, ack 1000001, win 65535, options [mss 1460,sackOK,TS val 5000 ecr 1000,nop,wscale 10], length 0
```
Trova `mss 1460` nel tuo SYN. Ora guarda i byte grezzi dello stesso frame per vedere l'incapsulamento in esadecimale:
```bash
tcpdump -nn -XX -c 1 -r osi-lab.pcap 'tcp[tcpflags] == tcp-syn'
```
Output atteso (i byte della tua cattura sono diversi):
```text
10:15:02.150000 IP 192.0.2.10.50514 > 203.0.113.80.80: Flags [S], seq 1000000, win 64240, options [mss 1460,sackOK,TS val 1000 ecr 0,nop,wscale 7], length 0
0x0000: 0000 5e00 5301 0000 5e00 5310 0800 4500 ..^.S...^.S...E.
0x0010: 003c 1094 4000 4006 2bcd c000 020a cb00 .<..@.@.+.......
0x0020: 7150 c552 0050 000f 4240 0000 0000 a002 qP.R.P..B@......
0x0030: faf0 42da 0000 0204 05b4 0402 080a 0000 ..B.............
0x0040: 03e8 0000 0000 0103 0307 ..........
```
- I byte 0–13 sono l'header Ethernet: MAC di destinazione, MAC sorgente, poi `0800` (IPv4).
- `45` apre l'header IPv4: versione 4, lunghezza dell'header 5 × 4 = 20 byte. Il decimo byte dell'header IP, `06`, è il campo Protocol (TCP).
- Dentro le opzioni TCP, `02 04 05b4` è l'opzione MSS: tipo 2, lunghezza 4, valore `0x05b4` = 1460.
> [!NOTE]
> Ogni lato annuncia il segmento più grande che è disposto a *ricevere*, perciò il SYN-ACK può mostrare un MSS diverso. Valori inferiori a 1460 sono normali su reti private virtuali (VPN, virtual private network), collegamenti PPP over Ethernet (PPPoE) e alcune reti mobili o cloud, perché la loro MTU è più piccola o un apparato intermedio abbassa ("clamps") l'MSS. Sui pacchetti che invii, `tcpdump -v` può stampare `cksum … (incorrect -> …)`. È normale: la scheda di rete calcola il checksum dopo il punto di cattura (checksum offload).
### Passo 8 — Analizza la richiesta HTTP livello per livello
La richiesta HTTP è l'esempio più chiaro di incapsulamento completo: dati applicativi dentro un segmento TCP, dentro un pacchetto IP, dentro un frame Ethernet. Ora leggi tutti e quattro gli header di un solo frame.
**Wireshark:** applica il filtro di visualizzazione `http.request` e fai clic sul pacchetto `GET / HTTP/1.1`. Espandi ogni riga del riquadro dei dettagli del pacchetto:
```text
Frame 6: 140 bytes on wire (1120 bits), 140 bytes captured (1120 bits) on interface enp3s0, id 0
Ethernet II, Src: 00:00:5e:00:53:10, Dst: 00:00:5e:00:53:01
Internet Protocol Version 4, Src: 192.0.2.10, Dst: 203.0.113.80
Transmission Control Protocol, Src Port: 50514, Dst Port: 80, Seq: 1, Ack: 1, Len: 74
Hypertext Transfer Protocol
```
Fai clic su una riga del riquadro dei dettagli: Wireshark evidenzia i byte corrispondenti nel riquadro dei byte in basso. Fai clic su **Ethernet II**, poi su **Internet Protocol**, poi su **Transmission Control Protocol**, poi su **Hypertext Transfer Protocol**, e osserva l'evidenziazione spostarsi verso l'interno del frame. Questo è l'incapsulamento, visto dall'esterno verso l'interno.
**tcpdump:**
```bash
tcpdump -nn -e -v -r osi-lab.pcap 'tcp dst port 80 and tcp[tcpflags] & tcp-push != 0'
```
Il filtro tiene i segmenti che hai inviato alla porta 80 e che trasportano dati (flag PSH impostato). Output atteso:
```text
10:15:02.195000 00:00:5e:00:53:10 > 00:00:5e:00:53:01, ethertype IPv4 (0x0800), length 140: (tos 0x0, ttl 64, id 4247, offset 0, flags [DF], proto TCP (6), length 126)
192.0.2.10.50514 > 203.0.113.80.80: Flags [P.], cksum 0x4260 (correct), seq 1000001:1000075, ack 2000001, win 502, options [nop,nop,TS val 1001 ecr 5000], length 74: HTTP, length: 74
GET / HTTP/1.1
Host: example.com
User-Agent: curl/8.5.0
Accept: */*
```
Verifica che le dimensioni tornino:
| Elemento | Byte in questo esempio | Dove si legge |
|---|---|---|
| Richiesta HTTP (dati applicativi) | 74 | `length 74` di TCP / `Len: 74` di Wireshark |
| Header TCP (20 + 12 byte di opzioni timestamp) | 32 | lunghezza totale IP − header IP − dati |
| Header IPv4 | 20 | `Header Length: 20 bytes` di IP |
| Pacchetto IP (lunghezza totale IP) | 74 + 32 + 20 = 126 | `length 126` di IP |
| Header Ethernet | 14 | |
| Frame catturato (senza FCS) | 126 + 14 = 140 | `length 140` / `Frame 6: 140 bytes` |
Poi guarda la risposta del server (`HTTP/1.1 200 OK`) e confronta il suo header IP con quello della tua richiesta. Sorgente e destinazione sono scambiate, e il TTL di solito è **inferiore** al valore da cui il server è partito (spesso 64 o 128). Ogni router lungo il percorso lo ha decrementato di uno.
> [!NOTE]
> L'header TCP nei segmenti di dati spesso è di 32 byte invece di 20 perché molti sistemi aggiungono l'opzione timestamp a ogni segmento. Le tue dimensioni possono differire: versioni diverse di curl inviano header leggermente diversi (per esempio un altro `User-Agent`).
### Passo 9 — Associa ciò che hai visto ai livelli OSI
Mettere tutto insieme trasforma ciò che hai visto nel modello. Copia questa tabella nei tuoi appunti e compila l'ultima colonna con i valori della **tua** cattura.
| Livello OSI | PDU | Riga di Wireshark | Campo da annotare | Valore di esempio | Il tuo valore |
|---|---|---|---|---|---|
| 7 Applicazione | Dati | Hypertext Transfer Protocol | Riga della richiesta e `Host` | `GET / HTTP/1.1`, `example.com` | |
| 4 Trasporto | Segmento | Transmission Control Protocol | Porta sorgente, porta di destinazione, MSS nel SYN | `50514`, `80`, `1460` | |
| 4 Trasporto | Datagramma | User Datagram Protocol | Porta di destinazione della query DNS | `53` | |
| 3 Rete | Pacchetto | Internet Protocol Version 4 | IP sorgente e di destinazione, TTL, Protocol | `192.0.2.10`, `203.0.113.80`, `64`, `6` | |
| 2 Collegamento dati | Frame | Ethernet II | MAC sorgente e di destinazione, Type | `00:00:5e:00:53:10`, `00:00:5e:00:53:01`, `0x0800` | |
| 1 Fisico | Bit | Frame (metadati di cattura) | Bytes on wire | `140` | |
> [!NOTE]
> La riga **Frame** di Wireshark non è un header di protocollo. Sono informazioni che lo strumento di cattura aggiunge (orario di arrivo, lunghezza, interfaccia). È ciò che più si avvicina al livello 1 che vedrai, perché la cattura vede i bit solo dopo che la scheda di rete ha riconvertito i segnali in byte.
I livelli 5 e 6 non hanno una riga propria: con HTTP in chiaro su TCP, sul cavo non compare nessun protocollo di sessione o di presentazione separato. Con HTTPS, il Transport Layer Security (TLS) si collocherebbe tra TCP e HTTP (vedi la Sfida).
## Verifica
Hai completato il laboratorio quando tutti i controlli seguenti vanno a buon fine.
1. Il file di cattura esiste e contiene pacchetti. Wireshark: il file salvato si riapre e mostra pacchetti. tcpdump:
```bash
tcpdump -nn -r osi-lab.pcap 2>/dev/null | wc -l
```
Output atteso: un numero di almeno 7 (il numero esatto varia).
2. Il tuo SYN porta un MSS che corrisponde alla tua MTU. Wireshark: il filtro `tcp.flags.syn == 1 && tcp.flags.ack == 0` mostra il tuo SYN, con un MSS di 1460 su una MTU di 1500 byte. tcpdump:
```bash
tcpdump -nn -r osi-lab.pcap 'tcp[tcpflags] == tcp-syn'
```
Output atteso: una riga che contiene `Flags [S]` e `mss 1460` (oppure MTU − 40 se la tua MTU non è 1500).
Poi verifica la tua comprensione sulla cattura:
- [ ] Hai trovato l'EtherType `0x0800` nell'header Ethernet dei tuoi frame IPv4.
- [ ] Hai trovato il Protocol di IP `17` nella query DNS e `6` nella richiesta HTTP.
- [ ] L'indirizzo MAC di destinazione dei tuoi frame in uscita è quello del tuo gateway, non quello del server.
- [ ] Sai spiegare perché l'MSS è 1460: 1500 (MTU) − 20 (header IPv4) − 20 (header TCP).
- [ ] La tabella del Passo 9 è completa, con i tuoi valori.
## Risoluzione dei problemi
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Wireshark non mostra interfacce, oppure mostra "You don't have permission to capture on that device." | Il tuo utente non è autorizzato a catturare (gruppo `wireshark` su Linux, ChmodBPF su macOS, Npcap su Windows). | Linux: completa il Passo 2, poi esci dalla sessione e rientra (`id -nG` deve elencare `wireshark`). macOS: reinstalla Wireshark e accetta ChmodBPF. Windows: reinstalla Npcap dal programma di installazione di Wireshark. |
| `tcpdump: <interface>: You don't have permission to capture on that device` | Hai eseguito `tcpdump` senza `sudo`. | Esegui il comando del Passo 3 con `sudo`. |
| `tcpdump: osi-lab.pcap: Permission denied` | `tcpdump` ha rinunciato ai privilegi di root e non può scrivere nella cartella corrente. | Usa l'opzione `-Z "$USER"` come mostrato ed esegui il comando da `~/osi-lab`, che è tua. |
| La cattura resta vuota dopo il Passo 4. | Stai catturando sull'interfaccia sbagliata (per esempio una porta Ethernet scollegata, un bridge Docker o un'interfaccia VPN). | Controlla l'interfaccia che porta la route predefinita (Passo 1) e cattura su quella. In Wireshark, scegli l'interfaccia il cui grafico del traffico si muove. |
| Nessun pacchetto HTTP, solo TCP porta 443 o TLS. | Hai usato `https://`, oppure qualcosa ti ha reindirizzato a HTTPS. La cifratura nasconde il livello HTTP. | Usa esattamente `http://example.com/` con `curl`, non un browser. I browser spesso passano automaticamente a HTTPS. |
| Nessuna query DNS nella cattura. | Hai eseguito `dig` senza `@<dns-server>`, quindi la risposta è arrivata da una cache locale (per esempio `systemd-resolved` su `127.0.0.53`) o tramite DNS over HTTPS. | Esegui `dig @<dns-server> example.com A` con il server DNS del Passo 1. Se hai catturato sul loopback (`lo`), vedi solo la query verso la cache locale. |
| L'MSS è molto grande (per esempio 65495 su Linux), oppure gli indirizzi MAC sono tutti zeri. | Hai catturato sull'interfaccia di loopback, che ha una MTU molto grande e nessuna vera scheda di rete. | Cattura sulla tua interfaccia fisica (Passo 1). |
| I pacchetti mostrano `ethertype IPv6 (0x86dd)` e un MSS di 1440. | `curl` si è connesso via IPv6. L'header IPv6 è di 40 byte, quindi l'MSS è 1500 − 40 − 20 = 1440. | Aggiungi `-4` a `curl` come mostrato nel Passo 4, oppure tieni la cattura IPv6 come confronto aggiuntivo. |
| Nessun header Ethernet (`link-type RAW`) e un MSS inferiore a 1460. | Una VPN è attiva e hai catturato sulla sua interfaccia di tunnel. | Disconnetti la VPN per il laboratorio, oppure cattura sull'interfaccia fisica. Un MSS più piccolo attraverso una VPN è normale. |
## Sfida (facoltativa)
Ripeti la cattura con HTTPS: usa il filtro di cattura `tcp port 443` ed esegui `curl -4 -s -o /dev/null https://example.com/`. Senza aiuto passo passo, rispondi a queste domande a partire dalla cattura:
1. Quali header riesci ancora a leggere (Ethernet, IP, TCP), e dove inizia la parte cifrata?
2. Trova il Client Hello TLS. Quale informazione sul sito web è ancora visibile in chiaro? (Suggerimento: cerca l'estensione Server Name Indication, SNI.)
3. Come si accorda questo con l'affermazione della lezione che "la cifratura a un livello protegge solo i livelli superiori"?
## Pulizia
Ferma qualsiasi cattura ancora in corso (Wireshark: **Stop**; tcpdump: **Ctrl+C**), poi controlla che non resti nessun processo `tcpdump`:
```bash
pgrep -a tcpdump
```
Output atteso: nessuno (nessun processo elencato).
Elimina i file di cattura e la cartella del laboratorio. Possono contenere dati privati.
```bash
rm -rf ~/osi-lab
```
Su Windows, elimina in Esplora file la cartella in cui hai salvato `osi-lab.pcapng`.
Se ti sei aggiunto al gruppo `wireshark` **solo per questo laboratorio** (Passo 2), rimuovi l'appartenenza ed esci dalla sessione e rientra:
```bash
sudo gpasswd -d "$USER" wireshark
```
Output atteso:
```text
Removing user learner from group wireshark
```
Se hai installato Wireshark, Npcap o ChmodBPF solo per questo laboratorio, puoi disinstallarli con il gestore di pacchetti del tuo sistema o con il programma di disinstallazione di Wireshark.
> [!NOTE]
> Wireshark ricorda anche i file aperti di recente. Per svuotare l'elenco, usa **File → Open Recent → Clear Recent Files**.
## Cosa hai imparato
- Uno strumento di cattura ti mostra tutti gli header di un frame, così vedi l'incapsulamento direttamente e non solo nei diagrammi.
- L'header di ogni livello dice al ricevente che cosa viene dopo: l'EtherType `0x0800` significa IPv4, il Protocol di IP `6` significa TCP e `17` significa UDP, e la porta di destinazione sceglie l'applicazione.
- I tuoi frame in uscita vanno all'indirizzo MAC del gateway, mentre gli indirizzi IP identificano i veri estremi.
- Il segmento SYN annuncia l'MSS: 1460 byte su un collegamento Ethernet standard da 1500 byte, cioè 1500 − 20 (IPv4) − 20 (TCP).
- La cifratura nasconde i livelli che stanno sopra. HTTP in chiaro mostra la richiesta in chiaro; HTTPS mostra solo i livelli inferiori e l'handshake TLS.
- Catturare traffico è potente e delicato: cattura solo il tuo traffico, tieni i file privati ed eliminali quando hai finito.