Mutt : Configuration avancée

Allons un peu plus loin dans la configuration de mutt. Cet article apporte quelques éléments de sécurité supplémentaires, notamment le chiffrement des mots de passe IMAP / SMTP inscrits en clair dans notre configuration actuelle (pas bien !) et le chiffrement des mails.

CHIFFREMENT DES MOTS DE PASSE

Pour ne plus laisser inscrits en clair les mots de passe des comptes IMAP et SMTP dans .muttrc, je vous propose d’utiliser gpg (GnuPG), un outil de chiffrement de fichier.

Le principe est le suivant :

  • On renseigne les mots de passe IMAP et SMTP dans un fichier à part, puis on chiffre ce fichier à l’aide d’une paire de clés générées préalablement.
  • On configure mutt pour qu’il soit en mesure de déchiffrer temporairement ce fichier et lire les mots de passe.

On commence par générer une clé privée :

$ sudo gpg --gen-key

Sélectionnez le type de clef désiré :
   (1) RSA et RSA (par défaut)
   (2) DSA et Elgamal
   (3) DSA (signature seule)
   (4) RSA (signature seule)
Quel est votre choix ? 1
les clefs RSA peuvent faire entre 1024 et 4096 bits de longueur.
Quelle taille de clef désirez-vous ? (2048) 2048 #2048 sera suffisant
La taille demandée est 2048 bits
Veuillez indiquer le temps pendant lequel cette clef devrait être valable.
         0 = la clef n'expire pas
      <n>  = la clef expire dans n jours
      <n>w = la clef expire dans n semaines
      <n>m = la clef expire dans n mois
      <n>y = la clef expire dans n ans
Pendant combien de temps la clef est-elle valable ? (0) 0
La clef n'expire pas du tout
Est-ce correct ? (o/N) o

Une identité est nécessaire à la clef ; le programme la construit à partir
du nom réel, d'un commentaire et d'une adresse électronique de cette façon :
   « Heinrich Heine (le poète) <heinrichh@duesseldorf.de> »

Nom réel : Toto
Adresse électronique : toto@titi.com
Commentaire : #(optionnel)
Vous avez sélectionné cette identité :
    « Toto <toto@titi.com> »

Faut-il modifier le (N)om, le (C)ommentaire, l'(A)dresse électronique
ou (O)ui/(Q)uitter ? O
Une phrase de passe est nécessaire pour protéger votre clef secrète.

La génération prend un certain temps. Une fois terminée, on peut vérifier en affichant la liste des clés :

$ sudo gpg --list-keys
/home/pi/.gnupg/pubring.gpg
---------------------------
pub   2048R/D3640932 2015-11-21
uid                  Toto <toto@titi.com>
sub   2048R/6E7ACDE3 2015-11-2

Allons-y pour le chiffrement des mots de passe. Créer un nouveau répertoire puis créer et éditer le fichier qui va contenir les mots de passe :

$ cd
$ mkdir .mutt/
$ nano .mutt/password

Renseigner le fichier de la manière suivante :

set my_email_pass = "mot_de_passe_compte_mail"

Enregistrer puis quitter l’éditeur. Chiffrer le fichier à l’aide de la commande suivante :

$ gpg --encrypt --recipient <description> .mutt/password 
# (remplacer <description> par le nom renseigné lors de la génération de la paire de clés)
# Du coup dans ce tuto ce serait :
$ gpg --encrypt --recipient Toto .mutt/password

 Supprimer le fichier temporaire :

$ shred -n 50 -zuv .mutt/password

Appliquer les droits suivants sur password.gpg :

$ sudo chown pi .mutt/password.gpg
$ chmod 600 .mutt/password.gpg

Ça y est, nos mots de passe sont protégés. Modifions maintenant la config de mutt :

$ nano .muttrc

source "gpg --quiet --no-tty -dq ~/.mutt/password.gpg |"

# configuration de base
set realname = "pi"

# configuration imap
set spoolfile=imaps://imap.riseup.net:993/ 
set imap_user = "XXXXXXXXXX@riseup.net"
set imap_pass = $my_email_pass
set imap_passive="no"
set imap_check_subscribed="yes"
set imap_list_subscribed="yes"

# configuration SMTP
set smtp_url = "smtps://XXXXXXXXXX@riseup.net@mail.riseup.net:465/"
set smtp_pass = $my_email_pass

set locale="fr_FR"
set date_format="%A %d %b %Y à %H:%M:%S (%Z)"
set locale="iso-8859-15"

Tester le bon fonctionnement (votre passphrase sera demandée) :

$ echo 'test' | mutt -s 'test' mail_destinataire

Pour ne pas devoir entrer à chaque fois la passphrase, il est possible d’installer gpg-agent qui se chargera de la retenir pour une durée déterminée :

$ sudo apt-get install gnupg-agent pinentry-gtk2

Puis éditer le fichier gpg.conf et dé-commenter la ligne use-agent :

$ nano .gnupg/gpg.conf

[...]
use-agent #dé-commenter cette ligne en retirant la dièse # en début de ligne
[...]

Enregistrer puis quitter l’éditeur. Créer et éditer le fichier suivant :

$ nano .gnupg/gpg-agent.conf

Ajouter les lignes suivantes :

