Utiliser Git avec SSH et GPG

Si vous souhaitez utiliser SSH pour vos dépôts, il faudra générer des clés SSH. De même, si vous souhaitez signer vos commits, il faudra générer une clé GPG. Dans cet article, nous allons configurer l’ensemble pour pouvoir utiliser Git avec SSH et GPG.

Configurer SSH

Nous allons utiliser OpenSSH. Pour commencer, il faut donc l’installer :

pacman -S openssh

SSH (pour Secure SHell) est un protocole permettant d’établir une connexion sécurisée entre deux ordinateurs. Il peut être utilisé pour se connecter avec sFTP ou Git par exemple. Les étapes de configuration sont simples. Nous allons commencer par générer une paire de clés SSH. Pour cela, nous allons utiliser la commande ssh-keygen.

Générer une paire de clés publique/privée

Il est possible de générer ces clés sans passer d’options. Par défaut, la commande utilisera RSA avec un encodage de 2048 bits. Si vous souhaitez une autre configuration, voici les différentes options :

  • -t : choisir le format de l’encodage
  • -b : définir un nombre de bit pour l’encodage
  • -C : ajouter un commentaire pour identifier plus facilement la clé (optionnel)

Il existe différents formats d’encodage : RSA, DSA, ECDSA, Ed25519. Je ne suis pas expert en sécurité, mais d’après mes lectures, Ed25519 est l’algorithme qu’il faudrait choisir. Cependant, si le serveur utilisé est vieux, il est possible qu’il ne supporte pas les clés Ed25519. Il est alors préférable d’utiliser RSA. Avec Ed25519, il n’est pas nécessaire de spécifier un nombre de bit ; toutes les clés font 256 bits.

Dans un terminal, saisissez :

ssh-keygen -t ed25519
// Ou
ssh-keygen -t rsa -b 4096

Quel que soit le format choisi, vous devriez faire face à plusieurs choix :

Enter file in which to save the key (/home/username/.ssh/id_ed25519):
// Vous pouvez laisser la valeur par défaut

Enter passphrase (empty for no passphrase):
// Saisir un mot de passe fort

Enter same passphrase again:
// Le ressaisir

Je vous conseille d’utiliser un gestionnaire de mot de passe comme KeepassXC pour stocker vos phrases de passe (vos longs mots de passe), cela rend leur utilisation plus simple. Vous n’êtes pas obligé de saisir une phrase de passe, mais pour des questions de sécurité, c’est préférable (à moins que votre ordinateur soit déjà sécurisé et encrypté).

Une fois les clés créées, il faut suivre les instructions du service (Github/Gitlab par exemple) que vous utilisez pour ajouter la clé. Il vous sera souvent demandé d’ouvrir la clé publique avec un éditeur de texte, d’en copier le contenu et de le coller dans un formulaire disponible dans les paramètres du service utilisé.

Sur certains serveurs, il est également possible d’utiliser la commande ssh-copy-id pour ajouter la clé publique. Pour cela, il suffit de saisir :

// Pensez à changer le nom de la clé, le nom d’utilisateur et le nom du serveur
ssh-copy-id -i ~/.ssh/id_ed25519.pub nom-utilisateur@serveur-distant

Utiliser un agent SSH

Pour éviter d’avoir à saisir la phrase de passe à chaque connexion au serveur via SSH, il est possible d’utiliser un agent SSH et de le configurer pour qu’il mémorise la clé lors de la première utilisation.

Pour ajouter la clé SSH à l’agent d’authentification, il suffit de saisir les commandes suivantes :

// Démarrer l’agent SSH.
eval $(ssh-agent)

// Ajouter la clé. Pensez à changer le chemin et le nom si vous les avez modifiés.
ssh-add ~/.ssh/id_ed25519

Il est également possible de configurer l’agent SSH pour qu’il démarre avec systemd. Pour cela, nous allons créer un fichier de configuration, comme indiqué sur le wiki d’Archlinux. J’utilise Manjaro, il est possible que les chemins définis soient différents sur une autre distribution.

Nous allons créer un fichier de configuration :

nano ~/.config/systemd/user/ssh-agent.service

// Insérer dans le fichier :
[Unit]
Description=SSH key agent
[Service]
Type=simple
Environment=SSH_AUTH_SOCK=%t/ssh-agent.socket
ExecStart=/usr/bin/ssh-agent -D -a $SSH_AUTH_SOCK
[Install]
WantedBy=default.target

Il faut également modifier le profil Bash (.bash_profile ou .profile).

