So erstellen Sie ein VPN unter Ubuntu 20.04 mit Wireguard

Wireguard ist ein modernes und sehr einfach einzurichtendes VPN, das auf mehreren Betriebssystemen verfügbar ist. Die Anwendung ist in den offiziellen Repositories von Ubuntu 20.04 verfügbar, so dass sie auch sehr einfach zu installieren ist. Im Gegensatz zu anderer Software wie OpenVPN, die auf der Verwendung von SSL-Zertifikaten basiert, basiert Wireguard auf der Verwendung von Schlüsselpaaren. In diesem Tutorial sehen wir, wie Sie in wenigen einfachen Schritten einen VPN-Server und einen Client-Peer auf der neuesten stabilen Version von Ubuntu konfigurieren.

In diesem Tutorial lernen Sie:

• So installieren Sie Wireguard auf Ubuntu 20.04 Focal Fossa
• So erstellen Sie ein öffentliches und privates Schlüsselpaar
• Konfigurieren des Servers und eines Clientpeers
• So leiten Sie den gesamten eingehenden Datenverkehr an das VPN um

Wireguard VPN auf Ubuntu 20.04

Verwendete Softwareanforderungen und Konventionen

Installation

Wireguard ist offiziell im "universe" -Repository von Ubuntu 20.04 verfügbar, daher können wir es über apt installieren. Die verfügbare Version ist zum Zeitpunkt des Schreibens 1.0.20200319-1ubuntu1:

sudo apt install wireguard

Das System fordert uns auf, zu bestätigen, dass wir das Programm und seine Abhängigkeiten installieren möchten, und schließt den Vorgang in Sekundenschnelle ab.

Generieren von Schlüsseln

Wir müssen für jeden Computer, den wir in unserem VPN verwenden möchten, einen öffentlichen und einen privaten Schlüssel generieren. Der private Schlüssel sollte auf dem Computer geheim gehalten werden, der öffentliche Schlüssel wird verwendet, um von den anderen Peers auf den Computer zuzugreifen.

Um die Schlüssel zu generieren, können wir das Dienstprogramm wg verwenden. In der Wireguard-Konfigurationsdatei müssen wir auf den privaten Schlüssel des Computers verweisen, während der öffentliche Schlüssel auf den anderen Peers verwendet wird. Beachten Sie, dass wir die Schlüssel direkt referenzieren werden, so dass wir sie theoretisch nicht in Dateien speichern müssen. Wir werden es jedoch trotzdem tun, nur der Bequemlichkeit halber.

Um den privaten Schlüssel für unseren Server zu generieren, müssen wir den Unterbefehl genkey von wg verwenden. Der Befehl gibt den erstellten Schlüssel an stdout aus; Um den Schlüssel in eine Datei zu schreiben, können wir die Macht der Shell-Umleitungen nutzen:

wg genkey > server_private_key

Der Befehl generiert den Schlüssel und speichert ihn in der server_private_key Datei, löst jedoch die folgende Warnung aus:

Warning: writing to world accessible file.
Consider setting the umask to 077 and trying again.

Dies liegt daran, dass mit dem Standardbenutzer umask (002) die Dateien mit dem Modus 664 erstellt werden, also weltlesbar sind, was nicht empfohlen wird. Um dieses Problem zu lösen, können wir entweder die in der aktuellen Shell-Sitzung verwendete umask ändern, bevor wir die Dateien erstellen:

umask 077

Oder ändern Sie die Dateiberechtigungen nach der Erstellung auf 600. Hier werden wir uns für die letztere Lösung entscheiden.

Sobald unser privater Schlüssel fertig ist, können wir den öffentlichen Schlüssel generieren, der darauf basiert. Um die Aufgabe zu erfüllen, verwenden wir den Unterbefehl pubkey von wg. Genau wie zuvor verwenden wir Shell-Umleitungen: zuerst um den Inhalt der server_private_key-Datei an die stdin des Befehls zu übergeben, und dann und um den generierten Schlüssel in die server_public_key Datei umzuleiten:

wg pubkey < server_private_key > server_public_key

Um etwas Tipparbeit zu sparen, können wir beide Schlüssel mit nur einem Befehl generieren, der die Verwendung des Operators shell | (pipe) und des Befehls tee beinhaltet:

wg genkey | tee server_private_key | wg pubkey > server_public_key

Die Ausgabe des Befehls auf der linken Seite des Pipe-Operators (|) wird an die Standardeingabe des Programms auf der rechten Seite übergeben. Der tee-Befehl ermöglicht es uns stattdessen, die Ausgabe eines Befehls sowohl in eine Datei als auch in die Standardausgabe umzuleiten (mehr über Shell-Umleitungen hier).

Sobald unsere Schlüssel fertig sind, können wir die Serverkonfigurationsdatei erstellen.

Server-Konfigurationsdatei

Um unsere Wireguard-Installation zu konfigurieren, können wir eine Konfigurationsdatei namens wg0.conf mit folgendem Inhalt erstellen:

