Suivi des flux réseau

Introduction

Le trafic réseau est souvent découpé en petits morceaux appelés paquets avant d'être transmis sur le réseau. Lorsqu'un client et un serveur communiquent, ils s'échangent de nombreux paquets. Un « flux » (stream) représente la séquence complète et ordonnée de ces paquets pour une connexion donnée.

Cette distinction entre paquet et flux est l'un des changements de perspective les plus importants en analyse de protocoles. Les paquets individuels vous montrent ce qui s'est passé à un instant précis. Les flux, eux, révèlent la conversation dans son ensemble. De nombreux événements de la couche application, tels que les connexions, les soumissions de formulaires et les transferts de fichiers, deviennent beaucoup plus compréhensibles lorsque vous reconstruisez la conversation plutôt que d'examiner des paquets isolés un par un.

Dans ce laboratoire, vous apprendrez à utiliser tshark (la version en ligne de commande de Wireshark) pour reconstruire ces conversations réseau fragmentées. En suivant des flux TCP complets, vous serez capable de réassembler les paquets individuels et de visualiser l'intégralité de l'interaction entre un client et un serveur sous forme de texte lisible. Il s'agit d'une compétence essentielle pour le dépannage réseau et l'analyse de sécurité.

Identifier les flux TCP

Dans cette étape, vous apprendrez à identifier les différents flux TCP présents dans un fichier de capture réseau.

Lorsque tshark lit un fichier de capture, il regroupe automatiquement les paquets appartenant à la même connexion (même IP source, port source, IP destination et port destination) et leur attribue un index entier unique. Cet index est connu sous le nom de champ tcp.stream.

Vous pouvez considérer tcp.stream comme une étiquette de conversation créée par l'analyseur. Elle ne provient pas du réseau lui-même en tant que champ de protocole. Au lieu de cela, tshark déduit que certains paquets appartiennent au même ensemble car ils partagent les mêmes points de terminaison de connexion et la même séquence d'événements. C'est pourquoi l'analyse de flux est une « vue analyste » si utile des données.

Votre environnement a déjà été préparé avec un fichier de capture exemple nommé sample_traffic.pcap situé dans votre répertoire ~/project. Ce fichier contient un trafic web basique.

Pour voir tous les flux TCP uniques dans ce fichier de capture, vous pouvez demander à tshark d'extraire le champ tcp.stream de chaque paquet, de trier les résultats et d'afficher uniquement les valeurs uniques.

Exécutez la commande suivante dans votre terminal :

tshark -r sample_traffic.pcap -T fields -e tcp.stream | sort -n | uniq

Analysons cette commande :

-r sample_traffic.pcap : Indique à tshark de lire le fichier de capture spécifié.
-T fields : Spécifie que nous voulons extraire des champs spécifiques plutôt que le résumé de paquet par défaut.
-e tcp.stream : Indique à tshark d'afficher l'index du flux TCP pour chaque paquet.
| sort -n | uniq : Envoie la sortie vers des utilitaires Linux standard pour trier les nombres numériquement et supprimer les doublons.

Vous devriez obtenir un résultat similaire à celui-ci :

0
1

Ce résultat indique qu'il y a deux conversations TCP distinctes (Flux 0 et Flux 1) enregistrées dans ce fichier de capture.

Reconstruire le flux TCP

Maintenant que vous connaissez les numéros d'index des flux TCP, vous pouvez reconstruire la conversation entière. Ce processus est identique à la fonctionnalité « Suivre le flux TCP » (Follow TCP Stream) de l'interface graphique de Wireshark.

La reconstruction est particulièrement précieuse pour les protocoles textuels comme HTTP, SMTP et de nombreux protocoles d'application hérités, car l'analyste peut lire les requêtes et les réponses dans l'ordre où l'application les a vécues. Même lorsque l'échange sous-jacent s'étend sur plusieurs paquets, le flux reconstruit rétablit le fil conducteur.

Dans cette étape, nous allons reconstruire le flux 0. Ce flux contient une requête HTTP GET où un client a demandé une page web au serveur.

Pour suivre un flux dans tshark, on utilise l'option -z, qui sert à diverses tâches de statistiques et d'analyse. La syntaxe spécifique pour suivre un flux est -z follow,tcp,ascii,<stream_index>.

Exécutez la commande suivante pour reconstruire le flux 0 :

tshark -r sample_traffic.pcap -z follow,tcp,ascii,0 -q

Voici la signification des nouveaux arguments :

-z follow,tcp,ascii,0 : Indique à tshark de suivre le flux TCP avec l'index 0 et d'afficher la charge utile (payload) au format ascii (texte lisible).
-q : Signifie « quiet » (silencieux). Cela supprime la sortie par paquet par défaut afin que vous ne voyiez que les données du flux reconstruit.

