GNU/Linux >> LINUX-Kenntnisse > >> Cent OS

So richten Sie einen OpenVPN-Server unter CentOS 7 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 behandelt den Prozess der Einrichtung Ihres eigenen VPN-Servers durch Installation und Konfiguration von OpenVPN. 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 CentOS 7-Server zum Hosten Ihrer OpenVPN-Instanz.
Auf dem Server sollte eine 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 Linux-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, indem Sie Folgendes eingeben:
```
tar xzf EasyRSA-nix-3.0.5.tgz
```
Navigieren Sie zum 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"

Speichern und schließen Sie die Datei.

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 EPEL-Repositories verfügbar ist, und die neueste Version von EasyRSA herunterzuladen.

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

Aktivieren Sie das EPEL-Repository, indem Sie Folgendes eingeben:
```
sudo yum install epel-release
```
Sobald das Repository aktiviert ist, installieren Sie OpenVPN mit dem folgenden Befehl:
```
sudo yum 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 zum EasyRSA-Verzeichnis auf Ihrem OpenVPN-Server anf einen Diffie-Hellman-Schlüssel generieren:.
```
cd ~/EasyRSA-3.0.5/./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 dh.pem Datei in /etc/openvpn Verzeichnis:
```
sudo cp ~/EasyRSA-3.0.5/pki/dh.pem /etc/openvpn/
```
Generieren Sie als Nächstes eine HMAC-Signatur mit openvpn binär:
```
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 cp /usr/share/doc/openvpn-*/sample/sample-config-files/server.conf /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 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 nobody
persist-key
persist-tun
status 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 Robust And Highly Flexible Tunneling Application On server1
   Loaded: loaded (/usr/lib/systemd/system/[email protected]; disabled; vendor preset: disabled)
   Active: active (running) since Tue 2018-11-06 10:07:35 UTC; 7s ago
 Main PID: 19912 (openvpn)
   Status: "Initialization Sequence Completed"
   CGroup: /system.slice/system-openvpn.slice/[email protected]
           └─19912 /usr/sbin/openvpn --cd /etc/openvpn/ --config server1.conf

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

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

ip a show tun0

Die Ausgabe sollte in etwa so aussehen:

4: tun0: <POINTOPOINT,MULTICAST,NOARP,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast 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::f421:f382:3158:138f/64 scope link flags 800 
       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 ausgeführt .

Öffnen Sie die /etc/sysctl.conf Datei und fügen Sie die folgende Zeile hinzu:

sudo nano /etc/sysctl.conf

/etc/sysctl.conf

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 sysctl ausführen Befehl:

sudo sysctl -p

net.ipv4.ip_forward = 1

Wenn Sie die Voraussetzungen befolgt haben, sollte Firewalldrunning bereits auf Ihrem Server vorhanden sein.

Jetzt müssen wir Firewall-Regeln hinzufügen, den OpenVPN-Port öffnen und Masquerading aktivieren.

Beginnen Sie mit dem Hinzufügen von tun0 Schnittstelle zum trusted Bereich:

sudo firewall-cmd --permanent --zone=trusted --add-interface=tun0

Öffnen Sie den Standard-OpenVPN-Port 1194 indem Sie den openvpn-Dienst zur Liste der von firewalld zugelassenen Dienste hinzufügen:

sudo firewall-cmd --permanent --add-service openvpn

Setzen Sie IP-Masquerading auf trusted Bereich:

sudo firewall-cmd --permanent --zone=trusted --add-masquerade

Bevor Sie die nat-Regel hinzufügen, müssen Sie die öffentliche Netzwerkschnittstelle Ihres CentOS 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 eth0 wie in der Ausgabe unten gezeigt. Ihre Schnittstelle hat möglicherweise einen anderen Namen.

eth0

Der folgende Befehl erlaubt dem Datenverkehr, das VPN zu verlassen, wodurch Ihre VPN-Clients Zugriff auf das Internet erhalten. Vergessen Sie nicht, eth0 zu ersetzen um mit dem Namen der öffentlichen Netzwerkschnittstelle übereinzustimmen, die Sie im vorherigen Befehl gefunden haben.

sudo firewall-cmd --permanent --direct --passthrough ipv4 -t nat -A POSTROUTING -s  10.8.0.0/24 -o eth0 -j MASQUERADE

Laden Sie abschließend die Firewall-Regeln neu, damit die Änderungen wirksam werden:

sudo firewall-cmd --reload

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:

sudo cp /usr/share/doc/openvpn-*/sample/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

Hängen Sie die folgenden Zeilen am Ende der Datei an, um sie an die Servereinstellungen anzupassen:
~/openvpn-clients/base/client.conf
```
auth SHA256
key-direction 1
```

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 mit chmod ausführbar :

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. Nach der Überprüfung wird das Skript das Zertifikat widerrufen.
```
...
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.
```

Verwenden Sie gen-crl Option zum Generieren einer Zertifikatssperrliste (CRL):

./easyrsa gen-crl

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

Laden Sie die CRL-Datei auf den OpenVPN-Server hoch:

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

Melden Sie sich bei Ihrem OpenVPN-Server an Server und verschieben Sie die Datei nach /etc/openvpn Verzeichnis:
```
sudo mv /tmp/crl.pem /etc/openvpn
```
Öffnen Sie die Konfigurationsdatei des OpenVPN-Servers:
```
sudo nano /etc/openvpn/server1.conf
```
Fügen Sie die folgende Zeile am Ende der Datei ein
/etc/openvpn/server1.conf
```
crl-verify crl.pem
```
Speichern und schließen Sie die Datei.
Starten Sie den OpenVPN-Dienst neu, damit die Widerrufsanweisung wirksam wird:
```
sudo systemctl restart openvpn@server1
```
Zu diesem Zeitpunkt sollte der Client nicht mehr mit dem widerrufenen Zertifikat auf den OpenVPN-Server zugreifen können.

Wenn Sie zusätzliche Client-Zertifikate widerrufen müssen, wiederholen Sie einfach die gleichen Schritte.

So installieren und konfigurieren Sie Nextcloud mit Apache unter CentOS 7

So installieren Sie phpMyAdmin mit Nginx unter CentOS 7

Cent OS

So richten Sie einen DHCP-Server unter CentOS 8 ein

So installieren Sie OpenVPN auf CentOS 8

So richten Sie NFS-Server und -Client unter CentOS 8 ein

So richten Sie SSH unter CentOS und RHEL ein

So richten Sie einen TeamSpeak-Server unter CentOS 7 ein

So richten Sie einen Minecraft-Server unter CentOS 7 ein