So richten Sie den OpenVPN-Server ein

Wenn Sie einen VPN-Server in Ihrem lokalen Netzwerk ausführen, können externe Clients eine Verbindung zu Ihrem Server herstellen und auf das Netzwerk zugreifen, als wären sie direkt mit dem Server verbunden. Dies ist eine gängige Einrichtung für viele Unternehmen, die es ihren Mitarbeitern ermöglichen, sich aus der Ferne mit dem lokalen Unternehmensnetzwerk zu verbinden, so dass sie Zugriff auf interne Ressourcen haben, die nur im lokalen Netzwerk verfügbar sind. Linux-Administratoren und Power-User könnten auch daran interessiert sein, einen VPN-Server zu Hause einzurichten, da sie dann ihren Laptop oder ein anderes tragbares Gerät verwenden können, um sich unterwegs mit ihrem Heimnetzwerk zu verbinden.

Eine der besten Implementierungen eines VPN-Systems ist OpenVPN. Es ist vollständig Open Source und unterstützt viele Funktionen zur Anpassung. In diesem Tutorial gehen wir Schritt für Schritt die Anleitung zur Installation und Einrichtung von OpenVPN auf einem Linux-System durch. Dazu gehört auch die Installation von Easy-RSA für CA- und Client-Zertifikate. Dann zeigen wir, wie Sie ein Client-System verwenden, um eine Verbindung zum VPN-Server herzustellen und mit dem Zugriff auf das lokale Netzwerk des Servers zu beginnen. Folgen Sie uns unten, um loszulegen.

In diesem Tutorial lernen Sie:

So installieren Sie OpenVPN Server auf den wichtigsten Linux-Distributionen
So konfigurieren Sie einen Zertifizierungsstellenserver mit Easy-RSA
So konfigurieren Sie die Einstellungen des OpenVPN-Servers
So generieren Sie Zertifikate und Schlüssel für VPN-Clients
So verwalten Sie den OpenVPN-Dienst
So konfigurieren Sie den Kernel-Parameter für die IP-Weiterleitung
Erstellen von Clientkonfigurationsdateien
So verbinden Sie sich mit dem OpenVPN-Server

NOTE
In diesem Tutorial wird davon ausgegangen, dass Sie über mindestens drei Geräte verfügen. Eines ist für den OpenVPN-Server, ein anderes für die Zertifizierungsstelle und schließlich mindestens ein Clientgerät, das Sie für die Verbindung mit dem VPN-Server verwenden möchten.

Einrichten einer Zertifizierungsstelle

Zunächst richten wir das System ein, das wir für die Zertifizierungsstelle (CA) verwenden möchten. Befolgen Sie die folgenden Schritt-für-Schritt-Anweisungen, um den CA-Server fertigzustellen:

