Vue normale

Il y a de nouveaux articles disponibles, cliquez pour rafraîchir la page.
À partir d’avant-hierMagdiBlog

2 – Installation et configuration (màj le 07.07.2015)

Par : Olivier
7 juillet 2015 à 12:00

La manière la plus souple pour afficher des données sur un écran est d’utiliser le langage HTML (comme pour les pages web). Pour rendre le tout un peu plus dynamique, nous utiliserons PHP et un peu de JavaScript. Ces technologies et langages sont très répendues (web) et très simples à utiliser.

En résumé, le Pi HomeDashScreen est un navigateur web, qui affiche une page web 🙂 Le gros avantage de cette solution, c’est que vous pouvez avoir plusieurs écrans dans votre maison qui affichent la même URL. Si cette URL est accessible depuis l’extérieur de votre réseau, vous pouvez afficher  votre écran d’information depuis n’importe où 🙂

Dans mon cas, le serveur web est installé directement sur le Pi qui est relié à l’écran. Mais vous pouvez très bien vous contenter d’afficher l’URL publiée par un serveur distant 🙂

IMG_5389

Note : Pour être franc, c’est la partie la plus chi… la moins intéressante ! Si vous savez installer un serveur web et lancer une application au démarrage du système, passez directement à la suite. Notez toutefois que j’explique ici comment lancer une application (Firefox/Chromium), sans gestionnaire de connexion (ou display manager), sans gestionnaire de bureau et avec un gestionnaire de fenêtre minimaliste. Pour avoir passé plusieurs jours à trouver comment faire, je pense que ça peut être utile 🙂 Rien que l’auto-login en mode console, ça peut servir !

Note : Ce tuto a été mis à jour le 16.03.2015 pour fonctionner facilement avec une installation classique des dernières versions de Raspbian. Un grand merci à chipsetseo et au magazine The MagPi pour les infos 🙂

Note 2 : Je précise que le but est ici de ne pas passer par un environnement de bureau (tel que LXDE disponible par défaut sous Raspbian) inutile et lourd pour afficher une page web, mais simplement un gestionnaire de fenêtre (et notamment openbox) qui est nécessaire et suffisant pour l’affichage d’une fenêtre d’un navigateur comme Chromium. Il convient donc de ne pas activer l’interface graphique via l’outil raspi-config ; voire même de la désinstaller totalement en suivant ce tuto : Supprimer les paquets inutiles pour alléger Raspbian

Installation des paquets

raspbian_logo_tinyJe ne reviens pas sur l’installation de Raspbian sur la carte SD, ce sujet ayant été traité de nombreuses fois, et notamment dans les projets Pi TimeLapse et Pi CarJukeBox. Partons du principe que vous avez un Pi fonctionnel sous Raspbian, configuration réseau effectuée (ethernet ou wifi) et un accès à Internet.

Vous allez avoir besoin de quatres composants clés :

  • Apache : serveur web, pour assurer la publication du contenu à afficher
  • PHP : pour pouvoir traiter dynamiquement les données à afficher
  • Chromium : pour afficher le contenu HTML à l’écran
  • Openbox : gestionnaire de fenêtre très léger pour gérer l’affichage de Firefox
  • xinit : permet d’installer tout ce qu’il faut pour le serveur X (qui se charge véritablement d’afficher toutes ces choses à l’écran)

Pour installer ces composants, utilisez la commande suivante :

apt-get install apache2 php5 php5-cli chromium openbox xinit

Toutes les dépendances seront installées automatiquement.

Nous aurons ensuite besoin d’un certain nombre d’outils :

  • imagemagick : pour manipuler des images
  • xplanet : pour générer les images de la terre et de la lune
  • unclutter : pour masquer le curseur de la souris
  • x11-xserver-utils : pour gérer la mise en veille de l’écran

Comme précédemment nous utilisons la commande apt-get install :

apt-get install imagemagick php5-imagick php5-gd xplanet unclutter mingetty x11-xserver-utils

Configuration

Le but est qu’à chaque démarrage du Pi, le système lance Firefox en plein écran sur l’URL du contenu que nous souhaitons afficher, tout en masquant le curseur de la souris. Dans mon cas, je mets en veille l’écran à 1h du matin, et je le réveille à 7h30.

Apache

Rien de plus simple car nous pouvons directement utiliser la configuration par défaut ou presque. Le fichier qui nous intéresse est  /etc/apache2/sites-enabled/Default. Vous pouvez le vider et remplacer son contenu par :

<VirtualHost *:80>
        DocumentRoot /var/www
</VirtualHost>

Cette configuration minimaliste suffira pour ce que nous souhaitons faire. /var/www correspond au répertoire qui contiendra les fichiers à afficher sur l’écran.

Vous pouvez créer un fichier « /var/www/index.html » et y écrire « coucou« . Ouvrez Firefox et allez à l’adresse http://localhost (localhost, désigne la boucle locale, autrement dit, c’est votre machine, home sweet localhost !). Vous devriez voir votre message « coucou » 🙂

Lancer Chromium au démarrage sur la bonne URL

