PBKDF2-Hash-Generator
Mach aus einem Passwort und einem Salt einen mit PBKDF2 abgeleiteten Schlüssel – mit Hashfunktion, Iterationszahl und Schlüssellänge deiner Wahl. Die Ergebnisse erscheinen als Hex und Base64 zusammen mit fertig codierten Strings, den ersten Rechenschritten und passendem Python- und Node.js-Code. Der Schlüssel wird von der Web Crypto API deines Browsers berechnet und verlässt die Seite nie.
Zuletzt aktualisiert:
Rechenschritte
Codierte Hash-Strings
Code zum Nachbauen dieses Schlüssels
Anleitung: PBKDF2-Hash-Generator
- Gib das Passwort als Klartext ein (als UTF-8 codiert) oder wechsle für rohe Bytes zu Hex.
- Lege den Salt fest: Behalte den zufälligen 16-Byte-Salt, klicke auf „Neuer zufälliger Salt“ oder gib deinen eigenen als Text, Hex oder Base64 ein.
- Wähle Hash, Iterationen und Schlüssellänge oder eine Voreinstellung wie OWASP SHA-256 (600,000 Iterationen) oder WLAN WPA2 (SHA-1, 4,096 Iterationen, 32 Bytes).
- Klicke auf „Schlüssel erzeugen“ (er aktualisiert sich auch beim Tippen) und kopiere den Hex-, Base64- oder codierten String, den du brauchst.
- Um einen gespeicherten Wert zu prüfen, füge ihn bei „Erwarteter Schlüssel“ ein: Das Tool zeigt dir, ob er übereinstimmt.
- Öffne die Bereiche mit Schritten und Code, um zu sehen, wie der Schlüssel entstanden ist, und ihn in Python oder Node.js nachzubauen.
So funktioniert PBKDF2
PBKDF2 ist in RFC 8018 (PKCS #5 v2.1) spezifiziert. Es nimmt ein Passwort P, einen Salt S, eine Iterationszahl c und eine gewünschte Schlüssellänge dkLen und nutzt HMAC mit einer Hashfunktion als Pseudozufallsfunktion (PRF). Mit hLen = Ausgabegröße des Hashs:
- Ausgabe in Blöcke teilen: l = ⌈dkLen ÷ hLen⌉. Ein 32-Byte-Schlüssel mit HMAC-SHA256 braucht einen Block, ein 64-Byte-Schlüssel mit HMAC-SHA256 zwei.
- Erste Runde jedes Blocks: U1 = HMAC(P, S ‖ INT(i)), wobei INT(i) die Blocknummer i als 4-Byte-Big-Endian-Ganzzahl ist (00000001 für den ersten Block).
- Iterieren: Uj = HMAC(P, Uj−1) für j = 2 … c.
- Falten: Ti = U1 ⊕ U2 ⊕ … ⊕ Uc (bitweises XOR aller Runden).
- Ausgabe: DK = T1 ‖ T2 ‖ … ‖ Tl, gekürzt auf die ersten dkLen Bytes.
Die Gesamtkosten betragen c × l HMAC-Aufrufe (jedes HMAC sind zwei oder mehr Hash-Kompressionen). Da das Passwort in jeder Runde der HMAC-Schlüssel ist, muss ein Angreifer, der einen Versuch testen will, ebenfalls alle c Runden wiederholen. Der Salt macht die Arbeit für jeden Nutzer einzigartig, sodass eine vorberechnete Tabelle nicht viele Konten abdecken kann.
Empfohlene Einstellungen
| Hash (PRF) | Ausgabegröße (hLen) | OWASP-Iterationen (2023) | Natürliche Schlüssellänge |
|---|---|---|---|
| HMAC-SHA1 | 20 Bytes (160 Bit) | 1,300,000 | 20 Bytes |
| HMAC-SHA256 | 32 Bytes (256 Bit) | 600,000 | 32 Bytes |
| HMAC-SHA512 | 64 Bytes (512 Bit) | 210,000 | 64 Bytes |
Die Werte stammen aus dem OWASP Password Storage Cheat Sheet in der Fassung von 2023 und sollen erhöht werden, wenn Hardware schneller wird. NIST SP 800-132 (2010) setzt 1,000 Iterationen als Untergrenze und verlangt einen zufälligen Salt von mindestens 128 Bit. Halte die Schlüssellänge beim Speichern von Passwort-Hashes höchstens bei der Ausgabegröße des Hashs; für Verschlüsselungsschlüssel leite genau das ab, was die Chiffre braucht (32 Bytes für AES-256).
Testvektoren zur Prüfung einer Implementierung
| Quelle | Eingaben | Abgeleiteter Schlüssel (Hex) |
|---|---|---|
| RFC 6070 | HMAC-SHA1, P = “password”, S = “salt”, c = 1, dkLen = 20 | 0c60c80f961f0e71f3a9b524af6012062fe037a6 |
| RFC 6070 | HMAC-SHA1, P = “password”, S = “salt”, c = 4096, dkLen = 20 | 4b007901b765489abead49d926f721d065a429c1 |
| Gängiger SHA-256-Vektor | HMAC-SHA256, P = “password”, S = “salt”, c = 1, dkLen = 32 | 120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b |
| Gängiger SHA-256-Vektor | HMAC-SHA256, P = “password”, S = “salt”, c = 4096, dkLen = 32 | c5e478d59288c841aa530db6845c4c8d962893a001ce4e11a4963873aa98134a |
| IEEE 802.11i (WPA2) | HMAC-SHA1, Passphrase „password“, SSID „IEEE“, c = 4096, dkLen = 32 | f42c6fc52df0ebef9ebb4b90b38a5f902e83fe1b135a70e23aed762e9710a12e |
Wenn dein Code von diesen Werten abweicht, sind die üblichen Ursachen: der Salt als Text eingegeben, obwohl das System Hex-Bytes erwartet (oder umgekehrt), ein abschließender Zeilenumbruch im Passwort, eine andere Textcodierung als UTF-8 oder der Vergleich eines Hex-Strings mit einem Base64-String.
Wo PBKDF2 eingesetzt wird
- Passwortspeicherung: Der Standard-Hasher von Django (pbkdf2_sha256), Werkzeug/Flask, passlib und viele FIPS-validierte Systeme.
- WLAN: WPA2-Personal macht aus deiner Passphrase den 256-Bit-Pre-Shared-Key mit PBKDF2-HMAC-SHA1, 4,096 Iterationen und dem Netzwerknamen als Salt.
- Verschlüsselte Dateien und Tresore: Passwortgeschützte Archive, Festplattenverschlüsselung und Passwortmanager leiten ihren Verschlüsselungsschlüssel mit PBKDF2 oder einer neueren Funktion aus dem Master-Passwort ab.
- Browser: Die Web Crypto API stellt PBKDF2 nativ bereit, und genau das nutzt diese Seite.
Für ganz neue Passwortspeicherung ohne Compliance-Vorgaben widersteht eine speicherintensive Funktion wie Argon2id oder bcrypt GPU-Cracking bei gleichem Zeitaufwand besser als PBKDF2.
Häufige Fragen
Was ist PBKDF2?
PBKDF2 (Password-Based Key Derivation Function 2) ist in PKCS #5 definiert, heute RFC 8018. Es macht aus einem Passwort und einem Salt einen Schlüssel beliebiger Länge, indem es eine Pseudozufallsfunktion, normalerweise HMAC mit SHA-1, SHA-256 oder SHA-512, tausendfach ausführt. Die Wiederholung macht jeden Passwortversuch für einen Angreifer langsam.
Wie wird ein PBKDF2-Schlüssel berechnet?
Die Ausgabe wird in Blöcke von der Größe des Hashs aufgeteilt. Für Block i gilt U1 = HMAC(P, S ‖ INT(i)), wobei INT(i) die Zahl i als 4-Byte-Big-Endian-Zahl ist, dann U2 = HMAC(P, U1) und so weiter bis Uc. Der Block ist T_i = U1 ⊕ U2 ⊕ … ⊕ Uc. Die Blöcke werden aneinandergehängt und auf die gewünschte Schlüssellänge gekürzt.
Wie viele Iterationen sollte ich verwenden?
Das OWASP Password Storage Cheat Sheet (2023) empfiehlt 600,000 Iterationen für PBKDF2-HMAC-SHA256, 210,000 für PBKDF2-HMAC-SHA512 und 1,300,000 für PBKDF2-HMAC-SHA1. NIST SP 800-132 legt 1,000 als absolutes Minimum fest. Wähle die höchste Anzahl, die dein Server verkraftet, und erhöhe sie mit der Zeit.
Wie lang sollte der Salt sein?
NIST SP 800-132 verlangt einen Salt von mindestens 128 Bit (16 Bytes) aus einem sicheren Zufallsgenerator, einzigartig für jedes Passwort. Der Salt ist nicht geheim: Er wird neben dem Hash gespeichert, damit derselbe Schlüssel beim Login erneut abgeleitet werden kann.
Warum sollte die Schlüssellänge bei Passwörtern die Ausgabegröße des Hashs nicht überschreiten?
Wenn du mehr Bytes anforderst, als der Hash liefert (zum Beispiel 64 Bytes von SHA-256), durchläuft PBKDF2 für jeden zusätzlichen Block die gesamte Iterationsschleife erneut, ein Angreifer braucht aber nur den ersten Block, um einen Versuch zu prüfen. Dein Server leistet doppelte Arbeit ohne zusätzliche Sicherheit. Nutze SHA-512, wenn du 64 Bytes brauchst.
Ist PBKDF2 im Vergleich zu bcrypt oder Argon2 noch sicher?
PBKDF2 ist weiterhin von NIST zugelassen und für FIPS-140-Konformität erforderlich, braucht aber sehr wenig Speicher, sodass GPUs und Spezialhardware Versuche günstig parallel testen können. Für neue Passwortspeicherung bevorzugt OWASP Argon2id, dann scrypt oder bcrypt; nutze PBKDF2 mit hoher Iterationszahl, wo Compliance oder Kompatibilität es verlangen.
Wird mein Passwort an einen Server gesendet?
Nein. Der Schlüssel wird mit crypto.subtle.deriveBits in deinem eigenen Browser abgeleitet. Passwort, Salt und Ergebnis werden nicht hochgeladen, protokolliert oder gespeichert.
Werden alle Tools auf FreeToolCabin auf Qualität und Genauigkeit getestet?
Ja. Jedes Tool auf der Website durchläuft automatische Tests in echten Browsern, die prüfen, ob das Ergebnis stimmt und keine Fehler auftreten. Wenn du einen Fehler findest oder einen Vorschlag hast, schreib uns an [email protected] – wir sehen es uns an.