walk-hoary

Archives pour la catégorie Tutoriel

Wildcard letsencrypt

Cet article vous présente comment générer un wildcard letsencrypt avec validation automatique par DNS.

Si vous l’avez déjà créé en manuel, comme moi la première fois, voyez la note « Vous avez déjà créé votre certificat en manuel ».

Voici l’environnement :

  • Un reverse-proxy qui fait terminaison SSL sous nginx 1.14
  • Un serveur DNS sous BIND9

Principe de fonctionnement

Pour valider un wildcard, letsencrypt va vérifier la présence d’une entrée TXT dans votre zone DNS au moment de la création/renouvellement du certificat.

Cette entrée TXT est ajoutée par la commande certbot car on lui aura autorisé la mise à d’un champ TXT précis via BIND. Cela peut être fait à la main de façon interactive (–manual), je ne vous le conseille pas.

Pour cela, nous allons créer une clé sur notre serveur BIND et configurer la zone pour qu’elle permette de mettre à jour une entrée TXT précise de la zone.

Cette clé sera donnée au client certbot sur notre reverse-proxy (dans un fichier credential) au moment de la création du certificat.

Configation de BIND

Sur le serveur BIND, créez une nouvelle clé, elle servira pour mettre à jour vos TXT de challenge letsencrypt. (ici certbot est le nom de la clé)

cd /etc/bind
dnssec-keygen -a HMAC-SHA512 -b 512 -n HOST certbot.

Cela va générer deux fichiers : Kcertbot.+NNN+YYYYY.key et Kcertbot.+NNN+YYYYY.key (les deux contiennent la clé, ils ne servent qu’à vous, et pourraient même être supprimés)

Collez les 4 lignes suivantes dans /etc/bind/named.conf en remplaçant XXXxXxXVOTRECLE== par votre clé contenu dans un des deux fichiers précédents.

key "certbot." {
  algorithm hmac-sha512;
  secret "XXXxXxXVOTRECLE==";
};

Ajoutez les lignes suivantes à votre configuration de zone DNS (sous debian : /etc/bind/named.conf.local) en remplaçant example.com par votre domaine.

zone "example.com" {
  [...]
  update-policy {
    grant certbot. name _acme-challenge.example.com. txt;
  };
};

Redémarrez bind avec

systemctl restart bind9

Configuration sur le reverse-proxy

Vous devez installer le paquet python3-certbot-dns-rfc2136 qui est une extension pour permettre à certbot de modifier votre zone DNS pour faire vérifier le challenge. Il en existe d’autres si vous avez des zones sur d’autres systèmes (OVH, gandi, cloudflare…)

apt install python3-certbot-dns-rfc2136

Créez un fichier qui contiendra les credentials pour certbot dans /etc/letsencrypt/dns-rfc2136-credentials-bind.ini et collez la configuration suivante en remplaçant IP_OR_DNS_OF_BIND et XXXxXxXVOTRECLE== votre hôte DNS et votre clé crée dans la section précédente.

dns_rfc2136_server = IP_OR_DNS_OF_BIND
dns_rfc2136_port = 53
dns_rfc2136_name = certbot.
dns_rfc2136_secret = XXXxXxXVOTRECLE==
dns_rfc2136_algorithm = HMAC-SHA512

Puis rendez le fichier non lisible par autre que root.

chmod 700 /etc/letsencrypt/dns-rfc2136-credentials-bind.ini

Création du certificat sur le reverse-proxy

certbot certonly --dns-rfc2136 --dns-rfc2136-credentials /etc/letsencrypt/dns-rfc2136-credentials-bind.ini -d *.example.com

Vous avez déjà créé votre certificat en manuel ?

Si vous avez déjà créé votre certificat de façon interactive (avec l’option –manual de certbot) donc sans l’avoir fait avec une clé bind, pas de pannique ! Vous devez tout de même suivre cet article jusqu’à l’étape de création de certificat que vous pouvez remplacer par un renouvellement de vos certificat (cerbot renew)

Voici ce que vous devez mettre dans votre fichier cat /etc/letsencrypt/renewal/example.com.conf