[Interface]
PrivateKey = <private key of the server (the content of the server_private_key file)>
Address = 10.0.0.1/24
ListenPort = 51820

Beachten Sie, dass der Name der Datei beliebig ist, aber er sollte auf dem Namen basieren, den wir für unsere Schnittstelle verwenden werden, in diesem Fall wg0. Dieser Name wird beim Starten des Dienstes referenziert, wie wir unten sehen werden.

In unserem Beispiel. Der Abschnitt [interface] der Konfigurationsdatei enthält die folgenden Felder:

• PrivateKey
• Adresse
• ListenPort

Der Wert des Felds "PrivateKey" ist nichts anderes als der private Schlüssel des Servers, den wir zuvor generiert haben.

Im Feld Adresse haben wir die Adresse angegeben, die der Schnittstelle im VPN zusammen mit der Subnetzmaske in der CIDR-Notation zugewiesen werden soll. In diesem Fall haben wir 10.0.0.1/24 verwendet, sodass unsere Wireguard-"Server"-Adresse innerhalb des VPN 10.0.0.1 lautet, was im verfügbaren Adressbereich von 10.0.0.1 bis 10.0.0.254 liegt.

Schließlich haben wir im Feld ListenPort angegeben, an welchem Port Wireguard auf eingehenden Datenverkehr lauscht. Eine Regel, die diesen Datenverkehr zulässt, muss auch zu unserer Firewall hinzugefügt werden. Wir werden dies im nächsten Abschnitt tun.

Wir können nun die Berechtigungen der Dateien ändern und sie in das Verzeichnis /etc/wireguard verschieben:

chmod 600 server_public_key server_private_key wg0.conf
sudo mv server_private_key server_public_key wg0.conf /etc/wireguard

Wir können jetzt den wg-quick-Dienst starten, indem wir den Namen der Wireguard-Schnittstelle nach @ im Unit-Namen angeben. Wie lautet diese Schreibweise? Es ist eine Funktion von systemd: Mit ihm können wir mehrere Unit-Dateien auf der Basis einer "Vorlage" generieren und den Wert, der in der Vorlage ersetzt wird, nach dem @-Symbol im Namen der Einheit übergeben. Dies ist der Inhalt der Einheit wg-quick@.service:

[Unit]
Description=WireGuard via wg-quick(8) for %I
After=network-online.target nss-lookup.target
Wants=network-online.target nss-lookup.target
Documentation=man:wg-quick(8)
Documentation=man:wg(8)
Documentation=https://www.wireguard.com/
Documentation=https://www.wireguard.com/quickstart/
Documentation=https://git.zx2c4.com/wireguard-tools/about/src/man/wg-quick.8
Documentation=https://git.zx2c4.com/wireguard-tools/about/src/man/wg.8

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/usr/bin/wg-quick up %i
ExecStop=/usr/bin/wg-quick down %i
Environment=WG_ENDPOINT_RESOLUTION_RETRIES=infinity

[Install]
WantedBy=multi-user.target

Der Wert, den wir nach dem @ im Unit-Namen angeben, wenn wir sie starten oder stoppen, ersetzt %i in den Zeilen ExecStart und ExecStop. In diesem Fall verwenden wir wg0:

sudo systemctl enable --now wg-quick@wg0

Mit dem obigen Befehl haben wir den Dienst gestartet und auch make so, dass beim Booten automatisch gestartet wird. Um zu überprüfen, ob unsere Konfiguration angewendet wurde, können wir den Befehl wg ausführen. Die erzeugte Ausgabe sollte Informationen über die wg0-Schnittstelle anzeigen:

sudo wg
interface: wg0
  public key: nNx3Zpcv9D2dtgHDsoYGBNr64zG5jTJ4Z4T2sE759V4=
  private key: (hidden)
  listening port: 51820

Lassen Sie uns nun fortfahren und unsere Firewall und Paketweiterleitung konfigurieren.

Firewall und Netzwerkeinrichtung

In diesem Tutorial gehe ich von der Verwendung von ufw aus. Wie bereits erwähnt, müssen wir eine Regel hinzufügen, um eingehenden Datenverkehr über den Port zuzulassen, den wir in der Konfigurationsdatei 51820 angegeben haben. Wir tun dies, indem wir einen sehr einfachen Befehl ausführen:

sudo ufw allow 51820/udp

Wir müssen auch die Paketweiterleitung auf unserem System zulassen. Um die Aufgabe zu erfüllen, entfernen wir den Kommentar aus Zeile 28 der Datei /etc/sysctl.conf, so dass er wie folgt aussieht:

Uncomment the next line to enable packet forwarding for IPv4
net.ipv4.ip_forward=1

Um die Änderungen wirksam zu machen, ohne das System neu zu starten, müssen wir den folgenden Befehl ausführen:

sudo sysctl -p

Im nächsten Schritt konfigurieren wir den Client.

Generierung von Client-Schlüsseln

