Exposure of Sensitive Information to an Unauthorized Actor

Draft Class

Structure: Simple

Description

This weakness occurs when an application unintentionally reveals sensitive data to someone who shouldn't have access to it.

Extended Description

An information exposure happens when sensitive data leaks from your system. This can include personal user details like financial or health information, internal system data such as configuration or logs, business secrets, or even metadata about your application's operations. The leak can be direct, like accidentally including private data in an error message, or indirect, where another vulnerability allows unauthorized access to protected resources. The impact depends heavily on what's exposed and who sees it. Different parties—end users, administrators, or third parties—have different expectations of privacy. While many vulnerabilities can lead to data leaks, this specific weakness focuses on errors in how the code itself handles, transmits, or sanitizes sensitive information, rather than broader access control failures.

Common Consequences 1

Scope: Confidentiality

Impact: Read Application Data

Detection Methods 6

Automated Static Analysis - Binary or BytecodeSOAR Partial

According to SOAR [REF-1479], the following detection techniques may be useful: ``` Cost effective for partial coverage: ``` Bytecode Weakness Analysis - including disassembler + source code weakness analysis Inter-application Flow Analysis

Dynamic Analysis with Automated Results InterpretationHigh

According to SOAR [REF-1479], the following detection techniques may be useful: ``` Highly cost effective: ``` Web Application Scanner Web Services Scanner Database Scanners

Dynamic Analysis with Manual Results InterpretationSOAR Partial

According to SOAR [REF-1479], the following detection techniques may be useful: ``` Cost effective for partial coverage: ``` Fuzz Tester Framework-based Fuzzer Automated Monitored Execution Monitored Virtual Environment - run potentially malicious code in sandbox / wrapper / virtual machine, see if it does anything suspicious

Manual Static Analysis - Source CodeHigh

According to SOAR [REF-1479], the following detection techniques may be useful: ``` Highly cost effective: ``` Manual Source Code Review (not inspections)

Automated Static Analysis - Source CodeHigh

According to SOAR [REF-1479], the following detection techniques may be useful: ``` Highly cost effective: ``` Context-configured Source Code Weakness Analyzer ``` Cost effective for partial coverage: ``` Source code Weakness Analyzer

Architecture or Design ReviewHigh

According to SOAR [REF-1479], the following detection techniques may be useful: ``` Highly cost effective: ``` Formal Methods / Correct-By-Construction ``` Cost effective for partial coverage: ``` Attack Modeling Inspection (IEEE 1028 standard) (can apply to requirements, design, source code, etc.)

Potential Mitigations 1

Phase: Architecture and Design

Strategy: Separation of Privilege

Compartmentalize the system to have "safe" areas where trust boundaries can be unambiguously drawn. Do not allow sensitive data to go outside of the trust boundary and always be careful when interfacing with a compartment outside of the safe area. Ensure that appropriate compartmentalization is built into the system design, and the compartmentalization allows for and reinforces privilege separation functionality. Architects and designers should rely on the principle of least privilege to decide the appropriate time to use privileges and the time to drop privileges.

Demonstrative Examples 8

ID : DX-38

The following code checks validity of the supplied username and password and notifies the user of a successful or failed login.

Code Example:Bad
Perl
perl

In the above code, there are different messages for when an incorrect username is supplied, versus when the username is correct but the password is wrong. This difference enables a potential attacker to understand the state of the login function, and could allow an attacker to discover a valid username by trying different values until the incorrect password message is returned. In essence, this makes it easier for an attacker to obtain half of the necessary authentication credentials.

While this type of information may be helpful to a user, it is also useful to a potential attacker. In the above example, the message for both failed cases should be the same, such as:

Code Example:Result
bash

ID : DX-118

This code tries to open a database connection, and prints any exceptions that occur.

Code Example:

Bad

PHP

php

//print exception message that includes exception message and configuration file location* catch (Exception $e) { ``` echo 'Caught exception: ', $e->getMessage(), '\n'; echo 'Check credentials in config file at: ', $Mysql_config_location, '\n'; }

If an exception occurs, the printed message exposes the location of the configuration file the script is using. An attacker can use this information to target the configuration file (perhaps exploiting a Path Traversal weakness). If the file can be read, the attacker could gain credentials for accessing the database. The attacker may also be able to replace the file with a malicious one, causing the application to use an arbitrary database.

ID : DX-119

In the example below, the method getUserBankAccount retrieves a bank account object from a database using the supplied username and account number to query the database. If an SQLException is raised when querying the database, an error message is created and output to a log file.

Code Example:Bad
Java
java

