D3FEND Weakness Taxonomy

tree matrix

This is a taxonomy of Weakness types. Navigate this tree by expanding the arrows on the nodes with children. You may also select multiple properties to display their values alongside the tree nodes.

name: Weakness
abbreviated IRI: d3f:Weakness
definition: A weakness is a condition in a software, firmware, hardware, or service component that, under certain circumstances, could contribute to the introduction of vulnerabilities.

▶ Weakness (10)
- ▶ Improper Check or Handling of Exceptional Conditions (12)
- ▶ Incorrect Calculation (11)
- ▶ Insufficient Control Flow Management (13)
- ▶ Improper Adherence to Coding Standards (31)
- ▶ Improper Neutralization (11)
- ▶ Improper Control of a Resource Through its Lifetime (28)
- ▶ Improper Access Control (41)
- ▶ Improper Interaction Between Multiple Correctly-Behaving Entities (4)
- ▶ Incorrect Comparison (9)
- ▶ Protection Mechanism Failure (28)

row depth: 1

max depth: 10

scale: 100%

Improper Access Control

On-Chip Debug and Test Interface With Improper Access Control

Insufficient Granularity of Access Control

Insufficient Granularity of Address Regions Protected by Register Locks

Improper Restriction of Write-Once Bit Fields

Improper Prevention of Lock Bit Modification

Security-Sensitive Hardware Controls with Missing Lock Bit Protection

Inclusion of Undocumented Features or Chicken Bits

CPU Hardware Not Configured to Support Exclusivity of Write and Execute Operations

Improper Access Control Applied to Mirrored or Aliased Memory Regions

Improper Restriction of Security Token Assignment

Improper Handling of Overlap Between Protected Memory Ranges

Improper Access Control for Register Interface

Improper Physical Access Control

Sensitive Non-Volatile Information Not Protected During Debug

Policy Uses Obsolete Encoding

Policy Privileges are not Assigned Consistently Between Control and Data Agents

Generation of Incorrect Security Tokens

Improper Access Control for Volatile Memory Containing Boot Code

Hardware Child Block Incorrectly Connected to Parent System

Access Control Check Implemented After Asset is Accessed

Mutable Attestation or Measurement Reporting Data

Incorrect Decoding of Security Identifiers

Incorrect Conversion of Security Identifiers

Insecure Security Identifier Mechanism

Missing Source Identifier in Entity Transactions on a System-On-Chip (SOC),Missing Security Identifier

Incorrect Chaining or Granularity of Debug Components

Improperly Preserved Integrity of Hardware Configuration State During a Power Save/Restore Operation

Improper Translation of Security Attributes by Fabric Bridge

Missing Protection for Mirrored Regions in On-Chip Fabric Firewall

Hardware Allows Activation of Test or Debug Logic at Runtime

Improper Setting of Bus Controlling Capability in Fabric End-point

Fabric-Address Map Allows Programming of Unwarranted Overlaps of Protected and Unprotected Ranges

Improper Access Control in Fabric Bridge

Improper Protection for Outbound Error Messages and Alert Signals

Improper Management of Sensitive Trace Data

Unauthorized Error Injection Can Degrade Hardware Redundancy

Improper Privilege Management

Execution with Unnecessary Privileges

Incorrect Privilege Assignment

Use of Web Link to Untrusted Target with window.opener Access

J2EE Misconfiguration: Weak Access Permissions for EJB Methods

ASP.NET Misconfiguration: Use of Identity Impersonation

.NET Misconfiguration: Use of Impersonation

Privilege Defined With Unsafe Actions

Unsafe ActiveX Control Marked Safe For Scripting

Privilege Chaining

Privilege Context Switching Error

Privilege Dropping / Lowering Errors

Least Privilege Violation

Improper Check for Dropped Privileges

Improper Handling of Insufficient Privileges

Incorrect Use of Privileged APIs

Improper Ownership Management

Unverified Ownership

Incorrect Ownership Assignment

Improper Authorization

Exposure of Sensitive Information Through Metadata

Improper Authorization of Index Containing Sensitive Information

Exposure of Sensitive Information Through Data Queries

Improper Restriction of Software Interfaces to Hardware Features

Unprotected Confidential Information on Device is Accessible by OSAT Vendors

Security Version Number Mutable to Older Versions

Files or Directories Accessible to External Parties

Command Shell in Externally Accessible Directory

Storage of File With Sensitive Data Under FTP Root

Storage of File with Sensitive Data Under Web Root

Unparsed Raw Web Content Delivery

Exposure of Version-Control Repository to an Unauthorized Control Sphere

Exposure of Core Dump File to an Unauthorized Control Sphere

Exposure of Access Control List Files to an Unauthorized Control Sphere

Use of Persistent Cookies Containing Sensitive Information

Exposure of Backup File to an Unauthorized Control Sphere

Incorrect Permission Assignment for Critical Resource

Insecure Preserved Inherited Permissions

Insecure Inherited Permissions

Improper Preservation of Permissions

Critical Data Element Declared Public

Incorrect Default Permissions

Sensitive Cookie Without 'HttpOnly' Flag

Incorrect Execution-Assigned Permissions

Missing Authorization

Improper Authorization in Handler for Custom URL Scheme

Not Using Complete Mediation

Improper Protection of Alternate Path

Direct Request ('Forced Browsing')

Missing Write Protection for Parametric Data Values

Direct Request ('Forced Browsing')

Incorrect Authorization

Guessable CAPTCHA

Use of Non-Canonical URL Paths for Authorization Decisions

Authorization Bypass Through User-Controlled Key

Authorization Bypass Through User-Controlled SQL Primary Key

Permissive Cross-domain Policy with Untrusted Domains

Internal Asset Exposed to Unsafe Debug Access Level or State

Incorrect Behavior Order: Authorization Before Parsing and Canonicalization

Improper Export of Android Application Components

Use of Implicit Intent for Sensitive Communication

Incorrect User Management

Placement of User into Incorrect Group

Improper Authentication

Weak Authentication

Weak Password Recovery Mechanism for Forgotten Password

Not Using Password Aging

Guessable CAPTCHA

Unverified Password Change

Authentication Bypass by Assumed-Immutable Data

Use of Weak Credentials

Weak Password Requirements

Empty Password in Configuration File

Use of Default Credentials

Use of Default Password

Use of Default Cryptographic Key

Use of Hard-coded Credentials

Use of Hard-coded Password

Use of Hard-coded Cryptographic Key

Incorrect Implementation of Authentication Algorithm

Missing Critical Step in Authentication

Improper Restriction of Excessive Authentication Attempts

Use of Password Hash Instead of Password for Authentication

Authentication Bypass: OpenSSL CTX Object Modified after SSL Objects are Created

Use of Password System for Primary Authentication

Use of Single-factor Authentication

Authentication Bypass by Alternate Name

Use of Client-Side Authentication

Reflection Attack in an Authentication Protocol

Authentication Bypass by Primary Weakness

Authentication Bypass by Spoofing

Reliance on IP Address for Authentication

Using Referer Field for Authentication

Reliance on Reverse DNS Resolution for a Security-Critical Action

Insufficiently Protected Credentials

Weak Encoding for Password

Password in Configuration File

J2EE Misconfiguration: Plaintext Password in Configuration File

ASP.NET Misconfiguration: Password in Configuration File

Empty Password in Configuration File

Plaintext Storage of a Password

Missing Password Field Masking

Unprotected Transport of Credentials

