Hachage de mots de passe non sécurisé (CWE-916) : pourquoi SHA-256 ne suffit pas et comment stocker les mots de passe

Concepts Clés et Termes

Hachage rapide

SHA-256, SHA-1 et MD5 sont conçus pour être rapides. Un seul GPU moderne calcule des milliards d'empreintes SHA-256 par seconde, donc les mots de passe courts ou courants tombent en quelques heures face à la force brute et aux attaques par dictionnaire.

Sel

Une valeur aléatoire stockée avec chaque empreinte pour que des mots de passe identiques donnent des empreintes différentes. Sans sel, une seule table précalculée casse tous les comptes d'un coup, et des empreintes égales révèlent les utilisateurs qui partagent un mot de passe.

Fonction coûteuse en mémoire (Argon2id)

Argon2id fait coûter chaque essai en temps et en mémoire, ce qui supprime l'essentiel de l'avantage d'un GPU. Le minimum OWASP est de 19 Mio de mémoire, deux itérations et une voie (memory_cost=19456, time_cost=2, parallelism=1) ; scrypt et bcrypt sont des alternatives acceptables.

Chaîne PHC et re-hachage

PasswordHasher.hash() renvoie une chaîne telle que $argon2id$v=19$m=19456,t=2,p=1$... contenant l'algorithme, les paramètres, le sel et l'empreinte. check_needs_rehash() signale quand les paramètres stockés sont plus faibles que les actuels, pour mettre à niveau l'empreinte à la prochaine connexion réussie.

Temps de réponse et énumération de comptes

Si les e-mails inconnus répondent instantanément alors que les vrais prennent le temps d'une vérification d'empreinte, les temps de réponse révèlent quels comptes existent. Vérifier contre une empreinte factice fait durer les deux chemins le même temps.

Déroulement de l'Attaque Étape par Étape

Code Source : Vulnérable vs Sécurisé

# users.py : une empreinte rapide et sans sel par mot de passe
import hashlib

from .db import db


# même mot de passe, même empreinte, des milliards d'essais par seconde sur GPU
def create_user(email: str, password: str) -> None:
    digest = hashlib.sha256(password.encode()).hexdigest()
    db.execute("INSERT INTO users (email, password_hash) VALUES (?, ?)", (email, digest))


# les e-mails inconnus répondent tout de suite, le temps révèle donc les comptes existants
def check_login(email: str, password: str) -> bool:
    row = db.execute("SELECT password_hash FROM users WHERE email = ?", (email,)).fetchone()
    return row is not None and row[0] == hashlib.sha256(password.encode()).hexdigest()

# users.py : Argon2id avec un sel par mot de passe et mise à niveau à la connexion
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError

from .db import db

# minimum OWASP pour Argon2id : 19 Mio, 2 itérations, 1 voie
hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
DUMMY_HASH = hasher.hash("timing-equaliser")


# la chaîne stockée contient algorithme, paramètres, sel et empreinte
def create_user(email: str, password: str) -> None:
    if not 12 <= len(password) <= 128:
        raise ValueError("password must be 12 to 128 characters")
    db.execute("INSERT INTO users (email, password_hash) VALUES (?, ?)", (email, hasher.hash(password)))


# les inconnus paient aussi une vérification ; les empreintes faibles sont mises à niveau
def check_login(email: str, password: str) -> bool:
    row = db.execute("SELECT id, password_hash FROM users WHERE email = ?", (email,)).fetchone()
    stored = row[1] if row else DUMMY_HASH
    try:
        hasher.verify(stored, password)
    except (VerificationError, InvalidHashError):
        return False
    if row is None:
        return False
    if hasher.check_needs_rehash(stored):
        db.execute("UPDATE users SET password_hash = ? WHERE id = ?", (hasher.hash(password), row[0]))
    return True

Liste de Contrôle de Sécurité pour l'Ingénierie

• Hachez les mots de passe avec Argon2id (au moins 19 Mio de mémoire, 2 itérations, 1 voie), scrypt ou bcrypt ; ajoutez une règle Semgrep qui signale les appels hashlib sur des variables de mot de passe et exécutez Bandit B324 pour MD5 et SHA-1.
• Stockez la chaîne PHC complète renvoyée par la bibliothèque, sans jamais extraire ni réutiliser le sel.
• Appelez check_needs_rehash() après chaque connexion réussie et remplacez les empreintes créées avec des paramètres plus faibles.
• Vérifiez contre une empreinte factice quand le compte n'existe pas, pour que le temps de réponse ne révèle pas les e-mails inscrits.
• Exigez au moins 12 caractères, acceptez les longues phrases de passe jusqu'à au moins 64 et refusez les mots de passe présents dans des listes de fuites.

Sources

• CWE-916: Use of Password Hash With Insufficient Computational Effort
• OWASP Password Storage Cheat Sheet
• argon2-cffi — PasswordHasher
• RFC 9106 — Argon2 Memory-Hard Function