Bcrypt-Hash-Generator & Verifizierer

Was ist Bcrypt?

// Node.js — bcryptjs / bcrypt (emits $2b$)
const bcrypt = require('bcrypt');
const hash = await bcrypt.hash('correct horse battery staple', 12);
// -> $2b$12$dUSFKqT1FCMYZ6hcQfsxuONizEqcX8IGK8snfVSowP5Uu.TDJoPUq
const ok = await bcrypt.compare('correct horse battery staple', hash); // true

# Python — bcrypt
import bcrypt
hashed = bcrypt.hashpw(b'correct horse battery staple', bcrypt.gensalt(12))
bcrypt.checkpw(b'correct horse battery staple', hashed)  # True

# PHP — password_hash (emits $2y$)
$hash = password_hash('correct horse battery staple', PASSWORD_BCRYPT, ['cost' => 12]);
password_verify('correct horse battery staple', $hash); // true

# Apache htpasswd CLI — bcrypt entry to stdout (-B bcrypt, -b inline, -n stdout)
htpasswd -Bbn admin 'correct horse battery staple'
# -> admin:$2y$12$dUSFKqT1FCMYZ6hcQfsxuONizEqcX8IGK8snfVSowP5Uu.TDJoPUq

Hauptfunktionen

Beispiele für den Bcrypt-Generator

Passwort: correct horse battery staple
Kosten: 12
Präfix: $2b$

$2b$12$dUSFKqT1FCMYZ6hcQfsxuONizEqcX8IGK8snfVSowP5Uu.TDJoPUq

Passwort: correct horse battery staple
Hash: $2b$12$dUSFKqT1FCMYZ6hcQfsxuONizEqcX8IGK8snfVSowP5Uu.TDJoPUq

✓ Treffer — das Passwort ist für diesen Hash korrekt

$2b$12$dUSFKqT1FCMYZ6hcQfsxuONizEqcX8IGK8snfVSowP5Uu.TDJoPUq

Version: $2b$ · Kosten: 12 · Salt: dUSFKqT1FCMYZ6hcQfsxuO · Digest: NizEqcX8IGK8snfVSowP5Uu.TDJoPUq

So nutzt du den Bcrypt-Generator

1. 1

   Passwort eingeben & Kostenfaktor wählen

   Tippe im Tab „Generieren“ ein Passwort ein oder klicke auf „Zufallspasswort“. Wähle einen Kostenfaktor (4–15; 12 ist der moderne Standard) und ein Versions-Präfix — $2b$, $2a$ oder $2y$ — passend zu deinem Stack.

2. 2

   Hash generieren

   Der Bcrypt-Hash wird lokal mit einem frischen zufälligen Salt berechnet und erscheint als einzelne 60-Zeichen-Zeichenkette $2b$12$.... Klicke auf „Kopieren“, um ihn zu übernehmen, oder generiere neu für einen frisch gesalteten Hash.

3. 3

   Anatomie lesen oder prüfen

   Das Anatomie-Panel teilt den Hash in Version, Kostenfaktor, Salt und Digest auf. Wechsle zum Tab „Prüfen“, um einen gespeicherten Hash und ein Passwort einzufügen und sofort zu bestätigen, ob sie übereinstimmen.

Common Errors

bcrypt.decrypt(hash)  // no such operation

bcrypt.compare(password, hash)  // returns true / false

cost: 4  // far too fast, weak against brute force

cost: 12  // modern default, resists brute force

hash(pw) === storedHash  // fails — different salts

bcrypt.compare(pw, storedHash)  // correct check

Häufige Anwendungsfälle

Passwort-Hash in einer Datenbank anlegen

Erzeuge einen Bcrypt-Hash für ein Admin- oder Testkonto und füge ihn direkt in deine users-Tabelle ein, sodass du dich anmelden kannst, ohne zuerst einen vollständigen Registrierungsablauf zu verkabeln.

Eine fehlschlagende Anmeldung debuggen

Prüfe ein bekanntermaßen korrektes Passwort gegen den gespeicherten Hash, um zu bestätigen, ob der Hash selbst korrekt ist, und isoliere so den Fehler von deinem Authentifizierungscode.

Den richtigen Kostenfaktor wählen

Generiere auf mehreren Kostenstufen auf deiner eigenen Hardware, um zu erspüren, wie lange jede dauert, und wähle dann einen Work-Faktor, der Brute Force widersteht, ohne echte Anmeldungen zu verlangsamen.

