P. COVES P. COVES
P. COVES Un pense-bête pour le moi du futur

Password-store

Au début, il suffisait d’un mot de passe, c’était simple : password. Puis, il a fallu le changer tous les six mois, qu’à cela ne tienne, password0, password1 et les suivants faisaient l’affaire. Mais après le mot de passe devait contenir au moins une majuscule, puis un chiffre, puis un ou plusieurs caractères spéciaux et sont apparus Password, Passw0rd et autres Pass/w0rd.

On le sait désormais, utiliser le même mot de passe pour des services différents et choisir des mots de passe faciles à mémoriser deviner sont de mauvaises pratiques. Mais trouver et se souvenir de trop nombreux mots de passe différents n’est pas aisé.

Et puis au fond, pourquoi s’embêter à les trouver? Autant les générer aléatoirement. Et tant qu’on y est, pourquoi s’embêter à les mémoriser? Un ordinateur fait ça tellement mieux que nous.

Un gestionnaire de mots de passe fait exactement cela : générer, mémoriser, et remplir les mots de passe à notre place. Il suffit de n’en retenir qu’un pour débloquer tous les autres.

Il existe un vaste choix de gestionnaires de mots de passe. Certains sont payants, d’autres gratuits, voir même libres et open-source. Tous ont un cœur de fonctionnalités communs mais certains proposent des services comme, par exemple le partage de mots de passe avec des tiers de confiance.

Ce guide décrit l’usage de pass que ses développeurs présentent comme le gestionnaire de mots de passe standard UNIX. Pass est libre, open-source et repose sur deux outils qui le sont tout autant :

  • GnuPG pour la génération et le (dé)chiffrement des mots de passe.
  • Git pour la synchronisation entre machines et le partage entre utilisateurs.

Initialiser pass

Lors du premier usage de pass il faut initialiser non seulement le gestionnaire de mots de passe mais aussi lui indiquer d’utiliser git pour les garder à jour entre machines/utilisateurs.

Initialisation locale

Comme dit ci-dessus, pass repose sur GPG pour le chiffrement et le déchiffrement des mots de passe. De fait, il est nécessaire de disposer des clés publiques pour le chiffrement et d’au moins une clé privée pour le déchiffrement.

La suite de ce guide se déroule sur la machine d’Alice qui souhaite pouvoir partager ses mots de passe avec Bob.

❯ gpg --list-keys
$HOME/.gnupg/pubring.kbx
-------------------------------
pub   rsa3072/0xE8CD8414956820D7 2021-01-31 [SC] [expires: 2023-01-31]
      Key fingerprint = 086E B3AD F84C E139 1140  73F8 E8CD 8414 9568 20D7
      Keygrip = 67916BB87698F3C72E22D1C59410079AA8CB1C91
uid                   [ultimate] Alice
sub   rsa3072/0xAA4B503920AD4610 2021-01-31 [E]
      Keygrip = ADBC8BEFC648501AC694C3CA3DAED838B853C638

pub   rsa3072/0x2CAC3B0C969BF324 2021-01-31 [SC] [expires: 2023-01-31]
      Key fingerprint = 38D5 4AFC D21C D568 AEBC  6BEE 2CAC 3B0C 969B F324
      Keygrip = DD2875EF06D9E8966D8CF9E2A5D0A7012320ABEC
uid                   [ultimate] Bob
sub   rsa3072/0x78DB1FB7AA98AB88 2021-01-31 [E]
      Keygrip = 6E9B1252A14E01E82A5983F40C523BBC1CB5F655

Alice possède sa clé publique de chiffrement ainsi que celle de Bob. Elle peut donc chiffrer pour eux deux.

❯ gpg --list-secret-keys
$HOME/.gnupg/pubring.kbx
-------------------------------
sec   rsa3072/0xE8CD8414956820D7 2021-01-31 [SC] [expires: 2023-01-31]
      Key fingerprint = 086E B3AD F84C E139 1140  73F8 E8CD 8414 9568 20D7
      Keygrip = 67916BB87698F3C72E22D1C59410079AA8CB1C91