Ceci ce fait en trois étapes. Dans un premier temps, il faut s’auto-loguer en tant qu’utilisateur au démarrage du système (dans mon cas, mon nom d’utilisateur est Jarvis. On ne se moque pas 😉 ). Une fois logué, l’utilisateur lance une session du gestionnaire de fenêtre Openbox. Lorsqu’Openbox démarre, il lance à son tour Chromium.

Auto-login au démarrage en mode console

Editez le fichier /etc/inittab et remplacez la ligne :

1:2345:respawn:/sbin/getty 115200 tty1

par :

1:2345:respawn:/bin/login -f jarvis tty1/dev/tty1 2>&1

(Remplacez « jarvis » par votre nom d’utilisateur)

Lancer une session Openbox automatiquement

Cela concerne l’utilisateur qui se connecte au démarrage, nous devons donc éditer le fichier /home/jarvis/.bash_profile. Il se peut que ce fichier n’existe pas, vous devrez alors le créer et y inscrire :

startx

Lancer Firefox au démarrage d’Openbox

Très simple, il suffit d’éditer le fichier  /home/jarvis/.config/openbox/autostart et d’ajouter en fin de fichier la commande pour lancer Chromium :

chromium -kiosk –incognito

(-kiosk pour lancer en mode plein écran ; –incognito pour que chromium se lance toujours en ignorant la session précédente)

Configuration de Chromium

Nous approchons du but. Il ne reste plus qu’à configurer Firefox pour sa page d’accueil par défaut soit http://localhost. Pour cela, il suffit d’aller dans les préférences de Chromium et de saisir http://localhost dans le champ « page d’accueil ».

Mise en veille à heure fixe

Pour gérer la mise en veille de votre moniteur à heure fixe, vous pouvez utiliser CRON, qui est un planificateur de tâche. En root, tapez crontab -e puis ajouter les deux lignes suivantes :

0 1 * * *       su - jarvis -c "xset -display :0 dpms force off" # met le moniteur en veille à 1h du matin
30 7 * * *      su - jarvis -c "xset -display :0 dpms force on" #réveille le moniteur à 7h30 du matin

Ceci permet uniquement de mettre en veille le moniteur. Si vous souhaitez éteindre totalement votre Pi, vous devez remplacer les deux lignes ci-dessus par la ligne :

0 1 * * *       /sbin/shutdown -h now # éteint le PI à 1h du matin

Ceci aura pour effet d’éteindre proprement votre Pi. Il ne vous reste plus qu’à utiliser un programmateur horraire, pour couper l’alimentation et la rallumer le lendemain matin.

Installation terminée

Si vous avez bien suivi l’ensemble de ce qui est expliqué dans cet article, vous devriez voir votre page d’accueil, qui n’affiche pour le moment que « coucou », à chaque démarrage de votre Pi. A partir de maintenant, nous allons nous concentrer sur les différents modules à afficher 🙂 C’est la partie la plus sympa 🙂

L’article 2 – Installation et configuration (màj le 07.07.2015) est apparu en premier sur MagdiBlog.

Créer une passerelle sécurisée avec un Raspberry Pi

Par : Olivier
20 février 2015 à 21:43

raspberry_pi_authentification_chiffrement_600

Qu’il s’agisse de domotique, de vidéo-surveillance ou de simple partage de fichiers, les besoins de se connecter à un équipement se trouvant à l’intérieur de notre maison à travers Internet se multiplient. Bien que ces systèmes soient de plus en plus généralisés et faciles à mettre en place, la question de la sécurité est souvent reléguée au second plan.

Comment s’assurer que personne ne nous espionne avec nos caméras IP installées dans notre salon ? Comment empêcher une personnes curieuse, voire malveillante, de jouer avec notre centrale domotique ?

Dans l’ensemble de mes articles, j’ai toujours insisté sur l’importance de sécuriser ces accès. Aujourd’hui, je vous propose de voir comment créer un point d’accès sécurisé grâce à un Raspberry Pi.

Contexte

camera_ipPrenons l’exemple d’une caméra IP. Ce type de caméra dispose généralement d’une interface web qui vous permet de la configurer et de visionner les images. Vous vous connectez à cette interface web grâce à un navigateur en vous connectant sur une URL du type http://192.168.0.17:8080. (192.168.0.17 étant l’adresse IP de votre caméra sur le réseau interne à votre maison).

Cela signifie que le service (c’est à dire le logiciel) qui vous permet d’interagir avec votre caméra, est disponible sur le port 8080/TCP. Si vous voulez pouvoir accéder à votre caméra depuis l’extérieur de votre maison, c’est à dire en passant par Internet, vous allez devoir configurer votre box, modem ou routeur, pour autoriser les flux sur ce même port 8080/TCP à destination de l’adresse IP interne de votre caméra. Votre box agit alors comme un « aiguilleur », qui lorsqu’il recevra une connexion depuis l’extérieur de votre réseau sur le port 8080/TCP redirigera le flux vers votre caméra IP.

Le hic, c’est que cela fonctionnera avec vous, mais aussi avec tout le reste de la planète ! N’importe qui connecté à internet peut se connecter à votre caméra !

