Configuração OpenVPN com Easy-RSA#

Nota

Este guia é um trabalho em progresso, e será actualizado de acordo com a sua actualização. Por favor, leve este status em consideração.

Este guia mostra como configurar clientes OpenVPN para iniciar sessão usando um Nitrokey Pro 2 ou um Nitrokey Storage 2. Para gestão de chaves de software estaremos a usar `Easy-RSA <https://github.com/OpenVPN/easy-rsa>>x id=»343»></x>__, um utilitário que tem vindo a evoluir juntamente com o OpenVPN.

Para assinar os certificados, usaremos um Nitrokey HSM 2 estabelecido como Certificate Authority>, contudo, este guia não cobre a criação da própria CA (é claro e bem documentado aqui).

Vamos usar o Easy-RSA, porque parece proporcionar alguma flexibilidade, e permite a gestão de chaves através de PKIs externos. Vamos usá-lo no servidor para emitir o pedido de assinatura, e repetir o mesmo processo no cliente. Os pedidos de assinatura de certificados serão assinados pela CA no Nitorkey HSM, e retransmitidos ao servidor e ao cliente.

Pré-requisitos #

Na documentação seguinte serão necessárias 3 máquinas diferentes, como a seguir:

Servidor OpenVPN (v. 2.5) na Debian 10 (máquina virtual EC2 - AWS)
Cliente OpenVPN (v. 2.4.9) no Fedora 30 (máquina local)
A Autoridade Certificadora estará acessível a partir de uma máquina autônoma com Fedora 30 (máquina local)

Para interagir com os dispositivos, iremos requerer OpenSC 0,20 instalado na máquina cliente e CA (as máquinas locais). Pode seguir as instruções para a configurar em ` este link (*Unix) <https://github.com/OpenSC/OpenSC/wiki/Compiling-and-Installing-on-Unix-flavors>`__.

Para descarregar as dependências das máquinas Fedora, podemos fazer esta instrução:

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

Para Debian Linux, estão disponíveis pacotes OpenSC mais recentes here.

Utilizaremos as seguintes Nitrokeys para a gestão da chave física:

Uma chave de autenticação usando a Nitrokey Pro 2 (pdf)
Uma Autoridade Certificadora (AC) usando o Nitrokey HSM 2 (pdf)

Como lembrete, para construir uma Autoridade Certificadora no Nitrokey HSM 2, você pode seguir as instruções disponíveis ` na documentação <certificate-authority.html#sign-a-server-certificate>`_.

Alternativamente, pode configurar a sua própria CA num ` numa máquina separada <https://www.digitalocean.com/community/tutorials/how-to-set-up-and-configure-a-certificate-authority-ca-on-ubuntu-20-04>`__, ou utilizar o tutorial OpenVPN que também se baseia em Easy-RSA. As últimas 2 opções dependem de soluções de software para a gestão de chaves.

Lado do servidor #

Install OpenVPN #

Primeiro precisamos habilitar o IP Forwarding editando /etc/sysctl.conf arquivo
```
$ editor /etc/sysctl.conf
```
Descomentar ou editar em conformidade a seguinte linha
```
net.ipv4.ip_forward=1
```
Feche depois de salvá-lo, e digite este comando
```
$ sysctl -p
```
Uma vez feito o reencaminhamento IP, teremos de descarregar a última versão do OpenvPN para o nosso servidor Debian 10, de acordo com estas instruções:

Mude para root e baixe a chave GPG que assinou o pacote

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

Adicione a URL dos pacotes OpenVPN adequados ao arquivo sources.list arquivo
```
# echo "deb http://build.openvpn.net/debian/openvpn/release/2.5 buster main" > /etc/apt/sources.list.d/openvpn-aptrepo.list
# exit
```
Descarregámos o OpenVPN 2.5 como «prompt de senha» requer pelo menos OpenVPN `versão 2.4.8 <https://community.openvpn.net/openvpn/ticket/1215>>x id=»139»></x>__ para iniciar sessão.

A seguir baixamos o OpenVPN

$ sudo apt install openvpn

Se você quiser verificar a versão, é possível chamar --version e imprimir o seguinte:

$ 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

Install Easy-RSA #

Para construir o PKI, iremos descarregar a última versão do Easy-RSA nas máquinas do servidor e do cliente. Para obter a última versão, vá para a página Lançamento no projecto oficial do EasyRSA GitHub, copie o link para o ficheiro que termina em .tgz, e depois cole-o no seguinte comando:

Faça o download do último lançamento

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

Extrair o tarball

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

Create a PKI for OpenVPN server #

Antes de poder criar a chave privada e o certificado do seu servidor OpenVPN, você precisa criar um diretório local de Infraestrutura de Chave Pública no seu servidor OpenVPN. Você usará esse diretório para gerenciar os pedidos de certificados do servidor e dos clientes, em vez de fazê-los diretamente no seu servidor CA.

Para construir um diretório PKI no seu servidor OpenVPN, você precisará preencher um arquivo chamado vars com alguns valores padrão.

Criar um ficheiro vars` ficheiro

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

