GNU/Linux >> Linux Esercitazione > >> Ubuntu

Come configurare un server OpenVPN su Ubuntu 18.04

Sia che tu voglia accedere a Internet in modo sicuro mentre sei connesso a una rete Wi-Fi pubblica non affidabile, aggirare i contenuti con restrizioni geografiche o consentire ai tuoi colleghi di connettersi in modo sicuro alla rete aziendale quando lavorano in remoto, l'utilizzo di una VPN è la soluzione migliore.

Una VPN ti consente di connetterti a server VPN remoti, rendendo la tua connessione crittografata e sicura e di navigare sul Web in modo anonimo mantenendo privati i tuoi dati di traffico.

Ci sono molti provider VPN commerciali tra cui puoi scegliere, ma non puoi mai essere veramente sicuro che il provider non stia registrando la tua attività. L'opzione più sicura è configurare il tuo server VPN.

Questo tutorial ti guiderà attraverso il processo di configurazione del tuo server VPN installando e configurando OpenVPN su Ubuntu 18.04. Ti mostreremo anche come generare certificati client e creare file di configurazione

OpenVPN è una soluzione VPN Secure Socket Layer (SSL) open source completa. Implementa l'estensione di rete sicura OSI layer 2 o 3 utilizzando il protocollo SSL/TLS.

Prerequisiti #

Per completare questo tutorial, avrai bisogno di:

Sudo accesso a un server Ubuntu 18.04 per ospitare la tua istanza OpenVPN.
Il server dovrebbe avere un firewall UFW di base configurato.
Macchina dedicata separata che funge da CA (autorità di certificazione). Se non desideri utilizzare una macchina dedicata per la tua CA, puoi creare la CA sul tuo server OpenVPN o sulla tua macchina locale. Una volta completata la creazione della CA, si consiglia di spostare la directory della CA in un luogo sicuro o offline.

Questo tutorial presuppone che la CA sia su una macchina Ubuntu 18.04 separata. Gli stessi passaggi (con piccole modifiche) verranno applicati se utilizzi il tuo server come CA.

Il motivo per cui utilizziamo una macchina CA separata è impedire agli aggressori di infiltrarsi nel server. Se un utente malintenzionato riesce ad accedere alla chiave privata della CA, potrebbe utilizzarla per firmare nuovi certificati, che gli consentiranno l'accesso al server VPN.

Creazione di CA con EasyRSA #

Quando si configura un nuovo server OpenVPN, il primo passo è costruire una Public Key Infrastructure (PKI). Per farlo dovremo creare quanto segue:

Un certificato di autorità di certificazione (CA) e una chiave privata.
Un certificato separato e una coppia di chiavi private per il server emesse dalla nostra CA.
Un certificato separato e una coppia di chiavi private per ogni client emesso dalla nostra CA.

Come menzionato nei prerequisiti per motivi di sicurezza, creeremo la CA su un computer autonomo.

Per creare CA, richieste di certificati e firmare certificati utilizzeremo un'utilità CLI denominata EasyRSA.

Esegui i seguenti passaggi sulla tua macchina CA .

Innanzitutto, scarica l'ultima versione di EasyRSA dal repository Github del progetto con il seguente comando wget:
```
cd && wget https://github.com/OpenVPN/easy-rsa/releases/download/v3.0.5/EasyRSA-nix-3.0.5.tgz
```
Una volta completato il download, estrai l'archivio con:
```
tar xzf EasyRSA-nix-3.0.5.tgz
```
Passare alla directory EasyRSA e creare un file di configurazione denominato vars copiando il vars.example file:
```
cd ~/EasyRSA-3.0.5/cp vars.example vars
```

Apri il file, decommenta e aggiorna le seguenti voci in modo che corrispondano alle tue informazioni.

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"

Prima di generare una coppia di chiavi CA, è necessario inizializzare una nuova PKI con:

./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

