---
title: "Livello di trasporto: TCP, UDP e porte"
domain: networking
level: beginner
duration: "50 min"
objectives:
  - Spiegare il compito del livello di trasporto e come le porte identificano i processi (porte ben note, registrate ed effimere).
  - Confrontare TCP e UDP (connessioni, affidabilità, ordinamento, overhead) e sceglierne uno per una data applicazione.
  - Descrivere l'handshake a tre vie di TCP, la chiusura della connessione, i numeri di sequenza e di conferma, la ritrasmissione e il controllo di flusso.
  - Identificare i socket in ascolto e gli stati di connessione (LISTEN, ESTABLISHED, TIME_WAIT) con `ss` o `netstat`.
  - Diagnosticare «connection refused» rispetto a «connection timed out».
lang: it
source_hash: 6d1886187aec
---

# Livello di trasporto: TCP, UDP e porte

## Perché è importante
Distribuisci una piccola applicazione web su un server e la provi dal tuo portatile. Il browser dice *connection refused* (connessione rifiutata). Un collega prova un minuto dopo da casa e ottiene *connection timed out* (connessione scaduta). Entrambi i messaggi significano «non funziona», ma indicano problemi completamente diversi. Il primo dice che il server ha risposto: «qui non ascolta nessuno». Il secondo dice che non ha risposto nulla, quindi i pacchetti sono stati scartati da qualche parte lungo il percorso. Se sai distinguerli, sai se guardare l'applicazione o il firewall.

Le stesse conoscenze spiegano enigmi quotidiani. Perché una videochiamata va avanti nonostante una brutta connessione Wi-Fi mentre un download si blocca? Perché un server molto carico mostra migliaia di connessioni in uno stato chiamato `TIME_WAIT`? Perché un solo server può eseguire un server web e un server Secure Shell (SSH) sullo stesso indirizzo Internet Protocol (IP)? Tutte le risposte stanno nel livello di trasporto, la casa del Transmission Control Protocol (TCP) e dello User Datagram Protocol (UDP), e argomento di questa lezione.

## Obiettivi di apprendimento
- Spiegare il compito del livello di trasporto e come le porte identificano i processi (porte ben note, registrate ed effimere).
- Confrontare TCP e UDP (connessioni, affidabilità, ordinamento, overhead) e sceglierne uno per una data applicazione.
- Descrivere l'handshake a tre vie di TCP, la chiusura della connessione, i numeri di sequenza e di conferma, la ritrasmissione e il controllo di flusso.
- Identificare i socket in ascolto e gli stati di connessione (LISTEN, ESTABLISHED, TIME_WAIT) con `ss` o `netstat`.
- Diagnosticare «connection refused» rispetto a «connection timed out».

## Concetti chiave

### Porte: dall'host al processo
Un indirizzo IP porta un pacchetto all'edificio giusto. Non dice quale appartamento. Un server su `203.0.113.80` può eseguire contemporaneamente un server web, un server SSH e un database, e il tuo portatile può avere venti schede del browser aperte. Qualcosa deve decidere a quale programma appartiene ciascun pacchetto.

Questo è il compito del **livello di trasporto** (livello 4 del [modello OSI](../04-osi-model/lesson.it.md)). Trasporta dati tra *processi*, non solo tra host. Per farlo, etichetta ogni messaggio con due numeri di **porta**: una di origine e una di destinazione. Una porta è un numero a 16 bit, da 0 a 65535. Un programma che vuole ricevere traffico chiede una porta al sistema operativo; da quel momento il sistema operativo gli consegna tutto ciò che arriva su quella porta. Smistare i dati in arrivo per porta si chiama **demultiplexing**; mescolare i dati di molti programmi su un solo indirizzo IP è il **multiplexing**.

La RFC 6335 divide i numeri di porta in tre intervalli, e la Internet Assigned Numbers Authority (IANA) mantiene il registro:

| Intervallo | Nome nella RFC 6335 | Chiamate anche | Usate per |
|---|---|---|---|
| 0–1023 | Porte di sistema | **Porte ben note** (well-known) | Servizi standard: 22 SSH, 53 Domain Name System (DNS), 443 HTTP Secure (HTTPS) |
| 1024–49151 | Porte utente | **Porte registrate** | Servizi registrati presso IANA: 3389 Remote Desktop Protocol (RDP), 5432 PostgreSQL |
| 49152–65535 | Porte dinamiche e/o private | **Porte effimere** | Porte di origine temporanee dei client, mai assegnate a un servizio |

Un server ascolta su una porta fissa e ben nota perché i client sappiano dove trovarlo. A un client non importa quale porta usa, quindi il sistema operativo sceglie una **porta effimera** libera ogni volta che apre una connessione.

> [!NOTE]
> Non tutti i sistemi operativi seguono l'intervallo dinamico della RFC 6335. Windows (da Vista) e macOS usano per impostazione predefinita 49152–65535, mentre Linux usa 32768–60999. Controlla il tuo con `cat /proc/sys/net/ipv4/ip_local_port_range` su Linux, `sysctl net.inet.ip.portrange.first net.inet.ip.portrange.last` su macOS o `netsh int ipv4 show dynamicport tcp` su Windows. Questo conta quando scrivi regole firewall per il traffico di ritorno.

L'estremità di un programma, un indirizzo IP più una porta più un protocollo, si chiama **socket**. Una connessione è identificata dalla sua **4-tupla**: indirizzo IP di origine, porta di origine, indirizzo IP di destinazione, porta di destinazione. Aggiungendo il protocollo si ottiene la **5-tupla** che firewall e dispositivi di Network Address Translation (NAT) tengono sotto controllo. Poiché la porta del client è diversa, due schede del browser possono parlare con la stessa porta del server nello stesso momento senza mescolare i propri dati:

![Un client su 192.0.2.10 esegue la scheda 1 del browser sulla porta effimera 50514, la scheda 2 sulla 50515 e un client SSH sulla 50600. Un server su 203.0.113.80 è in ascolto sulla porta 443 (server web) e sulla porta 22 (server SSH). Entrambe le schede si connettono alla 443 e il client SSH alla 22. Le tre connessioni TCP sono 192.0.2.10:50514 verso 203.0.113.80:443, 192.0.2.10:50515 verso 203.0.113.80:443 e 192.0.2.10:50600 verso 203.0.113.80:22](../../../assets/diagrams/tcp-ports-sockets.it.svg)

*Figura 1. Due connessioni condividono la destinazione `203.0.113.80:443`. Restano distinte, perché le loro 4-tuple differiscono per la porta di origine.*

Alcune porte che incontrerai di continuo:

| Porta | Protocollo | Servizio |
|---|---|---|
| 22 | TCP | Secure Shell (SSH) |
| 25 | TCP | Simple Mail Transfer Protocol (SMTP), da server a server |
| 53 | UDP e TCP | DNS |
| 67 / 68 | UDP | Dynamic Host Configuration Protocol (DHCP), server / client |
| 80 | TCP | Hypertext Transfer Protocol (HTTP) |
| 123 | UDP | Network Time Protocol (NTP) |
| 443 | TCP, e UDP per HTTP/3 | HTTPS |
| 3389 | TCP e UDP | Remote Desktop Protocol (RDP) |

