WireGuard VPN-Server auf Ubuntu einrichten: Kompletter Guide

WireGuard hat die Welt der virtuellen privaten Netzwerke (VPN) grundlegend revolutioniert. Im Gegensatz zu traditionellen Schwergewichten wie OpenVPN oder IPsec arbeitet WireGuard direkt als schlankes Kernel-Modul. Mit weniger als 4.000 Zeilen Quellcode bietet es minimale Angriffsfläche, modernste Kryptografie // Curve25519, ChaCha20-Poly1305, BLAKE2s // und maximale Datendurchsätze bei extrem niedriger Latenz.

Dieser Leitfaden führt dich durch die vollständige Einrichtung eines produktionsreifen WireGuard-Gateways unter Ubuntu 24.04 LTS (Noble Numbat) und Ubuntu 26.04 LTS (Resolute Raccoon) inklusive IPv4/IPv6 Dual-Stack, UFW-Firewall-Routing, Post-Quantum Pre-Shared Keys und automatisierter Peer-Generierung per QR-Code.

Die hier vermittelten Netzwerk- und Krypto-Grundlagen sind essenzieller Bestandteil moderner Serverumgebungen und orientieren sich an Standards von Prüfungen wie der LPIC-1 Serie.

💡 Hinweis: WireGuard ist seit Linux Kernel 5.6 fester Bestandteil des offiziellen Kernels. Unter Ubuntu 24.04 (Kernel 6.8) und Ubuntu 26.04 (Kernel 7.0) sind keine externen Repositories (PPAs) oder Kernel-Module aus Fremdquellen mehr erforderlich.

🚀 Vorteil gegenüber OpenVPN: WireGuard kennt kein schwerfälliges Verbindungs-Handshake-Protokoll im Userspace. Verbindungen stehen sofort („Instant Connect“) und überstehen IP-Wechsel (z. B. vom WLAN ins 5G-Mobilfunknetz) ohne Verbindungsabbruch (Roaming).

WireGuard Architektur & Tunnel-Konzept

Im WireGuard-Modell sind alle Teilnehmer gleichberechtigte Peers. In der Server-Praxis dient der Ubuntu-Host als zentrales Gateway, das den Datenverkehr der Clients verschlüsselt annimmt und über die physische Netzwerkschnittstelle ins lokale Netz oder ins Internet weiterleitet (NAT / Masquerading):


┌─────────────────────────────────────────────────────────────┐
│             WireGuard VPN Architektur & Tunnel              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   Remote Clients (Roadwarrior)      WireGuard Gateway       │
│   ┌───────────────────────────┐     ┌───────────────────┐   │
│   │ Laptop / Smartphone       │     │ Ubuntu Server     │   │
│   │ IP: 10.8.0.2 / fd42::2    │     │ IP: 10.8.0.1      │   │
│   └─────────────┬─────────────┘     └─────────┬─────────┘   │
│                 │                             │             │
│                 ▼                             ▼             │
│   ═══════════════════════════════════════════════════════   │
│       Verschlüsselter UDP-Tunnel (Port 51820 / ChaCha20)    │
│   ═══════════════════════════════════════════════════════   │
│                                               │             │
│                                               ▼             │
│                                 ┌───────────────────────┐   │
│                                 │ Internet & LAN-Netz   │   │
│                                 │ (NAT / Masquerading)  │   │
│                                 └───────────────────────┘   │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Die wichtigsten Eckdaten des Setups:

Parameter	Wert / Konfiguration	Zweck
VPN-Subnetz (IPv4)	`10.8.0.0/24`	Privater Adressraum für Tunnel-Clients (Server: `10.8.0.1`)
VPN-Subnetz (IPv6)	`fd42:42:42::/64`	Eindeutige Local-IPv6-Adressen (Server: `fd42:42:42::1`)
VPN-Port	`51820 / UDP`	Standard-Port für eingehenden WireGuard-Traffic
Verschlüsselung	ChaCha20-Poly1305 + Noise Protocol	State-of-the-Art symmetrische Tunnelverschlüsselung
Key-Austausch	Curve25519 (ECDH) + Pre-Shared Key (PSK)	Asymmetrischer Schlüsselaustausch mit Post-Quantum Schutz

