Physical Address

304 North Cardinal St.
Dorchester Center, MA 02124

Ubuntu 24.04 Server: Einen eigenen WireGuard VPN-Server einrichten

Ubuntu 24.04 Server: Einen eigenen WireGuard VPN-Server einrichten
Navigation

WireGuard hat sich seit seiner Einführung 2016 als leistungsstarke und sichere Alternative zu herkömmlichen VPN-Protokollen etabliert. Mit der Veröffentlichung von Ubuntu 24.04 LTS im April 2024 ist es an der Zeit, einen Blick darauf zu werfen, wie du deinen eigenen WireGuard VPN-Server auf dieser aktuellen Ubuntu-Version einrichten kannst. 

Dieser Artikel führt dich Schritt für Schritt durch den Prozess und gibt dir wichtige Hinweise zu Sicherheit und Fehlerbehebung.

Grundvoraussetzungen

Bevor du mit der Einrichtung beginnst, stelle sicher, dass du Folgendes hast:

  • Einen Ubuntu 24.04 Server (physisch oder virtuell)
  • Root-Zugriff oder einen Benutzer mit sudo-Rechten
  • Eine stabile Internetverbindung
  • Grundlegende Kenntnisse in der Linux-Kommandozeile
Tipp: Wenn du noch keinen Ubuntu-Server hast, kannst du einen virtuellen Server (VPS) bei Anbietern wie Hetzner, Linode oder AWS mieten. Diese bieten oft einfache Anleitungen zur Ersteinrichtung.

System aktualisieren

Beginne damit, dein System auf den neuesten Stand zu bringen:

sudo apt update && sudo apt upgrade -y
Bash

Dieser Befehl aktualisiert die Liste der verfügbaren Pakete und installiert dann alle verfügbaren Updates.

WireGuard installieren

WireGuard ist in den Standard-Repositories von Ubuntu 24.04 enthalten. Installiere es mit folgendem Befehl:

sudo apt install wireguard -y
Bash
Netzwerk-Forwarding aktivieren

Aktiviere das IP-Forwarding, damit dein Server als Router fungieren kann:

sudo sed -i 's/#net.ipv4.ip_forward=1/net.ipv4.ip_forward=1/' /etc/sysctl.conf
sudo sysctl -p
Bash

IP-Forwarding erlaubt deinem Server, Netzwerkverkehr zwischen verschiedenen Netzwerkschnittstellen weiterzuleiten. Dies ist notwendig, damit dein VPN-Server als Gateway für deine Clients fungieren kann.

WireGuard-Schlüssel generieren

Erzeuge ein Schlüsselpaar für deinen Server:

wg genkey | sudo tee /etc/wireguard/privatekey | wg pubkey | sudo tee /etc/wireguard/publickey
Bash

Visualisierung:

+-------------------+
|    Dein Server    |
|                   |
|  +-------------+  |
|  | Private Key |  |
|  +-------------+  |
|         |         |
|         v         |
|  +-------------+  |
|  | Public Key  |  |
|  +-------------+  |
+-------------------+
Markdown
WireGuard-Konfiguration erstellen

Erstelle eine Konfigurationsdatei für WireGuard:

sudo nano /etc/wireguard/wg0.conf
Bash

Füge folgenden Inhalt ein:

[Interface]
PrivateKey = <Inhalt von /etc/wireguard/privatekey>
Address = 10.0.0.1/24
ListenPort = 51820
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 = <Client-Public-Key>
AllowedIPs = 10.0.0.2/32
Bash

Erklärung:

  • PrivateKey: Der private Schlüssel deines Servers
  • Address: Die IP-Adresse, die dein Server im VPN-Netzwerk haben wird
  • ListenPort: Der Port, auf dem WireGuard lauscht
  • PostUp/PostDown: Befehle, die beim Start/Stop des VPN ausgeführt werden, um NAT zu konfigurieren
  • Peer: Konfiguration für einen Client
  • AllowedIPs: IP-Adressen, die diesem Client zugewiesen werden