Uma vez aberto o arquivo, cole nas duas linhas a seguir
```
set_var EASYRSA_ALGO "ec"
set_var EASYRSA_DIGEST "sha512"
```
Estas são as duas únicas linhas que você precisa neste vars arquivo no seu servidor OpenVPN já que não será usado como Autoridade Certificadora. Eles assegurarão que suas chaves privadas e pedidos de certificados sejam configurados para usar a Criptografia Elíptica Curva (ECC) para gerar chaves, e assegurar assinaturas para seus clientes e servidor OpenVPN.

Em relação à escolha dos algoritmos criptográficos, sigo o modelo em este tutorial, e pode personalizá-los de acordo com as suas necessidades específicas.
Inicializar o PKI

Depois de ter preenchido o ficheiro vars você pode prosseguir com a criação do directório PKI. Para isso, execute o script easyrsa com a opção init-pki:
```
$ ./easyrsa init-pki
```

Depois de ter iniciado o seu PKI no servidor OpenVPN, você está pronto para passar para o próximo passo, que é criar um pedido de certificado de servidor OpenVPN e chave privada.

Create `server.req` and `server.key`#

Agora que o seu servidor OpenVPN tem todos os pré-requisitos instalados, o próximo passo é gerar um par de chaves composto de uma chave privada (para manter segredo), e um Certificado de Pedido de Assinatura (.csr) no seu servidor OpenVPN.

Em termos gerais, em sistemas onde geramos uma chave e pedido, estes ficheiros são deixados por encriptar usando o argumento nopass, uma vez que os servidores normalmente precisam de arrancar sem a introdução de qualquer palavra-passe. Isto gera uma chave não criptografada, portanto tenha em mente proteger seu acesso e permissões de arquivo cuidadosamente.

Dica

Notas de configuração do OpenVPN:

O servidor, e cada cliente, deve ter seu próprio arquivo cert e key file. O servidor e todos os clientes irão usar o mesmo arquivo CA.
O certificado do servidor deve ter o seguinte:

keyUsage: digitalSignature, keyEncipherment`
extendedKeyUsage: serverAuth`

Criar o pedido de assinatura para o servidor

Navegue para o diretório ~/easyrsa no seu servidor OpenVPN como seu usuário não-root, e digite os seguintes comandos:
```
$ cd easyrsa/
$ ./easyrsa gen-req server nopass
```
Isto irá criar uma chave privada para o servidor e um ficheiro de pedido de certificado chamado server.req.

Uma vez que você tenha um certificado assinado, você o transferirá de volta para o servidor OpenVPN.
Copie a chave para o diretório do servidor OpenVPN
```
$ sudo cp /home/admin/EasyRSA/pki/private/server.key /etc/openvpn/server/
```
Após completar estes passos, você criou com sucesso uma chave privada para o seu servidor OpenVPN. Você também gerou um pedido de assinatura de certificado para o servidor OpenVPN.

Dica

Extensões de arquivo para pedidos de assinatura de certificado

A extensão de arquivo que é adotada pelo tutorial CA e HSM indica a criação de um arquivo .csr, porém o Easy-RSA cria pedidos de assinatura de certificado com uma extensão .req.

Usaremos intercambiavelmente ambas as extensões, enquanto nos certificamos de que transferimos os arquivos certos para a Autoridade Certificadora, e geramos um certificado final com uma extensão .crt.

Na próxima seção deste guia, assinaremos um arquivo .req com nossa CA no dispositivo HSM 2. Para este fim, vou usar uma máquina dedicada para assinar os pedidos.

Sign and retrieve `server.crt`#

