Passwort-Hash-Generator & -Prüfer

Passwörter mit bcrypt, scrypt, Argon2id und PBKDF2 vollständig in Ihrem Browser hashen und prüfen — PHC-Format-Zeichenketten erzeugen, ein Kandidatenpasswort gegen einen vorhandenen Hash prüfen und die darin verborgenen Parameter ansehen. Nichts wird hochgeladen.
Nur für Testpasswörter. Echte Benutzerpasswörter sollten niemals in eine Webseite eingefügt werden. Dieses Werkzeug läuft vollständig in Ihrem Browser — die Zeichenketten verlassen Ihren Tab nie — aber ein echter Datenabfluss beginnt mit einem einzigen Einfügen.
bcrypt-Aufwand (2^Aufwand Runden)
bcrypt-Variante die Variante ändert nur das Präfix; der Hash selbst ist identisch
scrypt N (CPU-Aufwand)
scrypt r / p r =   p = Blockgröße 128·r Byte; Speicher = 128·N·r Byte (N=214, r=8 → 16 MiB)
Argon2id m (Speicher)
Argon2id t / p t =   p = t = Durchläufe; p = Parallelität (Lanes)
PBKDF2-PRF
PBKDF2-Iterationen  OWASP 2023: 600.000 für HMAC-SHA-256 (1.300.000 für SHA-1, 210.000 für SHA-384/512)
Ausgabelänge (Byte)  bcrypt-Ausgabe ist fest auf 23 Byte (31 bcrypt-Base64-Zeichen) festgelegt
AlgorithmusParameterSpeicherAusgabelängeZeit (dieser Browser)
bcryptAufwand 124 KiB23 Byte-
scryptN=214, r=8, p=116 MiB32 Byte-
Argon2idm=19 MiB, t=2, p=119 MiB32 Byte-
PBKDF2HMAC-SHA-256, 600.000 Iterationen~032 Byte-
Parameter-Spickzettel (OWASP Password Storage Cheat Sheet, Minimalwerte 2023)
AlgorithmusMinimumHinweise
Argon2idm = 19 MiB (19.456 KiB), t = 2, p = 1bevorzugt; speicherhart
scryptN = 214, r = 8, p = 1speicherhart (mindestens 16 MiB)
bcryptAufwand = 10nur Aufwandsfaktor; Passwortgrenze 72 Byte
PBKDF2-HMAC-SHA256600.000 Iterationennur iterationshart — GPU-freundlich, letzte Wahl
Die Standardwerte auf dieser Seite liegen auf oder über jedem Minimum. Für den Produktivbetrieb wählen Sie zuerst Argon2id, scrypt oder bcrypt, falls es nicht verfügbar ist, PBKDF2 nur aus Gründen der FIPS-Konformität.
PHP-Interoperabilität — password_hash($pw, PASSWORD_BCRYPT) liefert $2y$10$...: Fügen Sie das bei „Prüfen“ zusammen mit dem Kandidatenpasswort ein, und diese Seite beantwortet genau das, was password_verify() antworten würde. Ausgaben von PASSWORD_ARGON2ID ($argon2id$v=19$m=65536,t=4,p=1$...) werden ebenfalls geprüft. PHC-Zeichenketten aus passlib, django-argon2 und der crypto.scrypt-Verpackung werden ebenfalls geparst.
Selbsttest
Führt die Seitenengine erneut gegen öffentliche Vektoren aus: die crypt_blowfish-Testsuite für bcrypt, mit node/OpenSSL erzeugte scrypt- und Argon2id-Zeichenketten, die PBKDF2-Vektoren aus RFC 6070 und der öffentliche SHA-256-Satz, dazu Erzeugen-und-Prüfen-Hin- und Rückrechnungen in jedem Algorithmus sowie Negativtests (ein falsches Passwort muss fehlschlagen, fehlerhafte Zeichenketten müssen abgelehnt werden). Nichts wird irgendwohin gesendet.
Passwort-Hashing von Grund auf erklärt
In einem Satz: Ein Passwort-Hash ist absichtlich langsam (und möglichst speicherhungrig), damit ein Angreifer bei einem Diebstahl der Datenbank nicht Milliarden Versuche pro Sekunde durchführen kann — das Gegenteil des Ziels eines schnellen Hashes wie SHA-256, der auf Geschwindigkeit ausgelegt ist.
Warum nicht einfach das Passwort mit SHA-256 hashen?

