Debilidades

• CWE-5
  J2EE Misconfiguration: Data Transmission Without Encryption

  This vulnerability occurs when a J2EE application transmits sensitive data, like login credentials or session tokens, across a network without using strong…

• CWE-6
  J2EE Misconfiguration: Insufficient Session-ID Length

  This vulnerability occurs when a J2EE application uses session identifiers that are too short, making them easier for attackers to predict or capture.

• CWE-7
  J2EE Misconfiguration: Missing Custom Error Page

  This vulnerability occurs when a J2EE application uses the server's default error pages instead of custom ones, potentially leaking sensitive system details.

• CWE-8
  J2EE Misconfiguration: Entity Bean Declared Remote

  This vulnerability occurs when an Entity Bean in a J2EE application is incorrectly configured with a remote interface. This exposes data access methods to…

• CWE-9
  J2EE Misconfiguration: Weak Access Permissions for EJB Methods

  This vulnerability occurs when Enterprise JavaBean (EJB) methods are configured with overly permissive access rights, allowing attackers to exploit elevated…

• CWE-11
  ASP.NET Misconfiguration: Creating Debug Binary

  Deploying an ASP.NET application with debug binaries enabled exposes detailed system information, which attackers can use to map your infrastructure and plan…

• CWE-12
  ASP.NET Misconfiguration: Missing Custom Error Page

  This vulnerability occurs when an ASP.NET application fails to configure custom error pages, allowing attackers to extract sensitive information from the…

• CWE-13
  ASP.NET Misconfiguration: Password in Configuration File

  This vulnerability occurs when an ASP.NET application stores passwords or other sensitive credentials in plaintext within configuration files like web.config.…

• CWE-14
  Compiler Removal of Code to Clear Buffers

  A compiler optimization can remove security-critical code intended to wipe sensitive data from memory, leaving secrets exposed. This happens when the compiler…

• CWE-15
  External Control of System or Configuration Setting

  This vulnerability occurs when an application allows users to directly modify critical system settings or configuration values from an external source.

• CWE-20
  Improper Input Validation

  This vulnerability occurs when an application accepts data from an external source but fails to properly verify that the data is safe and correctly formatted…

  High likelihood
• CWE-22
  Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')

  This vulnerability occurs when an application builds a file path using user input but fails to properly validate it, allowing an attacker to break out of the…

  High likelihood
• CWE-23
  Relative Path Traversal

  This vulnerability occurs when an application builds file paths using user-supplied input without properly validating or sanitizing it. Attackers can exploit…

• CWE-24
  Path Traversal: '../filedir'

  Path traversal, often called directory traversal, occurs when an application builds a file path using user input without properly blocking sequences like…

• CWE-25
  Path Traversal: '/../filedir'

  This vulnerability, often called directory traversal, occurs when an application builds a file path using user input without properly blocking sequences like…

• CWE-26
  Path Traversal: '/dir/../filename'

  This vulnerability occurs when an application builds a file path using user input but fails to properly block directory traversal sequences like…

• CWE-27
  Path Traversal: 'dir/../../filename'

  This vulnerability occurs when an application builds file paths using user input but fails to properly block sequences like 'dir/../../filename'. Attackers…

• CWE-28
  Path Traversal: '..\filedir'

  This vulnerability occurs when an application builds a file path using user input but fails to block or properly handle '..\' sequences. This oversight allows…

• CWE-29
  Path Traversal: '\..\filename'

  This vulnerability occurs when an application builds file paths using user input but fails to block '\..\filename' sequences. Attackers can use these leading…

• CWE-30
  Path Traversal: '\dir\..\filename'

  This vulnerability occurs when an application builds file paths using user input but fails to properly sanitize sequences like '\dir\..\filename'. Attackers…

• CWE-31
  Path Traversal: 'dir\..\..\filename'

  This vulnerability occurs when an application builds file paths using user input but fails to properly block sequences like 'dir\..\..\filename'. Attackers…

• CWE-32
  Path Traversal: '...' (Triple Dot)

  This vulnerability occurs when an application builds file paths using user input but fails to properly filter out '...' (triple dot) sequences. Attackers can…

• CWE-33
  Path Traversal: '....' (Multiple Dot)

  This vulnerability occurs when an application builds file paths using user input but fails to properly filter sequences of multiple dots ('....'). Attackers…

• CWE-34
  Path Traversal: '....//'

  This vulnerability occurs when an application builds file paths using user input but fails to properly sanitize '....//' sequences. Attackers can use this…

• CWE-35
  Path Traversal: '.../...//'

  This vulnerability occurs when an application builds file paths using user input but fails to properly sanitize the '.../...//' sequence. Attackers can use…

• CWE-36
  Absolute Path Traversal

  This vulnerability occurs when an application builds file paths using user input without properly blocking absolute paths like '/etc/passwd' or…

• CWE-37
  Path Traversal: '/absolute/pathname/here'

  This vulnerability occurs when an application accepts user input containing absolute file paths (starting with a forward slash like '/etc/passwd') and uses it…

• CWE-38
  Path Traversal: '\absolute\pathname\here'

  This vulnerability occurs when an application accepts user-supplied input containing Windows-style absolute paths (like '\absolute\pathname\here') without…

• CWE-39
  Path Traversal: 'C:dirname'

  This vulnerability occurs when an application accepts user input containing Windows drive letters (like 'C:dirname') without proper validation, allowing…

• CWE-40
  Path Traversal: '\\UNC\share\name\' (Windows UNC Share)

  This vulnerability occurs when an application accepts user input containing a Windows UNC share path (like '\\UNC\share\name') without proper validation,…

• CWE-41
  Improper Resolution of Path Equivalence

  This vulnerability occurs when an application fails to properly handle different text representations that refer to the same file or directory on the system.…

• CWE-42
  Path Equivalence: 'filename.' (Trailing Dot)

  This vulnerability occurs when a system accepts file or directory paths that end with a dot (like 'file.txt.' or 'folder.') without properly checking them.…

• CWE-43
  Path Equivalence: 'filename....' (Multiple Trailing Dot)

  This vulnerability occurs when an application accepts file or directory paths containing multiple trailing dots (like 'file....') without proper validation.…

• CWE-44
  Path Equivalence: 'file.name' (Internal Dot)

  This vulnerability occurs when an application accepts file paths containing internal dots (like 'file.ordir') without properly checking them. Attackers can…

• CWE-45
  Path Equivalence: 'file...name' (Multiple Internal Dot)

  This vulnerability occurs when an application accepts file paths containing sequences of multiple internal dots (like 'file...name') without proper…

• CWE-46
  Path Equivalence: 'filename ' (Trailing Space)

  This vulnerability occurs when an application processes file paths that end with a space character (like 'document.txt ') without properly normalizing or…

• CWE-47
  Path Equivalence: ' filename' (Leading Space)

  This vulnerability occurs when an application accepts file or directory paths that begin with a space character (like ' filename'), without properly…

• CWE-48
  Path Equivalence: 'file name' (Internal Whitespace)

  This vulnerability occurs when an application accepts file paths containing internal spaces (like 'file name') without proper validation. Attackers can…

• CWE-49
  Path Equivalence: 'filename/' (Trailing Slash)

  This vulnerability occurs when an application accepts file or directory paths that end with a slash (e.g., 'documents/') without properly normalizing them.…

• CWE-50
  Path Equivalence: '//multiple/leading/slash'

  This vulnerability occurs when an application accepts file or directory paths containing multiple leading slashes (like '//multiple/leading/slash') without…

• CWE-51
  Path Equivalence: '/multiple//internal/slash'

  This vulnerability occurs when an application accepts file or directory paths containing multiple consecutive forward slashes (e.g., '/var//www///html')…