As instruções seguintes requerem a transferência do arquivo server.req` (ou server.csr) para o sistema CA.

A transferência em si não é sensível à segurança, embora seja aconselhável verificar se o arquivo recebido corresponde à cópia do remetente, se o transporte não é confiável.

Para passar por estes passos, vou confiar extensivamente em estas instruções, para assinar os pedidos de assinatura de certificado, uma vez que os geramos com Easy-RSA.

Sign the `server.req` file#

Na máquina local dedicada a acessar o HSM, usaremos as ferramentas fornecidas pelo Opensc 0.20 para assinar o arquivo .req e enviá-lo de volta ao servidor OpenVPN. Nós assumimos que transferimos o arquivo da máquina do servidor para a máquina CA.

Primeiro começamos por ligar o HSM Nitrokey, e introduza esta instrução para listar as chaves disponíveis.

Consultar a lista de dispositivos disponíveis
```
$ p11tool --list-all
```
(Required step) If this is the first time you sign a certificate with the CA, you might want to retrieve the URI of the CA’s private key from the HSM, and include it in the config file.
- O URI da chave deve estar neste formato:
```
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
```

Criar openvpn/ directório sob `x id="38"></x>`

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

Assine o 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

Retrieve the `server.crt` file to the server machine#

Transferir os certificados assinados para o servidor

Da máquina CA, copie os arquivos server.crt` e chain.crt para o servidor OpenVPN. Neste exemplo vamos usar o comando scp como se segue:
```
$ scp openvpn/{server.crt,chain.crt} admin@your_openvpnserver_ip:/tmp
```
Colocar os certificados no diretório do servidor
```
$ mv /tmp/{server.crt,chain.crt} /etc/openvpn/server
```
Aviso

Certificado CA e chain.crt`

No acima, o AC retorna o certificado de corte assinado, e inclui o certificado do AC CA.crt que é o `x id="117"></x> arquivo. Isto pode ser feito através de um canal inseguro, embora o cliente seja encorajado a confirmar se o chain.crt é válido, se o transporte não for confiável.

É possível renomear o arquivo chain.crt arquivo para CA.crt na máquina alvo, no entanto usaremos chain.crt` nas próximas instruções.

Configure the OpenVPN server #

Uma ligação que utiliza TLS requer múltiplos certificados e chaves para autenticação. Agora que as emitimos e assinámos, podemos colocá-las nos directórios certos. A repartição dos certificados e chaves que devem ser localizados no directório raiz é a seguinte:

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

No seu servidor OpenVPN, agora você pode criar o arquivo de configuração server.conf com o seu editor de texto favorito. O ficheiro pode ser configurado de acordo com as suas necessidades, enquanto nos certificamos de alterar o certificado do servidor e as secções chave de acordo com os nomes que escolheu para os seus ficheiros que assinámos:

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

Aqui está o arquivo de configuração que podemos usar para testar estas instruções:

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

Para testar se a configuração funciona corretamente, podemos usar este comando:

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

Start the OpenVPN service on the server #

Habilite o serviço OpenVPN adicionando-o ao systemctl, e inicie-o usando estes comandos:

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

Para verificar duas vezes se o serviço OpenVPN está ativo, use este comando:

$ sudo systemctl status openvpn@server

O OpenVPN deve estar a funcionar neste momento.

Configuração do lado do cliente #

Install OpenVPN and Easy-RSA #

Instalar o software

Podemos usar diretamente dnf install para instalar o OpenVPN 2.4.9 e o Easy-RSA 3.0.7
$ sudo dnf install openvpn easy-rsa
Então criamos como não-root um diretório para Easy RSA chamado Easy-RSA`
```
$ mkdir ~/easyrsa
```
E ligue-o ao pacote Easy RSA que acabámos de instalar
```
$ ln -s /usr/share/easy-rsa/3/* ~/easyrsa/
```

Create a PKI for the OpenVPN client #

Da mesma forma que criamos uma PKI no servidor OpenVPN, vamos criar uma PKI usando Easy-RSA no lado do cliente.

Create a `client.req` and `client.key`#

Da mesma forma que emitimos o par de chaves no corte, geramos um par de chaves para o cliente que será composto pelo client.req arquivo e o client.key arquivo. Este último deve ser mantido em segredo na máquina do cliente.

Sign `client.req` and issue the `client.crt` file #

Para transferir o arquivo client.req para a máquina CA, usaremos o mesmo método que usamos para o arquivo server.req.

