Comprendre SSH et connecter Git à GitHub sous Linux

Introduction

Dans le tutoriel précédent, nous avons installé Git et configuré le nom ainsi que l’adresse e-mail utilisés pour identifier nos commits.

Cependant, cette configuration ne permet pas encore à notre machine de communiquer de manière sécurisée avec GitHub.

Pour envoyer un projet vers GitHub ou récupérer les modifications d’un dépôt distant, plusieurs méthodes d’authentification existent. Dans ce tutoriel, nous allons utiliser SSH.

Nous découvrirons ce qu’est SSH, comment fonctionne une clé SSH et comment connecter une machine Linux à un compte GitHub.

Qu’est-ce que SSH ?

SSH signifie « Secure Shell ».

Il s’agit d’un protocole permettant d’établir une connexion sécurisée entre deux machines à travers un réseau.

SSH est notamment utilisé pour :

• administrer un serveur Linux à distance ;
• transférer des fichiers de manière sécurisée ;
• s’authentifier auprès de services comme GitHub ;
• envoyer et récupérer du code sans saisir ses identifiants à chaque opération.

Dans notre cas, SSH permettra à GitHub de reconnaître notre machine Linux.

Comment fonctionne une clé SSH ?

L’authentification SSH utilise une paire de clés composée de deux fichiers :

• une clé privée ;
• une clé publique.

La clé privée

La clé privée reste uniquement sur votre machine.

Elle ne doit jamais être communiquée, envoyée ou publiée. Une personne possédant votre clé privée pourrait essayer de l’utiliser pour s’authentifier à votre place.

La clé publique

La clé publique peut être partagée.

C’est cette clé que nous allons ajouter à notre compte GitHub. GitHub pourra ensuite vérifier que notre machine possède bien la clé privée correspondante.

Le fonctionnement peut être résumé ainsi :

1. la clé privée reste sur la machine Linux ;
2. la clé publique est enregistrée sur GitHub ;
3. lors d’une connexion, GitHub vérifie que les deux clés correspondent ;
4. si la vérification réussit, la connexion est autorisée.

Vérifier la configuration de Git

Dans le précédent tutoriel, nous avons configuré le nom et l’adresse e-mail utilisés par Git.

Vous pouvez vérifier cette configuration avec :

git config --global user.name
git config --global user.email

Exemple de résultat :

Cette adresse e-mail peut également être utilisée comme commentaire lors de la création de la clé SSH.

Attention : le nom et l’adresse e-mail identifient l’auteur des commits. La clé SSH sert, quant à elle, à authentifier la machine auprès de GitHub. Il s’agit donc de deux configurations différentes.

Vérifier la présence du client SSH

Pour vérifier que le client SSH est installé, utilisez :

ssh -V

Exemple de résultat :

La version affichée dépend de votre distribution.

Si la commande n’est pas disponible sur Ubuntu ou Debian, installez le client OpenSSH avec :

sudo apt update
sudo apt install openssh-client

Vérifiez ensuite de nouveau son installation :

ssh -V

Vérifier si une clé SSH existe déjà

Avant de générer une nouvelle clé, il est important de vérifier si une paire de clés existe déjà sur la machine.

Utilisez la commande suivante :

ls -al ~/.ssh

Le symbole ~ représente le dossier personnel de l’utilisateur actuellement connecté.

Si le dossier n’existe pas, le terminal peut afficher qu’il n’existe pas.

Ce résultat signifie simplement qu’aucune clé SSH n’a encore été créée dans l’emplacement par défaut.

Si le dossier existe, vous pourriez trouver des fichiers comme :

id_ed25519
id_ed25519.pub
known_hosts

Les fichiers suivants forment une paire :

• id_ed25519 : clé privée ;
• id_ed25519.pub : clé publique.

Ne supprimez pas et ne remplacez pas une clé existante sans vérifier si elle est déjà utilisée pour un autre service.

Générer une nouvelle clé SSH

Nous allons créer une clé utilisant l’algorithme Ed25519, recommandé par GitHub pour les systèmes compatibles.

Remplacez l’adresse de l’exemple par celle associée à votre compte GitHub :

ssh-keygen -t ed25519 -C "adresse@example.com"

La commande affiche :

Le terminal demande ensuite une phrase secrète :

La phrase secrète protège la clé privée si une autre personne accède aux fichiers de la machine.

Vous pouvez :

• saisir une phrase secrète puis la confirmer ;
• laisser le champ vide en appuyant deux fois sur Entrée.

Pour une meilleure sécurité, il est recommandé d’utiliser une phrase secrète.

Après la création, un résultat semblable apparaît :

Deux fichiers ont été créés :

~/.ssh/id_ed25519
~/.ssh/id_ed25519.pub

Le fichier sans extension est la clé privée. Le fichier se terminant par .pub est la clé publique.

Vérifier la création des clés

Affichez le contenu du dossier SSH :

ls -l ~/.ssh

Exemple de résultat :

Ne partagez jamais le fichier suivant :

~/.ssh/id_ed25519

Seul le fichier public peut être transmis :

~/.ssh/id_ed25519.pub

Démarrer l’agent SSH

