Comment configurer un serveur OpenVPN sur Ubuntu 18.04

Que vous souhaitiez accéder à Internet en toute sécurité tout en étant connecté à un réseau Wi-Fi public non fiable, contourner le contenu géo-restreint ou permettre à vos collègues de se connecter en toute sécurité au réseau de votre entreprise lorsque vous travaillez à distance, l'utilisation d'un VPN est la meilleure solution.

Un VPN vous permet de vous connecter à des serveurs VPN distants, ce qui rend votre connexion cryptée et sécurisée et de surfer sur le Web de manière anonyme en gardant vos données de trafic privées.

Il existe de nombreux fournisseurs de VPN commerciaux parmi lesquels vous pouvez choisir, mais vous ne pouvez jamais être vraiment sûr que le fournisseur n'enregistre pas votre activité. L'option la plus sûre consiste à configurer votre propre serveur VPN.

Ce didacticiel vous guidera tout au long du processus de configuration de votre propre serveur VPN en installant et en configurant OpenVPN sur Ubuntu 18.04. Nous vous montrerons également comment générer des certificats clients et créer des fichiers de configuration

OpenVPN est une solution VPN SSL (Secure Socket Layer) open-source et complète. Il implémente l'extension de réseau sécurisé OSI de couche 2 ou 3 à l'aide du protocole SSL/TLS.

Prérequis #

Pour terminer ce tutoriel, vous aurez besoin de :

Accès Sudo à un serveur Ubuntu 18.04 pour héberger votre instance OpenVPN.
Le serveur doit avoir un pare-feu UFW de base configuré.
Machine dédiée distincte pour servir de CA (autorité de certification). Si vous ne souhaitez pas utiliser une machine dédiée pour votre autorité de certification, vous pouvez créer l'autorité de certification sur votre serveur OpenVPN ou votre machine locale. Une fois que vous avez terminé de créer l'autorité de certification, il est recommandé de déplacer le répertoire de l'autorité de certification dans un endroit sécurisé ou hors ligne.

Ce didacticiel suppose que l'autorité de certification se trouve sur une machine Ubuntu 18.04 distincte. Les mêmes étapes (avec de petites modifications) s'appliqueront si vous utilisez votre serveur en tant qu'autorité de certification.

La raison pour laquelle nous utilisons une machine CA distincte est d'empêcher les attaquants d'infiltrer le serveur. Si un attaquant parvient à accéder à la clé privée de l'AC, il pourra l'utiliser pour signer de nouveaux certificats, ce qui lui donnera accès au serveur VPN.

Construire une autorité de certification avec EasyRSA #

Lors de la configuration d'un nouveau serveur OpenVPN, la première étape consiste à créer une infrastructure à clé publique (PKI). Pour ce faire, nous devrons créer les éléments suivants :

Un certificat d'autorité de certification (CA) et une clé privée.
Un certificat distinct et une paire de clés privées pour le serveur émis par notre autorité de certification.
Un certificat et une paire de clés privées distincts pour chaque client émis par notre autorité de certification.

Comme mentionné dans les conditions préalables pour des raisons de sécurité, nous allons créer l'autorité de certification sur une machine autonome.

Pour créer une autorité de certification, des demandes de certificats et signer des certificats, nous utiliserons un utilitaire CLI nommé EasyRSA.

Effectuez les étapes suivantes sur votre ordinateur CA .

Tout d'abord, téléchargez la dernière version d'EasyRSA à partir du dépôt Github du projet avec la commande wget suivante :
```
cd && wget https://github.com/OpenVPN/easy-rsa/releases/download/v3.0.5/EasyRSA-nix-3.0.5.tgz
```
Une fois le téléchargement terminé, extrayez l'archive avec :
```
tar xzf EasyRSA-nix-3.0.5.tgz
```
Basculez vers le répertoire EasyRSA et créez un fichier de configuration nommé vars en copiant le vars.example fichier :
```
cd ~/EasyRSA-3.0.5/cp vars.example vars
```

Ouvrez le fichier, décommentez et mettez à jour les entrées suivantes pour qu'elles correspondent à vos informations.

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"

