Datasets:

Krutikp

/

ComplianceLLM

like 0

Insufficient Entropy

Base

Draft

The product uses an algorithm or scheme that produces insufficient entropy, leaving patterns or clusters of values that are more likely to occur than others.

::NATURE:ChildOf:CWE ID:330:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:330:VIEW ID:1003:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation:NOTE:REALIZATION: This weakness is caused during implementation of an architectural security tactic.::

::SCOPE:Access Control:SCOPE:Other:IMPACT:Bypass Protection Mechanism:IMPACT:Other:NOTE:An attacker could guess the random numbers generated and could gain unauthorized access to a system if the random numbers are used for authentication and authorization.::

::PHASE:Implementation:DESCRIPTION:Determine the necessary entropy to adequately provide for randomness and predictability. This can be achieved by increasing the number of bits of objects such as keys and seeds.::

::REFERENCE:CVE-2001-0950:DESCRIPTION:Insufficiently random data used to generate session tokens using C rand(). Also, for certificate/key generation, uses a source that does not block when entropy is low.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0950::REFERENCE:CVE-2008-2108:DESCRIPTION:Chain: insufficient precision (CWE-1339) in random-number generator causes some zero bits to be reliably generated, reducing the amount of entropy (CWE-331):LINK:https://www.cve.org/CVERecord?id=CVE-2008-2108::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Insufficient Entropy::TAXONOMY NAME:WASC:ENTRY ID:11:ENTRY NAME:Brute Force::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:MSC32-C:ENTRY NAME:Properly seed pseudorandom number generators:MAPPING FIT:Exact::

::59::

::TYPE:Maintenance:NOTE:As of CWE 4.5, terminology related to randomness, entropy, and predictability can vary widely. Within the developer and other communities, randomness is used heavily. However, within cryptography, entropy is distinct, typically implied as a measurement. There are no commonly-used definitions, even within standards documents and cryptography papers. Future versions of CWE will attempt to define these terms and, if necessary, distinguish between them in ways that are appropriate for different communities but do not reduce the usability of CWE for mapping, understanding, or other scenarios.::

Small Space of Random Values

Base

Draft

The number of possible random values is smaller than needed by the product, making it more susceptible to brute force attacks.

::NATURE:ChildOf:CWE ID:330:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation:NOTE:REALIZATION: This weakness is caused during implementation of an architectural security tactic.::

::SCOPE:Access Control:SCOPE:Other:IMPACT:Bypass Protection Mechanism:IMPACT:Other:NOTE:An attacker could easily guess the values used. This could lead to unauthorized access to a system if the seed is used for authentication and authorization.::

::PHASE:Architecture and Design Requirements:STRATEGY:Libraries or Frameworks:DESCRIPTION:Use products or modules that conform to FIPS 140-2 [REF-267] to avoid obvious entropy problems. Consult FIPS 140-2 Annex C (Approved Random Number Generators).::

::REFERENCE:CVE-2002-0583:DESCRIPTION:Product uses 5 alphanumeric characters for filenames of expense claim reports, stored under web root.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0583::REFERENCE:CVE-2002-0903:DESCRIPTION:Product uses small number of random numbers for a code to approve an action, and also uses predictable new user IDs, allowing attackers to hijack new accounts.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0903::REFERENCE:CVE-2003-1230:DESCRIPTION:SYN cookies implementation only uses 32-bit keys, making it easier to brute force ISN.:LINK:https://www.cve.org/CVERecord?id=CVE-2003-1230::REFERENCE:CVE-2004-0230:DESCRIPTION:Complex predictability / randomness (reduced space).:LINK:https://www.cve.org/CVERecord?id=CVE-2004-0230::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Small Space of Random Values::

::TYPE:Maintenance:NOTE:As of CWE 4.5, terminology related to randomness, entropy, and predictability can vary widely. Within the developer and other communities, randomness is used heavily. However, within cryptography, entropy is distinct, typically implied as a measurement. There are no commonly-used definitions, even within standards documents and cryptography papers. Future versions of CWE will attempt to define these terms and, if necessary, distinguish between them in ways that are appropriate for different communities but do not reduce the usability of CWE for mapping, understanding, or other scenarios.::

Incorrect Usage of Seeds in Pseudo-Random Number Generator (PRNG)

Base

Draft

The product uses a Pseudo-Random Number Generator (PRNG) but does not correctly manage seeds.

PRNGs are deterministic and, while their output appears random, they cannot actually create entropy. They rely on cryptographically secure and unique seeds for entropy so proper seeding is critical to the secure operation of the PRNG. Management of seeds could be broken down into two main areas: (1) protecting seeds as cryptographic material (such as a cryptographic key); (2) whenever possible, using a uniquely generated seed from a cryptographically secure source PRNGs require a seed as input to generate a stream of numbers that are functionally indistinguishable from random numbers. While the output is, in many cases, sufficient for cryptographic uses, the output of any PRNG is directly determined by the seed provided as input. If the seed can be ascertained by a third party, the entire output of the PRNG can be made known to them. As such, the seed should be kept secret and should ideally not be able to be guessed. For example, the current time may be a poor seed. Knowing the approximate time the PRNG was seeded greatly reduces the possible key space. Seeds do not necessarily need to be unique, but reusing seeds may open up attacks if the seed is discovered.

::NATURE:ChildOf:CWE ID:330:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:330:VIEW ID:1003:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation:NOTE:REALIZATION: This weakness is caused during implementation of an architectural security tactic.::

::SCOPE:Access Control:SCOPE:Other:IMPACT:Bypass Protection Mechanism:IMPACT:Other:NOTE:If a PRNG is used incorrectly, such as using the same seed for each initialization or using a predictable seed, then an attacker may be able to easily guess the seed and thus the random numbers. This could lead to unauthorized access to a system if the seed is used for authentication and authorization.::

::REFERENCE:CVE-2020-7010:DESCRIPTION:Cloud application on Kubernetes generates passwords using a weak random number generator based on deployment time.:LINK:https://www.cve.org/CVERecord?id=CVE-2020-7010::REFERENCE:CVE-2019-11495:DESCRIPTION:server uses erlang:now() to seed the PRNG, which results in a small search space for potential random seeds:LINK:https://www.cve.org/CVERecord?id=CVE-2019-11495::REFERENCE:CVE-2018-12520:DESCRIPTION:Product's PRNG is not seeded for the generation of session IDs:LINK:https://www.cve.org/CVERecord?id=CVE-2018-12520::REFERENCE:CVE-2016-10180:DESCRIPTION:Router's PIN generation is based on rand(time(0)) seeding.:LINK:https://www.cve.org/CVERecord?id=CVE-2016-10180::

::TAXONOMY NAME:PLOVER:ENTRY NAME:PRNG Seed Error::

::TYPE:Maintenance:NOTE:As of CWE 4.5, terminology related to randomness, entropy, and predictability can vary widely. Within the developer and other communities, randomness is used heavily. However, within cryptography, entropy is distinct, typically implied as a measurement. There are no commonly-used definitions, even within standards documents and cryptography papers. Future versions of CWE will attempt to define these terms and, if necessary, distinguish between them in ways that are appropriate for different communities but do not reduce the usability of CWE for mapping, understanding, or other scenarios.::

Use of Cryptographically Weak Pseudo-Random Number Generator (PRNG)

Base

Draft

The product uses a Pseudo-Random Number Generator (PRNG) in a security context, but the PRNG's algorithm is not cryptographically strong.

When a non-cryptographic PRNG is used in a cryptographic context, it can expose the cryptography to certain types of attacks. Often a pseudo-random number generator (PRNG) is not designed for cryptography. Sometimes a mediocre source of randomness is sufficient or preferable for algorithms that use random numbers. Weak generators generally take less processing power and/or do not use the precious, finite, entropy sources on a system. While such PRNGs might have very useful features, these same features could be used to break the cryptography.

::NATURE:ChildOf:CWE ID:330:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:330:VIEW ID:1003:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation:NOTE:REALIZATION: This weakness is caused during implementation of an architectural security tactic.::

::SCOPE:Access Control:IMPACT:Bypass Protection Mechanism:NOTE:If a PRNG is used for authentication and authorization, such as a session ID or a seed for generating a cryptographic key, then an attacker may be able to easily guess the ID or cryptographic key and gain access to restricted functionality.::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::PHASE:Implementation:DESCRIPTION:Use functions or hardware which use a hardware-based random number generation for all crypto. This is the recommended solution. Use CyptGenRandom on Windows, or hw_rand() on Linux.::

::REFERENCE:CVE-2021-3692:DESCRIPTION:PHP framework uses mt_rand() function (Marsenne Twister) when generating tokens:LINK:https://www.cve.org/CVERecord?id=CVE-2021-3692::REFERENCE:CVE-2009-3278:DESCRIPTION:Crypto product uses rand() library function to generate a recovery key, making it easier to conduct brute force attacks.:LINK:https://www.cve.org/CVERecord?id=CVE-2009-3278::REFERENCE:CVE-2009-3238:DESCRIPTION:Random number generator can repeatedly generate the same value.:LINK:https://www.cve.org/CVERecord?id=CVE-2009-3238::REFERENCE:CVE-2009-2367:DESCRIPTION:Web application generates predictable session IDs, allowing session hijacking.:LINK:https://www.cve.org/CVERecord?id=CVE-2009-2367::REFERENCE:CVE-2008-0166:DESCRIPTION:SSL library uses a weak random number generator that only generates 65,536 unique keys.:LINK:https://www.cve.org/CVERecord?id=CVE-2008-0166::

::TAXONOMY NAME:CLASP:ENTRY NAME:Non-cryptographic PRNG::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:MSC30-C:ENTRY NAME:Do not use the rand() function for generating pseudorandom numbers:MAPPING FIT:CWE More Abstract::

::TYPE:Maintenance:NOTE:As of CWE 4.5, terminology related to randomness, entropy, and predictability can vary widely. Within the developer and other communities, randomness is used heavily. However, within cryptography, entropy is distinct, typically implied as a measurement. There are no commonly-used definitions, even within standards documents and cryptography papers. Future versions of CWE will attempt to define these terms and, if necessary, distinguish between them in ways that are appropriate for different communities but do not reduce the usability of CWE for mapping, understanding, or other scenarios.::

Predictable from Observable State

Base

Draft

A number or object is predictable based on observations that the attacker can make about the state of the system or network, such as time, process ID, etc.

::NATURE:ChildOf:CWE ID:340:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation:NOTE:REALIZATION: This weakness is caused during implementation of an architectural security tactic.::

::SCOPE:Other:IMPACT:Varies by Context:NOTE:This weakness could be exploited by an attacker in a number ways depending on the context. If a predictable number is used to generate IDs or keys that are used within protection mechanisms, then an attacker could gain unauthorized access to the system. If predictable filenames are used for storing sensitive information, then an attacker might gain access to the system and may be able to gain access to the information in the file.::

::PHASE:Implementation:DESCRIPTION:Increase the entropy used to seed a PRNG.::PHASE:Architecture and Design Requirements:STRATEGY:Libraries or Frameworks:DESCRIPTION:Use products or modules that conform to FIPS 140-2 [REF-267] to avoid obvious entropy problems. Consult FIPS 140-2 Annex C (Approved Random Number Generators).::PHASE:Implementation:DESCRIPTION:Use a PRNG that periodically re-seeds itself using input from high-quality sources, such as hardware devices with high entropy. However, do not re-seed too frequently, or else the entropy source might block.::

::REFERENCE:CVE-2002-0389:DESCRIPTION:Mail server stores private mail messages with predictable filenames in a world-executable directory, which allows local users to read private mailing list archives.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0389::REFERENCE:CVE-2001-1141:DESCRIPTION:PRNG allows attackers to use the output of small PRNG requests to determine the internal state information, which could be used by attackers to predict future pseudo-random numbers.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-1141::REFERENCE:CVE-2000-0335:DESCRIPTION:DNS resolver library uses predictable IDs, which allows a local attacker to spoof DNS query results.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0335::REFERENCE:CVE-2005-1636:DESCRIPTION:MFV. predictable filename and insecure permissions allows file modification to execute SQL queries.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1636::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Predictable from Observable State::

::TYPE:Maintenance:NOTE:As of CWE 4.5, terminology related to randomness, entropy, and predictability can vary widely. Within the developer and other communities, randomness is used heavily. However, within cryptography, entropy is distinct, typically implied as a measurement. There are no commonly-used definitions, even within standards documents and cryptography papers. Future versions of CWE will attempt to define these terms and, if necessary, distinguish between them in ways that are appropriate for different communities but do not reduce the usability of CWE for mapping, understanding, or other scenarios.::

Predictable Exact Value from Previous Values

Base

Draft

An exact value or random number can be precisely predicted by observing previous values.

::NATURE:ChildOf:CWE ID:340:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Other:IMPACT:Varies by Context::

::PHASE::DESCRIPTION:Increase the entropy used to seed a PRNG.::PHASE:Architecture and Design Requirements:STRATEGY:Libraries or Frameworks:DESCRIPTION:Use products or modules that conform to FIPS 140-2 [REF-267] to avoid obvious entropy problems. Consult FIPS 140-2 Annex C (Approved Random Number Generators).::PHASE:Implementation:DESCRIPTION:Use a PRNG that periodically re-seeds itself using input from high-quality sources, such as hardware devices with high entropy. However, do not re-seed too frequently, or else the entropy source might block.::

::REFERENCE:CVE-2002-1463:DESCRIPTION:Firewall generates easily predictable initial sequence numbers (ISN), which allows remote attackers to spoof connections.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1463::REFERENCE:CVE-1999-0074:DESCRIPTION:Listening TCP ports are sequentially allocated, allowing spoofing attacks.:LINK:https://www.cve.org/CVERecord?id=CVE-1999-0074::REFERENCE:CVE-1999-0077:DESCRIPTION:Predictable TCP sequence numbers allow spoofing.:LINK:https://www.cve.org/CVERecord?id=CVE-1999-0077::REFERENCE:CVE-2000-0335:DESCRIPTION:DNS resolver uses predictable IDs, allowing a local user to spoof DNS query results.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0335::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Predictable Exact Value from Previous Values::

::TYPE:Maintenance:NOTE:As of CWE 4.5, terminology related to randomness, entropy, and predictability can vary widely. Within the developer and other communities, randomness is used heavily. However, within cryptography, entropy is distinct, typically implied as a measurement. There are no commonly-used definitions, even within standards documents and cryptography papers. Future versions of CWE will attempt to define these terms and, if necessary, distinguish between them in ways that are appropriate for different communities but do not reduce the usability of CWE for mapping, understanding, or other scenarios.::

Predictable Value Range from Previous Values

Base

Draft

The product's random number generator produces a series of values which, when observed, can be used to infer a relatively small range of possibilities for the next value that could be generated.

The output of a random number generator should not be predictable based on observations of previous values. In some cases, an attacker cannot predict the exact value that will be produced next, but can narrow down the possibilities significantly. This reduces the amount of effort to perform a brute force attack. For example, suppose the product generates random numbers between 1 and 100, but it always produces a larger value until it reaches 100. If the generator produces an 80, then the attacker knows that the next value will be somewhere between 81 and 100. Instead of 100 possibilities, the attacker only needs to consider 20.

::NATURE:ChildOf:CWE ID:340:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Other:IMPACT:Varies by Context::

::PHASE::DESCRIPTION:Increase the entropy used to seed a PRNG.::PHASE:Architecture and Design Requirements:STRATEGY:Libraries or Frameworks:DESCRIPTION:Use products or modules that conform to FIPS 140-2 [REF-267] to avoid obvious entropy problems. Consult FIPS 140-2 Annex C (Approved Random Number Generators).::PHASE:Implementation:DESCRIPTION:Use a PRNG that periodically re-seeds itself using input from high-quality sources, such as hardware devices with high entropy. However, do not re-seed too frequently, or else the entropy source might block.::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Predictable Value Range from Previous Values::

::TYPE:Maintenance:NOTE:As of CWE 4.5, terminology related to randomness, entropy, and predictability can vary widely. Within the developer and other communities, randomness is used heavily. However, within cryptography, entropy is distinct, typically implied as a measurement. There are no commonly-used definitions, even within standards documents and cryptography papers. Future versions of CWE will attempt to define these terms and, if necessary, distinguish between them in ways that are appropriate for different communities but do not reduce the usability of CWE for mapping, understanding, or other scenarios.::

Use of Invariant Value in Dynamically Changing Context

Base

Draft

The product uses a constant value, name, or reference, but this value can (or should) vary across different environments.

::NATURE:ChildOf:CWE ID:330:VIEW ID:1000:ORDINAL:Primary::

::ORDINALITY:Primary::ORDINALITY:Resultant::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Other:IMPACT:Varies by Context::

::REFERENCE:CVE-2002-0980:DESCRIPTION:Component for web browser writes an error message to a known location, which can then be referenced by attackers to process HTML/script in a less restrictive context:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0980::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Static Value in Unpredictable Context::

::TYPE:Relationship:NOTE:overlaps default configuration.::

Origin Validation Error

Class

Draft

The product does not properly verify that the source of data or communication is valid.

::NATURE:ChildOf:CWE ID:345:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:345:VIEW ID:1003:ORDINAL:Primary::NATURE:ChildOf:CWE ID:284:VIEW ID:1000::

::ORDINALITY:Primary::ORDINALITY:Resultant::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation:NOTE:REALIZATION: This weakness is caused during implementation of an architectural security tactic.::

::SCOPE:Access Control:SCOPE:Other:IMPACT:Gain Privileges or Assume Identity:IMPACT:Varies by Context:NOTE:An attacker can access any functionality that is inadvertently accessible to the source.::

::REFERENCE:CVE-2000-1218:DESCRIPTION:DNS server can accept DNS updates from hosts that it did not query, leading to cache poisoning:LINK:https://www.cve.org/CVERecord?id=CVE-2000-1218::REFERENCE:CVE-2005-0877:DESCRIPTION:DNS server can accept DNS updates from hosts that it did not query, leading to cache poisoning:LINK:https://www.cve.org/CVERecord?id=CVE-2005-0877::REFERENCE:CVE-2001-1452:DESCRIPTION:DNS server caches glue records received from non-delegated name servers:LINK:https://www.cve.org/CVERecord?id=CVE-2001-1452::REFERENCE:CVE-2005-2188:DESCRIPTION:user ID obtained from untrusted source (URL):LINK:https://www.cve.org/CVERecord?id=CVE-2005-2188::REFERENCE:CVE-2003-0174:DESCRIPTION:LDAP service does not verify if a particular attribute was set by the LDAP server:LINK:https://www.cve.org/CVERecord?id=CVE-2003-0174::REFERENCE:CVE-1999-1549:DESCRIPTION:product does not sufficiently distinguish external HTML from internal, potentially dangerous HTML, allowing bypass using special strings in the page title. Overlaps special elements.:LINK:https://www.cve.org/CVERecord?id=CVE-1999-1549::REFERENCE:CVE-2003-0981:DESCRIPTION:product records the reverse DNS name of a visitor in the logs, allowing spoofing and resultant XSS.:LINK:https://www.cve.org/CVERecord?id=CVE-2003-0981::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Origin Validation Error::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 3-3:ENTRY NAME:Req SR 2.12 RE(1)::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 4-1:ENTRY NAME:Req SD-1::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 4-1:ENTRY NAME:Req SR-2::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 4-1:ENTRY NAME:Req SVV-1::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 4-2:ENTRY NAME:Req CR 2.12 RE(1)::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 4-2:ENTRY NAME:Req CR 3.1 RE(1)::

::111::141::142::160::21::384::385::386::387::388::510::59::60::75::76::89::

::TYPE:Maintenance:NOTE:This entry has some significant overlap with other CWE entries and may need some clarification. See terminology notes.::TYPE:Terminology:NOTE:The Origin Validation Error term was originally used in a 1995 thesis [REF-324]. Although not formally defined, an issue is considered to be an origin validation error if either (1) an object [accepts] input from an unauthorized subject, or (2) the system [fails] to properly or completely authenticate a subject. A later section says that an origin validation error can occur when the system (1) does not properly authenticate a user or process or (2) does not properly authenticate the shared data or libraries. The only example provided in the thesis (covered by OSVDB:57615) involves a setuid program running command-line arguments without dropping privileges. So, this definition (and its examples in the thesis) effectively cover other weaknesses such as CWE-287 (Improper Authentication), CWE-285 (Improper Authorization), and CWE-250 (Execution with Unnecessary Privileges). There appears to be little usage of this term today, except in the SecurityFocus vulnerability database, where the term is used for a variety of issues, including web-browser problems that allow violation of the Same Origin Policy and improper validation of the source of an incoming message.::

Improper Verification of Cryptographic Signature

Base

Draft

The product does not verify, or incorrectly verifies, the cryptographic signature for data.

::NATURE:ChildOf:CWE ID:345:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:345:VIEW ID:1003:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation:NOTE:REALIZATION: This weakness is caused during implementation of an architectural security tactic.::

::SCOPE:Access Control:SCOPE:Integrity:SCOPE:Confidentiality:IMPACT:Gain Privileges or Assume Identity:IMPACT:Modify Application Data:IMPACT:Execute Unauthorized Code or Commands:NOTE:An attacker could gain access to sensitive data and possibly execute unauthorized code.::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::REFERENCE:CVE-2002-1796:DESCRIPTION:Does not properly verify signatures for trusted entities.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1796::REFERENCE:CVE-2005-2181:DESCRIPTION:Insufficient verification allows spoofing.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-2181::REFERENCE:CVE-2005-2182:DESCRIPTION:Insufficient verification allows spoofing.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-2182::REFERENCE:CVE-2002-1706:DESCRIPTION:Accepts a configuration file without a Message Integrity Check (MIC) signature.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1706::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Improperly Verified Signature::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:SEC06-J:ENTRY NAME:Do not rely on the default automatic signature verification provided by URLClassLoader and java.util.jar::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 3-3:ENTRY NAME:Req SR 1.9::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 4-1:ENTRY NAME:Req SM-6::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 4-2:ENTRY NAME:Req EDR 3.12::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 4-2:ENTRY NAME:Req NDR 3.12::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 4-2:ENTRY NAME:Req HDR 3.12::

::463::475::

Use of Less Trusted Source

Base

Draft

The product has two different sources of the same data or information, but it uses the source that has less support for verification, is less trusted, or is less resistant to attack.

::NATURE:ChildOf:CWE ID:345:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Access Control:IMPACT:Bypass Protection Mechanism:IMPACT:Gain Privileges or Assume Identity:NOTE:An attacker could utilize the untrusted data source to bypass protection mechanisms and gain access to sensitive data.::

