---
title: "Couche transport : TCP, UDP et ports"
domain: networking
level: beginner
duration: "50 min"
objectives:
  - Expliquer le rôle de la couche transport et comment les ports identifient les processus (ports bien connus, enregistrés et éphémères).
  - Comparer TCP et UDP (connexions, fiabilité, ordre, surcoût) et choisir l'un des deux pour une application donnée.
  - Décrire la poignée de main TCP en trois temps, la fermeture de la connexion, les numéros de séquence et d'acquittement, la retransmission et le contrôle de flux.
  - Identifier les sockets en écoute et les états de connexion (LISTEN, ESTABLISHED, TIME_WAIT) avec `ss` ou `netstat`.
  - Diagnostiquer « connection refused » par rapport à « connection timed out ».
lang: fr
source_hash: 6d1886187aec
---

# Couche transport : TCP, UDP et ports

## Pourquoi c'est important
Vous déployez une petite application web sur un serveur et vous l'essayez depuis votre portable. Le navigateur affiche *connection refused* (connexion refusée). Un collègue essaie une minute plus tard depuis chez lui et obtient *connection timed out* (délai de connexion dépassé). Les deux messages signifient « ça ne marche pas », mais ils renvoient à des problèmes complètement différents. Le premier dit que le serveur a répondu : « personne n'écoute ici ». Le second dit que rien n'a répondu, donc que les paquets ont été perdus quelque part en chemin. Si vous savez les distinguer, vous savez s'il faut examiner l'application ou le pare-feu.

Les mêmes connaissances expliquent des énigmes du quotidien. Pourquoi un appel vidéo continue-t-il malgré une mauvaise connexion Wi-Fi alors qu'un téléchargement reste bloqué ? Pourquoi un serveur très sollicité affiche-t-il des milliers de connexions dans un état appelé `TIME_WAIT` ? Pourquoi un même serveur peut-il faire tourner un serveur web et un serveur Secure Shell (SSH) sur la même adresse Internet Protocol (IP) ? Toutes les réponses se trouvent dans la couche transport, domaine du Transmission Control Protocol (TCP) et du User Datagram Protocol (UDP), et sujet de cette leçon.

## Objectifs pédagogiques
- Expliquer le rôle de la couche transport et comment les ports identifient les processus (ports bien connus, enregistrés et éphémères).
- Comparer TCP et UDP (connexions, fiabilité, ordre, surcoût) et choisir l'un des deux pour une application donnée.
- Décrire la poignée de main TCP en trois temps, la fermeture de la connexion, les numéros de séquence et d'acquittement, la retransmission et le contrôle de flux.
- Identifier les sockets en écoute et les états de connexion (LISTEN, ESTABLISHED, TIME_WAIT) avec `ss` ou `netstat`.
- Diagnostiquer « connection refused » par rapport à « connection timed out ».

## Concepts clés

### Ports : de l'hôte au processus
Une adresse IP amène un paquet au bon immeuble. Elle ne dit pas à quel appartement. Un serveur en `203.0.113.80` peut faire tourner en même temps un serveur web, un serveur SSH et une base de données, et votre portable peut avoir vingt onglets de navigateur ouverts. Il faut bien que quelque chose décide à quel programme appartient chaque paquet.

C'est le rôle de la **couche transport** (couche 4 du [modèle OSI](../04-osi-model/lesson.fr.md)). Elle transporte des données entre des *processus*, pas seulement entre des hôtes. Pour cela, elle étiquette chaque message avec deux numéros de **port** : un port source et un port destination. Un port est un nombre de 16 bits, de 0 à 65535. Un programme qui veut recevoir du trafic demande un port au système d'exploitation ; dès lors, le système lui remet tout ce qui arrive sur ce port. Trier les données entrantes par port s'appelle le **démultiplexage** ; mélanger les données de nombreux programmes sur une même adresse IP, c'est le **multiplexage**.

La RFC 6335 répartit les numéros de port en trois plages, et l'Internet Assigned Numbers Authority (IANA) tient le registre :

| Plage | Nom dans la RFC 6335 | Aussi appelés | Utilisés pour |
|---|---|---|---|
| 0–1023 | Ports système | **Ports bien connus** (well-known) | Services standard : 22 SSH, 53 Domain Name System (DNS), 443 HTTP Secure (HTTPS) |
| 1024–49151 | Ports utilisateur | **Ports enregistrés** | Services enregistrés auprès de l'IANA : 3389 Remote Desktop Protocol (RDP), 5432 PostgreSQL |
| 49152–65535 | Ports dynamiques et/ou privés | **Ports éphémères** | Ports source temporaires des clients, jamais attribués à un service |

Un serveur écoute sur un port fixe et bien connu pour que les clients sachent où le trouver. Un client se moque du port qu'il utilise ; le système d'exploitation choisit donc un **port éphémère** libre à chaque ouverture de connexion.

> [!NOTE]
> Tous les systèmes d'exploitation ne suivent pas la plage dynamique de la RFC 6335. Windows (depuis Vista) et macOS utilisent par défaut 49152–65535, mais Linux utilise 32768–60999. Vérifiez le vôtre avec `cat /proc/sys/net/ipv4/ip_local_port_range` sous Linux, `sysctl net.inet.ip.portrange.first net.inet.ip.portrange.last` sous macOS ou `netsh int ipv4 show dynamicport tcp` sous Windows. Cela compte quand vous écrivez des règles de pare-feu pour le trafic retour.

L'extrémité d'un programme, une adresse IP plus un port plus un protocole, s'appelle un **socket**. Une connexion est identifiée par son **4-uplet** : adresse IP source, port source, adresse IP destination, port destination. Ajoutez le protocole et vous obtenez le **5-uplet** que suivent les pare-feu et les équipements de Network Address Translation (NAT). Comme le port du client diffère, deux onglets de navigateur peuvent parler au même port du serveur en même temps sans mélanger leurs données :

![Un client en 192.0.2.10 exécute l'onglet 1 du navigateur sur le port éphémère 50514, l'onglet 2 sur le 50515 et un client SSH sur le 50600. Un serveur en 203.0.113.80 écoute sur le port 443 (serveur web) et le port 22 (serveur SSH). Les deux onglets se connectent au 443 et le client SSH au 22. Les trois connexions TCP sont 192.0.2.10:50514 vers 203.0.113.80:443, 192.0.2.10:50515 vers 203.0.113.80:443 et 192.0.2.10:50600 vers 203.0.113.80:22](../../../assets/diagrams/tcp-ports-sockets.fr.svg)

