Comment configurer le serveur OpenVPN

L’exécution d’un serveur VPN sur votre réseau local permettra aux clients extérieurs de se connecter à votre serveur et d’accéder au réseau comme s’ils y étaient directement connectés. Il s’agit d’une configuration courante pour de nombreuses entreprises, qui permettent à leurs employés de se connecter à distance au réseau d’entreprise local, afin qu’ils aient accès à des ressources internes qui ne sont disponibles que sur le réseau local. Les administrateurs Linux et les utilisateurs expérimentés peuvent également être intéressés par la mise en place d’un serveur VPN à la maison, car ils peuvent ensuite utiliser leur ordinateur portable ou un autre appareil portable pour se connecter à leur réseau domestique lors de leurs déplacements.

L’une des meilleures implémentations d’un système VPN est OpenVPN. Il est entièrement open source et prend en charge de nombreuses fonctionnalités de personnalisation. Dans ce tutoriel, nous allons passer en revue les instructions étape par étape pour installer et configurer OpenVPN sur un système Linux. Cela inclut l’installation d’Easy-RSA pour l’autorité de certification et les certificats clients. Ensuite, nous montrerons comment utiliser un système client pour se connecter au serveur VPN et commencer à accéder au réseau local du serveur. Suivez-nous ci-dessous pour commencer.

Dans ce tutoriel, vous allez apprendre :

Comment installer OpenVPN Server sur les principales distributions Linux
Comment configurer un serveur d’autorité de certification avec Easy-RSA
Comment configurer les paramètres du serveur OpenVPN
Comment générer des certificats et des clés pour les clients VPN
Comment gérer le service OpenVPN
Comment configurer le paramètre du noyau de transfert IP
Comment créer des fichiers de configuration client
Comment se connecter au serveur OpenVPN

REMARQUE
Ce tutoriel suppose que vous avez au moins trois appareils. L’un est destiné au serveur OpenVPN, un autre à l’autorité de certification, et enfin au moins un appareil client que vous prévoyez d’utiliser pour vous connecter au serveur VPN.

Mise en place d’une autorité de certification

Tout d’abord, nous allons configurer le système que nous prévoyons d’utiliser pour l’autorité de certification (CA). Suivez les instructions étape par étape ci-dessous pour terminer le serveur CA :