[...]
[renewalparams]
[...]
authenticator = dns-rfc2136
dns_rfc2136_credentials = /etc/letsencrypt/dns-rfc2136-credentials-bind.ini

Vous devriez pouvoir lancez votre certbot renew…

Remarques

Voici quelques infos à savoir sur letsencrypt que je n’ai eu que tard :

Le renouvellement (certbot renew) se fait uniquement sur les certificats expirant à J-30. (les certificats sont signés pour 90 jours).
Ne pas oublier de révoquer un certificat avant de la supprimer pour éviter les alertes d'e-mails d'expiration envoyées par letsencrypt (certbot revoke --cert-path /etc/letxencrypt/live/example.com/cert.pem)
Évitez de créer des certificat pour des domaines différents, le renouvellement échouera si un seul domaine ne fonctionne pas.

Ansible avec AWX

AWX est un frontend pour piloter Ansible. Il s’agit de la version opensource de Tower qui lui, est stabilisé avec mise à disposition d’un support.

A propos de cet article

Je vous donne ici les instructions pour installer Ansible et AWX sur une debian buster 64 bits.

Pour information, j’ai utilisé un container LXC (Proxmox 6). L’utilisation de docker dans un container « non-privilégié » est possible en ajoutant les lignes suivantes dans la config /etc/pve/lxc/XXXXX.conf :

unprivileged: 1
lxc.apparmor.profile: unconfined
lxc.cgroup.devices.allow: a
lxc.cap.drop:

Toutes les commandes si dessous se font en root.

Ansible

Prérequis

Installons le nécessaire pour ajouter une clé et l’usage de https dans les dépôts.

apt update
apt dist-upgrade
apt -y install gnupg2 apt-transport-https

Installation

Ajoutons le dépôt de chez launchpad et installons ansible. La version installée devrait correspondre sensible à la 2.8.6 (au 2019-10-25)

echo "deb http://ppa.launchpad.net/ansible/ansible/ubuntu bionic main" | tee /etc/apt/sources.list.d/ansible.list
apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 93C4A3FD7BB9C367
apt update
apt install -y ansible
ansible --version

AWX

Pre-requis

On ajoute le dépot et on install docker-ce. La version installée devrait correspondre sensible à la 19.03.4 (au 2019-10-25)

echo "deb [arch=amd64] https://download.docker.com/linux/debian buster stable" | tee /etc/apt/sources.list.d/docker-ce.list
apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 7EA0A9C3F273FCD8
apt update
apt install -y docker-ce
docker --version

Je désactive l’IPV6 afin d’être sûr que AWX écoutera sur l’interface IPV4 (et je ne m’en sert pas entre mes VM).

cat <<EOF > /etc/sysctl.conf
net.ipv6.conf.all.disable_ipv6 = 1
net.ipv6.conf.all.autoconf = 0
net.ipv6.conf.default.disable_ipv6 = 1
net.ipv6.conf.default.autoconf = 0
EOF
sysctl -p

Installons un générateur de mot de passe et docker-compose (Ce sera celui des dépôt debian officiels)

apt -y git pwgen docker-compose

AWX

Récupérons AWX

cd ~
git clone --depth 50 https://github.com/ansible/awx.git

Configurons quelques valeurs

cd awx/installer
sed -i "s|docker_compose_dir=.*$|docker_compose_dir=/var/lib/awx|g" inventory
sed -i "s|^#project_data_dir=.*$|project_data_dir=/var/awx_projects|g" inventory
sed -i "s|^postgres_data_dir=.*$|postgres_data_dir=/var/pgdocker|g" inventory
sed -i "s|^secret_key=.*$|secret_key=$(pwgen -N 1 -s 30)|g" inventory
sed -i "s|^pg_admin_password=.*$|pg_admin_password=$(pwgen -N 1 -s 30)|g" inventory
sed -i "s|^pg_password=.*$|pg_password=$(pwgen -N 1 -s 30)|g" inventory
sed -i "s|^rabbitmq_password=.*$|rabbitmq_password=$(pwgen -N 1 -s 30)|g" inventory

Lonçons la création des containers AWX

ansible-playbook -i inventory install.yml