Il passaggio successivo consiste nel creare la CA:
```
./easyrsa build-ca
```
Se non vuoi che ti venga richiesta una password ogni volta che firmi i tuoi certificati, esegui build-ca comando usando il nopass opzione:./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
```
Ti verrà chiesto di impostare una password per la chiave CA e di inserire un nome comune per la tua CA.

Una volta completato, lo script creerà due file:certificato pubblico CA ca.crt e chiave privata CA ca.key .

Ora che l'Autorità di certificazione (CA) è stata creata, puoi utilizzarla per firmare richieste di certificati per uno o più server e client OpenVPN.

Installazione di OpenVPN e EasyRSA #

Il nostro prossimo passo è installare il pacchetto OpenVPN che è disponibile nei repository di Ubuntu e scaricare l'ultima versione di EasyRSA.

I seguenti passaggi vengono eseguiti sul server OpenVPN .

L'installazione di OpenVPN è piuttosto semplice, basta eseguire i seguenti comandi sul server OpenVPN :
```
sudo apt updatesudo apt install openvpn
```
Scarica l'ultima versione di EasyRSA:
```
cd && wget https://github.com/OpenVPN/easy-rsa/releases/download/v3.0.5/EasyRSA-nix-3.0.5.tgz
```
Una volta completato il download, digita il seguente comando per estrarre l'archivio:
```
tar xzf EasyRSA-nix-3.0.5.tgz
```
Sebbene abbiamo già inizializzato una PKI sulla macchina CA, dobbiamo anche creare una nuova PKI sul server OpenVPN. Per farlo, usa gli stessi comandi di prima:
```
cd ~/EasyRSA-3.0.5/./easyrsa init-pki
```
Se ti chiedi ancora perché abbiamo bisogno di due installazioni EasyRSA, è perché utilizzeremo questa istanza EasyRSA per generare richieste di certificati che verranno firmate utilizzando l'istanza EasyRSA sulla macchina CA .

Può sembrare complicato e poco confuso, ma una volta letto l'intero tutorial vedrai che non è davvero complicato.

Creazione di chiavi Diffie-Hellman e HMAC #

In questa sezione, genereremo una forte chiave Diffie-Hellman che verrà utilizzata durante lo scambio delle chiavi e un file di firma HMAC per aggiungere un ulteriore livello di sicurezza alla connessione.

Per prima cosa vai alla directory EasyRSA sul tuo server OpenVPN .
```
cd ~/EasyRSA-3.0.5/
```
Genera una chiave Diffie-Hellman:
```
./easyrsa gen-dh
```
Lo script genererà parametri DH lunghi 2048 bit. Questo può richiedere del tempo, specialmente su server con poche risorse. Una volta completato, sullo schermo verrà stampato il seguente messaggio:
```
DH parameters of size 2048 created at /home/serveruser/EasyRSA-3.0.5/pki/dh.pem
```
Copia il dh.pem file nel /etc/openvpn directory:
```
sudo cp ~/EasyRSA-3.0.5/pki/dh.pem /etc/openvpn/
```
Genera una firma HMAC:
```
openvpn --genkey --secret ta.key
```
Una volta completato, copia il ta.key file nel /etc/openvpn directory:
```
sudo cp ~/EasyRSA-3.0.5/ta.key /etc/openvpn/
```

Creazione del certificato del server e della chiave privata #

Questa sezione descrive come generare una chiave privata e una richiesta di certificato per il server OpenVPN.

Vai alla directory EasyRSA sul tuo server OpenVPN e genera una nuova chiave privata per il server e un file di richiesta del certificato:
```
cd ~/EasyRSA-3.0.5/./easyrsa gen-req server1 nopass
```
Stiamo usando il nopass argomento perché vogliamo avviare il server OpenVPN senza inserire una password. Anche in questo esempio stiamo usando server1 come identificatore del nome del server (entità). Se scegli un nome diverso per il tuo server, non dimenticare di modificare le istruzioni di seguito in cui viene utilizzato il nome del server.

Il comando creerà due file, una chiave privata (server1.key ) e un file di richiesta del certificato (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
```

Copia la chiave privata in /etc/openvpn directory:

sudo cp ~/EasyRSA-3.0.5/pki/private/server1.key /etc/openvpn/

