GPG (GNU Privacy Guard) vous permet de protéger des fichiers, signer des documents, vérifier l’authenticité de logiciels et prouver votre identité dans vos commits Git — le tout grâce à la cryptographie à clé publique, sans avoir à partager un mot de passe secret. Lorsque vous envoyez un fichier chiffré, seul le destinataire disposant de sa clé privée peut le déchiffrer. Lorsque vous signez un commit Git, n’importe qui peut vérifier que c’est bien vous qui l’avez rédigé et que le code n’a pas été altéré. Ce guide couvre l’utilisation pratique de GPG : génération de clés, chiffrement de fichiers, signatures numériques et intégration avec Git.

Prérequis

  • Un système Linux, macOS ou Windows
  • GnuPG 2.2 ou ultérieur installé (vérifiez avec gpg --version)
  • Un terminal ou une invite de commande
  • Une adresse e-mail pour l’identité de votre clé

Installer GnuPG

# Debian / Ubuntu (généralement pré-installé)
sudo apt install gnupg

# RHEL / Fedora
sudo dnf install gnupg2

# macOS
brew install gnupg

# Vérifier l'installation
gpg --version
# gpg (GnuPG) 2.4.x

Générer votre paire de clés

# Génération interactive avec toutes les options
gpg --full-generate-key

Lorsque vous êtes invité à répondre :

  1. Type de clé : Choisissez ECC (sign and encrypt) ou RSA and RSA pour une compatibilité maximale
  2. Taille de la clé : 4096 pour RSA, ou Curve 25519 pour ECC
  3. Expiration : Définissez 1 à 2 ans (vous pouvez prolonger ensuite). Ne créez jamais de clés sans expiration
  4. Nom et e-mail : Utilisez la même adresse que votre compte Git et GitHub
  5. Phrase de passe : Choisissez une phrase de passe robuste — elle protège votre clé privée en cas de vol du fichier
# Lister vos clés
gpg --list-keys
gpg --list-secret-keys --keyid-format long

# Exemple de sortie :
# sec   ed25519/ABC123DEF456 2025-12-12 [SC] [expires: 2027-12-12]
#       ABCDEF1234567890ABCDEF1234567890ABC123DE
# uid           [ultimate] Your Name <you@example.com>
# ssb   cv25519/789GHI012JKL 2025-12-12 [E] [expires: 2027-12-12]

L’identifiant de clé (ABC123DEF456 dans cet exemple) est celui que vous utilisez pour référencer votre clé dans les commandes.

Générer un certificat de révocation

Faites-le immédiatement après la création de votre clé — avant d’en avoir besoin :

gpg --gen-revoke --output revoke-cert.asc ABC123DEF456

Conservez ce fichier en lieu sûr hors ligne (clé USB, copie imprimée). Si votre clé est compromise, vous publiez ce certificat pour la révoquer.

Chiffrer et déchiffrer des fichiers

Chiffrement pour un destinataire (asymétrique)

# Importer d'abord la clé publique du destinataire
gpg --import colleague-pubkey.asc

# Chiffrer un fichier pour un destinataire précis
gpg --encrypt --recipient colleague@example.com secret-report.pdf
# Crée : secret-report.pdf.gpg

# Chiffrer pour plusieurs destinataires
gpg --encrypt --recipient alice@example.com --recipient bob@example.com data.tar.gz

# Chiffrer et signer (recommandé — prouve l'expéditeur)
gpg --encrypt --sign --recipient colleague@example.com secret-report.pdf

# Chiffrer avec ASCII armor (sortie texte pour e-mail)
gpg --encrypt --armor --recipient colleague@example.com message.txt
# Crée : message.txt.asc (encodé en base64, sûr pour l'e-mail)

Déchiffrer un fichier

# Déchiffrer (GPG utilise automatiquement votre clé privée)
gpg --decrypt secret-report.pdf.gpg > secret-report.pdf

# Déchiffrer et vérifier la signature
gpg --decrypt signed-encrypted-file.gpg
# La sortie inclut : "Good signature from ..."

Chiffrement symétrique (par mot de passe)

Quand vous n’avez pas la clé publique du destinataire, utilisez un mot de passe partagé :

