Profiler les performances de Tshark

Introduction

Dans ce laboratoire, vous apprendrez à évaluer et à analyser les performances de l'outil en ligne de commande tshark de Wireshark en utilisant des mesures de temps et des techniques de traitement de paquets. Vous allez explorer l'activation de statistiques de temps détaillées avec --print-timers, le traitement de fichiers de capture et l'interprétation de la sortie JSON pour comprendre les différentes phases de traitement.

Grâce à des exercices pratiques, vous allez vous entraîner à mesurer les temps de traitement, à filtrer des types de trafic spécifiques et à analyser les indicateurs de performance. Le laboratoire offre une expérience pratique avec les commandes tshark pour compter les paquets et examiner le trafic DHCP tout en évaluant les performances de Wireshark.

Skills Graph

Activer les compteurs de temps avec --print-timers

Dans cette étape, nous allons explorer comment mesurer les performances du traitement des paquets de Wireshark en utilisant l'option --print-timers. Cela est particulièrement utile lorsque vous souhaitez comprendre où Tshark passe la majeure partie de son temps lors de l'analyse du trafic réseau.

Avant de commencer, assurons-nous que nous sommes dans le bon répertoire de travail. Cela garantit que toutes nos commandes fonctionneront avec les chemins de fichiers attendus :

cd ~/project

L'option --print-timers indique à Tshark de suivre et de rapporter combien de temps il passe à effectuer différentes tâches lors du traitement des paquets. Essayons-le avec une capture d'échantillon de trafic DHCP fournie avec Wireshark :

tshark --print-timers -r /usr/share/wireshark/example_captures/dhcp.pcap

Après avoir exécuté cette commande, vous verrez une sortie similaire à :

Timer 1: 0.000000 seconds
Timer 2: 0.000123 seconds
...

Ces compteurs de temps représentent différentes étapes du traitement des paquets. Pour nous concentrer sur un seul compteur de temps spécifique, nous pouvons utiliser grep pour filtrer la sortie. Par exemple, pour voir uniquement les résultats du Compteur 1 :

tshark --print-timers -r /usr/share/wireshark/example_captures/dhcp.pcap | grep "Timer 1"

Voici ce que chaque compteur de temps principal mesure généralement :

• Compteur 1 : Temps passé à lire le fichier de capture depuis le disque
• Compteur 2 : Temps passé à traiter et à décoder les paquets
• Compteur 3 : Temps passé à appliquer les filtres d'affichage (le cas échéant)

Comprendre ces compteurs de temps permet d'identifier les goulots d'étranglement de performance lors de la manipulation de fichiers de capture volumineux ou de scénarios de filtrage complexes.

Traiter un fichier avec -r capture.pcap

Dans cette étape, vous apprendrez à traiter des fichiers de capture de paquets en utilisant l'outil en ligne de commande tshark de Wireshark avec l'option -r. Cela est essentiel pour analyser le trafic réseau enregistré au préalable dans des fichiers .pcap, qui sont des fichiers binaires contenant des paquets réseau capturés.

1. Tout d'abord, assurez-vous que vous êtes dans le bon répertoire de travail. Cela est important car certaines commandes peuvent attendre que les fichiers se trouvent à des emplacements spécifiques :

   cd ~/project

