This weakness occurs when software relies on a hashing algorithm that is not cryptographically secure—such as MD5 or SHA-1—to protect sensitive data like…
This weakness occurs when software relies on a hashing algorithm that is not cryptographically secure—such as MD5 or SHA-1—to protect sensitive data like passwords or session tokens. Weak hashes can be reversed or collided with relative ease, allowing attackers to recover the original data or forge valid hashes. Using strong, modern hashing algorithms is essential for any security-critical operation.
Developers often choose hashing algorithms based on speed or familiarity rather than cryptographic strength. Older algorithms like MD5 and SHA-1 were designed for data integrity checks, not password storage, and have known collision vulnerabilities. Even when a weak hash is salted, the underlying algorithm's weakness remains. The problem is compounded when hashes are used for security-sensitive purposes—password verification, API token generation, or session management—where an attacker who obtains the hash can either reverse it (via rainbow tables or brute force) or craft collisions to bypass authentication.
If an attacker gains access to a database of weak hashes, they can recover plaintext passwords or forge authentication tokens without needing the original secret. This leads to account takeover, unauthorized access to user data, and potential lateral movement within a system. Even a single weak hash used for a critical function—such as password reset tokens or API keys—can compromise the entire authentication scheme.
import hashlib
def hash_password(password):
return hashlib.md5(password.encode()).hexdigest()
def verify_password(stored_hash, user_input):
return stored_hash == hashlib.md5(user_input.encode()).hexdigest()Why it's vulnerable:
MD5 is cryptographically broken and unsuitable for password storage. Attackers can precompute MD5 hashes (rainbow tables) or reverse them in seconds.
import hashlib
import secrets
def hash_password(password):
salt = secrets.token_hex(16)
hash_obj = hashlib.pbkdf2_hmac('sha256', password.encode(), salt.encode(), 100000)
return f"{salt}${hash_obj.hex()}"
def verify_password(stored_hash, user_input):
salt, hash_hex = stored_hash.split('$')
hash_obj = hashlib.pbkdf2_hmac('sha256', user_input.encode(), salt.encode(), 100000)
return hash_hex == hash_obj.hex()<?php
function hash_password($password) {
return md5($password);
}
function verify_password($stored_hash, $user_input) {
return $stored_hash === md5($user_input);
}
?>Why it's vulnerable:
MD5 is deprecated for cryptographic use and can be reversed or collided with in milliseconds using online tools or precomputed tables.
<?php
function hash_password($password) {
return password_hash($password, PASSWORD_BCRYPT, ['cost' => 12]);
}
function verify_password($stored_hash, $user_input) {
return password_verify($user_input, $stored_hash);
}
?>hashlib.pbkdf2_hmac, PHP's password_hash) are reliable.
Review your codebase for calls to md5(), sha1(), or hash() with weak algorithm names used on passwords, tokens, or session identifiers. Check your database schema for password or token columns; if they are short (32 or 40 characters) and hexadecimal, they may be MD5 or SHA-1 hashes. If you have access to logs, look for failed authentication attempts that spike after a data breach announcement—a sign that attackers are using recovered plaintext from weak hashes.