Tout d’abord, installez le package Easy-RSA. Ce sera l’outil que nous utiliserons pour générer une clé privée qui signera ensuite les demandes des connexions clients entrantes qui ont besoin de l’autorité de certification pour vérifier l’identité du serveur OpenVPN. Sur les systèmes basés sur Debian et Ubuntu :
```
sudo apt install easy-rsa
```
Sur les systèmes basés sur Fedora :
```
sudo dnf install easy-rsa
```
Ensuite, commençons par la configuration d’Easy-RSA. Pour ce faire, nous allons créer un répertoire pour notre infrastructure à clé publique (PKI). Cela peut être nommé comme vous voulez, mais nous allons le garder simple à titre d’exemple :
```
mkdir ~/easy-rsa
```
Ensuite, nous pouvons soit copier tous les fichiers Easy-RSA dans notre nouveau répertoire PKI, soit simplement créer un lien symbolique vers ceux-ci. L’avantage de créer le lien symbolique est que nous n’aurons pas besoin de modifier notre répertoire PKI en cas de futures mises à jour du package Easy-RSA. Exécutez la commande suivante pour créer le lien :
```
ln -s /usr/share/easy-rsa/* ~/easy-rsa/
cd ~/easy-rsa
```
Une fois que nous sommes dans le répertoire ~/easy-rsa, nous exécutons le script qui l’initialise en tant que répertoire PKI.
```
./easyrsa init-pki
```
Ensuite, nous devons définir certaines variables dans notre configuration. Cela peut être fait en créant un fichier nommé vars à l’intérieur du répertoire PKI ~/easy-rsa.
```
nano vars
```
Le contenu suivant peut être collé à l’intérieur ; Il suffit de l’adapter pour qu’il reflète vos propres informations :
```
set_var EASYRSA_REQ_COUNTRY    "US"
set_var EASYRSA_REQ_PROVINCE   "LA"
set_var EASYRSA_REQ_CITY       "Los Angeles"
set_var EASYRSA_REQ_ORG        "LinuxConfig.org"
set_var EASYRSA_REQ_EMAIL      "admin@linuxconfig.org"
set_var EASYRSA_REQ_OU         "Linux Tutorials"
set_var EASYRSA_ALGO           "ec"
set_var EASYRSA_DIGEST         "sha512"
```
Après avoir modifié le fichier à votre satisfaction, enregistrez les modifications et quittez-le.
Ensuite, nous allons exécuter le script build-ca. Cela créera l’autorité de certification, qui génère une paire de clés publique et privée.
```
./easyrsa build-ca
```
Vous serez invité à entrer une phrase secrète qui sécurise la paire de clés. Entrez ensuite un nom qui représente votre serveur d’autorité de certification, tel que le nom d’hôte ou le nom d’utilisateur. Nous utilisons linuxconfig-CA dans la capture d’écran ci-dessous :
Votre serveur est maintenant prêt à agir en tant qu’autorité de certification. Tous les clients qui ont besoin d’interagir avec votre autorité de certification auront besoin d’une copie du fichier ca.crt, qui doit être stocké dans le répertoire ~/easy-rsa/pki, si vous nous avez suivis.
```
cat ~/easy-rsa/pki/ca.crt
```
C’est à vous de décider comment vous choisissez de distribuer le fichier, mais tous les clients VPN auront besoin d’une copie de celui-ci.

AVERTISSEMENT
Assurez-vous de sécuriser votre fichier ca.key. Ce fichier est stocké dans ~/easy-rsa/pki/private/ca.key et ne doit jamais quitter le système. Si ce fichier est compromis, l’objectif de l’AC sera rendu inutile.

Installation d’OpenVPN et Easy-RSA

Nous passons maintenant au serveur VPN. C’est là que nous installerons le logiciel du serveur VPN, tandis que le serveur CA que nous avons configuré dans la section précédente sera responsable de l’émission ou de la révocation des certificats.

La première étape consiste à installer le logiciel OpenVPN et Easy-RSA. Ceux-ci peuvent être facilement installés via des dépôts officiels sur toutes les principales distributions Linux. Vous pouvez utiliser la commande appropriée ci-dessous pour installer OpenVPN et Easy-RSA avec le gestionnaire de paquets de votre système.

Pour installer OpenVPN et Easy-RSA sur Ubuntu, Debian et Linux Mint :


sudo apt install openvpn easy-rsa

Pour installer OpenVPN et Easy-RSA sur Fedora, CentOS, AlmaLinux et Red Hat :


sudo dnf install openvpn easy-rsa

Pour installer OpenVPN et Easy-RSA sur Arch Linux et Manjaro :


sudo pacman -S openvpn easy-rsa

Configuration d’OpenVPN Server et d’Easy-RSA

Nous allons maintenant commencer à configurer le serveur VPN. Les premières étapes vous sembleront familières, car nous devons répéter certaines choses que nous avons également faites sur le serveur CA. Commençons.