TCP e UDP hanno spazi di porte separati. La porta TCP 53 e la porta UDP 53 sono due socket diversi, e un programma può ascoltare su una senza l'altra.

> [!CHECK]
> Il tuo portatile apre due connessioni verso `https://www.example.com` nello stesso momento. Entrambe vanno a `203.0.113.80:443`. Come fa il server a tenere separati i loro dati?
>
> - [ ] Ogni connessione usa una porta di destinazione diversa sul server
> - [x] Il portatile usa una porta di origine effimera diversa per ciascuna, quindi le due 4-tuple differiscono
> - [ ] Il server può gestire una sola connessione per indirizzo IP client alla volta
> - [ ] Il browser aggiunge un numero di connessione all'header IP
>
> La porta del server resta 443 per entrambe. Il sistema operativo dà a ogni connessione la propria porta di origine effimera, e la 4-tupla (IP di origine, porta di origine, IP di destinazione, porta di destinazione) identifica ogni connessione in modo univoco.

### TCP e UDP a confronto
Internet ha due protocolli di trasporto di uso quotidiano. Fanno compromessi opposti.

Lo **User Datagram Protocol (UDP)** (RFC 768) è l'opzione minimale. Aggiunge un header di 8 byte (porta di origine, porta di destinazione, lunghezza e un checksum) e invia il messaggio. Ogni messaggio è un **datagramma**: arriva intero o non arriva affatto. UDP è **senza connessione**: nessuna fase di apertura, nessuna conferma, nessuna ritrasmissione. Se un datagramma si perde, si duplica o viene superato da uno successivo, UDP non se ne accorge. Sta all'applicazione decidere se conta.

Il **Transmission Control Protocol (TCP)** (RFC 9293) fa molto di più. È **orientato alla connessione**: entrambi i lati si accordano per comunicare prima che fluiscano dati. Poi consegna un **flusso di byte** affidabile e ordinato: ogni byte è numerato, confermato e rinviato se perso, e il programma ricevente legge i byte nell'ordine in cui sono stati inviati. TCP rallenta anche quando il ricevente o la rete non riescono a stare al passo. La sua unità di dati è il **segmento**, con un header da 20 a 60 byte.

![Confronto. Prima di inviare: TCP esegue un handshake a tre vie; UDP invia e basta. Consegna: TCP conferma i dati e rinvia le perdite; UDP è best effort, senza ACK. Ordine: TCP è un flusso di byte ordinato; UDP invia datagrammi separati. Controllo di flusso e di congestione: integrato in TCP; assente in UDP, compito dell'applicazione. Dimensione dell'header: TCP da 20 a 60 byte, UDP 8 byte. Usi tipici di TCP: HTTPS 443, SSH 22, SMTP 25, IMAPS 993. Usi tipici di UDP: DNS 53, DHCP 67/68, NTP 123, QUIC 443](../../../assets/diagrams/tcp-vs-udp.it.svg)

*Figura 2. TCP compra affidabilità e ordine con un handshake, conferme e un header più grande. UDP offre velocità e semplicità e lascia il resto all'applicazione.*

Scegliere tra i due è una questione di cosa fa più male: attendere o perdere dati.

| Applicazione | Scelta abituale | Perché |
|---|---|---|
| Pagine web, interfacce di programmazione delle applicazioni (API), trasferimento di file, e-mail, SSH | TCP | Ogni byte deve arrivare, in ordine. Un breve ritardo è accettabile. |
| Query DNS | UDP (TCP per risposte grandi e trasferimenti di zona) | Una piccola domanda, una piccola risposta. Una query persa viene semplicemente ripetuta. La RFC 7766 richiede che i server DNS supportino anche TCP. |
| Chiamate voce e video, giochi online | UDP | Un pacchetto in ritardo è inutile. Meglio saltarlo che fermare tutto mentre viene rinviato. |
| DHCP | UDP | Il client non ha ancora un indirizzo IP e deve trasmettere in broadcast. TCP non può: una connessione ha esattamente due estremità. |
| Video in diretta verso molti riceventi (multicast) | UDP | Stesso motivo: TCP è solo uno a uno. |

UDP non è «inaffidabile» in senso negativo. È *privo di opinioni*. **QUIC** (RFC 9000) è l'esempio migliore: funziona sopra UDP e costruisce una propria affidabilità, ordinamento, controllo di congestione e cifratura Transport Layer Security (TLS) 1.3 integrata. HTTP/3 (RFC 9114) usa QUIC, ed è per questo che oggi HTTPS usa sia la porta TCP 443 sia la porta UDP 443.

> [!CHECK]
> Un team crea un gioco multigiocatore. Il server invia la posizione di ogni giocatore 30 volte al secondo. Quale trasporto è più adatto, e perché?
>
> - [ ] TCP, perché un aggiornamento di posizione perso deve sempre essere rinviato
> - [x] UDP, perché una vecchia posizione rinviata è inutile quando ne esiste una più recente, e aspettarla bloccherebbe il gioco
> - [ ] UDP, perché cifra i dati e impedisce i trucchi
> - [ ] TCP, perché UDP non può trasportare più di un messaggio al secondo
>
> Ogni aggiornamento sostituisce il precedente, quindi una ritrasmissione arriva troppo tardi per servire, e la consegna in ordine di TCP tratterrebbe gli aggiornamenti più recenti mentre aspetta. Né TCP né UDP cifrano nulla da soli.

### La connessione TCP: apertura e chiusura
Una connessione TCP inizia con l'**handshake a tre vie** (three-way handshake). Pensa a una telefonata: «Mi senti?» «Sì, ti sento, mi senti tu?» «Sì.» Solo allora comincia la conversazione.

L'handshake usa i flag, singoli bit dell'header TCP. Il flag **SYN** (synchronize) apre una connessione, il flag **ACK** (acknowledgement, conferma) dice che il numero di conferma è valido, il flag **FIN** (finish) chiude una direzione e il flag **RST** (reset) interrompe subito una connessione.

![Handshake TCP tra un client su 192.0.2.10:50514 (CLOSED) e un server su 203.0.113.80:443 (LISTEN). 1: il client invia SYN seq=1000 e passa a SYN-SENT; il server passa a SYN-RECEIVED. 2: il server invia SYN, ACK seq=5000 ack=1001; il client passa a ESTABLISHED. 3: il client invia ACK ack=5001; il server passa a ESTABLISHED. Poi il client invia 100 byte di dati a seq=1001, per esempio un TLS ClientHello, e il server risponde ACK ack=1101](../../../assets/diagrams/tcp-handshake.it.svg)

*Figura 3. Tre messaggi aprono la connessione. Ogni lato sceglie il proprio numero di sequenza iniziale e l'altro lato lo conferma aggiungendo uno.*

