PAB's blog

Nous allons expliquer ici comment fabriquer un photomètre avec la plateforme Arduino et le composant BH1750 (encore appelé GY-30, fiche technique ici) que l'on trouve pour quelques euros chez les bons revendeurs électroniques.

Un photomètre qui parle en série

Une première version du photomètre sera simple : nous utiliserons les facultés d'Arduino à communiquer via un port série pour afficher le niveau de luminosité mesuré. Le circuit est alors assez simple (cf. représentation ci-dessous) :

• le pin VCC du capteur se connecte au pin 5V de l'Arduino
• le pin GND du capteur se connecte au pin GND de l'Arduino
• le pin SDA du capteur se connecte au pin A4 (Analogique 4) de l'Arduino
• le pin SDL du capteur se connecte au pin A5 (Analogique 5) de l'Arduino

On compile alors le code suivant et on le charge sur l'Arduino (par exemple avec l'IDE Arduino) :

#include <Wire.h>
 
int BH1750_address = 0x23; // i2c Addresse
byte buff[2];
 
void setup() {
  
  Wire.begin();
  BH1750_Init(BH1750_address);
  
  delay(200);
  Serial.begin(9600);
  Serial.println("Démarrage du système... patientez svp !");
}
 
void loop() {
  
  float valf=0;
 
  if(BH1750_Read(BH1750_address)==2){
    valf=((buff[0]<<8)|buff[1])/1.2;
  
    if(valf<0) {
      Serial.print("> 65535");
    }
    else {
      Serial.print((int)valf,DEC);
    }
    Serial.println(" lx"); 
  }
  delay(1000);
}
 
void BH1750_Init(int address) {
  Wire.beginTransmission(address);
  Wire.write(0x10); // 1 [lux] aufloesung
  Wire.endTransmission();
}
 
byte BH1750_Read(int address) {
  byte i=0;
  Wire.beginTransmission(address);
  Wire.requestFrom(address, 2);
  while(Wire.available()) {
    buff[i] = Wire.read(); 
    i++;
  }
  Wire.endTransmission();  
  return i;
}

Et hop, sur le port série, on peut voir :

Démarrage du système... patientez svp !
92 lx
92 lx
92 lx
75 lx
47 lx
342 lx
43 lx

Un photomètre avec son propre écran LCD

