Proper password storage is a critical aspect of application security. When user credentials are compromised, the damage can extend far beyond your application due to password reuse. This guide covers fundamental techniques and best practices for securely storing passwords in your systems.

Password Storage Fundamentals

The core principle of secure password storage is that you should never store the actual password. Instead, you store a cryptographic hash of the password that can be used for verification without revealing the original password.

Why Not Store Plaintext Passwords?

Storing passwords in plaintext poses several serious risks:

• If your database is compromised, attackers immediately gain access to all user accounts
• Internal staff with database access can view user passwords
• Users often reuse passwords across multiple sites, so a breach of your system could compromise their accounts elsewhere
• It violates security best practices and likely breaches data protection regulations

Secure Hashing Techniques

A cryptographic hash function converts data of arbitrary size into a fixed-size output. Good password hashing functions have these properties:

• One-way: It should be computationally infeasible to reverse the hash to obtain the original password
• Deterministic: The same input always produces the same output
• Collision-resistant: It should be extremely unlikely for two different inputs to produce the same hash
• Slow: The function should be deliberately slow to compute to resist brute-force attacks

Recommended Hashing Algorithms

Modern password hashing algorithms are specifically designed to be slow and resource-intensive to prevent brute-force attacks. The most recommended algorithms include:

Salt and Pepper

Salting is a critical technique that adds an additional layer of security to password hashing.

What is a Salt?

A salt is a random value that is generated for each user and combined with their password before hashing. This ensures that even if two users have the same password, their hashed passwords will be different. Salts are typically stored alongside the password hash in the database.

What is a Pepper?

A pepper is similar to a salt but with one key difference: it's not stored in the database. Instead, it's a secret value stored in application configuration or environment variables. This adds an extra layer of protection if the database is compromised but the application server remains secure.

Implementation Examples

Here are examples of how to implement secure password hashing in different programming languages:

Node.js with bcrypt

const bcrypt = require('bcrypt');
const saltRounds = 12;
// Hashing a password
async function hashPassword(plainTextPassword) {
  try {
    const hash = await bcrypt.hash(plainTextPassword, saltRounds);
    return hash;
  } catch (err) {
    console.error(err);
    throw err;
  }
}

// Verifying a password
async function verifyPassword(plainTextPassword, hashedPassword) {
  try {
    const match = await bcrypt.compare(plainTextPassword, hashedPassword);
    return match;
  } catch (err) {
    console.error(err);
    throw err;
  }
}Copy

Python with Argon2

from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError

ph = PasswordHasher(
    time_cost=3,      # Number of iterations
    memory_cost=65536, # Memory usage in kibibytes (64 MB)
    parallelism=4,    # Degree of parallelism
    hash_len=32,      # Length of the hash in bytes
    salt_len=16       # Length of the salt in bytes
)

# Hashing a password
def hash_password(password):
    return ph.hash(password)

# Verifying a password
def verify_password(password, hash):
    try:
        ph.verify(hash, password)
        return True
    except VerifyMismatchError:
        return FalseCopy

PHP with password_hash

// Hashing a password
function hashPassword($password) {
    // PASSWORD_ARGON2ID is available in PHP 7.3+
    // For older versions, use PASSWORD_BCRYPT
    $hash = password_hash($password, PASSWORD_ARGON2ID, [
        'memory_cost' => 65536, // 64MB
        'time_cost' => 4,       // 4 iterations
        'threads' => 3          // 3 threads
    ]);
    
    return $hash;
}

// Verifying a password
function verifyPassword($password, $hash) {
    return password_verify($password, $hash);
}Copy

Best Practices

Follow these guidelines to ensure your password storage implementation is as secure as possible:

Password Upgrade Strategy

As cryptographic standards evolve, you may need to upgrade your password hashing algorithm. Here's a strategy for upgrading existing password hashes:

1. Add a field to your user database to track which hashing algorithm was used
2. When users log in successfully with the old algorithm, rehash their password with the new algorithm
3. Update the algorithm field and store the new hash
4. During verification, check the algorithm field to determine which verification method to use

function verifyAndUpgradePasswordIfNeeded(user, providedPassword) {
  let isValid = false;
  
  // Check which algorithm was used
  if (user.passwordVersion === 'bcrypt') {
    isValid = bcrypt.compareSync(providedPassword, user.passwordHash);
  } else if (user.passwordVersion === 'pbkdf2') {
    isValid = verifyPbkdf2Password(providedPassword, user.passwordHash);
  }
  
  // If valid and using old algorithm, upgrade to new algorithm
  if (isValid && user.passwordVersion !== 'argon2id') {
    const newHash = argon2.hash(providedPassword);
    
    // Update user record with new hash and algorithm version
    updateUserPassword(user.id, newHash, 'argon2id');
  }
  
  return isValid;
}

Common Mistakes to Avoid

Be aware of these common password storage mistakes that can compromise security:

Compliance and Regulations

Different industries and regions have specific requirements for password storage. Here are some key regulations to be aware of:

Conclusion

Secure password storage is a fundamental aspect of application security. By implementing modern hashing algorithms with proper salting, you can significantly reduce the risk of credential compromise even if your database is breached.

Remember these key points:

• Never store plaintext passwords
• Use modern, slow hashing algorithms (Argon2id, bcrypt, scrypt)
• Always salt passwords with unique, random values
• Configure appropriate work factors for your environment
• Implement a strategy for upgrading password hashes as technology evolves

By following these guidelines, you'll create a robust foundation for protecting your users' credentials and maintaining their trust in your application.