Tout d’abord, créez le répertoire easy-rsa comme nous l’avons fait précédemment, et créez un lien symbolique avec les fichiers installés.
```
mkdir ~/easy-rsa
ln -s /usr/share/easy-rsa/* ~/easy-rsa/
cd ~/easy-rsa
```
Créez un fichier vars, mais cette fois-ci, nous n’avons pas besoin de remplir toutes les informations que nous avons faites sur l’autorité de certification.
```
nano vars
```
Collez les lignes suivantes dans le fichier et enregistrez-le :
```
set_var EASYRSA_ALGO "ec"
set_var EASYRSA_DIGEST "sha512"
```
Il s’agit des paramètres de sécurité recommandés pour une vitesse et une sécurité maximales. Vous pouvez, bien sûr, les modifier comme bon vous semble.
À l’intérieur du répertoire ~/easy-rsa, nous exécutons le script qui l’initialise en tant que répertoire PKI.
```
./easyrsa init-pki
```
Ensuite, nous allons générer une clé privée pour le serveur VPN, ainsi qu’une demande de signature de certificat (CSR). Dans les étapes ultérieures, cette demande devra être signée par l’autorité de certification que nous avons configurée précédemment. Jetez un coup d’œil à la syntaxe de commande suivante :
```
./easyrsa gen-req linuxconfig-server nopass
```
Ici, nous passons l’option gen-req au script easyrsa. Ensuite, nous passons un nom pour notre serveur VPN, qui sera linuxconfig-server. Enfin, l’option nopass supprimera la protection par mot de passe sur le fichier de demande, ce qui simplifie l’ensemble du processus.
Nous devons maintenant copier la clé privée du serveur VPN dans le répertoire OpenVPN. Le résultat de la commande précédente doit vous indiquer le chemin complet vers votre clé privée. Dans notre cas, la commande suivante est utilisée :
```
sudo cp ~/easy-rsa/pki/private/linuxconfig-server.key /etc/openvpn/server/
```
Vous devrez remplacer linuxconfig-server.key par le nom de votre propre clé privée.
L’étape suivante consiste à transférer le CSR sur le serveur de l’autorité de certification pour qu’il soit signé. Vous pouvez transférer le fichier comme vous le souhaitez, par exemple avec la commande scp.
```
scp ~/easy-rsa/pki/reqs/linuxconfig-server.req linuxconfig@ca_server:/tmp
```
Passons maintenant au serveur CA. Maintenant que le fichier .req est transféré sur le serveur de l’autorité de certification, nous allons l’importer puis signer la demande :
```
cd ~/easy-rsa
./easyrsa import-req /tmp/linuxconfig-server.req linuxconfig-server
./easyrsa sign-req server linuxconfig-server
```
Assurez-vous de substituer vos propres noms usuels si nécessaire. Le nôtre est simplement linuxconfig-server. Vous serez également invité à saisir le mot de passe que nous avons configuré précédemment sur le serveur de l’autorité de certification.
Nous devons maintenant transférer les fichiers ca.key et linuxconfig-server.crt du serveur CA vers le serveur VPN. Pour ce faire, utilisez scp ou la méthode de votre choix :
```
scp ~/easy-rsa/pki/issued/linuxconfig-server.crt linuxconfig@vpn_server:/tmp
scp ~/easy-rsa/pki/ca.crt linuxconfig@vpn_server:/tmp
```
Revenons au serveur VPN maintenant. Sur le serveur VPN, sortez les fichiers du répertoire /tmp que nous venons de transférer et placez-les dans le répertoire /etc/openvpn/server. Vous aurez besoin des autorisations root pour les déplacer :
```
sudo mv /tmp/{linuxconfig-server.crt,ca.crt} /etc/openvpn/server
```
Comme dernière mesure de sécurité, nous pouvons générer une clé pré-partagée tls-crypt. Cela renforce la sécurité du serveur OpenVPN et facilite le traitement du trafic entrant.
```
cd ~/easy-rsa
openvpn --genkey secret ta.key
```
Copiez le fichier ta.key généré dans le répertoire /etc/openvpn/server/ :
```
sudo cp ta.key /etc/openvpn/server
```

Nous sommes maintenant prêts à passer à la génération de certificats et de clés pour chaque client qui se connectera au VPN.

Générer des certificats et des clés pour les clients

Ces étapes seront effectuées sur le serveur VPN, jusqu’à ce que nous passions finalement au serveur CA, ce qui sera clairement indiqué. Vous devrez répéter ces étapes pour chaque client VPN. C’est là que certains scripts Bash peuvent s’avérer utiles, au cas où vous souhaiteriez aider à automatiser le processus à l’avenir.