• CWE-52
  Path Equivalence: '/multiple/trailing/slash//'

  This vulnerability occurs when an application accepts file or directory paths containing multiple consecutive forward slashes (like…

• CWE-53
  Path Equivalence: '\multiple\\internal\backslash'

  This vulnerability occurs when an application accepts file paths containing sequences of multiple internal backslashes (like '\multiple\\internal\\backslash')…

• CWE-54
  Path Equivalence: 'filedir\' (Trailing Backslash)

  This vulnerability occurs when an application accepts file or directory paths that end with a backslash (like 'filedir\') without properly normalizing or…

• CWE-55
  Path Equivalence: '/./' (Single Dot Directory)

  This vulnerability occurs when an application accepts file paths containing '/./' (single dot directory) sequences without proper validation. Attackers can…

• CWE-56
  Path Equivalence: 'filedir*' (Wildcard)

  This vulnerability occurs when an application accepts file or directory paths containing an asterisk wildcard ('*') without proper validation. Attackers can…

• CWE-57
  Path Equivalence: 'fakedir/../realdir/filename'

  This vulnerability occurs when an application uses external input to build file paths, allowing attackers to bypass access controls. By submitting a path like…

• CWE-58
  Path Equivalence: Windows 8.3 Filename

  This vulnerability occurs when an application's security controls successfully block access to a file's full name on Windows, but fail to protect the shorter…

• CWE-59
  Improper Link Resolution Before File Access ('Link Following')

  This vulnerability occurs when an application uses a filename to access a file but fails to properly check if that name points to a symbolic link, shortcut,…

  Medium likelihood
• CWE-61
  UNIX Symbolic Link (Symlink) Following

  This vulnerability occurs when a software application opens files or directories without properly checking if they are symbolic links (symlinks). If an…

  High likelihood
• CWE-62
  UNIX Hard Link

  This vulnerability occurs when an application opens a file or directory without verifying if the name points to a hard link that leads outside its intended…

• CWE-64
  Windows Shortcut Following (.LNK)

  This vulnerability occurs when an application opens a file or directory without properly validating that it is a Windows shortcut (.LNK). If the shortcut's…

  Low likelihood
• CWE-65
  Windows Hard Link

  This vulnerability occurs when a Windows application opens a file or directory without properly verifying if the path points to a hard link. An attacker can…

• CWE-66
  Improper Handling of File Names that Identify Virtual Resources

  This vulnerability occurs when software incorrectly processes a filename that points to a 'virtual' resource—like a device, pipe, or internal system…

• CWE-67
  Improper Handling of Windows Device Names

  This vulnerability occurs when an application builds file paths from user input but fails to properly recognize or handle Windows reserved device names like…

  High likelihood
• CWE-69
  Improper Handling of Windows ::DATA Alternate Data Stream

  This vulnerability occurs when an application fails to properly secure or monitor Windows Alternate Data Streams (ADS), allowing them to be used to hide or…

• CWE-72
  Improper Handling of Apple HFS+ Alternate Data Stream Path

  This vulnerability occurs when software fails to correctly process HFS+ file system paths that point to alternate data streams, such as a file's data or…

• CWE-73
  External Control of File Name or Path

  This vulnerability occurs when an application uses unvalidated user input to construct file or directory paths for filesystem operations.

  High likelihood
• CWE-74
  Improper Neutralization of Special Elements in Output Used by a Downstream Component ('Injection')

  This vulnerability occurs when an application uses untrusted external input to build a command, query, or data structure for another component, but fails to…

  High likelihood
• CWE-75
  Failure to Sanitize Special Elements into a Different Plane (Special Element Injection)

  This vulnerability occurs when an application fails to properly filter or encode user-supplied data containing special characters or commands that can be…

• CWE-76
  Improper Neutralization of Equivalent Special Elements

  This vulnerability occurs when an application successfully blocks or sanitizes a known set of dangerous inputs but fails to recognize and handle alternative…

  High likelihood
• CWE-77
  Improper Neutralization of Special Elements used in a Command ('Command Injection')

  This vulnerability occurs when an application builds a system command using untrusted user input without properly sanitizing it. An attacker can inject their…

  High likelihood
• CWE-78
  Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection')

  OS Command Injection occurs when an application builds a system command using untrusted, external input without properly sanitizing it. This allows an…

  High likelihood
• CWE-79
  Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')

  This vulnerability occurs when a web application fails to properly sanitize or encode user-supplied input before displaying it on a webpage viewed by other…

  High likelihood
• CWE-80
  Improper Neutralization of Script-Related HTML Tags in a Web Page (Basic XSS)

  This vulnerability, commonly known as Basic Cross-Site Scripting (XSS), occurs when a web application fails to properly sanitize user input containing HTML…

  High likelihood
• CWE-81
  Improper Neutralization of Script in an Error Message Web Page

  This vulnerability occurs when an application fails to properly sanitize user-supplied input before displaying it within an error message web page. If special…

• CWE-82
  Improper Neutralization of Script in Attributes of IMG Tags in a Web Page

  This vulnerability occurs when a web application fails to properly sanitize or escape script code within the attributes of HTML IMG tags, such as the 'src'…

• CWE-83
  Improper Neutralization of Script in Attributes in a Web Page

  This vulnerability occurs when a web application fails to properly sanitize or block JavaScript URIs (like 'javascript:') within HTML tag attributes.…

• CWE-84
  Improper Neutralization of Encoded URI Schemes in a Web Page

  This vulnerability occurs when a web application fails to properly sanitize user-supplied input that contains malicious scripts disguised using encoded URI…

• CWE-85
  Doubled Character XSS Manipulations

  This vulnerability occurs when a web application fails to properly sanitize user input that contains doubled characters, allowing attackers to bypass filters…

• CWE-86
  Improper Neutralization of Invalid Characters in Identifiers in Web Pages

  This vulnerability occurs when an application fails to properly filter or escape invalid characters within web identifiers like HTML tag names or URI schemes,…

• CWE-87
  Improper Neutralization of Alternate XSS Syntax

  This vulnerability occurs when an application fails to properly sanitize user-supplied input that uses alternative methods to execute cross-site scripting…

• CWE-88
  Improper Neutralization of Argument Delimiters in a Command ('Argument Injection')

  This vulnerability occurs when an application builds a command string for execution by another component, but fails to properly separate or 'neutralize' the…

• CWE-89
  Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')

  SQL Injection occurs when an application builds a database query using untrusted user input without properly sanitizing it. This allows an attacker to insert…

  High likelihood
• CWE-90
  Improper Neutralization of Special Elements used in an LDAP Query ('LDAP Injection')

  This vulnerability occurs when an application builds an LDAP query using untrusted user input without properly sanitizing it. An attacker can inject special…

• CWE-91
  XML Injection (aka Blind XPath Injection)

  XML Injection occurs when an application fails to properly validate or escape user-controlled input before including it in XML documents or queries. This…

• CWE-93
  Improper Neutralization of CRLF Sequences ('CRLF Injection')

  This vulnerability occurs when an application uses carriage return and line feed characters (CRLF) to structure data, like separating lines or records, but…

• CWE-94
  Improper Control of Generation of Code ('Code Injection')

  This vulnerability occurs when an application builds executable code using unvalidated external input, such as user data. Because the application fails to…

  Medium likelihood
• CWE-95
  Improper Neutralization of Directives in Dynamically Evaluated Code ('Eval Injection')

  This vulnerability occurs when an application takes user input and passes it directly into a dynamic code execution function, like eval(), without properly…

  Medium likelihood
• CWE-96
  Improper Neutralization of Directives in Statically Saved Code ('Static Code Injection')

  Static Code Injection occurs when an application incorporates unvalidated or improperly sanitized user input directly into a static, executable resource like…

• CWE-97
  Improper Neutralization of Server-Side Includes (SSI) Within a Web Page

  This vulnerability occurs when a web application dynamically generates pages but fails to properly sanitize user-supplied input that could be interpreted as…

• CWE-98
  Improper Control of Filename for Include/Require Statement in PHP Program ('PHP Remote File Inclusion')

  This vulnerability occurs when a PHP application uses unvalidated or insufficiently restricted user input directly within file inclusion functions like…

  High likelihood
• CWE-99
  Improper Control of Resource Identifiers ('Resource Injection')

  This vulnerability occurs when an application accepts user input as a resource identifier (like a file path or port number) without proper validation,…

  High likelihood
• CWE-102
  Struts: Duplicate Validation Forms

  This vulnerability occurs when an application defines multiple Struts validation forms with identical names. The framework then unpredictably selects only one…

• CWE-103
  Struts: Incomplete validate() Method Definition

  This vulnerability occurs in a Struts application when a validator form either completely omits a validate() method or includes one but fails to call…

• CWE-104
  Struts: Form Bean Does Not Extend Validation Class

  This vulnerability occurs in Apache Struts applications when a form bean class does not properly extend the framework's validation class. This bypasses the…

• CWE-105
  Struts: Form Field Without Validator

  This vulnerability occurs when a Struts application form contains an input field that lacks a corresponding validator, leaving it open to unverified user input.

• CWE-106
  Struts: Plug-in Framework not in Use

  This weakness occurs when a Java application, particularly one using the Struts framework, does not implement a structured input validation plugin like the…

• CWE-107
  Struts: Unused Validation Form

  This vulnerability occurs when a Struts application contains validation form definitions that are no longer linked to any active form or action, leaving…

• CWE-108
  Struts: Unvalidated Action Form

  In Apache Struts, every Action Form that processes user input must have a corresponding validation form configured. Missing this validation exposes the…

• CWE-109
  Struts: Validator Turned Off

  This vulnerability occurs when an application built with Apache Struts intentionally disables its built-in validation framework. By turning off the Struts…

• CWE-110
  Struts: Validator Without Form Field

  This vulnerability occurs when a Struts application's validation configuration file references form fields that no longer exist in the corresponding…

• CWE-111
  Direct Use of Unsafe JNI

  This weakness occurs when a Java application directly calls native code through the Java Native Interface (JNI), exposing the entire application to security…

• CWE-112
  Missing XML Validation

  This vulnerability occurs when an application processes XML data from an untrusted source without first validating its structure and content against a defined…

• CWE-113
  Improper Neutralization of CRLF Sequences in HTTP Headers ('HTTP Request/Response Splitting')

  This vulnerability occurs when an application accepts user-supplied data and includes it directly in HTTP headers without properly filtering out carriage…

• CWE-114
  Process Control

  Process Control vulnerabilities occur when an application executes commands or loads libraries from an untrusted source or environment, allowing an attacker…

• CWE-115
  Misinterpretation of Input

  This vulnerability occurs when software incorrectly interprets or processes input data, leading to unintended and potentially harmful security consequences.…

• CWE-116
  Improper Encoding or Escaping of Output

  This vulnerability occurs when an application builds a structured message—like a query, command, or request—for another component but fails to properly encode…

  High likelihood
• CWE-117
  Improper Output Neutralization for Logs

  This vulnerability occurs when an application creates log entries using unvalidated external data, allowing attackers to inject malicious characters or…

  Medium likelihood
• CWE-118
  Incorrect Access of Indexable Resource ('Range Error')

  This vulnerability occurs when software fails to properly check the boundaries of an indexed resource, like an array, buffer, or file, before accessing it.…

• CWE-119
  Improper Restriction of Operations within the Bounds of a Memory Buffer

  This vulnerability occurs when software accesses a memory buffer but reads from or writes to a location outside its allocated boundary. This can corrupt…

  High likelihood
• CWE-120
  Buffer Copy without Checking Size of Input ('Classic Buffer Overflow')

  This vulnerability occurs when a program copies data from one memory location to another without first verifying that the source data will fit within the…

  High likelihood
• CWE-121
  Stack-based Buffer Overflow

  A stack-based buffer overflow occurs when a program writes more data to a buffer located on the call stack than it can hold, corrupting adjacent memory and…

  High likelihood
• CWE-122
  Heap-based Buffer Overflow

  A heap-based buffer overflow occurs when a program writes more data to a memory buffer allocated in the heap than it can hold, corrupting adjacent memory…

  High likelihood
• CWE-123
  Write-what-where Condition

  A write-what-where condition occurs when an attacker can control both the data written and the exact memory location where it's written, often due to a severe…

  High likelihood
• CWE-124
  Buffer Underwrite ('Buffer Underflow')

  A buffer underwrite, also known as buffer underflow, happens when a program writes data to a memory location before the official start of a buffer.

  Medium likelihood
• CWE-125
  Out-of-bounds Read

  An out-of-bounds read occurs when software accesses memory outside the boundaries of a buffer, array, or similar data structure, reading data it wasn't…

• CWE-126
  Buffer Over-read

  This vulnerability occurs when a program reads data from a memory buffer using an index or pointer that points beyond the buffer's allocated boundary,…

• CWE-127
  Buffer Under-read

  A buffer under-read occurs when a program attempts to read data from a memory location positioned before the start of an allocated buffer.

• CWE-128
  Wrap-around Error

  A wrap-around error happens when a variable exceeds the maximum value its data type can hold, causing it to unexpectedly reset to a very small, negative, or…

  Medium likelihood
• CWE-129
  Improper Validation of Array Index

  This vulnerability occurs when software uses unverified, external input to calculate or access an array index, without properly checking that the index points…

  High likelihood
• CWE-130
  Improper Handling of Length Parameter Inconsistency

  This vulnerability occurs when a program reads a structured data packet or message but fails to properly validate that the declared length field matches the…

• CWE-131
  Incorrect Calculation of Buffer Size

  This vulnerability occurs when a program miscalculates the amount of memory needed for a buffer, potentially leading to a buffer overflow that can crash the…

  High likelihood
• CWE-134
  Use of Externally-Controlled Format String

  This vulnerability occurs when a program uses a format string from an untrusted, external source (like user input, a network packet, or a file) in a…

  High likelihood
• CWE-135
  Incorrect Calculation of Multi-Byte String Length

  This vulnerability occurs when software incorrectly measures the length of strings containing multi-byte or wide characters, leading to buffer overflows, data…

• CWE-138
  Improper Neutralization of Special Elements

  This vulnerability occurs when an application accepts external input but fails to properly sanitize special characters or syntax that have specific meanings…

• CWE-140
  Improper Neutralization of Delimiters

  This vulnerability occurs when an application fails to properly handle or sanitize delimiter characters within data inputs, allowing them to be misinterpreted…

• CWE-141
  Improper Neutralization of Parameter/Argument Delimiters

  This vulnerability occurs when an application fails to properly sanitize special characters that act as delimiters in data being passed between system…

• CWE-142
  Improper Neutralization of Value Delimiters

  This vulnerability occurs when an application fails to properly sanitize or escape special characters that act as data separators (delimiters) before passing…

• CWE-143
  Improper Neutralization of Record Delimiters

  This vulnerability occurs when an application fails to properly sanitize or escape special characters that function as record separators in data streams. When…

• CWE-144
  Improper Neutralization of Line Delimiters

  This vulnerability occurs when an application fails to properly sanitize or escape line break characters (like newline or carriage return) in user-supplied…

• CWE-145
  Improper Neutralization of Section Delimiters

  This vulnerability occurs when an application fails to properly sanitize or validate special characters that act as section delimiters in data streams. When…

• CWE-146
  Improper Neutralization of Expression/Command Delimiters

  This vulnerability occurs when an application fails to properly sanitize input that contains special characters used as delimiters in expressions or commands.…

• CWE-147
  Improper Neutralization of Input Terminators

  This vulnerability occurs when an application accepts external input but fails to properly handle special characters that downstream systems interpret as…

• CWE-148
  Improper Neutralization of Input Leaders

  This vulnerability occurs when an application fails to properly validate or handle input that begins with special control characters or sequences, known as…

• CWE-149
  Improper Neutralization of Quoting Syntax

  This vulnerability occurs when an application fails to properly validate or escape quote characters (like single ' or double " quotes) in user input.…

• CWE-150
  Improper Neutralization of Escape, Meta, or Control Sequences

  This vulnerability occurs when an application fails to properly sanitize or escape special character sequences in user-supplied input before passing that data…

• CWE-151
  Improper Neutralization of Comment Delimiters

  This vulnerability occurs when an application accepts user input and fails to properly sanitize characters that can be interpreted as comment markers (like…

• CWE-152
  Improper Neutralization of Macro Symbols

  This vulnerability occurs when an application accepts user input containing macro symbols (like those used in templates or configuration files) and passes it…

• CWE-153
  Improper Neutralization of Substitution Characters

  This vulnerability occurs when an application accepts user input and fails to properly sanitize special characters that can trigger command or variable…

• CWE-154
  Improper Neutralization of Variable Name Delimiters

  This vulnerability occurs when an application fails to properly sanitize or escape special characters that act as delimiters for variable names before passing…

• CWE-155
  Improper Neutralization of Wildcards or Matching Symbols

  This vulnerability occurs when an application fails to properly sanitize user-supplied input containing wildcard characters (like *, ?, or [ ]) before passing…

• CWE-156
  Improper Neutralization of Whitespace

  This vulnerability occurs when an application fails to properly handle or sanitize whitespace characters in input before passing that data to another system…

• CWE-157
  Failure to Sanitize Paired Delimiters

  This vulnerability occurs when an application fails to properly validate or neutralize the special characters that come in pairs to define boundaries, such as…

• CWE-158
  Improper Neutralization of Null Byte or NUL Character

  This weakness occurs when an application receives data but fails to properly handle or remove NUL characters (\0) before passing that data to another system…

• CWE-159
  Improper Handling of Invalid Use of Special Elements

  This vulnerability occurs when an application fails to properly validate or neutralize special characters and control elements within user-supplied input.…

• CWE-160
  Improper Neutralization of Leading Special Elements

  This vulnerability occurs when an application accepts external input but fails to properly sanitize leading special characters or commands before passing that…

• CWE-161
  Improper Neutralization of Multiple Leading Special Elements

  This vulnerability occurs when an application accepts external input but fails to properly sanitize multiple special characters or sequences at the beginning…

• CWE-162
  Improper Neutralization of Trailing Special Elements

  This vulnerability occurs when an application fails to properly sanitize or remove trailing special characters from user-supplied input before passing it to…

• CWE-163
  Improper Neutralization of Multiple Trailing Special Elements

  This vulnerability occurs when software accepts external input but fails to properly sanitize or incorrectly handles multiple trailing special characters or…

• CWE-164
  Improper Neutralization of Internal Special Elements

  This vulnerability occurs when an application accepts data from a source but fails to properly sanitize internal control elements or metadata before passing…

• CWE-165
  Improper Neutralization of Multiple Internal Special Elements

  This vulnerability occurs when an application accepts external input but fails to properly sanitize multiple internal control characters or delimiters before…

• CWE-166
  Improper Handling of Missing Special Element

  This vulnerability occurs when software expects a specific delimiter, terminator, or other special marker in its input but fails to properly handle situations…

• CWE-167
  Improper Handling of Additional Special Element

  This vulnerability occurs when software receives data from another component but fails to properly process or validate unexpected special characters or…

• CWE-168
  Improper Handling of Inconsistent Special Elements

  This vulnerability occurs when software fails to correctly process input containing conflicting or mismatched special elements like characters, symbols, or…

• CWE-170
  Improper Null Termination

  This weakness occurs when software fails to properly end a string or array with the required null character or equivalent terminator.

  Medium likelihood
• CWE-172
  Encoding Error

  This vulnerability occurs when software incorrectly transforms data between different formats, leading to corrupted or misinterpreted information that can…

• CWE-173
  Improper Handling of Alternate Encoding

  This vulnerability occurs when software fails to correctly process input that arrives in a different character encoding than expected, allowing that input to…

• CWE-174
  Double Decoding of the Same Data

  This vulnerability occurs when an application decodes the same piece of data twice in sequence. This double processing can bypass or neutralize security…

• CWE-175
  Improper Handling of Mixed Encoding

  This vulnerability occurs when software fails to correctly process input that contains multiple character encodings within the same data stream.

• CWE-176
  Improper Handling of Unicode Encoding

  This vulnerability occurs when software fails to correctly process or interpret Unicode-encoded input, leading to security bypasses, data corruption, or…

• CWE-177
  Improper Handling of URL Encoding (Hex Encoding)

  This vulnerability occurs when an application fails to correctly process URL-encoded (also known as percent-encoded or hex-encoded) input, either by…

• CWE-178
  Improper Handling of Case Sensitivity

  This vulnerability occurs when software fails to consistently handle uppercase and lowercase letters when checking or accessing resources, leading to…

• CWE-179
  Incorrect Behavior Order: Early Validation

  This vulnerability occurs when an application validates user input before applying security filters or data normalization. Attackers can exploit this order of…

• CWE-180
  Incorrect Behavior Order: Validate Before Canonicalize

  This vulnerability occurs when a system checks user input for malicious content before standardizing its format, allowing specially crafted data to bypass…

• CWE-181
  Incorrect Behavior Order: Validate Before Filter

  This vulnerability occurs when a system checks user input for validity before cleaning or filtering it. This flawed sequence allows malicious data to pass…

• CWE-182
  Collapse of Data into Unsafe Value

  This vulnerability occurs when an application's data filtering or transformation process incorrectly merges or simplifies information, producing a result that…

• CWE-183
  Permissive List of Allowed Inputs

  This vulnerability occurs when an application's security filter uses an allowlist that is too broad, mistakenly permitting dangerous inputs that should have…

• CWE-184
  Incomplete List of Disallowed Inputs

  This vulnerability occurs when a security filter or validation mechanism relies on a 'denylist'—a predefined list of forbidden inputs—but that list is missing…

• CWE-185
  Incorrect Regular Expression

  This vulnerability occurs when a regular expression is written incorrectly, causing it to match or validate data in unintended and potentially dangerous ways.

• CWE-186
  Overly Restrictive Regular Expression

  This weakness occurs when a regular expression is too narrow, failing to detect all the dangerous or unexpected input values it was designed to catch.

• CWE-187
  Partial String Comparison

  This weakness occurs when software checks only part of a string or token to determine a match, instead of comparing the entire value. This incomplete…

• CWE-188
  Reliance on Data/Memory Layout

  This vulnerability occurs when software incorrectly assumes how data is structured in memory or within network packets, leading to unexpected behavior when…

  Low likelihood
• CWE-190
  Integer Overflow or Wraparound

  Integer overflow or wraparound occurs when a calculation produces a numeric result that exceeds the maximum value a variable can hold. Instead of increasing…

  Medium likelihood
• CWE-191
  Integer Underflow (Wrap or Wraparound)

  Integer underflow occurs when a subtraction operation results in a value smaller than the data type's minimum limit, causing the value to wrap around to a…

• CWE-192
  Integer Coercion Error

  An integer coercion error occurs when a program incorrectly converts, extends, or truncates a number between different data types, leading to unexpected values.

  Medium likelihood
• CWE-193
  Off-by-one Error

  An off-by-one error occurs when a program incorrectly calculates a boundary, such as a loop counter or array index, by being one unit too high or too low.…

• CWE-194
  Unexpected Sign Extension

  This vulnerability occurs when a signed number from a smaller data type is moved or cast to a larger type, causing its sign bit to be incorrectly extended. If…

  High likelihood
• CWE-195
  Signed to Unsigned Conversion Error

  This vulnerability occurs when a signed integer (which can hold negative values) is converted to an unsigned integer (which holds only non-negative values).…

• CWE-196
  Unsigned to Signed Conversion Error

  This vulnerability occurs when a program takes an unsigned integer and converts it directly to a signed integer. If the original unsigned value is too large…

  Medium likelihood
• CWE-197
  Numeric Truncation Error

  A numeric truncation error happens when a program converts a number to a smaller data type, cutting off its higher-order bits and corrupting the original value.

  Low likelihood
• CWE-198
  Use of Incorrect Byte Ordering

  This vulnerability occurs when software processes data from another system without considering byte order (endianness), such as big-endian or little-endian.…

• CWE-200
  Exposure of Sensitive Information to an Unauthorized Actor

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

  High likelihood
• CWE-201
  Insertion of Sensitive Information Into Sent Data

  This vulnerability occurs when an application sends data to an external party, but accidentally includes sensitive information—like passwords, keys, or…

• CWE-202
  Exposure of Sensitive Information Through Data Queries

  This vulnerability occurs when an attacker uses statistical analysis on aggregated or anonymized data to uncover sensitive details about individuals, even…

  Medium likelihood
• CWE-203
  Observable Discrepancy

  This vulnerability occurs when an application responds differently to unauthorized users based on internal conditions. Attackers can observe these…

• CWE-204
  Observable Response Discrepancy

  This vulnerability occurs when an application responds differently to similar requests, unintentionally leaking details about its internal state or logic to…

• CWE-205
  Observable Behavioral Discrepancy

  This vulnerability occurs when an application behaves differently in ways that unauthorized users can detect. These observable differences can reveal internal…

• CWE-206
  Observable Internal Behavioral Discrepancy

  This vulnerability occurs when a system's internal steps or decisions become visible to an attacker because the system behaves differently at each stage.…

• CWE-207
  Observable Behavioral Discrepancy With Equivalent Products

  This vulnerability occurs when a system that should remain anonymous behaves differently than other products with the same purpose, allowing attackers to…

• CWE-208
  Observable Timing Discrepancy

  This vulnerability occurs when an application takes measurably different amounts of time to perform different operations, such as checking a password or…

• CWE-209
  Generation of Error Message Containing Sensitive Information

  This vulnerability occurs when an application reveals sensitive details about its internal systems, user data, or environment within error messages shown to…

  High likelihood
• CWE-210
  Self-generated Error Message Containing Sensitive Information

  This vulnerability occurs when an application detects a problem and generates its own error messages that accidentally expose sensitive system or user data.

• CWE-211
  Externally-Generated Error Message Containing Sensitive Information

  This vulnerability occurs when an application triggers an error message from an external component—like a database, interpreter, or operating system—and that…

• CWE-212
  Improper Removal of Sensitive Information Before Storage or Transfer

  This vulnerability occurs when an application stores or transmits a resource containing sensitive data without properly cleaning it first, potentially…

• CWE-213
  Exposure of Sensitive Information Due to Incompatible Policies

  This vulnerability occurs when a system's data handling aligns with the developer's security rules but accidentally reveals information that other…

• CWE-214
  Invocation of Process Using Visible Sensitive Information

  This vulnerability occurs when a process is started with sensitive data, such as passwords or API keys, passed directly in its command-line arguments or…

• CWE-215
  Insertion of Sensitive Information Into Debugging Code

  This vulnerability occurs when developers embed sensitive data, such as passwords or API keys, within debugging statements like logs or console outputs, and…

• CWE-219
  Storage of File with Sensitive Data Under Web Root

  This vulnerability occurs when an application saves sensitive files, such as configuration data or private keys, inside the web server's publicly accessible…

• CWE-220
  Storage of File With Sensitive Data Under FTP Root

  This vulnerability occurs when an application saves sensitive files, such as configuration or user data, within the directory served by an FTP server without…

• CWE-221
  Information Loss or Omission

  This weakness occurs when an application fails to log critical security events or records them inaccurately, which can misguide security decisions and hinder…

• CWE-222
  Truncation of Security-relevant Information

  This vulnerability occurs when a system shortens or cuts off security-critical data during display, logging, or processing. This truncation can hide the true…

• CWE-223
  Omission of Security-relevant Information

  This vulnerability occurs when an application fails to capture or present crucial security-related details, such as the origin of a request or the specifics…

• CWE-224
  Obscured Security-relevant Information by Alternate Name

  This vulnerability occurs when a system logs or reports security-critical events using a nickname or alias for a component, instead of its official, unique…

• CWE-226
  Sensitive Information in Resource Not Removed Before Reuse

  This vulnerability occurs when a system releases a resource like memory or a file for reuse but fails to erase the sensitive data it previously contained. The…

• CWE-228
  Improper Handling of Syntactically Invalid Structure

  This vulnerability occurs when software fails to properly reject or process input that doesn't follow the expected format or structure, often leading to…

• CWE-229
  Improper Handling of Values

  This vulnerability occurs when software fails to correctly process situations where input contains too few values, too many values, or undefined values for…

• CWE-230
  Improper Handling of Missing Values

  This vulnerability occurs when software fails to properly check for or handle missing data values. It happens when a parameter, field, or argument name is…

• CWE-231
  Improper Handling of Extra Values

  This vulnerability occurs when software receives more input values than it was designed to handle, and fails to properly manage or reject the excess data.

• CWE-232
  Improper Handling of Undefined Values

  This vulnerability occurs when software fails to properly check for or handle undefined, null, or unsupported values passed to parameters, configuration…

• CWE-233
  Improper Handling of Parameters

  This vulnerability occurs when software fails to correctly process input that contains an unexpected number of parameters, missing fields, or undefined…

• CWE-234
  Failure to Handle Missing Parameter

  This vulnerability occurs when a function or method receives fewer arguments than it expects. The function will still attempt to process its expected number…

  High likelihood
• CWE-235
  Improper Handling of Extra Parameters

  This vulnerability occurs when a system fails to properly manage situations where it receives more parameters, fields, or arguments with the same name than it…

• CWE-236
  Improper Handling of Undefined Parameters

  This vulnerability occurs when software fails to properly manage input parameters, field names, or arguments that it doesn't recognize or support. Instead of…

• CWE-237
  Improper Handling of Structural Elements

  This vulnerability occurs when an application fails to properly validate, sanitize, or interpret the complex internal parts of structured data, such as file…

• CWE-238
  Improper Handling of Incomplete Structural Elements

  This vulnerability occurs when software fails to properly process or validate data structures that are missing required components or are only partially formed.

• CWE-239
  Failure to Handle Incomplete Element

  This vulnerability occurs when a system fails to properly manage or validate data elements that are missing required parts or are only partially defined.

• CWE-240
  Improper Handling of Inconsistent Structural Elements

  This vulnerability occurs when a system fails to properly manage situations where related data structures or elements should match but are inconsistent.

• CWE-241
  Improper Handling of Unexpected Data Type

  This vulnerability occurs when software fails to properly validate or safely process data that arrives in an unexpected format. For example, the system might…

• CWE-242
  Use of Inherently Dangerous Function

  This vulnerability occurs when code uses functions that are inherently unsafe and cannot be reliably secured, posing a direct risk to application stability…

  High likelihood
• CWE-243
  Creation of chroot Jail Without Changing Working Directory

  This vulnerability occurs when a program creates a chroot jail but fails to change its current working directory afterward. Because the process's working…

  High likelihood
• CWE-244
  Improper Clearing of Heap Memory Before Release ('Heap Inspection')

  Using realloc() to resize buffers containing secrets like passwords or keys can leave that sensitive data exposed in memory, as the original data is not…

• CWE-245
  J2EE Bad Practices: Direct Management of Connections

  This vulnerability occurs when a J2EE application handles database connections directly instead of using the container's built-in connection management system.

• CWE-246
  J2EE Bad Practices: Direct Use of Sockets

  This vulnerability occurs when a J2EE application creates network sockets directly, bypassing the container-managed communication framework provided by the…

• CWE-248
  Uncaught Exception

  This vulnerability occurs when a function throws an error or exception, but the calling code does not have a proper handler to catch and manage it.

• CWE-250
  Execution with Unnecessary Privileges

  This vulnerability occurs when software runs with higher permissions than it actually needs to perform its tasks. This excessive privilege creates security…

  Medium likelihood
• CWE-252
  Unchecked Return Value

  This vulnerability occurs when a program fails to verify the result of a function or method call, allowing it to continue execution without detecting errors…

  Low likelihood
• CWE-253
  Incorrect Check of Function Return Value

  This vulnerability occurs when a program misinterprets or improperly validates the return value from a function, causing it to miss critical error states or…

  Low likelihood
• CWE-256
  Plaintext Storage of a Password

  This vulnerability occurs when an application stores user passwords as readable text instead of using secure, one-way hashing. This insecure practice exposes…

  High likelihood
• CWE-257
  Storing Passwords in a Recoverable Format

  This vulnerability occurs when an application stores user passwords in a format that can be easily reversed or decrypted back to their original plaintext…

  High likelihood
• CWE-258
  Empty Password in Configuration File

  This vulnerability occurs when a configuration file, script, or application uses an empty string as a password, effectively disabling authentication for a…

  High likelihood
• CWE-259
  Use of Hard-coded Password

  This vulnerability occurs when an application embeds a password directly into its source code or configuration files. This hard-coded secret is then used…

  High likelihood
• CWE-260
  Password in Configuration File

  This vulnerability occurs when an application stores sensitive passwords directly within a configuration file, making them easily readable to anyone with…

• CWE-261
  Weak Encoding for Password

  Using simple encoding like Base64 to hide a password provides no real security, as it can be easily reversed.

• CWE-262
  Not Using Password Aging

  This vulnerability occurs when a system lacks password expiration policies, allowing users to keep the same password indefinitely.

  Low likelihood
• CWE-263
  Password Aging with Long Expiration

  The system enforces password changes, but the time allowed between changes is excessively long, weakening security.

  Low likelihood
• CWE-266
  Incorrect Privilege Assignment

  This vulnerability occurs when a system mistakenly grants a user, process, or entity a specific permission or privilege they should not have. This error…

• CWE-267
  Privilege Defined With Unsafe Actions

  This vulnerability occurs when a system grants a user, role, or process a specific permission that can be misused to perform dangerous, unintended actions.…

• CWE-268
  Privilege Chaining

  Privilege chaining occurs when an attacker combines two separate permissions or capabilities, neither of which is dangerous on its own, to perform a harmful…

  High likelihood
• CWE-269
  Improper Privilege Management

  This vulnerability occurs when an application fails to correctly manage user permissions, allowing someone to perform actions or access data beyond their…

  Medium likelihood
• CWE-270
  Privilege Context Switching Error

  This vulnerability occurs when an application fails to properly manage user permissions while moving between different security contexts, potentially allowing…

• CWE-271
  Privilege Dropping / Lowering Errors

  This vulnerability occurs when a system or process fails to reduce its elevated permissions before transferring control of a resource to a less-privileged…

  High likelihood
• CWE-272
  Least Privilege Violation

  This vulnerability occurs when software fails to reduce its elevated system privileges after completing a sensitive operation, leaving it with unnecessary and…

• CWE-273
  Improper Check for Dropped Privileges

  This vulnerability occurs when an application tries to lower its system privileges but fails to verify that the operation was successful.

  Medium likelihood
• CWE-274
  Improper Handling of Insufficient Privileges

  This vulnerability occurs when an application fails to properly manage situations where it lacks the necessary permissions to execute an action. This flawed…

• CWE-276
  Incorrect Default Permissions

  This vulnerability occurs when software installation scripts set overly permissive file or directory access rights by default. Instead of restricting write…

  Medium likelihood
• CWE-277
  Insecure Inherited Permissions

  This vulnerability occurs when an application sets default file or directory permissions that are too permissive, and these insecure settings are…

• CWE-278
  Insecure Preserved Inherited Permissions

  This vulnerability occurs when a software product copies or extracts files while unintentionally preserving insecure permissions from their original source,…

• CWE-279
  Incorrect Execution-Assigned Permissions

  This vulnerability occurs when a running application incorrectly changes an object's access permissions, overriding the security settings that a user or…

• CWE-280
  Improper Handling of Insufficient Permissions or Privileges

  This vulnerability occurs when a system fails to properly manage situations where it lacks the necessary permissions to perform an action or access a…

• CWE-281
  Improper Preservation of Permissions

  This vulnerability occurs when a system fails to correctly maintain file or object permissions during operations like copying, sharing, or restoring data. As…

• CWE-282
  Improper Ownership Management

  This vulnerability occurs when a system incorrectly assigns or fails to verify which user or process rightfully controls a specific object or resource.

• CWE-283
  Unverified Ownership

  This vulnerability occurs when an application fails to confirm that a user has legitimate ownership rights to a sensitive resource before allowing them to…

• CWE-284
  Improper Access Control

  The software fails to properly limit who can access a resource, allowing unauthorized users or systems to interact with it.

• CWE-285
  Improper Authorization

  This vulnerability occurs when an application fails to properly verify whether a user has permission to access specific data or perform certain actions before…

  High likelihood
• CWE-286
  Incorrect User Management

  This vulnerability occurs when an application incorrectly handles user accounts, roles, or group memberships, leading to improper access control.

• CWE-287
  Improper Authentication

  Improper Authentication occurs when a system fails to properly verify a user's claimed identity, allowing access without sufficient proof of who they are.

  High likelihood
• CWE-288
  Authentication Bypass Using an Alternate Path or Channel

  This vulnerability occurs when a system has a primary login requirement, but attackers can find an unprotected backdoor or alternative route that completely…

• CWE-289
  Authentication Bypass by Alternate Name

  This vulnerability occurs when a system checks access based on a resource or user name, but fails to account for all the different names or aliases that could…

• CWE-290
  Authentication Bypass by Spoofing

  This weakness occurs when an application's authentication system can be tricked into accepting forged or manipulated credentials, allowing unauthorized access…

• CWE-291
  Reliance on IP Address for Authentication

  This vulnerability occurs when a system uses a client's IP address as the sole or primary method to verify their identity.

  High likelihood
• CWE-293
  Using Referer Field for Authentication

  This vulnerability occurs when a web application uses the HTTP Referer header as a sole or primary method for authentication or authorization decisions. Since…

  High likelihood
• CWE-294
  Authentication Bypass by Capture-replay

  This vulnerability occurs when an attacker can intercept and record legitimate authentication traffic, then replay it later to gain unauthorized access. The…

  High likelihood
• CWE-295
  Improper Certificate Validation

  This vulnerability occurs when an application fails to properly verify the authenticity of a digital certificate, or performs the verification incorrectly,…

• CWE-296
  Improper Following of a Certificate's Chain of Trust

  This vulnerability occurs when software fails to properly validate the entire certificate chain back to a trusted root authority. This mistake can cause the…

  Low likelihood
• CWE-297
  Improper Validation of Certificate with Host Mismatch

  This vulnerability occurs when an application accepts a valid SSL/TLS certificate without properly verifying that it actually belongs to the specific host…

  High likelihood
• CWE-298
  Improper Validation of Certificate Expiration

  This vulnerability occurs when an application fails to properly check if a digital certificate has expired, potentially trusting certificates that are no…

  Low likelihood
• CWE-299
  Improper Check for Certificate Revocation

  This vulnerability occurs when an application fails to properly verify whether a security certificate has been revoked, potentially allowing it to accept and…

  Medium likelihood
• CWE-300
  Channel Accessible by Non-Endpoint

  This vulnerability occurs when a system fails to properly verify who is on the other end of a communication link or to secure the channel itself. This allows…

• CWE-301
  Reflection Attack in an Authentication Protocol

  A reflection attack is a flaw in mutual authentication protocols that allows an attacker to impersonate a legitimate user without knowing the secret key. This…

  Medium likelihood
• CWE-302
  Authentication Bypass by Assumed-Immutable Data

  This vulnerability occurs when an authentication system incorrectly treats certain data as unchangeable, when in fact an attacker can manipulate it to bypass…

• CWE-303
  Incorrect Implementation of Authentication Algorithm

  This weakness occurs when a developer implements a standard authentication algorithm, but makes critical mistakes in the code that cause it to function…

• CWE-304
  Missing Critical Step in Authentication

  This vulnerability occurs when a software authentication process omits a required step, weakening its overall security.

• CWE-305
  Authentication Bypass by Primary Weakness

  This vulnerability occurs when a system's core authentication logic is technically correct, but an attacker can completely bypass it by exploiting a separate,…

• CWE-306
  Missing Authentication for Critical Function

  This vulnerability occurs when a software feature that performs a sensitive action or uses significant system resources does not verify the user's identity…

  High likelihood
• CWE-307
  Improper Restriction of Excessive Authentication Attempts

  This vulnerability occurs when an application fails to properly limit how many times someone can attempt to log in or verify their identity in rapid…

• CWE-308
  Use of Single-factor Authentication

  Relying solely on single-factor authentication, like a password, exposes systems to significant security risks because it depends on only one type of proof…

  High likelihood
• CWE-309
  Use of Password System for Primary Authentication

  This weakness occurs when an application relies solely on password-based authentication as its main security gate. This single-factor approach is inherently…

  High likelihood
• CWE-311
  Missing Encryption of Sensitive Data

  This vulnerability occurs when an application stores or sends sensitive information without first encrypting it, leaving the data exposed.

  High likelihood
• CWE-312
  Cleartext Storage of Sensitive Information

  This vulnerability occurs when an application stores sensitive data like passwords, credit card numbers, or personal information in plain text, without any…

• CWE-313
  Cleartext Storage in a File or on Disk

  This vulnerability occurs when an application writes sensitive data, such as passwords or personal information, directly to a file or disk without using…

• CWE-314
  Cleartext Storage in the Registry

  This vulnerability occurs when an application saves sensitive data, like passwords or keys, as plain text in the Windows Registry.

• CWE-315
  Cleartext Storage of Sensitive Information in a Cookie

  This vulnerability occurs when an application directly stores sensitive data, like session tokens or personal details, in a browser cookie without encryption.

• CWE-316
  Cleartext Storage of Sensitive Information in Memory

  This vulnerability occurs when an application stores sensitive data, such as passwords or encryption keys, in memory without any form of encryption or…

• CWE-317
  Cleartext Storage of Sensitive Information in GUI

  This vulnerability occurs when an application stores sensitive data, such as passwords or personal information, in plain text within its graphical user…

• CWE-318
  Cleartext Storage of Sensitive Information in Executable

  This vulnerability occurs when an application embeds sensitive information, like passwords or keys, directly within its executable code without encryption.

• CWE-319
  Cleartext Transmission of Sensitive Information

  This vulnerability occurs when an application sends sensitive data, such as passwords or personal information, over a network connection without using…

  High likelihood
• CWE-321
  Use of Hard-coded Cryptographic Key

  This vulnerability occurs when an application embeds a fixed, unchangeable cryptographic key directly within its source code or configuration files.

  High likelihood
• CWE-322
  Key Exchange without Entity Authentication

  This vulnerability occurs when a system establishes a cryptographic key with another party without first confirming that party's true identity.

  High likelihood
• CWE-323
  Reusing a Nonce, Key Pair in Encryption

  This vulnerability occurs when a cryptographic nonce or key pair is reused, compromising the security of the encrypted data.

  High likelihood
• CWE-324
  Use of a Key Past its Expiration Date

  This vulnerability occurs when an application continues to use a cryptographic key or password after its designated expiration date. Doing so dramatically…

  Low likelihood
• CWE-325
  Missing Cryptographic Step

  This vulnerability occurs when a software implementation skips a critical step in a cryptographic process, resulting in security that is significantly weaker…

• CWE-326
  Inadequate Encryption Strength

  This vulnerability occurs when an application protects sensitive information with encryption, but the specific algorithm or key strength used is too weak to…

• CWE-327
  Use of a Broken or Risky Cryptographic Algorithm

  The software relies on a cryptographic algorithm or protocol that is either fundamentally flawed or considered too weak by modern security standards.

  High likelihood
• CWE-328
  Use of Weak Hash

  This vulnerability occurs when software uses a hashing algorithm that is cryptographically weak, allowing attackers to feasibly reverse the hash to find the…

• CWE-329
  Generation of Predictable IV with CBC Mode

  This vulnerability occurs when software uses a predictable or reused Initialization Vector (IV) with Cipher Block Chaining (CBC) mode encryption. Predictable…

  Medium likelihood
• CWE-330
  Use of Insufficiently Random Values

  This vulnerability occurs when an application uses random values that are not sufficiently unpredictable in security-sensitive operations, making them easier…

  High likelihood
• CWE-331
  Insufficient Entropy

  This vulnerability occurs when a system's random number generator or algorithm lacks sufficient unpredictability, creating patterns or predictable outputs…

• CWE-332
  Insufficient Entropy in PRNG

  This vulnerability occurs when a Pseudo-Random Number Generator (PRNG) doesn't have enough randomness (entropy) to start with, or isn't using enough during…

  Medium likelihood
• CWE-333
  Improper Handling of Insufficient Entropy in TRNG

  This vulnerability occurs when a system fails to properly manage the limited or unpredictable output rate of a true random number generator (TRNG),…

  Low likelihood
• CWE-334
  Small Space of Random Values

  This vulnerability occurs when a system uses a random number generator that produces too few possible values. Attackers can easily predict or guess these…

• CWE-335
  Incorrect Usage of Seeds in Pseudo-Random Number Generator (PRNG)

  This vulnerability occurs when a Pseudo-Random Number Generator (PRNG) is used, but its initial seed value is not handled securely or predictably,…

• CWE-336
  Same Seed in Pseudo-Random Number Generator (PRNG)

  This vulnerability occurs when a Pseudo-Random Number Generator (PRNG) is repeatedly initialized with the same starting seed value.

• CWE-337
  Predictable Seed in Pseudo-Random Number Generator (PRNG)

  This vulnerability occurs when a Pseudo-Random Number Generator (PRNG) uses an easily guessable starting value, like the current system time or a process ID,…

• CWE-338
  Use of Cryptographically Weak Pseudo-Random Number Generator (PRNG)

  This vulnerability occurs when software uses a pseudo-random number generator (PRNG) that is not cryptographically strong for security-sensitive operations,…

  Medium likelihood
• CWE-339
  Small Seed Space in PRNG

  This vulnerability occurs when a Pseudo-Random Number Generator (PRNG) uses a seed that has too few possible values, making it easy for an attacker to guess…

• CWE-340
  Generation of Predictable Numbers or Identifiers

  This vulnerability occurs when a system creates numbers or identifiers that are too easy to guess, undermining security mechanisms that rely on…

• CWE-341
  Predictable from Observable State

  This vulnerability occurs when an attacker can guess or deduce sensitive values, like random numbers or identifiers, by observing predictable system or…

• CWE-342
  Predictable Exact Value from Previous Values

  This vulnerability occurs when a system uses a predictable sequence for generating values, allowing an attacker to accurately guess future numbers by…

• CWE-343
  Predictable Value Range from Previous Values

  This vulnerability occurs when a system's random number generator produces values that, after observing previous outputs, allow an attacker to predict a…

• CWE-344
  Use of Invariant Value in Dynamically Changing Context

  This vulnerability occurs when code uses a fixed, unchanging value (like a hardcoded string, number, or reference) in a situation where that value should…

• CWE-345
  Insufficient Verification of Data Authenticity

  This vulnerability occurs when an application fails to properly check where data comes from or confirm its legitimacy, allowing untrusted or forged…

• CWE-346
  Origin Validation Error

  This vulnerability occurs when an application fails to properly confirm the true origin of incoming data or communication, allowing attackers to spoof their…

• CWE-347
  Improper Verification of Cryptographic Signature

  This vulnerability occurs when an application fails to properly check the digital signature on data, or skips the verification step entirely, allowing…

• CWE-348
  Use of Less Trusted Source

  This vulnerability occurs when a system has access to multiple sources for the same critical data, but it chooses to rely on the less secure or less…

• CWE-349
  Acceptance of Extraneous Untrusted Data With Trusted Data

  This vulnerability occurs when a system processes both trusted and untrusted data together, but fails to separate them. The application incorrectly treats all…

• CWE-350
  Reliance on Reverse DNS Resolution for a Security-Critical Action

  This vulnerability occurs when an application uses a reverse DNS lookup on an IP address to get a hostname and then uses that hostname for a security…

• CWE-351
  Insufficient Type Distinction

  This vulnerability occurs when an application fails to properly differentiate between different types of data or objects, leading to unintended and insecure…

• CWE-352
  Cross-Site Request Forgery (CSRF)

  Cross-Site Request Forgery (CSRF) happens when a web application cannot reliably tell if a user actually intended to submit a request, allowing an attacker to…

  Medium likelihood
• CWE-353
  Missing Support for Integrity Check

  This vulnerability occurs when a system uses a communication protocol that lacks built-in integrity verification, such as a checksum or cryptographic hash, to…

  Medium likelihood
• CWE-354
  Improper Validation of Integrity Check Value

  This vulnerability occurs when software fails to properly check the integrity of data by validating its checksum or hash value. Without this verification, the…

  Medium likelihood
• CWE-356
  Product UI does not Warn User of Unsafe Actions

  This vulnerability occurs when a software interface fails to alert users before they perform a risky action. Without clear warnings, users can be more easily…

• CWE-357
  Insufficient UI Warning of Dangerous Operations

  This vulnerability occurs when a software application does present a warning to a user before a risky action, but the warning is designed or placed in a way…

• CWE-358
  Improperly Implemented Security Check for Standard

  This vulnerability occurs when software fails to correctly implement one or more critical security checks required by a standard protocol, algorithm, or…

• CWE-359
  Exposure of Private Personal Information to an Unauthorized Actor

  This vulnerability occurs when an application fails to adequately protect sensitive personal data, allowing access to individuals who either lack proper…

• CWE-360
  Trust of System Event Data

  This vulnerability occurs when software blindly trusts system event data without verifying its source, allowing attackers to spoof events and manipulate…

  High likelihood
• CWE-362
  Concurrent Execution using Shared Resource with Improper Synchronization ('Race Condition')

  A race condition occurs when multiple processes or threads access a shared resource simultaneously without proper coordination, creating a timing window where…

  Medium likelihood
• CWE-363
  Race Condition Enabling Link Following

  This vulnerability occurs when a program checks a file's status before using it, creating a brief window where an attacker can replace that file with a…

• CWE-364
  Signal Handler Race Condition

  A signal handler race condition occurs when a program's signal handling routine is vulnerable to timing issues, allowing its state to be corrupted through…

  Medium likelihood
• CWE-366
  Race Condition within a Thread

  This vulnerability occurs when two or more threads within the same application access and manipulate a shared resource (like a variable, data structure, or…

  Medium likelihood
• CWE-367
  Time-of-check Time-of-use (TOCTOU) Race Condition

  This vulnerability occurs when a program verifies a resource's state (like a file's permissions or existence) but then uses it after that state has already…

  Medium likelihood
• CWE-368
  Context Switching Race Condition

  This vulnerability occurs when an application switches between different security contexts (like privilege levels or domains) using a series of steps that can…

• CWE-369
  Divide By Zero

  A divide-by-zero error occurs when software attempts to perform a division operation where the denominator is zero.

  Medium likelihood
• CWE-370
  Missing Check for Certificate Revocation after Initial Check

  This vulnerability occurs when software only verifies a certificate's revocation status once, then continues to trust it for subsequent privileged actions…

  Medium likelihood
• CWE-372
  Incomplete Internal State Distinction

  This vulnerability occurs when an application fails to accurately track its own operational state. The system incorrectly assumes it's in one mode or…

• CWE-374
  Passing Mutable Objects to an Untrusted Method

  This vulnerability occurs when a function receives a direct reference to mutable data, such as an object or array, instead of a safe copy of that data.

  Medium likelihood
• CWE-375
  Returning a Mutable Object to an Untrusted Caller

  This vulnerability occurs when a method directly returns a reference to its internal mutable data, allowing untrusted calling code to modify that data…

  Medium likelihood
• CWE-377
  Insecure Temporary File

  This vulnerability occurs when an application creates temporary files with insecure permissions or in predictable locations, allowing attackers to read,…

• CWE-378
  Creation of Temporary File With Insecure Permissions

  This vulnerability occurs when a program creates a temporary file but sets its file permissions too loosely, allowing other users or processes on the system…

  High likelihood
• CWE-379
  Creation of Temporary File in Directory with Insecure Permissions

  This vulnerability occurs when an application creates a temporary file in a directory that is too permissive, allowing unauthorized users or processes to see,…

  Low likelihood
• CWE-382
  J2EE Bad Practices: Use of System.exit()

  This vulnerability occurs when a J2EE application directly calls System.exit(), which forcibly terminates the entire application server process, not just the…

• CWE-383
  J2EE Bad Practices: Direct Use of Threads

  Creating or managing threads directly within a J2EE application is a risky practice that violates the platform's standards and often leads to unstable…

• CWE-384
  Session Fixation

  Session fixation occurs when an application authenticates a user without first destroying the previous session ID. This allows an attacker who knows that…

• CWE-385
  Covert Timing Channel

  A covert timing channel is a security flaw where an attacker can deduce secret information by observing how long certain operations take to execute. Instead…

  Medium likelihood
• CWE-386
  Symbolic Name not Mapping to Correct Object

  This vulnerability occurs when a program uses a fixed symbolic name (like a constant or identifier) to refer to an object, but that name can later point to a…

• CWE-390
  Detection of Error Condition Without Action

  This weakness occurs when software successfully identifies an error condition but then fails to take any meaningful action to address it. The error is…

  Medium likelihood
• CWE-391
  Unchecked Error Condition

  This vulnerability occurs when a program fails to properly check or handle error conditions, such as exceptions or return codes. By ignoring these failures,…

  Medium likelihood
• CWE-392
  Missing Report of Error Condition

  This vulnerability occurs when a system fails to properly signal that an error has happened. Instead of returning a clear error code, status, or exception,…

• CWE-393
  Return of Wrong Status Code

  This vulnerability occurs when a function returns an inaccurate status code or value that misrepresents the actual outcome of an operation. This false signal…

• CWE-394
  Unexpected Status Code or Return Value

  This vulnerability occurs when software fails to properly validate the full range of possible return values from a function or system call. While a returned…

• CWE-395
  Use of NullPointerException Catch to Detect NULL Pointer Dereference

  Using a try-catch block for NullPointerException as a substitute for proper null checks is an anti-pattern. This approach masks the root cause of null pointer…

• CWE-396
  Declaration of Catch for Generic Exception

  This weakness occurs when code catches a generic exception type like 'Exception' or 'Throwable', which can hide specific errors and create insecure error…

• CWE-397
  Declaration of Throws for Generic Exception

  This vulnerability occurs when a method is declared to throw an overly broad exception type, such as a generic 'Exception' or 'Throwable'. This practice masks…

• CWE-400
  Uncontrolled Resource Consumption

  This vulnerability occurs when an application fails to properly manage a finite resource, allowing an attacker to exhaust it and cause a denial of service.

  High likelihood
• CWE-401
  Missing Release of Memory after Effective Lifetime

  This vulnerability occurs when a program allocates memory but fails to properly release it after it's no longer needed, causing a gradual accumulation of…

  Medium likelihood
• CWE-402
  Transmission of Private Resources into a New Sphere ('Resource Leak')

  This vulnerability occurs when an application unintentionally exposes internal resources, like files, memory, or database connections, to unauthorized users…

• CWE-403
  Exposure of File Descriptor to Unintended Control Sphere ('File Descriptor Leak')

  This vulnerability occurs when a parent process launches a child process without first closing sensitive file descriptors. The child process inherits these…

• CWE-404
  Improper Resource Shutdown or Release

  This vulnerability occurs when a program fails to properly close or release a system resource—like a file handle, database connection, or memory block—after…

  Medium likelihood
• CWE-405
  Asymmetric Resource Consumption (Amplification)

  This vulnerability occurs when a system allows an attacker to trigger a disproportionate amount of resource consumption—like CPU, memory, or bandwidth—with…

• CWE-406
  Insufficient Control of Network Message Volume (Network Amplification)

  This vulnerability occurs when a system fails to properly limit the amount of network traffic it can generate in response to a request, allowing an attacker…

• CWE-407
  Inefficient Algorithmic Complexity

  This vulnerability occurs when a software component uses an algorithm with poor worst-case performance. An attacker can exploit this by providing specially…

  Low likelihood
• CWE-408
  Incorrect Behavior Order: Early Amplification

  This vulnerability occurs when a system allows a user to trigger a resource-intensive operation before verifying their identity or checking their permissions.

• CWE-409
  Improper Handling of Highly Compressed Data (Data Amplification)

  This vulnerability occurs when software fails to safely process highly compressed data, where a small input file can trigger the creation of an extremely…

• CWE-410
  Insufficient Resource Pool

  This vulnerability occurs when a system's resource pool is too small to handle maximum usage. Attackers can exploit this by making a high volume of requests,…

• CWE-412
  Unrestricted Externally Accessible Lock

  This vulnerability occurs when a system correctly checks for a lock's existence, but an unauthorized external actor can control or influence that lock.

• CWE-413
  Improper Resource Locking

  This vulnerability occurs when an application fails to properly lock a shared resource, such as a file or memory location, before performing operations that…

• CWE-414
  Missing Lock Check

  This vulnerability occurs when software fails to verify that a proper synchronization lock is active before accessing or modifying a shared resource,…

• CWE-415
  Double Free

  A double free vulnerability occurs when a program mistakenly calls the 'free()' function twice on the same block of memory.

  High likelihood
• CWE-416
  Use After Free

  Use After Free happens when a program continues to use a pointer to a memory location after that memory has been freed. This can lead to unpredictable…

  High likelihood
• CWE-419
  Unprotected Primary Channel

  This vulnerability occurs when an application exposes a privileged administrative interface or restricted functionality through a primary channel (like a…

• CWE-420
  Unprotected Alternate Channel

  This vulnerability occurs when an application secures its main communication path but leaves a backup or alternative channel with weaker or no protection.

• CWE-421
  Race Condition During Access to Alternate Channel

  A race condition occurs when an application opens a secondary communication channel intended for an authorized user, but fails to secure it, allowing other…

• CWE-422
  Unprotected Windows Messaging Channel ('Shatter')

  This vulnerability, often called a 'Shatter' attack, occurs when a Windows application running with high privileges accepts messages from the Windows…

• CWE-424
  Improper Protection of Alternate Path

  This vulnerability occurs when an application fails to secure every possible route a user could take to reach sensitive features or data, leaving backdoors or…

• CWE-425
  Direct Request ('Forced Browsing')

  This vulnerability occurs when a web application fails to verify user permissions for every protected page, file, or API endpoint, allowing attackers to…

• CWE-426
  Untrusted Search Path

  This vulnerability occurs when an application relies on an external search path, provided by a user or environment, to find and load critical resources like…

  High likelihood
• CWE-427
  Uncontrolled Search Path Element

  This vulnerability occurs when an application searches for critical files like libraries or executables using a predefined list of directories, but one or…

• CWE-428
  Unquoted Search Path or Element

  This vulnerability occurs when a program uses a file path or command that contains spaces and is not enclosed in quotes. The operating system may misinterpret…

• CWE-430
  Deployment of Wrong Handler

  This vulnerability occurs when a system incorrectly assigns or routes an object to the wrong processing component.

• CWE-431
  Missing Handler

  This vulnerability occurs when a software component lacks the necessary code to properly handle an error or unexpected event.

• CWE-432
  Dangerous Signal Handler not Disabled During Sensitive Operations

  This vulnerability occurs when a program's signal handler, which shares resources like global variables with other handlers, can be interrupted and re-entered…

• CWE-433
  Unparsed Raw Web Content Delivery

  This vulnerability occurs when a web application stores unprocessed files—like configuration scripts or raw source code—in publicly accessible directories…

• CWE-434
  Unrestricted Upload of File with Dangerous Type

  This vulnerability occurs when an application accepts file uploads without properly restricting the file types, allowing attackers to upload and execute…

  Medium likelihood
• CWE-435
  Improper Interaction Between Multiple Correctly-Behaving Entities

  This weakness occurs when individually secure components interact in unexpected ways within a larger system, creating new security flaws that weren't present…

• CWE-436
  Interpretation Conflict

  An interpretation conflict occurs when two systems process the same data or sequence of events differently, leading one system to make incorrect decisions…

• CWE-437
  Incomplete Model of Endpoint Features

  This vulnerability occurs when a security product, proxy, or monitoring system sits between endpoints but lacks a full understanding of what those endpoints…

• CWE-439
  Behavioral Change in New Version or Environment

  This vulnerability occurs when a component's behavior unexpectedly changes after an update or when deployed to a different environment, and the systems or…

• CWE-440
  Expected Behavior Violation

  This weakness occurs when a software component, such as a function, API, or feature, fails to act as documented or intended. The system's actual behavior…

• CWE-441
  Unintended Proxy or Intermediary ('Confused Deputy')

  A confused deputy vulnerability occurs when a system receives a request from a client and forwards it to an external destination without properly identifying…

• CWE-444
  Inconsistent Interpretation of HTTP Requests ('HTTP Request/Response Smuggling')

  This weakness occurs when a proxy, firewall, or other intermediary HTTP agent interprets a malformed HTTP request or response differently than the final…

• CWE-446
  UI Discrepancy for Security Feature

  This vulnerability occurs when a user interface incorrectly displays a security feature as active or properly configured, misleading users into believing they…

• CWE-447
  Unimplemented or Unsupported Feature in UI

  This vulnerability occurs when a user interface displays a security feature as active and functional, but the underlying code that powers it is either missing…

• CWE-448
  Obsolete Feature in UI

  This vulnerability occurs when a user interface (UI) includes outdated or deprecated features, but fails to alert users about their obsolete status. This can…

• CWE-449
  The UI Performs the Wrong Action

  This vulnerability occurs when a user interface (UI) element or command performs a different, unintended action than what the user requested, potentially…

• CWE-450
  Multiple Interpretations of UI Input

  This vulnerability occurs when a user interface can interpret the same input in multiple ways, but automatically chooses a less secure option without warning…

• CWE-451
  User Interface (UI) Misrepresentation of Critical Information

  This vulnerability occurs when a user interface fails to accurately display or highlight crucial information, potentially misleading users about the true…

• CWE-453
  Insecure Default Variable Initialization

  This vulnerability occurs when software sets an internal variable to an insecure or unnecessarily weak default value during initialization, rather than using…

• CWE-454
  External Initialization of Trusted Variables or Data Stores

  This vulnerability occurs when an application sets up its critical internal variables or storage systems using data from untrusted, external sources that an…

• CWE-455
  Non-exit on Failed Initialization

  This vulnerability occurs when software continues to run as normal after encountering a critical security failure during its startup process. Instead of…

• CWE-456
  Missing Initialization of a Variable

  This vulnerability occurs when a program uses a variable before giving it a starting value, causing the software to rely on unpredictable data left over in…

• CWE-457
  Use of Uninitialized Variable

  This vulnerability occurs when a program accesses a variable before it has been assigned a value, leading to unpredictable behavior and potential security…

  High likelihood
• CWE-459
  Incomplete Cleanup

  This vulnerability occurs when an application fails to properly remove temporary files, data structures, or system resources after they are no longer needed.

• CWE-460
  Improper Cleanup on Thrown Exception

  This vulnerability occurs when a program fails to properly restore its state or release resources after an exception is thrown, leaving the application in an…

  Medium likelihood
• CWE-462
  Duplicate Key in Associative List (Alist)

  This vulnerability occurs when an associative list (alist) contains duplicate keys, which can cause unexpected behavior when software incorrectly handles or…

  Low likelihood
• CWE-463
  Deletion of Data Structure Sentinel

  This vulnerability occurs when a program accidentally removes or corrupts a special marker used to define the boundaries of a data structure, leading to logic…

• CWE-464
  Addition of Data Structure Sentinel

  This vulnerability occurs when a program unintentionally adds or modifies a special marker, known as a sentinel, within a data structure, leading to critical…

  High likelihood
• CWE-466
  Return of Pointer Value Outside of Expected Range

  This vulnerability occurs when a function returns a memory pointer that points outside the expected buffer range, potentially exposing unrelated memory or…

• CWE-467
  Use of sizeof() on a Pointer Type

  This vulnerability occurs when a developer uses the sizeof() operator on a pointer variable instead of the data it points to, leading to incorrect size…

  High likelihood
• CWE-468
  Incorrect Pointer Scaling

  This vulnerability occurs when a programmer incorrectly accounts for pointer arithmetic in C or C++, causing the program to access unintended memory…

  Medium likelihood
• CWE-469
  Use of Pointer Subtraction to Determine Size

  This vulnerability occurs when a program calculates a size or offset by subtracting two memory pointers, but the pointers point to locations in different…

  Medium likelihood
• CWE-470
  Use of Externally-Controlled Input to Select Classes or Code ('Unsafe Reflection')

  This vulnerability occurs when an application uses unvalidated external input, like a URL parameter or form field, to dynamically decide which class to load…

• CWE-471
  Modification of Assumed-Immutable Data (MAID)

  This vulnerability occurs when an application fails to protect data it assumes cannot be changed, allowing an attacker to alter it.

• CWE-472
  External Control of Assumed-Immutable Web Parameter

  This vulnerability occurs when a web application incorrectly trusts data that appears to be fixed or hidden from the user, such as values in hidden form…

• CWE-473
  PHP External Variable Modification

  This vulnerability occurs when a PHP application fails to properly validate or sanitize variables that originate from outside the application, such as HTTP…

• CWE-474
  Use of Function with Inconsistent Implementations

  This vulnerability occurs when code relies on a function whose behavior changes across different operating systems or versions, leading to unpredictable…

• CWE-475
  Undefined Behavior for Input to API

  This API function exhibits unpredictable or undefined behavior when its control parameter is not set to the exact, required value.

• CWE-476
  NULL Pointer Dereference

  This vulnerability occurs when a program attempts to access or manipulate memory using a pointer that is set to NULL, causing a crash or unexpected behavior.

  Medium likelihood
• CWE-477
  Use of Obsolete Function

  This vulnerability occurs when code relies on deprecated or obsolete functions, indicating outdated practices and insufficient maintenance that can introduce…

• CWE-478
  Missing Default Case in Multiple Condition Expression

  This vulnerability occurs when code with multiple conditional branches, like a switch statement, lacks a default case to handle unexpected values.

• CWE-479
  Signal Handler Use of a Non-reentrant Function

  This vulnerability occurs when a signal handler in your code calls a function that is not safe to re-enter. If that function is interrupted and called again…

  Low likelihood
• CWE-480
  Use of Incorrect Operator

  This vulnerability occurs when a developer mistakenly uses the wrong operator in their code, leading to unintended and potentially insecure logic.

  Low likelihood
• CWE-481
  Assigning instead of Comparing

  This flaw occurs when a developer accidentally uses the assignment operator (=) instead of the comparison operator (== or ===). The code assigns a value when…

  Low likelihood
• CWE-482
  Comparing instead of Assigning

  This vulnerability occurs when a developer accidentally uses a comparison operator (like '==') where an assignment operator (like '=') was intended, creating…

  Low likelihood
• CWE-483
  Incorrect Block Delimitation

  This vulnerability occurs when a developer fails to use explicit braces or delimiters to group multiple statements within a block, leading to unexpected…

  Low likelihood
• CWE-484
  Omitted Break Statement in Switch

  This vulnerability occurs when a developer forgets to include a 'break' statement inside a switch-case block. Without it, the code execution 'falls through'…

  Medium likelihood
• CWE-486
  Comparison of Classes by Name

  This vulnerability occurs when an application determines an object's trustworthiness or behavior solely by checking its class name. Since multiple classes can…

  High likelihood
• CWE-487
  Reliance on Package-level Scope

  This weakness occurs when a Java application mistakenly treats package-level access as a security boundary, assuming it can prevent unauthorized access to code.

  Medium likelihood
• CWE-488
  Exposure of Data Element to Wrong Session

  This vulnerability occurs when an application fails to properly isolate data between different user sessions, allowing information from one user's session to…

• CWE-489
  Active Debug Code

  This vulnerability occurs when software is deployed to production with debugging or diagnostic features still enabled and accessible.

• CWE-491
  Public cloneable() Method Without Final ('Object Hijack')

  This vulnerability occurs when a class implements a public clone() method without declaring it final. This allows attackers to create copies of objects…

• CWE-492
  Use of Inner Class Containing Sensitive Data

  Using inner classes to handle sensitive data can unintentionally expose that data because of how Java compiles them. The compiler transforms inner classes…

  Medium likelihood
• CWE-493
  Critical Public Variable Without Final Modifier

  This vulnerability occurs when a security-sensitive variable is declared as public but not marked as final, allowing untrusted code to unexpectedly change its…

  High likelihood
• CWE-494
  Download of Code Without Integrity Check

  This vulnerability occurs when an application fetches and runs code from an external source—like a remote server or CDN—without properly verifying where it…

  Medium likelihood
• CWE-495
  Private Data Structure Returned From A Public Method

  This vulnerability occurs when a public method directly returns a reference to a private, internal data structure. Because the reference is live, external…

• CWE-496
  Public Data Assigned to Private Array-Typed Field

  This vulnerability occurs when a developer stores sensitive data in a private array, but then assigns a publicly accessible reference to that same array. This…

• CWE-497
  Exposure of Sensitive System Information to an Unauthorized Control Sphere

  This vulnerability occurs when an application unintentionally reveals sensitive details about its underlying system, such as file paths, software versions, or…

• CWE-498
  Cloneable Class Containing Sensitive Information

  This vulnerability occurs when a class containing sensitive information, such as credentials or personal data, is made cloneable. Attackers can bypass normal…

  Medium likelihood
• CWE-499
  Serializable Class Containing Sensitive Data

  This vulnerability occurs when a class containing sensitive information, such as credentials or personal data, is left serializable by default. Because the…

  High likelihood
• CWE-500
  Public Static Field Not Marked Final

  This vulnerability occurs when a class exposes a public static field without declaring it as final, allowing unintended modification from anywhere in the…

  High likelihood
• CWE-501
  Trust Boundary Violation

  This vulnerability occurs when an application incorrectly stores or processes trusted and untrusted data together within the same structure, such as an…

• CWE-502
  Deserialization of Untrusted Data

  This vulnerability occurs when an application accepts and processes serialized data from an untrusted source without proper validation, allowing an attacker…

  Medium likelihood
• CWE-506
  Embedded Malicious Code

  This vulnerability occurs when an application or codebase contains intentionally harmful code inserted by a developer or third party.

• CWE-507
  Trojan Horse

  A Trojan Horse vulnerability occurs when software presents itself as legitimate and useful, but secretly contains malicious functionality that bypasses…

• CWE-508
  Non-Replicating Malicious Code

  This type of malicious code is designed to operate only on the specific system it initially infects. Unlike viruses or worms, it does not contain mechanisms…

• CWE-509
  Replicating Malicious Code (Virus or Worm)

  This weakness describes software that is vulnerable to infection by self-replicating malicious programs like viruses or worms. Once such malware compromises a…

• CWE-510
  Trapdoor

  A trapdoor, often called a backdoor, is a hidden piece of code intentionally placed within software. It activates in response to a specific, often secret,…

• CWE-511
  Logic/Time Bomb

  A logic or time bomb is malicious code intentionally placed within software to trigger harmful actions when a specific condition is met or a predetermined…

• CWE-512
  Spyware

  Spyware is software that secretly gathers personal information about a user or their activities. It does this by accessing data from other sources on the…

• CWE-514
  Covert Channel

  A covert channel is a hidden communication path that allows data to be transmitted in a way that bypasses the system's intended security controls and…

• CWE-515
  Covert Storage Channel

  A covert storage channel is a type of security flaw where one process secretly encodes data into a shared system resource (like a file, memory bit, or status…

  High likelihood
• CWE-520
  .NET Misconfiguration: Use of Impersonation

  This vulnerability occurs when a .NET application is configured to run with impersonation, potentially granting it excessive system-level permissions that…

• CWE-521
  Weak Password Requirements

  This vulnerability occurs when an application fails to enforce strong password policies, making user accounts easier to compromise through guessing or…

• CWE-522
  Insufficiently Protected Credentials

  This vulnerability occurs when an application handles sensitive credentials like passwords or API keys in an insecure way, making them easy for attackers to…

• CWE-523
  Unprotected Transport of Credentials

  This vulnerability occurs when a login page or authentication system transmits user credentials (like usernames and passwords) over a network without proper…

• CWE-524
  Use of Cache Containing Sensitive Information

  This vulnerability occurs when an application stores sensitive data in a cache that is accessible to unauthorized users or external systems.

• CWE-525
  Use of Web Browser Cache Containing Sensitive Information

  This vulnerability occurs when a web application fails to implement secure caching directives, allowing sensitive user data or pages to be stored in the…

• CWE-526
  Cleartext Storage of Sensitive Information in an Environment Variable

  This vulnerability occurs when an application stores sensitive data, such as passwords or API keys, as plain text in an environment variable.

• CWE-527
  Exposure of Version-Control Repository to an Unauthorized Control Sphere

  This vulnerability occurs when a version control repository, like Git or SVN, is accidentally placed in a location accessible to unauthorized users, such as a…

• CWE-528
  Exposure of Core Dump File to an Unauthorized Control Sphere

  This vulnerability occurs when an application creates a core dump file (a snapshot of memory at the time of a crash) and places it in a location accessible to…

• CWE-529
  Exposure of Access Control List Files to an Unauthorized Control Sphere

  This vulnerability occurs when an application stores sensitive access control list (ACL) files in a location that is accessible to unauthorized users or…

• CWE-530
  Exposure of Backup File to an Unauthorized Control Sphere

  This vulnerability occurs when backup or temporary files are stored in locations that unauthorized users can access, such as web directories.

• CWE-531
  Inclusion of Sensitive Information in Test Code

  This vulnerability occurs when sensitive data, such as credentials, API keys, or internal logic, is embedded within test code or debugging applications that…

• CWE-532
  Insertion of Sensitive Information into Log File

  This vulnerability occurs when an application unintentionally writes confidential data, such as passwords or API keys, into its log files.

  Medium likelihood
• CWE-535
  Exposure of Information Through Shell Error Message

  This vulnerability occurs when a web application's command shell returns detailed error messages to users. Attackers can analyze these messages to understand…

• CWE-536
  Servlet Runtime Error Message Containing Sensitive Information

  This vulnerability occurs when a Java servlet application displays detailed runtime error messages that reveal sensitive information about the application's…

• CWE-537
  Java Runtime Error Message Containing Sensitive Information

  This vulnerability occurs when a Java application's runtime error messages reveal sensitive details about the system, such as file paths, internal IP…

• CWE-538
  Insertion of Sensitive Information into Externally-Accessible File or Directory

  This vulnerability occurs when an application unintentionally stores confidential data—like passwords, API keys, or personal user details—in a location that…

• CWE-539
  Use of Persistent Cookies Containing Sensitive Information

  This vulnerability occurs when a web application stores sensitive data, like authentication details or personal information, within persistent cookies that…

• CWE-540
  Inclusion of Sensitive Information in Source Code

  This vulnerability occurs when sensitive information like passwords, API keys, or internal logic is exposed within source code that remains accessible on a…

• CWE-541
  Inclusion of Sensitive Information in an Include File

  This vulnerability occurs when sensitive data like passwords or system details is placed inside a publicly accessible include file. Attackers can directly…

• CWE-543
  Use of Singleton Pattern Without Synchronization in a Multithreaded Context

  This vulnerability occurs when a singleton pattern is implemented in a multithreaded application without proper synchronization, potentially leading to…

• CWE-544
  Missing Standardized Error Handling Mechanism

  This weakness occurs when software lacks a unified, consistent approach to managing errors across its codebase, leading to unpredictable security gaps and…

• CWE-546
  Suspicious Comment

  This weakness occurs when code contains comments that flag potential issues, such as bugs, security gaps, or unfinished work, which can expose underlying…

• CWE-547
  Use of Hard-coded, Security-relevant Constants

  This vulnerability occurs when code directly embeds security-critical values like passwords, cryptographic keys, or access levels as raw numbers or strings,…

• CWE-548
  Exposure of Information Through Directory Listing

  This vulnerability occurs when a web server is misconfigured to display a full list of files within a directory instead of serving a default web page,…

• CWE-549
  Missing Password Field Masking

  This vulnerability occurs when an application fails to hide password characters as they are typed, making them visible to anyone who can see the screen. This…

• CWE-550
  Server-generated Error Message Containing Sensitive Information

  This vulnerability occurs when a web application or server returns detailed error messages that reveal sensitive internal information about the system.

• CWE-551
  Incorrect Behavior Order: Authorization Before Parsing and Canonicalization

  This vulnerability occurs when a web server checks access permissions before fully processing and normalizing a URL, potentially allowing attackers to bypass…

• CWE-552
  Files or Directories Accessible to External Parties

  This vulnerability occurs when an application exposes files or directories to users who shouldn't have access to them.

• CWE-553
  Command Shell in Externally Accessible Directory

  This vulnerability occurs when a command shell script is placed in a web-accessible directory, such as /cgi-bin/. Attackers can directly request this file to…

• CWE-554
  ASP.NET Misconfiguration: Not Using Input Validation Framework

  This vulnerability occurs when an ASP.NET application fails to implement a structured input validation framework, relying instead on ad-hoc or missing…

• CWE-555
  J2EE Misconfiguration: Plaintext Password in Configuration File

  A J2EE application insecurely stores an unprotected password within a configuration file.

• CWE-556
  ASP.NET Misconfiguration: Use of Identity Impersonation

  This vulnerability occurs when an ASP.NET application is configured to run using impersonated credentials, which can grant the application excessive and…

• CWE-558
  Use of getlogin() in Multithreaded Application

  Using the getlogin() function in a multithreaded application can lead to unreliable or incorrect username results, creating security and logic flaws.

• CWE-560
  Use of umask() with chmod-style Argument

  This vulnerability occurs when a program incorrectly uses the `umask()` system call with an argument formatted for `chmod()`, leading to unintended and overly…

• CWE-561
  Dead Code

  Dead code refers to sections of a program that can never run during normal execution, effectively making them inactive and unreachable.

• CWE-562
  Return of Stack Variable Address

  This vulnerability occurs when a function returns a pointer to its own local variable. Since that variable's memory is on the stack, the pointer becomes…

• CWE-563
  Assignment to Variable without Use

  This vulnerability occurs when a value is stored in a variable, but that variable is never read or used in subsequent code, creating a 'dead store.'

• CWE-564
  SQL Injection: Hibernate

  This vulnerability occurs when an application uses Hibernate to construct dynamic SQL queries with unsanitized user input, allowing an attacker to alter the…

• CWE-565
  Reliance on Cookies without Validation and Integrity Checking

  This vulnerability occurs when an application uses cookies to make security decisions—like granting access or changing settings—but fails to verify that the…

• CWE-566
  Authorization Bypass Through User-Controlled SQL Primary Key

  This vulnerability occurs when an application allows a user to directly control the primary key value used in a SQL query, enabling them to access database…

• CWE-567
  Unsynchronized Access to Shared Data in a Multithreaded Context

  This vulnerability occurs when multiple threads in an application can read and modify shared data, like static variables, without proper coordination. This…

• CWE-568
  finalize() Method Without super.finalize()

  This vulnerability occurs when a Java class overrides the finalize() method but fails to call super.finalize() within it.

• CWE-570
  Expression is Always False

  This vulnerability occurs when code contains a conditional expression that can never evaluate to true, causing a section of the program to be permanently…

• CWE-571
  Expression is Always True

  This vulnerability occurs when code contains a conditional expression that will always evaluate to 'true', making the check ineffective and potentially…

• CWE-572
  Call to Thread run() instead of start()

  This vulnerability occurs when a program incorrectly calls a thread's `run()` method directly, instead of using the `start()` method. This mistake causes the…

• CWE-573
  Improper Following of Specification by Caller

  This weakness occurs when software fails to properly follow the documented rules, protocols, or requirements of an external component it uses, such as a…

• CWE-574
  EJB Bad Practices: Use of Synchronization Primitives

  This vulnerability occurs when an Enterprise JavaBeans (EJB) component improperly uses thread synchronization primitives, violating the EJB specification's…

• CWE-575
  EJB Bad Practices: Use of AWT Swing

  This vulnerability occurs when an Enterprise JavaBeans (EJB) component incorrectly uses AWT or Swing UI toolkits, violating the EJB specification's design…

• CWE-576
  EJB Bad Practices: Use of Java I/O

  This vulnerability occurs when an Enterprise JavaBeans (EJB) component incorrectly uses Java I/O (java.io) operations to access the file system, violating the…

• CWE-577
  EJB Bad Practices: Use of Sockets

  This vulnerability occurs when an Enterprise JavaBeans (EJB) component breaks the EJB specification by directly creating or using network sockets.

• CWE-578
  EJB Bad Practices: Use of Class Loader

  This vulnerability occurs when an Enterprise JavaBeans (EJB) component directly manipulates the Java class loader, violating the EJB specification's security…

• CWE-579
  J2EE Bad Practices: Non-serializable Object Stored in Session

  This vulnerability occurs when a Java application stores an object in the user's session that cannot be serialized, which can break critical application…

• CWE-580
  clone() Method Without super.clone()

  This vulnerability occurs when a class's clone() method creates a new object directly instead of calling super.clone().

• CWE-581
  Object Model Violation: Just One of Equals and Hashcode Defined

  This vulnerability occurs when a Java class defines either the equals() method or the hashCode() method, but not both, breaking a fundamental contract of…

• CWE-582
  Array Declared Public, Final, and Static

  This vulnerability occurs when an array is declared as public, final, and static, which does not protect the data inside the array from being altered.

• CWE-583
  finalize() Method Declared Public

  This vulnerability occurs when a Java class declares its finalize() method as public, violating secure coding practices for mobile code.

• CWE-584
  Return Inside Finally Block

  This vulnerability occurs when a function places a return statement inside a finally block. This dangerous pattern silently discards any unhandled exceptions…

• CWE-585
  Empty Synchronized Block

  An empty synchronized block is a Java code construct where a synchronized block exists but contains no executable statements inside it.

• CWE-586
  Explicit Call to Finalize()

  This vulnerability occurs when code directly calls an object's finalize() method from outside its designated finalizer context.

• CWE-587
  Assignment of a Fixed Address to a Pointer

  This vulnerability occurs when code explicitly assigns a hardcoded memory address to a pointer, instead of using a dynamic or null value.

• CWE-588
  Attempt to Access Child of a Non-structure Pointer

  This vulnerability occurs when code incorrectly treats a pointer to a basic data type (like an integer) as if it points to a structured object (like a…

• CWE-589
  Call to Non-ubiquitous API

  This vulnerability occurs when software relies on an operating system function that isn't available on all versions of the target platform. This can cause…

• CWE-590
  Free of Memory not on the Heap

  This vulnerability occurs when a program calls free() on a memory pointer that wasn't originally allocated using standard heap functions like malloc(),…

• CWE-591
  Sensitive Data Storage in Improperly Locked Memory

  This vulnerability occurs when an application stores sensitive information, like passwords or encryption keys, in system memory that isn't properly secured…

• CWE-593
  Authentication Bypass: OpenSSL CTX Object Modified after SSL Objects are Created

  This vulnerability occurs when an application modifies an OpenSSL context object after it has already been used to create active SSL/TLS connections.

• CWE-594
  J2EE Framework: Saving Unserializable Objects to Disk

  This vulnerability occurs when a J2EE application framework attempts to save objects to disk that cannot be properly serialized, risking application failure.

• CWE-595
  Comparison of Object References Instead of Object Contents

  This vulnerability occurs when code incorrectly checks if two object references point to the same memory location, rather than comparing the actual data or…

• CWE-597
  Use of Wrong Operator in String Comparison

  This vulnerability occurs when a developer incorrectly compares string values, typically by using reference equality operators (like == or !=) instead of…

• CWE-598
  Use of GET Request Method With Sensitive Query Strings

  This vulnerability occurs when a web application handles sensitive data, like passwords or session tokens, by passing them within the URL's query string using…

• CWE-599
  Missing Validation of OpenSSL Certificate

  This vulnerability occurs when an application uses OpenSSL but fails to properly verify server certificates by not calling SSL_get_verify_result(). Without…

• CWE-600
  Uncaught Exception in Servlet

  This vulnerability occurs when a Java Servlet fails to properly catch and handle exceptions, potentially exposing sensitive system information in error…

• CWE-601
  URL Redirection to Untrusted Site ('Open Redirect')

  An open redirect vulnerability occurs when a web application uses unvalidated user input to determine the destination of a redirect, allowing an attacker to…

  Low likelihood
• CWE-602
  Client-Side Enforcement of Server-Side Security

  This vulnerability occurs when a server incorrectly trusts the client to enforce critical security rules, such as input validation or access controls, instead…

  Medium likelihood
• CWE-603
  Use of Client-Side Authentication

  This vulnerability occurs when an application places its authentication logic solely within the client-side code, such as in a mobile app or web browser,…

• CWE-605
  Multiple Binds to the Same Port

  This vulnerability occurs when a system's socket configuration allows multiple applications to bind to the same network port simultaneously. This can let a…

• CWE-606
  Unchecked Input for Loop Condition

  This vulnerability occurs when an application fails to properly validate or limit user-supplied values that control loop iterations. Without these checks,…

• CWE-607
  Public Static Final Field References Mutable Object

  This vulnerability occurs when a class exposes a public or protected static final field that points to a changeable object. Because the field's reference is…

• CWE-608
  Struts: Non-private Field in ActionForm Class

  This vulnerability occurs when an Apache Struts ActionForm class exposes a field without declaring it as private. This allows other parts of the application…

• CWE-609
  Double-Checked Locking

  Double-checked locking is an insufficient synchronization pattern where a program checks a resource's state, acquires a lock, and checks the state again…

• CWE-610
  Externally Controlled Reference to a Resource in Another Sphere

  This vulnerability occurs when an application uses user-supplied input to reference a resource located outside its intended security boundary, allowing…

• CWE-611
  Improper Restriction of XML External Entity Reference

  This vulnerability occurs when an application processes XML input without properly restricting external entity references. Attackers can exploit this to read…

• CWE-612
  Improper Authorization of Index Containing Sensitive Information

  This vulnerability occurs when a system indexes sensitive documents for search but fails to properly restrict who can query that index. Attackers can then…

• CWE-613
  Insufficient Session Expiration

  Insufficient session expiration occurs when an application allows old session tokens or IDs to remain valid for too long, letting attackers reuse them to gain…

• CWE-614
  Sensitive Cookie in HTTPS Session Without 'Secure' Attribute

  This vulnerability occurs when a web application transmits sensitive cookies over an HTTPS connection but fails to set the 'Secure' attribute on those cookies.

• CWE-615
  Inclusion of Sensitive Information in Source Code Comments

  This vulnerability occurs when developers leave sensitive details within source code comments. These can include internal file paths, hidden URLs, inactive…

• CWE-616
  Incomplete Identification of Uploaded File Variables (PHP)

  This vulnerability occurs in PHP applications that rely on the deprecated, auto-registered global variables for file uploads (like $varname, $varname_size).…

• CWE-617
  Reachable Assertion

  A reachable assertion occurs when an attacker can trigger an assert() statement or similar debugging check, causing the application to crash or behave in a…

• CWE-618
  Exposed Unsafe ActiveX Method

  This vulnerability occurs when an ActiveX control, designed for web browsers, exposes methods that bypass the browser's built-in security restrictions. These…

• CWE-619
  Dangling Database Cursor ('Cursor Injection')

  A dangling database cursor occurs when a database cursor is not properly closed, potentially allowing other users to access it while it retains its original,…

• CWE-620
  Unverified Password Change

  This vulnerability occurs when an application allows a user to set a new password without first verifying their identity through the old password or a secure…

• CWE-621
  Variable Extraction Error

  This vulnerability occurs when an application uses unvalidated external input to dynamically select which variables to populate with data. Without proper…

• CWE-622
  Improper Validation of Function Hook Arguments

  This vulnerability occurs when an application adds monitoring or interception hooks to critical functions, but fails to properly check the arguments passed to…

• CWE-623
  Unsafe ActiveX Control Marked Safe For Scripting

  This vulnerability occurs when an ActiveX control designed for limited use is incorrectly flagged as safe for scripting, allowing web pages to access its…

• CWE-624
  Executable Regular Expression Error

  This vulnerability occurs when an application uses a regular expression that can execute code, either because it directly contains executable logic with…

• CWE-625
  Permissive Regular Expression

  This weakness occurs when a regular expression is too permissive, failing to properly validate or sanitize input by allowing unintended values or patterns.

• CWE-626
  Null Byte Interaction Error (Poison Null Byte)

  This vulnerability occurs when software incorrectly processes null bytes (NUL characters) as data moves between different systems or programming languages,…

• CWE-627
  Dynamic Variable Evaluation

  This vulnerability occurs when an application allows user input to directly determine which variable or function name is used at runtime. Without strict…

• CWE-628
  Function Call with Incorrectly Specified Arguments

  This weakness occurs when a function is called with arguments that are incorrectly specified, causing the function to behave in an unintended and consistently…

• CWE-636
  Not Failing Securely ('Failing Open')

  This vulnerability occurs when a system, upon encountering an error or failure, defaults to its least secure configuration instead of a safer alternative.…

• CWE-637
  Unnecessary Complexity in Protection Mechanism (Not Using 'Economy of Mechanism')

  This weakness occurs when a security feature is implemented with excessive complexity, creating unnecessary risk. Overly intricate protection mechanisms are…

• CWE-638
  Not Using Complete Mediation

  This vulnerability occurs when software fails to verify access permissions every single time a user or process tries to use a resource. Instead, it might rely…

• CWE-639
  Authorization Bypass Through User-Controlled Key

  This vulnerability occurs when an application's authorization system fails to verify that a user is allowed to access specific data before retrieving it,…

  High likelihood
• CWE-640
  Weak Password Recovery Mechanism for Forgotten Password

  This vulnerability occurs when an application's password reset or recovery feature is poorly designed or implemented, allowing attackers to bypass…

  High likelihood
• CWE-641
  Improper Restriction of Names for Files and Other Resources

  This vulnerability occurs when an application creates file or resource names using unvalidated user input, failing to properly limit what characters or paths…

  Low likelihood
• CWE-642
  External Control of Critical State Data

  This vulnerability occurs when an application stores security-sensitive state data in locations that unauthorized users can access and modify.

  High likelihood
• CWE-643
  Improper Neutralization of Data within XPath Expressions ('XPath Injection')

  XPath Injection occurs when an application uses unvalidated user input to build an XPath query for an XML database. Without proper sanitization, attackers can…

  High likelihood
• CWE-644
  Improper Neutralization of HTTP Headers for Scripting Syntax

  This vulnerability occurs when an application fails to properly sanitize or escape user-controlled data placed within HTTP response headers. Malicious…

  High likelihood
• CWE-645
  Overly Restrictive Account Lockout Mechanism

  This vulnerability occurs when an application's account lockout feature is too strict, allowing attackers to easily trigger it and lock legitimate users out…

  High likelihood
• CWE-646
  Reliance on File Name or Extension of Externally-Supplied File

  This vulnerability occurs when an application uses the name or extension of an uploaded file to decide how to handle it. Attackers can manipulate this by…

  High likelihood
• CWE-647
  Use of Non-Canonical URL Paths for Authorization Decisions

  This vulnerability occurs when an application's authorization logic relies on specific URL paths but fails to enforce a single, standardized format. Attackers…

  High likelihood
• CWE-648
  Incorrect Use of Privileged APIs

  This vulnerability occurs when software incorrectly uses functions that require special permissions. Attackers can exploit these mistakes to gain unauthorized…

  Low likelihood
• CWE-649
  Reliance on Obfuscation or Encryption of Security-Relevant Inputs without Integrity Checking

  This vulnerability occurs when an application uses obfuscation or encryption to hide security-sensitive data (like tokens or parameters) but fails to verify…

  High likelihood
• CWE-650
  Trusting HTTP Permission Methods on the Server Side

  This vulnerability occurs when a server incorrectly assumes that HTTP GET requests are always safe and cannot change server-side data. Attackers can exploit…

  High likelihood
• CWE-651
  Exposure of WSDL File Containing Sensitive Information

  This vulnerability occurs when a Web Service Definition Language (WSDL) file, which acts as a public blueprint for a web service, is exposed in a way that…

• CWE-652
  Improper Neutralization of Data within XQuery Expressions ('XQuery Injection')

  XQuery Injection occurs when an application uses unvalidated user input to build an XQuery expression for querying an XML database. Without proper…

  High likelihood
• CWE-653
  Improper Isolation or Compartmentalization

  This vulnerability occurs when an application fails to enforce strong boundaries between components that operate at different security levels, allowing…

• CWE-654
  Reliance on a Single Factor in a Security Decision

  This vulnerability occurs when a system's security check depends almost entirely on just one condition, object, or piece of data to decide whether to grant…

• CWE-655
  Insufficient Psychological Acceptability

  This weakness occurs when security features are so cumbersome or confusing that well-intentioned users feel forced to turn them off or find workarounds,…

• CWE-656
  Reliance on Security Through Obscurity

  This weakness occurs when a system's primary defense relies on hiding how it works, rather than using a robust, well-tested security mechanism. If an attacker…

• CWE-657
  Violation of Secure Design Principles

  This weakness occurs when a system's architecture or design fails to follow fundamental security principles, creating a flawed foundation that can lead to…

• CWE-662
  Improper Synchronization

  This vulnerability occurs when a multi-threaded or multi-process application allows shared resources to be accessed by multiple threads or processes…

• CWE-663
  Use of a Non-reentrant Function in a Concurrent Context

  This vulnerability occurs when a program uses a function that is not safe for reentrancy within a concurrent environment, such as multi-threaded code or…

• CWE-664
  Improper Control of a Resource Through its Lifetime

  This vulnerability occurs when software fails to properly manage a resource throughout its entire lifecycle—from creation and active use to its final release…

• CWE-665
  Improper Initialization

  This vulnerability occurs when software fails to properly set up a resource before use, or provides incorrect starting values, leaving it in an unpredictable…

  Medium likelihood
• CWE-666
  Operation on Resource in Wrong Phase of Lifetime

  This vulnerability occurs when software interacts with a resource—like memory, a file, or a network connection—at an incorrect stage of its existence, leading…

• CWE-667
  Improper Locking

  This vulnerability occurs when a program fails to correctly acquire or release a lock on a shared resource, such as a file, database record, or memory…

• CWE-668
  Exposure of Resource to Wrong Sphere

  This vulnerability occurs when an application unintentionally makes a resource accessible to users or systems that should not have permission to use it.

• CWE-669
  Incorrect Resource Transfer Between Spheres

  This vulnerability occurs when an application incorrectly moves or shares a resource (like data, permissions, or functionality) between different trust…

• CWE-670
  Always-Incorrect Control Flow Implementation

  This weakness occurs when a section of code is structured in a way that always executes incorrectly, regardless of input or conditions. The control flow logic…

• CWE-671
  Lack of Administrator Control over Security

  This weakness occurs when a system's built-in security settings cannot be adjusted by its administrator. This prevents tailoring security to the specific…

• CWE-672
  Operation on a Resource after Expiration or Release

  This vulnerability occurs when a program continues to use a resource—like memory, a file handle, or a network connection—after it has been freed, closed, or…

• CWE-673
  External Influence of Sphere Definition

  The application allows external parties to modify its security boundaries or trusted zones, which should be defined and controlled internally.

• CWE-674
  Uncontrolled Recursion

  This vulnerability occurs when an application fails to limit how deeply a function can call itself. Without proper controls, this uncontrolled recursion can…

• CWE-675
  Multiple Operations on Resource in Single-Operation Context

  This vulnerability occurs when a software component performs the same action on a resource multiple times, even though the action is designed to be executed…

• CWE-676
  Use of Potentially Dangerous Function

  This vulnerability occurs when code calls a function that can be dangerous if misused, but can also be used safely with proper precautions. The risk lies not…

  High likelihood
• CWE-680
  Integer Overflow to Buffer Overflow

  This vulnerability occurs when a program calculates the size of memory to allocate, but an integer overflow in that calculation results in a much smaller…

• CWE-681
  Incorrect Conversion between Numeric Types

  This vulnerability occurs when a program converts a value from one numeric type to another (like a 64-bit integer to a 32-bit integer) and the conversion…

  High likelihood
• CWE-682
  Incorrect Calculation

  This vulnerability occurs when software performs a calculation that produces wrong or unexpected results, which are then used to make security decisions or…

  High likelihood
• CWE-683
  Function Call With Incorrect Order of Arguments

  This vulnerability occurs when a program calls a function but supplies the arguments in the wrong order, which can cause unexpected behavior or security flaws.

• CWE-684
  Incorrect Provision of Specified Functionality

  This weakness occurs when software behaves differently than its documented specifications, which can mislead users and create security risks.

• CWE-685
  Function Call With Incorrect Number of Arguments

  This weakness occurs when a program calls a function, method, or subroutine but provides the wrong number of arguments—either too many or too few. This…

• CWE-686
  Function Call With Incorrect Argument Type

  This vulnerability occurs when a program calls a function or method but passes an argument of the wrong data type, which can cause unexpected behavior or…

• CWE-687
  Function Call With Incorrectly Specified Argument Value

  This vulnerability occurs when a function is called with an argument that holds an incorrect or unexpected value, leading to unintended program behavior or…

• CWE-688
  Function Call With Incorrect Variable or Reference as Argument

  This vulnerability occurs when a function is called with the wrong variable or reference passed as an argument. This simple coding mistake can cause the…

• CWE-689
  Permission Race Condition During Resource Copy

  This vulnerability occurs when a system copies a file or resource but delays setting its final permissions until the entire copy operation is finished. During…

• CWE-690
  Unchecked Return Value to NULL Pointer Dereference

  This vulnerability occurs when a program calls a function that can return a NULL pointer to signal failure, but the code does not check for this error…

• CWE-691
  Insufficient Control Flow Management

  This vulnerability occurs when a program's execution flow isn't properly managed, allowing attackers to bypass critical checks, trigger unexpected code paths,…

• CWE-692
  Incomplete Denylist to Cross-Site Scripting

  This vulnerability occurs when an application relies on an incomplete denylist to block cross-site scripting (XSS) attacks, leaving the door open for…

• CWE-693
  Protection Mechanism Failure

  This weakness occurs when software either lacks a necessary security control, implements one that is too weak, or fails to activate an existing control in a…

• CWE-694
  Use of Multiple Resources with Duplicate Identifier

  This vulnerability occurs when a system uses multiple resources that can share the same identifier, even though the application logic requires each identifier…

• CWE-695
  Use of Low-Level Functionality

  This vulnerability occurs when code bypasses high-level framework controls by directly using low-level system functions, violating the intended security model.

• CWE-696
  Incorrect Behavior Order

  This weakness occurs when a system executes multiple dependent actions in the wrong sequence, leading to unexpected and potentially vulnerable states.

• CWE-697
  Incorrect Comparison

  This weakness occurs when a security-critical decision relies on a flawed comparison between two pieces of data. The incorrect logic can create a gap that…

• CWE-698
  Execution After Redirect (EAR)

  Execution After Redirect (EAR) occurs when a web application sends a redirect response to a user's browser but continues to run server-side code, potentially…

• CWE-703
  Improper Check or Handling of Exceptional Conditions

  This vulnerability occurs when software fails to properly plan for or manage rare but possible error scenarios, leaving it unprepared for unexpected events…

• CWE-704
  Incorrect Type Conversion or Cast

  This vulnerability occurs when software incorrectly changes data from one type to another, leading to unexpected behavior or security flaws.

• CWE-705
  Incorrect Control Flow Scoping

  This vulnerability occurs when a program fails to return execution to the correct point in the code after finishing a specific operation or handling an error.…

• CWE-706
  Use of Incorrectly-Resolved Name or Reference

  This vulnerability occurs when software uses a name, path, or reference to access a resource, but that identifier points to something outside the area the…

• CWE-707
  Improper Neutralization

  This vulnerability occurs when an application fails to properly validate or sanitize structured data before it's received from an external source or sent to…

• CWE-708
  Incorrect Ownership Assignment

  This vulnerability occurs when a system grants ownership of a resource to an entity that should not have that level of control, placing it outside the…

• CWE-710
  Improper Adherence to Coding Standards

  This weakness occurs when developers don't consistently follow established coding standards and best practices, which can introduce security flaws or make…

• CWE-732
  Incorrect Permission Assignment for Critical Resource

  This vulnerability occurs when a system grants overly permissive access to a sensitive resource, allowing unauthorized users or processes to read or alter it.

  High likelihood
• CWE-733
  Compiler Optimization Removal or Modification of Security-critical Code

  This vulnerability occurs when a compiler's optimization process unintentionally strips out or alters security-critical code that a developer intentionally…

• CWE-749
  Exposed Dangerous Method or Function

  This vulnerability occurs when a software component exposes an API or interface containing a high-risk function that lacks proper access controls, allowing…

  Low likelihood
• CWE-754
  Improper Check for Unusual or Exceptional Conditions

  This weakness occurs when software fails to properly anticipate and handle rare or unexpected runtime situations that fall outside normal operation.

  Medium likelihood
• CWE-755
  Improper Handling of Exceptional Conditions

  This vulnerability occurs when software fails to properly manage unexpected situations or errors, leaving it in an unstable or insecure state.

  Medium likelihood
• CWE-756
  Missing Custom Error Page

  This vulnerability occurs when an application fails to display its own user-friendly error pages, instead falling back to default system messages that can…

• CWE-757
  Selection of Less-Secure Algorithm During Negotiation ('Algorithm Downgrade')

  This vulnerability occurs when a protocol or system allows negotiating a security algorithm (like encryption) but chooses a weaker option than the strongest…

• CWE-758
  Reliance on Undefined, Unspecified, or Implementation-Defined Behavior

  This weakness occurs when software depends on specific behaviors of an API, data structure, or system component that are not formally guaranteed by its…

• CWE-759
  Use of a One-Way Hash without a Salt

  This vulnerability occurs when a system uses a one-way hash function (like MD5 or SHA-256) to protect sensitive data like passwords, but fails to add a unique…

• CWE-760
  Use of a One-Way Hash with a Predictable Salt

  This vulnerability occurs when an application uses a one-way hash (like for password storage) but combines it with a predictable or easily guessed salt. This…

• CWE-761
  Free of Pointer not at Start of Buffer

  This vulnerability occurs when a program incorrectly frees a memory pointer that no longer points to the beginning of the allocated heap buffer, often due to…

• CWE-762
  Mismatched Memory Management Routines

  This vulnerability occurs when a program uses incompatible functions to allocate and free memory. For example, freeing memory with a function that doesn't…

  Low likelihood
• CWE-763
  Release of Invalid Pointer or Reference

  This vulnerability occurs when a program tries to free a memory resource back to the system but uses an incorrect deallocation method or calls the correct…

• CWE-764
  Multiple Locks of a Critical Resource

  This vulnerability occurs when a critical resource, such as a file, data structure, or connection, is locked more times than the software logic intended,…

• CWE-765
  Multiple Unlocks of a Critical Resource

  This vulnerability occurs when a critical resource, like a lock or semaphore, is unlocked more times than it was locked, putting the system into an unexpected…

• CWE-766
  Critical Data Element Declared Public

  This vulnerability occurs when a critical piece of data—like a variable, field, or class member—is mistakenly declared as public when it should be kept…

• CWE-767
  Access to Critical Private Variable via Public Method

  This vulnerability occurs when a class exposes a public method that directly accesses or alters a private variable.

• CWE-768
  Incorrect Short Circuit Evaluation

  This vulnerability occurs when a program's conditional statement uses short-circuit evaluation (where later parts of an AND/OR check are skipped if the…

  Low likelihood
• CWE-770
  Allocation of Resources Without Limits or Throttling

  This vulnerability occurs when a system allows users or processes to request resources without any built-in caps or rate limits. Think of it as a buffet with…

  High likelihood
• CWE-771
  Missing Reference to Active Allocated Resource

  This vulnerability occurs when software loses track of a resource it has allocated, like memory or a file handle, preventing the system from properly…

  Medium likelihood
• CWE-772
  Missing Release of Resource after Effective Lifetime

  This vulnerability occurs when a program fails to properly release a system resource—like memory, file handles, or network sockets—after it is no longer…

  High likelihood
• CWE-773
  Missing Reference to Active File Descriptor or Handle

  This vulnerability occurs when a program fails to keep track of open files or resources, preventing the system from properly closing and reclaiming them.

• CWE-774
  Allocation of File Descriptors or Handles Without Limits or Throttling

  This vulnerability occurs when an application creates file descriptors or handles for a user or process without enforcing any limits on the total number that…

  Low likelihood
• CWE-775
  Missing Release of File Descriptor or Handle after Effective Lifetime

  This vulnerability occurs when a program fails to properly close file descriptors or handles after they are no longer needed, leaving these system resources…

• CWE-776
  Improper Restriction of Recursive Entity References in DTDs ('XML Entity Expansion')

  This vulnerability occurs when an XML parser allows Document Type Definitions (DTDs) to contain recursively defined entities without proper limits, enabling…

  Medium likelihood
• CWE-777
  Regular Expression without Anchors

  This vulnerability occurs when a regular expression used for validation or sanitization lacks anchors, allowing unintended characters or malicious payloads to…

  Medium likelihood
• CWE-778
  Insufficient Logging

  This weakness occurs when an application fails to properly record important security events or captures them with insufficient detail, making it hard to spot…

  Medium likelihood
• CWE-779
  Logging of Excessive Data

  This vulnerability occurs when an application records more information than necessary in its logs, making log files difficult to analyze and potentially…

  Low likelihood
• CWE-780
  Use of RSA Algorithm without OAEP

  This vulnerability occurs when an application implements RSA encryption but fails to use Optimal Asymmetric Encryption Padding (OAEP), significantly weakening…

  Medium likelihood
• CWE-781
  Improper Address Validation in IOCTL with METHOD_NEITHER I/O Control Code

  This vulnerability occurs when a Windows driver defines an IOCTL using METHOD_NEITHER but fails to properly check the user-supplied memory addresses before…

• CWE-782
  Exposed IOCTL with Insufficient Access Control

  This vulnerability occurs when a system exposes an IOCTL (Input/Output Control) interface that performs sensitive operations, but fails to implement proper…

• CWE-783
  Operator Precedence Logic Error

  This vulnerability occurs when a developer writes a conditional expression where the intended logic is broken due to misunderstanding or misapplying the rules…

  Low likelihood
• CWE-784
  Reliance on Cookies without Validation and Integrity Checking in a Security Decision

  This vulnerability occurs when an application makes security decisions—like granting access or verifying identity—based solely on cookie data without first…

  High likelihood
• CWE-785
  Use of Path Manipulation Function without Maximum-sized Buffer

  This vulnerability occurs when a program uses a path manipulation function but supplies an output buffer that is too small to hold the maximum possible path…

• CWE-786
  Access of Memory Location Before Start of Buffer

  This vulnerability occurs when software attempts to read from or write to a memory location positioned before the official start of a buffer.

• CWE-787
  Out-of-bounds Write

  This vulnerability occurs when software incorrectly writes data outside the boundaries of its allocated memory buffer, either beyond the end or before the…

  High likelihood
• CWE-788
  Access of Memory Location After End of Buffer

  This vulnerability occurs when software attempts to read from or write to a memory buffer using an index or pointer that points past the buffer's allocated…

• CWE-789
  Memory Allocation with Excessive Size Value

  This vulnerability occurs when a program allocates memory based on a user-supplied or untrusted size value without proper validation. If an attacker provides…

• CWE-790
  Improper Filtering of Special Elements

  This vulnerability occurs when an application accepts data from a source but fails to properly sanitize or incorrectly filters out special characters or…

• CWE-791
  Incomplete Filtering of Special Elements

  This vulnerability occurs when an application accepts data from a source but fails to properly clean or neutralize all special characters or commands before…

• CWE-792
  Incomplete Filtering of One or More Instances of Special Elements

  This vulnerability occurs when an application receives external data but fails to properly neutralize all instances of potentially dangerous characters or…

• CWE-793
  Only Filtering One Instance of a Special Element

  This vulnerability occurs when an application processes incoming data but only removes or neutralizes one occurrence of a dangerous element, leaving other…

• CWE-794
  Incomplete Filtering of Multiple Instances of Special Elements

  This vulnerability occurs when an application receives data from a source but fails to remove or neutralize every instance of a potentially dangerous element…

• CWE-795
  Only Filtering Special Elements at a Specified Location

  This vulnerability occurs when a security filter only checks for dangerous input patterns at specific, predefined locations within the data. It fails to scan…

• CWE-796
  Only Filtering Special Elements Relative to a Marker

  This vulnerability occurs when software filters dangerous inputs or characters, but only checks for them in specific, expected locations (like the start or…

• CWE-797
  Only Filtering Special Elements at an Absolute Position

  This vulnerability occurs when software checks for dangerous characters or patterns only at a fixed, hardcoded location in input data. Because it ignores…

• CWE-798
  Use of Hard-coded Credentials

  This vulnerability occurs when software contains built-in, unchangeable authentication secrets like passwords or encryption keys within its source code or…

  High likelihood
• CWE-799
  Improper Control of Interaction Frequency

  This vulnerability occurs when an application fails to properly restrict how often or how many times a user or automated system can interact with it.

• CWE-804
  Guessable CAPTCHA

  This vulnerability occurs when a CAPTCHA challenge is too easy for automated bots to solve, either by guessing or using pattern recognition, allowing them to…

• CWE-805
  Buffer Access with Incorrect Length Value

  This vulnerability occurs when software reads from or writes to a buffer using a loop or sequential operation, but mistakenly calculates or provides an…

  High likelihood
• CWE-806
  Buffer Access Using Size of Source Buffer

  This vulnerability occurs when a program uses the size of the source data buffer to control reading or writing to a smaller destination buffer, potentially…

• CWE-807
  Reliance on Untrusted Inputs in a Security Decision

  This vulnerability occurs when an application's security check depends on user-controlled data that can be manipulated to bypass protection mechanisms, such…

  High likelihood
• CWE-820
  Missing Synchronization

  This vulnerability occurs when multiple parts of your application (like threads or processes) use the same resource—such as a variable, file, or data…

• CWE-821
  Incorrect Synchronization

  This vulnerability occurs when multiple parts of a program, such as threads or processes, access a shared resource like a variable, file, or data structure…

• CWE-822
  Untrusted Pointer Dereference

  This vulnerability occurs when software takes a value from an untrusted source, treats it as a memory address (a pointer), and then accesses that memory…

• CWE-823
  Use of Out-of-range Pointer Offset

  This vulnerability occurs when a program calculates a new memory address using a valid pointer and an offset, but the resulting address points outside the…

• CWE-824
  Access of Uninitialized Pointer

  This vulnerability occurs when a program tries to use a pointer variable before it has been assigned a valid memory address.

• CWE-825
  Expired Pointer Dereference

  This vulnerability occurs when a program tries to use a pointer that still points to a memory location that has already been freed or released.

• CWE-826
  Premature Release of Resource During Expected Lifetime

  This happens when software incorrectly frees or closes a resource—like memory, a file handle, or a network connection—while that resource is still supposed to…

• CWE-827
  Improper Control of Document Type Definition

  This vulnerability occurs when an application fails to properly restrict which Document Type Definitions (DTDs) can be referenced during XML parsing.…

• CWE-828
  Signal Handler with Functionality that is not Asynchronous-Safe

  This weakness occurs when a program's signal handler contains code that is not asynchronous-safe. This means the handler can be interrupted or can corrupt…

• CWE-829
  Inclusion of Functionality from Untrusted Control Sphere

  This weakness occurs when an application integrates executable code, like a library or plugin, from a source it does not fully control or trust.

• CWE-830
  Inclusion of Web Functionality from an Untrusted Source

  This vulnerability occurs when a web application directly imports and executes functionality, like a widget or script, from an external, untrusted domain.…

• CWE-831
  Signal Handler Function Associated with Multiple Signals

  This vulnerability occurs when a single function is registered to handle multiple different operating system signals, creating potential race conditions if…

• CWE-832
  Unlock of a Resource that is not Locked

  This vulnerability occurs when a program tries to unlock a resource, such as a mutex or semaphore, that is not currently in a locked state.

• CWE-833
  Deadlock

  Deadlock occurs when two or more threads or processes become permanently stuck, each waiting for the other to release a shared resource like a lock or mutex,…

• CWE-834
  Excessive Iteration

  This vulnerability occurs when a program runs a loop too many times because it lacks proper limits on its iterations.

• CWE-835
  Loop with Unreachable Exit Condition ('Infinite Loop')

  An infinite loop occurs when a program's iteration logic contains an exit condition that can never be satisfied, causing the loop to run indefinitely and…

• CWE-836
  Use of Password Hash Instead of Password for Authentication

  This vulnerability occurs when an application's authentication system accepts a password hash directly from the client for verification, instead of receiving…

• CWE-837
  Improper Enforcement of a Single, Unique Action

  This vulnerability occurs when a system fails to properly prevent users from repeating an action that should only be performed once, such as submitting a…

• CWE-838
  Inappropriate Encoding for Output Context

  This vulnerability occurs when a system uses one type of encoding for its output, but the component receiving that data expects a different encoding. The…

• CWE-839
  Numeric Range Comparison Without Minimum Check

  This vulnerability occurs when software validates that a number is within an acceptable range by only checking that it's less than or equal to a maximum…

• CWE-841
  Improper Enforcement of Behavioral Workflow

  This weakness occurs when an application requires a user to follow a specific sequence of actions, but fails to enforce that order. Attackers can exploit this…

• CWE-842
  Placement of User into Incorrect Group

  This vulnerability occurs when a system or administrator assigns a user to the wrong security group or role.

• CWE-843
  Access of Resource Using Incompatible Type ('Type Confusion')

  Type confusion occurs when a program creates a resource—like a pointer, object, or variable—with one data type, but later incorrectly accesses it as a…

• CWE-862
  Missing Authorization

  This vulnerability occurs when an application fails to verify whether a user has permission to access specific data or execute certain actions before allowing…

  High likelihood
• CWE-863
  Incorrect Authorization

  This vulnerability occurs when an application checks if a user is allowed to perform an action or access data, but the check is flawed or incomplete, allowing…

  High likelihood
• CWE-908
  Use of Uninitialized Resource

  This vulnerability occurs when software attempts to use a resource—like memory, a file handle, or an object—before it has been properly set up or assigned a…

  Medium likelihood
• CWE-909
  Missing Initialization of Resource

  The software fails to properly set up a critical resource before using it.

  Medium likelihood
• CWE-910
  Use of Expired File Descriptor

  This vulnerability occurs when a program attempts to use a file descriptor after it has been closed, treating it as if it were still valid.

  Medium likelihood
• CWE-911
  Improper Update of Reference Count

  This vulnerability occurs when a program uses a reference counter to track resource usage but fails to update the count correctly, either by missing an update…

  Medium likelihood
• CWE-912
  Hidden Functionality

  Hidden functionality refers to undocumented features, commands, or code within a product that are not part of its official specification and are not obvious…

• CWE-913
  Improper Control of Dynamically-Managed Code Resources

  This vulnerability occurs when an application fails to properly secure access to code resources that can be created or altered at runtime, such as variables,…

• CWE-914
  Improper Control of Dynamically-Identified Variables

  This vulnerability occurs when an application fails to properly secure access to variables whose names are determined at runtime, allowing attackers to read…

• CWE-915
  Improperly Controlled Modification of Dynamically-Determined Object Attributes

  This vulnerability occurs when an application accepts user input that specifies which object attributes or fields to create or update, but fails to restrict…

• CWE-916
  Use of Password Hash With Insufficient Computational Effort

  This vulnerability occurs when a system protects passwords by hashing them, but uses a hashing algorithm that is too fast or computationally cheap. This makes…

• CWE-917
  Improper Neutralization of Special Elements used in an Expression Language Statement ('Expression Language Injection')

  Expression Language Injection occurs when an application uses untrusted, external input to build an expression language statement—common in frameworks like…

• CWE-918
  Server-Side Request Forgery (SSRF)

  Server-Side Request Forgery (SSRF) occurs when a web application fetches a remote resource based on user-controlled input, but fails to properly validate or…

• CWE-920
  Improper Restriction of Power Consumption

  This vulnerability occurs when software running on a power-constrained device, like a battery-powered mobile or embedded system, fails to actively manage and…

• CWE-921
  Storage of Sensitive Data in a Mechanism without Access Control

  This vulnerability occurs when an application saves sensitive information to a storage location that lacks proper access restrictions, allowing unauthorized…

• CWE-922
  Insecure Storage of Sensitive Information

  This vulnerability occurs when an application stores sensitive data—like credentials, personal information, or encryption keys—without enforcing proper access…

• CWE-923
  Improper Restriction of Communication Channel to Intended Endpoints

  This vulnerability occurs when a system opens a communication channel for a sensitive task but fails to properly verify that it's actually talking to the…

• CWE-924
  Improper Enforcement of Message Integrity During Transmission in a Communication Channel

  This vulnerability occurs when an application receives data over a network but fails to properly verify that the information wasn't altered in transit.

• CWE-925
  Improper Verification of Intent by Broadcast Receiver

  This vulnerability occurs when an Android app's Broadcast Receiver accepts an Intent without confirming it originated from a trusted, authorized source, such…

• CWE-926
  Improper Export of Android Application Components

  This vulnerability occurs when an Android app makes a component (like an Activity, Service, or Content Provider) available to other apps without enforcing…

• CWE-927
  Use of Implicit Intent for Sensitive Communication

  This vulnerability occurs when an Android app uses an implicit intent to send sensitive data, allowing any other app on the device to potentially intercept…

• CWE-939
  Improper Authorization in Handler for Custom URL Scheme

  This vulnerability occurs when an app implements a custom URL scheme handler but fails to properly verify which other apps or sources are allowed to trigger it.

• CWE-940
  Improper Verification of Source of a Communication Channel

  This vulnerability occurs when an application accepts incoming communication requests without properly checking where they originate from, allowing…

• CWE-941
  Incorrectly Specified Destination in a Communication Channel

  This vulnerability occurs when an application establishes an outgoing communication channel but fails to correctly define or enforce the intended recipient.…

• CWE-942
  Permissive Cross-domain Security Policy with Untrusted Domains

  This vulnerability occurs when a web application's cross-domain security policy, like a Content Security Policy (CSP), explicitly allows communication with…

• CWE-943
  Improper Neutralization of Special Elements in Data Query Logic

  This vulnerability occurs when an application builds a query for a data store (like a database) but fails to properly sanitize user-controlled input. This…

• CWE-1004
  Sensitive Cookie Without 'HttpOnly' Flag

  This vulnerability occurs when an application stores sensitive data in a cookie but fails to set the 'HttpOnly' flag, leaving the cookie accessible to…

  Medium likelihood
• CWE-1007
  Insufficient Visual Distinction of Homoglyphs Presented to User

  This vulnerability occurs when an application shows text or symbols to users without clearly distinguishing between characters that look identical or very…

  Medium likelihood
• CWE-1021
  Improper Restriction of Rendered UI Layers or Frames

  This vulnerability occurs when a web application fails to properly control whether its pages can be embedded within frames or UI layers from other websites,…

• CWE-1022
  Use of Web Link to Untrusted Target with window.opener Access

  This vulnerability occurs when a web application links to an external, untrusted site without protecting its own window from being manipulated by that site.…

  Medium likelihood
• CWE-1023
  Incomplete Comparison with Missing Factors

  This weakness occurs when a program compares two items but fails to check all the necessary attributes that define their true relationship. The incomplete…

• CWE-1024
  Comparison of Incompatible Types

  This vulnerability occurs when code directly compares two values of fundamentally different data types, which can lead to unreliable or incorrect results…

• CWE-1025
  Comparison Using Wrong Factors

  This weakness occurs when a program compares two items but checks the wrong properties or attributes. This flawed comparison leads to incorrect decisions,…

• CWE-1037
  Processor Optimization Removal or Modification of Security-critical Code

  This vulnerability occurs when a processor's performance optimization unintentionally strips out or alters security-critical code that a developer…

  Low likelihood
• CWE-1038
  Insecure Automated Optimizations

  This vulnerability occurs when software uses automated tools to optimize code for performance or efficiency, but those optimizations accidentally weaken or…

  Low likelihood
• CWE-1039
  Inadequate Detection or Handling of Adversarial Input Perturbations in Automated Recognition Mechanism

  This vulnerability occurs when a system uses automated AI or machine learning to classify complex inputs like images, audio, or text, but fails to correctly…

• CWE-1041
  Use of Redundant Code

  This weakness occurs when a codebase contains identical or nearly identical logic duplicated across multiple functions, methods, or modules. This redundancy…

• CWE-1042
  Static Member Data Element outside of a Singleton Class Element

  This weakness occurs when a class that isn't designed as a singleton (a class meant to have only one instance) contains a non-final static member variable.…

• CWE-1043
  Data Element Aggregating an Excessively Large Number of Non-Primitive Elements

  This weakness occurs when a data structure, like a class or object, contains too many complex sub-elements (e.g., other objects or structs) instead of simple…

• CWE-1044
  Architecture with Number of Horizontal Layers Outside of Expected Range

  This occurs when a software system is built with either too many or too few distinct architectural layers, falling outside a recommended range that supports…

• CWE-1045
  Parent Class with a Virtual Destructor and a Child Class without a Virtual Destructor

  This occurs when a base class defines a virtual destructor, but a derived class inherits from it without declaring its own virtual destructor.

• CWE-1046
  Creation of Immutable Text Using String Concatenation

  This weakness occurs when code builds a string within a loop using simple concatenation (like +=), which unintentionally creates new string objects every time…

• CWE-1047
  Modules with Circular Dependencies

  This weakness occurs when software modules have circular references, meaning Module A depends on Module B, which in turn depends back on Module A, creating a…

• CWE-1048
  Invokable Control Element with Large Number of Outward Calls

  This weakness occurs when a single function, method, or callable code block makes an excessively high number of calls to other objects or components outside…

• CWE-1049
  Excessive Data Query Operations in a Large Data Table

  This weakness occurs when an application runs a database query that uses numerous joins and sub-queries on a very large table, leading to severe performance…

• CWE-1050
  Excessive Platform Resource Consumption within a Loop

  This vulnerability occurs when a loop contains code that repeatedly consumes critical system resources like file handles, database connections, memory, or…

• CWE-1051
  Initialization with Hard-Coded Network Resource Configuration Data

  This vulnerability occurs when software uses fixed, hard-coded values—like IP addresses, domain names, or URLs—to identify network resources during its…

• CWE-1052
  Excessive Use of Hard-Coded Literals in Initialization

  This weakness occurs when software initializes variables or data structures using hard-coded values (like strings, file paths, or network addresses) instead…

• CWE-1053
  Missing Documentation for Design

  This weakness occurs when software lacks clear design documentation, making it difficult to understand how the system is structured and intended to work.

• CWE-1054
  Invocation of a Control Element at an Unnecessarily Deep Horizontal Layer

  This weakness occurs when code in one architectural layer directly calls functions or methods in a much deeper layer, skipping over the intermediate layers…

• CWE-1055
  Multiple Inheritance from Concrete Classes

  This weakness occurs when a single class inherits functionality and state from more than one concrete (fully implemented) parent class.

• CWE-1056
  Invokable Control Element with Variadic Parameters

  This weakness occurs when a callable function or method is defined to accept a variable number of arguments (variadic parameters).

• CWE-1057
  Data Access Operations Outside of Expected Data Manager Component

  This weakness occurs when an application bypasses its dedicated, central data manager component and performs data access operations through other code paths.

• CWE-1058
  Invokable Control Element in Multi-Thread Context with non-Final Static Storable or Member Element

  This happens when a method or function, designed to run in a multi-threaded environment, accesses or modifies a non-final static variable or class member.…

• CWE-1059
  Insufficient Technical Documentation

  This weakness occurs when a software or hardware product lacks comprehensive technical documentation. Missing or incomplete details about the system's…

• CWE-1060
  Excessive Number of Inefficient Server-Side Data Accesses

  This weakness occurs when an application makes an excessive number of individual data queries to a server or database, instead of using more efficient methods…

• CWE-1061
  Insufficient Encapsulation

  This weakness occurs when a software component exposes too much of its internal workings, such as data structures or implementation logic. This lack of proper…

• CWE-1062
  Parent Class with References to Child Class

  This weakness occurs when a parent class directly references its child classes, their methods, or their member variables, creating a problematic and tightly…

• CWE-1063
  Creation of Class Instance within a Static Code Block

  This weakness occurs when a class instance is created inside a static initializer block, causing premature and potentially expensive object creation.

• CWE-1064
  Invokable Control Element with Signature Containing an Excessive Number of Parameters

  This weakness occurs when a function, method, or subroutine is defined with an unnecessarily high number of parameters in its signature.

• CWE-1065
  Runtime Resource Management Control Element in a Component Built to Run on Application Servers

  This weakness occurs when an application built to run on a managed application server bypasses the server's high-level APIs and instead uses low-level…

• CWE-1066
  Missing Serialization Control Element

  This weakness occurs when a class or data structure is marked as serializable but lacks the required control methods to properly handle the serialization and…

• CWE-1067
  Excessive Execution of Sequential Searches of Data Resource

  This weakness occurs when a database query is structured in a way that forces the system to scan entire tables row-by-row, instead of using an available index…

• CWE-1068
  Inconsistency Between Implementation and Documented Design

  This weakness occurs when the actual code implementation deviates from the intended design described in its official documentation, creating a mismatch…

• CWE-1069
  Empty Exception Block

  This weakness occurs when a try-catch or try-finally block is present but contains no code to handle the caught exception or perform cleanup.

• CWE-1070
  Serializable Data Element Containing non-Serializable Item Elements

  This weakness occurs when a class or data structure is marked as serializable, but it contains one or more member elements that cannot be serialized. This…

• CWE-1071
  Empty Code Block

  An empty code block occurs when a section of source code, such as a conditional statement or function body, contains no executable statements.

• CWE-1072
  Data Resource Access without Use of Connection Pooling

  This weakness occurs when an application creates a new database connection for every request instead of using a managed connection pool. This inefficient…

• CWE-1073
  Non-SQL Invokable Control Element with Excessive Number of Data Resource Accesses

  This weakness occurs when a client-side function or method makes an excessive number of individual data requests through a non-SQL data manager, instead of…

• CWE-1074
  Class with Excessively Deep Inheritance

  This weakness occurs when a class inherits from an excessive number of parent classes, creating a deep and complex inheritance hierarchy.

• CWE-1075
  Unconditional Control Flow Transfer outside of Switch Block

  This weakness occurs when code uses an unconditional jump, like a 'goto' statement, outside of a structured control flow block like a switch statement. This…

• CWE-1076
  Insufficient Adherence to Expected Conventions

  This weakness occurs when software code, design, documentation, or other components fail to follow established industry or project-specific standards and…

• CWE-1077
  Floating Point Comparison with Incorrect Operator

  This vulnerability occurs when code compares two floating-point numbers using direct equality operators (like == or !=) without accounting for inherent…

• CWE-1078
  Inappropriate Source Code Style or Formatting

  This weakness occurs when source code violates established style guidelines for formatting, indentation, whitespace, or commenting, making it difficult to…

• CWE-1079
  Parent Class without Virtual Destructor Method

  This occurs when a base class, designed to be inherited from, does not declare its destructor as virtual. This oversight prevents proper cleanup when objects…

• CWE-1080
  Source Code File with Excessive Number of Lines of Code

  This weakness occurs when a single source code file grows excessively large, containing too many lines of code.

• CWE-1082
  Class Instance Self Destruction Control Element

  This vulnerability occurs when an object's code contains logic that triggers its own deletion or destruction during runtime.

• CWE-1083
  Data Access from Outside Expected Data Manager Component

  This weakness occurs when an application is designed to handle all data operations through a dedicated manager component (like a database layer), but code…

• CWE-1084
  Invokable Control Element with Excessive File or Data Access Operations

  This weakness occurs when a single function or method performs an excessive number of file or database operations, such as repeated reads, writes, or queries.…

• CWE-1085
  Invokable Control Element with Excessive Volume of Commented-out Code

  This weakness occurs when a callable function, method, or procedure contains a large amount of inactive, commented-out code within its implementation body.

• CWE-1086
  Class with Excessive Number of Child Classes

  This weakness occurs when a parent class has an excessive number of child classes that inherit from it, creating a deep and overly complex inheritance tree.

• CWE-1087
  Class with Virtual Method without a Virtual Destructor

  This occurs when a class defines a virtual method but does not also provide a virtual destructor.

• CWE-1088
  Synchronous Access of Remote Resource without Timeout

  This vulnerability occurs when an application makes a synchronous call to a remote service or resource but does not set a timeout, or sets an infinite one.…

• CWE-1089
  Large Data Table with Excessive Number of Indices

  This weakness occurs when an application uses a database table with a very large number of rows and creates too many indexes on it, degrading overall system…

• CWE-1090
  Method Containing Access of a Member Element from Another Class

  This weakness occurs when a method in one class directly accesses a private or internal member (like a field or property) of a different class, bypassing…

• CWE-1091
  Use of Object without Invoking Destructor Method

  This weakness occurs when a program accesses an object but fails to properly call its destructor or finalizer method. This leaves the cleanup of the object's…

• CWE-1092
  Use of Same Invokable Control Element in Multiple Architectural Layers

  This weakness occurs when the same piece of code or control logic is duplicated across different architectural layers of an application, such as the…

• CWE-1093
  Excessively Complex Data Representation

  This weakness occurs when software uses an overly complicated internal model to represent its data or the relationships between data elements.

• CWE-1094
  Excessive Index Range Scan for a Data Resource

  This weakness occurs when a database query performs an index range scan that can access an unnecessarily large number of rows from a substantial data table,…

• CWE-1095
  Loop Condition Value Update within the Loop

  This vulnerability occurs when a loop's exit condition depends on a variable that is also modified inside the loop body. This creates a complex and often…

• CWE-1096
  Singleton Class Instance Creation without Proper Locking or Synchronization

  This flaw occurs when a Singleton class is implemented without proper thread-safe controls, allowing multiple instances to be created in concurrent…

• CWE-1097
  Persistent Storable Data Element without Associated Comparison Control Element

  This weakness occurs when a persistent data object lacks the necessary methods to be properly compared, which can lead to inconsistent or incorrect behavior…

• CWE-1098
  Data Element containing Pointer Item without Proper Copy Control Element

  This weakness occurs when a data structure contains a pointer, but the code lacks proper methods to copy or initialize that pointer safely.

• CWE-1099
  Inconsistent Naming Conventions for Identifiers

  This weakness occurs when a codebase uses mixed naming styles for elements like variables, functions, data types, or files, creating an inconsistent and…

• CWE-1100
  Insufficient Isolation of System-Dependent Functions

  This weakness occurs when an application fails to separate its core logic from functions that depend on a specific operating system, hardware, or external…

• CWE-1101
  Reliance on Runtime Component in Generated Code

  This vulnerability occurs when software depends on automatically generated code that requires a specific, often external, runtime component to function.…

• CWE-1102
  Reliance on Machine-Dependent Data Representation

  This weakness occurs when software directly depends on how a specific machine, processor, or operating system represents data in memory. Code that makes…

• CWE-1103
  Use of Platform-Dependent Third Party Components

  This weakness occurs when software depends on third-party libraries or components that behave differently or lack support across various target platforms or…

• CWE-1104
  Use of Unmaintained Third Party Components

  This weakness occurs when software depends on third-party libraries, frameworks, or modules that are no longer actively updated or supported by their creators…

• CWE-1105
  Insufficient Encapsulation of Machine-Dependent Functionality

  This weakness occurs when an application relies on hardware-specific or platform-dependent features but fails to isolate that code from the rest of the…

• CWE-1106
  Insufficient Use of Symbolic Constants

  This weakness occurs when developers embed raw numbers or text strings directly in code instead of using named symbolic constants, making future updates and…

• CWE-1107
  Insufficient Isolation of Symbolic Constant Definitions

  This weakness occurs when a codebase uses symbolic constants (like named values for numbers or strings) but scatters their definitions across many files…

• CWE-1108
  Excessive Reliance on Global Variables

  This weakness occurs when a codebase depends too heavily on global variables to store and manage state, rather than keeping data within appropriate local…

• CWE-1109
  Use of Same Variable for Multiple Purposes

  This weakness occurs when a single variable is reused to handle multiple, unrelated tasks or to store different pieces of data throughout the code. This…

• CWE-1110
  Incomplete Design Documentation

  This vulnerability occurs when a system's design documentation is missing critical details about how the software actually works. Key omissions include…

• CWE-1111
  Incomplete I/O Documentation

  This weakness occurs when a product's documentation fails to clearly and completely define its inputs, outputs, or how it interacts with other systems or…

• CWE-1112
  Incomplete Documentation of Program Execution

  This weakness occurs when a system's documentation fails to completely list all the ways its behavior can be controlled or changed during execution.

• CWE-1113
  Inappropriate Comment Style

  This weakness occurs when source code comments are written in a style or format that doesn't match the project's established standards or common conventions…

• CWE-1114
  Inappropriate Whitespace Style

  This weakness occurs when source code uses inconsistent or non-standard whitespace formatting, such as irregular indentation, spacing, or line breaks.

• CWE-1115
  Source Code Element without Standard Prologue

  This weakness occurs when source code files or modules lack a consistent, standardized header or prologue that the development team has agreed upon.

• CWE-1116
  Inaccurate Comments

  This weakness occurs when code comments do not correctly describe or explain the actual behavior of the associated code. Misleading comments create a…

• CWE-1117
  Callable with Insufficient Behavioral Summary

  This weakness occurs when a function, method, or API lacks clear documentation about its behavior. The signature or comments fail to properly explain what…

• CWE-1118
  Insufficient Documentation of Error Handling Techniques

  This weakness occurs when software documentation fails to clearly explain how the system manages errors, exceptions, or unexpected conditions. Developers are…

• CWE-1119
  Excessive Use of Unconditional Branching

  This weakness occurs when code relies heavily on unconditional jumps like 'goto' statements, making the program flow difficult to follow.

• CWE-1120
  Excessive Code Complexity

  This weakness occurs when software contains sections of code that are unnecessarily intricate, as measured by established complexity metrics like cyclomatic…

• CWE-1121
  Excessive McCabe Cyclomatic Complexity

  This weakness occurs when a function or method has an overly complex control flow, measured by a high McCabe Cyclomatic Complexity score. This makes the code…

• CWE-1122
  Excessive Halstead Complexity

  This weakness occurs when code has an excessively high Halstead complexity score, indicating it is overly intricate and difficult to analyze.

• CWE-1123
  Excessive Use of Self-Modifying Code

  The software relies heavily on code that rewrites itself during execution, making it difficult to analyze and maintain.

• CWE-1124
  Excessively Deep Nesting

  This weakness occurs when a function, method, or code block contains too many levels of nested loops, conditionals, or other control structures, making the…

• CWE-1125
  Excessive Attack Surface

  This weakness occurs when a software product has an unnecessarily large number of entry and exit points that an attacker can target, exceeding a reasonable…

• CWE-1126
  Declaration of Variable with Unnecessarily Wide Scope

  This weakness occurs when a variable is declared with a broader scope than it actually needs, such as declaring a variable at a global or function level when…

• CWE-1127
  Compilation with Insufficient Warnings or Errors

  This weakness occurs when source code is compiled without enabling a comprehensive set of warning flags from the compiler. This practice allows subtle bugs,…

• CWE-1164
  Irrelevant Code

  Irrelevant code refers to sections of a program that have no impact on its execution, data, or logic. Removing this code would not change the software's…

• CWE-1173
  Improper Use of Validation Framework

  This vulnerability occurs when a software application either fails to use or incorrectly implements a built-in or library-provided input validation framework.

• CWE-1174
  ASP.NET Misconfiguration: Improper Model Validation

  This vulnerability occurs when an ASP.NET application either completely bypasses the built-in model validation system or implements it incorrectly, allowing…

• CWE-1176
  Inefficient CPU Computation

  This weakness occurs when software uses inefficient algorithms or suboptimal CPU operations, performing unnecessary or overly complex calculations that waste…

• CWE-1177
  Use of Prohibited Code

  This vulnerability occurs when software incorporates a function, library, or third-party component that has been explicitly banned by the development team or…

• CWE-1188
  Initialization of a Resource with an Insecure Default

  This vulnerability occurs when software uses an insecure default setting or value for a resource, assuming an administrator will change it later.

• CWE-1189
  Improper Isolation of Shared Resources on System-on-a-Chip (SoC)

  This vulnerability occurs when a System-on-a-Chip (SoC) fails to properly separate shared hardware resources between secure (trusted) and non-secure…

• CWE-1190
  DMA Device Enabled Too Early in Boot Phase

  This vulnerability occurs when a device with Direct Memory Access (DMA) capability is activated before the system's security settings are fully locked in…

• CWE-1191
  On-Chip Debug and Test Interface With Improper Access Control

  This vulnerability occurs when a hardware chip's debug or test interface (like JTAG) lacks proper access controls. Without correct authorization checks,…

• CWE-1192
  Improper Identifier for IP Block used in System-On-Chip (SOC)

  This weakness occurs when a System-on-Chip (SoC) lacks a secure, unique, and permanent identifier for its internal hardware components (IP blocks). Without…

• CWE-1193
  Power-On of Untrusted Execution Core Before Enabling Fabric Access Control

  This vulnerability occurs when a system powers up hardware components containing untrusted firmware before establishing critical security controls for the…

• CWE-1204
  Generation of Weak Initialization Vector (IV)

  This vulnerability occurs when software uses a weak or predictable Initialization Vector (IV) for cryptographic operations. Many encryption algorithms require…

• CWE-1209
  Failure to Disable Reserved Bits

  This vulnerability occurs when reserved bits in a hardware design are left active in production. Designers sometimes use these bits for debugging or future…

• CWE-1220
  Insufficient Granularity of Access Control

  This vulnerability occurs when a system's access controls are too broad, allowing unauthorized users or processes to read or modify sensitive resources.…

• CWE-1221
  Incorrect Register Defaults or Module Parameters

  This vulnerability occurs when hardware description language (HDL) code sets insecure default values for hardware registers or configurable module parameters.…

• CWE-1222
  Insufficient Granularity of Address Regions Protected by Register Locks

  This vulnerability occurs when a hardware design uses a single lock bit to protect a large, coarse block of memory addresses. This lack of granularity creates…

• CWE-1223
  Race Condition for Write-Once Attributes

  This vulnerability occurs when an untrusted software component wins a race condition and writes to a hardware register before the trusted component can,…

• CWE-1224
  Improper Restriction of Write-Once Bit Fields

  This vulnerability occurs when hardware write-once protection mechanisms, often called 'sticky bits,' are incorrectly implemented, allowing software to…

• CWE-1229
  Creation of Emergent Resource

  This vulnerability occurs when a system's normal operations unintentionally create new, exploitable resources that attackers can use to bypass security…

• CWE-1230
  Exposure of Sensitive Information Through Metadata

  This vulnerability occurs when an application protects the primary source of sensitive data but fails to secure the metadata derived from it. Attackers can…

• CWE-1231
  Improper Prevention of Lock Bit Modification

  This vulnerability occurs when hardware or firmware uses a lock bit to protect critical system registers or memory regions, but fails to properly prevent that…

• CWE-1232
  Improper Lock Behavior After Power State Transition

  This vulnerability occurs when a hardware lock bit, designed to protect critical system configuration registers, is improperly reset or becomes programmable…

• CWE-1233
  Security-Sensitive Hardware Controls with Missing Lock Bit Protection

  This vulnerability occurs when a hardware device uses a lock bit to protect critical configuration registers, but the lock fails to prevent writes to all…

• CWE-1234
  Hardware Internal or Debug Modes Allow Override of Locks

  Hardware debug modes or internal states can bypass critical system lock protections, allowing unauthorized changes to device configuration.

• CWE-1235
  Incorrect Use of Autoboxing and Unboxing for Performance Critical Operations

  This weakness occurs when a program relies on automatic boxing and unboxing of primitive types within performance-sensitive code sections, causing unnecessary…

• CWE-1236
  Improper Neutralization of Formula Elements in a CSV File

  This vulnerability occurs when an application writes user-supplied data into a CSV file without properly sanitizing special characters. Spreadsheet programs…

• CWE-1239
  Improper Zeroization of Hardware Register

  This vulnerability occurs when a hardware component fails to properly erase sensitive data from its internal registers before a new user or process gains…

• CWE-1240
  Use of a Cryptographic Primitive with a Risky Implementation

  This weakness occurs when a product uses a custom, unverified, or non-compliant implementation of a cryptographic algorithm instead of a trusted, standard…

• CWE-1241
  Use of Predictable Algorithm in Random Number Generator

  This vulnerability occurs when a device or application relies on a predictable algorithm to generate pseudo-random numbers, making the output sequence…

• CWE-1242
  Inclusion of Undocumented Features or Chicken Bits

  This vulnerability occurs when a hardware device or chip includes undocumented configuration bits (often called 'chicken bits') or hidden features that can…

• CWE-1243
  Sensitive Non-Volatile Information Not Protected During Debug

  This vulnerability occurs when security-critical data stored in hardware fuses is left unprotected and accessible during debug modes.

• CWE-1244
  Internal Asset Exposed to Unsafe Debug Access Level or State

  This vulnerability occurs when a system's debug or test interface supports multiple access levels, but an internal asset is incorrectly assigned a permissive…

• CWE-1245
  Improper Finite State Machines (FSMs) in Hardware Logic

  This vulnerability occurs when hardware logic contains flawed Finite State Machines (FSMs). Attackers can exploit these design errors to force the system into…

• CWE-1246
  Improper Write Handling in Limited-write Non-Volatile Memories

  This vulnerability occurs when a system fails to properly manage write operations on memory hardware that has a limited lifespan, such as Flash or EEPROM.…

• CWE-1247
  Improper Protection Against Voltage and Clock Glitches

  This vulnerability occurs when a hardware device lacks proper physical safeguards against deliberate electrical manipulation. Without dedicated protection…

• CWE-1248
  Semiconductor Defects in Hardware Logic with Security-Sensitive Implications

  A security-critical hardware component contains physical flaws in its semiconductor material, which can cause it to malfunction and undermine its security…

• CWE-1249
  Application-Level Admin Tool with Inconsistent View of Underlying Operating System

  This vulnerability occurs when an administrative tool (like a web interface or API) fails to accurately display the true state of the underlying operating…

• CWE-1250
  Improper Preservation of Consistency Between Independent Representations of Shared State

  This vulnerability occurs when a system with multiple independent components (like distributed services or separate hardware units) each maintain their own…

• CWE-1251
  Mirrored Regions with Different Values

  This vulnerability occurs when a system maintains duplicate copies of data or resources (like cached memory or shadow registers) but fails to keep them…

• CWE-1252
  CPU Hardware Not Configured to Support Exclusivity of Write and Execute Operations

  This vulnerability occurs when a CPU's hardware is not set up to enforce a strict separation between writing data to memory and executing instructions from…

• CWE-1253
  Incorrect Selection of Fuse Values

  This vulnerability occurs when a hardware security fuse is incorrectly programmed to represent a 'secure' state as logic 0 (unblown). An attacker can…

• CWE-1254
  Incorrect Comparison Logic Granularity

  This vulnerability occurs when a system compares sensitive data, like passwords or authentication tokens, piece-by-piece instead of as a complete unit. If the…

• CWE-1255
  Comparison Logic is Vulnerable to Power Side-Channel Attacks

  This vulnerability occurs when a device's power consumption is monitored during security checks, allowing attackers to deduce secret reference values by…

• CWE-1256
  Improper Restriction of Software Interfaces to Hardware Features

  This vulnerability occurs when a system's software interfaces to hardware features—like power, clock, or performance management—are not properly locked down.…

• CWE-1257
  Improper Access Control Applied to Mirrored or Aliased Memory Regions

  This vulnerability occurs when a hardware design maps the same physical memory to multiple addresses (aliasing or mirroring) but fails to apply consistent…

• CWE-1258
  Exposure of Sensitive System Information Due to Uncleared Debug Information

  This vulnerability occurs when hardware fails to erase sensitive data like cryptographic keys and intermediate values before entering debug mode, leaving them…

• CWE-1259
  Improper Restriction of Security Token Assignment

  This vulnerability occurs when a System-on-a-Chip (SoC) fails to properly secure its Security Token mechanism. These tokens control which actions different…

• CWE-1260
  Improper Handling of Overlap Between Protected Memory Ranges

  This vulnerability occurs when a system incorrectly allows different memory protection ranges to overlap. This flaw can let attackers bypass security controls…

• CWE-1261
  Improper Handling of Single Event Upsets

  This vulnerability occurs when hardware logic fails to properly manage single-event upsets (SEUs), which are temporary bit flips caused by environmental…

• CWE-1262
  Improper Access Control for Register Interface

  This vulnerability occurs when a system's hardware registers, which act as a software-to-hardware control panel, lack proper access restrictions. Malicious or…

• CWE-1263
  Improper Physical Access Control

  This vulnerability occurs when a device or system has areas meant to be physically secure, but the safeguards in place are too weak to stop someone with…

• CWE-1264
  Hardware Logic with Insecure De-Synchronization between Control and Data Channels

  This vulnerability occurs when a hardware design incorrectly forwards data before its security or permission checks have finished processing. It's a timing…

• CWE-1265
  Unintended Reentrant Invocation of Non-reentrant Code Via Nested Calls

  This vulnerability occurs when a non-reentrant function is called, and during its execution, another call is triggered that unexpectedly re-enters the same…

• CWE-1266
  Improper Scrubbing of Sensitive Data from Decommissioned Device

  This vulnerability occurs when a system lacks a reliable method for administrators to permanently erase sensitive information before taking hardware or…

• CWE-1267
  Policy Uses Obsolete Encoding

  This vulnerability occurs when a hardware system uses outdated or deprecated encoding methods to enforce security policies and access controls.

• CWE-1268
  Policy Privileges are not Assigned Consistently Between Control and Data Agents

  This vulnerability occurs when hardware access control policies are inconsistent, allowing an agent with control privileges to modify write permissions even…

• CWE-1269
  Product Released in Non-Release Configuration

  This vulnerability occurs when a product ships to customers while still configured with its pre-production or manufacturing settings, which typically include…

• CWE-1270
  Generation of Incorrect Security Tokens

  This vulnerability occurs when a system's security token mechanism, designed to control permissions for different entities or agents, generates tokens that…

• CWE-1271
  Uninitialized Value on Reset for Registers Holding Security Settings

  Security-critical hardware registers start with random, unpredictable values when a device powers on or resets, creating an immediate vulnerability window…

• CWE-1272
  Sensitive Information Uncleared Before Debug/Power State Transition

  This vulnerability occurs when a device changes its power mode or enters a debug state but fails to wipe sensitive data that should become inaccessible after…

• CWE-1273
  Device Unlock Credential Sharing

  This vulnerability occurs when the secret keys or passwords required to unlock a device's hidden features are shared between multiple organizations, creating…

• CWE-1274
  Improper Access Control for Volatile Memory Containing Boot Code

  This vulnerability occurs when a system's secure-boot process loads bootloader code into volatile memory (like DRAM or SRAM) but fails to properly lock down…

• CWE-1275
  Sensitive Cookie with Improper SameSite Attribute

  This vulnerability occurs when a sensitive cookie does not have a secure SameSite attribute configured, leaving it exposed to cross-site request forgery…

  Medium likelihood
• CWE-1276
  Hardware Child Block Incorrectly Connected to Parent System

  This vulnerability occurs when a hardware component (IP block) is wired incorrectly to the main system, creating hidden security flaws even if basic functions…

• CWE-1277
  Firmware Not Updateable

  This vulnerability occurs when a hardware product lacks a mechanism for users to install firmware updates, leaving known security flaws permanently unpatched.

• CWE-1278
  Missing Protection Against Hardware Reverse Engineering Using Integrated Circuit (IC) Imaging Techniques

  This vulnerability occurs when hardware lacks safeguards against physical inspection, allowing attackers to extract sensitive data by capturing and analyzing…

• CWE-1279
  Cryptographic Operations are run Before Supporting Units are Ready

  This vulnerability occurs when cryptographic processes start before their required dependencies are properly initialized and ready to supply valid data,…

• CWE-1280
  Access Control Check Implemented After Asset is Accessed

  This vulnerability occurs when a hardware-based security check runs after the protected resource has already been accessed, creating a dangerous timing window.

• CWE-1281
  Sequence of Processor Instructions Leads to Unexpected Behavior

  Certain sequences of valid and invalid processor instructions can cause the CPU to lock up or behave unpredictably, often requiring a hard reset to recover.

• CWE-1282
  Assumed-Immutable Data is Stored in Writable Memory

  This vulnerability occurs when data that should be permanent and unchangeable—like a bootloader, device IDs, or one-time configuration settings—is placed in…

• CWE-1283
  Mutable Attestation or Measurement Reporting Data

  This vulnerability occurs when the hardware registers storing boot integrity measurements can be altered by an attacker, allowing them to forge verification…

• CWE-1284
  Improper Validation of Specified Quantity in Input

  This vulnerability occurs when an application accepts user input meant to define a quantity—like a number, size, or count—but fails to properly check if that…

• CWE-1285
  Improper Validation of Specified Index, Position, or Offset in Input

  This vulnerability occurs when software accepts user input to determine a location—like an array index, file position, or memory offset—but fails to properly…

• CWE-1286
  Improper Validation of Syntactic Correctness of Input

  This vulnerability occurs when software expects input in a specific, well-structured format but fails to properly check that the incoming data actually…

• CWE-1287
  Improper Validation of Specified Type of Input

  This vulnerability occurs when software expects a specific type of data as input but fails to properly check that the incoming data actually matches that type.

• CWE-1288
  Improper Validation of Consistency within Input

  This vulnerability occurs when an application accepts structured input containing multiple related fields but fails to verify that the values across those…

• CWE-1289
  Improper Validation of Unsafe Equivalence in Input

  This vulnerability occurs when an application accepts user input as a reference (like a file path or resource identifier) but fails to properly check if that…

• CWE-1290
  Incorrect Decoding of Security Identifiers

  This vulnerability occurs when a hardware decoder incorrectly interprets security identifiers in bus transactions, allowing untrusted agents to gain…

• CWE-1291
  Public Key Re-Use for Signing both Debug and Production Code

  This vulnerability occurs when the same cryptographic key is used to sign both development/debug software builds and final production releases. This insecure…

• CWE-1292
  Incorrect Conversion of Security Identifiers

  This vulnerability occurs when a hardware system incorrectly translates security identifiers during bus protocol conversion. An improper mapping allows…

• CWE-1293
  Missing Source Correlation of Multiple Independent Data

  This vulnerability occurs when a system trusts a single source of data without verification, making it impossible to detect if that source has been tampered…

• CWE-1294
  Insecure Security Identifier Mechanism

  This vulnerability occurs when a System-on-Chip (SoC) implements a Security Identifier mechanism to control transaction permissions, but the implementation…

• CWE-1295
  Debug Messages Revealing Unnecessary Information

  The product's debug messages or logs expose excessive internal system details, potentially revealing sensitive information that could aid an attacker.

• CWE-1296
  Incorrect Chaining or Granularity of Debug Components

  This vulnerability occurs when hardware debug components, such as test ports and scan chains, are incorrectly connected or organized within a chip's design.…

• CWE-1297
  Unprotected Confidential Information on Device is Accessible by OSAT Vendors

  This vulnerability occurs when a semiconductor chip does not properly secure sensitive data, making it accessible to third-party Outsourced Semiconductor…

• CWE-1298
  Hardware Logic Contains Race Conditions

  A hardware race condition occurs when security-critical logic circuits receive signals at slightly different times, creating temporary glitches that can…

• CWE-1299
  Missing Protection Mechanism for Alternate Hardware Interface

  This vulnerability occurs when a hardware component's security controls only protect the primary access path, leaving alternate interfaces unprotected.…

• CWE-1300
  Improper Protection of Physical Side Channels

  This vulnerability occurs when a hardware device lacks adequate safeguards against physical side-channel attacks. Attackers can exploit measurable patterns in…

• CWE-1301
  Insufficient or Incomplete Data Removal within Hardware Component

  The product's data removal process fails to completely erase all data from hardware components, potentially leaving sensitive information behind.

• CWE-1302
  Missing Source Identifier in Entity Transactions on a System-On-Chip (SOC)

  This vulnerability occurs when a System-On-Chip (SoC) component sends a transaction without its required security identifier. The destination hardware cannot…

• CWE-1303
  Non-Transparent Sharing of Microarchitectural Resources

  This vulnerability occurs when a processor's internal performance features, like caches and branch predictors, are unintentionally shared between different…

• CWE-1304
  Improperly Preserved Integrity of Hardware Configuration State During a Power Save/Restore Operation

  This vulnerability occurs when a hardware component saves its configuration state during a power-down operation but fails to protect or verify the integrity…

• CWE-1310
  Missing Ability to Patch ROM Code

  A system or System-on-Chip (SoC) lacks a mechanism to update its initial boot code stored in Read-Only Memory (ROM), permanently exposing devices to unfixable…

• CWE-1311
  Improper Translation of Security Attributes by Fabric Bridge

  This vulnerability occurs when a hardware bridge incorrectly converts security attributes between different fabric protocols, potentially changing a…

• CWE-1312
  Missing Protection for Mirrored Regions in On-Chip Fabric Firewall

  An on-chip fabric firewall fails to apply its security rules to mirrored memory or MMIO regions, only protecting the primary address range. This allows…

• CWE-1313
  Hardware Allows Activation of Test or Debug Logic at Runtime

  This vulnerability occurs when hardware includes test or debug features that remain accessible during normal operation. An attacker can activate these…

• CWE-1314
  Missing Write Protection for Parametric Data Values

  This vulnerability occurs when a hardware device fails to protect the scaling parameters used to convert raw sensor readings. Untrusted software can alter…

• CWE-1315
  Improper Setting of Bus Controlling Capability in Fabric End-point

  This vulnerability occurs when a hardware fabric endpoint is incorrectly configured to grant bus controller privileges to a device that should only respond to…

• CWE-1316
  Fabric-Address Map Allows Programming of Unwarranted Overlaps of Protected and Unprotected Ranges

  This vulnerability occurs when a hardware fabric's address map incorrectly allows protected and unprotected memory regions to overlap. Attackers can exploit…

• CWE-1317
  Improper Access Control in Fabric Bridge

  This vulnerability occurs when a hardware fabric bridge, which connects different IP blocks on a chip, fails to properly verify access permissions for…

• CWE-1318
  Missing Support for Security Features in On-chip Fabrics or Buses

  This vulnerability occurs when the communication channels (fabrics or buses) within a chip lack built-in or enabled security features, such as privilege…

• CWE-1319
  Improper Protection against Electromagnetic Fault Injection (EM-FI)

  This vulnerability occurs when a hardware device lacks sufficient shielding against electromagnetic interference, allowing attackers to disrupt its internal…

• CWE-1320
  Improper Protection for Outbound Error Messages and Alert Signals

  This vulnerability occurs when hardware alert systems for critical conditions, like overheating or power surges, lack proper security. Untrusted software or…

• CWE-1321
  Improperly Controlled Modification of Object Prototype Attributes ('Prototype Pollution')

  Prototype pollution occurs when an application takes user-supplied input and uses it to improperly modify the properties of a JavaScript object's prototype.…

• CWE-1322
  Use of Blocking Code in Single-threaded, Non-blocking Context

  This vulnerability occurs when an application designed to be single-threaded and non-blocking, for performance and scalability, inadvertently executes code…

• CWE-1323
  Improper Management of Sensitive Trace Data

  This vulnerability occurs when sensitive trace data from a System-on-Chip (SoC), such as information from CPUs or cryptographic modules, is stored in…

• CWE-1325
  Improperly Controlled Sequential Memory Allocation

  This vulnerability occurs when a system allocates memory separately for each item in a collection but fails to enforce a global limit on the total memory used…

• CWE-1326
  Missing Immutable Root of Trust in Hardware

  This vulnerability occurs when a hardware chip lacks a permanent, unchangeable root of trust. Without this immutable foundation, attackers can bypass secure…

• CWE-1327
  Binding to an Unrestricted IP Address

  This vulnerability occurs when software or a service is configured to bind to the IP address 0.0.0.0 (or :: in IPv6), which acts as a wildcard, accepting…

• CWE-1328
  Security Version Number Mutable to Older Versions

  This vulnerability occurs when a hardware system's security version number can be changed, allowing an attacker to downgrade or roll back the boot firmware to…

• CWE-1329
  Reliance on Component That is Not Updateable

  This vulnerability occurs when a product depends on a component that cannot be updated or patched to fix security flaws or critical bugs.

• CWE-1330
  Remanent Data Readable after Memory Erase

  Sensitive data stored in memory hardware can still be accessed or reconstructed even after a standard clear or erase command has been executed.

• CWE-1331
  Improper Isolation of Shared Resources in Network On Chip (NoC)

  This vulnerability occurs when a Network on Chip (NoC) fails to properly separate its internal, shared resources—like buffers, switches, and channels—between…

• CWE-1332
  Improper Handling of Faults that Lead to Instruction Skips

  This vulnerability occurs when a hardware device lacks or incorrectly implements the necessary circuitry or sensors to detect and respond to the skipping of…

• CWE-1333
  Inefficient Regular Expression Complexity

  This vulnerability occurs when an application uses a poorly constructed regular expression that can trigger catastrophic backtracking, leading to extreme CPU…

  High likelihood
• CWE-1334
  Unauthorized Error Injection Can Degrade Hardware Redundancy

  This vulnerability occurs when an attacker without proper permissions can deliberately inject faults into a hardware system's backup components. This action…

• CWE-1335
  Incorrect Bitwise Shift of Integer

  This vulnerability occurs when a program attempts to shift an integer's bits by an invalid amount—either a negative number or a value equal to or greater than…

• CWE-1336
  Improper Neutralization of Special Elements Used in a Template Engine

  This vulnerability occurs when an application uses a template engine to process user-controlled input but fails to properly sanitize special syntax…

• CWE-1338
  Improper Protections Against Hardware Overheating

  This vulnerability occurs when a hardware device lacks sufficient safeguards to prevent dangerous temperature increases during operation.

• CWE-1339
  Insufficient Precision or Accuracy of a Real Number

  This vulnerability occurs when a program uses a data type or algorithm that cannot accurately represent or calculate the fractional part of a real number,…

• CWE-1341
  Multiple Releases of Same Resource or Handle

  This vulnerability occurs when a program incorrectly tries to close or release the same system resource—like memory, a file, or a network connection—more than…

• CWE-1342
  Information Exposure through Microarchitectural State after Transient Execution

  This vulnerability occurs when a CPU fails to completely erase temporary data traces left behind by speculative execution or error recovery processes. These…

• CWE-1351
  Improper Handling of Hardware Behavior in Exceptionally Cold Environments

  This weakness occurs when a hardware device or its firmware lacks proper safeguards to maintain security functions when operated in extremely cold…

• CWE-1357
  Reliance on Insufficiently Trustworthy Component

  This weakness occurs when a system integrates a component that cannot be fully trusted to meet security, reliability, and maintenance standards, creating risk…

• CWE-1384
  Improper Handling of Physical or Environmental Conditions

  This weakness occurs when a hardware device fails to manage unexpected physical or environmental situations, whether they happen naturally or are deliberately…

• CWE-1385
  Missing Origin Validation in WebSockets

  This vulnerability occurs when a WebSocket connection is established without verifying the origin of incoming messages, allowing potentially malicious data…

• CWE-1386
  Insecure Operation on Windows Junction / Mount Point

  This vulnerability occurs when a Windows application opens a file or directory without properly validating that the path is not a symbolic link (junction or…

• CWE-1389
  Incorrect Parsing of Numbers with Different Radices

  This vulnerability occurs when software processes numeric input expecting standard decimal numbers (base 10), but fails to handle inputs formatted in other…

• CWE-1390
  Weak Authentication

  This vulnerability occurs when a system's login or identity verification process is too easy to bypass or fool. While it attempts to check who a user claims…

• CWE-1391
  Use of Weak Credentials

  This vulnerability occurs when a system relies on weak authentication credentials—like default passwords, hard-coded keys, or easily guessable values—that an…

• CWE-1392
  Use of Default Credentials

  This vulnerability occurs when a system, device, or application relies on pre-configured, publicly known credentials like passwords or encryption keys for…

• CWE-1393
  Use of Default Password

  This vulnerability occurs when a system or device uses a pre-configured, publicly known password for authentication, often for administrative or critical…

• CWE-1394
  Use of Default Cryptographic Key

  This vulnerability occurs when a system uses a pre-configured, publicly known cryptographic key for security-critical operations instead of generating a…

• CWE-1395
  Dependency on Vulnerable Third-Party Component

  This vulnerability occurs when your software relies on an external library, framework, or module that contains known security flaws.

• CWE-1419
  Incorrect Initialization of Resource

  This weakness occurs when a system fails to properly set up a resource during its creation, leaving it in an unstable, incorrect, or insecure state when used…

• CWE-1420
  Exposure of Sensitive Information during Transient Execution

  Transient execution vulnerabilities occur when a processor speculatively runs operations that don't officially commit, potentially leaking sensitive data…

• CWE-1421
  Exposure of Sensitive Information in Shared Microarchitectural Structures during Transient Execution

  This vulnerability occurs when a processor's speculative execution (transient operations) can temporarily access restricted data from another security domain.…

• CWE-1422
  Exposure of Sensitive Information caused by Incorrect Data Forwarding during Transient Execution

  This vulnerability occurs when a CPU incorrectly forwards outdated or incorrect data during speculative execution. This allows sensitive information to leak…

• CWE-1423
  Exposure of Sensitive Information caused by Shared Microarchitectural Predictor State that Influences Transient Execution

  This vulnerability occurs when separate software components, like different processes or virtual machines, share the processor's internal prediction…

• CWE-1426
  Improper Validation of Generative AI Output

  This vulnerability occurs when an application uses a generative AI model (like an LLM) but fails to properly check the AI's output before using it. Without…

• CWE-1427
  Improper Neutralization of Input Used for LLM Prompting

  This vulnerability occurs when an application builds prompts for a Large Language Model (LLM) using external data, but does so in a way that the LLM cannot…

• CWE-1428
  Reliance on HTTP instead of HTTPS

  This vulnerability occurs when an application uses unencrypted HTTP connections instead of the secure HTTPS alternative, even when HTTPS is available.

• CWE-1429
  Missing Security-Relevant Feedback for Unexecuted Operations in Hardware Interface

  This vulnerability occurs when a hardware interface discards operations without providing any security-relevant feedback, such as error notifications or logs.…

• CWE-1431
  Driving Intermediate Cryptographic State/Results to Hardware Module Outputs

  This vulnerability occurs when a hardware cryptographic module leaks sensitive internal data through its output channels. Instead of only providing the final…

• CWE-1434
  Insecure Setting of Generative AI/ML Model Inference Parameters

  This vulnerability occurs when a generative AI or ML model is deployed with inference parameters that are too permissive, causing it to frequently generate…

Sin coincidencias. Prueba con otra palabra clave.