Storing Passwords in a Recoverable Format

Authentication Bypass by Capture-replay

Password Aging with Long Expiration

Improper Certificate Validation

Improper Validation of Certificate Expiration

Improper Validation of Certificate with Host Mismatch

Improper Check for Certificate Revocation

Missing Check for Certificate Revocation after Initial Check

Improper Following of a Certificate's Chain of Trust

Missing Validation of OpenSSL Certificate

Missing Authentication for Critical Function

Key Exchange without Entity Authentication

Authentication Bypass Using an Alternate Path or Channel

Direct Request ('Forced Browsing')

Missing Protection Mechanism for Alternate Hardware Interface

Overly Restrictive Account Lockout Mechanism

Origin Validation Error

Missing Origin Validation in WebSockets

Improper Verification of Source of a Communication Channel

Improper Verification of Intent by Broadcast Receiver

Exposed Dangerous Method or Function

Exposed Unsafe ActiveX Method

Exposed IOCTL with Insufficient Access Control

Improper Restriction of Communication Channel to Intended Endpoints

Sensitive Cookie with Improper SameSite Attribute

Reliance on IP Address for Authentication

Improper Validation of Certificate with Host Mismatch

Channel Accessible by Non-Endpoint

Unprotected Primary Channel

Unprotected Alternate Channel

Race Condition During Access to Alternate Channel

Missing Protection Mechanism for Alternate Hardware Interface

Unprotected Windows Messaging Channel ('Shatter')

Improper Verification of Source of a Communication Channel

Improper Verification of Intent by Broadcast Receiver

Incorrectly Specified Destination in a Communication Channel

Permissive Cross-domain Policy with Untrusted Domains

Improper Interaction Between Multiple Correctly-Behaving Entities

Insecure Automated Optimizations

Processor Optimization Removal or Modification of Security-critical Code

Compiler Optimization Removal or Modification of Security-critical Code

Compiler Removal of Code to Clear Buffers

Reliance on Data/Memory Layout

Use of Incorrect Byte Ordering

Interpretation Conflict

Improper Neutralization of CRLF Sequences in HTTP Headers ('HTTP Request/Response Splitting')

Misinterpretation of Input

Incomplete Model of Endpoint Features

Inconsistent Interpretation of HTTP Requests ('HTTP Request/Response Smuggling')

Null Byte Interaction Error (Poison Null Byte)

Trusting HTTP Permission Methods on the Server Side

Improper Neutralization of Invalid Characters in Identifiers in Web Pages

Behavioral Change in New Version or Environment

Improper Control of a Resource Through its Lifetime

Incorrect Access of Indexable Resource ('Range Error')

Improper Restriction of Operations within the Bounds of a Memory Buffer

Access of Memory Location Before Start of Buffer

Buffer Underwrite ('Buffer Underflow')

Buffer Under-read

Expired Pointer Dereference

Use of Out-of-range Pointer Offset

Integer Overflow to Buffer Overflow

Out-of-bounds Read

Buffer Over-read

Buffer Under-read

Out-of-bounds Write

Heap-based Buffer Overflow

Write-what-where Condition

Buffer Underwrite ('Buffer Underflow')

Stack-based Buffer Overflow

Buffer Copy without Checking Size of Input ('Classic Buffer Overflow')

Use of Path Manipulation Function without Maximum-sized Buffer

Access of Uninitialized Pointer

Return of Pointer Value Outside of Expected Range

Untrusted Pointer Dereference

Access of Memory Location After End of Buffer

Buffer Over-read

Heap-based Buffer Overflow

Stack-based Buffer Overflow

Buffer Access with Incorrect Length Value

Buffer Access Using Size of Source Buffer

Buffer Copy without Checking Size of Input ('Classic Buffer Overflow')

Use of Path Manipulation Function without Maximum-sized Buffer

Creation of Emergent Resource

Covert Timing Channel

Covert Storage Channel

Improper Preservation of Consistency Between Independent Representations of Shared State

Application-Level Admin Tool with Inconsistent View of Underlying Operating System

Mirrored Regions with Different Values

Reliance on Component That is Not Updateable

Firmware Not Updateable

Missing Ability to Patch ROM Code

Information Loss or Omission

Truncation of Security-relevant Information

Omission of Security-relevant Information

Insufficient Logging

Missing Security-Relevant Feedback for Unexecuted Operations in Hardware Interface

Obscured Security-relevant Information by Alternate Name

Product UI does not Warn User of Unsafe Actions

Declaration of Catch for Generic Exception

Declaration of Throws for Generic Exception

User Interface (UI) Misrepresentation of Critical Information

Insufficient Visual Distinction of Homoglyphs Presented to User

Improper Restriction of Rendered UI Layers or Frames

Incomplete Internal State Distinction

Uncontrolled Resource Consumption

Incorrect Use of Autoboxing and Unboxing for Performance Critical Operations

Improper Write Handling in Limited-write Non-Volatile Memories

Asymmetric Resource Consumption (Amplification)

Large Data Table with Excessive Number of Indices

Excessive Platform Resource Consumption within a Loop

Excessive Index Range Scan for a Data Resource

Non-SQL Invokable Control Element with Excessive Number of Data Resource Accesses

Insufficient Control of Network Message Volume (Network Amplification)

Data Resource Access without Use of Connection Pooling

Inefficient Algorithmic Complexity

Inefficient Regular Expression Complexity

Inefficient CPU Computation

Creation of Immutable Text Using String Concatenation

Excessive Data Query Operations in a Large Data Table

Creation of Class Instance within a Static Code Block

Static Member Data Element outside of a Singleton Class Element

Excessive Execution of Sequential Searches of Data Resource

Improper Handling of Highly Compressed Data (Data Amplification)

Incorrect Behavior Order: Early Amplification

Improper Restriction of Recursive Entity References in DTDs ('XML Entity Expansion')

Invokable Control Element with Excessive File or Data Access Operations

Allocation of Resources Without Limits or Throttling

Allocation of File Descriptors or Handles Without Limits or Throttling

Improperly Controlled Sequential Memory Allocation

Memory Allocation with Excessive Size Value

Missing Reference to Active Allocated Resource

Missing Reference to Active File Descriptor or Handle

Logging of Excessive Data

Improper Restriction of Power Consumption

Improper Resource Shutdown or Release

Improper Scrubbing of Sensitive Data from Decommissioned Device

Improper Check for Certificate Revocation

Missing Check for Certificate Revocation after Initial Check

Incomplete Cleanup

Sensitive Information in Resource Not Removed Before Reuse

Information Exposure through Microarchitectural State after Transient Execution

Improper Zeroization of Hardware Register

Insufficient or Incomplete Data Removal within Hardware Component

Remanent Data Readable after Memory Erase

Improper Clearing of Heap Memory Before Release ('Heap Inspection')

Sensitive Information Uncleared Before Debug/Power State Transition

Improper Cleanup on Thrown Exception

finalize() Method Without super.finalize()

Release of Invalid Pointer or Reference

Mismatched Memory Management Routines

Free of Memory not on the Heap

Free of Pointer not at Start of Buffer

Missing Release of Resource after Effective Lifetime

Use of Object without Invoking Destructor Method

Missing Release of File Descriptor or Handle after Effective Lifetime

Missing Release of Memory after Effective Lifetime

Asymmetric Resource Consumption (Amplification)

Excessive Platform Resource Consumption within a Loop

Data Resource Access without Use of Connection Pooling

