SHA-256 vs bcrypt vs Argon2: Wann was verwenden?

"Wenn ich Passwoerter mit SHA-256 hashe und speichere, sollte es sicher sein, oder?"

Viele Entwickler stellen diese Frage. Die Schlussfolgerung ist: Sie sollten SHA-256 nicht fuer Passwoerter verwenden.

Dieser Leitfaden erklaert die Unterschiede zwischen Hashing-Algorithmen und die richtige Wahl fuer jede Situation.

---

Hashing vs Verschluesselung: Grundkonzepte

Hashing

Eingabe → Hash-Funktion → Ausgabe fester Laenge (irreversibel)

"password" → SHA-256 → "5e884898da28047d..."

• Einseitig: Original kann nicht wiederhergestellt werden
• Deterministisch: Gleiche Eingabe = Gleiche Ausgabe
• Feste Laenge: Ausgabegroesse unabhaengig von Eingabegroesse

Verschluesselung

Eingabe + Schluessel → Verschluesselung → Chiffretext → Entschluesselung + Schluessel → Original

"password" + key → AES → "Xyz..." → AES + key → "password"

• Zweiseitig: Original mit Schluessel wiederherstellbar
• Schluesselabhaengig: Kann ohne Schluessel nicht entschluesselt werden

Verwenden Sie Hashing fuer Passwortspeicherung. Sie benoetigen das Original nicht — vergleichen Sie einfach den Eingabewert mit dem Hash.

---

Klassifizierung von Hashing-Algorithmen

Schneller Hash

Langsamer Hash (Passwort-Hash)

---

Warum sollten Sie Passwoerter nicht mit SHA-256 speichern?

Grund 1: Zu schnell

SHA-256 ist fuer Geschwindigkeit konzipiert. Dies ist ein Vorteil fuer Dateiintegritaetspruefungen, aber ein fataler Fehler fuer Passwortspeicherung.

Moderne GPU-Leistung:
- MD5: 180 Milliarden Hashes/Sek
- SHA-256: 10 Milliarden Hashes/Sek
- bcrypt (cost 12): 1.000 Hashes/Sek

Selbst ein komplexes 8-Zeichen-Passwort kann in Minuten geknackt werden, wenn es mit SHA-256 gespeichert wird.

Grund 2: Manuelle Salt-Verwaltung erforderlich

# ❌ Falscher Ansatz
hash = sha256(password)

# Problem: Anfaellig fuer Rainbow-Table-Angriffe

# ⚠️ Verbessert, aber immer noch ungenuegend
salt = generate_random_salt()
hash = sha256(salt + password)

# Problem: Immer noch zu schnell

Grund 3: GPU-Beschleunigungsanfaelligkeit

SHA-256 ist leicht auf GPUs zu parallelisieren. Angreifer koennen Hashes mit wenigen Gaming-GPUs mit enormer Geschwindigkeit berechnen.

---

bcrypt: 27 Jahre bewaehrter Standard

Wie es funktioniert

bcrypt(cost, salt, password) → hash

cost: Anzahl der Berechnungsiterationen (2^cost)
salt: 22-Zeichen-Zufallszeichenkette (automatisch generiert)

Warum ist bcrypt sicher?

1. Absichtlich langsam: Geschwindigkeit durch cost factor kontrolliert
2. Automatisches Salt: Jedes Mal anderer Hash
3. Speicherintensiv: Schwer mit GPU zu beschleunigen

Cost Factor Leitfaden (2026)

Code-Beispiele

// Node.js with bcrypt
const bcrypt = require('bcrypt');

// Hashing (Registrierung)
const hash = await bcrypt.hash(password, 12); // cost 12

// Verifizierung (Login)
const isValid = await bcrypt.compare(inputPassword, storedHash);

# Python with bcrypt
import bcrypt

# Hashing
hashed = bcrypt.hashpw(password.encode(), bcrypt.gensalt(rounds=12))

# Verifizierung
is_valid = bcrypt.checkpw(input_password.encode(), stored_hash)

---

Argon2: Der Standard der naechsten Generation

Was ist Argon2?

Gewinner des Password Hashing Competition 2015. Es ist der von OWASP fuer 2026 empfohlene #1-Algorithmus.

Argon2-Varianten

Argon2-Parameter

Argon2id(memory, iterations, parallelism, password, salt)

- memory: Speichernutzung (KB)
- iterations: Anzahl der Iterationen
- parallelism: Anzahl paralleler Threads

OWASP Empfohlene Einstellungen (2026)

Minimale Einstellungen:
- memory: 64MB (65536 KB)
- iterations: 3
- parallelism: 4