nano ~/.bash_profile

// Ajoutez :
export SSH_AUTH_SOCK="$XDG_RUNTIME_DIR/ssh-agent.socket"

Nous modifions le fichier de configuration de SSH pour lui indiquer d’ajouter les clés à l’agent SSH.

nano ~/.ssh/config

// Ajoutez :
Host *
 AddKeysToAgent  yes
 IdentityFile  ~/.ssh/id_ed25519

Il ne nous reste plus qu’à démarrer le service créé pour l’agent SSH.

// Nous activons l’agent SSH à chaque démarrage
sudo systemctl --user enable ssh-agent

// Nous activons l’agent SSH pour la session en cours
systemctl --user start ssh-agent

Configurer GPG

GnuPG vous permet d’encrypter et de signer vos données. Il peut être utilisé pour des mails ou pour les commits Git par exemple. Il permet de vérifier l’authenticité d’un message tout en le chiffrant. Ainsi, si vous publiez un message, une autre personne peut s’assurer qu’il s’agit bien de vous et non de quelqu’un d’autre.

Générer une clé GPG

Nous commençons par installer GnuPG :

sudo pacman -S gnupg

Ensuite, nous générerons une paire de clés complètes :

gpg --full-generate-key

Cette commande va vous demander d’effectuer plusieurs choix :

Sélectionnez le type de clef désiré :
   (1) RSA et RSA (par défaut)
   (2) DSA et Elgamal
   (3) DSA (signature seule)
   (4) RSA (signature seule)
  (14) Existing key from card
Quel est votre choix ? 1
// On choisit RSA et RSA (signature et encryptage)

les clefs RSA peuvent faire une taille comprise entre 1024 et 4096 bits.
Quelle taille de clef désirez-vous ? (2048) 4096
// On choisit 4096 bits

Veuillez indiquer le temps pendant lequel cette clef devrait être valable.
         0 = la clef n'expire pas
      <n>  = la clef expire dans n jours
      <n>w = la clef expire dans n semaines
      <n>m = la clef expire dans n mois
      <n>y = la clef expire dans n ans
Pendant combien de temps la clef est-elle valable ? (0) 
// Là c’est à vous de voir, ici je choisis l’option par défaut

La clef n'expire pas du tout
Est-ce correct ? (o/N) o
// On confirme que c'est correct

GnuPG doit construire une identité pour identifier la clef.

Nom réel : Prénom Nom
Adresse électronique : mon@email.com
Commentaire : 
// On saisit son nom et on choisit une adresse e-mail ; le commentaire n’est pas utile.

Changer le (N)om, le (C)ommentaire, l'(A)dresse électronique
ou (O)ui/(Q)uitter ? O
// On confirme que tout est correct

Là, il va falloir saisir une phrase de passe. Évidemment, le mieux est de choisir un mot de passe fort. Si ce n’est pas le cas, vous devriez avoir une alerte pour vous demander si vous êtes sûr de ne pas vouloir un mot de passe plus fort. Encore une fois, un logiciel comme KeepassXC est utile pour stocker le mot de passe.

Juste après avoir saisi votre mot de passe, il va falloir bouger la souris et/ou taper sur votre clavier pour générer la clé.

D’après la documentation de GnuPG, il est important d’ajouter une ligne de configuration dans le profil Bash (.bash_profile ou .profile). Elle permet à pinentry (qui gère les dialogues d’entrée) d’utiliser le bon téléscripteur (TTY).

nano ~/.bash_profile

// Ajoutez :
export GPG_TTY=$(tty)

Indiquez la clé à utiliser

Si vous utilisez Github ou Gitlab, il faut leur indiquer votre clé publique. Pour cela, nous allons utiliser les options --armor et --export. Ces options permettent d’exporter la clé en créant une sortie ASCII avec armure. Pour commencer, il faut lister les clés pour récupérer le bon ID.

// Vous n’êtes pas obligé de saisir l’adresse e-mail, mais si vous avez beaucoup de clés ça permet de les filtrer
gpg --list-secret-keys --keyid-format LONG mon@email.com

// Vous allez avoir une sortie de ce type :
pub   rsa4096/6FCE2FC5D1A09DBA 2020-03-21 [SC]
      0B70CBDDE4313EFD3F3484CB6FCE2FC5D1A09DBA
uid                [  ultime ] Mon Nom <mon@email.com>
sub   rsa4096/75B044AA7470F95C 2020-03-21 [E]
// Ce qui nous intéresse ici, c’est la chaîne de caractère après « rsa4096 ». Soit : 6FCE2FC5D1A09DBA

