A.8.8 Technological
Management of technical vulnerabilities
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 (15)
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
- SI-2mostlycovers — A.8.8's processes for identifying, assessing and remediating technical vulnerabilities (including timely patching) account for the bulk of SI-2's flaw-remediation requirements; residual exists around explicit pre-install testing, side-effect analysis, and mandatory integration into configuration management that sit outside A.8.8's stated scope.
Aligned NIST CSF 2.0 outcomes (22)
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
- PR.PS-02domain mandateimplements — A.8.8's operational process for identifying, assessing and remediating technical vulnerabilities (including patching and replacement) directly gives effect to the PR.PS-02 outcome of maintaining/replacing/removing software in line with risk; the link is within the shared 'vulnerability and maintenance' domain but PR.PS-02 does not name vulnerability management explicitly.
Related OWASP ASVS 5.0 requirements (10)
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 (1574)
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-1004partialfinds — A.8.8's reach is DISCLOSURE — it surfaces vulnerabilities that carry a published advisory in a third-party component. CWE-1004 instances with CVEs (e.g., CVE-2024-47833, CVE-2022-24045) are a minority of all latent instances; the bulk of missing-HttpOnly-flag defects live in custom first-party code that no advisory names, and A.8.8's scanning and inventory-based mechanism does not read source.
- CWE-1007partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities that have been published as advisories/CVEs. CWE-1007 does surface as CVEs (browsers, web forums in the observed examples), so a minority of instances are reachable; the bulk of homoglyph weaknesses in custom first-party display/URL/username code is never disclosed and never found by this control.
- CWE-1021partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. Clickjacking does surface as CVEs in third-party components (e.g., CVE-2017-5697 firmware, CVE-2017-4015 DLP product), so A.8.8 finds that minority. The bulk of CWE-1021, however, is a first-party web application configuration/coding defect (missing X-Frame-Options / CSP frame-ancestors), which A.8.8's disclosure-based programme does not reach.
- CWE-1050partialfinds — A.8.8's disclosure-based vulnerability management surfaces CWE-1050 only when it appears as a vendor-published CVE/advisory in an inventoried third-party component, leaving most first-party custom loop-resource defects undisclosed.
- CWE-1088partialfinds — A.8.8's reach is DISCLOSURE — it sees instances that carry a vendor-published flaw. CWE-1088 is primarily a first-party code defect (developer-written synchronous calls without timeouts), and only a minority of such instances surface as CVEs (the observed examples are in well-known products). Penetration testing (guidance e) could find some runtime hangs, but the bulk of missing-timeout bugs in custom code are never published as advisories, so A.8.8 discovers only the disclosed share.
- CWE-1104partialfinds — REACH: a disclosure-reach control sees only instances that carry a vendor-published flaw, so `finds` is at most `partial` (rule, 2026-10-17).
- CWE-1104partialremoves — 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-112partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-112 (Missing XML Validation) is primarily a first-party code defect where the developer fails to enable schema validation, which A.8.8 does not reach. A minority of instances surface as CVEs in third-party XML libraries (e.g., parser validation bypasses), and those are what A.8.8 finds.
- CWE-113partialfinds — A.8.8's reach is DISCLOSURE — it sees only what vendors publish. CWE-113 is an implementation defect in first-party application code (custom web apps failing to neutralize CRLF in headers), and the bulk of instances live in code no advisory names. A.8.8 finds the minority where the weakness surfaces as a CVE in a third-party component (e.g., CVE-2020-15811 in a proxy, CVE-2021-41084 in a Scala HTTP interface), matching the same disclosure-bounded minority that graded A.8.8 -> CWE-89 at `partial`.
- CWE-120partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw, so it finds buffer overflows in third-party components with published CVEs (a real, named minority) but not the bulk of CWE-120 instances, which live in first-party custom code and are the province of A.8.29's source-reading testing.
- CWE-1204partialfinds — A.8.8's reach is disclosure-based: it finds weak-IV instances only where a vendor has published an advisory or CVE for the affected component. CWE-1204 commonly surfaces as CVEs (ZeroLogon, BEAST, WEP, multiple CBC-mode examples), so the disclosed share is real, but it remains a minority of latent instances — first-party code with weak IV generation is never reached by A.8.8's scanning and inventory-based programme.
- CWE-121partialfinds — A.8.8's reach is DISCLOSURE-based: it finds stack-based buffer overflows when they appear as published CVEs/advisories in third-party components (a real but minority share, since buffer overflows do commonly surface as CVEs), but it does not reach the first-party code defects that constitute the bulk of this weakness class.
- CWE-122partialfinds — A.8.8's reach is DISCLOSURE — it surfaces heap-based buffer overflows only where they appear as published CVEs in third-party components in the inventory. CWE-122 is overwhelmingly an implementation-phase defect in custom code, which A.8.8 does not read; the disclosed third-party share is a minority, matching the same logic that graded A.8.8 -> CWE-89 at `partial`.
- CWE-123partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw, and write-what-where conditions do commonly surface as CVEs (memory corruption is widely disclosed), so the disclosed share is a minority of the class but a real one.
- CWE-1236partialfinds — A.8.8's reach is disclosure-based: it finds vulnerabilities through published advisories, vendor disclosures, and scanning against known CVE databases. CSV injection does surface as CVEs (CVE-2019-12134, CVE-2019-4521, CVE-2019-17661), so the disclosed share is non-trivial, but the majority of CSV injection instances live in first-party application export code that nobody publishes an advisory about, leaving them outside A.8.8's view.
- CWE-124partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, published advisories, patch management), and CWE-124 does surface as CVEs (multiple observed examples listed), so the disclosed share is reachable; but the bulk of buffer underwrite instances live in custom code or unpublished third-party components, capping the rung at `partial` per the disclosure-reach doctrine.
- CWE-1240partialfinds — A.8.8's reach is disclosure-based: it finds CWE-1240 instances only where the weak primitive has been published as a CVE or is detectable by vulnerability scanners (e.g., weak cipher suites, MD5 usage, outdated TLS configurations). The observed examples show CWE-1240 commonly surfaces as CVEs, so the disclosed share is real but remains a minority of latent instances — custom or internal implementations of risky primitives are never surfaced.
- CWE-1241partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances carrying a vendor-published flaw. CWE-1241 (predictable PRNG) does surface as CVEs in third-party components (e.g., CVE-2021-3692 PHP mt_rand()), so A.8.8 finds that minority; the bulk of instances are first-party design choices in custom code that never receive a CVE and are outside A.8.8's disclosure-based reach.
- CWE-125partialfinds — A.8.8's reach is DISCLOSURE — it surfaces OOB reads only where they appear as published CVEs in third-party components in the asset inventory. CWE-125 commonly surfaces as CVEs (Heartbleed, kernel/IP-stack bugs), so a real share is found, but first-party OOB reads and un-disclosed instances are outside the clause's reach, capping the rung at `partial`.
- CWE-126partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, vendor advisories, third-party library tracking), and CWE-126 commonly surfaces as CVEs (Heartbleed, etc.), so the disclosed share is found; the remainder — buffer over-reads in first-party code and in third-party components without published advisories — is outside A.8.8's reach, capping the rung at `partial`.
- CWE-1265partialfinds — A.8.8's reach is DISCLOSURE-based (vulnerability scanning, advisories, third-party tracking); CWE-1265 does surface as CVEs (CVE-2014-1772, CVE-2018-8174), so the disclosed minority is found, but the bulk of reentrancy defects in first-party code are not visible to a disclosure-scoped programme.
- CWE-127partialfinds — A.8.8's reach is disclosure-based: it finds vulnerabilities that surface as published advisories in third-party components. Buffer under-reads do occasionally appear as CVEs (e.g., CVE-2021-40985), so the disclosed minority is found, but the bulk of CWE-127 instances live in first-party code and are discovered by static analysis or code review, which A.8.8 does not perform.
- CWE-1275partialfinds — A.8.8's disclosure reach only surfaces instances with published advisories/CVEs, and while some products do disclose this SameSite cookie flaw, most instances in custom web applications are never published, so it finds a minority.
- CWE-1277partialblocks — A.8.8 explicitly addresses the unpatchable scenario with compensating controls (workarounds, turning off services, firewalls, virtual patching, increased monitoring) that can block exploitation of vulnerabilities in unpatchable firmware, but the root weakness — inability to update — remains, so new vulnerabilities discovered over the device's lifetime cannot be addressed at source and the compensating controls are mitigations rather than full blocks.
- CWE-128partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. Wrap-around errors are first-party code defects whose primary detection methods (static analysis, code review) belong to A.8.28/A.8.29, not A.8.8. A.8.8 finds CWE-128 only where it surfaces as a published advisory in a third-party component, which is a minority of all wrap-around instances.
- CWE-1284partialfinds — A.8.8's reach is DISCLOSURE-based (vulnerability scanning against published advisories and component inventory). CWE-1284 is primarily a first-party input-validation code defect that A.8.8 does not inspect; it is found only where the weakness surfaces as a published CVE in a third-party component, which is a minority of instances.
- CWE-1285partialfinds — A.8.8's reach is disclosure-based (vendor advisories, vulnerability scanning of known components), and CWE-1285 is primarily a first-party implementation defect — the modes of introduction list 'Implementation' and the demonstrative examples are all in the developer's own code. A.8.8 finds it only where it surfaces as a published CVE in a third-party component (the observed examples show CVEs do exist for this class), which is a minority of latent instances; the bulk lives in first-party source that A.8.8's disclosure reach does not see.
- CWE-1287partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, published advisories, third-party library tracking); CWE-1287 is a first-party implementation defect whose bulk in custom code is never published as a CVE, so A.8.8 finds only the minority of instances that surface as advisories in third-party components or are caught by its penetration-testing component.
- CWE-1288partialfinds — A.8.8's reach is DISCLOSURE — it finds weaknesses only where they carry a vendor-published flaw. CWE-1288 does surface as CVEs (the observed examples show CVE-2006-3790, CVE-2008-4114, CVE-2018-16733), so the disclosed share is a real minority; most inconsistent-input-validation defects in deployed code are never published and remain outside A.8.8's view.
- CWE-1289partialfinds — A.8.8's reach is disclosure-based vulnerability scanning plus penetration testing; it finds CWE-1289 instances that surface as published CVEs in third-party components (the observed examples are all such) and some that pen testing can observe from outside (case/encoding bypasses), but the majority of CWE-1289 instances live in first-party input-validation code that A.8.8's programme does not read.
- CWE-129partialfinds — A.8.8's reach is DISCLOSURE — it sees array-index validation errors only where they have been published as CVEs or vendor advisories, and most CWE-129 instances in first-party code never surface that way; the observed CVEs show the class does get disclosed, so the found share is a minority rather than zero.
- CWE-130partialfinds — A.8.8's reach is disclosure-based (vendor advisories, third-party component inventory); CWE-130 is an implementation bug in parsing code that lives mostly in first-party code A.8.8 does not read, so only the disclosed share — instances that have surfaced as CVEs in third-party components (Heartbleed being the canonical example) — is found, which is a minority of latent instances.
- CWE-131partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw, and CWE-131 commonly surfaces as CVEs in third-party components (font libraries, JavaScript engines, kernels), so the disclosed share is non-trivial; but the bulk of buffer-size calculation errors live in first-party custom code that never receives a CVE, and A.8.8's reach does not extend to source-reading tests on the organisation's own code (that is A.8.29's territory), leaving a nameable majority of instances outside its view.
- CWE-1321partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. Prototype pollution does commonly surface as CVEs in third-party libraries (lodash, jQuery, etc., as the observed examples show), so A.8.8 finds those. But most prototype pollution lives in first-party JavaScript code that nobody publishes an advisory about, and that share is invisible to A.8.8's disclosure-based programme — the same scope seam that put A.8.8 -> CWE-89 at `partial`.
- CWE-1325partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw, and CWE-1325 does surface as CVEs (CVE-2020-36049, CVE-2019-20176, CVE-2013-1591), so a minority of instances are reachable through published advisories and component inventory; the bulk of this implementation-phase memory-allocation defect lives in first-party code that no advisory names.
- CWE-1327partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw — and CWE-1327 does surface as CVEs (CVE-2023-41742, CVE-2022-21947), so vulnerability scanning and management will find it where disclosed, but the disclosed share of any weakness class is a minority, capping the rung at `partial`.
- CWE-1329partialfinds — Vulnerability-management processes can detect and drive replacement of non-updateable components, but cannot retroactively make them patchable.
- CWE-1329partialblocks — A.8.8's section (i) explicitly addresses the case where 'no update is available or the update cannot be installed' with six compensating measures (workarounds, turning off services, firewalls, virtual patching, increased monitoring, awareness) that can block exploitation of vulnerabilities in unpatchable components, but the underlying weakness — the unpatchable component itself — remains, and the compensating controls are not always applicable (e.g., turning off services may break required functionality) and can be bypassed, leaving a nameable remainder of exploitable cases.
- CWE-1333partialfinds — A.8.8's reach is DISCLOSURE: it finds ReDoS only where a vendor has published an advisory (third-party libraries tracked under 8.8(f)), and the disclosed share of this class is a minority — most inefficient regex complexity lives in first-party code that no advisory names.
- CWE-1335partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities via published advisories, scanning tools, and third-party library tracking. CWE-1335 does surface as CVEs (multiple observed examples), so a minority of instances in third-party components are found; first-party code defects, which constitute the bulk of bitwise shift bugs, are outside A.8.8's source-reading reach.
- CWE-1336partialfinds — A.8.8's reach is DISCLOSURE — it sees template injection only where it surfaces as a published advisory in a third-party component (the observed CVEs show SSTI/CSTI does commonly appear as CVEs in libraries and engines), but the bulk of template injection lives in first-party application code that A.8.8's disclosure-based programme does not reach, mirroring the A.8.8 -> CWE-89 anchor at the same rung.
- CWE-134partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities via published advisories and component inventory. CWE-134 is a first-party code defect whose High-rated detection methods (source code analysis) belong to A.8.29, not A.8.8. A.8.8 finds format string bugs only where they appear as published CVEs in third-party components, which is a minority of instances, matching the A.8.8 -> CWE-89 anchor.
- CWE-1341partialfinds — A.8.8's reach is DISCLOSURE — published advisories and component inventory — and CWE-1341 (double free / double close) is an implementation-phase code defect that mostly lives in first-party code invisible to that reach; the minority of instances that surface as CVEs in third-party components (e.g. CVE-2019-13351, CVE-2004-0772) are found, mirroring the A.8.8 -> CWE-89 anchor.
- CWE-1357partialfinds — REACH: a disclosure-reach control sees only instances that carry a vendor-published flaw, so `finds` is at most `partial` (rule, 2026-10-17).
- CWE-1385partialfinds — A.8.8's reach is disclosure-based: it finds this weakness only where it has been published as a CVE in a third-party component (the observed examples show it does get CVE'd), but most missing-origin-validation instances are in first-party WebSocket code that A.8.8's scanning and inventory-based mechanisms do not inspect, mirroring the A.8.8 -> CWE-89 anchor.
- CWE-1386partialfinds — A.8.8's reach is DISCLOSURE (published advisories and component inventory); CWE-1386 is a first-party implementation defect, so A.8.8 only finds the minority of instances that have been published as CVEs (e.g., CVE-2021-26426, CVE-2020-0863, CVE-2019-1161, CVE-2014-0568), while the bulk of junction/mount-point handling flaws in custom code remain outside its view, mirroring the A.8.8 -> CWE-89 anchor.
- CWE-1389partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities that have been published as advisories/CVEs in third-party components. CWE-1389 does surface as CVEs (multiple examples cited: CVE-2021-29662, CVE-2021-28918, CVE-2021-29921, CVE-2021-29923, CVE-2021-29424, CVE-2020-13776), so the class is not invisible to this reach, but the bulk of instances are first-party parsing bugs in code nobody has published an advisory about, which A.8.8's disclosure-based programme never sees.
- CWE-1392partialfinds — A.8.8's reach is DISCLOSURE — vulnerability scanning tools test for catalogued default credentials (Nessus/Qualys plugins, CVE-driven checks), and default credentials commonly surface as CVEs (multiple examples in CWE-1392), but the scanner only knows defaults that have been published or fingerprinted; many default credentials in custom, niche, or OT products are never catalogued, leaving a nameable remainder.
- CWE-1394partialfinds — A.8.8's reach is DISCLOSURE-based: it finds default cryptographic keys only when they surface as published advisories/CVEs (as the observed examples show they sometimes do), but the undisclosed majority of latent default-key instances in deployed products is never reached by scanning against vendor-published flaw data.
- CWE-140partialfinds — A.8.8's reach is DISCLOSURE — it finds delimiter-neutralization flaws only where they have been published as advisories in third-party components, and most CWE-140 instances live in first-party code that no advisory names, mirroring the A.8.8 -> CWE-89 anchor at the same rung.
- CWE-141partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw, and CWE-141 is a first-party code-level implementation defect. A.8.8 finds it only where it surfaces as a published CVE in a third-party component (as CVE-2003-0307 did), which is a minority of instances; the bulk lives in first-party code that A.8.8's disclosure-based programme does not reach.
- CWE-1427partialfinds — A.8.8's disclosure-based vulnerability management only surfaces CWE-1427 instances that have vendor-published CVEs or reports, missing first-party prompt-construction flaws, so it finds a minority.
- CWE-144partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw, and CWE-144 (line-delimiter neutralization) is an implementation-phase flaw that mostly lives in custom code never assigned a CVE; the minority of instances that do surface as published advisories in third-party components are within A.8.8's scanning and inventory reach, mirroring the A.8.8 -> CWE-89 anchor.
- CWE-145partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances carrying a vendor-published flaw, and CWE-145 (section delimiter neutralization, e.g. MIME multipart boundaries) does occasionally surface as CVEs in widely-used parsers, so a minority of instances are found; most instances in first-party or unadvised code are outside its view.
- CWE-146partialfinds — A.8.8's reach is disclosure-based (vendor advisories, component inventory), so it finds CWE-146 only where the weakness surfaces as a published CVE in a third-party component; most instances live in first-party code that no advisory names, which is the same remainder that caps A.8.8 -> CWE-89 at `partial`.
- CWE-147partialfinds — A.8.8's reach is disclosure-based (vendor advisories, CVE databases, vulnerability scanning of known issues); CWE-147 does surface as CVEs (the observed examples are all published mail-server flaws), so the disclosed share is findable, but most latent instances in first-party parsers and protocol handlers are not reached by A.8.8's programme — that requires source-reading testing (A.8.28/A.8.29).
- CWE-149partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-149 does surface as CVEs (the observed examples include CVE-2004-0956 and CVE-2003-1016), so the disclosed share is non-zero, but the bulk of quoting-syntax injection lives in first-party code that nobody publishes an advisory about, and A.8.8's scanning and inventory reach does not read source. Same shape as A.8.8 -> CWE-89: a minority of instances found, the remainder bounded by what never gets disclosed.
- CWE-15partialfinds — A.8.8's reach is disclosure-based (vendor advisories, component inventory) plus penetration testing; it finds CWE-15 where the weakness lives in a third-party component with a published CVE or surfaces at runtime under a pen test, but the bulk of CWE-15 instances are first-party implementation flaws that A.8.8's programme does not read in source.
- CWE-150partialfinds — A.8.8's reach is DISCLOSURE on third-party components, and CWE-150 is primarily a first-party code defect (the application fails to neutralize escape sequences before passing them downstream); A.8.8 finds it only where it surfaces as a published advisory in a third-party component, which is a minority of instances, mirroring the A.8.8 -> CWE-89 anchor.
- CWE-151partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities that surface as published advisories, primarily in third-party components. CWE-151 does have CVE examples (CVE-2002-0001, CVE-2004-0162, etc.), so the class is not invisible to disclosure-based scanning, but most instances are implementation-phase flaws in first-party code that A.8.8's component-inventory reach does not inspect, leaving a nameable remainder outside its view.
- CWE-156partialfinds — A.8.8's reach is disclosure-based: it finds vulnerabilities that have been published as advisories in third-party components. CWE-156 is primarily a first-party implementation defect, so A.8.8 only reaches the minority of instances that surface as CVEs in third-party components (the observed examples from 2002-2004 show it does occasionally disclose), with the bulk of first-party whitespace-handling defects invisible to this control.
- CWE-158partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw, and CWE-158 commonly surfaces as CVEs (many examples cited), so the disclosed share is non-trivial; but most null-byte injection defects live in first-party code that A.8.8's scanning and advisory-tracking programme does not reach, leaving a nameable remainder.
- CWE-160partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw in third-party components. CWE-160 is an input-handling defect that mostly lives in first-party code, which A.8.8 does not reach via its advisory-based mechanism; only the minority of instances that surface as CVEs in tracked third-party components are found, mirroring the A.8.8 -> CWE-89 anchor.
- CWE-161partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw, and CWE-161 is a first-party input-handling defect that rarely surfaces as a CVE; the disclosed share is a minority, capping the rung at `partial` per the same logic as A.8.8 -> CWE-89.
- CWE-162partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-162 is primarily a first-party implementation defect (custom parsers, URL/file handlers), and the disclosed share of any weakness class is a minority; the observed CVEs (CVE-2004-0847, CVE-2002-1451, CVE-2001-0446) are all in third-party frameworks/servers, so A.8.8 finds that minority but not the bulk of latent instances.
- CWE-163partialfinds — A.8.8's reach is DISCLOSURE-based, and CWE-163 does surface as CVEs (CVE-2002-1078, CVE-2004-0281), so vulnerability scanning and advisory tracking find the disclosed minority of instances; most instances of improper trailing-special-element handling in deployed code are not published and remain outside A.8.8's view.
- CWE-167partialfinds — A.8.8's reach is DISCLOSURE — it surfaces vulnerabilities that have been published as advisories or CVEs. CWE-167 (improper handling of additional special elements, e.g. extra '<' before SCRIPT tag) does surface as CVEs in the observed examples, so the disclosed minority is reachable; the bulk of first-party input-handling defects of this class are not visible to a disclosure-based programme.
- CWE-170partialfinds — A.8.8's reach is disclosure-based (vendor advisories, vulnerability scanning, third-party library tracking), so it finds CWE-170 only where the null-termination defect surfaces as a published CVE in a third-party component — a minority of instances, since most CWE-170 lives in first-party source code that A.8.8 does not read.
- CWE-173partialfinds — A.8.8's reach is disclosure-based (published advisories, component inventory), and CWE-173 is primarily a first-party input-handling defect that rarely surfaces as a CVE; the clause finds it only where it is already disclosed in a third-party component, which is a minority of latent instances.
- CWE-174partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-174 does surface as CVEs (six observed examples), so the class is not invisible to disclosure-based scanning, but the disclosed share is a minority of all latent double-decoding defects, most of which live in first-party code and never receive a CVE.
- CWE-176partialfinds — A.8.8's reach is DISCLOSURE — it finds this weakness only where it has been published as a CVE in a third-party component (the observed examples show CVEs do exist for this class), but most Unicode handling defects live in first-party code that no advisory names, so the disclosed share is a minority.
- CWE-177partialfinds — A.8.8's reach is primarily disclosure-based (vendor advisories, vulnerability scanning, third-party library tracking), and CWE-177 is an implementation defect in first-party URL handling logic that mostly never receives a CVE; the penetration-testing component (item e) adds some runtime reach for in-scope systems, but the bulk of latent instances in custom code are outside the clause's view, matching the same disclosure-bound reasoning that graded A.8.8 finds CWE-89 = partial.
- CWE-178partialfinds — A.8.8's reach is disclosure-based: it finds CWE-178 only where the case-sensitivity defect has been published as a CVE/advisory in a third-party component or widely-known product. Most CWE-178 instances are first-party implementation logic (string comparisons, file-name handling, filter checks) that never surface in vulnerability databases, so the disclosed share is a minority.
- CWE-179partialfinds — A.8.8's reach is DISCLOSURE — vulnerability scanning, published advisories, and third-party component tracking. CWE-179 is a first-party implementation defect (validation order vs. canonicalization) that surfaces as CVEs in some cases (the observed examples are all CVEs) but the bulk of latent instances in deployed custom code are not published advisories, so the disclosed share is a minority.
- CWE-180partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-180 does surface as CVEs in third-party products (the observed examples are all CVEs), so the disclosed share is non-zero, but the bulk of CWE-180 instances live in first-party validation/canonicalization logic that A.8.8's scanning-and-advisory programme does not read — that is A.8.29's reach. A minority of instances found, same shape as A.8.8 -> CWE-89.
- CWE-182partialfinds — A.8.8's reach is disclosure-based — it finds vulnerabilities that have been published as advisories. CWE-182 does surface as CVEs (the observed examples are all CVE entries), so the disclosed share is non-trivial, but the bulk of CWE-182 instances are latent defects in custom filtering/normalization logic that never get published as advisories, leaving a nameable remainder outside A.8.8's view.
- CWE-183partialfinds — A.8.8's disclosure-based vulnerability management finds CWE-183 only where an unsafe allowlist is published as an advisory/CVE for a component in the operator's inventory, so it surfaces a minority of instances while unpublished custom-code allowlist flaws remain unseen.
- CWE-184partialfinds — A.8.8 surfaces published vulnerabilities in the operator's third-party components, so it can find CWE-184 instances that carry a CVE, but most incomplete-denylist flaws in first-party code are not disclosed and fall outside this disclosure-based reach.
- CWE-187partialfinds — A.8.8's reach is DISCLOSURE — published advisories and component inventory — and CWE-187 is a first-party implementation defect (strncmp with attacker-controlled length, substring auth checks) that lives in code the organization wrote, not in a third-party component with a CVE. The clause discovers this weakness only where it has already been published as an advisory, which is a minority of latent instances; the bulk is reached by source-reading controls (A.8.28/A.8.29), not by A.8.8.
- CWE-190partialfinds — A.8.8's reach is DISCLOSURE — it identifies vulnerabilities through vendor advisories, vulnerability scanning, and third-party component tracking. Integer overflows in third-party components with published CVEs are found (the observed examples include several), but the bulk of CWE-190 instances in first-party/custom code are not what A.8.8 reaches; those require source-reading testing (A.8.28/A.8.29). Same logic as the A.8.8 finds CWE-89 = partial anchor.
- CWE-191partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. Integer underflow is primarily a first-party code defect discoverable by static analysis or code review, which A.8.8 does not reach. A.8.8 finds this weakness only where it has been published as a CVE in a third-party component, which is a minority of latent instances.
- CWE-192partialfinds — A.8.8's reach is DISCLOSURE (vulnerability scanning against CVE databases, third-party component tracking) with limited RUNTIME through penetration testing. Integer coercion errors are implementation bugs primarily found by static analysis of source code, which is A.8.29's reach, not A.8.8's. A.8.8 discovers CWE-192 only where it surfaces as a published CVE in a third-party component (e.g., CVE-2022-2639) or manifests as an observable crash/exploitable condition during a penetration test — a minority of latent instances.
- CWE-195partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-195 is an implementation-phase code defect in first-party source, discoverable by static analysis or code review (A.8.28/A.8.29 territory), not by vulnerability scanning or patch management. A.8.8 finds it only where it surfaces as a CVE in a third-party component, which is a minority of instances — the same logic that graded A.8.8 finds CWE-89 = partial.
- CWE-196partialfinds — A.8.8's disclosure reach finds only vendor-published vulnerable third-party components, while most unsigned-to-signed conversion errors live in first-party code that no advisory covers, so only a minority of latent instances are discovered.
- CWE-201partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-201 does commonly surface as CVEs (the observed examples show multiple disclosed cases), so vulnerability scanning and the disclosed-vulnerability portion of the programme find that share. The remainder is the majority: CWE-201 is primarily a first-party code defect where developers include sensitive information in responses, and A.8.8's scanning and third-party library tracking do not see custom code patterns of information leakage.
- CWE-206partialfinds — A.8.8's reach is DISCLOSURE — vendor advisories, CVE-published flaws, third-party component tracking. CWE-206 is primarily a first-party architecture/implementation weakness (behavioral side channels in login flows, error responses, etc.) that rarely surfaces as a published advisory. The control finds the disclosed minority of instances — those that have been published as CVEs or vendor bulletins — but the bulk of CWE-206 in deployed first-party code is outside its disclosure-based reach, mirroring the A.8.8 -> CWE-89 anchor.
- CWE-208partialfinds — A.8.8's reach is DISCLOSURE — it finds CWE-208 only where a vendor has published a CVE for a timing discrepancy in software present in the asset inventory and a scanner flags it. Several CWE-208 instances do surface as CVEs (CVE-2019-10071, CVE-2014-0984, CVE-2003-0078, etc.), so the class commonly discloses, but most timing discrepancies in custom or unexamined code are never published, capping the grade at `partial` under the disclosure-reach ceiling.
- CWE-212partialfinds — A.8.8's disclosure reach finds CWE-212 instances that have been published as CVEs in third-party or vendor components, but most improper-removal flaws in custom code never surface through advisories, so only a minority of latent instances are discovered.
- CWE-213partialfinds — A.8.8's vulnerability management surfaces disclosed instances where CWE-213 exposures appear as CVEs such as phpinfo() or Telnet environment disclosure, but most incompatible-policy exposures in custom applications are not vendor-published vulnerabilities, so it finds only a minority.
- CWE-214partialfinds — A.8.8's reach is DISCLOSURE — it finds CWE-214 only where the weakness has been published as a CVE in a third-party component (the observed examples are all CVE-published). Most CWE-214 instances are first-party code defects where developers pass credentials on command lines or in environment variables, which A.8.8's scanning and inventory-based programme does not reach; that is A.8.29's territory. A minority of instances, by the same logic as A.8.8 -> CWE-89 = partial.
- CWE-215partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, vendor advisories, CVE awareness), and CWE-215 does surface as CVEs (CVE-2004-2268, CVE-2002-0918, CVE-2003-1078), so the disclosed minority is found; the bulk of first-party instances — debug code with sensitive info that never receives a CVE — is outside this reach.
- CWE-219partialfinds — A.8.8's disclosure reach surfaces CWE-219 instances that are published as CVEs (matching the observed examples), but most sensitive files placed under a web root are bespoke deployment mistakes never disclosed, so it finds only a minority.
- CWE-22partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. Path traversal commonly surfaces as CVEs in third-party components (many examples in the CWE-22 record), so A.8.8 finds that disclosed share; first-party path-traversal defects in the organization's own code are invisible to vulnerability scanning and management, which is the same remainder that caps A.8.8 -> CWE-89 at `partial`.
- CWE-229partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw, and CWE-229 (improper handling of parameter/argument counts and undefined values) does surface in CVEs for third-party components, so the control finds a minority of latent instances through published advisories and scanning against them.
- CWE-23partialfinds — A.8.8's reach is DISCLOSURE: it sees only instances that carry a vendor-published flaw. CWE-23 is an implementation defect that commonly surfaces as CVEs in third-party components (many observed examples), so A.8.8 finds that disclosed minority; the bulk of path-traversal instances in custom first-party code are never published as advisories and remain outside the clause's reach.
- CWE-230partialfinds — A.8.8's reach is DISCLOSURE — it sees only third-party components with vendor-published flaws. CWE-230 does surface as CVEs (multiple observed examples), so the disclosed minority is reachable, but most CWE-230 instances live in first-party code that A.8.8's scanning and patch-management mechanisms do not inspect.
- CWE-232partialfinds — A.8.8's reach is DISCLOSURE — it identifies vulnerabilities through vendor advisories, scanning tools, and third-party library tracking. CWE-232 is primarily a first-party implementation defect (undefined value handling in the organization's own code), and most instances carry no published advisory. The disclosed share is a minority, capped at `partial` by the disclosure reach, though some instances do surface as CVEs (e.g., CVE-2000-1003) and scanning tools can detect some runtime undefined-value crashes.
- CWE-234partialfinds — A.8.8's reach is DISCLOSURE — published advisories and component inventory. CWE-234 is a first-party implementation defect (missing-parameter handling in function calls); it surfaces in A.8.8's view only where it appears in a third-party component with a published advisory, which is a minority of instances, mirroring the A.8.8 -> CWE-89 anchor.
- CWE-236partialfinds — A.8.8's reach is disclosure-based (vendor advisories, CVE feeds, scanning against published signatures), and CWE-236 does surface as CVEs (per the observed examples), so the class is not invisible to the clause — but the disclosed share of any implementation-level weakness is a minority of latent instances, capping the rung at `partial`.
- CWE-239partialfinds — A.8.8's reach is DISCLOSURE-based (vulnerability scanning against known advisories, third-party component tracking); CWE-239 does surface as CVEs (the four observed examples), so disclosed instances are found, but the bulk of incomplete-element handling flaws in deployed code are not published and A.8.8's scanning does not reach first-party implementation testing, leaving a nameable remainder.
- CWE-24partialfinds — A.8.8's reach is DISCLOSURE — vulnerability scanning, patch management, and tracking third-party libraries all see only what carries a published advisory. Path traversal commonly surfaces as CVEs (it is a well-known class), so the disclosed share is non-trivial, but most path traversal in custom first-party code never gets a CVE and is outside A.8.8's view. The penetration-testing element in (e) is part of the programme but does not change the control's primary disclosure-based reach, and the guidance is clear that an actor naming one reach is not credited with others.
- CWE-241partialfinds — A.8.8's reach is DISCLOSURE — it surfaces vulnerabilities in third-party components that carry a published advisory. CWE-241 does appear in CVEs (the observed examples include FTP and anti-virus products), so the disclosed share is findable, but it is a minority of the class — most type-handling defects live in first-party code that A.8.8's disclosure-based programme does not read, and the weakness is flagged as under-studied, so the CVE population is thin.
- CWE-242partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, vendor advisories, third-party component tracking), and CWE-242 does surface in CVEs for third-party products (e.g., CVE-2007-4004), so a nameable minority of instances are found; the majority — first-party code using gets(), strcpy(), etc. — is implementation-phase source code that A.8.8 does not read, capping the rung at `partial`.
- CWE-25partialfinds — A.8.8's reach is DISCLOSURE — it sees only path-traversal instances that carry a vendor-published advisory/CVE, which is a minority of all latent instances since most path traversal lives in first-party code that nobody publishes an advisory about; the class commonly surfaces as CVEs (e.g., CVE-2022-20775), so the disclosure-based share is a real but bounded minority, matching the A.8.8 -> CWE-89 anchor at the same rung.
- CWE-250partialfinds — A.8.8's reach is DISCLOSURE — vendor advisories, vulnerability scanning, and penetration testing. CWE-250 is a design/architecture weakness in first-party code about least privilege, primarily discoverable by source review and architectural analysis (which A.8.8 does not reach). The minority of instances that surface as CVEs or are noticed by penetration testers are found; the bulk of design-level unnecessary-privilege decisions are not.
- CWE-252partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw — and CWE-252 is a first-party code defect that surfaces as CVEs only when it appears in a third-party component; the disclosed share is a minority, capping the rung at `partial`.
- CWE-253partialfinds — A.8.8's reach is DISCLOSURE — vendor advisories and CVE-published flaws — and CWE-253 is primarily a first-party code defect (return-value handling) discovered by static analysis or code review, not by scanning deployed systems against advisories. A.8.8 finds it only where it has been published as a CVE (e.g., CVE-2023-49286), which is a minority of instances; the bulk lives in first-party code that A.8.8's disclosure-based programme does not see.
- CWE-256partialfinds — A.8.8's reach is DISCLOSURE — it sees vulnerabilities that have been published as advisories. CWE-256 (plaintext password storage) is overwhelmingly a first-party code defect (config files, properties files, registry entries written by the developer's own application), so the disclosed share is a minority; A.8.8 finds it where it appears in third-party components with published CVEs (e.g., CVE-2022-30275) but not in the bulk of custom code.
- CWE-259partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw — and hard-coded passwords do commonly surface as CVEs (CVE-2022-29964, CVE-2021-37555, CVE-2021-35033), so the disclosed share is a real minority but not negligible; the bulk of hard-coded passwords in proprietary first-party code never publishes an advisory and is outside A.8.8's view.
- CWE-26partialfinds — A.8.8's reach is DISCLOSURE — it sees only path-traversal instances that carry a vendor-published flaw (CVE), and most path traversal lives in first-party code that never gets an advisory, mirroring the A.8.8 -> CWE-89 anchor where the disclosed share is a minority.
- CWE-266partialfinds — A.8.8's disclosure reach surfaces incorrect privilege assignment only where it is a published vulnerability in inventoried third-party components, so it finds a minority of latent instances and misses the bulk in first-party code.
- CWE-267partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances carrying a vendor-published flaw. CWE-267 does surface as CVEs (the observed examples show this), so a minority of instances are found through published advisories and scanning, but the bulk of the class lives in custom privilege/role definitions that never receive a CVE assignment.
- CWE-268partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-268 does sometimes surface as CVEs (the observed examples list four), so A.8.8's vulnerability scanning and advisory monitoring find that minority of disclosed instances, but privilege chaining is fundamentally a design/architecture weakness whose latent instances are mostly not published and thus outside this control's reach.
- CWE-27partialfinds — A.8.8's reach is disclosure-based (vendor-published advisories and component inventory), and path traversal commonly surfaces as CVEs in third-party software, so A.8.8 finds the disclosed share; however, most CWE-27 instances are first-party code defects in custom applications that never appear in published advisories, leaving a nameable remainder outside the control's reach.
- CWE-270partialfinds — A.8.8's reach is disclosure-based: it finds CWE-270 only where the flaw has been published as a CVE/advisory in a third-party component present in the inventory. Most CWE-270 instances are design/implementation defects in first-party code that nobody has published an advisory about, so the control surfaces a minority of latent instances.
- CWE-273partialfinds — A.8.8's reach is disclosure-based (vendor advisories, scanning, pentest), and CWE-273 is a first-party code logic error about checking return values from privilege-drop calls; A.8.8 finds it only where it surfaces as a published CVE (the observed examples exist but are rare), while most instances live in first-party code that no advisory covers and that penetration testing rarely reaches because the missing check is internal.
- CWE-276partialfinds — A.8.8's reach is DISCLOSURE — vulnerability scanning, CVE tracking, and penetration testing against known issues. CWE-276 (incorrect default permissions) does surface as CVEs (multiple observed examples) and is detectable by file-permission checks in vulnerability scanners, so A.8.8 finds a minority of instances; the remainder is custom installations and configurations that never receive a published advisory.
- CWE-28partialfinds — A.8.8's reach is disclosure — it sees only instances that carry a vendor-published flaw — and path traversal in first-party code is rarely published as a CVE; the class does commonly surface as CVEs (CVE-2002-0661, -0946, -1042, -1209, -1178), so the disclosed share is a minority but real, capping the rung at `partial`.
- CWE-280partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances carrying a vendor-published flaw. CWE-280 is a code-level implementation defect that is described as under-studied and rarely surfaces as CVEs (researchers focus on excess permissions rather than insufficient ones), so the disclosed share is small but non-zero (the observed examples CVE-2003-0501 and CVE-2004-0148 are in scope). A.8.8 finds that minority; most instances live in code no advisory was ever published about.
- CWE-281partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, vendor advisories, CVE-driven detection), and CWE-281 is primarily a first-party implementation defect in how products handle permissions during copy/restore/share operations; the disclosed share (the CVE examples cited) is a minority of latent instances, so A.8.8 finds that minority and not the bulk.
- CWE-284partialfinds — Vulnerability scans and penetration tests routinely detect missing or misconfigured access-control mechanisms, prompting timely remediation.
- CWE-288partialfinds — A.8.8's reach is disclosure-based (vendor advisories, vulnerability scanning, CVE feeds), and CWE-288 commonly surfaces as CVEs (multiple observed examples carry CVE IDs), so the disclosed share is found; the remainder is first-party design flaws in alternate paths/channels that have not been publicly disclosed and are not surfaced by A.8.8's programme.
- CWE-289partialfinds — A.8.8's reach is disclosure-based vulnerability scanning and management; CWE-289 does surface as CVEs (e.g., CVE-2003-0317, CVE-2004-0847), so the disclosed share is found, but most CWE-289 instances are first-party design/implementation flaws in authentication logic that never receive a published advisory and are outside A.8.8's reach.
- CWE-29partialfinds — A.8.8's reach is disclosure-based: it identifies vulnerabilities through vendor advisories, scanning tools, and third-party library tracking. CWE-29 instances that surface as published CVEs in third-party components are found, but the bulk of path traversal flaws live in first-party code that A.8.8 does not read, mirroring the A.8.8 -> CWE-89 anchor.
- CWE-290partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities that have been published as advisories or CVEs. CWE-290 does surface as CVEs (e.g., CVE-2022-30319, CVE-2009-1048), so the disclosed share is non-trivial, but the bulk of authentication-bypass-by-spoofing instances live in custom authentication code that no advisory has been published about, and A.8.8's scanning and tracking mechanisms do not read first-party source.
- CWE-291partialfinds — A.8.8's reach is DISCLOSURE, and CWE-291 does surface as CVEs (e.g., CVE-2022-30319), so vulnerability scanning and published-advisory tracking find a minority of instances; most reliance-on-IP-for-authentication design choices are never disclosed and remain invisible to this control.
- CWE-294partialfinds — A.8.8's reach is DISCLOSURE-based, and CWE-294 does surface as CVEs (observed examples include CVE-2005-3435 and CVE-2007-4961), so vulnerability scanning, advisory tracking, and external reports will surface some instances; the disclosed share of any weakness class is a minority, capping the rung at `partial`.
- CWE-295partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-295 does surface as CVEs (Apple goto fail, Go framework, router firmware, etc.), so the disclosed share is found, but the bulk of certificate-validation defects live in custom first-party code with no published advisory, which is outside A.8.8's reach and belongs to A.8.29.
- CWE-296partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-296 does surface as CVEs (OpenSSL EVP_VerifyFinal bypasses, TLS validation defects), so vulnerability scanning and advisory tracking will find the disclosed share in third-party components. The remainder — first-party certificate validation code, which is where the bulk of this weakness class lives — is outside A.8.8's reach, capping the rung at `partial`.
- CWE-297partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities through published advisories and scanning for known flaws. CWE-297 does commonly surface as CVEs (multiple observed examples), so A.8.8 discovers that disclosed minority; the majority of certificate hostname-validation defects in deployed first-party code are never published and remain outside the clause's reach.
- CWE-298partialfinds — A.8.8's disclosure reach finds CWE-298 where it surfaces as a published CVE in a third-party component in the inventory (the observed examples show CVEs do get assigned), but the bulk of certificate-expiration-validation defects live in first-party code and in components without published advisories, which A.8.8's scanning and inventory-based programme does not reach.
- CWE-299partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-299 does surface as CVEs (multiple observed examples), so the disclosed share is non-trivial, but it remains a minority of all instances: most certificate-revocation-check failures live in custom code that never receives an advisory, and A.8.8 has no source-reading or runtime reach to find them.
- CWE-30partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw via vulnerability scanning and advisory monitoring. CWE-30 is an implementation defect in first-party code (path-handling logic), and the vast majority of path traversal instances in deployed code are not disclosed CVEs but live in custom applications. A.8.8 finds the minority that surface as published third-party component vulnerabilities (CVE-2002-1987-style disclosures), but does not reach first-party code where most of this weakness class lives.
- CWE-301partialfinds — A.8.8's reach is DISCLOSURE — it identifies vulnerabilities through vendor advisories, CVE databases, and scanning for known flaws in third-party components. CWE-301 does surface as CVEs (CVE-2024-11022, CVE-2005-3435), so the disclosed minority is findable. But reflection attacks in custom/first-party authentication protocols — the bulk of latent instances — are design-level weaknesses that never get CVE assignments and are outside A.8.8's disclosure-based reach.
- CWE-302partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, published advisories, component inventory), and CWE-302 is a first-party authentication design/implementation flaw; only the minority of instances that surface as published CVEs/advisories are found, mirroring the A.8.8 -> CWE-89 anchor where first-party code defects are mostly outside the disclosure reach.
- CWE-303partialfinds — A.8.8's reach is DISCLOSURE (vendor-published flaws in third-party components) plus the penetration-testing route it names; CWE-303 is primarily a first-party implementation defect whose high-rated detection methods (code review, static analysis) belong to A.8.28/A.8.29, not A.8.8. A minority of instances are found: those in third-party components carrying a published CVE, plus a further slice surfaced by penetration testing where the authentication bypass is observable from outside.
- CWE-304partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities that carry a vendor-published flaw, primarily in third-party components. CWE-304 (missing critical step in authentication) does surface as CVEs (e.g., CVE-2004-2163, CVE-2005-3327), so the disclosed share is findable through A.8.8's vulnerability scanning and third-party library tracking. However, most CWE-304 instances are first-party authentication implementation flaws that never receive a public advisory, leaving a nameable remainder outside the control's reach.
- CWE-305partialfinds — A.8.8's reach is disclosure — it sees vulnerabilities that have been published as CVEs/advisories, primarily in third-party components. CWE-305 is predominantly a first-party implementation flaw (authentication comparison logic, array initialization affecting password state), and A.8.8 does not reach first-party source code — that is A.8.29's territory. The disclosed third-party share of this class is a minority, capping the grade at partial.
- CWE-306partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities that have been published as advisories. CWE-306 does commonly surface as CVEs (numerous examples in the observed examples section: CVE-2024-11680, CVE-2022-31260, CVE-2022-29951, etc.), so A.8.8 finds the disclosed minority of instances. However, most CWE-306 instances are design-level omissions that never receive CVE numbers — internal applications, undocumented interfaces, or 'by design' decisions that no external researcher reports — so the disclosed share is a minority of latent instances, capped at `partial` by the disclosure-reach rule.
- CWE-307partialfinds — A.8.8's reach is DISCLOSURE — it finds CWE-307 instances only where they carry a vendor-published advisory. CWE-307 commonly surfaces as CVEs (multiple examples in the entry), so the disclosed share is real, but the majority of latent instances are first-party authentication designs that lack rate limiting and are never published as advisories; A.8.8's scanning and inventory reach does not see those.
- CWE-308partialfinds — A.8.8's disclosure reach finds only vendor-published instances of single-factor authentication in tracked components, leaving first-party and unadvertised implementations undiscovered.
- CWE-31partialfinds — A.8.8's reach is DISCLOSURE; it finds path traversal where it is already a published vulnerability in a third-party component (CVE-2002-0160 being a textbook example), but most CWE-31 instances live in first-party code that no advisory was ever published about, so the disclosed share is a minority.
- CWE-312partialfinds — A.8.8's reach is DISCLOSURE: it surfaces cleartext-storage instances only when they appear as published CVEs in third-party components, which is a minority of the class — the bulk of CWE-312 is a first-party architecture/design omission (developer chose not to encrypt) that never surfaces as a vendor advisory and is outside A.8.8's reach.
- CWE-313partialfinds — A.8.8's disclosure-based reach finds CWE-313 only where it has been published as a CVE in a third-party component (the observed examples include several), but the bulk of cleartext-storage instances are first-party design choices in the organization's own code — credentials in config files, properties files, log files — that never receive CVE assignments and so are outside A.8.8's scanning and advisory-tracking scope.
- CWE-315partialfinds — A.8.8's reach is DISCLOSURE — it sees instances that carry a vendor-published flaw or surface to penetration testing. CWE-315 is a first-party design/implementation defect (storing sensitive data in cleartext in a cookie) that rarely appears as a published advisory; most instances live in custom code with no CVE. Penetration testing can find some deployed instances, but the bulk of latent instances are not on A.8.8's disclosure path, mirroring the A.8.8 -> CWE-89 anchor.
- CWE-316partialfinds — A.8.8's disclosure reach finds only instances with published CVEs or vendor vulnerability reports, which surfaces some known cleartext-in-memory flaws but misses the majority of undisclosed custom-code instances.
- CWE-319partialfinds — A.8.8's disclosure reach surfaces cleartext transmission where it appears as a published CVE/advisory in a third-party component (the OT/ICS and network-device examples in CWE-319's observed list), and its penetration-testing item can sniff some deployed instances, but the bulk of CWE-319 — first-party code that chose HTTP over HTTPS, credentials sent in email, internal debug channels, JTAG interfaces — is never published as an advisory and is outside A.8.8's source-reading reach, leaving a majority undiscovered.
- CWE-32partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities that have been published as advisories/CVEs. CWE-32 is primarily a first-party implementation defect in custom code, and the disclosed share of path-traversal instances (those in third-party components with published CVEs) is a minority; the remainder is custom code that never receives a CVE assignment.
- CWE-321partialfinds — A.8.8's reach is DISCLOSURE: it finds hard-coded keys only where a vendor has published a CVE/advisory for a third-party component in the operator's inventory. CWE-321 does surface as CVEs (multiple observed examples), so the disclosed third-party share is real, but it is a minority of all instances — first-party code is outside A.8.8's reach (that is A.8.28/A.8.29), and many hard-coded keys remain unpublished. `full` is out of reach on disclosure-only scanning.
- CWE-322partialfinds — A.8.8's reach is disclosure (vendor-published flaws), and CWE-322 does commonly surface as CVEs (e.g., TLS/SSL implementations with unauthenticated key exchange), so the disclosed share is found; the remainder is unauthenticated key exchange in first-party or custom code that never receives a CVE, which A.8.8's disclosure-based programme does not see.
- CWE-323partialfinds — A.8.8's reach is DISCLOSURE — it surfaces only instances that carry a vendor-published flaw. CWE-323 does surface as CVEs (CVE-2024-36289, CVE-2024-21530), so vulnerability scanning and management will find those disclosed third-party instances, but the bulk of nonce-reuse defects live in first-party cryptographic code that no advisory names, leaving a nameable remainder outside the clause's reach.
- CWE-324partialfinds — A.8.8 can surface the disclosed or externally visible instances such as expired certificates through vulnerability awareness and scanning, but it misses the larger share of embedded, internal, or undisclosed expired-key/password defects, so it finds only a minority.
- CWE-325partialfinds — A.8.8's reach is DISCLOSURE — it finds only instances that carry a vendor-published flaw. CWE-325 does surface as CVEs (e.g., CVE-2001-1585), so the disclosed share is non-zero, but the bulk of missing-crypto-step instances are in first-party code that never receives a CVE, which A.8.8's scanning and advisory-monitoring programme does not reach.
- CWE-328partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances carrying a vendor-published flaw. Weak hash usage in third-party components with published CVEs (and there are many, per the observed examples) is discoverable, but the majority of latent weak-hash instances live in first-party code, which A.8.8 does not read; that requires source analysis (A.8.29's reach). Same shape as the A.8.8 -> CWE-89 anchor at `partial`.
- CWE-329partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances carrying a vendor-published flaw. CWE-329 does surface as CVEs (CVE-2020-5408, CVE-2017-11133, BEAST, etc.), so the disclosed minority is reachable via scanning and tracking, but the bulk of instances are first-party implementation choices (predictable or null IVs in custom code) that never appear in any advisory and are outside A.8.8's view.
- CWE-33partialfinds — A.8.8's reach is DISCLOSURE — it finds CWE-33 only where the weakness surfaces as a published advisory in a third-party component the inventory tracks. Most CWE-33 instances are first-party implementation defects in path-handling code, which A.8.8 does not read; the disclosed share is a minority, matching the same logic that graded A.8.8 -> CWE-89 at `partial`.
- CWE-331partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, tracking third-party libraries, receiving reports), and CWE-331 does surface as CVEs (e.g., CVE-2001-0950, CVE-2008-2108), so the disclosed share of instances in third-party components is found; the bulk of insufficient-entropy weaknesses live in first-party code where a weak PRNG or predictable seed was chosen, and A.8.8 does not see those.
- CWE-332partialfinds — A.8.8's reach is disclosure-only: it finds CWE-332 only where a vendor publishes an advisory or an external report surfaces it (e.g., CVE-2019-1715 in a security product's DRBG). Most PRNG entropy flaws are first-party implementation choices — weak seeding, fallback to non-crypto PRNGs — that never receive a CVE, so the disclosed share is a minority.
- CWE-334partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-334 is a design/implementation weakness in first-party code (session ID length, predictable random number generation) that is primarily discovered through code review or static analysis, not through vulnerability scanning of disclosed advisories. A.8.8 finds CWE-334 only where it surfaces as a CVE in a third-party component, which is a minority of instances; the bulk of CWE-334 in first-party code is outside its reach.
- CWE-335partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities through published advisories, vendor notifications, and scanning against known vulnerability databases. CWE-335 does surface as CVEs (four observed examples), so A.8.8 finds that minority share. The majority of PRNG seed misuse lives in first-party/custom code that never receives a published advisory, and A.8.8's disclosure-based reach does not see it; penetration testing may catch some externally observable instances (predictable session IDs, tokens) but not the bulk.
- CWE-337partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-337 is primarily a first-party code defect (developers seeding PRNGs with process ID or system time), and A.8.8 only finds it where a third-party component ships with this weakness AND it has been published as a CVE/advisory. The observed examples show it does surface as CVEs (so not `none`), but the disclosed share is a minority of all instances, capping the rung at `partial`.
- CWE-338partialfinds — A.8.8's reach is DISCLOSURE — it finds weak PRNG usage only where a vendor has published a CVE/advisory about it (e.g. CVE-2008-0166 on OpenSSL, CVE-2021-3692 on a PHP framework). The bulk of CWE-338 instances live in first-party code where a developer chose rand()/Math.random() over a CSPRNG, and A.8.8's scanning does not read source — that is A.8.29's reach. The disclosed share is a minority, and the class does surface as CVEs, so the rung is `partial` rather than `none`.
- CWE-339partialfinds — A.8.8's reach is DISCLOSURE — it sees instances that carry a vendor-published flaw. CWE-339 does surface as CVEs (e.g., CVE-2019-10908 on RandomStringUtils/java.util.Random's 48-bit seed), so a minority of instances are caught when the issue appears in a third-party component with a published advisory or in a product whose flaw becomes a CVE; the bulk of small-seed-space defects in first-party code are never disclosed and never found by A.8.8's scanning/penetration programme.
- CWE-34partialfinds — A.8.8's reach is DISCLOSURE — it surfaces path traversal only where it appears as a published vulnerability in a third-party component, which is a minority of instances; most CWE-34 lives in first-party code that no advisory names.
- CWE-342partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-342 commonly surfaces as CVEs (the observed examples are all published advisories on predictable sequence numbers, IDs, and ports), so the disclosed share is non-trivial, but it remains a minority of the class; first-party code with predictable RNG choices is not reached by A.8.8's scanning and advisory-monitoring programme.
- CWE-343partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw, and CWE-343 instances in third-party components with published CVEs (e.g., weak PRNGs in widely-used libraries) are a minority of the class; the bulk of predictable-RNG flaws live in first-party code that A.8.8's mechanism does not read.
- CWE-347partialfinds — A.8.8's reach is DISCLOSURE-based (vendor advisories, vulnerability scanning of known issues), and CWE-347 does surface as CVEs (observed examples include CVE-2002-1796, CVE-2005-2181/2182, CVE-2002-1706), so the disclosed third-party share is found; the majority of CWE-347 instances live in first-party code where developers wrote signature verification incorrectly, which A.8.8's scanning and advisory programme does not reach.
- CWE-349partialfinds — A.8.8's reach is disclosure-based (published advisories, vendor CVEs), and CWE-349 is a first-party implementation logic flaw in data handling; the disclosed share of this class is a minority (the observed CVEs exist but most instances in custom code never surface as advisories), so A.8.8 finds that minority and nothing more.
- CWE-35partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-35 is a first-party code defect (implementation phase), and while path traversal does surface as CVEs (the observed examples cite CVE-2005-2169 and CVE-2005-0202), the bulk of instances live in custom code that never gets a published advisory. A.8.8 finds the disclosed minority, not the bulk.
- CWE-350partialfinds — A.8.8's reach is DISCLOSURE-based vulnerability scanning of deployed software; CWE-350 does surface as CVEs (multiple examples from 2000-2004), so scanning flags disclosed instances in third-party products, but the weakness is fundamentally a first-party design/code defect (Architecture and Design phase) that A.8.8's scanning tools do not read in custom code, leaving the majority of latent instances undiscovered.
- CWE-352partialfinds — A.8.8's reach is published advisories and component inventory; CSRF is overwhelmingly a first-party application design flaw, so A.8.8 only discovers it where it has already been published as a CVE in a third-party component (e.g., a web framework or CMS), which is a minority of latent CSRF instances — the same disclosure-bounded logic that graded A.8.8 -> CWE-89 at `partial`.
- CWE-353partialfinds — A.8.8's reach is DISCLOSURE — it finds this weakness only where it surfaces as a published CVE/advisory in a third-party component (as CVE-2025-32890 demonstrates), which is a minority of instances; first-party protocol implementations lacking integrity checks are outside its disclosure-based view.
- CWE-354partialfinds — A.8.8's reach is disclosure-based (vendor advisories, vulnerability scanning, penetration testing of deployed systems); CWE-354 surfaces as CVEs (e.g., CVE-2024-47573) and can be exercised by penetration tests, so a minority of instances are found, but most checksum-validation defects in first-party code are not disclosed and not visible to A.8.8's programme.
- CWE-358partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities that have been published as advisories/CVEs in deployed components. CWE-358 (improperly implemented security checks for standards) commonly surfaces as CVEs (all observed examples are CVE-assigned), so vulnerability scanning against the asset inventory will catch the disclosed share. That disclosed share is a minority of all latent instances — many CWE-358 flaws live in first-party code or in components where the implementation error has not been published — so the rung is `partial` and not `mostly`.
- CWE-359partialfinds — A.8.8 reaches published/third-party advisories and component inventories, so it finds only the minority of CWE-359 instances that surface as CVEs or vendor disclosures, while most privacy exposures in first-party code or undisclosed design flaws remain outside its view.
- CWE-36partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-36 is an implementation defect in first-party code (path construction without neutralizing absolute path sequences), discovered in practice by static analysis of source or dynamic testing of the running system, neither of which A.8.8 names. Where the defect surfaces as a CVE in a third-party component, A.8.8's scanning and inventory reach finds it; the bulk of latent instances in first-party code are outside its view, matching the A.8.8 -> CWE-89 anchor's reasoning.
- CWE-366partialfinds — A.8.8's reach is DISCLOSURE-based: it finds race conditions only where they are published vulnerabilities in third-party components (e.g., CVE-2022-2621), and most race conditions are implementation defects in custom code that no advisory covers, so the disclosed share is a minority.
- CWE-367partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances carrying a vendor-published flaw. TOCTOU does surface as CVEs (five observed examples in the CWE entry), so the weakness is not invisible to the clause, but the disclosed share is a minority: most CWE-367 instances live in first-party code that never receives a CVE, and A.8.8's scanning/inventory programme has no view of those.
- CWE-369partialfinds — A.8.8's reach is DISCLOSURE — it sees vulnerabilities via vendor advisories and component inventory. CWE-369 does commonly surface as CVEs (CVE-2007-3268, CVE-2007-2723, CVE-2007-2237 are listed observed examples), so the disclosed share is non-trivial, but the bulk of divide-by-zero instances live in first-party code that A.8.8's disclosure-based programme does not reach.
- CWE-37partialfinds — A.8.8's reach is DISCLOSURE — it finds path-traversal instances only where a third-party component carries a published advisory and is in the asset inventory; the class does surface as CVEs (multiple observed examples), so the disclosed share is non-trivial, but most path-traversal defects in deployed code are in first-party custom code that A.8.8 does not read, leaving a majority unfound.
- CWE-378partialfinds — A.8.8's reach is disclosure-based: it finds CWE-378 only where the weakness surfaces as a published CVE in a third-party component (e.g., CVE-2022-24823 in a Java framework). Most CWE-378 instances live in first-party code using tmpfile()/createTempFile() and never receive a CVE, so the disclosed share is a minority.
- CWE-379partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-379 does surface as CVEs (the observed examples include CVE-2022-27818, CVE-2021-41989, CVE-2021-21290), so it is not 'rarely does', but the disclosed share of any weakness class is a minority of latent instances, and most insecure temp-file creation lives in custom code that never gets a CVE assigned.
- CWE-38partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-38 is a code-level defect in first-party implementation; the detection methods CWE rates `High` (static analysis of source, dynamic analysis) are source-reading tests belonging to A.8.29, not A.8.8. A.8.8 finds path traversal only where it has already been published as a CVE in a third-party component, which is a minority of latent instances.
- CWE-384partialfinds — A.8.8's reach is DISCLOSURE — it sees only what vendors publish. Session fixation is primarily a first-party design/implementation flaw in custom session-handling code, which A.8.8 does not reach; it finds the weakness only where it surfaces as a published advisory in a third-party component (e.g., CVE-2022-2820, the Tomcat default case), which is a minority of instances.
- CWE-39partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, published advisories, third-party component tracking) with some runtime coverage via the penetration testing it names; CWE-39 is a first-party implementation defect whose detection methods rated High are source-reading tests belonging to A.8.28/A.8.29, so A.8.8 finds it only where it surfaces as a published advisory or is caught by its scanning/pen-test components — a minority of latent instances.
- CWE-393partialfinds — A.8.8's disclosure/scanning reach catches CWE-393 only where a vulnerable component already has a published CVE or advisory, while most wrong-status-code defects are first-party implementation logic never disclosed, so it finds a minority of latent instances.
- CWE-394partialfinds — A.8.8's reach is disclosure-based: it finds CWE-394 instances where the unchecked-return-value defect has been published as a vendor advisory or CVE in a third-party component, and the observed examples show this class does surface as CVEs. The remainder is first-party code with unchecked return values that never receives a published advisory, which A.8.8's scanning and intake do not reach.
- CWE-40partialfinds — A.8.8's reach is DISCLOSURE-based — it finds this weakness only where it has been published as a CVE/advisory for a specific product, which is a minority of latent instances. CWE-40 is a first-party code defect in UNC path handling, and the detection methods that would find it (static analysis, dynamic testing, code review) belong to A.8.29, not A.8.8. Consistent with the A.8.8 finds CWE-89 = partial anchor for the same reason.
- CWE-401partialfinds — A.8.8's reach is DISCLOSURE — vendor advisories, vulnerability scanning, and third-party library tracking. Memory leaks do surface as CVEs in major components (kernels, widely-deployed libraries), so A.8.8 finds that disclosed share, but the bulk of CWE-401 instances live in first-party application code that never receives a CVE, which is outside the clause's reach.
- CWE-409partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw via vulnerability scanning, CVE tracking, and supplier reporting. CWE-409 does surface as CVEs (XML bombs in web servers, parsing libraries), so the disclosed third-party share is found. But the majority of CWE-409 instances live in first-party code (custom XML parsers, custom decompression handlers) where no advisory exists, and A.8.8 does not read source — that reach belongs to A.8.28/A.8.29. Same logic as A.8.8 finds CWE-89 = partial.
- CWE-41partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-41 commonly surfaces as CVEs (many observed examples listed), so the disclosed share is non-trivial, but it remains a minority of latent instances because most path-equivalence defects live in first-party code that no advisory has been published about.
- CWE-413partialfinds — A.8.8's reach is disclosure-based: it finds vulnerabilities that have been published as advisories. CWE-413 does surface as CVEs (e.g. CVE-2022-20141 in kernel locking), so the disclosed share is non-trivial, but the bulk of improper resource locking defects live in first-party code that never gets an advisory and is invisible to A.8.8's scanning/inventory reach.
- CWE-414partialfinds — A.8.8 can surface this weakness only where it is already a published CVE in a tracked third-party component, which is a minority of latent instances.
- CWE-415partialfinds — A.8.8's reach is DISCLOSURE — it finds double-free instances only where they appear as published advisories in third-party components (multiple CVEs exist for CWE-415), but the majority of double-free bugs in custom first-party code are never published and so are outside this control's view, matching the same disclosure-bound reasoning that graded A.8.8 finds CWE-89 = partial.
- CWE-416partialfinds — A.8.8's reach is DISCLOSURE — it identifies vulnerabilities through published advisories, vendor notifications, and scanning against known vulnerability databases. UAF does commonly surface as CVEs (browsers, OS kernels, mobile platforms), so A.8.8 finds the disclosed share in third-party components, but the bulk of UAF instances live in custom first-party code that never receives a CVE and is invisible to A.8.8's reach — that source-reading work belongs to A.8.28/A.8.29, not here.
- CWE-42partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities through published advisories and component inventory. CWE-42 does surface as CVEs (multiple examples cited), so A.8.8 discovers it in third-party components where disclosed, but the disclosed share is a minority of latent instances — most path-handling code with trailing-dot issues has no published advisory.
- CWE-420partialfinds — A.8.8's reach is DISCLOSURE (third-party by nature), and CWE-420 is fundamentally a first-party architectural omission where the developer failed to protect an alternate channel. The class does surface as CVEs (multiple observed examples), so A.8.8's vulnerability scanning and published-advisory tracking catches a minority of instances; penetration testing in the clause's programme can also discover some alternate channels. But the bulk of latent instances — design-level omissions in first-party code where the alternate path is not externally obvious — are not reached by A.8.8's disclosure-based mechanism, which is the same scope seam that put A.8.8 -> CWE-89 at `partial`.
- CWE-421partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, tracking third-party libraries, receiving reports), and CWE-421 is primarily a first-party architecture/design flaw in custom code; the disclosed share (e.g., CVE-1999-0351, CVE-2003-0230) is a minority of instances, and while the clause's penetration-testing item can surface some race conditions, most latent instances in deployed first-party code are not found by this programme.
- CWE-422partialfinds — A.8.8's disclosure reach finds the minority of CWE-422 instances that surface as published CVEs in third-party products present in the inventory (the listed CVEs from 2002–2004 are examples), but the class is explicitly noted as under-reported and most shatter vulnerabilities live in first-party application code that A.8.8 does not read.
- CWE-425partialfinds — A.8.8's reach is DISCLOSURE — it sees vulnerabilities through published advisories, vendor CVE feeds, and scanning against known-flaw inventories. CWE-425 (forced browsing) does surface as CVEs (multiple examples in the CWE entry), so the disclosed minority is reachable, but the bulk of forced-browsing instances are first-party authorization flaws in custom web applications that never receive a CVE and are outside A.8.8's disclosure-based reach.
- CWE-427partialfinds — A.8.8's reach is DISCLOSURE — it identifies vulnerabilities via published advisories, vendor feeds, and scanning against known-CVE databases. CWE-427 does surface as CVEs (DLL hijacking, dependency confusion, binary planting), so A.8.8 finds the disclosed minority of instances in third-party components and published products, but it does not read source code (that is A.8.28/A.8.29) and cannot find CWE-427 in custom or unpublished code, capping the rung at `partial`.
- CWE-43partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, published advisories, component inventory); CWE-43 is an implementation flaw in path handling, mostly in first-party code that does not surface as CVEs. A.8.8 finds it only where it appears as a published vulnerability in a third-party component — a minority of instances.
- CWE-430partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning against published advisories and component inventory), and CWE-430 is primarily a first-party application/configuration error (wrong handler assignment in routing logic or server config). A minority of instances surface as published CVEs (the observed examples include a handful) and A.8.8's penetration testing guidance (item e) can find some deployed-handler-misrouting cases dynamically, but most CWE-430 instances are first-party code/config defects that require source review or targeted application testing outside A.8.8's reach.
- CWE-431partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw, and CWE-431 (missing exception handler) is primarily a first-party implementation defect that A.8.8's scanning and inventory mechanisms do not inspect at source; the minority of instances that surface as CVEs in third-party components (e.g. CVE-2022-25302) are within reach, but the bulk of missing-handler bugs in custom code are not.
- CWE-437partialfinds — A.8.8's reach is DISCLOSURE — it identifies vulnerabilities through published information resources, scanning tools, and penetration testing based on known patterns. CWE-437 (incomplete endpoint modeling) instances that surface as CVEs (e.g., CVE-2024-55629) or manifest as exploitable behavior during penetration testing are found, but the disclosed share of this design-level weakness class is a minority, and many instances remain latent in proprietary intermediary products without published advisories.
- CWE-44partialfinds — A.8.8's reach is DISCLOSURE, which caps `finds` at `partial`; CWE-44 occasionally surfaces as CVEs (e.g., CVE-2025-24813) so the disclosed share is non-zero, but most instances of this internal-dot path equivalence defect live in custom code that vulnerability scanning never sees.
- CWE-444partialfinds — A.8.8's reach is DISCLOSURE — it finds CWE-444 instances where the weakness has been published as a CVE in a third-party component (proxies, load balancers, web servers), and CWE-444 does commonly surface as CVEs; the remainder is first-party HTTP parsing code and undisclosed third-party instances, which A.8.8's vulnerability-scanning and inventory-based programme does not reach.
- CWE-454partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-454 is primarily a first-party code defect (PHP register_globals, Java system properties, environment variable handling) where the bulk of instances never receive a CVE; the disclosed minority that do (CVE-2000-0959, CVE-2001-0033, CVE-2001-0872, CVE-2001-0084, CVE-2022-43468) is what A.8.8 surfaces, matching the same disclosure-bound `partial` shape as A.8.8 -> CWE-89.
- CWE-457partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, published advisories, third-party inventory); CWE-457 is a first-party code defect whose bulk lives in custom code that never receives a CVE, so only the minority of disclosed instances are surfaced — the same shape as A.8.8 -> CWE-89.
- CWE-46partialfinds — A.8.8's reach is disclosure-based, and CWE-46 is a first-party implementation flaw; the clause finds it only where the weakness surfaces as a published advisory or is caught by its penetration-testing/scan programme, which is a minority of latent instances in deployed code.
- CWE-470partialfinds — A.8.8's reach is DISCLOSURE — it surfaces only vulnerabilities published as advisories in third-party components. Unsafe reflection is a first-party code defect that requires source or runtime analysis to find, and A.8.8 sees only the minority of instances that surface as CVEs in third-party libraries (e.g., CVE-2018-1000613, CVE-2004-2331), not the bulk in first-party code.
- CWE-472partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, vendor advisories, third-party component tracking) plus limited penetration testing. CWE-472 is a first-party web application implementation flaw; A.8.8 finds it where it has been published as a CVE (and there are many) or where a pen test happens to exercise the relevant hidden fields, but the bulk of instances in custom code never surface as advisories and are outside A.8.8's reach.
- CWE-476partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. NULL pointer dereferences do commonly surface as CVEs (many examples in CWE-476's observed examples), so the disclosed share is non-trivial, but it remains a minority of all instances: most CWE-476 flaws live in first-party code that nobody has published an advisory about, and A.8.8's scanning and patching programme does not read source.
- CWE-479partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, vendor advisories, third-party library tracking), and CWE-479 is primarily a first-party implementation defect in signal handler code. A.8.8 finds it only where it surfaces as a published advisory or is detectable by scanning/penetration testing of deployed systems — a minority of latent instances, since most signal handler non-reentrancy bugs are subtle code-level defects discovered through code review or static analysis, not external disclosure.
- CWE-480partialfinds — A.8.8's reach is DISCLOSURE — it finds CWE-480 only where the typo surfaces as a vendor-published advisory in a third-party component. Most CWE-480 instances are programmer typos in first-party code that never receive a CVE, so the disclosed share is a minority, matching the same disclosure-reach logic that graded A.8.8 -> CWE-89 at `partial`.
- CWE-49partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities via published advisories, vendor feeds, and CVE databases. CWE-49 does surface as CVEs (multiple observed examples listed), so the disclosed share is findable through vulnerability scanning (item d) and third-party library tracking (item f). However, the disclosed share of any weakness class is a minority, capping the rung at `partial`.
- CWE-494partialfinds — A.8.8's disclosure-based reach surfaces CWE-494 where it appears as a vendor-published flaw (the observed examples include multiple firmware and software update CVEs), but the bulk of instances live in custom code that never receives a CVE, so the found share is a minority.
- CWE-50partialfinds — A.8.8's reach is DISCLOSURE plus RUNTIME (penetration testing). CWE-50 surfaces as CVEs in third-party components (the observed examples are all published), so the disclosed share is found by vulnerability scanning and library tracking. Penetration testing can also exercise the weakness from outside in deployed applications. The remainder is bounded and nameable: CWE-50 in first-party custom code that carries no published advisory and falls outside penetration-test coverage is never found.
- CWE-502partialfinds — Regular scanning of third-party libraries and timely patching reduce the likelihood that unsafe deserialization vulnerabilities remain active.
- CWE-521partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-521 instances in third-party authentication components with published CVEs (e.g., CVE-2020-4574) are found, but the majority of weak-password-requirement instances are first-party design decisions about the product's own password policy, which never surface as advisories and are outside A.8.8's reach.
- CWE-524partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-524 does surface as CVEs (e.g., CVE-2024-30127 on HTTP Cache-Control), so the disclosed minority is found by vulnerability scanning and threat intelligence; the bulk of cache-misconfiguration instances in custom code are not published and remain outside A.8.8's view.
- CWE-525partialfinds — A.8.8's reach is DISCLOSURE — it finds CWE-525 only where the missing Cache-Control policy surfaces as a published CVE in a third-party product (as in CVE-2024-30127 and CVE-2024-45314), but the bulk of instances are in custom web applications that never receive a CVE and so are outside the clause's view.
- CWE-528partialfinds — A.8.8's disclosure-based vulnerability management can surface core-dump exposures that appear as published advisories or scanner signatures, but most instances are local configuration or file-permission flaws never disclosed, so it finds only a minority.
- CWE-539partialfinds — A.8.8's disclosure-based inventory and vulnerability feeds surface CWE-539 only when a deployed product has a published advisory or CVE flagging sensitive data in persistent cookies, leaving custom and unadvertised instances unfound.
- CWE-540partialfinds — A.8.8's reach is DISCLOSURE — it sees instances that carry a vendor-published flaw or surface through penetration testing. CWE-540 does occasionally surface as CVEs (CVE-2022-25512, CVE-2022-24867, CVE-2007-6197 are observed examples) and pen tests can find exposed source files, but the bulk of CWE-540 instances are first-party code defects (credentials, tokens, comments embedded in the organisation's own source) that never become published advisories, capping the rung at `partial`.
- CWE-548partialfinds — A.8.8's reach is disclosure-based vulnerability management, and directory listings do surface as CVEs (e.g., CVE-2023-37599) and are caught by the penetration testing the clause names in (e), so a share is found; but most CWE-548 instances are first-party web server configuration oversights that carry no advisory and fall outside the disclosed-vulnerability inventory, capping the share at partial.
- CWE-55partialfinds — A.8.8's reach is disclosure: it finds CWE-55 only where the '/./' handling defect is already a published vulnerability in a third-party component (the observed CVEs show it does surface occasionally). Most CWE-55 instances are first-party path-normalization code that no advisory names, so A.8.8's scanning and inventory-based programme never reaches them — a minority share, matching the same disclosure-reach ceiling applied to A.8.8 -> CWE-89.
- CWE-551partialfinds — A.8.8's disclosure reach surfaces this ordering flaw only when it is a published vulnerability in a third-party web server or framework, leaving first-party instances unfound, so it finds a minority.
- CWE-552partialfinds — A.8.8's penetration-testing component (guidance item e) can discover some CWE-552 instances — exposed web roots, publicly readable cloud storage, misconfigured FTP — by probing from outside, but the bulk of the class is configuration misconfigurations (cloud storage ACLs, web server document roots, archive packaging) that rarely surface as CVEs and are typically found by configuration-review tooling (A.8.9) rather than vulnerability scanning, so disclosure-based scanning misses most of the class.
- CWE-565partialfinds — A.8.8's disclosure-driven vulnerability management surfaces CWE-565 mainly when it appears in published advisories or flagged third-party components, while most such cookie-validation flaws live in unpublished first-party web code, so only a minority of latent instances are found.
- CWE-57partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities in third-party components that have been published as CVEs/advisories. CWE-57 does surface as CVEs (CVE-2001-1152, CVE-2000-0191, CVE-2005-1366), so disclosed third-party instances are caught, but most path-equivalence weaknesses live in first-party application code, which A.8.8's disclosure-based programme does not reach.
- CWE-58partialfinds — A.8.8's reach is DISCLOSURE — it finds instances only where a vendor-published CVE exists for the third-party component carrying the flaw. CWE-58 does surface as CVEs (CVE-1999-0012, CVE-2001-0795, CVE-2005-0471), so disclosed instances are reachable, but the bulk of CWE-58 instances live in first-party protection mechanisms that never receive a CVE, leaving a nameable remainder outside the clause's view.
- CWE-588partialfinds — A.8.8's reach is disclosure-based (vendor advisories, component inventory); CWE-588 is primarily a first-party C implementation defect that A.8.8 never reads, so it finds only the minority of instances that surface as published advisories in third-party components (e.g., CVE-2021-3510), with most latent instances in custom code outside its view.
- CWE-59partialfinds — A.8.8's reach is DISCLOSURE — it surfaces link-following flaws only where they appear as published advisories in third-party components in the inventory. CWE-59 does surface as CVEs (many observed examples), so the disclosed share is non-trivial, but most link-following instances live in first-party code or in third-party components without a published advisory, which A.8.8 does not reach.
- CWE-590partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-590 is a first-party code defect (free() on a non-heap pointer in custom C/C++ code) that A.8.8's vulnerability scanning and inventory-based programme does not inspect; only the minority of instances that surface as published CVEs in third-party components (e.g., CVE-2023-22291 in a word-processor parser) are reachable, mirroring the A.8.8 -> CWE-89 anchor.
- CWE-598partialfinds — A.8.8's reach is disclosure-based (vendor-published advisories and component inventory), and CWE-598 is primarily a first-party application design/implementation flaw in how requests are constructed; only the minority of instances that surface as CVEs in published advisories are discoverable, while the bulk of latent instances in custom code are outside A.8.8's view.
- CWE-601partialfinds — A.8.8's reach is DISCLOSURE — it identifies vulnerabilities through vendor advisories, vulnerability scanning, and tracking third-party libraries. CWE-601 (Open Redirect) does surface as CVEs (CVE-2005-4206, CVE-2008-2951, CVE-2008-2052, CVE-2020-11053), so the disclosed share exists, but open redirects are predominantly a first-party web application code defect, and A.8.8's scanning reaches only the third-party components in its inventory where a published advisory exists — the same logic that graded A.8.8 finds CWE-89 = partial.
- CWE-606partialfinds — A.8.8's reach is DISCLOSURE-based (vendor advisories, CVE feeds, scanning of deployed components), so it finds CWE-606 only where the weakness surfaces as a published CVE in a third-party component (e.g., CVE-2025-32399 in a Profinet library); the majority of CWE-606 instances are first-party implementation defects invisible to disclosure-based scanning, leaving a nameable remainder outside the control's reach.
- CWE-61partialfinds — A.8.8's reach is DISCLOSURE-based (third-party components with published advisories), and CWE-61 does commonly surface as CVEs (multiple examples listed), so the disclosed share is findable — but most symlink-following bugs are implementation defects in first-party code that never appear in any advisory, capping the rung at `partial`.
- CWE-611partialfinds — REACH: a disclosure-reach control sees only instances that carry a vendor-published flaw, so `finds` is at most `partial` (rule, 2026-10-17).
- CWE-613partialfinds — A.8.8's reach is DISCLOSURE; it finds session-expiration weaknesses where they appear as published advisories in third-party components (the CVE examples above), but most CWE-613 instances live in first-party application code whose session-timeout choices never become CVEs, so the disclosed share is a minority.
- CWE-614partialfinds — A.8.8's reach is DISCLOSURE; CWE-614 is primarily a first-party code defect (missing Secure flag on cookies set in application code), and only a minority of instances surface as vendor advisories — the observed CVEs show the class does get disclosed sometimes, but most first-party cookie-handling code never appears in any advisory, so the disclosed share is a minority.
- CWE-616partialfinds — A.8.8 can surface CWE-616 only through published advisories/CVEs for third-party PHP applications, and that disclosed share is a minority of this implementation-level flaw while most instances in first-party or unadvertised code fall outside its disclosure reach.
- CWE-617partialfinds — A.8.8's reach is DISCLOSURE — it sees only vendor-published flaws, and the disclosed share of any weakness class is a minority, capping `finds` at `partial`. CWE-617 does surface as CVEs (multiple observed examples), so the disclosed portion is findable, but the bulk of latent reachable assertions in deployed code never carries a vendor advisory.
- CWE-618partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, published advisories, third-party inventory), and CWE-618 does surface as CVEs (CVE-2007-1120, CVE-2006-6838, CVE-2007-0321), so the disclosed minority of exposed unsafe ActiveX methods is found; first-party ActiveX code with no published advisory is outside A.8.8's reach.
- CWE-62partialfinds — A.8.8's reach is disclosure-based (vendor advisories, vulnerability scanning) plus penetration testing; CWE-62 is an implementation defect that surfaces in CVEs (multiple examples listed) and can be found by competent penetration testers probing for hard-link attacks, but most instances in first-party code are not visible to disclosure-based scanning and require source-level review outside A.8.8's reach.
- CWE-620partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-620 does surface as CVEs (CVE-2025-4903, CVE-2007-0681, CVE-2000-0944), so the disclosed share is non-trivial, but it remains a minority of all latent instances in deployed custom code, which A.8.8's scanning-and-advisory programme never inspects.
- CWE-621partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-621 is a first-party PHP implementation flaw (extract()/import_request_variables() misuse) that mostly lives in custom application code never assigned a CVE; the disclosed share is a minority, so on disclosure reach `finds` is at most `partial`, and the class does surface as CVEs (CVE-2006-7135, CVE-2006-7079, CVE-2007-0649, CVE-2006-6661, CVE-2006-2828), keeping it above `none`.
- CWE-622partialfinds — A.8.8's reach is disclosure-based: it sees CWE-622 instances only where they have been publicly reported (the 5 observed CVEs show the class does surface, so it is not 'rarely does'). Most CWE-622 instances are first-party implementation defects in hook handling that never receive a CVE, so A.8.8 finds a minority share.
- CWE-623partialfinds — A.8.8's reach is disclosure-based: it finds vulnerabilities that have been published as advisories or CVEs. CWE-623 does surface as CVEs (CVE-2007-0617, CVE-2007-0219, CVE-2006-6510 are observed examples), so disclosed instances in the operator's deployed estate are findable by vulnerability scanning. However, the disclosed share of any weakness class is a minority, and ActiveX safe-for-scripting markings are not a category that commonly generates advisories, capping the rung at `partial`.
- CWE-625partialfinds — A.8.8's reach is disclosure-based (vendor advisories, CVE databases, vulnerability scanning of deployed components). CWE-625 occasionally surfaces as CVEs (the observed examples list several), so the disclosed minority is reachable, but the bulk of permissive-regex instances live in first-party code and require source-level static analysis or code review, which A.8.8 does not name.
- CWE-64partialfinds — A.8.8's disclosure-driven scanning and advisory feeds find only the CWE-64 instances already published as CVEs, leaving unreported and first-party instances of this under-studied weakness outside its view.
- CWE-640partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, CVE feeds, supplier reporting), and CWE-640 does surface as CVEs in third-party products (WordPress plugins, web conference tools, etc.), so A.8.8 finds the disclosed minority of instances; first-party custom password-recovery code that never receives a CVE is outside its reach, which is A.8.29's territory.
- CWE-643partialfinds — Vulnerability management processes identify and remediate XPath injection flaws discovered post-deployment.
- CWE-644partialfinds — A.8.8's reach is disclosure-based (published advisories, vendor CVEs) plus penetration testing of deployed systems; CWE-644 is a first-party implementation flaw in HTTP header neutralization, so A.8.8 finds it where it surfaces as a CVE (e.g., CVE-2006-3918) or where a penetration test happens to exercise the header-injection path, but the bulk of latent instances in custom code are never published and are outside A.8.8's source-reading reach (which belongs to A.8.29).
- CWE-648partialfinds — A.8.8's reach is disclosure-based (vendor advisories, published CVEs, third-party component scanning); CWE-648 is a first-party code defect about privileged API misuse that only surfaces as a published advisory in a minority of cases, so A.8.8 finds the disclosed share and nothing more.
- CWE-652partialfinds — REACH: a disclosure-reach control sees only instances that carry a vendor-published flaw, so `finds` is at most `partial` (rule, 2026-10-17).
- CWE-66partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, vendor advisories, CVE tracking), and CWE-66 does surface as CVEs (e.g., ::$DATA, HFS+ named forks, MS-DOS device names), so the disclosed minority is found; most instances in custom code or unpatched products without published advisories remain latent.
- CWE-664partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances carrying a vendor-published flaw, and CWE-664 is a broad pillar category whose instances are mostly in custom code rather than third-party components with CVEs; the disclosed share is a minority, so a well-implemented A.8.8 programme finds some resource-lifecycle flaws (e.g. CVE-2018-1000613-style issues in libraries) but not the bulk.
- CWE-67partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances carrying a vendor-published flaw. CWE-67 is primarily a first-party implementation defect in how applications construct pathnames, and A.8.8's scanning/vulnerability-management programme does not inspect first-party source. The minority it does find is the slice where a third-party component ships with this weakness and it has been published as a CVE (the observed examples are historical CVEs in specific products), which is a bounded but small share of the class.
- CWE-676partialfinds — A.8.8's disclosure reach finds CWE-676 where it surfaces as published CVEs in third-party libraries (the observed examples include library-level strcpy/sprintf/strcat CVEs), but the dominant case — first-party code calling dangerous functions like strcpy() — is not visible to vulnerability scanning or vendor advisories, so only a minority of latent instances are found.
- CWE-680partialfinds — A.8.8's reach is disclosure: it finds this weakness only where it surfaces as a published CVE/advisory in a third-party component. CWE-680 does commonly appear in CVEs (observed examples include CVE-2021-43537 and CVE-2017-1000121), so the disclosed share is real, but most integer-overflow-to-buffer-overflow instances live in first-party code that no advisory names, leaving a nameable remainder outside A.8.8's view.
- CWE-682partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw, and CWE-682 is primarily a first-party code defect (arithmetic, logic, pointer math) that lives in custom code A.8.8's scanning and inventory never read; the disclosed minority that surfaces as CVEs (e.g., CVE-2020-0022, CVE-2010-1378) is found, but the bulk is not, matching the same disclosure-bound `partial` shape as A.8.8 -> CWE-89.
- CWE-689partialfinds — A.8.8's reach is disclosure-based (vendor advisories, CVE feeds, scanning of known-vulnerable components), and CWE-689 does surface as CVEs (CVE-2002-0760, CVE-2005-2174, CVE-2006-5214, CVE-2005-2475, CVE-2003-0265), so the disclosed minority is found; the bulk of instances live in first-party custom code (archive extractors, document management, OS utilities) where A.8.8 has no view, capping the rung at `partial`.
- CWE-69partialfinds — Vulnerability-management processes can identify and patch OS or application weaknesses that permit ADS abuse, but do not directly address improper ADS handling in custom code.
- CWE-690partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-690 does surface as CVEs (multiple examples in the CWE entry), so the disclosed share is non-trivial, but the bulk of unchecked-return-value defects live in first-party code that nobody publishes an advisory about, which A.8.8's scanning and inventory programme does not reach.
- CWE-691partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities through published advisories, scanning, and third-party library tracking. CWE-691 (insufficient control flow management) is primarily a first-party code defect introduced in architecture/design and implementation, and most instances are never published as CVEs. A.8.8 finds the minority that surface as disclosed vulnerabilities in third-party components (e.g., CVE-2014-1266 goto fail, CVE-2011-1027), but the bulk of CWE-691 in first-party code is outside its disclosure-based reach.
- CWE-692partialfinds — A.8.8's reach is disclosure-based (published advisories, component inventory), and CWE-692 is overwhelmingly a first-party implementation flaw in custom application code that does not get CVE assignments; A.8.8 finds it only where a third-party component ships with a published XSS-denylist bypass (the CVE examples exist but are a minority of the class), so a minority of latent instances are surfaced.
- CWE-693partialfinds — A.8.8 has DISCLOSURE reach — it finds only instances that surface as published CVEs or vendor advisories. CWE-693 is a broad pillar class (missing, insufficient, or ignored protection mechanisms) whose instances are predominantly identified through architecture review, code review, or testing rather than vulnerability disclosure. A.8.8's scanning tools surface the minority of protection-mechanism failures that vendors have published advisories for, but the bulk of the class — design-level omissions and ignored mechanisms in first-party code — is outside its reach.
- CWE-703partialfinds — A.8.8's reach is DISCLOSURE — it sees only vendor-published flaws. CWE-703 is a broad Pillar class whose instances are mostly application-specific exception-handling defects that rarely surface as CVEs; the minority that do (e.g. CVE-2022-22224 OSPF TLV handling, the cryptocurrency library chain) are caught by A.8.8's scanning and advisory monitoring, but the bulk of CWE-703 instances live in first-party code and are discovered only by source-reading or runtime testing, which A.8.8 does not perform.
- CWE-707partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities through scanning, vendor advisories, and CVE databases, so it discovers CWE-707 instances only where they surface as published flaws in third-party components; the vast majority of improper-neutralization defects live in custom first-party code and are invisible to this reach, which is the same boundary that placed A.8.8 finds CWE-89 at `partial`.
- CWE-73partialfinds — A.8.8's reach is DISCLOSURE-based: it finds CWE-73 where the weakness surfaces as a published advisory in a third-party component (CVE-2022-45918, CVE-2008-5748, CVE-2008-5764 are examples), but the bulk of CWE-73 instances live in first-party code where static analysis and code review — A.8.29's territory — are the High-rated detection methods, leaving the disclosed share a minority.
- CWE-757partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-757 is primarily a first-party protocol/implementation design weakness (the negotiation logic in the product's own code), which A.8.8's scanning and advisory-tracking programme does not reach. The minority of instances that do surface — third-party components with published downgrade CVEs (TLS libraries, SSH implementations) — are found by A.8.8's vulnerability scanning and supplier-advisory tracking, but the bulk of the class is outside its view.
- CWE-760partialfinds — A.8.8's reach is disclosure-based: it finds CWE-760 only where the predictable-salt defect appears as a published vulnerability in a third-party component (the observed CVEs show the class does surface this way), but the bulk of CWE-760 instances are first-party implementation choices in custom code that never receives an advisory, so the discovered share is a minority.
- CWE-763partialfinds — A.8.8's reach is disclosure-based: it finds CWE-763 only where the invalid-pointer/release defect has been published as a vendor advisory in a third-party component, and that disclosed share is a minority of latent instances — most CWE-763 lives in first-party code that A.8.8 does not read (that is A.8.29's reach).
- CWE-770partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-770 does commonly surface as CVEs (multiple observed examples in third-party libraries, interpreters, and products), so the disclosed minority is findable; the majority of CWE-770 instances live in first-party custom code that never receives a CVE and is outside A.8.8's reach.
- CWE-772partialfinds — A.8.8's disclosure-based vulnerability management can surface third-party resource-leak CVEs, but most CWE-772 instances are first-party implementation defects with no vendor advisory and so remain unfound.
- CWE-774partialfinds — A.8.8's reach is DISCLOSURE — it sees only vendor-published flaws in third-party components. CWE-774 is primarily a first-party code defect (resource allocation decisions in custom code), but a minority of instances do surface as CVEs in specific products (servers, libraries with handle leaks), which A.8.8's scanning and advisory-tracking would discover.
- CWE-776partialfinds — A.8.8's reach is DISCLOSURE — it finds XEE only where a vendor-published advisory exists for the XML parsing library or component, and XEE does surface as CVEs (CVE-2008-3281, CVE-2011-3288, CVE-2011-1755, CVE-2009-1955, CVE-2003-1564), so it is not `none`; but the bulk of XEE instances live in first-party custom XML processing code, which A.8.8's disclosure-based programme does not read, capping the rung at `partial`.
- CWE-78partialfinds — A.8.8's reach is DISCLOSURE — it finds OS command injection only where it has been published as a CVE in a third-party component, which is a minority of instances; most CWE-78 lives in first-party code that A.8.8's published-advisory and component-inventory programme does not read.
- CWE-782partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-782 lives predominantly in first-party driver/OS code where the organization is the author, and A.8.8 has no view of those instances; only the third-party subset that surfaces as CVEs (e.g., the observed CVE examples) is reached, which is a minority of the latent class.
- CWE-784partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-784 is a first-party code defect (implementation-phase), and like SQL injection, the detection methods that find it well (static analysis of source, code review) belong to A.8.29, not A.8.8. A.8.8 finds CWE-784 only where it has already been published as a CVE (the 2008–2009 examples show this happens), which is a minority of instances in custom code.
- CWE-786partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. Buffer underflows in third-party components that have published CVEs (the observed examples include several) are found via vulnerability scanning and advisory monitoring. But the bulk of CWE-786 instances are in first-party code, which A.8.8 does not reach — that belongs to A.8.29's source-reading testing. The disclosed share is a minority, so `partial`.
- CWE-787partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities via published advisories and component inventory, which surfaces out-of-bounds writes in third-party components where they commonly appear as CVEs, but most CWE-787 instances are in first-party code that no advisory names, leaving a nameable remainder outside its view.
- CWE-788partialfinds — A.8.8's reach is disclosure: it finds buffer overflows where they appear as published advisories in third-party components (a common case for CWE-788, which is heavily CVE'd), but does not reach the first-party code where most out-of-bounds memory access instances actually live.
- CWE-789partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, published advisories, component inventory); CWE-789 does surface as CVEs (multiple observed examples), so the disclosed minority is found, but most instances in first-party or un-disclosed code are outside A.8.8's view.
- CWE-79partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw in third-party components. XSS is overwhelmingly a first-party code defect in custom web applications, which A.8.8's scanning of published advisories and component inventory does not reach; that is A.8.29's territory (SAST/DAST). A.8.8 finds XSS only where it has been published as a CVE in a third-party component (CMS plugins, libraries, etc.), which is a minority of the class.
- CWE-793partialfinds — A.8.8's disclosure-based vulnerability management finds only the minority of CWE-793 instances that ship in third-party components with published advisories, while custom-code or unreported instances remain unknown.
- CWE-796partialfinds — A.8.8 operates on disclosed vendor advisories and component inventories, so it surfaces CWE-796 only where an instance is already a published vulnerability in a third-party component, leaving most first-party or unpublished instances unfound.
- CWE-798partialfinds — A.8.8's reach is DISCLOSURE — vulnerability scanning, component inventory, and published advisories — which surfaces hard-coded credentials only where they appear as disclosed flaws in third-party components; most CWE-798 instances live in first-party code or are never published, which A.8.8 does not reach.
- CWE-80partialfinds — A.8.8's reach is disclosure-based (published advisories, component inventory, vulnerability scanning); it finds XSS where the instance carries a CVE in a tracked third-party component or surfaces through its named penetration-testing route, but most XSS lives in first-party custom code that A.8.8 does not read — the same scope seam that graded A.8.8 finds CWE-89 = partial.
- CWE-805partialfinds — A.8.8's reach is DISCLOSURE — it finds buffer-length defects only where they surface as published advisories in third-party components. CWE-805 commonly produces CVEs (all observed examples are CVE entries), so the disclosed share is real, but most buffer-length errors in first-party code are never published and remain outside A.8.8's view, capping the rung at `partial`.
- CWE-806partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw, so it finds CWE-806 only where it surfaces as a CVE in a third-party component; first-party code with this implementation defect is invisible to the clause, and that is the majority of latent instances.
- CWE-807partialfinds — A.8.8's reach is disclosure — it sees only instances that carry a vendor-published flaw. CWE-807 does occasionally surface as CVEs (the observed examples are all CVEs in specific products), so A.8.8 finds that minority. The bulk of CWE-807 is a first-party design flaw in custom authentication/authorization code, which never gets a vendor advisory and is outside A.8.8's reach.
- CWE-81partialfinds — A.8.8's reach is disclosure (third-party advisories and component inventory); CWE-81 is typically a first-party defect in custom error pages, which A.8.8 does not inspect via source or dynamic testing (those belong to A.8.28/A.8.29). A.8.8 finds it only where it surfaces as a published CVE in a third-party component — a minority of instances, parallel to A.8.8 finds CWE-89 = partial.
- CWE-82partialfinds — A.8.8's reach is disclosure-based (vendor advisories, CVE databases, component inventory); CWE-82 is an implementation-phase defect in first-party web application code, so A.8.8 finds it only where it surfaces as a published advisory for a third-party component — a minority of instances, matching the same logic as A.8.8 finds CWE-89 = partial.
- CWE-822partialfinds — A.8.8's reach is DISCLOSURE-based (vulnerability scanning, advisories, third-party library tracking), and CWE-822 does commonly surface as CVEs (multiple observed examples), so the clause finds the disclosed share of latent instances — a minority, since most untrusted pointer dereferences in deployed code, especially first-party, never carry a published advisory.
- CWE-823partialfinds — A.8.8's reach is disclosure-based (vulnerability scanning, advisories, CVE feeds, third-party component inventory); it finds CWE-823 only where the out-of-range pointer offset has been published as a vendor advisory in a third-party component, which is a minority of the class — most instances live in first-party code and are reached by A.8.29's source-reading testing, not by A.8.8.
- CWE-824partialfinds — A.8.8's reach is DISCLOSURE (third-party components with vendor-published advisories); CWE-824 is an implementation-phase memory-safety bug that lives mostly in first-party code, which A.8.8 does not read. The disclosed share of this class is a minority, and `partial` is the ceiling for disclosure reach on a class that does commonly surface as CVEs.
- CWE-825partialfinds — A.8.8's reach is DISCLOSURE — it finds expired pointer dereferences only where they appear as published CVEs in third-party components in the inventory; first-party use-after-free defects (the bulk of the class, where CWE-825's detection methods rate static/dynamic analysis High) are outside its reach, so a minority of latent instances are found.
- CWE-827partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities that have been published as advisories or CVEs. CWE-827 does surface as CVEs (e.g., CVE-2010-2076), so the disclosed share is non-zero, but most instances of improper DTD handling live in first-party XML/SOAP parser configuration that nobody published an advisory about, leaving the majority of the class outside A.8.8's view.
- CWE-829partialfinds — A.8.8's reach is DISCLOSURE — it discovers vulnerabilities through published advisories, vendor reports, and scanning of known-vulnerable third-party libraries. CWE-829 commonly surfaces as CVEs (the observed examples are predominantly PHP file-inclusion CVEs, and third-party library vulnerabilities are heavily CVE-published), so A.8.8 finds a meaningful share of disclosed instances. The remainder is bounded and nameable: architectural decisions to include functionality from untrusted sources (e.g., the weather-widget design choice) that never receive a CVE, and bespoke file-inclusion patterns in first-party code that no advisory names. Disclosure reach caps this at `partial`.
- CWE-83partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-83 is a first-party implementation defect in custom web code, which A.8.8's vulnerability scanning and advisory-based programme does not reach. The minority it does find is the slice that surfaces as published CVEs in third-party components (the observed examples show CVEs do exist for this class), but the bulk of instances in custom code are outside its view, mirroring the A.8.8 -> CWE-89 anchor at the same rung.
- CWE-832partialfinds — A.8.8's reach is DISCLOSURE — it finds vulnerabilities that have been publicly disclosed as CVEs. CWE-832 does surface as CVEs in some cases (the observed examples are all OS kernel CVEs), so the disclosed share is non-zero. But CWE-832 is primarily a first-party implementation defect in custom code, and most instances are never published as CVEs; A.8.8's scanning and tracking reach only the third-party, disclosed minority, which is a partial share of the class.
- CWE-833partialfinds — A.8.8's reach is DISCLOSURE — it sees only what vendors publish as advisories. Deadlocks do occasionally surface as CVEs (the observed examples include OS, library, and web-server deadlocks), so A.8.8 finds that minority; the bulk of deadlock instances are implementation bugs in first-party code that never receive a vendor advisory and are outside this control's reach.
- CWE-835partialfinds — A.8.8's reach is DISCLOSURE — it sees only third-party components with published advisories. CWE-835 instances that surface as CVEs in third-party libraries (e.g., CVE-2025-32399, CVE-2022-25304) are discoverable through vulnerability scanning, but the majority of infinite loops live in first-party code where no advisory is ever published, and A.8.8 has no view of those.
- CWE-836partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw or surface through its scanning/penetration testing programme. CWE-836 does surface as CVEs (CVE-2009-1283, CVE-2005-3435), so the disclosed share is findable, but the weakness is fundamentally an authentication design choice that often goes unflagged in custom code and many products, leaving a nameable latent remainder outside the disclosure plane.
- CWE-839partialfinds — A.8.8's reach is DISCLOSURE — it finds only instances that surface as published advisories or CVEs. CWE-839 does appear in CVEs (the observed examples show this), so the disclosed minority is findable, but the bulk of CWE-839 instances are latent in first-party code logic that no vendor advisory names, and A.8.8's scanning/inventory programme does not read source.
- CWE-84partialfinds — A.8.8's reach is DISCLOSURE — it finds this weakness only where it surfaces as a published advisory or CVE, and the observed examples show CWE-84 does get CVEs, but the disclosed share of latent instances in custom web code is a minority, so the grade is `partial` and not `mostly`.
- CWE-843partialfinds — A.8.8's reach is disclosure-based: it finds type confusion where it surfaces as a published CVE in third-party components (the observed examples show CVEs do exist for this class), but misses first-party code entirely (that is A.8.29's domain) and the research-gap note indicates many type confusion instances are reported as 'memory corruption' rather than type confusion specifically, shrinking the disclosed share.
- CWE-87partialfinds — A.8.8's reach is disclosure-based (published advisories and component inventory), so it finds CWE-87 only where the alternate-syntax XSS flaw is already a published vulnerability in a third-party component; most instances live in first-party code that A.8.8 does not read, mirroring the A.8.8 -> CWE-89 anchor.
- CWE-88partialfinds — A.8.8's reach is DISCLOSURE — it identifies vulnerabilities through published advisories, vendor notifications, and scanning against known CVE feeds. CWE-88 does surface as CVEs in third-party components (PHPMailer, browsers, mail clients, etc., per the observed examples), so a minority of instances are findable. The bulk of argument injection lives in custom first-party code with no published advisory, which A.8.8's disclosure-based programme does not reach — same scope seam as A.8.8 -> CWE-89.
- CWE-89partialfinds — 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-90partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw in third-party components. LDAP injection is primarily a first-party code defect, and the detection methods that reach it (static/dynamic analysis of source) belong to A.8.29, not A.8.8. A.8.8 finds it only where it surfaces as a published CVE in a third-party component, which is a minority of instances.
- CWE-908partialfinds — A.8.8's reach is disclosure-based: it finds vulnerabilities that have been published as advisories or surface in third-party component inventories. CWE-908 does commonly appear as CVEs (multiple observed examples), so A.8.8 finds a minority of instances through that channel, while the bulk of uninitialized-resource defects in first-party code remain outside its reach.
- CWE-911partialfinds — A.8.8's reach is DISCLOSURE-based (vulnerability scanning, vendor advisories, patch management); CWE-911 is a code-level implementation bug whose bulk is found only by source-reading tools or development-time review, but the class does commonly surface as CVEs (many observed examples), so the disclosed minority is findable by A.8.8's scanning programme.
- CWE-914partialfinds — A.8.8's reach is DISCLOSURE — vendor-published flaws and scanning for known vulnerabilities. CWE-914 does surface as CVEs (multiple PHP-related examples in the CWE's observed examples), so a minority of instances are found via published advisories and signature-based scanning; the majority live in custom code that never appears in any advisory and is outside A.8.8's reach.
- CWE-915partialfinds — A.8.8's reach is disclosure-based, and mass assignment does surface as CVEs in published products (multiple examples in CWE-915's observed list), so the clause finds that minority; the bulk of mass-assignment instances live in custom first-party code that never receives a CVE, which A.8.8 does not reach.
- CWE-916partialfinds — A.8.8's reach is DISCLOSURE — it surfaces CWE-916 only where a vendor publishes an advisory for a third-party component with weak password hashing (the observed CVEs are all third-party products). Custom password-hashing implementations in first-party code, which constitute the bulk of this weakness class, are never disclosed and therefore never found by A.8.8's programme.
- CWE-917partialfinds — A.8.8's reach is DISCLOSURE — it sees EL injection only where it surfaces as a published advisory in a third-party component (Log4Shell being the canonical example). Most EL injection lives in first-party JSP/Spring code that no advisory names, which A.8.8's scanning and supplier-reporting channels do not reach.
- CWE-918partialfinds — A.8.8's reach is DISCLOSURE — it finds SSRF in third-party components with published CVEs (mail servers, cloud platforms, LLM frameworks all appear in the observed examples), but SSRF in the operator's own custom URL-fetching code is outside its reach, and most SSRF lives in first-party application logic.
- CWE-921partialfinds — Through vulnerability scanning and advisory tracking, A.8.8 finds known disclosed instances of this weakness in vulnerable components, but the undisclosed majority—especially custom applications that write sensitive data to world-readable storage without a published CVE—remains outside its disclosure-bound reach.
- CWE-93partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CRLF injection does surface as CVEs (multiple observed examples), so the disclosed share is findable, but the bulk of CRLF injection lives in custom first-party code that never gets a published advisory, leaving a nameable majority outside A.8.8's view.
- CWE-94partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw in third-party components. CWE-94 (code injection) does surface as CVEs in some libraries and frameworks, so A.8.8 finds that minority; the bulk of code injection lives in first-party code (eval(), dynamic code generation in the organization's own application), which A.8.8 does not reach — that is the job of SAST/DAST under A.8.29.
- CWE-940partialfinds — A.8.8's reach is DISCLOSURE — it finds CWE-940 only where the flaw has been published as a vendor advisory or surfaces in a tracked third-party component. The class does produce CVEs (CVE-2025-3651, the DNS-update CVEs), so it is not `none`, but most CWE-940 instances are first-party design/implementation flaws in custom code that never receive a public advisory, leaving a nameable undisclosed remainder.
- CWE-941partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-941 is primarily a first-party code defect (incorrect destination specification in the product's own communication logic), and A.8.8 finds it only where it has surfaced as a published CVE (the observed examples include CVE-2013-5211, CVE-1999-0513, CVE-1999-1379). Most instances of this weakness in deployed code are not published advisories, so the disclosed share is a minority — the same logic that graded A.8.8 finds CWE-89 = partial.
- CWE-942partialfinds — A.8.8's disclosure reach surfaces CWE-942 instances in third-party products that carry published CVEs, but misses the first-party cross-domain policy misconfigurations that have no vendor advisory, so it finds only a minority.
- CWE-95partialfinds — A.8.8's reach is published advisories and component inventory; eval injection does surface as CVEs (so not `none`), but the bulk of CWE-95 instances live in first-party code that nobody published an advisory about, which A.8.8's neighbour A.8.29 reaches and A.8.8 does not.
- CWE-96partialfinds — A.8.8's reach is DISCLOSURE — it sees only instances that carry a vendor-published flaw. CWE-96 is a first-party code defect (user input written into an executable resource), and while some instances surface as CVEs (the observed examples include CVE-2002-0495, CVE-2005-1876, etc.), the vast majority of static code injection in deployed code is in custom applications that never get a published advisory. A.8.8 finds the disclosed minority; the source-reading and dynamic-testing routes that would reach the rest belong to A.8.29, not A.8.8.
- CWE-98partialfinds — A.8.8's reach is disclosure-based (published advisories, component inventory) plus penetration testing; CWE-98 is a first-party PHP code defect whose systematic discovery belongs to source-reading testing (A.8.29), so A.8.8 finds it only where it surfaces as a disclosed CVE in a third-party component or is caught by a pen test — a minority of latent instances, parallel to A.8.8 finds CWE-89 = partial.
Mitigated MITRE ATT&CK techniques (3422)
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
- T1003.002mostlydetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalous behaviour, and increased monitoring to detect actual attacks, which surfaces in-memory or registry-based SAM dumping tools and techniques post-exploitation.
- T1003.004mostlydetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for actual attacks, logging of all steps, and alignment with incident management to surface technical vulnerabilities and related events, which would detect the use of tools like Mimikatz or Reg for dumping LSA secrets as a realized vulnerability exploitation on Windows assets.
- T1036.009mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, monitoring for vulnerabilities in products/services, and increased monitoring to detect actual attacks exploiting known vulnerabilities; T1036.009 is a post-exploitation evasion technique (PPID spoofing via fork/daemon) that is surfaced by these mechanisms once it is catalogued as a detectable indicator in endpoint or process telemetry.
- T1055.003mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, monitoring for vulnerabilities in products/services, and increased monitoring as a compensating control, all of which surface in-process injection techniques like thread execution hijacking (a known post-exploitation method observable via anomalous thread behavior, memory changes, or process anomalies).
- T1055.005mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, monitoring for vulnerabilities in products/services, and increased monitoring to detect attacks exploiting known vulnerabilities; this surfaces TLS callback injection (a known technique abusing PE/TLS structures) when it appears in scanned components, libraries, or as anomalous process behavior, with the bounded remainder being novel/undisclosed variants or injection into unmonitored processes.
- T1056.004mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, monitoring for attacks, and procedures to detect vulnerabilities in products/services (including external components), which surfaces the presence of hooking mechanisms or vulnerable libraries enabling T1056.004; the bounded remainder is in-memory hooking that leaves no persistent artifact for scanning.
- T1068mostlydetects — Systematic identification and remediation of software flaws limits the pool of unpatched vulnerabilities that can be abused to escalate privileges on a compromised host.
- T1068mostlyprevents — A.8.8's stated purpose is to prevent exploitation of technical vulnerabilities, and T1068 is exactly that — exploitation of a software vulnerability for privilege escalation. Patching, virtual patching, turning off vulnerable services, and access controls remove or shield the vulnerable code path so the technique cannot run. The remainder is nameable: zero-days are unknown until disclosed, BYOVD brings a vulnerable driver outside the asset inventory, and the window between disclosure and patch deployment leaves exposure, so the prevention is not complete.
- T1071.004mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, monitoring for actual attacks, and procedures to detect the existence of vulnerabilities (including in third-party components), which surfaces DNS-tunneling C2 as anomalous traffic or known vulnerable software enabling it; the remainder is pre-compromise adversary infrastructure acquisition that the clause cannot observe.
- T1074mostlydetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and increased monitoring when vulnerabilities are known; these surface the preparatory staging activity (unusual file copies, new central directories, cloud instance creation for staging) in most cases once it touches monitored assets or known-vulnerable components, though pre-compromise adversary staging outside the estate or in unmonitored locations remains unseen.
- T1106mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, monitoring for actual attacks, and alignment with incident management to surface technical vulnerabilities and related behaviors, which would discover most native API abuse (especially in-process or library-based execution) once it is present or leaves detectable artifacts.
- T1127.001mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, monitoring for vulnerabilities in products/services, and increased monitoring to detect attacks exploiting them; these surface MSBuild abuse (a known technique often tied to vulnerable build processes or living-off-the-land binaries) in most cases, with the bounded remainder being entirely novel/undisclosed inline-task variants unseen by any scanning or monitoring.
- T1127.002mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, monitoring for actual attacks, tracking third-party libraries, receiving vulnerability reports, and keeping audit logs of the process, all of which surface the presence or use of vulnerable ClickOnce components or the technique leveraging them on Windows assets.
- T1137.001mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests/vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and increased monitoring to detect attacks exploiting known vulnerabilities; this surfaces T1137.001 once the malicious Office template macro or its indicators are catalogued as a known vulnerability.
- T1137.004mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests/vulnerability assessments, tracking of third-party libraries, procedures to detect vulnerabilities in products/services (including external components), and increased monitoring for actual attacks, all of which surface this post-compromise persistence technique when it introduces or exposes a detectable vulnerability in Outlook configuration.
- T1137.006mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests/vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and increased monitoring to detect actual attacks, all of which surface the presence or use of malicious Office add-ins as a technical vulnerability after they are present on the system.
- T1189mostlyprevents — A.8.8's patching regime, asset inventory, and vulnerability scanning address the known browser/plugin vulnerabilities that drive-by compromise exploits, so a conformant implementation prevents the bulk of such attacks; the named remainder is zero-day exploits in browsers and plugins, plus systems that fall outside the patching cadence or where patches cannot yet be applied.
- T1190mostlydetects — Regular vulnerability scanning and timely patching of public-facing systems directly reduces the number of exploitable weaknesses an attacker can leverage to gain initial access.
- T1190mostlyprevents — A.8.8's stated purpose is to prevent exploitation of technical vulnerabilities, and T1190 is exactly that class — exploitation of software bugs, glitches and misconfigurations in public-facing systems; the control's identify-evaluate-remediate cycle (scanning, pen testing, vendor advisories, patching, virtual patching, workarounds) directly addresses this, but the named remainder is the zero-day and the disclosure-to-patch window where exploitation can precede remediation, plus systems where patches cannot be applied.
- T1203mostlydetects — Fewer unpatched client-side vulnerabilities mean attackers have reduced success when attempting to exploit user applications via malicious documents or web content.
- T1203mostlyprevents — A.8.8's stated purpose is to prevent exploitation of technical vulnerabilities, and its mechanism (asset inventory, scanning, patching, virtual patching, turning off services) directly removes the attack surface T1203 depends on; the bounded remainder is zero-day vulnerabilities, systems that cannot be patched in time, and vulnerabilities discovered after exploitation has already occurred.
- T1210mostlyprevents — By maintaining an asset inventory and applying patches to discovered vulnerabilities, the control shrinks the attack surface that adversaries scan for when attempting to exploit remote services for lateral movement.
- T1212mostlyprevents — A.8.8's stated purpose is to prevent exploitation of technical vulnerabilities, and T1212 is precisely exploitation of a software vulnerability for credential access; patching and remediation close the bulk of known exploitable flaws, but zero-days, vulnerabilities where no patch exists or cannot be installed, and assets missed by the inventory remain exploitable, which the clause itself acknowledges in its 'if no update is available' guidance.
- T1218.013mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, monitoring for vulnerabilities in products/services, and increased monitoring to detect attacks exploiting them; this surfaces mavinject.exe abuse (a known technique often tied to vulnerable signed binaries or injection flaws) in the monitored estate, with the bounded remainder being pre-compromise adversary acquisition of the binary itself.
- T1499.004mostlyprevents — A.8.8's purpose is explicitly to prevent exploitation of technical vulnerabilities, and its patching, virtual patching, and compensating control mechanisms prevent exploitation of known, patchable vulnerabilities that constitute the bulk of T1499.004 instances; the named remainders are zero-day vulnerabilities (explicitly cited in the technique), the window between disclosure and patch deployment, and systems that cannot be patched.
- T1505.001mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, procedures to detect vulnerabilities in products/services (including external components), and increased monitoring for actual attacks, all of which surface malicious or anomalous stored procedures after they are present.
- T1505.002mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and monitoring/evaluating the process, all of which surface the presence of a maliciously registered transport agent as a technical vulnerability on Exchange assets.
- T1546.001mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and monitoring/evaluating the process, all of which surface the registry changes or anomalous file-association behavior that realize T1546.001 after they exist; the bounded remainder is pre-compromise adversary acquisition of the technique itself.
- T1546.011mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, monitoring for vulnerabilities in products/services, and increased monitoring to detect attacks exploiting them; these surface Application Shimming (a known technique abusing installed shims or custom .sdb files) when it appears as a vulnerable configuration, anomalous shim database change, or post-exploitation artifact, with the bounded remainder being novel/undisclosed shim abuse that evades known-vulnerability detection.
- T1547mostlydetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in products/services/third-party components, and increased monitoring as a compensating control, all of which surface T1547 indicators (e.g. anomalous autostart entries, suspicious kernel modules, or known-vulnerable persistence mechanisms) after they are present on the estate.
- T1547.002mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and monitoring/evaluating the process, all of which surface the presence of an authentication package DLL registered for autostart/persistence (a detectable configuration or code-level weakness once present on a Windows asset).
- T1547.003mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and monitoring/evaluating the process, all of which surface the presence of a malicious time-provider DLL registered for persistence (a detectable configuration or component vulnerability).
- T1547.009mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, monitoring for vulnerabilities in products/services, and increased monitoring to detect attacks exploiting known vulnerabilities; these surface the presence or use of malicious shortcuts placed for persistence (a known post-exploitation technique) once the relevant vulnerability or anomalous file change is in scope.
- T1548.003mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, monitoring for actual attacks, and procedures to detect the existence of vulnerabilities (including in products/services and external components); these surface misconfigurations or weaknesses in sudo/sudoers that enable T1548.003 (e.g. NOPASSWD entries, disabled tty_tickets, or stale timestamp files) once present on the system.
- T1556.006mostlydetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in products/services/third-party components, receiving reports, and increased monitoring to detect attacks exploiting known vulnerabilities; this surfaces T1556.006 when it modifies MFA mechanisms that are catalogued as vulnerable (or when the modification itself is a detectable flaw), with the bounded remainder being stealthy or zero-day MFA patches outside scanned inventory.
- T1556.008mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and monitoring/evaluating the process, all of which surface the presence of a maliciously registered Network Provider DLL as a technical vulnerability (or anomalous credential-capture behavior) on Windows assets.
- T1564.007mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries/source code, receiving vulnerability reports, and monitoring/evaluating the process, all of which surface VBA stomping as a known technique in Office documents or malicious macros once it is present in the environment.
- T1565.001mostlydetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for attacks exploiting known vulnerabilities, and increased monitoring when patches cannot be applied; these surface stored data manipulation when it exploits a tracked technical vulnerability (or is visible in logs/audits), with the bounded remainder being novel/zero-day manipulation that evades known-vuln detection.
- T1565.003mostlydetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for attacks exploiting known vulnerabilities, and alignment with incident management to surface technical vulnerabilities and related events; this catches runtime data manipulation when it stems from or triggers a detectable exploited vulnerability (the dominant realized form), with the bounded remainder being stealthy manipulations that leave no observable vulnerability artifact.
- T1569mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, monitoring for attacks exploiting known vulnerabilities, and procedures to detect the existence of vulnerabilities (including in third-party components), which surfaces T1569 abuse when it leverages a known-vulnerable service or daemon; the bounded remainder is novel/undisclosed service-abuse techniques that fall outside known-vulnerability detection.
- T1574.006mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, monitoring for vulnerabilities in products/services, and increased monitoring to detect attacks exploiting known vulnerabilities; this surfaces T1574.006 (a known technique abusing LD_PRELOAD/DYLD_INSERT_LIBRARIES in loaded libraries) when it appears in scanned components, reported bugs, or observed anomalous behavior, with the bounded remainder being novel/undisclosed hijacks not yet in any vulnerability database.
- T1574.009mostlyprevents — A.8.8's stated purpose is to prevent exploitation of technical vulnerabilities, and T1574.009 exploits a configuration vulnerability (unquoted paths) that vulnerability scanning tools and configuration audits can identify and that the remediation process can fix by adding quotes or applying compensating controls; the remainder is the implementation-dependent gap — not all scanning tools detect unquoted paths, remediation requires timely action across the estate, and new unquoted paths can be introduced after assessment.
- T1612mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, procedures to detect vulnerabilities in products/services (including external components), and increased monitoring for actual attacks, all of which surface the custom malicious image or its build artifacts on the host after T1612 completes.
- T1685.004mostlydetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in products/services (including third-party components), receiving reports, and increased monitoring as a compensating control, all of which surface the presence or use of the audit-disabling technique or its artifacts on Linux systems.
- T1686mostlydetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in products/services/components, and increased monitoring as a compensating control, which surfaces firewall-tampering techniques (or their artifacts) once they create detectable vulnerable states or anomalous configurations on monitored assets.
- T1686.003mostlydetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests/vulnerability assessments, monitoring for actual attacks, and procedures to detect vulnerabilities (including in products/services and via reports), which surfaces the anomalous firewall modifications or disabled state as a technical vulnerability or configuration drift on Windows assets.
- T1687mostlyprevents — A.8.8's stated purpose is to prevent exploitation of technical vulnerabilities, and T1687 is exploitation of vulnerabilities in defensive components — which the asset inventory and scanning scope explicitly include. The control's patching, virtual patching, and compensating-control guidance addresses known vulnerabilities in security tools, but zero-day vulnerabilities in defensive software cannot be prevented by any vulnerability management process, which is the bounded remainder.
- T1003partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in products/services/components, increased monitoring of vulnerable systems, and alignment with incident management to surface technical weaknesses that enable T1003 (e.g. unpatched credential-dumping vectors in OS caches/memory); this discovers the enabling conditions before or during use, with the bounded remainder being novel/undisclosed credential-dumping techniques that evade known-vuln detection.
- T1003.008partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, monitoring for attacks exploiting known vulnerabilities, and increased monitoring when no patch exists; these surface the technique (or its precursor vuln) when it runs against inventoried assets, with the bounded remainder being unmonitored/unknown systems or zero-day variants outside the vulnerability-management scope.
- T1008partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and increased monitoring when mitigations are applied; these surface fallback-channel C2 when the alternate channel or its traffic pattern is already known or produces detectable anomalies, but do not guarantee detection of novel or obfuscated fallback implementations.
- T1021partialdetects — A.8.8 requires monitoring for vulnerabilities, scanning, penetration testing, and increased monitoring when no patch exists; this can surface anomalous remote-service logons or post-exploitation activity tied to known vulnerable remote-service software, but the control's scope is vulnerability discovery rather than general detection of the T1021 technique itself, leaving most legitimate or unpatched-account-based usage unseen.
- T1027.004partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and tracking of third-party libraries/source code, which can surface the presence of delivered uncompiled source or the post-compilation artifacts, but does not instrument or guarantee detection of the delivery or compilation step itself across all platforms and delivery vectors.
- T1027.005partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and increased monitoring to detect actual attacks, which surfaces the modified tool once it is recognized as a known indicator or vulnerability in the organization's asset inventory or threat intel.
- T1027.008partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and increased monitoring as compensating controls, which can surface stripped payloads when they match known vulnerable patterns, exhibit anomalous behavior, or are tied to disclosed vulnerabilities, but this is limited to post-compromise or known-signature cases and does not broadly detect the stripping technique itself across all platforms and implementations.
- T1027.009partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, and monitoring for vulnerabilities in products/services (including external components); these can surface embedded-payload techniques when they appear in known-vulnerable files, libraries, or binaries, but miss novel/undisclosed embedding methods that do not match published vulnerabilities.
- T1027.013partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in third-party libraries/source code, and increased monitoring as a compensating control, which can surface encoded/encrypted malicious files when they match known vulnerable patterns, signatures, or IOCs; however, it is scoped only to technical vulnerabilities (not arbitrary adversary obfuscation) and many T1027.013 instances have no associated CVE or detectable vulnerability.
- T1027.017partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in products/services/third-party components, and increased monitoring as a compensating control, which can surface SVG smuggling when it is treated as (or exposes) a detectable vulnerability or anomalous payload in scanned/analyzed files or libraries; this is a genuine but minority slice of the technique (most instances are delivery/obfuscation rather than a published vuln in a component).
- T1036partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and tracking of third-party components/libraries, which can surface masquerading artifacts (e.g. suspicious file metadata, renamed binaries, or anomalous process names) when they match known vulnerable or suspicious patterns, but this is limited to post-deployment scanning of inventory rather than real-time detection of the technique itself across all platforms and forms.
- T1037.001partialdetects — A.8.8 requires monitoring for vulnerabilities, scanning, penetration testing, and receiving reports to surface technical weaknesses; this can discover vulnerable logon-script configurations or the presence of malicious scripts after they are deployed, but does not instrument runtime execution of the persistence technique itself and leaves many deployment vectors (e.g., custom scripts without known CVEs) unseen.
- T1048.002partialdetects — A.8.8 requires monitoring for vulnerabilities, increased monitoring as a compensating control, and alignment with incident management to surface data on vulnerabilities, which can detect anomalous exfiltration over asymmetric encrypted protocols (e.g. via traffic anomalies or logs) but only as a slice — the control's core focus is vulnerability identification/evaluation/remediation in assets/components, not broad detection of this post-compromise exfiltration technique.
- T1056partialdetects — A.8.8 requires monitoring for vulnerabilities, vulnerability scanning, penetration testing, increased monitoring on known-vulnerable systems, and alignment with incident response to surface technical vulnerabilities and related events; this can detect some post-compromise input-capture artifacts (e.g. via anomalous behavior, known vulnerable hooking libraries, or scanning for indicators) but has no coverage of the technique's core stealthy mechanisms such as API hooking, keylogging, or form-grabbing on unpatched or unknown-vulnerable systems.
- T1056.001partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, monitoring for attacks exploiting known vulnerabilities, and increased monitoring when no patch exists; these surface keylogging (a known technique with published indicators) once present on monitored assets, with the bounded remainder being novel/undisclosed keyloggers or assets outside the inventory/monitoring scope.
- T1056.003partialprevents — A.8.8 prevents the initial-compromise variant of T1056.003 by identifying and patching vulnerabilities in externally facing web portals, but does not address the post-compromise variant where the adversary uses legitimate administrative access to install capture code, and even the vulnerability path leaves a window between disclosure and patch application.
- T1059.006partialdetects — A.8.8 requires monitoring for vulnerabilities, vulnerability scanning, penetration testing, and increased monitoring as a compensating control, which can surface Python-based execution anomalies or known vulnerable Python libraries/components after the fact; this is a genuine but minority slice of the technique (most in-flight Python abuse leaves no pre-existing vulnerable component to scan for).
- T1070partialdetects — A.8.8 requires monitoring for vulnerabilities, receiving reports, scanning, penetration testing, and increased monitoring as a compensating control when no patch exists; this surfaces some post-removal anomalies or indicators of the T1070 technique (especially via heightened logging or anomaly detection), but the clause's core focus is vulnerability discovery rather than artifact-removal detection and many T1070 variants (e.g. in-memory or selective log edits on unmonitored platforms) remain unseen.
- T1078partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, increased monitoring on vulnerable systems, and alignment with incident response to surface technical vulnerabilities and related activity; this can detect some post-compromise use of valid accounts (e.g. via anomalous behavior on known-vulnerable assets or during incident handling), but the bulk of T1078 (credential abuse, inactive accounts, pivoting without malware or exploitable vulns) sits outside its technical-vulnerability focus and is unseen by its mechanisms.
- T1078.003partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and increased monitoring when no patch exists; these can surface local account abuse (e.g. via anomalous logons, credential dumping artifacts, or unpatched privilege-escalation vectors), but the clause's core mechanism is vulnerability identification and remediation rather than real-time detection of the technique itself, leaving most behavioral indicators of local-account abuse outside its defined scope.
- T1078.004partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for vulnerabilities (including in cloud-provider resources via agreements), and increased monitoring as a compensating control, which can surface misconfigurations or vulnerable cloud accounts after they exist; this is a genuine but minority slice of the broad technique (credential abuse, brute force, phishing, persistence via additional credentials, privilege escalation via roles/Managed Identities) whose dominant vectors sit outside vulnerability management.
- T1082partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, increased monitoring on known-vulnerable systems, and alignment with incident management to surface technical vulnerabilities and related activity; this catches system-information-gathering behaviors (especially post-compromise reconnaissance on monitored assets) in most cases, with the bounded remainder being pre-compromise or stealthy discovery on unmonitored/unknown assets.
- T1098.003partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and evaluation of reports that can surface anomalous IAM/role changes as potential indicators of compromise or misconfiguration, but this is scoped to technical vulnerabilities in assets rather than directly targeting adversary role-addition TTPs, leaving most of the technique (especially external-account or post-compromise privilege tweaks) outside its view.
- T1098.006partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in products/services/third-party components, and increased monitoring when no patch exists; these surface anomalous permission/role changes that realize or indicate the technique in container environments (especially when tied to known vulnerable components or misconfigurations), though detection is post-compromise and does not cover every stealthy or zero-day execution path.
- T1098.007partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalous behaviour, and procedures to detect the existence of vulnerabilities (including in products/services and via reports), which surfaces the post-compromise group-addition technique when it triggers observable indicators such as anomalous account changes or known-vulnerable privilege-escalation patterns; the bounded remainder is stealthy additions that evade scanning/monitoring scope.
- T1104partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and procedures to detect the existence of vulnerabilities (including in third-party components and products), which surfaces multi-stage C2 infrastructure, loaders, and fallback channels once they are present on the estate or trigger observable behavior.
- T1105partialdetects — A.8.8 requires monitoring for vulnerabilities, vulnerability scanning, penetration testing, and increased monitoring as a compensating control, which can surface anomalous ingress tool-transfer activity (especially when tied to known vulnerable software or post-exploitation), but this is only a slice of the technique's many native utilities, protocols, and file-sync vectors that fall outside vulnerability-focused detection
- T1110partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for attacks exploiting known vulnerabilities, and increased monitoring when no patch exists; these surface brute-force attempts that leverage or expose credential weaknesses (especially offline or against known-vulnerable auth), but do not broadly instrument login failures, rate limiting, or the technique's core guessing behavior itself.
- T1110.001partialdetects — A.8.8 requires monitoring for vulnerabilities, receiving reports, scanning, penetration testing, and increased monitoring as a compensating control when no patch exists; this surfaces password-guessing attempts on monitored services or via anomaly detection, but the clause's scope is technical-vulnerability identification rather than exhaustive real-time detection of all guessing across every listed protocol or platform, leaving a genuine slice uncovered.
- T1110.003partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for attacks exploiting known vulnerabilities, and increased monitoring when no patch exists; these surface password-spraying attempts that leverage known weak/default credentials or unpatched authentication services, but the clause's scope is limited to technical vulnerabilities in assets and does not broadly instrument authentication logs, failed-login patterns, or throttling across all listed services and protocols.
- T1110.004partialdetects — A.8.8 requires monitoring for anomalous behaviour, vulnerability scanning, penetration testing, increased monitoring of vulnerable systems, and use of threat intelligence to surface vulnerabilities and attacks; this can detect credential stuffing in flight on managed assets or via known vulnerable services, but the control's scope is vulnerability-centric rather than exhaustive authentication monitoring and does not reach adversary acquisition of dumps or all external SSO/cloud targets.
- T1129partialdetects — A.8.8 requires monitoring for vulnerabilities, vulnerability scanning, penetration testing, and increased monitoring as a compensating control, which can surface indicators of shared module loading when tied to known vulnerable libraries or anomalous module behavior, but does not broadly instrument or detect the technique itself across arbitrary paths or in-process execution.
- T1133partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for attacks exploiting known vulnerabilities, and increased monitoring as a compensating control, which can surface T1133 when the exposed remote service (or its misconfiguration) is a known vulnerability; this is a genuine but minority slice of the technique (most T1133 use relies on valid accounts or unauthenticated exposure without a published vuln).
- T1136partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in products/services/components, receiving reports, and increased monitoring as a compensating control, all of which surface the anomalous creation of accounts (a detectable post-exploitation artifact) when it leaves evidence in logs, asset changes, or configuration.
- T1136.003partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and receiving vulnerability reports, which can surface the creation or anomalous use of a cloud account as a potential vulnerability or indicator after the fact; however, the control's scope is limited to technical vulnerabilities in assets/components and does not broadly instrument or detect adversary account creation behaviors across cloud platforms.
- T1137partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and monitoring/evaluating the process, all of which surface T1137 persistence mechanisms (e.g. malicious add-ins, templates, or Outlook rules) once present in Office components.
- T1137.001partialprevents — A.8.8's vulnerability management process can identify Office configurations with macro-related weaknesses, recommend patches, and suggest compensating controls (such as turning off capabilities or adding access controls), but T1137.001 is fundamentally abuse of legitimate template/macro functionality rather than a patchable vulnerability, so the control contributes to prevention without directly stopping template modification or macro execution.
- T1137.006partialprevents — A.8.8's asset inventory and monitoring aspects can surface unauthorized or anomalous Office add-ins, and its broader controls (access restrictions, configuration hardening) can constrain add-in installation, but the technique abuses legitimate Office functionality rather than exploiting a technical vulnerability, so the core mechanism of patching known vulnerabilities does not apply and prevention is limited to a slice.
- T1176.001partialdetects — A.8.8's asset inventory and vulnerability scanning can surface browser extensions present on managed systems and identify some malicious or vulnerable ones, but the source prose explicitly notes malicious extensions can defeat automated scanners, and the control's mechanism targets known software vulnerabilities rather than abuse of legitimate extension functionality.
- T1185partialprevents — A.8.8's patching and remediation process addresses known browser vulnerabilities that enable session hijacking (e.g., CVEs in browser software), but T1185 also exploits inherent browser functionality (proxy injection, cookie inheritance, malicious extensions) that vulnerability management does not reach, and zero-days remain unpatched.
- T1187partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, monitoring for attacks exploiting the vulnerability, and alignment with incident management to surface technical vulnerabilities and related events; this catches the post-compromise use of forced authentication (e.g. via anomalous SMB/WebDAV traffic or known vulnerable components) in most cases, with the bounded remainder being pre-compromise adversary-controlled resource setup outside the organization's monitored estate.
- T1189partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for actual attacks, and receiving/sharing vulnerability reports, which can surface drive-by compromise indicators (e.g., exploited browser/plugin versions or post-exploitation artifacts) after the fact; this is a genuine but minority slice of the technique's full kill-chain surface (watering-hole delivery, initial script execution, and exploitation itself largely occur outside organizational visibility).
- T1190partialresponds — A.8.8 requires incident-response alignment, timely action via 5.26 procedures when urgency demands, increased monitoring, and compensating controls (workarounds, virtual patching, traffic filters) once a vulnerability is known and an exploit event is underway; this bounds impact on the realized T1190 technique but does not contain/eradicate the actor or fully restore state, leaving the core response slice (and non-vulnerability-based exploits) uncovered.
- T1195partialprevents — A.8.8 includes supply-chain-adjacent elements — tracking third-party libraries for vulnerabilities, requiring suppliers to ensure vulnerability reporting and disclosure, verifying authenticity of remediation, and using updates from legitimate sources — that partially constrain T1195, but the control's core mechanism is identifying and patching KNOWN vulnerabilities, which does not reach deliberately introduced backdoors baked into software before the organization receives it.
- T1195.001partialdetects — A.8.8's tracking of third-party libraries for vulnerabilities (f) and its procedure to detect vulnerabilities in external components can surface some compromised dependencies, and vulnerability reports / threat intelligence feeds may flag weaponised packages, but the control is designed for known technical vulnerabilities rather than detecting malicious code embedded in dependencies — the core of T1195.001 — so what is caught is a slice rather than the technique's bulk.
- T1195.001partialprevents — A.8.8's tracking of third-party libraries (item f), supplier vulnerability reporting requirements (item c), and threat intelligence consumption can surface known-compromised or suspicious dependencies before incorporation, but the control's core mechanism — identifying and patching disclosed vulnerabilities — does not address malicious code embedded in dependencies that lack a known CVE, and software update management does not apply to software that is malicious from initial receipt.
- T1197partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, monitoring for attacks exploiting known vulnerabilities, and alignment with incident management to surface technical vulnerabilities and associated behaviors, which would detect BITS abuse when it leverages known vulnerable components, unpatched systems, or observable anomalous transfer/job patterns; the remainder is novel/undisclosed BITS abuse without a published vulnerability.
- T1202partialdetects — A.8.8 requires monitoring for vulnerabilities, scanning, penetration testing, and increased monitoring as a compensating control when patches are unavailable; this can surface post-exploitation artifacts of indirect command execution (e.g. anomalous process behavior or known vulnerable utilities) but does not instrument or discover the technique's stealthy pre-execution or in-flight abuse of proxy utilities.
- T1203partialresponds — A.8.8's incident-response tie-in, vulnerability disclosure handling, and post-identification actions (e.g. increased monitoring, workarounds, virtual patching, or following 5.26 procedures) engage some response activities once client-application exploitation is underway, but the clause's dominant focus is pre-exploitation identification and remediation of the vulnerability itself rather than containing/eradication of an in-progress T1203 event.
- T1204.002partialprevents — A.8.8's patching and vulnerability remediation prevents the subset of malicious file attacks that exploit known technical vulnerabilities (e.g., Office macro exploits, PDF reader flaws, browser exploits), but T1204.002 is fundamentally about user execution of a file — many listed file types (.exe, .lnk, .iso, .scr) require no vulnerability to be exploited, and zero-days plus pure social-engineering payloads remain unaffected by the patching regime.
- T1204.003partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and receiving vulnerability reports, which can surface malicious/backdoored images once present in the inventory or runtime; this is genuine but only a slice (pre-deployment upload, naming tricks, and images outside scanned inventory or cloud-provider responsibility remain unseen).
- T1204.005partialdetects — A.8.8's tracking of third-party libraries (item f), vulnerability scanning, and external reporting channels can surface some malicious packages — particularly those reported via threat intel, bug bounty, or known-malicious-package databases — but the control is built around known technical vulnerabilities (CVEs) rather than malicious code, so a novel malicious library without a published advisory largely falls outside its detection mechanism.
- T1210partialresponds — A.8.8's incident-response tie-in, urgency-based activation of 5.26 procedures, increased monitoring, and post-exploitation remediation (patching, virtual patching, workarounds) engage once T1210 exploitation is underway on discovered vulnerable remote services, but the bulk of the clause is pre-compromise identification/evaluation and the control does not itself contain or eradicate the actor
- T1216.001partialprevents — A.8.8's vulnerability management process can identify and remediate the underlying vulnerability that allows PubPrn to proxy execution, but the control does not inherently block the technique's execution path on unpatched systems.
- T1218partialdetects — A.8.8 requires monitoring for vulnerabilities, scanning, penetration testing, and increased monitoring as a compensating control when patches are unavailable; this can surface anomalous use of proxy binaries (e.g. via logs or behavioral indicators) after the fact, but the clause's focus is pre-exploitation vulnerability discovery rather than runtime detection of the signed-binary proxy technique itself, leaving most execution paths outside its primary scope.
- T1218.001partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and increased monitoring to detect actual attacks, all of which surface the use of this technique (especially on unpatched Windows systems where it is a known exploitable vector).
- T1218.001partialprevents — A.8.8 patches specific CVEs in hh.exe/HTML Help and applies compensating controls (virtual patching, access controls) that close some exploitation paths, but the technique fundamentally abuses hh.exe's legitimate functionality to render attacker-controlled CHM content, which vulnerability management cannot reach without removing the binary itself.
- T1218.004partialdetects — A.8.8 requires monitoring for vulnerabilities, scanning, penetration testing, and increased monitoring as a compensating control, which can surface anomalous or suspicious use of InstallUtil as a living-off-the-land binary; this is a genuine but minority slice of the technique's full attack surface (e.g., does not catch every stealthy invocation or pre-execution proxying).
- T1218.015partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and increased monitoring to detect actual attacks, all of which surface the presence or use of vulnerable Electron components or the malicious code they enable.
- T1219partialdetects — A.8.8 requires monitoring for anomalous behaviour, vulnerability scanning, penetration testing, increased monitoring of known-vulnerable systems, and alignment with incident response to surface technical issues; this can discover post-compromise use of remote access tools (especially when tied to known-vulnerable software or anomalous sessions), but the clause's scope is vulnerability-centric rather than broad behavioral detection of legitimate RAT abuse, leaving most in-band or non-vulnerable-tool usage unseen.
- T1219.001partialdetects — A.8.8 requires monitoring for anomalous behaviour, vulnerability scanning, penetration testing, increased monitoring of known-vulnerable systems, and alignment with incident response to surface technical vulnerabilities and related activity; this can detect IDE tunneling when it triggers observable anomalies, uses vulnerable IDE/extensions, or appears in scans/tests, but the control's scope is vulnerability-centric rather than broad behavioral detection of stealthy, legitimate-looking developer workflows, leaving a large remainder of technique executions unseen.
- T1220partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, monitoring for attacks exploiting known vulnerabilities, and alignment with incident management to surface technical vulnerabilities and related anomalous behavior, which would detect most in-the-wild uses of this technique once a CVE or report exists for the abused components (msxml, wmic, etc.).
- T1491.002partialprevents — A.8.8's stated purpose is to prevent exploitation of technical vulnerabilities, and external defacement primarily succeeds by exploiting unpatched vulnerabilities in external-facing web applications — which the clause directly addresses through scanning, patching, virtual patching, and workarounds. The bounded remainder is the technique's paths that bypass vulnerability management: zero-day exploits, vulnerabilities with no available patch, and credential-based access to web administration interfaces.
- T1495partialprevents — A.8.8 prevents firmware corruption where the attack exploits a KNOWN firmware vulnerability that the inventory, scanning, and patching process can identify and remediate, but it cannot prevent zero-day firmware exploits, physical-access attacks, or supply-chain compromises where firmware is corrupted before the vulnerability is known — and firmware patching cycles are slower and less universal than software patching, leaving a substantial remainder.
- T1498.002partialdetects — A.8.8 requires monitoring for vulnerabilities, scanning, penetration testing, and increased monitoring as a compensating control when patches are unavailable; this surfaces some reflection amplifiers (e.g. vulnerable NTP/DNS/memcache instances in the organization's own inventory) but has no vantage point on external reflectors, spoofed traffic, or the attack in flight against the victim.
- T1499partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for attacks exploiting the vulnerability, and alignment with incident detection to surface technical vulnerabilities (including those enabling endpoint resource exhaustion or crashes); this discovers many but not all T1499 realizations, especially novel or non-vulnerability-based ones like pure botnet flooding without a reported flaw.
- T1499partialprevents — A.8.8 prevents the subset of T1499 that relies on exploiting specific technical vulnerabilities to cause persistent crash conditions (patching closes those), but does not prevent resource-exhaustion endpoint DoS or volumetric attacks that do not depend on a known vulnerability being present and unpatched.
- T1499.004partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for attacks exploiting known vulnerabilities, and alignment with incident response to surface exploitation events; this detects some in-flight or post-crash DoS from known vulnerabilities but not zero-days, unmonitored systems, or pre-execution discovery of the technique itself.
- T1499.004partialresponds — A.8.8 requires incident-aligned procedures, increased monitoring, and use of incident response (5.26) for urgent vulnerabilities; this surfaces and contains an in-progress exploitation (including DoS effects) on covered assets, but the clause's core is preemptive patching rather than active containment/eradication once the technique is underway, and many compensating measures (workarounds, awareness) sit outside the verb.
- T1505.005partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and increased monitoring to detect actual attacks, all of which surface the modified/replaced termsrv.dll or anomalous Terminal Services behavior as a technical vulnerability or exploit indicator.
- T1525partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and tracking of third-party components/libraries, which can surface maliciously modified images in an inventory or registry as a known-vulnerable or anomalous artifact; this is genuine detection but only a slice, as the control's mechanisms focus on known vulnerabilities and do not reliably observe the initial implanting act itself or unknown backdoors.
- T1530partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for attacks exploiting known vulnerabilities, and increased monitoring as a compensating control; this surfaces some T1530 realizations (e.g. via anomalous access to misconfigured buckets or exploitation of a known vuln) but does not detect credential abuse, direct API access to properly-configured storage, or the initial misconfiguration itself.
- T1539partialprevents — A.8.8 can patch specific CVEs in browsers, web applications, or libraries that enable cookie theft (e.g., flaws allowing cookie extraction without full system compromise), but T1539 primarily operates through access-based mechanisms — malware reading cookie stores from disk/memory, AitM proxies intercepting sessions, and JavaScript injection via XSS or user execution — none of which are stopped by vulnerability management; the slice A.8.8 reaches is the subset where a patchable CVE is the enabler, not the bulk of the technique.
- T1542partialprevents — A.8.8's purpose is explicitly to prevent exploitation of technical vulnerabilities, and firmware/boot vulnerabilities are a category of technical vulnerability the clause's framework (asset inventory, vulnerability scanning, patch management, compensating controls like virtual patching and shielding) would address if properly implemented; however, the guidance is heavily software-focused (patches, third-party libraries, secure coding) and firmware is often excluded from standard vulnerability management programs, firmware patching is difficult and frequently skipped, and many firmware vulnerabilities have no available patches, so the practical prevention is a slice rather than the bulk.
- T1542.001partialprevents — A.8.8 can identify and patch known firmware vulnerabilities (e.g., vulnerable BIOS/UEFI versions that allow unauthorized modification) through its scanning, patching, and update processes, but the technique often relies on the adversary already having sufficient access to write firmware rather than exploiting a patchable vulnerability, and A.8.8 does not control that access path or provide firmware integrity monitoring.
- T1542.002partialprevents — A.8.8 covers firmware as part of 'software and other technologies' and its patching process can prevent exploitation of known firmware vulnerabilities, but firmware patching is often incomplete, not all firmware vulnerabilities are patchable, and the technique can use supply-chain or physical-access vectors that the control does not address.
- T1542.004partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party components, receiving vulnerability reports, and increased monitoring to detect actual attacks, which surfaces ROMMON firmware anomalies or unauthorized updates on network devices after they occur; this is a genuine but minority slice because the control's primary focus is known CVE-style vulnerabilities in an asset inventory rather than stealthy adversary firmware replacement at boot time, and many ROMMONkit indicators (e.g., physical/local access or TFTP-based overwrite) sit outside routine scanning scope.
- T1542.004partialprevents — A.8.8's vulnerability scanning, penetration testing, and patch management can identify and remediate the firmware vulnerabilities that ROMMONkit exploits, but the control cannot prevent an adversary with privileged access from loading unauthorized firmware if the vulnerability is unknown or unpatched.
- T1546.007partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and tracking of third-party components to surface technical vulnerabilities (including those enabling persistence like a malicious Netsh Helper DLL), but does not mandate detection of the runtime technique itself once the DLL is registered and triggered.
- T1546.016partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests/vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and increased monitoring to detect actual attacks, all of which surface the post-install execution or anomalous installer behavior associated with this technique on Linux/macOS/Windows platforms.
- T1546.018partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and tracking of third-party libraries/source code, which can surface Python startup-hook abuse (e.g. anomalous .pth or sitecustomize.py files) after it is present; this is genuine but only a slice, as the control's focus is known technical vulnerabilities rather than novel persistence implants and many implementations lack the specific file-integrity or Python-path monitoring needed to catch it reliably.
- T1547.008partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in products/components (including third-party), tracking of third-party libraries, and increased monitoring as a compensating control, all of which surface the presence of a malicious LSASS driver as a technical vulnerability or anomalous component on Windows assets.
- T1548.001partialprevents — A.8.8's vulnerability scanning, penetration testing, and remediation procedures can identify and remove unnecessary setuid/setgid binaries on existing systems, partially preventing the 'find and exploit existing binaries' variant; however, the control is fundamentally about software vulnerability management rather than configuration hardening, cannot prevent an adversary from setting these bits on their own code after gaining access, and does not mandate the kind of continuous configuration baselining that would close the gap.
- T1548.002partialprevents — A.8.8 can prevent UAC bypass where a known patchable vulnerability or remediable feature exists by patching or applying compensating controls, but many UAC bypass methods use legitimate auto-elevating Windows components or unpatched/unknown techniques, so prevention is incomplete.
- T1552partialdetects — A.8.8 requires monitoring for vulnerabilities, increased monitoring on vulnerable systems, vulnerability scanning/penetration testing, and receiving reports, which can surface the presence of unsecured credential artifacts (e.g. via known-vulnerable credential stores or post-exploit indicators) but does not broadly instrument for credential-search behaviors across all platforms or storage locations.
- T1552.005partialdetects — A.8.8 requires monitoring for vulnerabilities, increased monitoring as a compensating control, vulnerability scanning/penetration testing, and alignment with incident management to surface technical vulnerabilities; this can detect the presence of credentials or misconfigurations exposed via the Instance Metadata API (or related SSRF), but does not broadly instrument or surface the adversary technique of querying the API itself from a compromised instance.
- T1552.005partialprevents — A.8.8's vulnerability scanning, penetration testing, and patch management can identify and remediate SSRF vulnerabilities that enable the proxy-based vector of T1552.005, but the metadata API itself is a feature (not a patchable vulnerability) and direct access from a compromised instance is outside the control's mechanism, leaving the bulk of the technique's surface unaddressed.
- T1553partialprevents — A.8.8 can patch vulnerable trust mechanisms and apply workarounds that block subversion through known technical flaws, but it cannot prevent stolen code-signing certificates or privileged permission/registry modifications that do not exploit a vulnerability.
- T1553.001partialdetects — A.8.8's vulnerability scanning tools and penetration tests can identify macOS systems with known Gatekeeper bypass vulnerabilities (e.g., outdated macOS versions with logic errors in Gatekeeper), and the clause's 'increasing monitoring to detect actual attacks' measure provides some runtime detection capability, but the control's primary function is vulnerability identification and remediation rather than continuous monitoring of exploitation, so detection of the active technique is bounded.
- T1553.001partialprevents — A.8.8's patch management process can apply Apple security updates that remediate specific Gatekeeper bypass vulnerabilities (e.g., the macOS 13 Ventura notarization-on-relaunch fix), but the technique also encompasses logic errors, design-level issues, and methods like writing to previously opened applications that may lack available patches, and prevention depends on vendor release timing and organizational patch cadence.
- T1553.003partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests/vulnerability assessments, tracking of third-party libraries/source code, receiving vulnerability reports, and increased monitoring to detect attacks exploiting known vulnerabilities; these surface T1553.003 once the hijack (a known technique with published PoCs) appears in asset inventories or is reported/scanned, though pre-compromise adversary acquisition of SIP/trust components on external infrastructure is unseen.
- T1553.005partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and increased monitoring when no patch exists; these can surface MOTW-bypass artifacts (e.g. anomalous container/mount activity or known vulnerable formats) after the fact, but the control's scope is technical vulnerability management of assets/components and does not broadly instrument the specific MOTW bypass technique itself.
- T1553.005partialprevents — A.8.8 can identify MOTW-bypass behaviour as a vulnerability, apply vendor patches when Microsoft addresses container-file MOTW propagation, and deploy the workarounds the clause itself enumerates (blocking container file types, virtual patching, access controls, increased monitoring), but the technique exploits a design feature rather than a patchable flaw, the available mitigations are partial and trade against business function, and the technique can still be attempted against any container file the perimeter lets through.
- T1555.005partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in products/services (including third-party components), tracking third-party libraries, receiving vulnerability reports, and increasing monitoring to detect attacks exploiting known vulnerabilities; this surfaces T1555.005 when it relies on exploitable flaws in password manager implementations (e.g., memory scraping via known CVEs or brute-force weaknesses), though it does not broadly detect post-exploitation credential theft from an unpatched but non-vulnerable manager.
- T1555.005partialprevents — A.8.8 patches known software vulnerabilities in password managers (e.g., CVE-2019-3610), preventing the exploitation-based subset of T1555.005, but does not address memory extraction after legitimate unlock (a design feature, not a vulnerability) or brute forcing of weak master passwords (an authentication issue covered by A.8.5).
- T1555.006partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, monitoring for actual attacks, receiving vulnerability reports, and alignment with incident management to surface technical vulnerabilities (including in cloud services via agreements), which would detect misconfigurations or privileges enabling secret retrieval from stores like AWS Secrets Manager, Azure Key Vault; mostly because detection depends on the specific inventory/monitoring scope chosen and does not guarantee coverage of all adversary access paths or post-compromise secret requests.
- T1556.002partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, tracking of third-party libraries, receiving vulnerability reports, and increased monitoring to detect actual attacks, all of which surface the presence or use of a malicious password filter DLL as a technical vulnerability (or its indicators) after it is present.
- T1556.007partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in products/services (incl. third-party components), tracking third-party libraries, receiving vulnerability reports, and increased monitoring to detect attacks exploiting known vulnerabilities; this surfaces the backdoored hybrid auth processes (PTA agent DLL, AD FS config, registered rogue agent) once they are a detectable technical vulnerability or anomalous behavior, with the bounded remainder being stealth modifications that evade all listed detection methods before exploitation.
- T1557partialprevents — A.8.8's patching and configuration guidance can close some AiTM vectors (e.g., enforcing modern TLS, patching DNS/network software, disabling LLMNR), but the technique class exploits protocol design behaviors (ARP, DNS, LLMNR) and network positioning that are not software vulnerabilities to be patched, so the technique as a whole is not prevented.
- T1558.004partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and increased monitoring when mitigations are applied; these can surface observable precursors or artifacts of AS-REP roasting (e.g. anomalous AS-REQ volume or LDAP enumeration) on the monitored estate, but the core technique (offline cracking of captured AS-REP data) occurs outside the organization's visibility and many steps produce no detectable event until credential use.
- T1558.005partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in products/services (including third-party components), increased monitoring as a compensating control, and alignment with incident management to surface vulnerabilities that enable techniques like ccache theft; this covers the bulk of observable post-compromise artifacts on Linux/macOS with only narrow remainder for purely memory-resident ccache handling outside scanned inventory.
- T1559partialdetects — Addressing vulnerabilities in inter-process communication mechanisms reduces opportunities for attackers to abuse COM, DDE, or similar channels to execute code.
- T1559.002partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests/vulnerability assessments, tracking of third-party libraries, procedures to detect vulnerabilities in products/services (including external components), and increased monitoring for actual attacks, all of which surface DDE-based execution as anomalous or vulnerable behavior on Windows assets.
- T1559.002partialprevents — A.8.8 is a process control whose purpose is explicitly to prevent exploitation of technical vulnerabilities, and DDE abuse is a well-documented vulnerability with Microsoft-provided mitigations (registry keys, GPO settings, updates tracked under ADV170021) that a competent vulnerability management program would identify, apply, and verify — but the control is the management process, not the technical mitigation itself, so prevention depends on the organization actually implementing the configuration changes, and local exploitation vectors via DCOM are harder to reach through the typical patch-and-configure workflow.
- T1559.003partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and increased monitoring to detect actual attacks, all of which surface the improper XPC input handling or client validation weaknesses (often published as CVEs) that enable this macOS-specific technique.
- T1559.003partialprevents — A.8.8 identifies and remediates known XPC service vulnerabilities through patching, supplier disclosure, and scanning, which prevents exploitation of those specific flaws; the remainder is zero-days, design-level validation/sanitization flaws in custom code that scanning rarely surfaces, and vulnerabilities in third-party apps where the supplier does not release a fix.
- T1560.002partialdetects — A.8.8 requires monitoring for vulnerabilities, scanning, penetration testing, and increased monitoring as a compensating control when no patch exists; this can surface anomalous use of archival libraries (or their presence in unpatched software) after the fact, but does not instrument or detect the runtime technique of an adversary invoking a library to archive data for exfiltration.
- T1563partialdetects — A.8.8 requires monitoring for vulnerabilities, vulnerability scanning, penetration testing, increased monitoring on known issues, and alignment with incident response to surface technical vulnerabilities and related events; this can detect some hijacking artifacts (e.g. anomalous sessions or exploited vulnerable remote services) but does not broadly instrument for session hijacking behaviors across RDP/SSH/telnet.
- T1566.001partialprevents — A.8.8's patching and remediation activities prevent the subset of spearphishing attachments that rely on exploiting known, patchable software vulnerabilities (e.g., Office exploits), but the technique also succeeds via direct user execution of macros or executables without any vulnerability, via zero-day exploits that cannot yet be patched, and via the social engineering delivery that A.8.8 does not address.
- T1566.002partialprevents — A.8.8's vulnerability management process can identify and remediate the software vulnerabilities that spearphishing links exploit (e.g., browser or application flaws), but it does not prevent the user from clicking the link or the email from being delivered, so the technique is only partially addressed.
- T1569.002partialdetects — A.8.8 requires monitoring for vulnerabilities, scanning, penetration testing, and increased monitoring as a compensating control when patches are unavailable; this can surface anomalous service creation/execution tied to known vulnerable components or post-exploitation, but does not broadly instrument or detect the technique itself across Windows service control manager abuse.
- T1574partialdetects — A.8.8's vulnerability scanning and penetration testing can identify many of the underlying weaknesses that enable T1574 (unquoted service paths, weak service file permissions, DLL search order issues, vulnerable third-party libraries), but it does not detect the active hijacking of execution flow in real-time — it surfaces the preconditions, not the exploitation itself.
- T1574.001partialprevents — A.8.8 can patch specific vulnerabilities that enable DLL hijacking (e.g., applications with unsafe DLL loading paths, OS-level search-order issues), and its secondary measures (access controls, virtual patching, monitoring) constrain some instances, but the technique fundamentally abuses legitimate OS/application DLL-loading behavior rather than exploiting a single patchable CVE, so the bulk of the technique remains reachable.
- T1574.005partialprevents — A.8.8 identifies vulnerable installers through scanning/pen tests and applies vendor patches or compensating controls (workarounds, virtual patching, access controls), but the underlying weakness resides in third-party installer software the organization cannot directly fix, and not all instances are caught or patchable before exploitation.
- T1574.007partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, monitoring for vulnerabilities in products/services, and increased monitoring to detect attacks exploiting known vulnerabilities; this surfaces the technique when it leverages a known vulnerable binary, library, or configuration exposed via PATH hijacking, with the bounded remainder being novel/undisclosed instances of the technique.
- T1574.008partialprevents — A.8.8's vulnerability management process (scanning, pen testing, remediation coordination) can identify programs vulnerable to search-order hijacking and drive fixes such as code changes to use full paths, access controls on program directories, or virtual patching, but the control is a process that coordinates remediation rather than directly implementing the technical prevention — the actual blocking depends on the specific remediation actions taken, which are typically performed by other controls (A.8.28 secure coding, A.8.2 access control, A.8.16 monitoring).
- T1574.009partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in third-party libraries/source code, and increased monitoring to detect actual attacks exploiting known vulnerabilities; this surfaces the unquoted-path condition (a known, scannable misconfiguration) in assets and can detect exploitation in flight, with the bounded remainder being novel/undisclosed instances before they reach scanning sources.
- T1574.010partialprevents — A.8.8's vulnerability scanning (d) and penetration testing (e) can identify weak service file permissions, and its remediation guidance (i.3-4) covers adding access controls and virtual patching, but the control's primary mechanism is software patching for CVEs, not configuration hardening of file permissions, so prevention is indirect and depends on the scanning scope catching this class of weakness.
- T1574.012partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and increased monitoring to detect actual attacks, all of which surface COR_PROFILER-based hijacking when manifested as a known vulnerable .NET component, profiler DLL, or anomalous process behavior.
- T1578.002partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and logging of vulnerability management steps, which can surface anomalous creation of cloud instances (especially if tied to known vulnerable images, unapproved configs, or post-creation vuln assessment), but the control's scope is primarily vulnerability identification rather than general creation-event detection and many stealthy or policy-compliant creations go unseen.
- T1584.008partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in assets (incl. third-party components and network devices via inventory and scanning), and increased monitoring as a compensating control, which can surface some compromised network devices or related vulns post-compromise; however, the technique occurs pre-compromise on external third-party infrastructure outside the organization's estate and monitoring scope, so only a slice is detectable.
- T1588.006partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for reports, and awareness of disclosures, which can surface adversary activity of acquiring vulnerability information (especially public or vendor-reported ones); however, it does not instrument or observe the adversary's own pre-compromise research, closed-database access, or targeting of researchers, leaving a large slice of the technique unseen.
- T1592.002partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for reports, and awareness of third-party components, which can surface the adversary's reconnaissance of installed software versions (especially when it overlaps with known-vulnerable components or produces observable artifacts), but the control's scope is limited to post-identification vulnerability management rather than broadly detecting all pre-compromise host-software gathering techniques on PRE platforms.
- T1599partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and increased monitoring when a vulnerability is known; these can surface the compromise of a boundary device (or its vulnerable state) once present on the organization's estate, but the technique's upstream reconnaissance, device acquisition, and external bridging steps sit outside that scope.
- T1599partialprevents — A.8.8 patches and remediates known technical vulnerabilities in network devices, which prevents the subset of T1599 that relies on exploiting a CVE in router/firewall firmware; it does not reach credential-based compromise, zero-days, or abuse of legitimate device features, all of which are equally valid paths to bridging the boundary.
- T1602.002partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, monitoring for attacks exploiting known vulnerabilities, increased monitoring when no patch exists, and alignment with incident management to surface technical vulnerabilities (including those enabling config access via SNMP/SMI on network devices); this detects the technique when it triggers observable indicators, with the bounded remainder being stealthy/pre-compromise dumps that produce no detectable anomaly.
- T1606.002partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for anomalies, and increased monitoring to detect attacks exploiting known vulnerabilities; forged SAML tokens (often from stolen signing certs or misconfigurations) can be surfaced by these when the cert compromise or anomalous auth is in scope, but the control's focus is on known technical vulns in an asset inventory rather than novel forgery or pre-compromise cert theft, leaving a large remainder.
- T1610partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and increased monitoring when vulnerabilities are known; these can surface container deployment anomalies or vulnerable/privileged containers post-deployment (especially in cloud/K8s via asset inventory and scanning), but the control's scope is technical vulnerability management rather than general detection of the adversary technique itself, leaving most deployment vectors (e.g., via APIs, dashboards, or benign images) outside its primary mechanism.
- T1611partialprevents — A.8.8's vulnerability scanning, patching and remediation address the subset of T1611 escapes that rely on exploiting known technical vulnerabilities (kernel, container runtime, hypervisor CVEs), but a substantial portion of container/VM escapes rely on misconfigurations — privileged containers, bind mounts, exposed docker.sock — which are configuration issues outside A.8.8's mechanism, and zero-day exploits remain unprevented until disclosed and patched.
- T1647partialdetects — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and increased monitoring to detect actual attacks, all of which surface plist modification as a post-exploitation technique or indicator when it leaves detectable artifacts or known vulnerable components.
- T1649partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in products/services/third-party components, and increased monitoring when no patch exists; these surface certificate-related misconfigurations, weak enrollment rights, exposed CAs, and unpatched certificate services that enable T1649, covering the bulk of its technical vectors with a bounded remainder in post-compromise golden-certificate forging that may evade preemptive detection.
- T1653partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, and tracking of third-party components plus an audit log of all steps; these surface power-setting abuse (a post-compromise configuration change or utility misuse) when it matches known vulnerable patterns, reported IOCs, or anomalous behavior, with the bounded remainder being entirely novel or stealthy abuse that evades scanning and monitoring.
- T1671partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in products/services (including third-party/cloud components), receiving reports, and increased monitoring as a compensating control, all of which surface malicious OAuth integrations as a technical vulnerability in the SaaS/cloud environment after they are present.
- T1675partialdetects — A.8.8 requires vulnerability scanning, penetration testing, monitoring for anomalies, increased monitoring of vulnerable systems, and alignment with incident management to surface technical vulnerabilities and related activity; this can detect exploitation of ESXi flaws enabling T1675 (as in the cited 2023 zero-days), but does not broadly instrument guest-VM command execution or the specific APIs/tools involved.
- T1677partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in third-party libraries/source code, and procedures to detect vulnerabilities in products/services (including external components used in builds), which surfaces poisoned pipeline code or artifacts when they match known patterns or are reported; this is a genuine but minority slice because most T1677 variants (esp. novel/zero-day injections via PRs or indirect files) are not known vulnerabilities until after exploitation, and the control's scanning focus is post-deployment or on inventory rather than real-time CI pipeline integrity.
- T1685.002partialdetects — A.8.8 explicitly requires increased monitoring to detect actual attacks exploiting a known vulnerability, vulnerability scanning/penetration testing, receiving reports, and alignment with incident management for communicating vulnerability data; this surfaces some T1685.002 instances (e.g. via anomalous config changes or post-disable attack activity) but does not broadly instrument or detect the logging-disable technique itself across cloud platforms.
- T1686.002partialdetects — A.8.8 explicitly requires vulnerability scanning, penetration testing, monitoring for vulnerabilities in products/services/components, receiving reports, and increased monitoring as a compensating control, all of which surface the vulnerable firewall configurations, rule changes, or exploited device weaknesses that enable T1686.002; the bounded remainder is post-compromise adversarial changes that are not themselves a published vulnerability.
- T1689partialprevents — A.8.8's version-aware asset inventory, software update management, and removal of outdated software versions can prevent some downgrade attacks (e.g., by eliminating legacy PowerShell versions or outdated boot managers), but the control addresses vulnerabilities in current software rather than the backward-compatibility mechanism that downgrade attacks exploit, leaving protocol downgrade (HTTPS→HTTP) and similar vectors largely outside its reach.
Prevented OWASP Web Top 10 (2025) risks (19)
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
- A05mostlyfinds — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, receiving reports, and evaluating identified vulnerabilities, which directly surfaces injection flaws (SQL, command, XSS, etc.) in deployed systems, code, and components.
- A07mostlyfinds — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, receiving vulnerability reports, and evaluating reports to discover technical vulnerabilities, which directly surfaces most authentication failures (weak credentials, flawed reset flows, session issues) once they exist as exploitable flaws in deployed systems or components.
- A09mostlyfinds — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, procedures to detect vulnerabilities in products/services (including external components), and receiving/analyzing reports, all of which surface missing or ineffective logging/alerting as a technical vulnerability.
- A10mostlyfinds — A.8.8 explicitly requires vulnerability scanning tools, penetration tests, vulnerability assessments, tracking of third-party libraries, procedures to detect vulnerabilities in products/services, and receiving/analyzing reports, all of which surface error-handling, fail-open, and inconsistent-state weaknesses that fall under A10:2025.
- A01partialfinds — A.8.8 explicitly requires vulnerability scanning, penetration testing, vulnerability assessments, tracking third-party libraries, receiving reports, and evaluating identified issues, which surfaces many Broken Access Control instances (e.g. missing checks, IDOR) after deployment; however, this is only a slice as the category also includes design/implementation defects best found by code analysis rather than post-deployment vuln scanning.
- A03partialfinds — A.8.8 explicitly requires vulnerability scanning, penetration testing, tracking of third-party libraries, receiving reports, and evaluating systems against vulnerability information, which discovers vulnerable/outdated dependencies (the largest slice of A03); it does not address compromised build pipelines or signing infrastructure.
- A03partialremoves — A.8.8 explicitly requires acting on identified vulnerabilities by developing/applying patches, updates, workarounds, virtual patching or other mitigations that remove or neutralize the vulnerable/outdated dependency (the dominant member of A03); it does not address compromised build pipelines or signing infrastructure, which remain after the control runs.
- A05partialremoves — A.8.8 explicitly requires developing remediation (patches/updates), testing it, and applying it (or workarounds/virtual patching) to remove the vulnerable condition once identified; this directly remediates many injection flaws (e.g. via code changes or filters), but leaves a bounded remainder for cases with no available update, unpatchable interpreters, or where the control falls back only to detection/monitoring rather than removal.
- A06partialfinds — A.8.8 explicitly requires vulnerability scanning, penetration testing, vulnerability assessments, tracking of third-party libraries, and evaluation of reports to discover technical vulnerabilities, which surfaces some design-level weaknesses (e.g. missing controls detectable via testing or known patterns) but not the bulk of architecture-level insecure design flaws that require threat modeling or secure design review rather than post-deployment scanning.
- A10partialremoves — A.8.8's core purpose and procedures (identify, evaluate, patch/update, workaround, virtual patch, increased monitoring) directly remove or correct mishandled error paths, fail-open logic, and leaked information once discovered, but only for those that surface as identifiable technical vulnerabilities rather than all design or code-level exceptional-condition defects.
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.