Schwachstellen
944 CWE weaknesses, sortable by ID. Use the filter to narrow by name or ID.
- 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 ValidationHigh likelihood
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…
- CWE-22 Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')High likelihood
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…
- 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')Medium likelihood
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,…
- CWE-61 UNIX Symbolic Link (Symlink) FollowingHigh likelihood
This vulnerability occurs when a software application opens files or directories without properly checking if they are symbolic links (symlinks). If an…
- 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)Low likelihood
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…
- 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 NamesHigh likelihood
This vulnerability occurs when an application builds file paths from user input but fails to properly recognize or handle Windows reserved device names like…
- 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 PathHigh likelihood
This vulnerability occurs when an application uses unvalidated user input to construct file or directory paths for filesystem operations.
- CWE-74 Improper Neutralization of Special Elements in Output Used by a Downstream Component ('Injection')High likelihood
This vulnerability occurs when an application uses untrusted external input to build a command, query, or data structure for another component, but fails to…
- 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 ElementsHigh likelihood
This vulnerability occurs when an application successfully blocks or sanitizes a known set of dangerous inputs but fails to recognize and handle alternative…
- CWE-77 Improper Neutralization of Special Elements used in a Command ('Command Injection')High likelihood
This vulnerability occurs when an application builds a system command using untrusted user input without properly sanitizing it. An attacker can inject their…
- CWE-78 Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection')High likelihood
OS Command Injection occurs when an application builds a system command using untrusted, external input without properly sanitizing it. This allows an…
- CWE-79 Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')High likelihood
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…
- CWE-80 Improper Neutralization of Script-Related HTML Tags in a Web Page (Basic XSS)High likelihood
This vulnerability, commonly known as Basic Cross-Site Scripting (XSS), occurs when a web application fails to properly sanitize user input containing HTML…
- 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')High likelihood
SQL Injection occurs when an application builds a database query using untrusted user input without properly sanitizing it. This allows an attacker to insert…
- 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')Medium likelihood
This vulnerability occurs when an application builds executable code using unvalidated external input, such as user data. Because the application fails to…
- CWE-95 Improper Neutralization of Directives in Dynamically Evaluated Code ('Eval Injection')Medium likelihood
This vulnerability occurs when an application takes user input and passes it directly into a dynamic code execution function, like eval(), without properly…
- 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')High likelihood
This vulnerability occurs when a PHP application uses unvalidated or insufficiently restricted user input directly within file inclusion functions like…
- CWE-99 Improper Control of Resource Identifiers ('Resource Injection')High likelihood
This vulnerability occurs when an application accepts user input as a resource identifier (like a file path or port number) without proper validation,…
- 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 OutputHigh likelihood
This vulnerability occurs when an application builds a structured message—like a query, command, or request—for another component but fails to properly encode…
- CWE-117 Improper Output Neutralization for LogsMedium likelihood
This vulnerability occurs when an application creates log entries using unvalidated external data, allowing attackers to inject malicious characters or…
- 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 BufferHigh likelihood
This vulnerability occurs when software accesses a memory buffer but reads from or writes to a location outside its allocated boundary. This can corrupt…
- CWE-120 Buffer Copy without Checking Size of Input ('Classic Buffer Overflow')High likelihood
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…
- CWE-121 Stack-based Buffer OverflowHigh likelihood
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…
- CWE-122 Heap-based Buffer OverflowHigh likelihood
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…
- CWE-123 Write-what-where ConditionHigh likelihood
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…
- CWE-124 Buffer Underwrite ('Buffer Underflow')Medium likelihood
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.
- 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 ErrorMedium likelihood
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…
- CWE-129 Improper Validation of Array IndexHigh likelihood
This vulnerability occurs when software uses unverified, external input to calculate or access an array index, without properly checking that the index points…
- 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 SizeHigh likelihood
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…
- CWE-134 Use of Externally-Controlled Format StringHigh likelihood
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…
- 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 TerminationMedium likelihood
This weakness occurs when software fails to properly end a string or array with the required null character or equivalent terminator.
- 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 LayoutLow likelihood
This vulnerability occurs when software incorrectly assumes how data is structured in memory or within network packets, leading to unexpected behavior when…
- CWE-190 Integer Overflow or WraparoundMedium likelihood
Integer overflow or wraparound occurs when a calculation produces a numeric result that exceeds the maximum value a variable can hold. Instead of increasing…
- 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 ErrorMedium likelihood
An integer coercion error occurs when a program incorrectly converts, extends, or truncates a number between different data types, leading to unexpected values.
- 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 ExtensionHigh likelihood
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…
- 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 ErrorMedium likelihood
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…
- CWE-197 Numeric Truncation ErrorLow likelihood
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.
- 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 ActorHigh likelihood
This weakness occurs when an application unintentionally reveals sensitive data to someone who shouldn't have access to it.
- 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 QueriesMedium likelihood
This vulnerability occurs when an attacker uses statistical analysis on aggregated or anonymized data to uncover sensitive details about individuals, even…
- 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 InformationHigh likelihood
This vulnerability occurs when an application reveals sensitive details about its internal systems, user data, or environment within error messages shown to…
- 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 ParameterHigh likelihood
This vulnerability occurs when a function or method receives fewer arguments than it expects. The function will still attempt to process its expected number…
- 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 FunctionHigh likelihood
This vulnerability occurs when code uses functions that are inherently unsafe and cannot be reliably secured, posing a direct risk to application stability…
- CWE-243 Creation of chroot Jail Without Changing Working DirectoryHigh likelihood
This vulnerability occurs when a program creates a chroot jail but fails to change its current working directory afterward. Because the process's working…
- 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 PrivilegesMedium likelihood
This vulnerability occurs when software runs with higher permissions than it actually needs to perform its tasks. This excessive privilege creates security…
- CWE-252 Unchecked Return ValueLow likelihood
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…
- CWE-253 Incorrect Check of Function Return ValueLow likelihood
This vulnerability occurs when a program misinterprets or improperly validates the return value from a function, causing it to miss critical error states or…
- CWE-256 Plaintext Storage of a PasswordHigh likelihood
This vulnerability occurs when an application stores user passwords as readable text instead of using secure, one-way hashing. This insecure practice exposes…
- CWE-257 Storing Passwords in a Recoverable FormatHigh likelihood
This vulnerability occurs when an application stores user passwords in a format that can be easily reversed or decrypted back to their original plaintext…
- CWE-258 Empty Password in Configuration FileHigh likelihood
This vulnerability occurs when a configuration file, script, or application uses an empty string as a password, effectively disabling authentication for a…
- CWE-259 Use of Hard-coded PasswordHigh likelihood
This vulnerability occurs when an application embeds a password directly into its source code or configuration files. This hard-coded secret is then used…
- 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 AgingLow likelihood
This vulnerability occurs when a system lacks password expiration policies, allowing users to keep the same password indefinitely.
- CWE-263 Password Aging with Long ExpirationLow likelihood
The system enforces password changes, but the time allowed between changes is excessively long, weakening security.
- 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 ChainingHigh likelihood
Privilege chaining occurs when an attacker combines two separate permissions or capabilities, neither of which is dangerous on its own, to perform a harmful…
- CWE-269 Improper Privilege ManagementMedium likelihood
This vulnerability occurs when an application fails to correctly manage user permissions, allowing someone to perform actions or access data beyond their…
- 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 ErrorsHigh likelihood
This vulnerability occurs when a system or process fails to reduce its elevated permissions before transferring control of a resource to a less-privileged…
- 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 PrivilegesMedium likelihood
This vulnerability occurs when an application tries to lower its system privileges but fails to verify that the operation was successful.
- 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 PermissionsMedium likelihood
This vulnerability occurs when software installation scripts set overly permissive file or directory access rights by default. Instead of restricting write…
- 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 AuthorizationHigh likelihood
This vulnerability occurs when an application fails to properly verify whether a user has permission to access specific data or perform certain actions before…
- 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 AuthenticationHigh likelihood
Improper Authentication occurs when a system fails to properly verify a user's claimed identity, allowing access without sufficient proof of who they are.
- 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 AuthenticationHigh likelihood
This vulnerability occurs when a system uses a client's IP address as the sole or primary method to verify their identity.
- CWE-293 Using Referer Field for AuthenticationHigh likelihood
This vulnerability occurs when a web application uses the HTTP Referer header as a sole or primary method for authentication or authorization decisions. Since…
- CWE-294 Authentication Bypass by Capture-replayHigh likelihood
This vulnerability occurs when an attacker can intercept and record legitimate authentication traffic, then replay it later to gain unauthorized access. The…
- 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 TrustLow likelihood
This vulnerability occurs when software fails to properly validate the entire certificate chain back to a trusted root authority. This mistake can cause the…
- CWE-297 Improper Validation of Certificate with Host MismatchHigh likelihood
This vulnerability occurs when an application accepts a valid SSL/TLS certificate without properly verifying that it actually belongs to the specific host…
- CWE-298 Improper Validation of Certificate ExpirationLow likelihood
This vulnerability occurs when an application fails to properly check if a digital certificate has expired, potentially trusting certificates that are no…
- CWE-299 Improper Check for Certificate RevocationMedium likelihood
This vulnerability occurs when an application fails to properly verify whether a security certificate has been revoked, potentially allowing it to accept and…
- 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 ProtocolMedium likelihood
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…
- 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 FunctionHigh likelihood
This vulnerability occurs when a software feature that performs a sensitive action or uses significant system resources does not verify the user's identity…
- 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 AuthenticationHigh likelihood
Relying solely on single-factor authentication, like a password, exposes systems to significant security risks because it depends on only one type of proof…
- CWE-309 Use of Password System for Primary AuthenticationHigh likelihood
This weakness occurs when an application relies solely on password-based authentication as its main security gate. This single-factor approach is inherently…
- CWE-311 Missing Encryption of Sensitive DataHigh likelihood
This vulnerability occurs when an application stores or sends sensitive information without first encrypting it, leaving the data exposed.
- 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 InformationHigh likelihood
This vulnerability occurs when an application sends sensitive data, such as passwords or personal information, over a network connection without using…
- CWE-321 Use of Hard-coded Cryptographic KeyHigh likelihood
This vulnerability occurs when an application embeds a fixed, unchangeable cryptographic key directly within its source code or configuration files.
- CWE-322 Key Exchange without Entity AuthenticationHigh likelihood
This vulnerability occurs when a system establishes a cryptographic key with another party without first confirming that party's true identity.
- CWE-323 Reusing a Nonce, Key Pair in EncryptionHigh likelihood
This vulnerability occurs when a cryptographic nonce or key pair is reused, compromising the security of the encrypted data.
- CWE-324 Use of a Key Past its Expiration DateLow likelihood
This vulnerability occurs when an application continues to use a cryptographic key or password after its designated expiration date. Doing so dramatically…
- 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 AlgorithmHigh likelihood
The software relies on a cryptographic algorithm or protocol that is either fundamentally flawed or considered too weak by modern security standards.
- 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 ModeMedium likelihood
This vulnerability occurs when software uses a predictable or reused Initialization Vector (IV) with Cipher Block Chaining (CBC) mode encryption. Predictable…
- CWE-330 Use of Insufficiently Random ValuesHigh likelihood
This vulnerability occurs when an application uses random values that are not sufficiently unpredictable in security-sensitive operations, making them easier…
- 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 PRNGMedium likelihood
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…
- CWE-333 Improper Handling of Insufficient Entropy in TRNGLow likelihood
This vulnerability occurs when a system fails to properly manage the limited or unpredictable output rate of a true random number generator (TRNG),…
- 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)Medium likelihood
This vulnerability occurs when software uses a pseudo-random number generator (PRNG) that is not cryptographically strong for security-sensitive operations,…
- 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)Medium likelihood
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…
- CWE-353 Missing Support for Integrity CheckMedium likelihood
This vulnerability occurs when a system uses a communication protocol that lacks built-in integrity verification, such as a checksum or cryptographic hash, to…
- CWE-354 Improper Validation of Integrity Check ValueMedium likelihood
This vulnerability occurs when software fails to properly check the integrity of data by validating its checksum or hash value. Without this verification, the…
- 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 DataHigh likelihood
This vulnerability occurs when software blindly trusts system event data without verifying its source, allowing attackers to spoof events and manipulate…
- CWE-362 Concurrent Execution using Shared Resource with Improper Synchronization ('Race Condition')Medium likelihood
A race condition occurs when multiple processes or threads access a shared resource simultaneously without proper coordination, creating a timing window where…
- 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 ConditionMedium likelihood
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…
- CWE-366 Race Condition within a ThreadMedium likelihood
This vulnerability occurs when two or more threads within the same application access and manipulate a shared resource (like a variable, data structure, or…
- CWE-367 Time-of-check Time-of-use (TOCTOU) Race ConditionMedium likelihood
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…
- 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 ZeroMedium likelihood
A divide-by-zero error occurs when software attempts to perform a division operation where the denominator is zero.
- CWE-370 Missing Check for Certificate Revocation after Initial CheckMedium likelihood
This vulnerability occurs when software only verifies a certificate's revocation status once, then continues to trust it for subsequent privileged actions…
- 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 MethodMedium likelihood
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.
- CWE-375 Returning a Mutable Object to an Untrusted CallerMedium likelihood
This vulnerability occurs when a method directly returns a reference to its internal mutable data, allowing untrusted calling code to modify that data…
- 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 PermissionsHigh likelihood
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…
- CWE-379 Creation of Temporary File in Directory with Insecure PermissionsLow likelihood
This vulnerability occurs when an application creates a temporary file in a directory that is too permissive, allowing unauthorized users or processes to see,…
- 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 ChannelMedium likelihood
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…
- 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 ActionMedium likelihood
This weakness occurs when software successfully identifies an error condition but then fails to take any meaningful action to address it. The error is…
- CWE-391 Unchecked Error ConditionMedium likelihood
This vulnerability occurs when a program fails to properly check or handle error conditions, such as exceptions or return codes. By ignoring these failures,…
- 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 ConsumptionHigh likelihood
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.
- CWE-401 Missing Release of Memory after Effective LifetimeMedium likelihood
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…
- 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 ReleaseMedium likelihood
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…
- 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 ComplexityLow likelihood
This vulnerability occurs when a software component uses an algorithm with poor worst-case performance. An attacker can exploit this by providing specially…
- 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 FreeHigh likelihood
A double free vulnerability occurs when a program mistakenly calls the 'free()' function twice on the same block of memory.
- CWE-416 Use After FreeHigh likelihood
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…
- 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 PathHigh likelihood
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…
- 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 TypeMedium likelihood
This vulnerability occurs when an application accepts file uploads without properly restricting the file types, allowing attackers to upload and execute…
- 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 VariableHigh likelihood
This vulnerability occurs when a program accesses a variable before it has been assigned a value, leading to unpredictable behavior and potential security…
- 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 ExceptionMedium likelihood
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…
- CWE-462 Duplicate Key in Associative List (Alist)Low likelihood
This vulnerability occurs when an associative list (alist) contains duplicate keys, which can cause unexpected behavior when software incorrectly handles or…
- 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 SentinelHigh likelihood
This vulnerability occurs when a program unintentionally adds or modifies a special marker, known as a sentinel, within a data structure, leading to critical…
- 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 TypeHigh likelihood
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…
- CWE-468 Incorrect Pointer ScalingMedium likelihood
This vulnerability occurs when a programmer incorrectly accounts for pointer arithmetic in C or C++, causing the program to access unintended memory…
- CWE-469 Use of Pointer Subtraction to Determine SizeMedium likelihood
This vulnerability occurs when a program calculates a size or offset by subtracting two memory pointers, but the pointers point to locations in different…
- 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 DereferenceMedium likelihood
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.
- 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 FunctionLow likelihood
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…
- CWE-480 Use of Incorrect OperatorLow likelihood
This vulnerability occurs when a developer mistakenly uses the wrong operator in their code, leading to unintended and potentially insecure logic.
- CWE-481 Assigning instead of ComparingLow likelihood
This flaw occurs when a developer accidentally uses the assignment operator (=) instead of the comparison operator (== or ===). The code assigns a value when…
- CWE-482 Comparing instead of AssigningLow likelihood
This vulnerability occurs when a developer accidentally uses a comparison operator (like '==') where an assignment operator (like '=') was intended, creating…
- CWE-483 Incorrect Block DelimitationLow likelihood
This vulnerability occurs when a developer fails to use explicit braces or delimiters to group multiple statements within a block, leading to unexpected…
- CWE-484 Omitted Break Statement in SwitchMedium likelihood
This vulnerability occurs when a developer forgets to include a 'break' statement inside a switch-case block. Without it, the code execution 'falls through'…
- CWE-486 Comparison of Classes by NameHigh likelihood
This vulnerability occurs when an application determines an object's trustworthiness or behavior solely by checking its class name. Since multiple classes can…
- CWE-487 Reliance on Package-level ScopeMedium likelihood
This weakness occurs when a Java application mistakenly treats package-level access as a security boundary, assuming it can prevent unauthorized access to code.
- 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 DataMedium likelihood
Using inner classes to handle sensitive data can unintentionally expose that data because of how Java compiles them. The compiler transforms inner classes…
- CWE-493 Critical Public Variable Without Final ModifierHigh likelihood
This vulnerability occurs when a security-sensitive variable is declared as public but not marked as final, allowing untrusted code to unexpectedly change its…
- CWE-494 Download of Code Without Integrity CheckMedium likelihood
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…
- 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 InformationMedium likelihood
This vulnerability occurs when a class containing sensitive information, such as credentials or personal data, is made cloneable. Attackers can bypass normal…
- CWE-499 Serializable Class Containing Sensitive DataHigh likelihood
This vulnerability occurs when a class containing sensitive information, such as credentials or personal data, is left serializable by default. Because the…
- CWE-500 Public Static Field Not Marked FinalHigh likelihood
This vulnerability occurs when a class exposes a public static field without declaring it as final, allowing unintended modification from anywhere in the…
- 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 DataMedium likelihood
This vulnerability occurs when an application accepts and processes serialized data from an untrusted source without proper validation, allowing an attacker…
- 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 ChannelHigh likelihood
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…
- 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 FileMedium likelihood
This vulnerability occurs when an application unintentionally writes confidential data, such as passwords or API keys, into its log files.
- 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')Low likelihood
An open redirect vulnerability occurs when a web application uses unvalidated user input to determine the destination of a redirect, allowing an attacker to…
- CWE-602 Client-Side Enforcement of Server-Side SecurityMedium likelihood
This vulnerability occurs when a server incorrectly trusts the client to enforce critical security rules, such as input validation or access controls, instead…
- 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 KeyHigh likelihood
This vulnerability occurs when an application's authorization system fails to verify that a user is allowed to access specific data before retrieving it,…
- CWE-640 Weak Password Recovery Mechanism for Forgotten PasswordHigh likelihood
This vulnerability occurs when an application's password reset or recovery feature is poorly designed or implemented, allowing attackers to bypass…
- CWE-641 Improper Restriction of Names for Files and Other ResourcesLow likelihood
This vulnerability occurs when an application creates file or resource names using unvalidated user input, failing to properly limit what characters or paths…
- CWE-642 External Control of Critical State DataHigh likelihood
This vulnerability occurs when an application stores security-sensitive state data in locations that unauthorized users can access and modify.
- CWE-643 Improper Neutralization of Data within XPath Expressions ('XPath Injection')High likelihood
XPath Injection occurs when an application uses unvalidated user input to build an XPath query for an XML database. Without proper sanitization, attackers can…
- CWE-644 Improper Neutralization of HTTP Headers for Scripting SyntaxHigh likelihood
This vulnerability occurs when an application fails to properly sanitize or escape user-controlled data placed within HTTP response headers. Malicious…
- CWE-645 Overly Restrictive Account Lockout MechanismHigh likelihood
This vulnerability occurs when an application's account lockout feature is too strict, allowing attackers to easily trigger it and lock legitimate users out…
- CWE-646 Reliance on File Name or Extension of Externally-Supplied FileHigh likelihood
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…
- CWE-647 Use of Non-Canonical URL Paths for Authorization DecisionsHigh likelihood
This vulnerability occurs when an application's authorization logic relies on specific URL paths but fails to enforce a single, standardized format. Attackers…
- CWE-648 Incorrect Use of Privileged APIsLow likelihood
This vulnerability occurs when software incorrectly uses functions that require special permissions. Attackers can exploit these mistakes to gain unauthorized…
- CWE-649 Reliance on Obfuscation or Encryption of Security-Relevant Inputs without Integrity CheckingHigh likelihood
This vulnerability occurs when an application uses obfuscation or encryption to hide security-sensitive data (like tokens or parameters) but fails to verify…
- CWE-650 Trusting HTTP Permission Methods on the Server SideHigh likelihood
This vulnerability occurs when a server incorrectly assumes that HTTP GET requests are always safe and cannot change server-side data. Attackers can exploit…
- 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')High likelihood
XQuery Injection occurs when an application uses unvalidated user input to build an XQuery expression for querying an XML database. Without proper…
- 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 InitializationMedium likelihood
This vulnerability occurs when software fails to properly set up a resource before use, or provides incorrect starting values, leaving it in an unpredictable…
- 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 FunctionHigh likelihood
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…
- 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 TypesHigh likelihood
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…
- CWE-682 Incorrect CalculationHigh likelihood
This vulnerability occurs when software performs a calculation that produces wrong or unexpected results, which are then used to make security decisions or…
- 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 ResourceHigh likelihood
This vulnerability occurs when a system grants overly permissive access to a sensitive resource, allowing unauthorized users or processes to read or alter it.
- 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 FunctionLow likelihood
This vulnerability occurs when a software component exposes an API or interface containing a high-risk function that lacks proper access controls, allowing…
- CWE-754 Improper Check for Unusual or Exceptional ConditionsMedium likelihood
This weakness occurs when software fails to properly anticipate and handle rare or unexpected runtime situations that fall outside normal operation.
- CWE-755 Improper Handling of Exceptional ConditionsMedium likelihood
This vulnerability occurs when software fails to properly manage unexpected situations or errors, leaving it in an unstable or insecure state.
- 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 RoutinesLow likelihood
This vulnerability occurs when a program uses incompatible functions to allocate and free memory. For example, freeing memory with a function that doesn't…
- 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 EvaluationLow likelihood
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…
- CWE-770 Allocation of Resources Without Limits or ThrottlingHigh likelihood
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…
- CWE-771 Missing Reference to Active Allocated ResourceMedium likelihood
This vulnerability occurs when software loses track of a resource it has allocated, like memory or a file handle, preventing the system from properly…
- CWE-772 Missing Release of Resource after Effective LifetimeHigh likelihood
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…
- 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 ThrottlingLow likelihood
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…
- 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')Medium likelihood
This vulnerability occurs when an XML parser allows Document Type Definitions (DTDs) to contain recursively defined entities without proper limits, enabling…
- CWE-777 Regular Expression without AnchorsMedium likelihood
This vulnerability occurs when a regular expression used for validation or sanitization lacks anchors, allowing unintended characters or malicious payloads to…
- CWE-778 Insufficient LoggingMedium likelihood
This weakness occurs when an application fails to properly record important security events or captures them with insufficient detail, making it hard to spot…
- CWE-779 Logging of Excessive DataLow likelihood
This vulnerability occurs when an application records more information than necessary in its logs, making log files difficult to analyze and potentially…
- CWE-780 Use of RSA Algorithm without OAEPMedium likelihood
This vulnerability occurs when an application implements RSA encryption but fails to use Optimal Asymmetric Encryption Padding (OAEP), significantly weakening…
- 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 ErrorLow likelihood
This vulnerability occurs when a developer writes a conditional expression where the intended logic is broken due to misunderstanding or misapplying the rules…
- CWE-784 Reliance on Cookies without Validation and Integrity Checking in a Security DecisionHigh likelihood
This vulnerability occurs when an application makes security decisions—like granting access or verifying identity—based solely on cookie data without first…
- 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 WriteHigh likelihood
This vulnerability occurs when software incorrectly writes data outside the boundaries of its allocated memory buffer, either beyond the end or before the…
- 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 CredentialsHigh likelihood
This vulnerability occurs when software contains built-in, unchangeable authentication secrets like passwords or encryption keys within its source code or…
- 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 ValueHigh likelihood
This vulnerability occurs when software reads from or writes to a buffer using a loop or sequential operation, but mistakenly calculates or provides an…
- 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 DecisionHigh likelihood
This vulnerability occurs when an application's security check depends on user-controlled data that can be manipulated to bypass protection mechanisms, such…
- 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 AuthorizationHigh likelihood
This vulnerability occurs when an application fails to verify whether a user has permission to access specific data or execute certain actions before allowing…
- CWE-863 Incorrect AuthorizationHigh likelihood
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…
- CWE-908 Use of Uninitialized ResourceMedium likelihood
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…
- CWE-909 Missing Initialization of ResourceMedium likelihood
The software fails to properly set up a critical resource before using it.
- CWE-910 Use of Expired File DescriptorMedium likelihood
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.
- CWE-911 Improper Update of Reference CountMedium likelihood
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…
- 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' FlagMedium likelihood
This vulnerability occurs when an application stores sensitive data in a cookie but fails to set the 'HttpOnly' flag, leaving the cookie accessible to…
- CWE-1007 Insufficient Visual Distinction of Homoglyphs Presented to UserMedium likelihood
This vulnerability occurs when an application shows text or symbols to users without clearly distinguishing between characters that look identical or very…
- 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 AccessMedium likelihood
This vulnerability occurs when a web application links to an external, untrusted site without protecting its own window from being manipulated by that site.…
- 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 CodeLow likelihood
This vulnerability occurs when a processor's performance optimization unintentionally strips out or alters security-critical code that a developer…
- CWE-1038 Insecure Automated OptimizationsLow likelihood
This vulnerability occurs when software uses automated tools to optimize code for performance or efficiency, but those optimizations accidentally weaken or…
- 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 AttributeMedium likelihood
This vulnerability occurs when a sensitive cookie does not have a secure SameSite attribute configured, leaving it exposed to cross-site request forgery…
- 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 ComplexityHigh likelihood
This vulnerability occurs when an application uses a poorly constructed regular expression that can trigger catastrophic backtracking, leading to extreme CPU…
- 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…
Keine Treffer. Versuche ein anderes Stichwort.
Schluss mit dem Bezahlen pro Entwickler.
Schließ den Kreislauf.
Plexicus ist die KI-native ASPM, die scannt, filtert, fixt, pentestet und erklärt — autonom. Unbegrenzte Entwickler, unbegrenzte Repos, Fair-Use-KI-Aktionen. Echter kostenloser Tarif, €269/mo jährlich, wenn du bereit bist.