Linux : comment éviter d’entrer sa passphrase à chaque utilisation d’une clé SSH ?
Sommaire
I. Présentation
Pour s’authentifier et se connecter de manière sécurisée à un service ou un serveur, on a 2 possibilités sous Linux : le classique (et désuet) login / mot de passe, ou la clé SSH, protégée par une passphrase.
Plus besoin de se souvenir de 36 mots de passe différents : une clé SSH et c’est parti.
Oui, mais voilà : Quand on est amené à se connecter plusieurs fois par jour à des serveurs via SSH, ou qu’on effectue des rafraîchissements de son repository Git à partir du serveur, la passphrase nous sera demandée, systématiquement, à chaque nouvelle connexion.
Ce qui peut être vraiment lourd au bout de la cinquantième fois.
J’ai une astuce pour vous : vous connaissez Keepass ? Et bien on va reprendre le même principe : on va stocker de manière sécurisée la clé SSH ainsi que la passphrase dans un coffre sécurisé.
Ainsi, plus besoin de taper 50 fois votre passphrase chaque jour, vous ne la saisirez plus qu’une seule fois, au démarrage de votre système Linux. Et la magie fera le reste ! ?
Si vous souhaitez avec plus d'informations sur le système de clé privée/clé publique, je vous invite à lire ce cours écrit par Florian Burnel :
- Clés asymétriques : http://www.it-connect.fr/les-cles-asymetriques/
II. Prérequis
- Une distribution Linux (machine virtuelle, WSL2). Dans ce tuto, j’utilise Ubuntu version 20.04.
- Avoir une clé SSH déjà générée, avec une passphrase.
III. Vérifier la présence de la clé SSH
Pour commencer, on va vérifier que votre clé SSH est bien présente sur votre système Linux.
Pour cela, ouvrez un terminal, et tapez la commande :
ls -al ~/.ssh
Vous devriez voir apparaître plusieurs fichiers, celui qui nous intéresse étant id_rsa.
Note : ~ correspond au chemin de votre profil sous Linux, dans mon cas, il s’agit de : /home/thibault, comme on peut le voir sur la capture d’écran ci-dessus.
Avant d’installer et de configurer Keychain, une dernière chose à vérifier : votre clé SSH est une clé privée. Mais on va tout de même s’en assurer du côté des permissions de Linux :
On peut voir dans mon cas que ma clé privée (le fichier id_rsa) n’est pas vraiment privée. On va changer ça de suite, pour éviter des messages d’erreur de nos applications préférées :
sudo chmod 600 ~/.ssh/id_rsa
Note : Si vous n’êtes pas propriétaire des fichiers se trouvant dans votre dossier .ssh, il faudra vous réattribuer la propriété, sinon vous aurez des difficultés pour lire les fichiers.
Dans mon cas, mon nom d’utilisateur étant « thibault », cela donne :
sudo chown thibault:thibault ~/.ssh/id_rsa
On vient d’accorder des droits en lecture / écriture uniquement au propriétaire du fichier, et à personne d’autre. On ne peut pas faire plus privé. ?
IV. Installer et configurer Keychain pour sauvegarder automatiquement la passphrase
Ceux qui me connaissent savent que j'utilise Git pour le versioning de la totalité de mes scripts et des configurations serveurs / logiciels.
Et pour l'exemple, j'ai effectué un git clone, pour copier le contenu d'un répertoire distant (un repository) sur un répertoire local de mon poste. L'authentification s'effectue via ma clé SSH, et forcément, Git me demande de confirmer ma passphrase avant de lancer les actions.
Le truc particulièrement énervant, et notamment quand notre passphrase fait plus de 25 caractères, c'est que si je réexécute la même commande quelques secondes plus tard, je vais devoir à nouveau renseigner la passphrase.
Plutôt fastidieux, notamment lorsqu'on est dans mon cas et qu'on doit la renseigner plus de 50 fois par jour...
Pour éviter de taper encore et encore la même passphrase à chaque fois que l’on fait appel à notre clé SSH, on va s’installer Keychain, puis le configurer.
Pour l’installation, on reste sur du classique de chez classique :
sudo apt install -y keychain
Note : le -y indique de répondre « Oui » à la question : Êtes-vous sûr de vouloir continuer ? Une option particulièrement utile pour l’automatisation.
Pour vérifier que Keychain est bien installé sur votre système, tapez :
keychain --version
Il vous reste maintenant à modifier votre profil pour ajouter la configuration de keychain. Pour cela, ouvrez le fichier ~/.bashrc dans votre éditeur de texte préféré. Dans mon cas, j’utilise vim, mais libre à vous de passer sur d’autres éditeurs :
vim ~/.bashrc
Et ajoutez la ligne suivante à la fin du fichier :
eval `keychain --eval --agents ssh id_rsa
À chaque fois que vous rebooterez votre serveur ou que vous démarrerez, un nouveau terminal, keychain s’exécutera.
À la première exécution suite à un reboot, keychain reconnaîtra votre clé SSH et vous demandera de saisir la passphrase :
Par la suite, à chaque nouveau terminal créé, keychain vous avertira qu’il a déjà en stock la clé SSH ainsi que la passphrase. Plus besoin de la taper du coup, keychain s’en chargera à votre place à chaque fois que le système en aura besoin pour se connecter à une ressource distante.
V. Conclusion
Comment s’en assurer ? Dans mon cas, je crée un nouveau répertoire de test et je relance la copie de mon repository Git avec la commande :
git clone <mon-lien-git>
Et pouf ! Par magie, ça se fait, sans action de ma part : plus besoin de taper ma passphrase tout au long de la journée. Je la saisis le matin en arrivant et c’est réglé.
Sacré gain de temps, n’est-ce pas ?
Salute,
sudo chown thibault :thibault ~/.ssh/id_rsa => sudo chown thibault:thibault ~/.ssh/id_rsa
eval « keychain –eval –agents ssh id_rsa => eval `keychain –eval –agents ssh id_rsa`
Tcho !
Yes, je corrige ça, merci 🙂
C’est vrai que c’est ennuyeux de retaper les passphrases, mais du coup, elles servent à sécuriser la clé. si tu enregistres ta clé même hasher en sha256 tu crées un risque plutôt minime, mais il est là du coup. ne serait-il pas plus simple de mettre un mot de passe moi long plutôt que d’utiliser ce genre d’outils ?
Effectivement, c’est un risque supplémentaire, mais minime.
Même avec une passphrase plus courte, au bout du cinquantième commit Git de la journée, j’ai fini par craquer.
Les outils tels que Keychain permettent je pense un bon compromis entre la sécurité et l’usage.
Que ce soit sur Windows ou Linux, j’essaye toujours de trouver un compromis entre une sécurité accrue et qui a du sens, et un usage pas trop contraignant. Du coup, on pourrait aussi réduire la durée de validité de la clé SSH en question, limiter les IPs de confiance pouvant initier une session SSH, travailler sur les droits des comptes users, mettre en place un bastion SSH
En terme de sécurité, on peut aussi travailler sur les droits des comptes se connectant aux serveurs, limiter la plage des IPs de confiance pouvant initier des sessions SSH sur les serveurs, etc.
Alternative 1
# eval $(ssh-agent);ssh-add ~/.ssh/id_rsa
# ssh-add -l #liste les clés qui sont dans l’agent ssh
Alternative 2
générer une clé SSH sans phrase mais avec clé physique, type Yubikey par exemple.
# eval $(ssh-agent);ssh-add ~/.ssh/id_ecdsa_sk
pas de phrase à entrer, une doigt sur la clé suffit.
Pour ne pas avoir à rentrer le mot de passe de la clé dans mes scripts : eval `keychain –noask –eval id_rsa`
Bonjour,
Merci pour ce tutoriel. Je l’ai suivi et installé keychain sans problème
mais kchain ne me demande pas la passĥrase à l’ouverture du terminal:
* keychain 2.8.5 ~ http://www.funtoo.org
* Found existing ssh-agent: 1783
SSH_AUTH_SOCK=/run/user/1000/keyring/ssh; export SSH_AUTH_SOCK;
SSH_AGENT_PID=1783; export SSH_AGENT_PID;
* Known ssh key: /home/didier/.ssh/id_rsa
et je suis donc obligé d’entrer ma passphrase à chaque connexion sur un serveur distant.
merci!
Didier
Ubuntu 20.04.6 LTS
Gnome 3.36.8
Bonjour tout le monde.
Déjà merci bien pour le tuto très utile !
J’apporte une réponse un peu tardive, mais si cela peut aider quelqu’un :
À mettre dans le ~/.bashrc
eval `keychain –inherit local –-eval –-agents ssh ~/.ssh/id_rsa`
J’ai ajouté l’option ‘–inherit local’ à la commande eval `keychain –eval –agents ssh id_rsa` qui permet de toujours récupérer le dernier PID du ssh-agent.
Bonne journée à tout le monde