Si je vous dis que je peux me faire passer pour Linus Torvalds et créer des commits à sa place, est-ce que vous me croyez ? Figurez-vous que c'est tout à fait possible, que vous pouvez vous-même le faire et que ça ne demande même pas 5 minutes de votre temps.
Pour ce faire, rien de plus simple :
On crée un repo sur GitHub.
Sur notre machine, on crée un repo git :
$ mkdir gpg-poc
$ cd gpg-poc
$ git init
On change localement son nom d'utilisateur et son email, et on se fait passer pour quelqu'un d'autre :
$ git config --local user.name torvalds
$ git config --local user.email torvalds@linux-foundation.org
On crée un commit (vide pour aller plus vite) et on le push :
$ git commit -m "Hey, I'm Linus Torvalds" --allow-empty
$ git remote add origin [repo_url]
$ git push -u origin main
On constate par nous-même le résultat :
Bref, nous venons de réussir à usurper l'identité de notre cher Linus Torvalds. Cela ne paraît pas grande chose, mais en y réflechissant un peu, on pourrait s'en servir pour créer des commits malicieux en son nom sur des repos open source, ce qui nuirait fortement à son image (car si l'on regarde le repo torvalds/linux, on se rend compte que les commits qu'il produit ne sont pas signés).
Mais alors, est-ce qu'on peut se protéger de ce genre de pratiques ? Et peut-on s'assurer que le commit produit précédemment est frauduleux ? La réponse est oui, et ne demande que très peu d'investissement.
Introduction à GPG
GPG (GnuPG) est une implémentation open source du standard OpenPGP, défini par la RFC 4880. C'est une librairie cryptographique permettant principalement de chiffrer et signer des données et des communications. Elle est installée par défaut sur la grande majorité des distributions Linux ainsi que sur macOS. Les utilisateurs de Windows auront peut-être à l'installer.
Grâce à cette librairie, on peut par exemple chiffrer un fichier de manière symétrique à l'aide d'une passphrase (mot de passe) grâce à la commande suivante :
$ gpg -c [file]
Son exécution produit un fichier chiffré [file].gpg, dont on ne peut afficher le contenu que si l'on possède la clé de chiffrement. On peut ensuite le déchiffrer à l'aide de la commande complémentaire :
$ gpg [file].gpg
Dans le cadre de cet article, c'est plutôt la fonctionnalité de signature qui va nous intéresser, nous permettant de vérifier l'authenticité d'un commit.
Signatures Numériques
Définissons tout d'abord ce qu'est une signature au sens numérique du terme. Pour citer Wikipédia, c'est un mécanisme permettant d'authentifier l'auteur d'un document électronique. Cette authentification est essentiellement réalisée à l'aide de la cryptographie asymétrique, par exemple avec l'algorithme RSA.
En cryptographie asymétrique, on utilise une paire de clés. Cette paire de clés comprend :
Une clé publique. Cette clé pourra être partagée à n'importe qui, et permettra d'attester la validité des signatures générées.
Une clé privée. Celle-ci ne doit absolument pas être divulguée à qui que ce soit car c'est celle qui permettra de signer des données. Quiconque aura accès à cette clé pourra en l'occurrence créer des commits en votre nom.
Signer ses Commits avec GPG
Pour signer nos commits, nous allons donc devoir générer une paire de clés. Pour cela, on utilise la commande suivante :
$ gpg --full-generate-key
On renseigne ensuite les différents champs :
| Champs | Valeur | Description |
| Type | (4) RSA (sign only) | Le type de clé |
| Key size | 4096 | La taille de la clé |
| Valid for | 1y | Durée de validité de la clé (ici, 1 an) |
| Real name | [your_name] | Votre nom d'utilisateur |
| Email address | [your_email] | Votre adresse email (doit être vérifiée sur votre compte GitHub) |
NB : Si vous souhaitez garder votre adresse email privée, vous pouvez utiliser une adresse no-reply fournie par GitHub. Elle est accessible sur votre compte et se présente sous la forme [nombre]+[username]@users.noreply.github.com .
Évidemment, pensez bien à utiliser une passphrase assez robuste. Interdiction donc d'utiliser admin123 ou choupinette456. ⛔️
La clé est alors générée, et on peut le vérifier avec la commande suivante (qui peut nécessiter sudo) :
$ gpg --list-keys
/Users/ludal/.gnupg/pubring.kbx
-------------------------------
pub rsa4096 2023-01-11 [SC]
F8D75BED436334559F163392C22C6EBDC5D5AD76
uid [ultimate] iamludal <contact@iamludal.fr>
Maintenant que nous avons généré notre clé, il nous faut l'associer à notre compte GitHub en l'ajoutant via les paramètres. Pour ce faire, on exporte la clé publique que nous venons de créer et on la copie à notre presse-papiers (Ctrl + C).
$ gpg --armor --export [your_email]
On se rend ensuite sur GitHub dans le menu Settings > SSH and GPG keys et on clique sur New GPG key.
On nous propose alors de donner un titre à notre clé, qui sera par exemple le nom de notre machine. Dans le champs Key, on peut maintenant coller la clé que nous venons de copier. Faites TRÈS attention de bien renseigner la clé PUBLIQUE (ce qui sera de toute façon le cas si vous avez bien utilisé la commande précédente).
(la clé visible sur la capture ci-dessus est la clé publique, elle n'est donc pas sensible et sera de toute façon supprimée à la publication de l'article)
Il ne nous reste plus qu'à configurer git pour signer chacun de nos commits avec cette clé. Pour cela, on utilise les commandes suivantes :
$ git config --global commit.gpgsign true
$ git config --global user.signingkey [your_email]
Désormais, chaque commit sera signé et la passphrase que nous avons renseignée nous sera demandée. On constate alors que nos commits sont désormais vérifiés par GitHub :
En plus de cela, nous avons également la possibilité de marquer chaque commit n'ayant pas été signé comme Unverified. Il faut pour cela activer le mode vigilant dans les paramètres, toujours dans le menu SSH and GPG keys .
Si l'on essaye maintenant de faire un commit sans le signer, on verra un nouveau badge apparaître à côté de ce dernier, nous informant que GitHub n'a pas pu attester la validité du commit.
$ git config --local commit.gpgsign false
$ git commit -m "Unverified commit" --allow-empty
$ git push
Conclusion
Et voilà, en quelques minutes nous avons réussi à sécuriser nos commits grâce à la magie de la cryptographie asymétrique. À noter que vous pouvez évidemment posséder plusieurs clés, chacune pouvant par exemple correspondre à un appareil différent. J'espère vous avoir appris des choses grâce à cet article, et si vous avez des questions ou des remarques, n'hésitez-pas à m'en faire part dans les commentaires. 😉
