💡 Hinweis: Dieses Tutorial setzt voraus, dass du einen normalen Benutzer mit sudo-Rechten verwendest — wie im Tutorial Debian 13 Server absichern beschrieben.

Einleitung — Was ist WireGuard und warum solltest du es nutzen?

WireGuard ist ein modernes, schlankes VPN-Protokoll, das direkt im Linux-Kernel läuft. Es wurde von Jason A. Donenfeld entwickelt und ist seit Linux 5.6 fester Bestandteil des Kernels. Im Vergleich zu OpenVPN oder IPsec bietet WireGuard erhebliche Vorteile:

  • Minimaler Code: ~4.000 Zeilen vs. ~100.000 bei OpenVPN — weniger Code bedeutet weniger Angriffsfläche und einfacheres Auditing.
  • Höhere Performance: Durch die Kernel-Integration ist WireGuard deutlich schneller. In Benchmarks erreicht es oft 2-4x den Durchsatz von OpenVPN.
  • Moderne Kryptografie: ChaCha20 für Verschlüsselung, Poly1305 für Authentifizierung, Curve25519 für Schlüsselaustausch, BLAKE2s für Hashing. Keine veralteten Cipher-Suiten, keine Konfigurationsfehler möglich.
  • Einfache Konfiguration: Eine einzige Konfigurationsdatei pro Interface — kein Zertifikats-Management wie bei OpenVPN.
  • Roaming-fähig: WireGuard kommt mit wechselnden IP-Adressen zurecht — ideal für mobile Geräte.
  • Stealth: WireGuard antwortet nicht auf unauthentifizierte Pakete. Ein Portscan zeigt nichts an.

In diesem Tutorial richten wir einen vollständigen WireGuard-VPN-Server auf Debian 13 (Trixie) ein — vom Installieren über die Server- und Client-Konfiguration bis hin zu fortgeschrittenen Themen wie Site-to-Site-VPN, DNS-Tunneling und Performance-Optimierung.

Voraussetzungen

Bevor du loslegst, stelle sicher, dass folgende Punkte erfüllt sind:

  • Debian 13 (Trixie) — frisch installiert und aktualisiert
  • Root-Zugang oder ein User mit sudo-Rechten
  • Server abgesichert — SSH-Härtung, Firewall aktiv, Updates eingespielt. Falls noch nicht geschehen: Lies zuerst Tutorial #1: Debian 13 Server absichern.
  • Öffentliche IP-Adresse — dein Server muss aus dem Internet erreichbar sein
  • Ein freier UDP-Port — Standard ist 51820

Alle Befehle in diesem Tutorial werden als root ausgeführt. Falls du einen normalen User nutzt, stelle jedem Befehl sudo voran.

WireGuard installieren

Auf Debian 13 ist WireGuard in den Standard-Repositories enthalten. Die Installation ist denkbar einfach:

apt update
apt install wireguard wireguard-tools

Das Paket wireguard installiert das Kernel-Modul (falls nicht bereits im Kernel enthalten), wireguard-tools liefert die Userspace-Tools wg und wg-quick.

Prüfe, ob das Kernel-Modul geladen ist:

modprobe wireguard
lsmod | grep wireguard

Du solltest eine Ausgabe wie diese sehen:

wireguard             94208  0
curve25519_x86_64      36864  1 wireguard
libchacha20poly1305    16384  1 wireguard

Prüfe außerdem die installierte Version:

wg --version

Schlüsselpaare generieren (Server + Client)

WireGuard nutzt asymmetrische Kryptografie mit Curve25519-Schlüsselpaaren. Jeder Teilnehmer (Server und jeder Client) braucht ein eigenes Schlüsselpaar bestehend aus Private Key und Public Key.

Server-Schlüsselpaar

# Sichere Berechtigungen für das Verzeichnis
umask 077

# Private Key generieren
wg genkey | tee /etc/wireguard/server_private.key | wg pubkey > /etc/wireguard/server_public.key

# Schlüssel anzeigen (den Public Key brauchst du für die Clients)
cat /etc/wireguard/server_private.key
cat /etc/wireguard/server_public.key

Wichtig: Der Private Key darf niemals weitergegeben werden! Setze restriktive Dateiberechtigungen:

