OpenVPN sous OpenBSD

Services Réseaux

Les algorithmes de chiffrement asymétrique sont basés sur le partage entre les différents utilisateurs d'une clé publique.
Généralement le partage de cette clé se fait au travers d'un annuaire électronique (généralement au format LDAP)¹⁾ (Lightweight Directory Access Protocol) ou bien d'un site web.

Toutefois ce mode de partage a une grande lacune : rien ne garantit que la clé est bien celle de l'utilisateur a qui elle est associée.
En effet un pirate peut corrompre la clé publique présente dans l'annuaire en la remplaçant par sa clé publique.
Ainsi, le pirate sera en mesure de déchiffrer tous les messages ayant été chiffrés avec la clé présente dans l'annuaire.

Ainsi un certificat permet d'associer une clé publique à une entité (une personne, une machine, …) afin d'en assurer la validité.
Le certificat est en quelque sorte la carte d'identité de la clé publique, délivré par un organisme appelé autorité de certification (souvent notée CA pour Certification Authority).

Les certificats sont des petits fichiers divisés en deux parties :

• La partie contenant les informations
• La partie contenant la signature de l'autorité de certification

La structure des certificats est normalisée par le standard X.509 de l'UIT (Union Internationale des Télécommunications) (plus exactement X.509v3 est une norme spécifiant les formats pour les certificats à clé publique, les listes de révocation de certificat, les attributs de certificat, et un algorithme de validation du chemin de certification, définie par l'Union internationale des télécommunications (UIT) ²⁾), qui définit les informations contenues dans le certificat :

• La version de X.509 à laquelle le certificat correspond
• Le numéro de série du certificat
• L'algorithme de chiffrement utilisé pour signer le certificat
• Le nom (DN, pour Distinguished Name) de l'autorité de certification émettrice
• La date de début de validité du certificat
• La date de fin de validité du certificat
• L'objet de l'utilisation de la clé publique
• La clé publique du propriétaire du certificat
• La signature de l'émetteur du certificat (thumbprint)

L'ensemble de ces informations (informations + clé publique du demandeur) est signé par l'autorité de certification, cela signifie qu'une fonction de hachage ³⁾ crée une empreinte de ces informations, puis ce condensé est chiffré à l'aide de la clé privée de l'autorité de certification; la clé publique ayant été préalablement largement diffusée afin de permettre aux utilisateurs de vérifier la signature avec la clé publique de l'autorité de certification.

Lorsqu'un utilisateur désire communiquer avec une autre personne, il lui suffit de se procurer le certificat du destinataire. Ce certificat contient le nom du destinataire, ainsi que sa clé publique et est signé par l'autorité de certification.

Il est donc possible de vérifier la validité du message en appliquant d'une part la fonction de hachage aux informations contenues dans le certificat, en déchiffrant d'autre part la signature de l'autorité de certification avec la clé publique de cette dernière et en comparant ces deux résultats.

On distingue différents types de certificats selon le niveau de signature :

• Les certificats auto-signés sont des certificats à usage interne.

Signés par un serveur local, ce type de certificat permet de garantir la confidentialité des échanges au sein d'une organisation, par exemple pour le besoin d'un intranet. Il est ainsi possible d'effectuer une authentification des utilisateurs grâce à des certificats auto-signés.

Les certificats signés par un organisme de certification sont

nécessaires lorsqu'il s'agit d'assurer la sécurité des échanges avec des utilisateurs anonymes, par exemple dans le cas d'un site web sécurisé accessible au grand public. Le certificateur tiers permet d'assurer à l'utilisateur que le certificat appartient bien à l'organisation à laquelle il est déclaré appartenir.

Les certificats servent principalement dans trois types de contextes :

• Le certificat client, stocké sur le poste de travail de l'utilisateur

ou embarqué dans un conteneur tel qu'une carte à puce, permet d'identifier un utilisateur et de lui associer des droits. Dans la plupart des scénarios il est transmis au serveur lors d'une connexion, qui affecte des droits en fonction de l'accréditation de l'utilisateur. Il s'agit d'une véritable carte d'identité numérique utilisant une paire de clé asymétrique d'une longueur de 512 à 1024 bits. Le certificat serveur installé sur un serveur web permet d'assurer le lien

entre le service et le propriétaire du service. Dans le cas d'un site web, il permet de garantir que l'URL et en particulier le domaine de la page web appartiennent bien à telle ou telle entreprise. Par ailleurs il permet de sécuriser les transactions avec les utilisateurs grâce au protocole SSL.

• Le certificat VPN est un type de certificat installé dans les équipement

