Obwohl die Bekanntheit von WireGuard in den letzten Monaten stark zugenommen hat, ist das VPN-Protokoll bzw, die VPN-Software immer noch verhältnismäßig unbekannt. Ich nutze WireGuard seit einigen Monaten und möchte es nicht mehr missen. Vor allem der schnelle Verbindungsaufbau, das exzellente Roaming-Verhalten und die gute Performance haben mich überzeugt.
Was sich genau hinter WireGuard verbirgt und wie die Software arbeitet, habe ich bereits in meinem Artikel “WireGuard – neues VPN-Protokoll mit großer Zukunft” beschrieben. Jetzt folgt sozusagen der zweite Teil, in dem ich detailliert auf die Einrichtung unter Raspbian Buster und Android eingehe.
WireGuard Installation
Zunächst bringen wir die Paketquellen und alle Pakete auf den aktuellen Stand.
sudo apt update
sudo apt upgradeNachdem dies erledigt ist, widmen wir uns der Installation von WireGuard.
sudo apt install wireguardDie Installation an sich ist damit erledigt. Allerdings fehlt ab Raspberry Pi OS Bullseye iptables, d.h. dieses müssen wir auch noch installieren:
sudo apt install iptablesJetzt können wir mit der Konfiguration fortfahren.
Generierung der benötigten Schlüsselpaare
Zum Start benötigen wir jeweils einen privaten und öffentlichen Schlüssel für den Client und den Server.
Die Erstellung der Keys wird im Verzeichnis “/etc/wireguard” durchgeführt. Damit alle Dateien bei der Erstellung direkt restriktive Berechtigungen haben, muss die umask auf 077 gesetzt werden.
sudo su
cd /etc/wireguard
umask 077
wg genkey | tee peer1_private.key | wg pubkey > peer1_public.key
wg genkey | tee server_private.key | wg pubkey > server_public.keyMittels “ls” prüfen wir, ob alle vier Dateien erstellt wurden:
ls
peer1_private.key peer1_public.key server_private.key server_public.keyZum Schluss können die Keys mittels “cat” ausgegeben werden, da wir diese später sowieso benötigen.
exit
sudo cat /etc/wireguard/peer1_private.key
sudo cat /etc/wireguard/peer1_public.key
sudo cat /etc/wireguard/server_private.key
sudo cat /etc/wireguard/server_public.keyWireGuard Server Konfiguration erstellen
Im ersten Schritt aktivieren wir das IPv4 Forwarding in der Datei “/etc/sysctl.conf”. Dies kann entweder mit Entfernen der Auskommentierung der Zeile “net.ipv4.ip_forward = 1” oder alternativ mit diesem Befehl erfolgen:
sudo perl -pi -e 's/#{1,}?net.ipv4.ip_forward ?= ?(0|1)/net.ipv4.ip_forward = 1/g' /etc/sysctl.confAnschließend muss der Raspberry Pi neugestartet werden.
sudo rebootWir überprüfen den Status mit folgendem Befehl:
sysctl net.ipv4.ip_forwardWenn das IPv4 Forwarding aktiv ist muss als Ergebnis “net.ipv4.ip_forward = 1” zurückgegeben werden.
Jetzt erstellen wir die WireGuard-Konfiguration “/etc/wireguard/wg0.conf”. Welchen Editor ihr bevorzugt, bleibt natürlich euch überlassen.
sudo vim /etc/wireguard/wg0.confFolgendes Template könnt ihr als Ausgangsbasis nutzen.
[Interface]
Address = 100.64.0.1/24
ListenPort = 51820
PrivateKey = <insert server_private.key>
#replace eth0 with the interface open to the internet (e.g might be wlan0)
PostUp = iptables -A FORWARD -i %i -j ACCEPT; iptables -A FORWARD -o %i -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i %i -j ACCEPT; iptables -D FORWARD -o %i -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE
#Client1 Smartphone
[Peer]
PublicKey = <insert peer1_public.key>
AllowedIPs = 100.64.0.2/32
Neben den IP-Adressen müsst ihr den privaten Schlüssel vom Server und den öffentlichen Schlüssel vom Client ergänzen. Außerdem müsst ihr bei den iptables-Regeln evtl. die Netzwerkschnittstelle anpassen. Optional könnt ihr zudem einen anderen Port definieren. Wenn alles erledigt ist, solltest ihr die Datei unbedingt speichern.
Eine elegante Alternative ist die Verwendung von IP-Adressen (100.64.0.0/10), die für Carrier-Grade-NAT (RFC 6598) reserviert sind. Damit ist sichergestellt, dass die Tunnel-IPs nie mit den privaten Adressbereichen kollidieren können.
WireGuard Client Konfiguration erstellen
Am besten erstellt ihr für jeden Client eine eigene Konfiguration.
sudo vim /etc/wireguard/peer1.confFolgendes Template könnt ihr als Ausgangsbasis nutzen.
[Interface]
Address = 100.64.0.2/32
DNS = 192.168.178.1
PrivateKey = <insert peer1_private.key>
#Server
[Peer]
PublicKey = <insert server_public.key>
Endpoint = t6bibneqwcjxplum.myfritz.net:51820
AllowedIPs = 0.0.0.0/0, ::/0
#PersistentkeepAlive = 25Hier müsst ihr unter “[Interface]” die IP-Adresse des Clients anpassen und den gewünschten DNS-Server eintragen. In meinem Beispiel verwende ich die private IP der FRITZ!Box. Wer daheim Pi-Hole im Einsatz hat, kann hier die Pi-Hole Adresse eintragen und kommt somit auch von unterwegs in den Genuss der Werbefreiheit.
Außerdem müsst ihr noch den privaten Schlüssel des Clients ergänzen.
Unter “[Peer]” tragt ihr zunächst den öffentlichen Schlüssel des Servers ein.
Anschließend folgt die Internetadresse, unter welcher der WireGuard-Server erreichbar ist. Üblicherweise gibt es hier zwei Dinge zu beachten. Bei eurem Internetanschluss daheim, bekommt ihr mit großer Wahrscheinlichkeit eine dynamische IP-Adresse vom Provider zugewiesen. Der WireGuard-Client müsste die wechselnden IP-Adressen stets kennen, um sich zu verbinden. Als Hilfe kommt hier ein dynamischer DNS-Anbieter ins Spiel, der einen festen Domainnamen bereitstellt und dahinter automatisch die jweils aktuelle IP-Adresse zuweist. Bei Verwendung einer FRITZ!Box könnt ihr beispielsweise den Dienst “MyFRITZ!” nutzen. Eine andere Alternative wäre FreeDNS. Der zweite Punkt ergibt sich, wenn der Raspberry Pi in eurem Heimnetzwerk steht. In diesem Fall müsst ihr an eurem Router ein Port-Forwarding einrichten (UDP 51820), sodass der WireGuard-Traffic des Clients auf den Server weitergeleitet wird.
Unter “AllowedIPs” wird definiert, welche IP-Ranges über das WireGuard-VPN geroutet werden. Mit “0.0.0.0/0, ::/0” wird der komplette IPv4- und IPv6-Traffic geroutet (full tunnel). Mit 192.168.178.0/24 könnt ihr z.B. nur euer Heimnetzwerk routen (split tunnel).
“PersistentKeepalive” ist standardmäßig deaktiviert. Zunächst ein paar Hintergrundinfos um einzuordnen, ob ihr dieses Feature benötigt oder nicht. Normalerweise ist WireGuard nicht sehr gesprächig und sendet nur Daten, wenn etwas zu übertragen ist. Ansonsten verhält sich WireGuard ruhig. Wenn sich der Server hinter einem NAT oder einer Firewall befindet und der Client für eine bestimmte Zeit keine Daten zum Server sendet, entfernt der NAT-Router bzw. die Firewall den Host-Status aus der Verbindungstabelle. Falls jetzt der Server ein Paket zum Client sendet, kommt dieses nicht an, da der NAT-Router bzw. die Firewall nicht weiß, was mit dem Paket zu tun ist. Mit der Option “PersistentKeepalive” sendet der Client alle x Sekunden ein leeres Paket, um die Verbindung aufrechtzuhalten. Ein Wert von 25 Sekunden hat sich in der Praxis bewährt und funktioniert mit einem Großteil von Firewalls und NAT-Routern.
Kurz zusammengefasst benötigt ihr dieses Feature also nur, wenn ihr vom Server euren Client erreichen möchtet, obwohl dieser seit längerer Zeit keine Pakete gesendet hat. Die meisten Benutzer werden dieses Feature nicht benötigen. Falls doch, einfach die Auskommentierung der Zeile rückgängig machen.
WireGuard Server starten
Nun können wir WireGuard auf dem Server starten. Anstatt alle einzelnen Schritte manuell mit dem “wg”-Tool durchzuführen, bedienen wir uns beim Tool “wg-quick”.
sudo wg-quick up wg0
[#] ip link add wg0 type wireguard
[#] wg setconf wg0 /dev/fd/63
[#] ip -4 address add 100.64.0.1/24 dev wg0
[#] ip link set mtu 1432 up dev wg0
[#] iptables -A FORWARD -i wg0 -j ACCEPT; iptables -A FORWARD -o wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
Die MTU von 1432 bezieht sich auf PPPoE mit IPv4. Bei IPv6 müsst ihr die MTU auf 1412 setzen. Wenn ihr Kabelinternet habt, dann sind Werte von 1440 bei IPv4 und 1420 bei IPv6 richtig.
Danach prüfen wir den Status der wg0-Schnittstelle.
sudo wg
interface: wg0
public key: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxljP1wpITnI=
private key: (hidden)
listening port: 51820
peer: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxtJd9/esWN4=
allowed ips: 100.64.0.2/32Der Server läuft und ist für die Verbindung des Clients bereit.
WireGuard beenden funktioniert mit diesem Befehl:
sudo wg-quick down wg0Wenn WireGuard beim Systemstart automatisch geladen werden soll, kann dies mit folgendem Befehl realisiert werden:
sudo systemctl enable wg-quick@wg0
Created symlink /etc/systemd/system/multi-user.target.wants/wg-quick@wg0.service → /lib/systemd/system/wg-quick@.service.Der Daemon kann folgendermaßen gesteuert werden. Dabei müsst ihr allerdings darauf achten, dass ihr WireGuard zuerst beendet, sofern ihr es manuell gestartet habt.
sudo systemctl start wg-quick@wg0
sudo systemctl stop wg-quick@wg0
systemctl status wg-quick@wg0Zum Schluss werden die Berechtigungen von “/etc/wireguard/” und allen Dateien noch einmal korrigiert. Damit wird sichergestellt, dass nur root die entsprechenden Berechtigungen besitzt.
sudo chown -R root:root /etc/wireguard/
sudo chmod -R og-rwx /etc/wireguard/*WireGuard Client unter Android einrichten
Die Einstellungen in der Android-App können manuell, mittels einer Datei oder mit einem QR-Code erfolgen. Die letzte Variante ist dabei am bequemsten. Hierfür muss auf dem Server der QR-Code erstellt werden.
sudo apt install qrencodeNach dem Installieren von “qrencode” kann der QR-Code von der Client-Konfiguration erstellt werden:
sudo cat /etc/wireguard/peer1.conf | qrencode -t ansiutf8Auf dem Android-Gerät muss zunächst die WireGuard App via Google Play installiert werden. Daraufhin kann der erstellte QR-Code mit der App gescannt werden, um die Konfiguration zu importieren. Nachdem ein Name vergeben wurde, kann die Verbindung aktiviert werden.
-
- WireGuard Android App – QR-Code scannen
-
- WireGuard Android App – Tunnel Name vergeben
-
- WireGuard Android App – Tunnel Infos
Mit einem Klick auf den gerade erstellten Tunnel werden einige Infos angezeigt, unter anderem auch eine Trafficstatistik.
Auf dem Server kann ebenfalls der Status ausgegeben werden. Dort werden unter anderem alle verbundenen Clients angezeigt:
sudo wg
interface: wg0
public key: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxljP1wpITnI=
private key: (hidden)
listening port: 51820
peer: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxtJd9/esWN4=
endpoint: 11.12.13.14:53019
allowed ips: 100.64.0.2/32
latest handshake: 56 seconds ago
transfer: 927.04 KiB received, 64.85 MiB sentDer Client kann nun auch via Ping erreicht werden:
ping 100.64.0.2
PING 100.64.0.2 (100.64.0.2) 56(84) bytes of data.
64 bytes from 100.64.0.2: icmp_seq=1 ttl=64 time=95.9 ms
64 bytes from 100.64.0.2: icmp_seq=2 ttl=64 time=112.4 ms
64 bytes from 100.64.0.2: icmp_seq=3 ttl=64 time=71.7 ms
Noch zwei kleine Tipps für die Android-App. Ich importieren die Konfig vom Server immer zweimal. Einmal als “full tunnel” mit “0.0.0.0/0, ::/0” und einmal als “split tunnel”, lediglich mit dem Heimnetzwerk eingetragen, z.B. 192.168.178.0/24. So habt ihr volle Kontrolle und könnt je nach Situation den richtigen Tunnel nutzen.
-
- WireGuard Android App – Tunnel Einstellungen bearbeiten
-
- WireGuard Android App – Bestimmte Apps ausschließen
Beim Bearbeiten eines Tunnels (Tunnel Infos anzeigen und dann rechts oben auf das Stift-Icon) könnt ihr außerdem festlegen, welche Apps keinen Traffic über den Tunnel schicken dürfen.
Troubleshooting
WireGuard ist ein Kernel-Modul, das via DKMS automatisch installiert wird, sobald das System einen neuen Kernel benutzt. In seltenen Fällen kann es jedoch passieren, dass WireGuard nicht automatisch eingebunden wird und mit dem neuen Kernel nicht mehr funktioniert.
In diesem Fall sollte zunächst geprüft werden, ob das WireGuard Modul geladen wurde:
lsmod | grep wireguardFalls nicht kann es hilfreich sein, das Kernel-Modul neu zu konfigurieren:
sudo dpkg-reconfigure wireguard-dkms
sudo modprobe wireguardWenn dies keine Abhilfe schafft, könnt ihr noch folgendes ausprobieren:
sudo apt remove wireguard
sudo apt install bc libncurses5-dev
sudo apt install wireguardSollte dies auch keine Besserung bringen, könnt ihr alternativ das WireGuard Kernel Module und das wg Tool selber kompilieren. Davor muss aber sichergestellt sein, dass alle installierten WireGuard-Pakete deinstalliert sind!
sudo apt remove wireguard
# Toolchain installieren
sudo apt install libmnl-dev raspberrypi-kernel-headers build-essential git pkg-config
#Code laden
git clone https://git.zx2c4.com/wireguard-linux-compat
git clone https://git.zx2c4.com/wireguard-tools
# Kernel Module und das wg Tool kompilieren und installieren
make -C wireguard-linux-compat/src -j$(nproc)
sudo make -C wireguard-linux-compat/src install
make -C wireguard-tools/src -j$(nproc)
sudo make -C wireguard-tools/src install
# Neustarten und fertig
sudo rebootDie aktuell installierte Version könnt ihr am besten via “dmesg” herausfinden:
dmesg | grep wireguard
[ 466.479104] wireguard: WireGuard 1.0.0 loaded. See www.wireguard.com for information.
[ 466.479115] wireguard: Copyright (C) 2015-2019 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
Quellen
- https://www.wireguard.com/install/
- https://github.com/adrianmihalko/raspberrypiwireguard
- https://www.reddit.com/r/pihole/comments/bnihyz/guide_how_to_install_wireguard_on_a_raspberry_pi/
- https://emanuelduss.ch/2018/09/wireguard-vpn-road-warrior-setup/
- https://www.bachmann-lan.de/raspberry-pi-mit-wireguard-als-vpn-server-mit-wireguard/
Sie sehen gerade einen Platzhalterinhalt von X. Um auf den eigentlichen Inhalt zuzugreifen, klicken Sie auf die Schaltfläche unten. Bitte beachten Sie, dass dabei Daten an Drittanbieter weitergegeben werden.
Mehr Informationen
Neueste Kommentare