::REFERENCE:CVE-2001-0860:DESCRIPTION:Product uses IP address provided by a client, instead of obtaining it from the packet headers, allowing easier spoofing.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0860::REFERENCE:CVE-2004-1950:DESCRIPTION:Web product uses the IP address in the X-Forwarded-For HTTP header instead of a server variable that uses the connecting IP address, allowing filter bypass.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-1950::REFERENCE:CVE-2001-0908:DESCRIPTION:Product logs IP address specified by the client instead of obtaining it from the packet headers, allowing information hiding.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0908::REFERENCE:CVE-2006-1126:DESCRIPTION:PHP application uses IP address from X-Forwarded-For HTTP header, instead of REMOTE_ADDR.:LINK:https://www.cve.org/CVERecord?id=CVE-2006-1126::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Use of Less Trusted Source::

::141::142::73::76::85::

Acceptance of Extraneous Untrusted Data With Trusted Data

Base

Draft

The product, when processing trusted data, accepts any untrusted data that is also included with the trusted data, treating the untrusted data as if it were trusted.

::NATURE:ChildOf:CWE ID:345:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Access Control:SCOPE:Integrity:IMPACT:Bypass Protection Mechanism:IMPACT:Modify Application Data:NOTE:An attacker could package untrusted data with trusted data to bypass protection mechanisms to gain access to and possibly modify sensitive data.::

::REFERENCE:CVE-2002-0018:DESCRIPTION:Does not verify that trusted entity is authoritative for all entities in its response.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0018::REFERENCE:CVE-2006-5462:DESCRIPTION:use of extra data in a signature allows certificate signature forging:LINK:https://www.cve.org/CVERecord?id=CVE-2006-5462::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Untrusted Data Appended with Trusted Data::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:ENV01-J:ENTRY NAME:Place all security-sensitive code in a single JAR and sign and seal it::

::141::142::75::

Insufficient Type Distinction

Base

Draft

The product does not properly distinguish between different types of elements in a way that leads to insecure behavior.

::NATURE:ChildOf:CWE ID:345:VIEW ID:1000:ORDINAL:Primary::NATURE:PeerOf:CWE ID:436:VIEW ID:1000::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Other:IMPACT:Other::

::REFERENCE:CVE-2005-2260:DESCRIPTION:Browser user interface does not distinguish between user-initiated and synthetic events.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-2260::REFERENCE:CVE-2005-2801:DESCRIPTION:Product does not compare all required data in two separate elements, causing it to think they are the same, leading to loss of ACLs. Similar to Same Name error.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-2801::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Insufficient Type Distinction::

::TYPE:Relationship:NOTE:Overlaps others, e.g. Multiple Interpretation Errors.::

Missing Support for Integrity Check

Base

Draft

The product uses a transmission protocol that does not include a mechanism for verifying the integrity of the data during transmission, such as a checksum.

If integrity check values or checksums are omitted from a protocol, there is no way of determining if data has been corrupted in transmission. The lack of checksum functionality in a protocol removes the first application-level check of data that can be used. The end-to-end philosophy of checks states that integrity checks should be performed at the lowest level that they can be completely implemented. Excluding further sanity checks and input validation performed by applications, the protocol's checksum is the most important level of checksum, since it can be performed more completely than at any previous level and takes into account entire messages, as opposed to single packets.

::NATURE:ChildOf:CWE ID:345:VIEW ID:1000:ORDINAL:Primary::NATURE:PeerOf:CWE ID:354:VIEW ID:1000::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design:NOTE:OMISSION: This weakness is caused by missing a security tactic during the architecture and design phase.::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Other:IMPACT:Other:NOTE:Data that is parsed and used may be corrupted.::SCOPE:Non-Repudiation:SCOPE:Other:IMPACT:Hide Activities:IMPACT:Other:NOTE:Without a checksum it is impossible to determine if any changes have been made to the data after it was sent.::

::PHASE:Architecture and Design:DESCRIPTION:Add an appropriately sized checksum to the protocol, ensuring that data received may be simply validated before it is parsed and used.::PHASE:Implementation:DESCRIPTION:Ensure that the checksums present in the protocol design are properly implemented and added to each message before it is sent.::

::TAXONOMY NAME:CLASP:ENTRY NAME:Failure to add integrity check value::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 2-4:ENTRY NAME:Req SP.03.03 RE(1)::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 2-4:ENTRY NAME:Req SP.04.02 RE(1)::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 2-4:ENTRY NAME:Req SP.11.06 RE(2)::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 3-3:ENTRY NAME:Req SR 3.1::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 4-1:ENTRY NAME:Req SD-1::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 4-2:ENTRY NAME:Req CR 3.1::

::13::14::389::39::665::74::75::

Improper Validation of Integrity Check Value

Base

Draft

The product does not validate or incorrectly validates the integrity check values or checksums of a message. This may prevent it from detecting if the data has been modified or corrupted in transmission.

Improper validation of checksums before use results in an unnecessary risk that can easily be mitigated. The protocol specification describes the algorithm used for calculating the checksum. It is then a simple matter of implementing the calculation and verifying that the calculated checksum and the received checksum match. Improper verification of the calculated checksum and the received checksum can lead to far greater consequences.

::NATURE:ChildOf:CWE ID:345:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:345:VIEW ID:1003:ORDINAL:Primary::NATURE:ChildOf:CWE ID:754:VIEW ID:1000::NATURE:PeerOf:CWE ID:353:VIEW ID:1000::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation:NOTE:REALIZATION: This weakness is caused during implementation of an architectural security tactic.::

::SCOPE:Integrity:SCOPE:Other:IMPACT:Modify Application Data:IMPACT:Other:NOTE:Integrity checks usually use a secret key that helps authenticate the data origin. Skipping integrity checking generally opens up the possibility that new data from an invalid source can be injected.::SCOPE:Integrity:SCOPE:Other:IMPACT:Other:NOTE:Data that is parsed and used may be corrupted.::SCOPE:Non-Repudiation:SCOPE:Other:IMPACT:Hide Activities:IMPACT:Other:NOTE:Without a checksum check, it is impossible to determine if any changes have been made to the data after it was sent.::

::PHASE:Implementation:DESCRIPTION:Ensure that the checksums present in messages are properly checked in accordance with the protocol specification before they are parsed and used.::

::TAXONOMY NAME:ISA/IEC 62443:ENTRY ID:Part 3-3:ENTRY NAME:Req SR 3.1::TAXONOMY NAME:CLASP:ENTRY NAME:Failure to check integrity check value::

::145::463::75::

Product UI does not Warn User of Unsafe Actions

Base

Incomplete

The product's user interface does not warn the user before undertaking an unsafe action on behalf of that user. This makes it easier for attackers to trick users into inflicting damage to their system.

Product systems should warn users that a potentially dangerous action may occur if the user proceeds. For example, if the user downloads a file from an unknown source and attempts to execute the file on their machine, then the application's GUI can indicate that the file is unsafe.

::NATURE:ChildOf:CWE ID:221:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Non-Repudiation:IMPACT:Hide Activities::

::REFERENCE:CVE-1999-1055:DESCRIPTION:Product does not warn user when document contains certain dangerous functions or macros.:LINK:https://www.cve.org/CVERecord?id=CVE-1999-1055::REFERENCE:CVE-1999-0794:DESCRIPTION:Product does not warn user when document contains certain dangerous functions or macros.:LINK:https://www.cve.org/CVERecord?id=CVE-1999-0794::REFERENCE:CVE-2000-0277:DESCRIPTION:Product does not warn user when document contains certain dangerous functions or macros.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0277::REFERENCE:CVE-2000-0517:DESCRIPTION:Product does not warn user about a certificate if it has already been accepted for a different site. Possibly resultant.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0517::REFERENCE:CVE-2005-0602:DESCRIPTION:File extractor does not warn user if setuid/setgid files could be extracted. Overlaps privileges/permissions.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-0602::REFERENCE:CVE-2000-0342:DESCRIPTION:E-mail client allows bypass of warning for dangerous attachments via a Windows .LNK file that refers to the attachment.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0342::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Product UI does not warn user of unsafe actions::

::TYPE:Relationship:NOTE:Often resultant, e.g. in unhandled error conditions.::TYPE:Relationship:NOTE:Can overlap privilege errors, conceptually at least.::

Insufficient UI Warning of Dangerous Operations

Base

Draft

The user interface provides a warning to a user regarding dangerous or sensitive operations, but the warning is not noticeable enough to warrant attention.

::NATURE:ChildOf:CWE ID:693:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Non-Repudiation:IMPACT:Hide Activities::

::REFERENCE:CVE-2007-1099:DESCRIPTION:User not sufficiently warned if host key mismatch occurs:LINK:https://www.cve.org/CVERecord?id=CVE-2007-1099::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Insufficient UI warning of dangerous operations::

Improperly Implemented Security Check for Standard

Base

Draft

The product does not implement or incorrectly implements one or more security-relevant checks as specified by the design of a standardized algorithm, protocol, or technique.

::NATURE:ChildOf:CWE ID:573:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:693:VIEW ID:1000::NATURE:CanAlsoBe:CWE ID:345:VIEW ID:1000::NATURE:CanAlsoBe:CWE ID:290:VIEW ID:1000::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation:NOTE:This is an implementation error, in which the algorithm/technique requires certain security-related behaviors or conditions that are not implemented or checked properly, thus causing a vulnerability.::

::SCOPE:Access Control:IMPACT:Bypass Protection Mechanism::

::REFERENCE:CVE-2002-0862:DESCRIPTION:Browser does not verify Basic Constraints of a certificate, even though it is required, allowing spoofing of trusted certificates.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0862::REFERENCE:CVE-2002-0970:DESCRIPTION:Browser does not verify Basic Constraints of a certificate, even though it is required, allowing spoofing of trusted certificates.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0970::REFERENCE:CVE-2002-1407:DESCRIPTION:Browser does not verify Basic Constraints of a certificate, even though it is required, allowing spoofing of trusted certificates.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1407::REFERENCE:CVE-2005-0198:DESCRIPTION:Logic error prevents some required conditions from being enforced during Challenge-Response Authentication Mechanism with MD5 (CRAM-MD5).:LINK:https://www.cve.org/CVERecord?id=CVE-2005-0198::REFERENCE:CVE-2004-2163:DESCRIPTION:Shared secret not verified in a RADIUS response packet, allowing authentication bypass by spoofing server replies.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-2163::REFERENCE:CVE-2005-2181:DESCRIPTION:Insufficient verification in VoIP implementation, in violation of standard, allows spoofed messages.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-2181::REFERENCE:CVE-2005-2182:DESCRIPTION:Insufficient verification in VoIP implementation, in violation of standard, allows spoofed messages.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-2182::REFERENCE:CVE-2005-2298:DESCRIPTION:Security check not applied to all components, allowing bypass.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-2298::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Improperly Implemented Security Check for Standard::

::TYPE:Relationship:NOTE:This is a missing step error on the product side, which can overlap weaknesses such as insufficient verification and spoofing. It is frequently found in cryptographic and authentication errors. It is sometimes resultant.::

Exposure of Private Personal Information to an Unauthorized Actor

Base

Incomplete

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.

There are many types of sensitive information that products must protect from attackers, including system data, communications, configuration, business secrets, intellectual property, and an individual's personal (private) information. Private personal information may include a password, phone number, geographic location, personal messages, credit card number, etc. Private information is important to consider whether the person is a user of the product, or part of a data set that is processed by the product. An exposure of private information does not necessarily prevent the product from working properly, and in fact the exposure might be intended by the developer, e.g. as part of data sharing with other organizations. However, the exposure of personal private information can still be undesirable or explicitly prohibited by law or regulation. Some types of private information include: Government identifiers, such as Social Security Numbers Contact information, such as home addresses and telephone numbers Geographic location - where the user is (or was) Employment history Financial data - such as credit card numbers, salary, bank accounts, and debts Pictures, video, or audio Behavioral patterns - such as web surfing history, when certain activities are performed, etc. Relationships (and types of relationships) with others - family, friends, contacts, etc. Communications - e-mail addresses, private messages, text messages, chat logs, etc. Health - medical conditions, insurance status, prescription records Account passwords and other credentials Some of this information may be characterized as PII (Personally Identifiable Information), Protected Health Information (PHI), etc. Categories of private information may overlap or vary based on the intended usage or the policies and practices of a particular industry. Sometimes data that is not labeled as private can have a privacy implication in a different context. For example, student identification numbers are usually not considered private because there is no explicit and publicly-available mapping to an individual student's personal information. However, if a school generates identification numbers based on student social security numbers, then the identification numbers should be considered private.

::NATURE:ChildOf:CWE ID:200:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::TECHNOLOGY CLASS:Mobile:TECHNOLOGY PREVALENCE:Undetermined::

::TERM:Privacy violation::TERM:Privacy leak::TERM:Privacy leakage::

::PHASE:Architecture and Design:NOTE:OMISSION: This weakness is caused by missing a security tactic during the architecture and design phase.::PHASE:Implementation::PHASE:Operation::

::SCOPE:Confidentiality:IMPACT:Read Application Data::

::METHOD:Architecture or Design Review:DESCRIPTION:Private personal data can enter a program in a variety of ways: Directly from the user in the form of a password or personal information Accessed from a database or other data store by the application Indirectly from a partner or other third party If the data is written to an external location - such as the console, file system, or network - a privacy violation may occur.:EFFECTIVENESS:High::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::PHASE:Requirements:DESCRIPTION:Identify and consult all relevant regulations for personal privacy. An organization may be required to comply with certain federal and state regulations, depending on its location, the type of business it conducts, and the nature of any private data it handles. Regulations may include Safe Harbor Privacy Framework [REF-340], Gramm-Leach Bliley Act (GLBA) [REF-341], Health Insurance Portability and Accountability Act (HIPAA) [REF-342], General Data Protection Regulation (GDPR) [REF-1047], California Consumer Privacy Act (CCPA) [REF-1048], and others.::PHASE:Architecture and Design:DESCRIPTION:Carefully evaluate how secure design may interfere with privacy, and vice versa. Security and privacy concerns often seem to compete with each other. From a security perspective, all important operations should be recorded so that any anomalous activity can later be identified. However, when private data is involved, this practice can in fact create risk. Although there are many ways in which private data can be handled unsafely, a common risk stems from misplaced trust. Programmers often trust the operating environment in which a program runs, and therefore believe that it is acceptable store private information on the file system, in the registry, or in other locally-controlled resources. However, even if access to certain resources is restricted, this does not guarantee that the individuals who do have access can be trusted.::

::TAXONOMY NAME:7 Pernicious Kingdoms:ENTRY NAME:Privacy Violation::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:FIO13-J:ENTRY NAME:Do not log sensitive information outside a trust boundary::

::464::467::498::508::

::TYPE:Maintenance:NOTE:This entry overlaps many other entries that are not organized around the kind of sensitive information that is exposed. However, because privacy is treated with such importance due to regulations and other factors, and it may be useful for weakness-finding tools to highlight capabilities that detect personal private information instead of system information, it is not clear whether - and how - this entry should be deprecated.::

Trust of System Event Data

Base

Incomplete

Security based on event locations are insecure and can be spoofed.

Events are a messaging system which may provide control data to programs listening for events. Events often do not have any type of authentication framework to allow them to be verified from a trusted source. Any application, in Windows, on a given desktop can send a message to any window on the same desktop. There is no authentication framework for these messages. Therefore, any message can be used to manipulate any process on the desktop if the process does not check the validity and safeness of those messages.

::NATURE:ChildOf:CWE ID:345:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Confidentiality:SCOPE:Availability:SCOPE:Access Control:IMPACT:Gain Privileges or Assume Identity:IMPACT:Execute Unauthorized Code or Commands:NOTE:If one trusts the system-event information and executes commands based on it, one could potentially take actions based on a spoofed identity.::

::PHASE:Architecture and Design:DESCRIPTION:Never trust or rely any of the information in an Event for security.::

::REFERENCE:CVE-2004-0213:DESCRIPTION:Attacker uses Shatter attack to bypass GUI-enforced protection for CVE-2003-0908.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-0213::

::TAXONOMY NAME:CLASP:ENTRY NAME:Trust of system event data::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP29:ENTRY NAME:Faulty endpoint authentication::

Signal Handler Race Condition

Base

Incomplete

The product uses a signal handler that introduces a race condition.

Race conditions frequently occur in signal handlers, since signal handlers support asynchronous actions. These race conditions have a variety of root causes and symptoms. Attackers may be able to exploit a signal handler race condition to cause the product state to be corrupted, possibly leading to a denial of service or even code execution. These issues occur when non-reentrant functions, or state-sensitive actions occur in the signal handler, where they may be called at any time. These behaviors can violate assumptions being made by the regular code that is interrupted, or by other signal handlers that may also be invoked. If these functions are called at an inopportune moment - such as while a non-reentrant function is already running - memory corruption could occur that may be exploitable for code execution. Another signal race condition commonly found occurs when free is called within a signal handler, resulting in a double free and therefore a write-what-where condition. Even if a given pointer is set to NULL after it has been freed, a race condition still exists between the time the memory was freed and the pointer was set to NULL. This is especially problematic if the same signal handler has been set for more than one signal -- since it means that the signal handler itself may be reentered. There are several known behaviors related to signal handlers that have received the label of signal handler race condition: Shared state (e.g. global data or static variables) that are accessible to both a signal handler and regular code Shared state between a signal handler and other signal handlers Use of non-reentrant functionality within a signal handler - which generally implies that shared state is being used. For example, malloc() and free() are non-reentrant because they may use global or static data structures for managing memory, and they are indirectly used by innocent-seeming functions such as syslog(); these functions could be exploited for memory corruption and, possibly, code execution. Association of the same signal handler function with multiple signals - which might imply shared state, since the same code and resources are accessed. For example, this can be a source of double-free and use-after-free weaknesses. Use of setjmp and longjmp, or other mechanisms that prevent a signal handler from returning control back to the original functionality While not technically a race condition, some signal handlers are designed to be called at most once, and being called more than once can introduce security problems, even when there are not any concurrent calls to the signal handler. This can be a source of double-free and use-after-free weaknesses. Signal handler vulnerabilities are often classified based on the absence of a specific protection mechanism, although this style of classification is discouraged in CWE because programmers often have a choice of several different mechanisms for addressing the weakness. Such protection mechanisms may preserve exclusivity of access to the shared resource, and behavioral atomicity for the relevant code: Avoiding shared state Using synchronization in the signal handler Using synchronization in the regular code Disabling or masking other signals, which provides atomicity (which effectively ensures exclusivity)

::NATURE:ChildOf:CWE ID:362:VIEW ID:1000:ORDINAL:Primary::NATURE:CanPrecede:CWE ID:415:VIEW ID:1000::NATURE:CanPrecede:CWE ID:416:VIEW ID:1000::NATURE:CanPrecede:CWE ID:123:VIEW ID:1000::

::LANGUAGE NAME:C:LANGUAGE PREVALENCE:Sometimes::LANGUAGE NAME:C++:LANGUAGE PREVALENCE:Sometimes::

::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Confidentiality:SCOPE:Availability:IMPACT:Modify Application Data:IMPACT:Modify Memory:IMPACT:DoS: Crash, Exit, or Restart:IMPACT:Execute Unauthorized Code or Commands:NOTE:It may be possible to cause data corruption and possibly execute arbitrary code by modifying global variables or data structures at unexpected times, violating the assumptions of code that uses this global data.::SCOPE:Access Control:IMPACT:Gain Privileges or Assume Identity:NOTE:If a signal handler interrupts code that is executing with privileges, it may be possible that the signal handler will also be executed with elevated privileges, possibly making subsequent exploits more severe.::

::PHASE:Requirements:STRATEGY:Language Selection:DESCRIPTION:Use a language that does not allow this weakness to occur or provides constructs that make this weakness easier to avoid.::PHASE:Architecture and Design:DESCRIPTION:Design signal handlers to only set flags, rather than perform complex functionality. These flags can then be checked and acted upon within the main program loop.::PHASE:Implementation:DESCRIPTION:Only use reentrant functions within signal handlers. Also, use validation to ensure that state is consistent while performing asynchronous actions that affect the state of execution.::

::REFERENCE:CVE-1999-0035:DESCRIPTION:Signal handler does not disable other signal handlers, allowing it to be interrupted, causing other functionality to access files/etc. with raised privileges:LINK:https://www.cve.org/CVERecord?id=CVE-1999-0035::REFERENCE:CVE-2001-0905:DESCRIPTION:Attacker can send a signal while another signal handler is already running, leading to crash or execution with root privileges:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0905::REFERENCE:CVE-2001-1349:DESCRIPTION:unsafe calls to library functions from signal handler:LINK:https://www.cve.org/CVERecord?id=CVE-2001-1349::REFERENCE:CVE-2004-0794:DESCRIPTION:SIGURG can be used to remotely interrupt signal handler; other variants exist:LINK:https://www.cve.org/CVERecord?id=CVE-2004-0794::REFERENCE:CVE-2004-2259:DESCRIPTION:SIGCHLD signal to FTP server can cause crash under heavy load while executing non-reentrant functions like malloc/free.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-2259::

::Signals::Interprocess Communication::

::System Process::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Signal handler race condition::TAXONOMY NAME:7 Pernicious Kingdoms:ENTRY NAME:Signal Handling Race Conditions::TAXONOMY NAME:CLASP:ENTRY NAME:Race condition in signal handler::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP19:ENTRY NAME:Missing Lock::

Race Condition within a Thread

Base

Draft

If two threads of execution use a resource simultaneously, there exists the possibility that resources may be used while invalid, in turn making the state of execution undefined.

::NATURE:ChildOf:CWE ID:362:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:662:VIEW ID:1305:ORDINAL:Primary::NATURE:ChildOf:CWE ID:662:VIEW ID:1340:ORDINAL:Primary::

::LANGUAGE NAME:C:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C++:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:Java:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C#:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Other:IMPACT:Alter Execution Logic:IMPACT:Unexpected State:NOTE:The main problem is that -- if a lock is overcome -- data could be altered in a bad state.::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::PHASE:Architecture and Design:DESCRIPTION:Use locking functionality. This is the recommended solution. Implement some form of locking mechanism around code which alters or reads persistent data in a multithreaded environment.::PHASE:Architecture and Design:DESCRIPTION:Create resource-locking validation checks. If no inherent locking mechanisms exist, use flags and signals to enforce your own blocking scheme when resources are being used by other threads of execution.::

::REFERENCE:CVE-2022-2621:DESCRIPTION:Chain: two threads in a web browser use the same resource (CWE-366), but one of those threads can destroy the resource before the other has completed (CWE-416).:LINK:https://www.cve.org/CVERecord?id=CVE-2022-2621::

::System Process::

::TAXONOMY NAME:CLASP:ENTRY NAME:Race condition within a thread::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:CON32-C:ENTRY NAME:Prevent data races when accessing bit-fields from multiple threads:MAPPING FIT:CWE More Abstract::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:CON40-C:ENTRY NAME:Do not refer to an atomic variable twice in an expression:MAPPING FIT:CWE More Abstract::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:CON43-C:ENTRY NAME:Do not allow data races in multithreaded code:MAPPING FIT:Exact::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:VNA02-J:ENTRY NAME:Ensure that compound operations on shared variables are atomic::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:VNA03-J:ENTRY NAME:Do not assume that a group of calls to independently atomic methods is atomic::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP19:ENTRY NAME:Missing Lock::