Vous me direz : « Oui, mais il y a un mot de passe !« . En effet, il reste à trouver le mot de passe (si vous en avez un, et qu’il est suffisamment compliqué) pour pouvoir vous espionnez. Gardez cependant à l’esprit que de l’extérieur (comprenez depuis Internet), si vous pouvez vous connecter à votre caméra/box domotique/serveur de fichiers, alors tout le monde peut s’y connecter également.

Notions et principes de base en sécurité informatique

Pour sécuriser l’accès à un service (logiciel) à travers un réseau tel qu’Internet, il y a trois choses à mettre en place :

  • protéger l’accès grâce à un mot de passe : réserver l’accès à ceux qui connaissent le mot de passe
  • vérifier l’identité de la personne qui se connecte : s’assurer que la personne qui tente de se connecter est bien une personne autorisée
  • chiffrer les informations et les données lorsqu’elles transitent sur le réseau : empêcher que quelqu’un intercepte votre mot de passe et vos données personnelles

En effet, un mot de passe seul ne suffit pas car il peut être découvert ou volé. Et si vous pensez que personne ne peut vous voler votre mot de passe, détrompez vous ! La chose à garder en tête, c’est que lorsque vous êtes à l’extérieur de votre maison, vous utilisez un réseau que vous ne maîtrisez pas (WiFi publique, réseau 3G/4G de votre opérateur mobile, réseau de votre entreprise, etc…). Sur ces réseaux, vous n’avez absolument aucune garantie que personne n’observe ce que vous faites. On peut même dire que vous avez la certitude que vos données peuvent être lues par quelqu’un. Pour résumer : Si vous saisissez votre mot de passe quelque part, il sera visible par les équipements du réseau que vous utilisez.

Si vous n’êtes toujours pas convaincu par cette fragilité, je vous conseille vivement de lire le dossier dédié à ce sujet dans le dernier Canard PC Hardware (n° 23) http://www.canardpc.com/news-53226-cpc_hardware_n__23_est_disponible__.html. Vous verrez avec quelle facilité il est possible de récupérer vos mots de passe.

Comment faire pour se protéger ?

La solution pour éviter que votre mot de passe soit intercepté, est de chiffrer (comprenez crypter) les flux entre vous (votre navigateur, votre smartphone), et l’appareil auquel vous vous connectez (caméra ip, box domotique,…). Nous verrons plus loin comment mettre cela en place.

Enfin, pour nous assurer que notre accès est sécurisé, il convient de mettre en place un « contrôle d’identité« . Dans la vraie vie, pour contrôler que vous êtes bien la personne que vous prétendez être, on vous demande votre Carte Nationale d’Identité. Cette carte d’identité garantie que vous êtes bien vous en s’appuyant sur deux choses : la première c’est que vous la possédez (vous prouvez votre identité en étant détenteur de votre carte) ; la seconde est qu’elle a été faite par une autorité suprême, à savoir l’Etat, qui a préalablement réalisé les contrôles nécessaires avant de vous délivrer votre carte d’identité qui indique que vous êtes vous (Une carte réalisée par le boulanger du coin n’aurait pas la même authenticité). Pour résumer : Vous possédez une carte d’identité, et c’est l’Etat (entité de confiance) qui atteste que c’est bien vous. Vous pouvez donc récupérer votre colis à La Poste, puisque c’est l’Etat qui garantie que vous êtes bien vous. Retenez bien ce principe, car il est très important pour comprendre la suite.

Dans le monde de la sécurité, on parle d’authentification forte lorsqu’il est nécessaire de présenter au moins deux choses pour vous connecter : quelque chose que vous connaissez (un mot de passe), et quelque chose que vous possédez (une carte, un badge, un certificat) ou que vous êtes (une empreinte digitale, une empreinte vocale…).

Certificats

httpsEn informatique, pour désigner l’équivalent d’une carte d’identité, on parle de certificat. Lorsque vous allez sur un site internet utilisant un certificat, vous voyez généralement un petit cadenas dans la barre d’adresse et l’URL commence par https. En cliquant sur le cadenas, on peut afficher le certificat utilisé par le site :

certificat

Nous voyons que ce certificat a été émis par VeriSign qui est une autorité de certification reconnue dans le monde de l’Internet (à l’instar de l’Etat pour nos CNI). Ce certificat à été émis pour le site www.paypal.com de la société PayPal. Le site de Paypal présente donc un certificat qui atteste de son identité, et que cette identité à été vérifiée par VeriSign. Nous avons donc l’assurance qu’il s’agit bien du site de PayPal 🙂

Il s’agit là d’un certificat serveur, pour que les clients puissent vérifier qu’il s’agit bien d’un serveur légitime. Pour notre passerelle sécurisée, nous ajouterons un certificat client, pour que le serveur puisse valider que le client est bien légitime également.

A retenir

Pour garantir la sécurité d’un accès au travers d’un réseau il est nécessaire vérifier que vous êtes vous, que vous connaissez le mot de passe, et que ces données transitent chiffrées (cryptées) sur le réseau.

Pardonnez la longueur de ces explications, mais il nécessaire de bien comprendre les tenants et les aboutissants de ces éléments pour mettre en place un système fiable et sécurisé. Ceci étant dit, passons au choses sérieuses en réalisant un système qui mette tout ceci en œuvre. Procédons 🙂

