GNU/Linux >> LINUX-Kenntnisse > >> Ubuntu

So richten Sie einen OpenVPN-Server unter Ubuntu 18.04 ein

Egal, ob Sie sicher auf das Internet zugreifen möchten, während Sie mit einem nicht vertrauenswürdigen öffentlichen Wi-Fi-Netzwerk verbunden sind, geografisch eingeschränkte Inhalte umgehen oder Ihren Kollegen ermöglichen möchten, sich sicher mit Ihrem Unternehmensnetzwerk zu verbinden, wenn Sie remote arbeiten, die Verwendung eines VPN ist die beste Lösung.

Mit einem VPN können Sie sich mit entfernten VPN-Servern verbinden, Ihre Verbindung verschlüsselt und sicher machen und anonym im Internet surfen, indem Sie Ihre Verkehrsdaten privat halten.

Es gibt viele kommerzielle VPN-Anbieter, aus denen Sie wählen können, aber Sie können nie wirklich sicher sein, dass der Anbieter Ihre Aktivitäten nicht protokolliert. Am sichersten ist es, einen eigenen VPN-Server einzurichten.

Dieses Tutorial führt Sie durch den Prozess der Einrichtung Ihres eigenen VPN-Servers, indem Sie OpenVPN auf Ubuntu 18.04 installieren und konfigurieren. Wir zeigen Ihnen auch, wie Sie Client-Zertifikate generieren und Konfigurationsdateien erstellen

OpenVPN ist eine voll funktionsfähige Open-Source-SSL-VPN-Lösung (Secure Socket Layer). Es implementiert eine sichere Netzwerkerweiterung der OSI-Schicht 2 oder 3 unter Verwendung des SSL/TLS-Protokolls.

Voraussetzungen #

Um dieses Tutorial abzuschließen, benötigen Sie:

Sudo-Zugriff auf einen Ubuntu 18.04-Server zum Hosten Ihrer OpenVPN-Instanz.
Auf dem Server sollte eine grundlegende UFW-Firewall konfiguriert sein.
Separater dedizierter Computer, der als Ihre CA (Zertifizierungsstelle) dient. Wenn Sie keinen dedizierten Computer für Ihre CA verwenden möchten, können Sie die CA auf Ihrem OpenVPN-Server oder Ihrem lokalen Computer erstellen. Sobald Sie mit dem Erstellen der Zertifizierungsstelle fertig sind, wird empfohlen, das CA-Verzeichnis an einen sicheren Ort oder offline zu verschieben.

Dieses Tutorial geht davon aus, dass sich die Zertifizierungsstelle auf einem separaten Ubuntu 18.04-Computer befindet. Die gleichen Schritte (mit kleinen Änderungen) gelten, wenn Sie Ihren Server als Zertifizierungsstelle verwenden.

Der Grund, warum wir eine separate CA-Maschine verwenden, besteht darin, Angreifer daran zu hindern, den Server zu infiltrieren. Wenn es einem Angreifer gelingt, auf den privaten CA-Schlüssel zuzugreifen, kann er damit neue Zertifikate signieren, die ihm Zugriff auf den VPN-Server gewähren.

Zertifizierungsstelle mit EasyRSA erstellen #

Bei der Einrichtung eines neuen OpenVPN-Servers besteht der erste Schritt darin, eine Public Key Infrastructure (PKI) aufzubauen. Dazu müssen wir Folgendes erstellen:

Ein Zertifikat der Zertifizierungsstelle (CA) und ein privater Schlüssel.
Ein separates Zertifikat und ein privates Schlüsselpaar für den Server, ausgestellt von unserer Zertifizierungsstelle.
Ein separates Zertifikat und ein privates Schlüsselpaar für jeden Client, ausgestellt von unserer CA.

Wie in den Voraussetzungen aus Sicherheitsgründen erwähnt, bauen wir die Zertifizierungsstelle auf einem eigenständigen Computer auf.

Zum Erstellen von Zertifizierungsstellen, Zertifikatanforderungen und Signieren von Zertifikaten verwenden wir ein CLI-Dienstprogramm namens EasyRSA.

Führen Sie die folgenden Schritte auf Ihrem CA-Computer aus .

Laden Sie zunächst die neueste Version von EasyRSA aus dem Projekt-Github-Repository mit dem folgenden wget-Befehl herunter:
```
cd && wget https://github.com/OpenVPN/easy-rsa/releases/download/v3.0.5/EasyRSA-nix-3.0.5.tgz
```
Sobald der Download abgeschlossen ist, extrahieren Sie das Archiv mit:
```
tar xzf EasyRSA-nix-3.0.5.tgz
```
Wechseln Sie in das EasyRSA-Verzeichnis und erstellen Sie eine Konfigurationsdatei mit dem Namen vars durch Kopieren der vars.example Datei:
```
cd ~/EasyRSA-3.0.5/cp vars.example vars
```

Öffnen Sie die Datei und kommentieren Sie die folgenden Einträge aus und aktualisieren Sie sie entsprechend Ihren Informationen.

nano ~/EasyRSA-3.0.5/vars

~/EasyRSA-3.0.5/vars