chmod 600 /etc/wireguard/server_private.key

Client-Schlüsselpaar

Für jeden Client generierst du ein eigenes Schlüsselpaar. Am besten direkt auf dem Server in einem separaten Verzeichnis:

mkdir -p /etc/wireguard/clients
cd /etc/wireguard/clients

# Client 1
wg genkey | tee client1_private.key | wg pubkey > client1_public.key

# Optional: Pre-Shared Key für zusätzliche Sicherheit (Post-Quantum-Schutz)
wg genpsk > client1_psk.key

chmod 600 client1_private.key client1_psk.key

Der Pre-Shared Key (PSK) ist optional, bietet aber eine zusätzliche symmetrische Verschlüsselungsschicht. Das schützt selbst dann, wenn in Zukunft die Curve25519-Kryptografie gebrochen werden sollte (Post-Quantum-Sicherheit).

Server-Konfiguration (/etc/wireguard/wg0.conf)

Erstelle die Server-Konfigurationsdatei:

nano /etc/wireguard/wg0.conf

Füge folgenden Inhalt ein:

[Interface]
# Private IP-Adresse des Servers im VPN-Netz
Address = 10.0.0.1/24
# UDP-Port, auf dem WireGuard lauscht
ListenPort = 51820
# Private Key des Servers
PrivateKey = <INHALT_VON_server_private.key>

# Optional: DNS-Server für Clients
# DNS = 10.0.0.1

# PostUp/PostDown für NAT (siehe nächster Abschnitt)
PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

# --- Client 1 ---
[Peer]
PublicKey = <INHALT_VON_client1_public.key>
PresharedKey = <INHALT_VON_client1_psk.key>
# Welche IPs darf dieser Client im VPN nutzen?
AllowedIPs = 10.0.0.2/32

Erklärung der Parameter:

  • Address: Die VPN-interne IP des Servers. /24 definiert das Subnetz (10.0.0.0 – 10.0.0.255).
  • ListenPort: Der UDP-Port. Standard ist 51820. Du kannst jeden freien Port wählen.
  • PrivateKey: Der Private Key des Servers — ersetze den Platzhalter mit dem tatsächlichen Schlüssel.
  • PostUp/PostDown: Befehle, die beim Starten/Stoppen des Interfaces ausgeführt werden. Hier aktivieren wir NAT.
  • AllowedIPs: Definiert, welche IP-Adressen dieser Peer im VPN nutzen darf. /32 = genau eine IP.

Wichtig: Ersetze eth0 durch dein tatsächliches Netzwerk-Interface. Prüfe es mit:

ip route show default
# Ausgabe z.B.: default via 203.0.113.1 dev ens3 proto dhcp
# → Dein Interface ist "ens3"

Setze sichere Berechtigungen:

chmod 600 /etc/wireguard/wg0.conf

IP-Forwarding & NAT einrichten

Damit der VPN-Traffic vom Client über den Server ins Internet geroutet wird, muss IP-Forwarding aktiviert sein.

IP-Forwarding dauerhaft aktivieren

# Prüfen, ob bereits aktiv
sysctl net.ipv4.ip_forward

# Dauerhaft aktivieren
echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.d/99-wireguard.conf

# Optional: Auch für IPv6
echo "net.ipv6.conf.all.forwarding = 1" >> /etc/sysctl.d/99-wireguard.conf

# Sofort anwenden
sysctl -p /etc/sysctl.d/99-wireguard.conf

NAT mit iptables

Die NAT-Regeln haben wir bereits in der wg0.conf über PostUp/PostDown definiert. Falls du sie lieber separat verwalten möchtest:

# Manuell setzen (nicht nötig, wenn PostUp in wg0.conf steht)
iptables -A FORWARD -i wg0 -j ACCEPT
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

Alternative: NAT mit nftables

Debian 13 setzt standardmäßig auf nftables als Firewall-Backend. Falls du nftables direkt nutzen möchtest, ersetze die PostUp/PostDown-Zeilen in wg0.conf durch:

PostUp = nft add table ip wireguard; nft add chain ip wireguard forward { type filter hook forward priority 0 \; }; nft add rule ip wireguard forward iifname "wg0" accept; nft add chain ip wireguard nat { type nat hook postrouting priority 100 \; }; nft add rule ip wireguard nat oifname "eth0" masquerade
PostDown = nft delete table ip wireguard

