Extraire les champs de paquets dans Tshark

Introduction

Dans ce laboratoire, vous apprendrez à extraire des champs de paquets spécifiques à partir du trafic réseau en utilisant l'outil en ligne de commande tshark de Wireshark. Vous allez pratiquer la sélection de champs courants tels que l'adresse IP source (ip.src) et le port TCP (tcp.port), tout en maîtrisant le formatage de la sortie avec l'option -T fields et des séparateurs personnalisés.

Les exercices vous guideront à travers la capture de paquets, l'extraction de champs avec le flag -e, et l'exportation des données au format CSV. Vous apprendrez à structurer la sortie pour une meilleure lisibilité et analyse, en utilisant des techniques telles que la configuration du séparateur avec -E separator=, et la redirection de la sortie.

Skills Graph

Sélectionner des champs avec -e ip.src -e tcp.port

Dans cette étape, vous apprendrez à extraire des champs spécifiques à partir de captures de paquets réseau en utilisant l'outil en ligne de commande tshark de Wireshark. Les paquets réseau contiennent de nombreuses informations différentes, et souvent, nous avons seulement besoin d'examiner des champs spécifiques pour notre analyse. Ici, nous allons nous concentrer sur deux champs importants : l'adresse IP source (ip.src) qui nous indique d'où provient le paquet, et le numéro de port TCP (tcp.port) qui identifie le service ou l'application spécifique utilisé.

Tout d'abord, nous avons besoin d'un exemple de trafic réseau sur lequel travailler. La commande suivante générera un simple trafic web que nous pourrons capturer :

curl -s http://example.com > /dev/null

Maintenant, capturons ce trafic en utilisant tshark. La commande ci-dessous capturera 10 paquets et les enregistrera dans un fichier appelé sample.pcap. Le format .pcap est standard pour stocker les captures de trafic réseau :

tshark -c 10 -w sample.pcap

Notre fichier de capture étant prêt, nous pouvons maintenant extraire seulement les champs qui nous intéressent. La commande suivante lit le fichier de capture et affiche seulement les adresses IP source et les ports TCP :

tshark -r sample.pcap -T fields -e ip.src -e tcp.port

Décortiquons ce que chaque partie de cette commande fait :

