Utiliser Tshark pour l'analyse du trafic réseau

Introduction

Dans ce laboratoire (lab), vous apprendrez à utiliser tshark, l'interface en ligne de commande du puissant analyseur de protocoles réseau Wireshark. Maîtriser tshark vous permet d'optimiser vos flux de travail d'analyse réseau, d'automatiser des tâches et de mieux comprendre le trafic réseau.

Ce laboratoire vous guidera à travers différentes options de ligne de commande et des scénarios pratiques. Il vous dotera des compétences nécessaires pour analyser efficacement les captures réseau et résoudre les problèmes liés au réseau. L'approche en ligne de commande présente des avantages significatifs par rapport à l'interface graphique, en particulier pour les fichiers de capture volumineux ou l'analyse automatisée.

Skills Graph

Comprendre et capturer le trafic réseau avec Tshark

Dans cette étape, nous plongerons dans le monde de l'analyse du trafic réseau en utilisant Tshark. Tout d'abord, vous apprendrez ce qu'est Tshark et pourquoi c'est un outil précieux pour l'analyse réseau. Ensuite, nous découvrirons comment identifier les interfaces réseau de votre système, ce qui est crucial car vous devez savoir d'où capturer le trafic. Enfin, nous verrons comment capturer le trafic réseau en utilisant l'interface en ligne de commande de Wireshark, qui est Tshark.

Qu'est - ce que tshark?

Tshark est essentiellement la version en ligne de commande de Wireshark. Alors que Wireshark dispose d'une interface graphique idéale pour l'inspection visuelle, Tshark offre les mêmes fonctionnalités de base sans avoir besoin d'un affichage graphique. Avec Tshark, vous pouvez capturer des paquets depuis un réseau. Les paquets sont comme de petites enveloppes qui transportent des données sur un réseau. Il vous permet également d'afficher des informations détaillées sur ces paquets, telles que leur origine, leur destination et le type de données qu'ils transportent. Vous pouvez enregistrer les données capturées dans un fichier pour une analyse ultérieure. Cet outil est particulièrement utile dans plusieurs scénarios :

• Surveillance réseau automatisée : Vous pouvez configurer des scripts pour exécuter régulièrement Tshark et vérifier toute activité réseau anormale.
• Analyse efficace de fichiers de capture volumineux : Étant un outil en ligne de commande, il peut gérer de grandes quantités de données plus rapidement que certaines alternatives graphiques.
• Exécution sur des serveurs sans interface graphique : Les serveurs n'ont souvent pas d'affichage graphique, et Tshark peut être exécuté directement depuis la ligne de commande.
• Intégration de l'analyse réseau dans des scripts : Vous pouvez utiliser des commandes Tshark dans vos propres scripts pour effectuer des tâches d'analyse réseau personnalisées.

Installation de tshark

Avant de pouvoir commencer à utiliser Tshark, nous devons nous assurer qu'il est installé sur votre système. Pour installer Tshark sur un système utilisant le gestionnaire de paquets apt (comme Ubuntu), exécutez la commande suivante dans votre terminal. La partie sudo vous donne des privilèges d'administration, apt install est utilisé pour installer des paquets, -y répond automatiquement oui à toutes les invitations, et tshark est le paquet que nous voulons installer.

sudo apt install -y tshark

Identification de vos interfaces réseau

Avant de pouvoir commencer à capturer le trafic réseau, vous devez savoir quelle interface réseau surveiller. Une interface réseau est comme une porte par laquelle votre ordinateur se connecte à un réseau. Pour lister toutes les interfaces réseau disponibles sur votre système, exécutez la commande suivante :

tshark -D

Cette commande affichera une liste de toutes les interfaces réseau de votre système. La sortie ressemblera à ceci :

1. eth0
2. eth1
3. lo (Loopback)
4. any (Pseudo - périphérique qui capture sur toutes les interfaces)

Dans notre laboratoire (lab), nous utiliserons l'interface any. Il s'agit d'un pseudo - périphérique spécial qui nous permet de capturer le trafic de toutes les interfaces réseau disponibles en même temps.