Oder erstelle eine eigene nftables-Konfiguration unter /etc/nftables.conf:

table ip wireguard {
    chain forward {
        type filter hook forward priority 0; policy accept;
        iifname "wg0" accept
        oifname "wg0" ct state related,established accept
    }
    chain nat {
        type nat hook postrouting priority 100;
        oifname "eth0" masquerade
    }
}

WireGuard starten & als Service einrichten

Manuell starten und testen

# Interface starten
wg-quick up wg0

# Status prüfen
wg show

# Interface-Details anzeigen
ip addr show wg0

Die Ausgabe von wg show sollte in etwa so aussehen:

interface: wg0
  public key: <SERVER_PUBLIC_KEY>
  private key: (hidden)
  listening port: 51820

peer: <CLIENT1_PUBLIC_KEY>
  preshared key: (hidden)
  allowed ips: 10.0.0.2/32

Als systemd-Service einrichten

Damit WireGuard automatisch beim Booten startet:

# Service aktivieren
systemctl enable wg-quick@wg0

# Service starten
systemctl start wg-quick@wg0

# Status prüfen
systemctl status wg-quick@wg0

Falls du Änderungen an der Konfiguration vornimmst, starte den Service neu:

systemctl restart wg-quick@wg0

Tipp: Für Änderungen an Peers ohne Neustart kannst du auch wg set und wg syncconf nutzen:

# Peer hinzufügen ohne Neustart
wg set wg0 peer <CLIENT_PUBLIC_KEY> allowed-ips 10.0.0.3/32

# Oder: Konfiguration live synchronisieren
wg syncconf wg0 <(wg-quick strip wg0)

Client einrichten

Die Client-Konfiguration ist auf allen Plattformen identisch aufgebaut. Nur die Art der Installation unterscheidet sich.

Client-Konfigurationsdatei

Erstelle auf dem Server die Konfiguration für Client 1:

cat > /etc/wireguard/clients/client1.conf << EOF
[Interface]
# Private IP des Clients im VPN
Address = 10.0.0.2/32
# Private Key des Clients
PrivateKey = $(cat /etc/wireguard/clients/client1_private.key)
# DNS-Server (optional, z.B. Cloudflare)
DNS = 1.1.1.1, 1.0.0.1

[Peer]
# Public Key des Servers
PublicKey = $(cat /etc/wireguard/server_public.key)
# Pre-Shared Key
PresharedKey = $(cat /etc/wireguard/clients/client1_psk.key)
# Server-Adresse und Port
Endpoint = DEINE_SERVER_IP:51820
# Welchen Traffic über VPN leiten?
# 0.0.0.0/0 = ALLES (Full Tunnel)
# 10.0.0.0/24 = Nur VPN-Netz (Split Tunnel)
AllowedIPs = 0.0.0.0/0, ::/0
# Keep-Alive alle 25 Sekunden (wichtig hinter NAT)
PersistentKeepalive = 25
EOF

Wichtig: Ersetze DEINE_SERVER_IP durch die öffentliche IP-Adresse oder den Hostnamen deines Servers.

Linux-Client

# WireGuard installieren
apt install wireguard    # Debian/Ubuntu
dnf install wireguard-tools    # Fedora
pacman -S wireguard-tools    # Arch

# Konfiguration kopieren
scp root@SERVER_IP:/etc/wireguard/clients/client1.conf /etc/wireguard/wg0.conf

# Verbinden
wg-quick up wg0

# Automatisch starten
systemctl enable --now wg-quick@wg0

# Verbindung testen
ping 10.0.0.1
curl ifconfig.me    # Sollte die Server-IP zeigen

Windows-Client

  1. Lade den offiziellen WireGuard Windows Client herunter und installiere ihn.
  2. Öffne die WireGuard-App → „Tunnel hinzufügen“ → „Tunnel aus Datei importieren“
  3. Wähle die client1.conf-Datei aus
  4. Klicke auf „Aktivieren“

Alternativ kannst du die Konfiguration auch per QR-Code importieren (siehe unten).

macOS-Client

  1. Installiere WireGuard aus dem Mac App Store
  2. Öffne die App → „Tunnel importieren aus Datei“
  3. Wähle die client1.conf
  4. Aktiviere den Tunnel