set_var EASYRSA_REQ_COUNTRY    "US"
set_var EASYRSA_REQ_PROVINCE   "Pennsylvania"
set_var EASYRSA_REQ_CITY       "Pittsburgh"
set_var EASYRSA_REQ_ORG        "Linuxize"
set_var EASYRSA_REQ_EMAIL      "[email protected]"
set_var EASYRSA_REQ_OU         "Community"

Bevor wir ein CA-Schlüsselpaar generieren, müssen wir zuerst eine neue PKI initialisieren mit:

./easyrsa init-pki

init-pki complete; you may now create a CA or requests.
Your newly created PKI dir is: /home/causer/EasyRSA-3.0.5/pki

Der nächste Schritt besteht darin, die Zertifizierungsstelle zu erstellen:
```
./easyrsa build-ca
```
Wenn Sie nicht jedes Mal, wenn Sie Ihre Zertifikate signieren, zur Eingabe eines Passworts aufgefordert werden möchten, führen Sie build-ca aus Befehl mit dem nopass Option:./easyrsa build-ca nopass .
```
...
Enter PEM pass phrase:
Verifying - Enter PEM pass phrase:
-----
...
-----
Common Name (eg: your user, host, or server name) [Easy-RSA CA]:

CA creation complete and you may now import and sign cert requests.
Your new CA certificate file for publishing is at:
/home/causer/EasyRSA-3.0.5/pki/ca.crt
```
Sie werden aufgefordert, ein Kennwort für den CA-Schlüssel festzulegen und einen allgemeinen Namen für Ihre CA einzugeben.

Nach Abschluss erstellt das Skript zwei Dateien – das öffentliche CA-Zertifikat ca.crt und privater CA-Schlüssel ca.key .

Nachdem die Zertifizierungsstelle (CA) erstellt wurde, können Sie sie verwenden, um Zertifikatsanfragen für einen oder mehrere OpenVPN-Server und -Clients zu signieren.

Installieren von OpenVPN und EasyRSA #

Unser nächster Schritt besteht darin, das OpenVPN-Paket zu installieren, das in den Ubuntu-Repositories verfügbar ist, und die neueste Version von EasyRSA herunterzuladen.

Die folgenden Schritte werden auf dem OpenVPN-Server durchgeführt .

Die OpenVPN-Installation ist ziemlich einfach, führen Sie einfach die folgenden Befehle auf dem OpenVPN-Server aus :
```
sudo apt updatesudo apt install openvpn
```
Laden Sie die neueste Version von EasyRSA herunter:
```
cd && wget https://github.com/OpenVPN/easy-rsa/releases/download/v3.0.5/EasyRSA-nix-3.0.5.tgz
```
Sobald der Download abgeschlossen ist, geben Sie den folgenden Befehl ein, um das Archiv zu extrahieren:
```
tar xzf EasyRSA-nix-3.0.5.tgz
```
Obwohl wir bereits eine PKI auf dem CA-Rechner initialisiert haben, müssen wir auch eine neue PKI auf dem OpenVPN-Server erstellen. Verwenden Sie dazu dieselben Befehle wie zuvor:
```
cd ~/EasyRSA-3.0.5/./easyrsa init-pki
```
Wenn Sie sich immer noch fragen, warum wir zwei EasyRSA-Installationen benötigen, liegt das daran, dass wir diese EasyRSA-Instanz verwenden werden, um Zertifikatsanforderungen zu generieren, die mit der EasyRSA-Instanz auf dem CA-Computer signiert werden .

Es mag kompliziert und wenig verwirrend klingen, aber sobald Sie das gesamte Tutorial gelesen haben, werden Sie sehen, dass es wirklich nicht kompliziert ist.

Diffie-Hellman- und HMAC-Schlüssel erstellen #

In diesem Abschnitt generieren wir einen starken Diffie-Hellman-Schlüssel, der während des Schlüsselaustauschs verwendet wird, und eine HMAC-Signaturdatei, um der Verbindung eine zusätzliche Sicherheitsebene hinzuzufügen.

Navigieren Sie zunächst zum EasyRSA-Verzeichnis auf Ihrem OpenVPN-Server .
```
cd ~/EasyRSA-3.0.5/
```
Generieren Sie einen Diffie-Hellman-Schlüssel:
```
./easyrsa gen-dh
```
Das Skript generiert 2048 Bit lange DH-Parameter. Dies kann insbesondere auf Servern mit wenig Ressourcen einige Zeit in Anspruch nehmen. Nach Abschluss wird die folgende Nachricht auf Ihrem Bildschirm gedruckt:
```
DH parameters of size 2048 created at /home/serveruser/EasyRSA-3.0.5/pki/dh.pem
```
Kopieren Sie die dh.pem Datei in /etc/openvpn Verzeichnis:
```
sudo cp ~/EasyRSA-3.0.5/pki/dh.pem /etc/openvpn/
```
Generieren Sie eine HMAC-Signatur:
```
openvpn --genkey --secret ta.key
```
Wenn Sie fertig sind, kopieren Sie den ta.key Datei in /etc/openvpn Verzeichnis:
```
sudo cp ~/EasyRSA-3.0.5/ta.key /etc/openvpn/
```

