Décoder des protocoles personnalisés dans Tshark

Introduction

Dans ce laboratoire, vous apprendrez à analyser et à décoder des protocoles de réseau personnalisés à l'aide de l'outil en ligne de commande tshark de Wireshark. Vous allez pratiquer l'inspection de fichiers de capture de paquets avec une sortie détaillée et le décodage du trafic sur des ports non standard en tant que protocole HTTP.

Les exercices vous guideront dans l'utilisation d'indicateurs clés tels que -r, -V et -d pour manipuler les données de paquets, vérifier les détails des ports et enregistrer les résultats décodés. Ces compétences vous permettront de gérer des scénarios de protocole personnalisé dans des tâches d'analyse de réseau réelles.

Skills Graph

Inspecter les ports avec -r capture.pcap -V

Dans cette étape, vous apprendrez à inspecter les ports réseau dans un fichier de capture de paquets à l'aide de l'outil en ligne de commande tshark de Wireshark. Les ports réseau sont comme des portes qui permettent à différentes applications de communiquer sur un réseau. Nous allons utiliser le flag -r pour lire un fichier de capture de paquets et -V pour afficher des informations détaillées sur les paquets, ce qui est essentiel pour comprendre le trafic réseau.

Tout d'abord, assurez-vous d'être dans le bon répertoire où sont stockés nos fichiers de laboratoire :

cd ~/project

Un fichier de capture de paquets exemple capture.pcap a été fourni pour ce laboratoire. Ce fichier contient le trafic réseau enregistré que nous allons analyser. Pour inspecter les ports dans ce fichier de capture, exécutez :

tshark -r capture.pcap -V | less

Décortiquons cette commande :

• -r capture.pcap indique à tshark de lire à partir de notre fichier de capture de paquets
• -V active la sortie détaillée, affichant tous les détails disponibles sur les paquets
• | less envoie la sortie au programme less pour faciliter le défilement

La sortie détaillée vous montrera des informations importantes sur le réseau, notamment :

