Tshark-Leistung profilieren

Einführung

In diesem Lab lernen Sie, wie Sie die Leistung des Befehlszeilentools tshark von Wireshark mithilfe von Zeitmessungen und Paketverarbeitungstechniken profilieren und analysieren können. Sie werden die Aktivierung detaillierter Zeitstatistiken mit --print-timers, die Verarbeitung von Aufnahmefiles und die Interpretation der JSON-Ausgabe untersuchen, um die verschiedenen Verarbeitungsphasen zu verstehen.

Durch praktische Übungen üben Sie das Messen der Verarbeitungszeiten, das Filtern bestimmter Verkehrstypen und die Analyse von Leistungskennzahlen. Das Lab bietet praktische Erfahrungen mit tshark-Befehlen zum Zählen von Paketen und zur Untersuchung von DHCP-Verkehr, während Sie die Leistung von Wireshark profilieren.

Aktivieren von Zeitmessern mit --print-timers

In diesem Schritt werden wir untersuchen, wie man die Leistung der Paketverarbeitung von Wireshark mithilfe der Option --print-timers misst. Dies ist besonders nützlich, wenn Sie verstehen möchten, wo Tshark die meiste Zeit beim Analysieren von Netzwerkverkehr verbringt.

Bevor wir beginnen, stellen wir sicher, dass wir im richtigen Arbeitsverzeichnis sind. Dadurch wird sichergestellt, dass alle unsere Befehle mit den erwarteten Dateipfaden funktionieren:

cd ~/project

Die Option --print-timers teilt Tshark mit, die Zeit zu verfolgen und zu melden, die es für verschiedene Aufgaben bei der Paketverarbeitung benötigt. Versuchen wir es mit einer Beispielaufzeichnung von DHCP-Verkehr, die mit Wireshark ausgeliefert wird:

tshark --print-timers -r /usr/share/wireshark/example_captures/dhcp.pcap

Nachdem Sie diesen Befehl ausgeführt haben, sehen Sie eine Ausgabe ähnlich der folgenden:

Timer 1: 0.000000 seconds
Timer 2: 0.000123 seconds
...

Diese Zeitmesser repräsentieren verschiedene Phasen der Paketverarbeitung. Um uns auf einen bestimmten Zeitmesser zu konzentrieren, können wir grep verwenden, um die Ausgabe zu filtern. Beispielsweise, um nur die Ergebnisse von Timer 1 anzuzeigen:

tshark --print-timers -r /usr/share/wireshark/example_captures/dhcp.pcap | grep "Timer 1"

Hier ist, was jeder Hauptzeitmesser typischerweise misst:

Timer 1: Zeit, die für das Lesen der Aufzeichnungsdatei von der Festplatte benötigt wird
Timer 2: Zeit, die für die Verarbeitung und Dekodierung von Paketen benötigt wird
Timer 3: Zeit, die für die Anwendung von Anzeigefiltern (falls welche verwendet werden) benötigt wird

Das Verständnis dieser Zeitmesser hilft, Leistungsschneckentrapen zu identifizieren, wenn Sie mit großen Aufzeichnungsdateien oder komplexen Filterungsszenarien arbeiten.

Verarbeiten von Dateien mit -r capture.pcap

In diesem Schritt lernen Sie, wie Sie Paketaufzeichnungsdateien mit dem Befehlszeilentool tshark von Wireshark mithilfe der Option -r verarbeiten können. Dies ist unerlässlich für die Analyse von zuvor aufgezeichnetem Netzwerkverkehr, der in .pcap-Dateien gespeichert ist. .pcap-Dateien sind binäre Dateien, die aufgezeichnete Netzwerkpakete enthalten.

Stellen Sie zunächst sicher, dass Sie sich im richtigen Arbeitsverzeichnis befinden. Dies ist wichtig, da einige Befehle erwarten, dass sich die Dateien an bestimmten Orten befinden:
```
cd ~/project
```
Betrachten wir eine Beispiel-DHCP-Aufzeichnungsdatei, die mit der Wireshark-Installation ausgeliefert wird. DHCP (Dynamic Host Configuration Protocol) ist ein Netzwerkprotokoll, das verwendet wird, um Geräten automatisch IP-Adressen zuzuweisen. Das -r-Flag teilt tshark mit, aus der angegebenen Datei zu lesen:
```
tshark -r /usr/share/wireshark/example_captures/dhcp.pcap
```
Die Ausgabe zeigt jedes Paket mit grundlegenden Informationen in Spalten an:
- Paketnummer
- Zeitstempel (Sekunden seit Beginn der Aufzeichnung)
- Quell- → Ziel-IP-Adressen
- Protokoll (in diesem Fall DHCP)
- Paketlänge
- Protokollspezifische Informationen
```
1 0.000000 192.168.0.1 → 192.168.0.10 DHCP 342 DHCP Discover - Transaction ID 0x7c3e0c29
2 0.023512 192.168.0.10 → 192.168.0.1 DHCP 342 DHCP Offer - Transaction ID 0x7c3e0c29
...
```
Um die Gesamtzahl der Pakete in der Aufzeichnungsdatei zu zählen, leiten wir (|) die tshark-Ausgabe an wc -l weiter, das die Zeilen zählt. Jedes Paket wird in einer Zeile angezeigt:
```
tshark -r /usr/share/wireshark/example_captures/dhcp.pcap | wc -l
```
Für eine tiefere Analyse können wir das -V-Flag (ausführliche Ausgabe) verwenden, um alle verfügbaren Paketdetails anzuzeigen. Da dies eine große Menge an Ausgabe erzeugt, verwenden wir head -20, um nur die ersten 20 Zeilen anzuzeigen:
```
tshark -r /usr/share/wireshark/example_captures/dhcp.pcap -V | head -20
```