Non-SQL Invokable Control Element with Excessive Number of Data Resource Accesses

Invokable Control Element with Excessive File or Data Access Operations

Large Data Table with Excessive Number of Indices

Excessive Index Range Scan for a Data Resource

Inefficient CPU Computation

Creation of Immutable Text Using String Concatenation

Excessive Data Query Operations in a Large Data Table

Creation of Class Instance within a Static Code Block

Static Member Data Element outside of a Singleton Class Element

Excessive Execution of Sequential Searches of Data Resource

Insufficient Control of Network Message Volume (Network Amplification)

Inefficient Algorithmic Complexity

Inefficient Regular Expression Complexity

Incorrect Behavior Order: Early Amplification

Improper Handling of Highly Compressed Data (Data Amplification)

Improper Restriction of Recursive Entity References in DTDs ('XML Entity Expansion')

Insufficient Resource Pool

Modification of Assumed-Immutable Data (MAID)

Reliance on IP Address for Authentication

External Control of Assumed-Immutable Web Parameter

PHP External Variable Modification

Public Static Final Field References Mutable Object

Reliance on Package-level Scope

Private Data Structure Returned From A Public Method

Public Data Assigned to Private Array-Typed Field

Trust Boundary Violation

clone() Method Without super.clone()

Externally Controlled Reference to a Resource in Another Sphere

External Control of System or Configuration Setting

Session Fixation

Unintended Proxy or Intermediary ('Confused Deputy')

Improper Restriction of Rendered UI Layers or Frames

Server-Side Request Forgery (SSRF)

Use of Externally-Controlled Input to Select Classes or Code ('Unsafe Reflection')

URL Redirection to Untrusted Site ('Open Redirect')

Improper Restriction of XML External Entity Reference

External Control of File Name or Path

Process Control

Improper Synchronization

Invokable Control Element in Multi-Thread Context with non-Final Static Storable or Member Element

Use of a Non-reentrant Function in a Concurrent Context

Signal Handler Use of a Non-reentrant Function

Use of getlogin() in Multithreaded Application

Improper Locking

Hardware Internal or Debug Modes Allow Override of Locks

Improper Lock Behavior After Power State Transition

Security-Sensitive Hardware Controls with Missing Lock Bit Protection

Multiple Unlocks of a Critical Resource

Unlock of a Resource that is not Locked

Missing Lock Check

Improper Resource Locking

Sensitive Data Storage in Improperly Locked Memory

Double-Checked Locking

Unrestricted Externally Accessible Lock

Multiple Locks of a Critical Resource

Missing Synchronization

Use of Singleton Pattern Without Synchronization in a Multithreaded Context

Unsynchronized Access to Shared Data in a Multithreaded Context

Singleton Class Instance Creation without Proper Locking or Synchronization

Incorrect Synchronization

Call to Thread run() instead of start()

EJB Bad Practices: Use of Synchronization Primitives

Hardware Logic with Insecure De-Synchronization between Control and Data Channels

Synchronous Access of Remote Resource without Timeout

Improper Initialization

Initialization with Hard-Coded Network Resource Configuration Data

Excessive Use of Hard-Coded Literals in Initialization

Insecure Default Initialization of Resource,Initialization of a Resource with an Insecure Default

Insecure Default Variable Initialization

Incorrect Register Defaults or Module Parameters

Cryptographic Operations are run Before Supporting Units are Ready

Incorrect Initialization of Resource

Insecure Default Initialization of Resource,Initialization of a Resource with an Insecure Default

Insecure Default Variable Initialization

Incorrect Register Defaults or Module Parameters

Excessive Use of Hard-Coded Literals in Initialization

Initialization with Hard-Coded Network Resource Configuration Data

External Initialization of Trusted Variables or Data Stores

External Initialization of Trusted Variables or Data Stores

Non-exit on Failed Initialization

Allocation of Resources Without Limits or Throttling

Allocation of File Descriptors or Handles Without Limits or Throttling

Improperly Controlled Sequential Memory Allocation

Memory Allocation with Excessive Size Value

Use of Uninitialized Resource

Use of Uninitialized Variable

Missing Initialization of Resource

Uninitialized Value on Reset for Registers Holding Security Settings

Missing Initialization of a Variable

Operation on Resource in Wrong Phase of Lifetime

Authentication Bypass: OpenSSL CTX Object Modified after SSL Objects are Created

Multiple Binds to the Same Port

Operation on a Resource after Expiration or Release

Use of a Key Past its Expiration Date

Expired Pointer Dereference

Improper Validation of Certificate Expiration

Insufficient Session Expiration

Use of Expired File Descriptor

Premature Release of Resource During Expected Lifetime

Exposure of Resource to Wrong Sphere

Improper Isolation of Shared Resources on System-on-a-Chip (SoC)

Non-Transparent Sharing of Microarchitectural Resources

Assumed-Immutable Data is Stored in Writable Memory

Binding to an Unrestricted IP Address

Improper Isolation of Shared Resources in Network On Chip (NoC)

Use of Externally-Controlled Format String

Exposure of Sensitive Information to an Unauthorized Actor

Insertion of Sensitive Information Into Debugging Code

Exposure of Sensitive Information Due to Incompatible Policies

Debug Messages Revealing Unnecessary Information

Insertion of Sensitive Information Into Sent Data

Use of GET Request Method With Sensitive Query Strings

Generation of Error Message Containing Sensitive Information

Externally-Generated Error Message Containing Sensitive Information

Exposure of Information Through Shell Error Message

Java Runtime Error Message Containing Sensitive Information

Servlet Runtime Error Message Containing Sensitive Information

Server-generated Error Message Containing Sensitive Information

Self-generated Error Message Containing Sensitive Information

Driving Intermediate Cryptographic State/Results to Hardware Module Outputs

Exposure of Sensitive System Information to an Unauthorized Control Sphere

Invocation of Process Using Visible Sensitive Information

Exposure of Information Through Directory Listing

Observable Discrepancy

Observable Response Discrepancy

Non-Transparent Sharing of Microarchitectural Resources

Improper Protection of Physical Side Channels

Comparison Logic is Vulnerable to Power Side-Channel Attacks

Observable Behavioral Discrepancy

Observable Internal Behavioral Discrepancy

Observable Behavioral Discrepancy With Equivalent Products

Observable Timing Discrepancy

Incorrect Comparison Logic Granularity

Insertion of Sensitive Information into Externally-Accessible File or Directory

Insertion of Sensitive Information into Log File

Exposure of WSDL File Containing Sensitive Information

Inclusion of Sensitive Information in Source Code

Inclusion of Sensitive Information in Source Code Comments

Inclusion of Sensitive Information in Test Code

Inclusion of Sensitive Information in an Include File

Exposure of Sensitive System Information Due to Uncleared Debug Information

Device Unlock Credential Sharing

Exposure of Private Personal Information to an Unauthorized Actor

Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')

Absolute Path Traversal

Path Traversal: '\\UNC\share\name\' (Windows UNC Share)

Path Traversal: '\absolute\pathname\here'

Path Traversal: '/absolute/pathname/here'

Path Traversal: 'C:dirname'

Relative Path Traversal

Path Traversal: '/dir/../filename'

Path Traversal: 'dir\..\..\filename'

Path Traversal: 'dir/../../filename'

Path Traversal: '...' (Triple Dot)

Path Traversal: '..\filedir'

Path Traversal: '....//'

Path Traversal: '../filedir'

Path Traversal: '\..\filename'