réseaux, permettant de chiffrer les flux de communication de bout en bout entre deux points (par exemple deux sites d'une entreprise). Dans ce type de scénario, les utilisateurs possèdent un certificat client, les serveurs mettent en oeuvre un certificat serveur et les équipements de communication utilisent un certificat particulier (généralement un certificat IPSec.

Transport Layer Security (TLS) ou Sécurité de la couche de transport, et son prédécesseur Secure Sockets Layer (SSL), sont des protocoles de sécurisation des échanges sur Internet. Le protocole SSL a été développé à l'origine par Netscape. L'IETF en a poursuivi le développement en le rebaptisant Transport Layer Security (TLS). On parle parfois de SSL/TLS pour désigner indifféremment SSL ou TLS.

TLS (ou SSL) fonctionne suivant un mode client-serveur.

Il permet de satisfaire aux objectifs de sécurité suivants :

• l'authentification du serveur
• la confidentialité des données échangées (ou session chiffrée)
• l'intégrité des données échangées
• de manière optionnelle, l'authentification du client (mais dans la réalité celle-ci est souvent assurée par le serveur)

En bref - il est nécessaire de créer:

• certificat CA pour(Certification Authority) racine et clé privée
• un certificat et une clé privée pour le serveur OpenVPN
• fichiers de configuration
• d'autres fichiers comme dh, ta
• un certificat séparé et une clé privée pour chaque client qui se connectera au VPN

pkg_add openvpn
install -m 700 -d /etc/openvpn/private 
install -m 700 -d /etc/openvpn/private-client-conf 
install -m 755 -d /etc/openvpn/certs 
install -m 755 -d /var/log/openvpn 

Préparer des répertoires et des liens symboliques permettant d'exécuter openvpn chrooté ou non-chrootisé. Certains fichiers doivent être situés dans le répertoire de la prison chroot et /etc/openvpn devrait avoir des liens symboliques vers eux (ainsi vous pouvez exécuter chroot ou non et il ouvrira les mêmes fichiers) :

install -m 755 -d /var/openvpn/chrootjail/etc/openvpn
install -m 755 -d /etc/openvpn/chrootjail/etc/openvpn/ccd  # client custom configuration dir
install -m 755 -d /var/openvpn/chrootjail/var/openvpn
mv /etc/openvpn/ccd/ /etc/openvpn/crl.pem /var/openvpn/chrootjail/etc/openvpn/
ln -s /var/openvpn/chrootjail/etc/openvpn/crl.pem /etc/openvpn/crl.pem
ln -s /var/openvpn/chrootjail/etc/openvpn/ccd/ /etc/openvpn/
ln -s /var/openvpn/chrootjail/etc/openvpn/replay-persist-file /etc/openvpn/replay-persist-file
 
ls -alpd /etc/openvpn/certs /etc/openvpn/ccd /var/openvpn/chrootjail /var/openvpn/chrootjail/etc /var/openvpn/chrootjail/etc/openvpn /etc/openvpn/private /etc/openvpn/private-client-conf /var/log/openvpn

La sortie sera:

lrwxr-xr-x  1 root  bin     40 Nov 30 09:52 /etc/openvpn/ccd -> /var/openvpn/chrootjail/etc/openvpn/ccd/
drwxr-xr-x  2 root  wheel  512 Nov 23 11:51 /etc/openvpn/certs/
drwx------  2 root  wheel  512 Nov 23 11:50 /etc/openvpn/private/
drwx------  2 root  bin    512 Nov 25 20:55 /etc/openvpn/private-client-conf/
drwxr-xr-x  2 root  wheel  512 Mar  4  2013 /var/log/openvpn/
drwxr-xr-x  4 root  wheel  512 Nov 30 09:51 /var/openvpn/chrootjail/
drwxr-xr-x  3 root  wheel  512 Nov 30 09:46 /var/openvpn/chrootjail/etc/
drwxr-xr-x  3 root  wheel  512 Nov 30 09:25 /var/openvpn/chrootjail/etc/openvpn/

pkg_add easy-rsa 
cd /usr/local/share/easy-rsa/ 
ls -alpd easyrsa vars* 
less vars.example 

Passez en revue le vars.example, mais les valeurs par défaut devraient être correctes.
Assurez-vous que la durée de vie de l'autorité de certification, du certificat et de la liste de révocation de certificats est définie sur au moins 10 ans (sauf si vous souhaitez les régénérer plus souvent):

  #set_var EASYRSA_CA_EXPIRE 3650 #set_var EASYRSA_CERT_EXPIRE 3650 #set_var EASYRSA_CRL_DAYS 3650 

S'il est nécessaire de changer les paramètres - alors créez le fichier vars:

if [ -f /usr/local/share/easy-rsa/vars ]; then 
  echo "File already exists - verify: /usr/local/share/easy-rsa/vars"; 
  cat /usr/local/share/easy-rsa/vars; 
else 
  printf "set_var EASYRSA_CA_EXPIRE   3650\nset_var EASYRSA_CERT_EXPIRE   3650\nset_var EASYRSA_CRL_DAYS  
3650" > /usr/local/share/easy-rsa/vars;
  cat /usr/local/share/easy-rsa/vars;
fi

pkiDir="/etc/openvpn/easy-rsa-pki/" 
mkdir ${pkiDir} 
easyrsaDir="/usr/local/share/easy-rsa/" 
cd ${easyrsaDir} 

ls -alp /etc/openvpn/private/vpn-ta.key || openvpn --genkey --secret /etc/openvpn/private/vpn-ta.key 

./easyrsa --batch=0 --pki-dir=${pkiDir} init-pki # creates empty dirs ${pkiDir}/ ${pkiDir}/private/ 
${pkiDir}/reqs/ . batch=1 - overwrite/delete without asking
ls -alpd ${pkiDir} ${pkiDir}/*

./easyrsa --batch=1 --pki-dir=${pkiDir} gen-dh 
ls -alpd ${pkiDir}/dh.pem 

./easyrsa --batch=1 --pki-dir=${pkiDir} --req-cn=vpn-ca build-ca nopass
ls -alpd ${pkiDir}/ca.crt ${pkiDir}/private/ca.key ${pkiDir}/index.txt ${pkiDir}/serial
openssl x509 -in ${pkiDir}/ca.crt -text -noout
openssl rsa -in ${pkiDir}/private/ca.key -check -noout

alternativement - admin vpnserver fait ./easyrsa gen-req _UNIQUE_SERVER_SHORT_NAME_ et envoie le .req à CA juste pour signer / accepter.

./easyrsa --batch=1 --pki-dir=${pkiDir} --req-cn=vpnserver gen-req vpnserver nopass
ls -alpd ${pkiDir}/reqs/vpnserver.req ${pkiDir}/private/vpnserver.key
openssl req -in ${pkiDir}/reqs/vpnserver.req -text -noout
openssl rsa -in ${pkiDir}/private/vpnserver.key -check -noout

./easyrsa --batch=1 --pki-dir=${pkiDir} show-req vpnserver
./easyrsa --batch=1 --pki-dir=${pkiDir} sign server vpnserver # server - only for server
ls -alpd ${pkiDir}/issued/vpnserver.crt ${pkiDir}/certs_by_serial/01.pem 
openssl x509 -in ${pkiDir}/issued/vpnserver.crt -text -noout
echo "Last added cert in db: `cat ${pkiDir}/index.txt|tail -1`"
echo "Next added cert will have number: `cat ${pkiDir}/serial`"

Les certificats révoqués peuvent être ajoutés ultérieurement.
Initialement créer un fichier sans certificats révoqués.

Ce fichier doit exister, sinon openvpn se plaindra.

./easyrsa --batch=1 --pki-dir=${pkiDir} gen-crl
# make sure openvpn process can read this file - otherwise it will crash
chown :_openvpn ${pkiDir}/crl.pem; chmod g+r ${pkiDir}/crl.pem 
ls -alF ${pkiDir}/crl.pem
openssl crl -in ${pkiDir}/crl.pem -text -noout

cp -p ${pkiDir}/ca.crt /etc/openvpn/certs/vpn-ca.crt
cp -p ${pkiDir}/private/ca.key /etc/openvpn/private/vpn-ca.key
cp -p ${pkiDir}/issued/vpnserver.crt /etc/openvpn/certs/vpnserver.crt
cp -p ${pkiDir}/private/vpnserver.key /etc/openvpn/private/vpnserver.key
cp -p ${pkiDir}/dh.pem /etc/openvpn/dh.pem
cp -p ${pkiDir}/crl.pem /etc/openvpn/crl.pem

openssl x509 -in /etc/openvpn/certs/vpn-ca.crt -text -noout
openssl x509 -in /etc/openvpn/certs/vpnserver.crt -text -noout
openssl crl -in /etc/openvpn/crl.pem -text -noout
openssl rsa -in /etc/openvpn/private/vpn-ca.key -check -noout
openssl rsa -in /etc/openvpn/private/vpnserver.key -check -noout

OpenVpn avait une interface de gestion où l'admin peut se connecter et vérifier l'état, les clients actifs, etc.
C'est une fonctionnalité intéressante, mais la communication est en claire - donc ne la rendre disponible sur le réseau WAN, mais uniquement en interne sur admin localhost. Limitez-le sur le pare-feu.

Ensuite, lorsque openvpn est en cours d'exécution, connectez-vous à ssh sur le serveur openvpn, puis connectez-vous à la console de gestion openvpn à l'aide de telnet localhost 1195.

À l'étape suivante, le mot de passe d'une telle interface sera configuré.

test -f /etc/openvpn/private/mgmt.pwd || touch /etc/openvpn/private/mgmt.pwd
chown root:wheel /etc/openvpn/private/mgmt.pwd; chmod 600 /etc/openvpn/private/mgmt.pwd
vi /etc/openvpn/private/mgmt.pwd  # insert one line of text with clear-text password for management console

Définissez le mot de passe dans ce fichier - insérez une ligne de texte avec un mot de passe en clair pour la console de gestion. Vous pouvez noter le mot de passe en lieu sûr - ou - si vous l'oubliez, regardez dans ce fichier, le mot de passe est stocké en texte clair.

Dans cet exemple, openvpn s'exécutera sur tun0 avec des adresses IP dans la plage 10.8 / 16 et fournira l'accès au réseau local 192.168.0 / 24. Le nom du fichier de configuration du serveur est server_tun0.conf

test -f /etc/openvpn/server_tun0.conf || touch /etc/openvpn/server_tun0.conf
chown root:_openvpn /etc/openvpn/server_tun0.conf; chmod 640 /etc/openvpn/server_tun0.conf
vi /etc/openvpn/server_tun0.conf  # setup OpenVpn server

Editez le fichier de configuration en fonction de vos besoins.
L'exemple d'openvpn / server.conf par défaut contient lui-même des descriptions assez intéressantes.

Vous pouvez utiliser l'exemple décrit ci-dessous pour le réglage des paramètres - cette liste tous les paramètres que j'ai changé.

Vous pouvez l'utiliser en tant que server_tun0.conf - ou éditer votre server_tun0.conf utilisant ci-dessous à titre d'exemple:

  cat /etc/openvpn/server_tun0.conf | grep '^[^#;]' | grep CUSTOMIZED
 
  vi /etc/openvpn/server_tun0.conf
 
  ca /etc/openvpn/certs/vpn-ca.crt
  cert /etc/openvpn/certs/vpnserver.crt
  key /etc/openvpn/private/vpnserver.key
  dh /etc/openvpn/dh.pem
  ifconfig-pool-persist /var/openvpn/ipp.txt  # CUSTOMIZED by adminOfMine # put it to var as it is dynamic file
  tls-auth /etc/openvpn/private/vpn-ta.key 0 # This file is secret
  replay-persist /etc/openvpn/replay-persist-file
  max-clients 100
  status /var/log/openvpn/openvpn-status.log
  log-append  /var/log/openvpn/openvpn.log
  proto tcp  #or use udp if works better
  port 1194
  management 127.0.0.1 1195 /etc/openvpn/private/mgmt.pwd
  daemon openvpn
  chroot /var/openvpn/chrootjail
  crl-verify /etc/openvpn/crl.pem
  float
  persist-key
  persist-tun
 
  #Additional authorization options - needs to be configured - read further before enabling this
  ;auth-user-pass-verify /var/openvpn/custom-simple-auth via-env
  ;script-security 3
 
  # The following options were set by default 
  keepalive 10 120
  comp-lzo
  user _openvpn
  group _openvpn
  verb 3
 
  # If you would prefer to start openvpn directly and NOT via /etc/hostname - then you need to edit and uncomment those parameters
  ;dev tun0  # CUSTOMIZED by admin-of-mine #
  ;server 10.8.0.0 255.255.255.0  # Address range for the tun(4)interfaces
 
  # Add a route to the local network to the client's routing table
  ;push "route 192.168.0.0 255.255.255.0"
 
  # If you want to push DNS server setting to VPN clients - uncomment below and see openvpn documentation for   more info
  ;push "dhcp-option DNS 192.168.0.x"
 
  # If you use samba and want to have wins (windows netbios) name resolution then add WINS (samba nmbd) server IP
  ;push "dhcp-option WINS 192.168.0.x"

L'exemple ci-dessous permet aux clients vpn d'accéder à l'ensemble du réseau interne et donne un accès limité à l'openvpn-host.

Le pf.conf n'est pas complet, il montre juste des exemples d'entrées liées à openvpn.

Ajustez le fichier à votre configuration et vos besoins.
Restreindre les règles si nécessaire.

  log_opt = "log" # Set to ="log" to enable pflog for rulesfiles that use this macro. Setting to ="" will do no logging to pflog

  int_if="em0"
  tun_if="tun0"   # open-vpn interface
  ext_if="re0"    # external connections are forwarded to this interface
  allowIncoming_ifs="{" $int_if $tun_if "}"  # interfaces where (internal) incoming traffic is allowed

  table <myself> const { self }
  table <myBroadcast> const { self:broadcast }
  table <private> const { 10/8, 172.16/12, 192.168/16 }
  table <internet> const {0.0.0.0/0, !10/8, !172.16/12, !192.168/16 }

  vpnNetwork="10.8/16"
  table <vpnNet> const { $vpnNetwork }
  table <allowedIncomingLan> const { self:network $vpnNetwork }
  table <allowedIncomingExternal> const { 0/0 }   # these will be public IPs from the outside

  SpecialAddressReachableViaVpn="192.168.99.xx"
  lan_tcp_services="{ 22, 53, 80, 139, 445, 113, 1194 }"
  lan_udp_services="{ 53, 137:138,  1194 }"

  #... other rules, scrub, antispoof, etc.

## From LAN and VPN  to OPENVPN-SERVER -- INCOMING
 # allow incoming TCP to certain services - including OPENVPN port 1194
  pass  in  quick $log_opt on $allowIncoming_ifs proto tcp from <allowedIncomingLan> to <myself> port $lan_tcp_services  label "incomingToHost"
 # allow incoming UDP to certain services - including OPENVPN port 1194:
  pass  in  quick $log_opt on $allowIncoming_ifs proto udp from <allowedIncomingLan> to <myself> port $lan_udp_services  label "incomingToHost"
  pass  in  quick $log_opt on $allowIncoming_ifs proto udp from <allowedIncomingLan> to <myBroadcast> port { 137:138 }   # netbios name/datagram broadcasts
 # allow incoming ping
  pass  in  quick $log_opt on $allowIncoming_ifs inet proto icmp from { <allowedIncomingLan> } to <myself> icmp-type 8 code 0  label "icmp-in"
 # anything else is explicitly blocked here (so that rules allowing for routing and vpn will not allow what is not wanted)
  # block access to this host - whatever was not matched earlier
  block in  quick $log_opt on $allowIncoming_ifs from { <allowedIncomingLan> } to <myself>


## From LAN (VPN) to LAN  --  TRAVERSING - INBOUND
 # allow VPN access the LAN
 # Note: there is no network defined on $tun_if, so cannot use syntax like: pass ... from ($tun_if:network:0) to ...
  pass  in  quick $log_opt on $tun_if from <vpnNet> to ($int_if:network) label "vpn-in"
  pass  in  quick $log_opt on $tun_if from <vpnNet> to $SpecialAddressReachableViaVpn label "vpn-in-special"


## From OPENVPN-SERVER -- OUTGOING  - and -  From LAN (VPN) to LAN  --  TRAVERSING - OUTBOUND
 # allow and do NAT for VPN - the VPN clients will connect to other hosts in internal network using IP of this host as source IP
 # nat is not needed if the openvpnserver is the default router for all computers on LAN.
  pass  out quick $log_opt on $int_if to ($int_if:network) received-on $tun_if nat-to ($int_if:0) label "vpn-out-to-network"

 # INTERNET -- OUTGOING - allow LAN hosts to reach internet, etc. Do modulate state for tcp.
  ##match out on egress inet from !(egress:network) to any nat-to (egress:0)
  pass  out quick $log_opt on $ext_if from <hostsAllowedToAccessInternet> to <internet> nat-to ($ext_if:0) modulate state label "lan-out-to-internet"
  pass  out quick $log_opt on $tun_if from <vpnNet> to $SpecialAddressReachableViaVpn label "vpn-out-special"


## INTERNET -- INCOMING -- CAREFULLY
 # allow incoming connection from the internet - allow to connect to OPENVPN on UDP and TCP
  pass  in  quick $log_opt on $allowIncomingExternal_ifs proto udp from <allowedIncomingExternal> to <myself> port { 1194 } label "incoming-external:$srcaddr"
  pass  in  quick $log_opt on $allowIncomingExternal_ifs proto tcp from <allowedIncomingExternal> to <myself> port { 1194 } label "incoming-external:$srcaddr"
  block $log_opt

</code>

assurez-vous que le pare-feu est correctement configuré pour bloquer le trafic indésirable

vi /etc/sysctl.conf et activer le transfert ip - changer la ligne correspondante à
net.inet.ip.forwarding=1 

La modification ci-dessus ne sera activée qu'après le redémarrage suivant, donc lancez ip-forwarding également dans le système en cours d'exécution avec la commande:

sysctl net.inet.ip.forwarding=1

Exécuter (ajuster les paramètres si nécessaire):

/usr/local/sbin/openvpn --daemon --config /etc/openvpn/server_tun0.conf --dev tun0 --server 10.8.0.0 255.255.255.0 --push "route 192.168.0.0 255.255.255.0"

Vérifier:

L'interface doit être active et avoir des adresses IP affectées.
Vérifiez le périphérique que vous avez placé dans le fichier de configuration, par exemple tun0

ifconfig tun0

le processus doit être en cours d'exécution

pgrep -fl openvpn.*server

Vérifiez si le processus écoute sur l'interface appropriée (accessible depuis l'extérieur), le protocole approprié (tcp / udp) et le port:

netstat -an|grep '\.1194 ' # put port défini dans server_tun0.conf

Vérifier les journaux

ls -al /var/log/openvpn/*

Si quelque chose ne va pas, essayez avec

/usr/local/sbin/openvpn --daemon --verb 11 --config /etc/openvpn/server_tun0.conf 

et vérifier les journaux.

liste des processus en cours d'exécution:

pgrep -fl openvpn pgrep -xl openvpn

arrêter tous les processus openvpn en cours d'exécution:

pkill -x openvpn

Démarrage VARIANT1: Démarrage via /etc/hostname.*
Démarrage VARIANT2: Démarrage via le script /etc/rc.d/openvpn
Il est recommandé de démarrer openvpn à partir du fichier /etc/hostname.* .
De plus, les adresses IP et autres paramètres réseau sont normalement configurés dans /etc/hostname.* , il serait donc pratique de le configurer ici.
D'un autre côté, il est également pratique d'utiliser des scripts rc pour démarrer et arrêter des composants.

La solution présentée ci-dessous combinera les deux. L'openvpn sera démarré et partiellement configuré à partir de /etc/hostname.* .
Et le script rc peut être utilisé pour démarrer et arrêter openvpn.
Le script rc utilisera les fichiers /etc/hostname.* pour lancer openvpn (s).
Plusieurs openvpns peuvent être démarrés - avec différentes config - en tant que serveur ou client.

Example /etc/hostname.tun for openvpn server
Définissez les tunnels openvpn dans /etc/hostname.*
suivant l'exemple ci-dessous

  vi /etc/hostname.tun0
 
  up
  group openvpn
  description "OpenVPN to local net 192.168.0.x"
  !/usr/local/sbin/openvpn --daemon --config /etc/openvpn/server_$if.conf --dev $if --server 10.8.0.0 
  255.255.255.0 --push "route 192.168.0.0 255.255.255.0" & false
  # If you want to push DNS server setting to VPN clients (see openvpn documentation for more info) then add to 
  openvpn parameters above:
  #   --push "dhcp-option DNS 192.168.0.x"
  # If you use samba and want to have wins (windows netbios) name resolution then add WINS (samba nmbd) server 
  IP the add above also:
  #   --push "dhcp-option WINS 192.168.0.x"
  #
  # WARNING:
  # BOOTING process can be blocked, sshd not started and remote access blocked if this script fails!!!
  # If you change anything in script, test with: sh /etc/netstart tunX;  echo "exitCode=$?"
  # Replace tunX with proper network interface name. Verify that process started.
  # Make sure script runs non-interactively and the exit code is 0. 
  # Otherwise it will interrupt booting process!!!
  # Use '& false' at the end. The '&' prevents interactive data input, eg passwords. 
  # The 'false' command makes sure that no error status code will be returned.
  # do not use exit command in here - or rc booting would be interrupted.
  #
  # You can use variable $if = interface, eg $if=tun0, so you can use --config /etc/openvpn/server_$if.conf
  #
  # The file /etc/openvpn/server_$if.conf must exist
  # If you change binary name or --daemon option in command above - also change matching pattern in 
  /etc/rc.d/openvpn script
  # 
  #
  # In case you need more /dev/tun devices, eg tun4, do: cd /dev && { ./MAKEDEV tun4; cd - ; }
  # For debug - you can add/uncomment command like:
  # !echo "Starting openvpn on $if"
  #

Notez que les options –dev et –server et –push route sont définies directement dans le fichier /etc/hostname, de sorte que la configuration du réseau soit listée dans le fichier hostname.
Il est également possible de déplacer ces options dans openvpn server.conf si vous préférez.

ATTENTION: Il est important d'ajouter || false || false sorte que même si openvpn ne démarre pas, le processus de démarrage continuera. Sans cette commande, en cas d'erreur (par exemple lors de la mise à jour du système lorsque le paquet openvpn a été temporairement désinstallé) - le script rc passerait à la console d'administration pendant le démarrage - bloquant le démarrage de ssh et d'autres réseaux. Et cela pourrait être très mauvais sur les systèmes gérés à distance.

Aussi, utilisez || false || false et n'essayez pas d'utiliser la commande exit dans /etc/hostname car cela interromprait l'exécution du script rc au démarrage et sshd ne serait pas démarré.

Exemple /etc/hostname.tun pour le client openvpn
et exemple pour le client openvpn à démarrer au démarrage ou via le script rc (mais assurez-vous qu'il n'a pas besoin d'entrer manuellement le mot de passe):

vi /etc/hostname.tun3
 
  up
  group openvpnclient
  description "OpenVPN client to local openvpn server"
  !/usr/local/sbin/openvpn --daemon --config /etc/openvpn/vpnclient-unixlocaltest/vpnclient-unixlocaltest.conf.ovpn --dev $if & false
  #!/usr/local/sbin/openvpn --daemon --config /etc/openvpn/server_$if.conf --dev $if --server 10.8.0.0 255.255.255.0 --push "route 192.168.0.0 255.255.255.0" & false
  #
  # WARNING: 
  # BOOTING process can be blocked, sshd not started and remote access blocked if this script fails!!!
  # If you change anything in script, test with: sh /etc/netstart tunX;  echo "exitCode=$?"
  # Replace tunX with proper network interface name. Verify that process openvpn started.
  # Make sure script run NON-interactively and the exit code is 0. 
  # Otherwise it will interrupt booting process!!!
  # Use '& false' at the end. The '&' prevents interactive data input, eg passwords. 
  # The 'false' command makes sure that no error status code will be returned.
  # do not use exit command in here - or rc booting would be interrupted.
  #
  # You can use variable if = interface, eg if=tun0, so you can use --config /etc/openvpn/server_$if.conf
  #
  # The file /etc/openvpn/server_$if.conf must exist
  # If you change binary name or --daemon option in command above - also change matching pattern in /etc/rc.d/openvpn script
  # 
  #
  # In case you need more /dev/tun devices, eg tun4, do: cd /dev && { ./MAKEDEV tun4; cd - ; }
  # For debug - you can add/uncomment command like:
  # !echo "Starting openvpn on $if"
  #
 
**Une fois ceci configuré, alors:**
  * openvpn sera démarré lors du démarrage du système à partir de /etc/hostname.tun
  * pour arrêter la commande openvpn use: pkill -x openvpn
  * pour recommencer openvpn, utilisez la commande comme: sh /etc/netstart tun0 ou sh /etc/netstart tun0 tun1 tun2 tun3

C'est une étape facultative - si vous voulez utiliser le script /etc/rc.d/openvpn pour démarrer ou arrêter les VPN, continuez.

Le script openvpn dans le framework rc peut être utilisé pour démarrer / arrêter plusieurs openvpn.

Créer /etc/rc.d/openvpn
En cas d'existence d'un fichier, examinez-le

Si ce fichier n'existe pas, créez-le comme indiqué ci-dessous.

cat /etc/rc.d/openvpn && echo && echo "**** File already exists - just review if it is OK" 
vi /etc/rc.d/openvpn 

Le script agira de la même manière que les scripts rc normaux.

Le script peut nécessiter des ajustements dans les versions d'OpenBSD plus récentes que 5.6, en particulier si /etc/rc.d/rc.subr a changé.

Corrigez le script si nécessaire

Placez le contenu suivant dans /etc/rc.d/openvpn :

  #!/bin/sh
  #
  # openvpn rc.d script for OpenBSD - by Chris Pfaff
  #
  # This script acts like normal rc script if the openvpn_flags in rc.conf.local are set to typical openvpn 
  parameters
  # But if openvpn_flags are set to special string "-use-etc-hostname-" then script acts in special way:
  #  It starts the openvpns configured in /etc/hostname.if (eg in /etc/hostname.tun0)
  #  It will start multiple openvpn - each with its own config defined in /etc/hostname.tun*
  #  If script detects that a process is already running - it does not try to start again but returns with ok 
  status
  #  It supports usual parameters like: start, check, stop, restart, reload
  #
  # -d = debug mode - use to see verbose information about executed commands
  #
 
  daemon="/usr/local/sbin/openvpn"
 
  . /etc/rc.d/rc.subr
 
  if [ "$daemon_flags" != "-use-etc-hostname-" ]; then 
    # handle as usual
    rc_cmd $1
  else
    #special unusual handling
    #start openvpns defined in /etc/hostname.*
 
    # Edit if necessary
    # This pattern is being used for scanning /etc/hostname.tun*
    # and for finding running openvpn processes
    # and for searching individual openvpn process - then patter is appended with: [^a-zA-Z]${hnif}([^0-9]|$)
    processpattern='openvpn.*--daemon.*'
 
    [ -n "${_RC_DEBUG}" ] || _n="-n"
    PGREPFLAG="-f"
    PKILLFLAG="-f"
    [ -z "${_RC_DEBUG}" ] && PKILLFLAG="$PGREPFLAG -q"  # quiet if not debug mode
    [ -z "${_RC_DEBUG}" ] && PGREPFLAG="$PGREPFLAG -q"  # quiet if not debug mode
    [ -n "${_RC_DEBUG}" ] && PGREPFLAG="$PGREPFLAG -l"  # list process name in debug mode
    case "$1" in
    start|check)
        [ "$1" == "start" ] && echo $_n "${INRC:+ }${_name} "
        if [ X"${daemon_flags}" = X"NO" ]; then
            _rc_err "$0: need -f to force $1 since ${_name}_flags=NO"
            exit 1
        fi
        allprocstatus=0
        # search all hostname.tun* files which contain openvpn startup command
        hostnamepattern="/etc/hostname.tun*"
        for hostnamefile in $hostnamepattern; do
            if [ "$hostnamefile" = "$hostnamepattern" ]; then
                [ -n "${_RC_DEBUG}" ] && echo "no files $hostnamepattern"
                [ "$2" == "quiet" ] && exit 1
                _rc_e
  xit failed
            fi
            [ -n "${_RC_DEBUG}" ] && echo
            if grep -v "^[  ]*#" "$hostnamefile" | grep -q "$processpattern" ; then
                [ -n "${_RC_DEBUG}" ] && echo "File $hostnamefile is openvpn file - will be started/checked"
            else
                [ -n "${_RC_DEBUG}" ] && echo "File $hostnamefile is not related to openvpn - skipping"
                continue
            fi
            # extract interface name from filename
            hnif=${hostnamefile##/etc/hostname\.}
            if [ -z "$hnif" ]; then
                [ -n "${_RC_DEBUG}" ] && echo "Cannot get interface name from $hostnamefile"
                hnifstatus=1
                allprocstatus=1
                continue
            fi
 
            # check if process is already running for this network interface - if yes, do nothing and result is 
  ok 
            hnifprocesspattern="${processpattern}[^a-zA-Z]${hnif}([^0-9]|$)"  # eg server_tun0.conf or 
  client_tun0.conf or -dev tun0
            [ -n "${_RC_DEBUG}" ] && echo "Executing: pgrep ${PGREPFLAG} \"$hnifprocesspattern\""
            pgrep ${PGREPFLAG} "$hnifprocesspattern" && continue
 
            if [ "$1" == "check" ]; then
                [ -n "${_RC_DEBUG}" ] && echo "Missing openvpn process for ${hnif} - see $hostnamefile"
                hnifstatus=1
            else
                echo -n "$hnif "  # write name of started if
                # if process is not running for this interface - start it
                [ -n "${_RC_DEBUG}" ] && echo "Executing: /bin/sh /etc/netstart $hnif "
                /bin/sh /etc/netstart $hnif; hnifstatus=$?
                [ -n "${_RC_DEBUG}" ] && echo " status: $hnifstatus"  # etc/hostname scripts may return 0 even 
  if error occurred
            fi
            [ $hnifstatus -ne 0 ] && allprocstatus=1
        done
        # if ANY failed then return failure - (simple exit if check in quiet mode)
        [ "$2" == "quiet" -a $allprocstatus -ne 0 ] && exit 1
        [ $allprocstatus -ne 0 ] && _rc_exit failed
        [ "$2" == "quiet" ] && exit 0
        _rc_exit ok
        ;;
    stop)
        echo $_n "${INRC:+ }${_name} "
        [ -n "${_RC_DEBUG}" ] && echo "Executing: pkill ${PKILLFLAG} \"$processpattern\""
        pkill ${PKILLFLAG} "$processpattern"
        countdown=10
        while [ "((countdown--))" -gt 0 ]; do
            pgrep ${PKILLFLAG} "$processpattern" >/dev/null || continue
            sleep 1;
        done;
        [ -n "${_RC_DEBUG}" ] && echo "Executing: $0 ${_RC_DEBUG} ${_RC_FORCE} check quiet"
        $0 ${_RC_DEBUG} ${_RC_FORCE} check quiet && _rc_exit failed
        _rc_exit ok
        ;;
    reload)
        echo $_n "${INRC:+ }${_name} "
        [ -n "${_RC_DEBUG}" ] && echo "WARNING: Reload might crash the process if process is chrooted"
        [ -n "${_RC_DEBUG}" ] && echo "Executing: pkill -HUP ${PKILLFLAG} \"$processpattern\""
        pkill -HUP ${PKILLFLAG} "$processpattern" || _rc_exit failed
        sleep 10;
        [ -n "${_RC_DEBUG}" ] && echo "Executing: $0 ${_RC_DEBUG} ${_RC_FORCE} check quiet"
        [ -n "${_RC_DEBUG}" ] && echo "WARNING: Reload might crash the process if process is chrooted"
        $0 ${_RC_DEBUG} ${_RC_FORCE} check quiet || _rc_exit failed
        _rc_exit ok
        ;;
    restart)
        $0 ${_RC_DEBUG} ${_RC_FORCE} stop &&
            $0 ${_RC_DEBUG} ${_RC_FORCE} start
        ;;
    *)
        _rc_usage
        ;;
    esac
  fi

Le script /etc/rc.d/openvpn rc ne fonctionne que si openvpn_flags est défini dans rc.conf.local

Pour que le script rc openvpn soit compatible avec les fichiers /etc/hostname.*, définissez openvpn_flags sur une valeur codée en dur spéciale -use -use-etc-hostname-

Ajoutez à /etc/rc.conf.local :

openvpn_flags="-use-etc-hostname-"# then rc script is compatible with /etc/hostname.tunX to start openvpn (or check if they are running).

Et ajoutez (append) openvpn à la variable pkg_scripts. Ou si une telle variable n'existe pas, ajoutez-la comme dans l'exemple ci-dessous:

pkg_scripts="... openvpn"

Si vous ne voulez pas utiliser les fichiers /etc/hostname, mais seulement utiliser le script rc pour exécuter un processus openvpn, alors au lieu d'une chaîne spéciale, mettez des paramètres de démarrage normaux pour openvpn, par exemple:

  #To run openvpn not from /etc/hostname, but directly from rc script - use line below
  # And make sure parameters like dev, server, push "route...", etc are defined in server.conf
  #openvpn_flags="--daemon --config /etc/openvpn/server.conf --dev tun0"  # if there would be only one openvpn and not started from hostname.if

Créez / modifiez d'abord un modèle de configuration client:

vi /etc/openvpn/private/vpnclient.conf.template

Corrigez le modèle ci-dessous selon vos besoins. Changez en particulier la ligne remote openbsd.example.com 1194 à l'adresse (host.domain ou IP) de votre openvpn.
Cette adresse doit être accessible depuis l'extérieur (depuis Internet).

   ##############################################
   # Sample client-side OpenVPN 2.0 config file #
   # for connecting to multi-client server.     #
   #                                            #
   # This configuration can be used by multiple #
   # clients, however each client should have   #
   # its own cert and key files.                #
   #                                            #
   # On Windows, you might want to rename this  #
   # file so it has a .ovpn extension           #
   ##############################################
 
   # Specify that we are a client and that we
   # will be pulling certain config file directives
   # from the server.
   client
 
   # Use the same setting as you are using on
   # the server.
   # On most systems, the VPN will not function
   # unless you partially or fully disable
   # the firewall for the TUN/TAP interface.
   ;dev tap
   ;dev tun
 
   # Windows needs the TAP-Win32 adapter name
   # from the Network Connections panel
   # if you have more than one.  On XP SP2,
   # you may need to disable the firewall
   # for the TAP adapter.
   ;dev-node MyTap
 
   # Are we connecting to a TCP or
   # UDP server?  Use the same setting as
   # on the server.
   ;proto tcp
   ;proto udp
 
   # The hostname/IP and port of the server.
   # You can have multiple remote entries
   # to load balance between the servers.
   ;remote my-server-1 1194
   ;remote my-server-2 1194
 
   # Choose a random host from the remote
   # list for load-balancing.  Otherwise
   # try hosts in the order specified.
   ;remote-random
 
   # Keep trying indefinitely to resolve the
   # host name of the OpenVPN server.  Very useful
   # on machines which are not permanently connected
   # to the internet such as laptops.
   resolv-retry infinite
 
   # Most clients don't need to bind to
   # a specific local port number.
   nobind
 
   # Downgrade privileges after initialization (non-Windows only)
   ;user _openvpn
   ;group _openvpn
 
   # Try to preserve some state across restarts.
   persist-key
   persist-tun
 
   # If you are connecting through an
   # HTTP proxy to reach the actual OpenVPN
   # server, put the proxy server/IP and
   # port number here.  See the man page
   # if your proxy server requires
   # authentication.
   ;http-proxy-retry # retry on connection failures
   ;http-proxy [proxy server] [proxy port #]
 
   # Wireless networks often produce a lot
   # of duplicate packets.  Set this flag
   # to silence duplicate packet warnings.
   ;mute-replay-warnings
 
   # 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
 
   # Verify server certificate by checking
   # that the certificate has the nsCertType
   # field set to "server".  This is an
   # important precaution to protect against
   # a potential attack discussed here:
   #  http://openvpn.net/howto.html#mitm
   #
   # To use this feature, you will need to generate
   # your server certificates with the nsCertType
   # field set to "server".  The build-key-server
   # script in the easy-rsa folder will do this.
   #OBSOLETE# ns-cert-type server # this was replaced by: remote-cert-tls server
 
   # If a tls-auth key is used on the server
   # then every client must also have the key.
   ;tls-auth ta.key 1
 
   # Select a cryptographic cipher.
   # If the cipher option is used on the server
   # then you must also specify it here.
   ;cipher x
 
   # Enable compression on the VPN link.
   # Don't enable this unless it is also
   # enabled in the server config file.
   comp-lzo
 
   # Set log file verbosity.
   verb 3
 
   # Silence repeating messages
   ;mute 20
 
 
   # CUSTOMIZATIONS by adminOfMine # all lines below:
 
   #OBSOLETE# ns-cert-type server # this was replaced by: remote-cert-tls server
   # remote-cert-tls server - additional server certificate check, replaces obsolete ns-cert-type server
   remote-cert-tls server
 
   # Use those settings for UNIX:
   #UNIX# daemon openvpn
   #UNIX# user _openvpn
   #UNIX# group _openvpn
   #UNIX# chroot /var/empty
 
   remote openbsd.example.com 1194
   ;proto udp
   proto tcp
   dev tun1
   ;dev-node TAP
 
   float
 
   auth-user-pass
 
   # tls-auth is provided inline, so skip option tls-auth. But it is necessary to define the direction - using key-direction
   key-direction 1
 
   #TEMPLATE# do NOT put certificate config lines into the template
   #TEMPLATE# such lines will be added later - as commands with proper filename or as inline

Les certificats openvpn / keys / config doivent être générés pour chaque utilisateur.

Remarque: Si vous créez une clé + certificat openvpn distincte non seulement pour chaque utilisateur mais également pour chaque périphérique connecté, il est plus facile de révoquer le certificat (= refuser l'accès) pour ce seul périphérique.

générer une demande de certificat pour le client:

alternativement - vpn utilisateur lui-même fait quelque chose comme: ./easyrsa init-pki; ./easyrsa gen-req UNIQUE_CLIENT_SHORT_NAME et envoie la demande de cert à openvpn ca admin juste pour signer/accepter.

vpnclientuser=vpn-user-uniq-name
./easyrsa --batch=1 --pki-dir=${pkiDir} --req-cn=${vpnclientuser} gen-req ${vpnclientuser} nopass
ls -alpd ${pkiDir}/reqs/${vpnclientuser}.req ${pkiDir}/private/${vpnclientuser}.key
openssl req -in ${pkiDir}/reqs/${vpnclientuser}.req -text -noout
openssl rsa -in ${pkiDir}/private/${vpnclientuser}.key -check -noout

L'administrateur openvpn doit signer le certificat (sur le sereur openvpn - avec l'autorité de certification appropriée):

./easyrsa --batch=1 --pki-dir=${pkiDir} show-req ${vpnclientuser}
./easyrsa --batch=1 --pki-dir=${pkiDir} sign client ${vpnclientuser} # client - only for client
openssl x509 -in ${pkiDir}/issued/${vpnclientuser}.crt -text -noout
#cp -p ${pkiDir}/issued/${vpnclientuser}.crt /etc/openvpn/certs/${vpnclientuser}.crt   # no need to copy if using in-line
#cp -p ${pkiDir}/private/${vpnclientuser}.key /etc/openvpn/private/${vpnclientuser}.key # no need to copy if using in-line

Copiez le fichier vpnclient.conf.template préalablement préparé dans un nouveau fichier, par exemple:

cp -p /etc/openvpn/private/vpnclient.conf.template /etc/openvpn/private-client-conf/vpnclient-abc.conf.ovpn

Ensuite, ajoutez des certificats / fichiers de clés individuels - comme décrit ci-dessous

Il est possible d'incorporer tous les ca, certificats et clés dans le fichier de configuration - et alors un seul fichier suffit.

Pour intégrer tous les fichiers pour ca / cert / key / ta config à l' intérieur - ajouter ce qui suit à la fin du fichier de configuration du client (par exemple: /etc/openvpn/private-client-conf/vpnclient-abc.conf.ovpn)

mettre ici le contenu du vrai vpn-ca.crt / vpnclient.ca / vpnclient.key / vpn-ta.key

  # tls-auth is provided inline, so skip option tls-auth. But it is necessary to define the direction - using key-direction
  key-direction 1
  <ca>
  -----BEGIN CERTIFICATE-----
  ...content from vpn-ca.crt...
  -----END CERTIFICATE-----
  </ca>
  <cert>
  -----BEGIN CERTIFICATE-----
  ...content from vpnclient-abc.crt...
  -----END CERTIFICATE-----
  </cert>
  <key>
  -----BEGIN RSA PRIVATE KEY-----
  ...content from vpnclient-abc.key...
  -----END RSA PRIVATE KEY-----
  </key>
  <tls-auth>
  ...content from vpn-ta.key...
  </tls-auth>

Envoyer le *.ovpnfichier de configuration à l'utilisateur VPN.

ajoutez les lignes ci-dessous et rappelez-vous que vpn usr doit obtenir le fichier de configuration du client vpn avec des fichiers ca/certificate/key/ta séparés.

vous devrez peut-être également supprimer la ligne key-direction 1du fichier de configuration

Ajouter ce qui suit à la fin du fichier de configuration du client (par exemple à:) /etc/openvpn/private-client-conf/vpnclient-abc.conf.ovpn:

# tls-auth needs to have direction. For inline certificates it would need to be replaced with key-direction 1

tls-auth vpn-ta.key 1 
ca vpn-ca.crt 
cert vpnclient.crt 
key vpnclient.key 

Envoyez le *.ovpnfichier de configuration et tous les fichiers listés dans le bloc ci-dessus à l'utilisateur vpn.

Exemple de commandes (pour easy-rsa3):

Le certificat cible doit toujours exister sur le fichier sous easy-rsa, par exemple dans
${pkiDir}/issued/vpnclient-olduser.crt. Keyfile pour cet utilisateur n'est pas nécessaire, mais le certificat doit être présent

Pour révoquer (bloquer, interdire) le certificat:

cd /etc/openvpn/easy-rsa/3; ./easyrsa revoke vpnclient-olduser ./easyrsa gen-crl 

après avoir exécuté la commande ci-dessus, vous devriez voir un message comme Revoking Certificate 04. Data Base Updated

vérifier que le certificat est révoqué dans $ {pkiDir} /index.txt

egrep "vpnclient-olduser" ${pkiDir}/index.txt 

donne quelque chose comme: R 240425145061Z 140428150632Z 05 unknown /CN=vpnclient-olduser

assurez-vous que le processus openvpn peut lire ce fichier - sinon il va planter:

chown :_openvpn ${pkiDir}/crl.pem; chmod g+r ${pkiDir}/crl.pem 

assurez-vous que CRL est utilisé dans server.conf de openvpn:

egrep '^ *crl-verify.*crl.pem' /etc/openvpn/server.conf 

Copiez le fichier dans l'emplacement indiqué dans le fichier server.conf d'openvpn. si vous utilisez chroot - copiez crl.pem dans un emplacement visible après chrooting (/etc/openvpn/crl.pem peut être un lien symbolique - ne changez pas cela)

cp -p ${pkiDir}/crl.pem /etc/openvpn/crl.pem
ls -alF ${pkiDir}/crl.pem /etc/openvpn/crl.pem /var/openvpn/chrootjail/etc/openvpn/crl.pem  # all files should be the same
openssl crl -in /etc/openvpn/crl.pem -text

Après avoir mis à jour le fichier CRL, assurez-vous que le processus openvpn est capable de le lire.

Teste si l'utilisateur révoqué n'est plus capable de se connecter.
Ensuite, testez si les utilisateurs (non révoqués) peuvent encore se connecter pour s'assurer que tout va bien.

client (Win / Mac / Unix / Linux)
La création de config / keys / certificates a été décrite ci-dessus dans ADD VPN USER = generate CLIENT config / key / certificate

Afin de continuer, vous devez avoir le *.ovpnfichier de configuration avec les certificats / keyfiles / ta - soit incorporés dans *.ovpnou en tant que fichiers séparés (puis mettre ces fichiers séparés dans le même répertoire que *.ovpn)

Vérifiez *.ovpnet adaptez votre système. Vérifiez en particulier les paramètres:

• éloigné 1194 # définir l'adresse correcte du serveur VPN
• proto udp # tcp ou udp. Assurez-vous que le côté serveur prend également en charge le protocole
• dev tun1 # ajuste le nom de l'appareil ici
• auth-user-pass # désactiver si l'authentification supplémentaire n'est pas requise par le serveur
• Lignes de commentaire ou de commentaire pour unix: daemon openvpn, utilisateur _openvpn, groupe _openvpn, chroot / var / empty
• Assurez-vous que le certificat, la clé, etc est incorporé dans le fichier de configuration OU répertorié dans la configuration et joint
  

Un exemple de contenu *.ovpnpeut être quelque chose comme (ci-dessous est juste un exemple - ajuster la configuration pour chaque client si nécessaire):

  client
  resolv-retry infinite
  nobind
  persist-key
  persist-tun
  comp-lzo
  verb 3
  # remote-cert-tls server - additional server certificate check, replaces obsolete ns-cert-type server
  remote-cert-tls server
  remote  <server IP or vpnserver.domain.com> 1194  # set proper address of VPN server
  proto udp  # tcp or udp. Make sure server-side also supports the protocol
  dev tun1   # adjust device name here.
  float  # check if/how that works for float. Consider disabling persist-key/tun when having problems with reconnect from different IP.
  # ask for username/password
  auth-user-pass   # disable if not required by server
    # other options to be considered if needed:
    # auth-user-pass # ask for username/password
    # auth-user-pass /etc/openvpn/user-pass.auth
    # auth-retry nointeract
  #Uncomment lines marked with #UNIX# if you run on unix system
  #UNIX# daemon openvpn
  #UNIX# user _openvpn
  #UNIX# group _openvpn
  #UNIX# chroot /var/empty

Et il devrait définir certificat/clés - soit en ligne:

  key-direction 1
  <ca>
  -----BEGIN CERTIFICATE-----
  ...content from vpn-ca.crt...
  -----END CERTIFICATE-----
  </ca>
  <cert>
  -----BEGIN CERTIFICATE-----
  ...content from vpnclient-abc.crt...
  -----END CERTIFICATE-----
  </cert>
  <key>
  -----BEGIN RSA PRIVATE KEY-----
  ...content from vpnclient-abc.key...
  -----END RSA PRIVATE KEY-----
  </key>
  <tls-auth>
  ...content from vpn-ta.key...
  </tls-auth>

Ou en tant que fichier séparé - mais vous devez également avoir ces fichiers séparés et ils doivent être copiés dans le répertoire de configuration du client openvpn avec le *.ovpnfichier.

La définition de fichiers séparés dans *.ovpn ressemblerait à ceci:

  tls-auth vpn-ta.key 1
  ca vpn-ca.crt
  cert vpnclient.crt
  key vpnclient.key

• WINDOWS - télécharger le client OpenVPN à partir du site Web OpenVPN.
  

Copier vpnclient-my-user.conf.ovpndans openvpn client config dir après l'installation - par ex. si Openvpn est installé dans C:\Prog\OpenVPN - mettez-le dedans C:\Prog\OpenVPN\config.

Le processus OpenVPN-GUI doit être démarré en tant qu'administrateur (vous devrez peut-être créer un lien et modifier ses propriétés pour toujours exécuter en tant qu'administrateur).

Attention: Si vous n'exécutez pas le processus OpenVPN-GUI en tant qu'administrateur - il semblera fonctionner, mais après avoir établi la connexion, il ne sera pas en mesure de changer le routage et il ne sera pas possible de se connecter aux machines à l'autre extrémité le tunnel VPN (sauf si vous modifiez manuellement le routage - en tant qu'administrateur).

• MAC - installez TunnelBlick. Copiez vpnclient-user.conf.ovpn comme indiqué par tunnelblick.
  

Note: il peut être nécessaire de copier vpn-ta.key, car la version actuelle (Tunnelblick 3.4.1 (build 4054) de l'année 2014) a des problèmes pour lire le vpn-ta en ligne.

Je devais copier vpn-ta.keydirectement
~/Library/Application Support/Tunnelblick/Configurations/vpnclient-my-user.tblk/Contents/Resourceset ensuite ça a marché.

• UNIX / LINUX - installer le paquet openvpn, (le paquet client openvpn peut être identique ou inclus dans le serveur openvpn).

• WINDOWS - vous pouvez utiliser VPN GUI - il doit être exécuté en tant qu'administrateur pour définir le bon routage après l'établissement de la connexion. Le processus OpenVPN-GUI doit être démarré en tant qu'administrateur (vous devrez peut-être créer un lien et modifier ses propriétés pour toujours exécuter en tant qu'administrateur). Si vous n'exécutez pas le processus OpenVPN-GUI en tant qu'administrateur - cela semblera fonctionner, mais après avoir établi la connexion, il ne sera pas capable de modifier le routage et il ne sera pas possible de se connecter aux machines à l'autre extrémité du VPN tunnel (sauf si vous modifiez manuellement le routage - en tant qu'administrateur).

• MAC - utilisez l'interface graphique TunnelBlick. Si vous avez des problèmes de connexion - assurez - vous que vous avez copié vpn-ta.keyà~/Library/Application Support/Tunnelblick/Configurations/vpnclient-my-user.tblk/Contents/Resources

• UNIX / LINUX - utilisez des commandes comme ci-dessous:

openvpn –config /etc/openvpn/vpnclient-my-user.conf.ovpn

ifconfig tun1  # interface should be up and have IPs assigned. Check device that you have put in config file, eg. tun1  
pgrep -fl openvpn.*client  
less /var/log/messages  # search for entries from "^openvpn:"  

Il est également possible de faire en sorte que le serveur openvpn nécessite un nom d'utilisateur / mot de passe (en plus du certificat/keyfiles) Note: Ce n'est PAS un mot de passe pour key-file, c'est une authentification du côté openvpn

Le nom d'utilisateur et le mot de passe sont indépendants du nom du certificat et du nom du fichier de configuration

L'authentification peut être effectuée:

• contre un utilisateur / mot de passe UNIX (y compris les mots de passe ldap si yp est correctement configuré)
• directement contre ldap
• en utilisant un script personnalisé et des noms d'utilisateur / mots de passe personnalisés

Sous openvpn chroot-ed, il est difficile d'effectuer l'authentification unix / bsd ou ldap.

Donc dans les prochains exemples ci-dessous il y a 2 variantes:
Exécutez openvpn chrooted et utilisez le mot de passe openvpn-dedicated (simplifié) pour l'authentification
Exécutez openvpn normalement (pas chrooté) et utilisez l'authentification UNIX / BSD ou LDAP

Note: Cette méthode peut être utilisée avec ou sans chrootage

Liste des fichiers de mot de passe acceptés dans /etc/openvpn/custom-simple-auth.conf Il n'y a pas de vérification du nom d'utilisateur du certificat vpn par rapport aux noms d'utilisateurs ici.

préparer le lien symbolique pour l'environnement chrooté (donc openvpn peut être démarré avec ou sans chroot et atteindre le même fichier):

  ln -s /var/openvpn/chrootjail/etc/openvpn/custom-simple-auth.conf /etc/openvpn/custom-simple-auth.conf
 
  vi /etc/openvpn/custom-simple-auth.conf
 
  # This file contains authentication data for simple authentication script
  # each line should contain 2 values (separated by spaces or tab):
  # username password
  #
  # auth-check script gets given username/password from environment
  # then it reads list of valid username/password from this config file
  # If the given username/password matches any of the username/password from this config file then authentication is OK.
  #
  # comments can be made by adding # as the FIRST character in the line
  # commenteduser  commentedpassword
  vpn     vpn 

préparer le lien symbolique pour l'environnement chrooté (donc openvpn peut être démarré avec ou sans chroot et atteindre le même fichier):

  ln -s /var/openvpn/chrootjail/var/openvpn/custom-simple-auth /var/openvpn/custom-simple-auth

Créer un programme C simple pour effectuer une vérification d'authentification

  mkdir -p /etc/openvpn/additional-files/ 
  cd /etc/openvpn/additional-files/ 
  vi custom-simple-auth.c 

Ajouter du contenu comme dans le fichier joint:

  #include <sys/param.h>
  #include <sys/types.h>
  #include <stdio.h>
  #include <stdlib.h>
 
  /* 
  # Chris Pfaff
  # This is a simple script to do custom authentication for openvpn.
  #
  # It gets given username/password from environment
  # It reads list of valid usernames/password from config file
  # If the given username/password matches any of the username/password from the config file then authentication is OK.
  #
  # If it is static then it can be executed under chrooted environment
  # then move output to final location:
  # compile this file using -static option:
  # 
  gcc -static -o /var/openvpn/chrootjail/var/openvpn/custom-simple-auth /etc/openvpn/additional-files/custom-simple-auth.c
  ln -s /var/openvpn/chrootjail/var/openvpn/custom-simple-auth /var/openvpn/custom-simple-auth  # for chrooted env
 
  # Test with command like: (adjust the username, password):
  username=vpn password=vpn /var/openvpn/custom-simple-auth # should be ok with valid credentials
  username=wrong password=wrong /var/openvpn/custom-simple-auth # should fail with wrong credentials
 
 
  For openvpn - you need to edit the server.conf and add lines like this:
 
  ###############
  #### AUTHENTICATION of user - requiring username/password in addition to VPN client certificates
  ###############
  # Use custom static C executable that reads username/passwords from /etc/openvpn/custom-simple-auth.conf
  # It works when chrooted (compile as static executable, no libraries needed)
  auth-user-pass-verify /var/openvpn/custom-simple-auth via-env
  # It is possible to use the script in non-chrooted environment or chrooted env
  chroot /var/openvpn/chrootjail
 
  */
 
  char configFile[] = "/etc/openvpn/custom-simple-auth.conf";
  int DEBUG=3;
 
 
  int verifyAgainstFile(char* fileName, char* u, char* p) {  // check password against the strings configured in config file
      FILE *fp;
      char ch;
      const int maxLineLen=255;
      char line[maxLineLen];
      char ru[maxLineLen];
      char rp[maxLineLen];
 
      fp = fopen(fileName,"r"); // read mode
 
      if( fp == NULL ) {
          printf("Cannot open config file: %s\n",fileName);
          perror("Error while opening the config file.\n");
          exit(EXIT_FAILURE);
      }
 
      (DEBUG >= 3) && printf("The contents of %s file are :\n", fileName);
 
      while (!feof(fp)) {
          (DEBUG >= 3) && printf("Processing line... ");
          if (fgets(line, maxLineLen, fp) ) {
              (DEBUG >= 3) && printf(" '%s'  ", line);
              if (line[0] == '#') {
                  (DEBUG >= 3) && printf(" - this line is a comment - ignoring\n");
              } else if (sscanf(line, "%s %s", ru, rp) == 2) {
                  (DEBUG >= 3) && printf("%s %s  - ", ru, rp);
                  if ( (strncmp(u, ru, maxLineLen) == 0) && (strncmp(p, rp, maxLineLen) == 0) ) {
                      (DEBUG >= 1) && printf("auth ok\n");
                      return 1;  // auth ok
                  } else {
                      (DEBUG >= 1) && printf("failed auth\n");
                  }
              } else {
                  (DEBUG >= 2) && printf("failed scanf: %s %s\n", ru, rp);
                  // ru , rp - still might contain values from previous line, do not use them if sscanf failed
              }
          } else {
              (DEBUG >= 3) && printf("failed with fgets - end of file\n");
          }
      }
 
      fclose(fp);
      return 0;
  }
 
  int main() {
      int result;
      char *username;
      char *password;
 
      if(getenv("username") != NULL) {
          username = getenv("username");
      } else {
          printf("no username environmental variable set\n");
          return 1;
      }
 
      if(getenv("password") != NULL) {
          password = getenv("password");
      } else {
          printf("no password environmental variable set\n");
          return 1;
      }
 
      // EXAMPLE: Use system BSD authentication
      // This requires also the includes:
      // #include <login_cap.h>
      // #include <bsd_auth.h>
      //result = auth_userokay(username, NULL, NULL, password); // add auth libraries
 
 
      // Check given username/password against list of username/passwords stored in config file
      result = verifyAgainstFile(configFile, username, password);
 
      if(result == 0) {
          printf("authentication failed\n");
      } else {
          return 0;
      }
      return 1;
  }

puis compile en utilisant l'option static (-static = pas de dependances de librairies - necessaire pour l'environnement chrooté):

  gcc -static -o /var/openvpn/chrootjail/var/openvpn/custom-simple-auth /etc/openvpn/additional-files/custom-simple-auth.c
  ln -s /var/openvpn/chrootjail/var/openvpn/custom-simple-auth /var/openvpn/custom-simple-auth  # for chrooted env