Tout d’abord, créons un répertoire dans lequel nous allons stocker les clés pour les clients.
```
mkdir ~/client-keys
```
Accédez au répertoire Easy-RSA, puis utilisez le script easyrsa pour générer une demande pour un client. Dans cet exemple, notre client sera nommé linuxconfig-client. Changez le vôtre au besoin :
```
cd ~/easy-rsa
./easyrsa gen-req linuxconfig-client nopass
```
Copiez le fichier linuxconfig-client.key nouvellement créé dans le répertoire ~/client-keys que nous avons créé précédemment :
```
cp ~/easy-rsa/pki/private/linuxconfig-client.key ~/client-keys
```
Nous devrons également transférer le fichier linuxconfig-client.req sur le serveur de l’autorité de certification pour qu’il soit signé. Utilisez scp ou une autre méthode pour le faire :
```
scp ~/easy-rsa/pki/reqs/linuxconfig-client.req linuxconfig@ca_server:/tmp
```
Passons maintenant au serveur CA. Importez et signez la demande de certificat pour le client VPN sur le serveur de l’autorité de certification :
```
cd ~/easy-rsa
./easyrsa import-req /tmp/linuxconfig-client.req linuxconfig-client
./easyrsa sign-req client linuxconfig-client
```
Vous serez invité à entrer le mot de passe de l’autorité de certification configuré dans les étapes précédentes. Tout cela devrait vous sembler familier, car le processus est à peu près le même que lorsque nous avons signé le CSR pour le serveur VPN.

Transférons le fichier linuxconfig-client.crt vers le serveur VPN :


scp ~/easy-rsa/pki/issued/linuxconfig-client.crt linuxconfig@vpn_server:/tmp

Revenons au serveur VPN maintenant. Sur le serveur VPN, copiez le fichier linuxconfig-client.crt dans le répertoire que nous avons créé précédemment, ~/client-keys :
```
cp /tmp/linuxconfig-client.crt ~/client-keys
```
Nous devrons également copier les fichiers ta.key et ca.crt dans ce répertoire :
```
cp ~/easy-rsa/ta.key ~/client-keys
sudo cp /etc/openvpn/server/ca.crt ~/client-keys
```

Configuration d’OpenVPN

OpenVPN dispose de divers fichiers d’exemple qui peuvent être utilisés pour obtenir un coup de pouce avec vos propres configurations de serveur VPN. Nous allons utiliser l’un de ces fichiers et commencer à le personnaliser selon nos besoins. Vous pouvez également appliquer vos propres personnalisations en cours de route, mais certaines des suggestions ci-dessous seront nécessaires pour fonctionner avec la configuration précédente que nous avons configurée.

Notez que les étapes suivantes doivent être effectuées sur le serveur VPN.