Path Traversal: '....' (Multiple Dot)

Path Traversal: '.../...//'

Path Traversal: '\dir\..\filename'

Path Traversal: '/../filedir'

Passing Mutable Objects to an Untrusted Method

Returning a Mutable Object to an Untrusted Caller

Insecure Temporary File

Creation of Temporary File With Insecure Permissions

Creation of Temporary File in Directory with Insecure Permissions

Transmission of Private Resources into a New Sphere ('Resource Leak')

Exposure of File Descriptor to Unintended Control Sphere ('File Descriptor Leak')

Dangling Database Cursor ('Cursor Injection')

Uncontrolled Search Path Element

Unquoted Search Path or Element

Exposure of Data Element to Wrong Session

Public cloneable() Method Without Final ('Object Hijack')

Use of Inner Class Containing Sensitive Data

Critical Public Variable Without Final Modifier

Public Static Field Not Marked Final

Cloneable Class Containing Sensitive Information

Serializable Class Containing Sensitive Data

Insufficiently Protected Credentials

Weak Encoding for Password

Password in Configuration File

J2EE Misconfiguration: Plaintext Password in Configuration File

ASP.NET Misconfiguration: Password in Configuration File

Empty Password in Configuration File

Plaintext Storage of a Password

Missing Password Field Masking

Unprotected Transport of Credentials

Storing Passwords in a Recoverable Format

Use of Cache Containing Sensitive Information

Use of Web Browser Cache Containing Sensitive Information

Files or Directories Accessible to External Parties

Command Shell in Externally Accessible Directory

Storage of File With Sensitive Data Under FTP Root

Storage of File with Sensitive Data Under Web Root

Unparsed Raw Web Content Delivery

Exposure of Version-Control Repository to an Unauthorized Control Sphere

Exposure of Core Dump File to an Unauthorized Control Sphere

Exposure of Access Control List Files to an Unauthorized Control Sphere

Use of Persistent Cookies Containing Sensitive Information

Exposure of Backup File to an Unauthorized Control Sphere

Array Declared Public, Final, and Static

finalize() Method Declared Public

Struts: Non-private Field in ActionForm Class

External Control of Critical State Data

External Control of Assumed-Immutable Web Parameter

External Control of File Name or Path

Process Control

Untrusted Search Path

Reliance on Cookies without Validation and Integrity Checking

Reliance on Cookies without Validation and Integrity Checking in a Security Decision

External Control of System or Configuration Setting

Incorrect Permission Assignment for Critical Resource

Insecure Preserved Inherited Permissions

Insecure Inherited Permissions

Improper Preservation of Permissions

Critical Data Element Declared Public

Incorrect Default Permissions

Sensitive Cookie Without 'HttpOnly' Flag

Incorrect Execution-Assigned Permissions

Access to Critical Private Variable via Public Method

J2EE Misconfiguration: Entity Bean Declared Remote

Use of Implicit Intent for Sensitive Communication

Incorrect Resource Transfer Between Spheres

Exposure of Sensitive Information during Transient Execution

Exposure of Sensitive Information caused by Shared Microarchitectural Predictor State that Influences Transient Execution

Exposure of Sensitive Information in Shared Microarchitectural Structures during Transient Execution

Exposure of Sensitive Information caused by Incorrect Data Forwarding during Transient Execution

Improper Removal of Sensitive Information Before Storage or Transfer

Sensitive Information in Resource Not Removed Before Reuse

Information Exposure through Microarchitectural State after Transient Execution

Improper Zeroization of Hardware Register

Insufficient or Incomplete Data Removal within Hardware Component

Remanent Data Readable after Memory Erase

Improper Clearing of Heap Memory Before Release ('Heap Inspection')

Sensitive Information Uncleared Before Debug/Power State Transition

Exposure of Sensitive System Information Due to Uncleared Debug Information

Creation of chroot Jail Without Changing Working Directory

Unrestricted Upload of File with Dangerous Type

Download of Code Without Integrity Check

Inclusion of Functionality from Untrusted Control Sphere

Improper Control of Document Type Definition

Inclusion of Web Functionality from an Untrusted Source

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

External Influence of Sphere Definition

Untrusted Search Path

Incorrect Type Conversion or Cast

Incorrect Parsing of Numbers with Different Radices

Attempt to Access Child of a Non-structure Pointer

Incorrect Conversion between Numeric Types

Unsigned to Signed Conversion Error

Signed to Unsigned Conversion Error

Integer Coercion Error

Unexpected Sign Extension

Numeric Truncation Error

Access of Resource Using Incompatible Type ('Type Confusion')

Use of Incorrectly-Resolved Name or Reference

Improper Handling of Case Sensitivity

Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')

Absolute Path Traversal

Path Traversal: '\\UNC\share\name\' (Windows UNC Share)

Path Traversal: '\absolute\pathname\here'

Path Traversal: '/absolute/pathname/here'

Path Traversal: 'C:dirname'

Relative Path Traversal

Path Traversal: '/dir/../filename'

Path Traversal: 'dir\..\..\filename'

Path Traversal: 'dir/../../filename'

Path Traversal: '...' (Triple Dot)

Path Traversal: '..\filedir'

Path Traversal: '....//'

Path Traversal: '../filedir'

Path Traversal: '\..\filename'

Path Traversal: '....' (Multiple Dot)

Path Traversal: '.../...//'

Path Traversal: '\dir\..\filename'

Path Traversal: '/../filedir'

Symbolic Name not Mapping to Correct Object

Improper Resolution of Path Equivalence

Path Equivalence: 'fakedir/../realdir/filename'

Path Equivalence: 'file name' (Internal Whitespace)

Path Equivalence: Windows 8.3 Filename

Path Equivalence: 'filedir*' (Wildcard)

Path Equivalence: '//multiple/leading/slash'

Path Equivalence: 'filename.' (Trailing Dot)

Path Equivalence: 'filename....' (Multiple Trailing Dot)

Path Equivalence: 'file.name' (Internal Dot)

Path Equivalence: 'file...name' (Multiple Internal Dot)

Path Equivalence: 'filename/' (Trailing Slash)

Path Equivalence: '\multiple\\internal\backslash'

Path Equivalence: 'filename ' (Trailing Space)

Path Equivalence: ' filename' (Leading Space)

Path Equivalence: '/multiple/trailing/slash//'

Path Equivalence: '/./' (Single Dot Directory)

Path Equivalence: 'filedir\' (Trailing Backslash)

Path Equivalence: '/multiple//internal/slash'

Improper Link Resolution Before File Access ('Link Following')

UNIX Symbolic Link (Symlink) Following

Insecure Operation on Windows Junction / Mount Point

Windows Shortcut Following (.LNK)

Windows Hard Link

Improper Handling of File Names that Identify Virtual Resources

Improper Handling of Windows ::DATA Alternate Data Stream

Improper Handling of Windows Device Names

Improper Handling of Apple HFS+ Alternate Data Stream Path

Improper Control of Document Type Definition

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

Improper Update of Reference Count

Improper Control of Dynamically-Managed Code Resources

Use of Externally-Controlled Input to Select Classes or Code ('Unsafe Reflection')

Deserialization of Untrusted Data

Improper Control of Dynamically-Identified Variables

Dynamic Variable Evaluation

Variable Extraction Error

Improperly Controlled Modification of Dynamically-Determined Object Attributes

Improperly Controlled Modification of Object Prototype Attributes ('Prototype Pollution')