Vorbereitung & Installation

1. System aktualisieren & Pakete installieren

Installiere das WireGuard-Core-Tool wireguard, das Hilfswerkzeug qrencode (für Smartphone-QR-Codes) und iptables:


sudo apt update && sudo apt upgrade -y
sudo apt install wireguard wireguard-tools qrencode iptables -y

Überprüfe, ob das Kernelmodul geladen ist:


sudo modprobe wireguard
lsmod | grep wireguard

2. IP-Forwarding im Linux-Kernel aktivieren

Damit der Server Pakete aus dem VPN-Tunnel ins Internet weiterleiten darf, muss das IP-Forwarding für IPv4 und IPv6 im Kernel aktiviert werden. Erstelle dazu eine dedizierte Sysctl-Konfigurationsdatei:


sudo tee /etc/sysctl.d/99-wireguard.conf << 'EOF'
# IPv4 Packet Forwarding aktivieren
net.ipv4.ip_forward = 1

# IPv6 Packet Forwarding aktivieren
net.ipv6.conf.all.forwarding = 1
EOF

Lade die Kernel-Parameter sofort neu:


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

Prüfe die Ausgabe: Es sollte net.ipv4.ip_forward = 1 und net.ipv6.conf.all.forwarding = 1 erscheinen.

Schlüsselgenerierung (Server & Peer)

WireGuard basiert auf Public-Key-Kryptografie: Jeder Knoten besitzt ein privates und ein öffentliches Schlüsselpaar. Zusätzlich generieren wir einen Pre-Shared Key (PSK) für eine zusätzliche symmetrische Verschlüsselungsebene.

Sichere das Konfigurationsverzeichnis mit strikten Rechten ab:


sudo mkdir -p /etc/wireguard
sudo chmod 700 /etc/wireguard
cd /etc/wireguard

Generiere die Serverschlüssel:


umask 077
wg genkey | tee server_private.key | wg pubkey > server_public.key

Zeige die Schlüssel an (notiere dir den öffentlichen Schlüssel):


echo "Server Public Key: $(cat server_public.key)"

Server-Konfiguration (`wg0.conf`)

Ermittle zunächst den Namen deiner aktiven Standard-Netzwerkschnittstelle (z. B. eth0, enp1s0 oder ens3):


ip -o -4 route show to default | awk '{print $5}'

(Im folgenden Beispiel verwenden wir eth0. Falls dein Interface anders heißt, passe den Namen in den PostUp- und PostDown-Zeilen an).

Erstelle die Konfigurationsdatei /etc/wireguard/wg0.conf:


SERVER_PRIV_KEY=$(cat /etc/wireguard/server_private.key)

sudo tee /etc/wireguard/wg0.conf << EOF
[Interface]
# Server-Tunnel-IPs (Dual-Stack)
Address = 10.8.0.1/24, fd42:42:42::1/64
ListenPort = 51820
PrivateKey = ${SERVER_PRIV_KEY}

# Firewall- & NAT-Regeln beim Start (PostUp) und Stopp (PostDown)
PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -A FORWARD -o wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE; ip6tables -A FORWARD -i wg0 -j ACCEPT; ip6tables -A FORWARD -o wg0 -j ACCEPT; ip6tables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -D FORWARD -o wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE; ip6tables -D FORWARD -i wg0 -j ACCEPT; ip6tables -D FORWARD -o wg0 -j ACCEPT; ip6tables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

# Platzhalter für Clients (Peers)
EOF

Schütze die Datei mit restriktiven Dateirechten:


sudo chmod 600 /etc/wireguard/wg0.conf

Firewall-Konfiguration (UFW)