Installieren Sie zunächst das Easy-RSA-Paket. Dies wird das Tool sein, das wir verwenden, um einen privaten Schlüssel zu generieren, der dann Anfragen von eingehenden Client-Verbindungen signiert, bei denen die CA die Identität des OpenVPN-Servers überprüfen muss. Auf Debian- und Ubuntu-basierten Systemen:
```
sudo apt install easy-rsa
```
Auf Fedora-basierten Systemen:
```
sudo dnf install easy-rsa
```
Beginnen wir als Nächstes mit der Konfiguration von Easy-RSA. Dazu erstellen wir ein Verzeichnis für unsere Public Key Infrastructure (PKI). Dies kann beliebig benannt werden, aber wir werden es zum Beispiel einfach halten:
```
mkdir ~/easy-rsa
```
Als nächstes können wir entweder alle Easy-RSA-Dateien in unser neues PKI-Verzeichnis kopieren oder einfach einen symbolischen Link zu ihnen erstellen. Der Vorteil der Erstellung des symbolischen Links besteht darin, dass wir unser PKI-Verzeichnis nicht ändern müssen, falls es zukünftige Updates für das Easy-RSA-Paket gibt. Führen Sie den folgenden Befehl aus, um die Verknüpfung zu erstellen:
```
ln -s /usr/share/easy-rsa/* ~/easy-rsa/
cd ~/easy-rsa
```
Sobald wir uns im Verzeichnis ~/easy-rsa befinden, führen wir das Skript aus, das es als PKI-Verzeichnis initialisiert.
```
./easyrsa init-pki
```
Als nächstes müssen wir einige Variablen in unserer Konfiguration setzen. Dies kann durch Erstellen einer Datei mit dem Namen vars im PKI-Verzeichnis ~/easy-rsa erfolgen.
```
nano vars
```
Der folgende Inhalt kann eingefügt werden; Passen Sie es einfach an Ihre eigenen Informationen an:
```
set_var EASYRSA_REQ_COUNTRY    "US"
set_var EASYRSA_REQ_PROVINCE   "LA"
set_var EASYRSA_REQ_CITY       "Los Angeles"
set_var EASYRSA_REQ_ORG        "LinuxConfig.org"
set_var EASYRSA_REQ_EMAIL      "admin@linuxconfig.org"
set_var EASYRSA_REQ_OU         "Linux Tutorials"
set_var EASYRSA_ALGO           "ec"
set_var EASYRSA_DIGEST         "sha512"
```
Nachdem Sie die Datei zu Ihrer Zufriedenheit bearbeitet haben, speichern Sie die Änderungen und beenden Sie sie.
Als nächstes führen wir das build-ca-Skript aus. Dadurch wird die Zertifizierungsstelle erstellt, die ein öffentliches und privates Schlüsselpaar generiert.
```
./easyrsa build-ca
```
Sie werden aufgefordert, eine Passphrase einzugeben, die das Schlüsselpaar sichert. Geben Sie dann einen Namen ein, der Ihren CA-Server darstellt, z. B. den Hostnamen oder den Benutzernamen. Wir verwenden linuxconfig-CA im folgenden Screenshot:
Ihr Server ist jetzt bereit, als Zertifizierungsstelle zu fungieren. Alle Clients, die mit Ihrer Zertifizierungsstelle interagieren müssen, benötigen eine Kopie der Datei ca.crt, die im Verzeichnis ~/easy-rsa/pki gespeichert werden sollte, wenn Sie uns gefolgt sind.
```
cat ~/easy-rsa/pki/ca.crt
```
Es liegt an Ihnen, wie Sie die Datei verteilen, aber alle VPN-Clients benötigen eine Kopie davon.

WARNING
Achten Sie darauf, Ihre ca.key Datei sicher aufzubewahren. Diese Datei wird unter ~/easy-rsa/pki/private/ca.key gespeichert und sollte das System niemals verlassen. Wenn diese Datei kompromittiert wird, wird der Zweck der Zertifizierungsstelle unbrauchbar.

OpenVPN und Easy-RSA-Installation

Nun gehen wir zum VPN-Server über. Hier werden wir die VPN-Server-Software installieren, während der CA-Server, den wir im vorherigen Abschnitt konfiguriert haben, für das Ausstellen oder Widerrufen von Zertifikaten verantwortlich ist.

Der erste Schritt besteht darin, die OpenVPN-Software und Easy-RSA zu installieren. Diese können einfach über offizielle Repositories auf allen wichtigen Linux-Distributionen installiert werden. Sie können den entsprechenden Befehl unten verwenden, um OpenVPN und Easy-RSA mit dem Paketmanager Ihres Systems zu installieren.

So installieren Sie OpenVPN und Easy-RSA unter Ubuntu, Debian und Linux Mint:


sudo apt install openvpn easy-rsa

So installieren Sie OpenVPN und Easy-RSA auf Fedora, CentOS, AlmaLinux und Red Hat:


sudo dnf install openvpn easy-rsa

So installieren Sie OpenVPN und Easy-RSA auf Arch Linux und Manjaro:


sudo pacman -S openvpn easy-rsa

Einrichten von OpenVPN Server und Easy-RSA

Wir beginnen nun mit der Einrichtung des VPN-Servers. Die ersten Schritte werden Ihnen bekannt vorkommen, da wir einige Dinge wiederholen müssen, die wir auch auf dem CA-Server gemacht haben. Fangen wir an.