Improper Control of Generation of Code ('Code Injection')

Improper Neutralization of Directives in Dynamically Evaluated Code ('Eval Injection')

Improper Neutralization of Special Elements Used in a Template Engine

Improper Neutralization of Directives in Statically Saved Code ('Static Code Injection')

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

Insecure Storage of Sensitive Information

Cleartext Storage of Sensitive Information

Cleartext Storage in a File or on Disk

Cleartext Storage in the Registry

Cleartext Storage of Sensitive Information in GUI

Cleartext Storage of Sensitive Information in a Cookie

Cleartext Storage of Sensitive Information in an Environment Variable

Cleartext Storage of Sensitive Information in Memory

Cleartext Storage of Sensitive Information in Executable

Storage of Sensitive Data in a Mechanism without Access Control

Incorrect Calculation

Wrap-around Error

Incorrect Calculation of Buffer Size

Use of sizeof() on a Pointer Type

Incorrect Bitwise Shift of Integer

Insufficient Precision or Accuracy of a Real Number

Incorrect Calculation of Multi-Byte String Length

Integer Overflow or Wraparound

Integer Overflow to Buffer Overflow

Integer Underflow (Wrap or Wraparound)

Off-by-one Error

Incorrect Pointer Scaling

Use of Pointer Subtraction to Determine Size

Insufficient Control Flow Management

Unintended Reentrant Invocation of Non-reentrant Code Via Nested Calls

Sequence of Processor Instructions Leads to Unexpected Behavior

Concurrent Execution using Shared Resource with Improper Synchronization ('Race Condition')

Race Condition for Write-Once Attributes

Hardware Logic Contains Race Conditions

Signal Handler Race Condition

Signal Handler Function Associated with Multiple Signals

Signal Handler with Functionality that is not Asynchronous-Safe

Signal Handler Use of a Non-reentrant Function

Dangerous Signal Handler not Disabled During Sensitive Operations

Race Condition within a Thread

Time-of-check Time-of-use (TOCTOU) Race Condition

Race Condition Enabling Link Following

Context Switching Race Condition

Race Condition During Access to Alternate Channel

Permission Race Condition During Resource Copy

Deployment of Wrong Handler

Missing Handler

Improper Synchronization

Invokable Control Element in Multi-Thread Context with non-Final Static Storable or Member Element

Use of a Non-reentrant Function in a Concurrent Context

Signal Handler Use of a Non-reentrant Function

Use of getlogin() in Multithreaded Application

Improper Locking

Hardware Internal or Debug Modes Allow Override of Locks

Improper Lock Behavior After Power State Transition

Security-Sensitive Hardware Controls with Missing Lock Bit Protection

Multiple Unlocks of a Critical Resource

Unlock of a Resource that is not Locked

Missing Lock Check

Improper Resource Locking

Sensitive Data Storage in Improperly Locked Memory

Double-Checked Locking

Unrestricted Externally Accessible Lock

Multiple Locks of a Critical Resource

Missing Synchronization

Use of Singleton Pattern Without Synchronization in a Multithreaded Context

Unsynchronized Access to Shared Data in a Multithreaded Context

Singleton Class Instance Creation without Proper Locking or Synchronization

Incorrect Synchronization

Call to Thread run() instead of start()

EJB Bad Practices: Use of Synchronization Primitives

Hardware Logic with Insecure De-Synchronization between Control and Data Channels

Synchronous Access of Remote Resource without Timeout

Always-Incorrect Control Flow Implementation

Use of Incorrect Operator

Comparing instead of Assigning

Assigning instead of Comparing

Use of Wrong Operator in String Comparison

Incorrect Block Delimitation

Omitted Break Statement in Switch

Reachable Assertion

Execution After Redirect (EAR)

Operator Precedence Logic Error

Incorrect Behavior Order

DMA Device Enabled Too Early in Boot Phase

Power-On of Untrusted Execution Core Before Enabling Fabric Access Control

Cryptographic Operations are run Before Supporting Units are Ready

Access Control Check Implemented After Asset is Accessed

Incorrect Behavior Order: Early Validation

Incorrect Behavior Order: Validate Before Filter

Incorrect Behavior Order: Validate Before Canonicalize

Incorrect Behavior Order: Early Amplification

Incorrect Behavior Order: Authorization Before Parsing and Canonicalization

Incorrect Control Flow Scoping

Uncaught Exception

Uncaught Exception in Servlet

J2EE Bad Practices: Use of System.exit()

Use of NullPointerException Catch to Detect NULL Pointer Dereference

Declaration of Catch for Generic Exception

Declaration of Throws for Generic Exception

Non-exit on Failed Initialization

Return Inside Finally Block

Execution After Redirect (EAR)

Incorrect Short Circuit Evaluation

Improper Control of Interaction Frequency

Improper Restriction of Excessive Authentication Attempts

Improper Enforcement of a Single, Unique Action

Excessive Iteration

Use of Blocking Code in Single-threaded, Non-blocking Context

Uncontrolled Recursion

Improper Restriction of Recursive Entity References in DTDs ('XML Entity Expansion')

Loop with Unreachable Exit Condition ('Infinite Loop')

Improper Enforcement of Behavioral Workflow

Protection Mechanism Failure

Inadequate Detection or Handling of Adversarial Input Perturbations in Automated Recognition Mechanism,Automated Recognition Mechanism with Inadequate Detection or Handling of Adversarial Input Perturbations

Semiconductor Defects in Hardware Logic with Security-Sensitive Implications

Incorrect Selection of Fuse Values

Product Released in Non-Release Configuration

Missing Protection Against Hardware Reverse Engineering Using Integrated Circuit (IC) Imaging Techniques

Public Key Re-Use for Signing both Debug and Production Code

Missing Support for Security Features in On-chip Fabrics or Buses

Improper Protection against Electromagnetic Fault Injection (EM-FI)

Missing Immutable Root of Trust in Hardware

Improper Protections Against Hardware Overheating

Collapse of Data into Unsafe Value

Incomplete List of Disallowed Inputs

Incomplete Denylist to Cross-Site Scripting

Missing Encryption of Sensitive Data

Cleartext Storage of Sensitive Information

Cleartext Storage in a File or on Disk

Cleartext Storage in the Registry

Cleartext Storage of Sensitive Information in GUI

Cleartext Storage of Sensitive Information in a Cookie

Cleartext Storage of Sensitive Information in an Environment Variable

Cleartext Storage of Sensitive Information in Memory

Cleartext Storage of Sensitive Information in Executable

Cleartext Transmission of Sensitive Information

Reliance on HTTP instead of HTTPS

J2EE Misconfiguration: Data Transmission Without Encryption

Sensitive Cookie in HTTPS Session Without 'Secure' Attribute

Inadequate Encryption Strength

Use of Weak Hash

Use of Password Hash With Insufficient Computational Effort

Use of a One-Way Hash with a Predictable Salt

Use of a One-Way Hash without a Salt

Use of a Broken or Risky Cryptographic Algorithm

Use of a Cryptographic Primitive with a Risky Implementation

Use of Weak Hash

Use of Password Hash With Insufficient Computational Effort

Use of a One-Way Hash with a Predictable Salt

Use of a One-Way Hash without a Salt

Use of RSA Algorithm without OAEP

Use of Password Hash With Insufficient Computational Effort

Use of a One-Way Hash with a Predictable Salt

Use of a One-Way Hash without a Salt

Use of Insufficiently Random Values

Generation of Weak Initialization Vector (IV)

