Browse the Common Weakness Enumeration database. CWEs are a categorized list of software and hardware weakness types.
Top 50 CWEs by vulnerability count
CWE-1004VariantThe product uses a cookie to store sensitive information, but the cookie is not marked with the HttpOnly flag.
CWE-1007BaseThe product displays information or identifiers to a user, but the display mechanism does not make it easy for the user to distinguish between visually similar or identical glyphs (homoglyphs), which may cause the user to misinterpret a glyph and perform an unintended, insecure action.
CWE-102VariantThe product uses multiple Struts validation forms with the same name.
CWE-1021BaseThe web application does not restrict or incorrectly restricts frame objects or UI layers that belong to another application or domain.
CWE-1022VariantThe web application produces links to untrusted external sites outside of its sphere of control, but it does not properly prevent the external site from modifying security-critical properties of the window.opener object, such as the location property.
CWE-1023ClassThe product performs a comparison between entities that must consider multiple factors or characteristics of each entity, but the comparison does not include one or more of these factors.
CWE-1024ClassThe product performs a comparison between two entities, but the entities are of different, incompatible types that cannot be guaranteed to provide correct results when they are directly compared.
CWE-1025ClassThe code performs a comparison between two entities, but the comparison examines the wrong factors or characteristics of the entities.
CWE-103VariantThe product has a validator form that either does not define a validate() method, or defines a validate() method but does not call super.validate().
CWE-1037BaseThe developer builds a security-critical protection mechanism into the software, but the processor optimizes the execution of the program such that the mechanism is removed or modified.
CWE-1038ClassThe product uses a mechanism that automatically optimizes code, e.g. to improve a characteristic such as performance, but the optimizations can have an unintended side effect that might violate an intended security assumption.
CWE-1039ClassThe product uses an automated mechanism such as machine learning to recognize complex data inputs (e.g. image or audio) as a particular concept or category, but it does not properly detect or handle inputs that have been modified or constructed in a way that causes the mechanism to detect a different, incorrect concept.
CWE-104VariantIf a form bean does not extend an ActionForm subclass of the Validator framework, it can expose the application to other weaknesses related to insufficient input validation.
CWE-1041ClassThe product has multiple functions, methods, procedures, macros, etc. that contain the same code, i.e., the code has been copied or duplicated.
CWE-1042VariantThe code contains a member element that is declared as static (but not final), in which its parent class element is not a singleton class - that is, a class element that can be used only once in the 'to' association of a Create action.
CWE-1043BaseThe product uses a data element that has an excessively large number of sub-elements with non-primitive data types such as structures or aggregated objects.
CWE-1044BaseThe product's architecture contains too many - or too few - horizontal layers.
CWE-1045BaseA parent class has a virtual destructor method, but the parent has a child class that does not have a virtual destructor.
CWE-1046BaseThe product creates an immutable text string using string concatenation operations.
CWE-1047BaseThe product contains modules in which one module has references that cycle back to itself, i.e., there are circular dependencies.
CWE-1048BaseThe code contains callable control elements that contain an excessively large number of references to other application objects external to the context of the callable, i.e. a Fan-Out value that is excessively large.
CWE-1049BaseThe product performs a data query with a large number of joins and sub-queries on a large data table.
CWE-105VariantThe product has a form field that is not validated by a corresponding validation form, which can introduce other weaknesses related to insufficient input validation.
CWE-1050BaseThe product has a loop body or loop condition that contains a control element that directly or indirectly consumes platform resources, e.g. messaging, sessions, locks, or file descriptors.
CWE-1051BaseThe product initializes data using hard-coded values that act as network resource identifiers.
CWE-1052BaseThe product initializes a data element using a hard-coded literal that is not a simple integer or static constant element.
CWE-1053BaseThe product does not have documentation that represents how it is designed.
CWE-1054BaseThe code at one architectural layer invokes code that resides at a deeper layer than the adjacent layer, i.e., the invocation skips at least one layer, and the invoked code is not part of a vertical utility layer that can be referenced from any horizontal layer.
CWE-1055BaseThe product contains a class with inheritance from more than one concrete class.
CWE-1056BaseA named-callable or method control element has a signature that supports a variable (variadic) number of parameters or arguments.
CWE-1057BaseThe product uses a dedicated, central data manager component as required by design, but it contains code that performs data-access operations that do not use this data manager.
CWE-1058BaseThe code contains a function or method that operates in a multi-threaded environment but owns an unsafe non-final static storable or member data element.
CWE-1059ClassThe product does not contain sufficient technical or engineering documentation (whether on paper or in electronic form) that contains descriptions of all of the relevant software/hardware elements of the product.
CWE-106VariantWhen an application does not use an input validation framework such as the Struts Validator, there is a greater risk of introducing weaknesses related to insufficient input validation.
CWE-1060BaseThe product performs too many data queries without using efficient data processing functionality such as stored procedures.
CWE-1061ClassThe product does not sufficiently hide the internal representation and implementation details of data or methods.
CWE-1062BaseThe code has a parent class that contains references to a child class, its methods, or its members.
CWE-1063BaseA static code block creates an instance of a class.
CWE-1064BaseThe product contains a function, subroutine, or method whose signature has an unnecessarily large number of parameters/arguments.
CWE-1065BaseThe product uses deployed components from application servers, but it also uses low-level functions/methods for management of resources, instead of the API provided by the application server.
CWE-1066BaseThe product contains a serializable data element that does not have an associated serialization method.
CWE-1067BaseThe product contains a data query against an SQL table or view that is configured in a way that does not utilize an index and may cause sequential searches to be performed.
CWE-1068ClassThe implementation of the product is not consistent with the design as described within the relevant documentation.
CWE-1069VariantAn invokable code block contains an exception handling block that does not contain any code, i.e. is empty.
CWE-107VariantAn unused validation form indicates that validation logic is not up-to-date.
CWE-1070BaseThe product contains a serializable, storable data element such as a field or member, but the data element contains member elements that are not serializable.
CWE-1071BaseThe source code contains a block that does not contain any code, i.e., the block is empty.
CWE-1072BaseThe product accesses a data resource through a database without using a connection pooling capability.
CWE-1073BaseThe product contains a client with a function or method that contains a large number of data accesses/queries that are sent through a data manager, i.e., does not use efficient database capabilities.
CWE-1074BaseA class has an inheritance level that is too high, i.e., it has a large number of parent classes.