This is an old revision of the document!

OpenVPN

OpenVPN est un logiciel libre multi-plateforme permettant de créer un VPN.

Ce mode opératoire décrit l'installation d'OpenVPN qui permet de mettre en place un tunnel chiffré entre un client Windows et un serveur dd-wrt.

Avant de commencer il faut savoir qu'il existe 2 types de tunnels :

tunnel bridgé à notre LAN = il obtient une adresse dans le réseau grâce à une interface tap (c'est un pont réseau).
tunnel routé on utilise une interface tun qui défini son réseau propre ; le lien entre notre LAN et le tunnel se fera en routant les paquets.

Et 2 types d'authentification :

par pre-shared key (clé partagée) : ne permet qu'un seul client simultané, l'unique clé est connue à l'avance par le client et le serveur.
par certificat : plus long à mettre en place, l'authentification se fait par échange de certificat + vérification mutuelle de la validité de ce dernier. On utilise un CA (autorité de certification) pour valider les certificats des protagonistes. Dans ce cas chacun (le CA, le serveur et chaque client) doit avoir une paire de c.. clés : une publique et une privée.

On peut spécifier un fichier de conf avec l'option –config <fichier>. Les paramètres du fichier de conf peuvent être fournis en ligne de commande en les préfixant par –.

Tunnel bridgé

Générer la clé partagée

Sur le serveur :

openvpn --genkey --secret /tmp/static.key

Cette clé devra être communiquée au client.

Config serveur

Créer l'interface virtuelle,

openvpn --mktun --dev tap0

L'attacher au switch

brctl addif br0 tap0
ifconfig tap0 0.0.0.0 promisc up

Créer un lien symbolique vers l'exécutable :

ln -s /usr/sbin/openvpn /tmp/myvpn

Ouvrir le port tcp/1194

iptables -I INPUT 1 -p tcp --dport 1194 -j ACCEPT

Lancer le serveur

/tmp/myvpn --dev tap0 --secret /tmp/static.key --comp-lzo --port 1194 --proto tcp-server --verb 3 --daemon

Config client

Mon client est sous Windows, le fichier de conf ainsi que la pre-shared key générée sur le serveur sont situés dans C:\Program Files\OpenVPN\config.

client.ovpn

remote XXXX.dyndns.org
port 1194
dev tap
secret static.key
proto tcp-client
comp-lzo

Tunnel routé

Générer les certificats

La première chose pour utiliser l'authentification par certificat est de générer la paire de clés de l'autorité de certification. Ces clés seront utilisées pour certifier l'authenticité (signer) des clés publiques du serveur et des clients. Dans notre cas nous allons auto-signer les certificats sur le serveur, ui aura donc une double casquette : serveur VPN + CA.

Nous allons voir comment générer des certificats sous Ubuntu, puis nous les importerons sous DD-WRT. Les manips qui vont suivre se font en root.

OpenVPN contient des outils permettant de générer facilement des couples de clés. Ils sont situés dans le répertoire /usr/share/doc/openvpn/examples/easy-rsa ; il est conseillé de le copier dans un autre endroit, /etc/openvpn/easy-rsa par exemple, afin qu'une éventuelle future mise à jour du paquet n'efface pas tout ce que nous allons faire.

cp -R /usr/share/doc/openvpn/examples/easy-rsa /etc/openvpn/easy-rsa
cd /etc/openvpn/easy-rsa

CA

Editer le fichier vars et remplir les champs KEY_COUNTRY, KEY_PROVINCE, KEY_CITY, KEY_ORG, et KEY_EMAIL (il parait qu'il vaut mieux éviter les espaces). Puis :

./vars
./clean-all
./build-ca

Si vars n'est pas exécutable :

chmod +x vars

Si vous obtenez cette sortie en lançant build-ca :

./build-ca
req [options] <infile >outfile
where options  are

.. c'est que les variables du fichier vars n'ont pas été ajoutées dans l'environnement ; dans ce cas il faut les renseigner et les passer à la main dans le terminal :

export KEY_CONFIG=/etc/openvpn/easy-rsa/openssl.cnf
export KEY_DIR=/etc/openvpn/easy-rsa/keys
export KEY_SIZE=1024

export KEY_COUNTRY=FR
export KEY_PROVINCE=NA
export KEY_CITY=PARIS
export KEY_ORG="pt3us corp"
export KEY_EMAIL="me@myhost.mydomain"

Finalement si ça marche on obtient cette sortie :

./build-ca
Generating a 1024 bit RSA private key
..................................++++++
...........++++++
writing new private key to 'ca.key'
-----
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [FR]:
State or Province Name (full name) [NA]:
Locality Name (eg, city) [PARIS]:
Organization Name (eg, company) [pt3u corp]:
Organizational Unit Name (eg, section) []:
Common Name (eg, your name or your server's hostname) []:odin
Email Address [me@myhost.mydomain]:

.. suivi de prompt qui utiliseront les variables d'environnement précédemment enregistrées. Seul Common Name (eg, your name or your server's hostname) []: ne l'est pas ET DOIT être renseigné avec l'identifiant de la machine.

Serveur et client

On procède presque de la même façon pour générer les certificats du serveur et des clients :

./build-key-server server
./build-key client1

A chaque clé un prompt vous demande s'il faut signer les clés avec le CA ; il faut dire oui (“y”) !

Certificate is to be certified until Mar 15 18:25:51 2018 GMT (3650 days)
Sign the certificate? [y/n]:y


1 out of 1 certificate requests certified, commit? [y/n]y

Au final toutes les clés générées sont situées dans le répertoire keys/ :

server.key est la clé privée du serveur
server.crt est le certificat (= public) du serveur

Diffie Hellman

Maintenant il faut générer les paramètres Diffie Hellman :

./build-dh
 Generating DH parameters, 1024 bit long safe prime, generator 2
 This is going to take a long time
 .......+......................................................+.................
 .................+.........+.+....+...................+.++*++*++*

Fichiers générés

Les fichiers que l'on a générés :

ls keys/
01.pem  ca.key      dude.csr   index.txt.attr      serial      server.csr
02.pem  dh1024.pem  dude.key   index.txt.attr.old  serial.old  server.key
ca.crt  dude.crt    index.txt  index.txt.old       server.crt

les .key sont les clés privées donc secrètes
les .crt sont les certificats, publics
dh1024.pem c'est les paramètres Diffie Hellman (algo de chiffrement)

config serveur

Créer l'interface tunnel

/tmp/myvpn --mktun --dev tun0
ifconfig tun0 192.168.3.1 netmask 255.255.255.252 promisc up

Ouvrir le port tcp/1194 et activer le routage entre br0 et tun0

iptables -I INPUT 1 -p tcp --dport 1194 -j ACCEPT
iptables -I FORWARD -i br0 -o tun0 -j ACCEPT
iptables -I FORWARD -i tun0 -o br0 -j ACCEPT

Le fichier de conf, par exemple /tmp/server.ovpn :

#
# Partie commune aux tunnels Bridgés/routés
#
dev tun0
comp-lzo
port 1194
proto tcp-server
verb 3
daemon
# ping toutes les 15s ; considéré down au bout de 60s
keepalive 15 60
persist-key
persist-tun

#
# si on utilise une clé partagée
#
secret /tmp/static.key

#
# si on utilise des certificats
#
tls-server
ca /tmp/openvpn/ca.crt
dh /tmp/openvpn/dh1024.pem
cert /tmp/openvpn/server.crt
key /tmp/openvpn/server.key

server 192.168.3.0 255.255.255.0
client-to-client
max-clients 3

Lancer le serveur

/tmp/myvpn --config /tmp/server.ovpn

config client

# IP/port du serveur distant
client
remote <IP_DU_SERVEUR> 1194
dev tun
proto tcp-client

# compression
comp-lzo
persist-key
persist-tun
pull

# pre-shared key
# secret static.key

# TLS
tls-client
ca ca.crt
cert dude.crt
key dude.key

Conf avancée

On peut spécifier une conf par certificat en modifiant ainsi la conf du serveur:

# indique ou sont situes les fichiers
client-config-dir /tmp/openvpn/ccd
#ccd-exclusive

client-config-dir indique le répertoire contenant les fichiers nommés <common name> : le serveur utilisera le fichier idoine en récupérant ce champ dans le certificat du client. Par exemple pour configurer le client toto on créera un fichier /tmp/openvpn/ccd/toto. Ce dernier pourra contenir, par exemple :

ifconfig-push 192.168.3.10 192.168.3.9
push "route 192.168.2.0 255.255.255.0"

De cette façon on attribue au client toto l'IP 192.168.3.10 ; sa gateway (l'autre bout du tunnel) sera 192.168.3.9 (réseau 192.168.2.8/30) ; et on lui annoncera le réseau 192.168.2.0/24, atteingnable par VPN.

ccd-exclusive refuse les clients qui n'ont pas de fichier à leur nom dans le répertoire /tmp/openvpn/ccd.

Le driver TAP sous Windows impose l'utilisation d'un adressage en /30 (255.255.255.252) car c'est du point-à-point (2 IPs utilisables). Ainsi on ne peut utiliser les couples d'IPs suivantes (serveur/client) : (192.168.0.5,192.168.0.6), (9,10), (13,14), (17,18), etc… Sachant que DD-WRT ne permet par d'utiliser la première plage d'adresse, la 192.168.0.0/30 (de .0 à .3).

Explications :

créer une interco = un réseau /30 (255.255.255.252, 2 IPs possibles) avec une IP pour le serveur et une pour le client car le tunnel est point à point.

On peut couper la connexion si inactivité du client avec l'option –ping-restart <time>

Conf qui marche

C'est un tunnel TLS routé. Les fichiers sont les suivants :

exécutable (lien symbolique myvpn → /usr/sbin/openvpn) /tmp/openvpn/myvpn
fichier de conf du server : /tmp/openvpn/server.ovpn
certificat de l'autorité de certification : /tmp/openvpn/ca.crt
paramètres de chiffrement Diffie Hellman : /tmp/openvpn/dh1024.pem
certificat du serveur : /tmp/openvpn/server.crt
clé privée du serveur : /tmp/openvpn/server.key
paramètres spéciaux pour l'utilisateur dude : /tmp/openvpn/ccd/dude

Le serveur écoute en tcp/1165 et accepte jusqu'à 3 clients simultanés. Les fichiers définissant paramètres particuliers sont dans /tmp/openvpn/ccd ; c'est le cas pour l'utilisateur dude. La plage d'adresse du tunnel est 192.168.3.0/24 ; le serveur est le .1 ; dude est le .10.

Serveur DD-WRT

server.ovpn

mode server
proto tcp-server
port 1165
dev tun0
daemon
verb 3
comp-lzo

server 192.168.3.0 255.255.255.0

client-config-dir /tmp/openvpn/ccd
#ccd-exclusive
client-to-client
max-clients 3

keepalive 15 60
persist-key
persist-tun

# TLS
tls-server
ca /tmp/openvpn/ca.crt
dh /tmp/openvpn/dh1024.pem
cert /tmp/openvpn/server.crt
key /tmp/openvpn/server.key

/tmp/openvpn/ccd/dude

ifconfig-push 192.168.3.10 192.168.3.9
push "route 192.168.2.0 255.255.255.0"

Client Windows