# Chiffrer avec une phrase de passe (aucune clé requise)
gpg --symmetric --cipher-algo AES256 backup.tar.gz
# Demande une phrase de passe
# Crée : backup.tar.gz.gpg

# Déchiffrer
gpg --decrypt backup.tar.gz.gpg > backup.tar.gz

Signer des fichiers et des messages

Les signatures numériques prouvent l’authenticité (qui a signé) et l’intégrité (le contenu n’a pas changé).

# Créer une signature détachée (fichier .sig séparé)
gpg --detach-sign release-v1.0.tar.gz
# Crée : release-v1.0.tar.gz.sig

# Vérifier une signature détachée
gpg --verify release-v1.0.tar.gz.sig release-v1.0.tar.gz
# Good signature from "Your Name <you@example.com>"

# Créer une signature en clair (lisible par l'humain)
gpg --clearsign announcement.txt
# Crée : announcement.txt.asc (texte avec signature intégrée)

# Vérifier une signature en clair
gpg --verify announcement.txt.asc

Signature des commits Git

Les commits signés affichent un badge « Verified » sur GitHub et GitLab, attestant que vous êtes bien l’auteur du commit.

Configuration

# Trouver l'identifiant de votre clé GPG
gpg --list-secret-keys --keyid-format long
# sec   ed25519/ABC123DEF456 2025-12-12 [SC]

# Configurer Git pour utiliser votre clé
git config --global user.signingkey ABC123DEF456

# Activer la signature automatique de tous les commits
git config --global commit.gpgsign true

# Signer aussi les tags
git config --global tag.gpgsign true

# Si les invites GPG échouent, définissez le TTY
export GPG_TTY=$(tty)
echo 'export GPG_TTY=$(tty)' >> ~/.bashrc

Exporter votre clé publique vers GitHub/GitLab

# Exporter votre clé publique au format ASCII
gpg --export --armor ABC123DEF456

# Copiez la sortie (y compris -----BEGIN PGP PUBLIC KEY BLOCK-----)
# Collez-la dans GitHub : Settings > SSH and GPG keys > New GPG key

Signer en pratique

# Signer un commit individuel
git commit -S -m "Fix authentication bug"

# Vérifier les signatures dans le journal
git log --show-signature -3

# Signer un tag
git tag -s v1.0 -m "Release 1.0"

# Vérifier un tag signé
git tag -v v1.0

Comparaison des outils de chiffrement

FonctionnalitéGPG (GnuPG)ageOpenSSLSignal Protocol
Cas d’usageFichiers, e-mail, GitChiffrement de fichiersTLS, certificats, fichiersMessagerie
Gestion des clésTrousseau, serveurs de clésFichiers de clés simplesCertificats, CAAutomatique
ComplexitéÉlevée (nombreuses options)Très faibleModéréeIntégrée aux apps
Chiffrement asymétriqueOui (RSA, ECC)Oui (X25519)OuiOui
Signatures numériquesOuiNonOuiOui
Intégration GitNativeNonNonNon
Idéal pourE-mail, Git, paquetsChiffrement de fichiers simpleSécurité TLS/serveurApplications de chat

Utilisez GPG pour la signature des commits Git, le chiffrement des e-mails et la vérification des paquets logiciels. Utilisez age lorsque vous avez besoin d’un chiffrement de fichiers simple sans la complexité de la gestion de clés. Utilisez OpenSSL pour les certificats TLS et le chiffrement côté serveur.

Bonnes pratiques de gestion des clés

# Exporter votre clé privée pour sauvegarde (stockez hors ligne !)
gpg --export-secret-keys --armor ABC123DEF456 > private-key-backup.asc

# Exporter votre clé publique
gpg --export --armor ABC123DEF456 > public-key.asc

# Importer une clé depuis un fichier
gpg --import someone-public-key.asc

# Importer depuis un serveur de clés
gpg --keyserver keyserver.ubuntu.com --recv-keys THEIR_KEY_ID

# Déposer votre clé sur un serveur de clés
gpg --keyserver keyserver.ubuntu.com --send-keys ABC123DEF456

# Prolonger l'expiration avant qu'elle n'arrive
gpg --edit-key ABC123DEF456
# gpg> expire
# (définir la nouvelle expiration)
# gpg> save