WireGuard-Dienst aktivieren und starten

Aktiviere und starte den WireGuard-Dienst:

sudo systemctl enable wg-quick@wg0
sudo systemctl start wg-quick@wg0
Bash

Überprüfung: Du kannst den Status des Dienstes mit folgendem Befehl überprüfen:

sudo systemctl status wg-quick@wg0
Bash
Client-Konfiguration

Nach der Einrichtung deines WireGuard-Servers musst du Clients konfigurieren, um eine Verbindung herzustellen. Hier sind die grundlegenden Schritte für verschiedene Betriebssysteme:

Allgemeine Schritte:

Generiere ein Schlüsselpaar für den Client:

wg genkey | tee clientprivatekey | wg pubkey > clientpublickey
Bash

Erstelle eine Client-Konfigurationsdatei (z.B. client.conf):

[Interface]
PrivateKey = <Client-Private-Key>
Address = 10.0.0.2/32
DNS = 1.1.1.1

[Peer]
PublicKey = <Server-Public-Key>
Endpoint = <Server-IP>:51820
AllowedIPs = 0.0.0.0/0
Bash

Ersetze <Client-Private-Key>, <Server-Public-Key> und <Server-IP> mit den entsprechenden Werten.

Betriebssystemspezifische Anweisungen:

  • Windows: Installiere den offiziellen WireGuard-Client und importiere die .conf-Datei.
  • macOS: Installiere WireGuard aus dem App Store und importiere die Konfiguration.
  • Linux: Installiere WireGuard über den Paketmanager und platziere die Konfigurationsdatei in /etc/wireguard/.
  • iOS/Android: Installiere die WireGuard-App und scanne den QR-Code (siehe nächster Abschnitt).
QR-Code-Generierung für mobile Clients

Für eine einfache Konfiguration auf Mobilgeräten kannst du einen QR-Code generieren:

Installiere qrencode:

sudo apt install qrencode
Bash

Generiere den QR-Code:

qrencode -t ansiutf8 < client.conf
Bash

Scanne diesen Code mit der WireGuard-App auf deinem Mobilgerät.

Firewall konfigurieren

Je nachdem, welche Firewall auf deinem System eingerichtet ist, folge den entsprechenden Anweisungen:

Für UFW (Uncomplicated Firewall)

Wenn du UFW verwendest, öffne den WireGuard-Port mit folgenden Befehlen:

sudo ufw allow 51820/udp
sudo ufw enable
Bash

Überprüfung: Du kannst den Status der Firewall-Regeln mit sudo ufw statusüberprüfen.

Für iptables

Wenn du iptables direkt verwendest, nutze folgende Befehle:

sudo iptables -A INPUT -p udp --dport 51820 -j ACCEPT
sudo iptables -A OUTPUT -p udp --sport 51820 -j ACCEPT
Bash

Um diese Regeln dauerhaft zu speichern, führe anschließend aus:

sudo apt install iptables-persistent
sudo netfilter-persistent save
Bash

Überprüfung: Du kannst die iptables-Regeln mit sudo iptables -L -n -v überprüfen.

Erklärung:

  • Diese Befehle erlauben eingehenden und ausgehenden Verkehr auf Port 51820 (UDP), den WireGuard standardmäßig verwendet.
  • iptables-persistent sorgt dafür, dass die Regeln nach einem Neustart erhalten bleiben.

Wichtiger Hinweis für Anfänger:

Sei vorsichtig bei der Konfiguration deiner Firewall, besonders wenn du per SSH auf deinen Server zugreifst. Stelle sicher, dass du den SSH-Port (standardmäßig 22) nicht versehentlich blockierst, da dies den Zugriff auf deinen Server verhindern könnte.

Wenn du unsicher bist, welche Firewall auf deinem System aktiv ist, kannst du dies folgendermaßen überprüfen:

Für UFW:

sudo ufw status
Bash

