GNU/Linux >> Linux Esercitazione > >> Cent OS

Come configurare un server OpenVPN su CentOS 7

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 tratterà il processo di configurazione del tuo server VPN installando e configurando OpenVPN. 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 CentOS 7 per ospitare la tua istanza OpenVPN.
Il server dovrebbe avere un firewall 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 si trovi su una macchina Linux 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 .

Inizia scaricando 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 digitando:
```
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"

Salva e chiudi il file.

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 EPEL e scaricare l'ultima versione di EasyRSA.

I seguenti passaggi vengono eseguiti sul server OpenVPN .

Abilita il repository EPEL digitando:
```
sudo yum install epel-release
```
Una volta abilitato il repository, installa OpenVPN con il seguente comando:
```
sudo yum 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.

Vai alla directory EasyRSA sul tuo server OpenVPN anf genera una chiave Diffie-Hellman:.
```
cd ~/EasyRSA-3.0.5/./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/
```
Quindi, genera una firma HMAC utilizzando openvpn binario:
```
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 cp /usr/share/doc/openvpn-*/sample/sample-config-files/server.conf /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 ipp.txt
push "redirect-gateway def1 bypass-dhcp"
push "dhcp-option DNS 208.67.222.222"
push "dhcp-option DNS 208.67.220.220"
keepalive 10 120
tls-auth ta.key 0 # This file is secret
cipher AES-256-CBC
user nobody
group nobody
persist-key
persist-tun
status openvpn-status.log
verb 3
explicit-exit-notify 1
auth SHA256

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 Robust And Highly Flexible Tunneling Application On server1
   Loaded: loaded (/usr/lib/systemd/system/[email protected]; disabled; vendor preset: disabled)
   Active: active (running) since Tue 2018-11-06 10:07:35 UTC; 7s ago
 Main PID: 19912 (openvpn)
   Status: "Initialization Sequence Completed"
   CGroup: /system.slice/system-openvpn.slice/[email protected]
           └─19912 /usr/sbin/openvpn --cd /etc/openvpn/ --config server1.conf

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

All'avvio, il server OpenVPN crea un dispositivo tun tun0 . Per verificare se il dispositivo è disponibile, digita 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 pfifo_fast state UNKNOWN group default qlen 100
    link/none 
    inet 10.8.0.1 peer 10.8.0.2/32 scope global tun0
       valid_lft forever preferred_lft forever
    inet6 fe80::f421:f382:3158:138f/64 scope link flags 800 
       valid_lft forever preferred_lft forever

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 la seguente riga:

sudo nano /etc/sysctl.conf

/etc/sysctl.conf

net.ipv4.ip_forward = 1

Al termine, salva e chiudi il file.

Applica le nuove impostazioni eseguendo il seguente sysctl comando:

sudo sysctl -p

net.ipv4.ip_forward = 1

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

Ora dobbiamo aggiungere le regole del firewall per aprire la porta OpenVPN e abilitare il masquerading.

Inizia aggiungendo il tun0 interfaccia al trusted zona:

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

Apri la porta openvpn predefinita 1194 aggiungendo il servizio openvpn all'elenco dei servizi consentiti da firewalld :

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

Imposta il mascheramento IP su trusted zona:

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

Prima di aggiungere la regola nat devi conoscere l'interfaccia di rete pubblica del tuo server CentOS 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 eth0 come mostrato nell'output di seguito. La tua interfaccia potrebbe avere un nome diverso.

eth0

Il comando seguente consentirà al traffico di lasciare la VPN, fornendo ai tuoi client VPN l'accesso a Internet. Non dimenticare di sostituire eth0 in modo che corrisponda al nome dell'interfaccia di rete pubblica che hai trovato nel comando precedente.

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

Infine, ricarica le regole del firewall per rendere effettive le modifiche:

sudo firewall-cmd --reload

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:

sudo cp /usr/share/doc/openvpn-*/sample/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 le seguenti righe alla fine del file in modo che corrispondano alle impostazioni del server:
~/openvpn-clients/base/client.conf
```
auth SHA256
key-direction 1
```

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 con chmod :

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. Una volta verificato lo script revocherà il certificato.

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

Usa gen-crl opzione per generare un elenco di revoche di certificati (CRL):

./easyrsa gen-crl

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

Carica il file CRL sul server OpenVPN:

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

Accedi al tuo server OpenVPN server e sposta il file nel /etc/openvpn directory:
```
sudo mv /tmp/crl.pem /etc/openvpn
```
Apri il file di configurazione del server OpenVPN:
```
sudo nano /etc/openvpn/server1.conf
```
Incolla la riga seguente alla fine del file
/etc/openvpn/server1.conf
```
crl-verify crl.pem
```
Salva e chiudi il file.
Riavvia il servizio OpenVPN per rendere effettiva la direttiva di revoca:
```
sudo systemctl restart openvpn@server1
```
A questo punto, il client non dovrebbe più essere in grado di accedere al server OpenVPN utilizzando il certificato revocato.

Se hai bisogno di revocare certificati client aggiuntivi, ripeti gli stessi passaggi.

Come installare e configurare Nextcloud con Apache su CentOS 7

Come installare phpMyAdmin con Nginx su CentOS 7

Cent OS

Come configurare il server DHCP su CentOS 8

Come installare OpenVPN su CentOS 8

Come configurare server e client NFS su CentOS 8

Come configurare SSH su CentOS e RHEL

Come configurare un server TeamSpeak su CentOS 7

Come configurare un server Minecraft su CentOS 7