Trasferisci il file di richiesta del certificato sulla tua macchina CA:
```
scp ~/EasyRSA-3.0.5/pki/reqs/server1.req causer@your_ca_ip:/tmp
```
In questo esempio stiamo usando scp per trasferire il file, puoi anche usare rsync su ssh o qualsiasi altro metodo sicuro.
Accedi alla tua macchina CA , passa alla directory EasyRSA e importa il file di richiesta del certificato:
```
cd ~/EasyRSA-3.0.5./easyrsa import-req /tmp/server1.req server1
```
Il primo argomento è il percorso del file di richiesta del certificato e il secondo è il nome breve (entità) del server. Nel nostro caso il nome del server è 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.
```
Questo comando copia semplicemente il file di richiesta in pki/reqs directory.

Mentre sei ancora nella directory EasyRSA su macchina CA eseguire il comando seguente per firmare la richiesta:

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

Il primo argomento può essere server o client e il secondo è il nome breve (entità) del server.

Ti verrà chiesto di verificare che la richiesta provenga da una fonte attendibile. Digita yes e premi enter per confermare:

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
...

Se la tua chiave CA è protetta da password, ti verrà chiesto di inserire la password. Una volta verificato, lo script genererà il certificato SSL e ne stamperà il percorso completo.

...
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

Il passaggio successivo consiste nel trasferire il certificato firmato server1.crt e ca.crt file sul tuo server OpenVPN. Anche in questo caso puoi usare scp , rsync o qualsiasi altro metodo sicuro:
```
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
```
Accedi al tuo server OpenVPN e sposta il server1.crt e ca.crt file nel /etc/openvpn/ directory:
```
sudo mv /tmp/{server1,ca}.crt /etc/openvpn/
```

Dopo aver completato i passaggi descritti in questa sezione, dovresti avere i seguenti nuovi file sul tuo server OpenVPN :

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

Configurazione del servizio OpenVPN #

Ora che hai il certificato del server firmato dalla tua CA e trasferito al tuo server OpenVPN , è ora di configurare il servizio OpenVPN.

Utilizzeremo il file di configurazione di esempio fornito con il pacchetto di installazione di OpenVPN come punto di partenza e quindi aggiungeremo le nostre opzioni di configurazione personalizzate.

Inizia estraendo il file di configurazione in /etc/openvpn/ directory:

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

Apri il file con il tuo editor di testo preferito:

sudo nano /etc/openvpn/server1.conf

Trova le direttive dei parametri Certificate, Key e DH e cambia i nomi dei file:
/etc/openvpn/server1.conf
```
cert server1.crt
key server1.key 

dh dh.pem
```
Per reindirizzare il traffico dei client attraverso la VPN, trova e decommenta il redirect-gateway e dhcp-option opzioni:
/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"
```
Per impostazione predefinita vengono utilizzati i resolver OpenDNS. Puoi cambiarlo e utilizzare CloudFlare, Google o qualsiasi altro resolver DNS che desideri.
Trova l'user e group direttive e decommentare queste impostazioni rimuovendo il "; ” all'inizio di ogni riga:
/etc/openvpn/server1.conf
```
user nobody
group nogroup
```
Aggiungi la riga seguente alla fine del file. Questa direttiva cambierà l'algoritmo di autenticazione del messaggio (HMAC) da SHA1 a SHA256
/etc/openvpn/server1.conf
```
auth SHA256
```

Una volta terminato, il file di configurazione del server (esclusi i commenti) dovrebbe assomigliare a questo:

/etc/openvpn/server1.conf

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

Avvio del servizio OpenVPN #

In questo tutorial abbiamo usato server1.conf come file di configurazione. Per avviare il servizio OpenVPN con questa configurazione è necessario specificare il nome del file di configurazione dopo il nome del file dell'unità di sistema:

Sul tuo server OpenVPN eseguire il comando seguente per avviare il servizio OpenVPN:

sudo systemctl start openvpn@server1

Verifica se il servizio è stato avviato correttamente digitando:

sudo systemctl status openvpn@server1

