Limiter la Taille de Capture avec Tshark

Introduction

Dans ce laboratoire, vous apprendrez à contrôler la taille de la capture de paquets dans Wireshark à l'aide des commandes Tshark. Vous explorerez deux techniques essentielles : la limitation du nombre total de paquets avec -c 500 et la restriction de la longueur des paquets avec -s 128 pour ne capturer que les en-têtes et économiser de l'espace de stockage.

Grâce à des exercices pratiques sur l'interface eth1, vous capturerez le trafic dans limited.pcap et observerez comment différents paramètres affectent vos captures. Cette expérience pratique vous aidera à optimiser la collecte de paquets pour divers scénarios d'analyse.

Définir le Nombre de Paquets avec -c 500

Dans cette étape, vous apprendrez à contrôler la durée de la capture de paquets en limitant le nombre de paquets collectés par Tshark. Tshark est la version en ligne de commande de Wireshark, idéale pour les captures automatisées. L'option -c est particulièrement précieuse lorsque vous avez besoin d'un échantillon représentatif du trafic réseau sans surcharger votre système par une capture continue.

Commencez par ouvrir le terminal dans votre machine virtuelle LabEx. Le système vous place automatiquement dans le répertoire de travail correct (~/project), vous pouvez donc commencer immédiatement.
La structure de la commande utilise ce modèle de base :
```
tshark -c [nombre] [autres options]
```
Ici, [nombre] détermine précisément le moment où la capture s'arrête en spécifiant le nombre maximum de paquets à collecter. Cela évite les exécutions indéfinies qui pourraient remplir votre stockage.
Tout d'abord, identifions les interfaces réseau disponibles. Exécutez la commande suivante :
```
tshark -D
```
Vous verrez une liste d'interfaces, similaire à ceci :
```
1. eth0
2. eth1 (Interface fictive)
3. any
4. lo (Boucle locale)
...
```
Nous utiliserons eth1 pour nos captures, car il s'agit d'une interface fictive créée pour ce laboratoire afin de garantir une génération de trafic cohérente.
Capturons 500 paquets comme exercice principal. Exécutez cette commande :
```
tshark -c 500 -i eth1
```
La commande sudo est requise car la capture de paquets nécessite des privilèges administratifs. Cela indique à tshark de surveiller la connexion réseau eth1.
Pour générer du trafic que tshark peut capturer, ouvrez un nouveau terminal (ou divisez le terminal actuel) et exécutez la commande suivante :
```
ping -c 10 google.com
```
Cela enverra 10 paquets ICMP à google.com, créant une activité réseau sur eth1 que tshark peut capturer.

