Introduction
Dans ce laboratoire, vous apprendrez à capturer et analyser le trafic réseau à l'aide d'outils en ligne de commande en redirigeant la sortie de Tshark vers d'autres utilitaires. Vous allez pratiquer la capture de paquets sur l'interface eth1 avec tcpdump, le filtrage des messages d'erreur à l'aide de grep et le comptage des correspondances avec wc -l.
Le laboratoire se concentre sur des techniques pratiques de dépannage réseau, y compris la sauvegarde des captures au format pcap pour une analyse ultérieure. Vous apprendrez à vérifier les interfaces, à appliquer des filtres et à rationaliser les flux de travail d'analyse de paquets grâce aux pipes Unix et aux opérations sur les fichiers.
Capturer le trafic avec -i eth1
Dans cette étape, vous apprendrez à capturer le trafic réseau sur l'interface eth1 à l'aide de commandes Linux de base. L'interface eth1 est généralement l'interface réseau principale dans les systèmes Linux, représentant la première connexion Ethernet de votre machine.
Avant de capturer le trafic, il est important de vérifier que l'interface existe et est active. Les interfaces réseau peuvent être physiques (comme les ports Ethernet) ou virtuelles (comme les connexions VPN). Exécutez cette commande pour vérifier l'état de votre interface eth1 :
ip link show eth1
Vous devriez voir une sortie similaire à :
2: eth1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP mode DEFAULT group default qlen 1000
link/ether 00:16:3e:5e:6c:00 brd ff:ff:ff:ff:ff:ff
Le statut UP indique que l'interface est active. Maintenant, nous allons utiliser tcpdump, un outil de base pour l'analyse réseau qui vous permet de voir le trafic en temps réel. Cette commande de capture de base vous aidera à comprendre ce qui se passe sur votre réseau :
sudo tcpdump -i eth1 -c 5
Décortiquons ce que fait cette commande :
-i eth1: Spécifie quelle interface réseau surveiller (eth1 dans ce cas)-c 5: Limite la capture à 5 paquets, ce qui est suffisant pour la démonstration sans inonder votre terminal
La sortie montrera les détails des paquets, y compris les horodatages, les adresses IP source/destination et les informations de protocole :
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on eth1, link-type EN10MB (Ethernet), capture size 262144 bytes
12:34:56.789012 IP 192.168.1.100.22 > 192.168.1.1.12345: Flags [P.], seq 1:21, ack 1, win 501, length 20
12:34:56.789123 IP 192.168.1.1.12345 > 192.168.1.100.22: Flags [.], ack 21, win 1024, length 0
...
5 packets captured
5 packets received by filter
0 packets dropped by kernel
Pour une analyse plus détaillée, vous voudrez enregistrer les paquets dans un fichier. Les fichiers PCAP conservent toutes les données des paquets et peuvent être ouverts dans des outils graphiques comme Wireshark. Cette commande crée un fichier de capture :
sudo tcpdump -i eth1 -c 5 -w ~/project/eth1_capture.pcap
Le flag -w écrit les paquets dans le fichier eth1_capture.pcap dans votre répertoire de projet. Ce format binaire conserve toutes les informations originales des paquets telles qu'elles ont été capturées.
Filtrer les erreurs avec | grep "ERROR"
Dans cette étape, vous apprendrez à filtrer le trafic réseau pour les messages d'erreur à l'aide de la commande grep. Cela est particulièrement utile lors de l'analyse de grandes captures de paquets lorsque vous ne voulez voir que les paquets contenant des erreurs. L'opérateur pipe (|) dans Linux vous permet de prendre la sortie d'une commande et de l'utiliser comme entrée pour une autre commande, créant ainsi des flux de travail d'analyse puissants.
Tout d'abord, examinons le fichier de capture que nous avons créé à l'étape précédente. Exécutez la commande suivante pour afficher le contenu du fichier pcap au format texte. Cela convertit les données binaires des paquets en un format lisible par l'homme :
tcpdump -r ~/project/eth1_capture.pcap
Maintenant, créons un fichier journal d'exemple contenant à la fois des messages normaux et des messages d'erreur à des fins de démonstration. Cela nous aidera à comprendre le fonctionnement de grep avant de l'appliquer au trafic réseau réel :
echo -e "INFO: Connection established\nERROR: Authentication failed\nINFO: Data transfer complete\nERROR: Connection timeout" > ~/project/network.log
Pour filtrer uniquement les messages d'erreur de ce fichier journal, nous allons utiliser grep avec le motif "ERROR". grep recherche dans le texte ligne par ligne et n'imprime que les lignes qui correspondent au motif :
grep "ERROR" ~/project/network.log
Vous devriez voir une sortie ne contenant que les lignes d'erreur :
ERROR: Authentication failed
ERROR: Connection timeout
Maintenant, appliquons cela à notre capture de paquets réelle. Tout d'abord, nous devons convertir le fichier pcap au format texte lisible car grep fonctionne avec des fichiers texte. Cela crée une version texte de notre capture de paquets :
tcpdump -r ~/project/eth1_capture.pcap > ~/project/packets.txt
Ensuite, filtrons les messages d'erreur dans les données de paquets converties. Nous utilisons le flag -i pour rendre la recherche insensible à la casse, ce qui signifie qu'elle correspondra à "error", "ERROR" ou toute autre capitalisation :
grep -i "error" ~/project/packets.txt
Le flag -i rend la recherche insensible à la casse. Si des paquets contiennent "error" (en toutes capitalisations), ils seront affichés. Cela permet de s'assurer que nous ne manquons aucun message d'erreur en raison de différentes capitalisations dans les protocoles réseau.
Compter les correspondances avec | wc -l
Dans cette étape, nous apprendrons à quantifier les erreurs réseau en comptant les lignes correspondantes à l'aide de la commande wc -l. Cette technique aide les administrateurs réseau à comprendre la fréquence des erreurs dans le trafic capturé.
Avant de compter, revoyons tout d'abord les messages d'erreur que nous avons identifiés précédemment. La commande suivante affiche toutes les lignes contenant "error" (insensible à la casse) de notre fichier de capture de paquets :
grep -i "error" ~/project/packets.txt
Pour compter ces occurrences d'erreur plutôt que de les afficher, nous utiliserons un pipe (|) pour envoyer la sortie de grep à wc -l. La commande wc compte les mots, les lignes ou les caractères, et l'option -l compte spécifiquement les lignes :
grep -i "error" ~/project/packets.txt | wc -l
La commande affiche un simple nombre représentant le nombre de messages d'erreur trouvés :
2
Pour avoir un contexte, comptons également le nombre total de paquets dans notre fichier de capture. Cela nous aide à comprendre quelle proportion du trafic contient des erreurs :
wc -l ~/project/packets.txt
La sortie affiche à la fois le nombre et le nom du fichier :
50 packets.txt
Pour calculer le taux d'erreur en pourcentage, nous utiliserons des opérations arithmétiques de base en shell. Tout d'abord, nous stockons le nombre d'erreurs et le nombre total de paquets dans des variables, puis nous effectuons le calcul à l'aide de bc (un programme de calculatrice de base) :
errors=$(grep -i "error" ~/project/packets.txt | wc -l)
total=$(wc -l < ~/project/packets.txt)
echo "scale=2; ($errors/$total)*100" | bc
Le paramètre scale=2 indique à bc d'afficher deux décimales dans le résultat :
4.00
Enregistrer dans un fichier avec > output.txt
Dans cette étape, nous allons explorer comment sauvegarder les résultats d'analyse réseau dans des fichiers pour la documentation et une analyse plus approfondie. Lorsque vous travaillez avec la sortie de Tshark, il est souvent utile de stocker les données filtrées séparément plutôt que de simplement les afficher dans le terminal.
Tout d'abord, rappelons la commande que nous avons utilisée précédemment pour compter les occurrences d'erreur dans notre capture de paquets :
grep -i "error" ~/project/packets.txt | wc -l
L'opérateur > dans Linux nous permet de rediriger la sortie d'une commande vers un fichier au lieu de l'afficher à l'écran. Pour sauvegarder uniquement le nombre de comptage des erreurs dans un nouveau fichier appelé error_count.txt, nous modifions notre commande comme suit :
grep -i "error" ~/project/packets.txt | wc -l > ~/project/error_count.txt
Après avoir exécuté cela, vous pouvez vérifier que le fichier contient exactement ce que nous attendons - seulement le nombre de comptage des erreurs :
cat ~/project/error_count.txt
Parfois, nous avons besoin de plus que de simples comptages - nous voulons les messages d'erreur réels pour l'analyse. Pour sauvegarder toutes les lignes d'erreur correspondantes dans un fichier, nous supprimons la partie de comptage des mots :
grep -i "error" ~/project/packets.txt > ~/project/error_messages.txt
Vérifiez le contenu pour confirmer que tous les messages d'erreur ont été capturés :
cat ~/project/error_messages.txt
Pour une surveillance continue, nous pouvons vouloir ajouter à des fichiers existants plutôt que de les écraser. L'opérateur >> ajoute au fichier. Voici comment créer un rapport d'erreur avec horodatage :
echo "Error count at $(date):" >> ~/project/error_report.txt
grep -i "error" ~/project/packets.txt | wc -l >> ~/project/error_report.txt
Affichez votre fichier de rapport en croissance pour voir les données accumulées :
cat ~/project/error_report.txt
Résumé
Dans ce laboratoire, vous avez appris des techniques pratiques de capture et d'analyse de trafic réseau à l'aide d'outils en ligne de commande. Les exercices ont couvert la capture de paquets avec tcpdump, la vérification des interfaces à l'aide de ip link show et la création de fichiers PCAP pour une analyse hors ligne.
Vous avez également exploré des méthodes de traitement de données efficaces grâce aux opérations de piping, notamment le filtrage des erreurs avec grep, le comptage des correspondances via wc -l et la redirection de la sortie vers des fichiers texte. Ces compétences permettent d'extraire de manière ciblée des informations réseau pour un dépannage efficace.
