Browse cwe in architecture and design with official CWE context and Glexia analysis.
Search And Filters
Showing 50 of 379 CWE records · Page 2 of 8.
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 inserts sensitive information into debugging code, which could expose this information if the debugging code is not disabled in production.
The product releases a resource such as memory or a file so that it can be made available for reuse, but it does not clear or "zeroize" the information contained in the resource before the product performs a critical state transition or makes the resource available for reuse by other entities.
The J2EE application directly uses sockets instead of using framework method calls.
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.
The product incorrectly checks a return value from a function, which prevents it from detecting errors or exceptional conditions.
The product stores a password in plaintext within resources such as memory or files.
The storage of passwords in a recoverable format makes them subject to password reuse attacks by malicious users. In fact, it should be noted that recoverable encrypted passwords provide no significant benefit over plaintext passwords since they are subject not only to reuse by malicious attackers but also by malicious insiders. If a system administrator can recover a password directly, or use a brute force search on the available information, the administrator can use the password on other accounts.
The product contains a hard-coded password, which it uses for its own inbound authentication or for outbound communication to external components.
The product stores a password in a configuration file that might be accessible to actors who do not know the password.
The product does not have a mechanism in place for managing password aging.
The product supports password aging, but the expiration period is too long.
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.
The product attempts to drop privileges but does not check or incorrectly checks to see if the drop succeeded.
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 does not handle or incorrectly handles when it has insufficient privileges to access resources or functionality as specified by their permissions. This may cause it to follow unexpected code paths that may leave the product in an invalid state.
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 product does not perform or incorrectly performs an authorization check when an actor attempts to access a resource or perform an action.
When an actor claims to have a given identity, the product does not prove or insufficiently proves that the claim is correct.
The product requires authentication, but the product has an alternate path or channel that does not require authentication.
The product performs authentication based on the name of a resource being accessed, or the name of the actor performing the access, but it does not properly check all possible names for that resource or actor.
The product uses an IP address for authentication.
The referer field in HTTP requests can be easily modified and, as such, is not a valid means of message integrity checking.
A capture-replay flaw exists when the design of the product makes it possible for a malicious user to sniff network traffic and bypass authentication by replaying it to the server in question to the same effect as the original message (or with minor changes).
The product does not validate, or incorrectly validates, a certificate.
The product does not follow, or incorrectly follows, the chain of trust for a certificate back to a trusted root certificate.
The product communicates with a host that provides a certificate, but the product does not properly ensure that the certificate is actually associated with that host.
A certificate expiration is not validated or is incorrectly validated.
The product does not check or incorrectly checks the revocation status of a certificate, which may cause it to use a certificate that has been compromised.
The product does not adequately verify the identity of actors at both ends of a communication channel, or does not adequately ensure the integrity of the channel, in a way that allows the channel to be accessed or influenced by an actor that is not an endpoint.
Simple authentication protocols are subject to reflection attacks if a malicious user can use the target machine to impersonate a trusted user.
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 does not implement sufficient measures to prevent multiple failed authentication attempts within a short time frame.
The product uses an authentication algorithm that uses a single factor (e.g., a password) in a security context that should require more than one factor.
The use of password systems as the primary means of authentication may be subject to several flaws or shortcomings, each reducing the effectiveness of the mechanism.
The product does not encrypt sensitive or critical information before storage or transmission.
The product transmits sensitive or security-critical data in cleartext in a communication channel that can be sniffed by unauthorized actors.
The product uses a hard-coded, unchangeable cryptographic key.