Le matériel nécessaire

Rien de bien compliqué, un pack de base (Raspberry Pi, alimentation, carte SD et boitier) suffit. Je conseille toutefois le choix d’un modèle équipé d’un port Ethernet.

Raspberry_Pi_2Le Raspberry Pi 2 étant vendu au même prix que le B+, ne nous en privons pas !

Construction de la passerelle sécurisée : schéma global

raspberry_pi_passerelle_securisee

Le principe global est de mettre la passerelle sécurisée dans une DMZ (zone démilitarisée) et de bloquer les accès directs grâce au firewall (pare-feu) de la box Internet (ou du modem/routeur). De cette manière, tous les flux provenant de l’extérieur (Internet) sont redirigés vers la passerelle qui se charge de chiffrer les flux et de vérifier l’identité du visiteur. Ces deux étapes s’appuient sur des certificats. Si tout est ok, la passerelle redirige à son tour les flux vers l’équipement ciblé (On peut imaginer plusieurs équipement, caméras, une box domotique, un serveur de fichier,… ). L’authentification par mot de passe est assuré par l’équipement lui même en dernier ressort.

Note : Si votre box Internet ne permet pas de créer une DMZ, vous pouvez vous contenter de placer la passerelle directement dans votre réseau local. Il s’agira alors de configurer le firewall de la box pour rediriger tous les flux externes vers la passerelle.

Installation et configuration

Dans un premier tant il convient d’installer une Raspbian en bonne et due forme. Une fois démarré et la configuration de la carte réseau effectuée, nous aurons besoin d’installer Apache.

apt-get install apache2

Création des certificats

Nous allons donc créer un certificat serveur, et un certificat client (notez que vous pouvez créer autant de certificats client que vous le souhaitez, pour plusieurs personnes par exemple). Pour que ces certificats soient valides, nous devons les faire signer par une autorité de certification qui en attestera l’authenticité. Vous pouvez trouver ces services chez de nombreux fournisseurs reconnus, mais cela à un prix. Nous allons donc créer notre propre autorité de certification. Notez que cela n’est pertinent uniquement parce que travaillons sur nos environnements personnels, car l’autorité de certification que nous allons créer ne sera reconnue que par nous même.

L’outil qui permet de faire cela est openssl. Il est installé de base sur Raspbian.

Création de l’autorité de certification ou CA

Créez un fichier openssl.cnf et placez y cette configuration :

[ req ]
default_md = sha1
distinguished_name = req_distinguished_name

[ req_distinguished_name ]
countryName = Country
countryName_default = FR
countryName_min = 2
countryName_max = 2
localityName = Locality
localityName_default = France
organizationName = Organization
organizationName_default = Raspberry
commonName = Common Name
commonName_max = 64

[ certauth ]
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid:always,issuer:always
basicConstraints = CA:true
crlDistributionPoints = @crl

[ server ]
basicConstraints = CA:FALSE
keyUsage = digitalSignature, keyEncipherment, dataEncipherment
extendedKeyUsage = serverAuth
nsCertType = server
crlDistributionPoints = @crl

[ client ]
basicConstraints = CA:FALSE
keyUsage = digitalSignature, keyEncipherment, dataEncipherment
extendedKeyUsage = clientAuth
nsCertType = client
crlDistributionPoints = @crl

[ crl ]
URI=ca.crl

Créer le certificat auto-signé de l’autorité de certification en exécutant la commande suivante :

openssl req -config ./openssl.cnf -newkey rsa:2048 -nodes -keyform PEM -keyout ca.key -x509 -days 3650 -extensions certauth -outform PEM -out ca.cer

Ceci va générer deux fichiers ca.cer le certificat de l’autorité de certification et ca.key la clé qui sert au chiffrement du certificat.

Création du certificat serveur

Créez dans un premier temps une nouvelle clé :

openssl genrsa -out server.key 2048

Puis créez une CSR (Certificat Signing Request) ou une demande de signature de certificat (c’est l’équivalent du formulaire que vous remplissez en mairie pour faire votre carte d’identité) :

openssl req -config ./openssl.cnf -new -key server.key -out server.req

Vous devrez saisir certains paramètres dont le Common Name qui doit correspondre au nom de votre serveur (ou le nom de domaine que vous utiliserez pour vous y connecter).

Enfin, signez la CSR avec le certificat de l’autorité de certification pour obtenir votre certificat serveur :

openssl x509 -req -in server.req -CA ca.cer -CAkey ca.key -set_serial 100 -extfile openssl.cnf -extensions server -days 3650 -outform PEM -out server.cer

Trois fichiers seront générés, server.req qui est la CSR et que vous pouvez supprimer, ainsi que server.cer et server.key, respectivement le certificat et la clé du certificat.

Création du certificat client

Comme pour le certificat serveur, il faut commencer par générer une nouvelle clé :

openssl genrsa -out client.key 2048

Puis émettre une CSR :

openssl req -config ./openssl.cnf -new -key client.key -out client.req

Et signer la CSR avec la CA pour obtenir le certificat client :

openssl x509 -req -in client.req -CA ca.cer -CAkey ca.key -set_serial 101 -extfile openssl.cnf -extensions client -days 3650 -outform PEM -out client.cer