Falls du die Uncomplicated Firewall (UFW) einsetzt, musst du den WireGuard-Port freigeben und das Routing erlauben:

1. Port 51820 UDP freigeben


sudo ufw allow 51820/udp comment 'WireGuard VPN'

2. Forwarding-Policy anpassen

Öffne /etc/default/ufw und stelle sicher, dass DEFAULT_FORWARD_POLICY auf ACCEPT steht:


sudo sed -i 's/DEFAULT_FORWARD_POLICY="DROP"/DEFAULT_FORWARD_POLICY="ACCEPT"/' /etc/default/ufw

Lade die UFW-Regeln neu:


sudo ufw reload

WireGuard Service starten & aktivieren

WireGuard bringt mit wg-quick einen praktischen Systemd-Wrapper mit. Starte das Interface wg0:


sudo systemctl enable --now wg-quick@wg0

Überprüfe den Status des VPN-Interfaces:


sudo wg show

Du solltest nun die Details deines aktiven Interfaces sehen:


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

Client (Peer) anlegen & verbinden

Nun erstellen wir die Konfiguration für den ersten Client (z. B. Smartphone oder Laptop).

1. Client-Schlüssel generieren

Erstelle ein separates Verzeichnis für Client-Profile:


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

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

2. Peer am Server registrieren

Füge den Client zu /etc/wireguard/wg0.conf hinzu:


CLIENT1_PUB=$(cat client1_public.key)
CLIENT1_PSK=$(cat client1_preshared.key)

sudo tee -a /etc/wireguard/wg0.conf << EOF

# Client 1: Smartphone / Laptop
[Peer]
PublicKey = ${CLIENT1_PUB}
PresharedKey = ${CLIENT1_PSK}
AllowedIPs = 10.8.0.2/32, fd42:42:42::2/128
EOF

Lade die Serverkonfiguration ohne Neustart des Interfaces neu:


sudo wg syncconf wg0 <(wg-quick strip wg0)

3. Client-Konfigurationsdatei erstellen

Ermittle die öffentliche IP-Adresse oder die Domain deines Servers (SERVER_ENDPOINT):


SERVER_ENDPOINT="vpn.deinedomain.de" # oder Server-IPv4
SERVER_PUB=$(cat /etc/wireguard/server_public.key)
CLIENT1_PRIV=$(cat client1_private.key)

tee /etc/wireguard/clients/client1.conf << EOF
[Interface]
PrivateKey = ${CLIENT1_PRIV}
Address = 10.8.0.2/24, fd42:42:42::2/64
DNS = 1.1.1.1, 9.9.9.9

[Peer]
PublicKey = ${SERVER_PUB}
PresharedKey = ${CLIENT1_PSK}
Endpoint = ${SERVER_ENDPOINT}:51820
# 0.0.0.0/0, ::/0 leitet den gesamten Traffic durch das VPN (Full Tunnel)
AllowedIPs = 0.0.0.0/0, ::/0
# Hält die Verbindung hinter NAT-Routern / Firewalls aufrecht
PersistentKeepalive = 25
EOF

💡 Split-Tunneling: Wenn du nur den Zugriff auf dein Heimnetz/Server über das VPN leiten möchtest, aber normales Surfen über die lokale Internetverbindung laufen soll, setze AllowedIPs = 10.8.0.0/24, 192.168.1.0/24 (statt 0.0.0.0/0).

4. QR-Code für Smartphones erzeugen

Für die offizielle WireGuard-App (iOS / Android) kannst du die Konfigurationsdatei direkt im Terminal als scanbaren QR-Code ausgeben:


qrencode -t ansiutf8 < /etc/wireguard/clients/client1.conf

Öffne die WireGuard-App auf dem Smartphone, tippe auf + → QR-Code scannen, scanne den Terminal-Code und aktiviere den Tunnel.

Automatisierung: Client-Management Script

