Analyser la perte de paquets dans Tshark

Introduction

Dans ce laboratoire, vous apprendrez à analyser la perte de paquets TCP à l'aide de l'outil en ligne de commande Tshark de Wireshark. Vous allez pratiquer la capture du trafic réseau, l'identification des retransmissions et l'interprétation des statistiques de perte grâce à des commandes pratiques dans le terminal.

Les exercices vous guideront dans la détection des modèles de perte de paquets et la compréhension des métriques de performance réseau. Vous aurez l'expérience pratique à la fois avec les transmissions normales et les scénarios de perte simulés pour résoudre les problèmes de connexion TCP dans le monde réel.

Capturer le trafic TCP avec -f "tcp"

Dans cette étape, vous apprendrez à capturer le trafic TCP en utilisant l'option de filtre de capture -f "tcp" de Wireshark. Le TCP (Transmission Control Protocol) est l'un des protocoles de base d'Internet, chargé de la livraison fiable des données. Ce filtre garantit que seuls les paquets TCP sont capturés, ce qui est particulièrement utile lorsque vous souhaitez vous concentrer sur les comportements spécifiques au TCP, tels que l'établissement de connexion (trois-way handshake), les retransmissions et le contrôle de flux, sans être dérangé par le reste du trafic réseau.

Tout d'abord, ouvrez un terminal dans votre machine virtuelle LabEx en cliquant sur l'icône du terminal sur le bureau Xfce ou en utilisant le raccourci Ctrl+Alt+T. C'est dans le terminal que vous exécuterez toutes les commandes pour cette analyse réseau.
Accédez au répertoire de travail par défaut où nous allons stocker nos fichiers de capture :
```
cd ~/project
```
Ce répertoire a été créé spécifiquement pour votre travail de laboratoire, ce qui permet de garder vos fichiers organisés et séparés des fichiers système.
Commencez à capturer les paquets TCP en exécutant cette commande :
```
sudo tshark -f "tcp" -w tcp_capture.pcap
```
Décortiquons ce que chaque partie fait :
- sudo vous donne les privilèges d'administrateur nécessaires pour capturer les paquets.
- tshark est la version en ligne de commande de Wireshark.
- -f "tcp" indique à tshark de ne capturer que les paquets TCP.
- -w tcp_capture.pcap enregistre les paquets capturés dans un fichier nommé tcp_capture.pcap.
Pendant que tshark est en cours d'exécution, ouvrez un autre onglet/fenêtre de terminal (Ctrl+Shift+T) et générez un peu de trafic TCP. Nous allons utiliser curl pour effectuer une simple requête web :
```
curl -I https://www.labex.io
```
Le paramètre -I indique à curl de ne récupérer que les en-têtes HTTP, ce qui génère suffisamment de trafic pour notre analyse sans télécharger des données inutiles.
Après avoir attendu environ 5 à 10 secondes pour capturer suffisamment de paquets, arrêtez la capture en appuyant sur Ctrl+C dans le terminal où tshark est en cours d'exécution. Vous devriez voir une sortie similaire à :
```
Capturing on 'eth1'
10 packets captured
```
Cela confirme le nombre de paquets TCP capturés pendant votre session.
Vérifiez que votre fichier de capture a été créé avec succès en listant les fichiers dans le répertoire :
```
ls -lh tcp_capture.pcap
```
Les options -lh affichent la taille du fichier dans un format lisible par l'homme (comme KB ou MB) ainsi que d'autres détails. Cela permet de confirmer que votre capture a été enregistrée correctement avant de passer à l'étape suivante.

Vérifier les retransmissions avec -Y "tcp.analysis.retransmission"

Dans cette étape, nous allons examiner les retransmissions TCP qui se produisent lorsque l'émetteur ne reçoit pas d'accusé de réception (ACK) pour les paquets envoyés et doit les renvoyer. C'est une technique essentielle de dépannage réseau car les retransmissions fréquentes indiquent souvent une congestion réseau, une perte de paquets ou d'autres problèmes de connectivité.

Avant de commencer, comprenons ce que nous recherchons :

Une retransmission se produit lorsque le TCP ne reçoit pas d'ACK (accusé de réception) dans le délai prévu.
Wireshark/tshark peut identifier ces retransmissions en utilisant le filtre spécial "tcp.analysis.retransmission".
Nous allons d'abord vérifier une capture existante, puis en créer une nouvelle avec des problèmes réseau simulés.

Tout d'abord, assurez-vous que vous êtes dans le répertoire du projet où nos fichiers de capture sont stockés :
```
cd ~/project
```
Analysons le fichier de capture que nous avons créé précédemment pour détecter les éventuelles retransmissions. La commande se décompose comme suit :
- -r lit à partir d'un fichier de capture enregistré.
- -Y applique un filtre d'affichage pour afficher uniquement les retransmissions.
```
tshark -r tcp_capture.pcap -Y "tcp.analysis.retransmission"
```
Si votre connexion réseau était stable lors de la première capture, vous verrez probablement :
```
0 packets captured
```
C'est normal et indique qu'aucun paquet n'a besoin d'être retransmis pendant cette période de capture.
Pour mieux comprendre les retransmissions, nous allons maintenant créer une nouvelle capture tout en provoquant intentionnellement une congestion réseau. Ouvrez deux fenêtres de terminal :

