Browse cwe in operation with official CWE context and Glexia analysis.
Search And Filters
Showing 50 of 91 CWE records · Page 1 of 2.
The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory.
The product uses external input to construct a pathname that should be within a restricted directory, but it does not properly neutralize sequences such as ".." that can resolve to a location that is outside of that directory.
The product uses external input to construct a pathname that should be within a restricted directory, but it does not properly neutralize absolute path sequences such as "/abs/path" that can resolve to a location that is outside of that directory.
The product allows user input to control or influence paths or file names that are used in filesystem operations.
The product constructs all or part of a command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended command when it is sent to a downstream component.
The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component.
The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users.
The product constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. Without sufficient removal or quoting of SQL syntax in user-controllable inputs, the generated SQL query can cause those inputs to be interpreted as SQL instead of ordinary user data.
The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the syntax or behavior of the intended code segment.
The PHP application receives input from an upstream component, but it does not restrict or incorrectly restricts the input before its usage in "require," "include," or similar functions.
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.
A stack-based buffer overflow condition is a condition where the buffer being overwritten is allocated on the stack (i.e., is a local variable or, rarely, a parameter to a function).
A heap overflow condition is a buffer overflow, where the buffer that can be overwritten is allocated in the heap portion of memory, generally meaning that the buffer was allocated using a routine such as malloc().
Any condition where the attacker has the ability to write an arbitrary value to an arbitrary location, often as the result of a buffer overflow.
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 does not correctly calculate the size to be used when allocating a buffer, which could lead to a buffer overflow.
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 performs an operation at a privilege level that is higher than the minimum level required, which creates new weaknesses or amplifies the consequences of other weaknesses.
A product incorrectly assigns a privilege to a particular actor, creating an unintended sphere of control for that actor.
A particular privilege, role, capability, or right can be used to perform unsafe actions that were not intended, even when it is assigned to the correct entity.
Two distinct privileges, roles, capabilities, or rights can be combined in a way that allows an entity to perform unsafe actions that would not be allowed without that combination.
The product does not properly assign, modify, track, or check privileges for an actor, creating an unintended sphere of control for that actor.
The product does not properly manage privileges while it is switching between different contexts that have different privileges or spheres of control.
The product does not drop privileges before passing control of a resource to an actor that does not have those privileges.
The elevated privilege level required to perform operations such as chroot() should be dropped immediately after the operation is performed.
During installation, installed file permissions are set to allow anyone to modify those files.
A product defines a set of insecure permissions that are inherited by objects that are created by the program.
A product inherits a set of insecure permissions for an object, e.g. when copying from an archive file, without user awareness or involvement.
While it is executing, the product sets the permissions of an object in a way that violates the intended permissions that have been specified by the user.
The product assigns the wrong ownership, or does not properly verify the ownership, of an object or resource.
The product does not properly verify that a critical resource is owned by the proper entity.
The product does not restrict or incorrectly restricts access to a resource from an unauthorized actor.
The authentication scheme or implementation uses key data elements that are assumed to be immutable, but can be controlled or modified by the attacker.
The product does not perform any authentication for functionality that requires a provable user identity or consumes a significant amount of resources.
The product stores sensitive information in cleartext within a resource that might be accessible to another control sphere.
The product transmits sensitive or security-critical data in cleartext in a communication channel that can be sniffed by unauthorized actors.
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 contains a concurrent code sequence that requires temporary, exclusive access to a shared resource, but a timing window exists in which the shared resource can be modified by another code sequence operating concurrently.
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.
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 web application does not adequately enforce appropriate authorization on all restricted URLs, scripts, or files.
The product allows the upload or transfer of dangerous file types that are automatically processed within its environment.
The code uses a variable that has not been initialized, leading to unpredictable or unintended results.
The accidental deletion of a data-structure sentinel can cause serious programming logic problems.
The accidental addition of a data-structure sentinel can cause serious programming logic problems.
The product does not properly protect an assumed-immutable element from being modified by an attacker.
The product downloads source code or an executable from a remote location and executes the code without sufficiently verifying the origin and integrity of the code.
The product deserializes untrusted data without sufficiently ensuring that the resulting data will be valid.
The product contains code that appears to be malicious in nature.
