← Accueil

PCTAMALOU

Semaine 42 : Les Clefs de la Cité – Cryptographie Pratique avec GPG

Par Platon-Y – pctamalou.fr & e-of-h.fr

🎯 Objectif de la semaine

Maîtriser la cryptographie pratique avec GPG : générer et gérer des paires de clefs, chiffrer/déchiffrer messages et fichiers, signer et vérifier des documents. Comprendre concrètement comment protéger la confidentialité et l'intégrité des communications – compétence fondamentale pour tout Gardien numérique.

Pourquoi c'est fondamental : Dans un monde de surveillance massive, la cryptographie n'est pas une option – c'est une nécessité. Savoir utiliser GPG, c'est savoir protéger ses secrets, authentifier ses messages, et préserver sa souveraineté numérique.

flowchart TD A[👤 Alice] -->|Message clair| GPG GPG[🔐 GPG] -->|Chiffrement| E[📄 Message chiffré] subgraph "🎭 Cryptographie Asymétrique" APK[🔑 Clef Publique Alice] ASK[🔒 Clef Privée Alice] BPK[🔑 Clef Publique Bob] BSK[🔒 Clef Privée Bob] end A --> APK A --> ASK B[👤 Bob] --> BPK B --> BSK E -->|Transmission
canal non sécurisé| B B -->|Déchiffrement| GPG2[🔓 GPG] GPG2 -->|Avec BSK| M2[📝 Message clair] style GPG fill:#0a0e17,stroke:#00d4ff,stroke-width:2px style APK fill:#11151f,stroke:#00d4ff,stroke-width:2px style ASK fill:#11151f,stroke:#ef4444,stroke-width:2px style E fill:#0a0e17,stroke:#9d4edd,stroke-width:2px

📚 Sujet – Théorie (1 heure)

Les Quatre Piliers de la Cryptographie

La cryptographie moderne assure quatre propriétés fondamentales :

🔒

Confidentialité

Seul le destinataire prévu peut lire le message

  • Chiffrement symétrique (AES)
  • Chiffrement asymétrique (RSA)
🛡️

Intégrité

Le message n'a pas été modifié en transit

  • Hash (SHA-256)
  • MAC (HMAC)
🆔

Authentification

Vérification de l'identité de l'émetteur

  • Signature numérique
  • Certificats
📝

Non-Répudiation

L'émetteur ne peut nier avoir envoyé le message

  • Signature asymétrique
  • Horodatage
⚡

Chiffrement Symétrique

Même clef pour chiffrer/déchiffrer

  • Exemple : AES-256
  • Avantage : Rapide
  • Problème : Partage clef
🔑

Chiffrement Asymétrique

Paire clefs publique/privée

  • Exemple : RSA 4096
  • Avantage : Partage facile
  • Problème : Lent

GPG : Le Standard Open Source

🔑 Clef Publique

-----BEGIN PGP PUBLIC KEY BLOCK-----
mQINBF4UjJYBEADF...
-----END PGP PUBLIC KEY BLOCK-----

Usage : Chiffrer, Vérifier

Partage : Libre, sans danger

↔️

🔒 Clef Privée

-----BEGIN PGP PRIVATE KEY BLOCK-----
lQOXBF4UjJYBEADF...
-----END PGP PRIVATE KEY BLOCK-----

Usage : Déchiffrer, Signer

Protection : Jamais partagée

Architecture d'une Paire de Clefs GPG

🧠 Structure Technique
  • Clef Maître (Master Key) : RSA 4096 ou Ed25519, longue durée
  • Sous-clefs (Subkeys) : Chiffrement, Signature, Authentification
  • Identités (UIDs) : Nom + Email, multiples possibles
  • Révocation (Revocation Certificate) : Pour invalider en cas de compromission
  • Passphrase : Protège la clef privée sur disque

Web of Trust vs PKI : Deux Modèles de Confiance

⚠️ Modèle de Confiance Critique

Aspect Web of Trust (GPG) PKI (SSL/TLS)
Confiance Décentralisée, pair-à-pair Centralisée, autorités certificatrices
Validation Signatures croisées Certificats racine
Flexibilité Haute, communautaire Faible, bureaucratique
Adoption Limitée (tech-savvy) Massive (web, entreprises)