Oder per Terminal mit Homebrew:

brew install wireguard-tools
sudo wg-quick up /path/to/client1.conf

Android & iOS

Für mobile Geräte ist der QR-Code-Import am einfachsten:

# qrencode installieren
apt install qrencode

# QR-Code im Terminal anzeigen
qrencode -t ansiutf8 < /etc/wireguard/clients/client1.conf
  1. Installiere die WireGuard-App aus dem Google Play Store oder Apple App Store
  2. Öffne die App → „+“ → „Aus QR-Code erstellen“
  3. Scanne den QR-Code
  4. Vergib einen Namen und aktiviere den Tunnel

Mehrere Clients verwalten

Für jeden weiteren Client wiederholst du den Prozess: Schlüsselpaar generieren, Peer in wg0.conf hinzufügen, Client-Konfiguration erstellen.

Automatisiertes Script

Dieses Script vereinfacht das Anlegen neuer Clients:

#!/bin/bash
# add-wg-client.sh — Neuen WireGuard-Client anlegen

set -e

CLIENT_NAME="${1:?Bitte Client-Name angeben: ./add-wg-client.sh meinClient}"
SERVER_PUBLIC_KEY=$(cat /etc/wireguard/server_public.key)
SERVER_ENDPOINT="DEINE_SERVER_IP:51820"
CLIENT_DIR="/etc/wireguard/clients"

# Nächste freie IP finden
LAST_IP=$(grep -oP '10\.0\.0\.\K[0-9]+' /etc/wireguard/wg0.conf | sort -n | tail -1)
NEXT_IP=$((LAST_IP + 1))

if [ "$NEXT_IP" -gt 254 ]; then
    echo "Fehler: Keine freien IPs mehr im Subnetz!"
    exit 1
fi

echo "Erstelle Client: $CLIENT_NAME (10.0.0.$NEXT_IP)"

# Schlüssel generieren
umask 077
wg genkey | tee "$CLIENT_DIR/${CLIENT_NAME}_private.key" | wg pubkey > "$CLIENT_DIR/${CLIENT_NAME}_public.key"
wg genpsk > "$CLIENT_DIR/${CLIENT_NAME}_psk.key"

CLIENT_PRIVATE=$(cat "$CLIENT_DIR/${CLIENT_NAME}_private.key")
CLIENT_PUBLIC=$(cat "$CLIENT_DIR/${CLIENT_NAME}_public.key")
CLIENT_PSK=$(cat "$CLIENT_DIR/${CLIENT_NAME}_psk.key")

# Peer zur Server-Konfiguration hinzufügen
cat >> /etc/wireguard/wg0.conf << EOF

# --- $CLIENT_NAME ---
[Peer]
PublicKey = $CLIENT_PUBLIC
PresharedKey = $CLIENT_PSK
AllowedIPs = 10.0.0.$NEXT_IP/32
EOF

# Client-Konfiguration erstellen
cat > "$CLIENT_DIR/${CLIENT_NAME}.conf" << EOF
[Interface]
Address = 10.0.0.$NEXT_IP/32
PrivateKey = $CLIENT_PRIVATE
DNS = 1.1.1.1, 1.0.0.1

[Peer]
PublicKey = $SERVER_PUBLIC_KEY
PresharedKey = $CLIENT_PSK
Endpoint = $SERVER_ENDPOINT
AllowedIPs = 0.0.0.0/0, ::/0
PersistentKeepalive = 25
EOF

# Live hinzufügen (ohne Neustart)
wg set wg0 peer "$CLIENT_PUBLIC" preshared-key "$CLIENT_DIR/${CLIENT_NAME}_psk.key" allowed-ips "10.0.0.$NEXT_IP/32"

echo ""
echo "Client '$CLIENT_NAME' erstellt!"
echo "Config: $CLIENT_DIR/${CLIENT_NAME}.conf"
echo ""

# QR-Code anzeigen (falls qrencode installiert)
if command -v qrencode &> /dev/null; then
    echo "QR-Code:"
    qrencode -t ansiutf8 < "$CLIENT_DIR/${CLIENT_NAME}.conf"
fi

Nutzung:

chmod +x add-wg-client.sh
./add-wg-client.sh laptop
./add-wg-client.sh handy
./add-wg-client.sh tablet

Client entfernen

# Public Key des zu entfernenden Clients
CLIENT_PUBKEY=$(cat /etc/wireguard/clients/clientname_public.key)

# Peer live entfernen
wg set wg0 peer "$CLIENT_PUBKEY" remove

# Peer aus wg0.conf entfernen (manuell oder per sed)
# Danach Schlüsseldateien löschen

DNS über VPN leiten

Wenn du AllowedIPs = 0.0.0.0/0 nutzt (Full Tunnel), solltest du auch den DNS-Traffic über das VPN leiten. Andernfalls können DNS-Leaks deine echte IP verraten.

Option 1: Externen DNS in der Client-Config setzen

In der Client-Konfiguration:

[Interface]
DNS = 1.1.1.1, 1.0.0.1    # Cloudflare
# oder
DNS = 9.9.9.9, 149.112.112.112    # Quad9
# oder
DNS = 8.8.8.8, 8.8.4.4    # Google

Option 2: Eigenen DNS-Resolver auf dem VPN-Server

Für maximale Privatsphäre betreibst du einen eigenen DNS-Resolver:

# Unbound installieren
apt install unbound

# Konfiguration
cat > /etc/unbound/unbound.conf.d/wireguard.conf << EOF
server:
    interface: 10.0.0.1
    access-control: 10.0.0.0/24 allow
    access-control: 127.0.0.0/8 allow
    
    # Privacy
    hide-identity: yes
    hide-version: yes
    qname-minimisation: yes
    
    # Performance
    num-threads: 2
    msg-cache-size: 64m
    rrset-cache-size: 128m
    
    # DNSSEC
    auto-trust-anchor-file: "/var/lib/unbound/root.key"
EOF

# Starten
systemctl enable --now unbound

# Testen
dig @10.0.0.1 example.com

Dann in der Client-Config und der Server-Config:

DNS = 10.0.0.1

Option 3: Pi-hole als DNS mit Werbeblocker

Du kannst auch Pi-hole auf dem VPN-Server installieren und als DNS für alle VPN-Clients nutzen. So blockierst du Werbung und Tracker netzwerkweit:

# Pi-hole installieren
curl -sSL https://install.pi-hole.net | bash
# Bei der Installation: Interface wg0, DNS 10.0.0.1

# In der Client-Config:
DNS = 10.0.0.1

Site-to-Site VPN

Mit WireGuard kannst du nicht nur einzelne Clients, sondern ganze Netzwerke miteinander verbinden. Das ist ideal, um z.B. ein Büro-Netzwerk mit einem Rechenzentrum zu verknüpfen.

Szenario

  • Standort A (Server): LAN 192.168.1.0/24, WireGuard-IP 10.0.0.1
  • Standort B (Client): LAN 192.168.2.0/24, WireGuard-IP 10.0.0.2

Server-Konfiguration (Standort A)

[Interface]
Address = 10.0.0.1/24
ListenPort = 51820
PrivateKey = <SERVER_PRIVATE_KEY>

# IP-Forwarding aktivieren
PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

[Peer]
PublicKey = <STANDORT_B_PUBLIC_KEY>
# Erlaube sowohl die VPN-IP als auch das entfernte LAN
AllowedIPs = 10.0.0.2/32, 192.168.2.0/24

Client-Konfiguration (Standort B)

[Interface]
Address = 10.0.0.2/24
PrivateKey = <STANDORT_B_PRIVATE_KEY>

PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

[Peer]
PublicKey = <SERVER_PUBLIC_KEY>
Endpoint = SERVER_IP:51820
AllowedIPs = 10.0.0.1/32, 192.168.1.0/24
PersistentKeepalive = 25

Wichtig: Auf beiden Seiten muss IP-Forwarding aktiviert sein und die lokalen Geräte müssen wissen, dass das entfernte Netzwerk über den WireGuard-Gateway erreichbar ist. Dazu entweder statische Routen auf den Geräten setzen oder den WireGuard-Host als Default-Gateway verwenden.

Performance & MTU-Optimierung

WireGuard ist von Haus aus schnell, aber mit ein paar Anpassungen kannst du die Performance weiter optimieren.

