CloudAcademia
FR

Réseaux · Module 04 · Le modèle OSI : comment les réseaux communiquent

Lab : observer l'encapsulation avec Wireshark

Lab45 minDébutantMarkdown

Affichage du Markdown brut : le moteur de rendu n'a pas pu être chargé.

## Objectif
Vous capturez votre propre requête du système de noms de domaine (DNS, Domain Name System) et votre propre requête du protocole de transfert hypertexte (HTTP, Hypertext Transfer Protocol), puis vous décortiquez chaque paquet couche par couche. À la fin, vous saurez repérer les en-têtes Ethernet, du protocole Internet (IP, Internet Protocol), du protocole de contrôle de transmission (TCP, Transmission Control Protocol) et HTTP dans une capture réelle, et dire à quelle couche du modèle d'interconnexion des systèmes ouverts (OSI, Open Systems Interconnection) appartient chacun d'eux.

## Objectifs
- Capturer votre propre trafic avec Wireshark, ou avec `tcpdump` comme alternative.
- Identifier les en-têtes Ethernet, IP, du protocole de datagrammes utilisateur (UDP, User Datagram Protocol) ou TCP, et applicatifs dans une trame capturée.
- Associer chaque champ d'en-tête que vous observez à sa couche OSI et à son unité de données de protocole (PDU, protocol data unit).
- Décrire l'encapsulation et la désencapsulation à partir de données réelles, y compris les champs de démultiplexage (EtherType, Protocol d'IP, port).
- Trouver la taille maximale de segment (MSS, maximum segment size) TCP dans un segment SYN et expliquer pourquoi elle vaut 1460 octets sur Ethernet standard.