Um neue Clients in Zukunft mit einem einzigen Befehl anzulegen, empfiehlt sich ein automatisiertes Verwaltungsscript.

Erstelle /usr/local/bin/add-wireguard-client:


sudo tee /usr/local/bin/add-wireguard-client << 'EOF'
#!/bin/bash
set -euo pipefail

if [ -z "${1:-}" ]; then
    echo "Verwendung: sudo add-wireguard-client <client-name> [client-ip-suffix]"
    echo "Beispiel:   sudo add-wireguard-client laptop 3"
    exit 1
fi

CLIENT_NAME="$1"
IP_SUFFIX="${2:-}"

WG_DIR="/etc/wireguard"
CLIENT_DIR="$WG_DIR/clients"
SERVER_PUB=$(cat "$WG_DIR/server_public.key")
SERVER_ENDPOINT=$(curl -s ifconfig.me || ip route get 1.1.1.1 | awk '{print $7}')

mkdir -p "$CLIENT_DIR"
cd "$CLIENT_DIR"
umask 077

# Automatische IP-Ermittlung falls nicht angegeben
if [ -z "$IP_SUFFIX" ]; then
    LAST_IP=$(grep -oE '10\.8\.0\.[0-9]+' "$WG_DIR/wg0.conf" | sort -t. -k4 -n | tail -1 | awk -F. '{print $4}' || echo 1)
    IP_SUFFIX=$((LAST_IP + 1))
fi

CLIENT_IPV4="10.8.0.${IP_SUFFIX}"
CLIENT_IPV6="fd42:42:42::${IP_SUFFIX}"

echo "==> Generiere Schlüssel für Peer: $CLIENT_NAME ($CLIENT_IPV4)..."
PRIV_KEY=$(wg genkey)
PUB_KEY=$(echo "$PRIV_KEY" | wg pubkey)
PSK=$(wg genpsk)

# Server-Konfiguration erweitern
tee -a "$WG_DIR/wg0.conf" > /dev/null << PEER_CONF

# Peer: ${CLIENT_NAME}
[Peer]
PublicKey = ${PUB_KEY}
PresharedKey = ${PSK}
AllowedIPs = ${CLIENT_IPV4}/32, ${CLIENT_IPV6}/128
PEER_CONF

# Live-Reload ohne Disconnect
wg syncconf wg0 <(wg-quick strip wg0)

# Client-Konfigurationsdatei schreiben
CONF_FILE="$CLIENT_DIR/${CLIENT_NAME}.conf"
tee "$CONF_FILE" > /dev/null << CLIENT_CONF
[Interface]
PrivateKey = ${PRIV_KEY}
Address = ${CLIENT_IPV4}/24, ${CLIENT_IPV6}/64
DNS = 1.1.1.1, 9.9.9.9

[Peer]
PublicKey = ${SERVER_PUB}
PresharedKey = ${PSK}
Endpoint = ${SERVER_ENDPOINT}:51820
AllowedIPs = 0.0.0.0/0, ::/0
PersistentKeepalive = 25
CLIENT_CONF

echo "==> Konfiguration gespeichert in: $CONF_FILE"
echo ""
echo "=== QR-CODE FÜR MOBILE GERÄTE ==="
qrencode -t ansiutf8 < "$CONF_FILE"
EOF

sudo chmod +x /usr/local/bin/add-wireguard-client

Nun kannst du jederzeit beliebige neue Clients erstellen:


sudo add-wireguard-client tablet
sudo add-wireguard-client macbook 5

Site-to-Site VPN: Standortvernetzung zweier Netzwerke

Während das Roadwarrior-Setup einzelne Endgeräte anbindet, koppelt ein Site-to-Site VPN zwei komplette physische oder virtuelle Netzwerke transparent miteinander. Geräte an Standort A (z. B. 192.168.10.0/24) können direkt ohne Client-Software auf Server an Standort B (192.168.20.0/24) zugreifen:


┌─────────────────────────────────────────────────────────────┐
│           Site-to-Site VPN: Standortvernetzung              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   Standort A (Office / Cloud)       Standort B (Home-Lab)   │
│   LAN: 192.168.10.0/24              LAN: 192.168.20.0/24    │
│   ┌───────────────────┐             ┌───────────────────┐   │
│   │ Gateway A (Ubuntu)│             │ Gateway B (Ubuntu)│   │
│   │ IP: 10.8.0.1      │             │ IP: 10.8.0.2      │   │
│   └─────────┬─────────┘             └─────────┬─────────┘   │
│             │                                 │             │
│             ▼                                 ▼             │
│   ═══════════════════════════════════════════════════════   │
│         Dauerhafter WireGuard-Tunnel (UDP Port 51820)       │
│   ═══════════════════════════════════════════════════════   │
│                                                             │
│   Transparentes Routing (ohne NAT):                         │
│   - Gateway A leitet 192.168.20.0/24 -> 10.8.0.2            │
│   - Gateway B leitet 192.168.10.0/24 -> 10.8.0.1            │
│                                                             │
└─────────────────────────────────────────────────────────────┘

1. Konfiguration Gateway A (`/etc/wireguard/wg0.conf`)

Gateway A fungiert als Responder mit öffentlich erreichbarer IP:


[Interface]
Address = 10.8.0.1/24
ListenPort = 51820
PrivateKey = <GATEWAY_A_PRIVATE_KEY>
# Forwarding zwischen LAN-Interface (eth0) und VPN-Interface (wg0)
PostUp = iptables -A FORWARD -i wg0 -o eth0 -j ACCEPT; iptables -A FORWARD -i eth0 -o wg0 -j ACCEPT
PostDown = iptables -D FORWARD -i wg0 -o eth0 -j ACCEPT; iptables -D FORWARD -i eth0 -o wg0 -j ACCEPT

# Peer: Gateway B
[Peer]
PublicKey = <GATEWAY_B_PUBLIC_KEY>
PresharedKey = <SITE_TO_SITE_PSK>
# Erlaube sowohl die Tunnel-IP als auch das gesamte Remote-Subnetz
AllowedIPs = 10.8.0.2/32, 192.168.20.0/24

2. Konfiguration Gateway B (`/etc/wireguard/wg0.conf`)

Gateway B baut die Verbindung aktiv zu Gateway A auf:


[Interface]
Address = 10.8.0.2/24
PrivateKey = <GATEWAY_B_PRIVATE_KEY>
PostUp = iptables -A FORWARD -i wg0 -o eth0 -j ACCEPT; iptables -A FORWARD -i eth0 -o wg0 -j ACCEPT
PostDown = iptables -D FORWARD -i wg0 -o eth0 -j ACCEPT; iptables -D FORWARD -i eth0 -o wg0 -j ACCEPT

# Peer: Gateway A
[Peer]
PublicKey = <GATEWAY_A_PUBLIC_KEY>
PresharedKey = <SITE_TO_SITE_PSK>
Endpoint = gateway-a.deinedomain.de:51820
AllowedIPs = 10.8.0.1/32, 192.168.10.0/24
PersistentKeepalive = 25

💡 Statische Route im Hauptrouter: Damit Geräte in Standort A das Netz 192.168.20.0/24 erreichen, muss im Standard-Gateway (z. B. FRITZ!Box, pfSense) eine statische IPv4-Route hinterlegt werden: Ziel 192.168.20.0/24 via Gateway A (192.168.10.254).

Eigener DNS-Server & Interne Namensauflösung

In Unternehmens- und Homelab-Umgebungen sollen VPN-Clients oft nicht nur verschlüsselt ins Internet gelangen, sondern auch interne Hostnamen (z. B. vaultwarden.intern oder nas.corp) auflösen können, ohne dass DNS-Anfragen an öffentliche Resolver geschickt werden.

1. Unbound DNS-Resolver auf dem Server installieren


