Browse cwe for c with official CWE context and Glexia analysis.
Search And Filters
Showing 50 of 857 CWE records · Page 12 of 18.
The product contains a conditional statement with multiple logical expressions in which one of the non-leading expressions may produce side effects. This may lead to an unexpected state in the program after the execution of the conditional, because short-circuiting logic may prevent the side effects from occurring.
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 properly maintain a reference to a resource that has been allocated, which prevents the resource from being reclaimed.
The product does not properly maintain references to a file descriptor or handle, which prevents that file descriptor/handle from being reclaimed.
The product allocates file descriptors or handles on behalf of an actor without imposing any restrictions on how many descriptors can be allocated, in violation of the intended security policy for that actor.
The product does not release a file descriptor or handle after its effective lifetime has ended, i.e., after the file descriptor/handle is no longer needed.
The product uses XML documents and allows their structure to be defined with a Document Type Definition (DTD), but it does not properly control the number of recursive definitions of entities.
The product uses a regular expression to perform neutralization, but the regular expression is not anchored and may allow malicious or malformed data to slip through.
When a security-critical event occurs, the product either does not record the event or omits important details about the event when logging it.
The product logs too much information, making log files hard to process and possibly hindering recovery efforts or forensic analysis after an attack.
The product uses the RSA algorithm but does not incorporate Optimal Asymmetric Encryption Padding (OAEP), which might weaken the encryption.
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 implements an IOCTL with functionality that should be restricted, but it does not properly enforce access control for the IOCTL.
The product uses an expression in which operator precedence causes incorrect logic to be used.
The product uses a protection mechanism that relies on the existence or values of a cookie, but it does not properly ensure that the cookie is valid for the associated user.
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 reads or writes to a buffer using an index or pointer that references a memory location prior to the beginning of the buffer.
The product writes data past the end, or before the beginning, of the intended buffer.
The product reads or writes to a buffer using an index or pointer that references a memory location after the end of the buffer.
The product allocates memory based on an untrusted, large size value, but it does not ensure that the size is within expected limits, allowing arbitrary amounts of memory to be allocated.
The product receives data from an upstream component, but does not filter or incorrectly filters special elements before sending it to a downstream component.
The product receives data from an upstream component, but does not completely filter special elements before sending it to a downstream component.
The product receives data from an upstream component, but does not completely filter one or more instances of special elements before sending it to a downstream component.
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 does not filter all instances 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 contains hard-coded credentials, such as a password or cryptographic key.
The product does not properly limit the number or frequency of interactions that it has with an actor, such as the number of incoming requests.
The product uses a CAPTCHA challenge, but the challenge can be guessed or automatically recognized by a non-human actor.
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.
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 uses a protection mechanism that relies on the existence or values of an input, but the input can be modified by an untrusted actor in a way that bypasses the protection mechanism.
The product utilizes a shared resource in a concurrent manner but does not attempt to synchronize access to the resource.
The product utilizes a shared resource in a concurrent manner, but it does not correctly synchronize access to the resource.
The product obtains a value from an untrusted source, converts this value to a pointer, and dereferences the resulting pointer.
The product performs pointer arithmetic on a valid pointer, but it uses an offset that can point outside of the intended range of valid memory locations for the resulting pointer.
The product accesses or uses a pointer that has not been initialized.
The product dereferences a pointer that contains a location for memory that was previously valid, but is no longer valid.
The product releases a resource that is still intended to be used by itself or another actor.
The product defines a signal handler that contains code sequences that are not asynchronous-safe, i.e., the functionality is not reentrant, or it can be interrupted.
The product imports, requires, or includes executable functionality (such as a library) from a source that is outside of the intended control sphere.
The product includes web functionality (such as a web widget) from another domain, which causes it to operate within the domain of the product, potentially granting total access and control of the product to the untrusted source.
The product defines a function that is used as a handler for more than one signal.
The product attempts to unlock a resource that is not locked.
The product contains multiple threads or executable segments that are waiting for each other to release a necessary lock, resulting in deadlock.
The product performs an iteration or loop without sufficiently limiting the number of times that the loop is executed.
The product contains an iteration or loop with an exit condition that cannot be reached, i.e., an infinite loop.
The product records password hashes in a data store, receives a hash of a password from a client, and compares the supplied hash to the hash obtained from the data store.
