Unsicheres Passwort-Hashing (CWE-916): Warum SHA-256 nicht reicht und wie man Passwörter speichert

Kernkonzepte & Begriffe

Schneller Hash

SHA-256, SHA-1 und MD5 sind auf Geschwindigkeit ausgelegt. Eine einzige moderne GPU berechnet Milliarden SHA-256-Hashes pro Sekunde, sodass kurze oder gängige Passwörter Brute-Force- und Wörterbuchangriffen binnen Stunden erliegen.

Salt

Ein Zufallswert, der mit jedem Hash gespeichert wird, damit gleiche Passwörter verschiedene Hashes ergeben. Ohne ihn knackt eine einzige vorberechnete Tabelle alle Konten auf einmal, und gleiche Hashes verraten Nutzer mit demselben Passwort.

Speicherintensive Funktion (Argon2id)

Argon2id lässt jeden Versuch Zeit und Speicher kosten, was den Großteil des GPU-Vorteils beseitigt. Das OWASP-Minimum sind 19 MiB Speicher, zwei Iterationen und eine Spur (memory_cost=19456, time_cost=2, parallelism=1); scrypt und bcrypt sind vertretbare Alternativen.

PHC-String und Rehash

PasswordHasher.hash() liefert einen String wie $argon2id$v=19$m=19456,t=2,p=1$... mit Algorithmus, Parametern, Salt und Hash. check_needs_rehash() meldet, wenn gespeicherte Parameter schwächer als die aktuellen sind, damit der Hash beim nächsten erfolgreichen Login erneuert wird.

Antwortzeit und Konten-Enumeration

Antworten unbekannte E-Mail-Adressen sofort, während echte die Dauer einer Hash-Prüfung brauchen, verraten die Antwortzeiten, welche Konten existieren. Eine Prüfung gegen einen Schein-Hash lässt beide Wege gleich lange dauern.

Schritt-für-Schritt Angriffsablauf

Quellcode: Verwundbar vs. Sicher

# users.py: ein schneller, ungesalzener Digest pro Passwort
import hashlib

from .db import db


# gleiches Passwort, gleicher Hash, Milliarden Versuche pro Sekunde auf einer 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))


# unbekannte E-Mails antworten sofort, die Zeit verrät also existierende Konten
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 mit Salt pro Passwort und Erneuerung beim Login
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError

from .db import db

# OWASP-Minimum für Argon2id: 19 MiB, 2 Iterationen, 1 Spur
hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
DUMMY_HASH = hasher.hash("timing-equaliser")


# der gespeicherte String enthält Algorithmus, Parameter, Salt und Hash
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)))


# auch Unbekannte kosten eine Prüfung; schwache Hashes werden erneuert
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

Checkliste für Engineering & Systemsicherheit

• Passwörter mit Argon2id (mindestens 19 MiB Speicher, 2 Iterationen, 1 Spur), scrypt oder bcrypt hashen; eine Semgrep-Regel ergänzen, die hashlib-Aufrufe auf Passwortvariablen meldet, und Bandit B324 für MD5 und SHA-1 ausführen.
• Den vollständigen PHC-String speichern, den die Bibliothek liefert, und den Salt nie herauslösen oder wiederverwenden.
• Nach jedem erfolgreichen Login check_needs_rehash() aufrufen und Hashes mit schwächeren Parametern ersetzen.
• Bei nicht existierenden Konten gegen einen Schein-Hash prüfen, damit die Antwortzeit keine registrierten E-Mail-Adressen verrät.
• Mindestens 12 Zeichen verlangen, lange Passphrasen bis mindestens 64 Zeichen erlauben und Passwörter aus Leak-Listen ablehnen.

Quellen

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