Generation of Predictable IV with CBC Mode

Use of Predictable Algorithm in Random Number Generator

Insufficient Entropy

Improper Handling of Insufficient Entropy in TRNG

Insufficient Entropy in PRNG

Small Space of Random Values

J2EE Misconfiguration: Insufficient Session-ID Length

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

Same Seed in Pseudo-Random Number Generator (PRNG)

Predictable Seed in Pseudo-Random Number Generator (PRNG)

Small Seed Space in PRNG

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

Generation of Predictable Numbers or Identifiers

Predictable Exact Value from Previous Values

Predictable Value Range from Previous Values

Predictable from Observable State

Use of Invariant Value in Dynamically Changing Context

Assignment of a Fixed Address to a Pointer

Use of Hard-coded Credentials

Use of Hard-coded Password

Use of Hard-coded Cryptographic Key

Reusing a Nonce, Key Pair in Encryption

Insufficient Verification of Data Authenticity

Missing Source Correlation of Multiple Independent Data

Origin Validation Error

Improper Verification of Source of a Communication Channel

Improper Verification of Intent by Broadcast Receiver

Missing Origin Validation in WebSockets

Improper Verification of Cryptographic Signature

Use of Less Trusted Source

Acceptance of Extraneous Untrusted Data With Trusted Data

Insufficient Type Distinction

Cross-Site Request Forgery (CSRF)

Missing Support for Integrity Check

Improper Validation of Integrity Check Value

Trust of System Event Data

Unprotected Windows Messaging Channel ('Shatter')

Download of Code Without Integrity Check

Incomplete Identification of Uploaded File Variables (PHP)

Reliance on File Name or Extension of Externally-Supplied File

Reliance on Obfuscation or Encryption of Security-Relevant Inputs without Integrity Checking

Improper Enforcement of Message Integrity During Transmission in a Communication Channel

Insufficient UI Warning of Dangerous Operations

Multiple Interpretations of UI Input

Improperly Implemented Security Check for Standard

Improper Protection of Alternate Path

Direct Request ('Forced Browsing')

Client-Side Enforcement of Server-Side Security

Reliance on Cookies without Validation and Integrity Checking

Reliance on Cookies without Validation and Integrity Checking in a Security Decision

Use of Client-Side Authentication

Improper Isolation or Compartmentalization

Improper Isolation of Shared Resources on System-on-a-Chip (SoC)

Non-Transparent Sharing of Microarchitectural Resources

Improper Isolation of Shared Resources in Network On Chip (NoC)

Reliance on a Single Factor in a Security Decision

Use of Single-factor Authentication

Use of Password System for Primary Authentication

Insufficient Psychological Acceptability

Reliance on Security Through Obscurity

Selection of Less-Secure Algorithm During Negotiation ('Algorithm Downgrade')

Insufficient Logging

Reliance on Untrusted Inputs in a Security Decision

Authentication Bypass by Assumed-Immutable Data

Reliance on Reverse DNS Resolution for a Security-Critical Action

Reliance on Cookies without Validation and Integrity Checking in a Security Decision

Incorrect Comparison

Incomplete Comparison with Missing Factors

Incomplete List of Disallowed Inputs

Incomplete Denylist to Cross-Site Scripting

Partial String Comparison

Missing Default Case in Multiple Condition Expression

Numeric Range Comparison Without Minimum Check

Comparison of Incompatible Types

Comparison Using Wrong Factors

Comparison of Classes by Name

Comparison of Object References Instead of Object Contents

Use of Wrong Operator in String Comparison

Inadequate Detection or Handling of Adversarial Input Perturbations in Automated Recognition Mechanism,Automated Recognition Mechanism with Inadequate Detection or Handling of Adversarial Input Perturbations

Floating Point Comparison with Incorrect Operator

Incorrect Comparison Logic Granularity

Permissive List of Allowed Inputs

Permissive Cross-domain Policy with Untrusted Domains

Incorrect Regular Expression

Overly Restrictive Regular Expression

Permissive Regular Expression

Regular Expression without Anchors

Object Model Violation: Just One of Equals and Hashcode Defined

Improper Check or Handling of Exceptional Conditions

Improper Handling of Physical or Environmental Conditions

Improper Protection Against Voltage and Clock Glitches

Improper Handling of Single Event Upsets

Improper Handling of Faults that Lead to Instruction Skips

Improper Handling of Hardware Behavior in Exceptionally Cold Environments

Improper Handling of Missing Special Element

Improper Handling of Additional Special Element

Improper Handling of Inconsistent Special Elements

Improper Handling of Syntactically Invalid Structure

Improper Handling of Missing Special Element

Improper Handling of Additional Special Element

Improper Handling of Inconsistent Special Elements

Improper Handling of Values

Improper Handling of Missing Values

Improper Handling of Extra Values

Improper Handling of Undefined Values

Improper Handling of Parameters

Failure to Handle Missing Parameter

Improper Handling of Undefined Parameters

Improper Handling of Extra Parameters

Improper Handling of Structural Elements

Improper Handling of Inconsistent Structural Elements

Improper Handling of Length Parameter Inconsistency

Failure to Handle Incomplete Element

Improper Handling of Incomplete Structural Elements

Improper Handling of Unexpected Data Type

Uncaught Exception

Uncaught Exception in Servlet

Improper Handling of Insufficient Entropy in TRNG

Missing Report of Error Condition

Return of Wrong Status Code

Declaration of Throws for Generic Exception

Improper Check for Unusual or Exceptional Conditions

Unchecked Return Value

Unchecked Return Value to NULL Pointer Dereference

Incorrect Check of Function Return Value

Improper Check for Dropped Privileges

Improper Validation of Integrity Check Value

Unchecked Error Condition

Unexpected Status Code or Return Value

NULL Pointer Dereference

Unchecked Return Value to NULL Pointer Dereference

Improper Handling of Exceptional Conditions

Generation of Error Message Containing Sensitive Information

Externally-Generated Error Message Containing Sensitive Information

Exposure of Information Through Shell Error Message

Java Runtime Error Message Containing Sensitive Information

Servlet Runtime Error Message Containing Sensitive Information

Server-generated Error Message Containing Sensitive Information

Self-generated Error Message Containing Sensitive Information

Uncaught Exception

Uncaught Exception in Servlet

Improper Handling of Insufficient Privileges

Improper Handling of Insufficient Permissions or Privileges

Improper Handling of Insufficient Entropy in TRNG

Detection of Error Condition Without Action

Missing Report of Error Condition

Use of NullPointerException Catch to Detect NULL Pointer Dereference

Declaration of Catch for Generic Exception

Improper Cleanup on Thrown Exception

Missing Standardized Error Handling Mechanism

Not Failing Securely ('Failing Open')

Non-exit on Failed Initialization

Missing Custom Error Page

J2EE Misconfiguration: Missing Custom Error Page

ASP.NET Misconfiguration: Missing Custom Error Page

Improper Neutralization

Improper Encoding or Escaping of Output

Improper Output Neutralization for Logs

Improper Neutralization of HTTP Headers for Scripting Syntax

Inappropriate Encoding for Output Context

Improper Neutralization of Special Elements

Improper Neutralization of Delimiters

Improper Neutralization of Parameter/Argument Delimiters

Improper Neutralization of Expression/Command Delimiters

Improper Neutralization of Record Delimiters

Improper Neutralization of Line Delimiters

Improper Neutralization of Section Delimiters

Improper Neutralization of Value Delimiters

