Introduction
Dans ce laboratoire, vous acquerrez 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 fondamentales 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 bases, vous explorerez comment échanger des informations en toute sécurité avec d'autres personnes. 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 cruciales de maintenance des clés, 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
Maintenant, vous êtes 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 conviennent pour ce laboratoire.
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'identifiant utilisateur (Confirm User ID) : Vérifiez vos détails. Lorsque le message
Change (N)ame, (E)mail, or (O)kay/(Q)uit?s'affiche, tapezOet appuyez surEntrée.
Le système utilisera automatiquement des paramètres sécurisés par défaut :
- Type de clé : RSA et RSA (par défaut)
- Taille de la clé : 3072 bits (valeur par défaut sécurisée)
- Validité de la clé : 2 ans (expiration automatique pour la sécurité)
Remarque : Contrairement aux anciennes versions, le GPG moderne peut ne pas demander de phrase de passe lors de la génération de clé avec --gen-key. Si vous souhaitez ajouter une phrase de passe à votre clé pour plus de sécurité, vous pouvez le faire plus tard en utilisant :
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. Il s'agit d'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 correcte peut le déchiffrer pour retrouver sa forme originale.
Tout d'abord, créons un fichier texte simple sur lequel 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 en utilisant 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 correspondre au nom associé à votre clé GPG (labex).
gpg -e -r labex mytestfile.txt
GPG utilisera votre clé publique pour chiffrer le fichier. Vous ne serez pas invité à entrer votre phrase de passe car le chiffrement est effectué 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 d'afficher 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 les fichiers.
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 poursuivra 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 afficher 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 pour 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 implique l'exportation de votre clé publique vers un fichier et l'importation des clés publiques que vous recevez des autres 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 allons l'enregistrer 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éé en utilisant ls :
ls
Vous devriez voir labex.pub dans la liste des fichiers. Vous pouvez également afficher 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 maintenant partager avec d'autres.
Ensuite, vous simulerez 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 ce laboratoire, nous allons créer une paire de clés temporaire pour Alice, puis exporter la clé publique d'Alice pour simuler ce processus.
Tout d'abord, générons temporairement une paire de clés pour Alice. Nous utiliserons un mode 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 vers un fichier, en simulant la façon dont vous la recevriez d'Alice :
gpg --export --armor -o alice.pub alice@example.com
Pour cette démonstration de laboratoire, nous supprimerons également la clé secrète d'Alice du trousseau, car en réalité, vous n'auriez 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 Entrée.
gpg --delete-keys alice@example.com
Confirmez à nouveau la suppression en tapant y et en appuyant sur Entrée.
Vous avez maintenant la clé publique d'Alice dans le fichier alice.pub, simulant la façon dont vous la recevriez d'un autre utilisateur.
Nettoyez le fichier de génération de clé temporaire :
rm alice-key-params
Maintenant que vous avez la clé publique d'Alice dans un fichier, importez-la dans votre trousseau GPG en utilisant 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 maintenant dans votre trousseau, listez à nouveau toutes vos clés publiques.
gpg --list-keys
La sortie affichera désormais à la fois 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]
Notez que la clé d'Alice est marquée avec une 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 à établir une confiance dans une clé publique que vous avez reçue, puis à 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 : "Je fais confiance au fait que cette clé appartient à cette personne." C'est un concept fondamental du modèle "Web of Trust" (Toile de confiance) 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 Entrée. 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. Entrez votre phrase de passe si vous y êtes invité et appuyez sur Entrée.
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 pour la clé d'Alice. Après avoir signé la clé importée, GPG ne l'affiche plus comme [unknown]. Selon l'état de votre trousseau local, la clé peut apparaître avec un marqueur de validité plus fort tel que [full] ou [ultimate].
/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 [full] Alice <alice@example.com>
sub rsa2048 2025-07-01 [E] [expires: 2027-07-01]
Si vous souhaitez confirmer la signature directement, exécutez :
gpg --list-sigs alice@example.com
Vous devriez voir une ligne de signature pour labex <labex@example.com>, ce qui confirme que votre clé a signé la clé publique importée d'Alice.
Maintenant que vous avez une clé publique de confiance pour Alice, vous pouvez chiffrer un fichier qu'elle seule 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 en utilisant 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 maintenant chiffré en toute sécurité. 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 : créer une sauvegarde sécurisée de votre clé secrète et générer 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 perdue ou compromise.
Tout d'abord, créons une sauvegarde de votre clé secrète. C'est l'une des étapes les plus importantes dans la gestion d'une clé GPG.
La commande gpg --export-secret-keys est utilisée à cet effet. Nous utiliserons l'option --armor pour créer un fichier texte au format ASCII, facile à stocker et à transporter. Vous devez spécifier quelle 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 stockeriez ce fichier dans un emplacement hors ligne très sécurisé, tel qu'une clé USB chiffrée ou un coffre-fort sécurisé.
Ensuite, vous créerez un certificat de révocation. Cela doit être fait immédiatement après la génération de la clé et stocké en toute sécurité, séparément de votre sauvegarde de 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 en utilisant l'option --output.
gpg --output revoke.asc --gen-revoke labex
Vous serez guidé à travers un processus interactif :
- Lorsque la question
Create a revocation certificate for this key? (y/N)s'affiche, tapezyet appuyez surEntrée. - Vous serez invité à sélectionner une raison pour la révocation. Pour ce laboratoire, appuyez sur
Entréepour accepter la valeur par défaut0 = No reason specified. - Vous pouvez ajouter une description facultative. Pour l'instant, appuyez simplement sur
Entréepour la laisser vide. - Enfin, confirmez les détails en tapant
yet en appuyant surEntréelorsque la questionIs this okay? (y/N)s'affiche. - Si votre clé possède une phrase de passe, GPG vous la demandera pour autoriser la création de ce certificat. Entrez votre phrase de passe si vous y êtes invité et appuyez sur
Entrée.
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 la maintenance essentielle des clés.
Résumé
Dans ce laboratoire, 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 impliquait la sélection 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 de la clé, 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, démontrant ainsi les principes de base du chiffrement asymétrique.
En vous appuyant sur ces bases, vous avez exploré comment communiquer en toute sécurité avec d'autres personnes. Vous avez appris à échanger des clés publiques en utilisant gpg --export pour partager votre clé et gpg --import pour recevoir la clé d'un autre utilisateur. Le laboratoire a également couvert 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 essentielles de maintenance des clés, notamment la sauvegarde de votre clé secrète avec gpg --export-secret-keys et la création d'un certificat de révocation à l'aide de gpg --gen-revoke pour invalider votre paire de clés si elle est compromise.
