Konfiguracja OpenVPN z Easy-RSA#

Nitrokey 3

Nitrokey Passkey

Nitrokey FIDO2

Nitrokey U2F

Nitrokey HSM 2

Nitrokey Pro 2

Nitrokey Start

Nitrokey Storage 2

✓

⨯

⨯

⨯

⨯

✓

✓

✓

Informacja

Ten przewodnik jest w trakcie tworzenia i będzie aktualizowany na bieżąco. Proszę wziąć ten status pod uwagę.

Ten przewodnik pokazuje jak skonfigurować klientów OpenVPN do logowania przy użyciu Nitrokey Pro 2 lub Nitrokey Storage 2. Do programowego zarządzania kluczami będziemy używać Easy-RSA, narzędzia, które rozwijało się wraz z OpenVPN.

To sign the certificates, we will use a Nitrokey HSM 2 set up as Certificate Authority, however this guide does not cover the set up of the CA itself (it is clear and well documented here).

Użyjemy Easy-RSA, ponieważ wydaje się zapewniać pewną elastyczność i pozwala na zarządzanie kluczami przez zewnętrzne PKI. Użyjemy go na serwerze, aby wystawić żądanie podpisania certyfikatu i powtórzymy ten sam proces na kliencie. Żądania podpisania certyfikatu zostaną podpisane przez CA na HSM Nitorkey, i ponownie przesłane do serwera i klienta.

Wymagania wstępne#

W poniższej dokumentacji będziemy potrzebować 3 różnych maszyn, jak poniżej:

  • Serwer OpenVPN (v. 2.5) na Debianie 10 (maszyna wirtualna EC2 - AWS)

  • Klient OpenVPN (v. 2.4.9) na Fedorze 30 (maszyna lokalna)

  • Urząd certyfikacji będzie dostępny z wolnostojącej maszyny z Fedorą 30 (maszyna lokalna).

Do interakcji z urządzeniami będziemy potrzebowali OpenSC 0.20 zainstalowanego na maszynie klienckiej i CA (maszyny lokalne). Możesz postępować zgodnie z instrukcjami, aby skonfigurować go w ` tym linku (*Unix) <https://github.com/OpenSC/OpenSC/wiki/Compiling-and-Installing-on-Unix-flavors>`__.

Aby pobrać zależności na maszyny Fedora możemy skorzystać z tej instrukcji:

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

Dla Debiana Linuxa, nowsze pakiety OpenSC są dostępne tutaj.

Do fizycznego zarządzania kluczami będziemy używać następujących Nitrokeys:

Dla przypomnienia, aby zbudować Urząd Certyfikacji na Nitrokey HSM 2, możesz postępować zgodnie z instrukcjami dostępnymi ` w dokumentacji <certificate-authority.html#sign-a-server-certificate>`_.

Alternatywnie możesz skonfigurować własny CA na na oddzielnej maszynie, lub użyć samouczka OpenVPN, który również opiera się na Easy-RSA. Ostatnie 2 opcje polegają na rozwiązaniach programowych do zarządzania kluczami.

Po stronie serwera#

1. Zainstaluj OpenVPN#

  1. Najpierw musimy włączyć funkcję IP Forwarding poprzez edycję pliku /etc/sysctl.conf.

    $ editor /etc/sysctl.conf

  2. Usunąć lub odpowiednio edytować następującą linię

    net.ipv4.ip_forward=1

  3. Zamknij po zapisaniu i wprowadź następujące polecenie

    $ sysctl -p

    Po wykonaniu przekierowania IP, będziemy musieli pobrać najnowsze wydanie OpenvPN dla naszego serwera Debian 10, zgodnie z ` tymi instrukcjami <https://community.openvpn.net/openvpn/wiki/OpenvpnSoftwareRepos>`__:

  4. Zmień nazwę na root i pobierz klucz GPG, który podpisał pakiet

    $ sudo -s
# wget -O - https://swupdate.openvpn.net/repos/repo-public.gpg|apt-key add -

  5. Dodaj adresy URL odpowiednich pakietów OpenVPN do pliku sources.list.

    # echo "deb http://build.openvpn.net/debian/openvpn/release/2.5 buster main" > /etc/apt/sources.list.d/openvpn-aptrepo.list