Wenn UFW aktiv ist, zeigt dieser Befehl den Status an.

Für iptables:

sudo iptables -L
Bash

Dieser Befehl zeigt die aktuellen iptables-Regeln an, wenn iptables verwendet wird.

Wähle die Methode, die zu deiner Systemkonfiguration passt.

Wenn du dir unsicher bist, ist es ratsam, einen erfahrenen Administrator zu konsultieren oder weitere Ressourcen zur Firewall-Konfiguration in deiner spezifischen Umgebung zu Rate zu ziehen.

Leistungsoptimierung

Um die Leistung deines WireGuard-VPNs zu optimieren:

MTU-Optimierung

Finde die optimale MTU mit:

ping -c 10 -M do -s 1500 <Server-IP>
Bash

Reduziere die Größe, bis keine Fragmentierung mehr auftritt.

TCP BBR

Aktiviere den BBR-Algorithmus für besseren Durchsatz:

echo "net.core.default_qdisc=fq" | sudo tee -a /etc/sysctl.conf
echo "net.ipv4.tcp_congestion_control=bbr" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p
Bash
Kernel-Parameter

Optimiere die Netzwerkparameter:

echo "net.ipv4.tcp_fastopen=3" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p
Bash

Skalierung

Hinzufügen mehrerer Clients
  1. Generiere für jeden neuen Client ein Schlüsselpaar.
  2. Füge für jeden Client einen neuen [Peer]-Abschnitt zur Server-Konfiguration hinzu:
[Peer]
PublicKey = <Neuer-Client-Public-Key>
AllowedIPs = 10.0.0.3/32
Bash

Erhöhe die letzte Ziffer der IP-Adresse für jeden neuen Client.

Verwaltung von Benutzerkonten:

Erstelle ein Skript zur Verwaltung von Benutzern, z.B. manage_users.sh:

#!/bin/bash

function add_user() {
    # Logik zum Hinzufügen eines Benutzers
}

function remove_user() {
    # Logik zum Entfernen eines Benutzers
}

# Hauptmenü
Bash

Automatisierung

Skript zur automatischen Erstellung von Client-Konfigurationen:

Erstelle ein Skript create_client.sh:

#!/bin/bash

# Generiere Schlüssel
client_private_key=$(wg genkey)
client_public_key=$(echo $client_private_key | wg pubkey)

# Erstelle Konfigurationsdatei
cat << EOF > $1.conf
[Interface]
PrivateKey = $client_private_key
Address = 10.0.0.$2/32
DNS = 1.1.1.1

[Peer]
PublicKey = $(cat /etc/wireguard/publickey)
Endpoint = $(curl -s ifconfig.me):51820
AllowedIPs = 0.0.0.0/0
EOF

# Füge Client zum Server hinzu
echo "
[Peer]
PublicKey = $client_public_key
AllowedIPs = 10.0.0.$2/32" | sudo tee -a /etc/wireguard/wg0.conf

# Restart WireGuard
sudo systemctl restart wg-quick@wg0
Bash

Verwendung: ./create_client.sh client_name client_number

Backup und Automatisierung

Ein regelmäßiges Backup deiner WireGuard-Konfiguration ist entscheidend für die Datensicherheit und erleichtert die Wiederherstellung im Notfall. Wir werden ein Backup-Skript erstellen und es dann für automatische, regelmäßige Backups einrichten.

Backup-Skript erstellen

Erstelle zunächst ein Backup-Skript backup_wireguard.sh:

#!/bin/bash

backup_dir="/path/to/backup/directory"
date=$(date +%Y%m%d)

# Erstelle Backup
sudo tar -czf $backup_dir/wireguard_$date.tar.gz /etc/wireguard

# Lösche alte Backups (älter als 30 Tage)
find $backup_dir -name "wireguard_*.tar.gz" -mtime +30 -delete
Bash

Mache das Skript ausführbar:

chmod +x backup_wireguard.sh
Bash
Automatische Backups einrichten