Note : si vous créez plusieurs certificats, incrémentez le numéro de série qui est ici de 101 et qui était de 100 pour le certificat serveur.

Pour que vous puissiez installer votre certificat client dans votre navigateur internet ou votre smartphone, il convient de le convertir au format pkcs12. Le fichier pkcs12 contient à la fois la clé et le certificat :

openssl pkcs12 -export -inkey client.key -in client.cer -out client.p12

Nous obtenons ainsi le fichier client.p12 qui contient le certificat client. Vous devez installer ce fichier dans votre smartphone en vous l’envoyant par mail, ou dans votre navigateur sur votre PC en passant par les paramètres avancés.

Pour aller plus loin, nous pourrions créer une CRL ou liste de « révocation » ; il s’agit d’une liste dans laquelle est inscrit tous les certificats que nous souhaitons interdire. Si par exemple vous vous faites voler votre smartphone, vous pouvez ajouter le certificat qui était installé sur votre smartphone à cette liste de révocation pour en interdire l’accès. Vous obtiendrez plus d’information sur les certificats et les listes de révocation en suivant ce lien.

Apache et reverse-proxy

Il s’agit ici de mettre en place un proxy, ou plus précisément, un reverse proxy. Sa fonction première est de gérer l’aiguillage des flux vers la caméra ou la box domotique par exemple. En parallèle il assurera le chiffrement du flux ainsi que la vérification du certificat client (la carte d’identité de l’utilisateur).

Editez le fichier /etc/apache2/site-enabled/000-default et remplacez son contenu par la configuration suivante en remplaçant le chemin vers les certificats du serveur et de la CA :

<VirtualHost *:443>
  
  SSLEngine On # activation https
  SSLCertificateFile /chemin/server.cer # certificat serveur
  SSLCertificateKeyFile /chemin/server.key # clé du serveur
  SSLVerifyClient require # force le serveur à vérifier le certificat client
  SSLVerifyDepth 1 # le certificat client doit être signé par la même autorité de certification
  SSLCACertificateFile /chemin/ca.cer # certificat de l'autorité de certification
  ProxyRequests Off # désactive les requêtes proxy
  
  # redirige camera1 sur l'adresse IP et le port de la caméra 1
  ProxyPass /camera1/ http://192.168.0.17:8080/
  ProxyPassReverse /camera1/ http://192.168.100.17:8080/

  # redirige camera2 sur l'adresse IP de le port de la camera 2
  ProxyPass /camera2/ http://192.168.0.18:8080/
  ProxyPassReverse /camera2/ http://192.168.0.18:8080/
  <Proxy *>
    Order allow,deny
    Deny from all
    allow from all
  </Proxy>
  LogLevel warn
  ErrorLog ${APACHE_LOG_DIR}/rproxy_error.log
  CustomLog ${APACHE_LOG_DIR}/rproxy_access.log combined
</VirtualHost>

Firewall

Puisque nous sommes vigilants, nous allons configurer des règles firewall sur notre passerelle sécurisée pour nous assurer que seul le port 433/TCP soit accessible de l’extérieur. Nous utiliserons pour cela iptables qui est installé de base sur Raspbian.

Créez le fichier /etc/init.d/firewall.sh :

#! /bin/bash

### BEGIN INIT INFO
# Provides: firewall
# Required-Start:
# Required-Stop:
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Gateway firewall script
# Description: Enable service provided by daemon.
### END INIT INFO

tables_start()
{
iptables -N INPUT_LOG_ACCEPT
iptables -A INPUT_LOG_ACCEPT -j LOG --log-prefix "INPUT_ACCEPT -> "
iptables -A INPUT_LOG_ACCEPT -j ACCEPT

iptables -N INPUT_LOG_DROP
iptables -A INPUT_LOG_DROP -j LOG --log-prefix "INPUT_DROP -> "
iptables -A INPUT_LOG_DROP -j DROP

iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP

iptables -A INPUT -s 192.168.0.0/24 -j ACCEPT # accepte toutes les connexions en provenance du réseau local
iptables -A INPUT -p tcp --dport 433 -j INPUT_LOG_ACCEPT # on n'accepte que les connexions sur les port 433/TCP depuis l'extérieur
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -m state --state NEW,INVALID -j INPUT_LOG_DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

iptables -A OUTPUT -j ACCEPT
}

tables_clear()
{
iptables -F
iptables -t nat -F
iptables -X
iptables -t nat -X
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
}

tables_stop()
{
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -j REJECT
iptables -A OUTPUT -j REJECT
iptables -A FORWARD -j REJECT
}

tables_usage()
{
echo "usage: $0 [ start | stop | clear ]"
}

case "$1" in
stop)
echo " Stoping firewall ..."
tables_clear
tables_stop
exit 0
;;
clear)
tables_clear
exit 0
;;
start)
echo " Starting firewall ..."
tables_clear
tables_start
exit 0
;;

-h|--help)
tables_usage
exit 0
;;
*)
tables_clear
tables_start
exit 0
;;
esac

exit 1

Modifiez les droits d’exécution de ce script, puis lancez le automatiquement au démarrage du système :

