Generate Password Hashes — MD5, SHA-256 & SHA-512 Online

How to Use This Password Hash Generator and Verifier

Every time you store a user's credentials, you're making a security decision that can protect or expose thousands of accounts. This password hash generator and verifier gives you instant, browser-based hashes using the algorithms that modern cybersecurity standards actually recommend — so you can debug integrations, validate your implementation choices, and understand exactly what your authentication stack is doing, all without sending a single character to a server. Because all hashing and verification happen in this browser, nothing leaves your browser at any point. This client-side hashing tool is designed for developers doing software integration debugging, testing credential storage logic, or simply learning how password hashing and salting works in practice. The bcrypt generator explains each field in the output string — version, cost, salt, and digest — so you understand the format.

Pick the Algorithm

Choose your hashing algorithm from the dropdown. For new system password hashing, start with Argon2id; for existing bcrypt deployments, select bcrypt. The selector also exposes scrypt, PBKDF2, SHA-256, SHA-512, SHA-1, and MD5, each with its own parameter controls.

Paste Your Input

Paste any text into the input field — a demo password string or plain text you want to fingerprint. Avoid real credentials in any online tool; always use test values. For bcrypt, set the cost factor (default 12, the OWASP 2026 minimum). For Argon2id, configure memory, iterations, and parallelism.

Read the Output

SHA-family hashes appear in lowercase hexadecimal — 64 chars for SHA-256, 128 for SHA-512, 40 for SHA-1, 32 for MD5. bcrypt outputs a 60-character $2b$ encoded string; Argon2id follows the PHC string format.

Compare Two Hashes

Paste a known hash alongside a candidate password to verify a match — the same operation your framework's password_verify() or checkpw() performs, useful for isolating encoding mismatches before they reach production.

Step by Step

1. Select your algorithm and configure its parameters (cost factor, memory, iterations, parallelism).
2. Paste your test input into the password field — use a dummy value, never a real credential.
3. Click Generate and observe the hash output string along with live timing in milliseconds.
4. Switch to the Verify tab, paste the hash output plus the same input, and confirm the verification returns a match.
5. Optionally compare two hashes side by side to validate the cascading bit-flip effect or check a published file digest.

Argon2id vs bcrypt Hash Generator: Which Should You Pick?

The core question in modern password security is whether your chosen algorithm resists the hardware attacks attackers actually deploy. GPU and ASIC attacks can evaluate millions of SHA-256 hashes per second on commodity hardware, making plain SHA-256 credential handling catastrophically weak.

Argon2id is a memory-hard function that forces attackers to allocate significant RAM per guess — making GPU and ASIC attacks economically prohibitive at scale. The recommended minimum sets argon2id m=19 MiB t=2 p=1; for higher-security contexts, m=64 MiB / t=3 / p=4 significantly raises attacker cost.

bcrypt uses a tunable cost factor (expressed as a power of two — cost factor 12 means 2^12 = 4,096 rounds). It is CPU-hard but not memory-hard, meaning GPU clusters can attack it faster than Argon2id. The bcrypt 72-byte input limit is a subtle gotcha: passwords longer than 72 bytes are silently truncated. Cost 13-14 is preferred for new systems; anything above 14 noticeably affects login latency.

scrypt is also a memory-hard function — the scrypt N=2^17 r=8 p=1 baseline consumes 128 MiB per verification, making it resistant to GPU and ASIC parallelization. For interactive logins on modest hardware, N=2^15 r=8 p=1 is acceptable; never use N values below 2^14.

MD5 for Non-Security Deduplication

The MD5 algorithm produces a 128-bit fingerprint — a compact digest of 32 hexadecimal characters — and is deterministic: the same string always produces the same output. This makes it useful for non-security file integrity checks, cache keys, file deduplication, and lookup identifiers. Gravatar uses MD5(email) as an avatar key — a well-known example in production. However, stop using weak hashing algorithms like MD5 and SHA-1 for anything involving secure credential storage, digital signatures, or certificates — MD5 is broken for security purposes, with known hash collisions well within the reach of modern computing.

Common Questions About Hash Verification & Password Security

Is it safe to use this with real passwords?

This is a client-side hashing tool — all processing runs locally in your browser using the Web Crypto API. Your input never leaves your machine, and we do not store any passwords. That said, as a matter of security best practices, you should avoid using real credentials or production secrets in any online tool. Use dummy values for debugging integrations.

Can I reverse or decrypt a hash?

No — and no other tool can either. Hash functions are one-way by design and produce output that is infeasible to invert. There is no key that reverses them, because hashing is not encryption. The only approach to crack a hash is to guess inputs and check whether their hash matches the target. Modern memory-hard parameters make brute-force attacks on Argon2id and scrypt economically prohibitive at scale.

Why won't my framework verify the hash?

The most common causes of verification failures in web application security contexts are:

• Encoding mismatch: hex vs base64 encoding — if you store the hash in hex but your library expects base64, verification always fails.
• Whitespace/line endings: a trailing newline or space in a saved hash record will cause a mismatch.
• bcrypt prefix differences: some older libraries produce $2a$ hashes while newer ones expect $2b$.
• Pepper mismatch: if your deployment uses a pepper (a site-wide server secret not stored in the hash), missing it from the verification path will always fail.
• Wrong algorithm: attempting to verify using a different algorithm than was used to generate it will always fail.

What salt length should I use?

A 16-byte random salt (128 bits) is the minimum recommended across OWASP recommendations and NIST guidelines for all modern key derivation functions. For bcrypt, the salt is handled internally — it always generates and embeds a 22-character base64-encoded salt (128 bits) automatically, so you never manage it separately.

bcrypt Libraries by Language: Code Examples for Secure Development

Always use trusted libraries for creating password hashes — never roll your own cryptographic implementation.

bcrypt in Node.js

The bcryptjs package works in both Node.js and the browser; the native bcrypt npm package offers better performance server-side.

// npm install bcryptjs
const bcrypt = require('bcryptjs');

async function hashPassword(plaintext) {
  const costFactor = 12; // OWASP 2026 minimum; prefer 13-14 for new systems
  const hash = await bcrypt.hash(plaintext, costFactor);
  return hash; // $2b$12$...
}

async function verifyPassword(plaintext, storedHash) {
  const isValid = await bcrypt.compare(plaintext, storedHash);
  return isValid; // true or false
}

bcrypt in PHP

PHP has built-in bcrypt support via password_hash() and password_verify() — the native functions recommended for all PHP credential workflows.

<?php
$plaintext = 'hunter2';
$hash = password_hash($plaintext, PASSWORD_BCRYPT, ['cost' => 12]);

$isValid = password_verify($plaintext, $hash);

if (password_needs_rehash($hash, PASSWORD_BCRYPT, ['cost' => 13])) {
  $newHash = password_hash($plaintext, PASSWORD_BCRYPT, ['cost' => 13]);
}
?>

bcrypt in Java

Spring Security provides a production-ready bcrypt Java implementation via BCryptPasswordEncoder. For non-Spring projects, the jBCrypt library offers a standalone option.

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

public class PasswordService {
    private static final int COST_FACTOR = 12;
    private final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder(COST_FACTOR);

    public String hashPassword(String plaintext) {
        return encoder.encode(plaintext); // $2a$12$...
    }

    public boolean verifyPassword(String plaintext, String storedHash) {
        return encoder.matches(plaintext, storedHash);
    }
}

Security note: Always choose a strong password containing special characters, lowercase and uppercase letters, and numbers when generating test hashes. The cost option you set determines your brute force resistance: tune it to produce 250-500ms hashing time on your production hardware and benchmark annually.