Securely Hash and Verify Passwords

This skill implements secure password storage using industry-standard algorithms - Argon2, bcrypt, and scrypt - covering salt generation, timing-attack prevention, and modern security standards compliance. Core requirements are: never store plaintext passwords, use a cryptographically secure salt of at least 16 bytes per password, employ an adaptive hashing function, configure work factors that balance security and performance, and implement constant-time comparison during verification. Algorithm priority favors Argon2id (winner of the Password Hashing Competition, memory-hard) first, bcrypt second (well-established and widely supported), scrypt third, and PBKDF2 only as a legacy-compatibility fallback.

It provides working implementations in three languages: Python with Argon2id (a hasher class supporting hash, verify, and needs-rehash checks), Node.js with bcrypt (configurable salt rounds, currently recommended at 12-14), and Java with Spring Security's BCryptPasswordEncoder. Security configuration covers a benchmarking script to calibrate Argon2 parameters to a 250ms-1s target hashing time, and environment-specific settings - stronger parameters (time cost 4, 128MB memory, parallelism 2) for production versus faster settings for development. Advanced measures cover rate-limited verification (locking out an identifier after 5 failed attempts within a configurable window) and a password-migration pattern that verifies against a legacy hash (like MD5) on login and transparently upgrades to the new secure hash.

class SecurePasswordHasher:
    def __init__(self):
        # Argon2id parameters (adjust based on security requirements)
        self.ph = PasswordHasher(
            time_cost=3,     # Number of iterations
            memory_cost=65536,  # Memory usage in KiB (64MB)
            parallelism=1,   # Number of parallel threads
            hash_len=32,     # Hash output length
            salt_len=16      # Salt length
        )
    
    def hash_password(self, password: str) -> str:
        """Hash a password securely with Argon2id"""
        return self.ph.hash(password)

Use this skill when implementing or auditing password storage - choosing an algorithm (Argon2id, bcrypt, or scrypt), calibrating work factors, adding rate limiting and lockout, or migrating users off a legacy hash algorithm.

It is not a fit as a substitute for broader authentication system design (session management, MFA, account recovery flows) - it's scoped specifically to how a password is hashed, salted, and verified, not the surrounding auth architecture.

Inputs are the plaintext password to hash or verify, and your target environment (production versus development work factors). Outputs are a securely hashed password string, a boolean verification result with timing-attack protection, and, where applicable, a migrated hash and rate-limit lockout status.

Backend engineers implementing password storage who need concrete, language-specific implementations of Argon2id, bcrypt, or scrypt rather than building hashing logic from scratch - following OWASP guidelines (minimum 250ms hashing time, 128-bit salt, 256-bit hash output) and avoiding named pitfalls: never using MD5, SHA-1, or plain SHA-256, never implementing custom hashing algorithms, avoiding predictable or global salts, never logging plaintext passwords or hashes, and never hardcoding hash parameters in application code.