Zum Inhalt

Souveräne VPN-Infrastruktur: WireGuard Kernel-Space Kryptografie, Split-Tunnel Routing & nftables Härtung

Erstellt: 06.11.2026 Aktualisiert: 06.11.2026

Management Summary: Klassische VPN-Protokolle (OpenVPN, IPsec/IKEv2) leiden unter erheblichem Kontextwechsel-Overhead zwischen Kernel- und Userspace, komplexen Krypto-Aushandlungen und aufwendiger Zertifikatsverwaltung. Diese Architekturreferenz beschreibt den Betrieb von WireGuard direkt im Linux-Kernel (net/wireguard). Sie etabliert performante, kryptografisch kompromisslose Punkt-zu-Punkt- und Road-Warrior-Netzwerke mit ChaCha20-Poly1305, Curve25519, Post-Quanten-Schutz (PresharedKey), Dual-Stack IPv4/IPv6-Forwarding via nftables und Split-Horizon-DNS-Integration.

  • Kryptografische Klarheit

    Beseitigt Cipher-Suite-Aushandlungslücken durch feste moderne Primitive: Curve25519 ECDH, ChaCha20-Poly1305 AEAD, BLAKE2s-Hashing und SipHash24.

  • Kernel-Space Performance

    Paketverschlüsselung und Cryptokey Routing laufen direkt im Netzwerkstack des Linux-Kernels – ohne langsame /dev/net/tun-Kontextwechsel.

  • Cryptokey Routing-Tabelle

    Bindet öffentliche Peer-Schlüssel direkt an IP-Präfixe (AllowedIPs), um strikte Ingress-Filterung und Egress-Routing gleichzeitig zu erzwingen.

  • Stateful nftables NAT & Kill-Switch

    Gewährleistet leckfreies Forwarding, MSS-Clamping (tcp option maxseg size) und post-quantensichere symmetrische Schlüssel (wg genpsk).

1. Architektur-Paradigmen: Cryptokey Routing & Noise Protocol Framework

Anders als OpenVPN – das einen virtuellen tun0-Deskriptor nutzt und jedes IP-Paket zwischen Kernel und einem Userspace-OpenSSL-Prozess hin- und herkopiert – arbeitet WireGuard als natives virtuelles Linux-Kernel-Netzwerkinterface (wg0), basierend auf dem Noise_IK-Handshake:

%%{init: {'flowchart': {'wrappingWidth': 600}}}%%
flowchart TB
    subgraph ClientNode["Road-Warrior / Mobiler Peer"]
        App["Applikations-Socket<br/>10.88.0.2"]
        WGClient["Kernel wg0 Interface<br/>Curve25519 + ChaCha20"]
    end

    subgraph UntrustedNet["Öffentliches Internet (UDP/51820)"]
        UDP["Verschlüsseltes UDP-Payload<br/>Stealth / Keine Antwort bei Scan"]
    end

    subgraph ServerNode["Souveränes WireGuard Gateway"]
        WGServer["Kernel wg0 Interface<br/>Cryptokey Routing Table"]
        NFT["nftables forward / nat<br/>TCP MSS Clamping"]
        Unbound["Lokales Unbound DNS<br/>10.88.0.1:53"]
        LAN["Internes Server-VLAN<br/>192.168.10.0/24"]
    end

    App -->|"Unverschlüsseltes IP-Paket"| WGClient
    WGClient -->|"AEAD ChaCha20-Poly1305"| UDP
    UDP -->|"Verifizierter Peer-Key"| WGServer
    WGServer -->|"Port 53"| Unbound
    WGServer -->|"Subnetze"| NFT
    NFT -->|"Gerouteter Traffic"| LAN