Erstellen Sie zunächst das Verzeichnis easy-rsa, wie wir es zuvor getan haben, und erstellen Sie einen symbolischen Link zu den installierten Dateien.
```
mkdir ~/easy-rsa
ln -s /usr/share/easy-rsa/* ~/easy-rsa/
cd ~/easy-rsa
```
Erstellen Sie eine vars-Datei, aber dieses Mal müssen wir nicht alle Informationen ausfüllen, die wir auf der Zertifizierungsstelle gemacht haben.
```
nano vars
```
Fügen Sie die folgenden Zeilen in die Datei ein und speichern Sie sie:
```
set_var EASYRSA_ALGO "ec"
set_var EASYRSA_DIGEST "sha512"
```
Dies sind die empfohlenen Sicherheitseinstellungen sowohl für maximale Geschwindigkeit als auch für Sicherheit. Sie können sie natürlich nach Belieben ändern.
Im Verzeichnis ~/easy-rsa führen wir das Skript aus, das es als PKI-Verzeichnis initialisiert.
```
./easyrsa init-pki
```
Als Nächstes generieren wir einen privaten Schlüssel für den VPN-Server sowie einen Certificate Signing Request (CSR). In späteren Schritten muss diese Anforderung von der Zertifizierungsstelle signiert werden, die wir zuvor konfiguriert haben. Werfen Sie einen Blick auf die folgende Befehlssyntax:
```
./easyrsa gen-req linuxconfig-server nopass
```
Hier übergeben wir die Option gen-req an das easyrsa-Skript. Dann übergeben wir einen Namen für unseren VPN-Server, der linuxconfig-server sein wird. Schließlich beseitigt die Option nopass den Passwortschutz in der Anforderungsdatei, was den gesamten Prozess vereinfacht.
Jetzt müssen wir den privaten Schlüssel des VPN-Servers in das OpenVPN-Verzeichnis kopieren. Die Ausgabe des vorherigen Befehls sollte Ihnen den vollständigen Pfad zu Ihrem privaten Schlüssel mitteilen. In unserem Fall wird der folgende Befehl verwendet:
```
sudo cp ~/easy-rsa/pki/private/linuxconfig-server.key /etc/openvpn/server/
```
Sie müssten linuxconfig-server.key durch den Namen Ihres eigenen privaten Schlüssels ersetzen.
Der nächste Schritt besteht darin, die CSR auf den CA-Server zu übertragen, damit sie signiert werden kann. Sie können die Datei beliebig übertragen, z.B. mit dem Befehl scp.
```
scp ~/easy-rsa/pki/reqs/linuxconfig-server.req linuxconfig@ca_server:/tmp
```
Wechsel zum CA-Server jetzt. Nachdem die .req-Datei an den CA-Server übertragen wurde, importieren wir sie und signieren dann die Anforderung:
```
cd ~/easy-rsa
./easyrsa import-req /tmp/linuxconfig-server.req linuxconfig-server
./easyrsa sign-req server linuxconfig-server
```
Stellen Sie sicher, dass Sie bei Bedarf Ihre eigenen gebräuchlichen Namen ersetzen. Unserer ist einfach linuxconfig-server. Sie werden auch zur Eingabe des Kennworts aufgefordert, das wir zuvor auf dem CA-Server konfiguriert haben.
Jetzt müssen wir die Dateien ca.key und linuxconfig-server.crt vom CA-Server zurück auf den VPN-Server übertragen. Verwenden Sie dazu scp oder die von Ihnen bevorzugte Methode:
```
scp ~/easy-rsa/pki/issued/linuxconfig-server.crt linuxconfig@vpn_server:/tmp
scp ~/easy-rsa/pki/ca.crt linuxconfig@vpn_server:/tmp
```
Jetzt wieder auf den VPN-Server umschalten. Nehmen Sie auf dem VPN-Server die Dateien aus dem Verzeichnis /tmp, das wir gerade übertragen haben, und legen Sie sie im Verzeichnis /etc/openvpn/server ab. Sie benötigen Root-Berechtigungen, um sie zu verschieben:
```
sudo mv /tmp/{linuxconfig-server.crt,ca.crt} /etc/openvpn/server
```
Als letzte Sicherheitsmaßnahme können wir einen tls-crypt Pre Shared Key generieren. Dies erhöht die Sicherheit für den OpenVPN-Server und erleichtert die Verarbeitung des eingehenden Datenverkehrs.
```
cd ~/easy-rsa
openvpn --genkey secret ta.key
```
Kopieren Sie die generierte ta.key Datei in das Verzeichnis /etc/openvpn/server/:
```
sudo cp ta.key /etc/openvpn/server
```

Jetzt sind wir bereit, mit der Generierung von Zertifikaten und Schlüsseln für jeden Client fortzufahren, der sich mit dem VPN verbindet.

Generieren von Zertifikaten und Schlüsseln für Clients

Diese Schritte werden auf dem VPN-Server ausgeführt, bis wir schließlich auf den CA-Server umschalten, was deutlich angezeigt wird. Sie müssen diese Schritte für jeden VPN-Client wiederholen. Hier könnten sich einige Bash-Skripte als nützlich erweisen, falls Sie den Prozess in Zukunft automatisieren möchten.