Note : Pour ma part, j’ai du relancer cette commande 2 fois car j’ai eu un timeout, je n’ai pas noté si il venais de mon système trop lent ou de ma connexion internet.

Comptez 24Go pour AWX, il va occuper pas mal d’espace docker (/var/lib/docker) pour ses 5 VM :

root@ansible:/var/lib/awx# docker-compose ps
     Name                   Command               State                               Ports
 awx_memcached   docker-entrypoint.sh memcached   Up      11211/tcp
 awx_postgres    docker-entrypoint.sh postgres    Up      5432/tcp
 awx_rabbitmq    docker-entrypoint.sh /bin/ …   Up      15671/tcp, 15672/tcp, 25672/tcp, 4369/tcp, 5671/tcp, 5672/tcp
 awx_task        /tini -- /bin/sh -c /usr/b …   Up      8052/tcp
 awx_web         /tini -- /bin/sh -c /usr/b …   Up      0.0.0.0:80->8052/tcp

Voilà, à partir de là, vous pouvez vous y connecter avec votre navigateur sur le port 80 et les identifiants à changer de suite : admin / password

Pour les mises à jour

Les mises à de Ansible se feront par le gestionnaire de paquet Debian.

Pour AWX, il faudra lancer ces commandes :

cd /var/lib/awx
docker-compose stop
docker-compose pull
docker-compose up --force-recreate -d

Créer et monter un volume qcow2

Pour quoi faire ?
Cela peut être utile si vous avez un système de fichier NTFS dans lequel vous souhaitez sauvegarder des données sans perdre les droits UNIX qui vont avec, pour le chiffrer, le transférer, monter une VM…
Création de l’image (ici 1.1G, format qcow2)
qemu-img create -f qcow2 datas.qcow2 1100M
Création du device et attachement du fichier
modprobe nbd max_part=8
qemu-nbd –connect=/dev/nbd0 datas.qcow2
Création de la partition et formatage ext4
cfdisk /dev/nbd0
mkfs.ext4 /dev/nbd0p1
Montage du la partition
mount /dev/nbd0p1 datas

Mémo de compilation de kernel

Introduction

Il y a quelques années, il était assez fréquent de devoir recompiler son noyau linux pour pouvoir utiliser tel ou tel module… Aujourd’hui c’est très rare mais reste toujours instructif. Je vais donc détailler ici les étapes essentielles pour la compilation mais aussi l’installation d’un noyau compilé par vos petites main sous debian/ubuntu/linuxmint…

Pre-requis

Les sources

Les sources du noyau. On va prendre ceux de linuxmint, mais vous pouvez allez cherchez la version que vous voulez sur kernel.org. Ces deux moyens vont vous donner un fichier tar.gz que nous devons décompresser dans l’emplacement standard /usr/linux/src (Si vous prenez les sources depuis apt de votre distrib, il devrait se trouver dans /usr/src/). Vos sources sont à décompresser dans le répertoire universel /usr/src/linux/

Pour gérer les version, nous utilisons la méthode du lien symbolique en décompressant dans /usr/src/linux-source-3.0.2

sudo tar xvf MESSOURCES -C /usr/src/

Et Ferons un lien symbolique linux

sudo ln -s /usr/src/linux-source-3.0.2 /usr/src/linux

La configuration

Récupérer la configuration utilisé par le noyau de la distribution s’avère utile pour partir sur quelque chose qui marche. Ce n’est pas obligatoire si vous savez ce que vous faites. Vous trouverez ces config dans le répertoire /boot de votre système. (exemple /boot/config-3.2.0-30-generic)

sudo cp /boot/config-3.2.0-30-generic /usr/src/linux/.config

Outils

Pour compiler votre noyau, vous aurez besoin d’un compilateur, mais aussi d’un outil pour configurer et surement un autre pour packager car il est très utile d’en faire un .deb. Cela facilite la désinstallation par exemple ou sa distribution.

sudo aptitude install build-essential

Configurer

Rentrez dans le répertoire /usr/src/linux et lancez l’outil qui vous permettra de configurer votre kernel.

sudo make menuconfig ou sudo make xconfig si vous préférez une version graphique sous X