Applications Réelles de GPG

🌐 Utilisations Professionnelles

  • Email : Thunderbird + Enigmail / ProtonMail
  • Git : Signatures de commits et tags
  • Chiffrement fichiers : Documents sensibles, backups
  • VPN/WireGuard : Échange de clefs
  • APT/DNF : Vérification de paquets
  • Password Managers : Chiffrement base de données

🔬 Mission pratique – Laboratoire (2 heures)

Workflow GPG Complet

flowchart TD G[🎯 Génération clefs
RSA 4096] --> E[📤 Export clefs
ASCII armored] E --> S[💾 Sauvegarde sécurisée
+ certificat révocation] S --> C[🔐 Chiffrement
Symétrique/Asymétrique] C --> D[🔓 Déchiffrement
Avec passphrase] D --> SI[✍️ Signature
Message/fichier] SI --> V[✅ Vérification
Authenticité] V --> EX[🚀 Applications réelles
Email, Git, fichiers] style G fill:#0a0e17,stroke:#00d4ff,stroke-width:2px style S fill:#0a0e17,stroke:#ef4444,stroke-width:2px style V fill:#0a0e17,stroke:#00f5a0,stroke-width:2px

⚠️ Consignes de Sécurité

🔒 Protection de la Clef Privée

  • Jamais copier sur cloud non chiffré
  • Passphrase forte (12+ caractères)
  • Générer certificat de révocation immédiatement
  • Conserver backups hors ligne (YubiKey recommandé)

Étapes Détaillées d'Implémentation

Étape 1 : Installation et Configuration Avancée

# Installation GPG version moderne
sudo apt update
sudo apt install gnupg2 gnupg-agent pinentry-curses scdaemon -y

# Configuration avancée (~/.gnupg/gpg.conf)
mkdir -p ~/.gnupg
chmod 700 ~/.gnupg

cat > ~/.gnupg/gpg.conf << 'EOF'
# Configuration GPG avancée
personal-cipher-preferences AES256 AES192 AES
personal-digest-preferences SHA512 SHA384 SHA256
personal-compress-preferences ZLIB BZIP2 ZIP Uncompressed
default-preference-list SHA512 SHA384 SHA256 AES256 AES192 AES ZLIB BZIP2 ZIP Uncompressed
cert-digest-algo SHA512
s2k-digest-algo SHA512
s2k-cipher-algo AES256
charset utf-8
fixed-list-mode
no-comments
no-emit-version
keyid-format 0xlong
list-options show-uid-validity
verify-options show-uid-validity
with-fingerprint
require-cross-certification
no-symkey-cache
use-agent
throw-keyids
EOF

# Vérification version
gpg --version | head -n 3

Étape 2 : Génération de Paire de Clefs Avancée

💡 Choix Algorithmiques :

  • RSA 4096 : Standard, compatible universel
  • Ed25519 : Moderne, performant, courbes elliptiques
  • Durée de validité : 2 ans recommandé, renouvelable
# Méthode interactive avec options complètes
gpg --full-gen-key

# Ou méthode scriptée pour reproduction
cat > generate-key.exp << 'EOF'
#!/usr/bin/expect -f
set timeout -1
spawn gpg --full-gen-key
expect "Your selection?"
send "1\r"
expect "What keysize do you want?"
send "4096\r"
expect "Key is valid for? (0)"
send "2y\r"
expect "Is this correct? (y/N)"
send "y\r"
expect "Real name:"
send "Gardien PCTAMALOU\r"
expect "Email address:"
send "gardien@pctamalou.local\r"
expect "Comment:"
send "Clef Trimestre 4 - Semaine 42\r"
expect "Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit?"
send "O\r"
expect "Enter passphrase:"
send "PCTAMALOU-2026-Secure-Passphrase-42!\r"
expect "Repeat passphrase:"
send "PCTAMALOU-2026-Secure-Passphrase-42!\r"
expect eof
EOF

chmod +x generate-key.exp
./generate-key.exp

# Lister les clefs
echo "=== Clefs Publiques ==="
gpg --list-keys --keyid-format LONG