2. Examinons un fichier de capture DHCP d'exemple fourni avec l'installation de Wireshark. DHCP (Dynamic Host Configuration Protocol - Protocole de configuration dynamique d'hôte) est un protocole réseau utilisé pour attribuer automatiquement des adresses IP aux appareils. Le drapeau -r indique à tshark de lire à partir du fichier spécifié :

   tshark -r /usr/share/wireshark/example_captures/dhcp.pcap

3. La sortie affiche chaque paquet avec des informations de base sous forme de colonnes :

   • Numéro de paquet
   • Horodatage (en secondes depuis le début de la capture)
   • Adresses IP source → destination
   • Protocole (DHCP dans ce cas)
   • Longueur du paquet
   • Informations spécifiques au protocole

   1 0.000000 192.168.0.1 → 192.168.0.10 DHCP 342 DHCP Discover - Transaction ID 0x7c3e0c29
   2 0.023512 192.168.0.10 → 192.168.0.1 DHCP 342 DHCP Offer - Transaction ID 0x7c3e0c29
   ...

4. Pour compter le nombre total de paquets dans le fichier de capture, nous redirigeons (|) la sortie de tshark vers wc -l qui compte le nombre de lignes. Chaque paquet est affiché sur une ligne :

   tshark -r /usr/share/wireshark/example_captures/dhcp.pcap | wc -l

5. Pour une analyse plus approfondie, nous pouvons utiliser le drapeau -V (verbeux) pour afficher tous les détails disponibles sur les paquets. Étant donné que cela produit beaucoup de sortie, nous utilisons head -20 pour afficher seulement les 20 premières lignes :

   tshark -r /usr/share/wireshark/example_captures/dhcp.pcap -V | head -20

Filtrer le trafic TCP avec -Y "tcp"

Dans cette étape, vous apprendrez à filtrer le trafic TCP en utilisant l'option de filtre d'affichage -Y de Wireshark. TCP (Transmission Control Protocol - Protocole de contrôle de transmission) est l'un des protocoles de base de la communication réseau, chargé de la livraison fiable des données. Le filtre -Y permet d'isoler les paquets TCP du reste du trafic réseau, ce qui est essentiel lors de l'analyse de la navigation web, des transferts de fichiers ou d'autres applications basées sur TCP.

1. Tout d'abord, assurez-vous que vous êtes dans le bon répertoire de travail. Cela est important car certaines commandes peuvent dépendre de chemins de fichiers relatifs :

   cd ~/project

2. Appliquons maintenant un filtre TCP de base à notre fichier de capture d'exemple. Le drapeau -r spécifie le fichier d'entrée, tandis que -Y "tcp" indique à tshark de n'afficher que les paquets TCP :

   tshark -r /usr/share/wireshark/example_captures/http.pcap -Y "tcp"

3. La sortie affichera uniquement les paquets TCP, montrant l'échange de paquets de synchronisation (SYN, SYN-ACK) et les transferts de données suivants. Chaque ligne représente un paquet TCP avec son numéro de séquence, sa taille de fenêtre et ses indicateurs :

   1 0.000000 192.168.1.100 → 192.168.1.1 TCP 74 49278 → 80 [SYN] Seq=0 Win=64240 Len=0
   2 0.000042 192.168.1.1 → 192.168.1.100 TCP 74 80 → 49278 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0
   ...

4. Si vous souhaitez simplement compter le nombre de paquets TCP dans la capture, vous pouvez rediriger la sortie vers wc -l. Cela est utile pour obtenir rapidement des statistiques :

   tshark -r /usr/share/wireshark/example_captures/http.pcap -Y "tcp" | wc -l

5. Pour une analyse plus ciblée, vous pouvez filtrer le trafic TCP sur des ports spécifiques. Cet exemple montre uniquement le trafic sur le port 80 (HTTP). Notez que nous utilisons tcp.port au lieu de simplement tcp pour spécifier le numéro de port :

   tshark -r /usr/share/wireshark/example_captures/http.pcap -Y "tcp.port == 80"

Analyser la sortie de chronométrage au format JSON

Dans cette étape, nous allons examiner comment Wireshark enregistre les informations de chronométrage au format JSON. JSON (JavaScript Object Notation - Notation d'objet JavaScript) est un format de données léger, facile à lire pour les humains et à analyser pour les machines. Nous allons combiner les compétences en capture et filtrage de paquets des étapes précédentes pour générer des statistiques de chronométrage significatives.

Avant de commencer, assurons-nous que nous sommes dans le bon répertoire. Le dossier du projet contient tous les fichiers nécessaires et organisera notre travail :

cd ~/project

Maintenant, nous allons générer des données de chronométrage spécifiquement pour les paquets TCP. Le drapeau --print-timers indique à Tshark d'inclure les informations de chronométrage dans sa sortie, tandis que -T json la formate au format JSON. Nous enregistrons cela dans un fichier pour une analyse ultérieure :

tshark -r /usr/share/wireshark/example_captures/http.pcap -Y "tcp" --print-timers -T json > tcp_timings.json

Jetons rapidement un coup d'œil à la structure de notre sortie JSON. La commande head nous montre les 20 premières lignes, ce qui nous aide à comprendre comment les données sont organisées avant de les traiter plus en détail :

head -20 tcp_timings.json

Pour travailler efficacement avec les données JSON, nous allons utiliser jq, un puissant processeur JSON en ligne de commande. Si vous ne l'avez pas encore installé, cette commande l'installera :

sudo apt-get install -y jq

Maintenant, nous pouvons extraire des métriques de chronométrage spécifiques. Cette commande filtre le JSON pour afficher uniquement les informations de chronométrage pour chaque paquet, nous donnant une vue plus claire des données de chronométrage :

jq '.[].timers' tcp_timings.json | head -10

Enfin, créons un résumé plus ciblé qui affiche uniquement les numéros de paquets et leurs temps de traitement correspondants. Cela nous donne une vue claire du temps que chaque paquet a pris à être traité :

jq '.[].timers | {packet_number: .packet_num, processing_time: .processing_time}' tcp_timings.json | head -5

Résumé

Dans ce laboratoire, vous avez appris à évaluer les performances de Tshark en utilisant l'option --print-timers pour analyser les phases de traitement telles que la lecture de fichiers et le traitement des paquets. Les exercices ont montré comment interpréter les statistiques de chronométrage pour optimiser les flux de travail d'analyse réseau.

Vous avez également pratiqué des techniques essentielles d'analyse de paquets, notamment le traitement de fichiers de capture avec -r, l'examen du contenu des paquets et l'utilisation du mode verbeux. Le laboratoire a offert une expérience pratique avec les fichiers d'exemple de Wireshark pour développer les compétences de base en analyse du trafic réseau.