Oui faites pas comme moi, préférez compiler vos programme en tant qu’utilisateur ! 😉

Compilation et empacketage

sudo make-kpkg --initrd --revision=NumeroQueVousVoulez kernel_image kernel_headers modules_image

Cette commande va compiler et vous faire les 3 .deb qu’il vous faut pour installer votre kernel. Et c’est cette commande que j’oublie tout le temps 🙂 Vous connaissez sûrement la suite pour installer des .deb.



                      

Tags: , ,

Certificats pour serveurs

Cet article vous montre comment créer un certificat willcard signé par un tiers

Pourquoi un certificat ?

Parfois il m’arrive de ne pas pouvoir consulter mes emails car le réseau que j’utilise n’est pas sécurisé. J’entends par là que je ne sais pas qui est derrière et pourrait écouter mon trafic et capturer aisément mes identifiants.

J’ai donc décidé d’installer un certificat sur qth.fr. Comme la plupart de mes services sont en *.qth.fr j’ai choisis de faire un certificat willcard que j’ai fait signé par cacert. Le faire signer par autre que soit a l’avantage de pouvoir vérifier auprès de cacert que le certificat est valide. Il faut savoir que cacert est une autorité non reconnue par les navigateurs par défaut car son modele de confiance se base sur ses utilisateurs. (C’est les utilisateurs vérifient entre eux leur identité, cherchez « Key signing party » sur un moteur de recherche).

Ce serveur utilise donc les certificats de cacert ; pour installez le certificat root de cacert, rendez vous sur la page http://www.cacert.org/index.php?id=3 et cliquez simplment sur http://www.cacert.org/certs/root.crt . Attention, cela veux dire que vous acceptez tout les certificats signés par cacert !

Comment ça marche ? (grossièrement)

Pour sécuriser un site en SSL, le serveur doit obligatoirement connaitre un clée privée et un certificat publique signé. Il arrive qu’un ou plusieurs certificats intermédiaires soient nécessaires, j’en parlerais plus loin. Notez que les extensions varient d’un système à l’autre, mais on retrouve globalement KEY, CRT, CSR et PEM (ce dernier désigne en fait jusque c’est un fichier pour le chiffrement, j’utiliserais donc cette extension pour tous mes fichiers).

  • Le certificat privé « KEY » est un fichier généré que vous devez conserver et ne jamais le divulguer ! Il sera utilisé par votre serveur pour chiffrer votre trafic. Il peut être protégé par un mot de passe, libre à vous, personnellement je n’en met pas.
  • La demande de signature certificat « CSR » est un fichier généré à partir de la clé privée. ici je la crée en même temps. Elle peut être divulgué à votre tier de confiance. Elle contient diverses informations comme quels domaines il concerne, la durée de validité…
  • Le certificat « CRT » est le fichier généré par votre autorité de certification tiers.

Lorsque votre navigateur demande une page à votre serveur en SSL, ce dernier vous renvoie la réponse chiffrée avec le certificat publique signé par votre tiers. Votre navigateur peut donc vérifier que le certificat est valide auprès de l’autorité et déchiffrer la réponse du serveur.

Le certificat intermédiaire est parfois nécessaire lorsque l’autorité de certificat est inconnue de votre navigateur mais qui a pourtant été approuvé par une autre autorité, qui elle est connue de votre navigateur. Ce fichier doit donc être envoyé par le serveur en même temps que votre certificat signé. (Il peut y avoir plusieurs certificats intermédiaires).

Notez qu’il existe les certificats normaux et les certificats EV (Extended validate). Ces derniers permettent juste une vérification plus poussée de votre identification et provoque l’apparition de la barre d’adresse verte. (Sinon elle reste de la couleur normal)

Gérer un KEY et un CSR

Créer le fichier /usr/share/ssl-cert/ssleay-MONDOMAINE.cnf (un exemple se nome ssleay.cnf) et insérez ce texte que vous adapterez.