Kommen wir nun zu dem System, das wir als Client verwenden möchten. Wir müssen Wireguard darauf installieren. Sobald dies erledigt ist, können wir ein Schlüsselpaar generieren, genau wie wir es auf dem Server getan haben:

wg genkey | tee client_private_key | wg pubkey > client_public_key

Genau wie wir es serverseitig gemacht haben, erstellen wir die Konfigurationsdatei wg0.conf. Diesmal mit diesem Inhalt:

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

[Peer]
PublicKey = <server_public_key>
EndPoint  = <server_public_ip>:51820
AllowedIPs = 0.0.0.0/0

Die Bedeutung der im Abschnitt Schnittstelle enthaltenen Felder haben wir bereits bei der Erstellung der Serverkonfiguration gesehen. Hier haben wir nur die Werte an unseren Client angepasst (er wird die Adresse 10.0.0.2 im VPN haben).

In dieser Konfiguration haben wir einen neuen Abschnitt verwendet, [Peer]. Darin können wir die Informationen in Bezug auf einen Peer angeben, in diesem Fall den, den wir als "Server" verwenden. Die Felder, die wir verwendet haben, sind:

• PublicKey
• EndPoint
• Zulässige IPs

Im Feld PublicKey geben wir den öffentlichen Schlüssel des Peers an, in diesem Fall also den öffentlichen Schlüssel, den wir auf dem Server generiert haben.

Der Endpunkt ist die öffentliche IP-Adresse oder der Hostname des Peers, gefolgt von einem Doppelpunkt und der Portnummer, an der der Peer lauscht (in unserem Fall 51820).

Schließlich ist der Wert, der an das Feld "AllowedIPs" übergeben wird, eine durch Trennzeichen getrennte Liste von IP-Adressen und Subnetzmasken mit CIDR-Notation. Es wird nur Datenverkehr zugelassen, der von den angegebenen Adressen an den Peer geleitet wird. In diesem Fall haben wir 0.0.0.0/0 als Wert verwendet: Es funktioniert als "Catch-All"-Wert, sodass der gesamte Datenverkehr an den VPN-Peer (den Server) gesendet wird.

Genau wie wir es serverseitig gemacht haben, setzen wir die entsprechenden Berechtigungen und verschieben die Schlüssel und die Konfigurationsdatei in das Verzeichnis /etc/wireguard:

chmod 600 client_public_key client_private_key wg0.conf
sudo mv client_public_key client_private_key wg0.conf /etc/wireguard

Wenn die Konfigurationsdatei vorhanden ist, können wir den Dienst starten:

sudo systemctl enable --now wg-quick@wg0

Schließlich muss der Abschnitt [Peer] relativ zu unserem Client zu der Konfigurationsdatei hinzugefügt werden, die wir zuvor auf dem Server erstellt haben. Wir fügen den folgenden Inhalt hinzu:

[Peer]
PublicKey = <public key of the client>
AllowedIPs = 10.0.0.2/32

An dieser Stelle starten wir den Dienst neu:

sudo systemctl restart wg-quick@wg0

Die Informationen über den zugeordneten Peer sollten nun in der Ausgabe des wg-Befehls gemeldet werden:

sudo wg
interface: wg0
  public key: nNx3Zpcv9D2dtgHDsoYGBNr64zG5jTJ4Z4T2sE759V4=
  private key: (hidden)
  listening port: 51820

peer: t5pKKg5/9fJKiU0lrNTahv6gvABcmCjQq5gF3BxwiDQ=
  allowed ips: 10.0.0.2/32

Zu diesem Zeitpunkt sollten wir vom "Client"-System aus in der Lage sein, den Server unter der Adresse 10.0.0.1 anzupingen:

ping -c 3 10.0.0.1
PING 10.0.0.1 (10.0.0.1) 56(84) bytes of data.
64 bytes from 10.0.0.1: icmp_seq=1 ttl=64 time=2.82 ms
64 bytes from 10.0.0.1: icmp_seq=2 ttl=64 time=38.0 ms
64 bytes from 10.0.0.1: icmp_seq=3 ttl=64 time=3.02 ms

--- 10.0.0.1 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2003ms
rtt min/avg/max/mdev = 2.819/14.613/37.999/16.536 ms

Schlüsse

In diesem Tutorial haben wir gesehen, wie man ein VPN mit Wireguard auf der neuesten stabilen Version von Ubuntu erstellt: 20.04 Focal Fossa. Die Software ist sehr einfach zu installieren und zu konfigurieren, insbesondere im Vergleich zu anderen Lösungen, wie zum Beispiel OpenVpn.

Wir haben gesehen, wie wir die öffentlichen und privaten Schlüssel generieren, die für unser Setup verwendet werden, und wie wir sowohl den Server als auch einen Client so konfigurieren, dass der gesamte Datenverkehr an das VPN umgeleitet wird. Wenn Sie den Anweisungen folgen, haben Sie ein funktionierendes Setup. Weitere Informationen finden Sie auf der Projektseite.