Secure Hashing and Salt for PHP Passwords: A Modern Approach

When considering password protection in PHP, it’s crucial to employ up-to-date techniques to ensure both security and performance. The original question was raised in 2008, but PHP has evolved since then, providing built-in functions for safe password handling. Here’s a modern take on the subject, utilizing best practices and avoiding deprecated approaches like MD5 or SHA1.

Why Secure Hashing Matters

Passwords are hashed to prevent attackers from gaining access to user accounts, even if they manage to obtain the password database. The goal is to make the process of reversing a hash (i.e., cracking the password) prohibitively expensive in terms of time and computational power. This delay gives developers time to respond and lock down systems in case of a breach.

Modern PHP Hashing Functions

PHP offers a native, secure way to hash and verify passwords using the password_hash() and password_verify() functions introduced in PHP 5.5.

• password_hash(): Automatically generates a strong hash using the Blowfish-based bcrypt algorithm or Argon2i (from PHP 7.2 onward).
• password_verify(): Verifies a password against a stored hash, automatically applying any salt or other cryptographic parameters stored within the hash.

Using password_hash() and password_verify()

<?php
// Hash a password using bcrypt
$password = 'user_password';
$hashed_password = password_hash($password, PASSWORD_DEFAULT); // bcrypt by default

// Store $hashed_password in the database
echo "Hashed Password: " . $hashed_password;

// Verify the password during login
if (password_verify($password, $hashed_password)) {
    echo "Password is valid!";
} else {
    echo "Invalid password!";
}
?>

Explanation:

• PASSWORD_DEFAULT uses bcrypt, ensuring a strong, secure hash. If a better algorithm becomes available, PHP will adopt it without requiring changes to your code.
• You don’t need to manage salts manually; PHP generates them and stores them as part of the hash.

Salting: Automatic in Modern PHP

In older approaches, developers were responsible for generating and storing salts separately. However, with password_hash(), salting is automatic and embedded in the resulting hash. You don’t need to worry about creating or storing a salt explicitly.

Recommended Security Practices

• Use bcrypt or Argon2: Both are computationally expensive and resistant to brute-force attacks. Argon2 is considered the best option if your server supports it (PHP 7.2+).
• Enforce a strong password policy: Require users to create passwords with a mix of letters, numbers, and symbols.
• Use a sufficient cost factor: The cost factor determines how many times the hash is applied, increasing computational time. You can adjust the cost like this:

$options = ['cost' => 12]; // The default is 10; increase as needed
$hashed_password = password_hash($password, PASSWORD_DEFAULT, $options);

Password Rehashing

As computing power increases, the cost factor that was once sufficient may become inadequate. PHP allows you to check if a stored hash needs rehashing and update it accordingly:

if (password_needs_rehash($hashed_password, PASSWORD_DEFAULT, ['cost' => 12])) {
    $new_hashed_password = password_hash($password, PASSWORD_DEFAULT, ['cost' => 12]);
    // Update stored hash in the database
}

Legacy Systems: Migrating from MD5 or SHA1

If you’re dealing with older systems that still use MD5 or SHA1, it’s critical to update to stronger algorithms. A straightforward approach is to rehash the password the next time the user logs in:

if (md5($password) === $stored_md5_hash) {
    // User's password is valid, rehash using a stronger algorithm
    $new_hashed_password = password_hash($password, PASSWORD_DEFAULT);
    // Store $new_hashed_password in the database
}

The secure and efficient way to handle passwords in PHP today is by using password_hash() and password_verify(). These functions handle salting and hashing securely, making them superior to older methods like MD5 and SHA1. By adopting modern best practices, you ensure that your system is protected against current and future threats.

Key Takeaways:

• Always use password_hash() for storing passwords and password_verify() for validation.
• Avoid legacy algorithms like MD5 or SHA1, as they are vulnerable to attacks.
• Opt for bcrypt or Argon2 (if supported) with an appropriate cost factor for your system’s performance.