chmod 755  /etc/init.d/firewall.sh
cd /etc/init.d
update-rc.d firewall.sh defaults

Redémarrez votre Pi, tout est prêt 🙂

Le mot de la fin

Il est difficile de proposer une solution « clé en main » pour ce type de système car il faut l’adapter à son réseau et à ses besoins. Dans tout les cas, le plus important à retenir est le principe de centraliser tous les accès sur une passerelle sécurisée avec une authentification forte et un chiffrement des flux.

La sécurité informatique est un sujet très vaste et complexe qui fait intervenir de nombreuses technologies et une multitude de concepts. J’espère vous avoir permis de mettre un pied dedans en vous aidant à protéger l’accès à vos équipements.

Dans cet article j’ai pris l’exemple d’une caméra IP, car c’est un exemple « choquant » en terme de sécurité (on peut être espionné à l’intérieur de chez soit), mais cette passerelle sécurisée peut être utilisé pour tout type d’équipement et projet comme par exemple :

N’hésitez pas à intervenir en commentaire pour proposer des améliorations à cette passerelle sécurisée 😉

L’article Créer une passerelle sécurisée avec un Raspberry Pi est apparu en premier sur MagdiBlog.

Raspberry Pi Camera – 5 façons de faire du streaming

Par : Olivier
25 janvier 2015 à 17:00

IMG_8806Le module Raspberry Pi Camera (et la version sans filtre IR, le module NoIR) sont de petits circuits (2,5cm x 2,5cm) dotés d’un capteur photo de 2592 x 1944 pixels capable d’enregistrer en 1080p à 30 images par secondes (ou 60 fps en 720p). Ce module se branche directement sur le port CSI du Pi prévu à cet effet.

La version NoIR permet de voir les infra-rouge, ce qui autorisera une vision nocturne si on le couple à un projecteur infra-rouge comme expliqué à fin de cet article : Système de vidéo-surveillance abordable avec des Raspberry Pi

Que ce soit pour un système de vidéo surveillance ou pour le pilotage d’un robot à distance, il faut pouvoir récupérer le flux vidéo et le diffuser à travers le réseau (streaming). Nous allons voir dans cet article 5 méthodes pour diffuser le flux vidéo d’un module Raspberry Pi Camera, plus ou moins efficacement.

Introduction et matériel utilisé

Le module Raspberry Pi Camera étant branché directement sur un Raspberry Pi, si vous voulez pouvoir voir les images capturées depuis un autre endroit qu’un écran branché sur ce même Pi, vous allez devoir envoyer ces images à travers le réseau. De nombreuses utilisations sont possibles :

  • la caméra de surveillance que l’on souhaite observer depuis son smartphone quand on part en vacance
  • le robot que l’on souhaite piloter à distance depuis un ordinateur de contrôle
  • filmer et diffuser des images en direct à travers internet
  • etc…

Petit bémol sur la notion de « streaming » vidéo : En principe, lorsqu’on parle de streaming vidéo, il s’agit bien d’un flux vidéo diffusé en direct. Comme nous allons le voir plus loin dans cet article, cette méthode consomme énormément de ressources (notamment en terme de bande passante), et dans de nombreux cas, il sera plus judicieux de diffuser une « suite d’images » à intervalles réguliers.

IMG_8810Le matériel

Pour l’ensemble des méthodes exposées dans cet article, nous utiliserons le matériel et le montage suivant :

Le Raspberry Pi A+ est vraiment idéal pour ce genre projet. Découvrez pourquoi en lisant cet article : Raspberry Pi A+ : Le meilleur de tous

On installe une Raspbian, tout ce qu’il y a de plus standard, on se connecte à son réseau WiFi et on active le module caméra grâce à l’outil raspi-config.

Voyons maintenant comment diffuser les images sur le réseau.

Méthode 1 : Netcat et Mplayer

C’est la méthode la plus simple et la plus directe. Il s’agit simplement de rediriger le flux capturé par la commande raspivid dans netcat, puis de récupérer ce flux et l’injecter en entrée dans le lecteur vidéo Mplayer. L’inconvénient de cette méthode est que le flux vidéo n’est visible que depuis un seul PC distant.

Depuis un PC sous Linux exécutez dans un premier temps la commande suivante (après avoir installé mplayer si besoin) :

nc -l -p 5001 | /usr/bin/mplayer -fps 10 -cache 1024 -

Cette commande ordonne à nc (netcat) d’écouter sur le port 5001 et redirige ce qui arrive dans le lecteur vidéo Mplayer en prévoyant un cache de 1024 Ko pour 10 images par secondes.

Puis, sur le Pi, il suffit d’exécuter raspivid et de rediriger la sortie vers l’adresse IP de notre PC client en utilisant netcat :

raspivid -t 0 -w 1280 -h 720 -o - | nc adresse_ip_du_pc_client 5001

On indique ainsi à raspivid de capturer des images en 1280×720 pixels et de les envoyer à netcat.

Simple et efficace, une fenêtre Mplayer s’ouvre automatiquement sur le PC client avec les images en direct. On notera toutefois une forte latence qui peut varier de 3 à 15 secondes en fonction de la qualité et du nombre d’images transmisses et de la qualité du lien WiFi.