*Figure 1. Deux connexions partagent la destination `203.0.113.80:443`. Elles restent distinctes, car leurs 4-uplets diffèrent par le port source.*

Quelques ports que vous rencontrerez constamment :

| Port | Protocole | Service |
|---|---|---|
| 22 | TCP | Secure Shell (SSH) |
| 25 | TCP | Simple Mail Transfer Protocol (SMTP), de serveur à serveur |
| 53 | UDP et TCP | DNS |
| 67 / 68 | UDP | Dynamic Host Configuration Protocol (DHCP), serveur / client |
| 80 | TCP | Hypertext Transfer Protocol (HTTP) |
| 123 | UDP | Network Time Protocol (NTP) |
| 443 | TCP, et UDP pour HTTP/3 | HTTPS |
| 3389 | TCP et UDP | Remote Desktop Protocol (RDP) |

TCP et UDP ont des espaces de ports séparés. Le port TCP 53 et le port UDP 53 sont deux sockets différents, et un programme peut écouter sur l'un sans l'autre.

> [!CHECK]
> Votre portable ouvre deux connexions vers `https://www.example.com` en même temps. Les deux vont vers `203.0.113.80:443`. Comment le serveur sépare-t-il leurs données ?
>
> - [ ] Chaque connexion utilise un port de destination différent sur le serveur
> - [x] Le portable utilise un port source éphémère différent pour chacune, donc les deux 4-uplets diffèrent
> - [ ] Le serveur ne peut gérer qu'une seule connexion par adresse IP cliente à la fois
> - [ ] Le navigateur ajoute un numéro de connexion à l'en-tête IP
>
> Le port du serveur reste 443 pour les deux. Le système d'exploitation donne à chaque connexion son propre port source éphémère, et le 4-uplet (IP source, port source, IP destination, port destination) identifie chaque connexion de façon unique.

### TCP et UDP comparés
Internet dispose de deux protocoles de transport d'usage courant. Ils font des compromis opposés.

Le **User Datagram Protocol (UDP)** (RFC 768) est l'option minimale. Il ajoute un en-tête de 8 octets (port source, port destination, longueur et une somme de contrôle) et envoie le message. Chaque message est un **datagramme** : il arrive entier ou pas du tout. UDP est **sans connexion** : pas d'établissement, pas d'acquittement, pas de retransmission. Si un datagramme est perdu, dupliqué ou doublé par un datagramme plus récent, UDP ne s'en aperçoit pas. C'est à l'application de décider si cela compte.

Le **Transmission Control Protocol (TCP)** (RFC 9293) fait beaucoup plus. Il est **orienté connexion** : les deux côtés s'entendent pour communiquer avant que la moindre donnée circule. Il livre ensuite un **flux d'octets** fiable et ordonné : chaque octet est numéroté, acquitté et renvoyé en cas de perte, et le programme récepteur lit les octets dans l'ordre où ils ont été envoyés. TCP ralentit aussi quand le récepteur ou le réseau ne suit pas. Son unité de données est le **segment**, avec un en-tête de 20 à 60 octets.

