Suivre les flux TCP dans Tshark

Introduction

Dans ce laboratoire, vous apprendrez à analyser les flux TCP à l'aide de l'outil en ligne de commande tshark de Wireshark. Vous allez pratiquer les commandes essentielles pour lire les captures de paquets, identifier les conversations TCP et extraire des données de flux spécifiques pour une inspection détaillée.

Les exercices vous guideront tout au long de la vérification des fichiers de capture, de l'examen des détails du protocole et de la sauvegarde du contenu du flux. En terminant ce laboratoire, vous acquerrez des compétences pratiques dans l'analyse du trafic réseau en utilisant les puissantes fonctionnalités de filtrage et de statistiques de tshark.

Skills Graph

Lire une capture TCP avec -r tcp.pcap

Dans cette étape, vous apprendrez à lire un fichier de capture de paquets TCP à l'aide de l'outil en ligne de commande tshark de Wireshark. C'est la première étape de l'analyse du trafic réseau à partir d'un fichier de capture enregistré. Comprendre comment lire les captures de paquets est fondamental pour la résolution de problèmes et l'analyse du réseau.

L'option -r dans tshark vous permet de lire des paquets à partir d'un fichier de capture enregistré précédemment. Imaginez-le comme l'ouverture d'un document - le drapeau -r indique à tshark quel "document" (fichier de capture) ouvrir. Nous allons utiliser un fichier d'exemple nommé tcp.pcap situé dans votre répertoire ~/project.

1. Tout d'abord, vérifions que le fichier de capture existe à l'emplacement attendu. C'est une bonne pratique avant de tenter d'analyser tout fichier :

ls ~/project/tcp.pcap

2. Maintenant, nous allons utiliser tshark pour lire le fichier de capture. La commande de base sans aucun filtre vous montrera une vue d'ensemble de tout le trafic réseau dans le fichier :

tshark -r ~/project/tcp.pcap

Cela affiche une vue récapitulative avec des colonnes importantes :