Capture du trafic réseau

Maintenant que nous savons quelle interface utiliser, commençons à capturer du trafic réseau. La syntaxe de base pour capturer le trafic avec Tshark est la suivante :

tshark -i <interface> -w <output_file>

Voici ce que chaque partie signifie :

• -i <interface> : Cette option spécifie quelle interface réseau vous voulez capturer le trafic. Vous pouvez remplacer <interface> par le nom de l'interface réelle, comme eth0 ou any.
• -w <output_file> : Cette option spécifie l'emplacement et le nom du fichier où vous voulez enregistrer les paquets capturés.

Tout d'abord, créons un répertoire pour stocker nos fichiers capturés. La commande mkdir -p crée un répertoire s'il n'existe pas, et nous le créons à /home/labex/project/captures.

mkdir -p /home/labex/project/captures

Maintenant, commençons la capture. Nous utiliserons l'interface any et enregistrerons les paquets capturés dans un fichier nommé capture.pcapng dans le répertoire /home/labex/project.

tshark -i any -w /home/labex/project/capture.pcapng

Une fois que vous avez exécuté cette commande, vous verrez une sortie indiquant que Tshark a commencé à capturer des paquets. La sortie ressemblera à ceci :

Capturing on 'any'

Pour capturer du trafic significatif, nous devons le générer. Ouvrez un nouvel onglet de terminal et exécutez la commande suivante. La commande curl est utilisée pour transférer des données depuis un serveur. Ici, nous essayons d'accéder au site web https://www.example.com.

curl https://www.example.com

Après avoir généré le trafic, revenez au terminal où Tshark est en cours d'exécution et appuyez sur Ctrl + C pour arrêter la capture. Vous verrez un message indiquant combien de paquets ont été capturés. Cela pourrait ressembler à ceci :

Capturing on 'any'
164 packets captured

Examen du fichier capturé

Pour nous assurer que le fichier de capture a été créé avec succès, nous pouvons utiliser la commande ls -l. Cette commande liste les fichiers d'un répertoire et affiche des informations détaillées à leur sujet. Exécutez la commande suivante pour vérifier le fichier de capture :

ls -l /home/labex/project/capture.pcapng

Vous devriez voir une sortie similaire à ceci :

-rw-r--r-- 1 labex labex 24680 Jan 27 12:34 /home/labex/project/capture.pcapng

Maintenant, jetons un rapide coup d'œil à ce que nous avons capturé. Nous utiliserons à nouveau Tshark, mais cette fois avec l'option -r. L'option -r est utilisée pour lire un fichier de capture. Nous redirigerons la sortie vers la commande head - 10, qui nous montrera les 10 premiers paquets du fichier.

tshark -r /home/labex/project/capture.pcapng | head -10

