Wire-Level Paketanalyse mit tcpdump & Berkeley Packet Filters (BPF)

Erstellt: 08.11.2026 · Zuletzt aktualisiert: 08.11.2026 · Nejat Hakan

Management Summary: Wenn Systemprotokolle, Reverse-Proxy-Fehlerseiten und Firewall-Metriken widersprüchliche Diagnosen liefern, gilt im Netzwerkbetrieb ein unumstößlicher Grundsatz: Pakete auf der Leitung lügen niemals. Basierend auf der AF_PACKET-Socketschnittstelle des Linux-Kernels und der Bibliothek libpcap ist tcpdump das mächtigste Werkzeug zur Echtzeit-Paketinspektion. Durch die Auswertung von Berkeley Packet Filters (BPF) direkt im Kernel-Speicher filtert es Multi-Gigabit-Datenströme ohne spürbare CPU-Last, identifiziert TCP-Handshake-Blockaden und erzeugt forensische PCAP-Dateien für die Offline-Analyse in Wireshark.

In-Kernel BPF-Engine

Verstehe, wie BPF-Bytecode im Kernel-Speicher unerwünschte Frames verwirft, noch bevor teure Speicherkopien in den User-Space stattfinden.
TCP-Flag-Diagnose

Firewall-Drops, geschlossene Ports (RST) und hängende TLS-Handshakes anhand von SYN-, ACK-, FIN- und RST-Bits eindeutig unterscheiden.
Fortgeschrittene BPF-Syntax

Bitmasken auf Byte-Offsets anwenden, um TCP-Verbindungsversuche, ICMP-Fragmentierungsfehler und DNS-Timeouts gezielt zu isolieren.
Rotierende PCAP-Ringpuffer

Sporadische Produktivfehler ohne das Risiko volllaufender Festplatten aufzeichnen: Feste Ringpuffer mit -C und -W dimensionieren.

1. Die Architektur des Paketmitschnitts: `AF_PACKET` & In-Kernel BPF

Wie kann tcpdump Netzwerkverkehr abfangen, ohne laufende Anwendungen zu stören? Es nutzt die AF_PACKET-Socketschnittstelle des Linux-Kernels:

%%{init: {'flowchart': {'wrappingWidth': 350}}}%%
flowchart TB
    NIC["Physischer NIC RX Ring"] --> DRIVER["Treiber der Netzwerkkarte"]
    DRIVER --> CLONE["Kernel Packet Cloner"]
    CLONE -->|"Regulärer Pfad"| STACK["TCP/IP Kernel Stack"]
    CLONE -->|"Raw Copy"| BPF["In-Kernel BPF Engine<br/>Prüft Bytecode im RAM"]
    BPF -->|"Kein Treffer"| DROP["Verworfen (0% CPU)"]
    BPF -->|"Treffer"| RING["AF_PACKET Ring Buffer"]
    RING -->|"recvfrom()"| TCPDUMP["tcpdump Prozess<br/>Schreibt PCAP / stdout"]

Der Performance-Vorteil von In-Kernel BPF

Würde tcpdump jedes Paket über die Kernelschnittstelle in den User-Space kopieren, um dort String-Vergleiche durchzuführen, bräche die CPU bei Gigabit-Datenraten unter Interrupt-Last zusammen. Stattdessen wird dein BPF-Filterausdruck (z. B. 'tcp port 443') in BPF-Bytecode übersetzt und direkt im Kernel ausgeführt. Nicht passende Pakete werden in Nanosekunden verworfen.

2. Die goldene Capture-Regel & essenzielle Parameter

Die goldene Regel: IMMER -nn verwenden

Führe tcpdump niemals ohne den Parameter -nn aus. Ohne das erste -n versucht tcpdump, alle IP-Adressen per Reverse-DNS (PTR) in Hostnamen aufzulösen. Ohne das zweite -n werden Portnummern in Dienstnamen übersetzt. Die DNS-Abfragen erzeugen sofort neuen Netzwerkverkehr, den tcpdump erneut mitschneidet – eine katastrophale Endlosschleife, die das Terminal einfriert und das Netz flutet!