• Numéro de paquet (montrant l'ordre des paquets capturés)
• Horodatage (quand chaque paquet a été capturé)
• Adresses IP source et destination
• Protocole utilisé (TCP, UDP, etc.)
• Informations brèves sur le contenu du paquet

3. Pour approfondir l'examen du contenu des paquets, nous pouvons ajouter le drapeau -V (mode verbeux). Cela montre la décomposition complète du protocole de chaque paquet, couche par couche :

tshark -r ~/project/tcp.pcap -V

La sortie verbeuse révèle des détails sur :

• Couche Ethernet (adresses MAC)
• Couche IP (adresse IP source/destination, TTL, etc.)
• Couche TCP (ports, numéros de séquence, indicateurs)
• Données de la couche application (si présentes)

Cette vue détaillée vous aide à comprendre exactement ce qui se passe à chaque couche réseau pendant la communication.

Identifier l'index de flux avec -z conv,tcp

Dans cette étape, vous apprendrez à identifier les flux de conversations TCP dans une capture de paquets en utilisant tshark de Wireshark avec l'option -z conv,tcp. Cela permet d'analyser les modèles de communication entre les hôtes.

Avant de commencer, il est important de comprendre que les flux TCP représentent des conversations complètes entre deux points terminaux. Chaque flux a un numéro d'index unique qui nous aide à isoler et à analyser des communications spécifiques dans une capture réseau qui peut contenir de nombreuses connexions simultanées.

L'option -z conv,tcp affiche un tableau de toutes les conversations TCP dans la capture, montrant les index de flux, les adresses source/destination, les ports et le nombre de paquets. Cela nous donne une vue d'ensemble des activités TCP dans notre fichier de capture.

1. Tout d'abord, listons toutes les conversations TCP dans notre fichier de capture :

tshark -r ~/project/tcp.pcap -z conv,tcp

Lorsque vous exécutez cette commande, tshark traitera le fichier de capture de paquets et générera un récapitulatif de toutes les conversations TCP. La commande lit (-r) le fichier pcap spécifié et applique l'option de statistiques de conversation (-z conv,tcp).

2. La sortie affichera un tableau avec les colonnes suivantes :

   • Index de flux (identifiant unique pour chaque flux TCP)
   • Adresse source:port (montrant quel appareil a initié la connexion)
   • Adresse de destination:port (montrant l'appareil récepteur)
   • Nombre de paquets dans chaque direction (aide à identifier le flux de trafic)
   • Nombre total de paquets (donne la taille de la conversation)

3. Pour filtrer et voir seulement les statistiques de conversation (sans les détails des paquets), ajoutez -q (mode silencieux) :

tshark -r ~/project/tcp.pcap -z conv,tcp -q

L'option -q indique à tshark de n'afficher que les statistiques demandées, rendant la sortie plus propre et plus facile à lire lorsque nous ne sommes intéressés que par le récapitulatif de la conversation.

4. Notez les index de flux (première colonne) car vous en aurez besoin pour l'étape suivante où nous suivrons des flux spécifiques. Ces index sont essentiels car ils nous permettent de nous concentrer sur des conversations individuelles au sein d'une capture réseau potentiellement très chargée.

Suivre un flux avec -z follow,tcp,stream,0

Dans cette étape, vous apprendrez à suivre et à analyser un flux TCP spécifique à partir de la capture de paquets en utilisant tshark de Wireshark avec l'option -z follow,tcp. Cela vous permet de reconstituer le flux de données réel d'une conversation entre deux points terminaux, facilitant ainsi la compréhension de la communication au niveau de l'application.

L'option -z follow,tcp,stream,0 vous permet d'examiner le flux 0 (remplacez 0 par l'index de flux souhaité de l'étape précédente) sous forme de flux de données continu plutôt que de paquets individuels. Cela est particulièrement utile lors de l'analyse de protocoles comme HTTP où le chargement d'une seule page web peut impliquer plusieurs paquets.

1. Tout d'abord, suivons le flux 0 (la première conversation TCP) de notre capture. Cette commande lit le fichier pcap et reconstitue l'ensemble de la conversation :

tshark -r ~/project/tcp.pcap -z follow,tcp,stream,0

2. La sortie affichera trois informations importantes :

   • L'échange de données complet entre le client et le serveur, reconstitué dans l'ordre
   • Représentation ASCII des données de la couche application (ce que les applications ont réellement envoyé)
   • Indicateurs de direction (">" pour le client vers le serveur, "<" pour le serveur vers le client) qui aident à suivre qui a initié chaque partie de la conversation

3. Pour suivre un autre flux, remplacez "0" par l'index de flux souhaité (issu de la sortie de l'étape 2). Par exemple, pour voir la deuxième conversation de la capture :

tshark -r ~/project/tcp.pcap -z follow,tcp,stream,1

4. Pour obtenir une sortie plus propre montrant seulement les données (sans les en-têtes de paquets), ajoutez -q (mode silencieux). Cela est utile lorsque vous ne vous intéressez qu'aux données de l'application :

tshark -r ~/project/tcp.pcap -z follow,tcp,stream,0 -q

Sauvegarder le texte d'un flux avec redirection

Dans cette étape, vous apprendrez à sauvegarder le contenu d'un flux TCP dans un fichier en utilisant la redirection de sortie. Cette technique est particulièrement utile lorsque vous avez besoin d'analyser les modèles de communication réseau ou de partager les données capturées avec vos collègues. Le processus consiste à extraire les données spécifiques d'un flux TCP à partir d'un fichier de capture de paquets et de les stocker dans un fichier texte pour une analyse ultérieure.

1. Tout d'abord, sauvegardons le flux 0 dans un fichier nommé stream0.txt. Cette commande lit le fichier de capture de paquets (tcp.pcap) et extrait uniquement le contenu du flux TCP d'index 0, puis redirige la sortie vers un nouveau fichier texte :

tshark -r ~/project/tcp.pcap -z follow,tcp,stream,0 -q > ~/project/stream0.txt

2. Après avoir exécuté la commande, vérifiez que le fichier a été créé avec succès. La commande ls -l affiche des informations détaillées sur le fichier, y compris sa taille et sa date de création :

ls -l ~/project/stream0.txt

3. Pour afficher le contenu réel que vous avez sauvegardé, utilisez la commande cat. Cela affichera la conversation complète du flux TCP, y compris les messages du client et du serveur :

cat ~/project/stream0.txt

4. La même technique fonctionne pour n'importe quel flux TCP dans votre fichier de capture. Voici comment sauvegarder le flux 1 en changeant simplement l'index du flux dans la commande. Notez que nous créons un nouveau fichier (stream1.txt) pour éviter d'écraser le précédent :

tshark -r ~/project/tcp.pcap -z follow,tcp,stream,1 -q > ~/project/stream1.txt

5. Lors de l'examen de flux plus longs, l'ajout de numéros de ligne peut faciliter l'analyse. Le drapeau -n avec cat affiche chaque ligne avec son numéro correspondant, vous aidant à référencer des parties spécifiques de la conversation :

cat -n ~/project/stream0.txt

Résumé

Dans ce laboratoire, vous avez appris à analyser le trafic réseau TCP en utilisant l'outil en ligne de commande tshark de Wireshark. Les exercices ont couvert la lecture de captures de paquets avec -r, l'affichage d'informations détaillées sur les protocoles via -V, et l'identification des conversations TCP en utilisant -z conv,tcp pour l'analyse des flux.

Vous avez pratiqué le suivi de flux TCP spécifiques par leurs index et la sauvegarde du contenu des flux grâce à la redirection de sortie. Ces techniques fournissent un flux de travail pratique pour inspecter le trafic réseau, depuis la capture initiale jusqu'à l'examen ciblé des données en utilisant tshark.