Au fur et à mesure que les paquets circulent, vous verrez une sortie en temps réel dans le terminal tshark. Après exactement 500 paquets, tshark se termine automatiquement. La sortie ressemblera à ceci (bien qu'elle soit beaucoup plus longue pour 500 paquets) :

Capture sur 'eth1'
    1 0.000000000 192.168.X.X -> 142.250.X.X ICMP 84 Demande d'écho (ping)  id=0xXXXX, seq=1/256, ttl=64 (réponse dans 2)
    2 0.000000000 142.250.X.X -> 192.168.X.X ICMP 84 Réponse d'écho (ping) id=0xXXXX, seq=1/256, ttl=117 (demande dans 1)
... (beaucoup plus de lignes)
500 paquets capturés

Avant la capture complète de 500 paquets, testez avec un échantillon plus petit pour comprendre le mécanisme. Ce test de 10 paquets permet de vérifier votre configuration :
```
tshark -c 10 -i eth1
```
N'oubliez pas de générer du trafic dans un autre terminal pendant que cette commande s'exécute.

Définir la Longueur de l'Instantané avec -s 128

Dans cette étape, vous apprendrez à définir la longueur de la capture (snaplen) lors de la capture de paquets à l'aide de l'option -s dans Tshark. Cela détermine la quantité de chaque paquet capturée, 128 octets étant une valeur courante qui capture les en-têtes de paquets tout en économisant de l'espace de stockage. La longueur de la capture est particulièrement utile lorsque vous avez uniquement besoin des en-têtes de paquets pour l'analyse plutôt que le contenu complet du paquet.

Tout d'abord, assurez-vous d'être dans le répertoire de travail par défaut ~/project dans votre terminal. C'est là que nous exécuterons toutes nos commandes de capture pour maintenir l'organisation.
L'option de longueur de capture (-s) limite la quantité de chaque paquet capturée en spécifiant le nombre d'octets à enregistrer. Des valeurs plus petites économisent de l'espace disque mais peuvent manquer des données de charge utile importantes. La syntaxe de base est :
```
tshark -s [longueur] [autres options]
```
Capturons des paquets avec une longueur de capture de 128 octets combinée au nombre de paquets de l'étape précédente. Cette commande capturera les 128 premiers octets de chaque paquet jusqu'à ce qu'elle atteigne 500 paquets :
```
tshark -c 500 -s 128 -i eth1
```
N'oubliez pas de générer du trafic dans un terminal séparé (par exemple, ping -c 10 google.com) pendant que tshark est en cours d'exécution.
Vous verrez une sortie affichant les 128 premiers octets de chaque paquet. La capture s'arrêtera automatiquement après 500 paquets, comme spécifié par l'option -c. Cette combinaison permet de gérer à la fois la taille et la durée de la capture. La sortie sera similaire à l'étape précédente, mais les détails du paquet peuvent être tronqués s'ils dépassent 128 octets.
```
Capture sur 'eth1'
    1 0.000000000 192.168.X.X -> 142.250.X.X ICMP 84 Demande d'écho (ping)  id=0xXXXX, seq=1/256, ttl=64 (réponse dans 2)
... (beaucoup plus de lignes)
500 paquets capturés
```
Pour mieux comprendre comment la longueur de la capture affecte les captures, essayez ces commandes de comparaison. Remarquez comment la quantité de données affichée change avec différentes valeurs de -s. N'oubliez pas de générer du trafic pour chaque commande.
```
tshark -c 5 -s 64 -i eth1 ## Capture uniquement 64 octets par paquet
tshark -c 5 -s 0 -i eth1  ## Capture les paquets entiers (valeur par défaut)
```
Le paramètre -s 0 indique à tshark de capturer le paquet complet, ce qui est utile lorsque vous avez besoin du contenu complet du paquet mais consomme plus d'espace de stockage.

Capturer le Trafic avec -i eth1

Dans cette étape, nous allons nous concentrer sur la capture du trafic réseau à partir d'une interface spécifique à l'aide de l'option -i de Tshark. Les interfaces réseau sont les connexions physiques ou virtuelles que votre ordinateur utilise pour communiquer avec les réseaux. Lorsque vous avez plusieurs interfaces (comme Wi-Fi et Ethernet), il est crucial de spécifier la bonne pour une analyse ciblée des paquets.

Ouvrez votre terminal et accédez au répertoire de travail :
```
cd ~/project
```
Le drapeau -i indique à Tshark quelle interface réseau surveiller. La structure de commande de base est :
```
tshark -i [interface] [autres options]
```
Ici, [interface] doit être remplacé par le nom de votre interface réelle, généralement eth1 pour notre environnement de laboratoire.
Maintenant, combinons cela avec ce que nous avons appris sur les limites de paquets (-c) et la longueur de la capture (-s). Cette commande capturera 500 paquets de l'interface eth1, en enregistrant uniquement les 128 premiers octets de chaque paquet :
```
tshark -c 500 -s 128 -i eth1
```
Le sudo est requis car la capture de paquets nécessite des privilèges administratifs.
Pour générer un trafic de test pendant la capture, ouvrez un autre onglet de terminal et exécutez :
```
ping -c 3 google.com
```
Ceci envoie 3 paquets ICMP aux serveurs de Google, qui devraient apparaître dans votre capture. Observer ces paquets connus aide à vérifier que votre capture fonctionne correctement.
La capture s'arrêtera automatiquement après 500 paquets, mais vous pouvez l'arrêter manuellement à tout moment en appuyant sur :
```
Ctrl+C
```
Cette interruption de clavier termine la capture en toute sécurité tout en conservant les données capturées.

Enregistrer dans un Fichier avec -w limited.pcap

Dans cette étape, vous apprendrez à enregistrer le trafic réseau capturé dans un fichier pour une analyse ultérieure. L'option -w dans Tshark crée un fichier de capture de paquets (pcap) qui préserve toutes les données réseau capturées. Ceci est particulièrement utile lorsque vous avez besoin d'examiner les schémas de trafic hors ligne ou de partager les captures avec vos collègues.

Avant de commencer, assurez-vous que votre terminal est dans le répertoire de travail correct. Tapez :
```
cd ~/project
```
Ceci garantit que tous vos fichiers de capture seront enregistrés dans le dossier de projet désigné.
Le flag -w indique à Tshark où stocker les paquets capturés. La structure de commande de base est :
```
tshark -w [nom_du_fichier] [autres options]
```
Le nom de fichier doit se terminer par l'extension .pcap, qui est le format standard pour les fichiers de capture de paquets.
Maintenant, combinons toutes les options que nous avons apprises jusqu'à présent dans un exemple pratique. Cette commande va :
- Capturer exactement 500 paquets (-c 500)
- Limiter chaque paquet à 128 octets (-s 128)
- Écouter sur l'interface eth1 (-i eth1)
- Enregistrer tout dans un fichier appelé limited.pcap (-w limited.pcap)
```
tshark -c 500 -s 128 -i eth1 -w limited.pcap
```
Pendant que tshark est en cours d'exécution, ouvrez une autre fenêtre de terminal pour générer un trafic de test. Ces commandes créeront une activité réseau typique :
```
ping -c 3 google.com
curl http://example.com
```
Ce trafic simulé sera capturé par notre session tshark en cours d'exécution.
Après avoir capturé 500 paquets (ou appuyez sur Ctrl+C pour arrêter plus tôt), vérifiez que votre fichier de capture existe et vérifiez sa taille :
```
ls -lh limited.pcap
```
La sortie affiche les détails du fichier, y compris la taille et l'heure de création, similaire à ceci :
```
-rw-r--r-- 1 root root 56K 10 août XX:XX limited.pcap
```
Pour revoir vos paquets capturés plus tard, vous avez deux options principales :
- En utilisant tshark (ligne de commande) :
```
tshark -r limited.pcap
```
  Ceci affiche le contenu des paquets exactement comme ils ont été capturés, vous permettant d'analyser le trafic à votre convenance.
- En utilisant wireshark (interface graphique) :
  
  Remarque : Vous devez exécuter cette commande dans l'interface bureau.
```
wireshark limited.pcap &
```
  Ceci ouvrira le fichier limited.pcap dans l'interface utilisateur graphique de Wireshark, offrant un moyen plus visuel et interactif d'analyser les paquets capturés. Le & à la fin exécute la commande en arrière-plan, afin que vous puissiez continuer à utiliser votre terminal.

Résumé

Dans ce laboratoire, vous avez appris à contrôler la taille de la capture de paquets dans Tshark à l'aide de paramètres essentiels de la ligne de commande. Vous avez pratiqué la limitation du nombre de paquets avec -c 500 et la restriction de la longueur des paquets avec -s 128, en observant comment ces options affectent le comportement de la capture et l'efficacité du stockage.

Les exercices ont démontré la combinaison de ces techniques avec la sélection d'interface (-i eth1) pour une analyse ciblée du trafic. Grâce à des commandes telles que tshark -c 500 -s 128 -i eth1 -w limited.pcap, vous avez acquis une expérience pratique de l'application simultanée de plusieurs contraintes de capture et de l'enregistrement des résultats pour une analyse hors ligne à l'aide de tshark et wireshark.

Limiter la Taille de Capture dans Tshark