Dans le premier terminal, commencez à capturer le trafic TCP :
```
sudo tshark -f "tcp" -w retransmission_capture.pcap
```
Dans le deuxième terminal, exécutez un téléchargement lent qui peut déclencher des retransmissions :
```
curl --limit-rate 10k https://www.labex.io
```
Après quelques secondes, arrêtez les deux processus avec Ctrl+C.
Examinez maintenant le nouveau fichier de capture pour détecter les retransmissions :
```
tshark -r retransmission_capture.pcap -Y "tcp.analysis.retransmission"
```
Cette fois, vous devriez voir les paquets retransmis répertoriés, affichant les numéros de séquence et les détails temporels qui aident à diagnostiquer les problèmes de performance réseau.

Récapituler les statistiques de perte avec -z tcp,tree

Dans cette étape, vous apprendrez à utiliser la puissante fonctionnalité de statistiques de Wireshark avec l'option -z tcp,tree. Cette commande vous aide à analyser les conversations TCP et à identifier les modèles de perte de paquets en fournissant un aperçu structuré de tous les flux TCP dans vos données capturées.

Avant de commencer, comprenons ce que montrent les statistiques des conversations TCP :

La vue arborescente affiche la communication entre des paires d'hôtes.
Elle compte les trames (paquets) et les octets transférés dans chaque direction.
Elle permet d'identifier le trafic déséquilibré qui peut indiquer des problèmes.

Tout d'abord, assurez-vous que vous êtes dans le répertoire du projet où vos fichiers de capture sont stockés :
```
cd ~/project
```
Analysons maintenant les statistiques TCP de base de notre première capture. Cette commande lit le fichier de capture et génère un arbre de conversation :
```
tshark -r tcp_capture.pcap -z tcp,tree
```

La sortie affichera une table structurée de toutes les conversations TCP. Faites attention aux colonnes suivantes :

<- montre le trafic arrivant sur votre machine.
-> montre le trafic sortant de votre machine.
Total résume les deux directions.

======================================================
TCP Conversations
Filter:<No Filter>
|       <-      | |       ->      | |     Total     |
| Frames  Bytes | | Frames  Bytes | | Frames  Bytes |
======================================================

Examinons maintenant plus précisément la capture de retransmissions. Les retransmissions se produisent lorsque des paquets sont perdus et doivent être renvoyés :
```
tshark -r retransmission_capture.pcap -z tcp,tree
```
Recherchez les conversations où le nombre de trames est significativement plus élevé que les autres - cela indique souvent des problèmes de retransmission.
Pour une analyse plus précise, nous pouvons combiner cela avec notre filtre de retransmission précédent. Cela affiche uniquement les paquets retransmis dans l'arbre de conversation :
```
tshark -r retransmission_capture.pcap -Y "tcp.analysis.retransmission" -z tcp,tree
```
Cela permet de préciser exactement quelles conversations sont touchées par la perte de paquets.

Sortie silencieuse avec -q

Dans cette étape, nous allons explorer comment utiliser l'option -q de Wireshark pour simplifier votre analyse de paquets. Lorsque vous travaillez avec de grandes captures réseau, vous n'avez souvent pas besoin de voir chaque paquet individuellement - vous voulez simplement les statistiques importantes. L'option -q (silencieux) vous aide en masquant les listes détaillées des paquets et en affichant uniquement les données de synthèse.

Tout d'abord, naviguons jusqu'à notre répertoire de travail où les fichiers de capture sont stockés :
```
cd ~/project
```
Maintenant, analysons notre fichier de capture TCP en mode silencieux. Cette commande lit le fichier mais n'affiche que les statistiques des conversations TCP :
```
tshark -r tcp_capture.pcap -q -z tcp,tree
```
Pour comprendre ce que fait l'option -q, exécutons la même commande sans elle. Remarquez comment cette version affiche tous les paquets individuels avant les statistiques :
```
tshark -r tcp_capture.pcap -z tcp,tree
```
Nous pouvons combiner l'option silencieuse avec notre filtre de retransmission précédent. Cela nous donne une vue claire des seules statistiques de retransmission :
```
tshark -r retransmission_capture.pcap -Y "tcp.analysis.retransmission" -q -z tcp,tree
```

Le format de sortie ressemblera à ceci, affichant uniquement les statistiques des conversations sans les détails des paquets :

======================================================
TCP Conversations
Filter:tcp.analysis.retransmission
|       <-      | |       ->      | |     Total     |
| Frames  Bytes | | Frames  Bytes | | Frames  Bytes |
======================================================

Résumé

Dans ce laboratoire, vous avez appris à analyser la perte de paquets TCP à l'aide de Tshark grâce à des techniques pratiques de dépannage réseau. Vous avez capturé le trafic TCP avec des filtres spécifiques, identifié les retransmissions et généré des statistiques de connexion pour évaluer les performances du réseau.

Les exercices ont démontré comment utiliser les fonctionnalités avancées de Tshark telles que -z tcp,tree pour une analyse complète des flux TCP et -q pour un rapport statistique efficace. Ces compétences vous permettent de diagnostiquer rapidement et de résoudre les problèmes de perte de paquets dans des environnements réseau réels.