# -------------- BEGIN custom openssl.cnf -----
HOME                    = /etc/ssl/qth/
RANDFILE                = /dev/urandom
oid_section             = new_oids
[ new_oids ]
[ req ]
default_days            = 730            # how long to certify for (2yr)
default_keyfile         = /etc/ssl/qth/wildcard.qth.fr_key.pem
distinguished_name      = req_distinguished_name
encrypt_key             = no
string_mask = nombstr
req_extensions          = v3_req # Extensions to add to certificate request
[ req_distinguished_name ]
commonName              = Common Name (eg, YOUR name)
commonName_default      = qth.fr
commonName_max          = 64
countryName             = Country Name (2 letter code)
countryName_default             = FR
countryName_min                = 2
countryName_max                = 2
organizationName        = Organization Name (company)
organizationName_default        = QTH

localityName            = Locality Name (city, district)
localityName_default    = Paris

stateOrProvinceName     = State or Province Name (full name)
stateOrProvinceName_default = IDF
emailAddress            = ca-admin@localhost.com
emailAddress_max        = 40
[ v3_req ]
subjectAltName=DNS:qth.fr,DNS:*.qth.fr
# -------------- END custom openssl.cnf -----

Lancez la génération :

openssl req -batch -config /usr/share/ssl-cert/ssleay-wildcard.qth.fr.cnf -newkey rsa:2048 -out /etc/ssl/qth/wildcard.qth.fr_csr.pem

Faites signez votre CSR chez une autorité de confiance

Pour ma part j’utilise startssl qui permet de signer des certificat entre 1 et 3 ans en wildcard. Pour cela il est nécessaire d’être identifié en class 2, cela coute 59$ ce qui vous permet de signer des certificats pendant 1 an.

Donc si vous  vous démerdez bien, vous n’avez qu’a vous aqcuiter des 59$ une fois tous les 3 ans. Moi je suis partit pour 2 ans car je me suis trompé dans la génération du CSR car c’est là qu’est précisé la durée de validité. La révocation coûte 24$.

Configurez apache/nginx

Créez un virtualhost qui écoutera sur le port 443 et insérez la configuration suivante :

SSLEngine on
SSLCertificateFile /etc/ssl/qth/wildcard.qth.fr_crt.pem
SSLCertificateKeyFile /etc/ssl/wildcard.qth.fr_key.pem

Et si besoin les certificats intermédiaires (Ajoutez les si votre autorité en a car d’autres navigateurs peuvent se comporter différemment que le votre au moment de vos tests) :
SSLCertificateChainFile /etc/ssl/qth/wildcard.qth.fr_intermediate1.pem

Motion sous linux

Le logiciel motion sous GNU/Linux est un démon qui permet de faire des captures vidéo sur du long terme à partir d’une webcam.

Voici quelques fonctions sympas :

  • Créer une vidéo accéléré du ciel, d’une plante ou d’un escargot en accéléré
  • Capturer et envoyer sur un FTP l’image d’une webcam à intervalle régulière
  • Enregistrer les séquences de mouvement devant une webcam
  • Se connecter à motion via le web pour contrôler ou visualiser sa webcam
  • Avoir 8 webcams (ou plus) qui captent en même temps sur la même machine
  • Traquer et suivre avec une webcam motorisée les mouvements
  • Enregistrer les événements dans une base de données

Je vais vous préciser ici les options de base pour permettre les 3 fonctions ci dessous (Je pars de la config du paquet de Debian Squeeze) :

  1. Créer une image toute les 10s
  2. Créer un film d’une semaine de capture avec 1 minute capturée = 1 frame donc 1 journée capturée = 1 minutes de vidéo environ.
  3. Créer autant de séquences vidéo à 5 FPS que de détections de mouvement avec une image associée
# Pour le point 3 : On définit le framerate à 5FPS
framerate 5
# Je fixe la sensibilité à 1000 pixel pour la captation de mouvement
threshold 1000
# Je capture 3 frames de buffer avant une captation de mouvement
pre_capture 3
# Je clos les captation de mouvement 5 secondes si plus rien de bouge devant la webcam
gap 5
# Je décide d'avoir une image qui correspond aux premiers instant de detection de mouvement
output_normal first

