WireGuard VPN: Eigener Server in 15 Minuten

Wer remote auf sein Homelab zugreifen will, kommt an einem VPN nicht vorbei. OpenVPN ist konfigurationsaufwendig, IPsec ein Alptraum – und dann kam WireGuard. Minimalistisch, schnell, kryptografisch modern. Kernel-integriert ab Linux 5.6, mittlerweile auch nativ auf Windows, macOS, iOS und Android.

Dieser Guide zeigt den kompletten Aufbau eines WireGuard-Servers auf Linux – inklusive mehrerer Clients, Split Tunneling und den häufigsten Fallstricken.

Warum WireGuard?

WireGuard ist kein Ersatz für Enterprise-VPN mit RADIUS und Zertifikatsverwaltung. Für Homelab-Zugriff, Remote-Office-Anbindung und Site-to-Site-Tunnel zwischen eigenen Standorten ist es die beste Wahl.

Voraussetzungen

• Linux-Server mit öffentlicher IP (oder Port-Forwarding auf deiner Firewall)
• Ubuntu 22.04 / Debian 12 oder neuer (Kernel ≥ 5.6)
• Root- oder sudo-Zugang
• UDP-Port deiner Wahl (Standard: 51820) von außen erreichbar

# Kernel-Version prüfen
uname -r
# Ausgabe z. B.: 6.1.0-18-amd64  ✓

# WireGuard-Modul prüfen
lsmod | grep wireguard
# Falls leer: noch nicht geladen, aber vorhanden ab Kernel 5.6

Installation

# Ubuntu / Debian
sudo apt update && sudo apt install -y wireguard

# RHEL / Rocky / Alma
sudo dnf install -y epel-release
sudo dnf install -y wireguard-tools

# Arch
sudo pacman -S wireguard-tools

Server konfigurieren

1. Schlüsselpaar generieren

# Arbeitsverzeichnis mit korrekten Berechtigungen
cd /etc/wireguard
umask 077

# Server-Schlüsselpaar
wg genkey | tee server.key | wg pubkey > server.pub

cat server.key   # privater Schlüssel – NIEMALS weitergeben
cat server.pub   # öffentlicher Schlüssel – wird an Clients verteilt

2. Server-Konfiguration erstellen

# Netzwerk-Interface ermitteln (meist eth0 oder ens3)
ip route | grep default
# Ausgabe: default via 1.2.3.254 dev eth0 ...

nano /etc/wireguard/wg0.conf

[Interface]
# Privater Schlüssel des Servers
PrivateKey = <Inhalt von server.key>

# VPN-interne IP des Servers
Address = 10.10.99.1/24

# UDP-Port auf dem der Server lauscht
ListenPort = 51820

# IP-Forwarding aktivieren beim Start
PostUp   = sysctl -w net.ipv4.ip_forward=1
PostUp   = iptables -A FORWARD -i wg0 -j ACCEPT
PostUp   = iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT
PostDown = iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

# Für IPv6-Support zusätzlich:
# PostUp   = sysctl -w net.ipv6.conf.all.forwarding=1

Wichtig: eth0 durch dein tatsächliches Interface ersetzen (aus dem ip route-Output oben).

3. IP-Forwarding dauerhaft aktivieren

echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.conf
sysctl -p

4. WireGuard starten und aktivieren

# Interface hochfahren
wg-quick up wg0

# Status prüfen
wg show

# Autostart beim Booten
systemctl enable wg-quick@wg0
systemctl start wg-quick@wg0

Clients hinzufügen

Für jeden Client wird ein eigenes Schlüsselpaar generiert. Das geht direkt auf dem Server (und der public key wird dann auf den Client kopiert) oder direkt auf dem Client-Gerät.

Client-Schlüsselpaar generieren

# Auf dem Server (oder lokal auf dem Client)
wg genkey | tee client1.key | wg pubkey > client1.pub

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

Peer zum Server hinzufügen

nano /etc/wireguard/wg0.conf

# Am Ende der wg0.conf hinzufügen:

[Peer]
# Anzeigename als Kommentar – WireGuard ignoriert ihn, hilft aber zur Übersicht
# Name: Laptop Kevin

# Öffentlicher Schlüssel des Clients
PublicKey = <Inhalt von client1.pub>

# Optional aber empfohlen: Pre-Shared Key
PresharedKey = <Inhalt von client1.psk>

# Welche IP darf dieser Client im VPN nutzen?
AllowedIPs = 10.10.99.2/32

# Änderungen ohne Neustart übernehmen
wg syncconf wg0 <(wg-quick strip wg0)
# oder einfacher:
wg addconf wg0 <(wg-quick strip wg0)

Client-Konfigurationsdatei erstellen

Diese .conf wird auf das Client-Gerät (oder in die WireGuard-App) importiert:

[Interface]
# Privater Schlüssel des Clients
PrivateKey = <Inhalt von client1.key>

# VPN-IP des Clients
Address = 10.10.99.2/24

# DNS-Server im VPN (z. B. dein AdGuard Home oder Pi-hole)
DNS = 10.10.10.103

[Peer]
# Öffentlicher Schlüssel des Servers
PublicKey = <Inhalt von server.pub>

# Pre-Shared Key (falls konfiguriert)
PresharedKey = <Inhalt von client1.psk>

# Öffentliche IP/Domain des Servers + Port
Endpoint = deine-domain.de:51820

# Welche Routen über den VPN-Tunnel leiten?
# 0.0.0.0/0 = gesamter Traffic (Full Tunnel)
# Nur Heimnetz: 10.10.10.0/24
AllowedIPs = 0.0.0.0/0, ::/0

# Keepalive – wichtig hinter NAT (Router, Carrier-Grade-NAT)
PersistentKeepalive = 25