Zuerst erstellen wir ein Verzeichnis, in dem wir die Schlüssel für die Clients speichern werden.
```
mkdir ~/client-keys
```
Navigieren Sie zum Easy-RSA-Verzeichnis, und verwenden Sie dann das easyrsa-Skript, um eine Anforderung für einen Client zu generieren. In diesem Beispiel erhält unser Client den Namen linuxconfig-client. Ändern Sie Ihre nach Bedarf:
```
cd ~/easy-rsa
./easyrsa gen-req linuxconfig-client nopass
```
Kopieren Sie die neu erstellte linuxconfig-client.key Datei in das Verzeichnis ~/client-keys, das wir zuvor erstellt haben:
```
cp ~/easy-rsa/pki/private/linuxconfig-client.key ~/client-keys
```
Außerdem müssen wir die Datei linuxconfig-client.req auf den CA-Server übertragen, um sie zu signieren. Verwenden Sie dazu scp oder eine andere Methode:
```
scp ~/easy-rsa/pki/reqs/linuxconfig-client.req linuxconfig@ca_server:/tmp
```
Wechsel zum CA-Server jetzt. Importieren und signieren Sie die Zertifikatanforderung für den VPN-Client auf dem CA-Server:
```
cd ~/easy-rsa
./easyrsa import-req /tmp/linuxconfig-client.req linuxconfig-client
./easyrsa sign-req client linuxconfig-client
```
Sie werden zur Eingabe des CA-Kennworts aufgefordert, das in den vorherigen Schritten konfiguriert wurde. Das sollte Ihnen alles bekannt vorkommen, da der Prozess so ziemlich derselbe ist wie bei der Unterzeichnung der CSR für den VPN-Server.

Übertragen wir die Datei linuxconfig-client.crt auf den VPN-Server:


scp ~/easy-rsa/pki/issued/linuxconfig-client.crt linuxconfig@vpn_server:/tmp

Jetzt wieder auf den VPN-Server umschalten. Kopieren Sie auf dem VPN-Server die linuxconfig-client.crt in das Verzeichnis, das wir zuvor erstellt haben, ~/client-keys:
```
cp /tmp/linuxconfig-client.crt ~/client-keys
```
Wir müssen auch die Dateien ta.key und ca.crt in dieses Verzeichnis kopieren:
```
cp ~/easy-rsa/ta.key ~/client-keys
sudo cp /etc/openvpn/server/ca.crt ~/client-keys
```

OpenVPN-Konfiguration

OpenVPN verfügt über verschiedene Beispieldateien, die verwendet werden können, um eine Starthilfe für Ihre eigenen VPN-Serverkonfigurationen zu erhalten. Wir werden eine dieser Dateien verwenden und beginnen, sie an unsere Bedürfnisse anzupassen. Sie können auch Ihre eigenen Anpassungen auf dem Weg anwenden, aber einige der unten aufgeführten Vorschläge müssen angewendet werden, um mit der vorherigen Konfiguration zu arbeiten, die wir eingerichtet haben.

Beachten Sie, dass die folgenden Schritte auf dem VPN-Server durchzuführen sind.