# Point 2 : Je capture une frame toute les 60 secondes pour la vidéo en accélérée
ffmpeg_timelapse 60
# Je fait réinitialiser le film accéléré tout les lundi
ffmpeg_timelapse_mode weekly-monday
# Je fixe la qualité des vidéo à 15/31 (2 étant le plus fort)
ffmpeg_variable_bitrate 15
# Je définis la compression en mpeg4
ffmpeg_video_codec mpeg4

# Pour le point 1 : Je définis 1 capture image toutes les 10 secondes
snapshot_interval 10

Tags: , , ,

Un lecteur de musique autonome

Je suis sûr que vous connaissez déjà beaucoup de lecteur audio sous GNU/Linux, celui que je vous propose est séparé en 2, MPD :

  • Un backend qui lit la musique sans qu’il soit nécéssaire d’avoir une interface graphique lancée
  • Un ou des frontend pour controler votre musique, l’intéret est qu’il peut etre déporté sur une autre machine, que ce soit un pc ou même un téléphone.

Le daemon en backend s’appelle mpd, la première fois, il vous faut indiquer où se trouve vos MP3, ainsi que l’interface audio de sortie (pouvant être alsa, oss, jack… sur le device que vous voulez). Voici les lignes modifiées de mon fichier /etc/mpd.conf qui peuvent vous être utiles :

music_directory « /media/mp3/ »
password « motdepasse@read,add,control,admin »
default_permissions « read »
audio_output {
type « alsa »
name « My ALSA Device »
device « hw:0,0 » # optional
format « 44100:16:2 » # optional
}
mixer_type « software »

J’ai ici choisis d’utiliser une connexion par mot de passe pour controler mpd.

Pour le frontend qui va nous servir à controler notre mpd, nous avons une multitude de choix, cela va du client en ncurses (dans un terminal comme ntop), à l’application sur téléphone portable en passant par de multiples clients graphiques ou plugins pour lecteurs répputés.

J’ai choisis sonata sous GTK, a vous de jouer !

Tags:

Bridgez votre vpn avec votre reseau domestique

Bridger des interfaces réseau a l’interet de simuler une connexion directe ou se comportant comme un hub, tout en ayant la possibilité de filtrer les packets.

Ici je vous explique la mise en place d’un bridge tel qu’il puisse fonctionner.

Le serveur possede 4 interfaces réseau :

eth0 : Connexion indépendante non filtrée permettant l’administration du serveur 192.168.99.0/24

eth1 et eth2 : Connexion bridgées (mode promiscus).

eth3 : Connexion cliente dhcp prévue pour une connexion filtrante du serveur dans un réseau client. (Médiathèque, entreprise)

tap0 : connexion du réseau privé virtuel

br0 : Connexion du bridge rassenmblant eth1, eth2, et tap0

Un bridge d’interface se compose en interfaces bridgé et en une interface bridge (br0) rassemblant ces derniers. Les interfaces bridgées doivent être sans ip et en mode promiscus. Nous précisons tout les paramètre réseau à l’interface br0.

Modifions la configuration d’openvpn

sudo nano /etc/openvpn/server.conf

Remplacez dev tun par dev tap0

Remplacez server 10.8.0.0 255.255.255.0
par
server-bridge 192.168.9.128 255.255.255.0 192.168.9.129 192.168.9.254
(où 192.168.9.1 sera l’ip du serveur et 192.168.9.129 192.168.9.254 sera la plage dhcp)

Créez l’interface tap0 et bridgez vos interfaces ainsi (attention ceci provoque une microcoupure réseau) :
sudo openvpn –mktun –dev tap0
sudo ifconfig tap0 up
sudo brctl addbr br0
sudo brctl addif br0 tap0
sudo brctl addif br0 eth1
sudo brctl addif br0 eth2
sudo ifconfig tap0 0.0.0.0 promisc up
sudo ifconfig eth1 0.0.0.0 promisc up
sudo ifconfig eth2 0.0.0.0 promisc up
sudo ifconfig br0 up
sudo ifconfig br0 192.168.9.1

Sur le client, remplacez dev tun par dev tap dans le fichier /etc/openvpn/client.conf

Tags: , , ,

Créer un réseau privé virtuel

Le réseau privé virtuel ou VPN (Virtual Private Network) permet de vous connecter à un réseau par un tunnel crypté. Vous pouvez ainsi vous y connecter depuis une entreprise, depuis chez quelqu’un.

