Vulnerability Database
Every documented weakness class (CWE), sorted by CWE number.
- CWE-556: ASP.NET Misconfiguration: Use of Identity ImpersonationASP.NET Misconfiguration: Use of Identity Impersonation is a vulnerability where an ASP.NET application is configured to run with impersonated
- CWE-558: Use of getlogin() in Multithreaded ApplicationUse of getlogin() in Multithreaded Application is a vulnerability where a program uses the getlogin() function in a multithreaded context,
- CWE-560: Use of umask() with chmod-style ArgumentUse of umask() with chmod-style Argument is a vulnerability where a program incorrectly calls the umask() function with an argument specified as if
- CWE-561: Dead CodeDead Code refers to code that exists in a program but can never be executed, or code whose results are never used.
- CWE-562: Return of Stack Variable AddressReturn of Stack Variable Address occurs when a function returns a pointer or reference to a local variable that ceases to exist when the function
- CWE-563: Assignment to Variable without UseAssignment to Variable without Use occurs when a variable is assigned a value that is never subsequently read or used before being overwritten or
- CWE-564: SQL Injection: HibernateSQL Injection: Hibernate is a vulnerability where an application uses Hibernate ORM to execute dynamic SQL or HQL (Hibernate Query Language)
- CWE-565: Reliance on Cookies without Validation and Integrity CheckingReliance on Cookies without Validation and Integrity Checking is a vulnerability where a web application depends on the existence, format, or values
- CWE-566: Authorization Bypass Through User-Controlled SQL Primary KeyAuthorization Bypass Through User-Controlled SQL Primary Key is a vulnerability where an application allows users to specify primary key values used
- CWE-567: Unsynchronized Access to Shared Data in a Multithreaded ContextUnsynchronized Access to Shared Data in a Multithreaded Context is a vulnerability where a product fails to properly synchronize access to shared
- CWE-568: finalize() Method Without super.finalize()finalize() Method Without super.finalize() is a vulnerability in Java where a class overrides the finalize() method but fails to call
- CWE-570: Expression is Always FalseExpression is Always False occurs when a conditional expression evaluates to false under all possible circumstances due to logical contradictions,
- CWE-571: Expression is Always TrueExpression is Always True occurs when a conditional expression evaluates to true under all possible circumstances. This is the counterpart to CWE-570.
- CWE-572: Call to Thread run() Instead of start()Call to Thread run() Instead of start() is a programming error in Java where developers mistakenly invoke the run() method directly on a Thread
- CWE-573: Improper Following of Specification by CallerImproper Following of Specification by Caller is a vulnerability where a product fails to adhere to or incorrectly follows the specifications
- CWE-574: EJB Bad Practices: Use of Synchronization PrimitivesEJB Bad Practices: Use of Synchronization Primitives is a vulnerability where an Enterprise JavaBean (EJB) violates the EJB specification by
- CWE-575: EJB Bad Practices: Use of AWT/SwingEJB Bad Practices: Use of AWT/Swing is a vulnerability where an Enterprise JavaBean violates the EJB specification by incorporating AWT (Abstract
- CWE-576: EJB Bad Practices: Use of Java I/OEJB Bad Practices: Use of Java I/O is a vulnerability where an Enterprise JavaBean violates the EJB specification by utilizing the java.io package to
- CWE-577: EJB Bad Practices: Use of SocketsEJB Bad Practices: Use of Sockets is a vulnerability where an Enterprise JavaBean violates the EJB specification by utilizing socket operations for
- CWE-578: EJB Bad Practices: Use of Class LoaderEJB Bad Practices: Use of Class Loader is a vulnerability where an Enterprise JavaBean violates the EJB specification by directly using class loader
- CWE-579: J2EE Bad Practices: Non-serializable Object Stored in SessionJ2EE Bad Practices: Non-serializable Object Stored in Session is a vulnerability where a Java web application stores objects that do not implement
- CWE-580: clone() Method Without super.clone()clone() Method Without super.clone() is a programming error in Java where a class implements the clone() method but fails to call super.clone() when
- CWE-581: Object Model Violation: Just One of Equals and Hashcode DefinedObject Model Violation: Just One of Equals and Hashcode Defined is a Java programming error where a class overrides either the equals() method or the
- CWE-582: Array Declared Public, Final, and StaticArray Declared Public, Final, and Static is a security vulnerability in Java where a class declares an array with the modifiers public, static, and
- CWE-583: finalize() Method Declared Publicfinalize() Method Declared Public is a security vulnerability in Java where a class declares its finalize() method with public access instead of the
- CWE-584: Return Inside Finally BlockReturn Inside Finally Block is a programming error where a return statement is placed inside a finally block.
- CWE-585: Empty Synchronized BlockEmpty Synchronized Block is a code quality weakness in Java where a synchronized block contains no executable statements.
- CWE-586: Explicit Call to Finalize()Explicit Call to Finalize() is a code quality weakness in Java where application code directly calls the finalize() method on an object instead of
- CWE-587: Assignment of a Fixed Address to a PointerAssignment of a Fixed Address to a Pointer occurs when code assigns a hardcoded memory address to a pointer variable and then uses that pointer to
- CWE-588: Attempt to Access Child of a Non-structure PointerAttempt to Access Child of a Non-structure Pointer occurs when code treats a pointer to a non-structure type as if it were a pointer to a structure
- CWE-589: Call to Non-ubiquitous APICall to Non-ubiquitous API is a weakness where a product uses an API function that does not exist on all versions of the target platform or operating
- CWE-590: Free of Memory not on the HeapFree of Memory not on the Heap occurs when code attempts to free memory that was not dynamically allocated via malloc, calloc, realloc, or equivalent
- CWE-591: Sensitive Data Storage in Improperly Locked MemorySensitive Data Storage in Improperly Locked Memory occurs when an application stores sensitive information (passwords, cryptographic keys, PII) in
- CWE-593: Authentication Bypass: OpenSSL CTX Object Modified after SSL Objects are CreatedAuthentication Bypass: OpenSSL CTX Object Modified after SSL Objects are Created occurs when an application modifies SSLCTX security settings (like
- CWE-594: J2EE Framework: Saving Unserializable Objects to DiskJ2EE Framework: Saving Unserializable Objects to Disk occurs when a J2EE application attempts to persist session data or other objects that don't
- CWE-595: Comparison of Object References Instead of Object ContentsComparison of Object References Instead of Object Contents occurs when code uses reference equality operators (== or !=) to compare objects when it
- CWE-597: Use of Wrong Operator in String ComparisonUse of Wrong Operator in String Comparison occurs when code uses identity operators (==, ===, is) instead of equality methods to compare strings.
- CWE-598: Use of GET Request Method With Sensitive Query StringsUse of GET Request Method With Sensitive Query Strings occurs when an application transmits sensitive information (passwords, tokens, session IDs,
- CWE-599: Missing Validation of OpenSSL CertificateMissing Validation of OpenSSL Certificate occurs when an application using OpenSSL fails to properly verify SSL/TLS certificates during secure
- CWE-600: Uncaught Exception in ServletUncaught Exception in Servlet occurs when a Java servlet allows exceptions to propagate beyond the servlet code without being caught and handled.
- CWE-601: URL Redirection to Untrusted Site ('Open Redirect')URL Redirection to Untrusted Site occurs when a web application accepts a user-controlled input that specifies a link to an external site and uses
- CWE-602: Client-Side Enforcement of Server-Side SecurityClient-Side Enforcement of Server-Side Security occurs when an application relies on client-side code (JavaScript, mobile app, desktop application)
- CWE-603: Use of Client-Side AuthenticationUse of Client-Side Authentication occurs when an application performs authentication or credential verification primarily or exclusively on the
- CWE-611: Improper Restriction of XML External Entity ReferenceImproper Restriction of XML External Entity Reference (XXE) occurs when XML input containing a reference to an external entity is processed by a
- CWE-612: Improper Authorization of Index Containing Sensitive InformationImproper Authorization of Index Containing Sensitive Information occurs when an application creates or exposes search indexes, database indexes, or
- CWE-613: Insufficient Session ExpirationInsufficient Session Expiration occurs when a web application permits an attacker to reuse old session credentials or session IDs for authorization.
- CWE-614: Sensitive Cookie in HTTPS Session Without 'Secure' AttributeSensitive Cookie in HTTPS Session Without 'Secure' Attribute occurs when a cookie containing sensitive data (such as session tokens, authentication
- CWE-615: Inclusion of Sensitive Information in Source Code CommentsInclusion of Sensitive Information in Source Code Comments occurs when developers leave sensitive information in code comments that get deployed to
- CWE-616: Incomplete Identification of Uploaded File Variables (PHP)Incomplete Identification of Uploaded File Variables occurs in PHP applications when file upload handling code doesn't properly validate all aspects
- CWE-617: Reachable AssertionReachable Assertion occurs when a product contains an assert() or similar statement that can be triggered by an attacker, leading to an application
- CWE-618: Exposed Unsafe ActiveX MethodExposed Unsafe ActiveX Method is a vulnerability where an ActiveX control designed for use in web browsers exposes dangerous methods that perform
- CWE-619: Dangling Database Cursor (Cursor Injection)Dangling Database Cursor occurs when a database cursor is left open after its intended use, or when cursor references can be manipulated by attackers.
- CWE-620: Unverified Password ChangeUnverified Password Change occurs when an application allows users to change their password without verifying they are the legitimate account owner.
- CWE-621: Variable Extraction ErrorVariable Extraction Error occurs when applications use functions that automatically create variables from external input without proper validation.
- CWE-622: Improper Validation of Function Hook ArgumentsImproper Validation of Function Hook Arguments occurs when an application allows external code to register hooks or callbacks but doesn't properly
- CWE-623: Unsafe ActiveX Control Marked Safe For ScriptingUnsafe ActiveX Control Marked Safe For Scripting occurs when an ActiveX control that performs potentially dangerous operations (file system access,
- CWE-624: Executable Regular Expression ErrorExecutable Regular Expression Error occurs when applications use regular expression engines that allow executable code within patterns.
- CWE-625: Permissive Regular ExpressionPermissive Regular Expression occurs when a regex pattern intended for input validation is too lenient, allowing inputs that should be rejected.
- CWE-626: Null Byte Interaction Error (Poison Null Byte)Null Byte Interaction Error occurs when applications process user input containing null bytes (\x00) that cause string handling discrepancies between
- CWE-627: Dynamic Variable EvaluationDynamic Variable Evaluation occurs when applications use variable names derived from user input to access or modify variables dynamically.
- CWE-628: Function Call with Incorrectly Specified ArgumentsFunction Call with Incorrectly Specified Arguments occurs when a function is called with arguments that don't match the expected parameters in type,
- CWE-636: Not Failing Securely (Failing Open)Not Failing Securely occurs when an application responds to errors or exceptions by defaulting to an insecure state rather than a secure one.
- CWE-637: Unnecessary Complexity in Protection Mechanism (Unnecessary Indirection)Unnecessary Complexity in Protection Mechanism occurs when security controls are implemented with excessive indirection, layers, or complexity that
- CWE-638: Not Using Complete MediationNot Using Complete Mediation occurs when a system fails to check authorization for every access to a protected resource.
- CWE-639: Authorization Bypass Through User-Controlled KeyAuthorization Bypass Through User-Controlled Key occurs when the system's authorization functionality does not prevent one user from accessing
- CWE-640: Weak Password Recovery Mechanism for Forgotten PasswordWeak Password Recovery Mechanism for Forgotten Password occurs when an application implements a password recovery process that is susceptible to
- CWE-641: Improper Restriction of Names for Files and Other ResourcesImproper Restriction of Names for Files and Other Resources occurs when an application creates files, directories, database tables, or other
- CWE-642: External Control of Critical State DataExternal Control of Critical State Data occurs when security-critical application state (user roles, permissions, session data, authentication
- CWE-643: Improper Neutralization of Data within XPath Expressions (XPath Injection)XPath Injection occurs when user-supplied data is incorporated into XPath queries without proper sanitization.
- CWE-644: Improper Neutralization of HTTP Headers for Scripting SyntaxImproper Neutralization of HTTP Headers for Scripting Syntax occurs when user-controlled data is placed into HTTP response headers without proper
- CWE-645: Overly Restrictive Account Lockout MechanismOverly Restrictive Account Lockout Mechanism occurs when an application's account lockout policy is too aggressive, allowing attackers to
- CWE-646: Reliance on File Name or Extension of Externally-Supplied FileReliance on File Name or Extension of Externally-Supplied File occurs when an application makes security decisions based solely on the filename or
- CWE-647: Use of Non-Canonical URL Paths for Authorization DecisionsUse of Non-Canonical URL Paths for Authorization Decisions occurs when security controls match URL paths without normalizing them first.
- CWE-648: Incorrect Use of Privileged APIsIncorrect Use of Privileged APIs occurs when an application fails to properly control access to or invocation of privileged system functions.
- CWE-649: Reliance on Obfuscation or Encryption of Security-Relevant Inputs without Integrity CheckingReliance on Obfuscation or Encryption of Security-Relevant Inputs without Integrity Checking occurs when an application encrypts or obfuscates
- CWE-650: Trusting HTTP Permission Methods on the Server SideTrusting HTTP Permission Methods on the Server Side is a vulnerability where a web server or application incorrectly assumes that HTTP GET requests
- CWE-651: Exposure of WSDL File Containing Sensitive InformationExposure of WSDL File Containing Sensitive Information occurs when Web Services Description Language (WSDL) files are publicly accessible and contain
- CWE-652: Improper Neutralization of Data within XQuery Expressions (XQuery Injection)XQuery Injection occurs when user-supplied data is incorporated into XQuery expressions without proper sanitization.
- CWE-653: Improper Isolation or CompartmentalizationImproper Isolation or Compartmentalization occurs when an application fails to properly separate components, processes, or data that should be
- CWE-654: Reliance on a Single Factor in a Security DecisionReliance on a Single Factor in a Security Decision occurs when an application uses only one piece of information to make security-critical decisions.
- CWE-655: Insufficient Psychological AcceptabilityInsufficient Psychological Acceptability occurs when security mechanisms are so difficult, confusing, or frustrating to use that users circumvent,
- CWE-656: Reliance on Security Through ObscurityReliance on Security Through Obscurity occurs when an application depends primarily or solely on keeping security mechanisms secret rather than on
- CWE-657: Violation of Secure Design PrinciplesViolation of Secure Design Principles occurs when software architecture and design don't follow established security principles.
- CWE-662: Improper SynchronizationImproper Synchronization occurs when concurrent access to shared resources is not properly controlled, leading to race conditions, data corruption,
- CWE-663: Use of a Non-reentrant Function in a Concurrent ContextUse of a Non-reentrant Function in a Concurrent Context occurs when code calls functions that maintain internal static state in a multi-threaded
- CWE-664: Improper Control of a Resource Through its LifetimeImproper Control of a Resource Through its Lifetime occurs when an application does not properly manage the complete lifecycle of a resource from
- CWE-665: Improper InitializationImproper Initialization occurs when an application does not properly initialize critical variables, data structures, or resources before use.
- CWE-666: Operation on Resource in Wrong Phase of LifetimeOperation on Resource in Wrong Phase of Lifetime occurs when code performs operations on a resource that is inappropriate for the resource's current
- CWE-667: Improper LockingImproper Locking occurs when software incorrectly uses synchronization primitives to control access to shared resources.
- CWE-668: Exposure of Resource to Wrong SphereExposure of Resource to Wrong Sphere occurs when a product exposes a resource to the wrong control sphere, providing unintended actors with
- CWE-669: Incorrect Resource Transfer Between SpheresIncorrect Resource Transfer Between Spheres occurs when a product transfers a resource to another sphere in a way that violates the intended security
- CWE-670: Always-Incorrect Control Flow ImplementationAlways-Incorrect Control Flow Implementation occurs when code contains logic that will always produce incorrect behavior regardless of input or
- CWE-671: Lack of Administrator Control over SecurityLack of Administrator Control over Security occurs when a product does not provide administrators with sufficient control to manage security settings
- CWE-672: Operation on a Resource after Expiration or ReleaseOperation on a Resource after Expiration or Release occurs when code continues to use a resource after it has been released, expired, or otherwise
- CWE-673: External Influence of Sphere DefinitionExternal Influence of Sphere Definition occurs when an external actor can modify the boundaries or definitions of protection domains, trust zones, or
- CWE-674: Uncontrolled RecursionUncontrolled Recursion occurs when a function calls itself recursively without proper termination conditions or depth limits, leading to stack
- CWE-675: Multiple Operations on Resource in Single-Operation ContextMultiple Operations on Resource in Single-Operation Context is a vulnerability where a program performs the same operation on a resource two or more
- CWE-676: Use of Potentially Dangerous FunctionUse of Potentially Dangerous Function is a vulnerability where a program invokes library functions that can introduce security vulnerabilities when
- CWE-680: Integer Overflow to Buffer OverflowInteger Overflow to Buffer Overflow is a compound vulnerability where an integer overflow during memory allocation calculations results in allocating
- CWE-681: Incorrect Conversion between Numeric TypesIncorrect Conversion between Numeric Types is a vulnerability where a program converts values between different numeric types in a way that produces
