Introduction
Dans cet atelier, vous allez acquérir les compétences essentielles pour chiffrer et déchiffrer des fichiers dans un environnement Linux à l'aide de GPG (GNU Privacy Guard). Vous commencerez par générer votre propre paire de clés publique/privée, qui constitue le fondement du modèle de sécurité de GPG. Après la génération des clés, vous pratiquerez les opérations de base consistant à chiffrer un fichier pour vous-même, puis à le déchiffrer à l'aide de votre clé secrète et de votre phrase de passe.
En vous appuyant sur ces fondamentaux, vous explorerez comment échanger des informations de manière sécurisée avec d'autres utilisateurs. Cela inclut l'exportation de votre clé publique pour la partager et l'importation de la clé publique d'un autre utilisateur. Vous apprendrez également à signer une clé publique pour vérifier son authenticité et à effectuer des tâches de maintenance cruciales, telles que la sauvegarde de votre clé secrète et la création d'un certificat de révocation au cas où votre clé serait compromise.
Générer votre paire de clés GPG avec gpg --gen-key
Dans cette étape, vous allez générer votre paire de clés GPG (GNU Privacy Guard) personnelle. Une paire de clés GPG se compose de deux clés distinctes mais liées : une clé publique et une clé privée. Vous pouvez partager votre clé publique avec d'autres personnes afin qu'elles puissent chiffrer des fichiers pour vous. Vous devez garder votre clé privée secrète, car c'est la seule clé capable de déchiffrer les fichiers chiffrés avec votre clé publique.
Tout d'abord, assurons-nous que le paquet gnupg, qui fournit les fonctionnalités GPG, est installé sur votre système.
sudo apt-get update && sudo apt-get install -y gnupg
Vous êtes maintenant prêt à générer votre paire de clés. La commande gpg --gen-key vous guidera à travers un processus interactif.
Exécutez la commande suivante dans votre terminal :
gpg --gen-key
Vous verrez une note indiquant que cette commande utilise une génération de clé simplifiée. Pour des options plus avancées, vous pouvez utiliser gpg --full-generate-key, mais les options par défaut sont adaptées à cet atelier.
Les informations suivantes vous seront demandées :
- Nom réel (Real name) : Entrez
labex - Adresse e-mail (Email address) : Entrez
labex@example.com - Confirmer l'ID utilisateur : Vérifiez vos informations. Lorsque le message
Change (N)ame, (E)mail, or (O)kay/(Q)uit?s'affiche, tapezOet appuyez surEnter.
Le système utilisera automatiquement des paramètres par défaut sécurisés :
- Type de clé : RSA et RSA (par défaut)
- Taille de la clé : 3072 bits (standard de sécurité actuel)
- Validité de la clé : 2 ans (expiration automatique pour plus de sécurité)
Note : Contrairement aux anciennes versions, le GPG moderne peut ne pas demander de phrase de passe lors de la génération de clé via --gen-key. Si vous souhaitez ajouter une phrase de passe à votre clé pour une sécurité accrue, vous pourrez le faire plus tard avec :
gpg --edit-key labex
Tapez ensuite passwd à l'invite GPG pour définir une phrase de passe, puis save pour quitter.
Le système va maintenant générer votre paire de clés. Ce processus nécessite des données aléatoires (entropie) et peut prendre quelques instants.
Une fois terminé, vous verrez un message de confirmation similaire à celui-ci :
gpg: key <KEY_ID> marked as ultimately trusted
gpg: revocation certificate stored as '/home/labex/.gnupg/openpgp-revocs.d/<FINGERPRINT>.rev'
public and secret key created and signed.
pub rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
<FINGERPRINT>
uid labex <labex@example.com>
sub rsa3072 2025-07-01 [E] [expires: 2027-07-01]
Maintenant que vos clés sont générées, vous pouvez les visualiser. Pour voir votre nouvelle clé publique, exécutez :
gpg --list-keys
La sortie listera toutes les clés publiques de votre trousseau, y compris celle que vous venez de créer :
/home/labex/.gnupg/pubring.kbx
------------------------------
pub rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
<FINGERPRINT>
uid [ultimate] labex <labex@example.com>
sub rsa3072 2025-07-01 [E] [expires: 2027-07-01]
Pour voir votre clé privée, exécutez :
gpg --list-secret-keys
La sortie sera similaire, mais elle indiquera une clé secrète (sec) au lieu d'une clé publique (pub) :
/home/labex/.gnupg/pubring.kbx
------------------------------
sec rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
<FINGERPRINT>
uid [ultimate] labex <labex@example.com>
ssb rsa3072 2025-07-01 [E] [expires: 2027-07-01]
Vous avez maintenant créé et vérifié avec succès votre paire de clés GPG.
Chiffrer et déchiffrer un fichier local avec gpg -e et gpg --decrypt
Dans cette étape, vous utiliserez la paire de clés GPG que vous avez générée pour chiffrer puis déchiffrer un fichier. C'est un cas d'utilisation fondamental de GPG, vous permettant de protéger la confidentialité de vos données. Le chiffrement transforme vos données lisibles en un format illisible, et seule une personne possédant la clé privée correspondante peut les déchiffrer pour retrouver leur forme originale.
Tout d'abord, créons un fichier texte simple pour travailler. Toutes les opérations seront effectuées dans votre répertoire actuel, ~/project.
echo "This is a secret message for the lab." > mytestfile.txt
Maintenant, vous pouvez chiffrer ce fichier à l'aide de votre clé publique. La commande gpg -e est utilisée pour le chiffrement. Vous devez également spécifier le destinataire du message chiffré avec l'option -r, qui doit être le nom associé à votre clé GPG (labex).
gpg -e -r labex mytestfile.txt
GPG utilisera votre clé publique pour chiffrer le fichier. Aucune phrase de passe ne vous sera demandée car le chiffrement s'effectue avec la clé publique, qui n'est pas secrète.
Une fois la commande terminée, utilisez la commande ls pour voir le nouveau fichier chiffré.
ls
Vous devriez voir mytestfile.txt.gpg dans la sortie, aux côtés du fichier original.
mytestfile.txt mytestfile.txt.gpg
Le fichier mytestfile.txt.gpg contient les données chiffrées. Si vous essayez de visualiser son contenu, vous verrez des données binaires illisibles.
Maintenant, déchiffrons le fichier. Pour ce faire, vous utiliserez la commande gpg --decrypt. Comme vous déchiffrez, GPG utilisera votre clé privée.
Nous utiliserons l'option --output pour spécifier un nouveau fichier pour le contenu déchiffré, mytestfile.txt.decrypted. Cela évite d'écraser le fichier original et permet de distinguer clairement chaque fichier.
gpg --output mytestfile.txt.decrypted --decrypt mytestfile.txt.gpg
Si votre clé possède une phrase de passe, vous serez invité à la saisir. Si aucune phrase de passe n'a été définie lors de la génération de la clé, le déchiffrement se fera automatiquement. Vous devriez voir une sortie similaire à :
gpg: encrypted with 3072-bit RSA key, ID <KEY_ID>, created 2025-07-01
"labex <labex@example.com>"
Une fois déchiffré, vous pouvez visualiser le contenu du nouveau fichier pour confirmer qu'il correspond au message original.
cat mytestfile.txt.decrypted
La sortie devrait être le texte original que vous avez créé :
This is a secret message for the lab.
Vous avez réussi à chiffrer un fichier pour vous-même, puis à le déchiffrer à l'aide de votre paire de clés GPG.
Échanger des clés publiques avec gpg --export et gpg --import
Dans cette étape, vous apprendrez à échanger des clés publiques avec d'autres personnes. Pour chiffrer un fichier destiné à quelqu'un d'autre, vous avez besoin de sa clé publique. De même, si quelqu'un veut vous envoyer un fichier chiffré, il a besoin de votre clé publique. Ce processus consiste à exporter votre clé publique dans un fichier et à importer les clés publiques que vous recevez dans votre trousseau GPG.
Tout d'abord, exportons votre propre clé publique. Vous utiliserez la commande gpg --export. Il est recommandé d'utiliser l'option --armor, qui crée une version textuelle (ASCII) de la clé, facilitant ainsi le copier-coller dans des e-mails ou d'autres canaux de communication textuels. Nous l'enregistrerons dans un fichier nommé labex.pub.
Dans votre terminal, exécutez la commande suivante. Remplacez labex par l'identifiant utilisateur que vous avez utilisé lors de la génération de la clé.
gpg --export --armor -o labex.pub labex
Vous pouvez vérifier que le fichier a été créé à l'aide de ls :
ls
Vous devriez voir labex.pub dans la liste des fichiers. Vous pouvez également visualiser son contenu :
cat labex.pub
La sortie sera un bloc de texte commençant par -----BEGIN PGP PUBLIC KEY BLOCK-----. Il s'agit de votre clé publique, que vous pouvez désormais partager.
Ensuite, vous allez simuler la réception d'une clé publique d'un autre utilisateur et son importation dans votre trousseau. Dans un scénario réel, vous recevriez la clé publique d'une autre personne via un canal sécurisé. Pour cet atelier, nous allons créer une paire de clés temporaire pour Alice, puis exporter sa clé publique pour simuler ce processus.
Tout d'abord, générons temporairement une paire de clés pour Alice. Nous utiliserons un mode par lots (batch) pour automatiser ce processus sans invites interactives :
cat > alice-key-params << 'EOF'
Key-Type: RSA
Key-Length: 2048
Subkey-Type: RSA
Subkey-Length: 2048
Name-Real: Alice
Name-Email: alice@example.com
Expire-Date: 2y
%no-protection
%commit
EOF
Générez maintenant la paire de clés d'Alice en utilisant le fichier de paramètres :
gpg --batch --generate-key alice-key-params
Vous devriez voir une sortie confirmant la génération de la clé :
gpg: key <KEY_ID> marked as ultimately trusted
public and secret key created and signed.
Exportez maintenant la clé publique d'Alice dans un fichier, simulant ainsi la réception de sa clé :
gpg --export --armor -o alice.pub alice@example.com
Pour les besoins de cette démonstration, nous allons également supprimer la clé secrète d'Alice de votre trousseau, car en réalité, vous ne posséderiez que sa clé publique :
gpg --delete-secret-keys alice@example.com
Lorsque vous y êtes invité, confirmez la suppression en tapant y et en appuyant sur Enter.
gpg --delete-keys alice@example.com
À nouveau, confirmez la suppression en tapant y et en appuyant sur Enter.
Vous avez maintenant la clé publique d'Alice dans le fichier alice.pub, simulant la réception d'une clé d'un tiers.
Nettoyez le fichier temporaire de génération de clé :
rm alice-key-params
Maintenant que vous avez la clé publique d'Alice dans un fichier, importez-la dans votre trousseau GPG à l'aide de la commande gpg --import.
gpg --import alice.pub
Vous devriez voir une sortie confirmant que la clé a été importée :
gpg: key <KEY_ID>: public key "Alice <alice@example.com>" imported
gpg: Total number processed: 1
gpg: imported: 1
Pour confirmer que la clé d'Alice est bien dans votre trousseau, listez à nouveau toutes vos clés publiques.
gpg --list-keys
La sortie affichera désormais votre clé (labex) et la clé nouvellement importée (Alice).
/home/labex/.gnupg/pubring.kbx
------------------------------
pub rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
<FINGERPRINT_LABEX>
uid [ultimate] labex <labex@example.com>
sub rsa3072 2025-07-01 [E] [expires: 2027-07-01]
pub rsa2048 2025-07-01 [SC] [expires: 2027-07-01]
<FINGERPRINT_ALICE>
uid [ unknown] Alice <alice@example.com>
sub rsa2048 2025-07-01 [E] [expires: 2027-07-01]
Remarquez que la clé d'Alice est marquée avec un niveau de confiance [ unknown]. Vous apprendrez à gérer la confiance des clés à l'étape suivante.
Signer une clé publique et chiffrer un fichier pour un autre utilisateur
Dans cette étape, vous apprendrez comment établir la confiance dans une clé publique que vous avez reçue, puis comment l'utiliser pour chiffrer un fichier pour son propriétaire. Lorsque vous importez une clé publique, GPG n'a aucun moyen de savoir si elle est authentique. En « signant » la clé avec votre propre clé privée, vous créez une approbation cryptographique, indiquant essentiellement à votre configuration GPG : « J'ai la certitude que cette clé appartient bien à cette personne ». C'est un concept fondamental du modèle de « Toile de confiance » (Web of Trust) de GPG.
Tout d'abord, vous devez signer la clé publique d'Alice que vous avez importée à l'étape précédente. Vous utiliserez la commande gpg --sign-key, en identifiant la clé par son adresse e-mail (alice@example.com).
gpg --sign-key alice@example.com
GPG affichera les détails de la clé d'Alice et vous demandera de confirmer que vous souhaitez la signer.
pub rsa2048/XXXXXXXXXXXXXXXX 2025-07-01
created: 2025-07-01 expires: 2027-07-01 usage: SC
trust: unknown validity: unknown
sub rsa2048/YYYYYYYYYYYYYYYY 2025-07-01
created: 2025-07-01 expires: 2027-07-01 usage: E
[ unknown] (1). Alice <alice@example.com>
Really sign? (y/N)
Tapez y et appuyez sur Enter. Si votre clé possède une phrase de passe, vous serez invité à la saisir. En effet, une signature est une opération cryptographique qui ne peut être effectuée qu'avec votre clé secrète. Saisissez votre phrase de passe si nécessaire et appuyez sur Enter.
Une fois terminé, vous pouvez vérifier la signature en listant à nouveau les clés.
gpg --list-keys
Notez le changement dans l'entrée de la clé d'Alice. Le niveau de confiance n'est plus [unknown]. Il affiche désormais [ultimate] car vous lui avez explicitement accordé votre confiance en la signant.
/home/labex/.gnupg/pubring.kbx
------------------------------
pub rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
<FINGERPRINT_LABEX>
uid [ultimate] labex <labex@example.com>
sub rsa3072 2025-07-01 [E] [expires: 2027-07-01]
pub rsa2048 2025-07-01 [SC] [expires: 2027-07-01]
<FINGERPRINT_ALICE>
uid [ultimate] Alice <alice@example.com>
sub rsa2048 2025-07-01 [E] [expires: 2027-07-01]
Maintenant que vous avez une clé publique de confiance pour Alice, vous pouvez chiffrer un fichier que seule elle pourra ouvrir. Tout d'abord, créez un nouveau fichier à cet effet.
echo "This is a confidential message for Alice." > message-for-alice.txt
Ensuite, chiffrez ce fichier à l'aide de la commande gpg -e. Cette fois, spécifiez Alice comme destinataire avec l'option -r.
gpg -e -r alice@example.com message-for-alice.txt
GPG utilisera la clé publique d'Alice pour effectuer le chiffrement. Utilisez ls pour voir le résultat.
ls
Vous verrez le nouveau fichier chiffré, message-for-alice.txt.gpg, dans votre répertoire.
labex.pub mytestfile.txt
alice.pub mytestfile.txt.decrypted
message-for-alice.txt mytestfile.txt.gpg
message-for-alice.txt.gpg
Ce fichier est désormais chiffré de manière sécurisée. Seule une personne ayant accès à la clé privée d'Alice (et à sa phrase de passe) peut déchiffrer et lire le message.
Effectuer la maintenance des clés avec gpg --export-secret-keys et gpg --gen-revoke
Dans cette dernière étape, vous effectuerez deux tâches de maintenance critiques pour votre clé GPG : la création d'une sauvegarde sécurisée de votre clé secrète et la génération d'un certificat de révocation. Votre clé secrète est irremplaçable ; si vous la perdez, vous perdez l'accès à toutes les données chiffrées avec la clé publique correspondante. Un certificat de révocation est votre filet de sécurité, vous permettant d'invalider votre clé publique si votre clé secrète est un jour perdue ou compromise.
Tout d'abord, créons une sauvegarde de votre clé secrète. C'est l'une des étapes les plus importantes de la gestion d'une clé GPG.
La commande gpg --export-secret-keys est utilisée à cette fin. Nous utiliserons l'option --armor pour créer un fichier texte au format ASCII, facile à stocker et à transporter. Vous devez spécifier la clé à exporter par son identifiant utilisateur.
gpg --export-secret-keys --armor -o gpgkey.asc labex
Cette commande exporte la clé secrète de l'utilisateur labex dans un fichier nommé gpgkey.asc. Ce fichier est extrêmement sensible. Dans un scénario réel, vous devriez stocker ce fichier dans un endroit hors ligne très sûr, comme une clé USB chiffrée ou un coffre-fort numérique.
Ensuite, vous allez créer un certificat de révocation. Cela devrait être fait immédiatement après la génération de la clé et stocké de manière sécurisée, séparément de la sauvegarde de votre clé secrète. Si vous perdez votre clé secrète ou si elle est volée, vous pouvez publier ce certificat pour informer les autres que la clé ne doit plus être utilisée ou considérée comme fiable.
Utilisez la commande gpg --gen-revoke. Nous enregistrerons le certificat dans un fichier nommé revoke.asc à l'aide de l'option --output.
gpg --output revoke.asc --gen-revoke labex
Vous serez guidé à travers un processus interactif :
- Lorsqu'on vous demande
Create a revocation certificate for this key? (y/N), tapezyet appuyez surEnter. - Vous serez invité à sélectionner une raison pour la révocation. Pour cet atelier, appuyez sur
Enterpour accepter la valeur par défaut0 = No reason specified. - Vous pouvez ajouter une description facultative. Pour l'instant, appuyez simplement sur
Enterpour la laisser vide. - Enfin, confirmez les détails en tapant
yet en appuyant surEnterlorsqu'on vous demandeIs this okay? (y/N). - Si votre clé possède une phrase de passe, GPG la demandera pour autoriser la création de ce certificat. Saisissez votre phrase de passe si nécessaire et appuyez sur
Enter.
Vous verrez une confirmation indiquant que le certificat de révocation a été créé.
Revocation certificate created.
Please move it to a medium which you can hide away; if Mallory gets
access to this certificate he can use it to make your key unusable.
It is smart to print this certificate and store it away, just in case
your media become unreadable. But have some caution: The printout
might be scanned and reconstructed by a determined attacker.
Utilisez la commande ls pour vérifier que les deux nouveaux fichiers ont été créés dans votre répertoire ~/project.
ls
Vous devriez maintenant voir gpgkey.asc et revoke.asc dans la liste des fichiers. Vous avez effectué avec succès les opérations essentielles de maintenance des clés.
Résumé
Dans cet atelier, vous avez appris les opérations fondamentales de GNU Privacy Guard (GPG) dans un environnement Linux. Vous avez commencé par générer une paire de clés GPG personnelle, composée d'une clé publique et d'une clé privée, à l'aide de la commande gpg --gen-key. Ce processus a impliqué la définition des spécifications de la clé et la création d'un identifiant utilisateur protégé par une phrase de passe sécurisée. Après la génération des clés, vous avez pratiqué la fonction principale de GPG en chiffrant un fichier local pour vous-même avec gpg -e, puis en le déchiffrant à l'aide de votre clé privée et de la commande gpg --decrypt, illustrant ainsi les principes de base du chiffrement asymétrique.
En approfondissant ces bases, vous avez exploré comment communiquer de manière sécurisée avec autrui. Vous avez appris à échanger des clés publiques en utilisant gpg --export pour partager votre clé et gpg --import pour recevoir celle d'un autre utilisateur. L'atelier a également abordé l'importance d'établir la confiance en signant une clé publique importée, puis en l'utilisant pour chiffrer un fichier spécifiquement pour cet utilisateur. Enfin, vous avez effectué des tâches de maintenance essentielles, notamment la sauvegarde de votre clé secrète avec gpg --export-secret-keys et la création d'un certificat de révocation avec gpg --gen-revoke pour invalider votre paire de clés en cas de compromission.