uid                   [ultimate] Alice
ssb   rsa3072/0xAA4B503920AD4610 2021-01-31 [E]
      Keygrip = ADBC8BEFC648501AC694C3CA3DAED838B853C638

Alice est en possession de sa clé privée. Elle pourra donc déchiffrer les mots de passe.

L’initialisation de pass prend en argument la ou les identités capables de (dé)chiffrer les mots de passe :

❯ pass init Alice Bob
mkdir: created directory '$HOME/.password-store/'
Password store initialized for Alice, Bob

Fidèle à la philosophie UNIX, dans pass, tout est fichiers.

❯ tree -a $HOME/.password-store/
$HOME/.password-store/
└── .gpg-id

0 directories, 1 file

❯ cat $HOME/.password-store/.gpg-id
Alice
Bob

Pour le moment, aucun mot de passe n’est stocké. Le dossier ~/.password-store ne contient qu’un fichier ~/.password-store/.gpg-id qui liste les utilisateurs : Alice et Bob.

Initialisation de git

Les mots de passe stockés par pass sont chiffrés via GPG et peuvent donc librement être partagés : seules les personnes dotées des clés privées seront capables de les déchiffrer. Et quoi de mieux que git pour partager et éditer à plusieurs ce qui n’est rien d’autre que des fichiers de texte?

La bonne nouvelle ici, c’est que quiconque connait git, connait aussi son intégration dans pass. L’exemple suivant suppose que Alice a créé un dépôt sur https://gitlab.com appelé alice_and_bob.

❯ pass git init
Initialized empty Git repository in $HOME/.password-store/.git/
[master (root-commit) 2da90e6] Add current contents of password store.
 1 file changed, 2 insertions(+)
 create mode 100644 .gpg-id
[master 1155f54] Configure git repository for gpg file diff.
 1 file changed, 1 insertion(+)
 create mode 100644 .gitattributes
❯ pass git remote add origin git@gitlab.com:alice/alice_and_bob.git
❯ pass git push -u origin master
Enumerating objects: 6, done.
Counting objects: 100% (6/6), done.
Delta compression using up to 8 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (6/6), 530 bytes | 530.00 KiB/s, done.
Total 6 (delta 0), reused 0 (delta 0), pack-reused 0
To gitlab.com:alice/alice_and_bob.git
 * [new branch]      master -> master
Branch 'master' set up to track remote branch 'master' from 'origin'.

Les étapes sont les suivantes :

  1. Initialiser localement un dépôt git dans le dossier du gestionnaire de mots de passe.
  2. Indiquer à git où trouver le serveur pour pouvoir partager les futurs mots de passe.
  3. Pousser le contenu créé à l’étape d’initialisation locale.
❯ pass git ls-files
.gitattributes
.gpg-id

Pour le moment, seuls la configuration de git et les utilisateurs de pass sont versionnés.

Modifier/ajouter un membre

Si Alice et Bob décident un jour de partager leurs mots de passe avec Charles il leur faudra chacun ajouter la clé publique de ce dernier. Puis, l’un des deux devra lancer la commande suivante:

echo Charles >> ~/.password-store/.gpg-id
pass init $(cat ~/.password-store/.gpg-id)

Pass va alors ajouter le chiffrement à destination de Charles et il ne restera qu’à pousser le dépôt mis à jour.

Utiliser pass

Maintenant que pass est initialisé, il est temps de s’en servir.

Mémoriser un mot de passe n’est pas très utile s’il n’est pas associé à son identifiant et au service auquel la paire donne accès. Une approche qui a fait ses preuves consiste à mettre le mot de passe sur la première ligne puis des paires clé: valeur dans les lignes suivantes. Les intégrations de pass dans les navigateurs web comprennent et utilisent cela pour ouvrir les sites et s’identifier dessus en une seconde.

Insertion de mots de passe

Au début, il est nécessaire de renseigner les mots de passe en cours. Il sera toujours temps d’en générer de nouveaux plus tard.

❯ pass insert --multiline gitlab
Enter contents of gitlab and press Ctrl+D when finished:

Pass/w0rd
login: alice
url: https://gitlab.com/users/sign_in
[master 0a82e67] Add given password for gitlab to store.
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 gitlab.gpg

