Argon2id vs PBKDF2 vs bcrypt pour la dérivation de clé

Qu'est-ce qu'un KDF ?

Un KDF (Key Derivation Function) transforme un secret de faible entropie (mot de passe, fingerprint hardware) en une clé cryptographique de haute entropie. La propriété essentielle : le calcul doit être délibérément lent et coûteux pour rendre les attaques par dictionnaire et brute-force prohibitives.

Un KDF mal choisi transforme votre chiffrement AES-256-GCM solide en une porte ouverte : si la clé est dérivée rapidement, un GPU moderne peut tester des milliards de variantes par seconde.

PBKDF2 (2000)

PBKDF2 (Password-Based Key Derivation Function 2) est le KDF standard de référence depuis RFC 2898. Il applique une fonction de hachage itérativement un nombre configurable de fois.

• Avantages : standardisé NIST, FIPS 140-2 certifiable, disponible partout.
• Limites critiques : ne consomme quasiment pas de mémoire. Un GPU peut paralléliser massivement PBKDF2. Avec 100 000 itérations SHA-256, un RTX 4090 teste ~1 milliard de mots de passe par seconde.

bcrypt (1999)

bcrypt utilise l'algorithme Blowfish avec un facteur de coût configurable (2^cost itérations). Il est plus résistant aux GPUs que PBKDF2 mais limité à des mots de passe de 72 bytes maximum.

• Avantages : très répandu, bon track record sur 25 ans.
• Limites : 72 bytes max, pas optimal pour dériver des clés AES-256, mémoire toujours faible, GPUs récents le craquent 10× plus vite qu'en 2010.

Argon2id (2015)

Argon2 est le winner du Password Hashing Competition 2015. Il existe en trois variantes — Argon2i (résistant aux side-channels), Argon2d (résistant aux GPUs), et Argon2id (hybride recommandé). Ses paramètres sont :

• Memory cost : quantité de RAM requise (64 MB dans IronLock v2). Rend l'attaque GPU impraticable : un GPU a peu de RAM par core.
• Time cost : nombre d'itérations (3 par défaut).
• Parallelism : nombre de threads (4 par défaut).

Comparatif

Critère	Argon2id	bcrypt	PBKDF2-SHA256
Année	2015	1999	2000
Memory-hard	✓ configurable	✗	✗
Résistance GPU	Très haute	Moyenne	Faible
Résistance ASIC	Haute	Moyenne	Faible
Taille entrée max	Illimitée	72 bytes	Illimitée
Taille sortie	Variable	192 bits fixe	Variable
FIPS 140-2	Non	Non	Oui
OWASP recommandé	✓ Premier choix	Acceptable	Si FIPS requis

Implémentation Python

from argon2.low_level import hash_secret_raw, Type
import os

def derive_key_argon2id(
    secret: bytes,
    salt: bytes = None,
    key_len: int = 32,
    memory_cost: int = 65536,  # 64 MB
    time_cost: int = 3,
    parallelism: int = 4
) -> bytes:
    if salt is None:
        salt = os.urandom(16)
    
    key = hash_secret_raw(
        secret=secret,
        salt=salt,
        time_cost=time_cost,
        memory_cost=memory_cost,
        parallelism=parallelism,
        hash_len=key_len,
        type=Type.ID  # Argon2id
    )
    return key, salt

# Usage dans IronLock
hw_fingerprint = get_hardware_fingerprint()  # bytes
aes_key, salt  = derive_key_argon2id(hw_fingerprint)
# aes_key → chiffrement AES-256-GCM
# aes_key effacée de la mémoire après usage

Dans IronLock v2

IronLock v2 utilise Argon2id avec memory=64MB, time=3, parallelism=4 pour dériver la clé AES-256 à partir du fingerprint hardware. Le sel est stocké en clair dans le header .ironenc (pas besoin d'être secret — il rend chaque dérivation unique). La clé dérivée n'est jamais persistée sur disque ; elle vit uniquement en mémoire le temps du déchiffrement, puis est effacée.

Conclusion

Pour tout nouveau projet en 2026, Argon2id est le seul bon choix de KDF. PBKDF2 reste acceptable uniquement sous contrainte FIPS. bcrypt est en fin de vie pour les nouveaux développements. La migration d'IronLock v1 (PBKDF2-SHA256, 100 000 itérations) vers v2 (Argon2id 64MB) rend une attaque GPU ~62 000× plus coûteuse.