Serverzertifikat und privater Schlüssel werden erstellt #

Dieser Abschnitt beschreibt, wie Sie einen privaten Schlüssel und eine Zertifikatsanforderung für den OpenVPN-Server generieren.

Navigieren Sie zum EasyRSA-Verzeichnis auf Ihrem OpenVPN-Server und generieren Sie einen neuen privaten Schlüssel für den Server und eine Zertifikatsanforderungsdatei:
```
cd ~/EasyRSA-3.0.5/./easyrsa gen-req server1 nopass
```
Wir verwenden den nopass Argument, weil wir den OpenVPN-Server ohne Passworteingabe starten wollen. Auch in diesem Beispiel verwenden wir server1 als Servername (Entität) Identifikator. Wenn Sie einen anderen Namen für Ihren Server wählen, vergessen Sie nicht, die Anweisungen unten anzupassen, wo der Servername verwendet wird.

Der Befehl erstellt zwei Dateien, einen privaten Schlüssel (server1.key ) und eine Zertifikatanforderungsdatei (server1.req ).
```
-----
Common Name (eg: your user, host, or server name) [server1]:

Keypair and certificate request completed. Your files are:
req: /home/serveruser/EasyRSA-3.0.5/pki/reqs/server1.req
key: /home/serveruser/EasyRSA-3.0.5/pki/private/server1.key
```
Kopieren Sie den privaten Schlüssel nach /etc/openvpn Verzeichnis:
```
sudo cp ~/EasyRSA-3.0.5/pki/private/server1.key /etc/openvpn/
```
Übertragen Sie die Zertifikatanforderungsdatei auf Ihren CA-Rechner:
```
scp ~/EasyRSA-3.0.5/pki/reqs/server1.req causer@your_ca_ip:/tmp
```
In diesem Beispiel verwenden wir scp Um die Datei zu übertragen, können Sie auch rsync verwenden über ssh oder eine andere sichere Methode.
Melden Sie sich bei Ihrem CA-Rechner an , wechseln Sie in das EasyRSA-Verzeichnis und importieren Sie die Zertifikatsanforderungsdatei:
```
cd ~/EasyRSA-3.0.5./easyrsa import-req /tmp/server1.req server1
```
Das erste Argument ist der Pfad zur Zertifikatsanforderungsdatei und das zweite ist der Kurzname (Entität) des Servers. In unserem Fall ist der Servername server1 .
```
The request has been successfully imported with a short name of: server1
You may now use this name to perform signing operations on this request.
```
Dieser Befehl kopiert einfach die Anforderungsdatei in pki/reqs Verzeichnis.

Noch im EasyRSA-Verzeichnis auf dem CA-Rechner Führen Sie den folgenden Befehl aus, um die Anfrage zu signieren:

cd ~/EasyRSA-3.0.5./easyrsa sign-req server server1

Das erste Argument kann entweder server sein oder client und der zweite ist der Kurzname (Entität) des Servers.

Sie werden aufgefordert, zu bestätigen, dass die Anfrage von einer vertrauenswürdigen Quelle stammt. Geben Sie yes ein und drücken Sie enter bestätigen:

You are about to sign the following certificate.
Please check over the details shown below for accuracy. Note that this request
has not been cryptographically verified. Please be sure it came from a trusted
source or that you have verified the request checksum with the sender.

Request subject, to be signed as a server certificate for 1080 days:

subject=
    commonName                = server1

Type the word 'yes' to continue, or any other input to abort.
Confirm request details: yes
...

Wenn Ihr CA-Schlüssel passwortgeschützt ist, werden Sie aufgefordert, das Passwort einzugeben. Nach der Überprüfung generiert das Skript das SSL-Zertifikat und gibt den vollständigen Pfad dazu aus.

...
Certificate is to be certified until Sep 17 10:54:48 2021 GMT (1080 days)

Write out database with 1 new entries
Data Base Updated

Certificate created at: /home/causer/EasyRSA-3.0.5/pki/issued/server1.crt

Im nächsten Schritt übertragen Sie das signierte Zertifikat server1.crt und ca.crt Dateien zurück auf Ihren OpenVPN-Server. Auch hier können Sie scp verwenden , rsync oder eine andere sichere Methode:
```
scp ~/EasyRSA-3.0.5/pki/issued/server1.crt serveruser@your_server_ip:/tmpscp ~/EasyRSA-3.0.5/pki/ca.crt serveruser@your_server_ip:/tmp
```
Melden Sie sich bei Ihrem OpenVPN-Server an , und verschieben Sie server1.crt und ca.crt Dateien in das Verzeichnis /etc/openvpn/ Verzeichnis:
```
sudo mv /tmp/{server1,ca}.crt /etc/openvpn/
```

Nach Abschluss der in diesem Abschnitt beschriebenen Schritte sollten Sie die folgenden neuen Dateien auf Ihrem OpenVPN-Server haben :

/etc/openvpn/ca.crt
/etc/openvpn/dh.pem
/etc/openvpn/ta.key
/etc/openvpn/server1.crt
/etc/openvpn/server1.key