Vous verrez une sortie affichant la conversation HTTP complète :

===================================================================
Follow: tcp,ascii
Filter: tcp.stream eq 0
Node 0: 127.0.0.1:58548
Node 1: 127.0.0.1:8080
GET / HTTP/1.1
Host: localhost:8080
User-Agent: curl/7.81.0
Accept: */*

HTTP/1.0 200 OK
Server: SimpleHTTP/0.6 Python/3.10.12
Date: Thu, 05 Mar 2026 02:00:48 GMT
Content-type: text/html
Content-Length: 40
Last-Modified: Thu, 05 Mar 2026 02:00:44 GMT

Welcome to the LabEx Network Stream Lab

===================================================================

Dans cette sortie, vous pouvez clairement voir la requête du client (GET / HTTP/1.1...) suivie immédiatement par la réponse du serveur (HTTP/1.0 200 OK... et le contenu HTML). tshark a réussi à réassembler les paquets individuels en un bloc de texte cohérent.

Analyser la conversation

Lors de l'analyse du trafic réseau, les conversations peuvent être très longues. Afficher un flux massif directement dans le terminal peut rendre la lecture et l'analyse difficiles.

Enregistrer le flux reconstruit dans un fichier est une étape simple, mais elle reflète une habitude forensique plus large : préserver les artefacts d'analyse intermédiaires. Les enquêteurs conservent souvent des notes, des conversations extraites, des charges utiles décodées et des preuves filtrées sous forme de fichiers séparés afin que les conclusions puissent être examinées, comparées ou transmises à quelqu'un d'autre sans avoir à répéter les mêmes commandes depuis le début.

Dans cette étape, vous allez reconstruire le flux 1 et rediriger la sortie vers un fichier texte. Cela vous permet d'utiliser des éditeurs de texte standard ou des outils en ligne de commande pour inspecter la conversation à votre rythme.

Le flux 1 contient une requête HTTP POST, généralement utilisée lors de la soumission de données, comme un formulaire de connexion.

Exécutez la commande suivante pour suivre le flux 1 et enregistrer la sortie dans un fichier nommé stream1_analysis.txt :

tshark -r sample_traffic.pcap -z follow,tcp,ascii,1 -q > stream1_analysis.txt

L'opérateur > prend la sortie qui s'afficherait normalement à l'écran et l'écrit dans stream1_analysis.txt dans votre répertoire actuel (~/project).

Maintenant, utilisez la commande cat pour visualiser le contenu du fichier que vous venez de créer :

cat stream1_analysis.txt

Votre sortie devrait ressembler à ceci :

===================================================================
Follow: tcp,ascii
Filter: tcp.stream eq 1
Node 0: 127.0.0.1:45138
Node 1: 127.0.0.1:8080
POST /login HTTP/1.1
Host: localhost:8080
User-Agent: curl/7.81.0
Accept: */*
Content-Length: 23
Content-Type: application/x-www-form-urlencoded

user=labex&action=loginHTTP/1.0 501 Unsupported method ('POST')
Server: SimpleHTTP/0.6 Python/3.10.12
Date: Wed, 25 Oct 2026 10:00:05 GMT
Connection: close
Content-Type: text/html;charset=utf-8
Content-Length: 480

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
        "http://www.w3.org/TR/html4/strict.dtd">
...
===================================================================

En analysant ce fichier, vous pouvez observer les données exactes que le client a envoyées dans le corps de la requête POST (user=labex&action=login). Vous pouvez également voir la réponse du serveur, qui dans ce cas est une erreur 501 Unsupported method, indiquant que le serveur web Python simple utilisé pour générer ce trafic ne prend pas en charge les requêtes POST.

L'enregistrement des flux dans des fichiers est une technique très efficace lorsque vous devez extraire des fichiers, des identifiants ou des journaux détaillés à partir de captures réseau.

Résumé

Félicitations ! Vous avez terminé avec succès le laboratoire sur le suivi des flux réseau.

Dans ce laboratoire, vous avez appris à :

Identifier des flux TCP uniques au sein d'un fichier de capture de paquets en utilisant le champ tcp.stream.
Reconstruire et visualiser la conversation complète d'un flux TCP spécifique en utilisant la fonctionnalité follow de tshark.
Rediriger les données de flux reconstruites vers des fichiers texte pour une lecture plus aisée et une analyse approfondie.

Ces techniques sont fondamentales pour les administrateurs réseau et les professionnels de la sécurité lorsqu'ils enquêtent sur des problèmes réseau, analysent le comportement de logiciels malveillants ou vérifient les communications d'applications.