Improper Neutralization of Input Terminators

Null Byte Interaction Error (Poison Null Byte)

Improper Neutralization of Input Leaders

Improper Neutralization of Quoting Syntax

Improper Neutralization of Escape, Meta, or Control Sequences

Improper Neutralization of Comment Delimiters

Improper Neutralization of Macro Symbols

Improper Neutralization of Substitution Characters

Improper Neutralization of Variable Name Delimiters

Improper Neutralization of Wildcards or Matching Symbols

Path Equivalence: 'filedir*' (Wildcard)

Improper Neutralization of Whitespace

Failure to Sanitize Paired Delimiters

Improper Neutralization of Null Byte or NUL Character

Improper Handling of Invalid Use of Special Elements

Improper Handling of Additional Special Element

Improper Handling of Missing Special Element

Improper Handling of Inconsistent Special Elements

Improper Neutralization of Leading Special Elements

Improper Neutralization of Multiple Leading Special Elements

Path Equivalence: '//multiple/leading/slash'

Path Traversal: '/absolute/pathname/here'

Improper Neutralization of Trailing Special Elements

Improper Neutralization of Multiple Trailing Special Elements

Path Equivalence: 'filename....' (Multiple Trailing Dot)

Path Equivalence: '/multiple/trailing/slash//'

Path Equivalence: 'filename.' (Trailing Dot)

Path Equivalence: 'filename....' (Multiple Trailing Dot)

Path Equivalence: 'filename/' (Trailing Slash)

Path Equivalence: 'filename ' (Trailing Space)

Path Equivalence: 'filedir\' (Trailing Backslash)

Improper Neutralization of Internal Special Elements

Improper Neutralization of Multiple Internal Special Elements

Path Equivalence: '\multiple\\internal\backslash'

Path Equivalence: 'file...name' (Multiple Internal Dot)

Addition of Data Structure Sentinel

Improper Filtering of Special Elements

Incomplete Filtering of Special Elements

Only Filtering Special Elements at a Specified Location

Only Filtering Special Elements Relative to a Marker

Only Filtering Special Elements at an Absolute Position

Incomplete Filtering of One or More Instances of Special Elements

Incomplete Filtering of Multiple Instances of Special Elements

Only Filtering One Instance of a Special Element

Improper Validation of Generative AI Output

Improper Null Termination

Improper Handling of Alternate Encoding

Double Decoding of the Same Data

Improper Handling of Mixed Encoding

Improper Handling of Unicode Encoding

Improper Handling of URL Encoding (Hex Encoding)

Collapse of Data into Unsafe Value

Improper Input Validation

Improper Use of Validation Framework

Struts: Plug-in Framework not in Use

Struts: Validator Turned Off

Struts: Form Field Without Validator

ASP.NET Misconfiguration: Improper Model Validation

Struts: Duplicate Validation Forms

Struts: Unvalidated Action Form

ASP.NET Misconfiguration: Not Using Input Validation Framework

Improper Validation of Specified Quantity in Input

Unchecked Input for Loop Condition

Memory Allocation with Excessive Size Value

Improper Validation of Specified Index, Position, or Offset in Input

Improper Validation of Array Index

Improper Address Validation in IOCTL with METHOD_NEITHER I/O Control Code

Improper Validation of Syntactic Correctness of Input

Missing XML Validation

Improper Validation of Specified Type of Input

Improper Validation of Consistency within Input

Improper Validation of Unsafe Equivalence in Input

Incorrect Behavior Order: Early Validation

Incorrect Behavior Order: Validate Before Filter

Incorrect Behavior Order: Validate Before Canonicalize

Improper Validation of Function Hook Arguments

Improper Handling of Syntactically Invalid Structure

Improper Handling of Missing Special Element

Improper Handling of Additional Special Element

Improper Handling of Inconsistent Special Elements

Improper Handling of Values

Improper Handling of Missing Values

Improper Handling of Extra Values

Improper Handling of Undefined Values

Improper Handling of Parameters

Failure to Handle Missing Parameter

Improper Handling of Undefined Parameters

Improper Handling of Extra Parameters

Improper Handling of Structural Elements

Improper Handling of Inconsistent Structural Elements

Improper Handling of Length Parameter Inconsistency

Failure to Handle Incomplete Element

Improper Handling of Incomplete Structural Elements

Improper Handling of Unexpected Data Type

Improper Handling of Inconsistent Structural Elements

Improper Handling of Length Parameter Inconsistency

Deletion of Data Structure Sentinel

Improper Neutralization of Special Elements in Output Used by a Downstream Component ('Injection')

Improper Neutralization of Formula Elements in a CSV File

Failure to Sanitize Special Elements into a Different Plane (Special Element Injection)

Improper Neutralization of Equivalent Special Elements

Improper Neutralization of Special Elements used in a Command ('Command Injection')

Improper Neutralization of Input Used for LLM Prompting

Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection')

Improper Neutralization of Argument Delimiters in a Command ('Argument Injection')

Improper Neutralization of Special Elements used in an Expression Language Statement ('Expression Language Injection')

Executable Regular Expression Error

Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')

Improper Neutralization of Invalid Characters in Identifiers in Web Pages

Improper Neutralization of Script-Related HTML Tags in a Web Page (Basic XSS)

Improper Neutralization of Encoded URI Schemes in a Web Page

Incomplete Denylist to Cross-Site Scripting

Doubled Character XSS Manipulations

Improper Neutralization of Script in an Error Message Web Page

Improper Neutralization of Script in Attributes in a Web Page

Improper Neutralization of Script in Attributes of IMG Tags in a Web Page

Improper Neutralization of Alternate XSS Syntax

XML Injection (aka Blind XPath Injection)

Improper Neutralization of Data within XQuery Expressions ('XQuery Injection')

Improper Neutralization of Data within XPath Expressions ('XPath Injection')

Improper Neutralization of CRLF Sequences ('CRLF Injection')

Improper Neutralization of CRLF Sequences in HTTP Headers ('HTTP Request/Response Splitting')

Improper Control of Generation of Code ('Code Injection')

Improper Neutralization of Directives in Dynamically Evaluated Code ('Eval Injection')

Improper Neutralization of Special Elements Used in a Template Engine

Improper Neutralization of Directives in Statically Saved Code ('Static Code Injection')

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

Improper Neutralization of Special Elements in Data Query Logic

Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')

SQL Injection: Hibernate

Improper Neutralization of Data within XQuery Expressions ('XQuery Injection')

Improper Neutralization of Data within XPath Expressions ('XPath Injection')

Improper Neutralization of Special Elements used in an LDAP Query ('LDAP Injection')

Improper Control of Resource Identifiers ('Resource Injection')

Use of Multiple Resources with Duplicate Identifier

Duplicate Key in Associative List (Alist)

Struts: Duplicate Validation Forms

Improper Control of Dynamically-Identified Variables

Dynamic Variable Evaluation

Variable Extraction Error

Improper Restriction of Names for Files and Other Resources

Improper Adherence to Coding Standards

Use of Redundant Code

Architecture with Number of Horizontal Layers Outside of Expected Range

Invokable Control Element with Large Number of Outward Calls

Insufficient Technical Documentation

Missing Documentation for Design

Incomplete Design Documentation

Incomplete I/O Documentation

Incomplete Documentation of Program Execution

Insufficient Documentation of Error Handling Techniques

Insufficient Encapsulation

Invocation of a Control Element at an Unnecessarily Deep Horizontal Layer