Nous allons commencer par prendre le fichier d’exemple server.conf de la documentation d’OpenVPN et le copier dans le répertoire /etc/openvpn/server.
```
sudo cp /usr/share/doc/openvpn/examples/sample-config-files/server.conf /etc/openvpn/server/
```
Ouvrez le fichier nouvellement copié pour commencer à le modifier :
```
sudo nano /etc/openvpn/server/server.conf
```
Nous devrons configurer ce fichier pour utiliser le certificat TLS que nous avons créé précédemment. Localisez la ligne suivante et commentez-la en ajoutant un caractère ; devant celle-ci :
```
tls-auth ta.key 0 # This file is secret
```
En dessous, ajoutez la ligne suivante :
```
tls-crypt ta.key
```
Le résultat final devrait ressembler à :
```
;tls-auth ta.key 0 # This file is secret
tls-crypt ta.key
```
Ensuite, localisez la ligne de chiffrement suivante et commentez-la :
```
cipher AES-256-CBC
```
Juste en dessous, ajoutez les deux lignes suivantes :
```
cipher AES-256-GCM
auth SHA256
```
Le résultat final devrait ressembler à :
```
;cipher AES-256-CBC
cipher AES-256-GCM
auth SHA256
```
Cela forcera notre connexion VPN à utiliser un meilleur cryptage que la configuration par défaut.
Comme nous avons configuré notre serveur VPN pour utiliser ECC (Elliptic Curve Cryptography) au lieu de DH (Diffie-Hellman), nous devrons localiser la ligne dh suivante et la commenter :
```
dh dh2048.pem
```
Juste en dessous, ajoutez la ligne suivante :
```
dh none
```
Le résultat final devrait ressembler à ceci :
```
;dh dh2048.pem
dh none
```
Pour réduire les privilèges du démon OpenVPN lors de son initialisation, et donc réduire sa surface d’attaque potentielle, recherchez et décommentez les lignes suivantes :
```
;user nobody
;group nobody
```
Retirez le ; devant eux, de sorte qu’il se lise :
```
user nobody
group nobody
```
Si vous souhaitez rediriger tout le trafic client via le VPN, vous pouvez localiser la ligne suivante et la décommenter :
```
;push "redirect-gateway def1 bypass-dhcp"
```
Assurez-vous de supprimer le ; pour le décommenter.
Ce n’est pas strictement nécessaire, mais c’est le comportement que la plupart des VPN utilisent, c’est donc ce à quoi les clients s’attendent.
Décommentez les lignes suivantes qui donnent aux clients VPN des serveurs DNS à utiliser pour la résolution de noms. Il s’agit des adresses IP des serveurs OpenDNS, mais vous pouvez mettre toutes les adresses IP de serveur DNS que vous souhaitez :
```
;push "dhcp-option DNS 208.67.222.222"
;push "dhcp-option DNS 208.67.220.220"
```
Assurez-vous de supprimer les deux caractères ; précédents pour décommenter ces lignes.
Enfin, repérez les lignes suivantes :
```
cert server.crt
key server.key
```
Nous devrons les modifier pour qu’ils pointent vers les fichiers que nous avons générés précédemment. Dans notre exemple, nous avons utilisé linuxconfig-server comme nom commun, nous allons donc le changer en :
```
cert linuxconfig-server.crt
key linuxconfig-server.key
```

Tout est prêt, alors enregistrez vos modifications dans ce fichier et quittez-le.

Configurer la redirection IP

Sur le serveur OpenVPN, nous devrons modifier le paramètre du noyau de redirection IP afin de nous assurer que les clients VPN peuvent transmettre les requêtes au serveur OpenVPN, qui peut ensuite les rediriger vers une destination finale.

Modifiez le fichier suivant avec les autorisations root :
```
sudo nano /etc/sysctl.conf
```
Au bas du fichier, ajoutez la ligne suivante :
```
net.ipv4.ip_forward = 1
```
Enregistrez vos modifications et quittez le fichier.
Ensuite, pour que les modifications prennent effet, exécutez :
```
sudo sysctl -p
```

Démarrer le service OpenVPN

Maintenant qu’OpenVPN a été configuré, nous pouvons démarrer le service.

La commande suivante démarrera le service OpenVPN :


sudo systemctl start openvpn-server@server.service

Si vous souhaitez qu’OpenVPN démarre automatiquement chaque fois que le serveur s’allume, nous pouvons utiliser systemctl enable comme suit :


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

Pour vérifier l’état du service à tout moment, utilisez la commande suivante :


systemctl status openvpn.service

Création d’un fichier de configuration client

La dernière étape consiste à créer un fichier de configuration pour votre client VPN. Ce fichier, ainsi que les fichiers .crt et les fichiers .key, peuvent ensuite être envoyés aux clients VPN afin d’établir une connexion avec le serveur VPN.