Stealth-Verhalten & DoS-Resilienz

  1. Unsichtbarkeit bei Portscans: Ein WireGuard-UDP-Port (51820/udp) antwortet niemals auf unauthentifizierte Pakete. Enthält ein eingehendes Datagramm keinen gültigen MAC-Header (msg.mac1), verwirft der Kernel das Paket lautlos. Für Nmap (nmap -sU) ist der Port nicht von einem gefilterten oder geschlossenen Port zu unterscheiden.
  2. Stateless Cookie bei Überlast: Erfährt das Gateway ein hohes UDP-Flood-Volumen, antwortet es mit einem zustandslosen kryptografischen Cookie (msg.mac2), bevor rechenintensive Curve25519-Punktmultiplikationen durchgeführt werden.
  3. Flüchtige Sitzungsschlüssel (Perfect Forward Secrecy): WireGuard rotiert symmetrische Sitzungsschlüssel alle 180 Sekunden (REKEY_AFTER_TIME) oder nach 2⁶⁰ Paketen und löscht vorherige Schlüssel im Kernel-RAM.
Architektur-Metrik WireGuard (Linux Kernel) OpenVPN (DCO / Userspace) IPsec (StrongSwan / XFRM)
Codebasis-Umfang ~4.000 Zeilen C > 100.000 Zeilen (mit OpenSSL) > 400.000 Zeilen
Ausführungskontext Multi-Threaded Linux Kernel Userspace (oder DCO-Modul) Kernel XFRM + Userspace IKE Daemon
Handshake-Latenz 1-RTT (Noise_IK) 3–6 RTTs (TLS Handshake) 2–4 RTTs (IKEv2)
Roaming-Unterstützung Nahtlos (Aktualisiert Endpoint bei gültigem Paket) Erfordert Session-Renegotiation MOBIKE-Erweiterung erforderlich

2. Gateway-Einrichtung & Schlüsselzeremonie

Installiere die Userspace-Werkzeuge (wireguard-tools) und aktiviere IPv4/IPv6-Paket-Forwarding dauerhaft via sysctl.d:

/etc/sysctl.d/99-wireguard-router.conf
# IPv4- und IPv6-Paketweiterleitung aktivieren
net.ipv4.ip_forward = 1
net.ipv6.conf.all.forwarding = 1

# Loose Reverse Path Filtering für asymmetrisches VPN-Routing
net.ipv4.conf.all.rp_filter = 2
net.ipv4.conf.default.rp_filter = 2

# UDP-Socket-Puffer für hohe Durchsätze optimieren
net.core.rmem_max = 26214400
net.core.wmem_max = 26214400

Kernel-Parameter sofort anwenden via sudo sysctl --system.

Schlüsselpaare mit Post-Quanten-Schutz erzeugen

Selbst wenn ein Quantencomputer Curve25519 künftig per Shor-Algorithmus brechen sollte, sorgt ein symmetrischer 256-Bit PresharedKey (wg genpsk) für zusätzliche Entropie bei der HKDF-Schlüsselableitung und schützt vor „Harvest Now, Decrypt Later“-Szenarien:

Restriktive Schlüsselverwaltung unter /etc/wireguard
sudo mkdir -p /etc/wireguard/keys
sudo chmod 0700 /etc/wireguard /etc/wireguard/keys

# Gateway-Schlüsselpaar erzeugen
wg genkey | sudo tee /etc/wireguard/keys/server.key | wg pubkey | sudo tee /etc/wireguard/keys/server.pub

# Client-Schlüsselpaar (Laptop) + Post-Quanten Pre-Shared Key erzeugen
wg genkey | sudo tee /etc/wireguard/keys/peer_laptop.key | wg pubkey | sudo tee /etc/wireguard/keys/peer_laptop.pub
wg genpsk | sudo tee /etc/wireguard/keys/peer_laptop.psk

