---
categories: ['']
date: 2022-10-25T17:05:45+02:00
description: "Découverte du coffre fort numérique, gestionnaire de mot-de-passe unix, d'informations personnelles, qu'est 'pass'."
draft: false
include_toc: true
show_comments: false
tags: ['']
title: "Pass : À la Découverte d'un Gestionnaire de Mot de Passe"
translationKey: 'pass-password-store'
---
## Description
`pass` est un gestionnaire de mot-de-passe, respectant la philosophie Unix,
qui se veut être simple. Et, pour d'aucuns, il est CLI… mais pas que !
Des gestionnaires de mot-de-passe, il en existe pléthore ; pour n'en citer
quelques uns, tel KeePass *(et ses déclinaisons)*, BitWarden, etc…
Comme beaucoup, c'est plus un gestionnaire d'identités et d'informations
personnelles confidentielles qu'un basique gestionnaire de mots de passe.
En bref, c'est un coffre fort numérique, en CLI, à la sauce GPG !
Qu'a donc de **SI** particulier **pass** ?
Il est :
- CLI
- chiffré par GPG
- simple à utiliser
- *(peut)* utilise(r) Git
- mettre très temporairement en copie les infos dans le presse-papier.
Mais encore ?
Il fait de la complétion pour les shells suivants :
- Bash
- fish
- zsh
Et pour finir, il a des extensions intéressantes, certaines pour
navigateurs web, et des clients GUI pour différentes plateformes.
- Licence : GNU/GPL v2
- Site web: https://www.passwordstore.org
## Installation
Installons le binaire et l'interface graphique *— cette dernière n'est pas
nécessaire, mais utile —* :
⇒ Debian/*Buntu *(et assimilés)* : `apt install pass qtpass`
⇒ OpenBSD : `pkg_add password-store qtpass`
### Extensions
Parmi les extensions utiles, il y a :
- **[pass-import](https://github.com/roddhjav/pass-import)** pour importer
depuis de nombreux autres gestionnaires de mot-de passes ;
- pour Debian/*Buntu, il faut l'installer depuis le dépôt de
l'auteur, *qui fournit un paquet .deb.*
- quant à OpenBSD, installable depuis les ports,
- **[pass-extension-tail](https://github.com/palortoff/pass-extension-tail)**
pour afficher les informations secondaires, renfermées dans un des
fichiers chiffrés.
- pour Debian/*Buntu, depuis les dépôts officiels
- pour OpenBSD, depuis le dépôt git, avec la cible `make install`
- **[pass-otp](https://github.com/tadfisher/pass-otp#readme)** qui ajoute
le support des tokens OTP.
*Dans le contexte de sécurité multi-facteurs, il vaut mieux utiliser
une autre application, qui sera elle seule responsable de cet aspect.*
- pour Debian/*Buntu : **pass-extension-otp**, depuis les dépôts officiels
- pour OpenBSD : **pass-otp**, depuis les ports
Il en existe quelques autres… *dont **[pass-tomb](https://github.com/roddhjav/pass-tomb#readme)**.*
### Clients compatibles
Parmi les clients compatibles actifs, il existe principalement :
- **qtpass** : interface QT pour Linux, \*BSD
- **[Password Store](https://github.com/android-password-store/Android-Password-Store)** :
pour Android, disponible, entre autres, sur F-Droid ; *à coupler avec
l'app **OpenKeychain** pour gérer la clé GPG*.
- **BrowserPass** : un projet scindé en deux :
- [Browserpass-native](https://github.com/browserpass/browserpass-native) :
une sorte de proxy pour communiquer entre le gestionnaire et l'
extension pour les navigateurs web.
- Installable depuis les dépôts pour Debian/*Buntu, nommée **webext-browserpass**.
- Quant à OpenBSD, il faudra la compiler localement avec la cible
**make browserpass-openbsd64**, après avoir téléchargé le dépôt.
- [Browserpass-extension](https://github.com/browserpass/browserpass-extension) :
une extension pour les navigateurs Chrome et Firefox.
**Il n'est pas recommandé d'activer l'option OTP pour des raisons
de sécurité, pour la raison sus-mentionnée**.
- **[passforios](https://mssun.github.io/passforios/)** : pour iOS
- y'en a même [une](https://git.zx2c4.com/password-store/tree/contrib/emacs)
pour les addicts emacs….
Et certainement bien d'autres…
## Configuration
### Extensions
Un fichier de configuration spécial `~/.password-store/.extensions/COMMAND.bash`
peut être créé afin d'activer les extensions installées.
Il faut y ajouter :
- `PASSWORD_STORE_ENABLE_EXTENSIONS=true` pour ajouter le support des extensions
### VARIABLES ENVIRONNEMENT
Quelques variables d'environnement utiles :
- `PASSWORD_STORE_DIR` définit le répertoire par défaut du gestionnaire
- `PASSWORD_STORE_EXTENSIONS_DIR` définit le répertoire des fichiers
d'extension ; par défaut `PASSWORD_STORE_DIR/.extensions`.
- `PASSWORD_STORE_CLIP_TIME` est le nombre de secondes de rétention dans
le presse-papier, par défaut de **45 secondes**.
- `PASSWORD_STORE_GENERATED_LENGTH` est la longueur en nombre de caractères
du mot de passe à utiliser par défaut pour l'option `generate`.
- `PASSWORD_STORE_GPG_OPTS` afin de passer des options à GPG.
- `EDITOR` sera l'éditeur texte utilisé par l'option `edit`.
Et à coup sûr, d'autres…
### gpg-agent.conf
Il peut être utile, surtout en rapport avec l'extension **Browserpass**,
d'éditer le fichier `~/.gnupg/gpg-agent.conf` pour ajouter la gestion de
la saisie correcte des mots de passe par l'outil **pinentry**, tel que :
- `pinentry-program /usr/bin/pinentry-gtk-2` pour un bureau utilisant
les bibliothèques Gtk2, tel Cinnamon, Gnome 2, Mate, Xfce, …
- `pinentry-program /usr/bin/pinentry-gnome3`, pour Gnome 3, Xfce, …
- `pinentry-program /usr/bin/pinentry-x11` pour tout autre bureau sous
environnement X11, tel Enlightenment, LXDE, LXQt, dwm, …
- voire `pinentry-program /usr/bin/pinentry` ou son équivalent `/usr/bin/pinentry-curses`
si vous ne fonctionnez qu'en environnement terminal.
## Utilisation
Bien que le site soit descriptif quant à son installation et utilisation,
ainsi que le [man page](https://git.zx2c4.com/password-store/about/),
voyons ensemble quelques étapes intéressantes :
⇒ L'usage de la commande `pass` sans aucune option affiche le contenu
de l'arborescence tel que créé, par vos soins. Pour l'instant, il est vide.
---
### Initialisation
L'initialisation du gestionnaire se fait localement et est liée à une clé
GPG créée précédemment, tel que :
```sh
$ pass init email@domain.tld
mkdir: created directory ‘/home/your-user/.password-store’
Password store initialized for email@domain.tld.
```
Il est important de comprendre que l'initialisation puis l'ouverture du
gestionnaire demandera obligatoirement le mot de passe liée à la clé GPG.
### Gestion du dépôt git
En second, vient la phase du dépôt local git :
```sh
$ pass git init
Initialized empty Git repository in /home/your-user/.password-store/.git/
[master (root-commit) 998c8fd] Added current contents of password store.
1 file changed, 1 insertion(+)
create mode 100644 .gpg-id
```
Il crée localement le fichier `.gpg-id` qui renferme l'identifiant long
de l'empreinte de la clé GPG.
---
⇒ Ajout du dépôt extérieur
Ensuite ajouter un dépôt Git extérieur *— ceci sera utile pour la
réplication des données au-travers des différents GUI disponibles,
sur d'autres OS —* :
```sh
$ pass git remote add origin URL-depot-git
```
---
⇒ Ajout des signatures GPG
De plus, il est fortement recommandé d'ajouter le support des signatures
GPG :
```sh
$ pass git config --bool --add pass.signcommits true
```
Chaque commit nécessitera ainsi l'usage d'une clé GPG pour confirmer que
vous êtes bien l'auteur de la modification. *La Clé GPG peut très bien
être différente de celle liée au gestionnaire pass. Elle est liée à la
configuration du dépôt extérieur.*
---
⇒ À-propos de Git :
Les options de Git sont utilisables en argument de l'option `git` exactement
à l'identique de l'outil Git.
- Pour pousser un ou plusieurs commits vers le dépôt extérieur : `pass git push`, à minima.
- Pour récupérer depuis le dépôt extérieur : `pass git pull`…
- etc.
Du fait d'avoir initié le dépôt local git, chaque création, la moindre
modification, d'un fichier chiffré générera automatiquement un commit.
Si vous utilisez la signature GPG de commit, il vous sera demandé le mot
de passe lié à la clé GPG pour les commits… *qui, pour rappel, peut très
bien être différente de la clé GPG du gestionnaire pass*.
### Gestion des fichiers chiffrés
{{< note info >}}
Après un certain délai, relativement court : 45 sec., même la consultation
d'un fichier chiffré provoquera un appel du mot de passe lié à la clé GPG
relative au gestionnaire pass. Ne soyez pas étonné que cela vous soit
régulièrement demandé.
---
**Conventions d'écriture :**
- **La première ligne** d'un fichier chiffré est **toujours le mot-de-passe** !
- **La deuxième ligne** peut servir à entrer l'identifiant lié au mot-de-passe, autrement
dit le **login**
- **La troisième ligne** peut servir à entrer l'**URL** correspondante, s'il y a lieu…
- d'autres lignes… d'autres informations utiles, pertinentes, etc.
C'est une convention utile à respecter… mais par défaut, étant donné que c'est
un simple fichier texte chiffré, pass n'impose aucun schéma ou type d'organisation.
Si ce n'est qu'il est préférable d'avoir en première ligne l'écriture du
mot de passe, car c'est son mode opératoire, et là où toute extension,
tout client cherchera cette information précise.
Merci de lire le man page pour avoir d'autres notions de conventions.
{{}}
⇒ Création
Créons notre premier fichier chiffré nommé **test**, à l'aide de
l'option `insert` :
```sh
$ pass insert test
Enter password for test:
Retype password for test:
[master 53331b0] Add given password for test to store.
1 file changed, 0 insertions(+), 0 deletions(-)
create mode 100644 test.gpg
```
Lors de la création, il est demandé de taper un mot de passe, puis de le
ré-écrire une deuxième fois, puis un commit est généré.
Cette option permet de définir par ses propres soins un mot-de-passe.
L'utilisation de l'argument `-m` permet l'ajout d'autres informations, en
mode multilignes. Il faudra presser la combinaison de touches CTRL+D
pour sortir de ce mode d'édition.
{{< note warning >}}
ATTENTION : l'utilisation de cette option sur un fichier chiffré aura pour
conséquence de vider toute information existante. Il sera demandé de confirmer
avant ; en cas de refus de votre part, l'action cessera.
{{}}
⇒ Édition
L'édition de tout fichier chiffré se fait avec l'option `edit`, tel que :
```sh
$ pass edit test
```
Ce qui aura pour propos d'ouvrir l'éditeur de texte lié à votre environnement
ou par défaut `vi`, si aucun n'est configuré. *Là, encore pour les amoureux
d'emacs, installez l'extension correspondante.*
Il est ainsi possible de modifier toute information dans le fichier chiffré,
dont le mot de passe, lisible en clair.
⇒ Génération d'un mot de passe
{{< note warning >}}
ATTENTION : À moins d'utiliser l'argument `-i`, l'utilisation de cette option
sur un fichier chiffré aura pour conséquence de vider toute information
existante. Il sera demandé de confirmer avant ; en cas de refus de votre
part, l'action cessera.
{{}}
La génération d'un nouveau mot-de-passe pour un fichier chiffré se fait
par le biais de l'option `generate`, suivi du nom de fichier chiffré et
d'un chiffre représentant la longueur du mot de passe désiré :
```sh
$ pass generate test 32
An entry already exists for test. Overwrite it? [y/N] y
[master 5195534] Add generated password for test.
1 file changed, 0 insertions(+), 0 deletions(-)
The generated password for test is:
zJwz\1E(RjL3Ps{&7|?QZAt{&ps_A_GU
```
- Pour générer un mot-de-passe avec juste des lettres et des chiffres, dit
alphanumérique, c'est l'argument `-n` qu'il faut ajouter, tel que :
```sh
$ pass generate -n test 64
An entry already exists for test. Overwrite it? [y/N] y
[master 6dff2bd] Add generated password for test.
1 file changed, 0 insertions(+), 0 deletions(-)
The generated password for test is:
EWA0SlCkzcmlMgxMWJltGnHCMSxK4YXmPYg4X3BrNryJgoUREVVFaaOXSiKijbtm
```
L'option `generate` utilise le périphérique spécial `/dev/urandom` pour
générer le mot-de passe.
---
- L'argument `-c` copiera le mot de passe généré dans le presse-papier sans
l'afficher.
- L'argument `-i` est pertinent pour ne pas détruire les informations contenues
dans le fichier chiffré, tout en créant un nouveau mot de passe, tel que :
```sh
$ pass generate -i test 32
[master 25f75ab] Replace generated password for test.
1 file changed, 0 insertions(+), 0 deletions(-)
The generated password for test is:
FrCL98OE9C9*7bJusLVbw$%\@Y^[,|Lj
```
⇒ Voir le contenu
Pour voir le contenu d'un fichier chiffré, il suffit de l'appeler directement :
```sh
$ pass test
EWA0SlCkzcmlMgxMWJltGnHCMSxK4YXmPYg4X3BrNryJgoUREVVFaaOXSiKijbtm
login: test@gmail.com
URL: https://test-moi.tld
comments: Ceci est un faux compte pour test du gestionnaire `pass`
Merci de l'utiliser...
PIN: 123789654
```
*Les informations secondaires affichées dans cet exemple sont des ajouts
par mes soins, grâce à l'option `edit`.*
⇒ Trouver un contenu
Pour (re)trouver un contenu, c'est l'option `find` qui est à utiliser.
⇒ Copie et presse-papier
Pour copier dans le presse-papier, sachant qu'en suivant la convention de
la première ligne comme étant le mot de passe :
```sh
$ pass -c test
Copied test to clipboard. Will clear in 45 seconds.
```
Reste plus qu'à le coller où nécessaire.
Pour copier, selon la convention décrite ci-dessus, l'identifiant lié :
```sh
$ pass -c2 test
Copied test to clipboard. Will clear in 45 seconds.
```
Etc.
⇒ Suppression
La suppression d'un fichier chiffré est très simple :
```sh
$ pass rm test
rm: remove regular file ‘/home/your-user/.password-store/test.gpg’? y
removed ‘/home/your-user/.password-store/test.gpg’
```
---
Il existe quelques autres options ; je vous laisse les découvrir dans le
man page, telles `cp`, `ls` ou l'usage de `grep`, etc.
### OTP
La fonction OTP fonctionne bien, à partir du moment où l'on importe des
données depuis une autre source, grâce à l'extension **pass-import**.
En CLI, je ne suis pas arriver à utiliser **pass-otp** ; j'ai beau
eu faire `pass otp nom_fichier`, impossible ; alors qu'avec **qtpass**
et **Password Store**, cela fonctionne.
### qtpass
Bien-sûr, tout cela se gère aussi au-travers de l'interface graphique **qtpass**.
L'application graphique **qtpass** est intéressante car elle permet de
définir dans son onglet "Paramètres" :
- le comportement du presse-papier
- la longueur par défaut du mot-de-passe
- d'utiliser `pwgen` pour générer le mot-de-passe, et exclure ou non les
lettres en majuscule, les nombres, les autres symboles, tels les caractères
accentués, de générer des mots de passe facile à mémoriser
- d'utiliser git pour pousser automatiquement les push, les pulls, ajouter
la ou les clés GPG à gérer.
⇒ Dans son onglet "Programs", d'utiliser soit l'outil pass, soit les outils
natifs que sont Git et GPG…
⇒ De créer des profils de gestionnaire différents depuis l'onglet "Profiles".
⇒ De créer des modèles d'affichage de l'information pour les fichiers
chiffrés, depuis l'onglet "Templates".
### Password Store & OpenKeychain
L'app **Password Store** nécessite l'app **OpenKeychain**, toutes deux
installables depuis le store F-Droid.
**OpenKeychain** sert à stocker une ou plusieurs clés GPG.
Pour utiliser votre clé GPG dans votre smartphone, il vaut mieux se prémunir
de quelques précautions suivantes :
1. Génération d'un mot de passe aléatoire fort avec GPG, sur la station :
`gpg --armor --gen-random 1 20`
2. Chiffrement de la clé GPG dans la station, en utilisant le mot de passe
généré par GPG :
`gpg --armor --export-secret-keys "GPG-Fingerprint-long" | gpg --armor --symmetric --output mykey.sec.asc`
3. Transfert vers le smartphone, connecté en USB, ou par le biais d'une
carte SD.
4. Import dans OpenKeychain depuis le menu 'Importer ma clé' qui demandera
à nouveau le mot de passe généré à l'étape 1, et créera un fichier
nommé `decrypted.key` qu'il faudra importer lui aussi dans OpenKeychain.
### Browserpass
L'extension **Browserpass** pour les navigateurs web Chrome et Firefox est
simple à utiliser. Pour un site web donné, elle va chercher les occurrences
dans le gestionnaire **pass**. Elle va automatiquement cibler le site web
dont la page est ouverte.
- L'utilisation de la combinaison des touches CTRL+Shift+L permet
de rechercher les occurrences nécessaires, en lieu et place d'un clic
sur l'icône.
- La touche TAB permet de naviguer entre les différents occurrences
trouvées.
- Appuyer sur la touche ENTRÉE aura pour conséquence de remplir
automatiquement, valider la soumission d'un formulaire de connexion.
---
### Cas d'usage
1. Création d'un nouveau fichier chiffré, et/ou modification, soit en CLI
avec pass, soit avec la GUI qtpass.
2. git push, avec des commits signés, en SSH vers le dépôt GIT extérieur.
3. import dans Password Store, depuis le dépôt Git extérieur, par HTTPS
4. utilisation des extensions Browserpass pour la connexion à différents
sites web
5. utilisation d'OTP, soit au-travers d'une application tierce, soit après
import. *Personnellement, je préfère l'app tierce*.
Voilà un gestionnaire de mot de passe, totalement chiffré, par clé GPG,
dont les changements de chaque fichier .gpg sont versionnés par le biais
de Git, encapsulés soit dans une connexion SSH ou TLS selon l'usage.
Chaque usage, que ce soit de la consultation ou de la modification, quelque
soit l'outil utilisé, en CLI, par GUI, par une extension ou une autre,
telle l'extension Browserpass, nécessite absolument l'authentification GPG.
Voilà pour la découverte, assez complète, de ce gestionnaire de mot de passe,
voire d'informations personnelles… pardon, que dis-je, de ce coffre fort
numérique différent.
## Documentation
### Interne
- {{< inside2 l="sec/gpg/gpg-ed25519" >}}
- {{< inside2 l="sec/gpg/gpg-usage-securise" >}}
### Wikipedia
- {{< wp2 l="fr" n="Philosophie_d'Unix" >}}
---