Browse cwe in requirements with official CWE context and Glexia analysis.
Search And Filters
Showing 50 of 65 CWE records · Page 1 of 2.
The product constructs all or part of a command, data structure, or record using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify how it is parsed or interpreted when it is sent to a downstream component.
The product does not adequately filter user-controlled input for special elements with control implications.
The product correctly neutralizes certain special elements, but it improperly neutralizes equivalent special elements.
The product prepares a structured message for communication with another component, but encoding or escaping of the data is either missing or done incorrectly. As a result, the intended structure of the message is not preserved.
The product performs operations on a memory buffer, but it reads from or writes to a memory location outside the buffer's intended boundary. This may result in read or write operations on unexpected memory locations that could be linked to other variables, data structures, or internal program data.
The product copies an input buffer to an output buffer without verifying that the size of the input buffer is less than the size of the output buffer.
The product writes to a buffer using an index or pointer that references a memory location prior to the beginning of the buffer.
Wrap around errors occur whenever a value is incremented past the maximum value for its type and therefore "wraps around" to a very small, negative, or undefined value.
The product uses untrusted input when calculating or using an array index, but the product does not validate or incorrectly validates the index to ensure the index references a valid position within the array.
The product uses a function that accepts a format string as an argument, but the format string originates from an external source.
The product does not terminate or incorrectly terminates a string or array with a null character or equivalent terminator.
The product performs a calculation that can produce an integer overflow or wraparound when the logic assumes that the resulting value will always be larger than the original value. This occurs when an integer value is incremented to a value that is too large to store in the associated representation. When this occurs, the value may become a very small or negative number.
Integer coercion refers to a set of flaws pertaining to the type casting, extension, or truncation of primitive data types.
The product uses an unsigned primitive and performs a cast to a signed primitive, which can produce an unexpected value if the value of the unsigned primitive can not be represented using a signed primitive.
The code transmits data to another actor, but a portion of the data includes sensitive information that should not be accessible to that actor.
The product stores, transfers, or shares a resource that contains sensitive information, but it does not properly remove that information before the product makes the resource available to unauthorized actors.
The product does not encrypt sensitive or critical information before storage or transmission.
The product uses insufficiently random numbers or values in a security context that depends on unpredictable numbers.
The lack of entropy available for, or used by, a Pseudo-Random Number Generator (PRNG) can be a stability and security threat.
The number of possible random values is smaller than needed by the product, making it more susceptible to brute force attacks.
A Pseudo-Random Number Generator (PRNG) uses the same seed each time the product is initialized.
A Pseudo-Random Number Generator (PRNG) is initialized from a predictable seed, such as the process ID or system time.
A Pseudo-Random Number Generator (PRNG) uses a relatively small seed space, which makes it more susceptible to brute force attacks.
A number or object is predictable based on observations that the attacker can make about the state of the system or network, such as time, process ID, etc.
An exact value or random number can be precisely predicted by observing previous values.
The product's random number generator produces a series of values which, when observed, can be used to infer a relatively small range of possibilities for the next value that could be generated.
The product does not properly prevent a person's private, personal information from being accessed by actors who either (1) are not explicitly authorized to access the information or (2) do not have the implicit consent of the person about whom the information is collected.
The product uses a signal handler that introduces a race condition.
Opening temporary files without appropriate measures or controls can leave the file, its contents and any function that it impacts vulnerable to attack.
The product creates a temporary file in a directory whose permissions allow unintended actors to determine the file's existence or otherwise access that file.
[PLANNED FOR DEPRECATION. SEE MAINTENANCE NOTES AND CONSIDER CWE-252, CWE-248, OR CWE-1069.] Ignoring exceptions and other error conditions may allow an attacker to induce unexpected behavior unnoticed.
The product does not release or incorrectly releases a resource before it is made available for re-use.
The product does not initialize critical variables, which causes the execution environment to use unexpected values.
The code uses a variable that has not been initialized, leading to unpredictable or unintended results.
A PHP application does not properly protect against the modification of variables from external sources, such as query parameters or cookies. This can expose the application to numerous weaknesses that would not exist otherwise.
The code uses a function that has inconsistent implementations across operating systems and versions.
The product dereferences a pointer that it expects to be valid but is NULL.
The code uses deprecated or obsolete functions, which suggests that the code has not been actively reviewed or maintained.
The product defines a signal handler that calls a non-reentrant function.
The product does not mask passwords during entry, increasing the potential for attackers to observe and capture passwords.
Using Hibernate to execute a dynamic SQL statement built with user-controlled input can allow an attacker to modify the statement's meaning or to execute arbitrary SQL commands.
Casting a non-structure type to a structure type and accessing a field can lead to memory access errors or data corruption.
The product does not initialize or incorrectly initializes a resource, which might leave the resource in an unexpected state when it is accessed or used.
The product does not check or incorrectly checks for unusual or exceptional conditions that are not expected to occur frequently during day to day operation of the product.
The product allocates a reusable resource or group of resources on behalf of an actor without imposing any intended restrictions on the size or number of resources that can be allocated.
The product does not release a resource after its effective lifetime has ended, i.e., after the resource is no longer needed.
The product writes data past the end, or before the beginning, of the intended buffer.
The product uses a sequential operation to read or write a buffer, but it uses an incorrect length value that causes it to access memory that is outside of the bounds of the buffer.
To fulfill the need for a cryptographic primitive, the product implements a cryptographic algorithm using a non-standard, unproven, or disallowed/non-compliant cryptographic implementation.
The product does not provide its users with the ability to update or patch its firmware to address any vulnerabilities or weaknesses that may be present.