Konfigurieren des OpenVPN-Dienstes #

Nun, da Sie das Serverzertifikat von Ihrer Zertifizierungsstelle signiert und auf Ihren OpenVPN-Server übertragen haben , ist es an der Zeit, den OpenVPN-Dienst zu konfigurieren.

Wir werden die mit dem OpenVPN-Installationspaket bereitgestellte Beispielkonfigurationsdatei als Ausgangspunkt verwenden und ihr dann unsere eigenen benutzerdefinierten Konfigurationsoptionen hinzufügen.

Beginnen Sie mit dem Extrahieren der Konfigurationsdatei nach /etc/openvpn/ Verzeichnis:

sudo sh -c "gunzip -c /usr/share/doc/openvpn/examples/sample-config-files/server.conf.gz > /etc/openvpn/server1.conf"

Öffnen Sie die Datei mit Ihrem bevorzugten Texteditor:

sudo nano /etc/openvpn/server1.conf

Suchen Sie die Anweisungen für Zertifikats-, Schlüssel- und DH-Parameter und ändern Sie die Dateinamen:
/etc/openvpn/server1.conf
```
cert server1.crt
key server1.key 

dh dh.pem
```
Um den Client-Verkehr durch das VPN umzuleiten, suchen und kommentieren Sie das redirect-gateway und dhcp-option Optionen:
/etc/openvpn/server1.conf
```
push "redirect-gateway def1 bypass-dhcp"

push "dhcp-option DNS 208.67.222.222"
push "dhcp-option DNS 208.67.220.220"
```
Standardmäßig werden OpenDNS-Resolver verwendet. Sie können es ändern und CloudFlare, Google oder andere gewünschte DNS-Resolver verwenden.
Suchen Sie den user und group Direktiven und kommentieren Sie diese Einstellungen aus, indem Sie die „; ” am Anfang jeder Zeile:
/etc/openvpn/server1.conf
```
user nobody
group nogroup
```
Fügen Sie die folgende Zeile am Ende der Datei an. Diese Direktive ändert den Nachrichtenauthentifizierungsalgorithmus (HMAC) von SHA1 auf SHA256
/etc/openvpn/server1.conf
```
auth SHA256
```

Sobald Sie fertig sind, sollte die Serverkonfigurationsdatei (ohne Kommentare) etwa so aussehen:

/etc/openvpn/server1.conf

port 1194
proto udp
dev tun
ca ca.crt
cert server1.crt
key server1.key  # This file should be kept secret
dh dh.pem
server 10.8.0.0 255.255.255.0
ifconfig-pool-persist /var/log/openvpn/ipp.txt
push "redirect-gateway def1 bypass-dhcp"
push "dhcp-option DNS 208.67.222.222"
push "dhcp-option DNS 208.67.220.220"
keepalive 10 120
tls-auth ta.key 0 # This file is secret
cipher AES-256-CBC
user nobody
group nogroup
persist-key
persist-tun
status /var/log/openvpn/openvpn-status.log
verb 3
explicit-exit-notify 1
auth SHA256

OpenVPN-Dienst wird gestartet #

In diesem Tutorial haben wir server1.conf verwendet als Konfigurationsdatei. Um den OpenVPN-Dienst mit dieser Konfiguration zu starten, müssen wir den Namen der Konfigurationsdatei nach dem Dateinamen der systemd-Unit angeben:

Auf Ihrem OpenVPN-Server Führen Sie den folgenden Befehl aus, um den OpenVPN-Dienst zu starten:

sudo systemctl start openvpn@server1

Überprüfen Sie, ob der Dienst erfolgreich gestartet wurde, indem Sie Folgendes eingeben:

sudo systemctl status openvpn@server1

Wenn der Dienst aktiv ist und ausgeführt wird, sieht die Ausgabe etwa so aus:

● [email protected] - OpenVPN connection to server1
   Loaded: loaded (/lib/systemd/system/[email protected]; disabled; vendor preset: enabled)
   Active: active (running) since Mon 2018-10-08 20:11:57 UTC; 6min ago
     Docs: man:openvpn(8)
           https://community.openvpn.net/openvpn/wiki/Openvpn24ManPage
           https://community.openvpn.net/openvpn/wiki/HOWTO
 Main PID: 26739 (openvpn)
   Status: "Initialization Sequence Completed"

Aktivieren Sie den Dienst so, dass er beim Booten automatisch gestartet wird mit:

sudo systemctl enable openvpn@server1

Created symlink /etc/systemd/system/multi-user.target.wants/[email protected] → /lib/systemd/system/[email protected].

Wenn der OpenVPN-Dienst nicht gestartet werden kann, überprüfen Sie die Protokolle mit sudo journalctl -u openvpn@server1

Der OpenVPN-Server erstellt ein neues tun-Gerät tun0 . Um zu prüfen, ob das Gerät verfügbar ist, verwenden Sie den folgenden ip-Befehl:

ip a show tun0

Die Ausgabe sollte in etwa so aussehen:

4: tun0: <POINTOPOINT,MULTICAST,NOARP,UP,LOWER_UP> mtu 1500 qdisc fq state UNKNOWN group default qlen 100
    link/none 
    inet 10.8.0.1 peer 10.8.0.2/32 scope global tun0
       valid_lft forever preferred_lft forever
    inet6 fe80::1627:9a20:bca8:e6a5/64 scope link stable-privacy 
       valid_lft forever preferred_lft forever

An diesem Punkt ist Ihr OpenVPN-Server konfiguriert und läuft ordnungsgemäß.

Firewall- und Server-Netzwerkkonfiguration #

Um Netzwerkpakete richtig weiterzuleiten, müssen wir die IP-Weiterleitung aktivieren.

Die folgenden Schritte werden auf dem OpenVPN-Server durchgeführt .

Öffnen Sie die /etc/sysctl.conf Datei und fügen Sie die Zeile hinzu, die net.ipv4.ip_forward = 1 lautet, oder kommentieren Sie sie aus :

sudo nano /etc/sysctl.conf

/etc/sysctl.conf

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

Wenn Sie fertig sind, speichern und schließen Sie die Datei.

Wenden Sie die neuen Einstellungen an, indem Sie den folgenden Befehl ausführen:

sudo sysctl -p

net.ipv4.ip_forward = 1

Wenn Sie die Voraussetzungen erfüllt haben, sollte auf Ihrem Server bereits eine UFW-Firewall laufen.

Jetzt müssen wir Firewall-Regeln hinzufügen, um Masquerading zu aktivieren. Dadurch kann der Datenverkehr das VPN verlassen und Ihren VPN-Clients Zugriff auf das Internet geben.

Bevor Sie die Regeln hinzufügen, müssen Sie die öffentliche Netzwerkschnittstelle Ihres Ubuntu OpenVPN-Servers kennen. Sie können die Schnittstelle leicht finden, indem Sie den folgenden Befehl ausführen:

ip -o -4 route show to default | awk '{print $5}'

In unserem Fall heißt die Schnittstelle ens3 wie in der Ausgabe unten gezeigt. Ihre Schnittstelle wird wahrscheinlich einen anderen Namen haben.

ens3

Standardmäßig werden bei Verwendung von UFW die weitergeleiteten Pakete verworfen. Wir müssen das ändern und unsere Firewall anweisen, weitergeleitete Pakete zuzulassen.

Öffnen Sie die UFW-Konfigurationsdatei, suchen Sie DEFAULT_FORWARD_POLICY Taste und ändern Sie den Wert von DROP ACCEPT :

sudo nano /etc/default/ufw

/etc/default/ufw

...
# Set the default forward policy to ACCEPT, DROP or REJECT.  Please note that
# if you change this you will most likely want to adjust your rules
DEFAULT_FORWARD_POLICY="ACCEPT"
...

Als nächstes müssen wir die Standardrichtlinie für POSTROUTING festlegen chain in der nat-Tabelle und setze die Masquerade-Regel.

Öffnen Sie dazu die /etc/ufw/before.rules Datei und fügen Sie die gelb hervorgehobenen Zeilen wie unten gezeigt an.

sudo nano /etc/ufw/before.rules

Vergessen Sie nicht, ens3 zu ersetzen im -A POSTROUTING Zeile so, dass sie mit dem Namen der öffentlichen Netzwerkschnittstelle übereinstimmt, die Sie im vorherigen Befehl gefunden haben. Fügen Sie die Zeilen nach der letzten Zeile beginnend mit COMMIT ein .

/etc/ufw/before.rules

...
# don't delete the 'COMMIT' line or these rules won't be processed
COMMIT

#NAT table rules
*nat
:POSTROUTING ACCEPT [0:0]

# Forward traffic through ens3 - Change to public network interface
-A POSTROUTING -s 10.8.0.0/16 -o ens3 -j MASQUERADE

# don't delete the 'COMMIT' line or these rules won't be processed
COMMIT

Wenn Sie fertig sind, speichern und schließen Sie die Datei.

Wir müssen auch UDP-Datenverkehr auf Port 1194 öffnen Dies ist der Standard-OpenVPN-Port. Führen Sie dazu den folgenden Befehl aus:

sudo ufw allow 1194/udp

Falls Sie vergessen haben, den SSH-Port zu öffnen, um eine Sperrung zu vermeiden, führen Sie den folgenden Befehl aus, um den Port zu öffnen:

sudo ufw allow OpenSSH

Laden Sie abschließend die UFW-Regeln neu, indem Sie UFW deaktivieren und erneut aktivieren:

sudo ufw disablesudo ufw enable

Um die Änderungen zu überprüfen, führen Sie den folgenden Befehl aus, um die POSTROUTING-Regeln aufzulisten:

sudo iptables -nvL POSTROUTING -t nat

Chain POSTROUTING (policy ACCEPT 0 packets, 0 bytes)
 pkts bytes target     prot opt in     out     source               destination
    0     0 MASQUERADE  all  --  *      ens3    10.8.0.0/16          0.0.0.0/0

Erstellen der Client-Konfigurationsinfrastruktur #

In diesem Tutorial erstellen wir ein separates SSL-Zertifikat und generieren eine andere Konfigurationsdatei für jeden VPN-Client.

