Étendre Tshark avec des scripts Lua

Introduction

Dans ce laboratoire, vous apprendrez à étendre les capacités d'analyse de paquets de Wireshark en utilisant le scripting Lua. Vous explorerez le chargement de scripts personnalisés via des options de ligne de commande et le passage d'arguments pour améliorer la fonctionnalité.

Les exercices vous guident à travers la création de scripts Lua, leur test avec la commande tshark de Wireshark et la vérification de la sortie. Vous pratiquerez l'exécution de scripts avec des captures vides et apprendrez à interpréter les détails verbaux des paquets.

Charger le script avec -X lua_script:script.lua

Dans cette étape, vous apprendrez à charger un script Lua dans Wireshark en utilisant l'option -X. Lua est un langage de scripting léger qui s'intègre bien avec Wireshark, vous permettant d'étendre ses fonctionnalités pour une analyse personnalisée de paquets sans modifier le programme principal.

Tout d'abord, créons un simple script Lua dans le répertoire de travail par défaut. Ce script servira de cas de test de base pour vérifier que Wireshark peut charger et exécuter le code Lua avec succès :

Ouvrez un terminal et assurez-vous d'être dans le répertoire ~/project. C'est là que nous allons créer et stocker notre script Lua :
```
cd ~/project
```
Créez un nouveau fichier de script Lua nommé script.lua en utilisant nano. Nous utilisons nano car il est simple et disponible dans la plupart des environnements Linux :
```
nano script.lua
```
Ajoutez le code Lua de base suivant pour afficher un message lors du chargement. Cela démontre l'opération la plus fondamentale - la vérification de l'exécution du script :
```
-- Simple Wireshark Lua script
print("Wireshark Lua script loaded successfully!")
```
Enregistrez le fichier (Ctrl+O, Entrée) et quittez nano (Ctrl+X). Le script est maintenant prêt à être chargé par Wireshark.

Maintenant, chargeons ce script en utilisant l'interface en ligne de commande de Wireshark. Nous allons utiliser une combinaison spéciale de paramètres pour tester le script sans traiter le trafic réseau réel :

wireshark -X lua_script:script.lua -r /dev/null -k

Décortiquons ce que chaque partie de cette commande fait :