Um regelmäßige, automatische Backups zu erstellen, richten wir einen Cron-Job ein:

Öffne die Crontab zur Bearbeitung:

sudo crontab -e
Bash

Füge folgende Zeile hinzu, um das Backup täglich um 2 Uhr morgens durchzuführen:

0 2 * * * /path/to/backup_wireguard.sh
Bash

Speichere und schließe die Crontab.

Manuelles Backup durchführen

Du kannst jederzeit ein manuelles Backup erstellen, indem du das Skript direkt ausführst:

sudo ./backup_wireguard.sh
Bash
Wiederherstellung

Im Falle einer notwendigen Wiederherstellung:

Kopiere das Backup auf den Server (falls nötig) und entpacke es:

sudo tar -xzf wireguard_YYYYMMDD.tar.gz -C /
Bash

Stelle die korrekten Berechtigungen wieder her:

sudo chown -R root:root /etc/wireguard
sudo chmod -R 600 /etc/wireguard
Bash

Starte WireGuard neu:

sudo systemctl restart wg-quick@wg0
Bash

Monitoring und Logging

Aktiviere WireGuard-Logging:

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

Überwache Verbindungen:

sudo wg show
Bash

Analysiere Syslog für WireGuard-Einträge:

sudo grep WireGuard /var/log/syslog
Bash

IPv6-Unterstützung

Füge IPv6-Unterstützung zu deiner WireGuard-Konfiguration hinzu:

echo "net.ipv6.conf.all.forwarding=1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p
Bash

Erweitere die WireGuard-Konfiguration:

[Interface]
...
Address = 10.0.0.1/24, fd86:ea04:1111::1/64
...

[Peer]
...
AllowedIPs = 10.0.0.2/32, fd86:ea04:1111::2/128
Bash

Split-Tunneling

Für Split-Tunneling ändere die AllowedIPs in der Client-Konfiguration:

[Peer]
...
AllowedIPs = 10.0.0.0/24, fd86:ea04:1111::/64
Bash

Dies leitet nur den Verkehr für das VPN-Subnetz über den Tunnel.

Sicherheit

Regelmäßige Schlüsselrotation:

Erstelle ein Skript zur regelmäßigen Neugenerierung von Schlüsseln:

#!/bin/bash

# Generiere neue Schlüssel
new_private_key=$(wg genkey)
new_public_key=$(echo $new_private_key | wg pubkey)

# Aktualisiere Server-Konfiguration
sudo sed -i "s/PrivateKey = .*/PrivateKey = $new_private_key/" /etc/wireguard/wg0.conf

# Aktualisiere Client-Konfigurationen
# (Dies erfordert zusätzliche Logik für jeden Client)

# Starte WireGuard neu
sudo systemctl restart wg-quick@wg0
Bash

Zusätzliche Sicherheitsmaßnahmen:

  • Aktiviere Fail2Ban für SSH
  • Implementiere 2FA für Server-Zugriff
  • Halte das System stets aktuell

Updates und Wartung

WireGuard aktualisieren:

sudo apt update
sudo apt upgrade wireguard
Bash
Regelmäßige Wartungsaufgaben:
  1. Überprüfe Systemupdates: sudo apt update && sudo apt upgrade
  2. Überprüfe WireGuard-Logs: sudo journalctl -u wg-quick@wg0
  3. Überprüfe Firewall-Regeln: sudo ufw status oder sudo iptables -L
  4. Überprüfe Verbindungsstatus: sudo wg show
  5. Führe Backups durch
  6. Rotiere Schlüssel (siehe Sicherheitsbestpraktiken)

Troubleshooting

