8 Layer 4 - Die Transportschicht

8.1 Einführung: End-to-End-Kommunikation

Die Transportschicht (Layer 4) ist für die zuverlässige Datenübertragung zwischen Anwendungsprozessen verantwortlich und bildet die Brücke zwischen den Anwendungen und den Netzwerkdiensten. Während Layer 3 (die Vermittlungsschicht) sich mit der Weiterleitung von Paketen zwischen Netzwerken befasst, konzentriert sich Layer 4 auf die End-to-End-Kommunikation zwischen den eigentlichen Prozessen auf Quell- und Zielgeräten. Die zwei Hauptprotokolle auf dieser Schicht im TCP/IP-Modell sind TCP (Transmission Control Protocol) und UDP (User Datagram Protocol).

8.2 Hauptaufgaben von Layer 4

  1. Prozess-zu-Prozess-Kommunikation: Verwendung von Ports zur Identifikation von Anwendungen
  2. Verbindungsmanagement: Aufbau, Aufrechterhaltung und Abbau von Verbindungen (bei verbindungsorientierten Protokollen)
  3. Zuverlässige Datenübertragung: Sicherstellung, dass Daten vollständig und in der richtigen Reihenfolge ankommen
  4. Flusskontrolle: Anpassung der Übertragungsrate an die Kapazität des Empfängers
  5. Staukontrolle: Vermeidung von Netzwerküberlastung

8.3 Transmission Control Protocol (TCP)

TCP ist ein verbindungsorientiertes, zuverlässiges Protokoll, das sicherstellt, dass alle Daten ordnungsgemäß und in der richtigen Reihenfolge übertragen werden.

8.3.1 TCP-Paketformat (TCP-Segment)

Ein TCP-Segment enthält folgende Hauptkomponenten:

8.3.2 TCP-Verbindungsaufbau (Three-Way Handshake)

  1. SYN: Client sendet Segment mit gesetztem SYN-Flag und initialer Sequenznummer
  2. SYN-ACK: Server antwortet mit gesetztem SYN- und ACK-Flag, eigener Sequenznummer und Bestätigung der Client-Sequenznummer
  3. ACK: Client bestätigt die Server-Sequenznummer
Client                 Server
  |                      |
  |------ SYN, seq=x --->|  (1)
  |                      |
  |<-- SYN-ACK, seq=y ---|  (2)
  |       ack=x+1        |
  |                      |
  |------ ACK, ack=y+1 ->|  (3)
  |                      |
  |    Verbindung        |
  |    hergestellt       |

8.3.3 TCP-Verbindungsabbau (Four-Way Handshake)

  1. FIN: Eine Seite signalisiert den Verbindungsabbau mit dem FIN-Flag
  2. ACK: Die andere Seite bestätigt
  3. FIN: Die andere Seite sendet ebenfalls ein FIN
  4. ACK: Die erste Seite bestätigt
Client                 Server
  |                      |
  |------ FIN, seq=m --->|  (1)
  |                      |
  |<----- ACK, ack=m+1 --|  (2)
  |                      |
  |<----- FIN, seq=n ----|  (3)
  |                      |
  |------ ACK, ack=n+1 ->|  (4)
  |                      |
  |    Verbindung        |
  |    beendet           |

8.3.4 TCP-Zustandsdiagramm

TCP-Verbindungen durchlaufen verschiedene Zustände:

8.3.5 TCP-Zuverlässigkeitsmechanismen

  1. Bestätigungen und Retransmission: Empfänger bestätigt erhaltene Daten, Sender wiederholt unbestätigte Daten
  2. Sequenznummern: Ermöglichen die Erkennung von Duplikaten und die Wiederherstellung der korrekten Reihenfolge
  3. Checksummen: Erkennung von Übertragungsfehlern
  4. Timeouts: Wiederholung nach Zeitüberschreitung
  5. Sliding Window: Effizienter Transport mehrerer Segmente vor Bestätigung

8.3.6 TCP-Flusskontrolle