MTU richtig setzen

Die Maximum Transmission Unit (MTU) bestimmt die maximale Paketgröße. WireGuard hat einen Overhead von 60 Bytes (IPv4) bzw. 80 Bytes (IPv6). Die optimale MTU berechnet sich so:

# Standard-Ethernet-MTU: 1500
# WireGuard IPv4-Overhead: 60 Bytes
# → Optimale MTU: 1440

# Bei IPv6:
# WireGuard IPv6-Overhead: 80 Bytes
# → Optimale MTU: 1420

Setze die MTU in der [Interface]-Sektion:

[Interface]
MTU = 1420    # Sicherer Wert für IPv4 und IPv6
# Rest der Konfiguration...

Tipp: Falls du hinter einem weiteren Tunnel sitzt (z.B. PPPoE mit MTU 1492), musst du den Wert entsprechend reduzieren:

# PPPoE-MTU (1492) - WireGuard-Overhead (60) = 1432
MTU = 1432

Du kannst die optimale MTU auch durch Testen ermitteln:

# Vom Client aus testen (DF-Bit gesetzt, keine Fragmentierung)
ping -M do -s 1392 10.0.0.1    # Funktioniert? → MTU ≥ 1420
ping -M do -s 1412 10.0.0.1    # Funktioniert? → MTU ≥ 1440
ping -M do -s 1432 10.0.0.1    # "Message too long"? → MTU < 1460

Weitere Optimierungen

# Kernel-Parameter für bessere Netzwerk-Performance
cat >> /etc/sysctl.d/99-wireguard.conf << EOF

# TCP-Optimierungen
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216
net.ipv4.tcp_congestion_control = bbr
net.core.default_qdisc = fq
EOF

sysctl -p /etc/sysctl.d/99-wireguard.conf

Der BBR-Congestion-Control-Algorithmus von Google verbessert den Durchsatz besonders bei Verbindungen mit hoher Latenz erheblich.

Benchmark

Teste die VPN-Geschwindigkeit mit iperf3:

# Auf dem Server
apt install iperf3
iperf3 -s

# Auf dem Client
iperf3 -c 10.0.0.1 -t 30 -P 4

Firewall-Regeln für WireGuard (UFW)

Falls du ufw als Firewall nutzt (wie im Absicherungs-Tutorial empfohlen), musst du WireGuard-Traffic erlauben:

Grundregeln

# WireGuard-Port öffnen
ufw allow 51820/udp comment "WireGuard"

# Traffic von/zu wg0 erlauben
ufw allow in on wg0
ufw allow out on wg0

IP-Forwarding in UFW aktivieren

Standardmäßig blockiert UFW weitergeleiteten Traffic. Du musst die Forward-Policy anpassen:

nano /etc/default/ufw

Ändere:

DEFAULT_FORWARD_POLICY="ACCEPT"

NAT-Regeln in UFW

Füge die NAT-Regeln in die UFW-Konfiguration ein:

nano /etc/ufw/before.rules

Füge vor der Zeile *filter ein:

# NAT für WireGuard
*nat
:POSTROUTING ACCEPT [0:0]
-A POSTROUTING -s 10.0.0.0/24 -o eth0 -j MASQUERADE
COMMIT

Dann UFW neu laden:

ufw reload

Hinweis: Wenn du die NAT-Regeln über UFW verwaltest, entferne die PostUp/PostDown-Zeilen aus der wg0.conf, um Konflikte zu vermeiden.

Zusammenfassung & Checkliste

Hier eine Checkliste zum Abhaken — damit du nichts vergisst:

  • ☐ Debian 13 aktualisiert — sudo apt update && apt upgrade
  • ☐ WireGuard installiert — sudo apt install wireguard wireguard-tools
  • ☐ Server-Schlüsselpaar generiert — Private Key sicher gespeichert
  • ☐ Client-Schlüsselpaar(e) generiert — inkl. optionalem PSK
  • ☐ Server-Konfiguration erstellt — /etc/wireguard/wg0.conf
  • ☐ IP-Forwarding aktiviert — sysctl-Datei angelegt
  • ☐ NAT konfiguriert — via PostUp/PostDown oder UFW
  • ☐ WireGuard gestartet — wg-quick up wg0
  • ☐ Autostart eingerichtet — sudo systemctl enable wg-quick@wg0
  • ☐ Firewall konfiguriert — Port 51820/udp offen, Forward erlaubt
  • ☐ Client eingerichtet — Konfiguration importiert, Verbindung getestet
  • ☐ DNS-Leak-Test — dnsleaktest.com zeigt nur den VPN-DNS
  • ☐ IP-Leak-Test — ipleak.net zeigt die Server-IP
  • ☐ Dateiberechtigungen geprüft — chmod 600 auf alle Keys und Configs