::26::29::

Time-of-check Time-of-use (TOCTOU) Race Condition

Base

Incomplete

The product checks the state of a resource before using that resource, but the resource's state can change between the check and the use in a way that invalidates the results of the check. This can cause the product to perform invalid actions when the resource is in an unexpected state.

This weakness can be security-relevant when an attacker can influence the state of the resource between check and use. This can happen with shared resources such as files, memory, or even variables in multithreaded programs.

::NATURE:ChildOf:CWE ID:362:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:362:VIEW ID:1003:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::TERM:TOCTTOU:DESCRIPTION:The TOCTTOU acronym expands to Time Of Check To Time Of Use.::TERM:TOCCTOU:DESCRIPTION:The TOCCTOU acronym is most likely a typo of TOCTTOU, but it has been used in some influential documents, so the typo is repeated fairly frequently.::

::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Other:IMPACT:Alter Execution Logic:IMPACT:Unexpected State:NOTE:The attacker can gain access to otherwise unauthorized resources.::SCOPE:Integrity:SCOPE:Other:IMPACT:Modify Application Data:IMPACT:Modify Files or Directories:IMPACT:Modify Memory:IMPACT:Other:NOTE:Race conditions such as this kind may be employed to gain read or write access to resources which are not normally readable or writable by the user in question.::SCOPE:Integrity:SCOPE:Other:IMPACT:Other:NOTE:The resource in question, or other resources (through the corrupted one), may be changed in undesirable ways by a malicious user.::SCOPE:Non-Repudiation:IMPACT:Hide Activities:NOTE:If a file or other resource is written in this method, as opposed to in a valid way, logging of the activity may not occur.::SCOPE:Non-Repudiation:SCOPE:Other:IMPACT:Other:NOTE:In some cases it may be possible to delete files a malicious user might not otherwise have access to, such as log files.::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::PHASE:Implementation:DESCRIPTION:The most basic advice for TOCTOU vulnerabilities is to not perform a check before the use. This does not resolve the underlying issue of the execution of a function on a resource whose state and identity cannot be assured, but it does help to limit the false sense of security given by the check.::PHASE:Implementation:DESCRIPTION:When the file being altered is owned by the current user and group, set the effective gid and uid to that of the current user and group when executing this statement.::PHASE:Architecture and Design:DESCRIPTION:Limit the interleaving of operations on files from multiple processes.::PHASE:Implementation Architecture and Design:DESCRIPTION:If you cannot perform operations atomically and you must share access to the resource between multiple processes or threads, then try to limit the amount of time (CPU cycles) between the check and use of the resource. This will not fix the problem, but it could make it more difficult for an attack to succeed.::PHASE:Implementation:DESCRIPTION:Recheck the resource after the use call to verify that the action was taken appropriately.::PHASE:Architecture and Design:DESCRIPTION:Ensure that some environmental locking mechanism can be used to protect resources effectively.::PHASE:Implementation:DESCRIPTION:Ensure that locking occurs before the check, as opposed to afterwards, such that the resource, as checked, is the same as it is when in use.::

::REFERENCE:CVE-2015-1743:DESCRIPTION:TOCTOU in sandbox process allows installation of untrusted browser add-ons by replacing a file after it has been verified, but before it is executed:LINK:https://www.cve.org/CVERecord?id=CVE-2015-1743::REFERENCE:CVE-2003-0813:DESCRIPTION:A multi-threaded race condition allows remote attackers to cause a denial of service (crash or reboot) by causing two threads to process the same RPC request, which causes one thread to use memory after it has been freed.:LINK:https://www.cve.org/CVERecord?id=CVE-2003-0813::REFERENCE:CVE-2004-0594:DESCRIPTION:PHP flaw allows remote attackers to execute arbitrary code by aborting execution before the initialization of key data structures is complete.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-0594::REFERENCE:CVE-2008-2958:DESCRIPTION:chain: time-of-check time-of-use (TOCTOU) race condition in program allows bypass of protection mechanism that was designed to prevent symlink attacks.:LINK:https://www.cve.org/CVERecord?id=CVE-2008-2958::REFERENCE:CVE-2008-1570:DESCRIPTION:chain: time-of-check time-of-use (TOCTOU) race condition in program allows bypass of protection mechanism that was designed to prevent symlink attacks.:LINK:https://www.cve.org/CVERecord?id=CVE-2008-1570::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Time-of-check Time-of-use race condition::TAXONOMY NAME:7 Pernicious Kingdoms:ENTRY NAME:File Access Race Conditions: TOCTOU::TAXONOMY NAME:CLASP:ENTRY NAME:Time of check, time of use race condition::TAXONOMY NAME:CLASP:ENTRY NAME:Race condition in switch::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:FIO01-C:ENTRY NAME:Be careful using functions that use file names for identification::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP20:ENTRY NAME:Race Condition Window::

::27::29::

::TYPE:Relationship:NOTE:TOCTOU issues do not always involve symlinks, and not every symlink issue is a TOCTOU problem.::TYPE:Research Gap:NOTE:Non-symlink TOCTOU issues are not reported frequently, but they are likely to occur in code that attempts to be secure.::

Context Switching Race Condition

Base

Draft

A product performs a series of non-atomic actions to switch between contexts that cross privilege or other security boundaries, but a race condition allows an attacker to modify or misrepresent the product's behavior during the switch.

This is commonly seen in web browser vulnerabilities in which the attacker can perform certain actions while the browser is transitioning from a trusted to an untrusted domain, or vice versa, and the browser performs the actions on one domain using the trust level and resources of the other domain.

::NATURE:ChildOf:CWE ID:362:VIEW ID:1000:ORDINAL:Primary::NATURE:CanAlsoBe:CWE ID:364:VIEW ID:1000::

::ORDINALITY:Primary:DESCRIPTION:This weakness can be primary to almost anything, depending on the context of the race condition.::ORDINALITY:Resultant:DESCRIPTION:This weakness can be resultant from insufficient compartmentalization (CWE-653), incorrect locking, improper initialization or shutdown, or a number of other weaknesses.::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Confidentiality:IMPACT:Modify Application Data:IMPACT:Read Application Data::

::REFERENCE:CVE-2009-1837:DESCRIPTION:Chain: race condition (CWE-362) from improper handling of a page transition in web client while an applet is loading (CWE-368) leads to use after free (CWE-416):LINK:https://www.cve.org/CVERecord?id=CVE-2009-1837::REFERENCE:CVE-2004-2260:DESCRIPTION:Browser updates address bar as soon as user clicks on a link instead of when the page has loaded, allowing spoofing by redirecting to another page using onUnload method. ** this is one example of the role of hooks and context switches, and should be captured somehow - also a race condition of sorts **:LINK:https://www.cve.org/CVERecord?id=CVE-2004-2260::REFERENCE:CVE-2004-0191:DESCRIPTION:XSS when web browser executes Javascript events in the context of a new page while it's being loaded, allowing interaction with previous page in different domain.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-0191::REFERENCE:CVE-2004-2491:DESCRIPTION:Web browser fills in address bar of clicked-on link before page has been loaded, and doesn't update afterward.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-2491::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Context Switching Race Condition::

::26::29::

::TYPE:Relationship:NOTE:Can overlap signal handler race conditions.::TYPE:Research Gap:NOTE:Under-studied as a concept. Frequency unknown; few vulnerability reports give enough detail to know when a context switching race condition is a factor.::

Divide By Zero

Base

Draft

The product divides a value by zero.

This weakness typically occurs when an unexpected value is provided to the product, or if an error occurs that is not properly detected. It frequently occurs in calculations involving physical dimensions such as size, length, width, and height.

::NATURE:ChildOf:CWE ID:682:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:682:VIEW ID:1003:ORDINAL:Primary::NATURE:ChildOf:CWE ID:682:VIEW ID:1305:ORDINAL:Primary::NATURE:ChildOf:CWE ID:682:VIEW ID:1340:ORDINAL:Primary::

::PHASE:Implementation::

::SCOPE:Availability:IMPACT:DoS: Crash, Exit, or Restart:NOTE:A Divide by Zero results in a crash.::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::METHOD:Fuzzing:DESCRIPTION:Fuzz testing (fuzzing) is a powerful technique for generating large numbers of diverse inputs - either randomly or algorithmically - and dynamically invoking the code with those inputs. Even with random inputs, it is often capable of generating unexpected results such as crashes, memory corruption, or resource consumption. Fuzzing effectively produces repeatable test cases that clearly indicate bugs, which helps developers to diagnose the issues.:EFFECTIVENESS:High::

::REFERENCE:CVE-2007-3268:DESCRIPTION:Invalid size value leads to divide by zero.:LINK:https://www.cve.org/CVERecord?id=CVE-2007-3268::REFERENCE:CVE-2007-2723:DESCRIPTION:Empty content triggers divide by zero.:LINK:https://www.cve.org/CVERecord?id=CVE-2007-2723::REFERENCE:CVE-2007-2237:DESCRIPTION:Height value of 0 triggers divide by zero.:LINK:https://www.cve.org/CVERecord?id=CVE-2007-2237::

::TAXONOMY NAME:OWASP Top Ten 2004:ENTRY ID:A9:ENTRY NAME:Denial of Service:MAPPING FIT:CWE More Specific::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:FLP03-C:ENTRY NAME:Detect and handle floating point errors::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:INT33-C:ENTRY NAME:Ensure that division and remainder operations do not result in divide-by-zero errors:MAPPING FIT:Exact::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:NUM02-J:ENTRY NAME:Ensure that division and modulo operations do not result in divide-by-zero errors::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP1:ENTRY NAME:Glitch in computation::

Incomplete Internal State Distinction

Base

Draft

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.

::NATURE:ChildOf:CWE ID:664:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Other:IMPACT:Varies by Context:IMPACT:Unexpected State::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Incomplete Internal State Distinction::

::140::74::

::TYPE:Relationship:NOTE:This conceptually overlaps other categories such as insufficient verification, but this entry refers to the product's incorrect perception of its own state.::TYPE:Relationship:NOTE:This is probably resultant from other weaknesses such as unhandled error conditions, inability to handle out-of-order steps, multiple interpretation errors, etc.::TYPE:Maintenance:NOTE:This entry is being considered for deprecation. It was poorly-defined in PLOVER and is not easily described using the behavior/resource/property model of vulnerability theory.::

Passing Mutable Objects to an Untrusted Method

Base

Draft

The product sends non-cloned mutable data as an argument to a method or function.

The function or method that has been called can alter or delete the mutable data. This could violate assumptions that the calling function has made about its state. In situations where unknown code is called with references to mutable data, this external code could make changes to the data sent. If this data was not previously cloned, the modified data might not be valid in the context of execution.

::NATURE:ChildOf:CWE ID:668:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE NAME:C:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C++:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:Java:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C#:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Integrity:IMPACT:Modify Memory:NOTE:Potentially data could be tampered with by another function which should not have been tampered with.::

::PHASE:Implementation:DESCRIPTION:Pass in data which should not be altered as constant or immutable.::PHASE:Implementation:DESCRIPTION:Clone all mutable data before passing it into an external function . This is the preferred mitigation. This way, regardless of what changes are made to the data, a valid copy is retained for use by the class.::

::TAXONOMY NAME:CLASP:ENTRY NAME:Passing mutable objects to an untrusted method::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:OBJ04-J:ENTRY NAME:Provide mutable classes with copy functionality to safely allow passing instances to untrusted code::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP23:ENTRY NAME:Exposed Data::

Returning a Mutable Object to an Untrusted Caller

Base

Draft

Sending non-cloned mutable data as a return value may result in that data being altered or deleted by the calling function.

In situations where functions return references to mutable data, it is possible that the external code which called the function may make changes to the data sent. If this data was not previously cloned, the class will then be using modified data which may violate assumptions about its internal state.

::NATURE:ChildOf:CWE ID:668:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE NAME:C:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C++:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:Java:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C#:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Access Control:SCOPE:Integrity:IMPACT:Modify Memory:NOTE:Potentially data could be tampered with by another function which should not have been tampered with.::

::PHASE:Implementation:DESCRIPTION:Declare returned data which should not be altered as constant or immutable.::PHASE:Implementation:DESCRIPTION:Clone all mutable data before returning references to it. This is the preferred mitigation. This way, regardless of what changes are made to the data, a valid copy is retained for use by the class.::

::TAXONOMY NAME:CLASP:ENTRY NAME:Mutable object returned::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:OBJ04-J:ENTRY NAME:Provide mutable classes with copy functionality to safely allow passing instances to untrusted code::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:OBJ05-J:ENTRY NAME:Defensively copy private mutable class members before returning their references::TAXONOMY NAME:SEI CERT Perl Coding Standard:ENTRY ID:EXP34-PL:ENTRY NAME:Do not modify $_ in list or sorting functions:MAPPING FIT:Imprecise::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP23:ENTRY NAME:Exposed Data::

Creation of Temporary File With Insecure Permissions

Base

Draft

Opening temporary files without appropriate measures or controls can leave the file, its contents and any function that it impacts vulnerable to attack.

::NATURE:ChildOf:CWE ID:377:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Confidentiality:IMPACT:Read Application Data:NOTE:If the temporary file can be read by the attacker, sensitive information may be in that file which could be revealed.::SCOPE:Authorization:SCOPE:Other:IMPACT:Other:NOTE:If that file can be written to by the attacker, the file might be moved into a place to which the attacker does not have access. This will allow the attacker to gain selective resource access-control privileges.::SCOPE:Integrity:SCOPE:Other:IMPACT:Other:NOTE:Depending on the data stored in the temporary file, there is the potential for an attacker to gain an additional input vector which is trusted as non-malicious. It may be possible to make arbitrary changes to data structures, user information, or even process ownership.::

::PHASE:Requirements:DESCRIPTION:Many contemporary languages have functions which properly handle this condition. Older C temp file functions are especially susceptible.::PHASE:Implementation:DESCRIPTION:Ensure that you use proper file permissions. This can be achieved by using a safe temp file function. Temporary files should be writable and readable only by the process that owns the file.::PHASE:Implementation:DESCRIPTION:Randomize temporary file names. This can also be achieved by using a safe temp-file function. This will ensure that temporary files will not be created in predictable places.::

::REFERENCE:CVE-2022-24823:DESCRIPTION:A network application framework uses the Java function createTempFile(), which will create a file that is readable by other local users of the system:LINK:https://www.cve.org/CVERecord?id=CVE-2022-24823::

::TAXONOMY NAME:CLASP:ENTRY NAME:Improper temp file opening::

Creation of Temporary File in Directory with Insecure Permissions

Base

Incomplete

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.

On some operating systems, the fact that the temporary file exists may be apparent to any user with sufficient privileges to access that directory. Since the file is visible, the application that is using the temporary file could be known. If one has access to list the processes on the system, the attacker has gained information about what the user is doing at that time. By correlating this with the applications the user is running, an attacker could potentially discover what a user's actions are. From this, higher levels of security could be breached.

::NATURE:ChildOf:CWE ID:377:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Confidentiality:IMPACT:Read Application Data:NOTE:Since the file is visible and the application which is using the temp file could be known, the attacker has gained information about what the user is doing at that time.::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::PHASE:Requirements:DESCRIPTION:Many contemporary languages have functions which properly handle this condition. Older C temp file functions are especially susceptible.::PHASE:Implementation:DESCRIPTION:Try to store sensitive tempfiles in a directory which is not world readable -- i.e., per-user directories.::PHASE:Implementation:DESCRIPTION:Avoid using vulnerable temp file functions.::

::REFERENCE:CVE-2022-27818:DESCRIPTION:A hotkey daemon written in Rust creates a domain socket file underneath /tmp, which is accessible by any user.:LINK:https://www.cve.org/CVERecord?id=CVE-2022-27818::REFERENCE:CVE-2021-21290:DESCRIPTION:A Java-based application for a rapid-development framework uses File.createTempFile() to create a random temporary file with insecure default permissions.:LINK:https://www.cve.org/CVERecord?id=CVE-2021-21290::

::TAXONOMY NAME:CLASP:ENTRY NAME:Guessed or visible temporary file::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:FIO15-C:ENTRY NAME:Ensure that file operations are performed in a secure directory::

Covert Timing Channel

Base

Incomplete

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.

In some instances, knowing when data is transmitted between parties can provide a malicious user with privileged information. Also, externally monitoring the timing of operations can potentially reveal sensitive data. For example, a cryptographic operation can expose its internal state if the time it takes to perform the operation varies, based on the state. Covert channels are frequently classified as either storage or timing channels. Some examples of covert timing channels are the system's paging rate, the time a certain transaction requires to execute, and the time it takes to gain access to a shared bus.

::NATURE:ChildOf:CWE ID:514:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Confidentiality:SCOPE:Other:IMPACT:Read Application Data:IMPACT:Other:NOTE:Information exposure.::

::PHASE:Architecture and Design:DESCRIPTION:Whenever possible, specify implementation strategies that do not introduce time variances in operations.::PHASE:Implementation:DESCRIPTION:Often one can artificially manipulate the time which operations take or -- when operations occur -- can remove information from the attacker.::PHASE:Implementation:DESCRIPTION:It is reasonable to add artificial or random delays so that the amount of CPU time consumed is independent of the action being taken by the application.::

::TAXONOMY NAME:Landwehr:ENTRY NAME:Timing::TAXONOMY NAME:CLASP:ENTRY NAME:Covert Timing Channel::

::462::

::TYPE:Maintenance:NOTE:As of CWE 4.9, members of the CWE Hardware SIG are working to improve CWE's coverage of transient execution weaknesses, which include issues related to Spectre, Meltdown, and other attacks that create or exploit covert channels. As a result of that work, this entry might change in CWE 4.10.::

Symbolic Name not Mapping to Correct Object

Base

Draft

A constant symbolic reference to an object is used, even though the reference can resolve to a different object over time.

::NATURE:ChildOf:CWE ID:706:VIEW ID:1000:ORDINAL:Primary::NATURE:PeerOf:CWE ID:367:VIEW ID:1000::NATURE:PeerOf:CWE ID:610:VIEW ID:1000::NATURE:PeerOf:CWE ID:486:VIEW ID:1000::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Access Control:IMPACT:Gain Privileges or Assume Identity:NOTE:The attacker can gain access to otherwise unauthorized resources.::SCOPE:Integrity:SCOPE:Confidentiality:SCOPE:Other:IMPACT:Modify Application Data:IMPACT:Modify Files or Directories:IMPACT:Read Application Data:IMPACT:Read Files or Directories:IMPACT:Other:NOTE:Race conditions such as this kind may be employed to gain read or write access to resources not normally readable or writable by the user in question.::SCOPE:Integrity:SCOPE:Other:IMPACT:Modify Application Data:IMPACT:Other:NOTE:The resource in question, or other resources (through the corrupted one) may be changed in undesirable ways by a malicious user.::SCOPE:Non-Repudiation:IMPACT:Hide Activities:NOTE:If a file or other resource is written in this method, as opposed to a valid way, logging of the activity may not occur.::SCOPE:Non-Repudiation:SCOPE:Integrity:IMPACT:Modify Files or Directories:NOTE:In some cases it may be possible to delete files that a malicious user might not otherwise have access to -- such as log files.::

::TAXONOMY NAME:CLASP:ENTRY NAME:Symbolic name not mapping to correct object::

Detection of Error Condition Without Action

Base

Draft

The product detects a specific error, but takes no actions to handle the error.

::NATURE:ChildOf:CWE ID:755:VIEW ID:1000:ORDINAL:Primary::NATURE:CanPrecede:CWE ID:401:VIEW ID:1000::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation:NOTE:REALIZATION: This weakness is caused during implementation of an architectural security tactic.::

::SCOPE:Integrity:SCOPE:Other:IMPACT:Varies by Context:IMPACT:Unexpected State:IMPACT:Alter Execution Logic:NOTE:An attacker could utilize an ignored error condition to place the system in an unexpected state that could lead to the execution of unintended logic and could cause other unintended behavior.::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::PHASE:Implementation:DESCRIPTION:Properly handle each exception. This is the recommended solution. Ensure that all exceptions are handled in such a way that you can be sure of the state of your system at any given moment.::PHASE:Implementation:DESCRIPTION:If a function returns an error, it is important to either fix the problem and try again, alert the user that an error has happened and let the program continue, or alert the user and close and cleanup the program.::PHASE:Testing:DESCRIPTION:Subject the product to extensive testing to discover some of the possible instances of where/how errors or return values are not handled. Consider testing techniques such as ad hoc, equivalence partitioning, robustness and fault tolerance, mutation, and fuzzing.::

::REFERENCE:CVE-2022-21820:DESCRIPTION:A GPU data center manager detects an error due to a malformed request but does not act on it, leading to memory corruption.:LINK:https://www.cve.org/CVERecord?id=CVE-2022-21820::

::TAXONOMY NAME:CLASP:ENTRY NAME:Improper error handling::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:ERR00-J:ENTRY NAME:Do not suppress or ignore checked exceptions::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP4:ENTRY NAME:Unchecked Status Condition::

Unchecked Error Condition

Base

Incomplete