pinentry-program /usr/bin/pinentry-gtk-2
default-cache-ttl -1 #valeur à -1 : gpg-agent retiendra la passphrase en cache pour une durée infinie (attention à vérifier!).
max-cache-ttl -1

Lancer gpg-agent :

$ eval "$(gpg-agent --daemon)"

Lancer mutt. gpg-agent demande alors la passphrase pour pouvoir déchiffrer password.gpg. Il la retiendra alors indéfiniment suite à la config mise en place précédemment.

$ mutt

A ce stade, notre configuration devrait permettre à motion d’envoyer des mails sans qu’on ait besoin de fournir de passphrase.

CHIFFREMENT DES MAILS

Allons encore plus loin en utilisant gpg pour chiffrer le contenu des mails émis par motion. Cela permettra de préserver votre intimité et la confidentialité des images et vidéos transmises lors d’alertes mails.

Thunderbird sera le client qui recevra les mails chiffrés côté PC.

Suivre les étapes proposées par ce site : http://lehollandaisvolant.net/tuto/gpg/#i2 à partir du chapitre 2 jusqu’au 4.1 où il faudra exporter la clé publique sous forme de fichier (pour notre utilisation, ce ne sera pas utile de la rendre disponible sur les serveurs de clés). Copier ce fichier dans le home directory de l’utilisateur pi à l’aide d’une clé USB par exemple ou avec WinSCP.

Importer la clé publique à l’aide du fichier copié :

$ gpg --import votre_clé.asc

Vérifier en listant les clés :

$ gpg --list-keys

Nous avons donc deux paires de clés : celle générée au début de ce tutoriel pour chiffrer les mots de passe et celle importée précédemment.

On connait l’identité de la personne qui a généré la clé publique que l’on a importé (c’est nous même!) donc on peut lui (se) faire entièrement confiance. Éditer le niveau de confiance de la clé importée :

$ gpg --edit-key <nom_de_la_clé>
gpg (GnuPG) 1.4.12; Copyright (C) 2012 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.


pub  4096R/8XXXXXX9  créé : 2015-11-18  expire : 2020-11-16  utilisation : SCA #Il s'agit de la clé publique générée par Enigmail et importée précédemment.
                     confiance : inconnu       validité : inconnu #Son niveau de confiance est inconnu : GPG demandera à chaque fois s'il faut faire confiance ou non à cette clé. C'est ce paramètre qu'il faut modifier. 
sub  4096R/0XXXXXX4  créé : 2015-11-18  expire : 2020-11-16  utilisation : E
[ inconnue] (1). XXXXXXXXXX <XXXXXXXXXX@XXXXX.com>

gpg> trust #La commande trust permet de modifier le niveau de confiance d'une clé
pub  4096R/8XXXXXX9  créé : 2015-11-18  expire : 2020-11-16  utilisation : SCA
                     confiance : inconnu       validité : inconnu
sub  4096R/0XXXXXX4  créé : 2015-11-18  expire : 2020-11-16  utilisation : E
[ inconnue] (1). XXXXXXXXXX <XXXXXXXXXX@XXXXX.com>

Décidez maintenant de la confiance que vous portez en cet utilisateur pour
vérifier les clefs des autres utilisateurs (en regardant les passeports, en
vérifiant les empreintes depuis diverses sources, etc.)

  1 = je ne sais pas ou n'ai pas d'avis
  2 = je ne fais PAS confiance
  3 = je fais très légèrement confiance
  4 = je fais entièrement confiance
  5 = j'attribue une confiance ultime
  m = retour au menu principal

Quelle est votre décision ? 5
Voulez-vous vraiment attribuer une confiance ultime à cette clef ? (o/N) o

pub  4096R/8XXXXXX9  créé : 2015-11-18  expire : 2020-11-16  utilisation : SCA
                     confiance : ultime        validité : inconnu
sub  4096R/0XXXXXX4  créé : 2015-11-18  expire : 2020-11-16  utilisation : E
[ inconnue] (1). XXXXXXXXXX <XXXXXXXXXX@XXXXX.com>
Veuillez remarquer que la validité affichée pour la clef n'est pas
forcément correcte avant d'avoir relancé le programme.

gpg> quit

Tester en envoyant un mail dont le contenu sera chiffré avec la clé publique importée :

$ echo 'toto' | gpg -ea -r "nom_de_la_clé" | mutt -s 'test' mail_destinataire #évidemment le destinataire sera le compte mail ayant généré la paire de clé avec Enigmail.  

A l’ouverture du mail, Thunderbird va tenter de déchiffrer le message en demandant la passphrase associée à la clé privée.

Si l’envoi de mails chiffrés fonctionne, il reste encore à modifier la configuration de motion :

$ nano /etc/motion/motion.conf

Modifier les deux lignes suivantes :

[...]
on_event_start echo 'Alerte' | gpg -ea -r "clé publique du destinataire" | mutt -s 'Alerte détection le %d/%m/%Y à %H:%M:%S' email_destinataire
[...]
on_movie_end gpg --encrypt --recipient "clé publique du destinataire" %f && echo 'Vidéo capturée en pièce jointe' | gpg -ea -r "clé publique du destinataire" | mutt -s 'Vidéo capturée suite à la précédente détection' -a %f.gpg -- email_destinataire
[...]

Démarrer motion et faire un test de détection. Les mails reçus sont chiffrés. Thunderbird demandera la passphrase pour pouvoir les déchiffrer.