Browse cwe for c with official CWE context and Glexia analysis.
Search And Filters
Showing 50 of 857 CWE records · Page 7 of 18.
The product does not properly determine which state it is in, causing it to assume it is in state X when in fact it is in state Y, causing it to perform incorrect operations in a security-relevant manner.
The product sends non-cloned mutable data as an argument to a method or function.
Sending non-cloned mutable data as a return value may result in that data being altered or deleted by the calling function.
Creating and using insecure temporary files can leave application and system data vulnerable to attack.
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.
Authenticating a user, or otherwise establishing a new user session, without invalidating any existing session identifier gives an attacker the opportunity to steal authenticated sessions.
Covert timing channels convey information by modulating some aspect of system behavior over time, so that the program receiving the information can observe system behavior and infer protected information.
A constant symbolic reference to an object is used, even though the reference can resolve to a different object over time.
The product detects a specific error, but takes no actions to handle the error.
[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 encounters an error but does not provide a status code or return value to indicate that an error has occurred.
A function or operation returns an incorrect return value or status code that does not indicate the true result of execution, causing the product to modify its behavior based on the incorrect result.
The product does not properly check when a function or operation returns a value that is legitimate for the function, but is not expected by the product.
Catching overly broad exceptions promotes complex error handling code that is more likely to contain security vulnerabilities.
The product throws or raises an overly broad exceptions that can hide important details and produce inappropriate responses to certain conditions.
The product does not properly control the allocation and maintenance of a limited resource.
The product does not sufficiently track and release allocated memory after it has been used, making the memory unavailable for reallocation and reuse.
The product makes resources available to untrusted parties when those resources are only intended to be accessed by the product.
A process does not close sensitive file descriptors before invoking a child process, which allows the child to perform unauthorized I/O operations using those descriptors.
The product does not release or incorrectly releases a resource before it is made available for re-use.
The product does not properly control situations in which an adversary can cause the product to consume or produce excessive resources without requiring the adversary to invest equivalent work or otherwise prove authorization, i.e., the adversary's influence is "asymmetric."
The product does not sufficiently monitor or control transmitted network traffic volume, so that an actor can cause the product to transmit more traffic than should be allowed for that actor.
An algorithm in a product has an inefficient worst-case computational complexity that may be detrimental to system performance and can be triggered by an attacker, typically using crafted manipulations that ensure that the worst case is being reached.
The product allows an entity to perform a legitimate but expensive operation before authentication or authorization has taken place.
The product does not handle or incorrectly handles a compressed input with a very high compression ratio that produces a large output.
The product's resource pool is not large enough to handle peak demand, which allows an attacker to prevent others from accessing the resource by using a (relatively) large number of requests for resources.
The product properly checks for the existence of a lock, but the lock can be externally controlled or influenced by an actor that is outside of the intended sphere of control.
The product does not lock or does not correctly lock a resource when the product must have exclusive access to the resource.
A product does not check to see if a lock is present before performing sensitive operations on a resource.
The product calls free() twice on the same memory address.
The product reuses or references memory after it has been freed. At some point afterward, the memory may be allocated again and saved in another pointer, while the original pointer references a location somewhere within the new allocation. Any operations using the original pointer are no longer valid because the memory "belongs" to the code that operates on the new pointer.
The product uses a primary channel for administration or restricted functionality, but it does not properly protect the channel.
The product protects a primary channel, but it does not use the same level of protection for an alternate channel.
The product opens an alternate channel to communicate with an authorized user, but the channel is accessible to other actors.
The product does not properly verify the source of a message in the Windows Messaging System while running at elevated privileges, creating an alternate channel through which an attacker can directly send a message to the product.
The product does not sufficiently protect all possible paths that a user can take to access restricted functionality or resources.
The web application does not adequately enforce appropriate authorization on all restricted URLs, scripts, or files.
The product searches for critical resources using an externally-supplied search path that can point to resources that are not under the product's direct control.
The product uses a fixed or controlled search path to find resources, but one or more locations in that path can be under the control of unintended actors.
The product uses a search path that contains an unquoted element, in which the element contains whitespace or other separators. This can cause the product to access resources in a parent path.
The wrong "handler" is assigned to process an object.
A handler is not available or implemented.
The product uses a signal handler that shares state with other signal handlers, but it does not properly mask or prevent those signal handlers from being invoked while the original signal handler is still running.
The product stores raw content or supporting code under the web document root with an extension that is not specifically handled by the server.
The product allows the upload or transfer of dangerous file types that are automatically processed within its environment.
An interaction error occurs when two entities have correct behavior when running independently of each other, but when they are integrated as components in a larger system or process, they introduce incorrect behaviors that may cause resultant weaknesses.
Product A handles inputs or steps differently than Product B, which causes A to perform incorrect actions based on its perception of B's state.
A product acts as an intermediary or monitor between two or more endpoints, but it does not have a complete model of an endpoint's features, behaviors, or state, potentially causing the product to perform incorrect actions based on this incomplete model.
A's behavior or functionality changes with a new version of A, or a new environment, which is not known (or manageable) by B.
