Créateur de blog de Nicolargo, je suis un partisan des logiciels libres et un passionné des nouvelles technologies.
L’actualité open-source de la semaine…
L’actualité du libre et de l’open source en vrac:
Autres choses ?
Le but de ce billet est de détailler l’installation d’un serveur VPN routé de type SSL sur un système FreeBSD 7. Nous utiliserons pour cela le logiciel libre OpenVPN (licence GPL v2).
Robustesse et qualité de sa pile IP font du système FreeBSD un bon « hôte » pour notre serveur VPN. Afin de ne pas surcharger le serveur avec des logiciels inutiles, j’ai choisi l’installation minimale (développeur, comprenant les « ports ») à partir du réseau (ISO 7.x-RELEASE-i386-bootonly).
Avant de commencer l’installation d’OpenVPN, il est préférable de s’assurer que notre système d’exploitation est à jour en suivant cette procédure.
On commence par installer le port OpenVPN avec la commande suivante:
pkg_add -r openvpn
On automatise le lancement en ajoutant la ligne suivante au fichier /etc/rc.conf:
openvpn_enable= »YES »
OpenVPN permet la création de tunnel VPN de type SSL. Il faut donc que votre serveur puisse gérer des clès de chiffrement. Les étapes à suivre sont les suivantes:
vi openssl.cnf
dir = /etc/ssl/CA
default_days = 3650 # Valable 10 ans…
default_bits = 2048 # Clès de 2048 bits
countryName_default = FR
stateOrProvinceName_default = PACA
localityName_default = Valbonne
0.organizationName_default = MaBoite
commonName_default = mondomaine.com
emailAddress_default = contact@mondomaine.commkdir /etc/ssl/CA
cd /etc/ssl/CA
mkdir certs
mkdir crls
mkdir newcerts
mkdir privatetouch index.txt
echo 01 > serial
echo 01 > crlnumberopenssl req -nodes -new -x509 -keyout private/cakey.pem -out cacert.pem -days 3650
> Laisser les options par défaut
A ce stade, on doit avoir notre clés créé dans le fichier private/cakey.pem:
ls /etc/ssl/CA/private
cakey.pem
On génère ensuite le fichier de révocation:
cd /etc/ssl/CA
openssl ca -gencrl -out crls/crl.pem
chown root:nobody crls/crl.pem
On passe maintenant à la génération de notre certificat pour notre serveur VPN:
cd /etc/ssl/CA/certs
openssl req -nodes -new \
-keyout vpn.mondomaine.com.key \
-out vpn.mondomaine.com.csr
> Laisser les options par défaut puis entrer un mot de passe
chmod 600 /etc/ssl/CA/certs/vpn.mondomaine.com.key
Puis on le signe:
openssl ca -out al-vpn1.alcasat.net.crt
\-in al-vpn1.alcasat.net.csr
\-policy policy_anything
Enfin on génère les paramètres Diffie-Hellman pour l’échange des clés:
openssl dhparam -out dh2048.pem 2048
Pour configurer OpenVPN, nous allons nous baser sur une configuration d’exemple fournie par OpenVPN dans le fichier /usr/local/share/doc/openvpn/sample-config-files/server.conf.
mkdir /usr/local/etc/openvpn/
cp /usr/local/share/doc/openvpn/sample-config-files/server.conf \
/usr/local/etc/openvpn/openvpn.conf
Puis éditer le fichier /usr/local/etc/openvpn/openvpn.conf en adaptant la configuration à votre réseau.
Voici ma configuration:
et le fichier .conf correspondant:
port 1194
proto udp
dev tunca /etc/ssl/CA/cacert.pem
cert /etc/ssl/CA/certs/al-vpn1.alcasat.net.crt
key /etc/ssl/CA/certs/al-vpn1.alcasat.net.key
crl-verify /etc/ssl/CA/crls/crl.pem
dh /etc/ssl/CA/certs/dh2048.pemserver 192.168.40.0 255.255.255.0
ifconfig-pool-persist ipp.txt
push « route 192.168.1.0 255.255.255.0 »keepalive 10 120
cipher BF-CBC
comp-lzouser nobody
group nobodypersist-key
persist-tunstatus openvpn-status.log
verb 6
mute 20
On utilise le script système:
/usr/local/etc/rc.d/openvpn start
Pour vérifier que le tunnel VPN est prêt à accueillir des clients, on peut vérifier que le preocess openvpn est bien lancé et que l’interface tun0 est bien présente:
/usr/local/etc/rc.d/openvpn status
openvpn is running as pid 2212.ifconfig tun0
tun0: flags=8051<UP,POINTOPOINT,RUNNING,MULTICAST> metric 0 mtu 1500
inet 192.168.40.1 –> 192.168.40.2 netmask 0xffffffff
Opened by PID 2207
Pour relancer le serveur (en cas de changement de configuration):
/usr/local/etc/rc.d/openvpn restart
Pour arrêter le serveur:
/usr/local/etc/rc.d/openvpn stop
La consultation des logs peut être faire via la commande:
tail -f /var/log/messages | grep openvpn
Si votre réseau hébergeant le serveur VPN comporte des routeurs il faut leur ajouter la route suivante (exemple donnée pour un ajout de route sur un routeur FreeBSD):
route add -net 192.168.40.0/24 @IP-SERVEUR-VPN
A partir du serveur VPN, on génére les clés pour le nouveau client:
cd /etc/ssl/CA/certs
openssl req -nodes -new -keyout vpn-nicolargo.key -out vpn-nicolargo.csr
Generating a 2048 bit RSA private key
………………………………………..+++
……………….+++
writing new private key to ‘vpn-nicolargo.key’
—–
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter ‘.’, the field will be left blank.
—–
Country Name (2 letter code) [FR]:
State or Province Name (full name) [PACA]:
Locality Name (eg, city) [Valbonne]:
Organization Name (eg, company) [MaBoite]:
Organizational Unit Name (eg, section) []:
Common Name (eg, YOUR name) [mondomaine.com]:vpn-nicolargo.mondomaine.com
Email Address [contact@mondomaine.com]:monadresse@mondomaine.comPlease enter the following ‘extra’ attributes
to be sent with your certificate request
A challenge password []:monpassword
An optional company name []:
Il faut changer le fichier /etc/ssl/CA/serial (incrémenter la valeur de 1).
echo 02 > /etc/ssl/CA/serial
Puis signer le certificat:
openssl ca -out vpn-nicolargo.crt \
-in vpn-nicolargo.csr -policy policy_anything
Sur la machine cliente, on copie les 3 fichiers ainsi que la clés serveur cacert.pem dans le répertoire /etc/ssl/certs (à créer si il n’existe pas).
On doit se retrouver avec nos 4 fichiers:
ls /etc/ssl/certs/*
/etc/ssl/certs/cacert.pem
/etc/ssl/certs/vpn-nicolargo.crt
/etc/ssl/certs/vpn-nicolargo.csr
/etc/ssl/certs/vpn-nicolargo.key
On protége nos fichiers:
groupdadd nobody
chown root:nobody /etc/ssl/CA/cacert.pem
chown root:nobody /etc/ssl/CA/certs/vpn-nicolargo.*
chmod 600 /etc/ssl/CA/certs/vpn-nicolargo.key
Après installation d’OpenVPN sur votre machine cliente, on le configure en créant le fichier client.conf dans le répertoire /etc/openvpn/ (sous GNU/Linux Ubuntu):
sudo vi /etc/openvpn/client.conf
client
dev tun
proto udp
remote al-vpn1.alcasat.net 1194
nobind
user nobody
group nobody
persist-key
persist-tun
ca /etc/ssl/certs/cacert.pem
cert /etc/ssl/certs/vpn-hennionn.crt
key /etc/ssl/certs/vpn-hennionn.key
cipher BF-CBC
comp-lzo
verb 6
mute 20
Pour monter le VPN entre notre client et le serveur, on utilise le script système (sous GNU/Linux Ubuntu):
# sudo /etc/init.d/openvpn start client
* Starting VPN ‘client’ [OK]
L’arrêt se fera tout aussi simplement:
# sudo /etc/init.d/openvpn stop client
* Stopping VPN ‘client’ [OK]
Par défaut, au démarrage de la machine, OpenVPN va lancer tout les tunnels VPN dont il trouve une configuration dans le répertoire /etc/openvpn/. Si vous souhaitez désactiver cette fonction et monter vous même le VPN à la main, il faut éditer le fichier /etc/default/openvpn (sous GNU/Linux Ubuntu) et décommenter la ligne suivante:
AUTOSTART= »none »
Il est possible de configurer d’autres clients en suivant la même procédure, le tunnel VPN étant routé, il peut accueillir plusieurs utilisateurs en même temps.
Des clients OpenVPN avec interface graphique sont également disponibles sous Windows et Mac OS X.
Quelques sources utiles à la rédaction de ce billet:
Petite note à destination des utilisateurs de FreeBSD qui souhaite maintenir leur système à jour. Nous allons utiliser l’utilitaire freebsd-update.
La première chose à faire est de vérifier la version actuelle de votre système FreeBSD:
# uname -a
FreeBSD monbeauserveur 7.0-RELEASE FreeBSD 7.0-RELEASE #0
Si la version actuelle diffère de la dernière version disponible, on lance la mise à jour:
# freebsd-update upgrade -r 7.1-RELEASE
# freebsd-update install
On relance le système:
# shutdown -r now
On finalise la mise à jour:
# freebsd-update install
Puis on relance une dernière fois le système:
# shutdown -r now
Enfin on vérifie que tout est OK:
# uname -a
FreeBSD monbeauserveur 7.1-RELEASE FreeBSD 7.1-RELEASE #0
Il est également conseiller de mettre à jour vos logiciels tiers en suivant cette procédure.
Nous allons dans ce billet aller un peu plus dans le détail du fonctionnement de GStreamer (le Framework multimédia libre).
GStreamer est un framework multimédia: c’est à dire un ensemble de bibliothèques, d’outils et de conventions permettant le développement d’applications (source Wikipédia). Par multimédia, on attend ici la manipulation d’objets vidéo et audio.
Il est composé:
GStreamer est composé d’un cœur (GStreamer Core) permettant de construire une séquence d’actions à effectuer sur vos objets multimédia. Ce cœur s’occupe de la communication entre les différentes briques en gérant les entrées/sorties. Il manipule les données sous forme de blocs et se base sur une architecture logicielle objet.
Les plugins manipulent les objets multimédia. On peut diviser les plugins en différentes catégories:
Il faut noter que les plugins GStreamer sont livrés sous la forme de 3 packages:
gst-plugins-good: ceux sont les plugins jugés de bonnes qualités par les développeurs et qui sont distribué sous licences LGPL.
gst-plugins-ugly: ceux sont les plugins jugés de bonnes qualités mais qui peuvent poser des problèmes de licenses (non libres).
gst-plugins-bad: ceux sont les plugins en développement dont la qualité et/ou stabilité doivent être améliorés.
Afin d’expliquer le plus simplement le fonctionnement de GStreamer, nous allons prendre l’exemple d’une application ayant pour but de lire un fichier multimédia au format OGG (contenant des données audio encodées en Vorbis et vidéo encodées en Theroa) pour l’afficher sur votre écran et l’écouter sur vos haut parleurs.
Le schéma du framework correspondant est le suivant:
La classe principal est nommé pipeline. C’est l’enveloppe qui va contenir l’ensemble des actions a effectuer.
Le Pipeline contient une chaine d’élements (elements). L’élément est la classe la plus importante dans GStreamer. A chaque élément est associé une fonction (plugin).
On distingue 3 types d’élements:
Voici par exemple l’élément qui permet la lecture d’un fichier depuis votre disque dur: file-source.
Pour vous donner une idée, voici le code C qui permet la création d’un élément de test (fakesrc):
#include <gst/gst.h>
int
main (int argc,
char *argv[])
{
GstElement *element;
/* init GStreamer */
gst_init (&argc, &argv);
/* create element */
element = gst_element_factory_make (« fakesrc », « source »);
if (!element) {
g_print (« Failed to create element of type ’fakesrc’\n »);
return -1;
}
gst_object_unref (GST_OBJECT (element));
return 0;
}
Les lecteurs familiers avec GLib ne seront pas dépaysés…
Les pads sont les entrées/sorties des éléments. Ils servent à interconnecter les éléments entre eux. Il peut inclure des fonctions de vérification afin de s’assurer que le format des données correspond à ce qu’il attend. On peut distinguer deux sous ensembles de pad:
Il est possible d’associer plusieurs pads sinks et srcs à un même élément.
Exemples de pads pour l’élément vorbis-decoder:
Les liens entre les éléments se font toujours entre un pad src et un pad sink:
Les pads sont de loin les objets les plus complexes dans GStreamer. Ils contiennent un ensemble de paramètres (statique ou dynamique) permettant de définir les données attendues ou générées. Par exemple en tapant la commande « gst-inspect theoraenc » qui donne la description du plugin de décodage video Theroa:
Pad Templates:
SRC template: ‘src’
Availability: Always
Capabilities:
video/x-raw-yuv
format: I420
framerate: [ 0/1, 2147483647/1 ]
width: [ 1, 2147483647 ]
height: [ 1, 2147483647 ]SINK template: ‘sink’
Availability: Always
Capabilities:
video/x-theora
On peut y voir qu’il s’attend à avoir comme source une vidéo au format RAW-YUV, avec un nombre d’image par seconde et une taille pouvant varier selon le range affiché. En sortie, l’élement produira un vidéo au format THEORA.
Les bins sont des pipelines prédéfinis que l’on peut inclure comme de simple éléments dans une nouveau pipeline. Celà permet de simplifier grandement certaines actions complexe (rtpbin en est un bon exemple !).
Exemple de création d’un bin en langage C:
#include <gst/gst.h>
int
main (int argc,
char *argv[])
{
GstElement *bin, *pipeline, *source, *sink;
/* init */
gst_init (&argc, &argv);
/* create */
pipeline = gst_pipeline_new (« my_pipeline »);
bin = gst_bin_new (« my_bin »);
source = gst_element_factory_make (« fakesrc », « source »);
sink = gst_element_factory_make (« fakesink », « sink »);
/* First add the elements to the bin */
gst_bin_add_many (GST_BIN (bin), source, sink, NULL);
/* add the bin to the pipeline */
gst_bin_add (GST_BIN (pipeline), bin);
/* link the elements */
gst_element_link (source, sink);
[..]
}
J’espère que cette rapide introduction vous aura un peu éclairé sur les possibilités de GStreamer. Nhésitez pas à poser des questions et remarques sur le sujet dans l’espace GStreamer du forum de Nicolargo.
Sources:
L’actualité open-source de la semaine…
L’actualité du libre et de l’open source en vrac:
Autres choses ?
MiniUPnP est une implémentation libre du protocole NAT-PMP. Développé par Apple, ce successeur de UPnP IGD permet de configurer automatique et à la demande des applications des règles de NAT sur votre routeur d’accès. Free vient d’ajouter cette fonction sur le firmware des Freebox.
Nous allons voir dans ce billet comment fonctionne ce protocole et comment transformer votre routeur/firewall PF FreeBSD en un daemon NAT-PMP.
NAT-PMP est un protocole basée sur le protocole Bonjour. Ce dernier utilise des trames UDP sur le port 5351 qui sont envoyé vers l’adresse de la passerelle par défaut de votre réseau.
Il permettant à une application de:
Si l’adresse publique de la passerelle par défaut change, une alerte au format multicast (adresse 224.0.0.1 sur le port 5351) sera envoyée sur le réseau. Elle contiendra en donnée la nouvelle adresse.
Le daemon en question s’appelle minipnpd et est présent dans les ports de FreeBSD (/usr/ports/net/miniupnpd).
L’installation est classique:
portinstall net/miniupnpd
Il faut également ajouter les règles suivantes dans votre fichier de configuration PF (/etc/pf.conf par défaut):
# NAT section
# UPnPd rdr anchor
rdr-anchor « miniupnpd »# Rules section
# uPnPd rule anchor
anchor « miniupnpd »
puis relancer les règles PF:
pfctl -f /etc/pf.conf
et enfin ajouter la ligne suivante dans votre fichier /etc/rc.conf:
miniupnpd_enable= »YES »
La configuration doit se faire par un fichier /usr/local/etc/miniupnpd.conf. Vous pouvez utiliser le template suivant (à adapter à votre réseau):
# WAN network interface
ext_ifname=em0
# if the WAN interface has several IP addresses, you
# can specify the one to use below
#ext_ip=# there can be multiple listening ips for receiving SSDP traffic.
# the 1st IP is also used for UPnP Soap traffic.
listening_ip=192.168.0.254
port=5555# bitrates reported by daemon in bits per second
bitrate_up=131072
bitrate_down=524288# default presentation url is http address on port 80
#presentation_url=# report system uptime instead of daemon uptime
system_uptime=yes# notify interval in seconds default is 30 seconds.
#notify_interval=240# log packets in pf
#packet_log=no# uuid : generated by the install a new one can be created with
# uuidgen
uuid=%%UUID%%# UPnP permission rules
# (allow|deny) (external port range) ip/mask (internal port range)
# A port range is <min port>-<max port> or <port> if there is only
# one port in the range.
# ip/mask format must be nn.nn.nn.nn/nn
allow 1024-65535 192.168.0.0/24 1024-65535
deny 0-65535 0.0.0.0/0 0-65535
Pour lancer le daemon, il faut lancer la commande suivante:
/usr/local/etc/rc.d/miniupnpd start
Le plus simple est d’utiliser une des applications compatibles UPnP (voir liste dans le Wiki) ou bien d’utiliser le client en ligne de commande miniupnpc (compilable sous Linux, BSD, Mac OS X et Windows…).
Bien sûr ce daemon peut présenter un trou de sécurité assez important (possibilité d’ajouter des règles sur votre Firewall), il faut donc prendre toutes les précautions nécessaires sur les réseaux sensibles (notamment au niveau de la configuration de la section UPnP permission rules).
Grâce à la contribution de Thierry Legras, voici une nouvelle version de SJitter, mon outil en ligne de commande permettant de tester un réseau, notamment au niveau débit, délai et gigue. SJitter est disponible sous Linux, BSD, Mac OS X et Windows (via cygwin).
Cette nouvelle version apporte un meilleur control au niveau du tag permettant de faire les tests en IPv6 et surtout la possibilité (via l’option « -s ») de fixer le champs ToS des paquets IPv4 (très utile pour tester votre configuration QoS).
La page officielle de SJitter est ici, la forge là.
Lorenzo Cammilleri, stagiaire ingénieur, vient de finaliser une procédure pour compiler GStreamer (le framework multimédia) sous Microsoft Windows. Avant de lui laisser le clavier, je vous donne l’adresse de son blog ou il trace sont travail:
http://lorenzocam.wordpress.com/
Ce billet est largement inspiré de cette page ici. Ayant rencontré de nombreux problèmes, Andoni Morales Alastruey a modifié sa page puisqu’il manquait certaines étapes qui sont aussi décrites ici.
Voici la marche à suivre pour pouvoir compiler Gstreamer Winbuilds avec Visual Studio.
– Télécharger et installer Tortoise SVN: ICI
Dans le menu du click droit de la souris apparaît maintenant “SVN Checkout”.
– Dans un dossier vide, faire SVN Checkout de cette adresse : https://forja.rediris.es/svn/csl-longomatch/GStreamer-WinBuild/trunk
Les fichiers et dossiers vont être progressivement téléchargés.
– Installer Python
– Installer Perl
– Télécharger et installer le DirectX SDK
– Ouvrir le fichier C:\Program Files\Microsoft SDKs\Windows\v6.1\Samples\Multimedia\DirectShow\BaseClasses\baseclasses.sln avec Visual Studio
– Compiler en mode Debug_MBCS et Release_MBCS
– Ouvrir le fichier build\vsprops\common.vsprops de l’environnement Gstreamer et changer les macros MicrosoftSDK et DirectX pour spécifier les bons chemins
– Ouvrir le fichier build\GStreamer.sln et compiler en mode ReleaseWdkCrt sans se soucier des erreurs
– Compiler ensuite en mode Release : à ce moment il ne devrait plus y avoir d’erreurs !
Voilà tout !
—
L’actualité open-source de la semaine…
L’actualité du libre et de l’open source en vrac:
Autres choses ?
Vous avez un Mac et un téléphone portable ? Vous connaissez alors surêment le logiciel iSync qui permet de synchroniser vos contacts et calendriers.
Il manque cependant une fonction importante à ce petit logiciel: la possibilité d’automatiser cette synchronisation. En attendant qu’Apple ajoute cette fonction à iSync (et oui c’est ça le problème avec les logiciels propriétaires, il faut attendre :(), voici un petit hack qui va fonctionellement nous rendre le même service.
Nous allons pour cela utiliser un AppleScript. Il faut éditer un fichier nommé SyncNow.scpt dans le répertoire ~/Library/Scripts/ et contenant le code suivant:
tell application « Finder »
set iSyncRunning to 1
tell application « iSync » to synchronize
tell application « iSync »
repeat while (syncing is true)
delay 5
end repeat
if iSyncRunning is not true then
quit
end if
end tell
end tell
Ce script va ouvrir iSync, lancer un synchronisation, puis fermer iSync. Si le téléphone n’est pas à porté de Bluetooth, le script boucle jusqu’à ce que la synchronisation soit faite.
Vous pouvez tester le bon fonctionnement de ce script en ouvrant un terminal et en saisissant la commande suivante:
~/Library/Scripts/SyncNow.scpt
Afin d’automatiser le lancement de ce script, nous allons utiliser crontab (venu du monde unix). Elle permet de lancer une commande à une heure précise. Il faut ouvrir un terminal, puis saisir:
crontab -e
Vous allez vous retrouver dans l’éditeur « vi ». Pour ajouter la ligne suivante, il faut au préalable cliquer sur la touche i.
0 11 * * 1-5 osascript Library/Scripts/SyncNow.scpt
Pour sortir de l’éditeur vi, il faut appuyer successivement sur les touche ESC ensuite : puis x et enfin ENTREE.
Et voilà, tout les matin à 11h00 (0 11), du lundi au vendredi (1-5), le script sera lancé et la synchronisation effectué !