htpasswd- / Basic-Auth-Einträge erstellen

Erzeuge einen $2y$-Bcrypt-Hash für eine Apache-, Docker-Registry- oder Caddy-Anmeldung und füge ihn dann in eine user:hash-Zeile für HTTP Basic Auth ein.

Test-Fixtures aufbauen

Präge per Passwort deterministische Bcrypt-Hashes, um Integrationstests eines Anmelde- oder Passwort-Zurücksetzen-Ablaufs zu befüllen, ohne einen echten Auth-Server hochzuziehen.

Einen gefundenen Hash prüfen

Lies die Anatomie einer Bcrypt-Zeichenkette in einer Konfiguration oder einem Dump, um ihren Kostenfaktor zu prüfen, und verifiziere sie gegen das erwartete Passwort, um einen Treffer zu bestätigen.

Technische Details

Blowfish-basiert, adaptiver Kostenfaktor

Bcrypt leitet seinen Hash aus der aufwändigen Schlüsseleinrichtung der Blowfish-Chiffre ab, die 2^Kosten-mal wiederholt wird. Den Kostenfaktor um eins zu erhöhen verdoppelt die Arbeit und hält die Funktion langsam gegenüber Brute Force, während sich die Hardware verbessert.

128-Bit-Zufalls-Salt

Jeder Hash bettet einen 16-Byte- (128-Bit-) Zufalls-Salt ein, Base64-codiert als 22 Zeichen nach dem Kostenfaktor. Der Salt macht jeden Hash einzigartig, sodass identische Passwörter nie einen Digest teilen und Rainbow Tables nicht greifen.

Selbstbeschreibendes 60-Zeichen-Format

Die Ausgabe ist $Version$Kosten$Salt+Digest — eine feste 60-Zeichen-Zeichenkette, die alles Nötige zur Prüfung enthält. Keine separate Salt-Spalte und kein Parameterspeicher sind erforderlich.

72-Byte-Passwortgrenze

Bcrypt hasht nur die ersten 72 Byte eines Passworts; alles darüber hinaus wird stillschweigend ignoriert. Für sehr lange Passphrasen ist das Vor-Hashen (etwa mit SHA-256) vor Bcrypt eine gängige Gegenmaßnahme.

Prüfen, nicht entschlüsseln

Bcrypt ist eine Einwegfunktion. Die Prüfung führt den Hash erneut auf dem Kandidaten-Passwort aus, mit dem aus dem gespeicherten Hash geparsten Salt und Kostenfaktor, und vergleicht dann die Digests in konstanter Zeit. Es gibt keine Operation, die den Klartext wiederherstellt.

Ehrlichkeitshinweise & Vorbehalte

Hashes werden lokal berechnet und nie gegen ein Live-System geprüft. Kopierte Hashes und jedes eingetippte Passwort leben in deiner Zwischenablage und im Browser-Speicher — behandle sie als Geheimnisse und leere deine Zwischenablage nach dem Einfügen in die Produktion.

Bewährte Vorgehensweisen

Kosten 12 oder höher verwenden

Kosten 12 ist die moderne Grundlinie; erhöhe sie für sensible Systeme Richtung 14, solange die Anmeldelatenz akzeptabel bleibt. Bewerte regelmäßig neu — was vor fünf Jahren langsam genug war, ist heute billig anzugreifen.

Klartext nie speichern oder loggen

Speichere nur den Bcrypt-Hash, nie das ursprüngliche Passwort, und halte Passwörter aus Logs und Fehlermeldungen heraus. Der gesamte Wert von Bcrypt geht verloren, wenn der Klartext daneben leakt.

Bcrypt den Salt überlassen

Bcrypt erzeugt und bettet einen sicheren Zufalls-Salt für dich ein. Liefere keinen eigenen statischen Salt und verwende keinen wieder — ein Zufalls-Salt pro Hash ist es, was Rainbow Tables aushebelt.

Die 72-Byte-Grenze beachten

Wenn du lange Passphrasen akzeptierst, denke daran, dass Bcrypt Bytes jenseits von 72 ignoriert. Erwäge Vor-Hashen mit SHA-256 oder prüfe Argon2id, wenn sehr lange Eingaben vollständig abgedeckt sein müssen.

FAQ zum Bcrypt-Generator