Solltest du auf Probleme stoßen, hier einige Tipps zur Fehlerbehebung:

  1. Verbindungsprobleme:
    • Überprüfe, ob der WireGuard-Port (51820/UDP) in der Firewall geöffnet ist.
    • Stelle sicher, dass dein Router den Port an deinen Server weiterleitet, falls nötig.
  2. Keine Internetverbindung über VPN:
    • Kontrolliere die NAT-Konfiguration (PostUp und PostDown Befehle in der Konfiguration).
    • Überprüfe, ob IP-Forwarding aktiviert ist.
  3. Schlüsselprobleme:
    • Stelle sicher, dass die Schlüssel korrekt in die Konfigurationsdateien kopiert wurden.
    • Generiere im Zweifel neue Schlüssel.
  4. DNS-Probleme:
    • Füge in der Client-Konfiguration einen DNS-Server hinzu, z.B. DNS = 1.1.1.1.
  5. Leistungsprobleme:
    • Überprüfe die MTU-Einstellungen und passe sie gegebenenfalls an.

Debugging aktivieren:

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

Anschließend kannst du die Logs mit dmesg | grep wireguard überprüfen.

Glossar

  • VPN: Virtual Private Network – ermöglicht eine sichere Verbindung über ein unsicheres Netzwerk.
  • WireGuard: Ein modernes VPN-Protokoll, bekannt für seine Einfachheit und Effizienz.
  • IP-Forwarding: Die Fähigkeit eines Systems, Netzwerkpakete zwischen verschiedenen Netzwerkschnittstellen weiterzuleiten.
  • NAT: Network Address Translation – ermöglicht mehreren Geräten, eine gemeinsame öffentliche IP-Adresse zu nutzen.
  • Firewall: Ein Sicherheitssystem, das eingehenden und ausgehenden Netzwerkverkehr basierend auf festgelegten Regeln kontrolliert.
  • UDP: User Datagram Protocol – ein Netzwerkprotokoll, das von WireGuard verwendet wird.

Fazit

Die Einrichtung eines eigenen WireGuard VPN-Servers auf Ubuntu 24.04 ist ein lohnenswertes Projekt, das dir mehr Kontrolle über deine Online-Privatsphäre und -Sicherheit gibt. Mit dieser Anleitung hast du nun alle notwendigen Werkzeuge und Informationen an der Hand, um nicht nur einen funktionierenden VPN-Server aufzusetzen, sondern ihn auch effizient zu verwalten, zu optimieren und zu sichern.

Wichtige Punkte zum Mitnehmen:

  1. Einfachheit: WireGuard zeichnet sich durch seine relativ einfache Konfiguration aus, was es auch für Einsteiger zugänglich macht.
  2. Leistung: Dank seiner modernen Architektur bietet WireGuard eine hervorragende Leistung bei geringem Ressourcenverbrauch.
  3. Sicherheit: Mit starker Verschlüsselung und einem minimalistischen Codebase bietet WireGuard ein hohes Maß an Sicherheit.
  4. Flexibilität: Die Möglichkeit zur Skalierung, Split-Tunneling und IPv6-Unterstützung macht WireGuard vielseitig einsetzbar.
  5. Wartung: Regelmäßige Updates, Backups und Sicherheitsüberprüfungen sind entscheidend für den langfristigen, sicheren Betrieb.

Denk daran, dass die Einrichtung eines VPN-Servers Verantwortung mit sich bringt. Halte dich stets über die neuesten Sicherheitspraktiken auf dem Laufenden und stelle sicher, dass dein Server regelmäßig gewartet wird. Mit der richtigen Pflege wird dein WireGuard VPN-Server ein zuverlässiges Werkzeug für sicheres und privates Surfen im Internet sein.

Ob du den VPN für persönliche Zwecke, für ein kleines Team oder als Teil einer größeren Netzwerkinfrastruktur einsetzt – die Flexibilität und Effizienz von WireGuard machen es zu einer ausgezeichneten Wahl für moderne VPN-Lösungen.Viel Erfolg bei deinem VPN-Projekt und genieße die Vorteile eines selbstverwalteten, sicheren Netzwerkzugangs!

Ressourcen

Schlagwörter

Ähnliche Beiträge

Kommentar verfassen