Debuggen mit Protokollen in Tshark

Einführung

In diesem Lab werden Sie essentielle Debugging-Techniken mit dem Befehlszeilentool Tshark von Wireshark lernen. Sie werden untersuchen, wie Sie Debug-Level mit --log-level festlegen, Live-Netzwerkverkehr auf eth0 mit -i erfassen und Logs mit --log-file in Dateien speichern können, um sie später zu analysieren.

Durch praktische Übungen werden Sie das Konfigurieren von Debug-Modi, das Überwachen von Netzwerkverkehr und das Interpretieren von Log-Ausgaben üben. Dieses Lab bietet praktische Erfahrungen mit den Kern-Debugging-Funktionen von Tshark in einer kontrollierten VM-Umgebung.

Festlegen des Debug-Levels mit --log-level debug

In diesem Schritt lernen Sie, wie Sie die Detailstufe der Protokollmeldungen (Log-Nachrichten) einstellen können, wenn Sie das Befehlszeilentool tshark von Wireshark verwenden. Die Option --log-level hilft Ihnen, zu steuern, wie viel Informationen tshark anzeigt. Dies ist besonders nützlich, wenn Sie verstehen möchten, was im Hintergrund passiert, oder wenn Sie Probleme beheben müssen.

Zunächst bereiten wir unsere Arbeitsumgebung vor. Öffnen Sie ein Terminal in Ihrer LabEx-VM. Wir werden im Standardprojektverzeichnis arbeiten, um alles organisiert zu halten:
```
cd ~/project
```
Die grundlegende Befehlsstruktur zum Einstellen der Protokollierungsstufen ist einfach. Sie geben einfach die gewünschte Stufe nach der Option an:
```
tshark --log-level <level>
```
Hier sind die am häufigsten verwendeten Protokollierungsstufen, von der wenigsten zur meiste Detailstufe geordnet:
- critical - Zeigt nur schwerwiegende Fehler an, die möglicherweise verhindern, dass tshark funktioniert
- warning - Zeigt potenzielle Probleme an, die nicht kritisch sind, aber beachtenswert sind
- message - Die Standardstufe, die normale Betriebsmeldungen anzeigt
- info - Liefert zusätzliche Informationsmeldungen über die Aktivitäten von tshark
- debug - Zeigt die detailliertesten technischen Informationen für eine tiefergehende Fehlersuche
Für diese Übung verwenden wir die Stufe debug, um die maximale Menge an Informationen zu sehen. Dies hilft uns, alle hinter den Kulissen ablaufenden Vorgänge von tshark zu verstehen. Führen Sie diesen Befehl aus:
```
tshark --log-level debug
```
Nach dem Ausführen des Befehls werden Sie feststellen, dass es viel mehr Ausgabe gibt als normalerweise. Diese Debug-Ausgabe enthält Initialisierungsdetails, interne Verarbeitungsmeldungen und technische Informationen darüber, wie tshark den Netzwerkverkehr verarbeitet.
Wenn Sie tshark beenden möchten, drücken Sie einfach Strg+C im Terminal. Diese Tastenkombination sendet ein Unterbrechungssignal, um den aktuell laufenden Befehl zu stoppen.

Netzwerkverkehr mit -i eth0 erfassen

In diesem Schritt werden wir untersuchen, wie man Live-Netzwerkverkehr mit dem leistungsstarken Befehlszeilentool tshark von Wireshark erfassen kann. Netzwerkschnittstellen sind die physischen oder virtuellen Punkte, an denen Ihr Computer an ein Netzwerk angeschlossen ist. eth0 ist in Linux-Systemen typischerweise die erste Ethernet-Schnittstelle.

