Common Weakness Enumeration (CWE)

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

The product does not properly maintain references to a file descriptor or handle, which prevents that file descriptor/handle from being reclaimed.

The product defines an IOCTL that uses METHOD_NEITHER for I/O, but it does not validate or incorrectly validates the addresses that are provided.

The product invokes a function for normalizing paths or file names, but it provides an output buffer that is smaller than the maximum possible size, such as PATH_MAX.

The product receives data from an upstream component, but only filters a single instance of a special element before sending it to a downstream component.

The product receives data from an upstream component, but only accounts for special elements at a specified location, thereby missing remaining special elements that may exist before sending it to a downstream component.

The product receives data from an upstream component, but only accounts for special elements positioned relative to a marker (e.g. "at the beginning/end of a string; the second argument"), thereby missing remaining special elements that may exist before sending it to a downstream component.

The product receives data from an upstream component, but only accounts for special elements at an absolute position (e.g. "byte number 10"), thereby missing remaining special elements that may exist before sending it to a downstream component.

The product uses the size of a source buffer when reading from or writing to a destination buffer, which may cause it to access memory that is outside of the bounds of the buffer.

The product defines a function that is used as a handler for more than one signal.

The product has multiple functions, methods, procedures, macros, etc. that contain the same 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 element that can be used only once in the 'to' association of a Create action.

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 product's architecture contains too many - or too few - horizontal layers.

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

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

The code contains callable control elements that contain an excessively large number of references to other application objects external to the context of the callable, i.e. a Fan-Out value that is excessively large.

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

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

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 the invoked code is not part of a vertical utility layer that can be referenced from any horizontal layer.

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

The product does not sufficiently hide the internal representation and implementation details of data or methods, which might allow external components or modules to modify data unexpectedly, invoke unexpected functionality, or introduce dependencies that the programmer did not intend.

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

A static code block creates an instance of a class.

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