L’agent SSH est un programme qui conserve temporairement les clés privées en mémoire. Il évite notamment de rechercher manuellement la clé lors de chaque connexion.

Démarrez-le avec :

eval "$(ssh-agent -s)"

Exemple de résultat :

Le numéro du processus sera différent sur votre machine.

Ajouter la clé privée à l’agent SSH

Ajoutez maintenant la clé privée :

ssh-add ~/.ssh/id_ed25519

Si vous avez défini une phrase secrète, le terminal la demande :

Saisissez-la puis validez.

Aucun caractère ne s’affiche pendant la saisie. Ce comportement est normal sous Linux.

Une fois la clé ajoutée, vous obtenez un résultat semblable à celui-ci :

Vous pouvez vérifier les clés chargées dans l’agent avec :

ssh-add -l

Exemple de résultat :

Afficher la clé publique

Pour afficher la clé publique dans le terminal, utilisez :

cat ~/.ssh/id_ed25519.pub

Le résultat ressemble à ceci :

La clé doit être copiée entièrement, depuis ssh-ed25519 jusqu’à l’adresse e-mail située à la fin.

Attention à ne pas utiliser cette commande sur le fichier privé :

~/.ssh/id_ed25519

Ajouter la clé SSH sur GitHub

Connectez-vous à votre compte sur GitHub, puis effectuez les opérations suivantes :

1. Cliquez sur votre photo de profil en haut à droite.

2. Cliquez sur Settings.

3. Dans le menu latéral, cliquez sur SSH and GPG keys.

4. Cliquez sur New SSH key.
5. Dans le champ Title, indiquez un nom permettant de reconnaître la machine, par exemple « Machine Linux personnelle ».

6. Dans Key type, sélectionnez Authentication Key.

7. Dans le champ Key, collez la clé publique.

8. Cliquez sur Add SSH key.
9. Confirmez l’opération si GitHub vous demande de vous authentifier.

Il est important de coller uniquement la clé publique contenue dans id_ed25519.pub. GitHub décrit également cette procédure dans sa documentation officielle.

Tester la connexion SSH avec GitHub

Une fois la clé ajoutée au compte GitHub, revenez dans le terminal et lancez :

ssh -T git@github.com

Lors de la première connexion, un avertissement peut apparaître :

Cet avertissement indique que la machine ne connaît pas encore le serveur SSH de GitHub.

Avant de continuer, vérifiez que l’empreinte affichée correspond à l’une des empreintes SSH officielles de GitHub.

Si l’empreinte correspond, saisissez yes puis appuyez sur Entrée.

Si votre clé possède une phrase secrète, celle-ci peut vous être demandée.

Lorsque la connexion fonctionne, GitHub affiche :

Ce message confirme que :

• GitHub a reconnu la clé publique ;
• la machine possède la clé privée correspondante ;
• l’authentification SSH fonctionne correctement.

La phrase indiquant que GitHub ne fournit pas d’accès au shell n’est pas une erreur. La connexion SSH de GitHub sert principalement aux opérations Git, et non à l’ouverture d’un terminal distant. La commande de test est celle recommandée dans la documentation officielle de GitHub.

Comprendre l’adresse SSH d’un dépôt GitHub

Un dépôt GitHub peut être utilisé avec une adresse HTTPS ou une adresse SSH.

Une adresse HTTPS ressemble à ceci :

https://github.com/utilisateur/projet.git

L’adresse SSH du même dépôt ressemble à ceci :

git@github.com:utilisateur/projet.git

Lorsque vous utiliserez SSH, il faudra sélectionner l’option SSH dans le bouton Code du dépôt GitHub.

Par exemple, la commande permettant de cloner un dépôt avec SSH sera :

git clone git@github.com:utilisateur/projet.git

Nous verrons plus précisément le clonage, l’envoi et la récupération de modifications dans les prochains tutoriels.

Bonnes pratiques de sécurité

Pour protéger votre accès à GitHub :

• ne communiquez jamais votre clé privée ;
• utilisez une phrase secrète pour protéger la clé ;
• ne publiez jamais le contenu de id_ed25519 ;
• créez une clé différente pour chaque machine importante ;
• donnez un titre clair à chaque clé sur GitHub ;
• supprimez de GitHub les clés appartenant à des machines perdues ou inutilisées ;
• conservez les permissions sécurisées du dossier .ssh.

Vous pouvez vérifier les permissions avec :

ls -ld ~/.ssh
ls -l ~/.ssh

Si nécessaire, appliquez les permissions recommandées :

chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519
chmod 644 ~/.ssh/id_ed25519.pub

Conclusion

Dans ce tutoriel, nous avons découvert le fonctionnement de SSH et connecté une machine Linux à GitHub.

Nous avons appris à :

• distinguer une clé privée d’une clé publique ;
• vérifier les clés déjà présentes ;
• générer une clé Ed25519 ;
• démarrer l’agent SSH ;
• charger une clé privée dans l’agent ;
• ajouter la clé publique au compte GitHub ;
• tester la connexion avec ssh -T git@github.com.

Notre machine Linux peut maintenant s’authentifier auprès de GitHub de manière sécurisée. Cette configuration nous permettra prochainement de cloner des dépôts ainsi que d’envoyer et de récupérer des modifications avec Git.