Password Hashing: bcrypt, Argon2, PBKDF2

Storing passwords in plaintext is catastrophic — a single database breach exposes every account. Passwords must be processed with a one-way function before storage so that even database access doesn't reveal the original password.

A hash function converts input of any length into a fixed-length output. The same input always produces the same output, but the original cannot be recovered from the hash. Examples: SHA-256, bcrypt, Argon2.

General-purpose hash functions like SHA-256 are designed to be fast. An attacker can compute billions of SHA-256 hashes per second on a GPU, making brute-force cracking feasible.

Password hashing requires slow, expensive functions.

A salt is a random value added to each password before hashing. It ensures two users with the same password have different hashes, preventing rainbow table and batch cracking attacks. The salt is stored alongside the hash (it's not secret).

bcrypt was designed in 1999 specifically for password hashing. It has a configurable cost factor that controls how slow the hashing is. As hardware improves, increase the cost factor to maintain security.

Cost factor of 12 is common today — takes ~250ms to hash on a modern CPU.

PBKDF2 (Password-Based Key Derivation Function 2) applies a hash function (e.g., HMAC-SHA256) many times (iterations). More iterations = slower = more secure. Recommended by NIST and used by WPA2 for Wi-Fi passwords.

Argon2 won the Password Hashing Competition in 2015. It's the modern standard. It's configurable on:

• Time cost — number of iterations
• Memory cost — RAM required (limits GPU acceleration)
• Parallelism — number of threads

Use Argon2id for most applications.

A rainbow table is a precomputed lookup of hash → plaintext. Without salting, an attacker who has the hash can look it up in the table instantly. Salting renders rainbow tables useless because each hash is unique.

Common offline cracking approaches:

• Dictionary attack — try common passwords and variations
• Brute force — try all character combinations
• Rule-based — apply mutation rules to dictionary (append year, capitalize, leet speak)
• Tools: Hashcat, John the Ripper

Order of preference for new applications:

1. Argon2id — best resistance to GPU/ASIC cracking
2. bcrypt — widely supported, proven track record
3. PBKDF2 — NIST-approved, required in some compliance contexts

Never use: MD5, SHA-1, or unsalted SHA-256 for passwords.

When a user logs in:

1. Retrieve stored hash and salt for the user
2. Hash the submitted password with the same salt and algorithm
3. Compare resulting hash to stored hash (constant-time comparison)
4. Never decrypt — comparison only

Which password hashing algorithm is considered the current best practice and was the winner of the Password Hashing Competition?

Passwords must be stored as hashes, not plaintext. Fast algorithms like SHA-256 are unsuitable — use slow password hashing functions: Argon2id (preferred), bcrypt, or PBKDF2. Always use a random salt per password to prevent rainbow table attacks. Never roll your own cryptography — use proven libraries.