Note : Un test réalisé sur un Raspberry Pi B, branché en Ethernet, permet de réduire la latence à environ une seconde.

Si vous souhaitez enregistrer le flux vidéo dans un fichier sur le PC client, il suffit de modifier la première commande de cette manière :

nc -l -p 5001 | /usr/bin/mplayer -fps 10 -cache 1024 -demuxer h264es -dumpstream -dumpfile ./Bureau/ma_video.h264 -

Méthode 2 : streaming VLC

Cette méthode, relativement simple à mettre en place, souffre d’une très forte latence. Toutefois, et contrairement à la première méthode, le flux vidéo est visible depuis plusieurs postes clients.

Sur le Pi, il suffit d’installer VLC :

apt-get install vlc

Puis de rediriger la sortie de la commande raspivid (comme dans la méthode 1) vers VLC en exécutant la commande suivante :

raspivid -t 0 -n --width 1280 --height 720 -o - | cvlc stream:///dev/stdin --sout '#standard{access=http,mux=ts,dst=:8090}' :demux=h264

Coté PC client, il suffit de lire le flux vidéo avec VLC grâce à la commande :

cvlc http://adresse_ip_du_pi:8090

Pour enregistrer le flux vidéo dans un fichier, utilisez la commande suivante :

cvlc http://adresse_ip_du_pi:8090 --sout file/ts:./Bureau/ma_video.h264

Cette méthode est à privilégier si vous souhaitez diffuser votre flux vidéo à plusieurs personnes sur internet par exemple, et que la latence n’est pas un problème.

Méthode 3 : streaming de Pi à Pi avec OMXplayer

Les méthodes 1 et 2 permettent de diffuser le flux vidéo à destination d’un ordinateur distant. Si vous souhaitez capturer un flux vidéo depuis un Pi pour l’observer depuis un autre Pi branché à un écran, il convient d’utiliser le lecteur OMXplayer.

Cette méthode est un peu plus complexe à mettre en oeuvre mais permet plus de souplesse quant à l’usage que l’on souhaite en faire. Depuis le Pi équipé du module caméra, nous allons procéder exactement comme pour la méthode 1, en redirigeant la sortie de la commande raspivid dans netcat. Puis, sur le Pi branché à l’écran de visionnage, nous allons dans un premier temps récupérer le flux netcat pour l’enregistrer dans un fichier et le lire, dans un deuxième temps, avec OMXplayer.

Sur le Pi de visionnage, créez d’abord un fichier de type fifo :

mkfifo /dev/shm/video.fifo

Deux points très important à comprendre dans cette commande :

  • /dev/shm : ce point montage fonctionne comme un disque dur mais aucune donnée ne sera stockée sur le disque dur en lui même ; tout sera géré en mémoire vive. C’est parfait pour y placer un fichier vidéo tampon.
  • fichier de type .fifo : les fichiers de type fifo fonctionnent comme les fichiers standards, mais se comportent comme des « pipes », ce qui permet au système d’y stocker des données sans passer par le système de fichier. Encore une fois, parfait pour y placer un fichier vidéo tampon 🙂

Le fichier tampon étant prêt, il faut maintenant le remplir. Côté Pi de visionnage, mettez netcat en écoute en redirigeant la sortie vers le fichier tampon :

nc -l -p 5001 > /dev/shm/video.fifo

Puis côté Pi caméra, envoyez le flux vidéo à travers netcat comme dans la méthode 1 :

raspivid -t 0 -w 960 -h 540 -o - | nc adresse_ip_du_pi_visionnage 5001

De retour sur le Pi de visionnage, il suffit de dire à OMXplayer de lire le fichier tampon :

omxplayer /dev/shm/video.fifo

Cette méthode n’offre pas une latence exemplaire, mais permet de transmettre un flux vidéo de Pi à Pi. Idéal par exemple pour créer un portier vidéo, avec un Pi qui film et un Pi qui affiche la vidéo, les deux Pi étant reliés par WiFi 🙂

Méthode 4 : mjpg-streamer

A partir de là, on sort du streaming vidéo pur et dur puisqu’il s’agit, avec le mjpeg, de transmettre et d’afficher une suite de photos les unes après les autres. Le résultat est beaucoup moins fluide puisqu’on ne pourra espérer afficher que 5 à 10 images par seconde maximum (contre 10 à 30 images par secondes pour les méthodes précédentes), mais nous pourrons exploiter les images beaucoup plus simplement en les affichant dans une page web, ou sur un écran comme le PiHomeDashScreen par exemple. Si vous disposez d’un NAS Synology, ou d’un système sachant gérer des caméras IPs, vous pourrez également exploiter la caméra du Pi grâce à cette méthode.

Voici le lien vers la page SourceForge de mjpg-streamer : http://sourceforge.net/projects/mjpg-streamer/

Dans un premier temps, installez les dépendances de mjpg-streamer ainsi que subversion :

apt-get install subversion libv4l-dev libjpeg8-dev imagemagick

mjpg-streamer aura besoin d’un fichier videodev.sh pour fonctionner correctement :

ln -s /usr/include/linux/videodev2.h /usr/include/linux/videodev.h

Téléchargez ensuite la dernière version de mjpg-streamer grâce à subversion, puis installez le en utilisant les commandes suivantes :

