Bcrypt Hash Generator & Verifier

What Is 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

Key Features

Bcrypt Generator Examples

password: correct horse battery staple
cost: 12
prefix: $2b$

$2b$12$dUSFKqT1FCMYZ6hcQfsxuONizEqcX8IGK8snfVSowP5Uu.TDJoPUq

password: correct horse battery staple
hash: $2b$12$dUSFKqT1FCMYZ6hcQfsxuONizEqcX8IGK8snfVSowP5Uu.TDJoPUq

✓ Match — the password is correct for this hash

$2b$12$dUSFKqT1FCMYZ6hcQfsxuONizEqcX8IGK8snfVSowP5Uu.TDJoPUq

version: $2b$ · cost: 12 · salt: dUSFKqT1FCMYZ6hcQfsxuO · digest: NizEqcX8IGK8snfVSowP5Uu.TDJoPUq

How to Use the Bcrypt Generator

1. 1

   Enter a Password & Choose the Cost

   On the Generate tab, type a password or click Random password. Pick a cost factor (4–15; 12 is the modern default) and a version prefix — $2b$, $2a$, or $2y$ — to match your stack.

2. 2

   Generate the Hash

   The bcrypt hash is computed locally with a fresh random salt and appears as a single 60-character $2b$12$... string. Click Copy to lift it, or re-generate for a new salted hash.

3. 3

   Read the Anatomy or Verify

   The anatomy panel splits the hash into version, cost, salt, and digest. Switch to the Verify tab to paste a stored hash and a password and confirm instantly whether they match.

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

Common Use Cases

Seed a Password Hash in a Database

Generate a bcrypt hash for an admin or test account and insert it directly into your users table, so you can log in without wiring up a full signup flow first.

Debug a Failing Login

Verify a known-good password against the stored hash to confirm whether the hash itself is correct, isolating the bug from your authentication code.

Pick the Right Cost Factor

Generate at several cost levels on your own hardware to feel how long each takes, then choose a work factor that resists brute force without slowing real logins.

Create htpasswd / Basic Auth Entries

Produce a $2y$ bcrypt hash for an Apache, Docker Registry, or Caddy credential, then drop it into a user:hash line for HTTP Basic Auth.

Build Test Fixtures

Mint deterministic-by-password bcrypt hashes to seed integration tests of a login or password-reset flow without standing up a real auth server.

Audit a Hash You Found

Read the anatomy of a bcrypt string in a config or dump to check its cost factor, and verify it against the password you expect to confirm a match.

Technical Details

Blowfish-Based, Adaptive Cost

Bcrypt derives its hash from the Blowfish cipher's expensive key setup, repeated 2^cost times. Raising the cost by one doubles the work, keeping the function slow against brute force as hardware improves.

128-Bit Random Salt

Each hash embeds a 16-byte (128-bit) random salt, Base64-encoded as 22 characters after the cost. The salt makes every hash unique, so identical passwords never share a digest and rainbow tables do not apply.

Self-Describing 60-Character Format

The output is $version$cost$salt+digest — a fixed 60-character string carrying everything needed to verify it. No separate salt column or parameter store is required.

72-Byte Password Limit

Bcrypt only hashes the first 72 bytes of a password; anything beyond that is silently ignored. For very long passphrases, pre-hashing (for example with SHA-256) before bcrypt is a common mitigation.

Verify, Don't Decrypt

Bcrypt is one-way. Verification re-runs the hash on the candidate password using the salt and cost parsed from the stored hash, then compares digests in constant time. There is no operation that recovers the plaintext.

Honesty Notes & Caveats

Hashes are computed locally and never checked against a live system. Copied hashes and any password you typed live on your clipboard and in browser memory — treat them as secrets and clear your clipboard after pasting into production.

Best Practices

Use Cost 12 or Higher

Cost 12 is the modern baseline; raise it toward 14 for sensitive systems as long as login latency stays acceptable. Re-evaluate periodically — what was slow enough five years ago is cheap to attack today.

Never Store or Log Plaintext

Store only the bcrypt hash, never the original password, and keep passwords out of logs and error messages. The whole value of bcrypt is lost if the plaintext leaks alongside it.

Let bcrypt Handle the Salt

Bcrypt generates and embeds a secure random salt for you. Do not supply your own static salt or reuse one — a per-hash random salt is what defeats rainbow tables.

Mind the 72-Byte Limit

If you accept long passphrases, remember bcrypt ignores bytes past 72. Consider pre-hashing with SHA-256, or evaluate Argon2id, when very long inputs must be fully covered.

Bcrypt Generator FAQ