Tshark mit Lua-Skripten erweitern

Einführung

In diesem Lab lernen Sie, wie Sie die Paketanalyse-Fähigkeiten von Wireshark mithilfe von Lua-Skripting erweitern können. Sie werden untersuchen, wie Sie benutzerdefinierte Skripte über Befehlszeilenoptionen laden und Argumente übergeben können, um die Funktionalität zu verbessern.

Die Übungen führen Sie durch den Prozess der Erstellung von Lua-Skripten, das Testen dieser Skripte mit dem tshark-Befehl von Wireshark und die Überprüfung der Ausgabe. Sie werden das Ausführen von Skripten mit leeren Aufzeichnungen üben und lernen, ausführliche Paketdetails zu interpretieren.

Skript mit -X lua_script:script.lua laden

In diesem Schritt lernen Sie, wie Sie ein Lua-Skript in Wireshark mithilfe der -X-Option laden können. Lua ist eine leichte Skriptsprache, die gut mit Wireshark integriert wird und es Ihnen ermöglicht, dessen Funktionalität für benutzerdefinierte Paketanalysen zu erweitern, ohne das Kernprogramm zu ändern.

Zunächst erstellen wir ein einfaches Lua-Skript im Standardarbeitsverzeichnis. Dieses Skript dient als einfacher Testfall, um zu überprüfen, ob Wireshark Lua-Code erfolgreich laden und ausführen kann:

Öffnen Sie ein Terminal und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden. Hier erstellen und speichern wir unser Lua-Skript:
```
cd ~/project
```
Erstellen Sie eine neue Lua-Skriptdatei namens script.lua mit nano. Wir verwenden nano, da es einfach zu bedienen ist und in den meisten Linux-Umgebungen verfügbar ist:
```
nano script.lua
```
Fügen Sie den folgenden grundlegenden Lua-Code hinzu, um eine Nachricht auszugeben, wenn das Skript geladen wird. Dies demonstriert die grundlegendste Operation - die Überprüfung der Skriptausführung:
```
-- Simple Wireshark Lua script
print("Wireshark Lua script loaded successfully!")
```
Speichern Sie die Datei (Strg+O, Eingabe) und verlassen Sie nano (Strg+X). Das Skript ist nun bereit, von Wireshark geladen zu werden.

Jetzt laden wir dieses Skript über die Befehlszeilenschnittstelle von Wireshark. Wir verwenden eine spezielle Parameterkombination, um das Skript zu testen, ohne echten Netzwerkverkehr zu verarbeiten:

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

Lassen Sie uns analysieren, was jeder Teil dieses Befehls macht:

-X lua_script:script.lua teilt Wireshark mit, unser Lua-Skriptfile zu laden
-r /dev/null gibt eine leere Aufzeichnungsdatei an (wir testen nur das Laden des Skripts, keine Paketanalyse)
-k startet die Aufzeichnung sofort, ohne auf Benutzereingaben zu warten

Wenn Sie diesen Befehl ausführen, sollten Sie die Nachricht "Wireshark Lua script loaded successfully!" in der Terminalausgabe sehen. Dies bestätigt, dass Wireshark Ihr Lua-Skript erfolgreich gefunden, geladen und ausgeführt hat. Wenn Sie diese Nachricht nicht sehen, überprüfen Sie, ob die Skriptdatei sich an der richtigen Stelle befindet und keine Syntaxfehler enthält.

Übergeben Sie ein Argument mit -X lua_script1:arg1

In diesem Schritt lernen Sie, wie Sie Argumente an ein Lua-Skript in Wireshark mithilfe der -X lua_script1:-Option übergeben können. Diese Technik ist nützlich, wenn Sie Ihre Skripte flexibler gestalten möchten, indem Sie verschiedene Eingaben akzeptieren, ohne jedes Mal das Skript selbst ändern zu müssen.

Zunächst verstehen wir, wie das Übergeben von Argumenten in Wireshark's Lua-Umgebung funktioniert. Die -X lua_script1:-Option ermöglicht es Ihnen, einen Zeichenfolgenwert an Ihr Skript zu senden, der dann mit der get_string()-Funktion abgerufen werden kann. Dies ähnelt der Funktionsweise von Befehlszeilenargumenten in anderen Programmiersprachen.

Ändern wir nun unser vorhandenes Lua-Skript, um ein Argument zu akzeptieren und zu verarbeiten:

Öffnen Sie die script.lua-Datei aus dem vorherigen Schritt:
```
nano ~/project/script.lua
```
Ersetzen Sie den Inhalt durch den folgenden Code, der ein Argument akzeptiert und anzeigt:
```
-- Lua script with argument handling
local arg1 = get_string("lua_script1")
print("Received argument: " .. (arg1 or "no argument provided"))
```
Die get_string("lua_script1")-Funktion ruft das mit -X lua_script1: übergebene Argument ab. Der Teil or "no argument provided" liefert eine Standardnachricht, wenn kein Argument angegeben wurde.
Speichern Sie die Datei (Strg+O, Eingabe) und verlassen Sie nano (Strg+X).

Jetzt führen wir das Skript mit einem Argument aus:

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

Analysieren wir diesen Befehl:

-X lua_script:script.lua lädt unser Lua-Skriptfile
-X lua_script1:test123 übergibt "test123" als Argument an das Skript
-r /dev/null gibt eine leere Aufzeichnungsdatei an (da wir nur das Skript testen)
-k startet die Aufzeichnung sofort, ohne auf Benutzereingaben zu warten

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Received argument: test123

Um zu überprüfen, dass das Skript mit verschiedenen Eingaben funktioniert, versuchen Sie, es mit einem anderen Wert auszuführen:

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

Dies zeigt, wie Sie dasselbe Skript mit verschiedenen Argumenten wiederverwenden können, wodurch Ihre Analyse dynamischer wird und sich besser an verschiedene Szenarien anpassen lässt.

Datei mit -r capture.pcap verarbeiten

In diesem Schritt lernen Sie, wie Sie eine bereits aufgezeichnete Netzwerk-Aufzeichnungsdatei mit dem Befehlszeilentool Tshark von Wireshark mithilfe der -r-Option verarbeiten können. Dies ist nützlich, wenn Sie gespeicherten Netzwerkverkehr analysieren möchten, anstatt live Pakete aufzunehmen.

Zunächst benötigen wir eine Beispiel-Paket-Aufzeichnungsdatei, mit der wir arbeiten können. PCAP-Dateien enthalten tatsächliche Netzwerkverkehrsdaten, die wir analysieren können. Laden wir eine Standard-HTTP-Verkehrsbeispieldatei herunter:

Laden Sie eine Beispiel-PCAP-Datei in Ihr Projektverzeichnis herunter:

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

Überprüfen Sie, ob die Datei korrekt heruntergeladen wurde, indem Sie ihre Größe und Speicherort prüfen:
```
ls -lh ~/project/capture.pcap
```

Jetzt ändern wir unser Lua-Skript, um diese Aufzeichnungsdatei zu analysieren. Das Skript zählt alle Pakete in der Datei und gibt die Gesamtzahl aus. So aktualisieren Sie es:

Öffnen Sie das Skript zum Bearbeiten:
```
nano ~/project/script.lua
```

Aktualisieren Sie den Inhalt mit dieser Paketzähl-Logik:

-- 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()

Speichern Sie die Datei (Strg+O, Eingabe) und verlassen Sie nano (Strg+X).

Jetzt führen wir unser Skript anhand der Aufzeichnungsdatei aus. Dieser Befehl teilt Tshark mit:

Unser Lua-Skript zu verwenden (-X lua_script)
Ein Argument an das Skript zu übergeben (-X lua_script1)
Die heruntergeladene Datei zu verarbeiten (-r)
Stillzulegen, ohne GUI (-q)

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

Nach der Verarbeitung sollten Sie eine Ausgabe sehen, die Folgendes anzeigt:

Das Argument, das wir an das Skript übergeben haben
Die Gesamtzahl der gezählten Pakete

Beispielausgabe:

Argument received: analysis
Total packets processed: 83

Prüfen Sie die benutzerdefinierte Ausgabe mit -V

In diesem Schritt werden wir untersuchen, wie Sie die Ausgabe Ihres Lua-Skripts mithilfe der -V-Option (ausführliche Ausgabe) von Wireshark überprüfen können. Dies ist besonders nützlich, wenn Sie detaillierte Analyseergebnisse Ihres benutzerdefinierten Skripts neben den Standard-Paketinformationen sehen möchten.

Zunächst verbessern wir unser Lua-Skript, um sinnvollere Statistiken bereitzustellen. Wir ändern es so, dass es verschiedene Protokolltypen verfolgt:

Öffnen Sie das Skript in nano zum Bearbeiten:
```
nano ~/project/script.lua
```

Aktualisieren Sie das Skript mit dieser erweiterten Version, die HTTP- und TCP-Pakete zählt:

-- 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()

Speichern Sie die Datei (Strg+O, Eingabe) und verlassen Sie nano (Strg+X).

Jetzt führen wir unser Skript mit aktivierter ausführlicher Ausgabe aus. Die -V-Option teilt Wireshark mit, alle verfügbaren Informationen anzuzeigen, einschließlich der Ausgabe unseres benutzerdefinierten Skripts:

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

Sie sollten eine Ausgabe ähnlich der folgenden sehen, die sowohl Paketdetails als auch die Analyse Ihres Skripts anzeigt:

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

Um diese Ausgabe für die spätere Referenz zu speichern, leiten Sie sie in eine Datei um:

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

Abschließend überprüfen Sie die gespeicherte Ausgabe, indem Sie den Dateiinhalt anzeigen:

cat ~/project/analysis_output.txt

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie die Funktionalität von Wireshark mithilfe von Lua-Skripten über Befehlszeilenoperationen erweitern können. Die Schlüsselschritte umfassten das Laden von Lua-Skripten mit der Option -X lua_script:script.lua und das Testen dieser Skripts über die Befehlszeilenschnittstelle (CLI) von Wireshark.

Darüber hinaus haben Sie untersucht, wie Sie Argumente an Lua-Skripten mithilfe von -X lua_script1:arg1 übergeben können. Dies zeigt, wie Sie flexible Skripts erstellen können, die externe Parameter akzeptieren. Diese Technik verbessert die Paketanalysefähigkeiten von Wireshark durch anpassbare Lua-Erweiterungen.