svn co https://svn.code.sf.net/p/mjpg-streamer/code/
cd code/mjpg-streamer
make USE_LIBV4L2=true clean all
make DESTDIR=/usr install

Une fois installé, créez un répertoire temporaire et lancez raspistill en mode timelapse pour capturer 2 images par secondes :

mkdir /tmp/stream
raspistill --nopreview -w 640 -h 480 -q 5 -o /tmp/stream/pic.jpg -tl 500 -t 9999999

Enfin, lancez mjpg-streamer grâce à cette commande :

LD_LIBRARY_PATH=/usr/local/lib mjpg_streamer -i "input_file.so -f /tmp/stream -n pic.jpg" -o "output_http.so -w ./www"

Par défaut, mjpg-streamer lancera un serveur web sur le port 8080/TCP auquel vous pouvez accéder avec un navigateur en utilisant l’adresse : http://adresse_du_pi:8080

Vous devriez voir l’interface de démonstration de mjpg-streamer :

capture_mjpg-streamer

Les deux options les plus intéressantes sont JavaScript et Stream. Ces deux méthodes vous permettrons de récupérer les images pour les afficher dans une page web, ou sur le PiHomeDashScreen comme vous pouvez le voir dans la photo si dessous :

capture_homedashscreen_pi_camera

Pour réaliser cela, j’ai simplement placé le code suivant dans le fichier index.php du PiHomeDashScreen (consulter les articles de ce projet pour en savoir plus).

<div id="webcam"><img src="http://adresse_ip_du_pi:8080/?action=snapshot" /></div>

<script type="text/javascript">
  var imageNr = 0;
  var finished = new Array();
  var paused = false;
  function createImageLayer() {
    var img = new Image();
    img.style.position = "absolute";
    img.style.zIndex = -1;
    img.onload = imageOnload;
    img.onclick = imageOnclick;
    img.src = "http://adresse_ip_du_pi:8080/?action=snapshot&n=" + (++imageNr);
    var webcam = document.getElementById("webcam");
    webcam.insertBefore(img, webcam.firstChild);
  }
 
  function imageOnload() {
    this.style.zIndex = imageNr; // Image finished, bring to front!
    while (1 < finished.length) {
    var del = finished.shift(); // Delete old image(s) from document
    del.parentNode.removeChild(del);
  }
  finished.push(this);
    if (!paused) createImageLayer();
  }
</script>

C’est de loin la méthode que je recommande car elle permet de diffuser les images à plusieurs clients en même temps tout en conservant une latence acceptable pour peu que l’on se contente d’une image de qualité moyenne.

Méthode 5 : Serveur Web

Cette méthode consiste à capturer des images à intervalles régulier avec la commande raspistill, puis à les diffuser grâce à un serveur web Apache. C’est la méthode que j’ai utilisé pour réaliser ce Système de vidéo-surveillance abordable avec des Raspberry Pi.

video_surveillance_monitorin_safe

Cette méthode est très proche, fonctionnellement, de mjpg-streamer. Je songe d’ailleurs à refondre mon système de vidéo surveillance en utilisant mjpg-streamer.

Je vous invite à lire cet article pour en savoir plus sur cette méthode « artisanale » 😉Système de vidéo-surveillance abordable avec des Raspberry Pi

Conclusion

raspberry_pi_cameraLes méthodes de streaming vidéo pur (méthode 1 à 3) permettent un affichage fluide en sacrifiant la réactivité, ce qui rend cette option inutilisable pour le pilotage d’un robot par exemple.

Les méthodes utilisant une suite d’images sur le principe du mjpeg (méthode 4 et 5) permettent une plus grande souplesse dans l’exploitation des images et offrent globalement une meilleure latence (car moins d’images à traiter et à faire transiter par le réseau). Personnellement, j’utilise la méthode 4 avec mjpg-streamer pour la quasi totalité de mes projets actuels. C’est une méthode très polyvalente, simple à mettre en place et peu gourmande en ressource pour le Pi.

Quelque soit la méthode utilisée, le vrai problème reste la bande passante. Que ce soit en 3G, en Wifi ou même en Ethernet, la vitesse du réseau sera limitante pour la transmission d’images.

raspberry_pi_camera_noirVous trouverez sur le net beaucoup d’articles qui expliquent comment mettre en oeuvre le logiciel Motion sur un Raspberry Pi. Je conseille cette approche uniquement si vous souhaitez faire de la détection de mouvement car Motion est fait pour cela à la base. Même si Motion utilise le même principe du mjpeg que dans les méthodes 4 et 5, il est très gourmand en ressources pour un Pi et offrira moins de souplesse que mjpg-streamer.

Reste une méthode que je n’ai pas encore essayé à ce jour mais qui semble être intéressante car « prête à l’emploi » pour un Pi : http://elinux.org/RPi-Cam-Web-Interface.

Je vous invite à partager vos expériences sur ce sujet, notamment pour savoir si vous connaissez des méthodes qui offrent une latence très faible.

Article intéressant sur le sujet :

L’article Raspberry Pi Camera – 5 façons de faire du streaming est apparu en premier sur MagdiBlog.

❌
❌