1. **SYN.** Il client sceglie un **numero di sequenza iniziale (ISN, initial sequence number)**, qui 1000, e invia un segmento con il flag SYN. Annuncia anche opzioni come la propria **Maximum Segment Size (MSS, dimensione massima del segmento)**, il blocco di dati più grande che può ricevere in un segmento.
2. **SYN, ACK.** Il server sceglie il proprio ISN (5000) e conferma quello del client: `ack=1001` significa «ho ricevuto il tuo SYN; il prossimo byte che mi aspetto da te è il 1001». Un SYN conta come un byte dello spazio di sequenza anche se non trasporta dati.
3. **ACK.** Il client conferma il SYN del server con `ack=5001`. Entrambi i lati sono ora **ESTABLISHED** e i dati possono fluire in entrambe le direzioni.

Gli ISN reali non sono 1000 e 5000. Sono numeri a 32 bit scelti in modo imprevedibile (RFC 9293, secondo la RFC 6528), così che un attaccante non possa indovinarli e iniettare falsi segmenti in una connessione.

La chiusura avviene in quattro passi, perché ogni direzione si chiude separatamente:

![Chiusura TCP tra il client 192.0.2.10:50514 e il server 203.0.113.80:443, entrambi ESTABLISHED. 1: il client invia FIN seq=1101 e passa a FIN-WAIT-1. 2: il server invia ACK ack=1102 e passa a CLOSE-WAIT; il client passa a FIN-WAIT-2. L'applicazione server termina e chiama close(). 3: il server invia FIN seq=5001 e passa a LAST-ACK; il client passa a TIME-WAIT. 4: il client invia ACK ack=5002; il server passa a CLOSED. Il client attende in TIME-WAIT per 2 × MSL, 60 secondi su Linux, poi passa a CLOSED](../../../assets/diagrams/tcp-teardown.it.svg)

*Figura 4. Ogni lato invia il proprio FIN. Il lato che chiude per primo finisce in TIME-WAIT; l'altro ha finito non appena il suo FIN è confermato.*

- Il lato che chiude per primo invia FIN: «non ho altro da inviare». L'altro lato lo conferma e passa a **CLOSE-WAIT**: può ancora inviare dati finché la sua applicazione non chiama `close()`. Questo stato a senso unico è una **chiusura parziale** (half-close).
- Quando il secondo lato invia il proprio FIN e viene confermato, quel lato passa a CLOSED.
- Il lato che ha chiuso per primo attende in **TIME-WAIT** (`TIME_WAIT` in `netstat`) per il doppio della **Maximum Segment Lifetime (MSL, vita massima del segmento)** prima di dimenticare la connessione.

**Perché esiste TIME-WAIT.** Ha due compiti. Primo, se l'ultimo ACK si perde, l'altro lato rinvierà il suo FIN, e qualcuno deve ancora essere lì per confermarlo di nuovo. Secondo, impedisce che segmenti ritardatari della vecchia connessione siano accettati da una nuova connessione che per caso riusa la stessa 4-tupla. La RFC 9293 definisce la MSL come 2 minuti, il che renderebbe TIME-WAIT di 4 minuti; Linux usa 60 secondi fissi. TIME-WAIT è normale e costa pochissima memoria. Un client o un proxy molto attivo che apre molte connessioni brevi può mostrarne migliaia, e non è una perdita. Diventa un problema solo quando un client apre così tante connessioni verso lo *stesso* indirizzo e porta del server da esaurire le porte effimere. Il rimedio è riusare le connessioni (HTTP keep-alive, pool di connessioni), non disattivare TIME-WAIT.

Una connessione può anche terminare bruscamente con RST: un programma va in crash, un firewall reimposta la connessione, oppure arriva un segmento per una connessione che non esiste.

> [!CHECK]
> Dopo che un client chiude una connessione TCP verso un server web, `ss` sul client mostra la connessione in `TIME-WAIT` per circa un minuto. Cosa ti dice?
>
> - [ ] Il server non ha mai risposto al FIN del client, quindi la connessione è bloccata
> - [ ] L'applicazione client ha dimenticato di chiamare `close()`
> - [x] Non c'è nulla che non va: il lato che chiude per primo attende lì per poter rinviare un ultimo ACK perso e lasciar scadere i vecchi segmenti
> - [ ] Il client sta ancora inviando dati al server
>
> TIME-WAIT è l'ultimo stato normale di chi invia il primo FIN. Un'applicazione che dimentica di chiamare `close()` compare invece come CLOSE-WAIT, dal proprio lato.

### Affidabilità: numeri di sequenza, conferme e finestre
TCP numera byte, non segmenti. Il **numero di sequenza** di ogni segmento è il numero del suo primo byte di dati. Il **numero di conferma** è il prossimo byte che il ricevente si aspetta, ed è cumulativo: `ack=4001` significa «ho tutto fino al byte 4000». Nella Figura 3, il client invia 100 byte a partire da 1001, quindi il server risponde `ack=1101`.

Il mittente conserva ogni byte finché non è confermato. Se una conferma non arriva in tempo, scade il **timeout di ritrasmissione (RTO, retransmission timeout)** e il mittente rinvia. Il timeout si adatta al tempo di andata e ritorno misurato (RFC 6298). C'è anche un segnale più rapido: se il ricevente riceve un segmento fuori ordine, ripete la sua ultima conferma. Tre di questi **ACK duplicati** di fila dicono al mittente che manca un segmento, ed esso rinvia subito senza attendere il timer. È la **ritrasmissione rapida** (fast retransmit) (RFC 5681).

![Il mittente 192.0.2.10 invia seq=1001, 1000 byte; il ricevente 203.0.113.80 risponde ACK ack=2001 win=64000. Il segmento seq=2001 si perde nella rete. Il segmento seq=3001 arriva e il ricevente ripete ACK ack=2001, un duplicato che significa che manca ancora il byte 2001. Gli ACK duplicati o il timer di ritrasmissione fanno rinviare al mittente seq=2001, e il ricevente risponde ACK ack=4001](../../../assets/diagrams/tcp-retransmission.it.svg)

*Figura 5. Il ricevente può confermare solo fino al primo buco. Quando il buco è colmato, un solo ACK copre entrambi i segmenti.*

Il TCP moderno usa anche la **conferma selettiva (SACK, Selective Acknowledgement)** (RFC 2018), così il ricevente può dire esattamente quali blocchi ha già e il mittente rinvia solo ciò che manca.

Altri due meccanismi impediscono a TCP di inviare troppo in fretta:
- Il **controllo di flusso** protegge il *ricevente*. Ogni segmento porta una **finestra di ricezione** (`win`): quanti byte in più il ricevente può mettere in buffer in questo momento. Il mittente non ha mai in transito più dati non confermati di questo valore. Se la finestra scende a 0, il mittente si ferma e aspetta. Il window scaling (RFC 7323) permette alla finestra di superare i 64 KB sui collegamenti veloci.
- Il **controllo di congestione** protegge la *rete*. Il mittente tiene una propria stima, la finestra di congestione, parte piccolo (slow start), cresce finché tornano conferme e arretra quando vede perdite (RFC 5681). Linux usa per impostazione predefinita l'algoritmo CUBIC (RFC 9438); BBR, sviluppato da Google, è un'alternativa comune.

UDP non ha nulla di tutto ciò. Un'applicazione su UDP che ha bisogno di affidabilità o di controllo della velocità, come QUIC, deve costruirseli.

> [!CHECK]
> Un ricevente annuncia `win=0` nelle sue conferme. Cosa fa il mittente?
>
> - [ ] Rinvia subito tutti i dati non confermati
> - [ ] Chiude la connessione con FIN
> - [x] Smette di inviare nuovi dati finché il ricevente non annuncia una finestra maggiore di 0
> - [ ] Passa la connessione a UDP
>
> Una finestra di ricezione zero è controllo di flusso: l'applicazione ricevente non legge abbastanza in fretta e il suo buffer è pieno. Il mittente si ferma e sonda periodicamente finché la finestra non si riapre.

### Socket e loro stati
Su qualsiasi host puoi elencare i socket che il sistema operativo ha aperti. Su Linux lo strumento è `ss` (socket statistics); su macOS e Windows, `netstat`.

| Stato (come lo mostra `ss`) | Significato | Causa tipica |
|---|---|---|
| `LISTEN` | Un socket server in attesa di connessioni | Un servizio è in esecuzione e accetta connessioni su quell'indirizzo e porta |
| `SYN-SENT` | Una connessione è in corso; ancora nessuna risposta | Molti: la destinazione non risponde (cerca un timeout) |
| `SYN-RECV` | È arrivato un SYN ed è stato inviato il SYN, ACK | Molti: una rete lenta o un SYN flood |
| `ESTAB` | Una connessione stabilita | Traffico normale |
| `CLOSE-WAIT` | Il peer ha chiuso; la nostra applicazione non ancora | Molti: un bug dell'applicazione (non chiama mai `close()`) |
| `TIME-WAIT` | Abbiamo chiuso per primi e attendiamo 2 × MSL | Normale; molti su client e proxy molto attivi |
| `UNCONN` | Un socket UDP (UDP non ha connessioni) | Un servizio UDP come DNS o NTP |

`netstat` e la RFC scrivono gli stati in modo leggermente diverso: `ESTABLISHED`, `TIME_WAIT`, `CLOSE_WAIT` e, su Windows, `LISTENING`. Significano la stessa cosa.

Un **socket in ascolto** è associato a un indirizzo oltre che a una porta, e quell'indirizzo decide chi può connettersi:
- `127.0.0.1:5432` (o `[::1]:5432`): solo i programmi sulla stessa macchina, tramite l'interfaccia di loopback.
- `0.0.0.0:22` (o `[::]:22`, o `*:22`): ogni indirizzo IPv4 (o IPv6) dell'host, quindi chiunque possa raggiungere l'host.
- `203.0.113.80:443`: solo le connessioni che arrivano per quell'unico indirizzo.

Un server che «funziona in locale ma non dall'esterno» molto spesso ascolta solo su `127.0.0.1`.

I comandi che ti servono di più:

| Compito | Linux | macOS | Windows (PowerShell) |
|---|---|---|---|
| Socket TCP e UDP in ascolto, con il programma | `ss -tulpn` | `lsof -nP -iTCP -sTCP:LISTEN` e `lsof -nP -iUDP` | `netstat -ano` oppure `Get-NetTCPConnection -State Listen` |
| Tutti i socket TCP con il loro stato | `ss -tan` | `netstat -an -p tcp` | `netstat -an -p tcp` |

In `ss -tulpn`, le lettere significano: `-t` TCP, `-u` UDP, `-l` solo socket in ascolto, `-p` mostra il processo, `-n` mostra i numeri invece dei nomi dei servizi. Su Linux vedi il processo dei socket di altri utenti solo se lo esegui con `sudo`.

Per contare i socket TCP per stato, il che mostra subito un accumulo di TIME-WAIT o CLOSE-WAIT, su Linux:

```bash
ss -tan | awk 'NR>1 {print $1}' | sort | uniq -c
```

Su Windows (PowerShell), `Get-NetTCPConnection | Group-Object State` fa lo stesso.

> [!CHECK]
> `ss -tln` su un server mostra `LISTEN 0 4096 127.0.0.1:8000 0.0.0.0:*`. Il tuo collega non riesce a raggiungere la porta 8000 dal suo portatile. Qual è il motivo più probabile?
>
> - [ ] La porta è superiore a 1023, quindi solo gli amministratori possono connettersi
> - [ ] Il servizio è in TIME-WAIT e accetterà connessioni tra un minuto
> - [x] Il servizio ascolta solo sull'indirizzo di loopback, quindi accetta connessioni dal server stesso e da nessun altro posto
> - [ ] `0.0.0.0:*` significa che tutti i client sono bloccati
>
> L'indirizzo locale `127.0.0.1` limita l'ascolto all'interfaccia di loopback. La colonna del peer `0.0.0.0:*` significa semplicemente «qualsiasi peer» per un socket in ascolto. Associarlo a `0.0.0.0` (e aprire il firewall) lo renderebbe raggiungibile dall'esterno.

### «Connection refused» rispetto a «connection timed out»
Quando una connessione TCP fallisce, il messaggio di errore ti dice *fin dove è arrivato il SYN*.

![A sinistra: un client su 192.0.2.10 invia SYN a 198.51.100.20:8080, dove la porta è chiusa. L'host risponde RST, ACK e il client segnala connessione rifiutata in pochi millisecondi. A destra: un client su 192.0.2.10 invia SYN a 198.51.100.30:8080, dove un firewall lo scarta in silenzio. Il client ritenta il SYN altre due volte senza risposta e segnala connessione scaduta allo scadere del timeout](../../../assets/diagrams/tcp-refused-vs-timeout.it.svg)

*Figura 6. Rifiutata significa che qualcosa ha risposto. Scaduta significa che nulla ha risposto.*

- **Connection refused** (`ECONNREFUSED`). Il SYN ha raggiunto l'host di destinazione, ma nessun programma ascolta su quella porta, quindi lo stack TCP dell'host ha risposto con RST. L'errore arriva quasi subito. Un firewall configurato per *rifiutare* invece che per *scartare* ha lo stesso effetto, inviando RST o un messaggio «port unreachable» dell'Internet Control Message Protocol (ICMP). Guarda il server: il servizio è in esecuzione? Ascolta sulla porta e sull'indirizzo giusti (`ss -tlnp`)?
- **Connection timed out** (`ETIMEDOUT`). Non è tornata alcuna risposta. Il client rinvia il SYN più volte, attendendo ogni volta più a lungo, e rinuncia quando scade il suo timeout. Cause: un firewall o un security group cloud che scarta il traffico in silenzio, un host spento, un indirizzo IP sbagliato o un problema di instradamento. Guarda il percorso: firewall, security group, route.

Quanto dura un «timed out» dipende dal client. Su Linux con le impostazioni predefinite, il kernel ritenta il SYN con intervalli che partono da circa 1 secondo e poi raddoppiano, e rinuncia dopo poco più di 2 minuti (abbiamo misurato 136 s su Linux 7.2 con `net.ipv4.tcp_syn_retries = 6`). La maggior parte delle applicazioni imposta un proprio limite più breve, per esempio `curl --connect-timeout 5`.

Due errori affini vengono dal livello di rete anziché dal bersaglio:
- **No route to host** (`EHOSTUNREACH`): un router ha rimandato indietro un ICMP «host unreachable», oppure il tuo host non è riuscito a risolvere l'indirizzo Media Access Control (MAC) del next hop sul collegamento locale.
- **Network is unreachable** (`ENETUNREACH`): il tuo host non ha alcuna route verso quella destinazione (controlla `ip route`).

UDP non ha handshake, quindi non c'è nulla da rifiutare. Se un datagramma UDP raggiunge una porta chiusa, l'host di solito risponde con un ICMP «port unreachable», e un programma che ha usato `connect()` sul suo socket UDP può vedere un errore «connection refused» alla ricezione successiva. Più spesso, un client UDP semplicemente non sente nulla e deve affidarsi al proprio timeout.

> [!NOTE]
> Su Windows, un client che riceve RST può ritentare la connessione un paio di volte prima di segnalare l'errore, quindi il «refused» può richiedere circa due secondi invece di millisecondi. La distinzione (risposta rapida contro nessuna risposta) resta valida.

> [!CHECK]
> `curl https://198.51.100.20:8443` fallisce dopo esattamente 5 secondi con «Connection timed out», usando `--connect-timeout 5`. Dove guardi per prima cosa?
>
> - [ ] Nella configurazione del server web, perché ascolta sulla porta sbagliata
> - [x] Nel percorso: un firewall, un security group o un problema di instradamento sta scartando il SYN, oppure l'host è spento
> - [ ] Nell'intervallo di porte effimere del client, perché ha esaurito le porte
> - [ ] In TIME-WAIT sul server, perché le vecchie connessioni bloccano le nuove
>
> Una porta sbagliata su un host raggiungibile dà un immediato «connection refused» (RST). Un timeout significa nessuna risposta, il che indica qualcosa che scarta pacchetti o un host irraggiungibile.

## Come funziona
Mettiamo tutto insieme. Digiti `https://www.example.com` in un browser su un portatile a `192.0.2.10`. La pagina è servita da `203.0.113.80`.

1. **DNS su UDP.** Il browser ha bisogno dell'indirizzo IP. Il portatile invia una query DNS in un datagramma UDP da una porta effimera (diciamo 41837) alla porta 53 del resolver, e riceve un datagramma di risposta: `www.example.com` è `203.0.113.80`. Nessun handshake, due pacchetti.
2. **Scegliere una porta di origine.** Il browser chiede al sistema operativo una connessione TCP verso `203.0.113.80:443`. Il sistema operativo sceglie una porta effimera libera, la 50514. La 4-tupla `192.0.2.10:50514 → 203.0.113.80:443` ora identifica questa connessione.
3. **Handshake a tre vie.** SYN, SYN-ACK, ACK (Figura 3). Costa un round trip prima che i dati possano fluire. Il socket del server in LISTEN resta aperto per il client successivo; il sistema operativo crea un nuovo socket ESTABLISHED per questo.
4. **Dati.** Il browser avvia l'handshake TLS, poi invia la richiesta HTTP. Ogni segmento porta numeri di sequenza e di conferma; i segmenti persi sono ritrasmessi (Figura 5); la finestra di ricezione e la finestra di congestione limitano la velocità dei dati.
5. **Chiusura.** Quando il browser ha finito (spesso dopo aver tenuto la connessione aperta per un po' per altre richieste), un lato invia FIN, l'altro risponde con ACK e il proprio FIN (Figura 4). Chi ha inviato il primo FIN tiene la 4-tupla in TIME-WAIT per 60 secondi su Linux.
6. **Se qualcosa fallisce** al passo 3, l'errore ti dice dove: RST significa che l'host è raggiungibile ma nulla ascolta sulla 443 (refused); il silenzio significa che qualcosa sul percorso scarta il SYN (timed out).

Se browser e server supportano HTTP/3, i passi da 2 a 5 avvengono su QUIC sulla porta UDP 443, e QUIC combina il proprio handshake con quello TLS per risparmiare un round trip.

> [!CHECK]
> Nella sequenza qui sopra, quali messaggi viaggiano **prima** che il primo byte della richiesta HTTP lasci il portatile?
>
> - [ ] Solo la richiesta HTTP stessa; TCP invia i dati subito
> - [ ] Un handshake UDP con il resolver DNS, poi la richiesta HTTP
> - [x] Una query e una risposta DNS su UDP, l'handshake a tre vie di TCP e l'handshake TLS
> - [ ] La chiusura TCP della connessione precedente
>
> Il DNS non ha bisogno di handshake, ma TCP sì (SYN, SYN-ACK, ACK), e HTTPS aggiunge sopra l'handshake TLS. Per questo il riuso delle connessioni e l'handshake combinato di HTTP/3 fanno caricare le pagine più in fretta.

## Esempio pratico
Ti chiedono di controllare un server web Linux su `203.0.113.80`. Tutti gli indirizzi sono indirizzi di documentazione (RFC 5737).

**Quali servizi sono in ascolto?** Esegui come amministratore in modo che `ss` possa mostrare ogni processo:

```bash
sudo ss -tulpn
```

```text
Netid State  Recv-Q Send-Q  Local Address:Port  Peer Address:Port Process
udp   UNCONN 0      0           127.0.0.1:323        0.0.0.0:*     users:(("chronyd",pid=702,fd=5))
tcp   LISTEN 0      128           0.0.0.0:22         0.0.0.0:*     users:(("sshd",pid=812,fd=3))
tcp   LISTEN 0      511           0.0.0.0:443        0.0.0.0:*     users:(("nginx",pid=1034,fd=6))
tcp   LISTEN 0      4096        127.0.0.1:5432       0.0.0.0:*     users:(("postgres",pid=990,fd=7))
tcp   LISTEN 0      128              [::]:22            [::]:*     users:(("sshd",pid=812,fd=4))
```

Leggilo riga per riga:
- `udp UNCONN 127.0.0.1:323`: il demone NTP `chronyd` ha un socket UDP per comandi di controllo locali. I socket UDP compaiono come `UNCONN` perché UDP non ha connessioni.
- `tcp LISTEN 0.0.0.0:22` e `[::]:22`: SSH accetta connessioni su ogni indirizzo IPv4 e IPv6.
- `tcp LISTEN 0.0.0.0:443`: il server web, raggiungibile da ovunque il firewall lo consenta.
- `tcp LISTEN 127.0.0.1:5432`: il database PostgreSQL accetta solo connessioni locali. È un bene: l'applicazione web sullo stesso host può usarlo, Internet no.
- Per un socket in ascolto, `Send-Q` mostra il **backlog**: il numero massimo di connessioni che hanno completato l'handshake ma che il programma non ha ancora preso in carico (511 per nginx).

**Quali connessioni esistono in questo momento?**

```bash
ss -tan
```

```text
State      Recv-Q Send-Q     Local Address:Port      Peer Address:Port
LISTEN     0      128              0.0.0.0:22             0.0.0.0:*
LISTEN     0      511              0.0.0.0:443            0.0.0.0:*
LISTEN     0      4096           127.0.0.1:5432           0.0.0.0:*
ESTAB      0      0           203.0.113.80:443       192.0.2.10:50514
ESTAB      0      36          203.0.113.80:22      198.51.100.7:51022
TIME-WAIT  0      0           203.0.113.80:443       192.0.2.10:50388
ESTAB      0      0              127.0.0.1:5432         127.0.0.1:41870
ESTAB      0      0              127.0.0.1:41870        127.0.0.1:5432
LISTEN     0      128                 [::]:22                [::]:*
```

- `192.0.2.10:50514` è un browser connesso al server web. La sua porta di origine è effimera; il lato server è la 443.
- Un amministratore su `198.51.100.7` è connesso con SSH. `Send-Q 36` significa che 36 byte sono stati inviati ma non ancora confermati: normale per una sessione attiva.
- `TIME-WAIT … 192.0.2.10:50388` è una vecchia connessione dello stesso browser. L'ha chiusa per primo il *server* (per esempio per un timeout di keep-alive inattivo), quindi è il server a mantenere il TIME-WAIT.
- Le due righe `127.0.0.1` sono *una* connessione vista da entrambe le estremità: l'applicazione web (porta 41870) che parla con il database (5432). Le connessioni di loopback compaiono sempre due volte.

**Che aspetto ha un handshake sul cavo?** Una cattura con `tcpdump` sul server (`-n` mostra i numeri, `-t` nasconde i timestamp) mostra l'inizio della connessione del browser:

```bash
sudo tcpdump -n -t -i eth0 'tcp port 443 and host 192.0.2.10'
```

```text
IP 192.0.2.10.50514 > 203.0.113.80.443: Flags [S], seq 2864127401, win 64240, options [mss 1460,sackOK,TS val 3017325814 ecr 0,nop,wscale 7], length 0
IP 203.0.113.80.443 > 192.0.2.10.50514: Flags [S.], seq 1207650562, ack 2864127402, win 65160, options [mss 1460,sackOK,TS val 1554302991 ecr 3017325814,nop,wscale 7], length 0
IP 192.0.2.10.50514 > 203.0.113.80.443: Flags [.], ack 1, win 502, options [nop,nop,TS val 3017325839 ecr 1554302991], length 0
IP 192.0.2.10.50514 > 203.0.113.80.443: Flags [P.], seq 1:518, ack 1, win 502, options [nop,nop,TS val 3017325840 ecr 1554302991], length 517
IP 203.0.113.80.443 > 192.0.2.10.50514: Flags [.], ack 518, win 507, options [nop,nop,TS val 1554303016 ecr 3017325840], length 0
```

- `[S]` è SYN, `[S.]` è SYN-ACK (`.` sta per il flag ACK), `[.]` è un ACK semplice e `[P.]` sono dati con il flag PSH (push). `[F.]` e `[R]` sarebbero FIN e RST.
- Gli ISN sono numeri casuali a 32 bit: 2864127401 e 1207650562. Il SYN-ACK conferma 2864127401 + 1.
- Dalla terza riga in poi, `tcpdump` mostra numeri di sequenza *relativi* per risparmiare spazio: `ack 1` significa «ISN + 1». Il client poi invia i byte da 1 a 517 (`seq 1:518`, `length 517`, un TLS ClientHello) e il server conferma 518.
- `mss 1460` è il segmento più grande che ciascun lato accetta: un frame Ethernet da 1500 byte meno 20 byte di header IP e 20 di TCP. `win 502` con `wscale 7` significa una finestra di ricezione di 502 × 2⁷ = 64.256 byte.

> [!NOTE]
> Le dimensioni delle finestre, le opzioni e l'esatta disposizione delle colonne di `ss` variano con la versione del sistema operativo e le sue impostazioni. La struttura (flag, numeri di sequenza e di conferma, stati) è la stessa ovunque. Produrrai la tua cattura nel laboratorio.

## Errori comuni
- **Trattare «refused» e «timed out» come lo stesso problema.** Refused: vai sul server e controlla il servizio. Timed out: controlla firewall, security group e instradamento. Fare debug dell'applicazione quando un firewall scarta il SYN fa perdere ore.
- **Associare un servizio a `127.0.0.1` e chiedersi perché nessuno riesca a raggiungerlo**, o il contrario: associare un database o un'interfaccia di amministrazione a `0.0.0.0` «per farlo funzionare» ed esporlo a Internet.
- **Aprire solo la porta del server in un firewall stateless.** Le risposte tornano alla porta effimera del client. I firewall stateful lo gestiscono automaticamente; quelli stateless (come alcune access control list di rete, ACL, del cloud) richiedono l'intervallo effimero aperto per il traffico di ritorno, e Linux, Windows e macOS usano intervalli diversi.
- **«Sistemare» TIME-WAIT con ritocchi al kernel.** Migliaia di socket in TIME-WAIT sono normali su host molto attivi. Riusa invece le connessioni. La vecchia impostazione Linux `tcp_tw_recycle` rompeva i client dietro NAT ed è stata rimossa in Linux 4.12.
- **Ignorare CLOSE-WAIT.** I socket in CLOSE-WAIT che si accumulano e non spariscono mai sono un bug dell'applicazione: il programma non chiude mai connessioni che il peer ha già chiuso. Riavviare lo nasconde; correggere il codice lo cura.
- **Dare per scontato che TCP preservi i confini dei messaggi.** TCP è un flusso di byte. Due chiamate `send()` da 100 byte possono arrivare come una sola lettura da 200 byte, o come 150 + 50. Le applicazioni devono delimitare i propri messaggi (prefissi di lunghezza, delimitatori).
- **Dare per scontato che i datagrammi UDP arrivino.** UDP non avvisa quando un datagramma si perde. Un'applicazione su UDP ha bisogno di propri timeout e tentativi.
- **Dimenticare che le porte TCP e UDP sono separate.** Consentire la porta TCP 53 in un firewall non consente il DNS sulla porta UDP 53, e viceversa.

## Considerazioni sulla sicurezza
- **SYN flood.** Durante l'handshake, il server mantiene una connessione semi-aperta (SYN-RECV) per ogni SYN a cui risponde. Un attaccante che invia enormi quantità di SYN, di solito con indirizzi di origine falsificati, può riempire quella coda così che i client reali non riescano a connettersi. La difesa standard sono i **SYN cookie** (RFC 4987): quando la coda è piena, il server codifica i dettagli della connessione nel proprio ISN e non conserva stato finché non torna un ACK valido. Linux li abilita per impostazione predefinita (`net.ipv4.tcp_syncookies = 1`). Gli attacchi grandi richiedono inoltre rate limiting o un servizio di mitigazione a monte.
- **Scansione delle porte.** Poiché le porte chiuse rispondono con RST, quelle aperte con SYN-ACK e quelle filtrate con il silenzio, chiunque può mappare quali servizi espone un host. Questa è la **scansione delle porte** (port scanning), la stessa logica refused contro timeout che hai appena imparato. I difensori scansionano le *proprie* reti per trovare servizi che non dovrebbero essere esposti. Scansionare sistemi che non possiedi o che non sei esplicitamente autorizzato a testare può essere illegale e viola i termini di servizio della maggior parte dei provider.
- **Esporre il minimo possibile.** Ogni porta in ascolto è superficie d'attacco. Associa i servizi interni (database, cache, pannelli di amministrazione) a `127.0.0.1` o a un indirizzo privato, metti un firewall default-deny davanti a tutto il resto e non pubblicare mai SSH (22), RDP (3389) o database (3306, 5432, 6379…) direttamente su Internet. Usa invece una rete privata virtuale (VPN) o un bastion host. Rivedi regolarmente l'output di `ss -tulpn`.
- **Scartare o rifiutare?** Scartare rallenta le scansioni e rivela meno; rifiutare rende i fallimenti rapidi e chiari per gli utenti legittimi. Molte organizzazioni scartano al bordo di Internet e rifiutano all'interno della rete.
- **Riflessione e amplificazione UDP.** UDP non ha handshake, quindi l'indirizzo di origine è facile da falsificare. Gli attaccanti inviano piccole query a server DNS, NTP o memcached aperti con l'indirizzo della vittima come origine, e le risposte, più grandi, inondano la vittima. Non eseguire resolver aperti né servizi su UDP che rispondano a chiunque, e filtra le origini falsificate al bordo della rete (Best Current Practice BCP 38, RFC 2827).
- **TCP e UDP non cifrano.** Chiunque si trovi sul percorso può leggere e modificare i dati. Usa TLS (HTTPS, SMTP con STARTTLS, l'Internet Message Access Protocol su TLS, IMAPS), SSH o QUIC per tutto ciò che è sensibile. Gli ISN imprevedibili (RFC 6528) e i controlli della RFC 5961 rendono difficile l'iniezione alla cieca di falsi segmenti o RST, ma non proteggono da un attaccante che può vedere il traffico.

## Riepilogo
- Il livello di trasporto consegna i dati ai processi. Le porte (0–65535) li identificano: ben note/di sistema 0–1023, registrate/utente 1024–49151, dinamiche/effimere 49152–65535 (RFC 6335). Linux usa per impostazione predefinita 32768–60999 per le porte effimere. Una 4-tupla identifica una connessione.
- UDP (RFC 768) è senza connessione, best effort e minimale: un header di 8 byte, datagrammi separati, nessuna conferma. TCP (RFC 9293) è orientato alla connessione, affidabile e ordinato, con controllo di flusso e di congestione. QUIC (RFC 9000) costruisce sopra UDP funzioni simili a quelle di TCP più la cifratura.
- TCP si apre con SYN, SYN-ACK, ACK e si chiude con un FIN e un ACK in ogni direzione. Il lato che chiude per primo attende in TIME-WAIT (2 × MSL; 60 s su Linux), ed è normale.
- I numeri di sequenza contano byte; le conferme indicano il prossimo byte atteso. I dati persi sono rinviati dopo un timeout o ACK duplicati; la finestra di ricezione (controllo di flusso) e la finestra di congestione limitano la velocità di invio.
- `ss -tulpn` / `ss -tan` (Linux) e `netstat`, `lsof` o `Get-NetTCPConnection` (macOS, Windows) mostrano i socket in ascolto e gli stati. Controlla l'indirizzo di ascolto oltre alla porta.
- «Connection refused» significa che l'host ha risposto con RST: nulla ascolta lì. «Connection timed out» significa nessuna risposta: guarda firewall, instradamento e se l'host è acceso.

## Glossario
| Termine | Definizione |
|---|---|
| Livello di trasporto | Livello 4 OSI: trasporta dati tra processi su host diversi, usando le porte. |
| Porta | Numero a 16 bit (0–65535) che identifica l'estremità di un processo per TCP o UDP su un host. |
| Demultiplexing | Consegna dei dati in arrivo al processo giusto in base alla porta di destinazione. |
| Multiplexing | Combinazione dei dati di molti processi su un'unica connessione di rete o indirizzo IP, etichettati con le porte. |
| Porte ben note | Porte 0–1023, chiamate porte di sistema nella RFC 6335; usate dai servizi standard. |
| Porte registrate | Porte 1024–49151, chiamate porte utente nella RFC 6335; assegnate a servizi da IANA su richiesta. |
| Porta effimera | Porta temporanea che il sistema operativo assegna a un client per una connessione; la RFC 6335 riserva 49152–65535 per esse. |
| Socket | Estremità di comunicazione: un indirizzo IP, una porta e un protocollo, come usati da un programma. |
| 4-tupla | Indirizzo IP di origine, porta di origine, indirizzo IP di destinazione e porta di destinazione: insieme identificano una connessione. |
| 5-tupla | La 4-tupla più il protocollo (TCP o UDP); usata da firewall e NAT. |
| User Datagram Protocol (UDP) | Protocollo di trasporto senza connessione e best effort con un header di 8 byte (RFC 768). |
| Datagramma | Messaggio UDP autonomo che arriva intero o non arriva affatto. |
| Senza connessione | Invio di dati senza prima stabilire una connessione né conservare stato sul peer. |
| Transmission Control Protocol (TCP) | Protocollo di trasporto orientato alla connessione che consegna un flusso di byte affidabile e ordinato (RFC 9293). |
| Orientato alla connessione | Che richiede a entrambe le estremità di stabilire una connessione prima di scambiare dati. |
| Flusso di byte | Modello di servizio di TCP: una sequenza ordinata di byte senza confini di messaggio. |
| Segmento | L'unità di dati inviata da TCP: un header TCP più un pezzo del flusso di byte. |
| QUIC | Protocollo di trasporto sopra UDP con affidabilità, flussi, controllo di congestione e cifratura TLS 1.3 integrati (RFC 9000); usato da HTTP/3. |
| Handshake a tre vie | Lo scambio SYN, SYN-ACK, ACK che apre una connessione TCP. |
| SYN | Flag TCP che apre una connessione e porta il numero di sequenza iniziale. |
| ACK | Flag TCP che segna il numero di conferma come valido; presente su quasi ogni segmento dopo il primo. |
| FIN | Flag TCP che significa «non ho altri dati da inviare»; chiude una direzione della connessione. |
| RST | Flag TCP che interrompe subito una connessione, o rifiuta una connessione verso una porta chiusa. |
| Numero di sequenza iniziale (ISN) | Il numero di sequenza di partenza a 32 bit, imprevedibile, che ogni lato sceglie per una connessione. |
| Maximum Segment Size (MSS) | La quantità massima di dati che un host accetta in un segmento TCP, annunciata nel SYN. |
| ESTABLISHED | Stato TCP di una connessione aperta che può trasportare dati (`ESTAB` in `ss`). |
| CLOSE-WAIT | Stato TCP dopo che il peer ha chiuso ma l'applicazione locale non ancora (`CLOSE_WAIT` in `netstat`). |
| Chiusura parziale (half-close) | Connessione TCP in cui una direzione è chiusa mentre l'altra può ancora inviare. |
| TIME-WAIT | Stato TCP del lato che ha chiuso per primo, mantenuto per 2 × MSL (`TIME_WAIT` in `netstat`). |
| Maximum Segment Lifetime (MSL) | Il tempo massimo presunto di sopravvivenza di un segmento nella rete; 2 minuti nella RFC 9293. |
| Numero di sequenza | Il numero del primo byte di dati di un segmento TCP. |
| Numero di conferma | Il prossimo byte che un ricevente TCP si aspetta; conferma tutto ciò che lo precede. |
| Timeout di ritrasmissione (RTO) | Il timer adattivo dopo il quale TCP rinvia i dati non confermati (RFC 6298). |
| ACK duplicato | Una conferma ripetuta per lo stesso byte, inviata quando un segmento arriva fuori ordine. |
| Ritrasmissione rapida | Rinvio di un segmento dopo tre ACK duplicati, senza attendere l'RTO (RFC 5681). |
| Conferma selettiva (SACK) | Opzione TCP che permette al ricevente di segnalare esattamente quali blocchi ha ricevuto (RFC 2018). |
| Controllo di flusso | Limitare il mittente a ciò che il ricevente può mettere in buffer, tramite la finestra di ricezione. |
| Finestra di ricezione | Il numero di byte che un ricevente TCP può ancora accettare, annunciato in ogni segmento (`win`). |
| Controllo di congestione | Limitare la velocità di invio a ciò che la rete può trasportare, tramite la finestra di congestione (RFC 5681). |
| Socket in ascolto | Socket server nello stato LISTEN, in attesa di connessioni su un indirizzo e una porta. |
| Connection refused | Errore quando la destinazione risponde a un SYN con RST (o ICMP port unreachable): nulla è in ascolto. |
| Connection timed out | Errore quando nessuna risposta al SYN arriva prima del timeout del client. |
| No route to host | Errore (`EHOSTUNREACH`) quando un router segnala l'host irraggiungibile, o l'indirizzo MAC del next hop non può essere risolto. |
| Network is unreachable | Errore (`ENETUNREACH`) quando l'host locale non ha alcuna route verso la destinazione. |
| Backlog | La coda di connessioni che hanno completato l'handshake ma che il programma non ha ancora accettato. |
| SYN cookie | Difesa contro i SYN flood che codifica lo stato della connessione nell'ISN del server invece di memorizzarlo (RFC 4987). |
| Scansione delle porte | Sondare le porte di un host per scoprire quali sono aperte, chiuse o filtrate. |

## Verifica la comprensione
1. Perché un client usa una porta effimera invece di una fissa, mentre un server usa una porta fissa e ben nota?
2. Il DNS di norma usa UDP, ma il DHCP *deve* usare UDP. Qual è la differenza nei motivi?
3. In una cattura, un SYN ha `seq 2000` e il SYN-ACK ha `seq 7000`. Quali numeri di conferma portano il SYN-ACK e l'ACK finale, e perché «più uno»?
4. Un server mostra 3.000 socket in `TIME-WAIT` e 2.000 in `CLOSE-WAIT`. Quale numero ti preoccuperebbe e cosa guarderesti?
5. `ss -tln` mostra il tuo servizio su `0.0.0.0:8080`, ma i client da Internet ottengono «connection timed out». Elenca due cause possibili e come verificheresti ciascuna.
6. Perché i SYN flood sono un problema per i server TCP, e perché i SYN cookie non richiedono che il server ricordi nulla delle connessioni semi-aperte?

## Riferimenti
- [RFC 9293](https://www.rfc-editor.org/rfc/rfc9293) — Transmission Control Protocol (TCP).
- [RFC 768](https://www.rfc-editor.org/rfc/rfc768) — User Datagram Protocol.
- [RFC 6335](https://www.rfc-editor.org/rfc/rfc6335) — Procedures for the Management of the Service Name and Transport Protocol Port Number Registry.
- [IANA Service Name and Transport Protocol Port Number Registry](https://www.iana.org/assignments/service-names-port-numbers/).
- [RFC 6298](https://www.rfc-editor.org/rfc/rfc6298) — Computing TCP's Retransmission Timer.
- [RFC 5681](https://www.rfc-editor.org/rfc/rfc5681) — TCP Congestion Control.
- [RFC 2018](https://www.rfc-editor.org/rfc/rfc2018) — TCP Selective Acknowledgment Options.
- [RFC 7323](https://www.rfc-editor.org/rfc/rfc7323) — TCP Extensions for High Performance (window scaling, timestamps).
- [RFC 9438](https://www.rfc-editor.org/rfc/rfc9438) — CUBIC for Fast and Long-Distance Networks.
- [RFC 6528](https://www.rfc-editor.org/rfc/rfc6528) — Defending against Sequence Number Attacks.
- [RFC 5961](https://www.rfc-editor.org/rfc/rfc5961) — Improving TCP's Robustness to Blind In-Window Attacks.
- [RFC 4987](https://www.rfc-editor.org/rfc/rfc4987) — TCP SYN Flooding Attacks and Common Mitigations.
- [RFC 7766](https://www.rfc-editor.org/rfc/rfc7766) — DNS Transport over TCP — Implementation Requirements.
- [RFC 9000](https://www.rfc-editor.org/rfc/rfc9000) — QUIC: A UDP-Based Multiplexed and Secure Transport.
- [RFC 9114](https://www.rfc-editor.org/rfc/rfc9114) — HTTP/3.
- [RFC 2827](https://www.rfc-editor.org/rfc/rfc2827) — Network Ingress Filtering (BCP 38).
- [RFC 5737](https://www.rfc-editor.org/rfc/rfc5737) — IPv4 Address Blocks Reserved for Documentation.
- [Documentazione del kernel Linux: IP sysctl](https://docs.kernel.org/networking/ip-sysctl.html) — `ip_local_port_range`, `tcp_syn_retries`, `tcp_syncookies` e impostazioni correlate.