Avant de générer une paire de clés CA, nous devons d'abord initialiser une nouvelle PKI avec :

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

L'étape suivante consiste à créer l'autorité de certification :
```
./easyrsa build-ca
```
Si vous ne voulez pas être invité à entrer un mot de passe chaque fois que vous signez vos certificats, exécutez le build-ca commande utilisant le nopass option :./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
```
Il vous sera demandé de définir un mot de passe pour la clé CA et d'entrer un nom commun pour votre CA.

Une fois terminé, le script créera deux fichiers - certificat public CA ca.crt et la clé privée CA ca.key .

Maintenant que l'autorité de certification (CA) est créée, vous pouvez l'utiliser pour signer des demandes de certificat pour un ou plusieurs serveurs et clients OpenVPN.

Installer OpenVPN et EasyRSA #

Notre prochaine étape consiste à installer le package OpenVPN qui est disponible dans les dépôts d'Ubuntu et à télécharger la dernière version d'EasyRSA.

Les étapes suivantes sont effectuées sur le serveur OpenVPN .

L'installation d'OpenVPN est assez simple, il suffit d'exécuter les commandes suivantes sur le serveur OpenVPN :
```
sudo apt updatesudo apt install openvpn
```
Téléchargez la dernière version d'EasyRSA :
```
cd && wget https://github.com/OpenVPN/easy-rsa/releases/download/v3.0.5/EasyRSA-nix-3.0.5.tgz
```
Une fois le téléchargement terminé, tapez la commande suivante pour extraire l'archive :
```
tar xzf EasyRSA-nix-3.0.5.tgz
```
Bien que nous ayons déjà initialisé une PKI sur la machine CA, nous devons également créer une nouvelle PKI sur le serveur OpenVPN. Pour cela, utilisez les mêmes commandes que précédemment :
```
cd ~/EasyRSA-3.0.5/./easyrsa init-pki
```
Si vous vous demandez encore pourquoi nous avons besoin de deux installations EasyRSA, c'est parce que nous allons utiliser cette instance EasyRSA pour générer des demandes de certificat qui seront signées à l'aide de l'instance EasyRSA sur la machine CA .

Cela peut sembler compliqué et un peu déroutant, mais une fois que vous aurez lu tout le didacticiel, vous verrez que ce n'est vraiment pas compliqué.

Création des clés Diffie-Hellman et HMAC #

Dans cette section, nous allons générer une clé Diffie-Hellman forte qui sera utilisée lors de l'échange de clé et un fichier de signature HMAC pour ajouter une couche de sécurité supplémentaire à la connexion.

Accédez d'abord au répertoire EasyRSA sur votre serveur OpenVPN .
```
cd ~/EasyRSA-3.0.5/
```
Générez une clé Diffie-Hellman :
```
./easyrsa gen-dh
```
Le script générera des paramètres DH de 2048 bits. Cela peut prendre un certain temps, en particulier sur les serveurs disposant de peu de ressources. Une fois terminé, le message suivant s'affichera sur votre écran :
```
DH parameters of size 2048 created at /home/serveruser/EasyRSA-3.0.5/pki/dh.pem
```
Copiez le dh.pem fichier dans le /etc/openvpn répertoire :
```
sudo cp ~/EasyRSA-3.0.5/pki/dh.pem /etc/openvpn/
```
Générez une signature HMAC :
```
openvpn --genkey --secret ta.key
```
Une fois terminé, copiez le ta.key fichier dans le /etc/openvpn répertoire :
```
sudo cp ~/EasyRSA-3.0.5/ta.key /etc/openvpn/
```

Création du certificat de serveur et de la clé privée #

Cette section décrit comment générer une clé privée et une demande de certificat pour le serveur OpenVPN.

Accédez au répertoire EasyRSA sur votre serveur OpenVPN et générer une nouvelle clé privée pour le serveur et un fichier de demande de certificat :
```
cd ~/EasyRSA-3.0.5/./easyrsa gen-req server1 nopass
```
Nous utilisons le nopass argument car nous voulons démarrer le serveur OpenVPN sans saisie de mot de passe. Toujours dans cet exemple, nous utilisons server1 en tant qu'identifiant de nom de serveur (entité). Si vous choisissez un nom différent pour votre serveur, n'oubliez pas d'ajuster les instructions ci-dessous lorsque le nom du serveur est utilisé.

La commande créera deux fichiers, une clé privée (server1.key ) et un fichier de demande de certificat (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
```