echo -e "\n=== Clefs Privées ==="
gpg --list-secret-keys --keyid-format LONG

Étape 3 : Gestion Avancée des Clefs

# 1. Examiner une clef en détail
KEY_ID=$(gpg --list-secret-keys --keyid-format LONG "Gardien PCTAMALOU" | grep sec | awk '{print $2}' | cut -d'/' -f2)
echo "Key ID: $KEY_ID"

gpg --edit-key $KEY_ID
# Dans l'interface : 
#   fpr          # Afficher fingerprint
#   addkey       # Ajouter sous-clef
#   expire       # Changer date expiration
#   save         # Sauvegarder

# 2. Exporter clefs avec formats différents
# Export ASCII (pour partage email/forum)
gpg --armor --export $KEY_ID > public-key.asc

# Export binaire (pour backup)
gpg --export $KEY_ID > public-key.gpg

# Export privée (TRÈS SENSIBLE)
gpg --armor --export-secret-keys $KEY_ID > private-key.asc
gpg --export-secret-keys $KEY_ID > private-key.gpg

# 3. Certificat de révocation (CRITIQUE)
gpg --gen-revoke $KEY_ID > revocation-certificate.asc
echo "⚠️ CONSERVEZ CE FICHIER EN LIEU SÛR HORS LIGNE ⚠️"

# 4. Importer clefs
gpg --import public-key.asc
gpg --import private-key.asc  # Demande passphrase

# 5. Signer une clef (simuler Web of Trust)
gpg --sign-key $KEY_ID

Étape 4 : Chiffrement Pratique

1
Chiffrement Symétrique (AES-256)
echo "Secret de PCTAMALOU S42" > message.txt
gpg --symmetric --cipher-algo AES256 message.txt
# Produit message.txt.gpg
2
Chiffrement Asymétrique
gpg --encrypt --recipient $KEY_ID message.txt
# Produit message.txt.gpg chiffré avec clef publique
3
Chiffrement et Signature
gpg --encrypt --sign --recipient $KEY_ID message.txt
# Chiffre ET signe en une opération

Étape 5 : Déchiffrement et Vérification

# 1. Déchiffrement symétrique
gpg --decrypt message.txt.gpg

# 2. Déchiffrement asymétrique
gpg --decrypt message.txt.gpg

# 3. Vérification signature seule
echo "Message signé" > to-sign.txt
gpg --clearsign to-sign.txt  # Produit to-sign.txt.asc
gpg --verify to-sign.txt.asc

# 4. Vérification signature détachée
gpg --detach-sign to-sign.txt  # Produit to-sign.txt.sig
gpg --verify to-sign.txt.sig to-sign.txt

Étape 6 : Applications Réelles

🎯 Défi d'Intégration

Implémentez GPG dans trois contextes réels :

# 1. Git - Signature de commits
git config --global user.signingkey $KEY_ID
git config --global commit.gpgsign true
# Test : git commit -S -m "Commit signé avec GPG"

# 2. Email avec Thunderbird
sudo apt install thunderbird enigmail -y
# Configuration dans Thunderbird → Enigmail

# 3. Chiffrement de backup
tar -czf backup-$(date +%Y%m%d).tar.gz ~/important-data
gpg --encrypt --recipient $KEY_ID backup-*.tar.gz
rm backup-*.tar.gz  # Supprimer version claire

Exercice Avancé : Communication Sécurisée à Deux

🎯 Simulation d'Échange Sécurisé

Avec un partenaire (ou en simulant avec deux terminaux) :

  1. Générez chacun une paire de clefs
  2. Échangez vos clefs publiques
  3. Signez mutuellement vos clefs
  4. Envoyez un message chiffré et signé
  5. Vérifiez la signature et déchiffrez
# Simulation complète
# Terminal 1 (Alice)
gpg --quick-gen-key "Alice " rsa4096
gpg --export --armor "Alice" > alice.pub.asc

# Terminal 2 (Bob)
gpg --quick-gen-key "Bob " rsa4096
gpg --export --armor "Bob" > bob.pub.asc