Wichtige CLI-Parameter im Überblick

Parameter	Bedeutung & Praxiseinsatz
`-nn`	Deaktiviert DNS- und Portnamen-Auflösung. Zwingend erforderlich in der Produktion.
`-i eth0`	Bestimmt die Schnittstelle (`-i any` lauscht auf allen Interfaces, Bridges und Loopbacks).
`-s 0`	Setzt die Snapshot-Länge auf 0 (schneidet das gesamte Paket ohne Kürzung mit).
`-v`, `-vv`, `-vvv`	Erhöht die Detailtiefe (zeigt TTL, IP-IDs, TCP-Optionen und Prüfsummen an).
`-X` / `-XX`	Gibt Nutzdaten zusätzlich in Hexadezimal- und ASCII-Darstellung aus (ideal für HTTP/DNS).
`-e`	Gibt Layer-2-Ethernet-Header aus (Quell-/Ziel-MAC-Adressen und 802.1Q-VLAN-Tags).
`-c 100`	Beendet den Mitschnitt automatisch nach genau 100 passenden Paketen.
`-w trace.pcap`	Schreibt die Rohpakete direkt als Binärdatei für die spätere Analyse in Wireshark.
`-r trace.pcap`	Liest und analysiert eine bestehende PCAP-Datei offline im Terminal.

3. Berkeley Packet Filters (BPF-Syntax) beherrschen

BPF-Filter verknüpfen Primitive, Richtungen und Protokolle über logische Operatoren (and, or, not):

1. Grundlegende Filter-Primitive

# Gesamten Datenverkehr zu oder von Host 10.10.20.11 mitschneiden
sudo tcpdump -i eth0 -nn host 10.10.20.11

# Ausgehenden Webverkehr zu einem bestimmten Subnetz erfassen
sudo tcpdump -i eth0 -nn 'dst net 198.51.100.0/24 and (port 80 or port 443)'

# Eigenen SSH-Verkehr ausfiltern, um das Terminal nicht vollzuspammen
sudo tcpdump -i eth0 -nn 'not port 22'

2. Bitmasken auf TCP-Flags anwenden

Die wahre Stärke von BPF liegt in bitweisen Operationen auf Byte-Offsets. Die TCP-Flags befinden sich an Byte-Position 13 des TCP-Headers:

%%{init: {'flowchart': {'wrappingWidth': 350}}}%%
flowchart TB
    BYTE["TCP-Header Byte 13 (Flags)<br/>Session-Steuerungs-Bits"]

    subgraph InitGroup ["Verbindungsaufbau"]
        direction TB
        S["SYN (Bit 1): 0x02"]
        A["ACK (Bit 4): 0x10"]
        S --> A
    end

    subgraph TermGroup ["Verbindungsabbau"]
        direction TB
        F["FIN (Bit 0): 0x01"]
        R["RST (Bit 2): 0x04"]
        F --> R
    end

    BYTE --> InitGroup
    InitGroup --> TermGroup

# 1. Nur initiale Verbindungsversuche erfassen (SYN ohne ACK)
sudo tcpdump -i eth0 -nn 'tcp[tcpflags] & (tcp-syn|tcp-ack) == tcp-syn'

# 2. Verbindungsabbrüche und Resets erfassen (RST gesetzt)
sudo tcpdump -i eth0 -nn 'tcp[tcpflags] & tcp-rst != 0'

# 3. IPv4-Pakete mit gesetztem Don't-Fragment-Bit (DF) filtern
sudo tcpdump -i eth0 -nn 'ip[6] & 0x40 != 0'

4. Troubleshooting-Rezepte („Pakete lügen niemals“)

1. TCP 3-Way Handshake analysieren

Starte folgenden Mitschnitt während eines Verbindungsversuchs mit curl oder einem Datenbank-Client:

sudo tcpdump -i eth0 -nn -c 10 'tcp port 5432'

Muster der TCP-Flags auswerten:

Muster A: Gesunder, offener Port

Client.49210 > Server.5432: Flags [S], seq 100234
Server.5432 > Client.49210: Flags [S.], seq 892301, ack 100235
Client.49210 > Server.5432: Flags [.], ack 892302

Analyse: [S] (SYN) gefolgt von [S.] (SYN-ACK) und [.] (ACK). Die Verbindung steht erfolgreich.

Muster B: Port erreicht, aber Dienst gestoppt (Connection Refused)
```
Client.49210 > Server.5432: Flags [S], seq 100234
Server.5432 > Client.49210: Flags [R.], seq 0, ack 100235
```
Analyse: [R.] (RST-ACK). Das Paket erreichte den Zielhost, aber dort lauscht kein Prozess auf Port 5432.
Muster C: Firewall-Drop (Connection Timed Out)
```
Client.49210 > Server.5432: Flags [S], seq 100234
Client.49210 > Server.5432: Flags [S], seq 100234 (Retransmission)
```
Analyse: Wiederholte [S]-Pakete ohne jede Antwort des Servers. Das Paket wurde von nftables, UFW oder einer Cloud-Security-Group lautlos verworfen.

2. DNS-Probleme diagnostizieren

sudo tcpdump -i any -nn -c 20 'port 53'

Prüfe Query-IDs und Antwortcodes (NXDOMAIN, SERVFAIL oder fehlende Antworten).

3. Path MTU Discovery Fehler aufspüren

sudo tcpdump -i any -nn 'icmp[icmptype] == icmp-unreach and icmp[icmpcode] == 4'

Erkennt ICMP-Nachrichten des Typs Fragmentation Needed, die von fehlerhaften Zwischen-Firewalls verschluckt werden.

5. Rotierende PCAP-Ringpuffer in der Produktion

Um sporadisch auftretende Fehler über Stunden aufzuzeichnen, ohne Festplatten zum Überlaufen zu bringen, nutze -C (Dateigröße in MB) und -W (Anzahl rotierender Dateien):

# Zeichnet Pakete in /var/log/captures/ auf
# Rotiert zwischen 5 Dateien zu je 100 MB (Maximal 500 MB Festplattenbelegung)
sudo mkdir -p /var/log/captures
sudo tcpdump -i eth0 -nn -s 0 -C 100 -W 5 -w /var/log/captures/app_debug.pcap 'port 443 or port 5432'

tcpdump erzeugt zyklisch app_debug.pcap0 bis app_debug.pcap4 und überschreibt älteste Daten automatisch.

6. Live-Streaming direkt in Wireshark via SSH

Statt .pcap-Dateien umständlich per scp herunterzuladen, streame die Pakete direkt vom entfernten Debian-Server in dein lokales Wireshark auf der Workstation:

# Auf der lokalen Workstation ausführen:
ssh root@203.0.113.10 "tcpdump -U -s 0 -nn -i eth0 -w - 'not port 22'" | wireshark -k -i -

-U: Weist tcpdump an, Pakete sofort ungepuffert an stdout auszugeben.
-w -: Schreibt Rohdaten direkt in die Standardausgabe der SSH-Session.
wireshark -k -i -: Startet Wireshark sofort (-k) und liest aus stdin (-i -).

7. Nächste Schritte: Wechsel zu Cluster 3

Herzlichen Glückwunsch! Du hast Cluster 2: Sicherheit, Tunnel & Firewalling vollständig abgeschlossen. Im nächsten Cluster widmen wir uns dem Herzstück moderner RZ- und Cloud-Infrastrukturen:

Cluster 3: Linux als Layer-3 Router & NAT

Debian zum Enterprise-Router machen: IP-Forwarding, SNAT-Masquerading, DNAT-Portweiterleitung und Connection-Tracking-Tuning.

Zum Layer-3 Routing Leitfaden