L’option --multiline ou -m permet de renseigner toutes les informations d’un coup. En cas d’omission, pass demandera simplement le mot de passe à stocker. Il sera ensuite possible de rajouter les informations manquantes avec pass edit gitlab qui ouvrira gitlab.gpg déchiffré pour édition et le chiffrera automatiquement lors de la sauvegarde.

❯ pass git ls-files
.gitattributes
.gpg-id
gitlab.gpg

❯ pass git log
commit 0a82e67cb109f5b3cb6be9b1caf10592051f786d (HEAD -> master)
Author: Pablo COVES <coves@anatoscope.com>
Date:   Sun Jan 31 18:16:18 2021 +0100

    Add given password for gitlab to store.
[...]

❯ cat $HOME/.password-store/gitlab.gpg

y{GԐg
     $\
       1!,z2NzJGI.v9/}T<.>1ѽTwZ?=t')b<xgy=l>I^X#)sgm`Z$Kx&pIg?6a'ϝM7
s:ޒъ`)E1c       ğ
KKZ?)z;o.M'{#1+
               dAWlRS//`,'򽍼pe(  (TU}'?]=ű6d+3j9F\K"=WWXis/Slpᶲ\!tbT_6lv*
ŷH\QOnG7,XJ>'.O;}.g(P=                                                  }_TZ(q; Pzz]|nV@n6XkV=5?ȤeHd?^5"D&PvE˵ܙN[/90ALJoT
                      =
                       uLĐ:<_qz:!gi4?za.",lֳK51a*FO<J!LpA5'Q2wp#?|T^Q
                                                                    wkyyoJTbP=v+/V::7l|
O<+Ӽ1B5׳v׼|ظTWy)q3wcMV68bZL5FO                                                         -y!Vi2   ĝp$4rXO},U`&wkvo>,A2)%<qn6Pxn-~9ɾwqn֦

Le nouveau mot de passe est automatiquement versionné avec un message de commit dédié. Et, le fichier est bien chiffré via GPG

Génération de mots de passe

Lors de l’inscription à un nouveau service, plus question d’utiliser le mot de passe à tout faire : il faut en générer un nouveau aléatoirement.

❯ pass generate foo 42
[master 3481576] Add generated password for foo.
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 foo.gpg
The generated password for foo is:
}\\huh@Y&F`jUB>TI%_?0J;:yY]bw_/t]Wu]:NIjlZ

La sous-commande generate prend deux arguments : le nom du service et la longueur du mot de passe. Dans l’exemple ci-dessus, 42 caractères aléatoires sont inscrits chiffrés dans le nouveau fichier. Il faut ensuite ajouter les informations supplémentaires via pass edit foo.

Certains services ne supportent pas les caractères spéciaux, il suffit d’ajouter --no-symbols/-n pour générer des mots de passe plus simples.

Changer de mot de passe

Vient un moment où il est bon de changer de mot de passe, surtout si le même ou presque a été utilisé à de nombreux endroit.

Bien sûr, il est possible d’utiliser la sous-commande generate, mais le contenu du fichier chiffré serait alors totalement réécrit, perdant alors les informations associées.

L’option --in-place/-i indique à pass de ne changer que la première ligne, celle qui contient le fameux mot de passe :

❯ pass generate gitlab -i -n 23
[master 3cc9fdf] Replace generated password for gitlab.
 1 file changed, 0 insertions(+), 0 deletions(-)
 rewrite gitlab.gpg (100%)
The generated password for gitlab is:
h33STiuw5I3IOf013iTrVop

Le mot de passe à ne plus utiliser est désormais remplacé par 23 caractères aléatoires sans autres symboles que des chiffres et des lettres.

Récupérer les mots de passe

Enregistrer ou générer des mots de passe n’est pas vraiment suffisant, il faut aussi pouvoir les lire. Une fonctionnalité aussi basique ne peut être que la plus simple :

❯ pass gitlab
h33STiuw5I3IOf013iTrVop
login: alice
url: https://gitlab.com/users/sign_in

Si le but est simplement d’obtenir le mot de passe sans que le contenu du fichier déchiffré ne soit lisible, l’option --copy/-c est là :

