Argon2 CFFI Python : hachage de mots de passe…

Qu'est-ce qu'argon2-cffi

La bibliothèque argon2-cffi est un wrapper Python officiel pour l'algorithme de hachage de mots de passe Argon2, implémenté via l'interface CFFI (C Foreign Function Interface). Argon2 est un algorithme de hachage moderne qui a remporté le concours Password Hashing Competition en 2015 et est depuis considéré comme la référence en matière de stockage sécurisé des mots de passe.

Le principal avantage d'argon2-cffi réside dans ses performances élevées grâce à l'implémentation en C, tout en offrant une interface Python pratique. La bibliothèque est activement maintenue par la communauté et régulièrement mise à jour selon les dernières normes de sécurité.

Installation et configuration

Installation standard

pip install argon2-cffi

Installation avec dépendances supplémentaires

pip install argon2-cffi[dev]  # pour le développement
pip install argon2-cffi[tests]  # pour les tests

Vérification de l'installation

import argon2
print(argon2.__version__)

Variantes de l'algorithme Argon2

Argon2i (Data-Independent)

Argon2i est optimisé pour la protection contre les attaques par canaux auxiliaires (side-channel attacks). Il accède à la mémoire indépendamment du contenu du mot de passe, ce qui le rend résistant aux attaques temporelles. Recommandé pour les scénarios où la protection contre l'analyse temporelle est cruciale.

Argon2d (Data-Dependent)

Argon2d offre une protection maximale contre les attaques GPU et les attaques utilisant du matériel spécialisé. Il utilise des accès mémoire dépendants des données, ce qui rend le parallélisme des attaques plus difficile. Cependant, il est moins protégé contre les attaques par canaux auxiliaires.

Argon2id (Hybride)

Argon2id est un mode hybride qui combine les avantages des deux variantes. Il est utilisé par défaut dans argon2-cffi et recommandé pour la plupart des applications. Les premières passes s'exécutent comme Argon2i, et les suivantes comme Argon2d.

Démarrage rapide

Utilisation de base

from argon2 import PasswordHasher

# Création d'une instance du hasher
ph = PasswordHasher()

# Hachage d'un mot de passe
password = "mon_mot_de_passe_tres_secret"
hash_result = ph.hash(password)
print(f"Hash : {hash_result}")

# Vérification du mot de passe
try:
    ph.verify(hash_result, password)
    print("Mot de passe correct !")
except Exception as e:
    print(f"Mot de passe incorrect : {e}")

Travail avec différents types de données

from argon2 import PasswordHasher

ph = PasswordHasher()

# Hachage d'une chaîne de caractères
string_hash = ph.hash("mot_de_passe_texte")

# Hachage d'octets
bytes_password = b"mot_de_passe_octets"
bytes_hash = ph.hash(bytes_password)

# Vérification
ph.verify(string_hash, "mot_de_passe_texte")
ph.verify(bytes_hash, bytes_password)

Configuration de PasswordHasher

Paramètres du constructeur

from argon2 import PasswordHasher, Type

ph = PasswordHasher(
    time_cost=3,        # Nombre d'itérations (par défaut 2)
    memory_cost=65536,  # Mémoire en KB (par défaut 51200)
    parallelism=2,      # Nombre de threads (par défaut 1)
    hash_len=32,        # Longueur du hash en octets (par défaut 32)
    salt_len=16,        # Longueur du sel en octets (par défaut 16)
    encoding="utf-8",   # Encodage (par défaut "utf-8")
    type=Type.ID        # Type Argon2 (par défaut Type.ID)
)

Impact des paramètres sur la sécurité

time_cost augmente le temps d'exécution de manière linéaire. Chaque incrémentation de 1 double le temps de hachage.

memory_cost détermine la quantité de mémoire en kilo-octets. Des valeurs élevées rendent les attaques avec du matériel spécialisé plus difficiles.