SHA-256 auf einer modernen GPU läuft mit Milliarden Versuchen pro Sekunde. Ein 8-Zeichen-Passwort hat deutlich weniger als 1013 Kombinationen — Stunden GPU-Zeit, Minuten auf einer großen Anlage. Passwort-Hashfunktionen (KDFs) wehren das mit Aufwandsparametern ab: bcrypt wiederholt seinen Kern 2cost-mal, PBKDF2 iteriert HMAC Hunderttausende Male, scrypt und Argon2id verlangen zusätzlich Megabyte an Speicher pro Versuch, sodass GPUs (schnell, aber pro Kern speicherarm) ihren Vorteil verlieren. Ein Salz — zufällig und im Klartext im Hash-String gespeichert — verhindert vorberechnete Regenbogentabellen und zwingt jeden Versuch, für jeden Benutzer neu berechnet zu werden.

Die vier Algorithmen auf dieser Seite
AlgorithmusJahrHärteSignaturformatAchtung bei
bcrypt1999CPU (2Aufwand Schlüsselinitialisierungen)$2b$12$ + 22-Zeichen-Salz + 31-Zeichen-HashPasswortgrenze 72 Byte (alles darüber wird stillschweigend ignoriert); ein NUL-Byte beendet das Passwort in der ursprünglichen C-Implementierung
PBKDF22000 (RFC 2898/8018)CPU (Iterationen)$pbkdf2-sha256$i=600000$ + Salz + Hash (passlib-Stil)kein Speicheraufwand — GPUs und ASICs lieben es; nur die Iterationszahl ist einstellbar
scrypt2009 (RFC 7914)CPU + Speicher (128·N·r Byte)$scrypt$ln=14,r=8,p=1$ + Salz + HashN muss eine Zweierpotenz sein; der Speicher wächst linear mit r
Argon2id2015 (PHC-Gewinner, RFC 9106)CPU + Speicher (m KiB, t Durchläufe)$argon2id$v=19$m=19456,t=2,p=1$ + Salz + HashArgon2i (datenunabhängig) gegen Argon2d (datenabhängig) gegen Argon2id (hybrid) — wählen Sie immer id, außer Sie wissen, warum nicht
Speicherhärte gegen Rechenhärte

Eine GPU hat Tausende Kerne, doch jeder Kern hat nur wenig schnellen Speicher. Eine KDF, die 19 MiB Arbeitsspeicher pro Versuch braucht, begrenzt einen Angreifer auf so viele parallele Versuche, wie er 19-MiB-Speicherblöcke hat — deshalb kann Argon2id mit 19 MiB in der Praxis stärker sein als bcrypt mit Aufwand 15, obwohl es auf Ihrem Laptop weniger Zeit braucht. PBKDF2 hat darauf keine Antwort: Sein einziger Regler ist die Iterationszahl, und Hardware skaliert diese linear.

Eine PHC-Zeichenkette lesen

Das Modular-Crypt- bzw. PHC-Format beschreibt sich selbst: In $argon2id$v=19$m=19456,t=2,p=1$ICEiIyQlJicoKSorLC0uLw$WTGpK4hf... sind die Felder Algorithmus, Version, Parameter (m = Speicher in KiB, t = Durchläufe, p = Lanes), Base64-Salz und Base64-Hash. bcrypt ist älter als der Standard und hat seine eigene kompakte Form: Variante $2b$, dann 12 als Aufwand, dann Salz und Hash im eigenen Base64-Alphabet von bcrypt (./A-Za-z0-9). Die Prüfung dieser Seite akzeptiert all diese Formen und zeigt die geparsten Felder — fügen Sie einen beliebigen gefundenen Hash ein und sehen Sie, wie er zerlegt wird.

