Gérer les fichiers volumineux dans Tshark

Introduction

Dans ce laboratoire, vous apprendrez des techniques efficaces pour traiter de grands fichiers de capture de paquets à l'aide de l'outil en ligne de commande tshark de Wireshark. Vous allez pratiquer l'ouverture de fichiers PCAP avec -r, la limitation du nombre de paquets avec -c, le filtrage du trafic à l'aide de -Y et l'exportation de sous-ensembles avec -w.

Grâce à des exercices pratiques, vous maîtriserez la manipulation de grands ensembles de données en appliquant des limites de paquets, des filtres de protocole et une segmentation de fichiers. Ces compétences sont essentielles pour les scénarios de dépannage réseau nécessitant une optimisation des ressources et une extraction précise des données.

Ouvrir un fichier avec -r large.pcap

Dans cette étape, vous apprendrez à ouvrir et à examiner un fichier de capture de paquets (PCAP) à l'aide de l'interface en ligne de commande de Wireshark appelée tshark. Les fichiers PCAP contiennent des données de trafic réseau capturées à partir d'une interface réseau. L'option -r signifie "read" (lire) et indique à tshark quel fichier traiter.

Tout d'abord, nous devons nous déplacer dans le répertoire contenant notre fichier de capture de paquets. Dans le terminal, exécutez :
```
cd ~/project
```
Cela change votre répertoire de travail vers celui où le fichier large.pcap est stocké. Il est important d'être dans le bon répertoire pour que tshark puisse trouver le fichier.
Maintenant, ouvrons et affichons le contenu de large.pcap en utilisant :
```
tshark -r large.pcap
```
Cette commande lit le fichier et affiche les données des paquets dans votre terminal. Chaque ligne représente un paquet réseau capturé.
La sortie affiche plusieurs colonnes importantes d'informations pour chaque paquet :
- Numéro de paquet : Le numéro de séquence du paquet dans la capture
- Horodatage : Lorsque le paquet a été capturé
- Adresses IP source et destination : D'où vient le paquet et où il va
- Protocole : Le protocole réseau utilisé (comme TCP, UDP, HTTP)
- Longueur : La taille du paquet en octets
- Informations : Détails supplémentaires sur le contenu du paquet
Étant donné que les grands fichiers PCAP peuvent générer beaucoup de sortie, vous pouvez faciliter la lecture en utilisant le pipe (|) avec less :
```
tshark -r large.pcap | less
```
Cela vous permet de parcourir la sortie page par page en utilisant les touches fléchées. Appuyez sur q lorsque vous souhaitez quitter le visualiseur et revenir à l'invite de commande.

Limiter le traitement avec -c 10000

Dans cette étape, nous allons explorer comment contrôler la quantité de données traitées à partir de grands fichiers de capture de paquets. Lorsque vous travaillez sur l'analyse réseau, vous rencontrerez souvent des fichiers PCAP très volumineux qui peuvent contenir des millions de paquets. Traiter tous ces paquets d'un coup peut être long et consommer beaucoup de ressources. C'est là que l'option -c de tshark devient précieuse.

Le flag -c vous permet de spécifier exactement combien de paquets vous souhaitez traiter à partir du début du fichier. Cela est particulièrement utile lorsque vous testez simplement votre approche d'analyse ou lorsque vous n'avez besoin d'examiner qu'un échantillon représentatif du trafic.

Tout d'abord, assurons-nous que nous sommes dans le bon répertoire de travail où se trouve notre fichier de capture :
```
cd ~/project
```
Maintenant, nous allons traiter seulement les 10 000 premiers paquets de notre fichier large.pcap. La structure de la commande est simple : spécifiez le fichier d'entrée avec -r et la limite du nombre de paquets avec -c :
```
tshark -r large.pcap -c 10000
```
Lorsque la commande est terminée, vous verrez une confirmation indiquant que exactement 10 000 paquets ont été traités. La sortie indiquera clairement :
```
10000 packets captured
```
Étant donné que même 10 000 paquets peuvent générer une sortie importante, nous pouvons rediriger les résultats vers less pour une visualisation plus facile. Cela vous permet de parcourir la sortie page par page :
```
tshark -r large.pcap -c 10000 | less
```
Les scénarios pratiques où limiter le traitement des paquets est avantageux incluent :
- Analyser rapidement de grands fichiers sans attendre le traitement complet
- Vérifier que votre syntaxe de filtre fonctionne correctement avant de l'appliquer à l'ensemble du fichier
- Économiser les ressources système lorsque vous n'avez besoin que d'un échantillon du trafic
- Tester des scripts d'analyse sur un ensemble de données gérable avant de passer à l'échelle supérieure