[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.

::NATURE:ChildOf:CWE ID:754:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:703:VIEW ID:1305:ORDINAL:Primary::NATURE:ChildOf:CWE ID:703:VIEW ID:1340:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation:NOTE:REALIZATION: This weakness is caused during implementation of an architectural security tactic.::

::SCOPE:Integrity:SCOPE:Other:IMPACT:Varies by Context:IMPACT:Unexpected State:IMPACT:Alter Execution Logic::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::PHASE:Requirements:DESCRIPTION:The choice between a language which has named or unnamed exceptions needs to be done. While unnamed exceptions exacerbate the chance of not properly dealing with an exception, named exceptions suffer from the up call version of the weak base class problem.::PHASE:Requirements:DESCRIPTION:A language can be used which requires, at compile time, to catch all serious exceptions. However, one must make sure to use the most current version of the API as new exceptions could be added.::PHASE:Implementation:DESCRIPTION:Catch all relevant exceptions. This is the recommended solution. Ensure that all exceptions are handled in such a way that you can be sure of the state of your system at any given moment.::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Unchecked Return Value::TAXONOMY NAME:7 Pernicious Kingdoms:ENTRY NAME:Empty Catch Block::TAXONOMY NAME:CLASP:ENTRY NAME:Uncaught exception::TAXONOMY NAME:OWASP Top Ten 2004:ENTRY ID:A7:ENTRY NAME:Improper Error Handling:MAPPING FIT:CWE More Specific::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:ERR00-C:ENTRY NAME:Adopt and implement a consistent and comprehensive error-handling policy::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:ERR33-C:ENTRY NAME:Detect and handle standard library errors:MAPPING FIT:CWE More Abstract::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:ERR34-C:ENTRY NAME:Detect errors when converting a string to a number:MAPPING FIT:CWE More Abstract::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:FLP32-C:ENTRY NAME:Prevent or detect domain and range errors in math functions:MAPPING FIT:Imprecise::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:POS54-C:ENTRY NAME:Detect and handle POSIX library errors:MAPPING FIT:CWE More Abstract::TAXONOMY NAME:SEI CERT Perl Coding Standard:ENTRY ID:EXP31-PL:ENTRY NAME:Do not suppress or ignore exceptions:MAPPING FIT:Imprecise::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP4:ENTRY NAME:Unchecked Status Condition::

::TYPE:Maintenance:NOTE:This entry is slated for deprecation; it has multiple widespread interpretations by CWE analysts. It currently combines information from three different taxonomies, but each taxonomy is talking about a slightly different issue. CWE analysts might map to this entry based on any of these issues. 7PK has Empty Catch Block which has an association with empty exception block (CWE-1069); in this case, the exception has performed the check, but does not handle. In PLOVER there is Unchecked Return Value which is CWE-252, but unlike Empty Catch Block there isn't even a check of the issue - and Unchecked Error Condition implies lack of a check. For CLASP, Uncaught Exception (CWE-248) is associated with incorrect error propagation - uncovered in CWE 3.2 and earlier, at least. There are other issues related to error handling and checks.::TYPE:Other:NOTE:When a programmer ignores an exception, they implicitly state that they are operating under one of two assumptions: This method call can never fail. It doesn't matter if this call fails.::

Missing Report of Error Condition

Base

Draft

The product encounters an error but does not provide a status code or return value to indicate that an error has occurred.

::NATURE:ChildOf:CWE ID:755:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:684:VIEW ID:1000::NATURE:ChildOf:CWE ID:703:VIEW ID:1305:ORDINAL:Primary::NATURE:ChildOf:CWE ID:703:VIEW ID:1340:ORDINAL:Primary::

::ORDINALITY:Primary::ORDINALITY:Resultant::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Other:IMPACT:Varies by Context:IMPACT:Unexpected State:NOTE:Errors that are not properly reported could place the system in an unexpected state that could lead to unintended behaviors.::

::REFERENCE:[REF-1374]:DESCRIPTION:Chain: JavaScript-based cryptocurrency library can fall back to the insecure Math.random() function instead of reporting a failure (CWE-392), thus reducing the entropy (CWE-332) and leading to generation of non-unique cryptographic keys for Bitcoin wallets (CWE-1391):LINK:https://www.unciphered.com/blog/randstorm-you-cant-patch-a-house-of-cards::REFERENCE:CVE-2004-0063:DESCRIPTION:Function returns OK even if another function returns a different status code than expected, leading to accepting an invalid PIN number.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-0063::REFERENCE:CVE-2002-1446:DESCRIPTION:Error checking routine in PKCS#11 library returns OK status even when invalid signature is detected, allowing spoofed messages.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1446::REFERENCE:CVE-2002-0499:DESCRIPTION:Kernel function truncates long pathnames without generating an error, leading to operation on wrong directory.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0499::REFERENCE:CVE-2005-2459:DESCRIPTION:Function returns non-error value when a particular erroneous condition is encountered, leading to resultant NULL dereference.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-2459::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Missing Error Status Code::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:TPS03-J:ENTRY NAME:Ensure that tasks executing in a thread pool do not fail silently::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP6:ENTRY NAME:Incorrect Exception Behavior::

Return of Wrong Status Code

Base

Draft

A function or operation returns an incorrect return value or status code that does not indicate an error, but causes the product to modify its behavior based on the incorrect result.

This can lead to unpredictable behavior. If the function is used to make security-critical decisions or provide security-critical information, then the wrong status code can cause the product to assume that an action is safe, even when it is not.

::NATURE:ChildOf:CWE ID:684:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:703:VIEW ID:1000::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Other:IMPACT:Unexpected State:IMPACT:Alter Execution Logic:NOTE:This weakness could place the system in a state that could lead unexpected logic to be executed or other unintended behaviors.::

::METHOD:Fuzzing:DESCRIPTION:Fuzz testing (fuzzing) is a powerful technique for generating large numbers of diverse inputs - either randomly or algorithmically - and dynamically invoking the code with those inputs. Even with random inputs, it is often capable of generating unexpected results such as crashes, memory corruption, or resource consumption. Fuzzing effectively produces repeatable test cases that clearly indicate bugs, which helps developers to diagnose the issues.:EFFECTIVENESS:High::

::REFERENCE:CVE-2003-1132:DESCRIPTION:DNS server returns wrong response code for non-existent AAAA record, which effectively says that the domain is inaccessible.:LINK:https://www.cve.org/CVERecord?id=CVE-2003-1132::REFERENCE:CVE-2001-1509:DESCRIPTION:Hardware-specific implementation of system call causes incorrect results from geteuid.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-1509::REFERENCE:CVE-2001-1559:DESCRIPTION:Chain: System call returns wrong value (CWE-393), leading to a resultant NULL dereference (CWE-476).:LINK:https://www.cve.org/CVERecord?id=CVE-2001-1559::REFERENCE:CVE-2014-1266:DESCRIPTION:chain: incorrect goto in Apple SSL product bypasses certificate validation, allowing Adversary-in-the-Middle (AITM) attack (Apple goto fail bug). CWE-705 (Incorrect Control Flow Scoping) -> CWE-561 (Dead Code) -> CWE-295 (Improper Certificate Validation) -> CWE-393 (Return of Wrong Status Code) -> CWE-300 (Channel Accessible by Non-Endpoint).:LINK:https://www.cve.org/CVERecord?id=CVE-2014-1266::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Wrong Status Code::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP6:ENTRY NAME:Incorrect Exception Behavior::

::TYPE:Relationship:NOTE:This can be primary or resultant, but it is probably most often primary to other issues.::

Unexpected Status Code or Return Value

Base

Draft

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.

::NATURE:ChildOf:CWE ID:754:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Other:IMPACT:Unexpected State:IMPACT:Alter Execution Logic::

::REFERENCE:CVE-2004-1395:DESCRIPTION:Certain packets (zero byte and other lengths) cause a recvfrom call to produce an unexpected return code that causes a server's listening loop to exit.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-1395::REFERENCE:CVE-2002-2124:DESCRIPTION:Unchecked return code from recv() leads to infinite loop.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-2124::REFERENCE:CVE-2005-2553:DESCRIPTION:Kernel function does not properly handle when a null is returned by a function call, causing it to call another function that it shouldn't.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-2553::REFERENCE:CVE-2005-1858:DESCRIPTION:Memory not properly cleared when read() function call returns fewer bytes than expected.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1858::REFERENCE:CVE-2000-0536:DESCRIPTION:Bypass access restrictions when connecting from IP whose DNS reverse lookup does not return a hostname.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0536::REFERENCE:CVE-2001-0910:DESCRIPTION:Bypass access restrictions when connecting from IP whose DNS reverse lookup does not return a hostname.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0910::REFERENCE:CVE-2004-2371:DESCRIPTION:Game server doesn't check return values for functions that handle text strings and associated size values.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-2371::REFERENCE:CVE-2005-1267:DESCRIPTION:Resultant infinite loop when function call returns -1 value.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1267::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Unexpected Status Code or Return Value::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP4:ENTRY NAME:Unchecked Status Condition::TAXONOMY NAME:SEI CERT Perl Coding Standard:ENTRY ID:EXP00-PL:ENTRY NAME:Do not return undef:MAPPING FIT:Imprecise::

::TYPE:Relationship:NOTE:Usually primary, but can be resultant from issues such as behavioral change or API abuse. This can produce resultant vulnerabilities.::

Use of NullPointerException Catch to Detect NULL Pointer Dereference

Base

Draft

Catching NullPointerException should not be used as an alternative to programmatic checks to prevent dereferencing a null pointer.

Programmers typically catch NullPointerException under three circumstances: The program contains a null pointer dereference. Catching the resulting exception was easier than fixing the underlying problem. The program explicitly throws a NullPointerException to signal an error condition. The code is part of a test harness that supplies unexpected input to the classes under test. Of these three circumstances, only the last is acceptable.

::NATURE:ChildOf:CWE ID:705:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:755:VIEW ID:1000::

::LANGUAGE NAME:Java:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Availability:IMPACT:DoS: Resource Consumption (CPU)::

::METHOD:Automated Static Analysis - Binary or Bytecode:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Cost effective for partial coverage: Bytecode Weakness Analysis - including disassembler + source code weakness analysis Binary Weakness Analysis - including disassembler + source code weakness analysis:EFFECTIVENESS:SOAR Partial::METHOD:Dynamic Analysis with Manual Results Interpretation:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Cost effective for partial coverage: Framework-based Fuzzer:EFFECTIVENESS:SOAR Partial::METHOD:Manual Static Analysis - Source Code:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Cost effective for partial coverage: Manual Source Code Review (not inspections):EFFECTIVENESS:SOAR Partial::METHOD:Automated Static Analysis - Source Code:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Highly cost effective: Source code Weakness Analyzer Context-configured Source Code Weakness Analyzer:EFFECTIVENESS:High::METHOD:Architecture or Design Review:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Highly cost effective: Formal Methods / Correct-By-Construction Cost effective for partial coverage: Inspection (IEEE 1028 standard) (can apply to requirements, design, source code, etc.):EFFECTIVENESS:High::

::PHASE:Architecture and Design Implementation:DESCRIPTION:Do not extensively rely on catching exceptions (especially for validating user input) to handle errors. Handling exceptions can decrease the performance of an application.::

::TAXONOMY NAME:7 Pernicious Kingdoms:ENTRY NAME:Catching NullPointerException::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:ERR08-J:ENTRY NAME:Do not catch NullPointerException or any of its ancestors::

Declaration of Catch for Generic Exception

Base

Draft

Catching overly broad exceptions promotes complex error handling code that is more likely to contain security vulnerabilities.

Multiple catch blocks can get ugly and repetitive, but condensing catch blocks by catching a high-level class like Exception can obscure exceptions that deserve special treatment or that should not be caught at this point in the program. Catching an overly broad exception essentially defeats the purpose of a language's typed exceptions, and can become particularly dangerous if the program grows and begins to throw new types of exceptions. The new exception types will not receive any attention.

::NATURE:ChildOf:CWE ID:705:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:755:VIEW ID:1000::NATURE:ChildOf:CWE ID:221:VIEW ID:1000::

::LANGUAGE NAME:C++:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:Java:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C#:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:Python:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Non-Repudiation:SCOPE:Other:IMPACT:Hide Activities:IMPACT:Alter Execution Logic::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::TAXONOMY NAME:7 Pernicious Kingdoms:ENTRY NAME:Overly-Broad Catch Block::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP5:ENTRY NAME:Ambiguous Exception Type::TAXONOMY NAME:OMG ASCSM:ENTRY ID:ASCSM-CWE-396::TAXONOMY NAME:OMG ASCRM:ENTRY ID:ASCRM-CWE-396::

Declaration of Throws for Generic Exception

Base

Draft

Throwing overly broad exceptions promotes complex error handling code that is more likely to contain security vulnerabilities.

Declaring a method to throw Exception or Throwable makes it difficult for callers to perform proper error handling and error recovery. Java's exception mechanism, for example, is set up to make it easy for callers to anticipate what can go wrong and write code to handle each specific exceptional circumstance. Declaring that a method throws a generic form of exception defeats this system.

::NATURE:ChildOf:CWE ID:705:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:221:VIEW ID:1000::NATURE:ChildOf:CWE ID:703:VIEW ID:1000::

::LANGUAGE NAME:C++:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:Java:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C#:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Non-Repudiation:SCOPE:Other:IMPACT:Hide Activities:IMPACT:Alter Execution Logic::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::TAXONOMY NAME:7 Pernicious Kingdoms:ENTRY NAME:Overly-Broad Throws Declaration::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:ERR07-J:ENTRY NAME:Do not throw RuntimeException, Exception, or Throwable::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP5:ENTRY NAME:Ambiguous Exception Type::TAXONOMY NAME:OMG ASCSM:ENTRY ID:ASCSM-CWE-397::TAXONOMY NAME:OMG ASCRM:ENTRY ID:ASCRM-CWE-397::

::TYPE:Applicable Platform:NOTE:For C++, this weakness only applies to C++98, C++03, and C++11. It relies on a feature known as Dynamic Exception Specification, which was part of early versions of C++ but was deprecated in C++11. It has been removed for C++17 and later.::

Exposure of File Descriptor to Unintended Control Sphere ('File Descriptor Leak')

Base

Draft

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.

When a new process is forked or executed, the child process inherits any open file descriptors. When the child process has fewer privileges than the parent process, this might introduce a vulnerability if the child process can access the file descriptor but does not have the privileges to access the associated file.

::NATURE:ChildOf:CWE ID:402:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::OPERATING SYSTEM CLASS:Unix:OPERATING SYSTEM PREVALENCE:Undetermined::

::TERM:File descriptor leak:DESCRIPTION:While this issue is frequently called a file descriptor leak, the leak term is often used in two different ways - exposure of a resource, or consumption of a resource. Use of this term could cause confusion.::

::PHASE:Implementation:NOTE:REALIZATION: This weakness is caused during implementation of an architectural security tactic.::

::SCOPE:Confidentiality:SCOPE:Integrity:IMPACT:Read Application Data:IMPACT:Modify Application Data::

::REFERENCE:CVE-2003-0740:DESCRIPTION:Server leaks a privileged file descriptor, allowing the server to be hijacked.:LINK:https://www.cve.org/CVERecord?id=CVE-2003-0740::REFERENCE:CVE-2004-1033:DESCRIPTION:File descriptor leak allows read of restricted files.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-1033::REFERENCE:CVE-2000-0094:DESCRIPTION:Access to restricted resource using modified file descriptor for stderr.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0094::REFERENCE:CVE-2002-0638:DESCRIPTION:Open file descriptor used as alternate channel in complex race condition.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0638::REFERENCE:CVE-2003-0489:DESCRIPTION:Program does not fully drop privileges after creating a file descriptor, which allows access to the descriptor via a separate vulnerability.:LINK:https://www.cve.org/CVERecord?id=CVE-2003-0489::REFERENCE:CVE-2003-0937:DESCRIPTION:User bypasses restrictions by obtaining a file descriptor then calling setuid program, which does not close the descriptor.:LINK:https://www.cve.org/CVERecord?id=CVE-2003-0937::REFERENCE:CVE-2004-2215:DESCRIPTION:Terminal manager does not properly close file descriptors, allowing attackers to access terminals of other users.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-2215::REFERENCE:CVE-2006-5397:DESCRIPTION:Module opens a file for reading twice, allowing attackers to read files.:LINK:https://www.cve.org/CVERecord?id=CVE-2006-5397::

::System Process::File or Directory::

::TAXONOMY NAME:PLOVER:ENTRY NAME:UNIX file descriptor leak::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:FIO42-C:ENTRY NAME:Ensure files are properly closed when they are no longer needed::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP23:ENTRY NAME:Exposed Data::

Incorrect Behavior Order: Early Amplification

Base

Draft

The product allows an entity to perform a legitimate but expensive operation before authentication or authorization has taken place.

::NATURE:ChildOf:CWE ID:405:VIEW ID:1000::NATURE:ChildOf:CWE ID:696:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Availability:IMPACT:DoS: Amplification:IMPACT:DoS: Crash, Exit, or Restart:IMPACT:DoS: Resource Consumption (CPU):IMPACT:DoS: Resource Consumption (Memory):NOTE:System resources, CPU and memory, can be quickly consumed. This can lead to poor system performance or system crash.::

::REFERENCE:CVE-2004-2458:DESCRIPTION:Tool creates directories before authenticating user.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-2458::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Early Amplification::

::TYPE:Relationship:NOTE:Overlaps authentication errors.::

Improper Handling of Highly Compressed Data (Data Amplification)

Base

Incomplete

The product does not handle or incorrectly handles a compressed input with a very high compression ratio that produces a large output.

An example of data amplification is a decompression bomb, a small ZIP file that can produce a large amount of data when it is decompressed.

::NATURE:ChildOf:CWE ID:405:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Availability:IMPACT:DoS: Amplification:IMPACT:DoS: Crash, Exit, or Restart:IMPACT:DoS: Resource Consumption (CPU):IMPACT:DoS: Resource Consumption (Memory):NOTE:System resources, CPU and memory, can be quickly consumed. This can lead to poor system performance or system crash.::

::REFERENCE:CVE-2009-1955:DESCRIPTION:XML bomb in web server module:LINK:https://www.cve.org/CVERecord?id=CVE-2009-1955::REFERENCE:CVE-2003-1564:DESCRIPTION:Parsing library allows XML bomb:LINK:https://www.cve.org/CVERecord?id=CVE-2003-1564::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Data Amplification::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:IDS04-J:ENTRY NAME:Limit the size of files passed to ZipInputStream::

Insufficient Resource Pool

Base

Incomplete

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.

Frequently the consequence is a flood of connection or sessions.

::NATURE:ChildOf:CWE ID:664:VIEW ID:1000:ORDINAL:Primary::NATURE:CanPrecede:CWE ID:400:VIEW ID:1000::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::PHASE:Operation::

::SCOPE:Availability:SCOPE:Integrity:SCOPE:Other:IMPACT:DoS: Crash, Exit, or Restart:IMPACT:Other:NOTE:Floods often cause a crash or other problem besides denial of the resource itself; these are likely examples of *other* vulnerabilities, not an insufficient resource pool.::

::PHASE:Architecture and Design:DESCRIPTION:Do not perform resource-intensive transactions for unauthenticated users and/or invalid requests.::PHASE:Architecture and Design:DESCRIPTION:Consider implementing a velocity check mechanism which would detect abusive behavior.::PHASE:Operation:DESCRIPTION:Consider load balancing as an option to handle heavy loads.::PHASE:Implementation:DESCRIPTION:Make sure that resource handles are properly closed when no longer needed.::PHASE:Architecture and Design:DESCRIPTION:Identify the system's resource intensive operations and consider protecting them from abuse (e.g. malicious automated script which runs the resources out).::

::REFERENCE:CVE-1999-1363:DESCRIPTION:Large number of locks on file exhausts the pool and causes crash.:LINK:https://www.cve.org/CVERecord?id=CVE-1999-1363::REFERENCE:CVE-2001-1340:DESCRIPTION:Product supports only one connection and does not disconnect a user who does not provide credentials.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-1340::REFERENCE:CVE-2002-0406:DESCRIPTION:Large number of connections without providing credentials allows connection exhaustion.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0406::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Insufficient Resource Pool::TAXONOMY NAME:OWASP Top Ten 2004:ENTRY ID:A9:ENTRY NAME:Denial of Service:MAPPING FIT:CWE More Specific::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:TPS00-J:ENTRY NAME:Use thread pools to enable graceful degradation of service during traffic bursts::

Unrestricted Externally Accessible Lock

Base

Incomplete

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.

This prevents the product from acting on associated resources or performing other behaviors that are controlled by the presence of the lock. Relevant locks might include an exclusive lock or mutex, or modifying a shared resource that is treated as a lock. If the lock can be held for an indefinite period of time, then the denial of service could be permanent.

::NATURE:ChildOf:CWE ID:667:VIEW ID:1000:ORDINAL:Primary::NATURE:CanAlsoBe:CWE ID:410:VIEW ID:1000::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Availability:IMPACT:DoS: Resource Consumption (Other):NOTE:When an attacker can control a lock, the program may wait indefinitely until the attacker releases the lock, causing a denial of service to other users of the program. This is especially problematic if there is a blocking operation on the lock.::

::METHOD:White Box:DESCRIPTION:Automated code analysis techniques might not be able to reliably detect this weakness, since the application's behavior and general security model dictate which resource locks are critical. Interpretation of the weakness might require knowledge of the environment, e.g. if the existence of a file is used as a lock, but the file is created in a world-writable directory.::

::PHASE:Architecture and Design Implementation:DESCRIPTION:Use any access control that is offered by the functionality that is offering the lock.::PHASE:Architecture and Design Implementation:DESCRIPTION:Use unpredictable names or identifiers for the locks. This might not always be possible or feasible.::PHASE:Architecture and Design:DESCRIPTION:Consider modifying your code to use non-blocking synchronization methods.::

::REFERENCE:CVE-2001-0682:DESCRIPTION:Program can not execute when attacker obtains a mutex.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0682::REFERENCE:CVE-2002-1914:DESCRIPTION:Program can not execute when attacker obtains a lock on a critical output file.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1914::REFERENCE:CVE-2002-1915:DESCRIPTION:Program can not execute when attacker obtains a lock on a critical output file.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1915::REFERENCE:CVE-2002-0051:DESCRIPTION:Critical file can be opened with exclusive read access by user, preventing application of security policy. Possibly related to improper permissions, large-window race condition.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0051::REFERENCE:CVE-2000-0338:DESCRIPTION:Chain: predictable file names used for locking, allowing attacker to create the lock beforehand. Resultant from permissions and randomness.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0338::REFERENCE:CVE-2000-1198:DESCRIPTION:Chain: Lock files with predictable names. Resultant from randomness.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-1198::REFERENCE:CVE-2002-1869:DESCRIPTION:Product does not check if it can write to a log file, allowing attackers to avoid logging by accessing the file using an exclusive lock. Overlaps unchecked error condition. This is not quite CWE-412, but close.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1869::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Unrestricted Critical Resource Lock::TAXONOMY NAME:7 Pernicious Kingdoms:ENTRY NAME:Deadlock::TAXONOMY NAME:OWASP Top Ten 2004:ENTRY ID:A9:ENTRY NAME:Denial of Service:MAPPING FIT:CWE More Specific::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:LCK00-J:ENTRY NAME:Use private final lock objects to synchronize classes that may interact with untrusted code::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:LCK07-J:ENTRY NAME:Avoid deadlock by requesting and releasing locks in the same order::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP22:ENTRY NAME:Unrestricted lock::

::25::

::TYPE:Relationship:NOTE:This overlaps Insufficient Resource Pool when the pool is of size 1. It can also be resultant from race conditions, although the timing window could be quite large in some cases.::

Improper Resource Locking

Base

Draft

The product does not lock or does not correctly lock a resource when the product must have exclusive access to the resource.

When a resource is not properly locked, an attacker could modify the resource while it is being operated on by the product. This might violate the product's assumption that the resource will not change, potentially leading to unexpected behaviors.

::NATURE:ChildOf:CWE ID:667:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Availability:IMPACT:Modify Application Data:IMPACT:DoS: Instability:IMPACT:DoS: Crash, Exit, or Restart::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::PHASE:Architecture and Design:DESCRIPTION:Use a non-conflicting privilege scheme.::PHASE:Architecture and Design Implementation:DESCRIPTION:Use synchronization when locking a resource.::

::REFERENCE:CVE-2022-20141:DESCRIPTION:Chain: an operating system kernel has insufficent resource locking (CWE-413) leading to a use after free (CWE-416).:LINK:https://www.cve.org/CVERecord?id=CVE-2022-20141::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Insufficient Resource Locking::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:VNA00-J:ENTRY NAME:Ensure visibility when accessing shared primitive variables::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:VNA02-J:ENTRY NAME:Ensure that compound operations on shared variables are atomic::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:LCK00-J:ENTRY NAME:Use private final lock objects to synchronize classes that may interact with untrusted code::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP19:ENTRY NAME:Missing Lock::

Missing Lock Check

Base

Draft

A product does not check to see if a lock is present before performing sensitive operations on a resource.

::NATURE:ChildOf:CWE ID:667:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Availability:IMPACT:Modify Application Data:IMPACT:DoS: Instability:IMPACT:DoS: Crash, Exit, or Restart::

::PHASE:Architecture and Design Implementation:DESCRIPTION:Implement a reliable lock mechanism.::

::REFERENCE:CVE-2004-1056:DESCRIPTION:Product does not properly check if a lock is present, allowing other attackers to access functionality.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-1056::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Missing Lock Check::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP19:ENTRY NAME:Missing Lock::

Unprotected Primary Channel

Base

Draft

The product uses a primary channel for administration or restricted functionality, but it does not properly protect the channel.

::NATURE:ChildOf:CWE ID:923:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design:NOTE:OMISSION: This weakness is caused by missing a security tactic during the architecture and design phase.::PHASE:Implementation::

::SCOPE:Access Control:IMPACT:Gain Privileges or Assume Identity:IMPACT:Bypass Protection Mechanism::

::PHASE:Architecture and Design:DESCRIPTION:Do not expose administrative functionnality on the user UI.::PHASE:Architecture and Design:DESCRIPTION:Protect the administrative/restricted functionality with a strong authentication mechanism.::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Unprotected Primary Channel::

::383::

Unprotected Alternate Channel

Base

Draft

The product protects a primary channel, but it does not use the same level of protection for an alternate channel.

::NATURE:ChildOf:CWE ID:923:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design:NOTE:OMISSION: This weakness is caused by missing a security tactic during the architecture and design phase.::PHASE:Implementation::PHASE:Operation::

::SCOPE:Access Control:IMPACT:Gain Privileges or Assume Identity:IMPACT:Bypass Protection Mechanism::

::PHASE:Architecture and Design:DESCRIPTION:Identify all alternate channels and use the same protection mechanisms that are used for the primary channels.::

::REFERENCE:CVE-2020-8004:DESCRIPTION:When the internal flash is protected by blocking access on the Data Bus (DBUS), it can still be indirectly accessed through the Instruction Bus (IBUS).:LINK:https://www.cve.org/CVERecord?id=CVE-2020-8004::REFERENCE:CVE-2002-0567:DESCRIPTION:DB server assumes that local clients have performed authentication, allowing attacker to directly connect to a process to load libraries and execute commands; a socket interface also exists (another alternate channel), so attack can be remote.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0567::REFERENCE:CVE-2002-1578:DESCRIPTION:Product does not restrict access to underlying database, so attacker can bypass restrictions by directly querying the database.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1578::REFERENCE:CVE-2003-1035:DESCRIPTION:User can avoid lockouts by using an API instead of the GUI to conduct brute force password guessing.:LINK:https://www.cve.org/CVERecord?id=CVE-2003-1035::REFERENCE:CVE-2002-1863:DESCRIPTION:FTP service can not be disabled even when other access controls would require it.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1863::REFERENCE:CVE-2002-0066:DESCRIPTION:Windows named pipe created without authentication/access control, allowing configuration modification.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0066::REFERENCE:CVE-2004-1461:DESCRIPTION:Router management interface spawns a separate TCP connection after authentication, allowing hijacking by attacker coming from the same IP address.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-1461::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Unprotected Alternate Channel::

::TYPE:Relationship:NOTE:This can be primary to authentication errors, and resultant from unhandled error conditions.::

Race Condition During Access to Alternate Channel

Base

Draft

The product opens an alternate channel to communicate with an authorized user, but the channel is accessible to other actors.

This creates a race condition that allows an attacker to access the channel before the authorized user does.

::NATURE:ChildOf:CWE ID:420:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:362:VIEW ID:1000::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::

::SCOPE:Access Control:IMPACT:Gain Privileges or Assume Identity:IMPACT:Bypass Protection Mechanism::

::REFERENCE:CVE-1999-0351:DESCRIPTION:FTP Pizza Thief vulnerability. Attacker can connect to a port that was intended for use by another client.:LINK:https://www.cve.org/CVERecord?id=CVE-1999-0351::REFERENCE:CVE-2003-0230:DESCRIPTION:Product creates Windows named pipe during authentication that another attacker can hijack by connecting to it.:LINK:https://www.cve.org/CVERecord?id=CVE-2003-0230::

::System Process::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Alternate Channel Race Condition::

Direct Request ('Forced Browsing')

Base

Incomplete

The web application does not adequately enforce appropriate authorization on all restricted URLs, scripts, or files.

Web applications susceptible to direct request attacks often make the false assumption that such resources can only be reached through a given navigation path and so only apply authorization at certain points in the path.

::NATURE:ChildOf:CWE ID:862:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:862:VIEW ID:1003:ORDINAL:Primary::NATURE:ChildOf:CWE ID:288:VIEW ID:1000::NATURE:ChildOf:CWE ID:424:VIEW ID:1000::NATURE:CanPrecede:CWE ID:471:VIEW ID:1000::NATURE:CanPrecede:CWE ID:98:VIEW ID:1000::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::TECHNOLOGY CLASS:Web Based:TECHNOLOGY PREVALENCE:Undetermined::

::TERM:forced browsing:DESCRIPTION:The forced browsing term could be misinterpreted to include weaknesses such as CSRF or XSS, so its use is discouraged.::

::PHASE:Implementation::PHASE:Operation::

::SCOPE:Confidentiality:SCOPE:Integrity:SCOPE:Availability:SCOPE:Access Control:IMPACT:Read Application Data:IMPACT:Modify Application Data:IMPACT:Execute Unauthorized Code or Commands:IMPACT:Gain Privileges or Assume Identity::

::PHASE:Architecture and Design Operation:DESCRIPTION:Apply appropriate access control authorizations for each access to all restricted URLs, scripts or files.::PHASE:Architecture and Design:DESCRIPTION:Consider using MVC based frameworks such as Struts.::

::REFERENCE:CVE-2022-29238:DESCRIPTION:Access-control setting in web-based document collaboration tool is not properly implemented by the code, which prevents listing hidden directories but does not prevent direct requests to files in those directories.:LINK:https://www.cve.org/CVERecord?id=CVE-2022-29238::REFERENCE:CVE-2022-23607:DESCRIPTION:Python-based HTTP library did not scope cookies to a particular domain such that supercookies could be sent to any domain on redirect.:LINK:https://www.cve.org/CVERecord?id=CVE-2022-23607::REFERENCE:CVE-2004-2144:DESCRIPTION:Bypass authentication via direct request.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-2144::REFERENCE:CVE-2005-1892:DESCRIPTION:Infinite loop or infoleak triggered by direct requests.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1892::REFERENCE:CVE-2004-2257:DESCRIPTION:Bypass auth/auth via direct request.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-2257::REFERENCE:CVE-2005-1688:DESCRIPTION:Direct request leads to infoleak by error.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1688::REFERENCE:CVE-2005-1697:DESCRIPTION:Direct request leads to infoleak by error.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1697::REFERENCE:CVE-2005-1698:DESCRIPTION:Direct request leads to infoleak by error.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1698::REFERENCE:CVE-2005-1685:DESCRIPTION:Authentication bypass via direct request.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1685::REFERENCE:CVE-2005-1827:DESCRIPTION:Authentication bypass via direct request.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1827::REFERENCE:CVE-2005-1654:DESCRIPTION:Authorization bypass using direct request.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1654::REFERENCE:CVE-2005-1668:DESCRIPTION:Access privileged functionality using direct request.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1668::REFERENCE:CVE-2002-1798:DESCRIPTION:Upload arbitrary files via direct request.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1798::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Direct Request aka 'Forced Browsing'::TAXONOMY NAME:OWASP Top Ten 2007:ENTRY ID:A10:ENTRY NAME:Failure to Restrict URL Access:MAPPING FIT:CWE More Specific::TAXONOMY NAME:OWASP Top Ten 2004:ENTRY ID:A1:ENTRY NAME:Unvalidated Input:MAPPING FIT:CWE More Specific::TAXONOMY NAME:OWASP Top Ten 2004:ENTRY ID:A2:ENTRY NAME:Broken Access Control:MAPPING FIT:CWE More Specific::TAXONOMY NAME:WASC:ENTRY ID:34:ENTRY NAME:Predictable Resource Location::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP30:ENTRY NAME:Missing endpoint authentication::

::127::143::144::668::87::

::TYPE:Relationship:NOTE:Overlaps Modification of Assumed-Immutable Data (MAID), authorization errors, container errors; often primary to other weaknesses such as XSS and SQL injection.::TYPE:Theoretical:NOTE:Forced browsing is a step-based manipulation involving the omission of one or more steps, whose order is assumed to be immutable. The application does not verify that the first step was performed successfully before the second step. The consequence is typically authentication bypass or path disclosure, although it can be primary to all kinds of weaknesses, especially in languages such as PHP, which allow external modification of assumed-immutable variables.::

Untrusted Search Path

Base

Stable

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.

This might allow attackers to execute their own programs, access unauthorized data files, or modify configuration in unexpected ways. If the product uses a search path to locate critical resources such as programs, then an attacker could modify that search path to point to a malicious program, which the targeted product would then execute. The problem extends to any type of critical resource that the product trusts. Some of the most common variants of untrusted search path are: In various UNIX and Linux-based systems, the PATH environment variable may be consulted to locate executable programs, and LD_PRELOAD may be used to locate a separate library. In various Microsoft-based systems, the PATH environment variable is consulted to locate a DLL, if the DLL is not found in other paths that appear earlier in the search order.

::NATURE:ChildOf:CWE ID:642:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:668:VIEW ID:1003:ORDINAL:Primary::NATURE:ChildOf:CWE ID:673:VIEW ID:1000::NATURE:PeerOf:CWE ID:427:VIEW ID:1000::NATURE:PeerOf:CWE ID:428:VIEW ID:1000::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::OPERATING SYSTEM CLASS:Not OS-Specific:OPERATING SYSTEM PREVALENCE:Undetermined::

::TERM:Untrusted Path::

::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Confidentiality:SCOPE:Availability:SCOPE:Access Control:IMPACT:Gain Privileges or Assume Identity:IMPACT:Execute Unauthorized Code or Commands:NOTE:There is the potential for arbitrary code execution with privileges of the vulnerable program.::SCOPE:Availability:IMPACT:DoS: Crash, Exit, or Restart:NOTE:The program could be redirected to the wrong files, potentially triggering a crash or hang when the targeted file is too large or does not have the expected format.::SCOPE:Confidentiality:IMPACT:Read Files or Directories:NOTE:The program could send the output of unauthorized files to the attacker.::

::METHOD:Black Box:DESCRIPTION:Use monitoring tools that examine the software's process as it interacts with the operating system and the network. This technique is useful in cases when source code is unavailable, if the software was not developed by you, or if you want to verify that the build phase did not introduce any new weaknesses. Examples include debuggers that directly attach to the running process; system-call tracing utilities such as truss (Solaris) and strace (Linux); system activity monitors such as FileMon, RegMon, Process Monitor, and other Sysinternals utilities (Windows); and sniffers and protocol analyzers that monitor network traffic. Attach the monitor to the process and look for library functions and system calls that suggest when a search path is being used. One pattern is when the program performs multiple accesses of the same file but in different directories, with repeated failures until the proper filename is found. Library calls such as getenv() or their equivalent can be checked to see if any path-related variables are being accessed.::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::METHOD:Manual Analysis:DESCRIPTION:Use tools and techniques that require manual (human) analysis, such as penetration testing, threat modeling, and interactive tools that allow the tester to record and modify an active session. These may be more effective than strictly automated techniques. This is especially the case with weaknesses that are related to design and business rules.::

::PHASE:Architecture and Design Implementation:STRATEGY:Attack Surface Reduction:DESCRIPTION:Hard-code the search path to a set of known-safe values (such as system directories), or only allow them to be specified by the administrator in a configuration file. Do not allow these settings to be modified by an external party. Be careful to avoid related weaknesses such as CWE-426 and CWE-428.::PHASE:Implementation:DESCRIPTION:When invoking other programs, specify those programs using fully-qualified pathnames. While this is an effective approach, code that uses fully-qualified pathnames might not be portable to other systems that do not use the same pathnames. The portability can be improved by locating the full-qualified paths in a centralized, easily-modifiable location within the source code, and having the code refer to these paths.::PHASE:Implementation:DESCRIPTION:Remove or restrict all environment settings before invoking other programs. This includes the PATH environment variable, LD_LIBRARY_PATH, and other settings that identify the location of code libraries, and any application-specific search paths.::PHASE:Implementation:DESCRIPTION:Check your search path before use and remove any elements that are likely to be unsafe, such as the current working directory or a temporary files directory.::PHASE:Implementation:DESCRIPTION:Use other functions that require explicit paths. Making use of any of the other readily available functions that require explicit paths is a safe way to avoid this problem. For example, system() in C does not require a full path since the shell can take care of it, while execl() and execv() require a full path.::

::REFERENCE:CVE-1999-1120:DESCRIPTION:Application relies on its PATH environment variable to find and execute program.:LINK:https://www.cve.org/CVERecord?id=CVE-1999-1120::REFERENCE:CVE-2008-1810:DESCRIPTION:Database application relies on its PATH environment variable to find and execute program.:LINK:https://www.cve.org/CVERecord?id=CVE-2008-1810::REFERENCE:CVE-2007-2027:DESCRIPTION:Chain: untrusted search path enabling resultant format string by loading malicious internationalization messages.:LINK:https://www.cve.org/CVERecord?id=CVE-2007-2027::REFERENCE:CVE-2008-3485:DESCRIPTION:Untrusted search path using malicious .EXE in Windows environment.:LINK:https://www.cve.org/CVERecord?id=CVE-2008-3485::REFERENCE:CVE-2008-2613:DESCRIPTION:setuid program allows compromise using path that finds and loads a malicious library.:LINK:https://www.cve.org/CVERecord?id=CVE-2008-2613::REFERENCE:CVE-2008-1319:DESCRIPTION:Server allows client to specify the search path, which can be modified to point to a program that the client has uploaded.:LINK:https://www.cve.org/CVERecord?id=CVE-2008-1319::

::Program Invocation::Code Libraries::

::System Process::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Untrusted Search Path::TAXONOMY NAME:CLASP:ENTRY NAME:Relative path library search::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:ENV03-C:ENTRY NAME:Sanitize the environment when invoking external programs::

::38::

Uncontrolled Search Path Element

Base

Draft

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.

Although this weakness can occur with any type of resource, it is frequently introduced when a product uses a directory search path to find executables or code libraries, but the path contains a directory that can be modified by an attacker, such as /tmp or the current working directory. In Windows-based systems, when the LoadLibrary or LoadLibraryEx function is called with a DLL name that does not contain a fully qualified path, the function follows a search order that includes two path elements that might be uncontrolled: the directory from which the program has been loaded the current working directory In some cases, the attack can be conducted remotely, such as when SMB or WebDAV network shares are used. One or more locations in that path could include the Windows drive root or its subdirectories. This often exists in Linux-based code assuming the controlled nature of the root directory (/) or its subdirectories (/etc, etc), or a code that recursively accesses the parent directory. In Windows, the drive root and some of its subdirectories have weak permissions by default, which makes them uncontrolled. In some Unix-based systems, a PATH might be created that contains an empty element, e.g. by splicing an empty variable into the PATH. This empty element can be interpreted as equivalent to the current working directory, which might be an untrusted search element. In software package management frameworks (e.g., npm, RubyGems, or PyPi), the framework may identify dependencies on third-party libraries or other packages, then consult a repository that contains the desired package. The framework may search a public repository before a private repository. This could be exploited by attackers by placing a malicious package in the public repository that has the same name as a package from the private repository. The search path might not be directly under control of the developer relying on the framework, but this search order effectively contains an untrusted element.

::NATURE:ChildOf:CWE ID:668:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:668:VIEW ID:1003:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::OPERATING SYSTEM CLASS:Not OS-Specific:OPERATING SYSTEM PREVALENCE:Undetermined::

::TERM:DLL preloading:DESCRIPTION:This term is one of several that are used to describe exploitation of untrusted search path elements in Windows systems, which received wide attention in August 2010. From a weakness perspective, the term is imprecise because it can apply to both CWE-426 and CWE-427.::TERM:Binary planting:DESCRIPTION:This term is one of several that are used to describe exploitation of untrusted search path elements in Windows systems, which received wide attention in August 2010. From a weakness perspective, the term is imprecise because it can apply to both CWE-426 and CWE-427.::TERM:Insecure library loading:DESCRIPTION:This term is one of several that are used to describe exploitation of untrusted search path elements in Windows systems, which received wide attention in August 2010. From a weakness perspective, the term is imprecise because it can apply to both CWE-426 and CWE-427.::TERM:Dependency confusion:DESCRIPTION:As of February 2021, this term is used to describe CWE-427 in the context of managing installation of software package dependencies, in which attackers release packages on public sites where the names are the same as package names used by private repositories, and the search for the dependent package tries the public site first, downloading untrusted code. It may also be referred to as a substitution attack.::

::PHASE:Implementation::

::SCOPE:Confidentiality:SCOPE:Integrity:SCOPE:Availability:IMPACT:Execute Unauthorized Code or Commands::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::PHASE:Architecture and Design Implementation:STRATEGY:Attack Surface Reduction:DESCRIPTION:Hard-code the search path to a set of known-safe values (such as system directories), or only allow them to be specified by the administrator in a configuration file. Do not allow these settings to be modified by an external party. Be careful to avoid related weaknesses such as CWE-426 and CWE-428.::PHASE:Implementation:STRATEGY:Attack Surface Reduction:DESCRIPTION:When invoking other programs, specify those programs using fully-qualified pathnames. While this is an effective approach, code that uses fully-qualified pathnames might not be portable to other systems that do not use the same pathnames. The portability can be improved by locating the full-qualified paths in a centralized, easily-modifiable location within the source code, and having the code refer to these paths.::PHASE:Implementation:STRATEGY:Attack Surface Reduction:DESCRIPTION:Remove or restrict all environment settings before invoking other programs. This includes the PATH environment variable, LD_LIBRARY_PATH, and other settings that identify the location of code libraries, and any application-specific search paths.::PHASE:Implementation:DESCRIPTION:Check your search path before use and remove any elements that are likely to be unsafe, such as the current working directory or a temporary files directory. Since this is a denylist approach, it might not be a complete solution.::PHASE:Implementation:DESCRIPTION:Use other functions that require explicit paths. Making use of any of the other readily available functions that require explicit paths is a safe way to avoid this problem. For example, system() in C does not require a full path since the shell can take care of finding the program using the PATH environment variable, while execl() and execv() require a full path.::

::REFERENCE:CVE-2023-25815:DESCRIPTION:chain: a change in an underlying package causes the gettext function to use implicit initialization with a hard-coded path (CWE-1419) under the user-writable C: drive, introducing an untrusted search path element (CWE-427) that enables spoofing of messages.:LINK:https://www.cve.org/CVERecord?id=CVE-2023-25815::REFERENCE:CVE-2022-4826:DESCRIPTION:Go-based git extension on Windows can search for and execute a malicious ..exe in a repository because Go searches the current working directory if git.exe is not found in the PATH:LINK:https://www.cve.org/CVERecord?id=CVE-2022-4826::REFERENCE:CVE-2020-26284:DESCRIPTION:A Static Site Generator built in Go, when running on Windows, searches the current working directory for a command, possibly allowing code execution using a malicious .exe or .bat file with the name being searched:LINK:https://www.cve.org/CVERecord?id=CVE-2020-26284::REFERENCE:CVE-2022-24765:DESCRIPTION:Windows-based fork of git creates a .git folder in the C: drive, allowing local attackers to create a .git folder with a malicious config file:LINK:https://www.cve.org/CVERecord?id=CVE-2022-24765::REFERENCE:CVE-2019-1552:DESCRIPTION:SSL package searches under C:/usr/local for configuration files and other critical data, but C:/usr/local might be world-writable.:LINK:https://www.cve.org/CVERecord?id=CVE-2019-1552::REFERENCE:CVE-2010-3402:DESCRIPTION:DLL hijacking issue in document editor.:LINK:https://www.cve.org/CVERecord?id=CVE-2010-3402::REFERENCE:CVE-2010-3397:DESCRIPTION:DLL hijacking issue in encryption software.:LINK:https://www.cve.org/CVERecord?id=CVE-2010-3397::REFERENCE:CVE-2010-3138:DESCRIPTION:DLL hijacking issue in library used by multiple media players.:LINK:https://www.cve.org/CVERecord?id=CVE-2010-3138::REFERENCE:CVE-2010-3152:DESCRIPTION:DLL hijacking issue in illustration program.:LINK:https://www.cve.org/CVERecord?id=CVE-2010-3152::REFERENCE:CVE-2010-3147:DESCRIPTION:DLL hijacking issue in address book.:LINK:https://www.cve.org/CVERecord?id=CVE-2010-3147::REFERENCE:CVE-2010-3135:DESCRIPTION:DLL hijacking issue in network monitoring software.:LINK:https://www.cve.org/CVERecord?id=CVE-2010-3135::REFERENCE:CVE-2010-3131:DESCRIPTION:DLL hijacking issue in web browser.:LINK:https://www.cve.org/CVERecord?id=CVE-2010-3131::REFERENCE:CVE-2010-1795:DESCRIPTION:DLL hijacking issue in music player/organizer.:LINK:https://www.cve.org/CVERecord?id=CVE-2010-1795::REFERENCE:CVE-2002-1576:DESCRIPTION:Product uses the current working directory to find and execute a program, which allows local users to gain privileges by creating a symlink that points to a malicious version of the program.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1576::REFERENCE:CVE-1999-1461:DESCRIPTION:Product trusts the PATH environmental variable to find and execute a program, which allows local users to obtain root access by modifying the PATH to point to a malicous version of that program.:LINK:https://www.cve.org/CVERecord?id=CVE-1999-1461::REFERENCE:CVE-1999-1318:DESCRIPTION:Software uses a search path that includes the current working directory (.), which allows local users to gain privileges via malicious programs.:LINK:https://www.cve.org/CVERecord?id=CVE-1999-1318::REFERENCE:CVE-2003-0579:DESCRIPTION:Admin software trusts the user-supplied -uv.install command line option to find and execute the uv.install program, which allows local users to gain privileges by providing a pathname that is under control of the user.:LINK:https://www.cve.org/CVERecord?id=CVE-2003-0579::REFERENCE:CVE-2000-0854:DESCRIPTION:When a document is opened, the directory of that document is first used to locate DLLs , which could allow an attacker to execute arbitrary commands by inserting malicious DLLs into the same directory as the document.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0854::REFERENCE:CVE-2001-0943:DESCRIPTION:Database trusts the PATH environment variable to find and execute programs, which allows local users to modify the PATH to point to malicious programs.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0943::REFERENCE:CVE-2001-0942:DESCRIPTION:Database uses an environment variable to find and execute a program, which allows local users to execute arbitrary programs by changing the environment variable.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0942::REFERENCE:CVE-2001-0507:DESCRIPTION:Server uses relative paths to find system files that will run in-process, which allows local users to gain privileges via a malicious file.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0507::REFERENCE:CVE-2002-2017:DESCRIPTION:Product allows local users to execute arbitrary code by setting an environment variable to reference a malicious program.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-2017::REFERENCE:CVE-1999-0690:DESCRIPTION:Product includes the current directory in root's PATH variable.:LINK:https://www.cve.org/CVERecord?id=CVE-1999-0690::REFERENCE:CVE-2001-0912:DESCRIPTION:Error during packaging causes product to include a hard-coded, non-standard directory in search path.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0912::REFERENCE:CVE-2001-0289:DESCRIPTION:Product searches current working directory for configuration file.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0289::REFERENCE:CVE-2005-1705:DESCRIPTION:Product searches current working directory for configuration file.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1705::REFERENCE:CVE-2005-1307:DESCRIPTION:Product executable other program from current working directory.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1307::REFERENCE:CVE-2002-2040:DESCRIPTION:Untrusted path.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-2040::REFERENCE:CVE-2005-2072:DESCRIPTION:Modification of trusted environment variable leads to untrusted path vulnerability.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-2072::REFERENCE:CVE-2005-1632:DESCRIPTION:Product searches /tmp for modules before other paths.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1632::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Uncontrolled Search Path Element::

::38::471::

::TYPE:Relationship:NOTE:Unlike untrusted search path (CWE-426), which inherently involves control over the definition of a control sphere (i.e., modification of a search path), this entry concerns a fixed control sphere in which some part of the sphere may be under attacker control (i.e., the search path cannot be modified by an attacker, but one element of the path can be under attacker control).::TYPE:Theoretical:NOTE:This weakness is not a clean fit under CWE-668 or CWE-610, which suggests that the control sphere model might need enhancement or clarification.::

Unquoted Search Path or Element

Base

Draft

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.

If a malicious individual has access to the file system, it is possible to elevate privileges by inserting such a file as C:Program.exe to be run by a privileged program making use of WinExec.

::NATURE:ChildOf:CWE ID:668:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:668:VIEW ID:1003:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::OPERATING SYSTEM NAME:Windows NT:OPERATING SYSTEM PREVALENCE:Sometimes::OPERATING SYSTEM NAME:macOS:OPERATING SYSTEM PREVALENCE:Rarely::

::PHASE:Implementation::

::SCOPE:Confidentiality:SCOPE:Integrity:SCOPE:Availability:IMPACT:Execute Unauthorized Code or Commands::

::PHASE:Implementation:DESCRIPTION:Properly quote the full search path before executing a program on the system.::PHASE:Implementation:STRATEGY:Input Validation:DESCRIPTION:Assume all input is malicious. Use an accept known good input validation strategy, i.e., use a list of acceptable inputs that strictly conform to specifications. Reject any input that does not strictly conform to specifications, or transform it into something that does. When performing input validation, consider all potentially relevant properties, including length, type of input, the full range of acceptable values, missing or extra inputs, syntax, consistency across related fields, and conformance to business rules. As an example of business rule logic, boat may be syntactically valid because it only contains alphanumeric characters, but it is not valid if the input is only expected to contain colors such as red or blue. Do not rely exclusively on looking for malicious or malformed inputs. This is likely to miss at least one undesirable input, especially if the code's environment changes. This can give attackers enough room to bypass the intended validation. However, denylists can be useful for detecting potential attacks or determining which inputs are so malformed that they should be rejected outright.::PHASE:Implementation:STRATEGY:Input Validation:DESCRIPTION:Inputs should be decoded and canonicalized to the application's current internal representation before being validated (CWE-180). Make sure that the application does not decode the same input twice (CWE-174). Such errors could be used to bypass allowlist validation schemes by introducing dangerous inputs after they have been checked.::

::REFERENCE:CVE-2005-1185:DESCRIPTION:Small handful of others. Program doesn't quote the C:Program Files path when calling a program to be executed - or any other path with a directory or file whose name contains a space - so attacker can put a malicious program.exe into C:.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1185::REFERENCE:CVE-2005-2938:DESCRIPTION:CreateProcess() and CreateProcessAsUser() can be misused by applications to allow program.exe style attacks in C::LINK:https://www.cve.org/CVERecord?id=CVE-2005-2938::REFERENCE:CVE-2000-1128:DESCRIPTION:Applies to Common Files folder, with a malicious common.exe, instead of Program Files/program.exe.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-1128::

::Program Invocation::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Unquoted Search Path or Element::

::TYPE:Applicable Platform:NOTE:This weakness could apply to any OS that supports spaces in filenames, especially any OS that make it easy for a user to insert spaces into filenames or folders, such as Windows. While spaces are technically supported in Unix, the practice is generally avoided. .::TYPE:Maintenance:NOTE:This weakness primarily involves the lack of quoting, which is not explicitly stated as a part of CWE-116. CWE-116 also describes output in light of structured messages, but the generation of a filename or search path (as in this weakness) might not be considered a structured message. An additional complication is the relationship to control spheres. Unlike untrusted search path (CWE-426), which inherently involves control over the definition of a control sphere, this entry concerns a fixed control sphere in which some part of the sphere may be under attacker control. This is not a clean fit under CWE-668 or CWE-610, which suggests that the control sphere model needs enhancement or clarification.::

Deployment of Wrong Handler

Base

Incomplete

The wrong handler is assigned to process an object.

An example of deploying the wrong handler would be calling a servlet to reveal source code of a .JSP file, or automatically determining type of the object even if it is contradictory to an explicitly specified type.

::NATURE:ChildOf:CWE ID:691:VIEW ID:1000:ORDINAL:Primary::NATURE:CanPrecede:CWE ID:433:VIEW ID:1000::NATURE:PeerOf:CWE ID:434:VIEW ID:1000::

::ORDINALITY:Resultant:DESCRIPTION:This weakness is usually resultant from other weaknesses.::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Other:IMPACT:Varies by Context:IMPACT:Unexpected State::

::PHASE:Architecture and Design:DESCRIPTION:Perform a type check before interpreting an object.::PHASE:Architecture and Design:DESCRIPTION:Reject any inconsistent types, such as a file with a .GIF extension that appears to consist of PHP code.::

::REFERENCE:CVE-2001-0004:DESCRIPTION:Source code disclosure via manipulated file extension that causes parsing by wrong DLL.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0004::REFERENCE:CVE-2002-0025:DESCRIPTION:Web browser does not properly handle the Content-Type header field, causing a different application to process the document.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0025::REFERENCE:CVE-2000-1052:DESCRIPTION:Source code disclosure by directly invoking a servlet.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-1052::REFERENCE:CVE-2002-1742:DESCRIPTION:Arbitrary Perl functions can be loaded by calling a non-existent function that activates a handler.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1742::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Improper Handler Deployment::

::11::

Missing Handler

Base

Draft

A handler is not available or implemented.

When an exception is thrown and not caught, the process has given up an opportunity to decide if a given failure or event is worth a change in execution.

::NATURE:ChildOf:CWE ID:691:VIEW ID:1000:ORDINAL:Primary::NATURE:CanPrecede:CWE ID:433:VIEW ID:1000::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Other:IMPACT:Varies by Context::

::PHASE:Implementation:DESCRIPTION:Handle all possible situations (e.g. error condition).::PHASE:Implementation:DESCRIPTION:If an operation can throw an Exception, implement a handler for that specific exception.::

::REFERENCE:CVE-2022-25302:DESCRIPTION:SDK for OPC Unified Architecture (OPC UA) is missing a handler for when a cast fails, allowing for a crash:LINK:https://www.cve.org/CVERecord?id=CVE-2022-25302::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Missing Handler::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP4:ENTRY NAME:Unchecked Status Condition::

Unrestricted Upload of File with Dangerous Type

Base

Draft

The product allows the attacker to upload or transfer files of dangerous types that can be automatically processed within the product's environment.

::NATURE:ChildOf:CWE ID:669:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:669:VIEW ID:1003:ORDINAL:Primary::NATURE:PeerOf:CWE ID:351:VIEW ID:1000::NATURE:PeerOf:CWE ID:436:VIEW ID:1000::NATURE:PeerOf:CWE ID:430:VIEW ID:1000::

::ORDINALITY:Primary:DESCRIPTION:This can be primary when there is no check at all.::ORDINALITY:Resultant:DESCRIPTION:This is frequently resultant when use of double extensions (e.g. .php.gif) bypasses a sanity check.::ORDINALITY:Resultant:DESCRIPTION:This can be resultant from client-side enforcement (CWE-602); some products will include web script in web clients to check the filename, without verifying on the server side.::

::LANGUAGE NAME:ASP.NET:LANGUAGE PREVALENCE:Sometimes::LANGUAGE NAME:PHP:LANGUAGE PREVALENCE:Often::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::TECHNOLOGY NAME:Web Server:TECHNOLOGY PREVALENCE:Sometimes::

::TERM:Unrestricted File Upload:DESCRIPTION:Used in vulnerability databases and elsewhere, but it is insufficiently precise. The phrase could be interpreted as the lack of restrictions on the size or number of uploaded files, which is a resource consumption issue.::

::PHASE:Implementation::PHASE:Architecture and Design:NOTE:OMISSION: This weakness is caused by missing a security tactic during the architecture and design phase.::

::SCOPE:Integrity:SCOPE:Confidentiality:SCOPE:Availability:IMPACT:Execute Unauthorized Code or Commands:NOTE:Arbitrary code execution is possible if an uploaded file is interpreted and executed as code by the recipient. This is especially true for .asp and .php extensions uploaded to web servers because these file types are often treated as automatically executable, even when file system permissions do not specify execution. For example, in Unix environments, programs typically cannot run unless the execute bit is set, but PHP programs may be executed by the web server without directly invoking them on the operating system.::

::METHOD:Dynamic Analysis with Automated Results Interpretation:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Cost effective for partial coverage: Web Application Scanner Web Services Scanner Database Scanners:EFFECTIVENESS:SOAR Partial::METHOD:Dynamic Analysis with Manual Results Interpretation:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Cost effective for partial coverage: Fuzz Tester Framework-based Fuzzer:EFFECTIVENESS:SOAR Partial::METHOD:Manual Static Analysis - Source Code:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Highly cost effective: Focused Manual Spotcheck - Focused manual analysis of source Manual Source Code Review (not inspections):EFFECTIVENESS:High::METHOD:Automated Static Analysis - Source Code:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Highly cost effective: Source code Weakness Analyzer Context-configured Source Code Weakness Analyzer:EFFECTIVENESS:High::METHOD:Architecture or Design Review:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Highly cost effective: Formal Methods / Correct-By-Construction Cost effective for partial coverage: Inspection (IEEE 1028 standard) (can apply to requirements, design, source code, etc.):EFFECTIVENESS:High::

::PHASE:Architecture and Design:DESCRIPTION:Generate a new, unique filename for an uploaded file instead of using the user-supplied filename, so that no external input is used at all.[REF-422] [REF-423]::PHASE:Architecture and Design:STRATEGY:Enforcement by Conversion:DESCRIPTION:When the set of acceptable objects, such as filenames or URLs, is limited or known, create a mapping from a set of fixed input values (such as numeric IDs) to the actual filenames or URLs, and reject all other inputs.::PHASE:Architecture and Design:DESCRIPTION:Consider storing the uploaded files outside of the web document root entirely. Then, use other mechanisms to deliver the files dynamically. [REF-423]::PHASE:Implementation:STRATEGY:Input Validation:DESCRIPTION:Assume all input is malicious. Use an accept known good input validation strategy, i.e., use a list of acceptable inputs that strictly conform to specifications. Reject any input that does not strictly conform to specifications, or transform it into something that does. When performing input validation, consider all potentially relevant properties, including length, type of input, the full range of acceptable values, missing or extra inputs, syntax, consistency across related fields, and conformance to business rules. As an example of business rule logic, boat may be syntactically valid because it only contains alphanumeric characters, but it is not valid if the input is only expected to contain colors such as red or blue. Do not rely exclusively on looking for malicious or malformed inputs. This is likely to miss at least one undesirable input, especially if the code's environment changes. This can give attackers enough room to bypass the intended validation. However, denylists can be useful for detecting potential attacks or determining which inputs are so malformed that they should be rejected outright. For example, limiting filenames to alphanumeric characters can help to restrict the introduction of unintended file extensions.::PHASE:Architecture and Design:DESCRIPTION:Define a very limited set of allowable extensions and only generate filenames that end in these extensions. Consider the possibility of XSS (CWE-79) before allowing .html or .htm file types.::PHASE:Implementation:STRATEGY:Input Validation:DESCRIPTION:Ensure that only one extension is used in the filename. Some web servers, including some versions of Apache, may process files based on inner extensions so that filename.php.gif is fed to the PHP interpreter.[REF-422] [REF-423]::PHASE:Implementation:DESCRIPTION:When running on a web server that supports case-insensitive filenames, perform case-insensitive evaluations of the extensions that are provided.::PHASE:Architecture and Design:DESCRIPTION:For any security checks that are performed on the client side, ensure that these checks are duplicated on the server side, in order to avoid CWE-602. Attackers can bypass the client-side checks by modifying values after the checks have been performed, or by changing the client to remove the client-side checks entirely. Then, these modified values would be submitted to the server.::PHASE:Implementation:DESCRIPTION:Do not rely exclusively on sanity checks of file contents to ensure that the file is of the expected type and size. It may be possible for an attacker to hide code in some file segments that will still be executed by the server. For example, GIF images may contain a free-form comments field.::PHASE:Implementation:DESCRIPTION:Do not rely exclusively on the MIME content type or filename attribute when determining how to render a file. Validating the MIME content type and ensuring that it matches the extension is only a partial solution.::PHASE:Architecture and Design Operation:STRATEGY:Environment Hardening:DESCRIPTION:Run your code using the lowest privileges that are required to accomplish the necessary tasks [REF-76]. If possible, create isolated accounts with limited privileges that are only used for a single task. That way, a successful attack will not immediately give the attacker access to the rest of the software or its environment. For example, database applications rarely need to run as the database administrator, especially in day-to-day operations.::PHASE:Architecture and Design Operation:STRATEGY:Sandbox or Jail:DESCRIPTION:Run the code in a jail or similar sandbox environment that enforces strict boundaries between the process and the operating system. This may effectively restrict which files can be accessed in a particular directory or which commands can be executed by the software. OS-level examples include the Unix chroot jail, AppArmor, and SELinux. In general, managed code may provide some protection. For example, java.io.FilePermission in the Java SecurityManager allows the software to specify restrictions on file operations. This may not be a feasible solution, and it only limits the impact to the operating system; the rest of the application may still be subject to compromise. Be careful to avoid CWE-243 and other weaknesses related to jails.:EFFECTIVENESS:Limited::

::REFERENCE:CVE-2023-5227:DESCRIPTION:PHP-based FAQ management app does not check the MIME type for uploaded images:LINK:https://www.cve.org/CVERecord?id=CVE-2023-5227::REFERENCE:CVE-2001-0901:DESCRIPTION:Web-based mail product stores .shtml attachments that could contain SSI:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0901::REFERENCE:CVE-2002-1841:DESCRIPTION:PHP upload does not restrict file types:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1841::REFERENCE:CVE-2005-1868:DESCRIPTION:upload and execution of .php file:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1868::REFERENCE:CVE-2005-1881:DESCRIPTION:upload file with dangerous extension:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1881::REFERENCE:CVE-2005-0254:DESCRIPTION:program does not restrict file types:LINK:https://www.cve.org/CVERecord?id=CVE-2005-0254::REFERENCE:CVE-2004-2262:DESCRIPTION:improper type checking of uploaded files:LINK:https://www.cve.org/CVERecord?id=CVE-2004-2262::REFERENCE:CVE-2006-4558:DESCRIPTION:Double php extension leaves an active php extension in the generated filename.:LINK:https://www.cve.org/CVERecord?id=CVE-2006-4558::REFERENCE:CVE-2006-6994:DESCRIPTION:ASP program allows upload of .asp files by bypassing client-side checks:LINK:https://www.cve.org/CVERecord?id=CVE-2006-6994::REFERENCE:CVE-2005-3288:DESCRIPTION:ASP file upload:LINK:https://www.cve.org/CVERecord?id=CVE-2005-3288::REFERENCE:CVE-2006-2428:DESCRIPTION:ASP file upload:LINK:https://www.cve.org/CVERecord?id=CVE-2006-2428::

::File Processing::

::File or Directory::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Unrestricted File Upload::TAXONOMY NAME:OWASP Top Ten 2007:ENTRY ID:A3:ENTRY NAME:Malicious File Execution:MAPPING FIT:CWE More Specific::TAXONOMY NAME:OMG ASCSM:ENTRY ID:ASCSM-CWE-434::

::1::

::TYPE:Relationship:NOTE:This can have a chaining relationship with incomplete denylist / permissive allowlist errors when the product tries, but fails, to properly limit which types of files are allowed (CWE-183, CWE-184). This can also overlap multiple interpretation errors for intermediaries, e.g. anti-virus products that do not remove or quarantine attachments with certain file extensions that can be processed by client systems.::

Incomplete Model of Endpoint Features

Base

Incomplete

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.

::NATURE:ChildOf:CWE ID:436:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Other:IMPACT:Unexpected State:IMPACT:Varies by Context::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Extra Unhandled Features::

::TYPE:Relationship:NOTE:This can be related to interaction errors, although in some cases, one of the endpoints is not performing correctly according to specification.::

Behavioral Change in New Version or Environment

Base

Draft

A's behavior or functionality changes with a new version of A, or a new environment, which is not known (or manageable) by B.

::NATURE:ChildOf:CWE ID:435:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::TERM:Functional change::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Other:IMPACT:Quality Degradation:IMPACT:Varies by Context::

::REFERENCE:CVE-2002-1976:DESCRIPTION:Linux kernel 2.2 and above allow promiscuous mode using a different method than previous versions, and ifconfig is not aware of the new method (alternate path property).:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1976::REFERENCE:CVE-2005-1711:DESCRIPTION:Product uses defunct method from another product that does not return an error code and allows detection avoidance.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1711::REFERENCE:CVE-2003-0411:DESCRIPTION:chain: Code was ported from a case-sensitive Unix platform to a case-insensitive Windows platform where filetype handlers treat .jsp and .JSP as different extensions. JSP source code may be read because .JSP defaults to the filetype text.:LINK:https://www.cve.org/CVERecord?id=CVE-2003-0411::

::TAXONOMY NAME:PLOVER:ENTRY NAME:CHANGE Behavioral Change::

Expected Behavior Violation

Base

Draft

A feature, API, or function does not perform according to its specification.

::NATURE:ChildOf:CWE ID:684:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::TECHNOLOGY CLASS:ICS/OT:TECHNOLOGY PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::PHASE:Operation::

::SCOPE:Other:IMPACT:Quality Degradation:IMPACT:Varies by Context::

::REFERENCE:CVE-2003-0187:DESCRIPTION:Program uses large timeouts on unconfirmed connections resulting from inconsistency in linked lists implementations.:LINK:https://www.cve.org/CVERecord?id=CVE-2003-0187::REFERENCE:CVE-2003-0465:DESCRIPTION:strncpy in Linux kernel acts different than libc on x86, leading to expected behavior difference - sort of a multiple interpretation error?:LINK:https://www.cve.org/CVERecord?id=CVE-2003-0465::REFERENCE:CVE-2005-3265:DESCRIPTION:Buffer overflow in product stems the use of a third party library function that is expected to have internal protection against overflows, but doesn't.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-3265::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Expected behavior violation::

::TYPE:Theoretical:NOTE:The behavior of an application that is not consistent with the expectations of the developer may lead to incorrect use of the software.::

Inconsistent Interpretation of HTTP Requests ('HTTP Request/Response Smuggling')

Base

Incomplete

The product acts as an intermediary HTTP agent (such as a proxy or firewall) in the data flow between two entities such as a client and server, but it does not interpret malformed HTTP requests or responses in ways that are consistent with how the messages will be processed by those entities that are at the ultimate destination.

HTTP requests or responses (messages) can be malformed or unexpected in ways that cause web servers or clients to interpret the messages in different ways than intermediary HTTP agents such as load balancers, reverse proxies, web caching proxies, application firewalls, etc. For example, an adversary may be able to add duplicate or different header fields that a client or server might interpret as one set of messages, whereas the intermediary might interpret the same sequence of bytes as a different set of messages. For example, discrepancies can arise in how to handle duplicate headers like two Transfer-encoding (TE) or two Content-length (CL), or the malicious HTTP message will have different headers for TE and CL. The inconsistent parsing and interpretation of messages can allow the adversary to smuggle a message to the client/server without the intermediary being aware of it. This weakness is usually the result of the usage of outdated or incompatible HTTP protocol versions in the HTTP agents.

::NATURE:ChildOf:CWE ID:436:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:436:VIEW ID:1003:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::TECHNOLOGY CLASS:Web Based:TECHNOLOGY PREVALENCE:Undetermined::

::TERM:HTTP Request Smuggling::TERM:HTTP Response Smuggling::TERM:HTTP Smuggling::

::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Non-Repudiation:SCOPE:Access Control:IMPACT:Unexpected State:IMPACT:Hide Activities:IMPACT:Bypass Protection Mechanism:NOTE:An attacker could create HTTP messages to exploit a number of weaknesses including 1) the message can trick the web server to associate a URL with another URL's webpage and caching the contents of the webpage (web cache poisoning attack), 2) the message can be structured to bypass the firewall protection mechanisms and gain unauthorized access to a web application, and 3) the message can invoke a script or a page that returns client credentials (similar to a Cross Site Scripting attack).::