Die Flusskontrolle verhindert, dass ein schneller Sender einen langsamen Empfänger überlastet:

8.3.7 TCP-Staukontrolle

Die Staukontrolle verhindert eine Überlastung des Netzwerks:

8.4 User Datagram Protocol (UDP)

UDP ist ein verbindungsloses, unzuverlässiges Protokoll, das minimalen Overhead bietet.

8.4.1 UDP-Paketformat (UDP-Datagramm)

Ein UDP-Datagramm enthält folgende Komponenten:

8.4.2 Eigenschaften von UDP

8.5 TCP vs. UDP: Wann welches Protokoll?

Eigenschaft TCP UDP
Verbindung Verbindungsorientiert Verbindungslos
Zuverlässigkeit Garantierte Zustellung Best-Effort (keine Garantie)
Reihenfolge Erhält die Reihenfolge Keine Reihenfolgegarantie
Geschwindigkeit Langsamer durch Overhead Schneller, minimaler Overhead
Overhead Mindestens 20 Bytes Header 8 Bytes Header
Staukontrolle Ja Nein
Anwendungsbeispiele Webseiten, E-Mail, Dateien Streaming, DNS, VOIP, Spiele

8.6 Ports

Ports sind 16-Bit-Nummern (0-65535), die Anwendungen oder Dienste auf einem Host identifizieren.

8.6.1 Port-Kategorien

8.6.2 Socket

Ein Socket ist eine Kombination aus IP-Adresse und Port und identifiziert eindeutig eine Prozess-zu-Prozess-Kommunikation:

8.7 Layer 4 in Linux: Analyse und Überwachung

Linux bietet verschiedene Tools zur Analyse und Überwachung von Transportschichtverbindungen.

8.7.1 Netzwerkverbindungen anzeigen mit netstat

$ netstat -tuln
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State      
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN     
tcp        0      0 127.0.0.1:631           0.0.0.0:*               LISTEN     
tcp6       0      0 :::22                   :::*                    LISTEN     
udp        0      0 0.0.0.0:68              0.0.0.0:*                          
udp        0      0 0.0.0.0:5353            0.0.0.0:*

Optionen:

8.7.2 Verbindungen mit ss (Socket Statistics) anzeigen

$ ss -tuln
Netid  State    Recv-Q   Send-Q     Local Address:Port      Peer Address:Port  
udp    UNCONN   0        0                0.0.0.0:68             0.0.0.0:*      
udp    UNCONN   0        0                0.0.0.0:5353           0.0.0.0:*      
tcp    LISTEN   0        128              0.0.0.0:22             0.0.0.0:*      
tcp    LISTEN   0        5              127.0.0.1:631            0.0.0.0:*      
tcp    LISTEN   0        128                 [::]:22                [::]:*

Erweiterte Verwendung:

$ ss -tunlp
Netid  State    Recv-Q   Send-Q     Local Address:Port     Peer Address:Port   Process
udp    UNCONN   0        0                0.0.0.0:68            0.0.0.0:*       users:(("dhclient",pid=1234,fd=6))
tcp    LISTEN   0        128              0.0.0.0:22            0.0.0.0:*       users:(("sshd",pid=1456,fd=3))
tcp    LISTEN   0        5              127.0.0.1:631           0.0.0.0:*       users:(("cupsd",pid=1678,fd=12))

8.7.3 TCP-Verbindungszustände in Linux

In Linux-Ausgaben finden sich die folgenden TCP-Zustände:

8.7.4 Prozess-zu-Port-Zuordnung mit lsof

Das Tool lsof (List Open Files) kann verwendet werden, um zu sehen, welche Prozesse welche Ports nutzen:

$ lsof -i :22
COMMAND   PID USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
sshd     1456 root    3u  IPv4  16423      0t0  TCP *:ssh (LISTEN)
sshd     1456 root    4u  IPv6  16425      0t0  TCP *:ssh (LISTEN)
$ lsof -i TCP:80
COMMAND   PID     USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
nginx    2345     root    6u  IPv4  24567      0t0  TCP *:http (LISTEN)
nginx    2346 www-data    6u  IPv4  24567      0t0  TCP *:http (LISTEN)