Copiez la clé privée dans /etc/openvpn répertoire :

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

Transférez le fichier de demande de certificat sur votre ordinateur CA :
```
scp ~/EasyRSA-3.0.5/pki/reqs/server1.req causer@your_ca_ip:/tmp
```
Dans cet exemple, nous utilisons scp pour transférer le fichier, vous pouvez également utiliser rsync via ssh ou toute autre méthode sécurisée.
Connectez-vous à votre ordinateur CA , basculez vers le répertoire EasyRSA et importez le fichier de demande de certificat :
```
cd ~/EasyRSA-3.0.5./easyrsa import-req /tmp/server1.req server1
```
Le premier argument est le chemin d'accès au fichier de demande de certificat et le second est le nom court (entité) du serveur. Dans notre cas, le nom du serveur est 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.
```
Cette commande copie simplement le fichier de requête dans le pki/reqs répertoire.

Toujours dans le répertoire EasyRSA sur la machine CA exécutez la commande suivante pour signer la demande :

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

Le premier argument peut être soit server ou client et le second est le nom court (entité) du serveur.

Vous serez invité à vérifier que la demande provient d'une source fiable. Tapez yes et appuyez sur enter pour confirmer :

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

Si votre clé CA est protégée par un mot de passe, vous serez invité à entrer le mot de passe. Une fois vérifié, le script générera le certificat SSL et imprimera le chemin complet vers celui-ci.

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

L'étape suivante consiste à transférer le certificat signé server1.crt et ca.crt fichiers vers votre serveur OpenVPN. Encore une fois, vous pouvez utiliser scp , rsync ou toute autre méthode sécurisée :
```
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
```
Connectez-vous à votre serveur OpenVPN , et déplacez le server1.crt et ca.crt fichiers dans /etc/openvpn/ répertoire :
```
sudo mv /tmp/{server1,ca}.crt /etc/openvpn/
```

Une fois les étapes décrites dans cette section terminées, vous devriez avoir les nouveaux fichiers suivants sur votre serveur OpenVPN :

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

Configuration du service OpenVPN #

Maintenant que vous avez le certificat de serveur signé par votre autorité de certification et transféré sur votre serveur OpenVPN , il est temps de configurer le service OpenVPN.

Nous utiliserons l'exemple de fichier de configuration fourni avec le package d'installation OpenVPN comme point de départ, puis nous y ajouterons nos propres options de configuration personnalisées.

Commencez par extraire le fichier de configuration dans le /etc/openvpn/ répertoire :

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

Ouvrez le fichier avec votre éditeur de texte préféré :

sudo nano /etc/openvpn/server1.conf

Recherchez les directives des paramètres Certificate, Key et DH et modifiez les noms de fichiers :
/etc/openvpn/server1.conf
```
cert server1.crt
key server1.key 

dh dh.pem
```
Pour rediriger le trafic des clients via le VPN, recherchez et décommentez la redirect-gateway et dhcp-option option :
/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"
```
Par défaut, les résolveurs OpenDNS sont utilisés. Vous pouvez le modifier et utiliser CloudFlare, Google ou tout autre résolveur DNS de votre choix.
Trouver l'user et group directives et décommentez ces paramètres en supprimant le "; ” au début de chaque ligne :
/etc/openvpn/server1.conf
```
user nobody
group nogroup
```
Ajoutez la ligne suivante à la fin du fichier. Cette directive changera l'algorithme d'authentification de message (HMAC) de SHA1 à SHA256
/etc/openvpn/server1.conf
```
auth SHA256
```

Une fois que vous avez terminé, le fichier de configuration du serveur (hors commentaires) devrait ressembler à ceci :

/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

Démarrage du service OpenVPN #

