Quality Weaknesses with Indirect Security Impacts

The product is deployed to unauthorized actors with debugging code still enabled or active, which can create unintended entry points or expose sensitive information.

The product's architecture contains too many - or too few - horizontal layers.

The ASP.NET application does not use, or incorrectly uses, the model validation framework.

The ASP.NET application does not use an input validation framework.

The product sets a pointer to a specific address other than NULL or 0.

The variable's value is assigned but never used, making it a dead store.

The product uses an API function that does not exist on all versions of the target platform. This could cause portability problems or inconsistencies that allow denial...

The code contains a function or method whose signature and/or associated inline documentation does not sufficiently describe the callable's inputs, outputs, ...

The code contains a class instance that calls the method or function to delete or destroy itself.

A class contains an unnecessarily large number of children.

A class has an inheritance level that is too high, i.e., it has a large number of parent classes.

A class contains a virtual method, but the method does not have an associated virtual destructor.

The code is compiled without sufficient warnings enabled, which may prevent the detection of subtle bugs or quality issues.

A static code block creates an instance of a class.

The product creates an immutable text string using string concatenation operations.

The product declares a critical variable, field, or member to be public when intended security policy requires it to be private.

The product is intended to manage data access through a particular data manager component such as a relational or non-SQL database, but it contains code that performs ...

The product uses a dedicated, central data manager component as required by design, but it contains code that performs data-access operations that do not use this data...

The product uses a data element that has an excessively large number of sub-elements with non-primitive data types such as structures or aggregated objects.

The code contains a data element with a pointer that does not have an associated copy or constructor method.

The product accesses a data resource through a database without using a connection pooling capability.

The product contains dead code, which can never be executed.

The source code declares a variable in one scope, but the variable is only used within a narrower scope.

The source code contains a block that does not contain any code, i.e., the block is empty.

An invokable code block contains an exception handling block that does not contain any code, i.e. is empty.

The product contains an empty synchronized block.

The product has an attack surface whose quantitative measurement exceeds a desirable maximum.

The code is too complex, as calculated using a well-defined, quantitative measure.

The product performs a data query with a large number of joins and sub-queries on a large data table.

The product contains a data query against an SQL table or view that is configured in a way that does not utilize an index and may cause sequential searches t...

The code is structured in a way that a Halstead complexity measure exceeds a desirable maximum.

The product contains an index range scan for a large data table, but the scan can cover a large number of rows.

The code contains McCabe cyclomatic complexity that exceeds a desirable maximum.

The product performs too many data queries without using efficient data processing functionality such as stored procedures.

The product has a loop body or loop condition that contains a control element that directly or indirectly consumes platform resources, e.g. messaging, sessions, l...

The code is structured in a way that relies too much on using or setting global variables throughout various points in the code, instead of preserving the as...

The product initializes a data element using a hard-coded literal that is not a simple integer or static constant element.

The product uses too much self-modifying code.

The code uses too many unconditional branches (such as "goto").

The product uses an unnecessarily complex internal representation for its data structures or interrelationships between those structures.

The code contains a callable or other code grouping in which the nesting / branching is too deep.

The code performs a comparison such as an equality test between two float (floating point) values, but it uses comparison operators that do not account...

The product does not use, or incorrectly uses, an input validation framework that is provided by the source language or an independent library.

The source code contains comments that do not accurately describe or explain aspects of the portion of the code with which the comment is associated.

The source code uses comment styles or formats that are inconsistent or do not follow expected standards for the product.

The source code does not follow desired style or formatting for indentation, white space, comments, etc.

The source code contains whitespace that is inconsistent across the code or does not follow expected standards for the product.

The product's design documentation does not adequately describe control flow, data flow, system initialization, relationships between tasks, components, rati...

The document does not fully define all mechanisms that are used to control or influence how product-specific programs are executed.

The product's documentation does not adequately define inputs, outputs, or system/software interfaces.

The implementation of the product is not consistent with the design as described within the relevant documentation.

The product's code, documentation, or other artifacts do not consistently use the same naming conventions for variables, callables, groups of related callabl...

The code does not explicitly delimit a block that is intended to contain 2 or more statements, creating a logic error.

The code does not function according to its published specifications, potentially leading to incorrect usage.

The product performs CPU computations using algorithms that are not as efficient as they could be for the needs of the developer, i.e., the computati...

The product initializes data using hard-coded values that act as network resource identifiers.

The product's architecture, source code, design, documentation, or other artifact does not follow required conventions.

The documentation does not sufficiently describe the techniques that are used for error handling, exception processing, or similar mechanisms.

The product does not sufficiently hide the internal representation and implementation details of data or methods, which might allow external components or modules to m...