## Prérequis
- Un ordinateur qui vous appartient ou que vous administrez, sous Linux, macOS ou Windows 10/11, connecté par Ethernet ou Wi-Fi.
- **Wireshark 4.0 ou version ultérieure** ([wireshark.org](https://www.wireshark.org/)). Sous Windows, l'installateur installe aussi Npcap, le pilote de capture.
- Alternative pour Linux et macOS : **tcpdump 4.99 ou version ultérieure** (vérifiez avec `tcpdump --version`). macOS le fournit d'origine.
- **curl 7.68 ou version ultérieure**. Sous Windows 10/11, `curl.exe` est intégré.
- Un outil de requête DNS : `dig` (BIND 9) sous Linux et macOS, ou `nslookup` sous Windows.
- L'autorisation de capturer des paquets : droits d'administrateur, ou appartenance au groupe `wireshark` sous Linux (Étape 2).
- Leçon : [Le modèle OSI : comment les réseaux communiquent](lesson.fr.md), en particulier l'exemple concret.

> [!WARNING]
> **Autorisation et éthique.** Ne capturez que le trafic de votre propre ordinateur et d'un réseau qui vous appartient ou que vous avez expressément le droit de surveiller. Capturer le trafic d'autres personnes sans autorisation peut constituer une infraction et enfreindre le règlement de l'entreprise ou de l'établissement, même sur un réseau Wi-Fi partagé. Sur un réseau professionnel ou scolaire, consultez d'abord la charte d'utilisation acceptable, ou faites le lab chez vous. Les fichiers de capture peuvent contenir des données privées (par exemple, les noms DNS que d'autres applications interrogent). Ne les partagez pas et supprimez-les dans la section Nettoyage.
>
> **Coût :** gratuit. Vous n'utilisez que des outils open source et vous envoyez quelques kilo-octets de trafic.

## Architecture
<figure class="diagram" style="--dg-w: 900px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 900 420" width="900" height="420" role="img" aria-labelledby="osi-lab-architecture-fr-title osi-lab-architecture-fr-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="fr">
<title id="osi-lab-architecture-fr-title">Architecture du laboratoire : ce que vous capturez et où</title>
<desc id="osi-lab-architecture-fr-desc">Votre ordinateur, 192.0.2.10, exécute dig et curl à la couche 7. Leurs requêtes descendent la pile réseau du système d&#x27;exploitation (couche 4 TCP ou UDP, couche 3 IP, couche 2 Ethernet) jusqu&#x27;à l&#x27;interface réseau, point de capture de Wireshark et tcpdump. De là, les trames vont au routeur, la passerelle par défaut 192.0.2.1, qui les achemine vers le résolveur DNS 198.51.100.53 sur le port UDP 53 et vers le serveur web d&#x27;example.com 203.0.113.80 sur le port TCP 80.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="899" height="419" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<rect class="dg-panel" x="24" y="24" width="384" height="372" rx="14" fill="#f0f0ec"/>
<g class="dg-icon-neutral" transform="translate(44 40) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="86" y="56" font-size="16" class="dg-text" fill="#17171c" font-weight="700">Votre ordinateur</text>
<text x="86" y="76" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">192.0.2.10</text>
<g class="dg-l7"><rect class="dg-tint" x="42" y="100" width="348" height="64" rx="12" fill="#f3eefc" stroke="#c5a9f0" stroke-width="1.2"/>
<g class="dg-icon" transform="translate(58 118) scale(1.1667)" fill="none" stroke="#6d28d9" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect x="2" y="4" width="20" height="16" rx="2"/><path d="M2 9h20"/><path d="M6 6.5h.01"/><path d="M9 6.5h.01"/></g>
<text x="98" y="128" font-size="15" class="dg-ink" fill="#6d28d9" font-weight="700">Applications</text>
<text x="98" y="148" font-size="13" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">dig · curl</text>
</g>
<g class="dg-l7"><rect class="dg-solid" x="328" y="118" width="46" height="28" rx="14" fill="#6d28d9"/><text x="351.0" y="137" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">L7</text></g>
<path class="dg-line" d="M216.0 168V186M210.0 175l6-7 6 7M210.0 179l6 7 6-7" stroke="#cfcfc8" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<rect class="dg-card" x="42" y="190" width="348" height="92" rx="12" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-icon-neutral" transform="translate(58 204) scale(1.0833)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="16" height="16" x="4" y="4" rx="2"/><rect width="6" height="6" x="9" y="9" rx="1"/><path d="M15 2v2"/><path d="M15 20v2"/><path d="M2 15h2"/><path d="M2 9h2"/><path d="M20 15h2"/><path d="M20 9h2"/><path d="M9 2v2"/><path d="M9 20v2"/></g>
<text x="96" y="222" font-size="14.5" class="dg-text" fill="#17171c" font-weight="700">Pile réseau du système d&#x27;exploitation</text>
<g class="dg-l4"><rect class="dg-solid" x="52" y="240" width="104" height="28" rx="14" fill="#c2410c"/><text x="104.0" y="259" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">L4 · TCP/UDP</text></g>
<g class="dg-l3"><rect class="dg-solid" x="164" y="240" width="104" height="28" rx="14" fill="#b45309"/><text x="216.0" y="259" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">L3 · IP</text></g>
<g class="dg-l2"><rect class="dg-solid" x="276" y="240" width="104" height="28" rx="14" fill="#15803d"/><text x="328.0" y="259" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">L2 · Ethernet</text></g>
<path class="dg-line" d="M216.0 286V304M210.0 293l6-7 6 7M210.0 297l6 7 6-7" stroke="#cfcfc8" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<g class="dg-l1"><rect class="dg-tint" x="42" y="308" width="348" height="70" rx="12" fill="#ebf3f7" stroke="#9ac3d9" stroke-width="1.2"/>
<g class="dg-icon" transform="translate(58 318) scale(1.0833)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="m15 20 3-3h2a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h2l3 3z"/><path d="M6 8v1"/><path d="M10 8v1"/><path d="M14 8v1"/><path d="M18 8v1"/></g>
<text x="96" y="336" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">Interface réseau</text>
</g>
<g class="dg-l6"><rect class="dg-solid" x="56" y="346" width="320" height="24" rx="12" fill="#a21caf"/>
<g class="dg-icon-on" transform="translate(66 350) scale(0.6667)" fill="none" stroke="#ffffff" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="8"/><path d="m21 21-4.3-4.3"/></g>
<text x="88" y="362.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="600">Point de capture : Wireshark · tcpdump</text>
</g>
<rect class="dg-card" x="436" y="168" width="186" height="68" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(452 184) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6.01 18H6"/><path d="M10.01 18H10"/><path d="M15 10v4"/><path d="M17.84 7.17a4 4 0 0 0-5.66 0"/><path d="M20.66 4.34a8 8 0 0 0-11.31 0"/></g>
<text x="492" y="198" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Routeur</text>
<text x="492" y="217" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500">Passerelle par défaut</text>
<text x="529.0" y="258" font-size="13" class="dg-text" fill="#17171c" font-weight="500" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">192.0.2.1</text>
<rect class="dg-card" x="664" y="60" width="212" height="100" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(680 76) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/></g>
<text x="720" y="90" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Résolveur DNS</text>
<text x="720" y="109" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500"></text>
<text x="680" y="140" font-size="13" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">198.51.100.53</text>
<g class="dg-l4"><rect class="dg-solid" x="790" y="124" width="70" height="28" rx="14" fill="#c2410c"/><text x="825.0" y="143" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">UDP 53</text></g>
<rect class="dg-card" x="664" y="262" width="212" height="100" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(680 278) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="2" rx="2"/><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6 6h.01"/><path d="M6 18h.01"/></g>
<text x="720" y="292" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Serveur web</text>
<text x="720" y="311" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500">example.com</text>
<text x="680" y="342" font-size="13" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">203.0.113.80</text>
<g class="dg-l4"><rect class="dg-solid" x="790" y="326" width="70" height="28" rx="14" fill="#c2410c"/><text x="825.0" y="345" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">TCP 80</text></g>
<path class="dg-line" d="M390 343H422V202.0H436" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M622 202.0H643V110.0H664" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M643 202.0V312.0H664" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M427 196.0l7 6-7 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M655 104.0l7 6-7 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M655 306.0l7 6-7 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<circle class="dg-solid dg-l6" cx="390" cy="343" r="5" fill="#a21caf"/>
</svg></figure>

*Figure 1. Ce que vous capturez et où. Le point de capture est votre propre interface réseau : vous voyez donc tous les en-têtes que votre ordinateur envoie et reçoit.*

Wireshark et `tcpdump` copient chaque trame à son passage sur votre interface réseau. Vous voyez la trame complète avec tous ses en-têtes, exactement comme votre ordinateur l'envoie ou la reçoit.

> [!NOTE]
> Les adresses de ce lab sont des valeurs de documentation, les mêmes que celles de la leçon : adresses IP de la RFC 5737 et adresses de contrôle d'accès au support (MAC, Media Access Control) du bloc de documentation de la RFC 7042 (`00:00:5e:00:53:xx`). **Vos valeurs réelles seront différentes.** Votre ordinateur a probablement une adresse privée du type `192.168.1.x`, et `example.com` se résout en adresses publiques réelles. Notez vos propres valeurs au fur et à mesure.

## Étapes

### Étape 1 — Trouvez votre interface, vos adresses et la MTU
Vous devez savoir quelle interface transporte votre trafic avant de capturer dessus. Vous voulez aussi connaître vos adresses IP et MAC et votre passerelle, pour les reconnaître dans la capture. L'unité de transmission maximale (MTU, maximum transmission unit) vous permet de prévoir le MSS avant de le voir.

Sous Linux :

```bash
ip -4 route show default
ip link show <interface>
resolvectl dns
```

`<interface>` est le nom qui suit `dev` dans la sortie de la première commande (par exemple `enp3s0` ou `wlp2s0`). Si `resolvectl` n'est pas disponible, exécutez plutôt `cat /etc/resolv.conf`.

Sortie attendue :
```text
default via 192.0.2.1 dev enp3s0 proto dhcp src 192.0.2.10 metric 100
2: enp3s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP mode DEFAULT group default qlen 1000
    link/ether 00:00:5e:00:53:10 brd ff:ff:ff:ff:ff:ff
Global:
Link 2 (enp3s0): 198.51.100.53
```

Sous macOS et Windows, utilisez plutôt ces commandes :

| Information | macOS | Windows (Invite de commandes) |
|---|---|---|
| Interface et passerelle | `route -n get default` (lignes `gateway:` et `interface:`) | `ipconfig /all` (`Default Gateway`) |
| Votre adresse MAC et la MTU | `ifconfig <interface>` (lignes `ether` et `mtu`) | `ipconfig /all` (`Physical Address`) ; `netsh interface ipv4 show subinterfaces` (MTU) |
| Serveur DNS | `scutil --dns \| grep nameserver` | `ipconfig /all` (`DNS Servers`) |

Notez : le nom de l'interface, votre adresse IPv4, votre adresse MAC, l'adresse IP de la passerelle, l'adresse d'un serveur DNS IPv4 et la MTU. Avec une MTU de 1500, la leçon prévoit un MSS de 1500 − 20 (IPv4) − 20 (TCP) = 1460 octets.

> [!NOTE]
> Windows affiche les adresses MAC avec des tirets (`00-00-5E-00-53-10`). Wireshark affiche la même adresse avec des deux-points.

### Étape 2 — Préparez un dossier et l'autorisation de capture
Capturer des paquets exige des privilèges particuliers, car une capture peut voir tout le trafic de l'interface. Ne vous accordez que l'autorisation nécessaire et gardez les fichiers du lab dans un seul dossier pour faciliter le nettoyage.

```bash
mkdir -p ~/osi-lab
cd ~/osi-lab
```

Sortie attendue : aucune. Les commandes réussissent en silence.

Configurez ensuite l'autorisation de capture pour votre système :

- **Linux, Wireshark :** si Wireshark n'affiche aucune interface ou indique que vous n'avez pas la permission, ajoutez-vous au groupe `wireshark` (sous Debian et Ubuntu, exécutez d'abord `sudo dpkg-reconfigure wireshark-common` et répondez **Yes**). Fermez ensuite votre session et rouvrez-la.

  ```bash
  sudo usermod -aG wireshark "$USER"
  ```

  Souvenez-vous de l'avoir fait : le Nettoyage l'annule.
- **Linux et macOS, tcpdump :** vous exécutez `tcpdump` avec `sudo` à l'Étape 3. Aucune configuration n'est nécessaire.
- **macOS, Wireshark :** acceptez le composant **ChmodBPF** quand l'installateur le propose.
- **Windows, Wireshark :** assurez-vous que Npcap a été installé avec Wireshark.

> [!TIP]
> N'exécutez jamais toute l'application graphique Wireshark en tant que root ou administrateur. Wireshark contient beaucoup de code d'analyse de protocoles, et l'exécuter avec tous les privilèges augmente les dégâts qu'un paquet malveillant pourrait causer. La configuration par groupe ne donne que les droits nécessaires au petit utilitaire de capture (`dumpcap`).

Vérifiez l'appartenance au groupe sous Linux (après vous être reconnecté) :

```bash
id -nG
```

Sortie attendue (votre liste sera différente, mais doit inclure `wireshark`) :
```text
learner wheel wireshark
```

### Étape 3 — Démarrez la capture
Vous ne voulez que deux types de trafic : DNS (port UDP 53) et HTTP non chiffré (port TCP 80). Un **filtre de capture** indique au moteur de capture de ne conserver que ces paquets, afin que votre fichier reste petit et contienne le moins possible de données sans rapport.

**Wireshark :** ouvrez Wireshark. Sur l'écran d'accueil, saisissez ceci dans la zone du filtre de capture (« …using this filter »), puis double-cliquez sur votre interface de l'Étape 1 :

```text
tcp port 80 or udp port 53
```

Résultat attendu : la liste des paquets s'ouvre, vide ou avec quelques paquets DNS d'autres applications. La barre d'état affiche le nom de l'interface et un compteur de paquets.

**tcpdump (Linux et macOS) :** exécutez ceci dans un terminal et laissez-le tourner.

```bash
cd ~/osi-lab
sudo tcpdump -i <interface> -nn -Z "$USER" -w osi-lab.pcap 'tcp port 80 or udp port 53'
```

- `<interface>` est le nom de l'interface de l'Étape 1.
- `-nn` affiche les adresses et les numéros de port au lieu des noms.
- `-Z "$USER"` fait abandonner à `tcpdump` les privilèges root et écrire le fichier sous votre identité, afin que vous puissiez le lire et le supprimer sans `sudo`.
- `-w osi-lab.pcap` écrit les paquets bruts dans un fichier au lieu de les afficher.

Sortie attendue :
```text
tcpdump: listening on enp3s0, link-type EN10MB (Ethernet), snapshot length 262144 bytes
```

`EN10MB (Ethernet)` signifie que chaque paquet capturé commence par un en-tête Ethernet. Vous le verrez aussi en Wi-Fi : en mode normal (non moniteur), le système d'exploitation fournit les trames Wi-Fi à la capture sous forme de trames Ethernet.

### Étape 4 — Générez du trafic DNS et HTTP
Vous créez maintenant le trafic que vous allez décortiquer. Vous interrogez le DNS directement auprès de votre résolveur, pour que la requête traverse le réseau au lieu d'être servie par un cache local. Vous récupérez ensuite une page en HTTP non chiffré : avec HTTP Secure (HTTPS), le chiffrement vous masquerait la couche HTTP. L'option `-4` force IPv4 pour que vos résultats correspondent à ceux de la leçon.

Ouvrez un **second** terminal et exécutez :

```bash
dig @<dns-server> example.com A +short
curl -4 -s -o /dev/null -w '%{http_code} %{remote_ip}\n' http://example.com/
```

- `<dns-server>` est l'adresse du serveur DNS IPv4 de l'Étape 1.
- `-o /dev/null` ignore le corps de la page ; `-w` affiche le code d'état HTTP et l'adresse IP du serveur.

Sous Windows, exécutez plutôt ceci dans l'Invite de commandes :

```bat
nslookup example.com <dns-server>
curl.exe -4 -s -o NUL -w "%{http_code} %{remote_ip}\n" http://example.com/
```

Sortie attendue (Linux et macOS ; les adresses réelles diffèrent et vous pouvez en voir plusieurs) :
```text
203.0.113.80
200 203.0.113.80
```

`200` signifie que le serveur web a répondu correctement à la requête.

### Étape 5 — Arrêtez la capture et listez les paquets
Arrêtez la capture pour que le fichier soit complet, puis obtenez une vue d'ensemble avant de zoomer sur des paquets isolés.

**Wireshark :** cliquez sur le carré rouge (**Stop**), puis sur **File → Save As** et enregistrez sous `~/osi-lab/osi-lab.pcapng`. Saisissez `dns || http || tcp.port == 80` dans la barre de filtre d'affichage et appuyez sur Entrée.

**tcpdump :** appuyez sur **Ctrl+C** dans le premier terminal, puis relisez le fichier. Vous n'avez pas besoin de `sudo` pour le lire.

```bash
tcpdump -nn -r osi-lab.pcap
```

Sortie attendue (abrégée ; vos heures, adresses et numéros de séquence diffèrent) :
```text
reading from file osi-lab.pcap, link-type EN10MB (Ethernet), snapshot length 262144
10:15:02.120000 IP 192.0.2.10.41000 > 198.51.100.53.53: 6699+ [1au] A? example.com. (40)
10:15:02.135000 IP 198.51.100.53.53 > 192.0.2.10.41000: 6699 1/0/1 A 203.0.113.80 (56)
10:15:02.150000 IP 192.0.2.10.50514 > 203.0.113.80.80: Flags [S], seq 1000000, win 64240, options [mss 1460,sackOK,TS val 1000 ecr 0,nop,wscale 7], length 0
10:15:02.165000 IP 203.0.113.80.80 > 192.0.2.10.50514: Flags [S.], seq 2000000, ack 1000001, win 65535, options [mss 1460,sackOK,TS val 5000 ecr 1000,nop,wscale 10], length 0
10:15:02.180000 IP 192.0.2.10.50514 > 203.0.113.80.80: Flags [.], ack 1, win 502, options [nop,nop,TS val 1001 ecr 5000], length 0
10:15:02.195000 IP 192.0.2.10.50514 > 203.0.113.80.80: Flags [P.], seq 1:75, ack 1, win 502, options [nop,nop,TS val 1001 ecr 5000], length 74: HTTP: GET / HTTP/1.1
10:15:02.210000 IP 203.0.113.80.80 > 192.0.2.10.50514: Flags [P.], seq 1:79, ack 75, win 1050, options [nop,nop,TS val 5010 ecr 1001], length 78: HTTP: HTTP/1.1 200 OK
```

Vous devriez reconnaître l'histoire : une question et une réponse DNS, la poignée de main en trois temps de TCP (`[S]`, `[S.]`, `[.]`), la requête HTTP et la réponse HTTP. D'autres paquets suivent (le reste de la page et la fermeture de la connexion). Vous pouvez aussi voir des paquets DNS de `curl` lui-même et d'autres applications.

### Étape 6 — Décortiquez la requête DNS
Le DNS est le paquet le plus simple de la capture : un datagramme UDP portant une question. Servez-vous-en pour vous exercer à lire les couches de l'extérieur vers l'intérieur.

**Wireshark :** filtrez sur `dns`, puis cliquez sur la première requête (`Standard query … A example.com`). Le volet des détails du paquet affiche une ligne par couche :

```text
Frame 1: 82 bytes on wire (656 bits), 82 bytes captured (656 bits) on interface enp3s0, id 0
Ethernet II, Src: 00:00:5e:00:53:10, Dst: 00:00:5e:00:53:01
Internet Protocol Version 4, Src: 192.0.2.10, Dst: 198.51.100.53
User Datagram Protocol, Src Port: 41000, Dst Port: 53
Domain Name System (query)
```

Wireshark peut ajouter le nom du fabricant devant chaque adresse MAC. Développez chaque ligne avec la flèche et repérez : le **Type** d'Ethernet, le **Protocol** et le **Time to Live** (TTL) d'IP, et le **Destination Port** d'UDP.

**tcpdump :** ajoutez `-e` pour afficher l'en-tête Ethernet et `-v` pour afficher les détails de l'en-tête IP.

```bash
tcpdump -nn -e -v -r osi-lab.pcap 'udp port 53'
```

Sortie attendue (premier paquet affiché) :
```text
10:15:02.120000 00:00:5e:00:53:10 > 00:00:5e:00:53:01, ethertype IPv4 (0x0800), length 82: (tos 0x0, ttl 64, id 4242, offset 0, flags [DF], proto UDP (17), length 68)
    192.0.2.10.41000 > 198.51.100.53.53: 6699+ [1au] A? example.com. (40)
```

Lisez-la couche par couche :

| Couche | Ce que vous voyez | Signification |
|---|---|---|
| L2 Liaison de données | `00:00:5e:00:53:10 > 00:00:5e:00:53:01`, `ethertype IPv4 (0x0800)` | Votre adresse MAC envoie vers l'adresse MAC de la passerelle. L'EtherType `0x0800` dit « la charge utile est de l'IPv4 ». |
| L3 Réseau | `192.0.2.10 > 198.51.100.53`, `ttl 64`, `proto UDP (17)` | Les adresses IP identifient les deux hôtes de bout en bout. Le protocole `17` dit « la charge utile est de l'UDP ». |
| L4 Transport | `.41000 > .53` | Un port source aléatoire de votre côté ; le port 53 est DNS. La PDU est un **datagramme**. |
| L7 Application | `A? example.com.` | La question DNS elle-même : « quelle est l'adresse IPv4 de example.com ? » |

Vérifiez l'adresse MAC de destination : c'est celle de votre passerelle, même si le serveur DNS peut se trouver sur un autre réseau. Si votre serveur DNS est votre box ou votre routeur domestique, la passerelle et le serveur DNS sont le même équipement.

> [!NOTE]
> `length 82` correspond à la trame sans la séquence de contrôle de trame (FCS, frame check sequence) de 4 octets. La plupart des cartes réseau vérifient et retirent la FCS avant que la capture ne voie la trame ; les captures ne l'affichent donc généralement pas.

### Étape 7 — Lisez le MSS dans la poignée de main TCP
Dans la leçon, vous avez calculé que 1460 octets de données applicatives tiennent dans un segment TCP sur une liaison dont la MTU est de 1500 octets. TCP annonce ce nombre dans l'**option MSS** du segment SYN (synchronize, synchronisation), le premier paquet de la poignée de main. Vous le voyez maintenant sur le réseau.

**Wireshark :** appliquez ce filtre d'affichage, puis cliquez sur le premier paquet (votre SYN, envoyé depuis votre adresse IP) :

```text
tcp.flags.syn == 1
```

Développez **Transmission Control Protocol → Options**. Résultat attendu :

```text
TCP Option - Maximum segment size: 1460 bytes
```

Vous pouvez aussi filtrer directement sur la valeur avec `tcp.options.mss_val == 1460`.

**tcpdump :**

```bash
tcpdump -nn -e -v -r osi-lab.pcap 'tcp[tcpflags] & tcp-syn != 0'
```

Le filtre conserve les segments dont l'indicateur SYN est positionné : votre SYN et le SYN-ACK du serveur. Sortie attendue :
```text
10:15:02.150000 00:00:5e:00:53:10 > 00:00:5e:00:53:01, ethertype IPv4 (0x0800), length 74: (tos 0x0, ttl 64, id 4244, offset 0, flags [DF], proto TCP (6), length 60)
    192.0.2.10.50514 > 203.0.113.80.80: Flags [S], cksum 0x42da (correct), seq 1000000, win 64240, options [mss 1460,sackOK,TS val 1000 ecr 0,nop,wscale 7], length 0
10:15:02.165000 00:00:5e:00:53:01 > 00:00:5e:00:53:10, ethertype IPv4 (0x0800), length 74: (tos 0x0, ttl 64, id 4245, offset 0, flags [DF], proto TCP (6), length 60)
    203.0.113.80.80 > 192.0.2.10.50514: Flags [S.], cksum 0xa590 (correct), seq 2000000, ack 1000001, win 65535, options [mss 1460,sackOK,TS val 5000 ecr 1000,nop,wscale 10], length 0
```

Repérez `mss 1460` dans votre SYN. Examinez maintenant les octets bruts de la même trame pour voir l'encapsulation en hexadécimal :

```bash
tcpdump -nn -XX -c 1 -r osi-lab.pcap 'tcp[tcpflags] == tcp-syn'
```

Sortie attendue (les octets de votre capture diffèrent) :
```text
10:15:02.150000 IP 192.0.2.10.50514 > 203.0.113.80.80: Flags [S], seq 1000000, win 64240, options [mss 1460,sackOK,TS val 1000 ecr 0,nop,wscale 7], length 0
	0x0000:  0000 5e00 5301 0000 5e00 5310 0800 4500  ..^.S...^.S...E.
	0x0010:  003c 1094 4000 4006 2bcd c000 020a cb00  .<..@.@.+.......
	0x0020:  7150 c552 0050 000f 4240 0000 0000 a002  qP.R.P..B@......
	0x0030:  faf0 42da 0000 0204 05b4 0402 080a 0000  ..B.............
	0x0040:  03e8 0000 0000 0103 0307                 ..........
```

- Les octets 0–13 forment l'en-tête Ethernet : MAC de destination, MAC source, puis `0800` (IPv4).
- `45` ouvre l'en-tête IPv4 : version 4, longueur d'en-tête 5 × 4 = 20 octets. Le dixième octet de l'en-tête IP, `06`, est le champ Protocol (TCP).
- Dans les options TCP, `02 04 05b4` est l'option MSS : type 2, longueur 4, valeur `0x05b4` = 1460.

> [!NOTE]
> Chaque côté annonce le plus grand segment qu'il accepte de *recevoir* ; le SYN-ACK peut donc afficher un MSS différent. Des valeurs inférieures à 1460 sont normales sur les réseaux privés virtuels (VPN, virtual private network), les liaisons PPP sur Ethernet (PPPoE, PPP over Ethernet) et certains réseaux mobiles ou cloud, car leur MTU est plus petite ou un équipement intermédiaire abaisse (« clamps ») le MSS. Sur les paquets que vous envoyez, `tcpdump -v` peut afficher `cksum … (incorrect -> …)`. C'est normal : la carte réseau renseigne la somme de contrôle après le point de capture (délestage de la somme de contrôle, checksum offload).

### Étape 8 — Décortiquez la requête HTTP couche par couche
La requête HTTP est l'exemple le plus clair d'encapsulation complète : des données applicatives dans un segment TCP, dans un paquet IP, dans une trame Ethernet. Vous lisez maintenant les quatre en-têtes d'une même trame.

**Wireshark :** appliquez le filtre d'affichage `http.request` et cliquez sur le paquet `GET / HTTP/1.1`. Développez chaque ligne du volet des détails du paquet :

```text
Frame 6: 140 bytes on wire (1120 bits), 140 bytes captured (1120 bits) on interface enp3s0, id 0
Ethernet II, Src: 00:00:5e:00:53:10, Dst: 00:00:5e:00:53:01
Internet Protocol Version 4, Src: 192.0.2.10, Dst: 203.0.113.80
Transmission Control Protocol, Src Port: 50514, Dst Port: 80, Seq: 1, Ack: 1, Len: 74
Hypertext Transfer Protocol
```

Cliquez sur une ligne du volet des détails : Wireshark met en surbrillance les octets correspondants dans le volet des octets, en bas. Cliquez sur **Ethernet II**, puis sur **Internet Protocol**, puis sur **Transmission Control Protocol**, puis sur **Hypertext Transfer Protocol**, et regardez la surbrillance avancer vers l'intérieur de la trame. C'est l'encapsulation, vue de l'extérieur vers l'intérieur.

**tcpdump :**

```bash
tcpdump -nn -e -v -r osi-lab.pcap 'tcp dst port 80 and tcp[tcpflags] & tcp-push != 0'
```

Le filtre conserve les segments que vous avez envoyés vers le port 80 et qui portent des données (indicateur PSH positionné). Sortie attendue :
```text
10:15:02.195000 00:00:5e:00:53:10 > 00:00:5e:00:53:01, ethertype IPv4 (0x0800), length 140: (tos 0x0, ttl 64, id 4247, offset 0, flags [DF], proto TCP (6), length 126)
    192.0.2.10.50514 > 203.0.113.80.80: Flags [P.], cksum 0x4260 (correct), seq 1000001:1000075, ack 2000001, win 502, options [nop,nop,TS val 1001 ecr 5000], length 74: HTTP, length: 74
	GET / HTTP/1.1
	Host: example.com
	User-Agent: curl/8.5.0
	Accept: */*
```

Vérifiez que les tailles s'additionnent :

| Élément | Octets dans cet exemple | Où le lire |
|---|---|---|
| Requête HTTP (données applicatives) | 74 | `length 74` de TCP / `Len: 74` de Wireshark |
| En-tête TCP (20 + 12 octets d'options d'horodatage) | 32 | longueur totale IP − en-tête IP − données |
| En-tête IPv4 | 20 | `Header Length: 20 bytes` d'IP |
| Paquet IP (longueur totale IP) | 74 + 32 + 20 = 126 | `length 126` d'IP |
| En-tête Ethernet | 14 | |
| Trame capturée (sans FCS) | 126 + 14 = 140 | `length 140` / `Frame 6: 140 bytes` |

Regardez ensuite la réponse du serveur (`HTTP/1.1 200 OK`) et comparez son en-tête IP avec celui de votre requête. La source et la destination sont inversées, et le TTL est généralement **inférieur** à la valeur de départ du serveur (souvent 64 ou 128). Chaque routeur du chemin l'a décrémenté d'une unité.

> [!NOTE]
> L'en-tête TCP des segments de données fait souvent 32 octets plutôt que 20, car de nombreux systèmes ajoutent l'option d'horodatage à chaque segment. Vos tailles peuvent différer : des versions de curl différentes envoient des en-têtes légèrement différents (par exemple un autre `User-Agent`).

### Étape 9 — Associez ce que vous avez vu aux couches OSI
Tout rassembler transforme ce que vous avez vu en modèle. Copiez ce tableau dans vos notes et remplissez la dernière colonne avec les valeurs de **votre** capture.

| Couche OSI | PDU | Ligne Wireshark | Champ à relever | Valeur d'exemple | Votre valeur |
|---|---|---|---|---|---|
| 7 Application | Données | Hypertext Transfer Protocol | Ligne de requête et `Host` | `GET / HTTP/1.1`, `example.com` | |
| 4 Transport | Segment | Transmission Control Protocol | Port source, port de destination, MSS dans le SYN | `50514`, `80`, `1460` | |
| 4 Transport | Datagramme | User Datagram Protocol | Port de destination de la requête DNS | `53` | |
| 3 Réseau | Paquet | Internet Protocol Version 4 | IP source et de destination, TTL, Protocol | `192.0.2.10`, `203.0.113.80`, `64`, `6` | |
| 2 Liaison de données | Trame | Ethernet II | MAC source et de destination, Type | `00:00:5e:00:53:10`, `00:00:5e:00:53:01`, `0x0800` | |
| 1 Physique | Bit | Frame (métadonnées de capture) | Bytes on wire | `140` | |

> [!NOTE]
> La ligne **Frame** de Wireshark n'est pas un en-tête de protocole. Ce sont des informations que l'outil de capture ajoute (heure d'arrivée, longueur, interface). C'est ce qui se rapproche le plus de la couche 1 que vous verrez, car la capture ne voit les bits qu'après que la carte réseau a retransformé les signaux en octets.

Les couches 5 et 6 n'ont pas de ligne propre : avec du HTTP non chiffré sur TCP, aucun protocole distinct de session ou de présentation n'apparaît sur le réseau. Avec HTTPS, Transport Layer Security (TLS) se placerait entre TCP et HTTP (voir le Défi).

## Vérification
Vous avez terminé le lab quand toutes les vérifications ci-dessous réussissent.

1. Le fichier de capture existe et contient des paquets. Wireshark : le fichier enregistré se rouvre et affiche des paquets. tcpdump :

   ```bash
   tcpdump -nn -r osi-lab.pcap 2>/dev/null | wc -l
   ```

   Sortie attendue : un nombre d'au moins 7 (le nombre exact varie).

2. Votre SYN porte un MSS qui correspond à votre MTU. Wireshark : le filtre `tcp.flags.syn == 1 && tcp.flags.ack == 0` affiche votre SYN, avec un MSS de 1460 sur une MTU de 1500 octets. tcpdump :

   ```bash
   tcpdump -nn -r osi-lab.pcap 'tcp[tcpflags] == tcp-syn'
   ```

   Sortie attendue : une ligne qui contient `Flags [S]` et `mss 1460` (ou MTU − 40 si votre MTU n'est pas de 1500).

Vérifiez ensuite votre compréhension à partir de la capture :

- [ ] Vous avez trouvé l'EtherType `0x0800` dans l'en-tête Ethernet de vos trames IPv4.
- [ ] Vous avez trouvé le Protocol d'IP `17` dans la requête DNS et `6` dans la requête HTTP.
- [ ] L'adresse MAC de destination de vos trames sortantes est celle de votre passerelle, pas celle du serveur.
- [ ] Vous savez expliquer pourquoi le MSS vaut 1460 : 1500 (MTU) − 20 (en-tête IPv4) − 20 (en-tête TCP).
- [ ] Votre tableau de l'Étape 9 est complet, avec vos propres valeurs.

## Dépannage
| Symptôme | Cause probable | Solution |
|---|---|---|
| Wireshark n'affiche aucune interface, ou affiche « You don't have permission to capture on that device. » | Votre utilisateur n'est pas autorisé à capturer (groupe `wireshark` sous Linux, ChmodBPF sous macOS, Npcap sous Windows). | Linux : terminez l'Étape 2, puis fermez et rouvrez votre session (`id -nG` doit lister `wireshark`). macOS : réinstallez Wireshark et acceptez ChmodBPF. Windows : réinstallez Npcap depuis l'installateur de Wireshark. |
| `tcpdump: <interface>: You don't have permission to capture on that device` | Vous avez exécuté `tcpdump` sans `sudo`. | Exécutez la commande de l'Étape 3 avec `sudo`. |
| `tcpdump: osi-lab.pcap: Permission denied` | `tcpdump` a abandonné les privilèges root et ne peut pas écrire dans le dossier courant. | Utilisez l'option `-Z "$USER"` comme indiqué et lancez la commande depuis `~/osi-lab`, qui vous appartient. |
| La capture reste vide après l'Étape 4. | Vous capturez sur la mauvaise interface (par exemple un port Ethernet déconnecté, un pont Docker ou une interface VPN). | Vérifiez l'interface qui porte la route par défaut (Étape 1) et capturez sur celle-ci. Dans Wireshark, choisissez l'interface dont le graphique de trafic bouge. |
| Aucun paquet HTTP, seulement du TCP port 443 ou du TLS. | Vous avez utilisé `https://`, ou quelque chose vous a redirigé vers HTTPS. Le chiffrement masque la couche HTTP. | Utilisez exactement `http://example.com/` avec `curl`, pas un navigateur. Les navigateurs passent souvent automatiquement en HTTPS. |
| Aucune requête DNS dans la capture. | Vous avez exécuté `dig` sans `@<dns-server>` ; la réponse est donc venue d'un cache local (par exemple `systemd-resolved` sur `127.0.0.53`) ou via DNS over HTTPS. | Exécutez `dig @<dns-server> example.com A` avec le serveur DNS de l'Étape 1. Si vous avez capturé sur l'interface de bouclage (`lo`), vous ne voyez que la requête vers le cache local. |
| Le MSS est très grand (par exemple 65495 sous Linux), ou les adresses MAC sont toutes à zéro. | Vous avez capturé sur l'interface de bouclage, qui a une MTU très grande et aucune vraie carte réseau. | Capturez sur votre interface physique (Étape 1). |
| Les paquets affichent `ethertype IPv6 (0x86dd)` et un MSS de 1440. | `curl` s'est connecté en IPv6. L'en-tête IPv6 fait 40 octets, donc le MSS vaut 1500 − 40 − 20 = 1440. | Ajoutez `-4` à `curl` comme indiqué à l'Étape 4, ou gardez la capture IPv6 comme comparaison supplémentaire. |
| Pas d'en-tête Ethernet (`link-type RAW`) et un MSS inférieur à 1460. | Un VPN est actif et vous avez capturé sur son interface de tunnel. | Déconnectez le VPN pendant le lab, ou capturez sur l'interface physique. Un MSS plus petit via un VPN est normal. |

## Défi (facultatif)
Refaites la capture avec HTTPS : utilisez le filtre de capture `tcp port 443` et exécutez `curl -4 -s -o /dev/null https://example.com/`. Sans aide pas à pas, répondez à ces questions à partir de la capture :

1. Quels en-têtes pouvez-vous encore lire (Ethernet, IP, TCP), et où commence la partie chiffrée ?
2. Repérez le Client Hello TLS. Quelle information sur le site web reste visible en clair ? (Indice : cherchez l'extension Server Name Indication, SNI.)
3. En quoi cela correspond-il à l'affirmation de la leçon selon laquelle « le chiffrement à une couche ne protège que les couches situées au-dessus » ?

## Nettoyage
Arrêtez toute capture encore en cours (Wireshark : **Stop** ; tcpdump : **Ctrl+C**), puis vérifiez qu'il ne reste aucun processus `tcpdump` :

```bash
pgrep -a tcpdump
```

Sortie attendue : aucune (aucun processus n'est listé).

Supprimez les fichiers de capture et le dossier du lab. Ils peuvent contenir des données privées.

```bash
rm -rf ~/osi-lab
```

Sous Windows, supprimez dans l'Explorateur de fichiers le dossier où vous avez enregistré `osi-lab.pcapng`.

Si vous vous êtes ajouté au groupe `wireshark` **uniquement pour ce lab** (Étape 2), retirez cette appartenance, puis fermez et rouvrez votre session :

```bash
sudo gpasswd -d "$USER" wireshark
```

Sortie attendue :
```text
Removing user learner from group wireshark
```

Si vous avez installé Wireshark, Npcap ou ChmodBPF uniquement pour ce lab, vous pouvez les désinstaller avec le gestionnaire de paquets de votre système ou avec le désinstallateur de Wireshark.

> [!NOTE]
> Wireshark mémorise aussi les fichiers ouverts récemment. Pour vider la liste, utilisez **File → Open Recent → Clear Recent Files**.

## Ce que vous avez appris
- Un outil de capture vous montre tous les en-têtes d'une trame : vous voyez donc l'encapsulation directement, et pas seulement dans des schémas.
- L'en-tête de chaque couche indique au récepteur ce qui suit : l'EtherType `0x0800` signifie IPv4, le Protocol d'IP `6` signifie TCP et `17` signifie UDP, et le port de destination désigne l'application.
- Vos trames sortantes partent vers l'adresse MAC de la passerelle, tandis que les adresses IP identifient les véritables extrémités.
- Le segment SYN annonce le MSS : 1460 octets sur une liaison Ethernet standard de 1500 octets, soit 1500 − 20 (IPv4) − 20 (TCP).
- Le chiffrement masque les couches situées au-dessus. HTTP non chiffré montre la requête en clair ; HTTPS ne montre que les couches inférieures et la négociation TLS.
- Capturer du trafic est puissant et sensible : ne capturez que votre propre trafic, gardez les fichiers privés et supprimez-les quand vous avez terminé.