Troubleshooting

Verbindung kommt nicht zustande

# 1. Ist WireGuard aktiv?
wg show
systemctl status wg-quick@wg0

# 2. Lauscht der Port?
ss -ulnp | grep 51820

# 3. Firewall prüfen
ufw status
iptables -L -n

# 4. Logs prüfen (WireGuard ist standardmäßig leise)
# Debug-Modus aktivieren:
echo module wireguard +p > /sys/kernel/debug/dynamic_debug/control
dmesg | grep wireguard

# Debug wieder deaktivieren:
echo module wireguard -p > /sys/kernel/debug/dynamic_debug/control

Handshake findet nicht statt

  • Schlüssel vertauscht? Der Public Key des Servers muss in der Client-Config stehen und umgekehrt.
  • Endpoint falsch? Prüfe IP und Port.
  • NAT/Firewall blockiert? Teste mit nc -u -l 51820 auf dem Server und echo test | nc -u SERVER_IP 51820 vom Client.
  • Uhren synchron? WireGuard nutzt Zeitstempel. Prüfe mit timedatectl.

Verbindung steht, aber kein Internet

# IP-Forwarding aktiv?
sysctl net.ipv4.ip_forward    # Muss "1" sein

# NAT-Regeln vorhanden?
iptables -t nat -L -n | grep MASQUERADE

# DNS-Auflösung testen
ping 1.1.1.1        # Funktioniert? → DNS-Problem
ping google.com     # Funktioniert nicht? → DNS-Problem

# Korrektes Interface in PostUp?
ip route show default    # Zeigt das richtige Interface

Langsame Geschwindigkeit

  • MTU prüfen — Zu hohe MTU führt zu Fragmentierung. Teste verschiedene Werte (siehe oben).
  • CPU-Last prüfen — WireGuard nutzt den Kernel, aber bei vielen Clients kann die CPU zum Flaschenhals werden.
  • BBR aktivieren — Siehe Performance-Abschnitt oben.
  • iperf3-Test — Vergleiche mit/ohne VPN, um den Overhead zu messen.

Client trennt sich ständig

  • PersistentKeepalive setzen: PersistentKeepalive = 25 in der Client-Config. Besonders wichtig hinter NAT.
  • Mobilfunk: Manche Mobilfunkanbieter blockieren UDP. Teste mit einem anderen Netzwerk.

Nächste Schritte

Dein WireGuard-VPN läuft! Hier sind einige Ideen, wie du dein Setup weiter ausbauen kannst:

  • Monitoring einrichten: Nutze wg show in Kombination mit Prometheus/Grafana, um Traffic und Verbindungen zu überwachen. Das Tool prometheus_wireguard_exporter macht es einfach.
  • Web-Interface: Tools wie wg-easy bieten eine komfortable Web-Oberfläche zur Verwaltung von Clients.
  • Automatische Backups: Sichere /etc/wireguard/ regelmäßig — alle Schlüssel und Konfigurationen liegen dort.
  • Fail2Ban: WireGuard ist zwar von Natur aus stealth, aber du kannst trotzdem den SSH-Port zusätzlich per VPN-only absichern.
  • IPv6 einrichten: Nutze ein ULA-Prefix (z.B. fd00:vpn::1/64) für dein VPN und aktiviere IPv6-Forwarding.
  • Split-Tunneling: Leite nur bestimmten Traffic über das VPN, z.B. nur interne Ressourcen, während der Rest direkt geht.

Im nächsten Tutorial der Serie schauen wir uns an, wie du einen eigenen DNS-Server mit Pi-hole auf deinem VPN-Server einrichtest — für werbefreies Surfen über alle Geräte.

Hast du Fragen oder Probleme? Schreib einen Kommentar!