![Comparaison. Avant d'envoyer : TCP fait une poignée de main en trois temps ; UDP envoie directement. Livraison : TCP acquitte les données et renvoie les pertes ; UDP fonctionne au mieux, sans ACK. Ordre : TCP est un flux d'octets ordonné ; UDP envoie des datagrammes séparés. Contrôle de flux et de congestion : intégré à TCP ; aucun dans UDP, à la charge de l'application. Taille de l'en-tête : TCP 20 à 60 octets, UDP 8 octets. Usages typiques de TCP : HTTPS 443, SSH 22, SMTP 25, IMAPS 993. Usages typiques d'UDP : DNS 53, DHCP 67/68, NTP 123, QUIC 443](../../../assets/diagrams/tcp-vs-udp.fr.svg)

*Figure 2. TCP achète la fiabilité et l'ordre avec une poignée de main, des acquittements et un en-tête plus gros. UDP offre rapidité et simplicité et laisse le reste à l'application.*

Choisir entre les deux revient à savoir ce qui coûte le plus : attendre ou perdre des données.

| Application | Choix habituel | Pourquoi |
|---|---|---|
| Pages web, interfaces de programmation d'applications (API), transfert de fichiers, e-mail, SSH | TCP | Chaque octet doit arriver, dans l'ordre. Un court délai est acceptable. |
| Requêtes DNS | UDP (TCP pour les grosses réponses et les transferts de zone) | Une petite question, une petite réponse. Une requête perdue est simplement reposée. La RFC 7766 impose aux serveurs DNS de prendre aussi en charge TCP. |
| Appels voix et vidéo, jeux en ligne | UDP | Un paquet en retard est inutile. Mieux vaut l'ignorer que tout bloquer pendant qu'on le renvoie. |
| DHCP | UDP | Le client n'a pas encore d'adresse IP et doit émettre en diffusion (broadcast). TCP ne peut pas : une connexion a exactement deux extrémités. |
| Vidéo en direct vers de nombreux récepteurs (multicast) | UDP | Même raison : TCP est strictement un-à-un. |

UDP n'est pas « non fiable » au mauvais sens du terme. Il est *sans a priori*. **QUIC** (RFC 9000) en est le meilleur exemple : il fonctionne au-dessus d'UDP et construit sa propre fiabilité, son ordonnancement, son contrôle de congestion et un chiffrement Transport Layer Security (TLS) 1.3 intégré. HTTP/3 (RFC 9114) utilise QUIC, ce qui explique qu'aujourd'hui HTTPS utilise à la fois le port TCP 443 et le port UDP 443.

> [!CHECK]
> Une équipe crée un jeu multijoueur. Le serveur envoie la position de chaque joueur 30 fois par seconde. Quel transport convient le mieux, et pourquoi ?
>
> - [ ] TCP, car une mise à jour de position perdue doit toujours être renvoyée
> - [x] UDP, car une ancienne position renvoyée est inutile dès qu'une plus récente existe, et l'attendre figerait le jeu
> - [ ] UDP, car il chiffre les données et empêche la triche
> - [ ] TCP, car UDP ne peut pas transporter plus d'un message par seconde
>
> Chaque mise à jour remplace la précédente : une retransmission arrive donc trop tard pour servir, et la livraison dans l'ordre de TCP retiendrait les mises à jour plus récentes pendant l'attente. Ni TCP ni UDP ne chiffrent quoi que ce soit par eux-mêmes.

### La connexion TCP : établissement et fermeture
Une connexion TCP commence par la **poignée de main en trois temps** (three-way handshake). Pensez à un appel téléphonique : « Vous m'entendez ? » « Oui, je vous entends, vous m'entendez ? » « Oui. » Ce n'est qu'ensuite que la conversation commence.

La poignée de main utilise des drapeaux (flags), des bits isolés de l'en-tête TCP. Le drapeau **SYN** (synchronize) ouvre une connexion, le drapeau **ACK** (acknowledgement, acquittement) indique que le numéro d'acquittement est valide, le drapeau **FIN** (finish) ferme un sens, et le drapeau **RST** (reset) interrompt une connexion immédiatement.

![Poignée de main TCP entre un client en 192.0.2.10:50514 (CLOSED) et un serveur en 203.0.113.80:443 (LISTEN). 1 : le client envoie SYN seq=1000 et passe en SYN-SENT ; le serveur passe en SYN-RECEIVED. 2 : le serveur envoie SYN, ACK seq=5000 ack=1001 ; le client passe en ESTABLISHED. 3 : le client envoie ACK ack=5001 ; le serveur passe en ESTABLISHED. Puis le client envoie 100 octets de données à seq=1001, par exemple un TLS ClientHello, et le serveur répond ACK ack=1101](../../../assets/diagrams/tcp-handshake.fr.svg)

*Figure 3. Trois messages ouvrent la connexion. Chaque côté choisit son propre numéro de séquence initial et l'autre côté l'acquitte en lui ajoutant un.*

1. **SYN.** Le client choisit un **numéro de séquence initial (ISN, initial sequence number)**, ici 1000, et envoie un segment avec le drapeau SYN. Il annonce aussi des options comme sa **Maximum Segment Size (MSS, taille maximale de segment)**, le plus gros bloc de données qu'il peut recevoir dans un segment.
2. **SYN, ACK.** Le serveur choisit son propre ISN (5000) et acquitte celui du client : `ack=1001` signifie « j'ai reçu ton SYN ; le prochain octet que j'attends de toi est le 1001 ». Un SYN compte pour un octet de l'espace de séquence même s'il ne transporte pas de données.
3. **ACK.** Le client acquitte le SYN du serveur avec `ack=5001`. Les deux côtés sont maintenant **ESTABLISHED** et les données peuvent circuler dans les deux sens.

Les vrais ISN ne valent pas 1000 et 5000. Ce sont des nombres de 32 bits choisis de façon imprévisible (RFC 9293, d'après la RFC 6528), afin qu'un attaquant ne puisse pas les deviner et injecter de faux segments dans une connexion.

La fermeture se fait en quatre étapes, car chaque sens se ferme séparément :

![Fermeture TCP entre le client 192.0.2.10:50514 et le serveur 203.0.113.80:443, tous deux ESTABLISHED. 1 : le client envoie FIN seq=1101 et passe en FIN-WAIT-1. 2 : le serveur envoie ACK ack=1102 et passe en CLOSE-WAIT ; le client passe en FIN-WAIT-2. L'application serveur termine et appelle close(). 3 : le serveur envoie FIN seq=5001 et passe en LAST-ACK ; le client passe en TIME-WAIT. 4 : le client envoie ACK ack=5002 ; le serveur passe en CLOSED. Le client attend en TIME-WAIT pendant 2 × MSL, 60 secondes sous Linux, puis passe en CLOSED](../../../assets/diagrams/tcp-teardown.fr.svg)

*Figure 4. Chaque côté envoie son propre FIN. Le côté qui ferme en premier finit en TIME-WAIT ; l'autre a terminé dès que son FIN est acquitté.*

- Le côté qui ferme en premier envoie FIN : « je n'ai plus rien à envoyer ». L'autre côté l'acquitte et passe en **CLOSE-WAIT** : il peut encore envoyer des données jusqu'à ce que son application appelle `close()`. Cet état à sens unique est une **fermeture partielle** (half-close).
- Quand le second côté envoie son FIN et qu'il est acquitté, ce côté passe en CLOSED.
- Le côté qui a fermé en premier attend en **TIME-WAIT** (`TIME_WAIT` dans `netstat`) pendant deux fois la **Maximum Segment Lifetime (MSL, durée de vie maximale d'un segment)** avant d'oublier la connexion.

**Pourquoi TIME-WAIT existe.** Il a deux rôles. D'abord, si le tout dernier ACK est perdu, l'autre côté renverra son FIN, et quelqu'un doit encore être là pour l'acquitter de nouveau. Ensuite, il empêche que des segments retardataires de l'ancienne connexion soient acceptés par une nouvelle connexion qui réutiliserait par hasard le même 4-uplet. La RFC 9293 définit la MSL à 2 minutes, ce qui ferait un TIME-WAIT de 4 minutes ; Linux utilise 60 secondes fixes. TIME-WAIT est normal et coûte très peu de mémoire. Un client ou un proxy très sollicité qui ouvre beaucoup de connexions courtes peut en afficher des milliers, et ce n'est pas une fuite. Cela ne devient un problème que lorsqu'un client ouvre tant de connexions vers la *même* adresse et le *même* port de serveur qu'il épuise ses ports éphémères. Le remède est de réutiliser les connexions (HTTP keep-alive, pools de connexions), pas de désactiver TIME-WAIT.

Une connexion peut aussi se terminer brutalement avec RST : un programme plante, un pare-feu réinitialise la connexion, ou un segment arrive pour une connexion qui n'existe pas.

> [!CHECK]
> Après qu'un client a fermé une connexion TCP vers un serveur web, `ss` sur le client affiche la connexion en `TIME-WAIT` pendant environ une minute. Que cela vous indique-t-il ?
>
> - [ ] Le serveur n'a jamais répondu au FIN du client, donc la connexion est bloquée
> - [ ] L'application cliente a oublié d'appeler `close()`
> - [x] Rien d'anormal : le côté qui ferme en premier attend là pour pouvoir renvoyer un dernier ACK perdu et laisser expirer les anciens segments
> - [ ] Le client envoie encore des données au serveur
>
> TIME-WAIT est le dernier état normal de celui qui envoie le premier FIN. Une application qui oublie d'appeler `close()` apparaît plutôt en CLOSE-WAIT, de son propre côté.

### Fiabilité : numéros de séquence, acquittements et fenêtres
TCP numérote des octets, pas des segments. Le **numéro de séquence** de chaque segment est le numéro de son premier octet de données. Le **numéro d'acquittement** est le prochain octet attendu par le récepteur, et il est cumulatif : `ack=4001` signifie « j'ai tout jusqu'à l'octet 4000 ». Dans la Figure 3, le client envoie 100 octets à partir de 1001, donc le serveur répond `ack=1101`.

L'émetteur conserve chaque octet jusqu'à son acquittement. Si un acquittement n'arrive pas à temps, la **temporisation de retransmission (RTO, retransmission timeout)** expire et l'émetteur renvoie. La temporisation s'adapte au temps d'aller-retour mesuré (RFC 6298). Il existe aussi un signal plus rapide : si le récepteur reçoit un segment dans le désordre, il répète son dernier acquittement. Trois de ces **ACK en double** d'affilée indiquent à l'émetteur qu'un segment manque, et il renvoie aussitôt sans attendre la temporisation. C'est la **retransmission rapide** (fast retransmit) (RFC 5681).

![L'émetteur 192.0.2.10 envoie seq=1001, 1000 octets ; le récepteur 203.0.113.80 répond ACK ack=2001 win=64000. Le segment seq=2001 est perdu dans le réseau. Le segment seq=3001 arrive et le récepteur répète ACK ack=2001, un doublon signifiant que l'octet 2001 manque toujours. Les ACK en double ou la temporisation de retransmission poussent l'émetteur à renvoyer seq=2001, et le récepteur répond ACK ack=4001](../../../assets/diagrams/tcp-retransmission.fr.svg)

*Figure 5. Le récepteur ne peut acquitter que jusqu'au premier trou. Quand le trou est comblé, un seul ACK couvre les deux segments.*

Le TCP moderne utilise aussi l'**acquittement sélectif (SACK, Selective Acknowledgement)** (RFC 2018), de sorte que le récepteur peut dire exactement quels blocs il possède déjà et que l'émetteur ne renvoie que ce qui manque.

Deux mécanismes de plus empêchent TCP d'envoyer trop vite :
- Le **contrôle de flux** protège le *récepteur*. Chaque segment porte une **fenêtre de réception** (`win`) : combien d'octets de plus le récepteur peut mettre en mémoire tampon à cet instant. L'émetteur n'a jamais plus de données non acquittées en transit que cette valeur. Si la fenêtre tombe à 0, l'émetteur s'arrête et attend. Le facteur d'échelle de fenêtre (RFC 7323) permet à la fenêtre de dépasser 64 Ko sur les liaisons rapides.
- Le **contrôle de congestion** protège le *réseau*. L'émetteur tient sa propre estimation, la fenêtre de congestion, démarre petit (démarrage lent, slow start), grandit tant que les acquittements reviennent et recule quand il constate des pertes (RFC 5681). Linux utilise par défaut l'algorithme CUBIC (RFC 9438) ; BBR, développé par Google, est une alternative courante.

UDP n'a rien de tout cela. Une application sur UDP qui a besoin de fiabilité ou de régulation de débit, comme QUIC, doit les construire.

> [!CHECK]
> Un récepteur annonce `win=0` dans ses acquittements. Que fait l'émetteur ?
>
> - [ ] Il renvoie immédiatement toutes les données non acquittées
> - [ ] Il ferme la connexion avec FIN
> - [x] Il cesse d'envoyer de nouvelles données jusqu'à ce que le récepteur annonce une fenêtre supérieure à 0
> - [ ] Il bascule la connexion en UDP
>
> Une fenêtre de réception nulle relève du contrôle de flux : l'application réceptrice ne lit pas assez vite et sa mémoire tampon est pleine. L'émetteur fait une pause et sonde périodiquement jusqu'à ce que la fenêtre se rouvre.

### Sockets et leurs états
Sur n'importe quel hôte, vous pouvez lister les sockets que le système d'exploitation a ouverts. Sous Linux l'outil est `ss` (socket statistics) ; sous macOS et Windows, `netstat`.

| État (tel que `ss` l'affiche) | Signification | Cause typique |
|---|---|---|
| `LISTEN` | Un socket serveur en attente de connexions | Un service fonctionne et accepte les connexions sur cette adresse et ce port |
| `SYN-SENT` | Une connexion est en cours ; pas encore de réponse | Beaucoup : la destination ne répond pas (cherchez un timeout) |
| `SYN-RECV` | Un SYN est arrivé et le SYN, ACK a été envoyé | Beaucoup : un réseau lent ou un SYN flood |
| `ESTAB` | Une connexion établie | Trafic normal |
| `CLOSE-WAIT` | Le pair a fermé ; pas encore notre application | Beaucoup : un bogue applicatif (elle n'appelle jamais `close()`) |
| `TIME-WAIT` | Nous avons fermé en premier et attendons 2 × MSL | Normal ; beaucoup sur les clients et proxies très sollicités |
| `UNCONN` | Un socket UDP (UDP n'a pas de connexions) | Un service UDP comme DNS ou NTP |

`netstat` et la RFC écrivent les états un peu différemment : `ESTABLISHED`, `TIME_WAIT`, `CLOSE_WAIT` et, sous Windows, `LISTENING`. Ils désignent la même chose.

Un **socket en écoute** est lié à une adresse en plus d'un port, et cette adresse décide qui peut se connecter :
- `127.0.0.1:5432` (ou `[::1]:5432`) : uniquement les programmes de la même machine, via l'interface de boucle locale.
- `0.0.0.0:22` (ou `[::]:22`, ou `*:22`) : toutes les adresses IPv4 (ou IPv6) de l'hôte, donc quiconque peut atteindre l'hôte.
- `203.0.113.80:443` : uniquement les connexions qui arrivent pour cette adresse précise.

Un serveur qui « fonctionne en local mais pas depuis l'extérieur » écoute très souvent sur `127.0.0.1` uniquement.

Les commandes dont vous aurez le plus besoin :

| Tâche | Linux | macOS | Windows (PowerShell) |
|---|---|---|---|
| Sockets TCP et UDP en écoute, avec le programme | `ss -tulpn` | `lsof -nP -iTCP -sTCP:LISTEN` et `lsof -nP -iUDP` | `netstat -ano` ou `Get-NetTCPConnection -State Listen` |
| Tous les sockets TCP avec leur état | `ss -tan` | `netstat -an -p tcp` | `netstat -an -p tcp` |

Dans `ss -tulpn`, les lettres signifient : `-t` TCP, `-u` UDP, `-l` sockets en écoute uniquement, `-p` afficher le processus, `-n` afficher des nombres plutôt que des noms de service. Sous Linux, vous ne voyez le processus des sockets appartenant à d'autres utilisateurs que si vous l'exécutez avec `sudo`.

Pour compter les sockets TCP par état, ce qui révèle vite un amas de TIME-WAIT ou de CLOSE-WAIT, sous Linux :

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

Sous Windows (PowerShell), `Get-NetTCPConnection | Group-Object State` fait la même chose.

> [!CHECK]
> `ss -tln` sur un serveur affiche `LISTEN 0 4096 127.0.0.1:8000 0.0.0.0:*`. Votre collègue ne peut pas joindre le port 8000 depuis son portable. Quelle est la raison la plus probable ?
>
> - [ ] Le port est supérieur à 1023, donc seuls les administrateurs peuvent s'y connecter
> - [ ] Le service est en TIME-WAIT et acceptera des connexions dans une minute
> - [x] Le service n'écoute que sur l'adresse de boucle locale ; il accepte donc les connexions du serveur lui-même et de nulle part ailleurs
> - [ ] `0.0.0.0:*` signifie que tous les clients sont bloqués
>
> L'adresse locale `127.0.0.1` restreint l'écoute à l'interface de boucle locale. La colonne du pair `0.0.0.0:*` signifie simplement « n'importe quel pair » pour un socket en écoute. Une liaison à `0.0.0.0` (et l'ouverture du pare-feu) le rendrait joignable depuis l'extérieur.

### « Connection refused » ou « connection timed out »
Quand une connexion TCP échoue, le message d'erreur vous dit *jusqu'où le SYN est parvenu*.

![À gauche : un client en 192.0.2.10 envoie SYN à 198.51.100.20:8080, où le port est fermé. L'hôte répond RST, ACK et le client signale une connexion refusée en quelques millisecondes. À droite : un client en 192.0.2.10 envoie SYN à 198.51.100.30:8080, où un pare-feu l'ignore en silence. Le client réessaie deux fois le SYN sans réponse et signale un délai de connexion dépassé à l'expiration du délai](../../../assets/diagrams/tcp-refused-vs-timeout.fr.svg)

*Figure 6. Refusée signifie que quelque chose a répondu. Délai dépassé signifie que rien n'a répondu.*

- **Connection refused** (`ECONNREFUSED`). Le SYN a atteint l'hôte de destination, mais aucun programme n'écoute sur ce port ; la pile TCP de l'hôte a donc répondu par RST. Vous obtenez l'erreur presque instantanément. Un pare-feu configuré pour *rejeter* plutôt que pour *ignorer* produit le même effet, en envoyant RST ou un message « port unreachable » de l'Internet Control Message Protocol (ICMP). Regardez le serveur : le service fonctionne-t-il ? Écoute-t-il sur le bon port et la bonne adresse (`ss -tlnp`) ?
- **Connection timed out** (`ETIMEDOUT`). Aucune réponse n'est revenue. Le client renvoie le SYN plusieurs fois, en attendant à chaque fois plus longtemps, et abandonne quand son délai expire. Causes : un pare-feu ou un groupe de sécurité cloud qui ignore le trafic en silence, un hôte éteint, une mauvaise adresse IP ou un problème de routage. Regardez le chemin : pare-feu, groupes de sécurité, routes.

La durée d'un « timed out » dépend du client. Sous Linux avec les réglages par défaut, le noyau renvoie le SYN avec des intervalles qui commencent à environ 1 seconde puis doublent, et abandonne après un peu plus de 2 minutes (nous avons mesuré 136 s sous Linux 7.2 avec `net.ipv4.tcp_syn_retries = 6`). La plupart des applications fixent leur propre limite, plus courte, par exemple `curl --connect-timeout 5`.

Deux erreurs voisines proviennent de la couche réseau plutôt que de la cible :
- **No route to host** (`EHOSTUNREACH`) : un routeur a renvoyé un ICMP « host unreachable », ou votre propre hôte n'a pas pu résoudre l'adresse Media Access Control (MAC) du saut suivant sur le lien local.
- **Network is unreachable** (`ENETUNREACH`) : votre propre hôte n'a aucune route vers cette destination (vérifiez `ip route`).

UDP n'a pas de poignée de main, il n'y a donc rien à refuser. Si un datagramme UDP atteint un port fermé, l'hôte répond généralement par un ICMP « port unreachable », et un programme qui a utilisé `connect()` sur son socket UDP peut voir une erreur « connection refused » à sa prochaine réception. Plus souvent, un client UDP n'entend simplement rien et doit s'en remettre à son propre délai.

> [!NOTE]
> Sous Windows, un client qui reçoit RST peut retenter la connexion une ou deux fois avant de signaler l'erreur ; le « refused » peut donc y prendre environ deux secondes au lieu de quelques millisecondes. La distinction (réponse rapide ou absence de réponse) reste valable.

> [!CHECK]
> `curl https://198.51.100.20:8443` échoue après exactement 5 secondes avec « Connection timed out », avec `--connect-timeout 5`. Où regardez-vous en premier ?
>
> - [ ] Dans la configuration du serveur web, parce qu'il écoute sur le mauvais port
> - [x] Sur le chemin : un pare-feu, un groupe de sécurité ou un problème de routage ignore le SYN, ou l'hôte est hors service
> - [ ] Dans la plage de ports éphémères du client, parce qu'il a épuisé ses ports
> - [ ] Dans le TIME-WAIT du serveur, parce que les anciennes connexions bloquent les nouvelles
>
> Un mauvais port sur un hôte joignable donne immédiatement « connection refused » (RST). Un timeout signifie aucune réponse, ce qui désigne quelque chose qui ignore les paquets ou un hôte injoignable.

## Comment ça marche
Mettons tout bout à bout. Vous saisissez `https://www.example.com` dans un navigateur sur un portable en `192.0.2.10`. La page est servie depuis `203.0.113.80`.

1. **DNS sur UDP.** Le navigateur a besoin de l'adresse IP. Le portable envoie une requête DNS dans un datagramme UDP depuis un port éphémère (disons 41837) vers le port 53 du résolveur, et reçoit un datagramme en retour : `www.example.com` est `203.0.113.80`. Pas de poignée de main, deux paquets.
2. **Choisir un port source.** Le navigateur demande au système d'exploitation une connexion TCP vers `203.0.113.80:443`. Le système choisit un port éphémère libre, 50514. Le 4-uplet `192.0.2.10:50514 → 203.0.113.80:443` désigne désormais cette connexion.
3. **Poignée de main en trois temps.** SYN, SYN-ACK, ACK (Figure 3). Elle coûte un aller-retour avant que les données puissent circuler. Le socket du serveur en LISTEN reste ouvert pour le client suivant ; le système d'exploitation crée un nouveau socket ESTABLISHED pour celui-ci.
4. **Données.** Le navigateur lance la poignée de main TLS, puis envoie la requête HTTP. Chaque segment porte des numéros de séquence et d'acquittement ; les segments perdus sont retransmis (Figure 5) ; la fenêtre de réception et la fenêtre de congestion limitent le débit des données.
5. **Fermeture.** Quand le navigateur a terminé (souvent après avoir gardé la connexion ouverte un moment pour d'autres requêtes), un côté envoie FIN, l'autre répond par ACK et son propre FIN (Figure 4). Celui qui a envoyé le premier FIN garde le 4-uplet en TIME-WAIT pendant 60 secondes sous Linux.
6. **Si quelque chose échoue** à l'étape 3, l'erreur vous dit où : RST signifie que l'hôte est joignable mais que rien n'écoute sur le 443 (refused) ; le silence signifie que quelque chose sur le chemin ignore le SYN (timed out).

Si le navigateur et le serveur prennent en charge HTTP/3, les étapes 2 à 5 se déroulent sur QUIC, sur le port UDP 443, et QUIC combine sa propre poignée de main avec celle de TLS pour économiser un aller-retour.

> [!CHECK]
> Dans la séquence ci-dessus, quels messages circulent **avant** que le premier octet de la requête HTTP quitte le portable ?
>
> - [ ] Seulement la requête HTTP elle-même ; TCP envoie les données tout de suite
> - [ ] Une poignée de main UDP avec le résolveur DNS, puis la requête HTTP
> - [x] Une requête et une réponse DNS sur UDP, la poignée de main TCP en trois temps et la poignée de main TLS
> - [ ] La fermeture TCP de la connexion précédente
>
> DNS n'a pas besoin de poignée de main, mais TCP si (SYN, SYN-ACK, ACK), et HTTPS ajoute par-dessus la poignée de main TLS. C'est pourquoi la réutilisation des connexions et la poignée de main combinée de HTTP/3 accélèrent le chargement des pages.

## Exemple concret
On vous demande de vérifier un serveur web Linux en `203.0.113.80`. Toutes les adresses sont des adresses de documentation (RFC 5737).

**Quels services écoutent ?** Exécutez en administrateur pour que `ss` puisse afficher tous les processus :

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

Lisez ligne par ligne :
- `udp UNCONN 127.0.0.1:323` : le démon NTP `chronyd` a un socket UDP pour des commandes de contrôle locales. Les sockets UDP apparaissent en `UNCONN` parce qu'UDP n'a pas de connexions.
- `tcp LISTEN 0.0.0.0:22` et `[::]:22` : SSH accepte les connexions sur toutes les adresses IPv4 et IPv6.
- `tcp LISTEN 0.0.0.0:443` : le serveur web, joignable de partout où le pare-feu le permet.
- `tcp LISTEN 127.0.0.1:5432` : la base de données PostgreSQL n'accepte que les connexions locales. C'est bien : l'application web du même hôte peut l'utiliser, pas Internet.
- Pour un socket en écoute, `Send-Q` indique le **backlog** : le nombre maximal de connexions qui ont terminé la poignée de main mais que le programme n'a pas encore prises en charge (511 pour nginx).

**Quelles connexions existent en ce moment ?**

```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` est un navigateur connecté au serveur web. Son port source est éphémère ; côté serveur, c'est le 443.
- Un administrateur en `198.51.100.7` est connecté en SSH. `Send-Q 36` signifie que 36 octets sont envoyés mais pas encore acquittés : normal pour une session active.
- `TIME-WAIT … 192.0.2.10:50388` est une ancienne connexion du même navigateur. C'est le *serveur* qui l'a fermée en premier (par exemple à cause d'un délai d'inactivité keep-alive), donc c'est le serveur qui détient le TIME-WAIT.
- Les deux lignes `127.0.0.1` sont *une* seule connexion vue des deux extrémités : l'application web (port 41870) qui parle à la base de données (5432). Les connexions de boucle locale apparaissent toujours deux fois.

**À quoi ressemble une poignée de main sur le réseau ?** Une capture avec `tcpdump` sur le serveur (`-n` affiche des nombres, `-t` masque les horodatages) montre le début de la connexion du navigateur :

```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]` est SYN, `[S.]` est SYN-ACK (`.` représente le drapeau ACK), `[.]` est un ACK seul et `[P.]` sont des données avec le drapeau PSH (push). `[F.]` et `[R]` seraient FIN et RST.
- Les ISN sont des nombres aléatoires de 32 bits : 2864127401 et 1207650562. Le SYN-ACK acquitte 2864127401 + 1.
- À partir de la troisième ligne, `tcpdump` affiche des numéros de séquence *relatifs* pour gagner de la place : `ack 1` signifie « ISN + 1 ». Le client envoie ensuite les octets 1 à 517 (`seq 1:518`, `length 517`, un TLS ClientHello) et le serveur acquitte 518.
- `mss 1460` est le plus gros segment accepté par chaque côté : une trame Ethernet de 1500 octets moins 20 octets d'en-tête IP et 20 d'en-tête TCP. `win 502` avec `wscale 7` signifie une fenêtre de réception de 502 × 2⁷ = 64 256 octets.

> [!NOTE]
> Les tailles de fenêtre, les options et la disposition exacte des colonnes de `ss` varient selon la version du système d'exploitation et ses réglages. La structure (drapeaux, numéros de séquence et d'acquittement, états) est la même partout. Vous produirez votre propre capture dans le lab.

## Pièges courants
- **Traiter « refused » et « timed out » comme un seul et même problème.** Refused : allez sur le serveur et vérifiez le service. Timed out : vérifiez les pare-feu, les groupes de sécurité et le routage. Déboguer l'application alors qu'un pare-feu ignore le SYN fait perdre des heures.
- **Lier un service à `127.0.0.1` et se demander pourquoi personne ne peut l'atteindre**, ou l'inverse : lier une base de données ou une interface d'administration à `0.0.0.0` « pour que ça marche » et l'exposer à Internet.
- **N'ouvrir que le port du serveur dans un pare-feu sans état.** Les réponses reviennent vers le port éphémère du client. Les pare-feu avec état gèrent cela automatiquement ; ceux sans état (comme certaines listes de contrôle d'accès réseau, ACL, du cloud) exigent que la plage éphémère soit ouverte pour le trafic retour, et Linux, Windows et macOS utilisent des plages différentes.
- **« Corriger » TIME-WAIT par des réglages du noyau.** Des milliers de sockets en TIME-WAIT sont normaux sur des hôtes très sollicités. Réutilisez plutôt les connexions. L'ancien réglage Linux `tcp_tw_recycle` cassait les clients derrière un NAT et a été supprimé dans Linux 4.12.
- **Ignorer CLOSE-WAIT.** Des sockets en CLOSE-WAIT qui s'accumulent sans jamais disparaître sont un bogue applicatif : le programme ne ferme jamais des connexions que le pair a déjà fermées. Redémarrer le masque ; corriger le code le guérit.
- **Croire que TCP préserve les limites des messages.** TCP est un flux d'octets. Deux appels `send()` de 100 octets peuvent arriver en une seule lecture de 200 octets, ou en 150 + 50. Les applications doivent délimiter leurs messages (préfixes de longueur, délimiteurs).
- **Croire que les datagrammes UDP arrivent.** UDP ne prévient pas quand un datagramme est perdu. Une application sur UDP a besoin de ses propres délais et nouvelles tentatives.
- **Oublier que les ports TCP et UDP sont distincts.** Autoriser le port TCP 53 dans un pare-feu n'autorise pas le DNS sur le port UDP 53, et inversement.

## Considérations de sécurité
- **SYN floods.** Pendant la poignée de main, le serveur garde une connexion semi-ouverte (SYN-RECV) pour chaque SYN auquel il répond. Un attaquant qui envoie un nombre énorme de SYN, généralement avec des adresses source usurpées, peut remplir cette file pour que les vrais clients ne puissent plus se connecter. La défense standard, ce sont les **SYN cookies** (RFC 4987) : quand la file est pleine, le serveur encode les détails de la connexion dans son propre ISN et ne garde aucun état jusqu'au retour d'un ACK valide. Linux les active par défaut (`net.ipv4.tcp_syncookies = 1`). Les grosses attaques nécessitent en outre une limitation de débit ou un service de mitigation en amont.
- **Balayage de ports.** Comme les ports fermés répondent par RST, les ports ouverts par SYN-ACK et les ports filtrés par le silence, n'importe qui peut cartographier les services qu'un hôte expose. C'est le **balayage de ports** (port scanning), la même logique refused/timeout que vous venez d'apprendre. Les défenseurs balaient leurs *propres* réseaux pour trouver des services qui ne devraient pas être exposés. Balayer des systèmes qui ne vous appartiennent pas ou que vous n'êtes pas explicitement autorisé à tester peut être illégal et enfreint les conditions d'utilisation de la plupart des fournisseurs.
- **Exposer le moins possible.** Chaque port en écoute est une surface d'attaque. Liez les services internes (bases de données, caches, panneaux d'administration) à `127.0.0.1` ou à une adresse privée, placez un pare-feu en refus par défaut devant tout le reste, et ne publiez jamais SSH (22), RDP (3389) ou des bases de données (3306, 5432, 6379…) directement sur Internet. Utilisez plutôt un réseau privé virtuel (VPN) ou un hôte bastion. Passez régulièrement en revue la sortie de `ss -tulpn`.
- **Ignorer ou rejeter ?** Ignorer ralentit les balayages et en révèle moins ; rejeter rend les échecs rapides et clairs pour les utilisateurs légitimes. De nombreuses organisations ignorent en bordure d'Internet et rejettent à l'intérieur du réseau.
- **Réflexion et amplification UDP.** UDP n'a pas de poignée de main, l'adresse source est donc facile à falsifier. Les attaquants envoient de petites requêtes à des serveurs DNS, NTP ou memcached ouverts en prenant l'adresse de la victime pour source, et les réponses, plus volumineuses, inondent la victime. N'exploitez pas de résolveurs ouverts ni de services sur UDP qui répondent à tout le monde, et filtrez les sources usurpées en bordure de réseau (Best Current Practice BCP 38, RFC 2827).
- **TCP et UDP ne chiffrent pas.** Quiconque se trouve sur le chemin peut lire et modifier les données. Utilisez TLS (HTTPS, SMTP avec STARTTLS, l'Internet Message Access Protocol sur TLS, IMAPS), SSH ou QUIC pour tout ce qui est sensible. Les ISN imprévisibles (RFC 6528) et les vérifications de la RFC 5961 rendent difficile l'injection à l'aveugle de faux segments ou de faux RST, mais ils ne protègent pas contre un attaquant qui peut voir le trafic.

## Résumé
- La couche transport livre les données à des processus. Les ports (0–65535) les identifient : bien connus/système 0–1023, enregistrés/utilisateur 1024–49151, dynamiques/éphémères 49152–65535 (RFC 6335). Linux utilise par défaut 32768–60999 pour les ports éphémères. Un 4-uplet identifie une connexion.
- UDP (RFC 768) est sans connexion, au mieux et minimal : un en-tête de 8 octets, des datagrammes séparés, aucun acquittement. TCP (RFC 9293) est orienté connexion, fiable et ordonné, avec contrôle de flux et de congestion. QUIC (RFC 9000) construit sur UDP des fonctions semblables à celles de TCP, plus le chiffrement.
- TCP s'ouvre avec SYN, SYN-ACK, ACK et se ferme avec un FIN et un ACK dans chaque sens. Le côté qui ferme en premier attend en TIME-WAIT (2 × MSL ; 60 s sous Linux), ce qui est normal.
- Les numéros de séquence comptent des octets ; les acquittements désignent le prochain octet attendu. Les données perdues sont renvoyées après un timeout ou des ACK en double ; la fenêtre de réception (contrôle de flux) et la fenêtre de congestion limitent le débit d'envoi.
- `ss -tulpn` / `ss -tan` (Linux) et `netstat`, `lsof` ou `Get-NetTCPConnection` (macOS, Windows) affichent les sockets en écoute et leurs états. Vérifiez l'adresse d'écoute en plus du port.
- « Connection refused » signifie que l'hôte a répondu par RST : rien n'écoute là. « Connection timed out » signifie aucune réponse : examinez les pare-feu, le routage et si l'hôte est en marche.

## Glossaire
| Terme | Définition |
|---|---|
| Couche transport | Couche 4 de l'OSI : transporte des données entre des processus d'hôtes différents, au moyen de ports. |
| Port | Nombre de 16 bits (0–65535) qui identifie l'extrémité d'un processus pour TCP ou UDP sur un hôte. |
| Démultiplexage | Remise des données entrantes au bon processus d'après son port de destination. |
| Multiplexage | Regroupement des données de nombreux processus sur une même connexion réseau ou adresse IP, étiquetées par des ports. |
| Ports bien connus | Ports 0–1023, appelés ports système dans la RFC 6335 ; utilisés par les services standard. |
| Ports enregistrés | Ports 1024–49151, appelés ports utilisateur dans la RFC 6335 ; attribués à des services par l'IANA sur demande. |
| Port éphémère | Port temporaire que le système d'exploitation donne à un client pour une connexion ; la RFC 6335 réserve 49152–65535 à cet usage. |
| Socket | Extrémité de communication : une adresse IP, un port et un protocole, tels qu'utilisés par un programme. |
| 4-uplet | Adresse IP source, port source, adresse IP destination et port destination : ensemble, ils identifient une connexion. |
| 5-uplet | Le 4-uplet plus le protocole (TCP ou UDP) ; utilisé par les pare-feu et le NAT. |
| User Datagram Protocol (UDP) | Protocole de transport sans connexion, au mieux, avec un en-tête de 8 octets (RFC 768). |
| Datagramme | Message UDP autonome qui arrive entier ou pas du tout. |
| Sans connexion | Envoi de données sans établir de connexion préalable ni conserver d'état sur le pair. |
| Transmission Control Protocol (TCP) | Protocole de transport orienté connexion qui livre un flux d'octets fiable et ordonné (RFC 9293). |
| Orienté connexion | Exigeant que les deux extrémités établissent une connexion avant d'échanger des données. |
| Flux d'octets | Modèle de service de TCP : une suite ordonnée d'octets sans limites de message. |
| Segment | L'unité de données envoyée par TCP : un en-tête TCP plus un morceau du flux d'octets. |
| QUIC | Protocole de transport au-dessus d'UDP avec fiabilité, flux, contrôle de congestion et chiffrement TLS 1.3 intégrés (RFC 9000) ; utilisé par HTTP/3. |
| Poignée de main en trois temps | L'échange SYN, SYN-ACK, ACK qui ouvre une connexion TCP. |
| SYN | Drapeau TCP qui ouvre une connexion et porte le numéro de séquence initial. |
| ACK | Drapeau TCP qui marque le numéro d'acquittement comme valide ; présent sur presque tous les segments après le premier. |
| FIN | Drapeau TCP signifiant « je n'ai plus de données à envoyer » ; ferme un sens de la connexion. |
| RST | Drapeau TCP qui interrompt immédiatement une connexion, ou refuse une connexion vers un port fermé. |
| Numéro de séquence initial (ISN) | Le numéro de séquence de départ imprévisible, sur 32 bits, que chaque côté choisit pour une connexion. |
| Maximum Segment Size (MSS) | La plus grande quantité de données qu'un hôte accepte dans un segment TCP, annoncée dans le SYN. |
| ESTABLISHED | État TCP d'une connexion ouverte pouvant transporter des données (`ESTAB` dans `ss`). |
| CLOSE-WAIT | État TCP après la fermeture par le pair, quand l'application locale n'a pas encore fermé (`CLOSE_WAIT` dans `netstat`). |
| Fermeture partielle (half-close) | Connexion TCP dont un sens est fermé alors que l'autre peut encore envoyer. |
| TIME-WAIT | État TCP du côté qui a fermé en premier, conservé pendant 2 × MSL (`TIME_WAIT` dans `netstat`). |
| Maximum Segment Lifetime (MSL) | Durée maximale supposée de survie d'un segment dans le réseau ; 2 minutes dans la RFC 9293. |
| Numéro de séquence | Le numéro du premier octet de données d'un segment TCP. |
| Numéro d'acquittement | Le prochain octet qu'un récepteur TCP attend ; il acquitte tout ce qui précède. |
| Temporisation de retransmission (RTO) | Le minuteur adaptatif après lequel TCP renvoie les données non acquittées (RFC 6298). |
| ACK en double | Acquittement répété pour le même octet, envoyé quand un segment arrive dans le désordre. |
| Retransmission rapide | Renvoi d'un segment après trois ACK en double, sans attendre le RTO (RFC 5681). |
| Acquittement sélectif (SACK) | Option TCP qui permet au récepteur d'indiquer précisément quels blocs il a reçus (RFC 2018). |
| Contrôle de flux | Limitation de l'émetteur à ce que le récepteur peut mettre en tampon, au moyen de la fenêtre de réception. |
| Fenêtre de réception | Le nombre d'octets qu'un récepteur TCP peut encore accepter, annoncé dans chaque segment (`win`). |
| Contrôle de congestion | Limitation du débit d'envoi à ce que le réseau peut transporter, au moyen de la fenêtre de congestion (RFC 5681). |
| Socket en écoute | Socket serveur à l'état LISTEN, en attente de connexions sur une adresse et un port. |
| Connection refused | Erreur quand la destination répond à un SYN par RST (ou ICMP port unreachable) : rien n'écoute. |
| Connection timed out | Erreur quand aucune réponse au SYN n'arrive avant le délai du client. |
| No route to host | Erreur (`EHOSTUNREACH`) quand un routeur signale l'hôte injoignable, ou que l'adresse MAC du saut suivant ne peut pas être résolue. |
| Network is unreachable | Erreur (`ENETUNREACH`) quand l'hôte local n'a aucune route vers la destination. |
| Backlog | La file des connexions qui ont terminé la poignée de main mais que le programme n'a pas encore acceptées. |
| SYN cookies | Défense contre les SYN floods qui encode l'état de la connexion dans l'ISN du serveur au lieu de le stocker (RFC 4987). |
| Balayage de ports | Sondage des ports d'un hôte pour découvrir lesquels sont ouverts, fermés ou filtrés. |

## Vérifiez vos connaissances
1. Pourquoi un client utilise-t-il un port éphémère plutôt qu'un port fixe, alors qu'un serveur utilise un port fixe et bien connu ?
2. DNS utilise normalement UDP, mais DHCP *doit* utiliser UDP. Quelle est la différence entre les raisons ?
3. Dans une capture, un SYN a `seq 2000` et le SYN-ACK a `seq 7000`. Quels numéros d'acquittement portent le SYN-ACK et l'ACK final, et pourquoi « plus un » ?
4. Un serveur affiche 3 000 sockets en `TIME-WAIT` et 2 000 en `CLOSE-WAIT`. Quel nombre vous inquiéterait, et que regarderiez-vous ?
5. `ss -tln` montre votre service sur `0.0.0.0:8080`, mais les clients venant d'Internet obtiennent « connection timed out ». Citez deux causes possibles et la façon de vérifier chacune.
6. Pourquoi les SYN floods posent-ils problème aux serveurs TCP, et pourquoi les SYN cookies n'obligent-ils pas le serveur à mémoriser quoi que ce soit des connexions semi-ouvertes ?

## Références
- [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.
- [Documentation du noyau Linux : IP sysctl](https://docs.kernel.org/networking/ip-sysctl.html) — `ip_local_port_range`, `tcp_syn_retries`, `tcp_syncookies` et réglages associés.