Häufige Fehler
  • Schneller Hash für Passwörter. Passwort-Spalten mit MD5/SHA-1/SHA-256 fallen handelsüblichen GPUs mit Milliarden Versuchen pro Sekunde zum Opfer. Verwenden Sie den Hash-Generator für Dateien und Daten; für Passwörter die Algorithmen dieser Seite.
  • Ein Salz teilen. Ein gemeinsames Salz für alle Benutzer bedeutet, dass gleiche Passwörter gleiche Hashes haben und Regenbogentabellen wieder funktionieren. Jeder Hash hier erhält ein frisches zufälliges 16-Byte-Salz.
  • bcrypts 72 Byte ignorieren. "a"*100 und "a"*72 ergeben identische Hashes — der Rest wird verworfen. Diese Seite warnt am Eingabefeld, wenn das Passwort 72 Byte überschreitet. Argon2 kennt diese Grenze nicht.
  • Hashes mit == in eigenem Code vergleichen. Die Prüfung muss zeitkonstant sein; die Seiten-Engine macht das intern (sie berechnet neu und vergleicht die gespeicherten Bytes). Wenn Sie den Ansatz übernehmen, verwenden Sie einen zeitkonstanten Vergleich.
  • Parameter auf einem schnellen Entwicklungsrechner abstimmen. Zielen Sie auf etwa 250–500 ms Hashing auf der typischen Hardware Ihrer Produktiv-Benutzer, nicht auf Ihrem Arbeitsrechner. Die Schaltfläche Vergleichen zeigt, was dieser Browser tatsächlich erlebt.
  • Bei jeder Anmeldeprüfung neu hashen. Prüfen Sie zuerst; neu hashen (z. B. um den Aufwand zu erhöhen) nur nach erfolgreicher Prüfung, und speichern Sie die neue Zeichenkette. Die PHP-Funktion password_needs_rehash() existiert genau dafür.
FAQ

Welchen soll ich wählen? Argon2id mit mindestens den OWASP-Minimalwerten. Falls die Laufzeitumgebung ihn nicht bietet: scrypt, dann bcrypt (mit einem Aufwand, bei dem das Hashing ≥250 ms dauert). PBKDF2 nur dort, wo eine Zertifizierung es verlangt.

Warum steht ein zufälliges Salz in der Ausgabezeichenkette? Das Salz ist kein Geheimnis — es wird absichtlich im Klartext in der PHC-Zeichenkette gespeichert, damit die Prüfung nur die Zeichenkette und das Kandidatenpasswort braucht. Seine Aufgabe ist Eindeutigkeit, nicht Geheimhaltung.

Spielt die Variante ($2a$ / $2b$ / $2y$) eine Rolle? Bei ASCII-Passwörtern ergeben sie identische Hashes; $2a$ ist das Original aus den 1990ern, $2b$ behob einen seltenen Vorzeichenerweiterungsfehler (2014), $2y$ ist PHPs Kennzeichen dafür, dass die Korrektur vorhanden ist. Die Prüfung akzeptiert alle drei.

Wie lange sollte ein Hash dauern? Grob 250–500 ms pro Anmeldung auf Serverhardware. Unter 100 ms ist ein Offline-Knacken günstig; über 1 s beschweren sich die Benutzer, bevor die Sicherheit tatsächlich besser wird.

Kann ich einen anderswo erzeugten Hash prüfen? Ja — fügen Sie ihn ein und geben Sie das Kandidatenpasswort an. Bekannte, gut funktionierende Formate: PHP password_hash (bcrypt $2y$ und Argon2id), Python passlib, Djangos Argon2-Hasher und das scrypt-Zeichenkettenformat des Werkzeugs scrypt von Tarsnap.

Was macht die Schaltfläche „Vergleichen“? Sie hasht das aktuelle Passwort einmal mit jedem Algorithmus bei den Standardparametern der Seite und meldet die Zeit in diesem Browser — ein Gefühl für die Unterschiede des Aufwands, keine exakte Messung.