Ses applications et avantages sont nombreuses :
– Avoir une liaison crypté sur un support non crypté (du Wifi ouvert par exemple)
– Se connecter à son réseau domestique depuis n’importe où
– Isoler/sécuriser les communications en interconnectant des postes par VPN

Pour ma part c’est surtout pour les deux premier points. Ce tutoriel s’adresse plus particulièrement aux utilisateurs d’Ubuntu.

Commencons

Sur le client

Installez openvpn et openssh-server
sudo apt-get install openssl openvpn openssh-server
Donnez le droit à l’écriture dans le répertoire de configuration openvpn
sudo chmod o+w /etc/openvpn

La suite se fait sur le serveur

Installez openvpn
sudo apt-get install openssl openvpnNous allons maintenant créer des jeux de certification grace aux outils se trouvant dans /usr/share/doc/openvpn/examples/easy-rsa/
Les clés et certificats générés seront crées dans le sous repertoire keys.
cd /usr/share/doc/openvpn/examples/easy-rsa/

Avant de commencer, nous allons modifier les reglages par defaut utilisés par ces outils.
sudo nano vars
Editez à la fin de ce fichier les paramètres afin qu’ils correpondent aux votres :
export KEY_COUNTRY=FR
export KEY_PROVINCE=NA
export KEY_CITY=Paris
export KEY_ORG= »MonOrganisation »
export KEY_EMAIL= »mon@email.ici »
Enregistrez et fermez.

Executez ce fichier (Notez bien qu’il s’agit d’un point et non de sh en debut de ligne)
. ./vars

Nettoyez les jeux de clés déjà présent (Les clées precements crées seront effacés du repertoire keys)
sudo ./clean-all

Executez la génération du certicat qui autentifira tout les jeux de clés :
sudo ./build-ca
Répondez aux questions par une simple validation de la touche enter

Executez la génération du jeu de clé serveur :
Ici remplacez server par le hostname de votre serveur
sudo ./build-key-server server
Validez les questions par defaut SAUF « Common name » où mettez votre hostname expliqué ci dessus.
Et répondez « y » aux deux dernière questions ( Sign the certificate ? [y/n] requests certified, commit ? [y/n] )

Faites la même chose (mais avec « build-key ») pour chcunes des clés à destination de client (nous nous occuperons de les transferer plus tard)
Ici remplacez client par le hostname de votre client
sudo ./build-key client
Validez les questions par defaut SAUF « Common name » où mettez votre hostname expliqué ci dessus.
Et répondez « y » aux deux dernière questions ( Sign the certificate ? [y/n] requests certified, commit ? [y/n] )
Il n’est pas nécéssaire d’utiliser un mot de passe si vous pensez que la clé (fichier) ne pourrat être compromise.

Executez la génération des paramètres Diffie-Hellman
sudo ./build-dh

Voilà, vos clés et certificats sont prets, nous allons maintenant les placer au bon endroit.

Placement des clés au bons endroits

Restez dans le répertoire /usr/share/doc/openvpn/examples/easy-rsa/Déplacez les clés serveurs (remplacez server par le hostname donné au serveur)
sudo mv keys/server.crt keys/server.key keys/ca.crt keys/ca.key keys/dh1024.pem /etc/openvpn/

Déplacez la clé client
sudo scp keys/ca.crt keys/fanchbox.crt keys/fanchbox.csr keys/fanchbox.key utilisateur@ip-du-client:/etc/openvpn/
sudo rm keys/ca.crt keys/fanchbox.crt keys/fanchbox.csr keys/fanchbox.key

Paramètrage du serveur openvpn

Réutilisons l’exemple proposé par openvpn
cd /etc/openvpn
sudo cp /usr/share/doc/openvpn/examples/sample-config-files/server.conf.gz .
sudo gunzip server.conf.gz

Editez le fichier /etc/openvpn/server.conf
sudo nano server.conf
Modifiez les ligne faisant référence aux fichier clés (remplacez server par le hostname donné au serveur)
cert server.crt
key server.key # This file should be kept secret
Enregistrez et fermez le fichier

