What is Storing Passwords in a Recoverable Format (CWE-257)?

TL;DR: Storing passwords in a recoverable format makes them vulnerable to password reuse attacks. To prevent CWE-257, use strong, non-reversible encryption to protect stored passwords.

At-a-Glance Table

What is Storing Passwords in a Recoverable Format?

Storing Passwords in a Recoverable Format (CWE-257) is a type of vulnerability that occurs when passwords are stored in a format that can be recovered or decrypted, making them vulnerable to password reuse attacks. As defined by the MITRE Corporation under CWE-257, and classified by the OWASP Foundation under Not directly mapped…

Quick Summary

Storing passwords in a recoverable format makes them subject to password reuse attacks by malicious users. This vulnerability has significant consequences, including revealed passwords being reused elsewhere to impersonate users. It is essential to prevent CWE-257 by using strong, non-reversible encryption to protect stored passwords.

Jump to: What is Storing Passwords in a Recoverable Format? · Quick Summary · Storing Passwords in a Recoverable Format Overview · How Storing Passwords in a Recoverable Format Works · Business Impact of Storing Passwords in a Recoverable Format · Storing Passwords in a Recoverable Format Attack Scenario · How to Detect Storing Passwords in a Recoverable Format · How to Fix Storing Passwords in a Recoverable Format · Framework-Specific Fixes for Storing Passwords in a Recoverable Format · How to Ask AI to Check Your Code for Storing Passwords in a Recoverable Format · Storing Passwords in a Recoverable Format Best Practices Checklist · Storing Passwords in a Recoverable Format FAQ · Vulnerabilities Related to Storing Passwords in a Recoverable Format · References · Scan Your Own Site

Storing Passwords in a Recoverable Format Overview

• What: CWE-257 occurs when passwords are stored in a format that can be recovered or decrypted.
• Why it matters: CWE-257 has high likelihood of exploit and significant consequences, including revealed passwords being reused elsewhere to impersonate users.
• Where it occurs: CWE-257 typically occurs in password storage mechanisms, authentication systems, and other places where sensitive information is stored.
• Who is affected: CWE-257 affects any system that stores passwords in a recoverable format, making them vulnerable to password reuse attacks.
• Who is NOT affected: Systems that use strong, non-reversible encryption to protect stored passwords are not affected by CWE-257.

How Storing Passwords in a Recoverable Format Works

Root Cause

Storing passwords in a recoverable format makes them vulnerable to password reuse attacks because they can be easily recovered or decrypted.

Attack Flow

1. An attacker gains access to the system’s password storage mechanism.
2. The attacker uses specialized tools to recover or decrypt the stored passwords.
3. The attacker reuses the recovered passwords on other accounts, gaining unauthorized access.

Prerequisites to Exploit

• The system stores passwords in a recoverable format (e.g., plaintext or encrypted with a weak algorithm).
• The attacker has access to the system’s password storage mechanism.
• The attacker uses specialized tools to recover or decrypt the stored passwords.

Vulnerable Code

import hashlib

def store_password(password):
    # Store password in plaintext
    return password

# Usage:
password = "mysecretpassword"
stored_password = store_password(password)

This code stores passwords in plaintext, making them vulnerable to CWE-257. The fix is to use a password hashing algorithm like bcrypt or PBKDF2 with a sufficient work factor and salt.

Secure Code

import bcrypt

def store_password(password):
    # Hash password using bcrypt
    hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
    return hashed_password

# Usage:
password = "mysecretpassword"
stored_password = store_password(password)

This code uses the bcrypt library to hash passwords, making them secure against CWE-257.

Business Impact of Storing Passwords in a Recoverable Format

• Confidentiality: Revealed passwords can be reused elsewhere to impersonate users.
• Integrity: Passwords can be modified or tampered with, compromising system security.
• Availability: Systems may become unavailable due to password reuse attacks.

Storing Passwords in a Recoverable Format Attack Scenario

1. An attacker gains access to the system’s password storage mechanism.
2. The attacker uses specialized tools to recover or decrypt the stored passwords.
3. The attacker reuses the recovered passwords on other accounts, gaining unauthorized access.

How to Detect Storing Passwords in a Recoverable Format

Manual Testing

• Review password storage mechanisms for recoverable formats.
• Check for hardcoded passwords.
• Verify that passwords are stored using strong, non-reversible encryption.

Automated Scanners (SAST/DAST)

• Static analysis can detect CWE-257 by checking for recoverable formats and weak encryption algorithms.
• Dynamic analysis can detect CWE-257 by simulating password reuse attacks.

PenScan Detection

PenScan’s automated scan engines actively test for CWE-257, detecting recoverable formats and weak encryption algorithms.

False Positive Guidance

• CWE-257 may be reported as a false positive if the system uses strong, non-reversible encryption to protect stored passwords.
• Verify that the reported issue is not a false positive by reviewing the password storage mechanism and checking for hardcoded passwords.

How to Fix Storing Passwords in a Recoverable Format

• Use strong, non-reversible encryption (e.g., bcrypt or PBKDF2) to protect stored passwords.
• Store passwords securely using a password hashing algorithm with a sufficient work factor and salt.
• Regularly review and update password storage mechanisms to ensure they are secure against CWE-257.

Framework-Specific Fixes for Storing Passwords in a Recoverable Format

Java

Use Spring Security’s passwordEncoder bean to store encrypted passwords.

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

public class PasswordEncoder {
    private final BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();

    public String encodePassword(String password) {
        return passwordEncoder.encode(password);
    }
}

Python/Django

Use the bcrypt library to hash passwords.

import bcrypt

def store_password(password):
    hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
    return hashed_password

How to Ask AI to Check Your Code for Storing Passwords in a Recoverable Format

Review the following Python code block for potential CWE-257 vulnerabilities and rewrite it using strong, non-reversible encryption:

import hashlib

def store_password(password):
    # Store password in plaintext
    return password

Rewrite this code to use bcrypt or PBKDF2 with a sufficient work factor and salt.

Storing Passwords in a Recoverable Format Best Practices Checklist

✅ Use strong, non-reversible encryption (e.g., bcrypt or PBKDF2) to protect stored passwords. ✅ Store passwords securely using a password hashing algorithm with a sufficient work factor and salt. ✅ Regularly review and update password storage mechanisms to ensure they are secure against CWE-257.

Storing Passwords in a Recoverable Format FAQ

How do I prevent CWE-257?

Use strong, non-reversible encryption to protect stored passwords.

What are the consequences of CWE-257?

Revealed passwords may be reused elsewhere to impersonate users in question.

Can CWE-257 be exploited remotely?

Yes, if a system administrator can recover a password directly or use brute force search on available information.

What are the related weaknesses of CWE-257?

CWE-522 (Insufficiently Protected Credentials) and CWE-259 (Use of Hard-coded Password).

How do I detect CWE-257 manually?

Review password storage mechanisms for recoverable formats and check for hardcoded passwords.

What are the framework-specific fixes for CWE-257 in Java?

Use Spring Security’s passwordEncoder bean to store encrypted passwords.

Can AI help me detect CWE-257?

Yes, by using a coding assistant to review password storage mechanisms and suggest secure alternatives.

Vulnerabilities Related to Storing Passwords in a Recoverable Format

References

• MITRE CWE-257
• CAPEC-49
• NVD

Scan Your Own Site

Manual code review catches what you know to look for. An automated scan catches what you didn’t. Scan your own website using PenScan to find Storing Passwords in a Recoverable Format and other risks before an attacker does.