Tout d’abord, copiez le fichier d’exemple client.conf dans le répertoire ~/client-keys que nous avons créé précédemment :
```
cp /usr/share/doc/openvpn/examples/sample-config-files/client.conf ~/client-keysclient.conf
```
Il ne s’agit que d’un fichier modèle et nous devrons y apporter plusieurs modifications. Ouvrez le fichier pour commencer à le modifier :
```
nano ~/client-keys/client.conf
```
Localisez la ligne suivante :
```
remote my-server-1 1194
```
C’est ici que nous devons spécifier l’adresse IP de notre serveur VPN. Le 1194 n’est que le port sur lequel OpenVPN fonctionne, donc ne changez cette partie que si nécessaire. Remplacez my-server-1 par l’adresse IP de votre serveur OpenVPN.
Comme nous l’avons fait dans le fichier de configuration du serveur, décommentez les deux lignes suivantes :
```
;user nobody
;group nobody
```
Localisez les lignes suivantes et commentez-les :
```
ca ca.crt
cert client.crt
key client.key
```
Ceux-ci ne seront pas pertinents pour nous, puisque nous allons utiliser la configuration en ligne.
Localisez la ligne suivante et commentez-la :
```
tls-auth ta.key 1
```
Il s’agit d’une ligne non pertinente et nous utiliserons de toute façon une configuration en ligne.
Localisez la ligne suivante et commentez-la :
```
cipher AES-256-CBC
```
Remplacez-le par les deux lignes suivantes :
```
cipher AES-256-GCM
auth SHA256
```
Le résultat final devient :
```
;cipher AES-256-CBC
cipher AES-256-GCM
auth SHA256
```
Au bas de ce fichier, ajoutez la ligne suivante :
```
key-direction 1
```
Enregistrez et fermez le fichier lorsque vous avez terminé.

Nous allons maintenant combiner tous ces certificats, fichiers de configuration et fichiers de clé en un seul fichier .ovpn qui peut être envoyé au client pour une connexion facile.


cd ~/client-keys
cat client.conf > linuxconfig-client.ovpn
echo '<CA>' >> linuxconfig-client.ovpn
cat ca.crt >> linuxconfig-client.ovpn
echo '</CA>' >> linuxconfig-client.ovpn
echo '<cert>' >> linuxconfig-client.ovpn
cat linuxconfig-client.crt >> linuxconfig-client.ovpn
echo '</cert>' >> linuxconfig-client.ovpn
echo '<key>' >> linuxconfig-client.ovpn
cat linuxconfig-client.key >> linuxconfig-client.ovpn
echo '</key>' >> linuxconfig-client.ovpn
echo '<tls-crypt>' >> linuxconfig-client.ovpn
cat ta.key >> linuxconfig-client.ovpn
echo '</tls-crypt>'

C’est un peu lourd à faire, surtout à grande échelle, c’est pourquoi certains scripts Bash sont recommandés si vous prévoyez de le faire souvent. Quoi qu’il en soit, le résultat final est un fichier linuxconfig-client.ovpn complet qui peut être envoyé au client OpenVPN.

Se connecter au serveur OpenVPN

La connexion au serveur VPN est la partie la plus simple. Une fois que vous avez reçu tous les fichiers générés sur le serveur OpenVPN, utilisez la syntaxe de commande suivante pour vous connecter :


sudo openvpn --config linuxconfig-client.ovpn

Les instructions varient bien sûr selon les différents systèmes d’exploitation comme MacOS et Windows, mais le processus est essentiellement le même : il suffit de fournir le fichier .ovpn au programme client OpenVPN.

Réflexions finales

Dans ce tutoriel, nous avons vu comment configurer un serveur OpenVPN sur un système Linux. Cela comprenait également la configuration d’un serveur d’autorité de certification distinct à l’aide d’Easy-RSA. Le processus est assez long, mais nous permet d’auto-héberger un serveur VPN avec les meilleures mesures de sécurité. Vous savez maintenant comment générer des paires de clés et des configurations pour les futures connexions clientes et vous pouvez les distribuer sous la forme de fichiers .opvn.