sudo chmod 0600 /etc/wireguard/keys/*

3. Gehärtete Gateway- & Client-Konfiguration

Statt fehleranfälliger iptables-Befehle in PostUp/PostDown nutzen wir ein atomares nftables-Regelwerk, das beim Start der wg0-Schnittstelle eine dedizierte Tabelle lädt und beim Beenden wieder restlos entfernt:

/etc/wireguard/wg0.conf
[Interface]
Address = 10.88.0.1/24, fd88:cafe:1::1/64
ListenPort = 51820
PrivateKey = <INSERT_SERVER_PRIVATE_KEY>
# MTU-Fragmentierung bei PPPoE / Mobilfunk verhindern
MTU = 1380

# Atomare nftables-Regeln beim Start/Stopp laden
PostUp = nft -f /etc/wireguard/nft-wg0-up.nft
PostDown = nft delete table inet wg0_firewall

# --- Peer 1: Entwickler-Laptop ---
[Peer]
PublicKey = 8xK9pL2mN4vQ7wR1tY5uI0oP3aS6dF8gH2jK4lZ9xC0=
PresharedKey = 4mB7nV9cX2zL5kJ8hG1fD4sA7pO0iU3yT6rE9wQ2aZ8=
AllowedIPs = 10.88.0.10/32, fd88:cafe:1::10/128
/etc/wireguard/nft-wg0-up.nft
table inet wg0_firewall {
    chain forward {
        type filter hook forward priority filter; policy drop;

        # Bestehende Verbindungen erlauben
        ct state established,related accept

        # TCP MSS an Path-MTU anpassen (verhindert TLS-Handshake-Timeouts!)
        tcp flags syn tcp option maxseg size set rt mtu

        # Traffic von WireGuard ins Internet (eth0) und interne Netze erlauben
        iifname "wg0" oifname "eth0" accept
    }

    chain postrouting {
        type nat hook postrouting priority srcnat; policy accept;

        # VPN IPv4 und IPv6 ULA beim Verlassen über eth0 maskieren
        iifname "wg0" oifname "eth0" ip saddr 10.88.0.0/24 masquerade
        iifname "wg0" oifname "eth0" ip6 saddr fd88:cafe:1::/64 masquerade
    }
}
/etc/wireguard/laptop.conf
[Interface]
Address = 10.88.0.10/32, fd88:cafe:1::10/128
PrivateKey = <INSERT_PEER_LAPTOP_PRIVATE_KEY>
DNS = 10.88.0.1, fd88:cafe:1::1
MTU = 1380

# FULL TUNNEL: Sämtlichen Datenverkehr über das Gateway leiten
AllowedIPs = 0.0.0.0/0, ::/0

# SPLIT TUNNEL ALTERNATIVE: Nur VPN-Subnetz & internes LAN routen
# AllowedIPs = 10.88.0.0/24, 192.168.10.0/24, fd88:cafe:1::/64

# NAT-Mappings bei Carrier-Grade NAT (CGNAT) offen halten
PersistentKeepalive = 25

Schnittstelle aktivieren:

Systemd wg-quick Unit aktivieren
sudo systemctl enable --now wg-quick@wg0.service

4. Routing-Richtlinien (fwmark) & Leak-Schutz

Konfiguriert ein Client AllowedIPs = 0.0.0.0/0, überschreibt wg-quick nicht einfach das Default-Gateway der Haupttabelle (was eine Endlosschleife für verschlüsselte UDP-Pakete erzeugen würde). Stattdessen greift Policy-Based Routing (PBR) via FwMark:

  1. Jedes verschlüsselte äußere UDP-Paket des wg0-Sockets wird mit fwmark 0xca6c (51820) markiert.
  2. Eine Kernel-ip rule leitet alle unmarkierten Pakete (not fwmark 0xca6c) in Tabelle 51820, wo default dev wg0 liegt.
  3. Markierte Pakete umgehen Tabelle 51820 und verlassen den Rechner über das physische Gateway in table main.

5. Verifikation & Live-Telemetrie

Prüfe aktive Handshakes, Datendurchsatz und Routing ohne laufende Sitzungen zu stören:

WireGuard Handshakes und Status prüfen
# 1. Aktive Peers, Handshake-Zeitstempel und Datenzähler anzeigen
sudo wg show wg0

# 2. Konfiguration dynamisch neu einlesen, ohne bestehende Sessions zu trennen
sudo bash -c 'wg syncconf wg0 <(wg-quick strip wg0)'

# 3. Kernel Dynamic-Debug für Handshake-Diagnose aktivieren (dmesg -w)
echo 'module wireguard +p' | sudo tee /sys/kernel/debug/dynamic_debug/control