// Nous exportons la clé en créant une sortie ASCII avec armure :
gpg --armor --export laChaineDeCaractèreCopiée

// Pour notre exemple, ça donne :
gpg --armor --export 6FCE2FC5D1A09DBA

// Ce qui vous affichera :
-----BEGIN PGP PUBLIC KEY BLOCK-----
...
-----END PGP PUBLIC KEY BLOCK-----

Il faudra copier toute la sortie : de -----BEGIN PGP PUBLIC KEY BLOCK----- à -----END PGP PUBLIC KEY BLOCK-----. Puis, il faut vous rendre dans les paramètres de votre compte Github/Gitlab pour ajouter la clé.

Git, SSH et GPG

Configurer Git

Pour utiliser Git, il vous faudra au minimum définir un nom d’utilisateur et une adresse e-mail. Pour cela, nous allons utiliser la commande git config. Plusieurs options sont disponibles :

  • --global : configuration pour l’ensemble des dépôts
  • --local : configuration pour le dépôts en cours d’utilisation
  • --unset : supprimer une valeur

Nous allons renseigner un nom d’utilisateur, une adresse e-mail et la clé GPG pour cette adresse e-mail de manière globale.

// Définir le nom d’utilisateur de manière globale
git config --global user.name "Mon nom"

// Définir l’adresse e-mail de manière globale
git config --global user.email "mon@email.com"

Puisque nous avons précédemment défini une clé GPG, nous allons également l’ajouter. Il faut d’abord lister vos clés pour récupérer l’ID à utiliser. Certaines étapes sont les mêmes qu’au-dessus, mais si vous n’utilisez pas Github/Gitlab, je remets toutes les étapes :

// Vous n’êtes pas obligés de saisir l’adresse e-mail, mais si vous avez beaucoup de clés ça permet de les filtrer
gpg --list-secret-keys --keyid-format LONG mon@email.com

// Vous allez avoir une sortie de ce type :
pub   rsa4096/6FCE2FC5D1A09DBA 2020-03-21 [SC]
      0B70CBDDE4313EFD3F3484CB6FCE2FC5D1A09DBA
uid                [  ultime ] Mon Nom <mon@email.com>
sub   rsa4096/75B044AA7470F95C 2020-03-21 [E]
// Ce qui nous intéresse ici, c’est la chaîne de caractère après « rsa4096 ». Soit : 6FCE2FC5D1A09DBA

// Définir la clé GPG pour signer les commit de manière globale
git config --global user.signingkey [clé GPG au format 16 caractères]

// Avec notre exemple ça donne donc :
git config --global user.signingkey 6FCE2FC5D1A09DBA

Vous pourrez ensuite configurer chacun de vos dépôts avec une autre configuration, si besoin, en utilisant l’option --local. Cela peut être utile si vous souhaitez utiliser une autre adresse e-mail sur ce dépôt (par exemple une adresse no-reply Github/Gitlab).

Utiliser Git avec SSH

Maintenant que nous avons configuré SSH, nous pouvons utiliser une adresse ssh+git plutôt que https.

// Exemple avec Github, au lieu d’utiliser :
https://github.com/VotreNom/votre-repo.git

// Vous pourrez utiliser :
git@github.com:VotreNom/votre-repo.git

Ainsi, lorsque vous configurez votre dépôt distant :

// Au lieu de :
git remote add origin https://github.com/VotreNom/votre-repo.git

// Vous pouvez saisir :
git remote add origin git@github.com:VotreNom/votre-repo.git

Lorsque vous voudrez vous connecter au serveur via SSH (pour un push par exemple), Git vous demandera la phrase de passe de votre clé SSH. Il faudra saisir celle que vous avez définie lors de la génération de votre clé. Si vous avez configuré un agent SSH, vous n’aurez à la saisir qu’une seule fois. Sinon, la phrase de passe est demandée à chaque connexion.

Utiliser Git avec GPG

Je ne vais pas vous expliquer comment utiliser Git dans cet article, je vais simplement vous montrer comment signer votre travail.

  • Si vous voulez signer un commit avec votre clé GPG, il faudra utiliser l’option -s :
git commit -s
  • Il est également possible de signer automatiquement chaque commit. Pour cela, il faut utiliser la commande :
git config --global commit.gpgSign true
  • Il est également possible de signer ses étiquettes, toujours avec l’option -s :
git tag -s v1.0.0 -m 'v1.0.0'

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.