::PHASE:Implementation:DESCRIPTION:Use a web server that employs a strict HTTP parsing procedure, such as Apache [REF-433].::PHASE:Implementation:DESCRIPTION:Use only SSL communication.::PHASE:Implementation:DESCRIPTION:Terminate the client session after each request.::PHASE:System Configuration:DESCRIPTION:Turn all pages to non-cacheable.::

::REFERENCE:CVE-2022-24766:DESCRIPTION:SSL/TLS-capable proxy allows HTTP smuggling when used in tandem with HTTP/1.0 services, due to inconsistent interpretation and input sanitization of HTTP messages within the body of another message:LINK:https://www.cve.org/CVERecord?id=CVE-2022-24766::REFERENCE:CVE-2021-37147:DESCRIPTION:Chain: caching proxy server has improper input validation (CWE-20) of headers, allowing HTTP response smuggling (CWE-444) using an LF line ending:LINK:https://www.cve.org/CVERecord?id=CVE-2021-37147::REFERENCE:CVE-2020-8287:DESCRIPTION:Node.js platform allows request smuggling via two Transfer-Encoding headers:LINK:https://www.cve.org/CVERecord?id=CVE-2020-8287::REFERENCE:CVE-2006-6276:DESCRIPTION:Web servers allow request smuggling via inconsistent HTTP headers.:LINK:https://www.cve.org/CVERecord?id=CVE-2006-6276::REFERENCE:CVE-2005-2088:DESCRIPTION:HTTP server allows request smuggling with both a Transfer-Encoding: chunked header and a Content-Length header:LINK:https://www.cve.org/CVERecord?id=CVE-2005-2088::REFERENCE:CVE-2005-2089:DESCRIPTION:HTTP server allows request smuggling with both a Transfer-Encoding: chunked header and a Content-Length header:LINK:https://www.cve.org/CVERecord?id=CVE-2005-2089::