• -r sample.pcap indique à tshark de lire à partir de notre fichier de capture
• -T fields spécifie que nous voulons la sortie au format de champ (par opposition à d'autres formats comme XML ou JSON)
• -e ip.src sélectionne le champ de l'adresse IP source
• -e tcp.port sélectionne le champ du port TCP

La sortie apparaîtra sous forme de valeurs séparées par des tabulations, chaque ligne représentant un paquet et affichant d'abord l'adresse IP source, puis le numéro de port :

192.168.1.1    443
192.168.1.2    80

Pour faciliter la manipulation, nous pouvons enregistrer la sortie dans un fichier. Cela est particulièrement utile lorsqu'il s'agit de grandes captures ou lorsque nous voulons traiter les données plus en détail :

tshark -r sample.pcap -T fields -e ip.src -e tcp.port > temp.txt
cat temp.txt

Le symbole > redirige la sortie vers un fichier, et cat nous permet d'afficher le contenu de ce fichier. Cette approche nous donne un enregistrement permanent de nos données filtrées que nous pouvons consulter plus tard ou analyser avec d'autres outils.

Configurer la sortie en mode champs avec -T fields

Dans cette étape, nous allons explorer comment personnaliser la sortie de tshark pour afficher uniquement les champs de paquet spécifiques dont nous avons besoin. L'option -T fields transforme l'affichage par défaut des paquets en un format structuré plus facile à traiter et à analyser.

Lorsque vous exécutez tshark pour la première fois sans spécifier de champs, il affiche une vue complète mais parfois écrasante de chaque paquet :

tshark -r sample.pcap -c 3

Cette vue par défaut inclut tous les détails disponibles des paquets. Cependant, pour une analyse ciblée, nous avons souvent besoin de seulement quelques informations clés. C'est là que l'extraction de champs entre en jeu. La commande suivante montre comment sélectionner des champs spécifiques :

tshark -r sample.pcap -T fields -e frame.number -e ip.src -e ip.dst -e tcp.port

Décortiquons ce que chaque partie de cette commande fait :

• -T fields indique à tshark que nous voulons une sortie basée sur les champs plutôt que le résumé de paquet par défaut
• -e frame.number extrait la position du paquet dans le fichier de capture
• -e ip.src montre d'où provient le paquet (adresse IP source)
• -e ip.dst montre où le paquet se dirige (adresse IP de destination)
• -e tcp.port révèle quel port réseau est utilisé

Le résultat est une sortie propre, séparée par des tabulations, qui ressemble à ceci :

1    192.168.1.1    192.168.1.2    443
2    192.168.1.2    192.168.1.1    80

Ce format est particulièrement utile lorsque vous avez besoin de traiter les données plus en détail ou de les importer dans d'autres outils. Si vous n'êtes pas sûr quels champs sont disponibles ou si vous avez besoin de vérifier les noms de champs, vous pouvez rechercher dans la liste complète :

tshark -G fields | grep -E 'ip.src|ip.dst|tcp.port'

Cette commande vous aide à découvrir tous les champs liés aux adresses IP et aux ports TCP que vous pourriez vouloir inclure dans votre analyse.

Utiliser une virgule comme séparateur avec -E separator=

Dans cette étape, nous allons apprendre à changer le séparateur de champ dans la sortie de tshark des tabulations aux virgules. Cette modification est particulièrement utile lorsque vous avez besoin d'importer les données dans des applications de tableur comme Excel ou de les analyser avec des outils qui attendent le format CSV (Comma-Separated Values, valeurs séparées par des virgules).

Tout d'abord, revoyons la commande de base que nous avons utilisée précédemment, qui produit une sortie séparée par des tabulations. Cela nous aide à comprendre ce que nous allons changer :

tshark -r sample.pcap -T fields -e frame.number -e ip.src -e ip.dst -e tcp.port -c 3

Pour convertir cette sortie au format CSV, nous allons utiliser l'option -E avec separator=,. Cela indique à tshark d'utiliser des virgules au lieu de tabulations entre les champs :

tshark -r sample.pcap -T fields -e frame.number -e ip.src -e ip.dst -e tcp.port -E separator=, -c 3

Décortiquons ce que chaque partie de cette commande fait :

• -E separator=, est l'ajout clé qui change le séparateur en une virgule
• Toutes les autres options (-r, -T fields, -e fields, -c) fonctionnent exactement comme avant
• L'ordre des options n'a pas d'importance tant qu'elles sont toutes présentes

Après avoir exécuté cette commande, vous verrez une sortie formatée comme ceci :

1,192.168.1.1,192.168.1.2,443
2,192.168.1.2,192.168.1.1,80
3,192.168.1.3,192.168.1.4,22

Pour confirmer que le séparateur a bien été changé en virgules (ce qui est particulièrement utile si vous ne pouvez pas distinguer visuellement les tabulations des espaces), vous pouvez rediriger la sortie vers od -c, qui affiche les caractères spéciaux :

tshark -r sample.pcap -T fields -e frame.number -e ip.src -E separator=, -c 1 | od -c

Cette étape de vérification permet de s'assurer que votre sortie sera correctement interprétée par les lecteurs CSV, ce qui est crucial lors de la préparation des données pour l'analyse avec d'autres outils.

Exporter dans un fichier avec > fields.csv

Dans cette étape, nous allons apprendre à enregistrer les données de paquets extraites dans un fichier CSV (Comma-Separated Values, valeurs séparées par des virgules). Le format CSV est un format de fichier simple qui stocke des données tabulaires sous forme de texte brut, ce qui le rend parfait pour l'analyse dans les applications de tableur ou les outils de traitement de données. En enregistrant nos données de paquets dans un fichier, nous créons un enregistrement permanent qui peut être partagé, analysé ou traité plus tard.

Combinons tout ce que nous avons appris jusqu'à présent dans une seule commande qui extrait plusieurs champs de paquets et les enregistre dans un fichier :

tshark -r sample.pcap -T fields -e frame.number -e ip.src -e ip.dst -e tcp.port -E separator=, > fields.csv

Voici ce que chaque partie fait :

• -r sample.pcap lit notre fichier de capture de paquets
• -T fields indique à Tshark que nous voulons une sortie basée sur les champs
• Chaque option -e spécifie un champ à extraire (numéro de paquet, adresse IP source, adresse IP de destination et port)
• -E separator=, définit la virgule comme séparateur de champ
• > fields.csv redirige la sortie vers un fichier au lieu de l'afficher à l'écran

Après avoir exécuté cette commande, vérifions si notre fichier a été correctement créé :

ls -l fields.csv
head fields.csv

La commande ls -l affiche les détails du fichier, tandis que head affiche les premières lignes. Votre sortie devrait ressembler à ceci :

1,192.168.1.1,192.168.1.2,443
2,192.168.1.2,192.168.1.1,80
3,192.168.1.3,192.168.1.4,22

Pour rendre ces données plus compréhensibles, nous pouvons ajouter des en-têtes de colonne. Voici comment créer un nouveau fichier avec des en-têtes et le combiner avec nos données :

echo "Packet,Source,Destination,Port" > headers.csv
cat headers.csv fields.csv > final.csv
mv final.csv fields.csv

Cela crée une nouvelle version de notre fichier CSV avec des en-têtes descriptifs en haut, ce qui facilite considérablement la manipulation des données dans les applications de tableur.

Résumé

Dans ce laboratoire, vous avez appris à extraire des champs de paquets spécifiques à l'aide de l'outil en ligne de commande tshark de Wireshark. Les exercices ont couvert la sélection de champs avec l'option -e, la mise en forme de la sortie avec -T fields et la sauvegarde des résultats dans des fichiers pour analyse.

Vous avez également pratiqué la combinaison de plusieurs champs tels que frame.number, ip.src et tcp.port pour obtenir des sorties structurées. Ces techniques permettent de transformer efficacement les données brutes de paquets en formats organisés adaptés au dépannage réseau.