sudo apt install unbound -y

Erstelle die Konfiguration /etc/unbound/unbound.conf.d/wireguard.conf:


sudo tee /etc/unbound/unbound.conf.d/wireguard.conf << 'EOF'
server:
    interface: 10.8.0.1
    interface: 127.0.0.1
    access-control: 10.8.0.0/24 allow
    access-control: 127.0.0.0/8 allow
    
    # Datenschutz & DNSSEC
    hide-identity: yes
    hide-version: yes
    harden-glue: yes
    harden-dnssec-stripped: yes
    
    # Interne lokale Domäne auflösen
    local-zone: "intern." static
    local-data: "nas.intern. IN A 192.168.10.50"
    local-data: "wiki.intern. IN A 192.168.10.51"
    local-data: "router.intern. IN A 10.8.0.1"

# Upstream-DNS für alle externen Anfragen
forward-zone:
    name: "."
    forward-addr: 9.9.9.9        # Quad9 Primary
    forward-addr: 149.112.112.112 # Quad9 Secondary
EOF

Starte Unbound neu:


sudo systemctl enable --now unbound

2. Client-Konfiguration anpassen

Setze in den Client-Profilen die Server-Tunnel-IP als primären DNS:


[Interface]
DNS = 10.8.0.1, intern

Damit leitet der Client alle DNS-Abfragen an den integrierten Unbound-Resolver. Lokale Namen werden direkt aufgelöst, während externe Anfragen datenschutzfreundlich verschlüsselt ins Web weitergeleitet werden.

Strikter VPN-Kill-Switch für mobile Clients

Auf mobilen Laptops (z. B. auf Reisen oder in offenen Hotel-WLANs) darf bei einem unerwarteten Abbruch des VPN-Tunnels keinesfalls unverschlüsselter Datenverkehr über das physische WLAN fließen (Schutz vor Datendiebstahl / Session-Hijacking).

UFW Kill-Switch auf dem Linux-Client

Auf einem Linux-Client richtest du einen strikten Kill-Switch mit UFW ein:


# 1. Standard-Policy: Alles blockieren (eingehend und ausgehend)
sudo ufw default deny incoming
sudo ufw default deny outgoing

# 2. Ausgehenden Traffic über das WireGuard-Interface (wg0) erlauben
sudo ufw allow out on wg0 to any

# 3. Verbindungsaufbau zum WireGuard-Serverport über das physische Interface erlauben
sudo ufw allow out to <SERVER_IP> proto udp port 51820 comment 'WireGuard Server'

# 4. Lokalen LAN-Zugriff (optional) erlauben (z. B. Drucker / Router)
sudo ufw allow out to 192.168.1.0/24

# 5. UFW aktivieren
sudo ufw enable

⚠️ Wirkung des Kill-Switches: Reißt die WireGuard-Verbindung ab, blockiert die Firewall sofort jede Internetkommunikation. Es können keine unverschlüsselten Pakete unbemerkt über das offene WLAN fließen.

Monitoring & Fehlerbehebung

Status & aktiven Datenverkehr prüfen

Mit wg show siehst du in Echtzeit alle verbundenen Clients, deren Endpunkte, den letzten Handshake sowie übertragene Datenmengen:


sudo wg show

Beispielausgabe bei erfolgreicher Verbindung:


interface: wg0
  public key: 4HkL...8Xg=
  private key: (hidden)
  listening port: 51820

peer: 4HkL...8Xg=
  preshared key: (hidden)
  endpoint: 203.0.113.42:54120
  allowed ips: 10.8.0.2/32, fd42:42:42::2/128
  latest handshake: 14 seconds ago
  transfer: 2.14 MiB received, 18.76 MiB sent

⚠️ Handshake fehlt? Wenn bei latest handshake kein Eintrag steht oder dieser älter als 2 Minuten ist, kommt kein Traffic an. Typische Ursachen:

UDP-Port 51820 ist in der Firewall des Cloud-Providers (z. B. Hetzner Cloud Firewall, AWS Security Group) blockiert.

Der Client versucht eine Verbindung über Port forwarding / IPv4, der Server-Provider nutzt aber DS-Lite / CGNAT.

Falscher Public Key in der Server- oder Client-Konfiguration eingetragen.

MTU-Probleme bei Webseiten-Ladehemmungen

Falls der VPN-Tunnel steht, aber manche Webseiten nicht laden oder hängenbleiben, liegt oft eine zu große MTU (Maximum Transmission Unit) vor. Standardmäßig nutzt WireGuard eine MTU von 1420 Bytes.

Passe in der Client-Konfiguration die MTU unter [Interface] manuell an:


MTU = 1360

DNS-Leak-Test

Wenn der VPN-Tunnel aktiv ist, sollten alle DNS-Anfragen über den Tunnel laufen. Anderenfalls „leaken" deine DNS-Abfragen an den lokalen ISP und offenbaren deine Surfactivity.

DNS-Konfiguration am Client prüfen

Stelle sicher, dass in der Client-Konfiguration unter [Interface] ein DNS-Server angegeben ist:


[Interface]
PrivateKey = <DEIN_PRIVAT_SCHLÜSSEL>
Address = 10.8.0.2/24, fd42:42:42::2/64
DNS = 1.1.1.1, 9.9.9.9

💡 Empfohlene DNS-Server: Cloudflare (1.1.1.1, 1.0.0.1) oder Quad9 (9.9.9.9, 149.112.112.112) bieten DNS-over-HTTPS/TLS und gute Datenschutzrichtlinien.

DNS-Leak testen

Verbinde dich mit dem WireGuard-VPN
Öffne eine Website wie https://dnsleaktest.com oder https://ipleak.net
Führe einen Standard Test oder Extended Test durch
Die angezeigten DNS-Server sollten zum Standort des VPN-Servers gehören, nicht zu deinem lokalen ISP

Alternativ per Terminal:


# Prüfe welcher DNS-Server verwendet wird
resolvectl status | grep "DNS Server"

# DNS-Anfrage über den Tunnel senden
dig +short whoami.akamai.net @1.1.1.1

⚠️ Tipp: Falls DNS-Leaks auftreten, prüfe ob DNS = ... in der Client-Konfiguration gesetzt ist und ob der lokale DNS-Manager (z. B. systemd-resolved) den WireGuard-DNS nicht überschreibt.

nftables-Alternative für Fortgeschrittene

Ab Ubuntu 22.04 nutzt der Kernel standardmäßig nftables als Backdrop für iptables. Für produktive Server empfiehlt sich die direkte Nutzung von nftables statt der alter iptables-Kommandos.

WireGuard-Regeln mit nftables

Erstelle eine dedizierte nftables-Konfigurationsdatei:


sudo tee /etc/nftables.d/wireguard.nft << 'EOF'
#!/usr/sbin/nft -f

# Eingehenden WireGuard-Traffic erlauben
add rule inet filter input udp dport 51820 accept

# Forwarding für WireGuard-Tunnel erlauben
add rule inet filter forward iifname "wg0" accept
add rule inet filter forward oifname "wg0" accept

# NAT/Masquerading für IPv4
add rule inet nat postrouting oifname "eth0" ip saddr 10.8.0.0/24 masquerade

# NAT/Masquerading für IPv6
add rule inet nat postrouting oifname "eth0" ip6 saddr fd42:42:42::/64 masquerade
EOF

Lade die Konfiguration:


sudo nft -f /etc/nftables.d/wireguard.nft
sudo systemctl enable nftables

💡 Vorteil von nftables: Bessere Performance bei großen Regelsätzen, atomare Updates (entweder alle Regeln oder keine), und konsistente Syntax statt der veralteten iptables-Legacy-API.

Logging & Monitoring

WireGuard-Kernel-Debug aktivieren

