Comment fonctionne TCP : Le moteur de la communication Internet fiable

TCP (Transmission Control Protocol) transforme la couche IP chaotique, au mieux de ses efforts, en un **flux d'octets fiable, ordonné, vérifié d'erreurs**. C'est la plomberie sous HTTP, SSH, SMTP, TLS. Voici la mécanique.

1. Établissement connexion : Poignée de main 3 voies (SYN, SYN-ACK, ACK)

• Client → Serveur : **SYN** (seq=x). « Je veux parler, mon seq initial=x. »
• Serveur → Client : **SYN-ACK** (seq=y, ack=x+1). « OK, mon seq initial=y, j'ai eu ton SYN. »
• Client → Serveur : **ACK** (seq=x+1, ack=y+1). « J'ai eu ton SYN. Établie. »
• **États :** `SYN_SENT` → `SYN_RCVD` → `ESTABLISHED`.

2. Transfert données : Segments, numéros de séquence, ACKs

• App écrit flux octets → TCP découpe en **segments taille MSS** (typiquement 1460 octets).
• Chaque segment reçoit **Numéro de séquence** = décalage octet du premier octet.
• Récepteur envoie **ACK** = prochain numéro de séquence attendu (cumulatif).
• Retransmission : Expéditeur démarre timer (RTO) par segment. Pas d'ACK → **retransmission** (backoff exponentiel).
• Retransmission rapide : 3 ACKs dupliqués → suppose perte → retransmet *avant* timer.

3. Contrôle de flux : Fenêtre glissante

• Récepteur annonce **rwnd (Receive Window)** = espace buffer restant.
• Expéditeur plafonne **octets en vol ≤ min(cwnd, rwnd)**.
• Évite de submerger récepteur lent.

4. Contrôle de congestion : Les garde-fous du réseau

• Slow Start : cwnd=1 MSS → double chaque RTT (exponentiel) jusqu'à perte ou ssthresh.
• Congestion Avoidance : cwnd += 1 MSS par RTT (linéaire).
• Fast Recovery : Sur 3 DupACKs : ssthresh=cwnd/2, cwnd=ssthresh+3, retransmet, puis CA.
• Timeout : ssthresh=cwnd/2, cwnd=1 MSS → Slow Start.
• Modernes : **CUBIC** (défaut Linux), **BBR** (Google, basé modèle).

5. Fermeture connexion : Poignée de main 4 voies (FIN, ACK, FIN, ACK)

• Ferme actif → **FIN** (seq=u).
• Passif → **ACK** (ack=u+1). *Demi-fermeture* (peut encore envoyer données).
• Passif fini → **FIN** (seq=v).
• Actif → **ACK** (ack=v+1). **TIME_WAIT** (2*MSL) → CLOSED.

Garanties clés

1. Fiabilité : Checksums + ACKs + Retransmission.
2. Ordre : Numéros de séquence → réassemblage dans l'ordre.
3. Contrôle flux : Récepteur pas submergé.
4. Contrôle congestion : Réseau pas fondu.

Coût : En-têtes (20+ octets), latence (handshake, attente ACK), head-of-line blocking (une perte bloque le flux). QUIC/HTTP3 déplace ça sur UDP pour résoudre HOL.