::TAXONOMY NAME:PLOVER:ENTRY NAME:HTTP Request Smuggling::TAXONOMY NAME:WASC:ENTRY ID:26:ENTRY NAME:HTTP Request Smuggling::TAXONOMY NAME:WASC:ENTRY ID:27:ENTRY NAME:HTTP Response Smuggling::

::273::33::

::TYPE:Theoretical:NOTE:Request smuggling can be performed due to a multiple interpretation error, where the target is an intermediary or monitor, via a consistency manipulation (Transfer-Encoding and Content-Length headers).::

Unimplemented or Unsupported Feature in UI

Base

Draft

A UI function for a security feature appears to be supported and gives feedback to the user that suggests that it is supported, but the underlying functionality is not implemented.

::NATURE:ChildOf:CWE ID:446:VIEW ID:1000::NATURE:ChildOf:CWE ID:671:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Other:IMPACT:Varies by Context::

::PHASE:Testing:DESCRIPTION:Perform functionality testing before deploying the application.::

::REFERENCE:CVE-2000-0127:DESCRIPTION:GUI configuration tool does not enable a security option when a checkbox is selected, although that option is honored when manually set in the configuration file.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0127::REFERENCE:CVE-2001-0863:DESCRIPTION:Router does not implement a specific keyword when it is used in an ACL, allowing filter bypass.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0863::REFERENCE:CVE-2001-0865:DESCRIPTION:Router does not implement a specific keyword when it is used in an ACL, allowing filter bypass.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0865::REFERENCE:CVE-2004-0979:DESCRIPTION:Web browser does not properly modify security setting when the user sets it.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-0979::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Unimplemented or unsupported feature in UI::