Uma vez transferido, na máquina CA assinamos o arquivo de pedido de assinatura de certificado com este comando

$ 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

Import `client.crt` on the Nitrokey from the CA machine #

Após criar o ficheiro client.crt, ligamos o dispositivo Nitrokey Pro 2 à máquina CA, e importamos o ficheiro .crt para o dispositivo Pro 2 utilizando este comando:

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

Você pode ver se a chave está efetivamente armazenada na Nitrokey usando este comando:

$ pkcs15-tool -c

Ou, em alternativa

$ pkcs11-tool --list-objects

Para mais comandos pode consultar o wiki OpenSC.

Retrieve the `chain.crt` file from the CA machine #

Enquanto mantemos o arquivo client.crt`>`\ stored on the nitrokey Pro 2 device, we must retrieve the ``chain.crt arquivo na máquina do cliente, e armazená-lo no diretório adequado. Podemos usar scp como no método explicado na seção servidor deste guia.

Configure the client to interact with the Nitrokey #

Agora de volta à máquina cliente, vamos ligar a Nitrokey Pro e usá-la para estabelecer a ligação VPN com o servidor. Em termos gerais, uma conexão que utiliza TLS requer múltiplos certificados e chaves para autenticação:

The root certificate file (chain.crt)
Client certificate
Client key

Para este guia, podemos fazer o seguinte client.conf ficheiro, e adicionar-lhe as opções necessárias em conformidade:

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

Determinar o objeto correto

Cada fornecedor PKCS#11 pode suportar múltiplos dispositivos. Para visualizar a lista de objetos disponíveis, você pode usar o seguinte comando:

$ 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

Cada par de chaves certificado/privado tem um único Serialized id` string. A string de id serializada do certificado solicitado deve ser especificada, no arquivo de configuração. Podemos fazer isso adicionando a opção pkcs11-id usando aspas simples.

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

Adicionar a ID Serializada recuperada ao arquivo de configuração

Usando seu editor de texto favorito, abra o arquivo server.conf e adicione as seguintes linhas, tendo o cuidado de inserir seu próprio 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'

Para autenticação adicional settings relacionados com OpenVPN autenticação, pode também adicionar algumas linhas para lidar com a gestão de chaves, embora seja opcional.

Nota

Clique para ver o código

# 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

Etapa opcional

Se precisar de testar a configuração, com e sem a ficha na Nitrokey, pode adicionar linhas ao mesmo client.conf e comentar/descomentar as linhas relevantes de acordo com as suas necessidades:

Nota

Clique para ver o código

# non_nitrokey login

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

Configurar o cliente OpenVPN

O arquivo de configuração final client.conf deve ser parecido com este:

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

Problemas conhecidos

Existem algumas questões conhecidas relacionadas com o login no OpenVPN com OpenSC. Favor consultar estes assuntos aqui.

Start the OpenVPN client #

Iniciar o serviço OpenVPN no cliente

Ative o serviço OpenVPN, e inicie-o usando estes comandos:
```
$ sudo systemctl -f enable openvpn-server@server.service
$ sudo systemctl start openvpn-server@server.service
```
Para verificar duas vezes se o serviço OpenVPN está ativo, use este comando:
```
$ sudo systemctl status openvpn-server@server.service
```

Introduza o seu PIN de utilizador

Ao executar o cliente OpenVPN, é necessário introduzir o PIN da 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: ******

Aviso

Infelizmente o OpenVPN não parece ser capaz de estabelecer um aperto de mão e pára num erro como relatado here <https://support.nitrokey.com/t/nitrokey-pro-with-openssl-1-1-1-tls-1-3-and-rsa-based-certificates/2180/2>>x id=»217»></x>__, `aqui e aqui

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)

Em alguns casos relatados, não solicita um PIN no terminal. Uma alternativa seria usar este comando para fazer o login com o PIN:

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

Alternativamente, poderia recompilar OpenVPN cliente com suporte de sistema desactivado, e irá pedir-lhe o PIN como esperado.

Outra opção, seria fazer login na sua instância OpenVPN com o cliente Viscosity que proporciona uma melhor experiência ao usuário, especialmente para inserir o PIN.

Configuração OpenVPN com Easy-RSA#

Sign the server.req file#

Retrieve the server.crt file to the server machine#

Sign the `server.req` file#

Retrieve the `server.crt` file to the server machine#