OpenVPN-Konfiguration mit Easy-RSA#

Bemerkung

Diese Anleitung ist in Arbeit und wird entsprechend aktualisiert. Bitte berücksichtigen Sie diesen Status.

Diese Anleitung zeigt, wie man OpenVPN-Clients für die Anmeldung mit einem Nitrokey Pro 2 oder einem Nitrokey Storage 2 konfiguriert. Für die Software-Schlüsselverwaltung werden wir Easy-RSA verwenden, ein Dienstprogramm, das sich parallel zu OpenVPN entwickelt hat.

Zum Signieren der Zertifikate wird ein Nitrokey HSM 2 verwendet, der als Zertifizierungsstelle eingerichtet wird, Dieser Leitfaden behandelt jedoch nicht die Einrichtung der CA selbst (sie ist klar und gut dokumentiert hier).

Wir werden Easy-RSA verwenden, da es eine gewisse Flexibilität zu bieten scheint und die Schlüsselverwaltung über externe PKIs ermöglicht. Wir werden es auf dem Server verwenden, um die Signieranforderung zu erstellen, und den gleichen Prozess auf dem Client wiederholen. Die Certificate Signing Requests werden von der CA auf dem Nitorkey HSM signiert und an den Server und den Client zurückgesendet.

Voraussetzungen #

In der folgenden Dokumentation werden 3 verschiedene Maschinen wie folgt benötigt:

OpenVPN-Server (v. 2.5) auf Debian 10 (virtuelle EC2-Maschine - AWS)
OpenVPN-Client (v. 2.4.9) auf Fedora 30 (lokaler Rechner)
Die Zertifizierungsstelle wird von einem Einzelplatzrechner mit Fedora 30 zugänglich sein (lokaler Rechner)

Um mit den Geräten zu interagieren, benötigen wir OpenSC 0.20, das auf dem Client und dem CA-Rechner (den lokalen Rechnern) installiert ist. Sie können den Anweisungen zur Einrichtung in diesem Link (*Unix) folgen.

Um die Abhängigkeiten auf Fedora-Maschinen herunterzuladen, können wir diese Anleitung verwenden:

su -c 'dnf install readline-devel openssl-devel libxslt docbook-style-xsl pcsc-lite-devel automake autoconf libtool gcc zlib-devel'

Für Debian Linux sind aktuellere OpenSC-Pakete hier verfügbar.

Wir werden die folgenden Nitrokeys für die physische Schlüsselverwaltung verwenden:

Ein Authentifizierungsschlüssel unter Verwendung des Nitrokey Pro 2 (pdf)
Eine Zertifizierungsstelle (CA) unter Verwendung des Nitrokey HSM 2 (pdf)