::TYPE:Research Gap:NOTE:This issue needs more study, as there are not many examples. It is not clear whether it is primary or resultant.::

Obsolete Feature in UI

Base

Draft

A UI function is obsolete and the product does not warn the user.

::NATURE:ChildOf:CWE ID:446:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Other:IMPACT:Quality Degradation:IMPACT:Varies by Context::

::PHASE:Architecture and Design:DESCRIPTION:Remove the obsolete feature from the UI. Warn the user that the feature is no longer supported.::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Obsolete feature in UI::

The UI Performs the Wrong Action

Base

Incomplete

The UI performs the wrong action with respect to the user's request.

::NATURE:ChildOf:CWE ID:446:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Other:IMPACT:Quality Degradation:IMPACT:Varies by Context::

::PHASE:Testing:DESCRIPTION:Perform extensive functionality testing of the UI. The UI should behave as specified.::

::REFERENCE:CVE-2001-1387:DESCRIPTION:Network firewall accidentally implements one command line option as if it were another, possibly leading to behavioral infoleak.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-1387::REFERENCE:CVE-2001-0081:DESCRIPTION:Command line option correctly suppresses a user prompt but does not properly disable a feature, although when the product prompts the user, the feature is properly disabled.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0081::REFERENCE:CVE-2002-1977:DESCRIPTION:Product does not time out according to user specification, leaving sensitive data available after it has expired.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1977::

::TAXONOMY NAME:PLOVER:ENTRY NAME:The UI performs the wrong action::

External Initialization of Trusted Variables or Data Stores

Base

Draft

The product initializes critical internal variables or data stores using inputs that can be modified by untrusted actors.

A product system should be reluctant to trust variables that have been initialized outside of its trust boundary, especially if they are initialized by users. The variables may have been initialized incorrectly. If an attacker can initialize the variable, then they can influence what the vulnerable system will do.

::NATURE:ChildOf:CWE ID:1419:VIEW ID:1000:ORDINAL:Primary::NATURE:CanAlsoBe:CWE ID:456:VIEW ID:1000::

::LANGUAGE NAME:PHP:LANGUAGE PREVALENCE:Sometimes::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Integrity:IMPACT:Modify Application Data:NOTE:An attacker could gain access to and modify sensitive data or system information.::

::PHASE:Implementation:STRATEGY:Input Validation:DESCRIPTION:A product system should be reluctant to trust variables that have been initialized outside of its trust boundary. Ensure adequate checking (e.g. input validation) is performed when relying on input from outside a trust boundary.::PHASE:Architecture and Design:DESCRIPTION:Avoid any external control of variables. If necessary, restrict the variables that can be modified using an allowlist, and use a different namespace or naming convention if possible.::

::REFERENCE:CVE-2022-43468:DESCRIPTION:WordPress module sets internal variables based on external inputs, allowing false reporting of the number of views:LINK:https://www.cve.org/CVERecord?id=CVE-2022-43468::REFERENCE:CVE-2000-0959:DESCRIPTION:Does not clear dangerous environment variables, enabling symlink attack.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0959::REFERENCE:CVE-2001-0033:DESCRIPTION:Specify alternate configuration directory in environment variable, enabling untrusted path.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0033::REFERENCE:CVE-2001-0872:DESCRIPTION:Dangerous environment variable not cleansed.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0872::REFERENCE:CVE-2001-0084:DESCRIPTION:Specify arbitrary modules using environment variable.:LINK:https://www.cve.org/CVERecord?id=CVE-2001-0084::

::TAXONOMY NAME:PLOVER:ENTRY NAME:External initialization of trusted variables or values::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP25:ENTRY NAME:Tainted input to variable::

::TYPE:Relationship:NOTE:Overlaps Missing variable initialization, especially in PHP.::TYPE:Applicable Platform:NOTE:This is often found in PHP due to register_globals and the common practice of storing library/include files under the web document root so that they are available using a direct request.::

Non-exit on Failed Initialization

Base

Draft

The product does not exit or otherwise modify its operation when security-relevant errors occur during initialization, such as when a configuration file has a format error or a hardware security module (HSM) cannot be activated, which can cause the product to execute in a less secure fashion than intended by the administrator.

::NATURE:ChildOf:CWE ID:665:VIEW ID:1000::NATURE:ChildOf:CWE ID:705:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:636:VIEW ID:1000::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Other:IMPACT:Modify Application Data:IMPACT:Alter Execution Logic:NOTE:The application could be placed in an insecure state that may allow an attacker to modify sensitive data or allow unintended logic to be executed.::

::PHASE:Implementation:DESCRIPTION:Follow the principle of failing securely when an error occurs. The system should enter a state where it is not vulnerable and will not display sensitive error messages to a potential attacker.::

::REFERENCE:CVE-2005-1345:DESCRIPTION:Product does not trigger a fatal error if missing or invalid ACLs are in a configuration file.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1345::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Non-exit on Failed Initialization::

::TYPE:Research Gap:NOTE:Under-studied. These issues are not frequently reported, and it is difficult to find published examples.::

Incomplete Cleanup

Base

Draft

The product does not properly clean up and remove temporary or supporting resources after they have been used.

::NATURE:ChildOf:CWE ID:404:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:404:VIEW ID:1003:ORDINAL:Primary::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::TERM:Insufficient Cleanup::

::PHASE:Implementation::

::SCOPE:Other:SCOPE:Confidentiality:SCOPE:Integrity:IMPACT:Other:IMPACT:Read Application Data:IMPACT:Modify Application Data:IMPACT:DoS: Resource Consumption (Other):NOTE:It is possible to overflow the number of temporary files because directories typically have limits on the number of files allowed. This could create a denial of service problem.::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::PHASE:Architecture and Design Implementation:DESCRIPTION:Temporary files and other supporting resources should be deleted/released immediately after they are no longer needed.::

::REFERENCE:CVE-2000-0552:DESCRIPTION:World-readable temporary file not deleted after use.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0552::REFERENCE:CVE-2005-2293:DESCRIPTION:Temporary file not deleted after use, leaking database usernames and passwords.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-2293::REFERENCE:CVE-2002-0788:DESCRIPTION:Interaction error creates a temporary file that can not be deleted due to strong permissions.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0788::REFERENCE:CVE-2002-2066:DESCRIPTION:Alternate data streams for NTFS files are not cleared when files are wiped (alternate channel / infoleak).:LINK:https://www.cve.org/CVERecord?id=CVE-2002-2066::REFERENCE:CVE-2002-2067:DESCRIPTION:Alternate data streams for NTFS files are not cleared when files are wiped (alternate channel / infoleak).:LINK:https://www.cve.org/CVERecord?id=CVE-2002-2067::REFERENCE:CVE-2002-2068:DESCRIPTION:Alternate data streams for NTFS files are not cleared when files are wiped (alternate channel / infoleak).:LINK:https://www.cve.org/CVERecord?id=CVE-2002-2068::REFERENCE:CVE-2002-2069:DESCRIPTION:Alternate data streams for NTFS files are not cleared when files are wiped (alternate channel / infoleak).:LINK:https://www.cve.org/CVERecord?id=CVE-2002-2069::REFERENCE:CVE-2002-2070:DESCRIPTION:Alternate data streams for NTFS files are not cleared when files are wiped (alternate channel / infoleak).:LINK:https://www.cve.org/CVERecord?id=CVE-2002-2070::REFERENCE:CVE-2005-1744:DESCRIPTION:Users not logged out when application is restarted after security-relevant changes were made.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1744::

::File Processing::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Incomplete Cleanup::TAXONOMY NAME:OWASP Top Ten 2004:ENTRY ID:A10:ENTRY NAME:Insecure Configuration Management:MAPPING FIT:CWE More Specific::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:FIO42-C:ENTRY NAME:Close files when they are no longer needed:MAPPING FIT:CWE More Abstract::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:MEM31-C:ENTRY NAME:Free dynamically allocated memory when no longer needed:MAPPING FIT:CWE More Abstract::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:FIO04-J:ENTRY NAME:Release resources when they are no longer needed::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:FIO00-J:ENTRY NAME:Do not operate on files in shared directories::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP14:ENTRY NAME:Failure to release resource::

::TYPE:Relationship:NOTE:CWE-459 is a child of CWE-404 because, while CWE-404 covers any type of improper shutdown or release of a resource, CWE-459 deals specifically with a multi-step shutdown process in which a crucial step for proper cleanup is omitted or impossible. That is, CWE-459 deals specifically with a cleanup or shutdown process that does not successfully remove all potentially sensitive data.::TYPE:Relationship:NOTE:Overlaps other categories such as permissions and containment. Concept needs further development. This could be primary (e.g. leading to infoleak) or resultant (e.g. resulting from unhandled error conditions or early termination).::

Deletion of Data Structure Sentinel

Base

Incomplete

The accidental deletion of a data-structure sentinel can cause serious programming logic problems.

Often times data-structure sentinels are used to mark structure of the data structure. A common example of this is the null character at the end of strings. Another common example is linked lists which may contain a sentinel to mark the end of the list. It is dangerous to allow this type of control data to be easily accessible. Therefore, it is important to protect from the deletion or modification outside of some wrapper interface which provides safety.

::NATURE:ChildOf:CWE ID:707:VIEW ID:1000:ORDINAL:Primary::NATURE:PeerOf:CWE ID:464:VIEW ID:1000::

::LANGUAGE NAME:C:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C++:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Availability:SCOPE:Other:IMPACT:Other:NOTE:Generally this error will cause the data structure to not work properly.::SCOPE:Authorization:SCOPE:Other:IMPACT:Other:NOTE:If a control character, such as NULL is removed, one may cause resource access control problems.::

::PHASE:Architecture and Design:DESCRIPTION:Use an abstraction library to abstract away risky APIs. Not a complete solution.::PHASE:Build and Compilation:STRATEGY:Compilation or Build Hardening:DESCRIPTION:Run or compile the software using features or extensions that automatically provide a protection mechanism that mitigates or eliminates buffer overflows. For example, certain compilers and extensions provide automatic buffer overflow detection mechanisms that are built into the compiled code. Examples include the Microsoft Visual Studio /GS flag, Fedora/Red Hat FORTIFY_SOURCE GCC flag, StackGuard, and ProPolice.:EFFECTIVENESS:Defense in Depth::PHASE:Operation:DESCRIPTION:Use OS-level preventative functionality. Not a complete solution.::

::TAXONOMY NAME:CLASP:ENTRY NAME:Deletion of data-structure sentinel::

Addition of Data Structure Sentinel

Base

Incomplete

The accidental addition of a data-structure sentinel can cause serious programming logic problems.

Data-structure sentinels are often used to mark the structure of data. A common example of this is the null character at the end of strings or a special sentinel to mark the end of a linked list. It is dangerous to allow this type of control data to be easily accessible. Therefore, it is important to protect from the addition or modification of sentinels.

::NATURE:ChildOf:CWE ID:138:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE NAME:C:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C++:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Integrity:IMPACT:Modify Application Data:NOTE:Generally this error will cause the data structure to not work properly by truncating the data.::

::PHASE:Implementation Architecture and Design:DESCRIPTION:Encapsulate the user from interacting with data sentinels. Validate user input to verify that sentinels are not present.::PHASE:Implementation:DESCRIPTION:Proper error checking can reduce the risk of inadvertently introducing sentinel values into data. For example, if a parsing function fails or encounters an error, it might return a value that is the same as the sentinel.::PHASE:Architecture and Design:DESCRIPTION:Use an abstraction library to abstract away risky APIs. This is not a complete solution.::PHASE:Operation:DESCRIPTION:Use OS-level preventative functionality. This is not a complete solution.::

::TAXONOMY NAME:CLASP:ENTRY NAME:Addition of data-structure sentinel::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:STR03-C:ENTRY NAME:Do not inadvertently truncate a null-terminated byte string::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:STR06-C:ENTRY NAME:Do not assume that strtok() leaves the parse string unchanged::

Return of Pointer Value Outside of Expected Range

Base

Draft

A function can return a pointer to memory that is outside of the buffer that the pointer is expected to reference.

::NATURE:ChildOf:CWE ID:119:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:20:VIEW ID:700:ORDINAL:Primary::

::LANGUAGE NAME:C:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C++:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Confidentiality:SCOPE:Integrity:IMPACT:Read Memory:IMPACT:Modify Memory::

::TAXONOMY NAME:7 Pernicious Kingdoms:ENTRY NAME:Illegal Pointer Value::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP1:ENTRY NAME:Glitch in computation::

::TYPE:Maintenance:NOTE:This entry should have a chaining relationship with CWE-119 instead of a parent / child relationship, however the focus of this weakness does not map cleanly to any existing entries in CWE. A new parent is being considered which covers the more generic problem of incorrect return values. There is also an abstract relationship to weaknesses in which one component sends incorrect messages to another component; in this case, one routine is sending an incorrect value to another.::

Incorrect Pointer Scaling

Base

Incomplete

In C and C++, one may often accidentally refer to the wrong memory due to the semantics of when math operations are implicitly scaled.

::NATURE:ChildOf:CWE ID:682:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE NAME:C:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C++:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation:NOTE:Programmers may try to index from a pointer by adding a number of bytes. This is incorrect because C and C++ implicitly scale the operand by the size of the data type.::

::SCOPE:Confidentiality:SCOPE:Integrity:IMPACT:Read Memory:IMPACT:Modify Memory:NOTE:Incorrect pointer scaling will often result in buffer overflow conditions. Confidentiality can be compromised if the weakness is in the context of a buffer over-read or under-read.::

::PHASE:Architecture and Design:DESCRIPTION:Use a platform with high-level memory abstractions.::PHASE:Implementation:DESCRIPTION:Always use array indexing instead of direct pointer manipulation.::PHASE:Architecture and Design:DESCRIPTION:Use technologies for preventing buffer overflows.::

::TAXONOMY NAME:CLASP:ENTRY NAME:Unintentional pointer scaling::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:ARR39-C:ENTRY NAME:Do not add or subtract a scaled integer to a pointer:MAPPING FIT:Exact::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:EXP08-C:ENTRY NAME:Ensure pointer arithmetic is used correctly::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP1:ENTRY NAME:Glitch in computation::

Use of Pointer Subtraction to Determine Size

Base

Draft

The product subtracts one pointer from another in order to determine size, but this calculation can be incorrect if the pointers do not exist in the same memory chunk.

::NATURE:ChildOf:CWE ID:682:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE NAME:C:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C++:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Access Control:SCOPE:Integrity:SCOPE:Confidentiality:SCOPE:Availability:IMPACT:Modify Memory:IMPACT:Read Memory:IMPACT:Execute Unauthorized Code or Commands:IMPACT:Gain Privileges or Assume Identity:NOTE:There is the potential for arbitrary code execution with privileges of the vulnerable program.::

::METHOD:Fuzzing:DESCRIPTION:Fuzz testing (fuzzing) is a powerful technique for generating large numbers of diverse inputs - either randomly or algorithmically - and dynamically invoking the code with those inputs. Even with random inputs, it is often capable of generating unexpected results such as crashes, memory corruption, or resource consumption. Fuzzing effectively produces repeatable test cases that clearly indicate bugs, which helps developers to diagnose the issues.:EFFECTIVENESS:High::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::PHASE:Implementation:DESCRIPTION:Save an index variable. This is the recommended solution. Rather than subtract pointers from one another, use an index variable of the same size as the pointers in question. Use this variable to walk from one pointer to the other and calculate the difference. Always validate this number.::

::TAXONOMY NAME:CLASP:ENTRY NAME:Improper pointer subtraction::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:ARR36-C:ENTRY NAME:Do not subtract or compare two pointers that do not refer to the same array:MAPPING FIT:Exact::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP7:ENTRY NAME:Faulty Pointer Use::

Use of Externally-Controlled Input to Select Classes or Code ('Unsafe Reflection')

Base

Draft

The product uses external input with reflection to select which classes or code to use, but it does not sufficiently prevent the input from selecting improper classes or code.

If the product uses external inputs to determine which class to instantiate or which method to invoke, then an attacker could supply values to select unexpected classes or methods. If this occurs, then the attacker could create control flow paths that were not intended by the developer. These paths could bypass authentication or access control checks, or otherwise cause the product to behave in an unexpected manner. This situation becomes a doomsday scenario if the attacker can upload files into a location that appears on the product's classpath (CWE-427) or add new entries to the product's classpath (CWE-426). Under either of these conditions, the attacker can use reflection to introduce new, malicious behavior into the product.

::NATURE:ChildOf:CWE ID:913:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:913:VIEW ID:1003:ORDINAL:Primary::NATURE:ChildOf:CWE ID:610:VIEW ID:1000::NATURE:ChildOf:CWE ID:20:VIEW ID:700:ORDINAL:Primary::

::LANGUAGE NAME:Java:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:PHP:LANGUAGE PREVALENCE:Undetermined::LANGUAGE CLASS:Interpreted:LANGUAGE PREVALENCE:Sometimes::

::TERM:Reflection Injection::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Integrity:SCOPE:Confidentiality:SCOPE:Availability:SCOPE:Other:IMPACT:Execute Unauthorized Code or Commands:IMPACT:Alter Execution Logic:NOTE:The attacker might be able to execute code that is not directly accessible to the attacker. Alternately, the attacker could call unexpected code in the wrong place or the wrong time, possibly modifying critical system state.::SCOPE:Availability:SCOPE:Other:IMPACT:DoS: Crash, Exit, or Restart:IMPACT:Other:NOTE:The attacker might be able to use reflection to call the wrong code, possibly with unexpected arguments that violate the API (CWE-227). This could cause the product to exit or hang.::SCOPE:Confidentiality:IMPACT:Read Application Data:NOTE:By causing the wrong code to be invoked, the attacker might be able to trigger a runtime error that leaks sensitive information in the error message, such as CWE-536.::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::PHASE:Architecture and Design:DESCRIPTION:Refactor your code to avoid using reflection.::PHASE:Architecture and Design:DESCRIPTION:Do not use user-controlled inputs to select and load classes or code.::PHASE:Implementation:DESCRIPTION:Apply strict input validation by using allowlists or indirect selection to ensure that the user is only selecting allowable classes or code.::

::REFERENCE:CVE-2018-1000613:DESCRIPTION:Cryptography API uses unsafe reflection when deserializing a private key:LINK:https://www.cve.org/CVERecord?id=CVE-2018-1000613::REFERENCE:CVE-2004-2331:DESCRIPTION:Database system allows attackers to bypass sandbox restrictions by using the Reflection API.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-2331::

::TAXONOMY NAME:7 Pernicious Kingdoms:ENTRY NAME:Unsafe Reflection::TAXONOMY NAME:The CERT Oracle Secure Coding Standard for Java (2011):ENTRY ID:SEC06-J:ENTRY NAME:Do not use reflection to increase accessibility of classes, methods, or fields::

::138::

External Control of Assumed-Immutable Web Parameter

Base

Draft

The web application does not sufficiently verify inputs that are assumed to be immutable but are actually externally controllable, such as hidden form fields.

If a web product does not properly protect assumed-immutable values from modification in hidden form fields, parameters, cookies, or URLs, this can lead to modification of critical data. Web applications often mistakenly make the assumption that data passed to the client in hidden fields or cookies is not susceptible to tampering. Improper validation of data that are user-controllable can lead to the application processing incorrect, and often malicious, input. For example, custom cookies commonly store session data or persistent data across sessions. This kind of session data is normally involved in security related decisions on the server side, such as user authentication and access control. Thus, the cookies might contain sensitive data such as user credentials and privileges. This is a dangerous practice, as it can often lead to improper reliance on the value of the client-provided cookie by the server side application.

::NATURE:ChildOf:CWE ID:642:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:471:VIEW ID:1000::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::TERM:Assumed-Immutable Parameter Tampering::

::PHASE:Implementation:NOTE:OMISSION: This weakness is caused by missing a security tactic during the architecture and design phase.::

