Secure Password Hashing in PHP Login Systems: From MD5 and SHA to bcrypt

When building PHP login systems, secure password storage is fundamental to protecting user data. Developers often face confusion when selecting appropriate hashing algorithms, with common choices including MD5, SHA1, and SHA256. However, while widely used, these algorithms possess fundamental flaws for password protection purposes.

Limitations of Traditional Hashing Algorithms

MD5, SHA1, and SHA256 are all fast hash functions designed primarily for data integrity verification rather than password protection. Their computational efficiency and hardware optimization enable attackers to leverage modern computing resources (such as GPUs and ASICs) for effective brute-force or rainbow table attacks. Even with salt augmentation, the inherent characteristics of these algorithms render them unsuitable for password storage.

The traditional approach demonstrated in the code example exhibits multiple issues:

function createSalt()
{
    $string = md5(uniqid(rand(), true));
    return substr($string, 0, 3);
}

$salt = createSalt();
$hash = sha1($salt . $hash);

This method employs a mere 3-character salt and relies on pseudo-random number generation for salt creation, both of which are insufficient for security. The SHA1 algorithm itself has demonstrated collision vulnerabilities and is no longer recommended for security-sensitive applications.

bcrypt: The Modern Password Hashing Standard

bcrypt is specifically designed for password hashing, implementing a computationally intensive hashing process through configurable work factors. This design significantly increases the time cost of brute-force attacks while maintaining reasonable performance during verification. bcrypt also automatically handles salt generation, utilizing cryptographically secure random number generators (CSPRNGs) to ensure uniqueness and unpredictability.

In PHP 5.5 and later versions, the built-in password_hash() and password_verify() functions provide a straightforward yet powerful bcrypt implementation:

// Creating a hash
$hash = password_hash($password, PASSWORD_DEFAULT, ['cost' => 12]);
// If the ['cost' => 12] parameter is omitted, the default work factor is 10

// Verifying the password
if (password_verify($password, $hash)) {
    // Verification successful, execute login logic
}

The password_hash() function automatically generates a secure salt and returns a complete string containing the algorithm, work factor, salt, and hash value. The PASSWORD_DEFAULT constant ensures the use of the most secure algorithm recommended for the current PHP version, with potential future automatic upgrades to stronger algorithms like Argon2.

Caveats of bcrypt

While bcrypt is the current recommended standard, developers should be aware of two important limitations:

1. bcrypt silently truncates passwords exceeding 72 characters. This means portions of long passwords do not participate in hash computation, potentially reducing security.
2. bcrypt truncates passwords after encountering NUL characters (\0), which may cause issues in certain edge cases.

Some developers attempt to address the first limitation through pre-hashing, but this may introduce new security risks. It is advisable to use existing libraries evaluated by security experts, such as the BcryptSha provided by Zend Framework's Zend\Crypt component, or Paragonie's PasswordLock library, which adds an authenticated encryption layer on top of bcrypt hashes.

Backward Compatibility and Upgrade Strategies

For systems still running older PHP versions (below 5.5), upgrading to a supported version is strongly recommended. During the transition period, ircmaxell's password_compat library can provide a password_hash()-compatible API for legacy PHP installations.

When migrating existing password hashes, a progressive strategy should be adopted: upon a user's next successful login, verify the old hash using password_verify(), then generate a new bcrypt hash with password_hash() and update the database. This seamless migration ensures uninterrupted user experience while gradually enhancing system security.

Password security is an evolving field, and developers should continuously monitor new attack vectors and defense techniques. Regularly reviewing and updating password hashing strategies, following guidelines from authoritative organizations like OWASP, is crucial for maintaining long-term system security.