Déboguer avec des journaux dans Tshark

Introduction

Dans ce laboratoire, vous apprendrez les techniques essentielles de débogage en utilisant l'outil en ligne de commande Tshark de Wireshark. Vous explorerez comment définir les niveaux de débogage avec --log-level, capturer le trafic en direct sur eth1 en utilisant -i, et enregistrer les journaux dans des fichiers avec --log-file pour analyse.

Grâce à des exercices pratiques, vous allez vous entraîner à configurer les modes de débogage, surveiller le trafic réseau et interpréter les sorties des journaux. Ce laboratoire offre une expérience pratique des fonctionnalités de base de débogage de Tshark dans un environnement de machine virtuelle contrôlé.

Skills Graph

Définir le niveau de débogage avec --log-level debug

Dans cette étape, vous apprendrez à ajuster le niveau de détail des messages de journal lors de l'utilisation de l'outil en ligne de commande tshark de Wireshark. Le paramètre --log-level permet de contrôler la quantité d'informations affichées par tshark, ce qui est particulièrement utile lorsque vous avez besoin de comprendre ce qui se passe en coulisse ou de résoudre des problèmes.

1. Tout d'abord, préparons notre environnement de travail. Ouvrez un terminal dans votre machine virtuelle LabEx. Nous travaillerons dans le répertoire de projet par défaut pour garder tout organisé :

   cd ~/project

2. La structure de base de la commande pour définir les niveaux de journal est simple. Vous spécifiez simplement le niveau souhaité après le paramètre :

   tshark --log-level <level>

   Voici les niveaux de journal les plus couramment utilisés, classés du moins au plus détaillé :

   • critical - N'affiche que les erreurs graves qui pourraient empêcher tshark de fonctionner
   • warning - Affiche les problèmes potentiels qui ne sont pas critiques mais méritent d'être notés
   • message - Le niveau par défaut qui affiche les messages de fonctionnement normaux
   • info - Fournit des messages d'information supplémentaires sur les activités de tshark
   • debug - Affiche les informations techniques les plus détaillées pour une résolution approfondie des problèmes

3. Pour cet exercice, nous utiliserons le niveau debug pour voir le maximum d'informations. Cela nous aidera à comprendre toutes les opérations en coulisse de tshark. Exécutez cette commande :

   tshark --log-level debug

4. Après avoir exécuté la commande, vous remarquerez beaucoup plus de sortie que d'habitude. Cette sortie de débogage inclut des détails d'initialisation, des messages de traitement interne et des informations techniques sur la façon dont tshark gère le trafic réseau.

5. Lorsque vous êtes prêt à arrêter tshark, appuyez simplement sur Ctrl+C dans le terminal. Ce raccourci clavier envoie un signal d'interruption pour arrêter la commande en cours d'exécution.

Capturer le trafic avec -i eth1

Dans cette étape, nous allons explorer comment capturer le trafic réseau en direct en utilisant l'outil en ligne de commande puissant tshark de Wireshark. Les interfaces réseau sont les points physiques ou virtuels par lesquels votre ordinateur se connecte à un réseau, et eth1 est généralement la première interface Ethernet dans les systèmes Linux.

1. Tout d'abord, identifions les interfaces réseau disponibles sur votre machine virtuelle LabEx. Cela permet de nous assurer que nous surveillons la bonne interface :

   tshark -D

   Cette commande répertorie toutes les interfaces réseau accessibles par tshark. Recherchez eth1 dans la sortie - il s'agit généralement de votre connexion Ethernet principale.

2. Maintenant, nous allons commencer à capturer le trafic réseau réel. Le paramètre -i indique à tshark quelle interface surveiller :

   tshark -i eth1

3. Au fur et à mesure que les paquets circulent sur votre réseau, vous les verrez s'afficher en temps réel. Chaque ligne représente un paquet réseau et affiche :

   • L'heure exacte à laquelle il a été capturé (horodatage)
   • D'où il vient et où il va (adresses IP)
   • Le type de communication réseau qu'il contient (protocole)
   • La quantité de données qu'il transporte (longueur du paquet)

4. Laissez la capture s'exécuter pendant environ 10 secondes pour collecter un échantillon représentatif du trafic. Lorsque vous êtes prêt, appuyez sur Ctrl+C pour arrêter la capture. Cela vous offre une expérience pratique de capture de paquets en direct.

5. Parfois, vous pouvez vouloir capturer un nombre spécifique de paquets. Le paramètre -c vous permet de définir cette limite :

   tshark -i eth1 -c 10

   Cette commande s'arrêtera automatiquement après avoir capturé exactement 10 paquets, ce qui est utile pour des tests rapides.

6. Vous pouvez combiner cela avec le débogage pour obtenir des informations plus détaillées sur le processus de capture :

   tshark -i eth1 --log-level debug

   Cela affiche non seulement les paquets, mais aussi les opérations internes de tshark, vous aidant à comprendre ce qui se passe en coulisse.

Enregistrer les journaux dans un fichier avec --log-file tshark.log