The error message that is created includes information about the database query that may contain sensitive information about the database or query logic. In this case, the error message will expose the table name and column names used in the database. This data could be used to simplify other attacks, such as SQL injection (Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')) to directly access the database.

ID : DX-120

This code stores location information about the current user:

Code Example:

Bad

Java

java

...*

java

When the application encounters an exception it will write the user object to the log. Because the user object contains location information, the user's location is also written to the log.

ID : DX-129

The following is an actual MySQL error statement:

Code Example:Result
SQL
sql

The error clearly exposes the database credentials.

ID : DX-130

This code displays some information on a web page.

Code Example:Bad
JSP
jsp

The code displays a user's credit card and social security numbers, even though they aren't absolutely necessary.

ID : DX-131

The following program changes its behavior based on a debug flag.

Code Example:Bad
JSP
jsp

The code writes sensitive debug information to the client browser if the "debugEnabled" flag is set to true .

ID : DX-111

This code uses location to determine the user's current US State location.

First the application must declare that it requires the ACCESS_FINE_LOCATION permission in the application's manifest.xml:

Code Example:Bad
XML
xml

During execution, a call to getLastLocation() will return a location based on the application's location permissions. In this case the application has permission for the most accurate location possible:

Code Example:Bad
Java
java

While the application needs this information, it does not need to use the ACCESS_FINE_LOCATION permission, as the ACCESS_COARSE_LOCATION permission will be sufficient to identify which US state the user is in.

Observed Examples 19

CVE-2022-31162Rust library leaks Oauth client details in application debug logs

CVE-2021-25476Digital Rights Management (DRM) capability for mobile platform leaks pointer information, simplifying ASLR bypass

CVE-2001-1483Enumeration of valid usernames based on inconsistent responses

CVE-2001-1528Account number enumeration via inconsistent responses.

CVE-2004-2150User enumeration via discrepancies in error messages.

CVE-2005-1205Telnet protocol allows servers to obtain sensitive environment information from clients.

CVE-2002-1725Script calls phpinfo(), revealing system configuration to web user

CVE-2002-0515Product sets a different TTL when a port is being filtered than when it is not being filtered, which allows remote attackers to identify filtered ports by comparing TTLs.

CVE-2004-0778Version control system allows remote attackers to determine the existence of arbitrary files and directories via the -X command for an alternate history file, which causes different error messages to be returned.

CVE-2000-1117Virtual machine allows malicious web site operators to determine the existence of files on the client by measuring delays in the execution of the getSystemResource method.

CVE-2003-0190Product immediately sends an error message when a user does not exist, which allows remote attackers to determine valid usernames via a timing attack.

CVE-2008-2049POP3 server reveals a password in an error message after multiple APOP commands are sent. Might be resultant from another weakness.

CVE-2007-5172Program reveals password in error message if attacker can trigger certain database errors.

CVE-2008-4638Composite: application running with high privileges (Execution with Unnecessary Privileges) allows user to specify a restricted file to process, which generates a parsing error that leaks the contents of the file (Generation of Error Message Containing Sensitive Information).

CVE-2007-1409Direct request to library file in web application triggers pathname leak in error message.

CVE-2005-0603Malformed regexp syntax leads to information exposure in error message.

CVE-2004-2268Password exposed in debug information.

CVE-2003-1078FTP client with debug option enabled shows password to the screen.

CVE-2022-0708Collaboration platform does not clear team emails in a response, allowing leak of email addresses

References 3

Mobile App Top 10 List

Chris Wysopal

13-12-2010

https://www.veracode.com/blog/2010/12/mobile-app-top-10-list(2023-04-07)

ID: REF-172

Supplemental Details - 2022 CWE Top 25

MITRE

28-06-2022

https://cwe.mitre.org/top25/archive/2022/2022_cwe_top25_supplemental.html#problematicMappingDetails(2024-11-17)

ID: REF-1287

State-of-the-Art Resources (SOAR) for Software Vulnerability Detection, Test, and Evaluation

Gregory Larsen, E. Kenneth Hong Fong, David A. Wheeler, and Rama S. Moorthy

07-2014

https://www.ida.org/-/media/feature/publications/s/st/stateoftheart-resources-soar-for-software-vulnerability-detection-test-and-evaluation/p-5061.ashx(2025-09-05)

ID: REF-1479

Likelihood of Exploit

High

Applicable Platforms

Languages:

Not Language-Specific : Undetermined

Technologies:

Mobile : Undetermined

Modes of Introduction

Architecture and Design

Implementation

Related Attack Patterns

Alternate Terms

Information Disclosure

This term is frequently used in vulnerability advisories to describe a consequence or technical impact, for any vulnerability that has a loss of confidentiality. Often, Exposure of Sensitive Information to an Unauthorized Actor can be misused to represent the loss of confidentiality, even when the mistake - i.e., the weakness - is not directly related to the mishandling of the information itself, such as an out-of-bounds read that accesses sensitive memory contents; here, the out-of-bounds read is the primary weakness, not the disclosure of the memory. In addition, this phrase is also used frequently in policies and legal documents, but it does not refer to any disclosure of security-relevant information.

Information Leak

This is a frequently used term, however the "leak" term has multiple uses within security. In some cases it deals with the accidental exposure of information from a different weakness, but in other cases (such as "memory leak"), this deals with improper tracking of resources, which can lead to exhaustion. As a result, CWE is actively avoiding usage of the "leak" term.

Related Weaknesses

ChildOf:

Exposure of Resource to Wrong Sphere (CWE-668)

Taxonomy Mapping

PLOVER
OWASP Top Ten 2007
WASC

Notes

MaintenanceAs a result of mapping analysis in the 2020 Top 25 and more recent versions, this weakness is under review, since it is frequently misused in mapping to cover many problems that lead to loss of confidentiality. See Mapping Notes, Extended Description, and Alternate Terms.