Testez avec une commande comme: (ajustez le nom d'utilisateur, mot de passe):

username=vpn password=vpn /var/openvpn/custom-simple-auth # should be ok with valid credentials 
username=wrong password=wrong /var/openvpn/custom-simple-auth # should fail with wrong credentials 

AVERTISSEMENT: N'oubliez pas: après chaque mise à niveau du système d'exploitation OpenBsd:

• Testez si cet outil fonctionne correctement - en utilisant des tests simples ci-dessus
• Parfois, il peut être nécessaire de recompiler ce binaire en utilisant de nouveaux compilateurs - puis utilisez la commande “gcc -static …” ci-dessus

Créez également un fichier d'information pour expliquer à quoi sert ce binaire:

  vi /var/openvpn/chrootjail/var/openvpn/custom-simple-auth.txt
 
  # Chris Pfaff
  # This is a simple script to do custom authentication for openvpn.
  #
  # It gets given username/password from environment
  # It reads list of valid usernames/password from config file
  # If the given username/password matches any of the username/password from the config file then authentication is OK.
  #
  # If it is static then it can be executed under chrooted environment
  # then move output to final location:
  # compile this file using -static option:
  #
 
  gcc -static -o /var/openvpn/chrootjail/var/openvpn/custom-simple-auth /etc/openvpn/additional-files/custom-simple-auth.c
  ln -s /var/openvpn/chrootjail/var/openvpn/custom-simple-auth /var/openvpn/custom-simple-auth  # for chrooted env
 
  # Test with command like: (adjust the username, password):
  username=vpn password=vpn /var/openvpn/custom-simple-auth # should be ok with valid credentials
  username=wrong password=wrong /var/openvpn/custom-simple-auth # should fail with wrong credentials
 
  ln -s /var/openvpn/chrootjail/var/openvpn/custom-simple-auth.txt /var/openvpn/custom-simple-auth.txt # for chrooted env

  vi /etc/openvpn/server.conf
 
  ###############
  #### AUTHENTICATION of user - requiring username/password in addition to VPN client certificates
  # VARIANT 1A - using static executable
  # Use custom static C executable that reads username/passwords from /etc/openvpn/custom-simple-auth.conf
  # It works also when chrooted (this is static executable, no libraries needed)
  script-security 3  # CUSTOMIZED by adminOfMine #
  auth-user-pass-verify /var/openvpn/custom-simple-auth via-env  # CUSTOMIZED by adminOfMine #
  # It is possible to use the script in non-chrooted environment or chrooted env
  chroot /var/openvpn/chrootjail  # CUSTOMIZED by adminOfMine #

après avoir changé le server.conf - redémarrer OpenVPN et tester si elle fonctionne vérifier/var/log/openvpn/openvpn.log

Si vous avez besoin d'une authentification, activez-la également côté client en modifiant le fichier de configuration client openvpn (* .ovpn) et ajoutez:

  # ask for username/password 
  auth-user-pass # CUSTOMIZED by adminOfMine # 

Cette méthode d'authentification peut être utilisée avec chroot-ing ou sans.

Avec cette configuration, le nom d'utilisateur / mot de passe d'openvpn est indépendant du système utilisateur / mots de passe et indépendant du certificat openvpn (tous les certificats peuvent donc utiliser les mêmes mots de passe).
Il y a de la place pour l'amélioration, mais je la trouve assez bonne (et mieux que juste keyfile sans mot de passe du tout):

• quand quelqu'un se connecte à VPN il ne suffit pas d'avoir la clé, aussi un nom d'utilisateur / mot de passe est nécessaire et vérifié sur le côté serveur. (Par exemple, si vous perdez une clé USB avec votre keyfile openvpn, votre VPN est relativement sûr)
• Les utilisateurs / mots de passe openvpn (utilisés “en externe”) et les utilisateurs / mots de passe normaux (unix) (utilisés “en interne”) sont séparés. Cela peut être avantageux dans certains cas (par exemple, pas besoin de créer un compte Unix pour les utilisateurs VPN).

Gardez à l'esprit que openvpn stocke ces nom d'utilisateur / mot de passe dans ses fichiers de configuration (en clair) et si quelqu'un transige avec openvpn alors les mots de passe sont visibles, donc - dans le pire des cas - meilleur compromis mot de passe vpn.

Le script et la gestion du nom d'utilisateur / mot de passe peuvent être étendus. Il est possible de stocker sha/md5 du mot de passe de l'utilisateur (ou exporter depuis ldap/samba/master.passwd).

par exemple avec: cat /etc/master.passwd | grep “^$user” | cut … Ensuite, vérifiez le mot de passe de l'utilisateur donné au script en clair, faites la même md5/sha et vérifiez par rapport à la valeur stockée. Si elles correspondent, l'authentification est correcte. Mais cela ne sert à rien, car openvpn donne des mots de passe au binaire de vérification d'authentification en clair (via env ou fichier).

Exécutez les commandes suivantes pour préparer les fichiers de base sous env: chrooted:

Cette étape peut nécessiter des ajustements - en fonction de la version d'OpenBSD

  cd /var/openvpn/chrootjail
  filesToCopy="
  /bin/csh
  /usr/bin/head
  /usr/bin/tail
  /usr/bin/ldd
  /bin/echo
  /usr/lib/libc.so.65.0
  /usr/libexec/ld.so
  "
  for f in $filesToCopy; do
      f2=${f:1:255}
      f2dir=${f2%/*}
      echo "mkdir -p /var/openvpn/chrootjail/$f2dir; cp $f /var/openvpn/chrootjail/$f2; cp $f /var/openvpn/chrootjail/"
      mkdir -p /var/openvpn/chrootjail/$f2dir; cp $f /var/openvpn/chrootjail/$f2; cp $f /var/openvpn/chrootjail/
  done
 
  cat '#!/bin/csh
  setenv username "vpn"
  setenv password "vpn"
 
  /var/openvpn/custom-simple-auth-script.csh && echo "OK" || echo "error"
  ' > test-chroot-auth.csh
  chmod u+x test-chroot-auth.csh

Préparez le script pour vérifier l'authentification: custom-simple-auth-script.csh ln -s /var/openvpn/chrootjail/var/openvpn/custom-simple-auth-script.csh /var/openvpn/custom-simple-auth-script .csh vi /var/openvpn/chrootjail/var/openvpn/custom-simple-auth-script.csh

Mettez le contenu suivant dans le fichier

  #! /bin/csh
 
  # AUTH via-env - sets following variables
  # username=user
  # password=pass
 
  # AUTH via-file
  # filename is given in $1
  # file contains 2 lines with username (1st line) and with cleartext password (2nd line)
  #username
  #password
 
  # read expected (required) username/password from config file. VPN user must give the same username/password.
  set requiredUsername=`egrep -v '^#|$^' /etc/openvpn/custom-simple-auth.conf | head -1 | cut -f 1`
  set requiredPassword=`egrep -v '^#|$^' /etc/openvpn/custom-simple-auth.conf | head -1 | cut -f 2`
 
  # if via-file then load file content into internal variables
  if ( "$1" != "" ) then
      if ( -e "$1" ) then
          #read from file
          set username=`head -1 $1`
          set password=`head -2 $1 | tail -1`
          # echo username=$username
          # echo password=$password
      else
          exit 2  # no file given in $1
          # echo no file found
      endif
  endif
 
  # next part is common for via-file (variables loaded from file) or via-env (variables set by calling script)
 
  if ( "$username" == "$requiredUsername" && "$password" == "$requiredPassword" ) then
      # echo ok
      exit 0   # auth ok
  else
      # echo err
      exit 1  # file auth failed
  endif
  exit 10  # shall never happen, but just in case

Liste des fichiers de mot de passe acceptés dans /etc/openvpn/custom-simple-auth.conf Il n'y a pas de vérification du nom d'utilisateur du certificat vpn par rapport aux noms d'utilisateurs ici.

  ln -s /var/openvpn/chrootjail/etc/openvpn/custom-simple-auth.conf /etc/openvpn/custom-simple-auth.conf
 
  vi /etc/openvpn/custom-simple-auth.conf
 
  # The required username/password given in /etc/openvpn/custom-simple-auth.conf will be required by all the vpn users (the same for all users). 
  # Only first line from that file will be taken into account vpn vpn

modifier les paramètres (mot de passe du nom d'utilisateur) dans /etc/openvpn/custom-simple-auth.conf

  vi /etc/openvpn/server.conf
 
  ###############
  #### AUTHENTICATION of user - requiring username/password in addition to VPN client certificates
  # VARIANT 1B - authenticate under chroot using custom script
  # This script could work with chroot but it would need csh under chrooted dir and all necessary binaries and libraries
  # It is using simple hardcoded authentication
  script-security 3  # CUSTOMIZED by adminOfMine #
  # script must be available under that path after chrooting and necessary shell/libs must be present under chrooted dir
  auth-user-pass-verify /var/openvpn/custom-simple-auth-script.csh via-env  # CUSTOMIZED by adminOfMine #
  #
  # and via file
  #tmp-dir /tmp/openvpnauth  # CUSTOMIZED by adminOfMine #
  #auth-user-pass-verify /var/openvpn/custom-simple-auth-script.csh via-file  # CUSTOMIZED by adminOfMine #
  # It is possible to use the script in both non-chrooted environment or chrooted env

après avoir changé le server.conf - redémarrer OpenVPN et tester si elle fonctionne
vérifier/var/log/openvpn/openvpn.log

Si vous avez besoin d'une authentification, activez-la également côté client en modifiant le fichier de configuration client openvpn (* .ovpn) et ajoutez:

  # ask for username/password 
  auth-user-pass # CUSTOMIZED by adminOfMine # 

Note: Cette méthode semble être moins sûre:

• openvpn n'est pas chrooté
• si le mot de passe openvpn est hi-jacked, le mot de passe unix/ldap est également connu

Cela nécessite également que l'utilisateur authentifiant soit placé dans le groupe _openvpnusers.

Plus d'informations peuvent être trouvées ici: man openvpn_bsdauth

Pour utiliser cette variante - préparer le répertoire pour stocker les données (doit être fait dans le script de démarrage pour créer le répertoire sous fresh / tmp):

courir en tant que root: install -d -m 700 -o _openvpn -g _openvpn /tmp/openvpnauth;

Le répertoire doit exister et être vide et lisible pour le groupe _openvpn: ls -alpd /tmp/openvpnauth; ls /tmp/openvpnauth

Ajoutez les lignes suivantes à /etc/openvpn/server.conf: vi /etc/openvpn/server.conf

  ###############
  # VARIANT 2 - authenticate using system defined users - BSD and/or LDAP users:
  ###############
  # VARIANT 2A - authenticate using bsd authentication
  # # It does NOT work with chrooted openvpn
  #
  # This also requires that the authenticating user be put into the _openvpnusers group.
  #
  # # For via-env use script-security 3, for via-file 2 should be enough
  script-security 3
  auth-user-pass-verify /usr/local/libexec/openvpn_bsdauth via-env
  #
  # # You can switch to authentication via file (then no-one can peek password in openvpn_bsdauth process environment)
  # # But make sure no-one can read that file except root and _openvpn user.
  # # If you intend to use via-file then make sure directory is created (if in /tmp/ then it must be created after each reboot)
  # # use command: install -d -m 700 -o _openvpn -g _openvpn /tmp/openvpnauth; ll -d /tmp/openvpnauth
  #auth-user-pass-verify /usr/local/libexec/openvpn_bsdauth via-file
  #tmp-dir /tmp/openvpnauth  
  #script-security 2

N'oubliez pas que si vous utilisez auth via le fichier, créez le répertoire dans / tmp / - et il doit être recréé à chaque démarrage. Et utilisez la install -d -m …commande (listée ci-dessus) pour que les fichiers sous le répertoire ne puissent pas être lus par d'autres utilisateurs

Gardez à l'esprit que openvpn utilise des mots de passe en clair et si quelqu'un compromet openvpn alors les mots de passe sont visibles
Et rappelez-vous que l'utilisateur authentifiant doit appartenir au groupe _openvpnusers.

Pour tester l'authentification, utilisez une commande comme celle-ci (donnez le nom d'utilisateur / mot de passe dans les variables d'environnement):

username=someuser password=passstring /usr/local/libexec/openvpn_bsdauth; echo $? 
* exitcode = 0 - signifie authentifié
* exitcode = 1 - signifie erreur d'authentification (mot de passe erroné ou utilisateur non inclus dans le groupe _openvpnusers ou compte bloqué, etc.)

Je ne pouvais pas le faire fonctionner sous chrooted env, bien que cela puisse être possible - la connexion à ldap se fait via une connexion TCP. Mais ceci devrait configurer l'environnement pour le client ldap, etc. dans l'environnement chroot-ed.

Pour utiliser cette variante - d'abord préparer le répertoire pour stocker les données (doit être fait dans le script de démarrage pour créer le répertoire sous fresh / tmp):

courir en tant que root: install -d -m 700 -o _openvpn -g _openvpn /tmp/openvpnauth;

Le répertoire doit exister et être vide et lisible pour le groupe _openvpn: ls -alpd /tmp/openvpnauth; ls /tmp/openvpnauth

crée auth-ldap.conf

  test -e /etc/openvpn/auth-ldap.conf || cp -p /usr/local/share/examples/openvpn-auth-ldap/auth-ldap.conf /etc/openvpn/auth-ldap.conf

Ajustez le /etc/openvpn/auth-ldap.conf. Définissez la section LDAP en fonction de /etc/openldap/ldap.conf, définissez Authorization en fonction de /etc/login.conf

Voici un exemple simple et court
Il est recommandé de l'étendre et d'ajouter une configuration pour TLS, des conditions pour que les utilisateurs appartiennent à certains groupes, etc.

Exécuter vi /etc/openvpn/auth-ldap.confet modifier en fonction de l'exemple ci-dessous:

  <LDAP>
      URL             ldap://localhost
      Timeout         15
      TLSEnable       no
  </LDAP>
 
  <Authorization>
      BaseDN          "ou=Users,dc=domainofmine,dc=local"
      SearchFilter    "(&(objectclass=posixAccount)(uid=%u))"
      RequireGroup    false
  </Authorization>

Ajoutez les lignes suivantes à /etc/openvpn/server.conf: vi /etc/openvpn/server.conf

  ###############
  # VARIANT 2B - authenticate using ldap authentication plugin
  # # It does NOT work with chrooted openvpn
  #
  # # script-security 3, 2 should be enough if doing via file
  script-security 3  # CUSTOMIZED by adminOfMine #
  # give full plugin path and then ldap config file. Edit this config file to your environment
  plugin /usr/local/lib/openvpn-auth-ldap.so /etc/openvpn/auth-ldap.conf  # CUSTOMIZED by adminOfMine #
  # # If you intend to use via-file then make sure directory is created (if in /tmp/ then it must be created 
  after each reboot)
  # # use command: install -d -m 700 -o _openvpn -g _openvpn /tmp/openvpnauth; ll -d /tmp/openvpnauth
  tmp-dir /tmp/openvpnauth  # CUSTOMIZED by adminOfMine #

Rappelez-vous que si vous créez un répertoire dans / tmp / - alors il doit être recréé après chaque démarrage. Et utilisez la install -d -m …commande (listée ci-dessus) pour que les fichiers sous le répertoire ne puissent pas être lus par d'autres utilisateurs
Gardez à l'esprit que openvpn utilise des mots de passe en clair et si quelqu'un compromet openvpn alors les mots de passe sont visibles

après avoir changé le server.conf - redémarrez openvpn et testez si cela fonctionne, par exemple:

  /etc/rc.d/openvpn stop; sleep 1; /etc/rc.d/openvpn start; less /var/log/openvpn/openvpn.log 
 
  ifconfig tun0              # put device defined in server.conf 
  pgrep -fl openvpn.*server 
  netstat -an|grep '\.1194 ' # put port defined in server.conf 
  ls -al /var/log/openvpn/*  # check logs 

Rappelez-vous - si vous avez besoin d'authentification côté serveur puis activez également sur le côté client en changeant le fichier de configuration client OpenVPN (* de .ovpn) - ajouter: # demander passe auth-utilisateur nom d'utilisateur / mot de passe # autres options à considérer si nécessaire: # auth-user-pass /etc/openvpn/user-pass.auth # auth-réessayer nointeract

Test de connexion du client, par exemple en utilisant:

  # test openvpn connection - establish vpn connection locally on the server 
  openvpn --config /etc/openvpn/vpnclient-unixlocaltest/vpnclient-unixlocaltest.conf.ovpn; 
  # then stop local vpn tunnel with Ctrl+C if in foreground 
 
  In case vpn client runs in background: 
  tail -f /var/log/messages # if daemonized - check logfile # if no longer necessary then stop, eg. with: 
  pgrep -fl 'openvpn'; pkill -f 'openvpn.*client'; echo "---"; sleep 1; pgrep -fl 'openvpn'; 

Si vous avez des certificats et des clés et des certificats clients créés par simple RSA2 alors vous voudrez peut-être utiliser l'autorité de certification et certificats existants (parce que l'utilisation de nouveaux CA ferait anciens certificats clients inutiles - et ils devront être régénéré).

Hypothèses:

• easyrsa 2.0 a été installé dans /etc/openvpn/easy-rsa/2.0 (sinon - le déplacer là-bas)
• easyrsa 3 (package openbsd) est installé dans / usr / local / share / easy-rsa /
• Les clés pki compatibles easyrsa3 seront stockées dans pkiDir = “/ etc / openvpn / easy-rsa-pki /”

Pour migrer les clés de easy-rsa2 à easy-rsa3, utilisez le guide ci-dessous.

  pkiDir="/etc/openvpn/easy-rsa-pki/"
  easyrsaDir="/usr/local/share/easy-rsa/"
  easyrsa2OldDir="/etc/openvpn/easy-rsa/2.0"
  cd ${easyrsaDir}
  ./easyrsa --batch=1 --pki-dir=${pkiDir} init-pki
  ./easyrsa --batch=1 --pki-dir=${pkiDir} --req-cn=vpn-ca build-ca nopass; rm ${pkiDir}/ca.crt ${pkiDir}/private/ca.key  # this removes unwanted new ca but leaves dir structure
  ll -d ${pkiDir} ${pkiDir}/* ${pkiDir}/*/*
      #  drwx------  6 root  bin  512 Apr 28 23:17 /etc/openvpn/easy-rsa-pki/
      #  drwx------  2 root  bin  512 Apr 28 23:11 /etc/openvpn/easy-rsa-pki/certs_by_serial/
      #  -rw-------  1 root  bin    0 Apr 28 23:11 /etc/openvpn/easy-rsa-pki/index.txt
      #  drwx------  2 root  bin  512 Apr 28 23:11 /etc/openvpn/easy-rsa-pki/issued/
      #  drwx------  2 root  bin  512 Apr 28 23:17 /etc/openvpn/easy-rsa-pki/private/
      #  drwx------  2 root  bin  512 Apr 28 23:11 /etc/openvpn/easy-rsa-pki/reqs/
      #  -rw-------  1 root  bin    3 Apr 28 23:11 /etc/openvpn/easy-rsa-pki/serial
 
  #move files from easyrsa20 to easyrsa30
  cp -p /etc/openvpn/dh.pem ${pkiDir}/  # move current openvpn dh file in there
  mv ${easyrsa2OldDir}/keys/crl.pem    ${pkiDir}/  # move if file exists
  mv ${easyrsa2OldDir}/keys/index.txt* ${pkiDir}/
  mv ${easyrsa2OldDir}/keys/serial*    ${pkiDir}/
  mv ${easyrsa2OldDir}/keys/*.key      ${pkiDir}/private/
  mv ${easyrsa2OldDir}/keys/ca.crt     ${pkiDir}/
  mv ${easyrsa2OldDir}/keys/*.crt      ${pkiDir}/issued/
  mv ${easyrsa2OldDir}/keys/*.csr      ${pkiDir}/reqs/
  mv ${easyrsa2OldDir}/keys/??.pem     ${pkiDir}/certs_by_serial/

Au cas où vous auriez besoin de recréer le certificat de serveur (et toujours en utilisant l'option obsolète ns-cert pour les clients qui en ont encore besoin), utilisez des commandes comme:

  ./easyrsa --batch=1 --pki-dir=${pkiDir} --ns-cert="yes" --ns-comment="Easy-RSA Generated Server Certificate" --req-cn=vpnserver gen-req vpnserver nopass
    openssl req -in ${pkiDir}/reqs/vpnserver.req -text -noout
    ./easyrsa --batch=1 --pki-dir=${pkiDir} --ns-cert="yes" --ns-comment="Easy-RSA Generated Server Certificate" sign server vpnserver # server - only for server
    openssl x509 -in ${pkiDir}/issued/vpnserver.crt -text -noout
    cp -p ${pkiDir}/issued/vpnserver.crt /etc/openvpn/certs/vpnserver.crt; cp -p ${pkiDir}/private/vpnserver.key /etc/openvpn/private/vpnserver.key

Et rappelez-vous de redémarrer openvpn pour qu'il lise le nouveau certificat. Alors testez avec les clients existants !!!

Si vous obtenez une erreur avec easyrsa 4098901262292:error:0E065068:configuration file routines:STR_COPY:variable has no value:/usr/src/lib/libcrypto/crypto/../../libssl/src/crypto/conf/conf_def.c:573:line 3ou Expected to find openssl command at: opensslassurez-vous que vous utilisez easyrca installé à partir des paquets openbsd.

Cela a été nécessaire en Novembre 2016 avec OpenBsd 5.9 et EasyRSA-3.0.0

Si vous obtenez une erreur avec easyrsa comme:

  Easy-RSA error: 
  Missing or invalid OpenSSL 
  Expected to find openssl command at: openssl 

Vérifiez la version openssl

openssl version 
LibreSSL 2.0

Si la version ne démarre pas avec OpenSSL, elle pourrait ne pas être reconnue par le script easyrsa et nécessiter une correction. C'était le cas pour OpenBsd version 5.6 et EasyRSA-3.0.0-rc2.

Le correctif est assez simple (mais vérifiez que toutes les autres exécutions de easyrsa fonctionnent correctement).

  cp -p easyrsa easyrsa.old
  ## cat easyrsa.old | perl -pe 's/(\[ "\$\{val.. \*\}" = ")OpenSSL(" ] \|\| die)/$1LibreSSL$2/' > easyrsa
  cat easyrsa.old | perl -pe 's/(\[)( "\$\{val.. \*\}" = ")(OpenSSL)(")( ] \|\| die)/$1$2$3$4 -o $2LibreSSL$4$5/' > easyrsa; 
  diff easyrsa easyrsa.old 
 
  291c291
  <               [ "${val%% *}" = "LibreSSL" ] || die "\
  ---
  [ "${val%% *}" = "OpenSSL" -o  "${val%% *}" = "LibreSSL" ] || die "\

Ce problème a été observé après la mise à niveau vers OpenVPN 2.4.
Si les clients ne peuvent pas se connecter et que vous obtenez une erreur dans le fichier openvpn.log du côté serveur indiquant que “la liste de révocation de certificats a expiré”, régénérez simplement le certificat CRL.

Premièrement - définir les paramètres et le répertoire pour d'autres commandes

  pkiDir="/etc/openvpn/easy-rsa-pki/"
  easyrsaDir="/usr/local/share/easy-rsa/"
  cd ${easyrsaDir}
  ls -al vars.example
  egrep 'EASYRSA_CA_EXPIRE|EASYRSA_CERT_EXPIRE|EASYRSA_CRL_DAYS' vars.example
  echo
  ls -al vars
  egrep 'EASYRSA_CA_EXPIRE|EASYRSA_CERT_EXPIRE|EASYRSA_CRL_DAYS' vars

Passez en revue les vars.example ou vars (s'il existe). Assurez-vous que la durée de vie de l'autorité de certification, du certificat et de la liste de révocation de certificats est définie sur au moins 10 ans (sauf si vous souhaitez les régénérer plus souvent):

  set_var EASYRSA_CA_EXPIRE 3650 
  set_var EASYRSA_CERT_EXPIRE 3650 
  set_var EASYRSA_CRL_DAYS 3650 

S'il est nécessaire de changer les paramètres - alors créez / modifiez le fichier vars:

  if [ -f ${easyrsaDir}/vars ]; then 
    echo "File already exists - verify: /usr/local/share/easy-rsa/vars"; 
    ls -al ${easyrsaDir}/vars
    cat ${easyrsaDir}/vars;
    echo
  else 
    printf "set_var EASYRSA_CA_EXPIRE\t3650\nset_var EASYRSA_CERT_EXPIRE\t3650\nset_var EASYRSA_CRL_DAYS\t3650" > ${easyrsaDir}/vars;
    ls -al ${easyrsaDir}/vars
    cat ${easyrsaDir}/vars;
    echo
  fi

L'étape suivante consiste à régénérer le fichier CRL:

  ./easyrsa --batch=1 --pki-dir=${pkiDir} gen-crl
  # make sure openvpn process can read this file - otherwise it will crash
  chown :_openvpn ${pkiDir}/crl.pem; chmod g+r ${pkiDir}/crl.pem 
  ls -alF ${pkiDir}/crl.pem
  openssl crl -in ${pkiDir}/crl.pem -text -noout
 
  # Copy final certs/keys to openvpn config locations
  cp -p ${pkiDir}/crl.pem /etc/openvpn/crl.pem
  openssl crl -in /etc/openvpn/crl.pem -text  | egrep -i 'next update|last update'

Vérifiez le certificat - la prochaine mise à jour devrait être dans un avenir lointain.
Vous pouvez maintenant vous reconnecter avec les clients openvpn et vérifier si tout fonctionne.
Il ne doit pas y avoir de redémarrage de openvpn, la nouvelle liste CRL doit être relue par openvpn.

Liens supplémentaires
http://www.openbsdsupport.org
https://openvpn.net/index.php/open-source/documentation/howto.html
https://community.OpenVPN-Howto
http://www.kernel-panic.it/openbsd/vpn/vpn4.html

Note finale
AUCUNE GARANTIE, AUCUNE RESPONSABILITÉ - vous êtes entièrement responsable des systèmes que vous configurez / maintenez / modifiez. Ce guide est uniquement à titre d'information. Certaines erreurs et commandes non fonctionnelles ou effets secondaires imprévus sont possibles.

BSD License s'applique à ce guide. N'hésitez pas à distribuer, éditer, réutiliser le document au besoin, mais veuillez mentionner l'auteur et la source du document sur le Web.

Services Réseaux