Dans ce tutoriel, nous avons utilisé server1.conf en tant que fichier de configuration. Pour démarrer le service OpenVPN avec cette configuration, nous devons spécifier le nom du fichier de configuration après le nom du fichier d'unité systemd :

Sur votre serveur OpenVPN exécutez la commande suivante pour démarrer le service OpenVPN :

sudo systemctl start openvpn@server1

Vérifiez si le service a démarré avec succès en tapant :

sudo systemctl status openvpn@server1

Si le service est actif et en cours d'exécution, la sortie ressemblera à ceci :

● [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"

Activez le service pour qu'il démarre automatiquement au démarrage avec :

sudo systemctl enable openvpn@server1

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

Si le service OpenVPN ne démarre pas, vérifiez les journaux avec sudo journalctl -u openvpn@server1

Le serveur OpenVPN créera un nouveau périphérique tun tun0 . Pour vérifier si l'appareil est disponible, utilisez la commande ip suivante :

ip a show tun0

Le résultat devrait ressembler à ceci :

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

À ce stade, votre serveur OpenVPN est configuré et fonctionne correctement.

Configuration du pare-feu et de la mise en réseau du serveur #

Afin de transférer correctement les paquets réseau, nous devons activer le transfert IP.

Les étapes suivantes sont effectuées sur le serveur OpenVPN .

Ouvrez le /etc/sysctl.conf fichier et ajoutez ou décommentez la ligne qui lit 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

Une fois que vous avez terminé, enregistrez et fermez le fichier.

Appliquez les nouveaux paramètres en exécutant la commande suivante :

sudo sysctl -p

net.ipv4.ip_forward = 1

Si vous avez suivi les prérequis, vous devriez déjà avoir un pare-feu UFW en cours d'exécution sur votre serveur.

Nous devons maintenant ajouter des règles de pare-feu pour activer le masquage. Cela permettra au trafic de quitter le VPN, donnant à vos clients VPN un accès à Internet.

Avant d'ajouter les règles, vous devez connaître l'interface réseau publique de votre serveur Ubuntu OpenVPN. Vous pouvez facilement trouver l'interface en exécutant la commande suivante :

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

Dans notre cas, l'interface se nomme ens3 comme indiqué sur la sortie ci-dessous. Votre interface aura probablement un nom différent.

ens3

Par défaut, lors de l'utilisation d'UFW, les paquets transférés sont supprimés. Nous devrons changer cela et demander à notre pare-feu d'autoriser les paquets transférés.

Ouvrez le fichier de configuration UFW, localisez le DEFAULT_FORWARD_POLICY clé et changez la valeur de DROP pour 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"
...

Ensuite, nous devons définir la politique par défaut pour le POSTROUTING chaîne dans la table nat et définissez la règle de mascarade.

Pour cela, ouvrez le /etc/ufw/before.rules fichier et ajoutez les lignes surlignées en jaune comme indiqué ci-dessous.

sudo nano /etc/ufw/before.rules

N'oubliez pas de remplacer ens3 dans le -A POSTROUTING ligne pour correspondre au nom de l'interface réseau publique que vous avez trouvé dans la commande précédente. Collez les lignes après la dernière ligne en commençant par 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

Lorsque vous avez terminé, enregistrez et fermez le fichier.

Nous devons également ouvrir le trafic UDP sur le port 1194 qui est le port OpenVPN par défaut. Pour ce faire, exécutez la commande suivante :

sudo ufw allow 1194/udp

Si vous avez oublié d'ouvrir le port SSH, pour éviter d'être verrouillé, exécutez la commande suivante pour ouvrir le port :

sudo ufw allow OpenSSH

Rechargez enfin les règles UFW en désactivant et en réactivant UFW :

sudo ufw disablesudo ufw enable

Pour vérifier les modifications, exécutez la commande suivante pour répertorier les règles 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

Création de l'infrastructure de configuration client #

Dans ce didacticiel, nous allons créer un certificat SSL distinct et générer un fichier de configuration différent pour chaque client VPN.

La clé privée du client et la demande de certificat peuvent être générées soit sur la machine cliente, soit sur le serveur. Pour plus de simplicité, nous allons générer la demande de certificat sur le serveur puis l'envoyer à l'AC pour signature.

L'ensemble du processus de génération du certificat client et du fichier de configuration est le suivant :

Générez une clé privée et une demande de certificat sur le serveur OpenVPN.
Envoyez la demande à la machine CA à signer.
Copiez le certificat SSL signé sur le serveur OpenVPN et générez un fichier de configuration.
Envoyez le fichier de configuration à la machine du client VPN.

Commencez par créer un ensemble de répertoires pour stocker les fichiers clients :

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

base Le répertoire stockera les fichiers de base et la configuration qui seront partagés entre tous les fichiers client.
configs répertoire stockera la configuration client générée.
files répertoire stockera la paire certificat/clé spécifique au client.

Copiez le ca.crt et ta.key fichiers vers ~/openvpn-clients/base répertoire :

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

Copiez ensuite l'exemple de fichier de configuration du client VPN dans le fichier client-~/openvpn-clients/base annuaire. Nous utiliserons ce fichier comme configuration de base :

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

Nous devons maintenant modifier le fichier pour qu'il corresponde aux paramètres et à la configuration de notre serveur. Ouvrez le fichier de configuration avec votre éditeur de texte :

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

Trouvez la directive remote et modifiez l'espace réservé par défaut avec l'adresse IP publique de votre serveur 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
```

Localisez et commentez le ca , cert , et key directives. Les certificats et les clés seront ajoutés dans le fichier de configuration :

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

Ajoutez la ligne suivante à la fin du fichier pour correspondre aux paramètres du serveur :
~/openvpn-clients/base/client.conf
```
auth SHA256
```

Une fois que vous avez terminé, le fichier de configuration du serveur devrait ressembler à ceci :

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

Ensuite, créez un script bash simple qui fusionnera la configuration de base et les fichiers avec le certificat client et la clé, et stockera la configuration générée dans le ~/openvpn-clients/configs répertoire.

Ouvrez votre éditeur de texte et créez le script suivant :

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

Enregistrez le fichier et rendez-le exécutable en exécutant le chmod suivant commande :

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

Création de la clé privée du certificat client et du numéro de configuration

Le processus de génération d'une clé privée client et d'une demande de certificat est le même que lors de la génération d'une clé serveur et d'une demande de certificat.

Comme nous l'avons déjà mentionné dans la section précédente, nous allons générer la clé privée du client et la demande de certificat sur le serveur OpenVPN. Dans cet exemple, le nom du premier client VPN sera client1 .

Accédez au répertoire EasyRSA sur votre serveur OpenVPN et générer une nouvelle clé privée et un fichier de demande de certificat pour le client :

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

La commande créera deux fichiers, une clé privée (client1.key ) et un fichier de demande de certificat (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

Copiez la clé privée client1.key au ~/openvpn-clients/files répertoire que vous avez créé dans la section précédente :
```
cp ~/EasyRSA-3.0.5/pki/private/client1.key ~/openvpn-clients/files/
```
Transférez le fichier de demande de certificat sur votre ordinateur CA :
```
scp ~/EasyRSA-3.0.5/pki/reqs/client1.req causer@your_ca_ip:/tmp
```
Dans cet exemple, nous utilisons scp pour transférer le fichier, vous pouvez également utiliser rsync via ssh ou toute autre méthode sécurisée.
Connectez-vous à votre ordinateur CA , basculez vers le répertoire EasyRSA et importez le fichier de demande de certificat :
```
cd ~/EasyRSA-3.0.5./easyrsa import-req /tmp/client1.req client1
```
Le premier argument est le chemin d'accès au fichier de demande de certificat et le second est le nom du 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.
```
Depuis le répertoire EasyRSA sur la machine CA exécutez la commande suivante pour signer la demande :
```
cd ~/EasyRSA-3.0.5./easyrsa sign-req client client1
```
Vous serez invité à vérifier que la demande provient d'une source fiable. Tapez yes et appuyez sur enter pour confirmer :

Si votre clé CA est protégée par un mot de passe, vous serez invité à entrer le mot de passe. Une fois vérifié, le script générera le certificat SSL et imprimera le chemin complet vers celui-ci.
```
...
Certificate created at: /home/causer/EasyRSA-3.0.5/pki/issued/client1.crt
```
Ensuite, transférez le certificat signé client1.crt fichier vers votre serveur OpenVPN. Vous pouvez utiliser scp , rsync ou toute autre méthode sécurisée :
```
scp ~/EasyRSA-3.0.5/pki/issued/client1.crt serveruser@your_server_ip:/tmp
```
Connectez-vous à votre serveur OpenVPN , et déplacez le client1.crt fichier dans le ~/openvpn-clients/files répertoire :
```
mv /tmp/client1.crt ~/openvpn-clients/files
```
La dernière étape consiste à générer une configuration client à l'aide de gen_config.sh scénario. Basculez vers ~/openvpn-clients répertoire et exécutez le script en utilisant le nom du client comme argument :
```
cd ~/openvpn-clients./gen_config.sh client1
```
Le script créera un fichier nommé client1.ovpn dans le ~/client-configs/configs annuaire. Vous pouvez vérifier en listant le répertoire :
```
ls ~/openvpn-clients/configs
```
```
client1.ovpn
```

À ce stade, la configuration du client est créée. Vous pouvez maintenant transférer le fichier de configuration sur l'appareil que vous avez l'intention d'utiliser en tant que client.

Par exemple pour transférer le fichier de configuration sur votre machine locale avec scp vous devez exécuter la commande suivante :

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

Pour ajouter des clients supplémentaires, répétez simplement les mêmes étapes.

Connecter les clients #

Linux#

Votre environnement de distribution ou de bureau peut fournir un outil ou une interface utilisateur graphique pour se connecter aux serveurs OpenVPN. Dans ce tutoriel, nous allons vous montrer comment vous connecter au serveur en utilisant le openvpn outil.

Installez OpenVPN sur Ubuntu et Debian
```
sudo apt updatesudo apt install openvpn
```

Installez OpenVPN sur CentOS et Fedora

sudo yum install epel-releasesudo yum install openvpn

Une fois le package installé, pour vous connecter au serveur VPN utilisez le openvpn commande et spécifiez le fichier de configuration client :

sudo openvpn --config client1.ovpn

macOS #

Tunnelblick est une interface utilisateur graphique gratuite et open source pour OpenVPN sur OS X et macOS.

Windows #

Téléchargez et installez la dernière version de l'application OpenVPN sur la page de téléchargement d'OpenVPN.

Copiez le .ovpn fichier dans le dossier de configuration OpenVPN (\Users\<Name>\OpenVPN\Config ou \Program Files\OpenVPN\config ).

Lancez l'application OpenVPN.

Faites un clic droit sur l'icône de la barre d'état système OpenVPN et le nom du fichier de configuration OpenVPN que vous avez copié sera répertorié dans le menu. Cliquez sur Connecter.

Android et iOS #

Une application VPN développée par OpenVPN est disponible pour Android et iOS. Installez l'application et importez le client .ovp fichier.

Android OpenVPN Connect
Connexion OpenVPN iOS

Révocation des certificats clients #

Révoquer un certificat signifie invalider un certificat signé afin qu'il ne puisse plus être utilisé pour accéder au serveur OpenVPN.

Pour révoquer un certificat client, suivez les étapes ci-dessous :

Connectez-vous à votre ordinateur CA et basculez vers le répertoire EasyRSA :
```
cd EasyRSA-3.0.5
```

Exécutez le script easyrsa en utilisant le revoke argument, suivi du nom du client que vous souhaitez révoquer :

./easyrsa revoke client1

Vous serez invité à confirmer que vous souhaitez révoquer le certificat. Tapez yes et appuyez sur enter pour confirmer :

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

Si votre clé CA est protégée par un mot de passe, vous serez invité à entrer le mot de passe. Une fois vérifié, le script révoquera le certificat.

...
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 répertoire :
```
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
```
Enregistrez et fermez le fichier.
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.