Utilisation d’une SSH key avec GitHub
L’utilisation d’une SSH key avec GitHub permet un accès sans mot de passe aux référentiels Git. Au lieu d’identifier un utilisateur par son nom d’utilisateur et son mot de passe, la machine du développeur est authentifiée par la clé SSH.
Une clé SSH, c’est quoi ?
Secure Shell (SSH) est l’outil par défaut pour l’accès chiffré aux systèmes distants. SSH permet de se connecter à un serveur à partir d’une machine de développement locale. Github utilise SSH comme protocole de transmission et permet l’accès en lecture et en écriture aux référentiels distants.
Une connexion chiffrée est utilisée pour permettre l’authentification de la machine et pour garantir l’intégrité des données transmises. Sans celle-ci, des tiers seraient en mesure d’apporter des modifications aux référentiels.
Github via SSH utilise le chiffrement asymétrique comme méthode de chiffrement. Ce faisant, une paire de clés privée et publique est créée dans un premier temps. EIle est également nommée « Public-Private Keypair ». La clé privée reste sur l’ordinateur personnel, tandis que la clé publique est partagée avec des tiers comme GitHub.
Quand vous utilisez une SSH key pour accéder aux référentiels GitHub, vous n’avez pas besoin d’entrer de mot de passe. En général, la connexion sans mot de passe est considérée comme plus sûre, car les enregistreurs de frappe ou les chevaux de Troie ne peuvent ainsi pas espionner et accéder à vos données. Au lieu d’une personne connaissant le mot de passe, on utilise donc une machine sur laquelle la clé privée est stockée.
L’utilisation de GitHub via SSH est très pratique. Une fois configurée, la clé SSH permet un accès permanent à GitHub sans aucune autre intervention. D’autres protocoles et services exploitent également les clés SSH pour une connexion réseau chiffrée. Le protocole SFTP sécurisé peut également être utilisé pour échanger des fichiers avec des serveurs sans configuration supplémentaire.
La connexion aux référentiels Git est effectuée généralement dans l’invite de ligne de commande. Une fois la clé SSH configurée, vous pouvez facilement la pousser vers votre propre référentiel :
cd ./folder-with-git-repo/
git pushEn plus de l’application de ligne de commande, les applications avec interface graphique profitent également de la configuration d’une clé SSH. Les programmes FTP modernes prennent en charge le protocole de transfert de fichiers SSH (SFTP). Cette fonction est basée sur SSH et fait appel à des clés SSH existantes.
Comment utiliser les SSH keys avec GitHub
Pour accéder à votre compte GitHub à l’aide d’une SSH key, enregistrez la clé publique sur GitHub. La clé privée reste sur l’ordinateur personnel. La machine de développement est authentifiée auprès de GitHub en comparant les données de clé. Cela permet un accès en écriture à vos propres référentiels. Cette méthode fonctionne également avec des alternatives à GitHub comme Gitlab ou Bitbucket.
Aussi pratique que sont les clés SSH, il convient toutefois de les manipuler avec précaution. Ne partagez sous aucun prétexte la clé privée : si elle tombe entre de mauvaises mains, elle permettra à un tiers de s’authentifier à votre place. En votre nom, quelqu’un pourrait ainsi se connecter à un serveur ou modifier le code dans les référentiels.
Conditions requises pour l’utilisation de SSH key avec GitHub
Nous supposons que vous travaillez dans un environnement de type Linux. Il s’agit notamment de Linux/Unix, macOS et Windows sur lesquels WSL2 est installé. Les conditions suivantes doivent également être remplies :
- Git est installé
- SSH est installé
- Un compte GitHub a été créé
Commençons par vérifier si les conditions locales requises sont respectées. La commande suivante nous permet de tester si Git et SSH sont installés. Si vous ne recevez pas de message d’erreur « git not found » ou « ssh not found » s’afficher, cela signifie que les deux sont bien présents :
which git ssh
Nous créons également le répertoire .ssh dans le dossier utilisateur s’il n’existe pas déjà :
mkdir -vp ~/.ssh/Nous expliquerons ci-dessous comment créer et enregistrer une clé SSH pour utiliser GitHub. Une fois cette étape terminée, nous vous montrons comment enregistrer la clé SSH publique sur GitHub et vous expliquons comment accéder aux référentiels Git via SSH :
- Créer une paire de clés SSH sur son propre système
- Enregistrer la clé SSH publique sur GitHub
- Utiliser la clé SSH pour accéder au référentiel GitHub
Créer et enregistrer une clé SSH sur son propre système
Dans un premier temps, nous allons créer une paire de clés SSH publique/privée sur notre système local. Copiez les commandes utilisées pour cela dans le même ordre et exécutez-les dans l’invite de ligne de commande.
Nous adoptons ici la documentation officielle de GitHub. La procédure évolue de temps à autre. Pour résoudre des erreurs SSH, il est donc conseillé de s’y reporter.
Tout d’abord, nous démarrons le générateur de clés SSH ou « keygen » pour créer une paire de clés publique/privée pour GitHub. Nous utilisons la commande ssh-keygen, qui est déployée par défaut dans le cadre de l’installation OpenSSH sur le système :
Nous appelons ssh-keygen dans l’invite de ligne de commande et passons trois options :
- option -f suivie du chemin et du nom de la nouvelle clé
- option -t suivie du nom de l’algorithme, dans ce cas ed25519
- option -C suivie d’une adresse email en tant que commentaire
ssh-keygen -f "$HOME/.ssh/github_id_ed25519" -t ed25519 -C "votre_email@exemple.com"Vous pouvez utiliser n’importe quelle adresse email pour générer la paire de clés. Elle sert uniquement d’étiquette ; il ne doit pas nécessairement s’agir de la même adresse que celle que vous utilisez pour vous connecter à GitHub.
La commande SSH keygen nous invite à définir une « phrase de passe » pour la clé privée. Contrairement à un mot de passe, une phrase de passe peut contenir des espaces. Car elle doit comporter plusieurs mots, la phrase de passe est alors tout aussi facile à retenir et difficile à deviner. Pour plus de sécurité, on y inclut quelques chiffres ou caractères spéciaux. Saisissez la phrase de passe et appuyez sur « Entrée ». Répétez le processus pour terminer la création de la paire de clés SSH.
Nous utilisons l’algorithme Ed25519 pour notre paire de clés. Toute une série d’algorithmes est disponible. Nous présentons un aperçu des procédures de chiffrement dans un autre article.
Avant de pouvoir utiliser notre SSH key fraichement générée avec GitHub, nous allons franchir une autre étape. Cette option est facultative, mais fortement recommandée. Nous ajoutons la clé privée à ce qui est appelé l’« agent SSH ». Il s’agit d’un programme qui s’exécute en arrière-plan sur le système local. Exécutez la commande suivante dans l’invite de ligne de commande et entrez la phrase de passe lorsque vous y êtes invité :
- Windows/Linux
ssh-add ~/.ssh/github_id_ed25519- macOS jusqu’à 11 Big Sur
ssh-add -K ~/.ssh/github_id_ed25519- macOS à partir de 12 Monterey
ssh-add --apple-use-keychain ~/.ssh/github_id_ed25519L’agent SSH a accès à des clés privées ajoutées et permet de les utiliser pour les connexions sans saisir la phrase de passe à chaque reprise. Mais l’agent SSH a plus d’une corde à son arc :
“ssh-agent is a program that can hold a user’s private key, so that the private key passphrase only needs to be supplied once. A connection to the agent can also be forwarded when logging into a server, allowing SSH commands on the server to use the agent running on the user’s desktop.” — Source : https://www.ssh.com/academy/ssh/keygen#adding-the-key-to-ssh-agent
Traduction : « L’agent SSH est un programme qui conserve la clé privée d’un utilisateur, de sorte que la phrase de passe ne doit être saisie qu’une seule fois. Une connexion à l’agent SSH peut être transférée lors de la connexion à un serveur. Cela permet aux commandes SSH sur le serveur d’utiliser l’agent SSH qui est exécuté sur le poste de l’utilisateur. » (traduit par IONOS)
Enregistrer la SSH key sur GitHub
Nous avons créé une paire de clés SSH sur notre système local. Cela représente la moitié de la communication chiffrée lors de l’utilisation de Git en SSH. L’étape restante consiste à enregistrer la clé SSH publique dans Git.
Maintenant, nous avons besoin du contenu de la clé publique. Basculez dans l’invite de ligne de commande locale et entrez la commande suivante :
cat ~/.ssh/github_id_ed25519.pubAttention : le nom de fichier de la clé publique se termine par .pub pour « Public Key ». En revanche, la clé privée ne se termine pas par .priv ou autre terminaison similaire. Au lieu de cela, la clé privée n’a pas d’extension. Ne partagez que la clé publique avec GitHub et d’autres tiers.
Utiliser la clé SSH pour accéder au référentiel GitHub
Nous avons généré les clés localement et enregistré la SSH key publique sur GitHub. Testons tout d’abord si la connexion fonctionne. Nous utilisons la commande suivante :
ssh -T git@github.com
Si c’est la première fois que vous vous connectez à GitHub à partir de cet ordinateur, vous serez également invité à ajouter le serveur aux hôtes connus (« Known Hosts ») :
Lors de l’accès aux référentiels GitHub, nous distinguons l’accès en lecture de l’accès en écriture. Les référentiels publics peuvent être lus par n’importe qui ; aucune authentification, c’est-à-dire aucune clé SSH, n’est requise.
Pour télécharger un référentiel en tant que copie locale, il faut recourir à la commande git clone. Nous illustrons ceci en nous appuyant sur le référentiel de l’outil réseau populaire cURL. Nous visitons la page GitHub du référentiel public cURL et copions l’URL de clone :
Dotés de l’URL de clone, nous revenons à l’invite de ligne de commande locale. Nous créons un exemple de dossier repo sur le bureau et nous basculons dans celui-ci. Nous clonons ensuite le référentiel cURL en exécutant git clone avec l’URL de clone :
cd ~/Desktop/
mkdir -p repo && cd repo
git clone https://github.com/curl/curl.git
Nous basculons dans le dossier du référentiel cURL et utilisons la commande git status pour afficher l’état du référentiel :
cd ~/Desktop/repo/curl/
git status
La commande git pull, qui met à jour un référentiel, ne nécessite elle aussi qu’un accès en lecture. Nous exécutons git pull dans le dossier du référentiel ; en principe, cela fonctionne même en l’absence probable de changements :
git pullMaintenant, nous essayons d’écrire dans le référentiel GitHub avec la commande git push :
git push
Que se passe-t-il ici ? L’URL de clone utilisée pour cloner le référentiel public cURL commence par HTTPS. Pour notre clone local, une URL HTTPS est enregistrée par conséquent en tant qu’origine (« Origin »). Nous vérifions l’origine à l’aide de la commande git show :
git remote -v show
Une URL HTTPS est suffisante pour l’accès en lecture, mais une SSH key est requise pour écrire dans les référentiels GitHub. Car l’authentification des utilisateurs à travers le nom d’utilisateur et le mot de passe n’est plus prise en charge sur GitHub depuis août 2021.
Pour pouvoir toutefois tester git push, nous avons recours à une astuce. Tout d’abord, nous créons notre propre référentiel vide sur GitHub :
Selon les instructions sur GitHub, nous modifions l’URL push du clone cURL local sur notre système afin que notre référentiel GitHub vide soit utilisé comme origine. Nous avons également défini la branche comme « main ». Nous exécutons ensuite le push Git ; l’opération réussit et utilise notre clé SSH précédemment créée pour nous authentifier auprès de GitHub.
git remote set-url origin git@github.com:<user>/test.git
git branch -M main
git push -u origin main
Utilisez plusieurs clés SSH pour différents comptes GitHub
Il est aisément possible d’utiliser une seule clé SSH pour différents comptes GitHub ou autres. Rappelons-nous que nous pouvons partager la clé publique sans aucune hésitation.
Du point de vue technique, il est possible d’utiliser vos propres clés SSH pour différents services et sites. Deux méthodes coexistent :
- Appeler la commande SSH avec les paramètres
- Créer un fichier de configuration SSH
Les commandes SSH avec des paramètres pouvant être très longues, nous n’exposerons pas cette approche ici. En général, il est plus pratique d’utiliser un fichier de configuration SSH. Cela nécessite un peu plus d’effort lors de la configuration de votre propre système, mais cela ne doit être pratiqué qu’une seule fois. Voici un aperçu des dossiers et des fichiers impliqués dans la configuration SSH :
| Configuration SSH | Chemin | Explication |
|---|---|---|
| Dossier Config | ~/.ssh/ | Contient la configuration SSH et les paires de clés. |
| Private Key | ~/.ssh/key-name | Clé privée d’une paire de clés. |
| Public Key | ~/.ssh/key-name.pub | Clé publique d’une paire de clés. |
| Fichier Config | ~/.ssh/config | Fichier de configuration SSH. |
| Known Hosts | ~/.ssh/known_hosts | Liste des hôtes connectés auparavant. |
Commençons par créer le fichier de configuration SSH. Nous créons le fichier, ajustons les droits d’utilisateur et l’ouvrons dans l’éditeur de ligne de commande :
touch ~/.ssh/config
chmod 600 ~/.ssh/config
nano ~/.ssh/configCopiez ensuite le bloc suivant dans l’éditeur et suivez les captures d’écran pour enregistrer le fichier :
# Github
Host github github.com
HostName github.com
User git
IdentityFile "~/.ssh/github_id_ed25519"
IdentitiesOnly yes
Après avoir inséré le bloc de configuration GitHub, une connexion SSH peut être établie à l’aide du code hôte github défini :
ssh -T githubAjoutez des blocs de configuration pour des services ou des comptes supplémentaires au fichier de configuration SSH, comme illustré dans le schéma. Voici un aperçu des paramètres utilisés :
| Paramètre | Explication | Exemple |
|---|---|---|
| Host | Peut contenir plusieurs noms quelconques. | github.com github |
| HostName | Nom d’hôte du système distant sur lequel SSH est exécuté ; une adresse IP peut également être utilisée. | github.com |
| User | Utilisateur Git sur le système distant ; doit être récupéré avec exactitude. | git |
| IdentityFile | Chemin absolu de la clé privée. Ajustez cette valeur si vous utilisez plusieurs clés. | ~/.ssh/github_id_ed25519 |
| IdentitiesOnly | Spécifie que cet hôte doit être accessible par clé uniquement. | yes |
Voici un dernier conseil pour terminer. Si vous créez des configurations SSH pour plusieurs hôtes avec leurs propres clés, vous devez ajouter un bloc à la fin du fichier avec des paramètres pour les hôtes non répertoriés :
# For all hosts
Host *
IdentitiesOnly no
IgnoreUnknown UseKeychain,AddKeysToAgent
UseKeychain yes
AddKeysToAgent yesCela permet d’accéder à des hôtes non spécifiés sans clé SSH. Voici comment se connecter à un hôte à l’aide de son nom d’utilisateur et saisir le mot de passe lors de l’établissement de la connexion :
ssh user@hostEn l’absence de la ligne « IdentitiesOnly no » dans la configuration finale, SSH tente toutes les clés l’une après l’autre dans ~./ssh/ pour se connecter au serveur. Si aucune clé adéquate n’est trouvée, l’erreur « Too many authentication failures » (« Trop d’échecs d’authentification ») se produit.