Cette commande affichera des informations détaillées sur les paquets, y compris les horodatages (quand le paquet a été capturé), les adresses source et de destination (d'où le paquet provenait et où il allait), et les protocoles utilisés.

Filtrer le trafic réseau avec Tshark

Dans cette étape, nous allons explorer comment appliquer des filtres aux captures de trafic réseau. Lorsque l'on traite le trafic réseau, les fichiers de capture peuvent être assez volumineux et remplis d'une quantité énorme de données. Le filtrage nous permet de nous concentrer sur des types spécifiques de paquets qui nous intéressent. Cela est crucial car il nous permet d'analyser plus efficacement les fichiers de capture volumineux et d'identifier les modèles de trafic pertinents.

Comprendre les filtres d'affichage

Tshark utilise des filtres d'affichage pour sélectionner quels paquets afficher ou traiter à partir d'un fichier de capture. Imaginez ces filtres comme un moyen de dire à Tshark quels paquets vous voulez examiner. Ils utilisent une syntaxe spécifique pour définir des critères de correspondance basés sur les champs de protocole. Par exemple, vous pouvez dire à Tshark de n'afficher que les paquets appartenant à un certain protocole ou ayant une adresse IP spécifique. La syntaxe de base pour appliquer un filtre d'affichage est :

tshark -r "<filter_expression>" < input_file > -Y

Décortiquons les composants de cette commande :

• -r <input_file> : Cette partie de la commande spécifie le fichier de capture que Tshark doit lire. C'est comme dire à Tshark où trouver les données de trafic réseau.
• -Y "<filter_expression>" : Cela spécifie le filtre d'affichage que vous voulez appliquer. L'expression de filtre est un ensemble de règles qui définissent quels paquets doivent être sélectionnés.

Exemples de filtres d'affichage courants

Voici quelques expressions de filtre utiles que vous pouvez utiliser. Ces exemples couvrent différents aspects du filtrage de paquets, tels que le filtrage par protocole, adresse IP, port, méthode HTTP, requête DNS et la combinaison de plusieurs filtres.

• Filtrage par protocole : tcp, udp, icmp, http, dns. Par exemple, si vous utilisez tcp, Tshark n'affichera que les paquets utilisant le protocole TCP.
• Filtrage par adresse IP : ip.addr == 192.168.1.1. Ce filtre n'affichera que les paquets ayant l'adresse IP 192.168.1.1 soit comme source, soit comme destination.
• Filtrage par port : tcp.port == 80 ou tcp.port == 443. Ces filtres afficheront les paquets utilisant les ports TCP 80 ou 443. Le port 80 est couramment utilisé pour le trafic HTTP, et le port 443 est utilisé pour le trafic HTTPS.
• Filtrage par méthode HTTP : http.request.method == "GET". Ce filtre n'affichera que les requêtes HTTP utilisant la méthode GET.
• Filtrage par requête DNS : dns.qry.name contains "example.com". Ce filtre affichera les paquets DNS où le nom de la requête contient la chaîne "example.com".
• Combinaison de filtres : tcp.port == 80 and http.request.method == "POST". Ce filtre combine deux conditions. Il n'affichera que les paquets utilisant le port TCP 80 et ayant une requête HTTP POST.

Application de filtres à notre capture

Commençons par filtrer le trafic HTTPS (port TCP 443) à partir de notre fichier de capture. Nous utiliserons la commande suivante :

tshark -r /home/labex/project/capture.pcapng -Y "tcp.port == 443"

Lorsque vous exécutez cette commande, Tshark lira le fichier de capture /home/labex/project/capture.pcapng et appliquera le filtre tcp.port == 443. En conséquence, vous devriez voir uniquement les paquets utilisant le port TCP 443, qui est généralement utilisé pour le trafic HTTPS. La sortie inclura des détails sur ces paquets, tels que les adresses IP source et destination, les numéros de port et les indicateurs de paquet. Voici un exemple de ce à quoi la sortie pourrait ressembler :

  1   0.000000 192.168.1.100 → 93.184.216.34 TCP 74 43210 → 443 [SYN] Seq=0 Win=64240 Len=0 MSS=1460 WS=256 SACK_PERM=1
  2   0.023456 93.184.216.34 → 192.168.1.100 TCP 74 443 → 43210 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0 MSS=1460 WS=128 SACK_PERM=1
  3   0.023789 192.168.1.100 → 93.184.216.34 TCP 66 43210 → 443 [ACK] Seq=1 Ack=1 Win=64240 Len=0
  ...

Essayons un autre filtre pour rechercher le trafic DNS. Nous utiliserons la commande suivante :

tshark -r /home/labex/project/capture.pcapng -Y "dns"

Cette commande affichera uniquement les paquets DNS de la capture. La sortie montrera les requêtes et les réponses DNS, y compris des détails tels que le nom de la requête et l'adresse IP de la réponse. Voici un exemple de ce à quoi la sortie pourrait ressembler :

  8   0.034567 192.168.1.100 → 8.8.8.8 DNS 82 Standard query 0x1234 A example.com
  9   0.056789 8.8.8.8 → 192.168.1.100 DNS 98 Standard query response 0x1234 A example.com A 93.184.216.34

Compter les paquets par type

Vous pouvez également utiliser des filtres pour compter des types spécifiques de paquets. Cela peut être utile pour avoir une vue d'ensemble du trafic dans un fichier de capture. Par exemple, pour compter le nombre de paquets TCP, nous pouvons utiliser la commande suivante :

tshark -r /home/labex/project/capture.pcapng -Y "tcp" | wc -l

Dans cette commande, tshark lit le fichier de capture et applique le filtre tcp. La sortie de tshark est ensuite redirigée (|) vers la commande wc -l, qui compte le nombre de lignes dans la sortie. Étant donné que chaque ligne représente un paquet, cela nous donne le nombre de paquets TCP dans le fichier de capture.

Comptons le nombre de paquets HTTPS et enregistrons le résultat dans un fichier. Nous utiliserons la commande suivante :

tshark -r /home/labex/project/capture.pcapng -Y "tcp.port == 443" | wc -l > /home/labex/project/filtered_packet_count.txt

Cette commande est similaire à la précédente, mais au lieu de simplement afficher le compte, nous redirigeons (>) la sortie vers un fichier nommé filtered_packet_count.txt. Vous pouvez afficher le résultat avec la commande suivante :

cat /home/labex/project/filtered_packet_count.txt

La sortie montrera le nombre de paquets correspondant au filtre. Par exemple :

42

Extraction de champs spécifiques

Tshark peut extraire des champs spécifiques des paquets en utilisant les options -T fields et -e. Cela est utile lorsque vous n'êtes intéressé que par certaines informations des paquets, telles que l'hôte, la méthode et l'URI d'une requête HTTP. Voici un exemple de commande :

tshark -r /home/labex/project/capture.pcapng -Y "http" -T fields -e http.host -e http.request.method -e http.request.uri

Dans cette commande, tshark lit le fichier de capture, applique le filtre http pour sélectionner uniquement les paquets HTTP, puis utilise l'option -T fields pour spécifier que nous voulons extraire des champs. L'option -e est utilisée pour spécifier quels champs extraire. Dans ce cas, nous extrayons les champs http.host, http.request.method et http.request.uri. La sortie pourrait ressembler à ceci :

example.com	GET	/index.html
example.com	GET	/images/logo.png

Analyser et exporter le trafic réseau avec Tshark

Dans cette étape, nous allons nous concentrer sur la manière d'exporter le trafic réseau dans différents formats et d'effectuer une analyse de base du trafic en utilisant Tshark. Ces compétences sont cruciales car elles vous permettent de partager les données capturées avec vos collègues ou de les utiliser dans d'autres outils. À la fin de cette section, vous serez en mesure de gérer différents formats de fichiers et d'extraire des informations précieuses du trafic réseau.

Comprendre les formats de fichiers de capture

Wireshark, un analyseur de protocoles réseau bien connu, prend en charge plusieurs formats de fichiers de capture. Chaque format a ses propres caractéristiques uniques, il est important de les comprendre car elles déterminent comment les données peuvent être utilisées par la suite.

• pcapng : C'est le format par défaut utilisé par Wireshark. Il prend en charge plusieurs interfaces et dispose de fonctionnalités avancées. C'est un excellent choix lorsque vous avez besoin de capturer des scénarios réseau complexes.
• pcap : Le format classique. Il est compatible avec les outils plus anciens, mais il a moins de fonctionnalités que pcapng. Si vous avez besoin de travailler avec des systèmes hérités, ce format pourrait être votre premier choix.
• csv : Valeurs séparées par des virgules. Ce format est très utile lorsque vous souhaitez importer les données dans des tableurs pour une analyse plus approfondie.
• json : JavaScript Object Notation. C'est idéal pour l'analyse programmée, car il peut être facilement analysé par les langages de programmation.
• text : Un format texte brut qui est lisible par l'homme. Il est utile lorsque vous souhaitez visualiser rapidement les données sans outils spéciaux.

Exportation dans différents formats de fichiers

Pour changer le format d'un fichier de capture, vous pouvez utiliser l'option -F dans Tshark. La structure générale de la commande est la suivante :

tshark -r <input_file> -F <format> -w <output_file>

Ici, -r spécifie le fichier d'entrée, -F définit le format de sortie et -w définit le fichier de sortie.

Prenons un exemple et exportons notre capture au format pcap :

tshark -r /home/labex/project/capture.pcapng -F pcap -w /home/labex/project/export.pcap

Lorsque cette commande s'exécute avec succès, vous ne verrez aucune sortie à l'écran. Pour confirmer que l'exportation a réussi, vous pouvez utiliser la commande ls pour lister les détails du fichier exporté :

ls -l /home/labex/project/export.pcap

Vous devriez voir une sortie similaire à ceci :

-rw-r--r-- 1 labex labex 22468 Jan 27 12:45 /home/labex/project/export.pcap

Analyse des statistiques de protocole

Tshark n'est pas seulement utile pour exporter des fichiers, mais aussi pour générer diverses statistiques sur le trafic capturé. Explorons quelques-unes de ces options d'analyse statistique.

Statistiques de la hiérarchie des protocoles

Si vous souhaitez voir comment différents protocoles sont répartis dans votre capture, vous pouvez utiliser la commande suivante :

tshark -r /home/labex/project/capture.pcapng -z io,phs

L'option -z est utilisée pour spécifier le type de statistiques. Dans ce cas, io,phs signifie statistiques de la hiérarchie des protocoles. La sortie montrera la hiérarchie des protocoles et le pourcentage de paquets pour chaque protocole.

Protocol Hierarchy Statistics
|
+ Ethernet
  + Internet Protocol Version 4
    + Transmission Control Protocol
      + Transport Layer Security
        + Hypertext Transfer Protocol Secure
    + User Datagram Protocol
      + Domain Name System

Statistiques des conversations

Pour analyser les conversations entre les points terminaux du réseau, vous pouvez utiliser la commande suivante :

tshark -r /home/labex/project/capture.pcapng -z conv,tcp

Cette commande se concentre sur les conversations TCP. Elle montre des statistiques telles que les points terminaux impliqués, le nombre de paquets échangés et le nombre total d'octets transmis.

TCP Conversations
                                               |       <-      | |       ->      | |     Total     |    Relative    |   Duration   |
                                               | Frames  Bytes | | Frames  Bytes | | Frames  Bytes |      Start     |              |
192.168.1.100:43210 <-> 93.184.216.34:443          24   18765      18    4532      42    23297       0.000000000        8.2345

Statistiques des requêtes HTTP

Si votre capture contient du trafic HTTP, vous pouvez analyser les requêtes HTTP en utilisant la commande suivante :

tshark -r /home/labex/project/capture.pcapng -z http,tree

Cette commande organise les requêtes HTTP par URI et montre le nombre de requêtes pour chaque URI.

HTTP/Requests:
 /index.html                                    1 requests
 /images/logo.png                               2 requests

Exportation dans différents formats texte

En plus des formats binaires, Tshark peut également exporter des données dans des formats texte, qui sont souvent plus faciles à analyser.

Exportation au format CSV

Pour exporter des champs spécifiques de la capture dans un fichier CSV, vous pouvez utiliser la commande suivante :

tshark -r /home/labex/project/capture.pcapng -T fields -e frame.number -e ip.src -e ip.dst -e tcp.srcport -e tcp.dstport -E header=y -E separator=, > /home/labex/project/tcp_summary.csv

Ici, -T fields spécifie que nous voulons exporter des champs spécifiques. L'option -e est utilisée pour définir les champs que nous voulons exporter, tels que le numéro de trame, les adresses IP source et destination et les ports TCP source et destination. -E header=y ajoute un en-tête au fichier CSV et -E separator=, définit le séparateur comme une virgule.

Examen de l'exportation au format CSV

Après avoir exporté les données dans un fichier CSV, vous pouvez rapidement visualiser les premières lignes du fichier en utilisant la commande head :

head -5 /home/labex/project/tcp_summary.csv

La sortie pourrait ressembler à ceci :

frame.number,ip.src,ip.dst,tcp.srcport,tcp.dstport
1,192.168.1.100,93.184.216.34,43210,443
2,93.184.216.34,192.168.1.100,443,43210
3,192.168.1.100,93.184.216.34,43210,443
...

Techniques avancées avec Tshark et utilisation des pipes

Dans cette étape, vous allez apprendre des techniques avancées avec Tshark. Ces techniques sont essentielles pour l'analyse réseau car elles vous permettent d'effectuer des opérations complexes sur les données de trafic réseau. Plus précisément, vous allez apprendre à lire le trafic réseau à partir de l'entrée standard (stdin) et à combiner Tshark avec d'autres outils en ligne de commande en utilisant les pipes. Maîtriser ces compétences vous permettra de créer des flux de travail d'analyse réseau puissants, ce qui vous fera gagner du temps et des efforts lors de la manipulation de grandes quantités de données réseau.

Comprendre les pipes Linux et l'entrée standard

Dans le système d'exploitation Linux, les pipes (|) sont une fonctionnalité très utile. Ils agissent comme un pont entre deux commandes, vous permettant d'envoyer la sortie d'une commande en tant qu'entrée à une autre commande. De cette façon, vous pouvez enchaîner plusieurs commandes pour effectuer des tâches plus complexes. L'entrée standard (stdin) est un flux de données que le programme lit pour obtenir des entrées. Lorsque vous utilisez le symbole - avec de nombreux outils en ligne de commande, c'est un signal pour l'outil indiquant que l'entrée doit provenir de stdin plutôt que d'un fichier. Cela vous offre plus de flexibilité dans la façon de traiter les données.

Lire le trafic réseau à partir de l'entrée standard

Tshark a la capacité de lire les données de capture à partir de l'entrée standard en utilisant l'option -r -. Cette fonctionnalité est extrêmement utile dans les scénarios où vous souhaitez traiter des données provenant d'une autre commande ou lorsque vous avez besoin de filtrer une capture en temps réel. Au lieu de lire directement à partir d'un fichier, vous pouvez acheminer des données vers Tshark.

La syntaxe de base pour lire le trafic réseau à partir de l'entrée standard est :

cat <input_file> | tshark -r -

Essayons cela avec notre fichier de capture. La commande suivante lit le fichier de capture et affiche tous les paquets, de la même manière que si vous exécutiez tshark -r capture.pcapng.

cat /home/labex/project/capture.pcapng | tshark -r -

La sortie affichera tous les paquets de la capture, comme ceci :

  1   0.000000 192.168.1.100 → 93.184.216.34 TCP 74 43210 → 443 [SYN] Seq=0 Win=64240 Len=0 MSS=1460 WS=256 SACK_PERM=1
  2   0.023456 93.184.216.34 → 192.168.1.100 TCP 74 443 → 43210 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0 MSS=1460 WS=128 SACK_PERM=1
  ...

Filtrer les données provenant de l'entrée standard

Vous pouvez également appliquer des filtres lors de la lecture à partir de stdin. Cela vous permet de vous concentrer sur des types spécifiques de trafic réseau.

cat /home/labex/project/capture.pcapng | tshark -r - -Y "tcp.port == 80"

Cette commande affichera uniquement le trafic HTTP (port TCP 80) de la capture. En utilisant le filtre, vous pouvez rapidement isoler les données qui vous intéressent.

Créer un pipeline pour l'analyse réseau

Créons un pipeline plus complexe qui effectue plusieurs opérations sur les données de capture réseau. Ce pipeline va :

1. Lire le fichier de capture
2. Filtrer le trafic DNS
3. Extraire uniquement les noms de requêtes DNS
4. Les trier par ordre alphabétique
5. Supprimer les doublons
6. Enregistrer le résultat dans un fichier

cat /home/labex/project/capture.pcapng | tshark -r - -Y "dns" -T fields -e dns.qry.name | sort | uniq > /home/labex/project/dns_queries.txt

Examinons le résultat en exécutant la commande suivante :

cat /home/labex/project/dns_queries.txt

La sortie affichera une liste triée de noms de requêtes DNS uniques de votre capture, comme ceci :

example.com
www.example.com

Combiner Tshark avec d'autres outils

Tshark peut être combiné avec d'autres outils en ligne de commande pour une analyse plus puissante.

Compter les types de paquets avec grep

cat /home/labex/project/capture.pcapng | tshark -r - | grep TCP | wc -l > /home/labex/project/tcp_count.txt

Ce pipeline compte le nombre de paquets TCP dans la capture. En utilisant grep pour trouver les paquets TCP et wc -l pour les compter, vous pouvez rapidement avoir une idée de la quantité de trafic TCP dans votre capture.

Extraire les agents utilisateur HTTP avec sed

cat /home/labex/project/capture.pcapng | tshark -r - -Y "http.user_agent" -T fields -e http.user_agent | sed 's/,/\n/g' > /home/labex/project/user_agents.txt

Cela extrait toutes les chaînes d'agents utilisateur HTTP, en remplaçant les virgules par des sauts de ligne. Cela rend la sortie plus lisible et plus facile à analyser.

Enregistrer la sortie de stdin dans un fichier

Enregistrons la sortie complète d'une analyse Tshark à partir de stdin dans un fichier. De cette façon, vous pourrez revoir les données plus tard.

cat /home/labex/project/capture.pcapng | tshark -r - > /home/labex/project/stdin_output.txt

Vérifions le contenu en exécutant la commande suivante :

head -5 /home/labex/project/stdin_output.txt

Cela devrait afficher les 5 premières lignes de l'analyse, similaire à :

  1   0.000000 192.168.1.100 → 93.184.216.34 TCP 74 43210 → 443 [SYN] Seq=0 Win=64240 Len=0 MSS=1460 WS=256 SACK_PERM=1
  2   0.023456 93.184.216.34 → 192.168.1.100 TCP 74 443 → 43210 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0 MSS=1460 WS=128 SACK_PERM=1
  3   0.023789 192.168.1.100 → 93.184.216.34 TCP 66 43210 → 443 [ACK] Seq=1 Ack=1 Win=64240 Len=0
  4   0.024012 192.168.1.100 → 93.184.216.34 TLSv1.2 192 Client Hello
  5   0.045678 93.184.216.34 → 192.168.1.100 TLSv1.2 1023 Server Hello, Certificate, Server Key Exchange, Server Hello Done

Résumé

Dans ce laboratoire, vous avez appris à utiliser efficacement l'interface en ligne de commande de Wireshark (tshark) pour l'analyse du trafic réseau. Tout d'abord, vous avez compris les concepts de base de tshark et appris à capturer le trafic réseau à partir des interfaces réseau. Ensuite, vous avez exploré l'application de filtres pour vous concentrer sur des types de trafic spécifiques, ce qui est crucial lorsque vous manipulez de grands fichiers de capture.

Vous avez également appris à exporter le trafic réseau dans différents formats pour le partager ou l'analyser plus en détail. De plus, vous avez exploré les capacités d'analyse statistique de tshark pour comprendre la composition du trafic réseau. Enfin, vous avez progressé vers des techniques plus complexes, telles que la lecture du trafic à partir de l'entrée standard et la création de pipelines d'analyse en combinant tshark avec d'autres outils en ligne de commande. Ces compétences offrent des avantages par rapport à l'interface graphique de Wireshark dans des scénarios tels que la manipulation de grands fichiers, l'analyse automatisée, l'analyse sur des serveurs distants et la création de flux de travail reproductibles. En maîtrisant ces techniques, vous avez amélioré vos capacités de dépannage réseau et d'analyse de sécurité pour travailler plus efficacement dans divers contextes réseau.