• Les ports source et de destination de chaque paquet (qui identifient les applications en communication)
• Les informations sur le protocole (le type de communication en cours)
• Les horodatages des paquets (quand la communication s'est produite)
• D'autres détails spécifiques au protocole (informations techniques supplémentaires)

Pour une meilleure lisibilité, nous utilisons less pour afficher la sortie. Voici comment naviguer :

• Utilisez les flèches pour faire défiler vers le haut et vers le bas
• Appuyez sur q pour quitter une fois que vous avez terminé d'examiner les paquets

Exemple de sortie que vous pourriez voir :

Frame 1: 74 bytes on wire (592 bits), 74 bytes captured (592 bits)
Ethernet II, Src: 00:1a:2b:3c:4d:5e, Dst: 00:5e:4d:3c:2b:1a
Internet Protocol Version 4, Src: 192.168.1.100, Dst: 192.168.1.1
Transmission Control Protocol, Src Port: 54321, Dst Port: 80, Seq: 1, Ack: 1, Len: 0

Dans cet exemple, faites particulièrement attention à :

• Src Port: 54321 - le numéro de port sur l'ordinateur émetteur
• Dst Port: 80 - le numéro de port sur l'ordinateur récepteur (le port 80 indique généralement le trafic web HTTP)

Comprendre ces numéros de port permet d'identifier les applications ou services en communication sur le réseau.

Décoder le port 8080 comme HTTP avec -d tcp.port==8080,http

Dans cette étape, nous allons explorer comment indiquer manuellement à Tshark d'interpréter le trafic réseau sur le port 8080 comme un protocole HTTP. Cette technique est essentielle lorsque les applications utilisent des ports non standard pour la communication HTTP, que Tshark ne reconnaîtrait pas automatiquement comme du trafic web.

Tout d'abord, naviguons jusqu'à notre répertoire de travail où se trouve le fichier de capture. Cela garantit que nous travaillons avec le bon fichier de capture de paquets :

cd ~/project

Maintenant, nous allons utiliser la puissante fonctionnalité de décodage de Tshark. La commande suivante lit notre capture de paquets et applique des règles de décodage spéciales :

tshark -r capture.pcap -d tcp.port==8080,http | less

Décortiquons le paramètre -d qui fait tout le travail ici :

• tcp.port==8080 indique à Tshark que nous nous concentrons sur le trafic TCP via le port 8080
• http spécifie que nous voulons interpréter ce trafic comme un protocole HTTP

En cas de succès, vous verrez un contenu HTTP correctement formaté comme celui-ci :

Hypertext Transfer Protocol
    GET /index.html HTTP/1.1\r\n
    Host: example.com\r\n
    User-Agent: curl/7.68.0\r\n
    Accept: */*\r\n
    \r\n

Cette sortie montre clairement les en-têtes de requête HTTP, confirmant que notre décodage a fonctionné. Sans l'option -d, le même trafic apparaîtrait sous forme de segments TCP bruts, rendant l'analyse des communications web beaucoup plus difficile. Le pipe vers less facilite simplement le défilement de la sortie pour l'analyse.

Confirmer le décodage avec -V

Dans cette étape, nous allons vérifier si notre configuration de décodage HTTP sur le port 8080 fonctionne correctement. Cela est important car parfois les paquets peuvent ne pas être décodés comme prévu, et nous devons confirmer notre configuration. Nous allons utiliser le mode détaillé (flag -V) de Wireshark pour voir les informations détaillées sur le protocole de chaque paquet.

Tout d'abord, naviguons jusqu'à notre répertoire de travail où se trouve le fichier de capture :

cd ~/project

Maintenant, nous allons exécuter tshark avec notre règle de décodage et une sortie détaillée. La commande combine ce que nous avons appris dans les étapes précédentes :

tshark -r capture.pcap -d tcp.port==8080,http -V | less

Voici ce que chaque partie fait :

• -r capture.pcap lit notre fichier de capture de paquets
• -d tcp.port==8080,http applique notre règle de décodage HTTP au port 8080
• -V active la sortie détaillée affichant tous les détails du protocole
• | less facilite le défilement de la sortie longue

Lors de l'examen de la sortie, concentrez-vous sur ces éléments clés qui confirment un décodage HTTP réussi :

1. Hiérarchie des protocoles montrant HTTP comme protocole de la couche application (cela signifie que tshark le reconnaît comme du trafic HTTP)
2. En-têtes de requête/réponse HTTP (ils devraient être clairement visibles et correctement formatés)
3. Contenu de la charge utile HTTP (les données réelles transmises)

Voici un exemple de ce à quoi ressemble un trafic HTTP correctement décodé :

Hypertext Transfer Protocol
    GET /test.html HTTP/1.1\r\n
    Host: example.com:8080\r\n
    Connection: keep-alive\r\n
    User-Agent: Mozilla/5.0\r\n
    \r\n
    [Full request URI: http://example.com:8080/test.html]

Pour mieux comprendre l'impact du décodage, comparez cette sortie avec ce que vous avez vu dans l'Étape 1 lorsque nous n'avions pas appliqué le décodage HTTP. Vous devriez remarquer qu'en l'absence de décodage, le même trafic apparaîtrait sous forme de données TCP brutes sans la structure HTTP claire que nous voyons ici.

Sauvegarder le fichier décodé avec -w decoded.pcap

Dans cette étape, nous allons sauvegarder notre trafic HTTP décodé dans un nouveau fichier. Cela est important car cela conserve tout le travail de décodage du protocole que nous avons effectué tout en gardant les données originales des paquets intactes. Imaginez cela comme sauvegarder un document après avoir effectué des modifications - vous voulez conserver les deux versions.

Tout d'abord, assurons-nous que nous sommes dans le bon répertoire de travail. La commande cd permet de changer de répertoire, et nous allons dans notre dossier de projet :

cd ~/project

Maintenant, nous allons utiliser Tshark pour créer un nouveau fichier de capture avec notre trafic HTTP décodé. La commande peut sembler complexe, mais nous allons la décomposer morceau par morceau :

tshark -r capture.pcap -d tcp.port==8080,http -w decoded.pcap

Comprenons chaque partie de cette commande :

• -r capture.pcap indique à Tshark de lire à partir de notre fichier de capture original
• -d tcp.port==8080,http applique notre règle de décodage spéciale qui traite le trafic du port 8080 comme du trafic HTTP
• -w decoded.pcap spécifie où sauvegarder la nouvelle version décodée

Après avoir exécuté cela, nous devrions vérifier que notre nouveau fichier a été créé avec succès. La commande ls liste les fichiers, et -lh affiche les détails dans un format lisible par l'homme :

ls -lh decoded.pcap

Vous verrez une sortie comme celle-ci montrant votre nouveau fichier :

-rw-r--r-- 1 labex labex 1.2M Sep 15 10:30 decoded.pcap

Ce nouveau fichier contient tous les paquets originaux, mais maintenant tout le trafic sur le port 8080 sera correctement interprété comme du protocole HTTP, rendant l'analyse du trafic web beaucoup plus facile lors d'enquêtes futures.

Résumé

Dans ce laboratoire (lab), vous avez appris à analyser et décoder des protocoles de réseau personnalisés en utilisant tshark. Vous avez pratiqué la lecture de fichiers de capture de paquets avec le flag -r et l'examen des informations détaillées sur les paquets en utilisant le flag -V pour identifier le trafic HTTP non standard.

De plus, vous avez exploré le décodage de protocole en appliquant le flag -d pour interpréter le trafic sur le port 8080 comme du trafic HTTP. Le laboratoire a également abordé la sauvegarde de la sortie décodée dans un nouveau fichier avec le flag -w pour référence et analyse futures.