Der private Clientschlüssel und die Zertifikatsanforderung können entweder auf dem Clientcomputer oder auf dem Server generiert werden. Der Einfachheit halber generieren wir die Zertifikatsanforderung auf dem Server und senden sie dann zum Signieren an die Zertifizierungsstelle.

Der gesamte Vorgang zum Generieren des Client-Zertifikats und der Konfigurationsdatei ist wie folgt:

Generieren Sie einen privaten Schlüssel und eine Zertifikatsanforderung auf dem OpenVPN-Server.
Senden Sie die Anforderung zum Signieren an die CA-Maschine.
Kopieren Sie das signierte SSL-Zertifikat auf den OpenVPN-Server und generieren Sie eine Konfigurationsdatei.
Senden Sie die Konfigurationsdatei an den Rechner des VPN-Clients.

Erstellen Sie zunächst eine Reihe von Verzeichnissen zum Speichern der Client-Dateien:

mkdir -p ~/openvpn-clients/{configs,base,files}

base Das Verzeichnis speichert die Basisdateien und die Konfiguration, die von allen Clientdateien gemeinsam genutzt werden.
configs Verzeichnis speichert die generierte Client-Konfiguration.
files Verzeichnis speichert Client-spezifisches Zertifikat/Schlüsselpaar.

Kopieren Sie die ca.crt und ta.key Dateien nach ~/openvpn-clients/base Verzeichnis:

cp ~/EasyRSA-3.0.5/ta.key ~/openvpn-clients/base/cp /etc/openvpn/ca.crt ~/openvpn-clients/base/

Kopieren Sie als Nächstes die Beispiel-VPN-Client-Konfigurationsdatei in client-~/openvpn-clients/base Verzeichnis. Wir werden diese Datei als Basiskonfiguration verwenden:

cp /usr/share/doc/openvpn/examples/sample-config-files/client.conf ~/openvpn-clients/base/

Jetzt müssen wir die Datei bearbeiten, damit sie mit unseren Servereinstellungen und -konfigurationen übereinstimmt. Öffnen Sie die Konfigurationsdatei mit Ihrem Texteditor:

nano ~/openvpn-clients/base/client.conf

Suchen Sie die Remote-Direktive und ändern Sie den Standardplatzhalter mit der öffentlichen IP-Adresse Ihres OpenVPN-Servers:
~/openvpn-clients/base/client.conf
```
# The hostname/IP and port of the server.
# You can have multiple remote entries
# to load balance between the servers.
remote YOUR_SERVER_IP 1194
```

Suchen und kommentieren Sie ca , cert , und key Richtlinien. Die Zertifikate und Schlüssel werden in der Konfigurationsdatei hinzugefügt:

~/openvpn-clients/base/client.conf

# SSL/TLS parms.
# See the server config file for more
# description.  It's best to use
# a separate .crt/.key file pair
# for each client.  A single ca
# file can be used for all clients.
# ca ca.crt
# cert client.crt
# key client.key

Fügen Sie am Ende der Datei die folgende Zeile an, um die Servereinstellungen anzupassen:
~/openvpn-clients/base/client.conf
```
auth SHA256
```

Sobald Sie fertig sind, sollte die Serverkonfigurationsdatei etwa so aussehen:

~/openvpn-clients/base/client.conf

client
dev tun
proto udp
remote YOUR_SERVER_IP 1194
resolv-retry infinite
nobind
persist-key
persist-tun
remote-cert-tls server
cipher AES-256-CBC
verb 3
auth SHA256
key-direction 1

Erstellen Sie als Nächstes ein einfaches Bash-Skript, das die Basiskonfiguration und -dateien mit dem Clientzertifikat und -schlüssel zusammenführt, und speichern Sie die generierte Konfiguration in ~/openvpn-clients/configs Verzeichnis.

Öffnen Sie Ihren Texteditor und erstellen Sie das folgende Skript:

nano ~/openvpn-clients/gen_config.sh

~/openvpn-clients/gen_config.sh

#!/bin/bash

FILES_DIR=$HOME/openvpn-clients/files
BASE_DIR=$HOME/openvpn-clients/base
CONFIGS_DIR=$HOME/openvpn-clients/configs

BASE_CONF=${BASE_DIR}/client.conf
CA_FILE=${BASE_DIR}/ca.crt
TA_FILE=${BASE_DIR}/ta.key

CLIENT_CERT=${FILES_DIR}/${1}.crt
CLIENT_KEY=${FILES_DIR}/${1}.key

# Test for files
for i in "$BASE_CONF" "$CA_FILE" "$TA_FILE" "$CLIENT_CERT" "$CLIENT_KEY"; do
    if [[ ! -f $i ]]; then
        echo " The file $i does not exist"
        exit 1
    fi

    if [[ ! -r $i ]]; then
        echo " The file $i is not readable."
        exit 1
    fi
done

# Generate client config
cat > ${CONFIGS_DIR}/${1}.ovpn <<EOF
$(cat ${BASE_CONF})
<key>
$(cat ${CLIENT_KEY})
</key>
<cert>
$(cat ${CLIENT_CERT})
</cert>
<ca>
$(cat ${CA_FILE})
</ca>
<tls-auth>
$(cat ${TA_FILE})
</tls-auth>
EOF