Hohe Sicherheit:
- memory: 256MB
- iterations: 4
- parallelism: 8

Code-Beispiele

// Node.js with argon2
const argon2 = require('argon2');

// Hashing
const hash = await argon2.hash(password, {
  type: argon2.argon2id,
  memoryCost: 65536, // 64MB
  timeCost: 3,
  parallelism: 4
});

// Verifizierung
const isValid = await argon2.verify(storedHash, inputPassword);

# Python with argon2-cffi
from argon2 import PasswordHasher

ph = PasswordHasher(
    memory_cost=65536,
    time_cost=3,
    parallelism=4
)

# Hashing
hash = ph.hash(password)

# Verifizierung
try:
    ph.verify(stored_hash, input_password)
except VerifyMismatchError:
    # Passwort stimmt nicht ueberein

---

bcrypt vs Argon2: Was waehlen?

Vergleichstabelle

Auswahlleitfaden

bcrypt waehlen:

• Legacy-Systemkompatibilitaet erforderlich
• Bewaehrte Stabilitaet bevorzugt
• Einfache Konfiguration bevorzugt

Argon2id waehlen:

• Neues Projekt starten
• Neuesten Sicherheitsstandards folgen
• Hoher GPU-Widerstand erforderlich

2026 Empfehlungsreihenfolge (OWASP)

#1: Argon2id
#2: bcrypt
#3: scrypt
#4: PBKDF2 (wenn Kompatibilitaet erforderlich)

---

Wann SHA-256 verwenden

SHA-256 ist perfekt fuer andere Zwecke als Passwoerter.

Geeignete Anwendungsfaelle

Code-Beispiel

// Datei-Hash (Node.js)
const crypto = require('crypto');
const fs = require('fs');

const fileBuffer = fs.readFileSync('file.zip');
const hash = crypto.createHash('sha256').update(fileBuffer).digest('hex');

console.log(hash); // "a1b2c3d4..."

---

Praktische Implementierungs-Checkliste

Passwortspeicherung

• Argon2id oder bcrypt verwenden
• Angemessenen work factor einstellen (250-500ms)
• Bibliotheks-Auto-Salt-Generierung verwenden
• Vollstaendiges Hash-Ergebnis speichern (einschliesslich Salt)

Passwortverifizierung

• Timing-Attack-sichere Vergleichsfunktionen verwenden
• Konsistente Antwortzeit bei Verifizierungsfehler
• Fehlgeschlagene Login-Versuche begrenzen

Migration

• Schrittweises Upgrade auf neuen Hash
• Re-Hash mit neuem Algorithmus bei erfolgreichem Login
• Prefix verwenden, um alte Hashes zu identifizieren

---

Haeufig gestellte Fragen

F1: Wie gehe ich mit bestehenden Passwoertern um, die mit MD5 gespeichert sind?

A: Re-Hash mit dem neuen Algorithmus, wenn Benutzer sich anmelden.

// Bei erfolgreichem Login
if (hash.startsWith('$md5$')) {
  // Re-Hash mit bcrypt
  const newHash = await bcrypt.hash(inputPassword, 12);
  await updateUserHash(userId, newHash);
}

F2: Ist die 72-Byte-Grenze von bcrypt kein Problem?

A: Die meisten Passwoerter liegen innerhalb von 72 Bytes. Fuer laengere Eingaben hashen Sie zuerst mit SHA-256, dann wenden Sie bcrypt an.

// Umgang mit langen Passwoertern
const prehash = crypto.createHash('sha256').update(password).digest('base64');
const finalHash = await bcrypt.hash(prehash, 12);

F3: Macht ein hoher cost factor Sie nicht anfaellig fuer DoS-Angriffe?

A: Ja. Implementieren Sie Rate-Limiting bei Login-Anfragen. 250-500ms ist das angemessene Gleichgewicht.

F4: Ist pepper notwendig?

A: Pepper (geheimer Schluessel auf Anwendungsebene) bietet zusaetzliche Sicherheit, ist aber nicht erforderlich. Salt allein reicht aus.

F5: Kann ich Online-Hash-Tools verwenden?

A: Nur fuer Lern-/Testzwecke verwenden. In der Produktion muss das Hashing serverseitig erfolgen. Der Hash-Generator ist sicher, da er 100% clientseitig verarbeitet.

---

Fazit

Schluesselprinzipien:

1. Niemals schnelle Hashes (SHA-256, MD5) fuer Passwoerter verwenden
2. bcrypt cost 12+, Argon2 memory 64MB+
3. Bibliotheksbereitgestellte Auto-Salt-Generierung verwenden

---

Verwandte Tools