❯ pass gitlab -c
Copied gitlab to clipboard. Will clear in 45 seconds.

Intégrer pass

Devoir ouvrir un terminal pour accéder à ses mots de passe n’est pas viable sur le long terme. Encore moins sur un smart phone qui n’offre peut-être même pas cette possibilité. Heureusement, il est possible d’intégrer pass aux navigateurs web et aux applications mobiles.

Sur ordinateur

Les intégrations de pass sur ordinateur reposent sur un script (host application) que les applications peuvent appeler pour récupérer les mots de passe.

Plusieurs intégrations sont disponibles :

La liste officielle contient notamment une référence à QtPass, une interface graphique pour gérer pass.

Sur mobile

Les applications mobiles s’intègrent dans les navigateurs web des téléphones comme sur l’ordinateur mais aussi dans les autres applications. Pas besoin de passer d’une application à l’autre pour remplir l’identifiant et le mot de passe, tout se fait en un clic.

Utilisation au travail

Alice fait confiance à Bob et lui partage ses mots de passe personnels. Il ne serait cependant pas normal que Bob ait accès aux mots de passes que Alice doit partager avec Charles pour leur travail.

Comme dit plus haut dans ce guide, pour pass, tout est fichier. Il est donc parfaitement possible de créer une hiérarchie de fichiers.

❯ pass init -p work Alice Charles
mkdir: created directory '$HOME/.password-store/work'
Password store initialized for Alice, Charles (work)
[master ae922a9] Set GPG id to Alice, Charles (work).
 1 file changed, 2 insertions(+)
 create mode 100644 work/.gpg-id

❯ pass generate work/bar 23
[master b4c02f8] Add generated password for work/bar.
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 work/bar.gpg
The generated password for work/bar is:
.)zL+<>}N12U?tBj)-r&b3D

❯ ls -lah .password-store/work/
Permissions Size User   Date Modified Name
.rw-------    14 alice  1 Feb  8:58  .gpg-id
.rw-------   873 alice  1 Feb  9:00  bar.gpg

❯ cat .password-store/work/.gpg-id
Alice
Charles

❯ pass work/bar
.)zL+<>}N12U?tBj)-r&b3D

L’option --path/-p indique un répertoire dans lequel sera initialisé un autre ensemble de mots de passe pour un autre ensemble de personnes. Ici, Alice utilise un dossier work pour collaborer avec son collègue Charles après avoir importé sa clé publique. L’étape d’initialisation git n’est pas montrée ici, mais il est ensuite possible pour Alice et Charles de partager des mots de passes sans que Bob ne puisse les lire en suivant les étapes montrées précédemment.

One Time Password (OTP)

L’usage d’OTP, ces petits codes à six chiffres agissant comme une preuve supplémentaire de notre identité est de plus en plus fréquente. L’idée est simple : en plus d’un identifiant et d’un mot de passe, un code, renouvelé très fréquemment et seulement connu d’une personne est demandé. Le fait de fournir ce code prouve que la personne accédant au service a bien accès à une information connue du seul propriétaire et fournie par le service auparavant.

Nativement, pass ne sait pas gérer l’OTP, mais une extension, pass-otp ajoute cette fonctionnalité bien utile. Chose intéressante, elle est nativement embarquée dans les clients mobiles.

En pratique, lors de l’activation du Multifactor authentication/Two factor authentication, le service propose généralement un QrCode. Il suffit de le scanner avec l’application mobile pour que les paramètres de génération de l’OTP soient enregistrés. Synchroniser avec git permet de transmettre ces paramètres à toutes les machines et profiter de l’OTP de partout.

❯ pass otp gitlab
306264

Notes

Identités

Il est plus judicieux d’utiliser les identifiants hexadécimaux des clés plutôt que les identités pour désigner les parties en présence. Il faudrait utiliser 0xE8CD8414956820D7 à la place de Alice et 0x2CAC3B0C969BF324 à la place de Bob.

Alternatives

  • https://bitwarden.com/
  • https://keepass.info/
  • https://www.keepassx.org/
  • https://www.lastpass.com/
  • Liste non exhaustive.