Zunächst identifizieren wir, welche Netzwerkschnittstellen auf Ihrer LabEx-VM verfügbar sind. Dies hilft uns sicherzustellen, dass wir die richtige Schnittstelle überwachen:
```
tshark -D
```
Dieser Befehl listet alle Netzwerkschnittstellen auf, auf die tshark zugreifen kann. Suchen Sie in der Ausgabe nach eth0 – dies ist normalerweise Ihre primäre Ethernet-Verbindung.
Jetzt beginnen wir mit der Erfassung des eigentlichen Netzwerkverkehrs. Die Option -i teilt tshark mit, welche Schnittstelle überwacht werden soll:
```
tshark -i eth0
```
Wenn Pakete durch Ihr Netzwerk fließen, werden sie in Echtzeit angezeigt. Jede Zeile repräsentiert ein Netzwerkpaket und zeigt:
- Die genaue Zeit, zu der es erfasst wurde (Zeitstempel)
- Wo es herkommt und wohin es geht (IP-Adressen)
- Welche Art von Netzwerkkommunikation es enthält (Protokoll)
- Wie viel Daten es trägt (Paketlänge)
Lassen Sie die Erfassung etwa 10 Sekunden laufen, um eine repräsentative Stichprobe des Netzwerkverkehrs zu sammeln. Wenn Sie fertig sind, drücken Sie Strg+C, um die Erfassung zu stoppen. So erhalten Sie praktische Erfahrungen mit der Live-Paketerfassung.
Manchmal möchten Sie möglicherweise eine bestimmte Anzahl von Paketen erfassen. Die Option -c ermöglicht es Ihnen, diese Grenze festzulegen:
```
tshark -i eth0 -c 10
```
Dieser Befehl stoppt automatisch, nachdem genau 10 Pakete erfasst wurden. Dies ist nützlich für schnelle Tests.
Sie können dies mit der Fehlersuche kombinieren, um detailliertere Informationen über den Erfassungsprozess zu erhalten:
```
tshark -i eth0 --log-level debug
```
Dies zeigt nicht nur die Pakete, sondern auch die internen Vorgänge von tshark an und hilft Ihnen, zu verstehen, was im Hintergrund passiert.

Protokollieren in eine Datei mit --log-file tshark.log

In diesem Schritt lernen Sie, wie Sie die tshark-Erfassungsprotokolle (Log-Dateien) mithilfe der Option --log-file in einer Datei speichern können, um sie später zu analysieren. Dies ist besonders nützlich, wenn Sie Netzwerkverkehrsmuster dokumentieren oder Konnektivitätsprobleme beheben müssen, da es Ihnen ermöglicht, die Daten nach Belieben zu überprüfen, anstatt die Echtzeitausgabe zu beobachten.

Stellen Sie zunächst sicher, dass Sie sich im Standardarbeitsverzeichnis befinden. Dies ist wichtig, da die Protokolldatei im aktuellen Verzeichnis erstellt wird:
```
cd ~/project
```
Um den Netzwerkverkehr zu erfassen und gleichzeitig alle Protokolle in einer Datei namens tshark.log zu speichern, führen Sie diesen Befehl aus. Die Option -i eth0 gibt an, dass wir vom Ethernet-Interface erfassen:
```
tshark -i eth0 --log-file tshark.log
```
Lassen Sie die Erfassung etwa 10 Sekunden laufen, um genügend Daten zu sammeln. Drücken Sie dann Strg+C, um den Erfassungsprozess ordnungsgemäß zu beenden. Dieser Tastaturbefehl stellt sicher, dass die Protokolldatei richtig geschlossen wird.
Überprüfen Sie, ob die Protokolldatei erfolgreich erstellt wurde, indem Sie den Inhalt des Verzeichnisses auflisten. Die Option -l zeigt detaillierte Dateiinformationen wie Größe und Zeitstempel an:
```
ls -l tshark.log
```
Sie sollten die Datei mit ihrer Größe und Erstellungszeit sehen, was bestätigt, dass die Erfassung wie erwartet funktioniert hat.
Sehen Sie sich den Inhalt der Protokolldatei an, um die erfassten Pakete zu untersuchen. Der Befehl cat zeigt den gesamten Dateiinhalt in Ihrem Terminal an:
```
cat tshark.log
```
Die Ausgabe zeigt die erfassten Pakete in einem lesbaren Format an, einschließlich Zeitstempeln, Quell- und Zieladressen sowie Protokollinformationen.
Für ein umfassenderes Beispiel, das die vorherigen Schritte kombiniert, versuchen Sie diesen erweiterten Befehl, der mehrere nützliche Parameter enthält:
```
tshark -i eth0 --log-level debug --log-file tshark.log -c 20
```
Dieser umfassende Befehl wird:
- Pakete speziell vom eth0-Netzwerkschnittstelle erfassen
- Die Protokollierungsstufe auf Debug einstellen, um maximale Details zu erhalten
- Alle Ausgaben in die Datei tshark.log speichern
- Automatisch stoppen, nachdem genau 20 Pakete erfasst wurden