-X lua_script:script.lua indique à Wireshark de charger notre fichier de script Lua
-r /dev/null spécifie un fichier de capture vide (nous testons simplement le chargement du script, pas l'analyse de paquets)
-k démarre la capture immédiatement sans attendre une entrée utilisateur

Lorsque vous exécutez cette commande, vous devriez voir le message "Wireshark Lua script loaded successfully!" dans la sortie du terminal. Cela confirme que Wireshark a localisé, chargé et exécuté votre script Lua avec succès. Si vous ne voyez pas ce message, vérifiez que le fichier de script existe à l'emplacement correct et ne contient pas d'erreurs de syntaxe.

Passer un argument avec -X lua_script1:arg1

Dans cette étape, vous apprendrez à passer des arguments à un script Lua dans Wireshark en utilisant l'option -X lua_script1:. Cette technique est utile lorsque vous souhaitez rendre vos scripts plus flexibles en acceptant différentes entrées sans modifier le script lui-même à chaque fois.

Tout d'abord, comprenons comment le passage d'arguments fonctionne dans l'environnement Lua de Wireshark. L'option -X lua_script1: vous permet d'envoyer une valeur de chaîne de caractères à votre script, qui peut ensuite être accédée à l'aide de la fonction get_string(). Cela est similaire à la façon dont les arguments de ligne de commande fonctionnent dans d'autres langages de programmation.

Modifions notre script Lua existant pour accepter et traiter un argument :

Ouvrez le fichier script.lua de l'étape précédente :
```
nano ~/project/script.lua
```
Remplacez le contenu par le code suivant qui accepte et affiche un argument :
```
-- Lua script with argument handling
local arg1 = get_string("lua_script1")
print("Received argument: " .. (arg1 or "no argument provided"))
```
La fonction get_string("lua_script1") récupère l'argument passé avec -X lua_script1:. La partie or "no argument provided" fournit un message par défaut si aucun argument n'a été donné.
Enregistrez le fichier (Ctrl+O, Entrée) et quittez nano (Ctrl+X).

Maintenant, exécutons le script avec un argument :

wireshark -X lua_script:script.lua -X lua_script1:test123 -r /dev/null -k

Décortiquons cette commande :

-X lua_script:script.lua charge notre fichier de script Lua
-X lua_script1:test123 passe "test123" comme argument au script
-r /dev/null spécifie un fichier de capture vide (puisque nous testons simplement le script)
-k démarre la capture immédiatement sans attendre une entrée utilisateur

Vous devriez voir une sortie similaire à :

Received argument: test123

Pour vérifier que le script fonctionne avec différentes entrées, essayez de l'exécuter avec une autre valeur :

wireshark -X lua_script:script.lua -X lua_script1:another_value -r /dev/null -k

Cela démontre comment vous pouvez réutiliser le même script avec différents arguments, rendant votre analyse plus dynamique et adaptable à différents scénarios.

Traiter le fichier avec -r capture.pcap

Dans cette étape, vous apprendrez à traiter un fichier de capture réseau pré-enregistré en utilisant l'outil en ligne de commande Tshark de Wireshark avec l'option -r. Cela est utile lorsque vous souhaitez analyser le trafic réseau enregistré plutôt que de capturer des paquets en direct.

Tout d'abord, nous avons besoin d'un fichier de capture de paquets exemple pour travailler. Les fichiers PCAP contiennent des données de trafic réseau réelles que nous pouvons analyser. Téléchargeons un exemple de trafic HTTP standard :

Téléchargez un fichier pcap exemple dans votre répertoire de projet :

wget https://wiki.wireshark.org/SampleCaptures/http.cap -O ~/project/capture.pcap

Vérifiez que le fichier a été téléchargé correctement en vérifiant sa taille et son emplacement :
```
ls -lh ~/project/capture.pcap
```

Maintenant, nous allons modifier notre script Lua pour analyser ce fichier de capture. Le script comptera tous les paquets du fichier et affichera le total. Voici comment le mettre à jour :

Ouvrez le script pour le modifier :
```
nano ~/project/script.lua
```

Mettez à jour le contenu avec cette logique de comptage de paquets :

-- Packet counter script
local arg1 = get_string("lua_script1") or "default"
local packet_count = 0

-- Called for each packet
function tap.packet(pinfo,tvb)
    packet_count = packet_count + 1
end

-- Called after processing all packets
function tap.draw()
    print("Argument received: " .. arg1)
    print("Total packets processed: " .. packet_count)
end

-- Register the tap
tap = Listener.new()

Enregistrez le fichier (Ctrl+O, Entrée) et quittez nano (Ctrl+X).

Maintenant, exécutons notre script sur le fichier de capture. Cette commande indique à Tshark de :

Utiliser notre script Lua (-X lua_script)
Passer un argument au script (-X lua_script1)
Traiter le fichier que nous avons téléchargé (-r)
Exécuter en mode silencieux sans interface graphique (-q)

wireshark -X lua_script:script.lua -X lua_script1:analysis -r ~/project/capture.pcap -q

Après le traitement, vous devriez voir une sortie affichant :

L'argument que nous avons passé au script
Le nombre total de paquets comptés

Exemple de sortie :

Argument received: analysis
Total packets processed: 83

Vérifier la sortie personnalisée avec -V

Dans cette étape, nous allons explorer comment vérifier la sortie de votre script Lua en utilisant l'option -V (verbeux) de Wireshark. Cela est particulièrement utile lorsque vous avez besoin de voir les résultats d'analyse détaillés de votre script personnalisé en plus des informations standard sur les paquets.

Tout d'abord, améliorons notre script Lua pour fournir des statistiques plus significatives. Nous allons le modifier pour suivre différents types de protocoles :

Ouvrez le script pour le modifier dans nano :
```
nano ~/project/script.lua
```

Mettez à jour le script avec cette version améliorée qui compte les paquets HTTP et TCP :

-- Enhanced packet analyzer
local arg1 = get_string("lua_script1") or "default"
local stats = {
    total = 0,
    http = 0,
    tcp = 0
}

function tap.packet(pinfo,tvb)
    stats.total = stats.total + 1
    if pinfo.visited then return end

    if pinfo.protocols:find("http") then
        stats.http = stats.http + 1
    end
    if pinfo.protocols:find("tcp") then
        stats.tcp = stats.tcp + 1
    end
end

function tap.draw()
    print("=== Analysis Report ===")
    print("Argument received: " .. arg1)
    print("Total packets: " .. stats.total)
    print("HTTP packets: " .. stats.http)
    print("TCP packets: " .. stats.tcp)
    print("======================")
end

tap = Listener.new()

Enregistrez le fichier (Ctrl+O, Entrée) et quittez nano (Ctrl+X).

Maintenant, exécutons notre script avec la sortie verbeuse activée. Le drapeau -V indique à Wireshark d'afficher toutes les informations disponibles, y compris la sortie de notre script personnalisé :

wireshark -X lua_script:script.lua -X lua_script1:final_run -r ~/project/capture.pcap -q -V

Vous devriez voir une sortie similaire à celle-ci, montrant à la fois les détails des paquets et l'analyse de votre script :

=== Analysis Report ===
Argument received: final_run
Total packets: 83
HTTP packets: 10
TCP packets: 83
======================

Pour enregistrer cette sortie pour un usage ultérieur, redirigez-la vers un fichier :

wireshark -X lua_script:script.lua -X lua_script1:final_run -r ~/project/capture.pcap -q -V > ~/project/analysis_output.txt

Enfin, vérifiez la sortie enregistrée en affichant le contenu du fichier :

cat ~/project/analysis_output.txt

Résumé

Dans ce laboratoire (lab), vous avez appris à étendre les fonctionnalités de Wireshark à l'aide de scripts Lua via des opérations en ligne de commande. Les étapes clés comprenaient le chargement de scripts Lua avec l'option -X lua_script:script.lua et leur test via l'interface CLI (Command Line Interface) de Wireshark.

De plus, vous avez exploré le passage d'arguments aux scripts Lua en utilisant -X lua_script1:arg1, démontrant ainsi comment créer des scripts flexibles qui acceptent des paramètres externes. Cette technique améliore les capacités d'analyse de paquets de Wireshark grâce à des extensions Lua personnalisables.