Se il servizio è attivo e in esecuzione, l'output sarà simile a questo:

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

Abilita l'avvio automatico del servizio all'avvio con:

sudo systemctl enable openvpn@server1

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

Se il servizio OpenVPN non si avvia, controlla i log con sudo journalctl -u openvpn@server1

Il server OpenVPN creerà un nuovo dispositivo tun tun0 . Per verificare se il dispositivo è disponibile, utilizzare il seguente comando ip:

ip a show tun0

L'output dovrebbe essere simile a questo:

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

A questo punto, il tuo server OpenVPN è configurato e funziona correttamente.

Configurazione di rete di firewall e server #

Per inoltrare correttamente i pacchetti di rete, è necessario abilitare l'inoltro IP.

I seguenti passaggi vengono eseguiti sul server OpenVPN .

Apri il /etc/sysctl.conf file e aggiungi o decommenta la riga che legge net.ipv4.ip_forward = 1 :

sudo nano /etc/sysctl.conf

/etc/sysctl.conf

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

Al termine, salva e chiudi il file.

Applica le nuove impostazioni eseguendo il comando seguente:

sudo sysctl -p

net.ipv4.ip_forward = 1

Se hai seguito i prerequisiti, dovresti già avere un firewall UFW in esecuzione sul tuo server.

Ora dobbiamo aggiungere le regole del firewall per abilitare il masquerading. Ciò consentirà al traffico di lasciare la VPN, fornendo ai tuoi client VPN l'accesso a Internet.

Prima di aggiungere le regole devi conoscere l'interfaccia di rete pubblica del tuo server Ubuntu OpenVPN. Puoi trovare facilmente l'interfaccia eseguendo il seguente comando:

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

Nel nostro caso, l'interfaccia si chiama ens3 come mostrato nell'output di seguito. La tua interfaccia avrà probabilmente un nome diverso.

ens3

Per impostazione predefinita, quando si utilizza UFW i pacchetti inoltrati vengono eliminati. Dovremo cambiarlo e istruire il nostro firewall per consentire l'inoltro dei pacchetti.

Apri il file di configurazione UFW, individua il DEFAULT_FORWARD_POLICY e cambia il valore da DROP per ACCEPT :

sudo nano /etc/default/ufw

/etc/default/ufw

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

Successivamente, dobbiamo impostare la politica predefinita per il POSTROUTING catena nella tabella nat e imposta la regola della mascherata.

Per farlo, apri il /etc/ufw/before.rules file e aggiungi le righe evidenziate in giallo come mostrato di seguito.

sudo nano /etc/ufw/before.rules

Non dimenticare di sostituire ens3 nel -A POSTROUTING riga in modo che corrisponda al nome dell'interfaccia di rete pubblica trovata nel comando precedente. Incolla le righe dopo l'ultima riga che inizia con COMMIT .

/etc/ufw/before.rules

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

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

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

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

Quando hai finito, salva e chiudi il file.

Dobbiamo anche aprire il traffico UDP sulla porta 1194 che è la porta OpenVPN predefinita. Per farlo, esegui il seguente comando:

sudo ufw allow 1194/udp

Nel caso ti fossi dimenticato di aprire la porta SSH, per evitare di essere bloccato, esegui il seguente comando per aprire la porta:

sudo ufw allow OpenSSH

Infine, ricarica le regole UFW disabilitando e riattivando UFW:

sudo ufw disablesudo ufw enable

Per verificare le modifiche eseguire il seguente comando per elencare le regole di POSTROUTING:

sudo iptables -nvL POSTROUTING -t nat

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

Creazione dell'infrastruttura di configurazione client #

In questo tutorial creeremo un certificato SSL separato e genereremo un file di configurazione diverso per ogni client VPN.

La chiave privata del client e la richiesta di certificato possono essere generate sulla macchina client o sul server. Per semplicità genereremo la richiesta di certificato sul server e poi la invieremo alla CA per la firma.

L'intero processo di generazione del certificato client e del file di configurazione è il seguente:

Genera una chiave privata e una richiesta di certificato sul server OpenVPN.
Invia la richiesta alla macchina della CA da firmare.
Copia il certificato SSL firmato sul server OpenVPN e genera un file di configurazione.
Invia il file di configurazione alla macchina del client VPN.

Inizia creando una serie di directory in cui archiviare i file dei client:

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

base directory memorizzerà i file di base e la configurazione che saranno condivisi tra tutti i file client.
configs directory memorizzerà la configurazione del client generata.
files directory memorizzerà la coppia di chiavi/certificati specifici del client.

Copia il ca.crt e ta.key file nel ~/openvpn-clients/base directory:

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

Quindi copia il file di configurazione del client VPN di esempio nel client-~/openvpn-clients/base directory. Useremo questo file come configurazione di base:

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

Ora dobbiamo modificare il file in modo che corrisponda alle impostazioni e alla configurazione del nostro server. Apri il file di configurazione con il tuo editor di testo:

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

Trova la direttiva remota e cambia il segnaposto predefinito con l'indirizzo IP pubblico del tuo server OpenVPN:

~/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

Individua e commenta il ca , cert e key direttive. I certificati e le chiavi verranno aggiunti all'interno del file di configurazione:

~/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

Aggiungi la seguente riga alla fine del file in modo che corrisponda alle impostazioni del server:
~/openvpn-clients/base/client.conf
```
auth SHA256
```

Una volta terminato, il file di configurazione del server dovrebbe assomigliare a questo:

~/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

Quindi, crea un semplice script bash che unirà la configurazione di base e i file con il certificato e la chiave del client e memorizzerà la configurazione generata in ~/openvpn-clients/configs directory.

Apri il tuo editor di testo e crea il seguente script:

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

Salva il file e rendilo eseguibile eseguendo il seguente chmod comando:

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

Creazione della chiave privata e della configurazione del certificato client #

Il processo di generazione di una chiave privata del client e di una richiesta di certificato è lo stesso utilizzato per la generazione di una chiave del server e di una richiesta di certificato.

Come già accennato nella sezione precedente, genereremo la chiave privata del client e la richiesta di certificato sul server OpenVPN. In questo esempio, il nome del primo client VPN sarà client1 .

Vai alla directory EasyRSA sul tuo server OpenVPN e generare una nuova chiave privata e un file di richiesta di certificato per il client:

cd ~/EasyRSA-3.0.5/./easyrsa gen-req client1 nopass