Filtern von TCP-Verkehr mit -Y "tcp"

In diesem Schritt lernen Sie, wie Sie TCP-Verkehr mithilfe der Anzeigefilteroption -Y von Wireshark filtern können. TCP (Transmission Control Protocol) ist eines der Kernprotokolle in der Netzwerkkommunikation und verantwortlich für die zuverlässige Datenübertragung. Der -Y-Filter hilft, TCP-Pakete von anderen Netzwerkverkehr zu isolieren, was bei der Analyse von Webbrowsing, Dateiübertragungen oder anderen TCP-basierten Anwendungen unerlässlich ist.

Stellen Sie zunächst sicher, dass Sie sich im richtigen Arbeitsverzeichnis befinden. Dies ist wichtig, da einige Befehle von relativen Dateipfaden abhängen können:
```
cd ~/project
```
Wenden wir nun einen einfachen TCP-Filter auf unsere Beispielaufzeichnungsdatei an. Das -r-Flag gibt die Eingabedatei an, während -Y "tcp" tshark anweist, nur TCP-Pakete anzuzeigen:
```
tshark -r /usr/share/wireshark/example_captures/http.pcap -Y "tcp"
```
Die Ausgabe zeigt nur TCP-Pakete an, einschließlich des TCP-Handshakes (SYN, SYN-ACK) und der anschließenden Datenübertragungen. Jede Zeile repräsentiert ein TCP-Paket mit seiner Sequenznummer, Fenstergröße und Flags:
```
1 0.000000 192.168.1.100 → 192.168.1.1 TCP 74 49278 → 80 [SYN] Seq=0 Win=64240 Len=0
2 0.000042 192.168.1.1 → 192.168.1.100 TCP 74 80 → 49278 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0
...
```
Wenn Sie nur zählen möchten, wie viele TCP-Pakete in der Aufzeichnung enthalten sind, können Sie die Ausgabe an wc -l weiterleiten. Dies ist nützlich für schnelle Statistiken:
```
tshark -r /usr/share/wireshark/example_captures/http.pcap -Y "tcp" | wc -l
```
Für eine gezieltere Analyse können Sie TCP-Verkehr auf bestimmten Ports filtern. Dieses Beispiel zeigt nur Verkehr auf Port 80 (HTTP). Beachten Sie, wie wir tcp.port anstelle von nur tcp verwenden, um die Portnummer anzugeben:
```
tshark -r /usr/share/wireshark/example_captures/http.pcap -Y "tcp.port == 80"
```

Analyse der JSON-Zeitmessungsausgabe

In diesem Schritt werden wir untersuchen, wie Wireshark Zeitinformationen im JSON-Format aufzeichnet. JSON (JavaScript Object Notation) ist ein leichtgewichtiges Datenformat, das sowohl für Menschen einfach lesbar als auch für Maschinen einfach zu parsen ist. Wir werden die Paketaufzeichnungs- und Filterfähigkeiten aus den vorherigen Schritten kombinieren, um sinnvolle Zeitstatistiken zu generieren.

Bevor wir beginnen, stellen wir sicher, dass wir uns im richtigen Verzeichnis befinden. Der Projektordner enthält alle erforderlichen Dateien und hält unsere Arbeit organisiert:

cd ~/project

Jetzt werden wir Zeitdaten speziell für TCP-Pakete generieren. Das --print-timers-Flag teilt Tshark mit, Zeitinformationen in seiner Ausgabe einzuschließen, während -T json diese im JSON-Format formatiert. Wir speichern dies in einer Datei für eine spätere Analyse:

tshark -r /usr/share/wireshark/example_captures/http.pcap -Y "tcp" --print-timers -T json > tcp_timings.json

Werfen wir einen kurzen Blick auf die Struktur unserer JSON-Ausgabe. Der head-Befehl zeigt uns die ersten 20 Zeilen, was uns hilft, zu verstehen, wie die Daten organisiert sind, bevor wir sie weiter verarbeiten:

head -20 tcp_timings.json

Um effektiv mit JSON-Daten zu arbeiten, verwenden wir jq, einen leistungsstarken Befehlszeilen-JSON-Prozessor. Wenn Sie es noch nicht installiert haben, wird dieser Befehl es einrichten:

sudo apt-get install -y jq

Jetzt können wir spezifische Zeitmetriken extrahieren. Dieser Befehl filtert das JSON, um nur die Zeitgeberinformationen für jedes Paket anzuzeigen, wodurch wir eine sauberere Ansicht der Zeitdaten erhalten:

jq '.[].timers' tcp_timings.json | head -10

Schließlich erstellen wir eine fokussiertere Zusammenfassung, die nur die Paketnummern und die entsprechenden Verarbeitungszeiten anzeigt. Dies gibt uns eine klare Ansicht, wie lange die Verarbeitung jedes Pakets gedauert hat:

jq '.[].timers | {packet_number: .packet_num, processing_time: .processing_time}' tcp_timings.json | head -5

Zusammenfassung

In diesem Lab haben Sie gelernt, die Leistung von Tshark zu profilieren, indem Sie die Option --print-timers verwenden, um Verarbeitungsphasen wie Dateilesen und Paketverarbeitung zu analysieren. Die Übungen haben gezeigt, wie man Zeitstatistiken interpretiert, um Netzwerkanalyse-Workflows zu optimieren.

Sie haben auch essentielle Paketanalyse-Techniken geübt, darunter die Verarbeitung von Aufzeichnungsdateien mit -r, die Untersuchung von Paketinhalt und die Nutzung des ausführlichen Modus. Das Lab hat praktische Erfahrungen mit Wireshark's Beispieldateien vermittelt, um grundlegende Fähigkeiten in der Netzwerkverkehrsanalyse aufzubauen.