Speichern Sie die Datei und machen Sie sie ausführbar, indem Sie den folgenden chmod ausführen Befehl:

chmod u+x ~/openvpn-clients/gen_config.sh

Erstellen des privaten Schlüssels und der Konfiguration des Clientzertifikats #

Der Vorgang zum Generieren eines privaten Clientschlüssels und einer Zertifikatsanforderung ist derselbe wie beim Generieren eines Serverschlüssels und einer Zertifikatsanforderung.

Wie wir bereits im vorherigen Abschnitt erwähnt haben, generieren wir den privaten Schlüssel des Clients und die Zertifikatsanforderung auf dem OpenVPN-Server. In diesem Beispiel lautet der Name des ersten VPN-Clients client1 .

Navigieren Sie zum EasyRSA-Verzeichnis auf Ihrem OpenVPN-Server und generieren Sie einen neuen privaten Schlüssel und eine Zertifikatsanforderungsdatei für den Client:
```
cd ~/EasyRSA-3.0.5/./easyrsa gen-req client1 nopass
```
Der Befehl erstellt zwei Dateien, einen privaten Schlüssel (client1.key ) und eine Zertifikatanforderungsdatei (client1.req ).
```
Common Name (eg: your user, host, or server name) [client1]:

Keypair and certificate request completed. Your files are:
req: /home/serveruser/EasyRSA-3.0.5/pki/reqs/client1.req
key: /home/serveruser/EasyRSA-3.0.5/pki/private/client1.key
```
Kopieren Sie den privaten Schlüssel client1.key zu ~/openvpn-clients/files Verzeichnis, das Sie im vorherigen Abschnitt erstellt haben:
```
cp ~/EasyRSA-3.0.5/pki/private/client1.key ~/openvpn-clients/files/
```
Übertragen Sie die Zertifikatanforderungsdatei auf Ihren CA-Rechner:
```
scp ~/EasyRSA-3.0.5/pki/reqs/client1.req causer@your_ca_ip:/tmp
```
In diesem Beispiel verwenden wir scp Um die Datei zu übertragen, können Sie auch rsync verwenden über ssh oder eine andere sichere Methode.
Melden Sie sich bei Ihrem CA-Rechner an , wechseln Sie in das EasyRSA-Verzeichnis und importieren Sie die Zertifikatsanforderungsdatei:
```
cd ~/EasyRSA-3.0.5./easyrsa import-req /tmp/client1.req client1
```
Das erste Argument ist der Pfad zur Zertifikatsanforderungsdatei und das zweite der Clientname.
```
The request has been successfully imported with a short name of: client1
You may now use this name to perform signing operations on this request.
```
Aus dem EasyRSA-Verzeichnis auf CA-Maschine Führen Sie den folgenden Befehl aus, um die Anfrage zu signieren:
```
cd ~/EasyRSA-3.0.5./easyrsa sign-req client client1
```
Sie werden aufgefordert, zu bestätigen, dass die Anfrage von einer vertrauenswürdigen Quelle stammt. Geben Sie yes ein und drücken Sie enter bestätigen:

Wenn Ihr CA-Schlüssel passwortgeschützt ist, werden Sie aufgefordert, das Passwort einzugeben. Nach der Überprüfung generiert das Skript das SSL-Zertifikat und gibt den vollständigen Pfad dazu aus.
```
...
Certificate created at: /home/causer/EasyRSA-3.0.5/pki/issued/client1.crt
```
Als nächstes übertragen Sie das signierte Zertifikat client1.crt Datei zurück auf Ihren OpenVPN-Server. Sie können scp verwenden , rsync oder eine andere sichere Methode:
```
scp ~/EasyRSA-3.0.5/pki/issued/client1.crt serveruser@your_server_ip:/tmp
```
Melden Sie sich bei Ihrem OpenVPN-Server an , und verschieben Sie die Datei client1.crt Datei in den ~/openvpn-clients/files Verzeichnis:
```
mv /tmp/client1.crt ~/openvpn-clients/files
```
Der letzte Schritt besteht darin, mithilfe von gen_config.sh eine Client-Konfiguration zu generieren Skript. Wechseln Sie zu ~/openvpn-clients Verzeichnis und führen Sie das Skript mit dem Clientnamen als Argument aus:
```
cd ~/openvpn-clients./gen_config.sh client1
```
Das Skript erstellt eine Datei namens client1.ovpn in ~/client-configs/configs Verzeichnis. Sie können dies überprüfen, indem Sie das Verzeichnis auflisten:
```
ls ~/openvpn-clients/configs
```
```
client1.ovpn
```

An dieser Stelle wird die Client-Konfiguration erstellt. Sie können nun die Konfigurationsdatei auf das Gerät übertragen, das Sie als Client verwenden möchten.

Zum Beispiel, um die Konfigurationsdatei mit scp auf Ihren lokalen Rechner zu übertragen Sie sollten den folgenden Befehl ausführen:

scp ~/openvpn-clients/configs/client1.ovpn your_local_ip:/

Um weitere Clients hinzuzufügen, wiederholen Sie einfach die gleichen Schritte.

Clients werden verbunden #

Linux #

Ihre Distribution oder Desktop-Umgebung stellt möglicherweise ein Tool oder eine grafische Benutzeroberfläche bereit, um eine Verbindung zu OpenVPN-Servern herzustellen. In diesem Tutorial zeigen wir Ihnen, wie Sie sich mit openvpn mit dem Server verbinden Werkzeug.

Installieren Sie OpenVPN auf Ubuntu und Debian
```
sudo apt updatesudo apt install openvpn
```

Installieren Sie OpenVPN auf CentOS und Fedora

sudo yum install epel-releasesudo yum install openvpn

Sobald das Paket installiert ist, verwenden Sie openvpn, um sich mit dem VPN-Server zu verbinden Befehl und geben Sie die Client-Konfigurationsdatei an:

sudo openvpn --config client1.ovpn

macOS #

Tunnelblick ist eine kostenlose grafische Open-Source-Benutzeroberfläche für OpenVPN unter OS X und macOS.

Windows #

Laden Sie die neueste Version der OpenVPN-Anwendung herunter und installieren Sie sie von der Download-Seite von OpenVPN.

Kopieren Sie die .ovpn Datei in den OpenVPN-Konfigurationsordner (\Users\<Name>\OpenVPN\Config oder \Program Files\OpenVPN\config ).

Starten Sie die OpenVPN-Anwendung.

Klicken Sie mit der rechten Maustaste auf das OpenVPN-Taskleistensymbol und der Name der kopierten OpenVPN-Konfigurationsdatei wird im Menü aufgelistet. Klicken Sie auf Verbinden.

Android- und iOS-Nummer

Eine von OpenVPN entwickelte VPN-Anwendung ist sowohl für Android als auch für iOS verfügbar. Installieren Sie die Anwendung und importieren Sie den Client .ovp Datei.

Android OpenVPN Connect
iOS OpenVPN Connect

Widerrufen von Client-Zertifikaten #

Das Widerrufen eines Zertifikats bedeutet, ein signiertes Zertifikat ungültig zu machen, sodass es nicht mehr für den Zugriff auf den OpenVPN-Server verwendet werden kann.

Führen Sie die folgenden Schritte aus, um ein Client-Zertifikat zu widerrufen:

Melden Sie sich bei Ihrem CA-Rechner an und wechseln Sie in das EasyRSA-Verzeichnis:
```
cd EasyRSA-3.0.5
```

Führen Sie das easyrsa-Skript mit revoke aus Argument, gefolgt vom Kundennamen, den Sie widerrufen möchten:

./easyrsa revoke client1

Sie werden aufgefordert, zu bestätigen, dass Sie das Zertifikat widerrufen möchten. Geben Sie yes ein und drücken Sie enter bestätigen:

Please confirm you wish to revoke the certificate with the following subject:

subject=
    commonName                = client1

Type the word 'yes' to continue, or any other input to abort.
Continue with revocation: yes
...

Wenn Ihr CA-Schlüssel passwortgeschützt ist, werden Sie aufgefordert, das Passwort einzugeben. Once verified the script will revoke the certificate.

...
Revocation was successful. You must run gen-crl and upload a CRL to your
infrastructure in order to prevent the revoked cert from being accepted.

Use the gen-crl option to generate a certificate revocation list (CRL):

./easyrsa gen-crl

An updated CRL has been created.
CRL file: /home/causer/EasyRSA-3.0.5/pki/crl.pem

Upload the CRL file to the OpenVPN server:

scp ~/EasyRSA-3.0.5/pki/crl.pem serveruser@your_server_ip:/tmp

Login to your OpenVPN server server and move the file to the /etc/openvpn Verzeichnis:
```
sudo mv /tmp/crl.pem /etc/openvpn
```
Open the OpenVPN server configuration file:
```
sudo nano /etc/openvpn/server1.conf
```
Paste the following line at the end of the file
/etc/openvpn/server1.conf
```
crl-verify crl.pem
```
Speichern und schließen Sie die Datei.
Restart the OpenVPN service for the revocation directive to take effect:
```
sudo systemctl restart openvpn@server1
```
At this point, the client should no longer be able to access the OpenVPN server using the revoked certificate.

If you need revoke additional client certificates just repeat the same steps.

So richten Sie einen FTP-Server mit VSFTPD unter Ubuntu 18.04 ein

So installieren Sie VMware Workstation Player unter Ubuntu 18.04

Ubuntu

So richten Sie den CUPS-Druckserver unter Ubuntu 20.04 ein

So richten Sie OpenVPN auf Ubuntu Server ein

So richten Sie einen OpenVPN-Server unter Ubuntu 22.04 ein und konfigurieren ihn

So richten Sie den E-Mail-Server mit Plesk unter Ubuntu 20.04 ein

So richten Sie den Prosody XMPP-Server unter Ubuntu 20.04 ein

So installieren Sie OpenVPN-Server auf Ubuntu 20.04 LTS