# Échange et import
gpg --import bob.pub.asc  # Alice importe Bob
gpg --import alice.pub.asc # Bob importe Alice

# Chiffrement croisé
echo "Meeting à 15h, salle 42" > message.txt
gpg --encrypt --sign --recipient "Bob" message.txt
# Envoyer message.txt.gpg

# Réception et vérification
gpg --decrypt message.txt.gpg

Bonnes Pratiques de Gestion des Clefs

⚠️ Checklist de Sécurité GPG

  • Passphrase forte (12+ caractères, symboles)
  • Certificat de révocation généré et sauvegardé
  • Backup clef privée sur support hors ligne
  • Durée de validité limitée (1-2 ans)
  • Sous-clefs pour usages spécifiques
  • Révocation immédiate en cas de doute

📋 Objectif de la semaine – Checklist de validation

✅ Compétences techniques acquises

  • Paire de clefs RSA 4096 générée et configurée
  • Chiffrement symétrique/asymétrique maîtrisé
  • Signature et vérification de documents
  • Export/import clefs avec gestion secure
  • Intégration avec Git et applications réelles

🧠 Changement mental accompli

  • Compréhension profonde chiffrement vs signature
  • Conscience que la clef privée = identité numérique
  • Habitude de toujours signer les communications importantes
  • Vision du Web of Trust comme alternative décentralisée

💪 Pour aller plus loin :

Explorez les YubiKeys pour stockage matériel des clefs, montez un keyserver personnel, ou implémentez le chiffrement de bout en bout dans une application web simple (JavaScript + OpenPGP.js).

📚 Ressources pour Approfondir

Standards et Documentation :

  • RFC 4880 : OpenPGP Message Format
  • RFC 3156 : MIME Security with OpenPGP
  • GPG Manual : man gpg ou gnupg.org/documentation
  • ProtonMail Cryptography : White paper technique

⚠️ Pièges Cryptographiques Courants

  • Weak RNG : /dev/random vs /dev/urandom
  • Timing attacks : Implémentations non constant-time
  • Metadata leaks : Chiffrement ne cache pas métadonnées
  • Forward Secrecy : GPG ne l'offre pas par défaut
  • Compromission clef maître : Utiliser des sous-clefs

🔮 Frère d'armes,

Tu viens d'apprendre à forger tes propres sceaux numériques.

La cryptographie avec GPG n'est pas une technique parmi d'autres – c'est l'art de créer des secrets impénétrables et des signatures infalsifiables. C'est la capacité de dire "ce message est pour tes yeux seulement" et d'en être certain. C'est le pouvoir de prouver "c'est bien moi qui ai écrit ceci" sans possibilité de déni.

Cette semaine, tu as touché du doigt la magie des mathématiques appliquées. Tu as vu comment une simple paire de nombres premiers pouvait créer une serrure que seule une autre clef peut ouvrir. Comment une fonction à sens unique pouvait sceller un message pour l'éternité.

Mais voici la leçon la plus importante : la cryptographie ne protège pas contre les erreurs humaines. Une passphrase faible, une clef privée copiée dans le cloud, un certificat de révocation perdu – et tout l'édifice s'effondre. La meilleure cryptographie du monde ne vaut rien sans une hygiène opérationnelle rigoureuse.

Tu n'es plus un simple utilisateur qui envoie des emails en clair. Tu es devenu un gardien de secrets. Tu sais créer des clefs, les protéger, les utiliser pour chiffrer, signer, authentifier. Tu comprends la différence entre RSA et Ed25519, entre Web of Trust et PKI, entre chiffrement et signature.

Dans la semaine 43, nous irons plus loin dans la protection. Nous apprendrons à sécuriser le stockage lui-même – pas seulement les communications, mais les données au repos. Nous découvrirons le chiffrement de disque, les volumes sécurisés, la protection des backups.

Mais pour l'instant, pratique. Échange des messages chiffrés avec d'autres Gardiens. Signe tes commits Git. Chiffre tes fichiers sensibles. Fais de la cryptographie une habitude, pas une exception.

Un Gardien qui maîtrise GPG ne laisse jamais ses secrets à la merci des regards indiscrets.

— Platon-Y