8.7.5 Überwachung von TCP/UDP-Verbindungen in Echtzeit

Mit watch kann man die Ausgabe von ss oder netstat kontinuierlich aktualisieren:

$ watch -n 1 'ss -tunp | grep http'

8.7.6 PID und Socketstatistiken detailliert anzeigen

$ cat /proc/net/tcp
  sl  local_address rem_address   st tx_queue rx_queue tr tm->when retrnsmt   uid  timeout inode
   0: 0100007F:0277 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 16490 1 0000000000000000 100 0 0 10 0
   1: 00000000:0016 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 16423 1 0000000000000000 100 0 0 10 0

Diese Datei zeigt detaillierte Informationen über TCP-Verbindungen, inklusive Warteschlangenlängen, Timeouts und mehr.

8.7.7 Socket-Puffer und Warteschlangen analysieren

$ ss -tmi
State   Recv-Q  Send-Q  Local Address:Port   Peer Address:Port  
ESTAB   0       0       192.168.1.10:22      192.168.1.20:54321  
         skmem:(r0,rb87380,t0,tb16384,f0,w0,o0,bl0,d0)

8.7.8 Netzwerktraffic mit tcpdump analysieren

tcpdump ermöglicht die Erfassung und Analyse von TCP/UDP-Paketen auf Netzwerkschnittstellen:

$ tcpdump -i eth0 tcp port 80
$ tcpdump -i eth0 'tcp[tcpflags] & (tcp-syn|tcp-fin|tcp-rst) != 0'

Diese letzte Anweisung zeigt nur TCP-Pakete mit gesetzten SYN-, FIN- oder RST-Flags an, was hilfreich ist, um Verbindungsaufbau und -abbau zu überwachen.

8.8 Port-Scanning und Sicherheit

8.8.1 Port-Scanning mit nmap

$ nmap -sT 192.168.1.10        # TCP-Connect-Scan
$ nmap -sS 192.168.1.10        # TCP-SYN-Scan (benötigt root-Rechte)
$ nmap -sU 192.168.1.10        # UDP-Scan
$ nmap -sV -p 22,80,443 192.168.1.10  # Version-Scan für bestimmte Ports

8.8.2 Schutz vor unerwünschten Verbindungen mit iptables/nftables

# Eingehende Verbindungen zu Port 22 erlauben
$ iptables -A INPUT -p tcp --dport 22 -j ACCEPT

# Alle anderen eingehenden Verbindungen blockieren
$ iptables -A INPUT -p tcp --syn -j DROP

# Verbindungsversuche protokollieren
$ iptables -A INPUT -p tcp --dport 23 -j LOG --log-prefix "Telnet-Versuch: "

8.9 Praktische Anwendungen und Fehlerbehebung

8.9.1 TCP-Verbindungsaufbauprobleme erkennen

  1. SYN-Pakete werden gesendet, aber keine Antwort:
  2. Viele Verbindungen im SYN-RECEIVED-Zustand:
  3. Viele Verbindungen im TIME-WAIT-Zustand:

8.9.2 Ressourcenverwendung überwachen

# Anzahl der offenen TCP-Verbindungen pro Zustand
$ ss -tan | awk '{print $1}' | sort | uniq -c

# Top-10 der Verbindungen nach Quell-IP
$ ss -tan | awk '{print $(NF)" "$(NF-1)}' | sort | uniq -c | sort -rn | head -10

# Prozesse mit den meisten Netzwerkverbindungen
$ lsof -n -i | awk '{print $1}' | sort | uniq -c | sort -rn | head

8.10 Die wichtigsten Fakten

Die Transportschicht bildet die kritische Brücke zwischen Anwendungen und dem Netzwerk und ist entscheidend für die Ende-zu-Ende-Kommunikation zwischen Prozessen über das Internet oder andere Netzwerke.