Password Security Best Practices Cheat Sheet

const bcrypt = require('bcrypt');// Hashing: cost factor (salt rounds) controls work factor, 12 is a common defaultasync function hashPassword(plain) {  const saltRounds = 12;  return await bcrypt.hash(plain, saltRounds); // salt is generated and embedded automatically}// Verifyingasync function verifyPassword(plain, hash) {  return await bcrypt.compare(plain, hash); // true/false, timing-safe comparison}// Never store plaintext or use fast hashes like MD5/SHA1 for passwords

password_policy:  min_length: 12          # NIST recommends 8 minimum, 12+ for stronger accounts  max_length: 64          # allow long passphrases, don't artificially cap  require_uppercase: false   # composition rules add little value per NIST  require_special_char: false  check_against_breach_list: true   # reject passwords found in known breach corpora (e.g. HaveIBeenPwned)  block_common_passwords: true      # reject top-10k common password list  allow_paste: true        # supports password managers  lockout_threshold: 10    # account lockout after N failed attempts  mfa_required: true

# SHA-1 hash the password, send only the first 5 hex chars of the hashpassword="CorrectHorseBatteryStaple"hash=$(echo -n "$password" | sha1sum | tr 'a-z' 'A-Z' | cut -c1-40)prefix=${hash:0:5}suffix=${hash:5}curl -s "https://api.pwnedpasswords.com/range/$prefix" | grep -i "$suffix"# If a match with a count > 0 is returned, the password has appeared in a known breach

const argon2 = require('argon2');async function hashPassword(plain) {  return await argon2.hash(plain, {    type: argon2.argon2id,   // hybrid resists both side-channel and GPU attacks    memoryCost: 19456,       // ~19 MiB, OWASP 2023 minimum recommendation    timeCost: 2,             // iterations    parallelism: 1  });}async function verifyPassword(plain, hash) {  try {    return await argon2.verify(hash, plain); // handles embedded params/salt automatically  } catch {    return false; // malformed hash, never throw to caller  }}// argon2.needsRehash-style check: if stored params are weaker than current// policy, rehash on next successful login instead of forcing a reset

const { generateRegistrationOptions, verifyRegistrationResponse } = require('@simplewebauthn/server');// Step 1: server issues a challenge bound to the user and originasync function startRegistration(user) {  const options = await generateRegistrationOptions({    rpName: 'Example App',    rpID: 'example.com',    userID: user.id,    userName: user.email,    attestationType: 'none',    authenticatorSelection: { residentKey: 'preferred', userVerification: 'preferred' }  });  await saveChallenge(user.id, options.challenge); // store server-side, single use  return options;}// Step 2: verify the browser's response and persist the public key credentialasync function finishRegistration(user, credentialResponse) {  const expectedChallenge = await getChallenge(user.id);  const verification = await verifyRegistrationResponse({    response: credentialResponse,    expectedChallenge,    expectedOrigin: 'https://example.com',    expectedRPID: 'example.com'  });  if (verification.verified) {    await saveCredential(user.id, verification.registrationInfo); // store publicKey + counter, never a secret  }  return verification.verified;}

import timeimport redisr = redis.Redis()def check_and_record_attempt(username, ip):    key_user = f"failcount:user:{username}"    key_ip = f"failcount:ip:{ip}"    fails_user = int(r.get(key_user) or 0)    fails_ip = int(r.get(key_ip) or 0)    # Exponential backoff delay, capped, applied server-side before responding    delay = min(2 ** fails_user, 30)    time.sleep(delay)    if fails_user >= 10 or fails_ip >= 50:        # Soft-lock: require MFA/step-up or CAPTCHA rather than blocking outright        return "CHALLENGE_REQUIRED"    return "OK"def record_failure(username, ip):    pipe = r.pipeline()    pipe.incr(f"failcount:user:{username}")    pipe.expire(f"failcount:user:{username}", 900)  # 15 min sliding window    pipe.incr(f"failcount:ip:{ip}")    pipe.expire(f"failcount:ip:{ip}", 900)    pipe.execute()

import hmacimport secretsdef generate_reset_token():    # Cryptographically secure, URL-safe, 32 bytes of entropy    return secrets.token_urlsafe(32)def tokens_match(provided, expected):    # hmac.compare_digest runs in constant time regardless of where    # the strings first differ, preventing character-by-character    # timing attacks that == would be vulnerable to    return hmac.compare_digest(provided, expected)# Never compare secrets with `==`, `in`, or string startswith() checks