Split Tunneling

Full Tunnel (0.0.0.0/0) schickt allen Traffic über den VPN. Das ist sicher, aber langsam und verbraucht die Bandbreite des Servers. Split Tunneling leitet nur bestimmte Netze durch den Tunnel:

# Nur Homelab-Netz + VPN-Subnet durch den Tunnel
AllowedIPs = 10.10.10.0/24, 10.10.99.0/24

# Homelab + privates RFC1918 (sinnvoll für Site-to-Site)
AllowedIPs = 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16

Mit Split Tunneling läuft normales Internet-Browsing direkt über die eigene Leitung – nur Homelab-Traffic geht durch den Tunnel.

Firewall-Regeln (UFW)

Falls du UFW nutzt:

# WireGuard-Port erlauben
ufw allow 51820/udp

# Forwarding in UFW aktivieren
nano /etc/default/ufw
# DEFAULT_FORWARD_POLICY="ACCEPT"  ← ändern

# UFW-before-Regeln für NAT
nano /etc/ufw/before.rules

Ganz oben in before.rules (vor *filter):

*nat
:POSTROUTING ACCEPT [0:0]
-A POSTROUTING -s 10.10.99.0/24 -o eth0 -j MASQUERADE
COMMIT

ufw reload

Mehrere Clients verwalten

Bei vielen Peers lohnt sich ein kleines Management-Script:

#!/bin/bash
# add-peer.sh – neuen WireGuard-Client anlegen

NAME=$1
IP=$2   # z. B. 10.10.99.5

if [[ -z "$NAME" || -z "$IP" ]]; then
    echo "Usage: $0 <name> <vpn-ip>"
    exit 1
fi

cd /etc/wireguard
umask 077

# Schlüssel generieren
wg genkey | tee "clients/${NAME}.key" | wg pubkey > "clients/${NAME}.pub"
wg genpsk > "clients/${NAME}.psk"

PRIVKEY=$(cat "clients/${NAME}.key")
PUBKEY=$(cat  "clients/${NAME}.pub")
PSK=$(cat     "clients/${NAME}.psk")
SERVERPUB=$(cat server.pub)

# Peer zur Server-Config hinzufügen
cat >> wg0.conf <<EOF

[Peer]
# Name: ${NAME}
PublicKey = ${PUBKEY}
PresharedKey = ${PSK}
AllowedIPs = ${IP}/32
EOF

# Client-Config ausgeben
cat > "clients/${NAME}.conf" <<EOF
[Interface]
PrivateKey = ${PRIVKEY}
Address = ${IP}/24
DNS = 10.10.10.103

[Peer]
PublicKey = ${SERVERPUB}
PresharedKey = ${PSK}
Endpoint = deine-domain.de:51820
AllowedIPs = 10.10.10.0/24, 10.10.99.0/24
PersistentKeepalive = 25
EOF

# Änderungen live übernehmen
wg syncconf wg0 <(wg-quick strip wg0)

echo "✓ Peer '${NAME}' mit IP ${IP} angelegt."
echo "  Config: /etc/wireguard/clients/${NAME}.conf"

chmod +x add-peer.sh
mkdir -p /etc/wireguard/clients
./add-peer.sh laptop 10.10.99.2
./add-peer.sh handy  10.10.99.3

Status und Debugging

# Aktive Verbindungen anzeigen
wg show

# Ausgabe:
# interface: wg0
#   public key: abc123...
#   private key: (hidden)
#   listening port: 51820
#
# peer: xyz789...
#   preshared key: (hidden)
#   endpoint: 1.2.3.4:54321
#   allowed ips: 10.10.99.2/32
#   latest handshake: 42 seconds ago
#   transfer: 1.23 MiB received, 456 KiB sent

# Handshake-Zeitstempel aller Peers
wg show wg0 latest-handshakes

# Logs verfolgen
journalctl -u wg-quick@wg0 -f

# Konnektivität testen
ping 10.10.99.1     # vom Client: Server erreichbar?
ping 10.10.10.103   # AdGuard Home erreichbar?

Kein Handshake? Typische Ursachen:

1. Port nicht erreichbar – Firewall oder Router-Portweiterleitung prüfen
2. Falscher PublicKey – copy/paste mit Leerzeichen oder Zeilenumbruch
3. AllowedIPs falsch – auf Client und Server müssen die IPs passen
4. IP-Forwarding inaktiv – cat /proc/sys/net/ipv4/ip_forward muss 1 zurückgeben

Checkliste

• Kernel ≥ 5.6 (oder wireguard-dkms installiert)
• UDP-Port in der Firewall freigegeben
• Port-Forwarding auf dem Router eingerichtet (falls kein eigener Server mit direkter IP)
• IP-Forwarding dauerhaft in /etc/sysctl.conf aktiviert
• Pre-Shared Keys für alle Peers gesetzt (Post-Quantum-Schutz)
• PersistentKeepalive bei Clients hinter NAT aktiviert (25 Sek.)
• DNS im Client auf internen DNS-Server gesetzt (AdGuard, Pi-hole)
• Private Keys nur root-lesbar (chmod 600)
• Autostart mit systemctl enable wg-quick@wg0
• Test: Handshake aufgebaut, internes Netz erreichbar

Fazit

WireGuard ist der VPN-Standard für alle, die selbst Hand anlegen. Die Konfiguration ist in 15 Minuten erledigt, der Code-Footprint minimal und die Performance ausgezeichnet – besonders auf mobilen Geräten mit häufig wechselnden Netzwerken (Roaming ohne Verbindungsabbruch).

Wer sein Homelab von unterwegs sicher erreichen will, braucht nichts anderes.

Fragen oder eigene WireGuard-Setups? Schreib mir: info@westmeier.cloud