Protokolle auf Fehler überprüfen

In diesem Schritt werden Sie die im vorherigen Schritt erstellte tshark-Protokolldatei analysieren, um potenzielle Netzwerkprobleme und Fehler zu identifizieren. Dies ist eine entscheidende Fähigkeit für die Netzwerkfehlersuche, da Protokolle detaillierte Aufzeichnungen der Netzwerkaktivität und potenzieller Probleme enthalten.

Navigieren Sie zunächst in Ihr Projektverzeichnis, wenn Sie sich nicht bereits dort befinden. Dadurch stellen Sie sicher, dass Sie mit der richtigen Protokolldatei arbeiten:
```
cd ~/project
```
Sehen Sie sich den gesamten Inhalt der Protokolldatei an, um einen Überblick über den erfassten Netzwerkverkehr zu erhalten. Der Befehl cat zeigt den gesamten Dateiinhalt in Ihrem Terminal an:
```
cat tshark.log
```
Um gezielt nach Fehlermeldungen im Protokoll zu suchen, verwenden Sie grep mit einer gross- und kleinschreibungsunabhängigen Suche (-i-Option). Dies hilft, alle Fehlereinträge zu finden, unabhängig von der Groß- oder Kleinschreibung:
```
grep -i "error" tshark.log
```
Für eine umfassendere Analyse suchen Sie nach mehreren Arten von Problemen, einschließlich Warnungen und Fehlschlägen. Die -E-Option ermöglicht erweiterte reguläre Ausdrücke:
```
grep -E -i "error|warning|fail" tshark.log
```
Um die Anzahl der Fehlerereignisse zu quantifizieren, leiten Sie die grep-Ausgabe an den Wortzähler (wc) mit der Zeilenzählung (-l) weiter. So erhalten Sie schnell einen Überblick darüber, wie viele Fehler protokolliert wurden:
```
grep -i "error" tshark.log | wc -l
```
Für eine strukturiertere Ansicht von Paketebenenfehlern verwenden Sie tsharks Anzeigefilter (-Y), um nur Frames mit Fehlerflags anzuzeigen. Dies hilft, problematische Pakete in Ihrer Erfassung zu identifizieren:
```
tshark -r tshark.log -Y "frame.error_flag == 1"
```
Um nur die Fehlermeldungen für eine weitere Analyse oder Berichterstattung zu speichern, leiten Sie die grep-Ausgabe in eine neue Datei um. Dadurch wird ein sauberes, nur Fehler enthaltendes Protokoll erstellt:
```
grep -i "error" tshark.log > errors.txt
```

Zusammenfassung

In diesem Lab haben Sie praktische Techniken zur Netzwerkverkehrsanalyse mit dem Befehlszeilentool tshark von Wireshark gelernt. Sie haben die Einstellung der Debug-Ebene mit --log-level debug untersucht, um detaillierte Betriebsmeldungen zu erhalten, was für die Fehlersuche bei komplexen Netzwerkproblemen von entscheidender Bedeutung ist.

Darüber hinaus haben Sie das Erfassen von Live-Verkehr auf der Schnittstelle eth0 geübt, indem Sie verfügbare Schnittstellen identifiziert und Echtzeit-Paketedaten analysiert haben. Diese grundlegenden Fähigkeiten ermöglichen eine effiziente Netzwerküberwachung und Problemdiagnose in Befehlszeilenumgebungen.