Wir beginnen damit, die Beispieldatei server.conf aus der OpenVPN-Dokumentation zu nehmen und sie in das Verzeichnis /etc/openvpn/server zu kopieren.
```
sudo cp /usr/share/doc/openvpn/examples/sample-config-files/server.conf /etc/openvpn/server/
```
Öffnen Sie die neu kopierte Datei, um mit der Bearbeitung zu beginnen:
```
sudo nano /etc/openvpn/server/server.conf
```
Wir müssen diese Datei so konfigurieren, dass das TLS-Zertifikat verwendet wird, das wir zuvor erstellt haben. Suchen Sie die folgende Zeile, und kommentieren Sie sie aus, indem Sie ihr ein Zeichen ; voranstellen:
```
tls-auth ta.key 0 # This file is secret
```
Fügen Sie darunter die folgende Zeile hinzu:
```
tls-crypt ta.key
```
Das Endergebnis sollte wie folgt aussehen:
```
;tls-auth ta.key 0 # This file is secret
tls-crypt ta.key
```
Suchen Sie als Nächstes die folgende Chiffrezeile und kommentieren Sie sie aus:
```
cipher AES-256-CBC
```
Fügen Sie direkt darunter die folgenden zwei Zeilen hinzu:
```
cipher AES-256-GCM
auth SHA256
```
Das Endergebnis sollte wie folgt aussehen:
```
;cipher AES-256-CBC
cipher AES-256-GCM
auth SHA256
```
Dadurch wird unsere VPN-Verbindung gezwungen, eine bessere Verschlüsselung als die Standardkonfiguration zu verwenden.
Da wir unseren VPN-Server so konfiguriert haben, dass er ECC (Elliptic Curve Cryptography) anstelle von DH (Diffie-Hellman) verwendet, müssen wir die folgende dh-Zeile lokalisieren und auskommentieren:
```
dh dh2048.pem
```
Fügen Sie direkt darunter die folgende Zeile hinzu:
```
dh none
```
Das Endergebnis sollte wie folgt aussehen:
```
;dh dh2048.pem
dh none
```
Um die Berechtigungen des OpenVPN-Daemons bei der Initialisierung zu verringern und somit seine potenzielle Angriffsfläche zu verringern, suchen Sie die folgenden Zeilen und kommentieren Sie sie aus:
```
;user nobody
;group nobody
```
Entfernen Sie das ; vor ihnen, so dass es lautet:
```
user nobody
group nobody
```
Wenn Sie den gesamten Client-Datenverkehr über das VPN umleiten möchten, können Sie die folgende Zeile suchen und die Auskommentierung aufheben:
```
;push "redirect-gateway def1 bypass-dhcp"
```
Achten Sie darauf, das vorangestellte ; zu entfernen, um es auszukommentieren.
Dies ist nicht unbedingt notwendig, aber es ist das Verhalten, das die meisten VPNs verwenden, also ist es das, was die Kunden erwarten werden.
Heben Sie die Auskommentierung der folgenden Zeilen auf, die den VPN-Clients einige DNS-Server für die Namensauflösung zuweisen. Dies sind die IPs für OpenDNS-Server, aber Sie können beliebige DNS-Server-IPs einfügen:
```
;push "dhcp-option DNS 208.67.222.222"
;push "dhcp-option DNS 208.67.220.220"
```
Achten Sie darauf, die beiden vorangestellten η-Zeichen zu entfernen, um die Auskommentierung dieser Zeilen aufzuheben.
Suchen Sie abschließend die folgenden Zeilen:
```
cert server.crt
key server.key
```
Wir müssen diese so bearbeiten, dass sie auf die Dateien verweisen, die wir zuvor generiert haben. In unserem Beispiel haben wir linuxconfig-server als allgemeinen Namen verwendet, daher ändern wir diese in:
```
cert linuxconfig-server.crt
key linuxconfig-server.key
```

Fertig, also speichern Sie Ihre Änderungen an dieser Datei und beenden Sie sie.

Konfigurieren der IP-Weiterleitung

Auf dem OpenVPN-Server müssen wir den Parameter des IP-Weiterleitungskernels ändern, um sicherzustellen, dass VPN-Clients Anfragen an den OpenVPN-Server weiterleiten können, der sie dann an ein endgültiges Ziel weiterleiten kann.

Bearbeiten Sie die folgende Datei mit Root-Rechten:
```
sudo nano /etc/sysctl.conf
```
Fügen Sie am Ende der Datei die folgende Zeile hinzu:
```
net.ipv4.ip_forward = 1
```
Speichern Sie Ihre Änderungen und beenden Sie die Datei.
Führen Sie dann Folgendes aus, damit die Änderungen wirksam werden:
```
sudo sysctl -p
```

Starten Sie den OpenVPN-Dienst

Nachdem OpenVPN nun konfiguriert wurde, können wir den Dienst starten.

Mit dem folgenden Befehl wird der OpenVPN-Dienst gestartet:


sudo systemctl start openvpn-server@server.service

Wenn Sie möchten, dass OpenVPN automatisch gestartet wird, wenn sich der Server einschaltet, können wir systemctl enable wie folgt verwenden:


sudo systemctl -f enable openvpn-server@server.service

Verwenden Sie den folgenden Befehl, um den Status des Dienstes jederzeit zu überprüfen:


systemctl status openvpn.service

Erstellen einer Clientkonfigurationsdatei

Der letzte Schritt besteht darin, eine Konfigurationsdatei für Ihren VPN-Client zu erstellen. Diese Datei kann dann zusammen mit den .crt-Dateien und den .key-Dateien an die VPN-Clients gesendet werden, um eine Verbindung mit dem VPN-Server herzustellen.

