# Algorithmes symétriques
AES (Advanced Encryption Standard) : standard actuel, clés 128/192/256 bits
ChaCha20-Poly1305                  : alternative moderne, rapide sans accélération matérielle (mobile)
DES / 3DES                          : OBSOLÈTES, clé trop courte (56 bits), ne plus utiliser

# Modes d'opération (comment appliquer le chiffrement bloc par bloc)
ECB : Electronic Codebook   -> JAMAIS utiliser (motifs visibles, pas de diffusion)
CBC : Cipher Block Chaining -> nécessite un IV aléatoire unique par message
GCM : Galois/Counter Mode   -> AEAD (chiffre ET authentifie), RECOMMANDÉ par défaut

# AES-256-GCM avec la librairie cryptography (mode AEAD : confidentialité + intégrité)
import os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

key = AESGCM.generate_key(bit_length=256)  # à stocker dans un coffre-fort de secrets (vault)
aesgcm = AESGCM(key)

nonce = os.urandom(12)  # 96 bits, DOIT être unique pour chaque chiffrement avec la même clé
plaintext = b"Numero de carte: XXXX-XXXX-XXXX-1234"
associated_data = b"user_id=42"  # authentifié mais pas chiffré (ex: métadonnées de routage)

ciphertext = aesgcm.encrypt(nonce, plaintext, associated_data)

# Le déchiffrement échoue (exception) si le ciphertext, le nonce ou l'AAD ont été altérés
decrypted = aesgcm.decrypt(nonce, ciphertext, associated_data)
assert decrypted == plaintext

# Piège classique : réutiliser un nonce avec la même clé casse TOTALEMENT la sécurité de GCM
# (permet de retrouver le keystream et de forger des messages)
import os

def encrypt_record(aesgcm, plaintext: bytes, aad: bytes) -> dict:
    nonce = os.urandom(12)  # généré à CHAQUE appel, jamais réutilisé ni codé en dur
    ciphertext = aesgcm.encrypt(nonce, plaintext, aad)
    return {"nonce": nonce.hex(), "ciphertext": ciphertext.hex()}

# Stocker nonce + ciphertext ensemble (le nonce n'est pas secret, juste unique)

# Dérivation de clé à partir d'un mot de passe utilisateur (jamais utiliser le mot de passe brut comme clé)
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives import hashes
import os

def derive_key_from_password(password: str, salt: bytes | None = None) -> tuple[bytes, bytes]:
    salt = salt or os.urandom(16)
    kdf = PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt=salt, iterations=600_000)
    key = kdf.derive(password.encode())
    return key, salt

# Chiffrement symétrique en ligne de commande avec openssl (ex: sauvegarde chiffrée d'un dump SQL)
openssl enc -aes-256-gcm -salt -pbkdf2 -iter 200000   -in backup_technologik.sql -out backup_technologik.sql.enc -pass file:./backup.key

# Déchiffrement
openssl enc -d -aes-256-gcm -pbkdf2 -iter 200000   -in backup_technologik.sql.enc -out backup_technologik.sql -pass file:./backup.key

# Chiffrement au repos vs en transit
Au repos (at rest)  : disque, base de données, sauvegardes -> AES-256, gestion de clé via KMS/Vault
En transit           : réseau -> TLS 1.2/1.3 (voir leçon dédiée asymétrique/TLS)

# Rotation des clés : ne jamais garder la même clé indéfiniment
1. Générer une nouvelle clé (versionnée: key_v2)
2. Chiffrer les nouvelles données avec key_v2
3. Re-chiffrer progressivement les anciennes données (rewrap) en tâche de fond
4. Révoquer key_v1 une fois la migration terminée et auditée