Il comando creerà due file, una chiave privata (client1.key ) e un file di richiesta del certificato (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

Copia la chiave privata client1.key al ~/openvpn-clients/files directory che hai creato nella sezione precedente:
```
cp ~/EasyRSA-3.0.5/pki/private/client1.key ~/openvpn-clients/files/
```
Trasferisci il file di richiesta del certificato sulla tua macchina CA:
```
scp ~/EasyRSA-3.0.5/pki/reqs/client1.req causer@your_ca_ip:/tmp
```
In questo esempio stiamo usando scp per trasferire il file, puoi anche usare rsync su ssh o qualsiasi altro metodo sicuro.
Accedi alla tua macchina CA , passa alla directory EasyRSA e importa il file di richiesta del certificato:
```
cd ~/EasyRSA-3.0.5./easyrsa import-req /tmp/client1.req client1
```
Il primo argomento è il percorso del file di richiesta del certificato e il secondo è il nome del client.
```
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.
```
Dalla directory EasyRSA su macchina CA eseguire il comando seguente per firmare la richiesta:
```
cd ~/EasyRSA-3.0.5./easyrsa sign-req client client1
```
Ti verrà chiesto di verificare che la richiesta provenga da una fonte attendibile. Digita yes e premi enter per confermare:

Se la tua chiave CA è protetta da password, ti verrà chiesto di inserire la password. Una volta verificato, lo script genererà il certificato SSL e ne stamperà il percorso completo.
```
...
Certificate created at: /home/causer/EasyRSA-3.0.5/pki/issued/client1.crt
```
Quindi, trasferisci il certificato firmato client1.crt file di nuovo sul tuo server OpenVPN. Puoi usare scp , rsync o qualsiasi altro metodo sicuro:
```
scp ~/EasyRSA-3.0.5/pki/issued/client1.crt serveruser@your_server_ip:/tmp
```
Accedi al tuo server OpenVPN e sposta il client1.crt file nel ~/openvpn-clients/files directory:
```
mv /tmp/client1.crt ~/openvpn-clients/files
```
Il passaggio finale consiste nel generare una configurazione client utilizzando gen_config.sh sceneggiatura. Passa a ~/openvpn-clients directory ed eseguire lo script utilizzando il nome del client come argomento:
```
cd ~/openvpn-clients./gen_config.sh client1
```
Lo script creerà un file chiamato client1.ovpn nel ~/client-configs/configs directory. Puoi controllare elencando la directory:
```
ls ~/openvpn-clients/configs
```
```
client1.ovpn
```

A questo punto viene creata la configurazione del client. Ora puoi trasferire il file di configurazione sul dispositivo che intendi utilizzare come client.

Ad esempio per trasferire il file di configurazione sul tuo computer locale con scp dovresti eseguire il seguente comando:

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

Per aggiungere altri clienti, ripeti gli stessi passaggi.

Client in connessione #

Linux #

La distribuzione o l'ambiente desktop possono fornire uno strumento o un'interfaccia utente grafica per connettersi ai server OpenVPN. In questo tutorial, ti mostreremo come connetterti al server usando openvpn strumento.

Installa OpenVPN su Ubuntu e Debian
```
sudo apt updatesudo apt install openvpn
```

Installa OpenVPN su CentOS e Fedora

sudo yum install epel-releasesudo yum install openvpn

Una volta installato il pacchetto, per connettersi al server VPN utilizzare il openvpn comando e specificare il file di configurazione del client:

sudo openvpn --config client1.ovpn

macOS #

Tunnelblick è un'interfaccia utente grafica open source gratuita per OpenVPN su OS X e macOS.

Finestre #

Scarica e installa l'ultima build dell'applicazione OpenVPN nella pagina Download di OpenVPN.

Copia il .ovpn file nella cartella di configurazione di OpenVPN (\Users\<Name>\OpenVPN\Config o \Program Files\OpenVPN\config ).

Avvia l'applicazione OpenVPN.

Fare clic con il pulsante destro del mouse sull'icona della barra delle applicazioni di OpenVPN e il nome del file di configurazione di OpenVPN che hai copiato verrà elencato nel menu. Fare clic su Connetti.

Android e iOS #

Un'applicazione VPN sviluppata da OpenVPN è disponibile sia per Android che per iOS. Installa l'applicazione e importa il client .ovp file.

Android OpenVPN Connect
iOS OpenVPN Connect

Revocare certificati cliente #

Revocare un certificato significa invalidare un certificato firmato in modo che non possa più essere utilizzato per accedere al server OpenVPN.

Per revocare un certificato client, procedi nel seguente modo:

Accedi alla tua macchina CA e passare alla directory EasyRSA:
```
cd EasyRSA-3.0.5
```

Esegui lo script easyrsa usando revoke argomento, seguito dal nome del client che desideri revocare:

./easyrsa revoke client1

Ti verrà chiesto di verificare che desideri revocare il certificato. Digita yes e premi enter per confermare:

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
...

Se la tua chiave CA è protetta da password, ti verrà chiesto di inserire la password. Once verified the script will revoke the certificate.

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

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

./easyrsa gen-crl

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

Upload the CRL file to the OpenVPN server:

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

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

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

Come configurare il server FTP con VSFTPD su Ubuntu 18.04

Come installare VMware Workstation Player su Ubuntu 18.04

Ubuntu

Come configurare CUPS Print Server su Ubuntu 20.04

Come configurare OpenVPN su Ubuntu Server

Come configurare e configurare un server OpenVPN su Ubuntu 22.04

Come configurare il server di posta elettronica con Plesk su Ubuntu 20.04

Come configurare il server Prosody XMPP su Ubuntu 20.04

Come installare il server OpenVPN su Ubuntu 20.04 LTS