Kopieren Sie zunächst die Beispieldatei client.conf in das Verzeichnis ~/client-keys, das wir zuvor erstellt haben:
```
cp /usr/share/doc/openvpn/examples/sample-config-files/client.conf ~/client-keysclient.conf
```
Dies ist nur eine Vorlagendatei, an der wir mehrere Änderungen vornehmen müssen. Öffnen Sie die Datei, um mit der Bearbeitung zu beginnen:
```
nano ~/client-keys/client.conf
```
Suchen Sie die folgende Zeile:
```
remote my-server-1 1194
```
Hier müssen wir die IP unseres VPN-Servers angeben. Der 1194 ist nur der Port, auf dem OpenVPN läuft, also ändern Sie diesen Teil nur, wenn nötig. Ersetzen Sie my-server-1 durch die IP-Adresse Ihres OpenVPN-Servers.
Wie in der Serverkonfigurationsdatei kommentieren Sie die folgenden zwei Zeilen aus:
```
;user nobody
;group nobody
```
Suchen Sie die folgenden Zeilen und kommentieren Sie sie aus:
```
ca ca.crt
cert client.crt
key client.key
```
Diese werden für uns irrelevant sein, da wir die Inline-Konfiguration verwenden werden.
Suchen Sie die folgende Zeile und kommentieren Sie sie aus:
```
tls-auth ta.key 1
```
Dies ist eine irrelevante Linie und wir werden sowieso eine Inline-Konfiguration verwenden.
Suchen Sie die folgende Zeile und kommentieren Sie sie aus:
```
cipher AES-256-CBC
```
Ersetzen Sie sie durch die folgenden zwei Zeilen:
```
cipher AES-256-GCM
auth SHA256
```
Das Endergebnis wird:
```
;cipher AES-256-CBC
cipher AES-256-GCM
auth SHA256
```
Fügen Sie am Ende dieser Datei die folgende Zeile hinzu:
```
key-direction 1
```
Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Wir werden nun alle diese Zertifikate, Konfigurations- und Schlüsseldateien in einer einzigen .ovpn-Datei kombinieren, die zur einfachen Verbindung an den Client gesendet werden kann.


cd ~/client-keys
cat client.conf > linuxconfig-client.ovpn
echo '<CA>' >> linuxconfig-client.ovpn
cat ca.crt >> linuxconfig-client.ovpn
echo '</CA>' >> linuxconfig-client.ovpn
echo '<cert>' >> linuxconfig-client.ovpn
cat linuxconfig-client.crt >> linuxconfig-client.ovpn
echo '</cert>' >> linuxconfig-client.ovpn
echo '<key>' >> linuxconfig-client.ovpn
cat linuxconfig-client.key >> linuxconfig-client.ovpn
echo '</key>' >> linuxconfig-client.ovpn
echo '<tls-crypt>' >> linuxconfig-client.ovpn
cat ta.key >> linuxconfig-client.ovpn
echo '</tls-crypt>'

Dies ist etwas umständlich, insbesondere im großen Maßstab, weshalb einige Bash-Skripte empfohlen werden, wenn Sie dies häufig tun möchten. Auf jeden Fall ist das Endergebnis eine vollständige linuxconfig-client.ovpn-Datei, die an den OpenVPN-Client gesendet werden kann.

Verbindung zum OpenVPN-Server herstellen

Die Verbindung zum VPN-Server ist der einfachste Teil. Nachdem Sie alle Dateien erhalten haben, die auf dem OpenVPN-Server generiert wurden, verwenden Sie die folgende Befehlssyntax, um eine Verbindung herzustellen:


sudo openvpn --config linuxconfig-client.ovpn

Die Anweisungen variieren natürlich je nach Betriebssystem wie MacOS und Windows, aber im Wesentlichen ist der Vorgang fast derselbe – stellen Sie einfach die .ovpn-Datei dem OpenVPN-Client-Programm zur Verfügung.

Abschließende Gedanken

In diesem Tutorial haben wir gesehen, wie man einen OpenVPN-Server auf einem Linux-System einrichtet. Dazu gehörte auch die Einrichtung eines separaten Zertifizierungsstellen-Servers mittels Easy-RSA. Der Prozess ist ziemlich langwierig, ermöglicht es uns aber, einen VPN-Server mit den besten Sicherheitsmaßnahmen selbst zu hosten. Jetzt wissen Sie, wie Sie Schlüsselpaare und Konfigurationen für zukünftige Client-Verbindungen generieren und in Form von .opvn-Dateien verteilen können.