Storing passwords safely

Two words first

Authentication means checking who you are (logging in). Authorization means checking what you are allowed to do (can you delete this order?). This module covers both; this topic is about the first step of authentication: keeping passwords safe.

Why plain-text passwords are a disaster

Databases leak: a stolen backup, a hacked server, a careless employee. If passwords are stored as typed, every account is open at once. Worse, many people use the same password for email and banking, so one leak hurts them everywhere.

Hashing is not encryption

Salt: different hash for the same password

A salt is a random value made for each user and stored next to their hash. Two users with the password "india@123" get completely different hashes. This stops attackers from using rainbow tables, which are huge pre-computed lists of hashes for common passwords.

Slow on purpose

General hashes like SHA-256 are built to be fast: a gaming GPU can try billions per second, so short passwords fall in minutes. Password hashes are deliberately slow and use lots of memory, so each guess costs the attacker real time and money.

// Example only: runs on a server with Node.js and the argon2 package
import argon2 from 'argon2';

// Sign up: hash and store the result (salt is included inside it)
const hash = await argon2.hash(password, { type: argon2.argon2id });
// hash looks like: $argon2id$v=19$m=65536,t=3,p=4$<salt>$<hash>

// Log in: compare the typed password with the stored hash
const ok = await argon2.verify(user.passwordHash, typedPassword);

// bcrypt works the same way:
// const hash = await bcrypt.hash(password, 12);
// const ok = await bcrypt.compare(typedPassword, hash);

// PBKDF2 with Web Crypto (built into Node and browsers)
const enc = new TextEncoder();
const key = await crypto.subtle.importKey('raw', enc.encode(password), 'PBKDF2', false, ['deriveBits']);
const bits = await crypto.subtle.deriveBits(
  { name: 'PBKDF2', hash: 'SHA-256', salt: enc.encode(salt), iterations: 600000 },
  key,
  256 // 256 bits = 32 bytes
);