# exit

    Ściągnęliśmy OpenVPN 2.5, ponieważ „password prompt” wymaga przynajmniej OpenVPN version 2.4.8 do logowania.

  6. Następnie pobieramy OpenVPN

    $ sudo apt install openvpn

    Jeśli chcesz sprawdzić wersję, jest to możliwe poprzez wywołanie --version i wypisanie następującego wyniku:

    $ 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

2. Zainstaluj Easy-RSA#

Aby zbudować PKI, pobierzemy najnowszą wersję Easy-RSA na maszyny serwerowe i klienckie. Aby uzyskać najnowsze wydanie, przejdź na stronę Releases na oficjalnym projekcie EasyRSA GitHub, skopiuj link do pobrania pliku kończącego się na .tgz, a następnie wklej go do poniższego polecenia:

  1. Pobierz najnowszą wersję

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

  2. Wypakuj plik tarball

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

3. Utwórz PKI dla serwera OpenVPN#

Przed utworzeniem klucza prywatnego i certyfikatu dla serwera OpenVPN należy utworzyć lokalny katalog Public Key Infrastructure na serwerze OpenVPN. Katalog ten będzie wykorzystywany do zarządzania żądaniami certyfikatów dla serwera i klientów, zamiast zgłaszania ich bezpośrednio na serwerze CA.

Aby zbudować katalog PKI na serwerze OpenVPN, będziesz musiał wypełnić plik o nazwie vars pewnymi domyślnymi wartościami.

  1. Utwórz plik vars.

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

  2. Po otwarciu pliku, wklej następujące dwie linie

    set_var EASYRSA_ALGO "ec"
set_var EASYRSA_DIGEST "sha512"

    Są to jedyne dwie linie, których potrzebujesz w tym pliku vars na swoim serwerze OpenVPN, ponieważ nie będzie on używany jako Urząd Certyfikacji. Zapewnią one, że Twoje klucze prywatne i żądania certyfikatów są skonfigurowane tak, aby używać Elliptic Curve Cryptography (ECC) do generowania kluczy i bezpiecznych podpisów dla Twoich klientów i serwera OpenVPN.

    Jeśli chodzi o wybór algorytmów kryptograficznych, kieruję się wzorem z tego tutoriala, a Ty możesz je dostosować do swoich konkretnych potrzeb.

  3. Inicjalizacja PKI

    Po wypełnieniu pliku vars można przystąpić do tworzenia katalogu PKI. Aby to zrobić, należy uruchomić skrypt easyrsa z opcją init-pki:

    $ ./easyrsa init-pki

    Po zainicjalizowaniu PKI na serwerze OpenVPN, możesz przejść do kolejnego kroku, którym jest utworzenie żądania certyfikatu serwera OpenVPN oraz klucza prywatnego.

4. Utwórz server.req i server.key.#

Teraz, gdy Twój serwer OpenVPN ma już zainstalowane wszystkie wymagania wstępne, następnym krokiem jest wygenerowanie pary kluczy składającej się z klucza prywatnego (do utrzymania w tajemnicy), oraz Certificate Signing Request (.csr) na Twoim serwerze OpenVPN.

Ogólnie rzecz biorąc, w systemach, w których generujemy klucz i żądanie, pliki te pozostawiamy niezaszyfrowane, używając argumentu nopass, ponieważ serwery zazwyczaj muszą się uruchamiać bez podawania hasła. Generuje to niezaszyfrowany klucz, więc należy pamiętać o ochronie dostępu do niego i uprawnień do plików.

Wskazówka

Notatki konfiguracyjne z OpenVPN:

  1. The server, and each client, must have their own cert and key

    file. The server and all clients will use the same CA file.

  2. Certyfikat serwera powinien posiadać następujące cechy:

  • keyUsage:  digitalSignature, keyEncipherment

  • extendedKeyUsage: serverAuth

  1. Tworzenie żądania podpisania dla serwera

    Przejdź do katalogu ~/easyrsa na serwerze OpenVPN jako użytkownik nieroot, i wprowadź następujące polecenia:

    $ cd easyrsa/