WireGuard loggt standardmäßig absolut geräuschlos im Kernel. Für tiefergehendes Troubleshooting kannst du das dynamische Kernel-Debugging temporär aktivieren:


# WireGuard Dynamic Debugging im Kernel aktivieren
echo "module wireguard +p" | sudo tee /sys/kernel/debug/dynamic_debug/control

# Live-Log der Kernel-Meldungen für WireGuard anzeigen
sudo dmesg -wT | grep -i wireguard

Nach dem Debuggen kannst du das Logging wieder deaktivieren:


echo "module wireguard -p" | sudo tee /sys/kernel/debug/dynamic_debug/control

⚠️ Vorsicht: Dynamisches Kernel-Debugging erzeugt bei regem Datenverkehr viele Log-Einträge. Deaktiviere es nach erfolgreicher Fehlerdiagnose wieder.

Journalctl & Verbindungsüberwachung


# Letzte Systemd-Ereignisse von WireGuard anzeigen
journalctl -u wg-quick@wg0 --since "1 hour ago"

# Detaillierte Peer-Informationen und Transfer-Statistiken
sudo wg show wg0 dump

# Aktive UDP-Verbindungen auf Port 51820 prüfen
sudo ss -ulnp | grep 51820

Performance & Tuning

MTU-Optimierung

Die Standard-MTU von WireGuard (1420 Bytes) funktioniert in den meisten Netzwerken hervorragend. Bei Mobilfunkverbindungen (LTE/5G) oder DSL mit DS-Lite kann es jedoch zu Paketfragmentierung kommen.

Ermittle die optimale MTU per Ping ohne Fragmentierung:


# Optimale MTU ermitteln (PMTU-Discovery)
ping -M do -s 1392 -c 3 <SERVER_IP>

Falls Pakete verloren gehen, reduziere die MTU in der Client-Konfiguration unter [Interface]:


MTU = 1360

TCP BBR Congestion Control

Um den Durchsatz über das Gateway zu maximieren (insbesondere bei schwankenden Ping-Zeiten im Mobilfunk), aktiviere Googles BBR-Algorithmus:


sudo tee /etc/sysctl.d/99-wireguard-performance.conf << 'EOF'
net.core.default_qdisc = fq
net.ipv4.tcp_congestion_control = bbr
EOF

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

Firewall-Performance bei vielen Peers

Bei mehr als 50 aktiven Peers empfiehlt sich in nftables die Nutzung von Sets anstelle einzelner Filter-Regeln:


# Effizientes Peer-Set in nftables
sudo nft add set inet filter wireguard_peers '{ type ipv4_addr; }'
sudo nft add element inet filter wireguard_peers '{ 10.8.0.2, 10.8.0.3, 10.8.0.4 }'
sudo nft add rule inet filter forward ip saddr @wireguard_peers accept

Fazit

WireGuard ist die modernste VPN-Lösung für Linux-Server: schlank, performant und mit erstklassiger Kryptografie. Die Einrichtung auf Ubuntu 24.04 LTS oder 26.04 LTS ist dank nativer Kernel-Integration in wenigen Minuten erledigt.

Die wichtigsten Schritte im Überblick:

System vorbereiten: Pakete installieren, IP-Forwarding aktivieren, Firewall konfigurieren
Schlüssel erzeugen: Server-Keys + Pre-Shared Key für jeden Client
Server konfigurieren: wg0.conf mit Dual-Stack IPv4/IPv6 und NAT-Regeln
Clients anlegen: Schlüssel generieren, Peer registrieren, Konfiguration per QR-Code übertragen
Monitoring einrichten: wg show für Status, DNS-Leak-Tests für Sicherheit

💡 Für die Praxis: Beginne mit einem einzelnen Client und teste die Verbindung gründlich, bevor du weitere Peers hinzufügst. Das Automatisierungs-Script spart bei mehreren Geräten enorm viel Zeit.