Dans cette étape, vous apprendrez à enregistrer les journaux de capture de tshark dans un fichier pour une analyse ultérieure en utilisant l'option --log-file. Cela est particulièrement utile lorsque vous avez besoin de documenter les modèles de trafic réseau ou de résoudre des problèmes de connectivité, car cela vous permet de consulter les données à votre convenance plutôt que de regarder la sortie en temps réel.

1. Tout d'abord, assurez-vous d'être dans le répertoire de travail par défaut. Cela est important car le fichier journal sera créé dans votre répertoire actuel :

   cd ~/project

2. Pour commencer à capturer le trafic réseau et enregistrer simultanément tous les journaux dans un fichier nommé tshark.log, exécutez cette commande. Le -i eth1 spécifie que nous capturons depuis l'interface Ethernet :

   tshark -i eth1 --log-file tshark.log

3. Laissez la capture s'exécuter pendant environ 10 secondes pour collecter des données suffisantes, puis appuyez sur Ctrl+C pour arrêter proprement le processus de capture. Cet interruption clavier garantit que le fichier journal est correctement fermé.

4. Vérifiez que le fichier journal a été créé avec succès en listant le contenu du répertoire. Le paramètre -l affiche des informations détaillées sur le fichier, notamment la taille et l'horodatage :

   ls -l tshark.log

   Vous devriez voir le fichier répertorié avec sa taille et son heure de création, confirmant que la capture a fonctionné comme prévu.

5. Affichez le contenu du fichier journal pour examiner les paquets capturés. La commande cat affiche tout le contenu du fichier dans votre terminal :

   cat tshark.log

   La sortie affichera les paquets capturés dans un format lisible, y compris les horodatages, les adresses source/destination et les informations de protocole.

6. Pour un exemple plus complet combinant les étapes précédentes, essayez cette commande améliorée qui inclut plusieurs paramètres utiles :

   tshark -i eth1 --log-level debug --log-file tshark.log -c 20

   Cette commande complète permettra de :

   • Capturer des paquets spécifiquement depuis l'interface réseau eth1
   • Régler le niveau de journalisation sur le mode débogage pour obtenir le maximum de détails
   • Enregistrer toute la sortie dans le fichier tshark.log
   • S'arrêter automatiquement après avoir capturé exactement 20 paquets

Vérifier les journaux pour détecter les erreurs

Dans cette étape, vous allez analyser le fichier journal tshark créé à l'étape précédente pour identifier les problèmes potentiels et les erreurs réseau. Cette compétence est essentielle pour la résolution de problèmes réseau, car les journaux fournissent des enregistrements détaillés de l'activité réseau et des problèmes potentiels.

1. Tout d'abord, accédez à votre répertoire de projet si vous n'y êtes pas déjà. Cela garantit que vous travaillez avec le bon fichier journal :

   cd ~/project

2. Affichez le contenu complet du fichier journal pour avoir une vue d'ensemble du trafic réseau capturé. La commande cat affiche tout le contenu du fichier dans votre terminal :

   cat tshark.log

3. Pour rechercher spécifiquement les messages d'erreur dans le journal, utilisez grep avec une correspondance insensible à la casse (option -i). Cela permet de trouver toutes les entrées d'erreur, quelle que soit la casse :

   grep -i "error" tshark.log

4. Pour une analyse plus complète, recherchez plusieurs types de problèmes, notamment les avertissements et les échecs. L'option -E active les expressions régulières étendues :

   grep -E -i "error|warning|fail" tshark.log

5. Pour quantifier le nombre d'occurrences d'erreur, redirigez la sortie de grep vers la commande de comptage de mots (wc) avec l'option de comptage de lignes (-l). Cela vous donne rapidement une idée du nombre d'erreurs enregistrées :

   grep -i "error" tshark.log | wc -l

6. Pour avoir une vue plus structurée des erreurs au niveau des paquets, utilisez le filtre d'affichage (-Y) de tshark pour afficher uniquement les trames avec des indicateurs d'erreur. Cela permet d'identifier les paquets problématiques dans votre capture :

   tshark -r tshark.log -Y "frame.error_flag == 1"

7. Pour enregistrer uniquement les messages d'erreur pour une analyse ou un rapport ultérieur, redirigez la sortie de grep vers un nouveau fichier. Cela crée un journal propre ne contenant que les erreurs :

   grep -i "error" tshark.log > errors.txt

Résumé

Dans ce laboratoire (lab), vous avez appris des techniques pratiques d'analyse de trafic réseau en utilisant l'outil en ligne de commande tshark de Wireshark. Vous avez exploré la configuration des niveaux de débogage avec --log-level debug pour obtenir des messages opérationnels détaillés, ce qui est essentiel pour résoudre des problèmes réseau complexes.

De plus, vous avez pratiqué la capture de trafic en direct sur l'interface eth1 en identifiant les interfaces disponibles et en analysant les données de paquets en temps réel. Ces compétences fondamentales permettent une surveillance efficace du réseau et un diagnostic des problèmes dans les environnements en ligne de commande.