Secure password hashing and key derivation directly in your browser. Supports modern OWASP-recommended schemes (Argon2id, bcrypt, scrypt, PBKDF2), legacy Unix and Apache formats (SHA-crypt, MD5crypt, apr1, phpass), Windows NTLM hashes, SASL authentication mechanisms (SCRAM-SHA-256, CRAM-SHA-1), and MySQL 8+ authentication. No data ever leaves your device.
Blowfish-based cost factor
Unlike ordinary cryptographic hashes, password hashing key derivation functions (KDFs) are deliberately slow and resource-intensive. They defend against dictionary and rainbow-table attacks by forcing an attacker to consume significant memory and CPU time per guess. Below are both modern OWASP-recommended standards and historical schemes for compatibility with existing systems.
Winner of the Password Hashing Competition (2015). Combines side-channel resistance (Argon2i) with GPU/ASIC attack resistance (Argon2d). Recommended by OWASP as the default password hashing algorithm. Tunable parameters: memory, iterations, and parallelism.
Adaptive hash function based on the Blowfish cipher (Niels Provos and David Mazières). Uses the expensive EksBlowfish key schedule; cost is tunable as a power-of-two iteration count. The de facto industry standard on Unix and web applications for over 25 years.
Key derivation function by Colin Percival (RFC 7914). Its core idea is to require a large working memory (N), making parallel brute-force on GPUs and ASICs economically unviable. Parameters: N (cost), r (block size), p (parallelism).
Password-Based Key Derivation Function 2 (RFC 8018, NIST SP 800-132). Iteratively applies HMAC to password and salt. Simple and widely supported, but weaker than Argon2id and scrypt against specialized hardware. At least 600,000 iterations are recommended for SHA-256.
Family of schemes from /etc/shadow and web-server configs. SHA-512crypt ($6$) and SHA-256crypt ($5$) are glibc standards, MD5crypt ($1$) is a legacy BSD format, Apache MD5 ($apr1$) is the htpasswd format, and phpass ($P$) is a historic scheme from phpBB2 and WordPress. Use only for backward compatibility.
Windows password hash format (MD4 of UTF-16LE). Used in NTLM and NetNTLM protocols for Active Directory and SMB authentication. Do not use for storing new passwords — MD4 is fully broken.
Salted Challenge Response Authentication Mechanism (RFC 5802, RFC 7677). Stores SaltedPassword as StoredKey = H(ClientKey) and ServerKey = HMAC(SaltedPassword, "Server Key"), allowing the server to authenticate a client without storing the plaintext password. The standard in PostgreSQL and MongoDB.
Challenge-Response Authentication Mechanism (RFC 2195). A simple authentication scheme: the server sends a random string, and the client replies with HMAC-SHA-1(password, challenge). Used in IMAP, POP3, and SMTP SASL.
Two MySQL authentication schemes. caching_sha2_password (MySQL 8+ default) applies SHA-256 twice to the password. mysql_native_password (legacy) applies SHA-1 twice and is the standard for PHP applications prior to MySQL 8.
Per OWASP recommendations, in order of preference: Argon2id (parameters: m=19 MiB, t=2, p=1), scrypt (N=2¹⁷, r=8, p=1), or bcrypt (cost ≥ 10). Never use fast hashes (MD5, SHA-256, NTLM) to store passwords — a modern GPU can compute billions per second. All three recommended algorithms are deliberately slow and memory-hard, making an attack economically unviable.
Password hashing is a one-way transformation: recovering the original password from a hash is infeasible. This is exactly what you want for secure storage. Encryption is reversible: anyone with the key can recover the original data. Passwords must never be encrypted, only hashed.
A salt is a random string added to the password before hashing. It guarantees that two users with identical passwords receive different hashes, which defeats precomputed rainbow-table attacks and lets the salt be stored alongside the hash. All modern schemes (Argon2, bcrypt, scrypt, PBKDF2, SHA-crypt) embed the salt into their output string automatically.
SHA-256crypt deliberately iterates raw SHA-256 in a 5000-round loop with extra time-hardening steps. This slows computation, but not enough — GPUs still compute millions of SHA-256crypt hashes per second. Modern KDFs like Argon2id go further: they require large amounts of RAM, making parallel cracking on specialized hardware more expensive than on ordinary CPUs.
All operations run locally in your browser.