::SCOPE:Integrity:IMPACT:Modify Application Data:NOTE:Without appropriate protection mechanisms, the client can easily tamper with cookies and similar web data. Reliance on the cookies without detailed validation can lead to problems such as SQL injection. If you use cookie values for security related decisions on the server side, manipulating the cookies might lead to violations of security policies such as authentication bypassing, user impersonation and privilege escalation. In addition, storing sensitive data in the cookie without appropriate protection can also lead to disclosure of sensitive user data, especially data stored in persistent cookies.::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::PHASE:Implementation:STRATEGY:Input Validation:DESCRIPTION:Assume all input is malicious. Use an accept known good input validation strategy, i.e., use a list of acceptable inputs that strictly conform to specifications. Reject any input that does not strictly conform to specifications, or transform it into something that does. When performing input validation, consider all potentially relevant properties, including length, type of input, the full range of acceptable values, missing or extra inputs, syntax, consistency across related fields, and conformance to business rules. As an example of business rule logic, boat may be syntactically valid because it only contains alphanumeric characters, but it is not valid if the input is only expected to contain colors such as red or blue. Do not rely exclusively on looking for malicious or malformed inputs. This is likely to miss at least one undesirable input, especially if the code's environment changes. This can give attackers enough room to bypass the intended validation. However, denylists can be useful for detecting potential attacks or determining which inputs are so malformed that they should be rejected outright.::PHASE:Implementation:STRATEGY:Input Validation:DESCRIPTION:Inputs should be decoded and canonicalized to the application's current internal representation before being validated (CWE-180). Make sure that the application does not decode the same input twice (CWE-174). Such errors could be used to bypass allowlist validation schemes by introducing dangerous inputs after they have been checked.::

::REFERENCE:CVE-2002-0108:DESCRIPTION:Forum product allows spoofed messages of other users via hidden form fields for name and e-mail address.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0108::REFERENCE:CVE-2000-0253:DESCRIPTION:Shopping cart allows price modification via hidden form field.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0253::REFERENCE:CVE-2000-0254:DESCRIPTION:Shopping cart allows price modification via hidden form field.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0254::REFERENCE:CVE-2000-0926:DESCRIPTION:Shopping cart allows price modification via hidden form field.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0926::REFERENCE:CVE-2000-0101:DESCRIPTION:Shopping cart allows price modification via hidden form field.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0101::REFERENCE:CVE-2000-0102:DESCRIPTION:Shopping cart allows price modification via hidden form field.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0102::REFERENCE:CVE-2000-0758:DESCRIPTION:Allows admin access by modifying value of form field.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-0758::REFERENCE:CVE-2002-1880:DESCRIPTION:Read messages by modifying message ID parameter.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1880::REFERENCE:CVE-2000-1234:DESCRIPTION:Send email to arbitrary users by modifying email parameter.:LINK:https://www.cve.org/CVERecord?id=CVE-2000-1234::REFERENCE:CVE-2005-1652:DESCRIPTION:Authentication bypass by setting a parameter.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1652::REFERENCE:CVE-2005-1784:DESCRIPTION:Product does not check authorization for configuration change admin script, leading to password theft via modified e-mail address field.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1784::REFERENCE:CVE-2005-2314:DESCRIPTION:Logic error leads to password disclosure.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-2314::REFERENCE:CVE-2005-1682:DESCRIPTION:Modification of message number parameter allows attackers to read other people's messages.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-1682::

::TAXONOMY NAME:PLOVER:ENTRY NAME:Web Parameter Tampering::TAXONOMY NAME:OWASP Top Ten 2007:ENTRY ID:A4:ENTRY NAME:Insecure Direct Object Reference:MAPPING FIT:CWE More Specific::TAXONOMY NAME:OWASP Top Ten 2004:ENTRY ID:A1:ENTRY NAME:Unvalidated Input:MAPPING FIT:CWE More Specific::

::146::226::31::39::

::TYPE:Relationship:NOTE:This is a primary weakness for many other weaknesses and functional consequences, including XSS, SQL injection, path disclosure, and file inclusion.::TYPE:Theoretical:NOTE:This is a technology-specific MAID problem.::

Use of Function with Inconsistent Implementations

Base

Draft

The code uses a function that has inconsistent implementations across operating systems and versions.

The use of inconsistent implementations can cause changes in behavior when the code is ported or built under a different environment than the programmer expects, which can lead to security problems in some cases. The implementation of many functions varies by platform, and at times, even by different versions of the same platform. Implementation differences can include: Slight differences in the way parameters are interpreted leading to inconsistent results. Some implementations of the function carry significant security risks. The function might not be defined on all platforms. The function might change which return codes it can provide, or change the meaning of its return codes.

::NATURE:ChildOf:CWE ID:758:VIEW ID:1000:ORDINAL:Primary::

::ORDINALITY:Primary::ORDINALITY:Indirect::

::LANGUAGE NAME:C:LANGUAGE PREVALENCE:Often::LANGUAGE NAME:PHP:LANGUAGE PREVALENCE:Often::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Other:IMPACT:Quality Degradation:IMPACT:Varies by Context::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::PHASE:Architecture and Design Requirements:DESCRIPTION:Do not accept inconsistent behavior from the API specifications when the deviant behavior increase the risk level.::

::TAXONOMY NAME:7 Pernicious Kingdoms:ENTRY NAME:Inconsistent Implementations::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP3:ENTRY NAME:Use of an improper API::

Undefined Behavior for Input to API

Base

Incomplete

The behavior of this function is undefined unless its control parameter is set to a specific value.

::NATURE:ChildOf:CWE ID:573:VIEW ID:1000:ORDINAL:Primary::

::ORDINALITY:Indirect::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Architecture and Design::PHASE:Implementation::

::SCOPE:Other:IMPACT:Quality Degradation:IMPACT:Varies by Context::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::TAXONOMY NAME:7 Pernicious Kingdoms:ENTRY NAME:Undefined Behavior::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP1:ENTRY NAME:Glitch in computation::

::TYPE:Other:NOTE:The Linux Standard Base Specification 2.0.1 for libc places constraints on the arguments to some internal functions [21]. If the constraints are not met, the behavior of the functions is not defined. It is unusual for this function to be called directly. It is almost always invoked through a macro defined in a system header file, and the macro ensures that the following constraints are met: The value 1 must be passed to the third parameter (the version number) of the following file system function: __xmknod The value 2 must be passed to the third parameter (the group argument) of the following wide character string functions: __wcstod_internal __wcstof_internal __wcstol_internal __wcstold_internal __wcstoul_internal The value 3 must be passed as the first parameter (the version number) of the following file system functions: __xstat __lxstat __fxstat __xstat64 __lxstat64 __fxstat64::

NULL Pointer Dereference

Base

Stable

A NULL pointer dereference occurs when the application dereferences a pointer that it expects to be valid, but is NULL, typically causing a crash or exit.

NULL pointer dereference issues can occur through a number of flaws, including race conditions, and simple programming omissions.

::NATURE:ChildOf:CWE ID:710:VIEW ID:1000:ORDINAL:Primary::NATURE:ChildOf:CWE ID:754:VIEW ID:1000::NATURE:ChildOf:CWE ID:754:VIEW ID:1003:ORDINAL:Primary::

::ORDINALITY:Resultant:DESCRIPTION:NULL pointer dereferences are frequently resultant from rarely encountered error conditions, since these are most likely to escape detection during the testing phases.::

::LANGUAGE NAME:C:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C++:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:Java:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C#:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:Go:LANGUAGE PREVALENCE:Undetermined::

::TERM:NPD::TERM:null deref::TERM:nil pointer dereference:DESCRIPTION:used for access of nil in Go programs::

::PHASE:Implementation::

::SCOPE:Availability:IMPACT:DoS: Crash, Exit, or Restart:NOTE:NULL pointer dereferences usually result in the failure of the process unless exception handling (on some platforms) is available and implemented. Even when exception handling is being used, it can still be very difficult to return the software to a safe state of operation.::SCOPE:Integrity:SCOPE:Confidentiality:SCOPE:Availability:IMPACT:Execute Unauthorized Code or Commands:IMPACT:Read Memory:IMPACT:Modify Memory:NOTE:In rare circumstances, when NULL is equivalent to the 0x0 memory address and privileged code can access it, then writing or reading memory is possible, which may lead to code execution.::

::METHOD:Automated Dynamic Analysis:DESCRIPTION:This weakness can be detected using dynamic tools and techniques that interact with the software using large test suites with many diverse inputs, such as fuzz testing (fuzzing), robustness testing, and fault injection. The software's operation may slow down, but it should not become unstable, crash, or generate incorrect results.:EFFECTIVENESS:Moderate::METHOD:Manual Dynamic Analysis:DESCRIPTION:Identify error conditions that are not likely to occur during normal usage and trigger them. For example, run the program under low memory conditions, run with insufficient privileges or permissions, interrupt a transaction before it is completed, or disable connectivity to basic network services such as DNS. Monitor the software for any unexpected behavior. If you trigger an unhandled exception or similar error that was discovered and handled by the application's environment, it may still indicate unexpected conditions that were not handled by the application itself.::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::PHASE:Implementation:DESCRIPTION:If all pointers that could have been modified are sanity-checked previous to use, nearly all NULL pointer dereferences can be prevented.::PHASE:Requirements:DESCRIPTION:The choice could be made to use a language that is not susceptible to these issues.::PHASE:Implementation:DESCRIPTION:Check the results of all functions that return a value and verify that the value is non-null before acting upon it.:EFFECTIVENESS:Moderate::PHASE:Architecture and Design:DESCRIPTION:Identify all variables and data stores that receive information from external sources, and apply input validation to make sure that they are only initialized to expected values.::PHASE:Implementation:DESCRIPTION:Explicitly initialize all your variables and other data stores, either during declaration or just before the first usage.::PHASE:Testing:DESCRIPTION:Use automated static analysis tools that target this type of weakness. Many modern techniques use data flow analysis to minimize the number of false positives. This is not a perfect solution, since 100% accuracy and coverage are not feasible.::

::REFERENCE:CVE-2005-3274:DESCRIPTION:race condition causes a table to be corrupted if a timer activates while it is being modified, leading to resultant NULL dereference; also involves locking.:LINK:https://www.cve.org/CVERecord?id=CVE-2005-3274::REFERENCE:CVE-2002-1912:DESCRIPTION:large number of packets leads to NULL dereference:LINK:https://www.cve.org/CVERecord?id=CVE-2002-1912::REFERENCE:CVE-2005-0772:DESCRIPTION:packet with invalid error status value triggers NULL dereference:LINK:https://www.cve.org/CVERecord?id=CVE-2005-0772::REFERENCE:CVE-2009-4895:DESCRIPTION:Chain: race condition for an argument value, possibly resulting in NULL dereference:LINK:https://www.cve.org/CVERecord?id=CVE-2009-4895::REFERENCE:CVE-2020-29652:DESCRIPTION:ssh component for Go allows clients to cause a denial of service (nil pointer dereference) against SSH servers.:LINK:https://www.cve.org/CVERecord?id=CVE-2020-29652::REFERENCE:CVE-2009-2692:DESCRIPTION:Chain: Use of an unimplemented network socket operation pointing to an uninitialized handler function (CWE-456) causes a crash because of a null pointer dereference (CWE-476).:LINK:https://www.cve.org/CVERecord?id=CVE-2009-2692::REFERENCE:CVE-2009-3547:DESCRIPTION:Chain: race condition (CWE-362) might allow resource to be released before operating on it, leading to NULL dereference (CWE-476):LINK:https://www.cve.org/CVERecord?id=CVE-2009-3547::REFERENCE:CVE-2009-3620:DESCRIPTION:Chain: some unprivileged ioctls do not verify that a structure has been initialized before invocation, leading to NULL dereference:LINK:https://www.cve.org/CVERecord?id=CVE-2009-3620::REFERENCE:CVE-2009-2698:DESCRIPTION:Chain: IP and UDP layers each track the same value with different mechanisms that can get out of sync, possibly resulting in a NULL dereference:LINK:https://www.cve.org/CVERecord?id=CVE-2009-2698::REFERENCE:CVE-2009-2692:DESCRIPTION:Chain: uninitialized function pointers can be dereferenced allowing code execution:LINK:https://www.cve.org/CVERecord?id=CVE-2009-2692::REFERENCE:CVE-2009-0949:DESCRIPTION:Chain: improper initialization of memory can lead to NULL dereference:LINK:https://www.cve.org/CVERecord?id=CVE-2009-0949::REFERENCE:CVE-2008-3597:DESCRIPTION:Chain: game server can access player data structures before initialization has happened leading to NULL dereference:LINK:https://www.cve.org/CVERecord?id=CVE-2008-3597::REFERENCE:CVE-2020-6078:DESCRIPTION:Chain: The return value of a function returning a pointer is not checked for success (CWE-252) resulting in the later use of an uninitialized variable (CWE-456) and a null pointer dereference (CWE-476):LINK:https://www.cve.org/CVERecord?id=CVE-2020-6078::REFERENCE:CVE-2008-0062:DESCRIPTION:Chain: a message having an unknown message type may cause a reference to uninitialized memory resulting in a null pointer dereference (CWE-476) or dangling pointer (CWE-825), possibly crashing the system or causing heap corruption.:LINK:https://www.cve.org/CVERecord?id=CVE-2008-0062::REFERENCE:CVE-2008-5183:DESCRIPTION:Chain: unchecked return value can lead to NULL dereference:LINK:https://www.cve.org/CVERecord?id=CVE-2008-5183::REFERENCE:CVE-2004-0079:DESCRIPTION:SSL software allows remote attackers to cause a denial of service (crash) via a crafted SSL/TLS handshake that triggers a null dereference.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-0079::REFERENCE:CVE-2004-0365:DESCRIPTION:Network monitor allows remote attackers to cause a denial of service (crash) via a malformed RADIUS packet that triggers a null dereference.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-0365::REFERENCE:CVE-2003-1013:DESCRIPTION:Network monitor allows remote attackers to cause a denial of service (crash) via a malformed Q.931, which triggers a null dereference.:LINK:https://www.cve.org/CVERecord?id=CVE-2003-1013::REFERENCE:CVE-2003-1000:DESCRIPTION:Chat client allows remote attackers to cause a denial of service (crash) via a passive DCC request with an invalid ID number, which causes a null dereference.:LINK:https://www.cve.org/CVERecord?id=CVE-2003-1000::REFERENCE:CVE-2004-0389:DESCRIPTION:Server allows remote attackers to cause a denial of service (crash) via malformed requests that trigger a null dereference.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-0389::REFERENCE:CVE-2004-0119:DESCRIPTION:OS allows remote attackers to cause a denial of service (crash from null dereference) or execute arbitrary code via a crafted request during authentication protocol selection.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-0119::REFERENCE:CVE-2004-0458:DESCRIPTION:Game allows remote attackers to cause a denial of service (server crash) via a missing argument, which triggers a null pointer dereference.:LINK:https://www.cve.org/CVERecord?id=CVE-2004-0458::REFERENCE:CVE-2002-0401:DESCRIPTION:Network monitor allows remote attackers to cause a denial of service (crash) or execute arbitrary code via malformed packets that cause a NULL pointer dereference.:LINK:https://www.cve.org/CVERecord?id=CVE-2002-0401::REFERENCE:CVE-2001-1559:DESCRIPTION:Chain: System call returns wrong value (CWE-393), leading to a resultant NULL dereference (CWE-476).:LINK:https://www.cve.org/CVERecord?id=CVE-2001-1559::

::TAXONOMY NAME:7 Pernicious Kingdoms:ENTRY NAME:Null Dereference::TAXONOMY NAME:CLASP:ENTRY NAME:Null-pointer dereference::TAXONOMY NAME:PLOVER:ENTRY NAME:Null Dereference (Null Pointer Dereference)::TAXONOMY NAME:OWASP Top Ten 2004:ENTRY ID:A9:ENTRY NAME:Denial of Service:MAPPING FIT:CWE More Specific::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:EXP34-C:ENTRY NAME:Do not dereference null pointers:MAPPING FIT:Exact::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP7:ENTRY NAME:Faulty Pointer Use::

Use of Obsolete Function

Base

Draft

The code uses deprecated or obsolete functions, which suggests that the code has not been actively reviewed or maintained.

As programming languages evolve, functions occasionally become obsolete due to: Advances in the language Improved understanding of how operations should be performed effectively and securely Changes in the conventions that govern certain operations Functions that are removed are usually replaced by newer counterparts that perform the same task in some different and hopefully improved way.

::NATURE:ChildOf:CWE ID:710:VIEW ID:1000:ORDINAL:Primary::

::ORDINALITY:Indirect::

::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Other:IMPACT:Quality Degradation::

::METHOD:Automated Static Analysis - Binary or Bytecode:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Highly cost effective: Binary / Bytecode Quality Analysis Cost effective for partial coverage: Bytecode Weakness Analysis - including disassembler + source code weakness analysis:EFFECTIVENESS:High::METHOD:Manual Static Analysis - Binary or Bytecode:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Cost effective for partial coverage: Binary / Bytecode disassembler - then use manual analysis for vulnerabilities & anomalies:EFFECTIVENESS:SOAR Partial::METHOD:Dynamic Analysis with Manual Results Interpretation:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Highly cost effective: Debugger:EFFECTIVENESS:High::METHOD:Manual Static Analysis - Source Code:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Highly cost effective: Manual Source Code Review (not inspections) Cost effective for partial coverage: Focused Manual Spotcheck - Focused manual analysis of source:EFFECTIVENESS:High::METHOD:Automated Static Analysis - Source Code:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Highly cost effective: Source Code Quality Analyzer Source code Weakness Analyzer Context-configured Source Code Weakness Analyzer:EFFECTIVENESS:High::METHOD:Automated Static Analysis:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Highly cost effective: Origin Analysis:EFFECTIVENESS:High::METHOD:Architecture or Design Review:DESCRIPTION:According to SOAR, the following detection techniques may be useful: Highly cost effective: Formal Methods / Correct-By-Construction Inspection (IEEE 1028 standard) (can apply to requirements, design, source code, etc.):EFFECTIVENESS:High::

::PHASE:Implementation:DESCRIPTION:Refer to the documentation for the obsolete function in order to determine why it is deprecated or obsolete and to learn about alternative ways to achieve the same functionality.::PHASE:Requirements:DESCRIPTION:Consider seriously the security implications of using an obsolete function. Consider using alternate functions.::

::TAXONOMY NAME:7 Pernicious Kingdoms:ENTRY NAME:Obsolete::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP3:ENTRY NAME:Use of an improper API::TAXONOMY NAME:SEI CERT Perl Coding Standard:ENTRY ID:DCL30-PL:ENTRY NAME:Do not import deprecated modules:MAPPING FIT:CWE More Specific::TAXONOMY NAME:SEI CERT Perl Coding Standard:ENTRY ID:EXP30-PL:ENTRY NAME:Do not use deprecated or obsolete functions or modules:MAPPING FIT:CWE More Specific::

Missing Default Case in Multiple Condition Expression

Base

Draft

The code does not have a default case in an expression with multiple conditions, such as a switch statement.

If a multiple-condition expression (such as a switch in C) omits the default case but does not consider or handle all possible values that could occur, then this might lead to complex logical errors and resultant weaknesses. Because of this, further decisions are made based on poor information, and cascading failure results. This cascading failure may result in any number of security issues, and constitutes a significant failure in the system.

::NATURE:ChildOf:CWE ID:1023:VIEW ID:1000:ORDINAL:Primary::

::ORDINALITY:Primary::

::LANGUAGE NAME:C:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C++:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:Java:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:C#:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:Python:LANGUAGE PREVALENCE:Undetermined::LANGUAGE NAME:JavaScript:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Integrity:IMPACT:Varies by Context:IMPACT:Alter Execution Logic:NOTE:Depending on the logical circumstances involved, any consequences may result: e.g., issues of confidentiality, authentication, authorization, availability, integrity, accountability, or non-repudiation.::

::METHOD:Automated Static Analysis:DESCRIPTION:Automated static analysis, commonly referred to as Static Application Security Testing (SAST), can find some instances of this weakness by analyzing source code (or binary/compiled code) without having to execute it. Typically, this is done by building a model of data flow and control flow, then searching for potentially-vulnerable patterns that connect sources (origins of input) with sinks (destinations where the data interacts with external components, a lower layer such as the OS, etc.):EFFECTIVENESS:High::

::PHASE:Implementation:DESCRIPTION:Ensure that there are no cases unaccounted for when adjusting program flow or values based on the value of a given variable. In the case of switch style statements, the very simple act of creating a default case can, if done correctly, mitigate this situation. Often however, the default case is used simply to represent an assumed option, as opposed to working as a check for invalid input. This is poor practice and in some cases is as bad as omitting a default case entirely.::

::TAXONOMY NAME:CLASP:ENTRY NAME:Failure to account for default case in switch::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP4:ENTRY NAME:Unchecked Status Condition::

Use of Incorrect Operator

Base

Draft

The product accidentally uses the wrong operator, which changes the logic in security-relevant ways.

These types of errors are generally the result of a typo by the programmer.

::NATURE:ChildOf:CWE ID:670:VIEW ID:1000:ORDINAL:Primary::

::LANGUAGE NAME:C:LANGUAGE PREVALENCE:Sometimes::LANGUAGE NAME:C++:LANGUAGE PREVALENCE:Sometimes::LANGUAGE NAME:Perl:LANGUAGE PREVALENCE:Sometimes::LANGUAGE CLASS:Not Language-Specific:LANGUAGE PREVALENCE:Undetermined::

::PHASE:Implementation::

::SCOPE:Other:IMPACT:Alter Execution Logic:NOTE:This weakness can cause unintended logic to be executed and other unexpected application behavior.::

::METHOD:Automated Static Analysis:DESCRIPTION:This weakness can be found easily using static analysis. However in some cases an operator might appear to be incorrect, but is actually correct and reflects unusual logic within the program.::METHOD:Manual Static Analysis:DESCRIPTION:This weakness can be found easily using static analysis. However in some cases an operator might appear to be incorrect, but is actually correct and reflects unusual logic within the program.::

::REFERENCE:CVE-2022-3979:DESCRIPTION:Chain: data visualization program written in PHP uses the != operator instead of the type-strict !== operator (CWE-480) when validating hash values, potentially leading to an incorrect type conversion (CWE-704):LINK:https://www.cve.org/CVERecord?id=CVE-2022-3979::REFERENCE:CVE-2021-3116:DESCRIPTION:Chain: Python-based HTTP Proxy server uses the wrong boolean operators (CWE-480) causing an incorrect comparison (CWE-697) that identifies an authN failure if all three conditions are met instead of only one, allowing bypass of the proxy authentication (CWE-1390):LINK:https://www.cve.org/CVERecord?id=CVE-2021-3116::

::TAXONOMY NAME:CLASP:ENTRY NAME:Using the wrong operator::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:EXP45-C:ENTRY NAME:Do not perform assignments in selection statements:MAPPING FIT:CWE More Abstract::TAXONOMY NAME:CERT C Secure Coding:ENTRY ID:EXP46-C:ENTRY NAME:Do not use a bitwise operator with a Boolean-like operand:MAPPING FIT:CWE More Abstract::TAXONOMY NAME:Software Fault Patterns:ENTRY ID:SFP1:ENTRY NAME:Glitch in Computation::

Incorrect Block Delimitation

Base

Draft

The code does not explicitly delimit a block that is intended to contain 2 or more statements, creating a logic error.

In some languages, braces (or other delimiters) are optional for blocks. When the delimiter is omitted, it is possible to insert a logic error in which a statement is thought to be in a block but is not. In some cases, the logic error can have security implications.