A.8.29 Technological
Security testing in development and acceptance
Structured attributes from ISO/IEC 27002:2022 — control type · CIA properties · cybersecurity concept · operational capability · security domain. What do these mean?
Mapped NIST 800-53 r5 controls (18)
Our reading (mostly llm_verified) of how this ISO control and each NIST 800-53 control relate. Not an ISO or NIST product.
Direction: ← other covers this;
→ this covers other (F/M/P = full / mostly /
partial). gov = governs / implements (a mandate, not coverage).
Why these map — rationale
- SA-11mostlycovers — A.8.29's security testing in development and acceptance to validate requirements before production deployment accounts for the bulk of SA-11's developer testing/evaluation and evidence requirements across post-design SDLC stages, but leaves a residual of SA-11's ongoing control assessment plan and privacy-specific elements uncovered.
Aligned NIST CSF 2.0 outcomes (23)
NIST CSF 2.0 outcomes this ISO control aligns with — our analysis (mostly llm_verified).
Direction: ← other covers this;
→ this covers other (F/M/P = full / mostly /
partial). gov = governs / implements (a mandate, not coverage).
Why these map — rationale
- ID.IM-02domain mandateimplements — A.8.29's security testing in dev/acceptance directly operationalizes the identification of improvements from security tests (including supplier-coordinated ones) that ID.IM-02 requires; the link is within the shared testing-and-exercise domain but not by explicit citation of improvement identification.
- PR.PS-06domain mandateimplements — A.8.29's security testing in dev/acceptance directly operationalizes the integration and monitoring of secure SDLC practices named in PR.PS-06; testing is a core means within that domain (though not the only one).
Related OWASP ASVS 5.0 requirements (13)
Application-security verification requirements (OWASP ASVS 5.0) this ISO control aligns with; links open the ASVS chapter. Our analysis (mostly llm_verified) — many ISO controls have no ASVS counterpart.
Direction: ← other covers this;
→ this covers other (F/M/P = full / mostly /
partial). gov = governs / implements (a mandate, not coverage).
Related weaknesses / CWE (3279)
Weakness classes this ISO control helps prevent or mitigate — our analysis (mostly llm_verified).
Direction: ← other covers this;
→ this covers other (F/M/P = full / mostly /
partial). gov = governs / implements (a mandate, not coverage).
Why these map — rationale
- CWE-105fullfinds — A.8.29's static-analysis re-test and code review can mechanically cross-reference Struts form fields with configured validators, enabling discovery of every such missing-validator instance in the first-party code covered by the programme.
- CWE-315fullfinds — A.8.29's combined code review, static analysis, and penetration testing expose both the cookie-setting sink in source and the actual cleartext cookie value at runtime, so a well-implemented programme discovers this weakness completely.
- CWE-382fullfinds — CWE-382 is a literal source-code construct (a direct call to System.exit()) that SAST/code analysis tools detect near-mechanically, and A.8.29's programme explicitly names code analysis tools, code review, and penetration testing — together covering the full discovery surface for this weakness with no nameable remainder.
- CWE-481fullfinds — CWE-481 is a literal syntactic pattern in source code (assignment in a conditional position) that SAST tools flag with very high reliability, that code review catches, and that the combined A.8.29 programme (static analysis + code review + dynamic testing + penetration testing) is designed to discover; there is no nameable remainder in first-party code, matching the same logic that placed A.8.29 -> CWE-89 at the top rung.
- CWE-523fullfinds — A.8.29's testing programme — code review, vulnerability scanning, static analysis, and penetration testing — reaches CWE-523 from every angle: the missing-HTTPS-on-login weakness is visible in source (form action URLs), to static analysis (mixed-content / http:// in auth code), and trivially from outside via penetration testing (intercepting the credential POST). The clause explicitly names authentication (8.5) and cryptography (8.24) as security functions to be tested, and there is no further act of finding left over for this weakness class.
- CWE-581fullfinds — CWE-581 is a first-party Java source-code defect (equals overridden without hashCode) that static analysis tools — explicitly named in A.8.29's guidance — detect near-mechanically via well-established rules (e.g., SpotBugs HE_EQUALS_NO_HASHCODE), and code review (also named) catches it as a textbook contract violation; the weakness is observable from source with no meaningful remainder.
- CWE-583fullfinds — CWE-583 is a literal source-code pattern (a public finalize() method declaration) that A.8.29's programme — code review, static analysis tools, and acceptance testing — reaches directly; static analysis has well-known detectors for this construct and code review against secure coding guidelines catches it, leaving no remainder to name.
- CWE-586fullfinds — CWE-586 is a literal source-level pattern (an explicit call to a named method) that A.8.29's combined programme — code review, SAST, and acceptance testing — reaches directly; static analysis flags the call reliably and code review catches it, leaving no nameable remainder.
- CWE-607fullfinds — CWE-607 is a pure source-code declaration pattern (public/protected static final field of mutable type) that static analysis tools flag reliably and code review catches; A.8.29's SOURCE reach (code analysis tools, code review) covers it completely with no nameable remainder, unlike weaknesses that can be assembled at build time or hidden in binary-only components.
- CWE-793fullfinds — A.8.29's combined code review, static/dynamic testing, and penetration testing reaches this incomplete-filtering flaw both in source and as observable traversal behavior, leaving no named share undiscovered in a well-implemented program.
- CWE-8fullfinds — A.8.29's code review, configuration/static analysis, and penetration testing directly inspect the EJB deployment descriptor and source where a remote entity bean declaration is plainly visible, leaving no named remainder unfound.
- CWE-806fullfinds — A.8.29's full testing programme — code review, static analysis, vulnerability scanning, and penetration testing — is the complete set of pre-production discovery for a source-level buffer-size defect like CWE-806; the sizeof(source) vs sizeof(dest) pattern is mechanically caught by SAST and code review, and observable buffer overflows are caught by dynamic testing and pen testing, leaving no further act of finding.
- CWE-89fullfinds — The same secure-coding and static-analysis activities surface missing neutralization of SQL metacharacters before the system is accepted.
- CWE-918fullfinds — A.8.29's testing programme (code review, static analysis, vulnerability scanning, penetration testing, architecture review) covers every detection method CWE-918 rates High or Moderate, and the clause explicitly names code review for un-anticipated inputs and acceptance testing of acquired products, so no further act of finding is left over — the same logic the owner applied to A.8.29 finds CWE-89 = full.
- CWE-94fullfinds — A.8.29's programme of code review, static analysis, dynamic testing and penetration testing is the complete pre-production discovery set for code injection: eval/dynamic-execution sinks are visible to SAST, code review catches them, and penetration testing reaches the externally exploitable instances, with no nameable remainder.
- CWE-1004mostlyfinds — Security testing can detect missing HttpOnly flags but does not prevent the weakness.
- CWE-102mostlyfinds — Security testing in development can detect duplicate validation forms before release.
- CWE-1021mostlyfinds — Security testing can detect missing frame protections, but does not itself implement the control.
- CWE-1022mostlyfinds — Security testing can detect missing protections on external links through automated or manual checks.
- CWE-1023mostlyfinds — Security testing can detect missing comparison factors, yet testing is only one part of the control's scope.
- CWE-1024mostlyfinds — Security testing in development can detect type-mismatch defects through static analysis and unit tests.
- CWE-1025mostlyfinds — Security testing can detect incorrect comparison results during development and acceptance.
- CWE-1037mostlyfinds — Security testing in development can detect when optimizations have removed intended protections.
- CWE-1038mostlyfinds — Security testing in development and acceptance can detect unintended side-effects introduced by automated optimizations.
- CWE-1039mostlyfinds — Security testing in development can explicitly cover adversarial input testing for recognition mechanisms.
- CWE-104mostlyfinds — A.8.29's SOURCE reach (code review, static analysis) catches this Struts-specific pattern — a form bean extending ActionForm rather than ValidatorForm/ValidatorActionForm is a literal source-code construct that SAST rules and manual review flag. RUNTIME reach (penetration testing) also surfaces the consequence (insufficient input validation). The remainder is bounded: instances in code paths not exercised by tests and forms not covered by the SAST rule set.
- CWE-1045mostlyfinds — A.8.29's source reach (code review and static analysis) detects this C++ class-hierarchy pattern in most first-party code, but the runtime reach (penetration testing, dynamic testing) does not see it, and complex template code or third-party binary components remain a bounded, nameable remainder.
- CWE-1049mostlyfinds — Security testing in development can detect performance issues caused by excessive query operations.
- CWE-1050mostlyfinds — Security testing can discover the defect but does not remove it from production code.
- CWE-1051mostlyfinds — A.8.29's source reach (static analysis, code review) catches the bulk of CWE-1051 instances because hard-coded network resource identifiers are literal values in source code that linters and reviewers routinely flag; the bounded remainder is values that are obfuscated, split across constructs, or embedded in configuration that the source-scanning programme does not reach.
- CWE-1056mostlyfinds — Security testing can detect misuse of variadic functions but does not prevent their introduction.
- CWE-1057mostlyfinds — Security testing can detect unauthorized data-access paths bypassing the central manager.
- CWE-1058mostlyfinds — A.8.29's programme includes code review and static analysis tools, both of which are well-suited to detecting the non-final static field pattern in CWE-1058 (a structural code property that SAST detectors and trained reviewers reliably flag); the remainder is bounded and nameable — dynamic testing and penetration testing are weak for race-condition classes because manifestation is timing-dependent, and some instances require runtime context to confirm the multi-threaded reach.
- CWE-106mostlyfinds — A.8.29's SOURCE reach (code review and static analysis) directly inspects struts-config.xml for the validator plug-in declaration, and the weakness is a literal configuration choice visible in source; the nameable remainder is organizations whose SAST rules lack Struts-specific checks or whose code review does not focus on framework configuration choices.
- CWE-1065mostlyfinds — A.8.29's source reach (code review, static analysis) catches the pattern of low-level resource management calls in application-server contexts, and runtime testing can surface the resulting reliability issues; the remainder is cases where the low-level call is contextually justified or where static rules cannot reliably distinguish appropriate from inappropriate use.
- CWE-1066mostlyfinds — Security testing can detect missing serialization methods before production deployment.
- CWE-1068mostlyfinds — Security testing can detect deviations, yet does not prevent the inconsistency from occurring.
- CWE-107mostlyfinds — A.8.29's SOURCE reach (code review, static analysis) reaches this weakness — it is a first-party Java/Struts pattern visible by comparing validator.xml to the ActionForm class, and a well-implemented programme with thorough code review and Java-aware SAST will catch most instances; the remainder is bounded and nameable: tools without specific rules for unused Struts validation forms, and reviews that do not cross-check the XML against the form class, plus the fact that CWE-107 is classified as Quality Degradation rather than a security impact so security-focused testing may not prioritise it.
- CWE-1070mostlyfinds — A.8.29's SOURCE reach (SAST, code review) catches most instances of a serializable container holding non-serializable members, since this is a structural class-hierarchy property that serialization-aware static rules and review flag mechanically; the bounded remainder is cases where serialization is done through reflection, dynamic proxies, or custom frameworks that obscure the pattern from automated analysis.
- CWE-1071mostlyfinds — A.8.29's SOURCE reach (SAST and code review) detects empty code blocks near-mechanically in in-house code under development, since the pattern is literal in source; the bounded remainder is acquired products where only RUNTIME acceptance testing is available and the defect is not observable from outside, plus code outside the active development/acceptance cycle.
- CWE-1074mostlyfinds — A.8.29's source-side reach (SAST, code review) detects deep inheritance hierarchies as a structural code property that standard linters and static analyzers commonly flag; the bounded remainder is third-party code outside the developer's source view, since dynamic testing and penetration testing cannot observe this purely structural property.
- CWE-1077mostlyfinds — Security testing can detect floating-point comparison defects but does not prevent them by itself.
- CWE-1079mostlyfinds — A.8.29's SOURCE reach (static analysis tools, code review) detects CWE-1079 with high reliability — it is a mechanically checkable C++ class-design defect that linters and reviewers flag — but the RUNTIME reach (dynamic testing, penetration testing) does not observe it, and third-party/binary-only components without source access are outside the programme, leaving a bounded remainder.
- CWE-108mostlyfinds — A.8.29's SOURCE reach (code review, static analysis) catches this Struts configuration defect — either an Action Form has a validation form or it does not, and a reviewer or Struts-aware SAST rule finds it mechanically; the bounded remainder is organizations whose static-analysis rulesets lack Struts-specific patterns and whose reviewers are not Struts-familiar, where the missing validation form is not surfaced.
- CWE-1080mostlyfinds — A.8.29's SOURCE reach (code analysis tools, code review) mechanically detects file length — most SAST tools report it as a standard metric and reviewers notice it — so the programme finds the bulk of instances; the bounded remainder is programmes that do not configure the line-count metric or files sitting just under whatever threshold is set, since the weakness is a maintainability/quality signal rather than a direct security defect the testing programme is tuned to flag.
- CWE-1082mostlyfinds — A.8.29's SOURCE reach (static analysis tools, code review) catches the direct 'delete this' pattern mechanically — it is a well-known checker in tools like Coverity and Klocwork — and code review surfaces it in first-party code; the remainder is third-party/binary-only code where source access is absent and more subtle indirect self-destruction patterns that escape mechanical detection.
- CWE-1083mostlyfinds — Security testing can detect unauthorized direct access paths, but does not itself prevent their introduction.
- CWE-1085mostlyfinds — CWE-1085 is a purely source-visible property (excess commented-out lines, with a mechanical 2% threshold), and A.8.29's SOURCE reach via code analysis tools and code review activities can detect it directly; a well-implemented programme catches most instances, with the remainder bounded to third-party components where acceptance testing is runtime-focused and to borderline threshold cases.
- CWE-1087mostlyfinds — A.8.29's SOURCE reach (static analysis tools, code review) routinely detects missing virtual destructors in classes with virtual methods — a near-mechanical check most C++ linters perform — and code review would catch it; the bounded remainder is complex inheritance hierarchies where the tool or reviewer misses the base/derived relationship, and the RUNTIME half (penetration testing) does not typically surface this reliability defect.
- CWE-1088mostlyfinds — Security testing can detect missing timeouts, providing partial coverage of both the weakness and the control.
- CWE-109mostlyfinds — A.8.29's SOURCE reach (code review, static analysis) catches the literal `validate="false"` attribute in Struts action mappings as a near-mechanical pattern, and RUNTIME reach (penetration testing) can observe the resulting lack of input validation; the bounded remainder is configurations built dynamically or outside the SAST rule set's coverage.
- CWE-1090mostlyfinds — A.8.29's SOURCE reach (code review and static analysis tools) catches direct cross-class member access as a source-code pattern; the weakness is highly visible in code and many SAST tools flag encapsulation violations, so a well-implemented programme finds most instances, with the remainder being cases where the access pattern isn't flagged or reviewed.
- CWE-1091mostlyfinds — Security testing can detect missing destructor calls through static analysis or resource-leak testing.
- CWE-1096mostlyfinds — A.8.29's SOURCE reach (code review and static analysis tools) is well-suited to detecting the singleton-without-locking pattern, and most instances are caught by SAST rules and manual review; the bounded remainder is complex singleton implementations (reflection, class-loader tricks, double-checked locking variants) that escape rule-based detection.
- CWE-1098mostlyfinds — A.8.29's SOURCE reach (static analysis, code review) catches this well-defined C++ pattern mechanically — missing copy constructors/assignment operators on classes with pointer members are a classic lint and SAST finding — and RUNTIME reach (penetration testing) catches instances that manifest as double-free or use-after-free; the bounded remainder is third-party components outside the developer's source-reading tests and edge cases where custom pointer management defeats the analyzer.
- CWE-11mostlyfinds — Security testing in development and acceptance can detect debug binaries but does not prevent their creation or deployment.
- CWE-110mostlyfinds — A.8.29's SOURCE reach (code review, static analysis) directly targets this kind of cross-file inconsistency between ActionForm and validation form, and a well-implemented programme would catch most instances; the remainder is cases where automated rules lack specific Struts validator-form checks and reviewers don't compare the paired artifacts.
- CWE-1102mostlyfinds — Security testing can detect platform-specific representation issues but does not itself prevent their introduction.
- CWE-111mostlyfinds — Security testing can detect unsafe JNI usage through static analysis and fuzzing of native boundaries.
- CWE-1119mostlyfinds — Security testing can detect overly complex or unstructured code, yet the control focuses on testing rather than coding rules.
- CWE-112mostlyfinds — Security testing in development can detect missing XML validation but does not itself implement the control.
- CWE-1123mostlyfinds — A.8.29's SOURCE reach (static analysis tools, code review) detects self-modifying code patterns — writes to executable memory, mprotect calls, JIT-like constructs — and a reviewer can then judge whether usage is excessive; the bounded remainder is indirect or heavily obfuscated self-modification that resists mechanical pattern matching.
- CWE-113mostlyfinds — Security testing in development and acceptance can detect CRLF injection flaws before deployment.
- CWE-114mostlyfinds — Security testing can detect unsafe process or library loading but does not prevent it by itself.
- CWE-115mostlyfinds — Security testing can detect input misinterpretation flaws but does not itself implement the preventive controls.
- CWE-116mostlyfinds — Security testing can detect missing or incorrect encoding but does not itself implement the control.
- CWE-117mostlyfinds — Security testing can detect log injection flaws but does not prevent them at the source.
- CWE-1173mostlyfinds — Security testing can detect missing validation but does not enforce framework adoption.
- CWE-1174mostlyfinds — Security testing in development and acceptance will detect missing model validation.
- CWE-118mostlyfinds — Security testing can detect range errors through fuzzing and boundary-value analysis.
- CWE-1188mostlyfinds — A.8.29's combined programme (code review, static analysis, vulnerability scanning, penetration testing) reaches insecure defaults through both SOURCE (hardcoded defaults in first-party code) and RUNTIME (default configurations observable in deployed systems), and the clause explicitly names secure configuration testing; the remainder is defaults whose insecurity depends on threat context the tester cannot infer, and defaults buried in third-party components that acceptance testing inspects from outside only.
- CWE-119mostlyfinds — Security testing in development catches out-of-bounds accesses before release, covering most instances of the weakness.
- CWE-12mostlyfinds — Security testing can detect missing custom error pages during acceptance testing.
- CWE-120mostlyfinds — Security testing in development and acceptance can detect buffer overflows through fuzzing and static analysis, though it does not prevent them at the source.
- CWE-1204mostlyfinds — Security testing in development can detect use of static or predictable IVs before release.
- CWE-121mostlyfinds — Security testing (fuzzing, static analysis) detects stack overflows before release.
- CWE-122mostlyfinds — Security testing in development and acceptance can detect heap overflows before release.
- CWE-123mostlyfinds — Security testing in development and acceptance can detect write-what-where conditions before deployment.
- CWE-1236mostlyfinds — Security testing in development can detect formula injection but does not itself implement the mitigation.
- CWE-124mostlyfinds — Security testing in development catches buffer-underflow defects before release.
- CWE-1240mostlyfinds — Security testing can detect use of weak or non-compliant cryptographic primitives before deployment.
- CWE-1241mostlyfinds — Security testing can detect predictable RNG behavior before deployment.
- CWE-125mostlyfinds — Security testing in development and acceptance includes fuzzing and static analysis that detect out-of-bounds read defects before release.
- CWE-126mostlyfinds — Security testing in development can detect buffer over-reads before release.
- CWE-1265mostlyfinds — Security testing in development can detect reentrancy vulnerabilities through stress, concurrency, and fuzz testing.
- CWE-127mostlyfinds — Security testing can detect buffer under-reads before release.
- CWE-1275mostlyfinds — Security testing can detect missing SameSite attributes but does not prevent the weakness.
- CWE-128mostlyfinds — Security testing can detect wrap-around errors through boundary and fuzz testing.
- CWE-1284mostlyfinds — Security testing in development can detect missing quantity validation but does not itself implement the control.
- CWE-1285mostlyfinds — Security testing can detect missing or incorrect index validation during development and acceptance.
- CWE-1286mostlyfinds — Security testing in development catches missing or incorrect syntax validation.
- CWE-1287mostlyfinds — Security testing can detect type-validation flaws but does not prevent them during development.
- CWE-1288mostlyfinds — Security testing can detect consistency flaws but does not prevent them at design time.
- CWE-1289mostlyfinds — Security testing can detect unsafe equivalence flaws but does not prevent them at design time.
- CWE-129mostlyfinds — Security testing in development can detect out-of-bounds array access but does not prevent the weakness by itself.
- CWE-13mostlyfinds — A.8.29's SOURCE reach (SAST, code review) directly targets plaintext passwords in ASP.NET config files — a literal-string pattern that automated tools and manual review reliably flag, similar to CWE-798 which graded `mostly`. The bounded remainder is config files dynamically generated at build time, credentials in third-party ASP.NET components outside the acceptance-testing scope, and obfuscated/encrypted-then-decrypted credential storage.
- CWE-130mostlyfinds — Security testing in development can detect length-inconsistency vulnerabilities before deployment.
- CWE-1321mostlyfinds — Security testing in development catches prototype-pollution flaws before release.
- CWE-1322mostlyfinds — Security testing can detect blocking behavior but does not prevent the weakness by itself.
- CWE-1325mostlyfinds — Security testing can detect unbounded allocation patterns, but removing the weakness does not fulfill testing obligations.
- CWE-1327mostlyfinds — A.8.29's SOURCE+RUNTIME programme reaches CWE-1327 through multiple routes: SAST detects the literal 0.0.0.0 string in code or configuration-as-code, code review catches it, and penetration testing observes the unrestricted binding via network scanning. The remainder is bounded: bindings constructed dynamically at runtime, or present in infrastructure configuration outside the application test scope, are not reached by the same mechanical discovery.
- CWE-1333mostlyfinds — Security testing can detect and reject regex patterns with exponential worst-case complexity.
- CWE-1335mostlyfinds — Security testing in development can detect shift-related defects before release.
- CWE-1336mostlyfinds — Security testing can detect template-injection flaws but does not itself implement neutralization controls.
- CWE-134mostlyfinds — Security testing in development can detect format-string vulnerabilities before release.
- CWE-1341mostlyfinds — Security testing in development can detect double-release defects before release.
- CWE-135mostlyfinds — Security testing in development and acceptance can detect incorrect multi-byte string length calculations through targeted test cases.
- CWE-138mostlyfinds — Security testing can detect instances of CWE-138 but does not itself implement the neutralization controls.
- CWE-1385mostlyfinds — Security testing can detect missing origin validation in WebSocket implementations.
- CWE-1386mostlyfinds — Security testing can detect junction/mount-point weaknesses before release.
- CWE-1389mostlyfinds — Security testing can detect radix-related parsing flaws but does not prevent them by itself.
- CWE-1391mostlyfinds — Security testing can discover weak credentials, but does not guarantee they are prevented by design.
- CWE-1392mostlyfinds — A.8.29's combined programme (code review, SAST, vulnerability scanning, penetration testing, and acceptance testing of acquired products) reaches default credentials through both SOURCE (hardcoded defaults in source/config are caught by SAST and code review) and RUNTIME (pentesters routinely try common/default credentials, and acceptance testing checks acquired products against criteria), but the remainder is nameable: default credentials embedded in binary-only third-party components where source is unavailable, and defaults that are not easily guessable or documented, leave a slice the programme does not reach.
- CWE-1393mostlyfinds — A.8.29's SOURCE reach (SAST, code review) catches hardcoded default password strings in first-party code, and its RUNTIME reach (penetration testing, acceptance testing of acquired products) catches default credentials by trying well-known defaults against deployed or candidate systems — a standard pen-test check. The remainder is bounded: generated-but-predictable defaults, defaults stored in obfuscated or encrypted form, and defaults in binary-only components where neither source review nor standard credential-spray testing reaches them.
- CWE-1394mostlyfinds — A.8.29's testing programme (code review, static analysis, vulnerability scanning, penetration testing) covers the main detection routes for default cryptographic keys — hardcoded keys are caught by SAST and code review, configuration-resident defaults by configuration testing, and documented defaults by penetration testing with known values. The remainder is bounded and parallels the CWE-798 anchor: keys assembled at build time, baked into images as configuration, or shipped inside binary-only third-party components where only manual binary analysis rates High.
- CWE-14mostlyfinds — Security testing can detect residual sensitive data left by dead-store removal, but does not prevent the weakness itself.
- CWE-140mostlyfinds — Security testing in development and acceptance can detect delimiter-related weaknesses before deployment.
- CWE-141mostlyfinds — Security testing can detect delimiter issues but does not itself implement the neutralization.
- CWE-142mostlyfinds — Security testing in development and acceptance can detect delimiter-handling defects before release.
- CWE-1428mostlyfinds — A.8.29's combined programme of static analysis, dynamic testing, and penetration testing discovers reliance on HTTP in both first-party source and deployed systems, but instances in third-party components without source access or in configurations outside the test scope remain undiscovered.
- CWE-143mostlyfinds — Security testing can detect delimiter issues but does not itself implement the fix.
- CWE-144mostlyfinds — Security testing can detect the weakness but does not itself implement the neutralization.
- CWE-145mostlyfinds — Security testing in development and acceptance can detect delimiter-neutralization flaws before release.
- CWE-146mostlyfinds — Security testing can detect the weakness but does not prevent it by itself.
- CWE-147mostlyfinds — Security testing can detect terminator issues but does not itself implement the neutralization control.
- CWE-148mostlyfinds — Security testing can detect missing or malformed leaders, providing partial mitigation.
- CWE-149mostlyfinds — Security testing can detect quote-injection but does not itself implement the fix.
- CWE-15mostlyfinds — A.8.29's combined programme of code review, vulnerability scanning, and penetration testing discovers externally-controlled configuration settings in both first-party code and acquired products, but a nameable remainder exists in settings that are only exploitable through complex, multi-step attack chains that standard penetration testing may not uncover.
- CWE-150mostlyfinds — Security testing can detect the weakness but does not itself implement neutralization.
- CWE-151mostlyfinds — A.8.29's SOURCE+RUNTIME reach (SAST, code review, penetration testing, dynamic analysis) discovers comment-delimiter neutralization failures through the same taint-flow mechanisms that catch SQL injection and XSS; the remainder is bounded and nameable — comment delimiters in non-standard contexts (protocol fields, configuration parsers, shell interpreters) where SAST rules are sparser and the weakness may not surface as an externally observable exploit during one cycle of penetration testing.
- CWE-153mostlyfinds — Security testing can detect substitution-character flaws but does not itself implement neutralization.
- CWE-154mostlyfinds — Security testing can discover delimiter-injection flaws but does not itself implement the neutralization fix.
- CWE-155mostlyfinds — Security testing can detect wildcard issues but does not itself implement neutralization controls.
- CWE-156mostlyfinds — Security testing can detect whitespace handling issues but does not prevent them at the source.
- CWE-157mostlyfinds — Security testing in development can detect delimiter-handling weaknesses before release.
- CWE-158mostlyfinds — Security testing can detect null-byte flaws but does not itself implement the neutralization.
- CWE-159mostlyfinds — Security testing can discover the weakness but does not itself implement the preventive control.
- CWE-161mostlyfinds — A.8.29's SOURCE+RUNTIME reach (SAST, code review, DAST, penetration testing) covers this input-neutralization weakness in first-party code, and the canonical example (multiple leading slashes bypassing path checks) is exactly the kind of pattern pen testers probe and SAST rules flag; the remainder is the narrower, less-standardized variants of 'multiple leading special elements' that automated rules may not enumerate and that pen testers may not specifically craft, which is a bounded share rather than a vanishing one.
- CWE-162mostlyfinds — Security testing can detect the weakness but does not itself implement neutralization controls.
- CWE-163mostlyfinds — A.8.29's combined programme of code review, static analysis, and penetration testing reaches CWE-163 through both SOURCE and RUNTIME routes — the weakness is observable from outside (directory listings change with trailing slashes/dots) and is a pattern code review and SAST can detect in path-construction logic; the remainder is instances in third-party parsing libraries or deeply nested handling that the developer's own testing programme does not exercise.
- CWE-164mostlyfinds — Security testing in development and acceptance can detect the weakness but does not prevent it at design or coding time.
- CWE-165mostlyfinds — A.8.29's SOURCE+RUNTIME reach (SAST, code review, dynamic testing, penetration testing) discovers most instances of this parsing-time neutralization defect in first-party code; the remainder is the harder cases where multiple internal special elements interact in ways that evade automated tools and require deeper manual analysis.
- CWE-166mostlyfinds — Security testing can discover missing-element flaws but does not prevent them by itself.
- CWE-167mostlyfinds — Security testing in development catches improper handling of unexpected special elements before release.
- CWE-168mostlyfinds — Security testing can detect inconsistent-element flaws but does not prevent them by itself.
- CWE-170mostlyfinds — Security testing in development can detect missing or incorrect null terminators before release.
- CWE-172mostlyfinds — Security testing in development can detect encoding flaws before deployment.
- CWE-173mostlyfinds — Security testing can detect encoding-handling defects but does not itself implement the preventive coding controls.
- CWE-174mostlyfinds — A.8.29's SOURCE+RUNTIME reach covers CWE-174: SAST can flag double-decode patterns by tracking data flow through decode functions, code review catches the logic, and penetration testing surfaces it by probing protection bypasses (as the CVE examples show). The remainder is subtle cross-module cases where the two decodes sit in different components and the protection in between is implicit, plus the noted research gap meaning fewer tools specifically target the pattern.
- CWE-176mostlyfinds — Security testing can detect Unicode-handling flaws before deployment.
- CWE-177mostlyfinds — Security testing in development catches URL-decoding flaws before release, but does not itself define coding rules.
- CWE-178mostlyfinds — A.8.29's SOURCE+RUNTIME reach catches most CWE-178 instances: code review and static analysis flag case-handling defects in security-sensitive comparisons, and penetration testing surfaces bypass cases (filter evasion, ACL bypass via alternate case) that the CVE examples show are commonly exploited and thus observable from outside; the remainder is subtle implementation defects where case-handling is correct in tested paths but wrong in untested ones, which is bounded and nameable.
- CWE-179mostlyfinds — Security testing can detect early-validation flaws but does not inherently prevent them in design.
- CWE-180mostlyfinds — Security testing can detect validation-order defects before deployment.
- CWE-181mostlyfinds — A.8.29's combined programme of code review, static analysis and penetration testing reaches CWE-181 through both source and runtime channels — the ordering flaw is visible to a reviewer reading the validate/filter sequence, to data-flow-aware static analysis, and to penetration testing when the resulting bypass manifests as an exploitable behaviour (the CVE examples are directory traversals found from outside). The remainder is nameable: cases where the ordering subtlety escapes both review and SAST and the post-filter behaviour is not exploitable enough to surface in dynamic testing.
- CWE-182mostlyfinds — Security testing can detect collapse issues but does not prevent them by itself.
- CWE-183mostlyfinds — Security testing can detect overly broad allow-lists, but does not inherently prevent their creation.
- CWE-184mostlyfinds — Security testing can discover missing input checks, but does not prevent the weakness during development.
- CWE-185mostlyfinds — Security testing in development can detect regex-related flaws before release.
- CWE-186mostlyfinds — Security testing in development can detect overly restrictive regex through negative-test cases.
- CWE-187mostlyfinds — Security testing can detect and prevent partial string comparison flaws before deployment.
- CWE-188mostlyfinds — Security testing in development can detect layout-related defects before release.
- CWE-190mostlyfinds — Security testing in development can detect integer overflows before release.
- CWE-191mostlyfinds — Security testing in development catches integer underflow defects before release.
- CWE-192mostlyfinds — Security testing in development can detect integer coercion flaws via fuzzing and static analysis.
- CWE-193mostlyfinds — Security testing in development and acceptance can detect off-by-one errors before release.
- CWE-194mostlyfinds — Security testing in development can detect unexpected sign-extension behavior through targeted test cases.
- CWE-195mostlyfinds — Security testing in development can detect conversion-related defects before release.
- CWE-196mostlyfinds — Security testing can detect integer conversion errors through static analysis and fuzzing.
- CWE-197mostlyfinds — Security testing can detect truncation bugs through static analysis and fuzzing.
- CWE-198mostlyfinds — Security testing can detect byte-order defects before acceptance.
- CWE-20mostlyfinds — Testing against a defined set of requirements and using code review plus vulnerability scanning forces validation of inputs and handling of unanticipated conditions, reducing the chance that malformed data will be accepted.
- CWE-200mostlyfinds — Penetration testing and vulnerability scanning are performed to discover unintended exposure of sensitive data resulting from misconfigurations or coding errors.
- CWE-201mostlyfinds — A.8.29's SOURCE+RUNTIME reach covers CWE-201 well: code review and static analysis can spot sensitive fields being placed in response objects, and penetration testing/dynamic analysis can observe the data actually leaving the system (the weakness is by definition visible to another actor receiving the response). The remainder is bounded and nameable — cases where the sensitivity classification depends on business context the tester cannot infer (e.g., the 'show email address' setting example), or response paths the test plan does not exercise.
- CWE-204mostlyfinds — Security testing can detect observable response discrepancies before deployment.
- CWE-205mostlyfinds — Security testing can detect and require remediation of observable behavioral differences before release.
- CWE-207mostlyfinds — Security testing can detect and eliminate observable behavioral discrepancies before deployment.
- CWE-209mostlyfinds — Security testing can detect error messages that leak sensitive information.
- CWE-210mostlyfinds — Security testing can detect the weakness but does not prevent it by itself.
- CWE-211mostlyfinds — A.8.29's combined programme of code review, static analysis, and penetration/dynamic testing reaches CWE-211 well: missing exception handling and unsanitised error propagation are visible in source, and pentesters routinely trigger verbose errors to observe responses. The remainder is bounded and nameable — errors that only manifest under specific environmental conditions or through third-party error-generation paths the test plan does not exercise.
- CWE-214mostlyfinds — A.8.29's SOURCE reach (code review, SAST) catches the well-known pattern of passing credentials via command-line arguments or environment variables to process invocations, and the weakness is primarily a source-code defect; the remainder is bounded and nameable — dynamically constructed sensitive arguments that defeat static tracing, and instances inside third-party or binary-only components outside the reviewed source set.
- CWE-215mostlyfinds — Security testing in development catches debug statements and sensitive data leaks.
- CWE-219mostlyfinds — A.8.29's combined programme of code review, vulnerability scanning and penetration testing reaches CWE-219 through both SOURCE (the file-placement decision is visible in code/build/config) and RUNTIME (an attacker can request the file directly, so dynamic testing and pen-testing surface it), and the weakness is observable from outside; the remainder is files with non-obvious names or paths the test plan does not probe.
- CWE-22mostlyfinds — Security testing in development catches path traversal via static/dynamic analysis.
- CWE-220mostlyfinds — A.8.29's combined programme (code review, SAST, DAST, penetration testing) reaches CWE-220 through multiple routes: pentest directly surfaces sensitive files accessible under FTP root, code review catches the architectural placement, and SAST rules flag sensitive data in web/FTP-accessible directories; the remainder is cases where access control is technically present but subtly insufficient in ways automated tools miss.
- CWE-226mostlyfinds — Security testing can detect failures to sanitize resources before reuse.
- CWE-228mostlyfinds — Security testing can detect malformed-input issues but does not itself implement the handling logic.
- CWE-229mostlyfinds — Security testing can detect missing-value flaws but does not itself implement the handling logic.
- CWE-23mostlyfinds — Security testing in development catches path traversal via static/dynamic analysis, but does not itself implement the fix.
- CWE-230mostlyfinds — Security testing can detect missing-value flaws but does not itself prevent them.
- CWE-231mostlyfinds — Security testing can detect extra-value handling issues but does not prevent them by itself.
- CWE-232mostlyfinds — Security testing in development can detect missing handling of undefined values before release.
- CWE-233mostlyfinds — Security testing can detect missing-parameter issues but does not prevent them at design time.
- CWE-234mostlyfinds — Security testing in development and acceptance can detect missing-parameter conditions through negative and boundary testing.
- CWE-235mostlyfinds — Security testing can detect extra-parameter handling flaws but does not itself implement the fix.
- CWE-236mostlyfinds — Security testing can detect undefined-parameter handling flaws but does not prevent them at the source.
- CWE-237mostlyfinds — Security testing in development can detect weaknesses related to improper handling of complex structures.
- CWE-238mostlyfinds — A.8.29's programme (code review, static analysis, dynamic testing, penetration testing) reaches CWE-238 through both source inspection of parsing/structural-handling code and runtime probing with malformed inputs; the remainder is bounded by subtle cases where incomplete-structure handling is buried in complex state machines or deeply nested logic that escapes both SAST and fuzzing.
- CWE-239mostlyfinds — Security testing can detect incomplete-element handling but does not itself prevent the weakness in production code.
- CWE-24mostlyfinds — Security testing in development catches path-traversal flaws before release.
- CWE-240mostlyfinds — Security testing in development and acceptance can detect inconsistent structural handling before release.
- CWE-241mostlyfinds — Security testing can detect type-handling flaws but does not itself implement the preventive control.
- CWE-242mostlyfinds — Security testing can surface calls to unsafe functions but does not prevent their introduction.
- CWE-243mostlyfinds — A.8.29's SOURCE reach (code review, static analysis) covers this weakness well: the chroot-without-chdir pattern is a recognizable code construct that SAST tools check for and code review catches. The bounded remainder is cases where the chroot() and the (missing) chdir() are separated across modules or files, where dynamic loading obscures the call sequence, or where the organisation's SAST rule set does not include a chroot-misuse checker.
- CWE-244mostlyfinds — A.8.29's SOURCE reach (code review, static analysis tools) catches the canonical realloc()-on-sensitive-buffer pattern that CWE-244's extended description centers on, and SAST detectors flag it reliably; the remainder is the broader 'heap inspection' class — sensitive data left in freed memory through patterns SAST does not enumerate, third-party components where acceptance testing sees only runtime behaviour, and instances where the sensitive data flow is hard to trace statically.
- CWE-245mostlyfinds — A.8.29's code analysis and code review directly flag forbidden J2EE direct-connection patterns in source, but instances hidden in closed-source third-party components or indirect connection management can escape a single cycle.
- CWE-246mostlyfinds — A.8.29's SOURCE reach (code review, static analysis) catches the direct `new Socket()` pattern in J2EE contexts as a mechanical rule, and RUNTIME reach (penetration testing) can observe the resulting socket connections; the remainder is instances where the J2EE context is ambiguous to the tool or reviewer, or where the code falls outside the tested surface.
- CWE-248mostlyfinds — Security testing can detect uncaught exceptions before production deployment.
- CWE-25mostlyfinds — Security testing in development catches path-traversal flaws before production deployment.
- CWE-250mostlyfinds — A.8.29's SOURCE reach (code review, automated static analysis) catches most CWE-250 instances — setuid/setgid calls, excessive Android permission requests, and obvious privilege-not-dropped patterns are detectable by SAST and code review, and RUNTIME reach (penetration testing, dynamic analysis) observes process privilege levels at execution; the remainder is subtle architectural decisions about whether a privilege is genuinely 'unnecessary' for the component's purpose, which require design-level judgment beyond what security testing typically provides.
- CWE-252mostlyfinds — Security testing in development and acceptance can detect missing return-value checks.
- CWE-253mostlyfinds — Security testing in development catches missing or incorrect return-value checks.
- CWE-256mostlyfinds — A.8.29's SOURCE reach (code review, SAST/code analysis tools, architecture review) directly addresses plaintext password storage in source files, configuration files, and registry keys — the dominant cases in CWE-256's examples — and the clause explicitly names testing of authentication functions (8.5); the bounded remainder is passwords stored only in memory or in configuration artefacts outside the reviewed scope, which is nameable but not zero.
- CWE-257mostlyfinds — A.8.29's SOURCE reach (code review, static analysis) directly inspects the password-handling code where the reversible-encryption/compression/cleartext choice is made, and its RUNTIME reach (penetration testing) sees the format if the store is dumped; the remainder is third-party components outside the developer's source and custom reversible schemes that evade static rules.
- CWE-258mostlyfinds — A.8.29's combined programme of static analysis, code review, vulnerability scanning, and penetration testing reaches configuration files and can detect an empty password string, but discovery is not near-mechanical because the weakness requires a semantic check that a password field is non-empty, which some automated tools may miss.
- CWE-259mostlyfinds — A.8.29's SOURCE+RUNTIME reach finds hard-coded passwords well: SAST detects password string literals, code review catches them, and penetration testing extracts them from binaries; the same bounded remainder as the CWE-798 anchor applies -- credentials assembled at build time, baked into images as configuration, or shipped inside binary-only third-party components.
- CWE-26mostlyfinds — Security testing in development catches path traversal via static/dynamic analysis and penetration testing.
- CWE-260mostlyfinds — A.8.29's programme (code review, SAST, vulnerability scanning, penetration testing) reaches CWE-260 through SOURCE: static analysis tools reliably flag cleartext passwords in text-based configuration files (properties, YAML, JSON, XML, INI), and code review catches them in first-party code. The remainder mirrors the CWE-798 anchor: passwords assembled or injected into config at build/deploy time, baked into container images as configuration, stored in binary-only config formats SAST cannot parse, or shipped inside third-party components outside the developer's source tree.
- CWE-261mostlyfinds — A.8.29's SOURCE reach (SAST, code review) catches the typical literal Base64-on-password pattern near-mechanically, and RUNTIME reach (penetration testing) finds instances where the encoded password is exposed; the bounded remainder is passwords encoded through abstracted frameworks, custom encoding functions, or build-time assembly where the literal pattern is not in source.
- CWE-266mostlyfinds — A.8.29's combined programme of code review, static analysis, vulnerability scanning, and penetration testing reaches incorrect privilege assignments in both first-party source and deployed systems, but privilege-assignment errors that manifest only under specific runtime conditions or in complex role hierarchies may escape a single test cycle, leaving a bounded remainder.
- CWE-267mostlyfinds — A.8.29's programme (code review, penetration testing, vulnerability scanning) reaches CWE-267 through both source review of role/privilege definitions and runtime probing of unsafe actions; the remainder is subtle intent-vs-implementation gaps that require deeper architectural analysis beyond what standard testing catches.
- CWE-27mostlyfinds — Security testing in development catches path-traversal flaws before release but does not itself implement the control.
- CWE-272mostlyfinds — A.8.29's SOURCE reach (code review, SAST) catches the literal pattern of acquiring privilege without dropping it, and penetration testing can sometimes observe the running process retaining elevated privilege; the remainder is cases where the missing drop is conditional, in untested paths, or where the elevated state is not externally observable.
- CWE-273mostlyfinds — Security testing can detect failed privilege drops, yet the control does not require such checks as part of its core intent.
- CWE-274mostlyfinds — A.8.29's combined programme of code review, static analysis, and penetration/dynamic testing reaches most CWE-274 instances: missing or incorrect privilege-error handling is visible in source (un-checked return values from privilege calls, missing error branches) and often surfaces at runtime as crashes or altered execution when the system is exercised without sufficient privileges; the remainder is subtle handling paths that only manifest under specific privilege states and may evade both static rules and black-box testing.
- CWE-276mostlyfinds — A.8.29's combined programme (code review, static analysis, vulnerability scanning, penetration testing) reaches CWE-276 from both SOURCE (installer scripts setting chmod/icacls are visible in code) and RUNTIME (pen tests and config scans routinely flag world-writable files); the remainder is bounded and nameable — binary-only third-party installers where source reach does not apply, and permission issues inherited from external configuration rather than the installer itself.
- CWE-277mostlyfinds — Security testing may detect permission issues but does not prevent insecure inheritance by design.
- CWE-279mostlyfinds — A.8.29's SOURCE + RUNTIME programme reaches CWE-279: static analysis and code review detect suspicious permission-setting calls (chmod, file open modes, umask manipulations), and penetration testing verifies resulting file/object permissions at runtime. The remainder is bounded — cases where permission assignment is dynamic, conditional, or context-dependent in ways that resist pattern-based detection.
- CWE-28mostlyfinds — Security testing in development catches path-traversal flaws before release.
- CWE-280mostlyfinds — Security testing can detect missing or incorrect privilege handling.
- CWE-284mostlyfinds — Security testing explicitly validates authentication, access restriction, and cryptography functions, directly catching missing or incorrect access control checks before code reaches production.
- CWE-288mostlyfinds — Security testing can detect alternate-path bypasses but does not prevent them in production.
- CWE-289mostlyfinds — A.8.29's combined programme of code review, SAST and penetration testing reaches CWE-289 through both SOURCE (canonicalization handling, case-insensitive comparisons visible in authentication code) and RUNTIME (penetration testing routinely tries URL encoding, backslash variants, case variations — exactly the observed examples); the remainder is third-party authentication components outside the org's source and highly specific bypasses requiring deep knowledge of the application's scheme.
- CWE-29mostlyfinds — Security testing can discover path-traversal flaws but does not itself prevent them in production code.
- CWE-290mostlyfinds — Security testing can detect spoofing vulnerabilities but does not prevent them by itself.
- CWE-291mostlyfinds — A.8.29's combined programme reaches CWE-291 through both source and runtime: code review and SAST flag the IP-as-auth pattern (e.g., `if (cli.sin_addr == trusted)`), and penetration testing identifies it by probing the authentication mechanism. The remainder is bounded — cases where IP checking is one factor among several and the code does not make clear it is the sole or primary factor, or where the check is buried in a complex auth flow.
- CWE-293mostlyfinds — A.8.29's combined programme of code review, static analysis and penetration testing reaches CWE-293 through both SOURCE (the referer-check pattern is plainly visible in code) and RUNTIME (a tester spoofing the Referer header demonstrates the bypass), but CWE-293 is classified as an Architecture and Design weakness, so discovery depends on the review specifically examining authentication mechanisms and the pen test specifically manipulating the Referer header — a nameable remainder where the testing programme lacks those specific checks.
- CWE-294mostlyfinds — A.8.29's combined programme of code review, vulnerability scanning, and penetration testing reaches CWE-294 from both SOURCE (code review can spot authentication designs lacking nonces/timestamps/replay protection) and RUNTIME (pentesting routinely attempts capture-replay of credentials and session tokens, and the weakness is observable from outside); the bounded remainder is subtle protocol-design issues that neither static review nor standard pentest reliably surfaces.
- CWE-295mostlyfinds — A.8.29's programme (code review, static analysis, penetration testing) reaches most CWE-295 instances as first-party code defects — missing SSL_get_verify_result calls, disabled validation flags, unchecked hostname matching — all visible in source or observable at runtime by presenting an invalid certificate; the bounded remainder is instances where certificate pinning makes post-implementation testing difficult (noted in the CWE's Modes of Introduction) and validation logic buried inside third-party libraries that the developer's source-level review does not read, though pen-testing catches the symptom in many of those.
- CWE-296mostlyfinds — Security testing can detect missing or incorrect certificate chain validation.
- CWE-297mostlyfinds — Security testing can detect missing certificate validation and host-mismatch checks.
- CWE-298mostlyfinds — Security testing can detect missing certificate expiration checks but does not constitute the control's full intent.
- CWE-299mostlyfinds — Security testing can detect missing or incorrect certificate revocation checks.
- CWE-30mostlyfinds — Security testing in development and acceptance will detect path-traversal flaws before release.
- CWE-301mostlyfinds — Security testing can detect reflection vulnerabilities, providing partial coverage through verification rather than prevention.
- CWE-302mostlyfinds — Security testing can discover and block authentication bypasses that rely on mutable data.
- CWE-303mostlyfinds — Security testing can detect flawed authentication implementations but does not prevent them by itself.
- CWE-304mostlyfinds — A.8.29's combined programme (code review against requirements, static analysis, and penetration testing) reaches most CWE-304 instances: the missing step is visible in source against the protocol specification and exploitable at runtime, both of which the clause names; the remainder is subtle omissions that neither review against the spec nor dynamic probing surfaces, bounded by the rigour of the test plan.
- CWE-305mostlyfinds — Security testing can detect authentication bypass conditions before deployment.
- CWE-306mostlyfinds — A.8.29 explicitly tests authentication functions and combines code review, dynamic testing, and penetration testing that surface most missing-authentication flaws, while a bounded remainder remains in secondary channels, undisclosed binary components, and operational/post-deployment exposures that one test cycle may not enumerate.
- CWE-307mostlyfinds — A.8.29's combined programme of code review, static analysis, and penetration testing reaches CWE-307 through both SOURCE (missing rate-limiting/lockout logic is visible in authentication code) and RUNTIME (pentesting directly exercises brute-force resistance); the remainder is bounded and nameable — subtle design flaws where rate limiting exists but is bypassable under specific conditions, which a single test cycle may not surface.
- CWE-308mostlyfinds — A.8.29's functional authentication testing, code review, and penetration testing will expose most single-factor authentication weaknesses, but some instances in contexts where the need for a second factor is not explicitly required or is obscured in third-party components remain unfound.
- CWE-309mostlyfinds — A.8.29's programme (code review, static analysis, penetration testing, and explicit testing of authentication functions per 8.5) reaches CWE-309 well: the password-only authentication decision is visible in source (auth modules checking only password) and at runtime (pen test observes no second factor). The remainder is bounded — third-party authentication components where acceptance testing only superficially exercises the auth surface, and legacy/undocumented auth paths outside the test scope.
- CWE-31mostlyfinds — Security testing can discover traversal flaws but does not prevent them at the source.
- CWE-312mostlyfinds — Code review and static analysis can identify cleartext-storage patterns while runtime and penetration tests can expose accessible plaintext stores, leaving a bounded remainder in opaque services, unexercised paths, and context-dependent sensitive-data flows.
- CWE-313mostlyfinds — A.8.29's combined programme of code review, static analysis, vulnerability scanning and penetration testing reaches cleartext storage in files and on disk through both SOURCE (static analysis flags credentials and sensitive data in config/properties files, code review catches hardcoded secrets and cleartext writes) and RUNTIME (penetration testing finds world-readable files, dynamic testing exposes accessible cleartext stores); the remainder is bounded and nameable — encoded-but-not-encrypted data (base64 etc.) that static tools may treat as opaque, cleartext written to non-standard or runtime-generated temporary files outside the scanned surface, and cleartext in binary-only third-party components where source reach does not apply.
- CWE-314mostlyfinds — A.8.29's source reach (code review, static analysis) catches the typical pattern of registry writes with sensitive literals, and its runtime reach (penetration testing, dynamic analysis) catches instances where the data is actually stored unencrypted; the remainder is bounded and nameable — sensitive data assembled at runtime from multiple sources, stored through wrapper functions that obscure the registry call, or written via configuration rather than code.
- CWE-316mostlyfinds — Security testing can detect cleartext secrets in memory dumps or debug output.
- CWE-318mostlyfinds — Security testing may detect the issue but does not prevent it at the source.
- CWE-32mostlyfinds — Security testing in development catches path-traversal flaws before release, providing strong but post-coding coverage.
- CWE-321mostlyfinds — A.8.29's SOURCE + RUNTIME reach finds hard-coded cryptographic keys in first-party source via SAST, code review, and penetration testing — the same mechanism that graded A.8.29 finds CWE-798 = mostly; the bounded remainder is keys assembled at build time, baked into images as configuration, or shipped inside binary-only third-party components.
- CWE-322mostlyfinds — Security testing can detect missing entity authentication during key exchange.
- CWE-323mostlyfinds — Security testing can detect nonce reuse, yet the control addresses many other issues beyond this CWE.
- CWE-325mostlyfinds — Security testing can detect incomplete crypto implementations but does not itself enforce correct algorithm steps.
- CWE-328mostlyfinds — Security testing can detect weak-hash usage but does not prescribe algorithm choice.
- CWE-329mostlyfinds — Security testing in development can detect predictable IV usage before deployment.
- CWE-33mostlyfinds — A.8.29's combined programme of static analysis, dynamic testing, and penetration testing reaches path traversal flaws in first-party code through both source inspection and runtime observation, but the '....' variant is an obscure encoding that many automated tools miss, leaving a nameable remainder of instances undetected.
- CWE-330mostlyfinds — Security testing can detect weak randomness but does not prescribe the control itself.
- CWE-331mostlyfinds — Security testing can detect insufficient-entropy defects before release.
- CWE-332mostlyfinds — Security testing can detect insufficient entropy in PRNG implementations before deployment.
- CWE-333mostlyfinds — Security testing can detect insufficient entropy in TRNG implementations before deployment.
- CWE-334mostlyfinds — Security testing can detect insufficient randomness in tokens, session IDs, or keys.
- CWE-335mostlyfinds — Security testing can detect weak seeding but does not itself prevent the weakness.
- CWE-336mostlyfinds — Security testing can detect predictable PRNG output, but testing alone does not prevent the flaw.
- CWE-337mostlyfinds — Security testing can detect and prevent use of weak or predictable PRNG seeds.
- CWE-338mostlyfinds — Security testing can detect use of weak random number generators.
- CWE-339mostlyfinds — Security testing can detect weak PRNG seeding but does not prevent it by itself.
- CWE-34mostlyfinds — Security testing in development and acceptance catches path traversal via dynamic and static analysis.
- CWE-340mostlyfinds — Security testing in development can detect predictable identifiers through static/dynamic analysis and fuzzing, reducing residual risk.
- CWE-341mostlyfinds — Security testing can detect predictability issues but does not prevent them by itself.
- CWE-342mostlyfinds — Security testing can detect predictable random sequences before release.
- CWE-343mostlyfinds — Security testing can detect and reject predictable random-value generators.
- CWE-344mostlyfinds — A.8.29's SOURCE reach (SAST, code review) plus RUNTIME reach (penetration testing) catches the bulk of CWE-344 instances — hard-coded credentials, paths, URLs, and memory addresses are well-established SAST detections and the demonstrative examples are exactly that class; the remainder is nameable: invariant values whose 'should vary' property requires deployment-context understanding the tool cannot infer, and instances in third-party components outside the developer's source.
- CWE-345mostlyfinds — Security testing can detect missing or weak data authenticity verification.
- CWE-347mostlyfinds — A.8.29's source reach (code review, SAST) catches the common case — missing or obviously misconfigured signature verification calls — and runtime reach (penetration testing) catches cases where unsigned or malformed data is accepted; the remainder is verification logic that is present but subtly incorrect (e.g., a verify flag set wrong, a check that accepts a null signature), which requires careful review or targeted test cases to surface.
- CWE-348mostlyfinds — Security testing can detect and prevent acceptance of data from less-trusted sources during development.
- CWE-349mostlyfinds — Security testing can detect the weakness but does not itself implement preventive controls.
- CWE-35mostlyfinds — Security testing in development can detect path-traversal flaws before release.
- CWE-350mostlyfinds — A.8.29's source reach (code review, static analysis) reliably detects the pattern of using reverse-DNS results for security decisions — calls to gethostbyaddr() feeding an auth check are a recognizable signature — and penetration testing can attempt DNS spoofing to expose the trust, so the programme finds most instances; the remainder is cases where the lookup is buried in complex logic or where the security decision is implicit and not flagged by automated tools.
- CWE-351mostlyfinds — Security testing can detect type confusion vulnerabilities before deployment.
- CWE-352mostlyfinds — A.8.29's combined programme of code review, SAST, and penetration testing reaches CSRF through both source and runtime channels: missing tokens and unprotected state-changing endpoints are standard SAST and pen-test findings. The remainder is bounded and nameable — subtle flaws in token validation logic, referer-checking bypasses, and CSRF in less common frameworks or non-HTML endpoints that automated tools flag inconsistently.
- CWE-353mostlyfinds — A.8.29's SOURCE+RUNTIME reach finds CWE-353 through code review of protocol implementations (the absence of checksum/integrity logic is visible in source), penetration testing (transmitted data observed without integrity protection), and architecture review; the remainder is bounded — custom or layered protocols where integrity is assumed to be handled at another layer and the omission is not flagged.
- CWE-354mostlyfinds — Security testing can detect missing integrity validation but does not itself implement the control.
- CWE-356mostlyfinds — Security testing can verify presence of warnings for unsafe user actions.
- CWE-358mostlyfinds — Security testing in development and acceptance validates that required security checks function as specified.
- CWE-36mostlyfinds — Security testing in development can detect absolute path traversal via static analysis and fuzzing.
- CWE-362mostlyfinds — Security testing can detect race conditions, but does not prevent them at design or coding time.
- CWE-363mostlyfinds — Security testing can detect link-following races, but testing alone does not prevent the weakness.
- CWE-364mostlyfinds — Security testing can detect signal-handler race conditions before release.
- CWE-366mostlyfinds — Security testing can detect race conditions through concurrency and stress testing.
- CWE-368mostlyfinds — Security testing can detect race conditions during context switching across privilege boundaries.
- CWE-369mostlyfinds — Security testing in development can detect divide-by-zero conditions before release.
- CWE-37mostlyfinds — Security testing can discover path-traversal flaws but does not prevent them at runtime.
- CWE-372mostlyfinds — Security testing can detect state-machine flaws that manifest as incomplete internal state distinction.
- CWE-375mostlyfinds — A.8.29's code analysis and review can identify direct returns of mutable internal state, while dynamic and penetration testing can expose resulting unauthorized mutations, leaving a bounded remainder of indirect-aliasing and untested-path cases.
- CWE-377mostlyfinds — Security testing can detect insecure temporary files but does not prevent their creation.
- CWE-378mostlyfinds — Security testing can detect insecure temporary files but does not prevent their creation.
- CWE-379mostlyfinds — A.8.29's combined programme (code review, static analysis, vulnerability scanning, penetration testing) reaches CWE-379 through both SOURCE and RUNTIME: static analysis flags use of tmpfile()/File.createTempFile() with default permissions, code review spots insecure temp-file patterns, and penetration testing observes the resulting file permissions in /tmp or equivalent. The remainder is bounded and nameable: cases where the directory's own permissions are the defect rather than the file-creation call, and custom temp-file logic that standard tools do not pattern-match.
- CWE-38mostlyfinds — Security testing in development can discover path-traversal flaws before deployment.
- CWE-383mostlyfinds — A.8.29's SOURCE reach (code review and code analysis tools) directly catches the mechanical pattern of Thread instantiation inside servlet methods, which is exactly the demonstrative example; the bounded remainder is instances where the bad practice is obscured behind abstractions or where the tool stack does not flag J2EE-specific anti-patterns, and penetration/dynamic testing adds little because the flaw is a code-quality issue rather than an externally observable security defect.
- CWE-384mostlyfinds — Security testing can detect session-fixation issues, yet the weakness absence does not replace comprehensive testing.
- CWE-39mostlyfinds — Security testing can discover drive-letter traversal but does not prevent it at runtime.
- CWE-390mostlyfinds — Security testing can uncover missing error handling, but does not ensure the weakness is eliminated in production code.
- CWE-391mostlyfinds — Security testing can detect missing error handling before deployment.
- CWE-392mostlyfinds — Security testing can identify missing error reporting through negative test cases and exception handling checks.
- CWE-393mostlyfinds — Security testing in development can detect functions returning wrong status codes.
- CWE-394mostlyfinds — Security testing can detect missing checks for unexpected but valid return values.
- CWE-395mostlyfinds — Security testing can detect improper exception handling but does not prevent the coding practice itself.
- CWE-396mostlyfinds — Security testing in development can detect generic catch blocks, but does not guarantee their removal.
- CWE-397mostlyfinds — CWE-397 is a literal source-code pattern (a method signature declaring a generic exception type) that SAST tools and code review catch directly; A.8.29's programme names code analysis tools and code review as integral elements, and there is no build-time assembly or binary-only hiding that would create a nameable remainder, matching the top-rung reading the owner gave for A.8.29 -> CWE-89.
- CWE-40mostlyfinds — Security testing can discover and verify the absence of UNC-based path traversal vulnerabilities.
- CWE-401mostlyfinds — Security testing in development can detect unreleased memory, providing partial coverage of the weakness.
- CWE-403mostlyfinds — Security testing can uncover descriptor leaks but does not prevent them by itself.
- CWE-407mostlyfinds — Security testing can uncover performance issues stemming from algorithmic complexity.
- CWE-409mostlyfinds — Security testing can uncover decompression-bomb vulnerabilities before release.
- CWE-41mostlyfinds — Security testing can detect path-equivalence flaws before release, partially fulfilling the control.
- CWE-413mostlyfinds — Security testing can detect locking defects but does not itself implement locking controls.
- CWE-414mostlyfinds — Security testing can detect race conditions caused by missing locks but does not prevent them by itself.
- CWE-415mostlyfinds — Security testing in development can detect double-free conditions before release.
- CWE-416mostlyfinds — Security testing in development can detect use-after-free bugs before release.
- CWE-419mostlyfinds — A.8.29's combined programme of code review, vulnerability scanning and penetration testing reaches CWE-419 through both source and runtime: an unprotected admin or back-channel is visible in source (no authentication/encryption on the channel) and exploitable from outside (pen testing reaches it). The bounded remainder is channels that are obscure, dormant, or only exposed under conditions the test plan does not exercise.
- CWE-42mostlyfinds — Security testing can detect path-equivalence flaws before release.
- CWE-421mostlyfinds — Security testing can detect alternate-channel race conditions before deployment.
- CWE-422mostlyfinds — Security testing can discover shatter vulnerabilities but does not itself implement the control's broader acceptance criteria.
- CWE-424mostlyfinds — Security testing can discover unprotected alternate paths before release.
- CWE-425mostlyfinds — Security testing can detect forced-browsing flaws, but the control itself does not prevent them in production.
- CWE-426mostlyfinds — Security testing can discover search-path issues but does not itself prevent them in production code.
- CWE-427mostlyfinds — Security testing can detect uncontrolled search-path issues but does not prevent them by itself.
- CWE-428mostlyfinds — Security testing in development can detect unquoted search-path issues before deployment.
- CWE-43mostlyfinds — Security testing can detect path-equivalence flaws before deployment.
- CWE-430mostlyfinds — Security testing can detect incorrect handler assignments before deployment.
- CWE-431mostlyfinds — Security testing in development and acceptance can detect missing handlers through negative and exception test cases.
- CWE-433mostlyfinds — Security testing can detect the weakness but does not itself implement the preventive control.
- CWE-434mostlyfinds — Configuration and acceptance testing verify that file-upload handling enforces allowed types and does not permit dangerous content to be stored or executed.
- CWE-435mostlyfinds — Security testing during integration and acceptance can reveal interaction-induced weaknesses.
- CWE-436mostlyfinds — Security testing can detect and correct cases where one component misinterprets another’s state or messages.
- CWE-437mostlyfinds — Security testing can validate that the intermediary correctly handles all documented and undocumented endpoint features.
- CWE-44mostlyfinds — Security testing can discover path-equivalence flaws but does not itself prevent them in production.
- CWE-440mostlyfinds — Security testing in development and acceptance validates that functions behave as specified.
- CWE-444mostlyfinds — Security testing can detect HTTP request smuggling vulnerabilities in intermediary components.
- CWE-446mostlyfinds — Security testing in development and acceptance can detect UI discrepancies before release, providing strong mitigation for this weakness.
- CWE-447mostlyfinds — Security testing in development and acceptance would detect unimplemented security features before release.
- CWE-449mostlyfinds — Security testing in development and acceptance validates that UI actions match user intent and requirements.
- CWE-45mostlyfinds — A.8.29's combined programme of static analysis, code review, vulnerability scanning, and penetration testing reaches path-equivalence flaws in both first-party and acquired code, but the weakness's observability from outside is moderate (dynamic testing may miss some internal-dot variants), leaving a bounded remainder.
- CWE-450mostlyfinds — Security testing can detect and require fixes for multiple-interpretation UI input flaws.
- CWE-451mostlyfinds — Security testing can detect UI misrepresentation vulnerabilities before deployment.
- CWE-453mostlyfinds — Security testing can detect insecure defaults but does not prevent them.
- CWE-454mostlyfinds — Security testing can detect the weakness but does not prevent it at design time.
- CWE-455mostlyfinds — Security testing in development can detect missing exit-on-failure behavior during initialization.
- CWE-456mostlyfinds — Security testing in development and acceptance can detect uninitialized-variable conditions through static and dynamic analysis.
- CWE-457mostlyfinds — Security testing can detect uninitialized-variable bugs, but the control is broader.
- CWE-459mostlyfinds — A.8.29's source reach (code review, static analysis) catches the bulk of CWE-459 instances — unclosed streams, missing finally blocks, and leftover temp files are well-detected code patterns — but a nameable remainder of subtle cases (cleanup dependent on specific error paths, alternate data streams, conditions only observable at runtime) escapes automated detection and requires deeper analysis or specific runtime triggering.
- CWE-46mostlyfinds — Security testing in development can detect path-equivalence flaws before deployment.
- CWE-460mostlyfinds — Security testing can detect missing cleanup paths, thereby mitigating the weakness before deployment.
- CWE-462mostlyfinds — Security testing can detect duplicate-key conditions before release.
- CWE-463mostlyfinds — Security testing can detect sentinel deletion bugs before release.
- CWE-464mostlyfinds — A.8.29's programme (code review, static analysis, dynamic testing, penetration testing) reaches CWE-464 as a source-level implementation bug: code review and static analysis catch the bulk of accidental sentinel additions, and dynamic/penetration testing catches cases where the truncation produces observable behaviour. The remainder is bounded and nameable — sentinels introduced through subtle context-dependent logic or data flows that neither review nor the test conditions surface — which keeps it below the top rung.
- CWE-466mostlyfinds — Security testing in development can detect out-of-range pointer returns through static analysis and fuzzing.
- CWE-467mostlyfinds — Security testing can detect sizeof(pointer) errors but does not prevent them at source.
- CWE-468mostlyfinds — Security testing can discover pointer-scaling defects, yet eliminating the weakness itself does not satisfy the control's wider testing mandate.
- CWE-469mostlyfinds — Security testing in development can detect pointer-subtraction flaws through static analysis and fuzzing.
- CWE-47mostlyfinds — A.8.29's programme (SAST, code review, penetration testing) reaches CWE-47 through multiple routes — static analysis can flag improper path normalization, code review catches missing input trimming, and penetration testing can probe path equivalence edge cases — but the leading-space variant is a narrow rule that not every SAST ruleset covers and that dynamic testing only surfaces with specific path-traversal test cases, leaving a nameable remainder.
- CWE-470mostlyfinds — Security testing can detect and block unsafe reflection patterns before release.
- CWE-471mostlyfinds — Security testing can detect unauthorized modification paths for assumed-immutable data.
- CWE-472mostlyfinds — Security testing in development and acceptance will detect parameter tampering vulnerabilities before deployment.
- CWE-473mostlyfinds — Security testing can detect variable-injection flaws but does not itself implement the preventive controls.
- CWE-474mostlyfinds — Security testing can surface cross-platform inconsistencies but does not prevent their introduction in code.
- CWE-475mostlyfinds — Security testing can detect undefined behavior from invalid API inputs before deployment.
- CWE-476mostlyfinds — Security testing can detect NULL dereference defects before release.
- CWE-478mostlyfinds — Security testing can detect missing default cases but does not guarantee their prevention.
- CWE-479mostlyfinds — Security testing can detect unsafe signal-handler patterns before release.
- CWE-48mostlyfinds — A.8.29's combined programme of code review, static analysis, and penetration testing reaches CWE-48 through both SOURCE and RUNTIME: static analysis flags improper path normalization, code review spots missing whitespace handling, and penetration testing with crafted filenames (spaces) surfaces the ambiguity. The remainder is third-party/binary components where the path logic is not visible to source-reading tests, plus subtle cases where whitespace handling is deeply embedded in complex normalization chains.
- CWE-480mostlyfinds — Security testing and code review can catch operator errors before release.
- CWE-482mostlyfinds — Security testing can detect the flaw but does not prevent it at source.
- CWE-484mostlyfinds — Security testing in development can detect unintended fall-through behavior, though it is not the primary control.
- CWE-486mostlyfinds — A.8.29's SOURCE reach (code review and static analysis) catches the CWE-486 pattern — class-name string comparisons like getClass().getName().equals(...) — in first-party code, and SAST rules for this Java idiom exist; the remainder is bounded and nameable (cases where the SAST rule is not enabled, the comparison is done indirectly through overridden equals(), or code review misses it), and the RUNTIME reach (penetration testing) reaches only a slice because the flaw is internal and not externally observable without a targeted class-confusion probe.
- CWE-488mostlyfinds — Security testing can detect the weakness but does not itself implement the preventive control.
- CWE-489mostlyfinds — Security testing in development and acceptance catches active debug code before deployment.
- CWE-49mostlyfinds — A.8.29's combined programme of code review, static analysis, and penetration testing reaches CWE-49 through both source and runtime channels — SAST tools check path normalization logic, code review catches the missing validation, and pen testing routinely probes trailing-slash behaviour (as the CVE examples show). The remainder is bounded and nameable: custom path-handling logic that doesn't match known patterns and edge cases buried in framework code that automated tools don't traverse.
- CWE-491mostlyfinds — Security testing can detect clone-related state corruption during acceptance testing.
- CWE-492mostlyfinds — A.8.29's source reach (code review and SAST/code analysis tools, both explicitly named in the clause) catches CWE-492 well: the pattern of a non-static inner class accessing private fields of its enclosing class is a well-defined, mechanically detectable Java anti-pattern that tools like SpotBugs/FindBugs flag by rule, and security-focused code review identifies it. The remainder is the runtime reach — penetration testing and dynamic testing do not see this bytecode-translation issue from outside — and SAST configurations that omit the specific rule.
- CWE-493mostlyfinds — A.8.29's SOURCE reach (SAST + code review) reaches CWE-493 well — the pattern is literal in source (a non-final public field declaration) and is flagged by mainstream static analyzers and caught in code review — but the RUNTIME reach (dynamic testing, penetration testing) adds little because field mutability is not observable from outside, and the representative organization's SAST configuration and reviewer rigour leave a bounded remainder of instances undetected.
- CWE-494mostlyfinds — A.8.29's SOURCE reach (code review, static analysis) catches the canonical patterns — curl with -k, URLClassLoader without checksum, firmware update without signature verification — directly in first-party source, and RUNTIME reach (penetration testing) can observe the download behaviour; the remainder is third-party components with this weakness in binary-only form and cases where integrity verification is delegated to external configuration, neither of which the clause's programme sees.
- CWE-495mostlyfinds — Security testing can detect the weakness but does not itself prevent it at design time.
- CWE-496mostlyfinds — A.8.29's combined programme of static analysis, code review, and penetration testing reaches the source and runtime behaviour where a public-to-private array assignment is visible, but dynamic testing may not observe the integrity impact unless the test exercises the setter and subsequent array modification, leaving a bounded remainder.
- CWE-497mostlyfinds — A.8.29's SOURCE+RUNTIME programme (SAST, code review, penetration testing, dynamic testing) reaches the bulk of CWE-497 instances — the patterns are literal in source (e.printStackTrace, getenv+output, system() exposing process info, connection strings in logs) and observable at runtime by triggering errors; the remainder is nameable (subtle disclosures via timing, response-size differences, or complex conditional logic that don't match obvious patterns).
- CWE-498mostlyfinds — A.8.29's SOURCE reach (code review, SAST) directly detects the cloneable-class-with-fields pattern in first-party code, and RUNTIME reach (penetration testing) can observe cloning behavior externally; the remainder is bounded — classes where field sensitivity is purely contextual and not inferable from declarations, plus any cloneable sensitive classes shipped in third-party components outside the developer's source.
- CWE-499mostlyfinds — Security testing can detect serializable sensitive classes and verify they are properly protected.
- CWE-5mostlyfinds — A.8.29's combined programme (code review, vulnerability scanning, penetration testing) reaches CWE-5 from both source and runtime: code review catches relative HTTP links and hardcoded plaintext URLs, penetration testing observes plaintext transmission in flight, and configuration scanning catches SSL misconfigurations; the remainder is deployment-time configuration not visible to the development-side testing programme.
- CWE-50mostlyfinds — Security testing in development can detect path-equivalence flaws before deployment.
- CWE-500mostlyfinds — A.8.29's SOURCE reach (code review and static analysis tools, both named in the clause) catches CWE-500 reliably because the weakness is a syntactic source-code pattern (a public static field lacking the `final` modifier); the bounded remainder is code not subjected to review or analysis in a given cycle.
- CWE-501mostlyfinds — A.8.29's SOURCE+RUNTIME programme reaches most CWE-501 instances: code review and static analysis detect the common pattern of untrusted input stored in trusted contexts (as in the demonstrative examples), and penetration testing surfaces instances that lead to exploitable bypass. The remainder is design-level trust-boundary blurring that does not manifest as a specific code pattern or externally observable flaw, which the testing programme cannot mechanically reach.
- CWE-502mostlyfinds — Security testing includes validation of deserialization routines and the use of untrusted data, reducing the likelihood that unsafe object reconstruction will be deployed.
- CWE-507mostlyfinds — Security testing in development and acceptance can uncover hidden malicious behavior.
- CWE-51mostlyfinds — A.8.29's SOURCE+RUNTIME reach covers CWE-51: static analysis and code review can detect missing path normalization in first-party code, and penetration/dynamic testing can observe the weakness from outside by sending crafted multi-slash paths. The remainder is bounded and nameable — cases where path normalization is context-dependent (intentional handling in some code paths, not others) and where automated tools cannot judge whether validation is 'appropriate' without semantic understanding.
- CWE-511mostlyfinds — Security testing in development and acceptance can uncover hidden logic/time bombs before release.
- CWE-515mostlyfinds — Security testing may discover covert storage channels but does not ensure they are absent.
- CWE-52mostlyfinds — A.8.29's SOURCE+RUNTIME reach covers CWE-52 from multiple angles: code review and SAST can flag improper path normalization, and penetration/dynamic testing can probe for trailing-slash handling by sending crafted requests and observing path resolution. The remainder is bounded and nameable: subtle normalization cases in complex framework code paths, and third-party components where only acceptance testing applies.
- CWE-520mostlyfinds — A.8.29's programme includes code review, static analysis, and penetration testing, all of which reach a .NET configuration weakness like impersonation: the `<identity impersonate="true"/>` setting is visible in web.config and source, and SAST/config-scanning tools flag it. The remainder is bounded — cases where impersonation is used selectively or where the misconfiguration only manifests under specific runtime conditions that a single test cycle may not exercise.
- CWE-521mostlyfinds — A.8.29's programme explicitly covers authentication functions (8.5) and includes code review, SAST, DAST and penetration testing — all of which reach CWE-521 from both source (missing/weak password validation logic) and runtime (trying 'password123' at registration). The remainder is bounded and nameable: policies that exist but are subtly weak (e.g., allow 'Password1' but block 'password'), or are enforced inconsistently across entry points, which a single test cycle may not fully characterise.
- CWE-524mostlyfinds — A.8.29's SOURCE reach (code review, static analysis) and RUNTIME reach (penetration testing, dynamic testing) both reach CWE-524: code review and data-flow static analysis can identify sensitive data being placed in caches or missing cache-control directives, and penetration/dynamic testing can observe cache exposure from outside. The remainder is bounded and nameable -- caching done by opaque third-party libraries, browser-side caching under complex conditions, and cases where the sensitivity of cached data is not apparent from the code alone -- which keeps it at `mostly` rather than `full`.
- CWE-525mostlyfinds — A.8.29's SOURCE+RUNTIME reach covers CWE-525 well: missing or incorrect Cache-Control headers are visible in first-party web application source (where response headers are set), observable at runtime via HTTP response inspection, and a standard penetration-testing check. The remainder is bounded — conditional or framework-defaulted caching policies that automated tools and casual review can miss.
- CWE-526mostlyfinds — A.8.29's SOURCE reach (code review, static analysis) catches most instances where sensitive data is assigned to environment variables in first-party code, and RUNTIME reach (penetration testing) catches cases where env var contents leak through debug output or logs; the bounded remainder is env vars set dynamically at deployment/runtime or in binary-only third-party components, which neither static analysis nor code review sees.
- CWE-527mostlyfinds — A.8.29's combined programme (code review, vulnerability scanning, penetration testing) reaches this weakness on both SOURCE and RUNTIME axes: pentesters routinely probe for exposed .git/.svn directories via HTTP, SAST/deployment scanners flag version-control artifacts in build outputs, and code review of deployment configurations catches them. The bounded remainder is repositories in non-standard paths, behind access controls the test cannot reach, or in offline archives — nameable but not zero.
- CWE-529mostlyfinds — A.8.29's combined programme of code review, vulnerability scanning and penetration testing reaches this weakness on both SOURCE and RUNTIME axes: penetration testing and vulnerability scanning surface ACL files placed in web- or network-accessible directories, and code review can find hardcoded paths to such files. The remainder is bounded and nameable -- ACL files whose exposure depends on access path or authentication state not exercised by the test, or whose location is not enumerated in any scanned artefact.
- CWE-53mostlyfinds — A.8.29's SOURCE+RUNTIME reach applies to this software implementation weakness: SAST tools flag path-normalization defects, code review reads the path-handling code, and penetration testing with crafted multi-backslash inputs surfaces the ambiguity at runtime. The remainder is bounded and nameable — specific normalization edge cases that automated rules miss and that test cases don't exercise in a single cycle.
- CWE-530mostlyfinds — A.8.29's runtime reach (penetration testing, dynamic scanning, vulnerability scanning) routinely discovers backup files left in web-accessible locations — automated tools and pentest methodologies enumerate common backup extensions (.bak, .~bk, .old, etc.) and check for source disclosure, making this a standard pentest finding category. The remainder is bounded: backup files with non-standard names, in non-web-accessible paths, or created post-deployment by operational processes that fall outside the acceptance test window.
- CWE-531mostlyfinds — Security testing in development and acceptance can detect sensitive data left in test code.
- CWE-535mostlyfinds — Security testing can detect exposed error messages but does not prevent them by itself.
- CWE-536mostlyfinds — A.8.29's combined programme of code review, static analysis, and penetration testing reaches CWE-536 through both source (missing exception handling in servlet code is a pattern SAST flags reliably) and runtime (pen testing triggers errors and observes stack traces), with the bounded remainder being error paths hard to exercise under test and servlet code shipped only in binary third-party components.
- CWE-537mostlyfinds — A.8.29's SOURCE+RUNTIME reach covers this first-party Java implementation flaw: SAST rules detect exception handlers exposing sensitive variables, code review catches the pattern, and penetration testing can trigger exceptions to observe leaked data; the remainder is subtle variants (e.g., sensitive data assembled into a generic error message at runtime) that evade mechanical detection, similar to the CWE-798 anchor.
- CWE-538mostlyfinds — A.8.29's source reach (code review, SAST) catches most instances — patterns like logging sensitive credentials or writing sensitive data to accessible paths are visible in source and detectable by static analysis — but a nameable remainder requires deployment context to confirm the file/directory is externally accessible, or involves data sensitivity that is not obvious from the code alone.
- CWE-539mostlyfinds — Security testing can detect and prevent use of persistent cookies with sensitive data.
- CWE-54mostlyfinds — A.8.29's programme (code review, static analysis, penetration testing) reaches CWE-54 through both source and runtime routes — the trailing-backslash path handling is visible in code review and detectable by SAST rules for path traversal, and penetration testing can exercise it with crafted inputs; the remainder is instances where the specific path-handling branch is uncovered by tests or where static tools lack a rule for this equivalence variant.
- CWE-540mostlyfinds — A.8.29's SOURCE+RUNTIME reach covers CWE-540 well: code review and SAST catch hardcoded credentials and embedded tokens in source, while penetration/dynamic testing catches sensitive comments rendered to output and exposed include files; the bounded remainder is obfuscated secrets, binary-only third-party components, and conditional disclosures that evade one testing cycle.
- CWE-541mostlyfinds — Security testing can detect credentials in include files before deployment.
- CWE-544mostlyfinds — Security testing can detect inconsistent error handling but does not itself define the standardized mechanism.
- CWE-546mostlyfinds — A.8.29's SOURCE reach (code review per item (a) and code-analysis tools named in the clause) is well-suited to detecting suspicious comments, which are purely textual artifacts in source; a well-implemented security testing programme flags TODO/FIXME/HACK markers routinely, leaving a bounded remainder of third-party components not under the developer's source-reading tests and comments in formats the tool stack does not pattern-match.
- CWE-547mostlyfinds — A.8.29's SOURCE reach (code review and static analysis, both named in the clause) fully applies to CWE-547, which is a literal-in-source weakness; a well-implemented programme finds most hard-coded security-relevant constants, with a bounded remainder of cases where the constant's security relevance is not recognized by reviewers or tools.
- CWE-548mostlyfinds — Security testing in development and acceptance can detect and require remediation of exposed directory listings.
- CWE-549mostlyfinds — A.8.29's SOURCE reach (code review) catches missing password masking by checking input field types (e.g., type='password' vs type='text', PasswordField vs TextField), and its RUNTIME reach (dynamic testing, penetration testing) catches it by simply entering a password and observing the display; the weakness is observable from outside and near-mechanical to detect, with a small remainder for inconsistent or conditional masking implementations.
- CWE-55mostlyfinds — A.8.29's combined programme of code review, static analysis, and penetration testing reaches most CWE-55 instances: the '/./' pattern is visible in source (path normalization logic) and observable from outside (URL manipulation probes), and SAST tools that check path handling flag it. The remainder is nameable — path normalization delegated to third-party libraries or frameworks whose internals the developer's testing does not read, and bespoke path-handling code in components outside the tested scope.
- CWE-550mostlyfinds — Security testing can detect and require remediation of verbose error messages.
- CWE-551mostlyfinds — Security testing can detect this weakness but does not prevent it by itself.
- CWE-552mostlyfinds — A.8.29's combined programme of code review, vulnerability scanning and penetration testing reaches CWE-552 through both SOURCE (code that places files under web root or packages archives without exclusions) and RUNTIME (probing for accessible files, scanning cloud storage configurations); the remainder is bounded and nameable — archive contents not visible in the packaging logic, and storage or container configurations outside the test environment's scope.
- CWE-553mostlyfinds — Security testing can discover such files but does not prevent their introduction during development.
- CWE-554mostlyfinds — A.8.29's SOURCE reach (code review and static analysis tools, both named in the clause) can identify the absence of an input validation framework in first-party ASP.NET code; the remainder is cases where custom validation mimics framework patterns enough to evade automated detection, which is bounded.
- CWE-555mostlyfinds — A.8.29's SOURCE reach (code review, SAST) catches plaintext passwords in configuration files reliably — this is a textbook SAST pattern — and RUNTIME reach (penetration testing) finds exposed config files; the small remainder is config assembled at build time, encrypted-looking blobs whose key sits alongside, or binary-only third-party components where the literal pattern is not in source.
- CWE-556mostlyfinds — A.8.29's programme explicitly covers secure configuration testing (item c), and CWE-556 manifests in web.config and code that static analysis, code review and penetration testing all reach; the remainder is cases where impersonation is used in a context that looks legitimate to automated checks and requires human judgment to classify as unnecessary.
- CWE-558mostlyfinds — A.8.29's SOURCE reach (static analysis, code review) catches the literal getlogin() call pattern well, and the function's non-reentrancy is a textbook rule in C-language SAST tools; the remainder is cases where the multithreaded context is not inferable from the call site alone (wrapper functions, indirect calls, or threading inferred only at runtime), which dynamic testing and penetration testing are unlikely to surface because the symptom (wrong username returned) is subtle from outside.
- CWE-560mostlyfinds — A.8.29's SOURCE reach (SAST, code review) catches the umask()/chmod() confusion in first-party code, since the pattern is recognizable in source; the small remainder is calls where the argument is computed dynamically or where a particular SAST rule does not flag the construct.
- CWE-561mostlyfinds — Security testing can surface dead code but does not directly prevent or eliminate it.
- CWE-563mostlyfinds — A.8.29's source-level code analysis and code review reliably flag dead-store assignments in code with available source, but unused-variable defects inside binary-only third-party components remain outside its runtime and source reach.
- CWE-564mostlyfinds — Security testing can detect injection flaws but does not prevent them at design time.
- CWE-565mostlyfinds — Security testing can detect cookie-validation flaws but does not itself implement the required controls.
- CWE-566mostlyfinds — Security testing in development can detect missing authorization checks and unsafe SQL construction before release.
- CWE-567mostlyfinds — Security testing can detect race conditions but does not itself prevent the weakness.
- CWE-57mostlyfinds — Requires security testing that can detect path-traversal weaknesses before release.
- CWE-570mostlyfinds — Security testing in development and acceptance can surface dead-code paths caused by always-false expressions.
- CWE-571mostlyfinds — Security testing in development can surface constant-true conditions through automated checks.
- CWE-572mostlyfinds — A.8.29's programme includes code review and static analysis, which catch the literal run()-vs-start() pattern in first-party source; the bounded remainder is cases where the call is indirect (reflection, dynamic dispatch) or otherwise obscured from literal pattern matching.
- CWE-573mostlyfinds — Security testing can detect specification non-compliance but does not itself prevent the weakness.
- CWE-575mostlyfinds — A.8.29's SOURCE reach (code review, static analysis tools) detects this EJB-specific coding violation: AWT/Swing imports in @Stateless/@Stateful/@MessageDriven classes are visible in source and flaggable by configured linters and informed reviewers. The remainder is bounded — organizations without EJB-specific static-analysis rules or reviewers versed in the EJB spec's AWT/Swing prohibition will miss it.
- CWE-576mostlyfinds — A.8.29's SOURCE reach (code review and static analysis tools, both explicitly named) directly targets this weakness: CWE-576 is a code-level pattern — java.io usage inside an EJB bean — that static analysis with EJB-specific rules and manual code review catch reliably, and the weakness lives in first-party developer code where SOURCE reach applies fully; the small remainder is indirect or wrapped uses of java.io that evade pattern matching.
- CWE-577mostlyfinds — A.8.29's source reach (code review, SAST) catches the literal socket-usage pattern in EJB classes (ServerSocket, accept(), MulticastSocket) that the CWE examples show; a well-implemented programme with EJB-aware static analysis and code review finds the bulk of instances, with a bounded remainder of dynamically/reflectively constructed sockets and indirect usage through helper classes.
- CWE-579mostlyfinds — A.8.29's SOURCE reach (code review, SAST) catches the pattern mechanically — a class stored in an HttpSession that does not implement Serializable is a static-analysis rule in any Java/J2EE ruleset, and code review spots it directly; the remainder is the cases where serializability is conditional, inherited, or stored indirectly through reflection, which automated tools miss.
- CWE-580mostlyfinds — A.8.29's source-reading routes (code review and static analysis tools) reliably detect the missing super.clone() pattern, which is mechanically recognizable in Java source; the runtime routes (pen testing, dynamic testing) cannot observe this type-mismatch defect, so the share found is bounded by what fraction of the codebase is subjected to source-level inspection and by tool false negatives.
- CWE-582mostlyfinds — A.8.29's source-level static analysis and code review catch the public static final array pattern near-mechanically, but Java components accepted without source are outside that source reach, leaving a bounded remainder.
- CWE-585mostlyfinds — CWE-585 is a literal source-code pattern (an empty `synchronized` block) squarely within A.8.29's SOURCE reach; SAST tools have specific detectors for it and code review catches it, so well-implemented security testing in development and acceptance fully discovers this weakness class with no nameable remainder.
- CWE-587mostlyfinds — Security testing can detect fixed-address pointer assignments but does not prevent them.
- CWE-588mostlyfinds — Security testing can detect memory corruption caused by invalid pointer casts.
- CWE-59mostlyfinds — Security testing can detect link-following flaws before release.
- CWE-590mostlyfinds — Security testing in development can detect invalid-free defects before release.
- CWE-591mostlyfinds — Security testing can discover unlocked sensitive buffers, but does not itself implement the locking mechanism.
- CWE-593mostlyfinds — A.8.29's SOURCE reach (code review, static analysis) reaches this first-party C/OpenSSL implementation defect, and the pattern of modifying SSL_CTX after SSL object creation is observable in source; penetration testing can catch the auth-bypass symptom. The remainder is cases where the order-of-operations pattern is subtle enough that automated rules miss it and only expert manual review would catch it.
- CWE-594mostlyfinds — A.8.29's SOURCE reach (SAST, code review) catches most instances: static analysis can flag session/application-scoped beans that do not implement Serializable, and code review of J2EE session management is a standard check; penetration testing under load surfaces the crash symptom. The bounded remainder is objects registered dynamically into session scope, complex inheritance hierarchies where the Serializable requirement is non-obvious, and framework-specific edge cases that static rules miss.
- CWE-595mostlyfinds — A.8.29's SOURCE reach (code review, static analysis tools) catches the literal ==-on-objects pattern with high reliability — it is a classic SAST rule — and code review catches it as well; the small remainder is cases where the comparison is buried in reflection, dynamic dispatch, or non-standard types that defeat mechanical detection, and where the logic bug does not surface as an externally observable behavior for the RUNTIME half to catch.
- CWE-597mostlyfinds — Security testing can detect the flaw but does not prevent its introduction.
- CWE-598mostlyfinds — Security testing can detect sensitive data leakage via query strings.
- CWE-599mostlyfinds — Security testing could detect missing certificate validation but does not prevent the weakness at development time.
- CWE-6mostlyfinds — Security testing can detect and reject applications with insufficient session-ID length.
- CWE-600mostlyfinds — Security testing in development can detect uncaught exceptions and verify proper error handling before release.
- CWE-601mostlyfinds — A.8.29's programme (SAST, code review, vulnerability scanning, penetration testing) reaches open redirects through both SOURCE and RUNTIME: SAST flags redirect calls fed by user input, code review catches unvalidated URL parameters, and pen testing observes the redirect by following crafted URLs. The remainder is bounded and nameable -- conditional or chained redirects, redirects in third-party components not covered by the test plan, and cases where the malicious URL is constructed through non-obvious paths that a single test cycle misses.
- CWE-602mostlyfinds — Security testing can detect client-side enforcement but is not the primary mitigation.
- CWE-603mostlyfinds — Security testing can detect missing server-side authentication checks.
- CWE-605mostlyfinds — A.8.29's programme (code review, static analysis, penetration testing) reaches CWE-605 as a source-level pattern: SO_REUSEADDR combined with bind() is detectable by static analysis and code review in first-party code, and penetration testing can sometimes observe the resulting port-stealing behaviour at runtime. The remainder is third-party components where source is unavailable and the runtime symptom is not exercised by the test plan.
- CWE-606mostlyfinds — Security testing in development can detect and block unchecked loop conditions before release.
- CWE-608mostlyfinds — A.8.29's SOURCE reach (code review, SAST/code analysis tools) catches this near-mechanical pattern — non-private fields in ActionForm classes are a basic static-analysis check — and acceptance testing covers acquired Struts components; the bounded remainder is third-party binary-only components whose source the developer's programme cannot read.
- CWE-609mostlyfinds — A.8.29's SOURCE reach (code review and static analysis) detects the double-checked locking pattern in first-party code, and modern SAST tools have specific rules for this well-known idiom, so most instances are found; the remainder is bounded by SAST coverage gaps and the fact that the RUNTIME reach (penetration testing, dynamic testing) does not exercise this subtle concurrency defect, leaving a nameable slice uncaught.
- CWE-61mostlyfinds — Security testing can detect symlink-following vulnerabilities before deployment, covering most of the weakness.
- CWE-610mostlyfinds — Security testing can detect instances of the weakness but does not prevent it at design or coding time.
- CWE-611mostlyfinds — Security testing in development catches XXE via static analysis and dynamic XML fuzzing.
- CWE-613mostlyfinds — A.8.29's combined programme of code review, static analysis, and penetration testing reaches CWE-613 through both SOURCE (session-timeout configurations and token-expiration logic are visible in code, as the demonstrative example shows) and RUNTIME (a session that fails to expire is observable by waiting and re-using the credential). The remainder is bounded and nameable: session expiration logic that lives in framework defaults not surfaced in the reviewed code, or in distributed token-issuance/validation components where the expiration check is implicit rather than explicit.
- CWE-614mostlyfinds — A.8.29's combined programme of static analysis, dynamic testing, and penetration testing directly observes the missing Secure attribute in cookies during development and acceptance testing, but the weakness is a configuration detail that can be missed in test environments that do not perfectly mirror production HTTPS settings.
- CWE-615mostlyfinds — Security testing may incidentally discover sensitive comments, but that is not the control’s primary intent.
- CWE-616mostlyfinds — Security testing in development can detect the legacy upload pattern before deployment.
- CWE-617mostlyfinds — Security testing in development can detect reachable assertions before release, reducing the likelihood of exploitation.
- CWE-618mostlyfinds — Security testing can detect unsafe methods but does not itself prevent their introduction.
- CWE-619mostlyfinds — A.8.29's SOURCE reach (static analysis, code review) catches dangling-cursor patterns — unclosed cursors, missing finally/cleanup blocks, exception paths that skip close — and its RUNTIME reach (penetration testing) can sometimes observe the externally visible symptoms; the remainder is complex cursor lifecycles passed across functions or assembled dynamically where static analysis misses the pattern and pen testing sees no observable effect.
- CWE-62mostlyfinds — Security testing can discover hard-link issues but does not itself prevent them in production.
- CWE-620mostlyfinds — A.8.29's SOURCE+RUNTIME reach covers CWE-620: code review sees whether the password-change handler verifies the old credential, and penetration testing directly exercises the flow by attempting to change another user's password without it. The remainder is bounded and nameable — implementations where the check lives in a third-party auth framework or is split across layers that obscure the missing verification, and test plans that do not specifically target the password-change flow.
- CWE-621mostlyfinds — Security testing can detect variable extraction flaws before deployment.
- CWE-622mostlyfinds — Security testing in development and acceptance would detect missing validation of hook arguments through fuzzing or negative testing.
- CWE-623mostlyfinds — Security testing can detect unsafe ActiveX controls, but testing alone does not eliminate the root cause.
- CWE-624mostlyfinds — Security testing can detect executable regex flaws before production deployment.
- CWE-625mostlyfinds — Security testing can detect permissive regex through fuzzing or negative test cases.
- CWE-626mostlyfinds — Security testing can detect null-byte injection flaws before release.
- CWE-627mostlyfinds — Security testing can detect dynamic evaluation flaws but does not prevent them by itself.
- CWE-628mostlyfinds — Security testing in development can detect argument-related defects before release.
- CWE-639mostlyfinds — Security testing can detect missing authorization checks but does not prevent the weakness in production.
- CWE-64mostlyfinds — Security testing can uncover shortcut-following flaws but does not itself eliminate the weakness in production code.
- CWE-640mostlyfinds — A.8.29's combined programme (code review, static analysis, vulnerability scanning, penetration testing) reaches CWE-640 from both SOURCE and RUNTIME angles: pentesters routinely exercise password recovery flows for brute-force, token reuse, and information disclosure (the exact failure modes in the 2024-2025 CVE examples), and code review catches implementation flaws like missing throttling or returning the original password; the remainder is design-level weaknesses (e.g., security questions that are too common or guessable from social media) where the code looks reasonable and the weakness only surfaces under a review of the recovery design itself.
- CWE-641mostlyfinds — Security testing can detect improper filename handling but does not itself prevent the weakness.
- CWE-643mostlyfinds — Security testing in development catches XPath injection vulnerabilities before release.
- CWE-644mostlyfinds — Security testing catches header-injection issues before release, covering most of the weakness.
- CWE-645mostlyfinds — A.8.29's combined programme of code review, dynamic testing and penetration testing reaches this weakness from both SOURCE (lockout thresholds visible in code) and RUNTIME (a tester triggering lockout by attempting failed logins observes the behaviour directly), and the weakness is not hardware-only; the remainder is borderline threshold choices that a tester may not flag as 'too restrictive' without a defined policy on what counts as restrictive.
- CWE-646mostlyfinds — Security testing can detect the weakness, but the control does not guarantee its elimination.
- CWE-647mostlyfinds — Security testing can discover non-canonical URL bypasses but does not itself implement the preventive control.
- CWE-648mostlyfinds — Security testing can detect incorrect privileged API calls but does not prevent them at design time.
- CWE-649mostlyfinds — Security testing can detect missing integrity checks on encrypted or obfuscated security inputs.
- CWE-65mostlyfinds — Security testing can detect and block scenarios where applications follow malicious hard links.
- CWE-650mostlyfinds — Security testing can detect and prevent vulnerabilities where GET requests cause unintended state changes.
- CWE-652mostlyfinds — Security testing in development catches XQuery injection vulnerabilities before deployment.
- CWE-654mostlyfinds — A.8.29's testing programme reaches CWE-654 through both source (code review of authentication implementations, which 8.5 is explicitly named in the testing scope) and runtime (penetration testing reveals what factors the auth flow actually requires), and the weakness is observable from outside; the remainder is design-level decisions where the code correctly implements a single-factor requirement that the test plan accepts as meeting its criteria, which a testing programme does not second-guess.
- CWE-657mostlyfinds — Security testing can detect violations of secure design principles before release.
- CWE-66mostlyfinds — Security testing in development can detect path-traversal or virtual-resource handling flaws before deployment.
- CWE-662mostlyfinds — Security testing can detect synchronization flaws but does not itself implement the required controls.
- CWE-663mostlyfinds — Security testing can detect race conditions and re-entrancy issues but does not itself prevent the weakness.
- CWE-664mostlyfinds — A.8.29's combined programme of code review, static analysis, dynamic testing and penetration testing reaches most resource-lifecycle defects across creation, use and release phases (initialization errors, resource leaks, uncontrolled consumption, improper shutdown), but CWE-664 is a pillar category broad enough that specialized lifecycle issues — certain race conditions, complex state-management defects, and resource-control flaws only visible under specific deployment conditions — fall outside the standard testing programme's reach.
- CWE-665mostlyfinds — Security testing can detect uninitialized variables but does not itself enforce initialization practices.
- CWE-667mostlyfinds — Security testing can detect race conditions and locking errors before release.
- CWE-67mostlyfinds — Security testing in development can detect and prevent device-name pathname vulnerabilities.
- CWE-670mostlyfinds — Security testing in development and acceptance can detect paths that deviate from intended logic.
- CWE-672mostlyfinds — Security testing can detect use-after-release but does not prevent it at runtime.
- CWE-674mostlyfinds — Security testing in development can detect excessive recursion via static analysis or fuzzing.
- CWE-675mostlyfinds — Security testing can detect duplicate operations on resources before release.
- CWE-676mostlyfinds — Security testing can surface instances of dangerous functions but does not prevent their introduction.
- CWE-680mostlyfinds — Security testing can detect integer-overflow-to-buffer-overflow conditions during development.
- CWE-681mostlyfinds — Security testing can detect numeric conversion defects before release.
- CWE-682mostlyfinds — Security testing in development and acceptance can detect calculation flaws before deployment.
- CWE-683mostlyfinds — Security testing in development can detect argument-order defects, yet testing coverage is rarely exhaustive.
- CWE-684mostlyfinds — Security testing in development and acceptance validates that implemented functionality conforms to specifications before release.
- CWE-685mostlyfinds — A.8.29's SOURCE reach (code review, code analysis tools) catches CWE-685 near-mechanically by comparing call sites against function signatures, and the weakness is first-party code; the bounded remainder is calls resolved through dynamic dispatch, variadic interfaces, or external libraries whose signatures the analyzer lacks.
- CWE-686mostlyfinds — Security testing in development can detect type-related defects through unit, integration, and static-analysis testing.
- CWE-687mostlyfinds — Security testing in development can detect incorrect argument values before release.
- CWE-688mostlyfinds — Security testing can detect argument-related defects but does not prevent them at source.
- CWE-690mostlyfinds — Security testing in development can detect missing NULL checks before release.
- CWE-691mostlyfinds — Security testing in development and acceptance can detect control-flow weaknesses but does not itself implement preventive controls.
- CWE-692mostlyfinds — Security testing can discover incomplete denylists, yet the control does not mandate their replacement.
- CWE-694mostlyfinds — Security testing can detect duplicate identifiers before deployment.
- CWE-695mostlyfinds — Security testing can detect but does not prevent use of prohibited low-level code.
- CWE-696mostlyfinds — Security testing can detect ordering flaws but does not prevent them during development.
- CWE-697mostlyfinds — Security testing can detect incorrect comparison flaws before deployment.
- CWE-698mostlyfinds — Security testing can detect EAR flaws before deployment.
- CWE-7mostlyfinds — A.8.29's SOURCE+RUNTIME reach covers this weakness through multiple routes: static analysis and code review of web.xml/error-handling code catches the standard missing-error-page case, and dynamic/penetration testing triggers errors to observe whether the container's default page is exposed. The remainder is bounded and nameable — non-standard configuration locations, framework-specific error handling that bypasses web.xml, or partial error-page declarations that miss some exception types.
- CWE-703mostlyfinds — A.8.29's combined programme (SAST, code review, penetration testing) reaches most CWE-703 instances: static analysis has well-developed checkers for unchecked return values, missing null checks, and overly broad exception handlers (the demonstrative examples), and code review catches error-handling omissions in first-party source. The remainder is bounded and nameable — architectural error-handling decisions, rare exceptional conditions that do not surface under testing, and error-path logic that requires understanding business context rather than pattern matching.
- CWE-704mostlyfinds — Security testing can uncover type-conversion defects before release.
- CWE-705mostlyfinds — Security testing can detect control-flow scoping defects before release.
- CWE-706mostlyfinds — Security testing can detect incorrect name or reference resolution through fuzzing and negative test cases.
- CWE-707mostlyfinds — Security testing can detect neutralization flaws but does not itself implement the required controls.
- CWE-708mostlyfinds — A.8.29's security testing includes secure-configuration checks, vulnerability scanning, penetration testing and code review, which can surface incorrect resource ownership at install and runtime, though ownership flaws that depend on undocumented intended control spheres or unusual state-restoration flows can escape one cycle.
- CWE-710mostlyfinds — Testing can detect violations but does not prevent them.
- CWE-73mostlyfinds — Security testing can detect path-traversal issues but does not itself implement preventive controls.
- CWE-733mostlyfinds — Security testing in development can detect optimization-induced removal of security mechanisms.
- CWE-74mostlyfinds — Security testing in development catches injection vulnerabilities before release.
- CWE-749mostlyfinds — Security testing can detect exposed dangerous functions, but does not prevent their initial introduction.
- CWE-75mostlyfinds — Security testing catches injection vulnerabilities but does not itself implement the sanitization fix.
- CWE-754mostlyfinds — Security testing in development and acceptance verifies handling of error and exceptional conditions.
- CWE-755mostlyfinds — Security testing in development and acceptance verifies correct handling of exceptional conditions.
- CWE-756mostlyfinds — Security testing can detect missing custom error pages and verify they do not leak sensitive information.
- CWE-757mostlyfinds — Security testing can detect and block algorithm downgrade vulnerabilities before deployment.
- CWE-758mostlyfinds — Security testing can detect some instances of undefined behavior but does not prevent the root weakness.
- CWE-759mostlyfinds — Security testing can detect unsalted hashes but does not prevent their introduction.
- CWE-76mostlyfinds — Security testing can detect incomplete neutralization but does not prevent the weakness itself.
- CWE-760mostlyfinds — Security testing in development and acceptance can detect weak password hashing implementations.
- CWE-761mostlyfinds — Security testing can detect the flaw but does not prevent it at the source.
- CWE-762mostlyfinds — Security testing in development can detect mismatched alloc/free pairs before release.
- CWE-763mostlyfinds — Security testing can detect invalid pointer releases before release.
- CWE-764mostlyfinds — Security testing in development can exercise locking scenarios and detect multiple-lock conditions before release.
- CWE-765mostlyfinds — Security testing in development can detect resource-state anomalies caused by multiple unlocks.
- CWE-766mostlyfinds — A.8.29's SOURCE reach (SAST, code review) catches CWE-766 well: public-field declarations are literal in source and static analyzers flag them, and code review is named in the clause. The remainder is the 'critical' judgment — fields whose sensitivity is not apparent from name or type and only emerges from how the value is used elsewhere — which neither tool pattern-matching nor review reliably catches.
- CWE-767mostlyfinds — Security testing can detect improper exposure of private variables during acceptance.
- CWE-768mostlyfinds — Security testing can detect incorrect short-circuit behavior before release.
- CWE-77mostlyfinds — Security testing in development catches command-injection vulnerabilities before release.
- CWE-770mostlyfinds — A.8.29's combined programme of code review, static analysis, dynamic testing and penetration testing reaches CWE-770 through both SOURCE and RUNTIME: missing throttling, unbounded allocation loops and absent connection limits are patterns static analysis and code review surface, and DoS-style stress testing catches them at runtime. The remainder is bounded and nameable — limits that exist but are set too high for the deployment context, race conditions in resource accounting, and design-level decisions about whether a limit belongs at all — which keeps this below the `full` rung A.8.29 reaches on CWE-89.
- CWE-771mostlyfinds — Security testing can detect missing references to allocated resources before deployment.
- CWE-772mostlyfinds — A.8.29's combined programme (code review, static analysis, dynamic testing, penetration testing) reaches most CWE-772 instances: static analysis and code review catch the unclosed-handle/connection patterns in source, and dynamic/penetration testing can trigger resource exhaustion under load. The remainder is bounded and nameable — timing-dependent leaks that only manifest under specific operational conditions, and leaks inside third-party components the developer's testing does not fully reach.
- CWE-773mostlyfinds — A.8.29's programme (static analysis, code review, dynamic testing, penetration testing) reaches file descriptor/handle leaks through SOURCE and RUNTIME: SAST tools have well-established checkers for resource-leak patterns (open without close, handles not released on error paths), code review catches them, and runtime exhaustion is observable as DoS. The remainder is bounded and nameable — leaks triggered only by specific error paths, race conditions, or complex control flow that static analysis cannot fully resolve and that short test runs do not exercise.
- CWE-774mostlyfinds — Security testing can detect unbounded descriptor allocation before release.
- CWE-775mostlyfinds — Security testing can detect unreleased descriptors, providing partial coverage of the weakness.
- CWE-776mostlyfinds — Security testing can detect and block XML entity-expansion vulnerabilities before deployment.
- CWE-777mostlyfinds — Security testing can detect unanchored regex but does not prevent the weakness by itself.
- CWE-78mostlyfinds — Security testing and code review target insecure use of operating-system command interfaces, catching command-injection flaws introduced during development.
- CWE-780mostlyfinds — Security testing can detect use of RSA without OAEP during development.
- CWE-781mostlyfinds — A.8.29's SOURCE reach (SAST, code review) catches the classic METHOD_NEITHER-without-validation pattern that static analyzers flag specifically, and RUNTIME reach (penetration testing) reaches it where the driver is exercisable; the remainder is subtle cases where validation is present but incorrect in ways static analysis misses, and the local-privilege nature limits dynamic-discovery yield.
- CWE-783mostlyfinds — Security testing can detect logic errors caused by precedence issues.
- CWE-784mostlyfinds — Security testing can detect missing cookie validation but does not prevent the weakness by itself.
- CWE-785mostlyfinds — A.8.29's SOURCE reach (SAST, code review) catches the canonical pattern of calling realpath/readlink/PathAppend with a buffer smaller than PATH_MAX, which is a well-formed static-analysis check; the remainder is bounded and nameable — cases where the buffer size is computed dynamically, the call is wrapped, or the path-manipulation function is inlined or behind macros that defeat the checker.
- CWE-786mostlyfinds — Security testing in development can detect and eliminate pre-buffer memory accesses before release.
- CWE-787mostlyfinds — Security testing in development and acceptance can detect and prevent out-of-bounds write defects.
- CWE-788mostlyfinds — Security testing in development can detect buffer-overrun defects before release.
- CWE-789mostlyfinds — Security testing in development can detect and block excessive allocation flaws before deployment.
- CWE-79mostlyfinds — Secure-coding testing and automated code-analysis tools are applied to detect improper neutralization of script-related content during web-page generation.
- CWE-790mostlyfinds — Security testing can detect improper filtering but does not itself implement the filtering control.
- CWE-791mostlyfinds — Security testing in development and acceptance can detect incomplete filtering but does not itself implement the filtering.
- CWE-792mostlyfinds — Security testing in development and acceptance can detect incomplete filtering but does not itself implement the fix.
- CWE-794mostlyfinds — Security testing can detect incomplete filtering but does not itself implement the filtering mechanism.
- CWE-795mostlyfinds — A.8.29's SOURCE+RUNTIME reach (code review, SAST, penetration testing) discovers most instances of incomplete-location filtering in first-party code: the filter logic is visible to review and static analysis, and crafted inputs (e.g., nested '../' sequences) reveal the bypass under dynamic testing. The remainder is bounded and nameable — subtle cases where the filter's intended scope is complex and the bypass requires input shapes the test corpus does not exercise, which neither code review nor SAST nor pen-test reliably catches in one cycle.
- CWE-796mostlyfinds — A.8.29's programme (code review, SAST, penetration testing) reaches CWE-796 through both source and runtime: a reviewer sees the anchored regex and questions it, SAST flags anchored filters used for security, and pen-testing observes the bypass. The remainder is bounded and nameable — subtle cases where the marker is implicit, filters are multi-step, or the construct lives in third-party code outside the developer's source reach.
- CWE-797mostlyfinds — A.8.29's SOURCE+RUNTIME reach covers this first-party code defect: code review spots the recognizable anti-pattern of filtering only at a fixed position, SAST flags suspicious substring operations on untrusted input, and penetration testing discovers the bypass with crafted inputs like '....//'. The remainder is cases where the filtering logic is more complex (e.g., multiple conditional checks, dynamically computed positions) and harder for review and SAST to flag definitively, though runtime testing still reaches them.
- CWE-798mostlyfinds — created from the owner's anchor; an owner grade is a row and does not wait for an instrument (Mythos 2026-09-29T15:58Z).
- CWE-80mostlyfinds — Security testing in development catches unneutralized script tags before release.
- CWE-804mostlyfinds — Security testing can detect weak CAPTCHA implementations before deployment.
- CWE-805mostlyfinds — Security testing in development can detect out-of-bounds accesses, but does not guarantee prevention.
- CWE-807mostlyfinds — Security testing in development catches input-validation flaws before deployment.
- CWE-81mostlyfinds — Security testing in development and acceptance can detect unneutralized script in error pages but does not itself implement the fix.
- CWE-82mostlyfinds — Security testing in development can detect and drive remediation of improper script handling in IMG tags.
- CWE-820mostlyfinds — Security testing can detect missing synchronization through concurrency testing.
- CWE-821mostlyfinds — Security testing can detect synchronization flaws before production deployment.
- CWE-822mostlyfinds — Security testing can detect pointer-dereference flaws before release.
- CWE-823mostlyfinds — Security testing can detect out-of-range pointer offsets before release.
- CWE-824mostlyfinds — Security testing can detect uninitialized pointer usage before release.
- CWE-825mostlyfinds — Security testing can detect use-after-free issues, but removing this weakness alone does not fulfill the testing control.
- CWE-826mostlyfinds — Security testing can detect premature-release bugs, providing partial mitigation.
- CWE-827mostlyfinds — Security testing in development can detect XXE vectors arising from uncontrolled DTD references.
- CWE-828mostlyfinds — Security testing can detect unsafe signal handlers but does not prevent their introduction.
- CWE-829mostlyfinds — A.8.29's SOURCE reach (code review, SAST) catches the bulk of CWE-829 instances — file inclusion paths, remote script/widget includes, DTD loading are all visible in source and well-detected by static analysis, and the RUNTIME reach (penetration testing) catches exploitable inclusion vulnerabilities from outside; the bounded remainder is trust-boundary decisions about third-party libraries that look legitimate in code and are not exercised at runtime.
- CWE-83mostlyfinds — Security testing in development catches attribute-injection flaws before release but does not itself implement the fix.
- CWE-830mostlyfinds — Security testing can detect the weakness, but does not prevent its introduction during design or coding.
- CWE-831mostlyfinds — A.8.29's SOURCE reach (code review and SAST) catches the typical pattern of registering the same function for multiple signals via signal()/sigaction(), which is a recognizable source-level construct; the remainder is bounded and nameable — cases where registration is done through indirection, wrapper functions, or generated code that simple pattern matching misses.
- CWE-832mostlyfinds — Security testing may detect the flaw but does not prevent it by itself.
- CWE-833mostlyfinds — Security testing in development can detect deadlock conditions through stress and concurrency testing.
- CWE-834mostlyfinds — Security testing can detect excessive iteration through stress and fuzz testing.
- CWE-835mostlyfinds — Security testing can uncover infinite-loop conditions before release.
- CWE-836mostlyfinds — A.8.29's SOURCE+RUNTIME programme reaches this weakness: code review and static analysis see the hash-comparison pattern in the authentication routine, and penetration testing of the auth flow surfaces it from outside. The remainder is bounded — third-party authentication components where the pattern lives in binary-only code, and cases where the hash comparison is obscured by indirection that defeats pattern-matching tools.
- CWE-838mostlyfinds — Security testing can detect encoding mismatches, but testing alone does not prevent the weakness at source.
- CWE-839mostlyfinds — Security testing in development and acceptance can detect missing minimum checks through boundary-value and fuzz testing.
- CWE-84mostlyfinds — Security testing in development and acceptance will detect URI-scheme injection flaws before release.
- CWE-841mostlyfinds — Security testing can detect workflow bypasses but does not enforce them at runtime.
- CWE-843mostlyfinds — Security testing in development can detect type-confusion vulnerabilities through fuzzing and static analysis.
- CWE-85mostlyfinds — Security testing can detect doubled-character XSS, but testing alone does not prevent the weakness from being introduced.
- CWE-86mostlyfinds — Security testing can detect the weakness but does not itself implement the neutralization controls.
- CWE-87mostlyfinds — Security testing catches residual XSS but does not itself implement the neutralization controls.
- CWE-88mostlyfinds — Security testing can detect argument injection but does not prevent it at the source.
- CWE-9mostlyfinds — A.8.29's combined programme of code review, static analysis, and penetration testing reaches CWE-9 through both SOURCE (deployment descriptors are part of the codebase and pattern-matchable for ANYONE role grants) and RUNTIME (penetration testing would observe that restricted EJB methods are invocable without proper authorization); the remainder is bounded by incomplete coverage of EJB method surfaces and complex permission hierarchies that a single test cycle may not exhaustively exercise.
- CWE-90mostlyfinds — Security testing in development catches LDAP injection via dynamic analysis or fuzzing, but does not prevent it at the source.
- CWE-908mostlyfinds — Security testing in development and acceptance can detect uninitialized resource usage through dynamic analysis and fuzzing.
- CWE-909mostlyfinds — Security testing can detect missing initialization defects before deployment.
- CWE-91mostlyfinds — Security testing catches XML injection during development but does not itself implement the fix.
- CWE-910mostlyfinds — Security testing can detect use-after-close defects before release.
- CWE-911mostlyfinds — Security testing in development can detect reference-count defects before release, providing partial mitigation.
- CWE-912mostlyfinds — Security testing in development and acceptance can discover undocumented functionality before release.
- CWE-913mostlyfinds — Security testing can detect dynamic code weaknesses but does not prevent them at design or coding time.
- CWE-914mostlyfinds — Security testing can detect and prevent dynamic-variable weaknesses before release.
- CWE-915mostlyfinds — Security testing can detect mass-assignment flaws but does not itself prevent them at runtime.
- CWE-916mostlyfinds — A.8.29's source reach (code review, SAST) directly sees the hash function choice, salt handling, and iteration count in first-party authentication code, and penetration testing can extract hashes to confirm weakness; the bounded remainder is password hashing delegated to external auth services or implemented in binary-only third-party components where the configuration is opaque to source-reading tests.
- CWE-917mostlyfinds — Security testing in development and acceptance can detect EL injection but does not itself implement the fix.
- CWE-921mostlyfinds — A.8.29's combined programme (code review, static analysis, penetration testing) reaches CWE-921 through both source and runtime routes — a reviewer can see sensitive data being written to external/public storage, SAST can flag storage-API use with sensitive payloads, and a pentester can find the data sitting in an accessible location. The remainder is bounded and nameable: cases where the data's sensitivity is not apparent from code or storage context alone, so the storage-mechanism choice is not flagged.
- CWE-924mostlyfinds — A.8.29's combined programme reaches CWE-924 through both source and runtime: code review and SAST can spot missing or weak integrity checks (absent MAC verification, missing TLS certificate validation, unsigned message acceptance), and penetration testing can attempt MITM and message modification to surface the flaw at runtime. The remainder is bounded and nameable: subtle protocol-design weaknesses where an integrity check exists but is implemented incorrectly in ways that evade both static rules and external probing, plus third-party components outside the source reach.
- CWE-925mostlyfinds — Security testing can detect missing intent verification but does not prevent the weakness by itself.
- CWE-926mostlyfinds — Security testing can detect exported components lacking proper restrictions, providing partial coverage of the weakness.
- CWE-927mostlyfinds — Security testing can detect the weakness but does not itself prevent it at runtime.
- CWE-93mostlyfinds — Security testing can detect CRLF flaws but does not itself implement the neutralization.
- CWE-939mostlyfinds — Security testing can discover missing authorization checks, but does not itself implement the required controls.
- CWE-940mostlyfinds — A.8.29's combined programme of code review, automated analysis, and penetration testing reaches CWE-940 through both source and runtime channels: missing origin checks are visible in source review and exploitable channels are probeable in pen testing, as the CVE examples (DNS updates from non-queried hosts, Android intents, WebView URL schemes) all illustrate. The remainder is the logic-flaw character of the weakness — the absence of a check rather than the presence of a bug — which automated tools cannot pattern-match and which slips past review when the intended trust model is implicit or undocumented.
- CWE-941mostlyfinds — Security testing can detect incorrect destinations, yet it is a detection rather than prevention control.
- CWE-942mostlyfinds — Security testing can detect overly permissive cross-domain policies but does not prevent their initial introduction.
- CWE-943mostlyfinds — Security testing in development catches injection vulnerabilities before release but does not itself implement the fix.
- CWE-95mostlyfinds — Security testing in development can detect eval injection vulnerabilities before deployment.
- CWE-96mostlyfinds — Security testing in development and acceptance will detect static code injection but does not prevent it at the source.
- CWE-97mostlyfinds — Security testing can detect SSI flaws but does not itself implement the neutralization controls.
- CWE-98mostlyfinds — Security testing can detect RFI but does not prevent the weakness by itself.
- CWE-99mostlyfinds — Security testing can detect resource-injection flaws but does not itself implement preventive controls.
- CWE-1007partialfinds — Security testing can detect and require fixes for insufficient visual distinction of homoglyphs.
- CWE-103partialfinds — A.8.29's static analysis and code review can discover a missing super.validate() call in first-party Struts code, but the weakness is a specific framework implementation detail that dynamic testing and penetration testing rarely surface, so the combined programme finds a minority of latent instances.
- CWE-1041partialfinds — A.8.29's SOURCE reach (code analysis tools, code review) can detect structural code duplication via standard SAST duplication detectors, but CWE-1041 is a maintainability/quality property rather than a security flaw, so security-focused testing configurations often do not enable duplication checks; semantic duplicates (same logic, different syntax) evade mechanical detection, and runtime/dynamic testing cannot observe redundancy at all.
- CWE-1048partialfinds — A.8.29's source-code reach (static analysis tools, code review) can detect excessive fan-out as a measurable code-structure metric, but CWE-1048 is a maintainability/quality property rather than a security defect, so a representative organization's security-focused testing programme catches only a minority of instances; dynamic testing and penetration testing contribute nothing because the weakness has no runtime symptom.
- CWE-1052partialfinds — A.8.29's SOURCE reach (SAST, code review) can detect hard-coded literals in initialization, but CWE-1052 is a maintainability/quality weakness whose security impact is indirect, so security-focused testing under the clause is unlikely to prioritize it; the 'excessive' threshold is subjective and not all SAST tools flag it, leaving a nameable remainder of instances the programme misses.
- CWE-1054partialfinds — A.8.29's source reach (code review, static analysis) can detect layering violations when SAST tools are configured with architectural rules or when reviewers notice skipped layers, but CWE-1054 is fundamentally a maintainability/architectural-quality issue that only indirectly affects security, so a security-focused testing programme does not systematically target it and runtime/penetration testing cannot observe it from outside.
- CWE-1055partialfinds — A.8.29's source-level code analysis can flag this source-visible construct in first-party code, but it is not reachable by dynamic or penetration testing and acquired or legacy code without source escapes the control's developer-side source reach.
- CWE-1060partialfinds — A.8.29's code review and static analysis components (SOURCE reach) could flag some instances of excessive data queries as a side effect of thorough code review, since inefficient database access patterns are recognizable in source; however, the control's primary focus is security testing, not performance/quality, so most instances would not be caught by a security-focused programme.
- CWE-1062partialfinds — A.8.29's SOURCE reach (static analysis, code review) can detect the parent-to-child reference pattern as a code-structure finding, but CWE-1062 is primarily a reliability/maintainability concern rather than a security flaw, so security-focused dynamic testing and penetration testing do not target it; a minority of latent instances are surfaced by the programme's static and review routes.
- CWE-1064partialfinds — A.8.29's SOURCE reach (code review and static analysis tools) can detect excessive-parameter signatures as a code-structure pattern, but CWE-1064 is primarily a maintainability/quality issue whose security impact is indirect; a security-focused testing programme will not consistently configure linters or train reviewers to flag it, and the RUNTIME half of the reach (penetration testing, dynamic analysis) does not observe this weakness at all, leaving a nameable remainder.
- CWE-1067partialfinds — Security testing can detect slow sequential scans and missing indexes during acceptance.
- CWE-1072partialfinds — Code review and static analysis in A.8.29 may flag direct database access without connection pooling in first-party source, but this is primarily a performance/resilience issue that security test plans, dynamic testing, and penetration testing do not consistently target, so only a minority of latent instances are found.
- CWE-1073partialfinds — A.8.29's SOURCE reach (static analysis, code review) can detect patterns of excessive database calls in a function, and the clause names code analysis tools explicitly; however, CWE-1073 is primarily a performance/architectural concern rather than a security flaw, so a security-focused testing programme would not systematically target it — instances are found incidentally by SAST rules and reviewer attention, not by the programme's stated security test criteria.
- CWE-1075partialfinds — A.8.29's SOURCE reach (code review, static analysis) can detect goto statements outside switch blocks as suspicious control-flow patterns, but CWE-1075 is classified as a maintainability/quality issue that only indirectly affects security, so security-focused static analysis rules and code review checklists are not consistently configured to flag it; the RUNTIME half of the reach (dynamic testing, penetration testing) does not see this source-level pattern at all.
- CWE-1086partialfinds — A.8.29's SOURCE reach (code review, code analysis tools) could surface excessive child classes if reviewers or tools are configured to check structural quality metrics, but the control's programme is security-focused — vulnerability scanning, penetration testing, and dynamic testing do not observe this maintainability property, and security-oriented SAST rarely flags it; only a minority of instances are found.
- CWE-1089partialfinds — A.8.29's code review and static analysis can flag excessive indices in first-party code, but the weakness is a performance/design quality issue outside security-specific checks and observable runtime tests, so only a minority of latent instances are found.
- CWE-1095partialfinds — A.8.29's SOURCE reach (static analysis, code review) directly applies to this source-level loop pattern, which is mechanically detectable by linters and visible to reviewers; the bounded remainder is instances where the update is subtle enough to evade static rules or where security-focused testing deprioritises a maintainability-flavoured pattern.
- CWE-1100partialfinds — A.8.29's code review and architecture/design review activities can surface instances where system-dependent functionality is not properly isolated, but CWE-1100 is fundamentally an architectural/maintainability concern rather than a security defect, so it is not the primary target of the security testing programme; dynamic testing, penetration testing and vulnerability scanning do not reach it, leaving a minority of instances discoverable through deliberate code review.
- CWE-1103partialfinds — Security testing in development can include cross-platform compatibility and functionality equivalence tests.
- CWE-1108partialfinds — A.8.29's SOURCE reach (code review, static analysis) can identify excessive global variable usage as a code structure issue, but CWE-1108 is a maintainability/quality weakness that only indirectly affects security, so security-focused testing is unlikely to prioritize it; dynamic testing and penetration testing cannot observe it from outside, leaving a nameable remainder.
- CWE-1114partialfinds — A.8.29's source-level code review and static analysis can incidentally surface misleading or inconsistent whitespace in first-party code, but security testing does not target style issues and runtime/penetration tests or acquired binaries cannot see them, so only a minority of instances are found.
- CWE-1122partialfinds — A.8.29's SOURCE reach (SAST, code review) can detect Halstead complexity violations since SAST tools routinely compute complexity metrics and code review can identify excessive complexity, but the weakness is a code-quality metric that indirectly affects security rather than a direct security flaw, so a security-testing programme is not necessarily configured to flag it; the RUNTIME reach (penetration testing, dynamic testing) cannot observe this static property of code at all, leaving roughly half the programme's methods unable to reach it.
- CWE-1124partialfinds — Security testing can detect overly complex code but does not itself prevent the weakness.
- CWE-1125partialfinds — A.8.29's code review and penetration testing can identify some instances of excessive attack surface (unnecessary interfaces, exposed services enumerated during testing), but attack surface measurement is fundamentally an architectural assessment against a baseline, not a discrete finding that the standard SAST/DAST/pen-test cycle surfaces; the clause's named testing focus is security functions, secure coding and secure configurations, not attack-surface quantification.
- CWE-1126partialfinds — A.8.29's SOURCE reach (code review, static analysis tools) can detect unnecessarily wide variable scope, but CWE-1126 is primarily a maintainability/quality issue with only indirect security impact, so a security-focused testing cycle would catch only a minority of instances unless the toolchain is explicitly configured for code-quality checks.
- CWE-1164partialfinds — Security testing can detect dead code but does not directly prevent its introduction.
- CWE-1230partialfinds — A.8.29's combined programme (code review, vulnerability scanning, penetration testing) reaches some instances of metadata exposure — penetration testing can probe for exposed search indices or metadata fields, and code review can spot patterns where sensitive data flows into derived stores — but the weakness is fundamentally an architecture-and-design judgment about what can be inferred from metadata, which most instances do not surface to dynamic or static testing as a clear defect.
- CWE-1249partialfinds — A.8.29's testing programme reaches this weakness through both source and runtime: code review can spot hard-coded OS assumptions or missing dynamic queries, and penetration testing can discover the discrepancy by adding an OS-level user and observing whether the admin tool reflects it. The remainder is bounded — subtle cases where the inconsistency only manifests under specific timing or state conditions may evade a single test cycle.
- CWE-1293partialfinds — A.8.29's code review and architecture review components can identify some instances where a security-critical decision relies on a single data source without cross-validation, but the weakness is fundamentally architectural (a missing design property, not a present defect), so dynamic testing, penetration testing, and most SAST rules do not systematically surface it; only a minority of instances are found through careful review.
- CWE-131partialfinds — Security testing can detect buffer-size errors before release.
- CWE-1339partialfinds — A.8.29's SOURCE reach (code review, SAST) can surface some floating-point precision defects — suspicious comparisons, obvious rounding patterns, division-by-zero-adjacent constructs — and RUNTIME testing catches the downstream symptoms (crashes, infinite loops, overflows) seen in the observed CVE chains, but CWE-1339 is explicitly visible only with very specific numeric inputs, so most instances are silent under typical security test plans and the remainder is bounded by the gap between what SAST/review flag and what dynamic testing exercises.
- CWE-1426partialfinds — Code review and penetration testing under A.8.29 can surface missing or insufficient validation of generative AI outputs when model output reaches dangerous sinks, but because CWE-1426 is an emerging, research-gap weakness without established SAST/DAST coverage and model output is nondeterministic, a well-implemented test programme finds only a minority of latent instances.
- CWE-1434partialfinds — A.8.29's testing programme (code review, static analysis, dynamic testing, penetration testing) has SOURCE reach to configuration files containing inference parameters and RUNTIME reach to model outputs, so a well-implemented programme can find some instances — code review may flag obviously inappropriate parameter values, and dynamic/penetration testing can observe erroneous outputs (e.g., hallucinated package names). However, the 'correct' parameter setting is context-dependent and trade-off-laden, general security testing tools lack specific rules for AI/ML inference configurations, and tracing observed output problems back to the parameter setting requires domain expertise a representative security-testing programme does not systematically possess — leaving a majority of instances outside the programme's reach.
- CWE-160partialfinds — Security testing can detect the weakness but does not itself implement neutralization controls.
- CWE-175partialfinds — A.8.29's SOURCE+RUNTIME reach (code review, SAST, penetration testing) can find some CWE-175 instances, but mixed-encoding handling is a subtle logic flaw that SAST detects only sparsely and that requires specific test cases in dynamic/penetration testing, so one cycle surfaces a minority of latent instances.
- CWE-202partialfinds — Security testing can validate that inference attacks are mitigated in data-query functionality.
- CWE-206partialfinds — A.8.29's programme reaches CWE-206 through all three named routes: code review sees divergent response paths in source, vulnerability scanning flags some patterns, and penetration testing is exactly the activity that probes for behavioral discrepancies (timing, error-message, response-code differences). The weakness is observable from outside, so runtime testing reaches it well. The remainder is subtle timing or state-dependent discrepancies that require sophisticated, targeted probing to surface, plus behavioral discrepancies in third-party components outside the developer's test programme.
- CWE-208partialfinds — A.8.29's SOURCE reach (code review, static analysis) catches obvious non-constant-time comparisons and early-exit loops in security-sensitive code, and its RUNTIME reach (penetration testing) can surface some timing discrepancies under focused timing analysis, but many timing side channels are too subtle for standard code review, evade static-analysis pattern matching, and require specialised statistical timing measurement that ordinary pen testing does not perform — a nameable remainder that keeps the grade at `partial`.
- CWE-212partialfinds — A.8.29's combined programme of static analysis, dynamic testing, and penetration testing can discover instances of CWE-212 where sensitive data is improperly left in a resource before transfer, but the weakness is often a subtle design or implementation flaw in data handling logic that is difficult to surface through standard security testing unless specific test cases for data scrubbing are defined, making discovery a minority share of latent instances.
- CWE-213partialfinds — A.8.29's SOURCE+RUNTIME reach can find the mechanical instances (phpinfo() calls, DLL listings, unnecessary data in responses like the JSP SSN/CC example) via code review and dynamic/penetration testing, but the core of CWE-213 is a policy/requirements mismatch between developer and other stakeholders, which testing against a requirements set only catches when those requirements explicitly encode stakeholder policies — most latent instances of the policy-mismatch class are not surfaced by the testing programme.
- CWE-222partialfinds — A.8.29's SOURCE+RUNTIME programme reaches most CWE-222 instances: code review spots truncation logic in logging/display/handling code, SAST flags some patterns, and penetration testing observes truncation symptoms (truncated URIs in logs, truncated sub-domains in display) as in the CVE examples. The remainder is nameable — truncation that only manifests under specific input lengths or in rarely-exercised error paths may not surface in one cycle of testing.
- CWE-223partialfinds — A.8.29's SOURCE reach (code review) can find CWE-223 by examining logging conditions and noticing where security-relevant events are skipped, and RUNTIME reach (penetration testing) can surface some omissions by observing that attacker actions left no trace; however, the weakness is an OMISSION rather than a positive defect, detection is not near-mechanical, and a single cycle catches a minority of instances because reviewers must know what should be logged to spot what is missing, and penetration testing only reaches code paths the tester exercises.
- CWE-224partialfinds — A.8.29's source reach (code review, static analysis) can find this in first-party code where the wrong identifier is logged instead of the canonical one, but it is not a near-mechanical detection — it requires a reviewer or rule to recognise the security intent (canonical name should be logged) versus what is actually logged, and runtime/penetration testing only surfaces it if log content is specifically exercised.
- CWE-262partialfinds — A.8.29's security-function and secure-configuration testing can surface missing password aging in authentication and OS settings, but discovery is requirement-dependent and not near-mechanical, so only a minority of latent instances are found.
- CWE-263partialfinds — A.8.29's programme (code review, penetration testing, configuration testing) can surface some instances — penetration testing observes the long expiration in effect, code review finds hardcoded values — but CWE-263 is an architecture-and-design policy choice, not a code defect, and the testing validates against stated requirements, so unless the requirements specify an expiration ceiling most instances are not caught.
- CWE-268partialfinds — A.8.29's programme — code review, SAST, and penetration testing, with explicit testing of access restriction (8.3) — reaches most CWE-268 instances: code review catches role-check gaps like the OPERATOR-resets-admin-password pattern, and penetration testing exercises privilege combinations from outside. The remainder is bounded: subtle design-level chains that require full architectural understanding of the permission model and are not visible in any single code path or external behaviour.
- CWE-270partialfinds — A.8.29's source reach (code review) and runtime reach (penetration testing) can find some privilege context switching errors — the logic flaws are visible in source when reviewers know the privilege model, and some instances manifest as observable privilege escalation under dynamic testing. But CWE-270 is a research-gap weakness whose flaws are subtle architectural/logic errors often not observable from outside and not covered by standard static-analysis checkers, so a meaningful share of instances is missed.
- CWE-278partialfinds — A.8.29's source reach (code review, static analysis) can spot the pattern of inheriting permissions from archive files in first-party extraction code, and its runtime reach (penetration testing) can catch it by inspecting post-extraction file permissions, but discovery requires specific attention to this pattern rather than near-mechanical detection, so only a minority of latent instances are found in a single cycle.
- CWE-283partialfinds — A.8.29's SOURCE+RUNTIME reach finds most CWE-283 instances: code review catches the missing ownership check (it is literal in source, unlike CWE-798's build-time credentials), and penetration testing surfaces exploitable cases like the demonstrative process-kill example. The remainder is ownership checks missing in code paths not exercised by tests or not selected for review, and static analysis has limited rules for this semantic 'should this code check ownership?' question.
- CWE-324partialfinds — A.8.29's security testing programme (SAST, DAST, penetration testing) can discover an expired key in the application's own code or configuration during acceptance testing, but the weakness is often a runtime operational state (a key that was valid at deployment and has since expired) that a pre-deployment test cycle does not observe, so only a minority of instances are found.
- CWE-359partialfinds — A.8.29's testing programme (SAST, DAST, penetration testing) can discover instances of CWE-359 where private data is exposed through code flaws or runtime behaviour, but it cannot find exposures caused by operational practices, misconfigured data-sharing agreements, or Exif data left in images by third-party libraries where the exposure is a design choice rather than a testable defect.
- CWE-360partialfinds — A.8.29’s code review and penetration testing can surface unvalidated trust in system event data, but discovery depends on manual review of event-source trust boundaries rather than near-mechanical static or dynamic checks, so one cycle finds only a minority of latent instances.
- CWE-367partialfinds — A.8.29's programme covers manual code review (High for CWE-367), penetration testing/dynamic analysis (High), and automated static analysis (SOAR Partial), reaching the weakness through both SOURCE and RUNTIME; the remainder is the inherent difficulty of reliably triggering and observing race conditions during one cycle and the patterns automated tools miss.
- CWE-370partialfinds — A.8.29's SOURCE reach (code review, static analysis) can detect the missing re-check pattern in first-party TLS code, but CWE-370 is a subtle TOCTOU logic flaw that requires specific reviewer expertise or dedicated SAST rules to catch, and the RUNTIME half (penetration testing) is unlikely to reliably exploit the race, so a representative organisation's programme finds a minority of instances.
- CWE-374partialfinds — A.8.29's code review and static analysis can catch some non-cloned mutable objects passed to untrusted code, but the flaw is subtle, trust-boundary dependent, and rarely visible to dynamic or penetration testing, so only a minority of latent instances are found.
- CWE-385partialfinds — Security testing can uncover timing vulnerabilities but does not prevent their introduction.
- CWE-408partialfinds — A.8.29's SOURCE+RUNTIME reach (code review, static analysis, penetration testing) catches the CWE-408 pattern — an expensive operation ordered before the auth check is visible in source as a control-flow issue and is a known static-analysis target. The remainder is bounded: instances where the amplification is conditional, where the expensive operation is a simple-looking call that becomes costly only under specific inputs, or where the auth check is implicit across a distributed call chain — these slip past a single cycle of the programme.
- CWE-410partialfinds — Security testing can detect insufficient resource pools before deployment.
- CWE-412partialfinds — A.8.29's source + runtime programme reaches CWE-412 through code review (predictable lock-file names, externally-influenced lock targets), SAST (some patterns of externally-controlled lock acquisition), and penetration testing (DoS via held locks), but the weakness is subtle and context-dependent — the external influence and indefinite-hold conditions are not reliably surfaced by automated tools, and most instances require specific expertise or timing to manifest, so only a minority of latent instances are found in one cycle.
- CWE-432partialfinds — A.8.29's SOURCE reach (static analysis tools, code review) is well-suited to detecting the missing signal-masking pattern in CWE-432, and the weakness is a software implementation issue within the control's scope; the remainder is third-party code not subject to the developer's review and complex handler interactions where static analysis produces false negatives.
- CWE-439partialfinds — A.8.29's upgrade/environment test plans and acceptance checks can surface some behavior changes, but because they are security-focused and requirement-bound rather than full behavioral compatibility testing, only a minority of CWE-439 instances are reliably found.
- CWE-448partialfinds — Security testing can detect and flag obsolete UI features that lack appropriate warnings.
- CWE-477partialfinds — A.8.29's code review and static analysis components reach deprecated function calls in source code, but the runtime testing components (penetration testing, dynamic analysis) add little for a weakness that does not necessarily manifest at runtime, and SAST rule databases plus manual review leave a nameable remainder of deprecated functions not flagged (custom deprecations, language-version-specific markers, functions deprecated after the tool's last update).
- CWE-487partialfinds — A.8.29's SOURCE reach (code review and static analysis) can identify instances where package scope is relied on for security, but CWE-487 is a subtle design pattern rather than a mechanical defect, so detection depends on reviewer awareness and tool rule coverage; runtime/penetration testing rarely surfaces it, leaving a nameable remainder.
- CWE-508partialfinds — A.8.29's testing programme (code review, static analysis, penetration testing) can discover a minority of non-replicating malicious code instances — particularly obvious backdoors, suspicious network behaviour, or exploitable functionality visible from outside — but sophisticated malicious code is specifically designed to evade these routes, and the weakness can be introduced at Distribution or Operation phases that pre-deployment testing does not reach.
- CWE-510partialfinds — A.8.29's testing programme (code review, static analysis, penetration testing, independent acceptance testing) can find some trapdoors — especially poorly concealed ones or those with discoverable triggers — but trapdoors are by definition intentionally hidden code designed to evade detection, so well-crafted instances slip past the standard testing programme.
- CWE-512partialfinds — A.8.29's combined programme of code review, static analysis, dynamic testing and penetration testing can surface some spyware through observable indicators (unexpected cross-application data access, undocumented network egress, suspicious collection routines), but spyware is by design hidden functionality that mimics legitimate behaviour, so a substantial share evades detection.
- CWE-514partialfinds — Security testing can discover covert channels, yet the control does not mandate such specialized testing.
- CWE-528partialfinds — A.8.29's SOURCE+RUNTIME reach can find some instances: code review and static analysis can locate code that writes core dumps to insecure paths or handles them insecurely, and penetration testing can surface core dumps left in web-accessible directories. The remainder is bounded and nameable: most CWE-528 instances stem from OS-level core dump configuration (where dumps go, who can read them) that lives outside the application code the development-time programme inspects, and runtime testing only catches dumps that happen to land in externally observable locations.
- CWE-532partialfinds — A.8.29's SOURCE reach (SAST, code review) catches the bulk of CWE-532 instances where sensitive data is passed directly to logging calls, and RUNTIME reach (penetration testing) can surface sensitive data in accessible logs; the remainder is bounded and nameable — cases where sensitivity is context-dependent and not flagged by configured rules, and indirect logging patterns (e.g., logging entire objects whose toString() exposes sensitive fields) that SAST rules miss.
- CWE-543partialfinds — A.8.29's SOURCE reach (static analysis + code review) is highly effective against CWE-543: the non-synchronized singleton pattern is a well-known construct that automated static analysis and manual code review detect reliably. The bounded remainder is instances where the singleton is implemented through reflection, complex lazy initialization, or other patterns that evade pattern-matching static analysers, and cases where only dynamic timing-dependent observation would surface the race — neither reach is named in the clause's text as a separate credit.
- CWE-562partialfinds — Security testing in development can detect use-after-return bugs before release.
- CWE-58partialfinds — A.8.29's SOURCE+RUNTIME reach can find this weakness: code review of access-control logic can spot filename checks that don't normalize 8.3 forms, and penetration testing can probe 8.3 equivalents. But SAST tools rarely flag this Windows-specific behavior, and 8.3 probing is not a standard penetration test case, so only a minority of latent instances are surfaced in one cycle.
- CWE-589partialfinds — A.8.29's source reach (code review, static analysis) can detect calls to non-ubiquitous APIs, and its runtime reach (testing in an environment matching production) will surface the failure when the API is absent — but CWE-589 is fundamentally a portability/quality defect rather than a security flaw, so security-focused testing programmes do not systematically target it; the remainder is the cases where neither the SAST ruleset nor the reviewer is checking platform API coverage.
- CWE-689partialfinds — A.8.29's source reach (code review, SAST) can detect the underlying pattern of creating a resource with default permissions and setting them only after the copy completes, and runtime reach (penetration testing) can occasionally catch it under timing, but CWE-689 is a race condition explicitly flagged as a Research Gap/under-studied, and race conditions are notoriously hard for both static analysis (which sees the pattern but cannot prove concurrent access) and dynamic/penetration testing (which depends on hitting a narrow timing window), so only a minority of latent instances are surfaced by one cycle of the programme.
- CWE-69partialfinds — A.8.29's source + runtime reach can discover CWE-69 through code review of file-handling logic, static analysis rules for ADS handling, and penetration testing that probes for ::DATA bypass — but the weakness is obscure and Windows-specific, so a well-implemented programme catches a minority of latent instances rather than the bulk.
- CWE-72partialfinds — A.8.29's combined programme (code review, static analysis, penetration testing) can find some instances of CWE-72 in products that handle HFS+ paths — code review of path-handling logic and targeted pen-test cases can surface the flaw — but the weakness is theoretical, under-studied, and specific to a niche file system, so most instances are not reached by a representative testing programme that lacks HFS+-specific rules and test cases.
- CWE-778partialfinds — A.8.29's testing programme reaches most CWE-778 instances: code review finds missing log statements in first-party code (the Java login example), and vulnerability/configuration scanning finds logging that is disabled or misconfigured (the WCF and Azure examples). The bounded remainder is third-party components where the vendor's logging choices are not in the developer's source, and subtle cases where logging exists but omits important details that only an incident or detailed audit would surface.
- CWE-779partialfinds — A.8.29's SOURCE+RUNTIME reach can surface some instances of excessive logging — code review flags verbose logging statements and debug-level output left in production, and runtime testing observes log file growth and resource consumption — but the weakness is primarily an architectural/operational decision about log verbosity rather than a security function, secure coding rule, or secure configuration, so security testing is not the primary discovery mechanism and many instances (subtle over-logging, context-dependent verbosity) are not caught by the programme's routes.
- CWE-782partialfinds — Security testing can detect missing IOCTL authorization during development.
- CWE-837partialfinds — A.8.29's SOURCE+RUNTIME reach can surface CWE-837 through code review of state-management logic and through penetration testing that specifically exercises uniqueness constraints, but this is a business-logic flaw that automated SAST/DAST/vulnerability scanners do not reliably detect — discovery depends on the test plan enumerating the 'single action' requirement and on reviewer attention to state handling, so a well-implemented programme finds a minority of latent instances rather than the bulk.
- CWE-842partialfinds — A.8.29's testing programme (code review, SAST, penetration testing, secure configuration testing) reaches some CWE-842 instances — code defects in group-assignment logic and exploitable membership escalation are discoverable through access-control testing and pentest — but the weakness is largely a policy/logic correctness issue (the 'incorrect' is judged against intent), and administrative misconfigurations and design-level group-model errors are not what development testing surfaces, leaving a nameable remainder.
Mitigated MITRE ATT&CK techniques (3486)
Adversary techniques (MITRE ATT&CK Enterprise) this ISO control helps mitigate; links open attack.mitre.org. Our analysis (mostly llm_verified).
Direction: ← other covers this;
→ this covers other (F/M/P = full / mostly /
partial). gov = governs / implements (a mandate, not coverage).
Why these map — rationale
- T1068mostlydetects — Testing for insecure configurations, coding flaws, and design weaknesses before release limits the availability of privilege-escalation vulnerabilities that adversaries could exploit after gaining a foothold.
- T1027.018partialdetects — A.8.29's code review and vulnerability scanning activities could detect invisible Unicode characters in code being tested during development, but only if the test plan specifically includes such checks; the control is a pre-deployment testing framework whose scope is set by the organization based on the system's importance and nature, so detection of this specific obfuscation technique is not guaranteed.
- T1036.008partialdetects — A.8.29 mandates vulnerability scanning, penetration testing and code review in development/acceptance that can surface masquerading artifacts (e.g. polyglot files, anomalous headers, or insecure code enabling T1036.008), but this is limited to pre-deployment testing of in-house or acquired components and does not instrument or observe the live technique post-deployment.
- T1068partialprevents — A.8.29 mandates security testing that can identify and require remediation of the exploitable vulnerabilities before production deployment, but testing is proportionate to system importance and cannot guarantee discovery of every flaw an adversary might exploit.
- T1110.001partialprevents — A.8.29's security testing (including penetration testing, vulnerability scanning, and code review of authentication functions per 8.5) can identify weak authentication mechanisms before deployment and lead to their remediation, which prevents password guessing against the production system; but the control tests and validates rather than implements the prevention, the scope is set by the test plan, and remediation depends on the organization acting on findings.
- T1185partialdetects — A.8.29 mandates vulnerability scanning, penetration testing and code review during development and acceptance, which can surface browser-related flaws (e.g. insecure configurations, missing access restrictions or vulnerable extensions) before production; this is genuine but only a slice of the full technique surface, which also includes runtime process-injection behaviors, post-deployment pivoting and non-vulnerable inherent browser functionality that acceptance testing does not instrument or observe in operation.
- T1190partialprevents — A.8.29 mandates security testing before deployment, which can find and fix exploitable flaws in public-facing applications, but testing cannot guarantee discovery of every vulnerability and the control does not prevent exploitation of zero-days or flaws missed by the test scope.
- T1195partialdetects — A.8.29's code review, vulnerability scanning and penetration testing can surface some supply chain compromises — malicious additions to dependencies, known-vulnerable components, or backdoors in acquired code are within the test surface — but sophisticated compromises are designed to evade these tests, and manipulation occurring at the supplier's site or in distribution channels (shipment interdiction, factory-infected media, replacement of legitimate software) sits outside what pre-deployment acceptance testing can observe.
- T1195.001partialdetects — A.8.29's testing activities — vulnerability scanning, code review, and penetration testing — can detect some compromised dependencies by examining the code that actually runs in the test environment, but the technique is specifically designed to evade such testing (typosquatted packages, signed actions, natural-language agent files that pass signature screening), and A.8.29's primary scope is validating the organization's own security requirements rather than auditing third-party supply chain integrity.
- T1195.002partialprevents — A.8.29's code review, vulnerability scanning, and acquisition processes with security requirements can catch some supply chain compromises (e.g., malicious code inserted during in-house development, or compromised components evaluated before acquisition), but the technique's compromise point is upstream of where the control operates — at the supplier's development environment or in the update/distribution mechanism after acquisition — and sophisticated supply chain attacks are designed to evade the testing the clause prescribes.
- T1195.002partialdetects — A.8.29's code review, vulnerability scanning, penetration testing, and pre-acquisition evaluation of purchased components can surface malicious modifications to source code or compiled releases before deployment, but it is a pre-deployment control and does not detect compromise of update/distribution mechanisms that occurs after the software has been tested and accepted.
- T1203partialdetects — A.8.29 requires vulnerability scanning, penetration testing and code review during development and acceptance testing, which surfaces exploitable client-application vulnerabilities (including those due to insecure coding) before production; this is genuine detection of the class of weakness the technique relies on, but remains partial because the control is scoped only to pre-deployment testing of in-house or acquired systems and does not instrument or detect live exploitation attempts at runtime.
- T1203partialprevents — A.8.29's code review, vulnerability scanning, and penetration testing catch and remediate many exploitable vulnerabilities before deployment, but the testing scope is proportional rather than universal, zero-day and complex logic flaws remain unreachable, and third-party components may not receive equivalent depth of testing.
- T1204.003partialprevents — A.8.29's testing framework (vulnerability scanning, code review, penetration testing, secure configuration testing) applies to systems the organization develops, including custom images/AMIs/containers, and could catch backdoors before deployment; however, the core T1204.003 scenario involves users pulling already-malicious images from public repositories, which A.8.29's development-stage testing does not address, and the clause does not mandate image-integrity verification at deployment time.
- T1204.005partialdetects — A.8.29's code review, vulnerability scanning, and component evaluation activities can surface malicious libraries that are dependencies of systems being developed in-house or acquired before deployment, but the technique centers on users installing libraries at runtime in production environments, which A.8.29's pre-deployment testing does not reach.
- T1210partialdetects — Pre-deployment penetration testing and configuration validation of remote services and components reduces the chance that lateral-movement paths remain open due to unpatched or misconfigured services.
- T1210partialprevents — A.8.29 catches vulnerabilities in new/updated systems through code review, vulnerability scanning, and penetration testing before deployment, so vulnerabilities found and remediated cannot be exploited; however, existing deployed systems, third-party components, and undiscovered vulnerabilities remain exploitable, and testing depth is proportional rather than exhaustive.
- T1211partialdetects — A.8.29 mandates security testing (including vulnerability scanning, penetration testing, and code review) that surfaces exploitable flaws in code, configurations, and security functions before production; this can discover the specific vulnerabilities adversaries would later abuse for stealth/evasion, but does not detect the T1211 technique once it is running in a live environment.
- T1211partialprevents — A.8.29's vulnerability scanning, penetration testing, and code review can find and remediate flaws in in-house and acquired code before deployment, preventing exploitation of those specific vulnerabilities for stealth; however, T1211 also targets vulnerabilities in third-party SaaS, cloud infrastructure, and security tools outside the development-test scope, and zero-day flaws evade pre-deployment testing, leaving a substantial remainder.
- T1212partialdetects — A.8.29 requires vulnerability scanning, penetration testing and code review during development and acceptance testing, which can surface exploitable credential-related vulnerabilities (e.g. in auth functions or secure coding) before production; this is genuine but limited to pre-deployment discovery on in-house or evaluated components, not runtime detection of the live technique across all platforms or post-deployment exploitation.
- T1212partialprevents — A.8.29 mandates security testing including vulnerability scanning and penetration testing before deployment, which can identify and remediate the software vulnerabilities T1212 exploits, but testing cannot guarantee discovery of every exploitable flaw, leaving a residual attack surface.
- T1216partialprevents — A.8.29's testing of secure configurations (8.9, 8.20, 8.22) and application control mechanisms could verify that script proxy execution vectors are blocked before deployment, but the technique abuses default Microsoft-signed scripts present on production Windows systems regardless of how thoroughly the custom application was tested, so development-time validation addresses only a slice of the attack surface.
- T1491.002partialprevents — A.8.29's security testing (code review, vulnerability scanning, penetration testing, secure configuration testing) can identify and lead to remediation of vulnerabilities that would otherwise enable external defacement of web-facing systems, but it is a pre-deployment validation control rather than a direct prevention mechanism, and testing cannot catch all exploitable flaws nor address threats that emerge after release.
- T1499partialprevents — Security testing can identify and remediate code-level vulnerabilities, design flaws, and misconfigurations that enable crash-condition and resource-exhaustion DoS (e.g., unbounded request handling, unhandled exceptions, amplification misconfigs), but cannot prevent volumetric endpoint DoS that overwhelms a properly-coded service with traffic from botnets or spoofed sources.
- T1499.003partialprevents — Security testing during development can catch resource-exhaustion vulnerabilities through code review, penetration testing, and validation of security requirements (rate limiting, resource caps, input validation) before deployment, but the control tests against requirements the organization sets rather than mandating DoS-specific protections, and the technique's many vectors (any resource-intensive feature) are not comprehensively covered by the testing scope the clause describes.
- T1499.004partialdetects — A.8.29 requires vulnerability scanning, penetration testing and code review during development and acceptance, which can surface exploitable vulnerabilities (including those that could lead to application/system crashes) before production; this is genuine but partial because the control is scoped to pre-deployment testing of new/changed systems (not runtime detection of in-flight exploitation of T1499.004 on production assets), and the technique can still use zero-days or untested paths.
- T1505.001partialprevents — A.8.29's secure-configuration testing (8.9, 8.20, 8.22) and code review can catch and force remediation of database defaults that enable the technique's OS-execution paths (xp_cmdshell enabled, unrestricted CLR integration), but the control acts only pre-deployment and does not stop an adversary with database access from crafting malicious stored procedures for persistence on a running system.
- T1505.003partialdetects — A.8.29 mandates vulnerability scanning, penetration testing, and code review during development and acceptance testing, which can surface web shell indicators (e.g. anomalous server-side scripts or insecure configurations) before or during deployment to production; this is genuine but only a slice, as the control is scoped to pre-production testing of new/changed systems rather than runtime detection of deployed web shells on live servers.
- T1525partialdetects — Independent acceptance testing and vulnerability scanning of new or upgraded systems detect malicious implants or backdoors introduced during development or supply-chain stages.
- T1528partialprevents — Security testing in development can catch implementation flaws that enable token theft (insecure token storage, weak validation, excessive token lifetimes, improper OAuth implementation) and require remediation before deployment, but it cannot prevent the technique broadly because T1528's primary vectors — runtime container/VM compromise, CI/CD pipeline compromise, and OAuth social engineering — occur after deployment and outside the scope of pre-deployment testing.
- T1530partialprevents — A.8.29's pre-deployment security testing can catch insecure code that leaks credentials and insecure default configurations of cloud storage integrations, but T1530's primary vectors — post-deployment misconfigurations, overly-broad IAM permissions, and credentials leaked from logs or operational sources — sit outside the development testing scope.
- T1539partialprevents — Security testing in development can catch application-level vectors that enable cookie theft (XSS allowing JS-based cookie exfiltration, missing HttpOnly/Secure flags, session management flaws), but cannot prevent endpoint-based theft from browser memory/disk, AiTM proxy interception (Evilginx2), or phishing-driven cookie capture — all of which succeed against a perfectly tested application.
- T1546.016partialdetects — A.8.29 explicitly requires vulnerability scanning, penetration testing, and code review during development/acceptance testing, which can surface malicious or anomalous installer scripts and post-install content before production; this is limited to pre-deployment testing of in-house/outsourced code rather than runtime detection of the live technique across all platforms.
- T1548.001partialprevents — A.8.29's secure-configuration testing (referencing 8.9, 8.20, 8.22) can catch in-house developed applications that have unnecessary setuid/setgid bits set, preventing that slice; but the technique's bulk — adversary-introduced malware with setuid bits set by the attacker, and abuse of pre-existing system binaries — falls outside the development-and-acceptance pipeline A.8.29 governs.
- T1548.005partialprevents — A.8.29 mandates security testing of configurations including access restrictions, which can surface misconfigured just-in-time access or role-passing permissions before deployment, but testing is proportional to system importance and cannot guarantee every cloud permission path is exhaustively covered.
- T1552partialprevents — Security testing in development and acceptance can catch hardcoded credentials, insecure credential storage in custom code, and misconfigured credential repositories before deployment, but it cannot prevent credentials from becoming unsecured post-deployment (e.g., admins writing secrets to files later) nor prevent discovery of credentials legitimately stored by OS/application credential managers that an adversary reaches after compromise.
- T1552.001partialprevents — Security testing in development can catch and remediate insecurely stored credentials in code, configuration files, and components before deployment, removing the preconditions the technique exploits; however, it cannot prevent credentials stored in user-created files, operational configs added post-deployment, or third-party software, and testing depth is proportional rather than exhaustive.
- T1552.002partialprevents — A.8.29's secure coding review, secure configuration testing, and vulnerability scanning can catch and remediate insecure credential storage by the application under development before deployment, but T1552.002 harvests credentials stored by the OS, third-party software, and other services outside the scope of any single application's acceptance testing, so the technique's broader class of registry-resident credentials is not prevented.
- T1553partialdetects — Testing of secure configurations and code signing controls catches misconfigurations or trust-control bypasses that would allow adversaries to subvert code integrity checks.
- T1553partialprevents — Security testing during development can validate that trust mechanisms (code signing verification, trust store handling, attribute checks) are correctly implemented and identify insecure configurations or code that would allow trust subversion, but it cannot prevent certificate theft, post-deployment registry/permission modifications, or adversaries using legitimately-signed malicious code — all core T1553 vectors that operate outside the development testing scope.
- T1559.003partialprevents — A.8.29's code review, vulnerability scanning and penetration testing are designed to catch the exact class of flaw T1559.003 exploits (improper XPC client validation, poor input sanitization), so where testing surfaces and remediates those defects the technique cannot run against the deployed system; but the clause mandates testing 'in proportion to' importance and nature of the system rather than exhaustive coverage, and third-party components are evaluated against criteria rather than re-tested to the same depth, so a bounded remainder of vulnerable XPC handlers reaches production.
- T1574partialprevents — Security testing in development and acceptance can identify and remediate many conditions enabling execution flow hijacking (insecure library search paths, unquoted service paths, DLL planting vectors, weak service permissions) before deployment, but the control tests in proportion to importance rather than exhaustively, and some T1574 vectors involve runtime manipulation or post-deployment conditions that development-phase testing does not reach.
- T1574.001partialprevents — A.8.29's code review, vulnerability scanning, and penetration testing can identify and lead to remediation of DLL hijacking vulnerabilities (search order issues, phantom DLL references, insecure loading patterns) before deployment, but testing is pre-deployment and coverage-dependent: third-party components, post-deployment changes, and subtle hijacking vectors can still reach production, so the technique is reduced rather than eliminated.
- T1574.004partialprevents — Security testing during development can identify dylib hijacking vulnerabilities (weak linking, insecure search paths, missing signature verification) through code review, vulnerability scanning, and penetration testing, leading to remediation before deployment; however, testing scope is proportional and determined by the organization, third-party and outsourced components may not receive equivalent testing, and runtime loader behavior may not be fully exercised, leaving a meaningful remainder where the technique remains exploitable.
- T1574.005partialdetects — A.8.29 requires vulnerability scanning, penetration testing and code review during development and acceptance testing, which can surface this weakness in installers (e.g. via insecure temp-dir permissions or binary overwrites) before production; it does not instrument or monitor running systems for the technique in flight.
- T1574.005partialprevents — A.8.29 explicitly requires testing of secure configurations (including file permissions via 8.9/8.20/8.22), code review, vulnerability scanning, and penetration testing — all of which can surface the weak permissions on installer directories that T1574.005 exploits, preventing vulnerable code from reaching production; but the extent is partial because testing is risk-based and proportionate rather than exhaustive, third-party components are evaluated against acquisition criteria rather than deeply tested, and the control depends on remediation actually occurring before deployment.
- T1574.007partialdetects — A.8.29 explicitly requires vulnerability scanning, penetration testing and code review in a near-production test environment, which surfaces the insecure configuration, code, or design enabling PATH interception (e.g. via insecure defaults or untrusted search paths) before deployment; this is genuine but only a slice because the control is scoped to pre-production testing of new/changed systems and does not instrument or detect the live technique on deployed production systems.
- T1574.008partialprevents — Security testing during development can identify programs vulnerable to search order hijacking (via code review, penetration testing, and vulnerability scanning) and require remediation before deployment, but A.8.29 is a process control whose coverage depends on test thoroughness, does not reach third-party or legacy software uniformly, and cannot guarantee every vulnerable code path is caught before production.
- T1574.009partialdetects — A.8.29 requires vulnerability scanning, penetration testing and code review in development/testing that can surface unquoted-path flaws before deployment (and in test environments matching production), but does not monitor or detect the technique in a running production environment where the adversary actually places and triggers the higher-level executable.
- T1574.009partialprevents — A.8.29 mandates security testing including secure configurations and vulnerability scanning, which can identify unquoted service paths before deployment, but the control's scope is proportional to system importance and does not guarantee every path on every system is tested.
- T1574.010partialprevents — A.8.29's security testing activities — penetration testing, vulnerability scanning, and secure configuration testing of operating systems — can identify weak service file permissions and require remediation before deployment, but the control is testing-focused rather than enforcement-focused, does not guarantee complete coverage of all services, and does not address post-deployment drift that could reintroduce the weakness.
- T1574.011partialprevents — A.8.29's secure configuration testing (8.9, 8.20, 8.22) and vulnerability scanning can verify that service Registry ACLs are properly hardened before new systems or upgrades reach production, preventing the weakness from being deployed; however, the control only covers new/updated systems, leaves test scope to the organization, and does not address existing production misconfigurations or post-deployment Registry changes.
- T1574.014partialprevents — Security testing during development can identify and remediate some vulnerable code patterns and insecure configurations (e.g., unsafe assembly loading, unvalidated .config handling) that enable AppDomainManager hijacking before deployment, but the technique exploits .NET framework design and runtime tampering of configuration files and environment variables, which pre-deployment testing cannot fully prevent, and the control only covers systems the organization develops or acquires, not all .NET applications that may be present.
- T1599partialprevents — A.8.29's testing of secure configurations (including firewalls and other security components) and its penetration testing/vulnerability scanning can identify and remediate weaknesses in network boundary devices before deployment, preventing some instances of T1599; however, the clause applies at development and acceptance time only, does not cover the full estate of deployed network devices, and cannot prevent post-deployment compromise via new vulnerabilities, credential attacks, or configuration drift.
- T1611partialprevents — Security testing during development and acceptance can catch insecure container configurations (privileged containers, bind mounts, exposed docker.sock), known runtime vulnerabilities, and dangerous code patterns before deployment, preventing those specific escape vectors; however, it cannot catch zero-day kernel or hypervisor exploits, novel escape techniques, or runtime-only misconfigurations, leaving a substantial remainder of the technique's surface uncovered.
- T1677partialprevents — A.8.29's code review, secure configuration testing, and penetration testing can catch malicious modifications to CI configuration files and insecure pipeline designs (e.g., pull_request_target exposing secrets), but the control's primary scope is the application being deployed rather than the build infrastructure itself, and runtime/external vectors like malicious PRs from forks or self-hosted runner exploitation occur during pipeline execution and are not reachable by pre-deployment testing.
- T1685.007partialprevents — A.8.29's penetration testing and code review of security functions could test LLM-based autonomous defenses against prompt injection before deployment, but the clause addresses general security testing rather than AI/ML-specific threats, and tested systems remain vulnerable to novel prompt injection techniques at runtime.
- T1687partialprevents — A.8.29 tests in-house developed code (including defensive components) for security flaws before deployment, so vulnerabilities caught and remediated during testing cannot be exploited — but the bulk of T1687 targets third-party security software (commercial AV, EDR, firewalls) where A.8.29's reach is limited to acquisition criteria, and zero-days or post-deployment discoveries in any defensive component are outside the clause's pre-deployment testing scope.
- T1689partialprevents — Security testing during development and acceptance can identify and require remediation of downgrade-vulnerable configurations (e.g., systems accepting outdated protocol versions, insecure fallback settings) and insecure code that enables downgrade paths, so a tested-and-accepted system is less reachable by this technique; however, A.8.29 is a pre-deployment validation control that does not actively enforce at runtime, only covers systems passing through the testing process, and does not comprehensively catch all downgrade vectors (e.g., protocol-level negotiation, runtime feature downgrades like PowerShell version switching), leaving a substantial remainder.
- T1698partialprevents — A.8.29 mandates security testing during development and acceptance, which can identify and require remediation of some prompt-injection vulnerabilities (e.g., via code review, vulnerability scanning, and penetration testing of LLM-integrated applications) before deployment, but the technique operates through external content the LLM retrieves rather than through application code, the clause's enumerated testing categories (security functions, secure coding, secure configurations) do not explicitly address LLM input handling, and pre-deployment testing is a snapshot that cannot anticipate novel injection payloads.
Prevented OWASP Web Top 10 (2025) risks (22)
OWASP Web Top 10 (2025) risk categories this ISO control helps prevent or mitigate — our analysis (mostly llm_verified).
Direction: ← other covers this;
→ this covers other (F/M/P = full / mostly /
partial). gov = governs / implements (a mandate, not coverage).
Why these map — rationale
- A03partialfinds — A.8.29 explicitly requires vulnerability scanning, code review and penetration testing that surface insecure configurations, insecure code and system vulnerabilities in dependencies or components (including via acquisition evaluation), but does not address build pipelines or signing infrastructure at all.
- A09partialfinds — A.8.29 explicitly requires vulnerability scanning, penetration testing and code review that surface missing or broken logging/alerting (a detectable insecure configuration or functional failure), but this is only one slice of the many security functions and requirements the control tests against.
Control IDs, short titles and the structured attribute table (control type, CIA properties, cybersecurity-concept, operational capability, security domain) are facts from ISO/IEC 27001:2022 Annex A / ISO/IEC 27002:2022. The full implementation guidance prose lives in ISO/IEC 27002:2022 — not reproduced here. Cross-walks to NIST 800-53, NIST CSF 2.0, OWASP ASVS, CWE, MITRE ATT&CK and OWASP Web Top 10 are our own analysis (mostly llm_verified), not an ISO, NIST, MITRE or OWASP product — how ours compare.