$ ./easyrsa gen-req server nopass

    Spowoduje to utworzenie klucza prywatnego dla serwera i pliku żądania certyfikatu o nazwie server.req.

    Po uzyskaniu podpisanego certyfikatu, należy go przesłać z powrotem na serwer OpenVPN.

  2. Skopiuj klucz do katalogu serwera OpenVPN

    $ sudo cp /home/admin/EasyRSA/pki/private/server.key /etc/openvpn/server/

Po wykonaniu tych kroków, udało Ci się utworzyć klucz prywatny dla Twojego serwera OpenVPN. Wygenerowany został również certyfikat Certificate Signing Request dla serwera OpenVPN.

Wskazówka

Rozszerzenia plików dla wniosków o podpisanie certyfikatu

Rozszerzenie pliku przyjęte przez samouczek CA i HSM wskazuje na tworzenie pliku .csr, jednak Easy-RSA tworzy żądania podpisania certyfikatu z rozszerzeniem .req.

Będziemy używać zamiennie obu rozszerzeń, jednocześnie upewniając się, że przekazujemy odpowiednie pliki do Urzędu Certyfikacji i generujemy końcowy certyfikat z rozszerzeniem .crt.

W następnej części poradnika podpiszemy plik .req z naszym CA wdrożonym na urządzeniu HSM 2. W tym celu, użyję dedykowanej maszyny do podpisywania żądań.

5. Podpisz i odbierz server.crt.#

Poniższe instrukcje wymagają przeniesienia pliku server.req (lub server.csr) do systemu CA.

Sam transfer nie jest wrażliwy na bezpieczeństwo, choć dobrze jest sprawdzić, czy otrzymany plik odpowiada kopii nadawcy, jeśli transport jest niezaufany.

Aby przejść przez te kroki, będę w dużej mierze opierał się na tych instrukcjach, aby podpisać żądania podpisania certyfikatu, gdy już wygenerujemy je za pomocą Easy-RSA.

  1. Podpisz plik server.req

    Na maszynie lokalnej przeznaczonej do dostępu do HSM, wykorzystamy narzędzia dostarczone przez Opensc 0.20 w celu podpisania pliku .req i odesłania go do serwera OpenVPN. Zakładamy, że plik został przesłany z serwera na maszynę CA.

    Najpierw zaczynamy od podłączenia HSM Nitrokey, i wpisania tej instrukcji do listy dostępnych klawiszy.

    1. Zapytanie o listę dostępnych urządzeń

      $ p11tool --list-all

      (Wymagany krok) Jeśli po raz pierwszy podpisujesz certyfikat z urzędem certyfikacji, możesz pobrać URI klucza prywatnego urzędu certyfikacji z HSM i dołączyć go do pliku konfiguracyjnego.

      Informacja

      URI klucza powinien być w tym formacie:

      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

    2. Utwórz katalog openvpn/ pod certificate-authority/.

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

    3. Podpisać 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

  2. Pobranie pliku server.crt na maszynę serwera

    1. Prześlij podpisane certyfikaty na serwer

      Z maszyny CA skopiuj pliki server.crt i chain.crt na serwer OpenVPN. W tym przykładzie użyjemy polecenia scp jak poniżej:

      $ scp openvpn/{server.crt,chain.crt} admin@your_openvpnserver_ip:/tmp

    2. Umieść certyfikaty w katalogu serwera

      $ mv /tmp/{server.crt,chain.crt} /etc/openvpn/server

      Ostrzeżenie

      Certyfikat CA i chain.crt

      W powyższym przypadku CA zwraca podpisany certyfikat sever i dołącza certyfikat CA CA.crt, który jest plikiem chain.crt. Może to być zrobione przez niezabezpieczony kanał, ale klient jest zachęcany do potwierdzenia czy otrzymany chain.crt jest ważny, jeśli transport jest niezabezpieczony.

      Możliwa jest zmiana nazwy pliku chain.crt na CA.crt na maszynie docelowej, jednak w kolejnych instrukcjach będziemy używać chain.crt.

6. Skonfiguruj serwer OpenVPN#

Połączenie używające TLS wymaga wielu ` certyfikatów i kluczy do uwierzytelniania <https://wiki.teltonika-networks.com/view/OpenVPN_configuration_examples>`__. Teraz, gdy już je wystawiliśmy i podpisaliśmy, możemy umieścić je w odpowiednich katalogach. Podział certyfikatów i kluczy, które muszą znaleźć się w katalogu głównym jest następujący:

OpenVPN server

    - The root certificate file (CA.crt or chain.crt in our setup)
    - Server certificate
    - Server key
    - Diffie Hellman Parameters (optional)

Na swoim serwerze OpenVPN możesz teraz utworzyć plik konfiguracyjny server.conf za pomocą swojego ulubionego edytora tekstu. Plik może być skonfigurowany zgodnie z Twoimi potrzebami, a my zadbamy o to, aby zmienić sekcje certyfikatu i klucza serwera zgodnie z nazwami wybranymi przez Ciebie dla podpisanych przez nas plików:

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

Oto plik konfiguracyjny, którego możemy użyć do przetestowania tych instrukcji:

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

Aby sprawdzić, czy konfiguracja działa poprawnie, możemy użyć tej komendy:

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

7. Uruchomić usługę OpenVPN na serwerze#

Włącz usługę OpenVPN poprzez dodanie jej do systemctl, a następnie uruchom ją za pomocą tych poleceń:

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

Aby dwukrotnie sprawdzić, czy usługa OpenVPN jest aktywna, użyj tej komendy:

$ sudo systemctl status openvpn@server

W tym momencie OpenVPN powinien być uruchomiony.

Konfiguracja po stronie klienta#

1. Zainstaluj OpenVPN i Easy-RSA#

  1. Zainstaluj oprogramowanie

    Możemy użyć bezpośrednio dnf install, aby zainstalować OpenVPN 2.4.9 i Easy-RSA 3.0.7.

    $ sudo dnf install openvpn easy-rsa

  2. Następnie tworzymy jako non-root katalog dla Easy RSA o nazwie Easy-RSA.

    $ mkdir ~/easyrsa

  3. I połącz go z pakietem Easy RSA, który właśnie zainstalowaliśmy

    $ ln -s /usr/share/easy-rsa/3/* ~/easyrsa/

2. Utwórz PKI dla klienta OpenVPN#

W ten sam sposób, w jaki stworzyliśmy PKI na serwerze OpenVPN, stworzymy PKI używając Easy-RSA po stronie klienta.

3. Utwórz client.req i client.key.#

W ten sam sposób, w jaki wydaliśmy parę kluczy na serwerze, generujemy parę kluczy dla klienta, która będzie się składać z pliku client.req oraz pliku client.key. Ten ostatni musi być utrzymywany w tajemnicy na maszynie klienta.

4. Podpisz client.req i wystaw plik client.crt.#

Aby przenieść plik client.req na maszynę CA, użyjemy tej samej metody, co w przypadku pliku server.req.

Po przesłaniu, na maszynie CA podpiszemy plik z żądaniem podpisania certyfikatu tym poleceniem

$ 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

5. Zaimportuj client.crt na Nitrokey z maszyny CA.#

Po utworzeniu pliku client.crt, podłączamy urządzenie Nitrokey Pro 2 do maszyny CA i importujemy plik .crt do urządzenia Pro 2 za pomocą tego polecenia:

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

Możesz sprawdzić, czy klucz jest efektywnie przechowywany na Nitrokey za pomocą tego polecenia:

$ pkcs15-tool -c

Lub alternatywnie

$ pkcs11-tool --list-objects

Więcej poleceń można znaleźć na OpenSC wiki.

6. Pobierz plik chain.crt z maszyny CA.#

My natomiast zachowujemy plik client.crtstored on the nitrokey Pro 2 device, we must retrieve the chain.crt na maszynie klienta i przechowujemy go w odpowiednim katalogu. Możemy użyć scp jak w metodzie wyjaśnionej w części serwerowej tego poradnika.

7. Skonfiguruj klienta do współpracy z Nitrokey#

Teraz z powrotem na komputerze klienckim podłączymy Nitrokey Pro i użyjemy go do ustanowienia połączenia VPN z serwerem. Ogólnie rzecz biorąc, połączenie, które używa TLS wymaga wielu certyfikatów i kluczy do uwierzytelnienia:

OpenVPN client
    - The root certificate file (`chain.crt`)
    - Client certificate
    - Client key

Dla tego przewodnika możemy stworzyć następujący plik client.conf i dodać do niego wymagane opcje:

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

  1. Określ właściwy obiekt

    Każdy dostawca PKCS#11 może obsługiwać wiele urządzeń. Aby wyświetlić listę dostępnych obiektów możesz użyć następującego polecenia:

    $ 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

    Każda para certyfikat/klucz prywatny ma unikalny Serialized id ciąg znaków. Serializowany ciąg id żądanego certyfikatu powinien być określony w pliku konfiguracyjnym. Możemy to zrobić dodając opcję pkcs11-id używając pojedynczego cudzysłowu.

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

  2. Dodaj pobrany Serialized ID do pliku konfiguracyjnego

    Używając swojego ulubionego edytora tekstu, otwórz plik server.conf i dodaj następujące linie, uważając, aby wstawić własne Serialized id:

    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'

    Dla dodatkowych ` ustawień związanych z uwierzytelnianiem OpenVPN <https://openvpn.net/community-resources/how-to/>`__, możesz również dodać kilka linii do obsługi zarządzania kluczami, chociaż jest to opcjonalne.

    Informacja

    Kliknij, aby zobaczyć kod

    # 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

    Krok opcjonalny

    Jeśli potrzebujesz przetestować konfigurację, z i bez tokena na Nitrokey, możesz dodać linie do tego samego client.conf i skomentować/odkomentować odpowiednie linie zgodnie z Twoimi potrzebami:

    Informacja

    Kliknij, aby zobaczyć kod

    # non_nitrokey login

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

  3. Konfiguracja klienta OpenVPN

    Końcowy plik konfiguracyjny client.conf powinien wyglądać tak jak ten:

    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

  4. Configure OpenVPN (Windows only)

    Aby ustanowić uścisk dłoni, należy skonfigurować OpenSSL zawarty w OpenVPN.

    Utwórz katalog ssl w C:\Program Files\OpenVPN i utwórz plik openssl.cnf z następującą zawartością :

    openssl_conf = default_conf

    [default_conf ] ssl_conf = ssl_sect

    [ssl_sect ] system_default = ssl_default_sect

    [SignatureAlgorithms = RSA+SHA512:ECDSA+SHA512:RSA+SHA384:ECDSA+SHA384:RSA+SHA256:ECDSA+SHA256 MaxProtocol = TLSv1.2 MinProtocol = TLSv1.2

    Dzięki tej modyfikacji nie wystąpi błąd zgłoszony tutaj, tutaj i tutaj.

  5. Znane problemy

    Istnieją pewne znane problemy związane z logowaniem OpenVPN za pomocą OpenSC. Proszę zapoznać się z tymi problemami ` tutaj <https://github.com/Nitrokey/wiki/wiki/3rd-Party-Issues>`__.

8. Uruchom klienta OpenVPN#

  1. Uruchom usługę OpenVPN na kliencie

    Włącz usługę OpenVPN i uruchom ją za pomocą tych poleceń:

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

    Aby dwukrotnie sprawdzić, czy usługa OpenVPN jest aktywna, użyj tej komendy:

    $ sudo systemctl status openvpn-server@server.service

  2. Wprowadź swój kod PIN użytkownika

    Podczas uruchamiania klienta OpenVPN należy wprowadzić PIN Nitrokey:

    $ 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: ******

    Ostrzeżenie

    Unfortunately OpenVPN doesn’t seem to be able to establish a handshake on some operating systems and stops at an error as reported here, here and here

    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)

    W niektórych zgłoszonych przypadkach nie pojawia się monit o PIN na terminalu. Jednym z obejść byłoby użycie tej komendy do zalogowania się za pomocą PINu:

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

    Alternatywnie, możesz ` przekompilować klienta OpenVPN <https://forums.openvpn.net/viewtopic.php?f=4&t=23318>`__ z wyłączoną obsługą systemd, i będzie on pytał o PIN zgodnie z oczekiwaniami.

    Inną opcją jest zalogowanie się do instancji OpenVPN za pomocą klienta Viscosity, który zapewnia lepsze doświadczenie użytkownika, zwłaszcza przy wprowadzaniu kodu PIN.