Data Access Operations Outside of Expected Data Manager Component

Parent Class with References to Child Class

Data Access from Outside Expected Data Manager Component

Method Containing Access of a Member Element from Another Class

Insufficient Isolation of System-Dependent Functions

Insufficient Encapsulation of Machine-Dependent Functionality

Reliance on Data/Memory Layout

Use of Incorrect Byte Ordering

Critical Data Element Declared Public

Runtime Resource Management Control Element in a Component Built to Run on Application Servers

Missing Serialization Control Element

Inconsistency Between Implementation and Documented Design

Serializable Data Element Containing non-Serializable Item Elements

Insufficient Adherence to Expected Conventions

Parent Class with a Virtual Destructor and a Child Class without a Virtual Destructor

Serializable Data Element Containing non-Serializable Item Elements

Inappropriate Source Code Style or Formatting

Inappropriate Whitespace Style

Suspicious Comment

Use of Hard-coded, Security-relevant Constants

Insufficient Use of Symbolic Constants

Inappropriate Comment Style

Use of Same Variable for Multiple Purposes

Callable with Insufficient Behavioral Summary

Invokable Control Element with Excessive Volume of Commented-out Code

Inconsistent Naming Conventions for Identifiers

Inaccurate Comments

Source Code Element without Standard Prologue

Insufficient Isolation of Symbolic Constant Definitions

Parent Class without Virtual Destructor Method

Class Instance Self Destruction Control Element

Class with Virtual Method without a Virtual Destructor

Use of Object without Invoking Destructor Method

Persistent Storable Data Element without Associated Comparison Control Element

Data Element containing Pointer Item without Proper Copy Control Element

Excessive Reliance on Global Variables

Explicit Call to Finalize()

J2EE Framework: Saving Unserializable Objects to Disk

Use of Same Invokable Control Element in Multiple Architectural Layers

Excessively Complex Data Representation

Data Element Aggregating an Excessively Large Number of Non-Primitive Elements

Multiple Inheritance from Concrete Classes

Class with Excessively Deep Inheritance

Class with Excessive Number of Child Classes

Reliance on Runtime Component in Generated Code

Excessive Code Complexity

Modules with Circular Dependencies

Invokable Control Element with Variadic Parameters

Excessive Number of Inefficient Server-Side Data Accesses

Invokable Control Element with Signature Containing an Excessive Number of Parameters

Unconditional Control Flow Transfer outside of Switch Block

Source Code File with Excessive Number of Lines of Code

Loop Condition Value Update within the Loop

Excessive Use of Unconditional Branching

Excessive McCabe Cyclomatic Complexity

Excessive Halstead Complexity

Excessive Use of Self-Modifying Code

Excessively Deep Nesting

Excessive Attack Surface

Declaration of Variable with Unnecessarily Wide Scope

Compilation with Insufficient Warnings or Errors

Irrelevant Code

Struts: Unused Validation Form

Empty Code Block

Empty Exception Block

Empty Synchronized Block

Struts: Validator Without Form Field

Assignment to Variable without Use

Use of Prohibited Code

Use of Inherently Dangerous Function

Use of Potentially Dangerous Function

Use of Path Manipulation Function without Maximum-sized Buffer

Failure to Disable Reserved Bits

Reliance on Insufficiently Trustworthy Component

Use of Unmaintained Third Party Components

Reliance on Component That is Not Updateable

Firmware Not Updateable

Missing Ability to Patch ROM Code

NULL Pointer Dereference

Unchecked Return Value to NULL Pointer Dereference

Use of Obsolete Function

Omitted Break Statement in Switch

Active Debug Code

ASP.NET Misconfiguration: Creating Debug Binary

Expression is Always False

Expression is Always True

Improper Following of Specification by Caller

Struts: Incomplete validate() Method Definition

Struts: Form Bean Does Not Extend Validation Class

Creation of chroot Jail Without Changing Working Directory

Incorrect Check of Function Return Value

Improper Following of a Certificate's Chain of Trust

Missing Critical Step in Authentication

Missing Cryptographic Step

Generation of Predictable IV with CBC Mode

Improperly Implemented Security Check for Standard

Undefined Behavior for Input to API

finalize() Method Without super.finalize()

EJB Bad Practices: Use of Sockets

EJB Bad Practices: Use of Class Loader

J2EE Bad Practices: Non-serializable Object Stored in Session

clone() Method Without super.clone()

Object Model Violation: Just One of Equals and Hashcode Defined

Function Call with Incorrectly Specified Arguments

Function Call With Incorrectly Specified Argument Value

Use of umask() with chmod-style Argument

Function Call With Incorrect Argument Type

Function Call With Incorrect Variable or Reference as Argument

Function Call With Incorrect Order of Arguments

Function Call With Incorrect Number of Arguments

Multiple Operations on Resource in Single-Operation Context

Multiple Unlocks of a Critical Resource

Multiple Binds to the Same Port

Multiple Releases of Same Resource or Handle

Double Decoding of the Same Data

Multiple Locks of a Critical Resource

Use of Multiple Resources with Duplicate Identifier

Duplicate Key in Associative List (Alist)

Struts: Duplicate Validation Forms

Use of Low-Level Functionality

J2EE Bad Practices: Direct Use of Threads

Direct Use of Unsafe JNI

EJB Bad Practices: Use of Synchronization Primitives

EJB Bad Practices: Use of AWT Swing

J2EE Bad Practices: Direct Use of Sockets

EJB Bad Practices: Use of Java I/O

J2EE Bad Practices: Direct Management of Connections

J2EE Framework: Saving Unserializable Objects to Disk

Violation of Secure Design Principles

Improper Identifier for IP Block used in System-On-Chip (SOC),System-on-Chip (SoC) Using Components without Unique, Immutable Identifiers

Dependency on Vulnerable Third-Party Component

Execution with Unnecessary Privileges

Not Failing Securely ('Failing Open')

Non-exit on Failed Initialization

Unnecessary Complexity in Protection Mechanism (Not Using 'Economy of Mechanism')

Not Using Complete Mediation

Improper Protection of Alternate Path

Direct Request ('Forced Browsing')

Improper Isolation or Compartmentalization

Improper Isolation of Shared Resources in Network On Chip (NoC)

Improper Isolation of Shared Resources on System-on-a-Chip (SoC)

Non-Transparent Sharing of Microarchitectural Resources

Reliance on a Single Factor in a Security Decision

Use of Password System for Primary Authentication

Use of Single-factor Authentication

Insufficient Psychological Acceptability

Reliance on Security Through Obscurity

Lack of Administrator Control over Security

Unimplemented or Unsupported Feature in UI

Use of Hard-coded Credentials

Use of Hard-coded Password

Use of Hard-coded Cryptographic Key

Reliance on Undefined, Unspecified, or Implementation-Defined Behavior

Insecure Automated Optimizations

Compiler Optimization Removal or Modification of Security-critical Code

Compiler Removal of Code to Clear Buffers

Processor Optimization Removal or Modification of Security-critical Code

Reliance on Machine-Dependent Data Representation

Use of Platform-Dependent Third Party Components

Insufficient Encapsulation of Machine-Dependent Functionality

Reliance on Data/Memory Layout

Use of Incorrect Byte Ordering

Use of Function with Inconsistent Implementations

Call to Non-ubiquitous API

Return of Stack Variable Address

Assignment of a Fixed Address to a Pointer

Attempt to Access Child of a Non-structure Pointer