Chiffrer et déchiffrer avec AES-GCM en Python
Implémentez un chiffrement authentifié avec une gestion correcte des nonces.
Chiffrer et déchiffrer avec AES-GCM en Python est une leçon Cryptology Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Cryptology Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Cryptology Academy comprend 4 leçons au total.
Pourquoi utiliser AES-GCM ?
AES-GCM est un schéma de chiffrement authentifié avec données associées (AEAD). Il fournit la confidentialité (AES-CTR) ainsi que l'intégrité et l'authenticité (MAC GHASH) en un seul passage : c'est la norme pour le chiffrement moderne.
Composants de GCM : CTR + GHASH
AES-GCM = AES en mode compteur (chiffrement) + MAC polynomial GHASH (authentification). La balise d'authentification de 128 bits couvre à la fois le texte chiffré et les données authentifiées supplémentaires facultatives (AAD).
Exigences relatives aux valeurs uniques
La valeur unique de 96 bits ne doit jamais être réutilisée avec la même clé. La réutilisation d'une valeur unique compromet complètement GCM : un attaquant récupère la clé d'authentification et peut forger des textes chiffrés. Utilisez des valeurs uniques aléatoires ou un compteur avec une rotation des clés.
Chiffrer avec AES-GCM en Python
Utilisation de la couche hazmat :
import os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
# Generate a 256-bit key
key = AESGCM.generate_key(bit_length=256)
aesgcm = AESGCM(key)
# Fresh 96-bit nonce per encryption
nonce = os.urandom(12)
plaintext = b"sensitive payload"
aad = b"user_id=42" # authenticated but not encrypted
ciphertext = aesgcm.encrypt(nonce, plaintext, aad)
print("Nonce:", nonce.hex())
print("Ciphertext+tag:", ciphertext.hex())Déchiffrer avec AES-GCM en Python
Le déchiffrement vérifie automatiquement la balise et lève InvalidTag en cas d'échec :
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from cryptography.exceptions import InvalidTag
# key, nonce, ciphertext, aad from previous step
try:
recovered = aesgcm.decrypt(nonce, ciphertext, aad)
print("Decrypted:", recovered)
except InvalidTag:
print("Authentication failed — ciphertext tampered!")Stocker la valeur unique et le texte chiffré
Ajoutez la valeur unique au début du texte chiffré avant de le stocker. Lors du déchiffrement, séparez-les au 12e octet :
def encrypt_blob(key: bytes, data: bytes, aad: bytes = b"") -> bytes:
aesgcm = AESGCM(key)
nonce = os.urandom(12)
ct = aesgcm.encrypt(nonce, data, aad or None)
return nonce + ct # prepend nonce
def decrypt_blob(key: bytes, blob: bytes, aad: bytes = b"") -> bytes:
aesgcm = AESGCM(key)
nonce, ct = blob[:12], blob[12:]
return aesgcm.decrypt(nonce, ct, aad or None)Données authentifiées supplémentaires (AAD)
Les AAD sont authentifiées, mais pas chiffrées. Utilisez-les pour associer le texte chiffré à son contexte : ID utilisateur, ID d'enregistrement, version de l'API. Cela empêche un attaquant de déplacer un texte chiffré valide vers un autre contexte.
Utiliser l'API de chiffrement de bas niveau
Pour le chiffrement en continu ou sur place, utilisez directement l'API de chiffrement avec le mode GCM :
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
key = os.urandom(32)
nonce = os.urandom(12)
cipher = Cipher(algorithms.AES(key), modes.GCM(nonce))
encryptor = cipher.encryptor()
encryptor.authenticate_additional_data(b"aad-value")
ct = encryptor.update(b"hello world") + encryptor.finalize()
tag = encryptor.tag
print("Tag:", tag.hex())Résistance aux erreurs d'utilisation des valeurs uniques : AES-GCM-SIV
AES-GCM-SIV (RFC 8452) résiste aux erreurs d'utilisation des valeurs uniques : leur réutilisation révèle que deux textes en clair sont identiques, mais l'authenticité reste intacte (NOT). Privilégiez-le lorsque l'unicité des valeurs est difficile à garantir.
Dériver la clé avant le chiffrement
N'utilisez jamais un mot de passe brut comme clé AES. Dérivez une clé avec Argon2 ou HKDF :
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.hazmat.primitives import hashes
import os
master_secret = b"shared_secret_from_ECDH"
salt = os.urandom(16)
kdf = HKDF(algorithm=hashes.SHA256(), length=32, salt=salt, info=b"aes-gcm-key")
aes_key = kdf.derive(master_secret)
print("Derived AES key:", aes_key.hex())Considérations relatives aux performances
L'accélération matérielle AES-NI rend AES-GCM extrêmement rapide (environ 1 à 4 GB/s sur les processeurs modernes). La bibliothèque cryptography pour Python utilise OpenSSL, qui exploite AES-NI. Pour les fichiers de plus de 100 MB, utilisez un traitement en continu par blocs avec l'API de chiffrement de bas niveau.
Vérification des connaissances
Que se passe-t-il si la même valeur unique est utilisée deux fois avec AES-GCM et la même clé ?
Récapitulatif de la leçon
AES-GCM fournit un chiffrement authentifié en un seul passage. Utilisez une nouvelle valeur unique aléatoire de 96 bits pour chaque chiffrement. Ajoutez la valeur unique au début du texte chiffré pour le stockage. Les AAD associent le texte chiffré à son contexte. AES-GCM-SIV résiste à la mauvaise utilisation des valeurs uniques. Dérivez les clés avec HKDF et n'utilisez jamais de mots de passe bruts.
Questions Fréquemment Posées
La leçon « Chiffrer et déchiffrer avec AES-GCM en Python » est-elle gratuite ?
Oui — le texte complet de « Chiffrer et déchiffrer avec AES-GCM en Python » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Cryptology Academy, passe à CoddyKit PRO. Le cours Cryptology Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Chiffrer et déchiffrer avec AES-GCM en Python » ?
Implémentez un chiffrement authentifié avec une gestion correcte des nonces. Tu pratiques Cryptology Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Cryptology Academy ?
Aucune expérience préalable n'est requise. Cryptology Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Chiffrer et déchiffrer avec AES-GCM en Python » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Cryptology Academy ?
Oui. Chaque leçon Cryptology Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Présentation de la bibliothèque de cryptographie Python
- Chiffrer et déchiffrer avec AES-GCM en Python
- Paires de clés RSA et ECDSA en Python
- Pièges courants de la cryptographie Python et pratiques sécurisées