# Révoquer une clé compromise
gpg --import revoke-cert.asc
gpg --keyserver keyserver.ubuntu.com --send-keys ABC123DEF456

Cas particuliers et pièges courants

Les clés expirées ne peuvent plus chiffrer ni signer : Si votre clé expire, vous ne pouvez plus créer de nouvelles signatures ni chiffrer des données pour des destinataires. Vous pouvez toutefois déchiffrer d’anciennes données et prolonger la date d’expiration depuis la clé privée. Prolongez toujours avant l’expiration.

Confusion sur le modèle de confiance : Importer la clé publique d’une personne ne signifie pas que vous lui faites confiance. GPG marque les clés non fiables avec un avertissement. Utilisez gpg --edit-key THEIR_ID puis trust pour définir le niveau de confiance, ou signez leur clé avec lsign après avoir vérifié leur identité.

Agent SSH vs agent GPG : GPG dispose de son propre agent (gpg-agent) qui met en cache votre phrase de passe. Si vous utilisez aussi un agent SSH, des conflits peuvent survenir. GPG moderne peut également servir d’agent SSH — configurez cela dans ~/.gnupg/gpg-agent.conf avec enable-ssh-support.

Invites de phrase de passe graphiques en sessions sans interface : Lorsque vous exécutez GPG via SSH ou dans des scripts, le programme pinentry peut échouer faute d’interface graphique. Définissez GPG_TTY=$(tty) et configurez pinentry-curses dans ~/.gnupg/gpg-agent.conf :

echo "pinentry-program /usr/bin/pinentry-curses" >> ~/.gnupg/gpg-agent.conf
gpgconf --kill gpg-agent

Le chiffrement de gros fichiers est lent : GPG n’est pas conçu pour chiffrer des fichiers de plusieurs gigaoctets. Pour les données volumineuses, chiffrez avec un algorithme symétrique (AES256) et protégez la phrase de passe avec GPG, ou utilisez des outils comme age qui sont optimisés pour le chiffrement de fichiers.

Résolution de Problèmes

« gpg: signing failed: No secret key »

# Vérifier que l'identifiant de clé de signature correspond à votre config Git
git config --global user.signingkey
gpg --list-secret-keys --keyid-format long

# S'assurer que l'e-mail dans votre clé GPG correspond à votre e-mail Git
git config --global user.email

« gpg: decryption failed: No secret key »

# Vous avez besoin de la clé privée correspondant au destinataire du chiffrement
gpg --list-secret-keys

# Si la clé est sur une autre machine, exportez-la puis importez-la
# Sur la machine source :
gpg --export-secret-keys --armor KEYID > key.asc
# Sur la machine cible :
gpg --import key.asc

La signature des commits Git se bloque

# L'agent GPG ne peut pas demander la phrase de passe
export GPG_TTY=$(tty)

# Tester la signature GPG directement
echo "test" | gpg --clearsign

# Si vous utilisez VS Code ou un IDE, configurez le TTY dans votre profil shell
echo 'export GPG_TTY=$(tty)' >> ~/.bashrc

Résumé

  • GPG utilise la cryptographie à clé publique : votre clé publique chiffre les données, votre clé privée les déchiffre — partagez librement les clés publiques, protégez absolument les clés privées
  • Générez des clés avec gpg --full-generate-key et créez immédiatement un certificat de révocation stocké hors ligne pour une révocation d’urgence
  • Chiffrez des fichiers avec gpg --encrypt --recipient pour le chiffrement asymétrique, ou gpg --symmetric lorsque le partage d’une phrase de passe est plus simple
  • Signez les commits Git avec git commit -S et configurez commit.gpgsign true pour la signature automatique — ajoutez votre clé publique à GitHub pour les badges « Verified »
  • Définissez des dates d’expiration et prolongez-les avant qu’elles n’arrivent — une clé expirée bloque le chiffrement et la signature, mais déchiffre toujours les anciennes données
  • Sauvegardez votre clé privée hors ligne — la perdre signifie la perte définitive de la capacité de déchiffrement pour toutes les données chiffrées avec cette clé

Articles Connexes