Zur Erinnerung: Um eine Zertifizierungsstelle auf Nitrokey HSM 2 zu erstellen, können Sie die Anweisungen in der Dokumentation `befolgen.

Alternativ können Sie Ihre eigene CA auf einer auf einem separaten Rechner einrichten, oder das OpenVPN-Tutorial verwenden, das ebenfalls auf Easy-RSA setzt. Die letzten beiden Optionen verlassen sich auf Softwarelösungen für die Schlüsselverwaltung.

Server-Seite #

OpenVPN installieren #

Zuerst müssen wir die IP-Weiterleitung aktivieren, indem wir die Datei /etc/sysctl.conf bearbeiten
```
$ editor /etc/sysctl.conf
```
Dekommentieren Sie die folgende Zeile oder editieren Sie sie entsprechend
```
net.ipv4.ip_forward=1
```
Schließen Sie es nach dem Speichern, und geben Sie diesen Befehl ein
```
$ sysctl -p
```
Sobald die IP-Weiterleitung eingerichtet ist, müssen wir die neueste Version von OpenvPN für unseren Debian 10-Server herunterladen, wie in dieser Anleitung beschrieben:
Wechseln Sie zu root und laden Sie den GPG-Schlüssel herunter, der das Paket signiert hat
```
$ sudo -s
# wget -O - https://swupdate.openvpn.net/repos/repo-public.gpg|apt-key add -
```
Fügen Sie die URL der entsprechenden OpenVPN-Pakete in die Datei sources.list ein
```
# echo "deb http://build.openvpn.net/debian/openvpn/release/2.5 buster main" > /etc/apt/sources.list.d/openvpn-aptrepo.list
# exit
```
Wir haben OpenVPN 2.5 heruntergeladen, da „Passwortabfrage“ mindestens OpenVPN Version 2.4.8 zur Anmeldung benötigt.

Als nächstes laden wir OpenVPN herunter

$ sudo apt install openvpn

Wenn Sie die Version überprüfen wollen, ist es möglich, indem Sie --version aufrufen und das Folgende ausgeben:

$ sudo openvpn --version
OpenVPN 2.5_beta3 x86_64-pc-linux-gnu [SSL (OpenSSL)] [LZO] [LZ4] [EPOLL] [PKCS11] [MH/PKTINFO] [AEAD] built on Sep  1 2020
library versions: OpenSSL 1.1.1d 10 Sep 2019, LZO 2.10
Originally developed by James Yonan
Copyright (C) 2002-2018 OpenVPN Inc <sales@openvpn.net>
Compile time defines: enable_async_push=no enable_comp_stub=no enable_crypto_ofb_cfb=yes enable_debug=yes enable_def_auth=yes enable_dependency_tracking=no \ enable_dlopen=unknown enable_dlopen_self=unknown enable_dlopen_self_static=unknown enable_fast_install=needless enable_fragment=yes enable_iproute2=yes \ enable_libtool_lock=yes enable_lz4=yes enable_lzo=yes enable_maintainer_mode=no enable_management=yes enable_multihome=yes enable_pam_dlopen=no enable_pedantic=no \ enable_pf=yes enable_pkcs11=yes enable_plugin_auth_pam=yes enable_plugin_down_root=yes enable_plugins=yes enable_port_share=yes enable_selinux=no \ enable_shared=yes enable_shared_with_static_runtimes=no enable_silent_rules=no enable_small=no enable_static=yes enable_strict=no enable_strict_options=no \ enable_systemd=yes enable_werror=no enable_win32_dll=yes enable_x509_alt_username=yes with_aix_soname=aix with_crypto_library=openssl with_gnu_ld=yes \ with_mem_check=no with_sysroot=no

Easy-RSA installieren #

Um die PKI zu erstellen, laden wir die neueste Version von Easy-RSA auf den Server- und Client-Rechnern herunter. Um die neueste Version zu erhalten, gehen Sie auf die Seite Releases auf dem offiziellen EasyRSA GitHub Projekt, kopieren Sie den Download-Link für die Datei mit der Endung .tgz, und fügen Sie ihn in den folgenden Befehl ein:

Laden Sie die neueste Version herunter

$ cd ~
wget -P ~/ https://github.com/OpenVPN/easy-rsa/releases/download/v3.0.7/EasyRSA-3.0.7.tgz

Entpacken Sie den Tarball

$ cd ~
$ tar xvf EasyRSA-3.0.7.tgz
$ mv EasyRSA-3.0.7/ easyrsa/ # rename folder

Erstellen einer PKI für OpenVPN-Server #

Bevor Sie den privaten Schlüssel und das Zertifikat Ihres OpenVPN-Servers erstellen können, müssen Sie ein lokales Public Key Infrastructure-Verzeichnis auf Ihrem OpenVPN-Server anlegen. Sie werden dieses Verzeichnis verwenden, um die Zertifikatsanforderungen des Servers und der Clients zu verwalten, anstatt sie direkt auf Ihrem CA-Server zu stellen.

Um ein PKI-Verzeichnis auf Ihrem OpenVPN-Server zu erstellen, müssen Sie eine Datei namens vars mit einigen Standardwerten befüllen.

Erstellen Sie eine vars-Datei

$ touch ~/easyrsa/vars
$ cd easyrsa/
$ editor vars

Sobald die Datei geöffnet ist, fügen Sie die folgenden zwei Zeilen ein
```
set_var EASYRSA_ALGO "ec"
set_var EASYRSA_DIGEST "sha512"
```
Dies sind die einzigen beiden Zeilen, die Sie in dieser vars-Datei auf Ihrem OpenVPN-Server benötigen, da dieser nicht als Zertifizierungsstelle verwendet wird. Sie stellen sicher, dass Ihre privaten Schlüssel und Zertifikatsanforderungen so konfiguriert sind, dass sie Elliptic Curve Cryptography (ECC) verwenden, um Schlüssel und sichere Signaturen für Ihre Clients und den OpenVPN-Server zu erzeugen.

Was die Wahl der kryptographischen Algorithmen betrifft, so folge ich dem Modell in diesem Tutorial, und Sie können diese nach Ihren spezifischen Bedürfnissen anpassen.
Initialisieren der PKI

Sobald Sie die Datei vars ausgefüllt haben, können Sie mit der Erstellung des PKI-Verzeichnisses fortfahren. Führen Sie dazu das easyrsa-Skript mit der Option init-pki aus:
```
$ ./easyrsa init-pki
```

Nachdem Sie Ihre PKI auf dem OpenVPN-Server initialisiert haben, können Sie zum nächsten Schritt übergehen, nämlich der Erstellung einer OpenVPN-Server-Zertifikatsanforderung und eines privaten Schlüssels.

4. Erstellen Sie `server.req` und `server.key`#

Nachdem Ihr OpenVPN-Server nun alle Voraussetzungen installiert hat, besteht der nächste Schritt darin, auf Ihrem OpenVPN-Server ein Schlüsselpaar zu erzeugen, das aus einem privaten Schlüssel (den Sie geheim halten müssen) und einem Certificate Signing Request (.csr) besteht.

Im Allgemeinen werden auf Systemen, auf denen wir einen Schlüssel und eine Anfrage erzeugen, diese Dateien mit dem Argument nopass unverschlüsselt gelassen, da Server normalerweise ohne Passworteingabe starten müssen. Dadurch wird ein unverschlüsselter Schlüssel generiert, also achten Sie darauf, den Zugriff und die Dateiberechtigungen sorgfältig zu schützen.

Tipp

Konfigurationshinweise von OpenVPN:

Der Server und jeder Client müssen über eine eigene Cert- und Key-Datei verfügen. Der Server und alle Clients verwenden die gleiche CA-Datei.
Das Server-Zertifikat sollte folgende Eigenschaften haben:

keyUsage: digitalSignature, keyEncipherment
extendedKeyUsage: serverAuth

Erstellen Sie die Signieranforderung für den Server

Navigieren Sie als Nicht-Root-Benutzer in das Verzeichnis ~/easyrsa auf Ihrem OpenVPN-Server und geben Sie die folgenden Befehle ein:
```
$ cd easyrsa/
$ ./easyrsa gen-req server nopass
```
Dadurch wird ein privater Schlüssel für den Server und eine Zertifikatsanforderungsdatei namens server.req erzeugt.

Sobald Sie ein signiertes Zertifikat haben, übertragen Sie es zurück auf den OpenVPN-Server.
Kopieren Sie den Schlüssel in das Verzeichnis des OpenVPN-Servers
```
$ sudo cp /home/admin/EasyRSA/pki/private/server.key /etc/openvpn/server/
```
Nach Abschluss dieser Schritte haben Sie erfolgreich einen privaten Schlüssel für Ihren OpenVPN-Server erzeugt. Außerdem haben Sie einen Certificate Signing Request für den OpenVPN-Server erzeugt.

Tipp

Dateierweiterungen für Zertifikatsignierungsanforderungen

Die Dateierweiterung, die von der CA und dem HSM-Tutorial übernommen wird, deutet auf die Erstellung einer .csr-Datei hin, Easy-RSA erstellt jedoch Zertifikatsignierungsanfragen mit der Erweiterung .req.

Wir werden beide Erweiterungen austauschbar verwenden, wobei wir darauf achten, dass wir die richtigen Dateien an die Zertifizierungsstelle übertragen und ein endgültiges Zertifikat mit der Erweiterung .crt erzeugen.

Im nächsten Abschnitt dieser Anleitung werden wir eine .req-Datei mit unserer CA signieren, die auf dem HSM 2-Gerät eingesetzt wird. Zu diesem Zweck werde ich einen dedizierten Rechner verwenden, um die Anfragen zu signieren.

Unterschreiben und abrufen `server.crt`#

Die folgenden Anweisungen erfordern die Übertragung der Datei server.req (oder server.csr) auf das CA-System.

Die Übertragung selbst ist nicht sicherheitsrelevant, obwohl es ratsam ist, zu überprüfen, ob die empfangene Datei mit der Kopie des Absenders übereinstimmt, wenn der Transport nicht vertrauenswürdig ist.

Um diese Schritte durchzuführen, werde ich mich weitgehend auf diese Anweisungen stützen, um die Zertifikatsignierungsanforderungen zu signieren, nachdem wir sie mit Easy-RSA erzeugt haben.

Unterschreiben Sie die Datei `server.req`.#

Auf dem lokalen Rechner, der für den Zugriff auf das HSM vorgesehen ist, verwenden wir die von Opensc 0.20 bereitgestellten Tools, um die Datei .req zu signieren und sie an den OpenVPN-Server zurückzuschicken. Wir gehen davon aus, dass wir die Datei von der Server-Maschine auf die CA-Maschine übertragen haben.

Zuerst stecken wir den HSM Nitrokey ein und geben diese Anweisung zur Auflistung der verfügbaren Tasten ein.

Abfrage der Liste der verfügbaren Geräte
```
$ p11tool --list-all
```
(Erforderlicher Schritt) Wenn Sie zum ersten Mal ein Zertifikat mit der CA signieren, sollten Sie den URI des privaten Schlüssels der CA vom HSM abrufen und in die Konfigurationsdatei aufnehmen.
- Der URI des Schlüssels sollte in diesem Format vorliegen:
```
pkcs11:model=PKCS%2315%20emulated;manufacturer=www.CardContact.de;serial=DENK0104068;token=SmartCard-HSM%20%28UserPIN%29%00%00%00%00%00%00%00%00%00;id=%E0%16%1C%C8%B6%F5%D6%6A%C6%83%5E%CD%EC%B6%23%FC%05%06%A6%75;object=root;type=private
```

Erstellen Sie das Verzeichnis openvpn/ unter certificate-authority/

$ mkdir/opt/certificate-authority/
$ cd /opt/certificate-authority/

Signieren Sie die server.req

$ openssl ca -config sign_server_csrs.ini -engine pkcs11 -keyform engine -days 375 -notext -md sha512 -create_serial -in server.req -out /home/user/pki/issued/server.crt

Rufen Sie die Datei `server.crt` auf dem Serverrechner ab.#

Übertragen Sie die signierten Zertifikate auf den Server

Kopieren Sie von der CA-Maschine die Dateien server.crt und chain.crt auf den OpenVPN-Server. In diesem Beispiel werden wir den Befehl scp wie folgt verwenden:
```
$ scp openvpn/{server.crt,chain.crt} admin@your_openvpnserver_ip:/tmp
```
Legen Sie die Zertifikate in das Verzeichnis des Servers
```
$ mv /tmp/{server.crt,chain.crt} /etc/openvpn/server
```
Warnung

CA-Zertifikat und chain.crt

Im obigen Beispiel liefert die CA das signierte Server-Zertifikat zurück und fügt das CA-Zertifikat CA.crt bei, das die Datei chain.crt ist. Dies kann über einen unsicheren Kanal geschehen, obwohl der Client aufgefordert wird, zu bestätigen, ob die empfangene chain.crt gültig ist, wenn der Transport nicht vertrauenswürdig ist.

Es ist möglich, die Datei chain.crt auf dem Zielrechner in CA.crt umzubenennen, jedoch werden wir in den nächsten Anweisungen chain.crt verwenden.

Konfigurieren Sie den OpenVPN-Server #

Eine Verbindung, die TLS verwendet, erfordert mehrere Zertifikate und Schlüssel zur Authentifizierung. Nachdem wir diese nun ausgestellt und signiert haben, können wir sie in den richtigen Verzeichnissen ablegen. Die Aufschlüsselung der Zertifikate und Schlüssel, die sich im Stammverzeichnis befinden müssen, lautet wie folgt:

Die Stammzertifikatsdatei (CA.crt oder chain.crt in unserem Fall)
Server-Zertifikat
Server-Schlüssel
Diffie-Hellman-Parameter (optional)

Auf Ihrem OpenVPN-Server können Sie nun die Konfigurationsdatei server.conf mit Ihrem bevorzugten Texteditor erstellen. Die Datei kann nach Ihren Wünschen konfiguriert werden, wobei wir darauf achten, dass wir die Abschnitte für das Server-Zertifikat und den Schlüssel entsprechend den von Ihnen gewählten Namen für die von uns signierten Dateien ändern:

# OpenVPN Server Certificate - CA, server key and certificate
ca chain.crt
cert server.crt
key server.key

Hier ist die Konfigurationsdatei, die wir zum Testen dieser Anweisungen verwenden können:

port 1194
proto udp
dev tun
ca ca.crt
cert server.crt
key server.key  # This file should be kept secret
dh dh.pem
server 10.8.0.0 255.255.255.0
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
log         /var/log/openvpn/openvpn.log
log-append  /var/log/openvpn/openvpn.log
verb 3
explicit-exit-notify 1
tls-version-min 1.2 # Lower boundary for TLS version
tls-version-max 1.2 # Higher boundary for TLS version

Um zu testen, ob die Konfiguration richtig funktioniert, können wir diesen Befehl verwenden:

$ sudo openvpn --server --config server.conf

Starten Sie den OpenVPN-Dienst auf dem Server #

Aktivieren Sie den OpenVPN-Dienst, indem Sie ihn zu systemctl hinzufügen, und starten Sie ihn mit diesen Befehlen:

$ sudo systemctl -f enable openvpn@server
$ sudo systemctl start openvpn@server

Um doppelt zu prüfen, ob der OpenVPN-Dienst aktiv ist, verwenden Sie diesen Befehl:

$ sudo systemctl status openvpn@server

Das OpenVPN sollte an dieser Stelle laufen.

Client-seitige Konfiguration #

OpenVPN und Easy-RSA installieren #

Installieren Sie die Software

Wir können direkt dnf install benutzen, um OpenVPN 2.4.9 und Easy-RSA 3.0.7 zu installieren
$ sudo dnf install openvpn easy-rsa
Then we create as non-root a directory for Easy RSA called Easy-RSA
```
$ mkdir ~/easyrsa
```
Und verknüpfen Sie es mit dem Easy RSA-Paket, das wir gerade installiert haben
```
$ ln -s /usr/share/easy-rsa/3/* ~/easyrsa/
```

Erstellen Sie eine PKI für den OpenVPN-Client #

Auf die gleiche Weise, wie wir eine PKI auf dem OpenVPN-Server erstellt haben, werden wir eine PKI mit Easy-RSA auf der Client-Seite erstellen.

3. Erstellen Sie eine `client.req` und `client.key`#

Auf die gleiche Weise, wie wir das Schlüsselpaar auf dem Server erstellt haben, erzeugen wir ein Schlüsselpaar für den Client, das sich aus der Datei client.req und der Datei client.key zusammensetzt. Letztere muss auf dem Client-Rechner geheim gehalten werden.

Unterschreiben Sie `client.req` und erstellen Sie die Datei `client.crt`.#

Um die Datei client.req auf den CA-Rechner zu übertragen, verwenden wir die gleiche Methode wie bei der Datei server.req.

Nach der Übertragung signieren wir auf dem CA-Rechner die Zertifikatssignierungsanforderungsdatei mit diesem Befehl

$ openssl ca -config sign_server_csrs.ini -engine pkcs11 -keyform engine -days 375 -notext -md sha512 -create_serial -in client.req -out /home/user/pki/issued/client.crt

Importieren Sie `client.crt` auf den Nitrokey vom CA-Rechner #

Nachdem wir die Datei client.crt erstellt haben, schließen wir das Nitrokey Pro 2 Gerät an den CA-Rechner an und importieren die .crt mit diesem Befehl in das Pro 2 Gerät:

$ pkcs15-init --store-certificate client.crt --id 3

Mit diesem Befehl können Sie sehen, ob der Schlüssel tatsächlich auf dem Nitrokey gespeichert ist:

$ pkcs15-tool -c

Oder alternativ

$ pkcs11-tool --list-objects

Für weitere Befehle können Sie das OpenSC-Wiki konsultieren.

Rufen Sie die Datei `chain.crt` vom CA-Rechner ab.#

Während wir die Datei client.crt auf dem Nitrokey Pro 2-Gerät gespeichert haben, müssen wir die Datei chain.crt auf dem Client-Rechner abrufen und im entsprechenden Verzeichnis speichern. Wir können scp verwenden, wie in der Methode, die im Server-Abschnitt dieses Handbuchs erklärt wird.

Konfigurieren Sie den Client für die Interaktion mit dem Nitrokey #

Zurück auf dem Client-Rechner stecken wir nun den Nitrokey Pro ein und bauen damit die VPN-Verbindung mit dem Server auf. Generell gilt, dass eine Verbindung, die TLS verwendet, mehrere Zertifikate und Schlüssel zur Authentifizierung benötigt:

Die Stammzertifikatsdatei (chain.crt)
Kundenzertifikat
Kundenschlüssel

Für diese Anleitung können wir die folgende Datei client.conf verwenden und sie entsprechend mit den erforderlichen Optionen versehen:

client
dev tun
proto udp
remote <server> 1194
resolv-retry infinite
nobind
user nobody
group nobody
persist-key
persist-tun
ca ca.crt
remote-cert-tls server
cipher AES-256-CBC
verb 3
redirect-gateway def1
tls-version-min 1.2 # Lower boundary for TLS version
tls-version-max 1.2 # Higher boundary for TLS version

Bestimmen Sie das richtige Objekt

Jeder PKCS#11-Anbieter kann mehrere Geräte unterstützen. Um die Liste der verfügbaren Objekte anzuzeigen, können Sie den folgenden Befehl verwenden:

$ openvpn --show-pkcs11-ids /usr/lib64/pkcs11/opensc-pkcs11.so

The following objects are available for use.
Each object shown below may be used as parameter to

--pkcs11-id option please remember to use single quote mark.

Certificate
      DN:             CN=client
      Serial:         E53DA75C5B8F1518F520BCEF0128C09F
      Serialized id:  pkcs11:model=pkcs11:model=PKCS%NNNN%20emulated;token=User%20PIN%20%28OpenPGP%20card%29;manufacturer=ZeitControl;serial=000NNNNNN;id=%03

Jedes Zertifikat/Privatschlüsselpaar hat eine eindeutige Serialized id-Zeichenkette. Die serialisierte ID-Zeichenkette des angeforderten Zertifikats sollte in der Konfigurationsdatei angegeben werden. Wir können dies tun, indem wir die Option pkcs11-id mit einfachen Anführungszeichen hinzufügen.

pkcs11-id 'pkcs11:model=pkcs11:model=PKCS%NNNN%20emulated;token=User%20PIN%20%28OpenPGP%20card%29;manufacturer=ZeitControl;serial=000NNNNNN;id=%03'

Abgerufene serialisierte ID zur Konfigurationsdatei hinzufügen

Öffnen Sie mit Ihrem bevorzugten Texteditor die Datei server.conf und fügen Sie die folgenden Zeilen ein, wobei Sie darauf achten müssen, Ihre eigene Serialized id einzufügen:
```
pkcs11-providers /usr/lib64/pkcs11/opensc-pkcs11.so
pkcs11-id 'pkcs11:model=pkcs11:model=PKCS%NNNN%20emulated;token=User%20PIN%20%28OpenPGP%20card%29;manufacturer=ZeitControl;serial=000NNNNNN;id=%03'
```
Für zusätzliche Einstellungen, die sich auf die OpenVPN-Authentifizierung beziehen, können Sie auch einige Zeilen hinzufügen, um die Schlüsselverwaltung zu handhaben, obwohl dies optional ist.
Bemerkung

Klicken Sie, um den Code anzuzeigen
```
# nitrokey config

pkcs11-providers /usr/lib64/pkcs11/opensc-pkcs11.so
pkcs11-id 'pkcs11:model=pkcs11:model=PKCS%NNNN%20emulated;token=User%20PIN%20%28OpenPGP%20card%29;manufacturer=ZeitControl;serial=000NNNNNN;id=%03'
# pkcs11-pin-cache 300
# daemon
# auth-retry nointeract
# management-hold
# management-signal
# management 127.0.0.1 8888
# management-query-passwords
pkcs11-cert-private 1 # Prompt for PIN
```
Optionaler Schritt

Wenn Sie die Konfiguration mit und ohne Token auf dem Nitrokey testen wollen, können Sie Zeilen in dieselbe client.conf einfügen und die entsprechenden Zeilen je nach Bedarf kommentieren/dekommentieren:
Bemerkung

Klicken Sie, um den Code anzuzeigen
```
# non_nitrokey login

# cert client.crt
# key client.key
# tls-auth ta.key 1
```

Konfigurieren Sie den OpenVPN-Client

Die endgültige Konfigurationsdatei client.conf sollte wie diese aussehen:

client
dev tun
proto udp
remote <server> 1194
resolv-retry infinite
nobind
user nobody
group nobody
persist-key
persist-tun
ca ca.crt
remote-cert-tls server
cipher AES-256-CBC
verb 3
redirect-gateway def1
tls-version-min 1.2 # Lower boundary for TLS version
tls-version-max 1.2 # Higher boundary for TLS version

# nitrokey login

pkcs11-providers /usr/lib64/pkcs11/opensc-pkcs11.so
pkcs11-id 'pkcs11:model=pkcs11:model=PKCS%NNNN%20emulated;token=User%20PIN%20%28OpenPGP%20card%29;manufacturer=ZeitControl;serial=000NNNNNN;id=%03'
# pkcs11-pin-cache 300
# daemon
# auth-retry nointeract
# management-hold
# management-signal
# management 127.0.0.1 8888
# management-query-passwords
pkcs11-cert-private 1 # Prompt for PIN

# OR

# non_nitrokey login

# cert client.crt
# key client.key
# tls-auth ta.key 1

Bekannte Probleme

Es gibt einige bekannte Probleme im Zusammenhang mit dem OpenVPN-Login mit OpenSC. Bitte lesen Sie diese Probleme hier.

Starten Sie den OpenVPN-Client #

Starten Sie den OpenVPN-Dienst auf dem Client

Aktivieren Sie den OpenVPN-Dienst, und starten Sie ihn mit diesen Befehlen:
```
$ sudo systemctl -f enable openvpn-server@server.service
$ sudo systemctl start openvpn-server@server.service
```
Um zu überprüfen, ob der OpenVPN-Dienst aktiv ist, verwenden Sie diesen Befehl:
```
$ sudo systemctl status openvpn-server@server.service
```

Geben Sie Ihre Benutzer-PIN ein

Beim Ausführen des OpenVPN-Clients muss die PIN von Nitrokey eingegeben werden:

$ sudo openvpn --client --config client.conf
Fri Sep 11 17:42:01 2020 OpenVPN 2.4.9 x86_64-redhat-linux-gnu [SSL (OpenSSL)] [LZO] [LZ4] [EPOLL] [PKCS11] [MH/PKTINFO] [AEAD] built on Apr 24 2020
Fri Sep 11 17:42:01 2020 library versions: OpenSSL 1.1.1g FIPS  21 Apr 2020, LZO 2.08
Fri Sep 11 17:42:01 2020 PKCS#11: Adding PKCS#11 provider '/usr/lib64/pkcs11/opensc-pkcs11.so'
Enter User PIN (OpenPGP card) token Password: ******

Warnung

Leider scheint OpenVPN nicht in der Lage zu sein, einen Handshake aufzubauen und bricht mit einem Fehler ab, wie hier berichtet, hier und hier

This is what the error output looks like:

$ sudo openvpn --client --config client.conf
Fri Sep 11 17:42:01 2020 OpenVPN 2.4.9 x86_64-redhat-linux-gnu [SSL (OpenSSL)] [LZO] [LZ4] [EPOLL] [PKCS11] [MH/PKTINFO] [AEAD] built on Apr 24 2020
Fri Sep 11 17:42:01 2020 library versions: OpenSSL 1.1.1g FIPS  21 Apr 2020, LZO 2.08
Fri Sep 11 17:42:01 2020 PKCS#11: Adding PKCS#11 provider '/usr/lib64/pkcs11/opensc-pkcs11.so'
Enter User PIN (OpenPGP card) token Password: ******``
Fri Sep 11 17:42:12 2020 TCP/UDP: Preserving recently used remote address: [AF_INET]18.157.180.240:1194``
Fri Sep 11 17:42:12 2020 Socket Buffers: R=[212992->212992] S=[212992->212992]``
Fri Sep 11 17:42:12 2020 UDP link local: (not bound)
Fri Sep 11 17:42:12 2020 UDP link remote: [AF_INET]18.157.180.240:1194
Fri Sep 11 17:42:12 2020 NOTE: UID/GID downgrade will be delayed because of --client, --pull, or --up-delay
Fri Sep 11 17:42:12 2020 TLS: Initial packet from [AF_INET]18.157.180.240:1194, sid=d79690cf 9e38ce89
Fri Sep 11 17:42:12 2020 VERIFY OK: depth=1, CN=server_CA
Fri Sep 11 17:42:12 2020 VERIFY KU OK
Fri Sep 11 17:42:12 2020 Validating certificate extended key usage
Fri Sep 11 17:42:12 2020 ++ Certificate has EKU (str) TLS Web Server Authentication, expects TLS Web Server Authentication
Fri Sep 11 17:42:12 2020 VERIFY EKU OK
Fri Sep 11 17:42:12 2020 VERIFY OK: depth=0, CN=server
Fri Sep 11 17:42:12 2020 OpenSSL: error:141F0006:SSL routines:tls_construct_cert_verify:EVP lib
Fri Sep 11 17:42:12 2020 TLS_ERROR: BIO read tls_read_plaintext error
Fri Sep 11 17:42:12 2020 TLS Error: TLS object -> incoming plaintext read error
Fri Sep 11 17:42:12 2020 TLS Error: TLS handshake failed
Fri Sep 11 17:42:12 2020 SIGUSR1[soft,tls-error] received, process restarting
Fri Sep 11 17:42:12 2020 Restart pause, 5 second(s)

In einigen gemeldeten Fällen wird nicht nach einer PIN auf dem Terminal gefragt. Eine Abhilfe wäre, diesen Befehl zu verwenden, um sich mit der PIN anzumelden:

$ telnet 8888 password 'User PIN (OpenPGP card) token' <PIN>

Alternativ können Sie den OpenVPN -Client mit deaktivierter systemd-Unterstützung neu kompilieren, und er wird Sie wie erwartet zur Eingabe der PIN auffordern.

Eine andere Möglichkeit wäre, sich mit dem Viscosity-Client an Ihrer OpenVPN-Instanz anzumelden, was insbesondere bei der PIN-Eingabe eine bessere Benutzerfreundlichkeit bietet.

OpenVPN-Konfiguration mit Easy-RSA#

Unterschreiben Sie die Datei server.req.#

Rufen Sie die Datei server.crt auf dem Serverrechner ab.#

Unterschreiben Sie die Datei `server.req`.#

Rufen Sie die Datei `server.crt` auf dem Serverrechner ab.#