The product or code uses machine-dependent functionality, but it does not sufficiently encapsulate or isolate this functionality from the rest of the code.

The source code uses symbolic constants, but it does not sufficiently place the definitions of these constants into a more centralized or isolated location.

The product or code does not isolate system-dependent functionality into separate standalone modules.

The product does not contain sufficient technical or engineering documentation (whether on paper or in electronic form) that contains descriptions of...

The source code uses literal constants that may need to change or evolve over time, instead of using symbolic constants.

The code at one architectural layer invokes code that resides at a deeper layer than the adjacent layer, i.e., the invocation skips at least one layer, and t...

The code contains a function or method that operates in a multi-threaded environment but owns an unsafe non-final static storable or member d...

A function or method contains too many operations that utilize a data manager or file resource.

A function, method, procedure, etc. contains an excessive amount of code that has been commented out within its body.

The code contains callable control elements that contain an excessively large number of references to other application objects external to the conte...

The product contains a function, subroutine, or method whose signature has an unnecessarily large number of parameters/arguments.

A named-callable or method control element has a signature that supports a variable (variadic) number of parameters or arguments.

The product contains code that is not essential for execution, i.e. makes no state changes and has no side effects that alter data or control flow, such th...

When the J2EE container attempts to write unserializable objects to disk there is no guarantee that the process will complete successfully.

The product uses a large data table that contains an excessively large number of indices.

The product uses a loop with a control flow condition based on a value that is updated within the body of the loop.

A method for a class performs an operation that directly accesses a member element from another class.

The product does not have documentation that represents how it is designed.

The product contains a serializable data element that does not have an associated serialization method.

The product contains modules in which one module has references that cycle back to itself, i.e., there are circular dependencies.

The product contains a class with inheritance from more than one concrete class.

The product contains a client with a function or method that contains a large number of data accesses/queries that are sent through a data manager, i.e., does not use ...

The product omits a break statement within a switch or similar construct, causing code associated with multiple conditions to execute. This can cause problems when the...

A parent class has a virtual destructor method, but the parent has a child class that does not have a virtual destructor.

The code has a parent class that contains references to a child class, its methods, or its members.

A parent class contains one or more child classes, but the parent class does not have a virtual destructor method.

The product uses a storable data element that does not have all of the associated functions or methods that are necessary to support comparison.

The product is built from multiple separate components, but it uses a component that is not sufficiently trusted to meet expectations for security, reliability, update...

The code uses a data representation that relies on low-level data representation or constructs that may vary across different processors, physical machines, ...

The product uses automatically-generated code that cannot be executed without a specific runtime support component.

The product uses an API function, data structure, or other entity in a way that relies on properties that are not always guaranteed to hold for that entity.

A function returns the address of a stack variable, which will cause unintended program behavior, typically in the form of a crash.

The product uses deployed components from application servers, but it also uses low-level functions/methods for management of resources, instead of the API provided by...

The product contains a serializable, storable data element such as a field or member, but the data element contains member elements that are not serializable.

The product implements a Singleton design pattern but does not use appropriate locking or other synchronization mechanism to ensure that the singleton class is only in...

The source code contains elements such as source files that do not consistently provide a prologue or header that has been standardized for the project.

A source code file has too many lines of code.

The code contains a member element that is declared as static (but not final), in which its parent class element is not a singleton class - that is, a class...

The code contains comments that suggest the presence of bugs, incomplete functionality, or weaknesses.

The code has a synchronous call to a remote resource, but there is no timeout for the call, or the timeout is set to infinite.

The product performs unconditional control transfer (such as a "goto") in code outside of a branching structure such as a switch block.

The behavior of this function is undefined unless its control parameter is set to a specific value.

The code uses a function that has inconsistent implementations across operating systems and versions.

The product uses hard-coded constants instead of symbolic names for security-critical values, which increases the likelihood of mistakes during code maintenance or sec...

The product contains a method that accesses an object but does not later invoke the element's associated finalize/destructor method.

The code uses deprecated or obsolete functions, which suggests that the code has not been actively reviewed or maintained.

The product relies on third-party components that do not provide equivalent functionality across all desirable platforms.

The product invokes a potentially dangerous function that could introduce a vulnerability if it is used incorrectly, but the function can also be used safely.

The product uses a function, library, or third party component that has been explicitly prohibited, whether by the developer or the customer.

The product has multiple functions, methods, procedures, macros, etc. that contain the same code.

The product uses the same control element across multiple architectural layers.

The code contains a callable, block, or other code element in which the same variable is used to control more than one unique task or store more than one ins...

The product relies on third-party components that are not actively supported or maintained by the original developer or a trusted proxy for the original deve...