Testez en lancant openvpn avec le fichier de configuration :
sudo openvpn /etc/openvpn/server.conf

Si vous avez des erreurs, ceux ci sont généralement assez explicite (file not found…) pour les résoudre facilement.

Thu Jan 31 12:49:34 2008 OpenVPN 2.0.9 i486-pc-linux-gnu [SSL] [LZO] [EPOLL] built on May 21 2007
Thu Jan 31 12:49:34 2008 Diffie-Hellman initialized with 1024 bit key
Thu Jan 31 12:49:34 2008 TLS-Auth MTU parms [ L:1542 D:138 EF:38 EB:0 ET:0 EL:0 ]
Thu Jan 31 12:49:34 2008 TUN/TAP device tun0 opened
Thu Jan 31 12:49:34 2008 ifconfig tun0 10.8.0.1 pointopoint 10.8.0.2 mtu 1500
Thu Jan 31 12:49:35 2008 route add -net 10.8.0.0 netmask 255.255.255.0 gw 10.8.0.2
Thu Jan 31 12:49:35 2008 Data Channel MTU parms [ L:1542 D:1450 EF:42 EB:135 ET:0 EL:0 AF:3/1 ]
Thu Jan 31 12:49:35 2008 UDPv4 link local (bound): [undef]:1194
Thu Jan 31 12:49:35 2008 UDPv4 link remote: [undef]
Thu Jan 31 12:49:35 2008 MULTI: multi_init called, r=256 v=256
Thu Jan 31 12:49:35 2008 IFCONFIG POOL: base=10.8.0.4 size=62
Thu Jan 31 12:49:35 2008 IFCONFIG POOL LIST
Thu Jan 31 12:49:35 2008 Initialization Sequence Completed

Votre serveur est maintenant à l’écoute. (tant que vous ne coupez pas le programme).

Pour que cette configuration soit reconnue par le service openvpn (vous savez, le /etc/init.d/openvpn start), éditez le fichier /etc/default/openvpn

sudo nano /etc/default/openvpn

Ajoutez la ligne suivant, enregistrez et fermez.

AUTOSTART= »server »

Openvpn serat alors lancé à chaque démarrage.

Paramètrage d’openvpn sur le client

Resécurisons le répertoire dont nous avons modifié les permission précedement
sudo chmod o-w /etc/openvpn

Réutilisons l’exemple proposé par openvpn
cd /etc/openvpn
sudo cp /usr/share/doc/openvpn/examples/sample-config-files/client.conf .

Editez le fichier de configuration (celui ci est prévu pour se connecter à un serveur précis)
sudo nano /etc/openvpn/client.conf
Modifiez les lignes suivantes à votre convenance :
#Remplacez server par le hostname du serveur (accessible par le client)
remote server 1194
#Remplacez le nom des fichiers pour utiliser les clés du client
cert fanchbox.crt
key fanchbox.key
Enregistez et fermez.

Il ne vous reste plus qu’a lancer openvpn avec ce fichier de configuration pour vous connecter au serveur par vpn. Cela va vous créer une nouvelle interface avec une ip que vous attribuera le serveur (ici 10.8.0.x).
sudo openvpn /etc/openvpn/client.conf

Ce tutoriel s’inspire en partie des pages openvpn sur toulouse-sans-fil et openvpn sur Ubuntu-fr

Si vous êtes sages je vous expliquerai peut-être comment bridger le vpn avec votre réseau domestique, et comment vous y connecter grâce à gnome-network-manager.

Have fun !

Tags: , , , ,

Redirection de port via SSH

Rediriger un port peut s’avérer très utile lorsque par exemple vous n’avez pas accès au port tant convoité sur un serveur.

Dans mon cas, je souhaite pouvoir utiliser la base de donnée mysql située sur un serveur principal, depuis un site qui se situe sur une autre serveur (dit de secours).

Ce schema illustre bien mon exemple, pour réaliser cela, il suffira d’ouvrir une connexion ssh depuis le serveur principale vers le serveur secondaire en utilisant la redirection de port. 😉

Tags: , , ,

Je n'aime pas les boîtes noires.