Rajoutons un écran LCD pour afficher le résultat sans avoir à ouvrir un port série ! Nous allons donc brancher un LCD Keypad Shield (tel qu'ici) sur l'Arduino, et nous allons modifier le code comme suit :

#include <Wire.h>
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

int BH1750_address = 0x23; // i2c Addresse
byte buff[2];

void setup() {

  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("Look the world");

  Wire.begin();
  BH1750_Init(BH1750_address);

  delay(200);
  Serial.begin(9600);
}

void loop(){
  float valf=0;
  if(BH1750_Read(BH1750_address)==2) {
    valf=((buff[0]<<8)|buff[1])/1.2;
    if(valf<0) {lcd.setCursor(0,0); lcd.print("> 65535 lx");}
    else {lcd.setCursor(0,0); lcd.print((int)valf,DEC); lcd.print(" lx                    ");}
  }
  else {
    lcd.setCursor(0,0); lcd.print("Error...             "+BH1750_Read(BH1750_address));
  }
  delay(1000);
}

void BH1750_Init(int address) {
  Wire.beginTransmission(address);
  Wire.write(0x10); // 1 [lux] aufloesung
  Wire.endTransmission();
}

byte BH1750_Read(int address){
  byte i=0;
  Wire.beginTransmission(address);
  Wire.requestFrom(address, 2);
  while(Wire.available()){
    buff[i] = Wire.read();
    i++;
  }
  Wire.endTransmission();
  return i;
}

On compile et on charge sur l'Arduino, et hop le tour est joué !

Dans un précédent article (ici), je proposais une méthode pour renouveler les certificats Letsencrypt en l'absence d'un mécanisme officiel pour le moment. Dans cette méthode (enfin ce script), je vérifiais la date du certificat avec "date -r", extrapolant la date de fin de validité à l'aide de la date de création du certificat et de la connaissance de la durée de validité par défaut des certificats de Letsencrypt.

Il y a en fait beaucoup plus intelligent ! Merci à mon beau-frère pour cette idée (toujours écouter au moins d'une oreille son beau-frère !)

Le manuel d'OpenSSL nous apprend l'existence de l'option suivante :

-checkend arg
checks if the certificate expires within the next arg seconds and exits non-zero if yes it will expire or zero if not.

Dès lors, il est facile de détecter si un certificat périme dans les 30 jours (2 592 000 secondes) :

if openssl x509 -checkend 2592000 -noout -in file.pem
then
  echo "Certificat valide encore au moins 30 jours"
else
  echo "Certificat périmant dans les 30 jours... à renouveler !"
fi

fail2ban-client set JAILNAME unbanip IPADDRESS

où l'on remplacera JAILNAME par le nom de la "jail" de Fail2ban à l'origine du bannissement et IPADDRESS par l'adresse bannie.

Par exemple :

fail2ban-client set ssh unbanip 1.2.3.4

Pour permettre la génération d'un certificat avec Let's Encrypt pour Gitlab, il m'a été nécessaire d'effectuer les opérations suivantes :

• Modifier la gestion des fichiers d'assets dans gitlab/config/environments/production.rb,

config.serve_static_assets = true

• Redémarrer Gitlab par

service gitlab restart

• Puis effectuer la génération du certificat avec le script Let's Encrypt en pointant le webroot vers le dossier public :

certbot certonly -a webroot --webroot-path /path/to/gitlab/public -d mongit.domaine.tld

Depuis le début du mois, il est possible d'utiliser "Let's Encrypt" pour obtenir des certificats TLS/SSL pour sécuriser ses sites et services en ligne (bien que le système soit toujours annoncé en bêta). Ce matin, je décidais donc de m'y mettre et de remplacer mes certificats StartSSL.

Depuis Mai 2016, le service Let's Encrypt n'est plus en bêta et les limitations de la bêta évoquées ici ne sont plus mordantes !

Depuis Mai 2016, le client letsencrypt est devenu certbot (https://certbot.eff.org/) ! les commandes évoquées plus bas sont sans doute valables en remplaçant letsencrypt-auto par certbot !

Première étape : comprendre le fonctionnement

Le principe est assez simple et n'est pas très différent de celui déjà rencontré pour l'obtention de certificats auprès des opérateurs "classiques" (les StartSSL et consors). Classiquement, (i) on démontre la possession réelle du nom de domaine, (ii) on génère une clé privée et une clé publique et on transmet la clé publique à l'opérateur de certification qui (iii) fournit en retour un certificat attestant le lien entre le nom de domaine et la paire de clés crypto utilisées pour l'établissement de communications sécurisées. Avec Letsencrypt, ces étapes ont lieu mais automatiquement. Dans l'utilisation commune, Letsencrypt vient avec un script Python (letsencrypt-auto) qui va faire tout le travail :

• le script va créer un fichier mondomaine.tld/.well-known/acme-challenge/chaîne-choisie-au-hasard et le serveur distant cherchera à accéder à ce fichier pour authentifier la possession/maîtrise du domaine mondomaine.tld
• puis le script génère et échange les clés cryptographiques avec l'autorité de certification Letsencrypt
• et le certificat est rapatrié
• enfin, dans certains cas, le script se charge même de l'installer !

Par rapport à ce qui est fourni habituellement par les acteurs privés :

• la chaîne de bout en bout est plus transparente et libre
• le certificat est gratuit
• le certificat n'a une validité que de 90 jours (mais le renouvellement est gratuit et peut être géré automatiquement par le script tous les 2 mois par exemple)
• les certificats n'autorisent pas les wildcards (e.g. *.mondomaine.tld) ce qui a déjà été fort amplement débattu partout sur le web mais ne semble pas devoir changer.

Deuxième étape : installer Let’s Encrypt

Nous allons commencer par le cas simple d'un site statique. Le script letsencrypt se télécharge sur la machine d'hébergement à l'aide de git :

git clone https://github.com/letsencrypt/letsencrypt
cd letsencrypt

puis on peut lancer le script (qui va effectuer les installations supplémentaires nécessaires) par :

./letsencrypt-auto

Cela fonctionne très bien sur Debian Jessie et sans doute les autres systèmes récents (c'est la version de Python qui semble être un des facteurs limitants pour les "vieilles" distributions). On reviendra sur ce point plus loin.

Troisième étape : utiliser Let’s Encrypt pour un site statique

Commençons par le cas simple d'un site statique hébergé dans /var/www/mon-site/ et servi par Apache.

./letsencrypt-auto certonly -a webroot --webroot-path /var/www/mon-site/ -d mondomaine.tld

certonly car nous demandons à Let’s Encrypt de générer le certificat et de s'arrêter là (donc de ne pas l'installer lui-même). -a webroot car nous indiquons à Let’s Encrypt où se trouve la racine du site afin qu'il puisse y placer le fichier de "challenge" (.well-known/acme-challenge/chaîne-choisie-au-hasard). Et -d mondomaine.tld pour indiquer le domaine. Il est possible d'indiquer plusieurs domaines s'ils partagent le même webroot par exemple :

./letsencrypt-auto certonly -a webroot --webroot-path /var/www/mon-site/ -d mondomaine.tld -d www.mondomaine.tld

Dans ce cas le certificat contiendra les 2 domaines en SAN (Subject Alternative Names).

Au premier lancement, le script demande de saisir l'adresse courriel qui sera rattachée au compte (et qui recevra les éventuelles notifications de péremption des domaines non renouvelés).

Et hop, le script travaille et un certificat tout neuf (et valide !) est déposé dans /etc/letsencrypt/live/mondomaine.tld/fullchain.pem. La clé privée correspondante se trouve dans /etc/letsencrypt/live/mondomaine.tld/privkey.pem. Ce certificat peut alors être utilisé comme il l'a toujours été (par ex. appelé dans la configuration d'Apache ou de votre load balancer) - je détaille ici comment l'utiliser avec le load balancer Pound.

Let’s Encrypt et un blog dotclear

Aucune surprise ni difficulté avec dotclear :

./letsencrypt-auto certonly -a webroot --webroot-path /chemin/vers/blog/dotclear -d blog.bandinelli.net

et hop, /etc/letsencrypt/live/blog.bandinelli.net/fullchain.pem est créé ! Une commande pour un certificat, c'est classe et pratique !

Let’s Encrypt et Piwik

Aucune surprise ni difficulté avec Piwik :

./letsencrypt-auto certonly -a webroot --webroot-path /chemin/vers/racine/piwik -d piwik.mondomaine.tld

et hop, /etc/letsencrypt/live/piwik.mondomaine.tld/fullchain.pem est créé !

Let’s Encrypt et Wordpress

Aucune surprise ni difficulté avec Wordpress :

./letsencrypt-auto certonly -a webroot --webroot-path /chemin/vers/racine/wordpress -d mondomaine.tld

et hop, /etc/letsencrypt/live/mondomaine.tld/fullchain.pem est créé !

Let’s Encrypt et Drupal 7

Une petite astuce est nécessaire ici : par défaut le moteur de Drupal demande au serveur web de réécrire toutes les adresses et empêche l'accès à certaines adresses. Ainsi, le fichier .htaccess se trouvant à la racine d'un site Drupal contient la ligne suivante :

RewriteRule "(^|/)\." - [F]

Cette ligne ordonne à Apache de renvoyer vers la page "Accès interdit" toute requête qui débuterait par ".". Il faut bien évidemment désactiver cette sécurité pour Letsencrypt :

RewriteCond %{REQUEST_URI} !^/.well-known/acme-challenge/.*
RewriteRule "(^|/)\." - [F]

La condition RewriteCond désactive la redirection qui suit pour le challenge de letsencrypt seulement.

Une fois cela effectué, on peut utiliser la commande classique pour obtenir le certificat valide dans /etc/letsencrypt/live/mondomaine.tld/fullchain.pem :

./letsencrypt-auto certonly -a webroot --webroot-path /chemin/vers/site/drupal/ -d mondomaine.tld

Let’s Encrypt et ownCloud/Nextcloud

Une petite astuce est nécessaire ici : par défaut le moteur d'ownCloud demande au serveur web de réécrire toutes les adresses et empêche l'accès à certaines adresses. Ainsi, le fichier .htaccess se trouvant à la racine d'une instance ownCloud/Nextcloud contient la ligne suivante :

RewriteRule ^(\.|autotest|occ|issue|indie|db_|console).* - [R=404,L]

elle renvoie vers 404 tous les appels à un chemin démarrant par ".". Il est bien sûr nécessaire de désactiver cette ligne conditionnellement :

RewriteCond %{REQUEST_URI} !^/.well-known/acme-challenge/.*
RewriteRule ^(\.|autotest|occ|issue|indie|db_|console).* - [R=404,L]

Ensuite, sans surprise, pour obtenir le certificat valide dans /etc/letsencrypt/live/mondomainecloud.tld/fullchain.pem :

./letsencrypt-auto certonly -a webroot --webroot-path /chemin/vers/owncloud/ -d mondomainecloud.tld

Let’s Encrypt et une application Ruby on Rails

Aucune surprise ni difficulté avec une application Ruby on Rails servie en production par Unicorn, à condition de bien choisir le dossier public comme webroot :

./letsencrypt-auto certonly -a webroot --webroot-path /chemin/vers/application/public -d domaine.tld

et hop, /etc/letsencrypt/live/domaine.tld/fullchain.pem est créé !

Let’s Encrypt sur une vieille distribution ?

Si Let's Encrypt ne peut être lancé sur votre machine de production car elle dispose de versions trop anciennes des fichiers, rien n'est perdu ! Il est en effet possible de fournir au script un webroot qui serait par exemple partagé via SSH ! Par exemple :

apt install sshfs
mkdir /mnt/webroot-distant
sshfs user@machine:/path/to/webroot /mnt/webroot-distant
./letsencrypt-auto certonly -a webroot --webroot-path /mnt/webroot-distant -d mondomaine.tld

Conclusion

Très efficace et rapide, comment ne pas tomber sous le charme de Letsencrypt ? Il reste à valider : la procédure de renouvellement et la pérennité dans le temps de la structure. Pour y aider, on peut toujours faire un petit don sur la page d'accueil de Let’s Encrypt !

Si, comme moi, vous avez longuement cherché le moyen de modifier le message d'absence dans l'interface de Xivo, ne cherchez plus ! Il se paramètre très facilement sans passer par l'interface graphique en plaçant le fichier .wav adapté à cet emplacement :

/var/spool/asterisk/voicemail/contexte_du_client/numéro_boite_vocale/unavail.wav

Il suffit de le savoir !

Avec les outils inclus dans la suite ImageMagick, il est assez facile de modifier en lot les images d'un répertoire.

Par exemple, pour redimensionner tout un lot d'images (la plus grande dimension à 800 pixels), on pourra faire :

mogrify -resize 800x800 *.jpg

Pour effectuer des rotations de 180° sur plusieurs images, on fera :

mogrify -rotate 180 *.jpg

Plus compliqué, pour ajouter un texte (par exemple le nom du photographe) sur chaque photo, on pourra faire :

for file in *.jpg; do  convert $file -pointsize 20 -draw "gravity SouthEast fill white text 1,11 'Voici mon texte ' " $file; done

Cela transforme alors l'image comme suit :

Les photos prises avec les appareils modernes sont le plus souvent étiquetées de nombreuses données EXIF (nom de l'appareil, type d'objectif, ouverture, coordonnées GPS de la prise...). Il est parfois souhaitable de supprimer les données EXIF. Heureusement, exiftool existe sous Linux.

Il s'installe comme tout autre paquet, par exemple sous Debian :

apt install exiftool

Pour supprimer les données EXIF d'une photo, on exécute la commande :

exiftool -all= photo.jpg

et pour traiter toutes les images d'un répertoire :

exiftool -all= *.jpg

Si on ne veut supprimer qu'une seule valeur EXIF, par exemple la valeur d'orientation de la photo, on pourra faire :

exiftool -Orientation="" photo.jpg

ou bien pour la modifier :

exiftool -Orientation=1 photo.jpg

L'outil exiftool permet de faire bien plus que cela : afficher toutes les données EXIF, en réécrire certaines, créer de nouvelles données... l'imagination est presque la seule limite. Le manuel de l'outil vous fournira le détail sur les commandes ainsi qu'un grand nombre d'exemples.

Postgresql conserve en mémoire la valeur maximale attribuée au champ 'id' et utilise cette valeur pour générer un nouvel 'id' quand un nouvel enregistrement est pris en base. Cependant, si vous avez importé des données (par exemple depuis un fichier csv avec pgadmin3, important ainsi leurs 'id' initiaux), il se peut que la valeur maximale gardée en mémoire ne corresponde plus à la table existante. Lors d'un nouvel enregistrement, si la liste importée était plus longue que la liste initiale, ce message d'erreur risque d'apparaître :

PG::UniqueViolation: ERROR: Duplicate Key Value Violates Unique Constraint 'nom_de_votre_table_pkey'

Pour corriger l'information dans la base Postgresql, il est possible d'exécuter cette commande :

SELECT setval('nom_de_votre_table_id_seq', (SELECT MAX(id) FROM nom_de_votre_table));

SELECT MAX(id) FROM nom_de_votre_table) calcule la valeur maximale d'id existant dans les données de la table. SELECT setval('nom_de_votre_table_id_seq', value) attribue une nouvelle à la chaîne 'nom_de_votre_table_id_seq').