Filtrer le trafic IP avec -Y "ip"

Dans cette étape, nous allons nous concentrer sur le filtrage du trafic réseau pour afficher uniquement les paquets IP en utilisant l'option de filtre d'affichage puissante -Y de Tshark. Cela est particulièrement utile lorsque vous travaillez avec de grands fichiers de capture où vous avez besoin d'isoler rapidement le trafic d'un protocole spécifique.

Tout d'abord, naviguons jusqu'au répertoire du projet où se trouve notre fichier de capture. Cela garantit que nous travaillons avec le bon fichier :
```
cd ~/project
```
Maintenant, nous allons utiliser le filtre -Y pour afficher uniquement le trafic IP de notre fichier de capture. La commande ci-dessous lit le fichier 'large.pcap' et applique notre filtre :
```
tshark -r large.pcap -Y "ip"
```
Après avoir exécuté cette commande, vous remarquerez que la sortie n'affiche que les paquets qui répondent à ces critères :
- Utilisent soit le protocole IPv4, soit le protocole IPv6
- Contiennent des en-têtes IP appropriés dans leur structure
- Excluent le trafic non-IP tel que le protocole ARP (Address Resolution Protocol) ou le protocole STP (Spanning Tree Protocol)
Pour mieux gérer les grands fichiers, nous pouvons combiner ce filtre avec d'autres options que nous avons apprises. Cet exemple limite le traitement à 10 000 paquets et redirige la sortie vers less pour une visualisation plus facile :
```
tshark -r large.pcap -c 10000 -Y "ip" | less
```
Le filtre -Y utilise la syntaxe de filtre d'affichage de Wireshark, qui offre de nombreuses possibilités, notamment :
- Filtrage basé sur le protocole (ip, tcp, udp)
- Filtrage par adresse source/destination (ip.src, ip.dst)
- Filtrage par numéro de port (tcp.port, udp.port)

Sauvegarder un sous-ensemble avec -w small.pcap

Dans cette étape, vous allez apprendre à extraire et sauvegarder une partie spécifique du trafic réseau à partir d'un grand fichier de capture. Cela est particulièrement utile lorsque vous travaillez avec des fichiers PCAP massifs qui seraient trop gourmands en ressources à analyser dans leur intégralité.

Tout d'abord, naviguez jusqu'au répertoire du projet où se trouvent vos fichiers de capture. Cela garantit que toutes les opérations de fichiers se déroulent au bon endroit :
```
cd ~/project
```
La commande suivante montre comment combiner plusieurs fonctionnalités de Tshark pour créer un fichier de sous-ensemble gérable. Ici, nous lisons le fichier 'large.pcap', mais nous ne conservons que les 10 000 premiers paquets IP :
```
tshark -r large.pcap -c 10000 -Y "ip" -w small.pcap
```
Décortiquons cette commande :
- -r large.pcap spécifie le fichier d'entrée
- -c 10000 limite le traitement aux 10 000 premiers paquets
- -Y "ip" applique un filtre d'affichage pour n'inclure que le trafic IP
- -w small.pcap écrit les résultats filtrés dans un nouveau fichier
Après avoir exécuté la commande, vérifiez que le fichier de sortie a été créé avec succès. La commande ls avec les options -lh affiche la taille du fichier au format lisible par l'homme (comme KB/MB) ainsi que d'autres détails :
```
ls -lh small.pcap
```
Maintenant, vous pouvez travailler plus efficacement avec ce fichier filtré et plus petit. Pour afficher son contenu, redirigez la sortie vers less, qui permet de faire défiler les paquets :
```
tshark -r small.pcap | less
```
Cela est beaucoup plus rapide que de traiter le fichier original volumineux, tout en ne contenant que le trafic IP que vous avez spécifié.

Résumé

Dans ce laboratoire, vous avez appris les techniques clés pour traiter efficacement de grands fichiers de capture de paquets à l'aide de l'outil en ligne de commande tshark de Wireshark. Vous avez pratiqué l'ouverture de fichiers avec -r, la limitation du nombre de paquets via -c, l'application de filtres d'affichage avec -Y et l'exportation de sous-ensembles à l'aide de -w pour gérer efficacement de grands ensembles de données.

Les exercices ont démontré des compétences pratiques pour l'analyse en terminal, notamment la navigation dans la sortie avec less et l'extraction ciblée de paquets. Ces capacités sont essentielles pour les professionnels du réseau qui travaillent avec des captures de trafic volumineuses tout en optimisant l'utilisation des ressources système.