A.6.3 People
Information security awareness, education and training
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
- AT-2fullcovers — The ISO control establishes a recurring, role-aware awareness program that directly fulfills the intent of AT-2 to ensure all users understand their security responsibilities.
- AT-3fullcovers — By requiring targeted training for technical teams and skill-gap remediation, the ISO control satisfies AT-3’s mandate for role-based training aligned with job functions.
Aligned NIST CSF 2.0 outcomes (9)
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
- GV.RR-04partialcovers — A.6.3's focus on awareness/education/training to fulfill security responsibilities accounts for the bulk of including cybersecurity in HR practices (onboarding, role-specific training, ongoing awareness), but leaves a residual of other HR practices (hiring screening, disciplinary processes, offboarding) that the control does not address.
- PR.AT-01explicit mandateimplements — The ISO control establishes and operates a recurring awareness programme that ensures all personnel understand their security responsibilities and baseline controls, directly satisfying the CSF outcome of providing general awareness and training.
- PR.AT-02domain mandateimplements — The ISO control requires a targeted education and training plan for technical teams that need specialized skills, matching the CSF outcome of equipping individuals in specialized roles with the necessary knowledge and skills.
Related weaknesses / CWE (2402)
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-1428mostlyprevents — Graded mostly by the owner: using HTTP instead of HTTPS is either a deliberate trade of security for convenience or a gap in knowledge, and in either case awareness and training help.
- CWE-523mostlyprevents — Following the owner's ruling on the closely related CWE-1428 (Reliance on HTTP instead of HTTPS), unprotected transport of credentials is either a conscious choice of convenience or a knowledge gap, and education addresses both; training keeps most instances from arising, with a nameable remainder in developers who know the rule and choose convenience anyway.
- CWE-1004partialprevents — Training developers on secure cookie handling (including the HttpOnly flag) reduces instances of this implementation defect, but the effect is a minority one because the flag is a specific code-level detail that training alone does not reliably catch, with secure coding standards, code review and SAST carrying more of the burden.
- CWE-1007partialprevents — Training developers about homoglyph attacks can lead some to implement proper handling (punycode conversion, character restrictions), but this is a specialized technical issue where most general security training does not reach deeply enough to prevent the design/implementation choice that introduces the weakness.
- CWE-102partialprevents — Security training can teach developers to avoid duplicate Struts validation form names and keep validation logic in sync, but as a human-practice control it only reduces this implementation mistake rather than preventing it fully.
- CWE-1021partialprevents — Training developers on web application security can make them aware of clickjacking and the need for X-Frame-Options or CSP frame-ancestors headers, but this is a specific technical implementation detail that requires deliberate coding, and not all developers receive this specialized training; the remainder is developers who lack the specific knowledge or who omit the protection despite knowing about it.
- CWE-1022partialprevents — Training developers on web security can teach the rel='noopener noreferrer' requirement and prevent some instances of tabnabbing, but this is a niche technical detail that not all developers receive specific training on, and even trained developers may forget to apply it — consistent with the A.6.3 vs CWE-598 anchor for similar developer-introduced weaknesses.
- CWE-1024partialprevents — Training in secure coding practices and type-system awareness reduces some instances of incompatible-type comparisons by raising developer knowledge, but the defect is subtle and often arises from implicit assumptions about casting/conversion that even trained developers make; the effect is a minority slice, consistent with the A.6.3 -> CWE-598 anchor at the same rung.
- CWE-103partialprevents — Training can make developers aware of the need to define and correctly call the Struts validate()/super.validate() chain, preventing some instances, but the protection depends on fallible human practice and may not cover every framework-specific coding oversight.
- CWE-105partialprevents — Training technical teams in secure coding practices (which A.6.3 covers) helps some developers remember to add validators for all Struts form fields, but the defect is a specific implementation detail and training is fallible, so only a minority of instances are prevented.
- CWE-1050partialprevents — Training technical teams on secure coding and resource management (per A.6.3's education/training guidance) helps some developers avoid loops that exhaust platform resources, but the practice is fallible and most awareness content targets broader security responsibilities rather than this specific implementation defect, leaving the majority of instances to arise.
- CWE-1065partialprevents — Training technical teams on proper use of application server APIs and resource management best practices can reduce instances of this implementation defect, but the issue is a niche technical choice that most awareness programmes do not specifically target, leaving a substantial remainder.
- CWE-108partialprevents — Training can make Struts developers aware that every Action Form requires a corresponding validation form, reducing instances through knowledge transfer, but this is a narrow framework-specific implementation detail where even trained developers make coding mistakes, so training addresses only a minority of instances.
- CWE-1082partialprevents — Training technical teams in secure coding practices and language-specific pitfalls can teach developers to avoid the 'delete this' pattern, but this is a niche implementation-level reliability issue that general security awareness rarely addresses and developers remain fallible.
- CWE-1083partialprevents — Training can make developers aware that all data access should go through the designated data manager component, reducing some instances of this architectural violation, but the weakness is an implementation/code-level choice that training cannot reliably prevent — developers may still bypass the component for convenience or under deadline pressure, mirroring the A.8.28 -> CWE-502 and A.6.3 -> CWE-598 anchors at `partial`.
- CWE-1088partialprevents — Training technical teams in secure coding practices (A.6.3's education/training portion) raises the odds a developer sets timeouts on synchronous remote calls, but developers are fallible and the strongest control for this code-level defect is testing/review (A.8.29), so training moves only a minority of instances.
- CWE-109partialprevents — Training can make developers aware that disabling the Struts Validator exposes the application to XSS and other input-validation weaknesses, but the decision to set validate="false" is often a deliberate convenience/debugging choice that survives awareness, so only a minority of instances are prevented.
- CWE-1091partialprevents — Training technical teams on secure coding practices (including resource management) can reduce instances of missing destructor invocations, but this is a subtle programming defect that general security awareness rarely addresses and developers still make despite training.
- CWE-1098partialprevents — Education and training for technical teams can teach pointer/copy-constructor discipline (e.g. C++ Rule of Three), preventing a minority of instances, but this is a specialized implementation defect that most general security awareness does not reach and developers remain fallible.
- CWE-11partialprevents — A.6.3's training of technical teams on secure configuration and deployment practices lowers the odds a developer or build engineer deploys a debug binary to production, but training is a fallible human practice and does not stop the misconfiguration from being written into web.config or the build pipeline.
- CWE-1102partialprevents — A.6.3's technical training portion can help developers who are specifically trained on portability and cross-platform data representation issues avoid introducing machine-dependent constructs, but this is a narrow technical concern that general security awareness training does not reach, so only a minority of instances are prevented.
- CWE-1106partialprevents — Training on secure coding practices can teach developers to use symbolic constants instead of literals, reducing some instances, but this is a code-quality/maintainability issue rather than a direct security concern, so it is a minority effect of a fallible human practice.
- CWE-1109partialprevents — Training in secure coding and code-quality practices can make some developers more alert to reusing variables for distinct purposes, but the issue is a subtle code-quality defect that most often surfaces in code review or static analysis rather than from a knowledge gap, so training moves only a minority of instances.
- CWE-111partialprevents — Training raises awareness that JNI calls expose Java applications to native-code weaknesses, so educated developers are less likely to introduce unsafe JNI usage, but the effect is a minority one because the weakness requires specialized native-code safety knowledge, the decision to use JNI is often driven by functional necessity, and even trained developers remain fallible on native-language buffer overflows and similar defects — the strongest control here is A.8.29 security testing.
- CWE-1122partialprevents — Training technical teams in secure development practices can include awareness of code complexity and maintainability, which may reduce some instances of excessive Halstead complexity, but the clause does not specifically target code-quality metrics and the effect is fallible human practice rather than a mechanism that keeps the weakness from arising.
- CWE-1125partialprevents — Training can raise developer awareness of attack-surface concepts and influence design choices toward fewer exposed endpoints, but excessive attack surface is fundamentally an architectural and feature-scope property driven by design trade-offs and time pressure, not a knowledge gap that education reliably closes.
- CWE-1127partialprevents — Awareness and technical training can teach developers and build engineers to enable adequate compiler warnings, so it prevents some warning-deficient builds, but as a human-practice control it does not itself set or enforce compiler flags and many projects still compile with insufficient defaults.
- CWE-113partialprevents — Training can reduce CRLF-injection mistakes by teaching developers to validate header-bound input, but it does not itself neutralize CRLF sequences and leaves coding, review, and testing failures possible.
- CWE-1174partialprevents — Training ASP.NET developers on secure coding practices and framework features can reduce instances of improper model validation by closing the knowledge gap about the framework's validation capabilities, but the effect is limited to a minority of instances because the weakness is a specific framework feature that requires targeted training content and even trained developers misconfigure specific framework features.
- CWE-1188partialprevents — Training raises developer awareness about choosing secure defaults, but the weakness is a code-level implementation choice often driven by ease-of-use assumptions, and training is fallible — it moves a minority of instances, consistent with the A.6.3 vs CWE-598 anchor and the A.8.28 vs CWE-79 reading that practice-based controls reach only a slice.
- CWE-12partialprevents — Training can make ASP.NET developers aware that custom error pages must be enabled and how to configure the <customErrors> tag, reducing some instances of this misconfiguration, but it is a specific technical configuration detail that general awareness training often omits and that even trained developers can forget or misconfigure.
- CWE-120partialprevents — A.6.3's training of technical teams in secure coding practices (including awareness of unsafe functions like strcpy, gets, scanf) helps some developers avoid introducing classic buffer overflows, but training is fallible and a different clause (A.8.29 security testing) carries the stronger effect, matching the A.8.28 -> CWE-502 anchor's reasoning.
- CWE-1230partialprevents — Training can raise developer awareness that metadata (search indices, activity dates, statistical reports) can leak sensitive information, but this is a subtle architecture-and-design consideration that requires careful analysis of every derived data store, and most developers will not think of it even after training.
- CWE-1236partialprevents — Training developers about CSV/formula injection risks reduces a minority of instances by making them aware of the need to neutralize leading '=' and other formula triggers, but the practice is fallible and the strongest controls (secure coding standards, code review, security testing) carry the larger effect, matching the A.6.3 -> CWE-598 and A.8.28 -> CWE-79 partial pattern.
- CWE-124partialprevents — Training on secure coding practices (the technical-team portion of A.6.3) reduces some buffer-underwrite instances by raising developer awareness of bounds-checking and pointer arithmetic, but developers remain fallible and the clause mandates a practice rather than a mechanism, so only a minority of instances are prevented — consistent with the A.6.3 -> CWE-598 anchor at `partial`.
- CWE-1240partialprevents — A.6.3's training of technical teams can build cryptographic skills and reduce instances where developers choose risky primitives out of ignorance, but cryptographic implementation is highly specialized and even trained developers fall into subtle traps (MD5 use, LFSR for randomness, nonce reuse), so training moves a minority of instances.
- CWE-1241partialprevents — Training technical teams on secure development can help some developers recognize the need for cryptographically secure RNGs and avoid predictable ones like LFSR or mt_rand(), but the knowledge is specialized, the common pattern is a secure design switched to an insecure implementation under constraints, and the strongest controls (secure coding, security testing) carry the bulk of the effect.
- CWE-125partialprevents — A.6.3's education and training of technical teams can raise developer awareness of memory-safety practices (bounds checking, length validation) and reduce some out-of-bounds read introductions, but training is fallible and the strongest controls for this implementation-phase defect are secure coding (A.8.28) and security testing (A.8.29), so the effect is a minority one.
- CWE-1254partialprevents — Training developers about constant-time comparison functions and timing side-channels can prevent some instances of this subtle implementation defect, but it is specialized knowledge that most developers do not retain or apply consistently, so only a minority of instances are prevented.
- CWE-126partialprevents — A.6.3's education and training component can equip developers with memory-safety knowledge that prevents some buffer over-reads, but the clause's primary mechanism is general awareness rather than deep secure-coding practice, and trained developers remain fallible on subtle memory-safety defects.
- CWE-1275partialprevents — Training can teach developers to set the SameSite attribute on sensitive cookies, but this is a specific implementation detail that requires targeted web-security knowledge; most developers receiving general awareness training will not internalize this particular attribute setting, so only a minority of instances are prevented.
- CWE-1285partialprevents — Training developers in secure coding practices (input validation, bounds checking) raises awareness of the need to validate indices/positions/offsets before use, reducing some instances of this implementation defect, but the practice is fallible and the actual code change requires more than awareness, so only a minority of instances are prevented.
- CWE-1288partialprevents — Training technical teams on input validation practices reduces the odds a developer omits cross-field consistency checks, but CWE-1288 is a subtle implementation defect that even trained developers miss, so the effect is a minority of instances.
- CWE-1289partialprevents — Training raises awareness of case-insensitivity, encoding equivalence and similar gotchas (the XSS example in CWE-1289's own description is exactly the kind of pitfall secure-coding education addresses), but the defect is subtle and implementation-specific, so even well-trained developers miss it; the effect is a minority one, consistent with A.6.3's other developer-introduced-weakness grades.
- CWE-129partialprevents — Training developers on secure coding practices (input validation, bounds checking) reduces instances of improper array index validation, but is fallible — developers can still write code with missing or incorrect bounds checks even after training, leaving a substantial remainder.
- CWE-1291partialprevents — A.6.3's technical training can raise awareness of cryptographic key separation practices among firmware/hardware engineers, but the weakness typically arises from hardware-constraint and business decisions (e.g., silicon real estate economy, future-proofing choices) that training alone does not reach, leaving the majority of instances unaffected.
- CWE-1295partialprevents — Training developers about what should not appear in debug messages reduces some instances of this weakness, but it is a practice-based control whose effect depends on developer judgment at implementation time, leaving a majority of instances unaffected.
- CWE-13partialprevents — Training developers on secure configuration practices reduces instances of plaintext passwords in config files, but developers remain fallible and the practice catches only a minority of cases, consistent with the A.6.3 -> CWE-598 anchor at the same rung.
- CWE-130partialprevents — Training raises developer awareness of input validation and parsing hazards, which catches a minority of length-parameter inconsistencies before they ship, but the strongest effect on this implementation-phase defect belongs to secure coding (A.8.28) and security testing (A.8.29), and human practice is fallible.
- CWE-131partialprevents — Training technical teams on secure coding practices (including buffer handling and integer overflow awareness) reduces but does not eliminate incorrect buffer size calculations; the defect is a specific arithmetic/implementation error that even trained developers commit, and the strongest control is testing (A.8.29), not training.
- CWE-1327partialprevents — Training technical teams on secure configuration (which A.6.3 explicitly addresses) reduces instances of binding to 0.0.0.0, since this is often a convenience choice or knowledge gap, but the effect is a minority one because not all training programs cover this specific configuration nuance and the convenience factor of 'it just works' can override knowledge.
- CWE-1333partialprevents — Training can teach developers about regex backtracking risks and safer patterns, but CWE-1333 is a subtle implementation defect requiring specialized knowledge; most instances arise from developers who either were not trained on this topic or did not retain the guidance, leaving a majority of cases unaffected.
- CWE-1336partialprevents — Training developers on template engine security (sandboxing, escaping, untrusted input handling) reduces some instances of CWE-1336, but the topic is specialized and not all developers receive this specific training, so the effect is a minority one — parallel to A.6.3 vs CWE-598.
- CWE-134partialprevents — Training developers about format string risks prevents some instances where the defect arises from a knowledge gap (e.g., writing printf(input) instead of printf("%s", input)), but the practice is fallible and a different control (A.8.29 security testing) carries the stronger effect, matching the A.8.28 -> CWE-502 and A.8.28 -> CWE-79 anchors.
- CWE-1385partialprevents — Training can teach developers to validate WebSocket origins, but this is a specific implementation detail that training reaches only as a minority of cases, parallel to A.6.3 vs CWE-598 where the effect on a developer-introduced code defect is real but bounded.
- CWE-1386partialprevents — Training can raise developer awareness of Windows junction/mount point attack patterns and the need to check for reparse points when opening files, but this is a niche NTFS-specific implementation detail that most developers will not encounter in general training, and the actual mitigation requires code-level checks the training does not perform.
- CWE-1389partialprevents — Training can raise developer awareness of radix-parsing pitfalls (leading-zero octal, 0x hex), but this is a very specific technical detail that general security training rarely covers in depth, and even educated developers can miss the issue in particular parsing contexts — a minority effect, consistent with the A.6.3 vs CWE-598 anchor.
- CWE-1392partialprevents — Training makes administrators aware that default credentials must be changed, covering a real but minority of instances; the strongest control for this weakness is A.8.9 (configuration management), which mandates the change, and training is fallible like other human-practice controls.
- CWE-1393partialprevents — Training makes administrators aware they must change default passwords after installation and can reach first-party developers not to ship them, but it does not prevent third-party and COTS products from being designed with hardcoded default credentials, which is the dominant pattern in the observed examples.
- CWE-1394partialprevents — Training raises awareness that default keys must be changed and that products should not ship with hardcoded defaults, addressing the knowledge gap on both the developer and administrator sides, but the design decision to include default keys and the operational act of changing them are governed by configuration management (A.8.9), which carries the strong effect; training moves a minority of instances.
- CWE-14partialprevents — Training can teach developers about compiler dead-store elimination and the mitigations (volatile pointers, explicit_bzero, SecureZeroMemory), reducing some instances, but the issue is specialized and easy to forget, so the effect is a minority one — consistent with A.6.3 vs CWE-598 at the same rung.
- CWE-140partialprevents — Training developers about input handling and delimiter neutralization reduces a minority of instances, but the defect is a specific implementation detail that requires careful coding; training is fallible and the stronger controls (secure coding, code review, testing) carry most of the load, mirroring A.8.28 vs CWE-79 and A.6.3 vs CWE-598.
- CWE-141partialprevents — Training developers on input neutralization, including parameter/argument delimiter handling, reduces the likelihood they introduce this code defect, but the practice is fallible and a minority of instances are caught — consistent with the A.6.3 -> CWE-598 anchor and the A.8.28 -> CWE-502 doctrine that educated developers are of some help but not a complete safeguard.
- CWE-1427partialprevents — Training raises developer awareness of prompt injection risks, which prevents some instances where the weakness arises from lack of knowledge about LLM-specific threats, but the actual prevention requires specific technical mechanisms (input validation, prompt engineering, architectural separation of trusted/untrusted input) that training alone does not provide, and the practice is fallible.
- CWE-1434partialprevents — A.6.3's training of technical teams covers configuring systems to the required security level, and CWE-1434's modes of introduction explicitly cite hyperparameters set 'without adequate validation or understanding of their impact' — a knowledge gap training can close for some ML engineers. But the weakness is fundamentally an empirical-tuning problem (the 'best' temperature cannot be determined a priori and requires testing), and inference-parameter trade-offs are a specialized, emerging area where even trained practitioners fall short, so training moves only a minority of instances.
- CWE-146partialprevents — A.6.3's education and training portion targets technical teams whose roles require specific skill sets, including secure coding practice such as input neutralization, so trained developers are less likely to write delimiter-injection defects; the effect is partial because training is fallible and the strongest preventive control for this implementation defect sits in A.8.28/A.8.29, not in awareness and training.
- CWE-15partialprevents — Training developers about secure coding practices can reduce instances where they pass untrusted input directly to system configuration functions (sethostid, setCatalog, etc.), but this is an implementation-level defect that depends on developer skill and attention; the practice is fallible and a different clause (e.g., A.8.28 secure coding, A.8.29 security testing) carries the stronger effect, matching the A.6.3 -> CWE-598 anchor.
- CWE-152partialprevents — Training in secure coding practices helps some developers recognize and neutralize macro symbols, but CWE-152 is explicitly under-studied and obscure, so even well-trained developers may not know to handle it; the effect is a minority reduction, consistent with the A.6.3 vs CWE-598 and A.8.28 vs CWE-79 anchors.
- CWE-154partialprevents — Training developers on secure coding practices can help some avoid variable name delimiter injection, but this is a niche, under-studied weakness that standard awareness/training rarely covers explicitly, and developers remain fallible.
- CWE-156partialprevents — Training in secure input handling raises developer awareness of neutralization issues generally, catching some instances of whitespace mishandling, but the specific subtlety of whitespace interpretation by downstream components is a technical detail that training alone does not reliably prevent, leaving a majority of instances to slip through.
- CWE-158partialprevents — Training developers on secure input handling reduces the odds they introduce null-byte neutralization defects, but the practice is fallible and a specific, technical edge case like NUL handling is exactly the kind of detail training often misses.
- CWE-165partialprevents — Training developers on secure input handling reduces instances of improper neutralization of special elements, but the mechanism is fallible human practice and the specific case of MULTIPLE internal special elements is a subtle parsing nuance that training alone does not reliably catch, matching the A.8.28 -> CWE-79 partial anchor for analogous input-neutralization code defects.
- CWE-167partialprevents — Training developers about input handling and special-element recognition reduces but does not eliminate this implementation defect; the clause's mechanism is human practice, which is fallible and reaches only a minority of instances, consistent with the A.8.28 vs CWE-79 partial anchor on a closely related input-handling weakness.
- CWE-170partialprevents — Training technical developers about string-handling functions (strncpy, readlink, etc.) and null-termination requirements reduces some instances of CWE-170, but the weakness is a low-level C/C++ implementation detail that even trained developers introduce through off-by-one errors and misuse of 'safe' functions, so training moves only a minority of instances.
- CWE-174partialprevents — Training technical staff on secure input handling and encoding can reduce double-decoding defects, but this is a subtle implementation mistake that requires specific expertise and remains fallible even with training, so only a minority of instances are prevented.
- CWE-176partialprevents — Training helps developers understand Unicode encoding pitfalls (e.g., size argument units in conversion functions), but this is a specialized technical implementation defect where even trained developers make mistakes, and the effect is a minority reduction rather than the bulk.
- CWE-177partialprevents — Training developers on URL encoding handling reduces but does not eliminate instances of this implementation defect, mirroring the A.6.3 vs CWE-598 anchor where educated developers help but are fallible.
- CWE-178partialprevents — Training can raise developer awareness about case-sensitivity pitfalls (e.g., case-insensitive comparisons, filter bypass via alternate casing), but this is a subtle implementation defect where the developer often does not realise the mistake is being made, so training moves only a minority of instances.
- CWE-179partialprevents — Training developers in secure coding practices raises awareness of validation-ordering pitfalls for some, but the defect is subtle and the strongest control is code review/testing (A.8.29), so training moves only a minority of instances.
- CWE-180partialprevents — Training that covers input validation order can keep some instances of this subtle implementation defect from arising, but the issue is a specific technical knowledge gap about canonicalization-then-validate ordering that most general awareness programmes do not reach, so only a minority of instances are prevented.
- CWE-181partialprevents — Training can raise developer awareness of validate-before-filter ordering as a class of defect, but CWE-181 is a subtle implementation logic error that requires correct code construction; the training clause's effect is real but a minority one, similar to A.6.3 vs CWE-598.
- CWE-182partialprevents — Training technical teams in secure coding concepts can raise awareness that sanitization/normalization logic itself can collapse into unsafe values, preventing some instances, but this is a subtle implementation defect requiring specialized knowledge and the practice is fallible — consistent with the A.6.3 vs CWE-598 partial anchor and weaker than A.8.28's secure-coding reach.
- CWE-183partialprevents — Training helps developers understand allowlist risks and the need to vet each entry, but CWE-183 is a specific implementation defect where the developer includes unsafe inputs in the list — a detailed design choice that training alone does not fully prevent, mirroring the A.6.3 -> CWE-598 partial grade for developer-introduced weaknesses.
- CWE-184partialprevents — Training can teach developers that denylists are inherently incomplete and that allowlists or proper sanitization are preferred, reducing some instances, but developers remain fallible and the 'quick fix' denylist approach persists under time pressure, leaving a nameable remainder of instances.
- CWE-193partialprevents — Training can teach developers about common off-by-one pitfalls (null terminators, loop boundary conditions, length calculations), reducing a minority of instances, but these are subtle implementation bugs that even trained developers write, so the effect is real but bounded.
- CWE-202partialprevents — Training can raise developer awareness of inference attacks and lead some to design query interfaces that resist statistical disclosure, but this is a subtle design-level weakness requiring specific technical knowledge (k-anonymity, query thresholds, etc.) that general security training only partially conveys, so it moves a minority of instances.
- CWE-203partialprevents — Training helps developers recognize that uniform error messages, constant-time comparisons and non-leaking response patterns are security requirements, addressing the common knowledge-gap cases (error-message enumeration, basic auth timing); however, CWE-203 also covers deeper technical instances — cache/power/microarchitectural side channels, TTL and packet-level discrepancies — that exceed what general awareness training reaches, leaving a nameable remainder.
- CWE-204partialprevents — Training developers about information disclosure through error messages reduces instances of CWE-204, since the weakness is often a knowledge gap (developer doesn't realize differing responses leak validity), but it is a specific implementation detail requiring careful coding practice that training alone does not guarantee, similar to the A.6.3 -> CWE-598 anchor.
- CWE-208partialprevents — Training developers about constant-time comparison and timing side-channels reduces some instances of CWE-208, but the weakness typically arises from natural coding habits (early-exit loops, String.equals) rather than deliberate choices, so education moves a minority of cases and the remainder is bounded by the subtlety of the issue and library/framework defaults the developer never sees.
- CWE-209partialprevents — Training makes developers aware that error messages must not leak sensitive information and that exception output should be sanitized, which prevents a minority of instances; the remainder is the same fallible-developer problem that caps A.8.28 against code-level defects like XSS.
- CWE-211partialprevents — Training developers about secure error handling raises the odds they catch exceptions and configure runtimes to suppress sensitive output, but the practice is fallible and the specific technical configuration (e.g., PHP display_errors, container error pages) is often outside what awareness alone reliably changes.
- CWE-215partialprevents — Training makes developers aware that debug code should not carry sensitive information and should be disabled in production, so a minority of instances are avoided; the remainder is the fallibility of human practice and developers who never receive or do not retain the specific guidance.
- CWE-219partialprevents — Training can make developers aware that placing sensitive files under the web document root exposes them, but this is an architectural/placement decision that often arises from inattention rather than ignorance, and the practice is fallible — consistent with the A.6.3 vs CWE-598 anchor at the same rung.
- CWE-222partialprevents — Training can make developers and operators aware that truncating security-relevant information (long URLs, URIs, sub-domains) in logs or displays obscures attack sources, but this is a specific implementation detail that training reaches only as a minority effect; the primary mechanism is secure coding standards and code review, not awareness.
- CWE-223partialprevents — Training developers about what security-relevant information should be recorded reduces instances of this omission, but the decision of what to log is a code-level judgment that training alone does not fully govern, leaving a majority of instances unaffected.
- CWE-23partialprevents — A.6.3's training of technical teams on secure development practices reduces some instances of path traversal by raising developer awareness of input validation needs, but the practice is fallible and the strongest control for this implementation-phase code defect is A.8.29 security testing, mirroring the A.8.28 -> CWE-79 and A.6.3 -> CWE-598 anchors.
- CWE-230partialprevents — Training developers in secure coding practices, including input validation and null/empty value handling, reduces a minority of instances of this code-level defect, but the practice is fallible and the weakness is introduced in implementation where training alone does not reach the bulk of cases.
- CWE-233partialprevents — Training makes developers aware of the need to validate parameters and handle missing/undefined inputs, which reduces some instances of CWE-233, but the defect is a coding practice issue and the practice is fallible — the same boundary that placed A.8.28 vs CWE-502 at `partial`.
- CWE-234partialprevents — Security awareness and technical training can teach developers to validate required parameters and handle missing arguments, but it only reduces implementation mistakes, not fully preventing them.
- CWE-235partialprevents — Training can make developers aware of parameter-pollution-style issues and HTTP parameter handling pitfalls, reducing some instances, but CWE-235 is a specific implementation defect where the strongest control is testing and code review (A.8.29), and trained developers remain fallible on this technical detail.
- CWE-236partialprevents — Training developers on secure coding practices (input validation, parameter handling) reduces instances of undefined-parameter mishandling, but the effect is a minority one because training is fallible and the defect is a specific implementation choice the developer still has to make correctly.
- CWE-24partialprevents — Training developers in secure coding practices (input validation, path neutralization) reduces path traversal defects but is a fallible human practice; the A.6.3 vs CWE-598 anchor sets the rung for code-level defects developers introduce, and path traversal sits in the same band.
- CWE-242partialprevents — Training teaches developers that functions like gets() are inherently unsafe and to prefer bounded alternatives, so a meaningful minority of instances are avoided through awareness; the remainder is bounded by the fallibility of human practice and by legacy code where the dangerous call is already written, similar to A.8.28 -> CWE-79 at partial.
- CWE-243partialprevents — Training reduces developer-introduced implementation defects by some margin, and CWE-243 is a knowledge gap (developers must know chroot() does not change the working directory), but the weakness is sufficiently obscure and niche that typical training programmes would not cover it, leaving most instances unaffected.
- CWE-245partialprevents — Training on secure J2EE coding practices and container resource management can prevent some instances of direct connection management, but this is a specific technical detail that general security awareness training may not cover, and developers may still violate the standard under time pressure or when unaware of the J2EE restriction.
- CWE-246partialprevents — Training developers on J2EE secure coding practices can reduce instances of direct socket use, but it is a fallible human-practice effect against a coding defect; the strongest control is code review or static analysis, and developers may still use sockets for legitimate legacy communication.
- CWE-248partialprevents — Training developers in exception handling reduces uncaught-exception defects, but it is a fallible human practice and the strongest controls for this implementation-phase code defect are code review and static analysis (A.8.28/A.8.29), so only a minority of instances are prevented.
- CWE-25partialprevents — Training developers about secure input handling and path canonicalization reduces some path traversal defects, but the technical specifics of neutralizing '/../' sequences require more than general awareness and developers remain fallible, so only a minority of instances are prevented.
- CWE-250partialprevents — Training developers about least-privilege principles reduces some instances of CWE-250 where the unnecessary privilege arises from a developer's convenience choice or knowledge gap, but the weakness also stems from architectural decisions, library/framework defaults, and platform behaviors that training alone does not reach, leaving a nameable remainder.
- CWE-252partialprevents — Training developers in defensive programming and error-handling practices reduces instances of unchecked return values, but the practice is fallible and a different clause (e.g., A.8.28 secure coding, A.8.29 security testing) carries the stronger effect, matching the A.6.3 vs CWE-598 and A.8.28 vs CWE-79 anchors.
- CWE-253partialprevents — Training developers in secure coding practices reduces a minority of incorrect return-value checks, but the practice is fallible and the defect is a subtle implementation detail (e.g., checking < 0 when malloc returns NULL) that training alone does not reliably prevent.
- CWE-258partialprevents — Training can teach developers and administrators not to leave empty passwords in configuration files, but the practice is fallible and a different control (secure coding standards, configuration review) carries the stronger effect, matching the A.6.3 -> CWE-598 anchor at the same rung.
- CWE-259partialprevents — Training/awareness addresses hard-coded passwords as a known anti-pattern (the clause explicitly names password security as a baseline control topic), and a developer who has been educated will sometimes choose not to hard-code credentials, but the weakness is a code-level defect introduced during implementation where convenience pressures and time-to-market routinely override training, so the effect is a minority one.
- CWE-26partialprevents — Training developers about path traversal risks and secure input validation practices reduces the likelihood they introduce this code defect, but the effect is a minority one because training is fallible and the specific technical knowledge required varies across developers and teams.
- CWE-260partialprevents — Training developers on secure credential handling reduces instances of cleartext passwords in configuration files, but the practice is fallible and conscious convenience choices still occur, leaving a nameable remainder.
- CWE-261partialprevents — Training developers in proper password storage practices (hashing with bcrypt/scrypt/argon2 rather than encoding) addresses the knowledge gap behind choosing Base64 as 'protection', but the weakness is a specific technical design choice that requires targeted secure-coding education to reach, and even trained developers can still write this defect.
- CWE-262partialprevents — Training can make developers and administrators aware of password aging requirements (especially compliance-driven ones like PCI DSS), which may lead them to implement aging mechanisms, but this is a design/architecture decision where training is a fallible influence rather than a mechanism, leaving most instances unaffected.
- CWE-266partialprevents — Training developers in secure coding and access control principles can reduce instances of incorrect privilege assignment, but the defect is a subtle implementation-level mistake (e.g., seteuid misuse, wrong group ID, intent flag misuse) that training alone does not reliably prevent — the same fallibility that placed A.6.3 -> CWE-598 at `partial`.
- CWE-267partialprevents — Training developers about least-privilege and safe privilege design reduces some instances of CWE-267, but the weakness is a design/implementation defect in how privileges are defined, and human practice is fallible — consistent with the A.6.3 -> CWE-598 partial anchor on the same clause.
- CWE-27partialprevents — Training developers about input validation and path handling reduces path-traversal introductions, but the defect is a specific technical implementation error (multiple '../' neutralization) that training alone catches only a minority of, with secure coding standards, code review and security testing carrying the stronger preventive effect.
- CWE-270partialprevents — Training developers about privilege context switching can reduce instances of this implementation defect, but the weakness is a subtle code-level issue that even aware developers miss; the effect is real but a minority one, consistent with A.6.3's rung on other developer-introduced weaknesses.
- CWE-272partialprevents — Training technical teams on the principle of least privilege (A.6.3's education and training section) raises awareness that elevated privileges should be dropped after operations like chroot(), reducing some instances, but developers remain fallible on this specific code-level detail and the stronger controls are secure coding standards, code review, and static analysis.
- CWE-273partialprevents — Training developers in secure coding practices (including checking return values from privilege-management calls) reduces but does not eliminate this implementation defect; the practice is fallible and a different clause (e.g., A.8.28 secure coding, A.8.29 security testing) carries the stronger effect, matching the A.6.3 -> CWE-598 partial anchor.
- CWE-274partialprevents — Training developers about privilege handling and the consequences of insufficient-privilege states reduces a minority of instances, but the weakness is an implementation defect that requires secure coding practice (A.8.28) and security testing (A.8.29) to reach the bulk of it; training is fallible and sits at the same ceiling as other human-practice clauses on code-level defects.
- CWE-276partialprevents — Training installers and developers on secure default permissions reduces instances where world-writable or otherwise incorrect permissions are set during installation, but the practice is fallible and the strongest control for this weakness is configuration management establishing secure installation baselines; training reaches a minority of instances.
- CWE-278partialprevents — Training can raise developer awareness of permission-inheritance issues when copying from archives, but this is a specific technical defect in product design/implementation that general security training rarely covers in depth, and even aware developers may still implement it incorrectly.
- CWE-279partialprevents — A.6.3's education and training programme for technical teams covers secure configuration and coding practices, so trained developers are less likely to write code that sets execution-assigned permissions incorrectly; the effect is real but fallible, matching the same partial rung as A.8.28 vs CWE-79 and A.6.3 vs CWE-598.
- CWE-28partialprevents — Training raises developer awareness of path traversal risks and the need to sanitize '..\' sequences, but the defect is a specific implementation choice that even trained developers write; the strongest controls are secure coding standards (A.8.28) and security testing (A.8.29), so training moves a minority of instances.
- CWE-280partialprevents — Training raises developer awareness of permission-handling concerns, but CWE-280 is a subtle implementation defect (the CWE notes it is under-studied and developers often fail to consider access-failure paths), so even well-trained developers miss edge cases — a minority effect, consistent with A.8.28 vs CWE-79 at `partial`.
- CWE-281partialprevents — Training raises developer awareness of secure permission handling during file operations, which keeps some instances of CWE-281 from being written, but the weakness is a specific implementation defect and the training is general awareness rather than targeted secure-coding practice, so it moves a minority of instances.
- CWE-289partialprevents — Training can raise developer awareness of canonicalization and alternate-name authentication risks, but CWE-289 is a technical design/implementation defect whose prevention requires careful handling of encodings, case, and trailing characters — a fallible human-practice control moves a minority of instances, consistent with the A.6.3 -> CWE-598 and A.8.28 -> CWE-79 anchors.
- CWE-29partialprevents — Training developers in secure coding practices (input validation, path handling) reduces instances of path traversal defects, but the specific '\..\' bypass technique is subtle enough that even trained developers miss it, and training is fallible — consistent with the A.6.3 -> CWE-598 partial anchor and the A.8.28 -> CWE-79 partial anchor for implementation defects.
- CWE-291partialprevents — Training can make architects and developers aware that IP addresses can be spoofed and should not be the sole authentication factor, preventing some instances of this design weakness, but CWE-291 is an architectural decision where the remainder (architects without specific authentication-design training, or those who make a conscious simplicity/legacy choice) is nameable and not negligible.
- CWE-293partialprevents — Training on authentication principles and HTTP header spoofing helps some developers avoid using Referer for authentication, but this is a specialized design anti-pattern where the practice is fallible and a minority of instances are caught by awareness alone.
- CWE-294partialprevents — Training raises developer awareness of capture-replay risks and can influence the choice of authentication protocols that include replay protection (nonces, challenge-response), but the weakness is fundamentally an architectural/design defect that training alone does not prevent—developers remain fallible, and the strongest controls (cryptography, secure architecture) carry the primary effect.
- CWE-295partialprevents — Training developers on proper TLS/certificate validation APIs and the importance of chain, hostname, and revocation checks reduces some instances of CWE-295, but the weakness is a specialized implementation defect where even trained developers make mistakes (e.g., skipping SSL_get_verify_result, accepting self-signed certs, using curl -k), so the effect is a minority one — consistent with the A.6.3 vs CWE-598 anchor at the same rung.
- CWE-296partialprevents — Training technical teams on certificate validation practices can reduce instances of this implementation defect, but the weakness is a code-level choice about how chains are validated, and the primary prevention comes from secure coding standards (A.8.28) and security testing (A.8.29); training is fallible and reaches only a minority of cases.
- CWE-297partialprevents — Training can make developers aware that hostname verification is required and that pitfalls like NUL-byte handling and SAN/CN checks exist, but the weakness is an implementation defect (incorrect regex, truncation, missing checks) that training alone does not prevent — most instances arise from coding errors that require careful implementation and testing, not from ignorance of the requirement.
- CWE-304partialprevents — Training technical teams on authentication protocols and secure implementation reduces instances of skipped authentication steps, but developers remain fallible and the weakness is introduced at code-writing time, so only a minority of instances are prevented.
- CWE-305partialprevents — Training raises developer awareness of secure authentication practices (proper comparison, full validation, correct initialization), which prevents some instances of these primary coding errors, but the defects are implementation-level mistakes that training alone does not fully eliminate — analogous to A.8.28 vs CWE-502, where educated developers help but are fallible.
- CWE-306partialprevents — Training developers to recognize authentication requirements can reduce some instances of this architectural omission, but CWE-306 is primarily a design-time oversight rather than a knowledge gap or deliberate choice, so education moves only a minority of cases.
- CWE-307partialprevents — Training can make developers aware that authentication endpoints need rate limiting and account lockout, reducing some instances of this architectural omission, but it is a fallible human practice against a design/code defect — the same reasoning as A.6.3 -> CWE-598 and AT-2 -> CWE-79.
- CWE-308partialprevents — Training technical teams on authentication requirements can influence architectural decisions to require multiple factors, but CWE-308 is a design-phase weakness where the choice of single-factor is often a deliberate architectural decision or default that training only partially counters; the effect is real but a minority one, similar to A.6.3 vs CWE-598.
- CWE-309partialprevents — Training architects and developers about the risks of password-only authentication and the availability of MFA can influence the design decision, but the choice is often driven by cost, integration complexity, or legacy constraints that education does not reach, leaving a substantial remainder.
- CWE-31partialprevents — Training developers about path traversal patterns and secure input handling reduces but does not eliminate this implementation defect; the mechanism is human practice, fallible, and the strongest control for this weakness is secure coding practice and security testing rather than awareness.
- CWE-313partialprevents — Training raises developer awareness that sensitive data should not be stored in cleartext and addresses the knowledge gap behind most instances, but it is a fallible human-practice mechanism that does not ensure consistent application, and the technical implementation (choosing encryption, managing keys) requires more than awareness.
- CWE-314partialprevents — Training developers about secure storage practices reduces instances of cleartext registry storage, but the decision is made in code by fallible developers, so only a minority of instances are prevented — consistent with the A.6.3 vs CWE-598 anchor on a similar developer-knowledge weakness.
- CWE-316partialprevents — A.6.3's education and training component for technical teams can raise awareness of secure memory handling practices (clearing buffers, avoiding plaintext storage of secrets in memory), preventing some instances, but this is a low-level implementation detail that general awareness training rarely reaches and most developers will not encounter specific guidance on it.
- CWE-317partialprevents — Training developers about secure GUI design and the risks of displaying sensitive information in cleartext helps prevent some instances, but the weakness is often an architecture/design omission where developers don't realize data is sensitive or don't know GUI-specific protections, so general awareness training reaches only a minority of cases.
- CWE-318partialprevents — Training teaches developers not to embed secrets in executables, so a minority of instances are avoided by awareness, but the practice is fallible and the strongest control for this code-level defect is review and secret-scanning tools, not training.
- CWE-319partialprevents — Training helps where cleartext transmission is a developer or administrator choice (HTTP vs HTTPS, enabling secure transfer, not sending credentials in email) — the same logic that graded A.6.3 vs CWE-1428 at `mostly` — but CWE-319 is broader than CWE-1428 and includes hardware debug channels (JTAG), OT/ICS protocol choices baked into vendor products, and legacy systems where the protocol decision is not a conscious act by someone training can reach, leaving a nameable remainder that puts this below `mostly`.
- CWE-32partialprevents — Training developers about input validation and path traversal reduces instances of this weakness, but it is a fallible human-practice mechanism and the triple-dot variant is a subtle case that can slip past even trained developers, so only a minority of instances are kept from arising.
- CWE-322partialprevents — Training developers about authenticated key exchange (e.g., authenticated Diffie-Hellman, proper TLS certificate verification) addresses a knowledge gap that produces some instances of this design-phase omission, but the weakness is a specialized cryptographic protocol decision where many developers rely on library defaults they never examine, so training moves a minority of instances.
- CWE-323partialprevents — A.6.3's training for technical teams covers cryptographic skills and best practices, which prevents some instances of nonce/key pair reuse, but the flaw is a subtle implementation detail (often arising from RNG resets, object cloning, or hardcoded nonces) that even trained developers introduce, so the effect is a minority one — consistent with the A.6.3 vs CWE-598 anchor on developer-introduced weaknesses.
- CWE-324partialprevents — Training developers about cryptographic key management and certificate validation can reduce instances of expired-key usage, but the effect is a minority one because the weakness is a specific code defect (failing to check expiration) and training is fallible; the strongest controls for this weakness sit in A.8.24 (cryptography policy) and A.8.29 (security testing), not in awareness.
- CWE-325partialprevents — Training addresses the 'mistaken impression that the step is unnecessary' mode of introduction (a knowledge gap) but does not reach the deliberate performance-driven omission, and is fallible in practice -- consistent with the A.8.28 -> CWE-502 and A.6.3 -> CWE-598 anchors where training moves a minority of developer-introduced defects.
- CWE-328partialprevents — Training helps developers recognize weak hash algorithms as a knowledge gap, but the clause is general awareness rather than cryptographic-specific education; legacy code, library defaults, and deliberate compatibility choices remain outside its reach, and the dedicated cryptography control (A.8.24) carries the stronger effect.
- CWE-329partialprevents — Training developers on cryptographic best practices reduces instances of predictable IV generation, since CWE-329's own modes-of-introduction note that developers dismiss IV importance for ease of implementation; but this is a specialized cryptographic detail that not all developers are trained on, so the effect is a minority one, consistent with the A.6.3 vs CWE-598 and A.8.28 vs CWE-79 anchors.
- CWE-332partialprevents — Training technical teams on secure cryptographic practices can reduce instances where developers choose inadequate entropy sources (e.g., Math.random() for security purposes), but this is a specialized topic, training is fallible, and the weakness is a code-level defect that requires specific expertise to avoid — consistent with the A.8.28/CWE-79 and A.6.3/CWE-598 partial anchors.
- CWE-335partialprevents — Training developers about cryptographic best practices, including proper PRNG seeding (avoiding time-based or constant seeds, using cryptographically secure entropy sources), prevents some instances of CWE-335, but PRNG seeding is a specialized topic that not all training programs cover in depth, and developers remain fallible on the technical details.
- CWE-336partialprevents — Training developers on secure use of randomness (e.g., that PRNGs must be seeded from a strong entropy source, not a constant) prevents some instances of this code-level defect, but the effect is a minority one because the topic is specialized, training is general rather than targeted, and even trained developers write the flawed `new Random(SEED)` pattern.
- CWE-339partialprevents — Training developers on cryptographic best practices and proper PRNG usage can prevent some instances of small seed space choices, but this is a specific technical implementation detail that only a minority of trained developers will internalize, mirroring the A.6.3 vs CWE-598 anchor at the same rung.
- CWE-34partialprevents — Training developers about secure input handling and path canonicalization reduces path-traversal introductions, but it is a fallible human practice against a specific implementation defect, so it moves a minority of instances.
- CWE-342partialprevents — Training technical staff on secure coding practices can reduce instances of predictable-value weaknesses by raising awareness of proper randomness requirements, but the effect is a minority one: developers remain fallible, the technical knowledge required is specialized, and the stronger controls (A.8.24 cryptography, A.8.28 secure coding, A.8.29 security testing) carry the bulk of the preventive effect.
- CWE-343partialprevents — Training can teach developers to use cryptographically secure random number generators and avoid predictable constructions, addressing the knowledge gap that produces this flaw, but the effect is a minority one because the required knowledge is specialized, not all developers receive it, and even trained developers can still seed or use APIs incorrectly.
- CWE-344partialprevents — Training on secure coding practices helps some developers recognize when they are hardcoding values that should vary across environments, but the weakness is a subtle design/implementation judgment that training only partially addresses, consistent with A.6.3 -> CWE-598 at partial.
- CWE-347partialprevents — Training technical teams on cryptographic practices (which A.6.3's education-and-training half explicitly covers) reduces signature-verification omissions where the defect is a knowledge gap or a deliberate shortcut, but most CWE-347 instances are implementation errors — wrong API, missing verify call, incorrect verification logic — that training does not reach, mirroring the A.6.3 vs CWE-598 anchor.
- CWE-348partialprevents — Training helps developers understand that user-controlled sources (like HTTP_X_FORWARDED_FOR) should not be trusted over server-controlled ones (like REMOTE_ADDR), reducing instances where this knowledge gap leads to the defect, but the specific design choice between two sources remains a code-level decision that training alone does not fully prevent.
- CWE-349partialprevents — Training developers on trust-boundary validation and proper handling of mixed trusted/untrusted data reduces instances of CWE-349, but the effect is a minority one because training is fallible and the specific technical knowledge required varies across implementations, consistent with the A.6.3 vs CWE-598 and A.8.28 vs CWE-79 anchors.
- CWE-35partialprevents — Training developers on path traversal risks makes them more likely to use proper canonicalization rather than naive '../' removal, but the specific knowledge needed to defeat '.../...//' bypasses is specialized and the actual prevention rests on secure coding practice (A.8.28), so training moves a minority of instances.
- CWE-350partialprevents — Training of technical teams can raise awareness that reverse DNS is not a reliable authentication mechanism, preventing some instances where developers would otherwise rely on it for security decisions, but this is a specialized architectural topic that not all training programmes cover, leaving a substantial remainder.
- CWE-351partialprevents — Training raises developer awareness of type-distinction requirements (e.g., distinguishing user-initiated from synthetic events), but this is a subtle implementation defect where fallible developers still introduce the flaw despite education, matching the A.8.28 -> CWE-79 partial pattern for code-level defects.
- CWE-352partialprevents — Training developers about CSRF and the need for tokens/SameSite cookies reduces instances where the weakness arises from ignorance, but CSRF is a specific implementation defect requiring correct technical countermeasures, and trained developers still introduce it through flawed token validation or missing protections — a minority effect, matching the A.6.3 -> CWE-598 anchor at the same rung.
- CWE-356partialblocks — Security awareness training can teach users to heed or demand warnings for unsafe actions.
- CWE-356partialprevents — Training developers about secure UI design can make them more likely to include warning dialogs for unsafe actions, but the weakness is a design/implementation choice in the product itself, and training is a fallible human practice that moves only a minority of instances.
- CWE-358partialprevents — Training helps developers understand what standards require and how to implement security checks correctly, but the weakness is an implementation error that requires careful attention to detail; educated developers are fallible, and the strongest control for catching this class is A.8.29 security testing.
- CWE-359partialprevents — Training makes developers and personnel aware of privacy responsibilities and PII handling obligations, which reduces some instances of CWE-359 arising from design or implementation choices, but as a fallible human practice it leaves the majority of cases — design omissions, implementation errors, and operational decisions about data exposure — unaddressed, consistent with the A.6.3 -> CWE-598 partial anchor.
- CWE-36partialprevents — Training developers about path traversal risks (including absolute path sequences) reduces some instances of this implementation defect, but the practice is fallible and the strongest control is security testing (A.8.29) or secure coding (A.8.28), so only a minority of instances are prevented.
- CWE-37partialprevents — Training helps some developers recognize the need to validate absolute path inputs, but this is a specific implementation defect requiring specialized knowledge, and the practice is fallible — consistent with the A.6.3 vs CWE-598 anchor at partial.
- CWE-374partialprevents — Training developers on secure coding practices (the education and training component of A.6.3) reduces instances of this subtle reference-semantics defect, but the weakness is technical enough that even trained developers make the mistake, so only a minority of instances are prevented.
- CWE-375partialprevents — A.6.3's training of technical teams can reduce instances of this subtle defensive-copying defect by raising developer awareness of mutable-return hazards, but the weakness is a specific implementation pattern that most developers will not have been trained on, so only a minority of instances are prevented.
- CWE-378partialprevents — Training developers about secure temporary file creation (e.g., using mkstemp, setting restrictive permissions) reduces some instances of CWE-378, but this is a specific implementation detail that not all training programmes cover and even trained developers may default to convenient APIs like tmpfile() or createTempFile() without setting permissions, leaving a nameable remainder.
- CWE-379partialprevents — Training technical teams on secure coding practices (including proper use of temporary file APIs like mkstemp() over tmpfile(), or setting explicit permissions) addresses a knowledge gap that produces this weakness, but the effect is a minority one because the practice is fallible and not every developer receives or retains this specific guidance.
- CWE-38partialprevents — Training developers about input validation and path handling reduces the introduction of path traversal defects, but as a human practice it is fallible and addresses only a minority of instances; the strongest controls for this code-level defect are secure coding (A.8.28) and security testing (A.8.29).
- CWE-383partialprevents — Training technical teams on secure coding practices (the education/training portion of A.6.3) reduces instances of J2EE developers introducing direct thread use, but the practice is fallible and a specific code-level defect that other controls (secure coding standards, code review, SAST) reach more directly.
- CWE-385partialprevents — Training helps developers recognize timing-channel pitfalls (e.g., constant-time comparison) and avoid introducing them, but the topic is specialized enough that even a well-implemented awareness programme reaches only a minority of instances; many developers will not receive specific timing-attack training and even trained developers can miss subtle timing variations.
- CWE-39partialprevents — Training developers in secure input handling reduces instances of path traversal defects like drive-letter injection, but the practice is fallible and a different clause (secure coding/testing) carries the stronger effect, matching the A.6.3 vs CWE-598 anchor.
- CWE-390partialprevents — Training developers in secure coding practices and personal accountability for error handling reduces instances of empty catch/if blocks, but the effect is a minority one because the defect is subtle, fallible human practice is the mechanism, and code review/testing carry the stronger effect.
- CWE-392partialprevents — Training makes developers more aware of proper error-handling discipline, so a minority of CWE-392 instances are avoided, but the weakness is a code-level implementation detail that depends on the rigour of the implementer rather than on awareness, leaving the bulk of instances unaffected.
- CWE-393partialprevents — Training can make developers more careful about return-value handling and status-code semantics, reducing some instances of this subtle implementation bug, but most occurrences (like the Apple 'goto fail' defect) are accidental code errors that escape review and testing, so training moves only a minority of instances.
- CWE-394partialprevents — Training can teach developers to check return values consistently, but it is a fallible human practice against a code-level defect; the strongest effect comes from secure coding standards and security testing, leaving training with a minority share of prevented instances.
- CWE-395partialprevents — Training technical teams in secure coding practices can reduce instances of catching NullPointerException as a null-check substitute, but the mechanism is human practice and is fallible, so only a minority of instances are prevented.
- CWE-396partialprevents — Training developers on secure coding practices can reduce instances of catching overly broad exceptions, but the practice is fallible and the pattern is often introduced for code-clarity reasons that training does not reliably reach.
- CWE-401partialprevents — Training technical teams in secure coding and resource management raises awareness of memory lifetime issues and reduces a minority of memory leaks, but the defect is written in code and the strongest controls are code review, static analysis, and testing (A.8.29), so a nameable remainder of leaks persists even with well-trained developers.
- CWE-403partialprevents — Training can raise developer awareness of resource-cleanup hygiene before forking child processes, but CWE-403 is a specialized low-level implementation defect whose actual prevention comes from secure coding practice (A.8.28), code review, and testing (A.8.29); awareness education moves only a minority of instances, consistent with the A.6.3 vs CWE-598 anchor.
- CWE-409partialprevents — Technical training for teams that build parsers/handlers of compressed input can teach developers about decompression bombs and the need for size limits during decompression, but the general awareness programme does not reach this niche implementation defect, and only a minority of developers receive the relevant specialised training.
- CWE-41partialprevents — Training developers about path canonicalization and special-character handling reduces some instances of this implementation defect, but it is a specific technical detail that most developers do not encounter or internalize, so the effect is a minority one — consistent with the A.6.3 vs CWE-598 anchor at the same rung.
- CWE-415partialprevents — Training developers on secure memory management practices (proper error handling around free(), avoiding double-free in cleanup paths) reduces a minority of CWE-415 instances, but the bug is subtle, often arises from race conditions and complex error paths, and even well-trained developers introduce it — consistent with the A.8.28 -> CWE-79 and A.6.3 -> CWE-598 partial pattern.
- CWE-416partialprevents — A.6.3's education and training for technical teams can include memory management and pointer-lifetime concepts, which helps some developers avoid use-after-free bugs, but the clause is general awareness plus role-specific training rather than a targeted secure-coding mandate, and UAF defects are subtle enough that even well-trained developers introduce them — a minority effect.
- CWE-425partialprevents — Training developers about authorization requirements helps them avoid the false assumption that resources can only be reached through a given navigation path, but developers remain fallible and the strongest control for this code-level authorization defect is security testing (A.8.29), consistent with the A.6.3 vs CWE-598 anchor.
- CWE-426partialprevents — Training in secure coding practices can make developers aware of the risks of relying on externally-supplied search paths (PATH, LD_PRELOAD, APPHOME) and prompt them to use absolute paths or sanitize the environment, but this is a fallible human-practice effect on a specific implementation defect, with the strongest control being code review and security testing rather than awareness.
- CWE-427partialprevents — Training technical teams on secure coding practices (the education and training component of A.6.3) helps some developers avoid introducing uncontrolled search path elements, but the practice is fallible and the weakness is a specific implementation detail that most developers will not internalize from general awareness training.
- CWE-43partialprevents — Training developers about secure path handling and input validation can prevent some instances of this obscure path-equivalence defect, but the specific knowledge required (multiple trailing dots in filenames) is niche enough that even trained developers may miss it, leaving a majority of instances unaddressed.
- CWE-431partialprevents — Training developers in defensive coding practices can reduce the likelihood they write code without proper exception handlers, but this is a minority effect — the actual prevention comes from secure coding (A.8.28) and security testing (A.8.29), and training is fallible, matching the A.6.3 -> CWE-598 anchor's reading of training against code-level defects.
- CWE-440partialprevents — Training helps developers better understand and adhere to specifications, reducing some expected-behavior violations, but the defect is a code-level implementation choice that general awareness training only partially addresses — most such violations arise from subtle misunderstandings of specific specs that training cannot fully prevent.
- CWE-45partialprevents — Training on secure path handling raises developer awareness of traversal issues generally, but CWE-45 is a subtle variant (multiple internal dots) that requires specific knowledge to avoid; most instances arise from developers who have not been educated about this particular path equivalence, so training moves a minority of cases.
- CWE-450partialprevents — Training developers about secure UI design principles helps them recognize when ambiguous input needs user confirmation, but this is a specific implementation detail that depends on developer judgment and design discipline, so only a minority of instances are prevented.
- CWE-451partialblocks — Awareness training on phishing and UI spoofing can make users more skeptical of suspicious indicators, reducing successful exploitation of the misrepresentation, but the UI flaw itself remains present and exploitable — the training does not change the product's display logic, so a sufficiently convincing spoof still works.
- CWE-454partialprevents — Training can make developers aware of the pattern of not trusting externally-initialized variables for critical state, but the defect is written in code and the strongest controls are secure coding practice, code review and security testing; the training effect is real but a minority one, consistent with the A.6.3 -> CWE-598 and A.8.28 -> CWE-79 anchors.
- CWE-455partialprevents — Training raises developer awareness of handling initialization failures and security-relevant errors, which catches a minority of instances; the defect is a subtle code-level decision that even trained developers make, and the practice is fallible.
- CWE-457partialprevents — Training developers in secure coding practices (the technical-team portion of A.6.3) reduces uninitialized-variable defects, but the weakness is a subtle coding mistake that even trained developers introduce, so the effect is a minority one — consistent with the A.8.28 vs CWE-502 anchor at the same rung.
- CWE-46partialprevents — Training developers in secure coding practices can raise awareness of path normalization edge cases like trailing spaces, but the specific technical knowledge required is specialized and the issue is subtle, so only a minority of instances are prevented by awareness/education.
- CWE-460partialprevents — Training developers in secure coding practices (exception handling, resource cleanup) helps prevent some instances of improper cleanup on thrown exceptions, but as a fallible human practice it moves only a minority of instances, consistent with the A.8.28 -> CWE-502 anchor.
- CWE-463partialprevents — Training technical staff in secure coding practices can reduce sentinel-deletion bugs by raising awareness of buffer boundaries and data-structure invariants, but this is a subtle implementation defect that even trained developers introduce, so the effect is a minority one.
- CWE-467partialprevents — Training developers on secure C/C++ coding practices can reduce instances of sizeof-on-pointer mistakes, but this is a subtle language pitfall that even trained developers make; the effect is real but a minority one, consistent with A.6.3's other code-defect grades.
- CWE-468partialprevents — Training technical staff in secure C/C++ practices reduces incorrect pointer scaling for some developers who learn the implicit-scaling semantics, but the defect is a subtle implementation mistake that even trained programmers make, so only a minority of instances are prevented.
- CWE-469partialprevents — Training technical teams on secure C/C++ practices can reduce some instances of pointer-subtraction size mistakes, but the defect is a narrow low-level implementation issue that most developers never encounter, so training reaches only a minority of cases.
- CWE-47partialprevents — Training technical teams on secure coding practices (per A.6.3's education and training section) helps some developers recognize and avoid path-handling defects like leading-space path equivalence, but the practice is fallible and most instances of this specific implementation defect still arise.
- CWE-470partialprevents — Training developers on secure coding practices (including reflection safety) reduces but does not eliminate unsafe reflection defects; the practice is fallible and the specific knowledge required is narrow, matching the A.6.3 -> CWE-598 and A.8.28 -> CWE-79 anchors.
- CWE-471partialprevents — Training can make developers aware that hidden form fields, cookies, environment variables and similar inputs are attacker-modifiable, reducing some instances of MAID, but the weakness is a subtle implementation choice that training alone does not prevent for most developers.
- CWE-472partialprevents — Training developers that hidden fields, cookies and URL parameters are externally controllable addresses the knowledge gap behind CWE-472, but it is a fallible human practice that catches a minority of instances, consistent with the A.6.3 -> CWE-598 anchor.
- CWE-474partialprevents — Training can make developers aware of cross-platform function inconsistencies and the need to verify behavior across target environments, but this is specialized technical knowledge and developers remain fallible; the effect is real but covers a minority of instances, consistent with the A.6.3 -> CWE-598 and A.8.28 -> CWE-79/502 anchors.
- CWE-477partialprevents — Training technical teams about deprecated functions and their replacements (per A.6.3's education and training guidance) reduces instances where developers reach for obsolete APIs out of habit or knowledge gaps, but developers remain fallible and the universe of deprecated functions across languages and libraries is too large for training to cover completely.
- CWE-478partialprevents — Training developers in defensive programming practices (covered by A.6.3's education and training component for technical teams) makes them more likely to include default cases in switch/match statements, but this is a specific code-level omission that general awareness training reaches only partially; the strongest controls are code review and security testing (A.8.29), not training.
- CWE-479partialprevents — Training technical teams on secure coding practices can reduce signal-handler reentrancy defects for the small subset of developers writing signal handlers who receive specialized instruction, but this is a niche implementation-level concern that most training programmes do not reach in depth, leaving the majority of instances unaffected.
- CWE-487partialprevents — Training can correct the misconception that Java package scope is a security boundary, but CWE-487 is a narrow Java-language-specific implementation detail that general awareness training does not reach; only the technical-training slice for Java developers touches it, and even there it is one item among many, so a minority of instances are prevented.
- CWE-49partialprevents — Training developers about path handling and input validation reduces some instances of this subtle trailing-slash edge case, but the defect is a specific implementation detail that most developers will not have been trained on, so only a minority of instances are prevented.
- CWE-492partialprevents — Secure-coding training can teach developers to prefer static, local, or anonymous inner classes, preventing some instances of this subtle Java-specific defect, but most training programmes do not cover this narrow bytecode-transformation detail and developers remain fallible, so only a minority of instances are kept from arising.
- CWE-493partialprevents — Training/awareness can make developers aware of the need to mark critical public fields as final, reducing some instances of this implementation defect, but the practice is fallible and the specific guidance is narrow enough that most instances arise regardless.
- CWE-497partialprevents — Training developers to avoid exposing system information in error messages, debug output, and diagnostic functions reduces some instances of CWE-497, but as a fallible human practice it cannot reach the bulk of cases the way a mechanism-based control can.
- CWE-498partialprevents — Training technical teams on secure coding practices (the education/training portion of A.6.3) can reduce instances of cloneable classes holding sensitive data, but developers remain fallible on this niche implementation pattern, so only a minority of instances are prevented.
- CWE-499partialprevents — Secure coding training can teach developers to mark sensitive classes as non-serializable or guard them in readObject, reducing instances, but this is a specialized Java serialization concern that requires specific knowledge most awareness programmes do not deeply cover, so training moves a minority of instances.
- CWE-5partialprevents — Following the CWE-1428 anchor pattern: transmitting data without encryption is either a conscious choice of convenience or a knowledge gap, and education addresses both. Training J2EE developers on SSL configuration requirements and the three common SSL bypass patterns prevents most instances of this misconfiguration from arising in the first place.
- CWE-500partialprevents — A.6.3's education and training for technical teams covers secure coding practice, so a developer trained to recognise mutable shared state as a defect will mark such fields final; the effect is real but a minority one, because the practice is fallible and the clause's primary focus is awareness rather than the specific secure-coding rigour that catches this construct.
- CWE-502partialprevents — Training technical teams on secure deserialization practices reduces a minority of CWE-502 instances, but developers remain fallible and the owner explicitly identified A.8.29 (security testing) as the strongest control for this weakness, with A.8.28 (secure coding) graded only `partial` on the same pair.
- CWE-508partialprevents — Training helps personnel recognize malicious code during implementation and operation and follow secure handling practices, but the Distribution phase introduction vector (supply chain, compromised media) is largely outside training's reach, leaving a nameable remainder.
- CWE-52partialprevents — Training developers about path handling and input validation reduces the odds they write code that accepts malformed paths without normalization, but the effect is a minority one because the specific technical detail of trailing-slash equivalence is narrow and human practice is fallible, matching the A.6.3 -> CWE-598 partial anchor.
- CWE-520partialprevents — Training developers about secure .NET configuration can prevent some instances of dangerous impersonation choices, but impersonation has legitimate architectural uses (e.g., accessing user-specific NTFS resources), so a deliberate design choice to use it is not prevented by education; the remainder is bounded and nameable.
- CWE-521partialblocks — Training makes users aware of password-strength expectations and motivates stronger choices, but because the product still does not enforce strong passwords, any untrained or noncompliant user can set a weak password that remains exploitable.
- CWE-524partialprevents — Training makes developers aware that caches can leak sensitive information and that cache-control headers and access restrictions matter, which prevents some instances of this implementation-phase weakness, but the specific technical choices (no-cache headers, cache access scoping, deciding what to cache) require detailed knowledge that training provides only partially and fallibly.
- CWE-526partialprevents — Training helps developers understand that environment variables are not secure storage and that sensitive data should be encrypted or held in a vault, but the practice is fallible and developers under time pressure still choose env vars for convenience, so only a minority of instances are prevented.
- CWE-527partialprevents — Training/awareness about secure deployment practices (excluding .git/.svn directories from web roots, not bundling repository metadata into archives) addresses a knowledge gap that causes some instances of this weakness, but the effect is a minority one — most prevention comes from configuration management, deployment pipelines, and secure baselines, not from awareness alone.
- CWE-529partialprevents — Training can raise awareness among architects and designers that ACL files must not be placed in directories accessible to unauthorized actors, addressing the 'omission during architecture and design' mode of introduction, but the actual file placement is a design decision and training alone does not fully prevent the weakness from arising.
- CWE-530partialprevents — Training administrators about secure backup handling (not leaving backups in webroot, proper storage locations, secure naming) prevents some instances of this operational weakness, but the mechanism is human practice and fallible, leaving a majority of instances unaddressed.
- CWE-531partialprevents — Training and awareness can educate developers that test code should not contain credentials, session identifiers, or configuration details, reducing a minority of instances; the effect is bounded by the fallibility of human practice and the clause's general-awareness mechanism, consistent with A.6.3 -> CWE-598 and A.8.28 -> CWE-79 at the same rung.
- CWE-535partialprevents — Training developers about secure error handling reduces some instances of shell error message exposure, but the mechanism is human practice and fallible; the defect is a code-level implementation choice that training catches only when developers internalize the lesson, leaving a majority of instances unaffected.
- CWE-537partialprevents — Training developers on secure error handling and exception management can reduce instances of sensitive information leaking through Java runtime error messages, but it is a minority effect because the specific technical knowledge required (catching exceptions, sanitizing error output) is narrow and even trained developers make such mistakes.
- CWE-538partialprevents — Training helps developers recognize that sensitive data should not be written to externally accessible files or logs, but the practice is fallible and the specific decision about what to log is often made under time pressure or for debugging convenience, so only a minority of instances are prevented.
- CWE-54partialprevents — Training in secure path handling makes developers more likely to validate trailing backslashes, but the practice is fallible and a minority of instances are prevented, consistent with the A.6.3 -> CWE-598 and A.8.28 -> CWE-79 anchors.
- CWE-540partialprevents — Training can teach developers not to embed credentials, tokens, internal hostnames, or debug comments in source code, addressing the knowledge-gap instances, but a meaningful share of CWE-540 arises from deliberate convenience choices (hardcoded secrets for speed) or from third-party/legacy code the training does not reach, so it moves a minority of instances -- consistent with the A.6.3 -> CWE-598 anchor at the same rung.
- CWE-541partialprevents — Training helps developers understand not to store credentials in include files and to configure proper file handlers, but as a fallible human-practice control it prevents only a minority of instances; the A.6.3 vs CWE-598 anchor sets the same rung for developer-introduced weaknesses.
- CWE-544partialprevents — Training can make developers aware of the need for consistent error handling and teach them standardized patterns, but CWE-544 is an architecture-and-design omission that requires organizational decisions and code-review discipline beyond what awareness alone delivers; the practice is fallible and the remainder is the bulk of instances.
- CWE-547partialprevents — Training in secure coding practices can teach developers to use symbolic names instead of hard-coded security-relevant constants, but this is a subtle code-quality issue that many developers do not recognize as a security concern, and even trained developers fall back to hard-coded values for convenience, so the effect is a minority one.
- CWE-549partialprevents — Training teaches developers that password fields must be masked, reducing instances where the omission is a knowledge gap, but the weakness is introduced at implementation in UI code and training is fallible — a minority of instances are prevented, consistent with the A.6.3 vs CWE-598 anchor.
- CWE-550partialprevents — Training developers on secure error handling (what not to expose in error messages) reduces instances of CWE-550, but as a fallible human practice it catches only a minority of cases, consistent with the A.6.3 -> CWE-598 anchor at the same rung.
- CWE-551partialprevents — Training developers in secure coding practices can make some of them aware that authorization must follow URL canonicalization, but this is a subtle ordering defect that most awareness programmes do not name explicitly, and the practice is fallible — consistent with the A.6.3 vs CWE-598 partial anchor and the A.8.28 vs CWE-79 partial anchor on the same kind of developer-introduced code defect.
- CWE-552partialprevents — Training raises awareness of file placement under web roots, archive packaging hygiene, and cloud storage access configuration, and the clause specifically addresses technical teams' skills for configuring security — but CWE-552 arises from specific technical decisions (storage account flags, IAM bindings, archive exclusions) that training alone does not fully prevent, placing it closer to the CWE-598 anchor than the CWE-1428 one.
- CWE-553partialprevents — Training helps developers and operations staff understand not to place shell files in web-accessible directories, addressing the knowledge gap that often produces this weakness, but the specific technical nature of the mistake and operational oversights mean training prevents only a minority of instances.
- CWE-554partialprevents — Training developers about secure coding practices, including input validation frameworks, can reduce instances of this ASP.NET misconfiguration, but the effect is a minority one because the choice is a specific architectural/implementation decision and training is fallible, similar to the A.8.28 -> CWE-502 anchor at partial.
- CWE-555partialprevents — Training technical teams on secure configuration practices (which A.6.3 explicitly covers) helps developers avoid storing plaintext passwords in config files, but the mechanism is fallible human practice and a nameable class of instances arises from convenience, oversight, or incomplete coverage of J2EE-specific guidance.
- CWE-556partialprevents — Training on least-privilege principles and secure configuration can reduce instances where developers or administrators enable ASP.NET impersonation unnecessarily, but this is a specific technical configuration choice often inherited from templates or tutorials, and standard awareness/training rarely covers it explicitly, so only a minority of instances are prevented.
- CWE-558partialprevents — A.6.3's education and training component can reach C/POSIX developers with thorough secure-coding training that covers non-reentrant functions, so a minority of getlogin() instances are kept out by trained developers who know to use getlogin_r() or capture the value before threading; the remainder is developers without that specific training, who introduce the call regardless.
- CWE-560partialprevents — Training in secure coding practices makes developers more likely to read API documentation carefully and understand the inverted semantics of umask() versus chmod(), reducing some instances, but this is a subtle API misuse rooted in misleading man pages that even careful developers fall into, and general awareness training does not reach this niche technical detail.
- CWE-562partialprevents — A.6.3's training portion targets technical teams' specific skill sets, so education on memory management and stack-frame lifetimes can keep some instances of returning a stack address from being written, but this is a minority effect — most developers learn it through formal CS education, code review, or static analysis rather than security training, and the awareness half of the clause does not reach code-level decisions at all.
- CWE-565partialprevents — Training raises developer awareness that cookies must be validated and integrity-checked, addressing the conscious-choice and knowledge-gap cases, but the actual implementation requires specific technical skill (signing, HMAC, validation patterns) that awareness alone does not confer, leaving a majority of instances to be caught by other controls.
- CWE-566partialprevents — Training in secure development can teach developers to verify per-record authorization rather than rely on interface filtering, addressing the knowledge gap that produces this flaw, but the weakness is subtle (the code uses parameterized queries correctly yet still misses the authorization check) and human practice is fallible, so training prevents a minority of instances.
- CWE-57partialprevents — Training can raise developer awareness of path canonicalization pitfalls and the need to normalize before access checks, but CWE-57 is a subtle implementation defect rather than a conscious choice or knowledge gap, so education moves only a minority of instances.
- CWE-574partialprevents — A.6.3's education and training component targets technical teams whose roles require specific skill sets, so an EJB-aware training programme would cover the specification's restriction on synchronization primitives; however, this is a niche EJB-specific rule that general security awareness does not reach, and even trained developers remain fallible on a detail this specialised, leaving most instances to arise.
- CWE-579partialprevents — Training technical teams on J2EE secure development practices can prevent some instances of storing non-serializable objects in HttpSession, but this is a niche implementation detail that most training programmes do not specifically cover, so the effect is a minority one.
- CWE-580partialprevents — A.6.3's education and training component for technical teams can cover Java-specific secure coding practices including the clone() contract, so a trained Java developer is less likely to write this defect; the effect is real but a minority one because the weakness is a niche Java idiom that most general security awareness does not reach, and even targeted training is fallible.
- CWE-583partialprevents — Training for technical teams whose roles require specific skill sets (mobile code developers among them) can include secure coding practices for mobile code, so educated developers are less likely to declare finalize() as public; but this is a niche rule, training is fallible, and the clause mandates a practice rather than a mechanism, leaving a majority of instances uncovered.
- CWE-584partialprevents — Training developers in secure coding practices, including proper exception handling in Java, reduces instances of this subtle language-specific bug, but the practice is fallible and most instances arise from developers who either lack the specific knowledge or make the mistake despite training.
- CWE-585partialprevents — Training technical teams in secure coding and concurrency practices helps some developers avoid empty synchronized blocks, but this is a niche Java-specific defect that general awareness programmes do not target reliably; the effect is real but a minority one, mirroring the A.8.28 -> CWE-502 rung.
- CWE-586partialprevents — Secure coding training can teach developers that explicit finalize() calls are bad practice, but this is a niche Java-specific implementation detail that general awareness training does not reach, so only a minority of instances are prevented.
- CWE-587partialprevents — Training technical teams in secure coding practices (the education/training portion of A.6.3) reduces some instances of this low-level pointer defect, but the practice is fallible and the weakness is a niche implementation issue that requires specific knowledge to avoid, leaving a majority of instances untouched.
- CWE-588partialprevents — A.6.3's training of technical teams can reduce instances of this C-language type-casting defect by building awareness of safe pointer and cast practices, but the effect is a minority one — the defect is subtle and requires deep technical mastery that general security training does not reliably impart, and stronger controls (secure coding, code review, static analysis) carry the bulk of prevention.
- CWE-589partialprevents — Training can raise developer awareness of API portability concerns and deprecated functions, but this is a specialized technical knowledge area where general awareness training reaches only a minority of instances; the specific API-version knowledge required is not what A.6.3's general programme reliably delivers.
- CWE-59partialprevents — Training developers about secure file handling practices (checking for symlinks, using safe file APIs, avoiding predictable temp filenames) reduces some instances of link-following defects, but the effect is a minority one because the practice is fallible and the stronger control is A.8.29 security testing, consistent with the A.8.28 -> CWE-79 and A.6.3 -> CWE-598 anchors.
- CWE-590partialprevents — Training technical teams in memory management reduces but does not eliminate C-level free() misuse defects; the clause's education half reaches this weakness the way A.6.3 reaches other developer-introduced code defects, but the practice is fallible and the strongest control is testing/review (A.8.29).
- CWE-593partialprevents — Security awareness and technical training can reduce the chance developers mishandle OpenSSL context lifetimes, but as fallible human practice covering a subtle API-specific pitfall it prevents only a minority of instances.
- CWE-595partialprevents — Secure coding training can teach developers the == vs .equals() distinction, but this is a narrow, language-specific implementation gotcha that even trained developers fall into; the effect is a minority reduction, consistent with A.6.3 -> CWE-598 (partial) and A.8.28 -> CWE-502 (partial).
- CWE-597partialprevents — Training on secure coding practices can teach developers to use .equals() instead of == in Java and to understand type-strict comparison in JavaScript/PHP, but this is a subtle language-specific gotcha that even trained developers frequently make, so the effect is real but covers a minority of instances.
- CWE-598partialprevents — Graded partial by the owner; no reasoning was recorded for this row beyond the grade.
- CWE-599partialprevents — Training developers in secure coding practices can reduce instances of missing certificate validation calls, but the specific OpenSSL API requirement (SSL_get_verify_result) is a narrow technical detail that general awareness training is unlikely to cover completely, leaving a nameable remainder of instances where developers lack this specific knowledge.
- CWE-600partialprevents — Training developers about exception handling and the risk of stack-trace disclosure helps some developers write servlets that catch exceptions, but the weakness is a specific implementation defect and the clause's mechanism is general awareness rather than secure-coding practice, so the effect is a minority one.
- CWE-603partialprevents — Training can prevent some instances where developers lack knowledge that client-side authentication is insecure, but the weakness is an architectural design decision often made for non-security reasons (simplicity, performance, perceived trust in client), so training reaches a minority of cases.
- CWE-605partialprevents — Training technical teams in secure network programming can raise awareness of SO_REUSEADDR/INADDR_ANY binding risks, but CWE-605 is a niche socket-level implementation detail that most developers will not encounter or recall from general security training, so the effect is a minority of instances.
- CWE-606partialprevents — Training developers in secure coding practices helps them recognize and validate loop-condition inputs, but the effect is a minority one because the practice is fallible and a different clause (e.g. A.8.29 security testing) carries the stronger preventive effect, mirroring the A.8.28 -> CWE-502 anchor.
- CWE-607partialprevents — Training in secure coding practices can teach Java developers that arrays and collections remain mutable when assigned to public static final fields, addressing a knowledge gap that produces this defect; the effect is a minority one because the issue is specialized, training is fallible, and stronger controls (secure coding standards, code review, SAST) carry more of the load.
- CWE-61partialprevents — Education and training for technical teams can raise awareness of symlink-following risks so developers handle file paths defensively, but this is a specialized implementation defect that general awareness rarely covers and the practice is fallible, so only a minority of instances are prevented.
- CWE-611partialprevents — Training developers about secure XML parsing practices (disabling external entity resolution, using safe parser configurations) reduces some instances of XXE, but the weakness is a specific implementation defect that requires technical knowledge to avoid, and developers remain fallible; the strongest control for this weakness is A.8.29 security testing, not training.
- CWE-614partialprevents — Training developers on web application security covers the Secure cookie attribute as a known practice, reducing instances where the flag is omitted from unawareness, but it remains a granular implementation detail that trained developers still forget or overlook, so only a minority of instances are prevented.
- CWE-615partialprevents — Training can make developers aware that comments should not contain sensitive information (filenames, internal hostnames, credentials, etc.), but this is a carelessness/habit issue during implementation that training only partially addresses; many developers will still leave such information in comments despite awareness, and code review is the stronger control.
- CWE-616partialprevents — Training can teach developers to use $_FILES instead of the deprecated four-globals pattern, preventing some instances, but as a fallible human-practice mechanism against a specific PHP implementation defect it moves only a minority of cases — consistent with A.6.3 -> CWE-598 = partial and A.8.28 -> CWE-79 = partial.
- CWE-617partialprevents — Training developers about secure coding practices (including not using assert() for input validation in production) reduces some instances of reachable assertions, but the practice is fallible and the specific implementation detail requires targeted knowledge that general awareness only partially delivers.
- CWE-618partialprevents — Training developers about secure ActiveX design and browser security models can reduce some instances of exposed unsafe methods, but the weakness is a specialized architecture/implementation defect that most training programmes do not specifically target, and developers remain fallible.
- CWE-62partialprevents — Training can raise developer awareness of hard-link attack patterns and the need to check for them, but CWE-62 is a subtle implementation defect requiring specific UNIX filesystem knowledge that most developers lack, so education prevents only a minority of instances.
- CWE-620partialprevents — Training developers about authentication best practices can prevent some instances of this code-level defect, but the weakness is a specific implementation choice that requires secure coding practice, code review, and testing to fully address; training is fallible and reaches only a minority of cases, consistent with the A.6.3 vs CWE-598 anchor.
- CWE-621partialprevents — Training developers about secure coding practices (including dangers of extract() and similar functions without proper arguments) reduces but does not eliminate this implementation flaw; the effect is a minority one because the specific knowledge is technical, training is fallible, and stronger controls (code review, SAST, secure coding standards) carry the bulk of prevention.
- CWE-622partialprevents — Technical training under A.6.3 can teach developers writing hook code to validate arguments, reducing some instances, but this is a specialized low-level implementation defect where most developers lack the specific expertise and the remainder (untrained or fallible developers, and the deep kernel-level knowledge required) is substantial.
- CWE-623partialprevents — Training can make developers aware of the risks of marking ActiveX controls as safe-for-scripting, but this is a niche technical decision that depends on understanding the specific control's behavior rather than general security knowledge, so only a minority of instances are prevented.
- CWE-624partialprevents — Training in secure coding and input validation can keep some developers from inserting user-controlled inputs into regex patterns or enabling executable modifiers, but CWE-624 is a niche, under-studied implementation flaw (the CWE notes flag it as under-reported) that most awareness and even secure-coding programmes do not cover in depth, so only a minority of instances are prevented.
- CWE-627partialprevents — Training developers in secure coding practices reduces the likelihood they introduce dynamic variable evaluation with user-controlled names, but the weakness is a specialized implementation detail (mostly PHP, under-reported per CWE notes) and developers remain fallible; the strongest control is A.8.29 security testing, mirroring the A.8.28 -> CWE-79 and A.6.3 -> CWE-598 rungs.
- CWE-640partialprevents — Training helps developers recognize weak recovery designs (throttling, security questions, token invalidation) but the weakness is a detailed design/implementation choice that training alone does not prevent; the stronger controls are secure coding standards and security testing, leaving training as a minority effect.
- CWE-641partialprevents — Training developers about secure file/resource name handling and input validation reduces instances of this code-level defect, but the practice is fallible and the weakness requires careful implementation discipline that training alone does not guarantee, matching the A.6.3 -> CWE-598 anchor's `partial` rung for developer-introduced weaknesses.
- CWE-643partialprevents — Training technical teams on secure coding practices (the education and training component of A.6.3) helps developers avoid XPath injection by teaching input neutralization and parameterized query use, but the effect is a minority one because training is fallible and the strongest control for this implementation defect is secure coding standards and security testing, not awareness.
- CWE-644partialprevents — Training developers about output encoding and HTTP header handling reduces some instances of this implementation defect, but the weakness is a specific technical detail in code that even trained developers miss; the effect is a minority one, consistent with A.6.3 -> CWE-598 and A.8.28 -> CWE-79 at the same rung.
- CWE-647partialprevents — Training developers on secure authorization patterns reduces the odds they introduce URL-canonicalization flaws, but the issue is subtle and specialized, so even trained developers miss it; consistent with A.6.3 -> CWE-598 = partial on a comparable developer-introduced implementation flaw.
- CWE-649partialprevents — A.6.3's education and training component for technical teams covers cryptographic practices, and a well-implemented programme teaches the distinction between confidentiality and integrity protection, preventing some instances where developers would otherwise rely on encryption alone; the effect is a minority one because the topic is specialized, only developers implementing crypto receive it, and even trained developers can still confuse the two services.
- CWE-651partialprevents — Training developers to consider what their WSDL exposes (method names, parameters, deprecated services) can reduce instances where sensitive internal structure leaks, but WSDL files are typically auto-generated by frameworks from the code itself, so the weakness arises from architectural and configuration choices that awareness only partially reaches.
- CWE-652partialprevents — Training developers about input neutralization and parameterized XQuery construction reduces a minority of XQuery injection instances, but the effect is bounded by training's fallibility and the specialized nature of XQuery, with secure coding practice and security testing carrying the stronger preventive effect.
- CWE-654partialprevents — Training developers about the importance of multi-factor authentication can influence design decisions away from single-factor reliance, but the weakness is fundamentally an architectural choice and training is fallible — many systems still ship with single-factor auth despite awareness programmes existing.
- CWE-663partialprevents — Training technical teams on reentrancy, thread safety and signal-handler semantics can keep some instances of this defect from being written, but the topic is niche and the defect subtle enough that even trained developers miss it, so the effect is a minority one — the same shape as A.8.28 -> CWE-502.
- CWE-67partialprevents — Training on secure input handling can make some developers aware of Windows device name pitfalls and filter them, but this is a niche implementation detail that most general awareness training will not cover, so only a minority of instances are prevented.
- CWE-676partialprevents — Training developers about dangerous functions (strcpy, strcat, sprintf, etc.) and safer alternatives reduces but does not eliminate their use; the weakness is introduced at implementation by developer choice, and like A.8.28 vs CWE-79, a practice-based control moves a minority of instances because developers remain fallible.
- CWE-690partialprevents — Training raises developer awareness of the need to check return values from functions like malloc() or gethostbyaddr(), reducing a minority of instances, but the defect is a fallible coding practice that training alone does not reliably catch, consistent with the A.6.3 vs CWE-598 anchor.
- CWE-691partialprevents — Training developers in secure coding practices — proper error checking, control flow scoping, brace discipline, return-value handling — reduces instances of insufficient control flow management, but the mechanism is human practice and is fallible; the strongest control for this code-level defect is testing (A.8.29), not awareness.
- CWE-692partialprevents — Training can teach developers that denylist-based XSS protection is fundamentally insufficient and steer them toward allowlist/encoding approaches, reducing some instances, but developers still choose denylists under time pressure or from incomplete understanding, so the weakness continues to arise.
- CWE-695partialprevents — Training can inform developers that low-level functionality is prohibited by the framework and teach the safer alternatives, addressing the knowledge-gap mode of CWE-695, but it does not prevent deliberate workarounds when the framework lacks a needed capability, and developers remain fallible — consistent with the A.6.3 -> CWE-598 and A.8.28 -> CWE-79 anchors at `partial`.
- CWE-697partialprevents — Training raises developer awareness of common comparison pitfalls (wrong boolean operators, missing factors, non-constant-time checks, using attacker-controlled lengths), reducing a minority of instances, but the defect lives in the code itself and fallible human practice cannot prevent most of it.
- CWE-698partialprevents — Training on secure coding practices helps some developers recognize that code after a redirect must not execute, but CWE-698 is a subtle framework-specific implementation error that training reaches only as a minority of instances, much like A.6.3 vs CWE-598.
- CWE-703partialprevents — Awareness and technical training can teach developers to check return values and handle exceptions, reducing the introduction of CWE-703 flaws, but human fallibility and the breadth of exceptional-condition cases leave most instances not reliably prevented.
- CWE-710partialprevents — A.6.3's training of technical teams can raise awareness of coding standards and the skills needed to follow them, but adherence is a discipline issue where developers often know the standards yet cut corners; the mechanism is human practice, which is fallible, so only a minority of instances are prevented.
- CWE-73partialprevents — Training developers about input validation and path handling reduces instances of CWE-73 but is fallible human practice; the weakness is a code-level implementation defect that training alone cannot fully prevent, leaving a nameable remainder of cases where developers still write unvalidated path operations.
- CWE-749partialprevents — Training can make developers aware that dangerous methods should be restricted (visibility modifiers, access controls, framework-specific annotations like @JavascriptInterface), reducing a minority of instances, but the weakness is fundamentally an architecture/design and implementation choice that fallible human practice does not reliably prevent.
- CWE-756partialprevents — Training developers about secure error handling can make them aware that default error pages leak sensitive information and prompt them to configure custom error pages, but this is a specific implementation detail that only a minority of training programmes cover in depth, and even trained developers may not apply it consistently.
- CWE-759partialprevents — Training in secure password storage practices teaches developers to salt hashes, so a minority of instances are avoided through education, but the specific implementation detail is narrow enough that general awareness programmes do not reach most developers who introduce it.
- CWE-76partialprevents — Training helps some developers recognize that special elements have equivalent forms (alternate encodings, alternate switches) and broaden their neutralization logic, but the weakness is a subtle, specialized implementation defect where the developer's mental model of what to filter is incomplete — a knowledge gap training reaches only partially, with most instances still arising from developers who have not internalized the equivalence problem.
- CWE-760partialprevents — Training developers in secure password storage practices reduces the odds they choose a predictable salt, but the effect is a minority one: salt generation is a specific cryptographic implementation detail not all developers are trained on, the practice is fallible, and the stronger controls (A.8.24 cryptography policy, A.8.29 security testing) carry the bulk of the effect — consistent with the A.6.3 vs CWE-598 anchor at the same rung.
- CWE-761partialprevents — Training developers in secure memory management practices (pointer arithmetic, free() semantics) reduces some instances of this low-level C/C++ defect, but developers remain fallible and the practice catches a minority of cases, consistent with A.8.28 -> CWE-502 and A.6.3 -> CWE-598 at the same rung.
- CWE-762partialprevents — Training technical teams in secure coding practices (the education and training portion of A.6.3) helps some developers avoid mismatched allocation/deallocation calls, but the effect is a minority one because the specific knowledge required is detailed, human practice is fallible, and not every developer receives this targeted instruction -- consistent with the A.8.28 -> CWE-79 and A.6.3 -> CWE-598 anchors at this rung.
- CWE-766partialprevents — Training in secure coding principles (encapsulation, access modifiers, data hiding) helps some developers avoid declaring critical fields public, but the effect is a minority one because the decision is made at the code level and training is fallible; the A.6.3 anchor on CWE-598 (a similar developer-introduced code choice) sits at `partial` for the same reason.
- CWE-767partialprevents — Training in secure coding principles (encapsulation, access modifiers) helps some developers avoid exposing private variables through public methods, but the defect often arises from subtle typos or lapses in implementation discipline that training does not reliably catch, matching the A.8.28 -> CWE-79 partial rung for human-practice controls against code-level defects.
- CWE-772partialprevents — Training developers in secure coding practices (including resource lifecycle management) reduces a minority of CWE-772 instances by raising awareness of release obligations, but the defect is subtle—often hiding in exception paths—and the strongest controls are code review and security testing (A.8.29), not training alone.
- CWE-776partialprevents — Training developers in secure XML handling can teach them to disable DTD processing or limit entity expansion, preventing some instances, but this is a specific technical configuration that requires correct implementation and the practice is fallible, leaving most instances unaffected by training alone.
- CWE-78partialprevents — Training helps developers understand the risks of unsafe OS command construction and the need for input neutralization, but general awareness training is fallible and less directly applicable than dedicated secure coding practice (A.8.28, graded `partial` against XSS); most OS command injection instances arise from implementation mistakes that awareness alone does not prevent.
- CWE-780partialprevents — A.6.3's training of technical teams can teach developers to use OAEP with RSA, reducing some instances of this weakness, but the choice is a specialized cryptographic detail that not all developers receive specific training on, and even trained developers remain fallible — the same reasoning that placed A.6.3 vs CWE-598 at `partial`.
- CWE-782partialprevents — Training technical teams on secure coding practices including IOCTL access control reduces some instances, but the practice is fallible and the strongest control for this low-level implementation defect is secure coding standards and code review, not awareness training alone.
- CWE-784partialprevents — Training developers about cookie manipulation risks and proper session management can prevent some instances of trusting cookie values for security decisions, but this is a specific implementation defect requiring technical depth beyond general awareness, and most developers will not receive targeted training on cookie integrity checking.
- CWE-785partialprevents — Education and training for technical teams can teach developers about path manipulation function buffer-size requirements, but this is a very specific low-level C/C++ implementation defect where even trained developers make mistakes, and not all relevant developers receive this targeted training.
- CWE-787partialprevents — Training developers in secure coding practices (bounds checking, safe memory handling) reduces some out-of-bounds write instances, but the defect requires deep technical knowledge and even trained developers make these mistakes, so only a minority of instances are prevented.
- CWE-789partialprevents — Training technical teams on secure coding practices (the education/training portion of A.6.3) can reduce instances of unchecked memory allocation by raising developer awareness of input validation for size values, but the effect is a minority one — the same human-practice ceiling that caps A.8.28 on CWE-502 and CWE-79, and that graded A.6.3 partial on CWE-598.
- CWE-79partialblocks — Training partially blocks XSS exploitation by making users less likely to click on malicious links delivering XSS payloads and by making developers more likely to add some defensive measures, but it does not stop the underlying code defect from being exploitable, consistent with the AT-2 vs CWE-79 blocks=partial calibration anchor.
- CWE-79partialprevents — Training raises developer awareness of input neutralization responsibilities and can reduce some XSS introductions, but XSS requires specific technical secure-coding knowledge beyond general awareness, and trained developers remain fallible — consistent with the A.8.28 vs CWE-79 anchor at `partial` and the A.6.3 vs CWE-598 anchor at `partial` for a comparable developer-introduced weakness.
- CWE-791partialprevents — Training helps developers write more complete filters (e.g., using global match modifiers, testing edge cases), but the defect is a code-level implementation mistake that arises the same with or without awareness, so only a minority of instances are prevented.
- CWE-793partialprevents — Training on secure coding practices can teach developers to use global match modifiers and similar patterns, but CWE-793 is a subtle implementation detail that training only partially addresses; the practice is fallible and a different control (security testing/A.8.29) carries the stronger effect.
- CWE-794partialprevents — Training in secure coding practices (regex modifiers, complete filtering patterns) reduces instances of this developer-introduced implementation defect, but the weakness is a subtle code-level mistake that training catches only a minority of the time, consistent with A.6.3 -> CWE-598 at partial.
- CWE-795partialprevents — Training in secure input handling makes developers more likely to write comprehensive filters rather than position-specific ones, but this is a subtle implementation defect that training alone does not fully prevent — the strongest control is security testing (A.8.29), and developers remain fallible on the specific positional-filtering mistake.
- CWE-796partialprevents — Training in secure input validation practices helps some developers avoid writing positional-only filters, but the bug is subtle (e.g., `s/^\.\.\///` vs. a global match) and developer practice is fallible, so only a minority of instances are prevented.
- CWE-797partialprevents — Training developers in secure input validation practices reduces the likelihood they will write position-specific filtering instead of comprehensive sanitization, but the defect is subtle enough that even trained developers introduce it, and the stronger preventive effect comes from secure coding standards, code review, and security testing rather than awareness training.
- CWE-798partialblocks — Education on secure configuration practices discourages technical staff from embedding or relying on hard-coded credentials in systems and applications.
- CWE-798partialprevents — Training teaches developers not to hard-code credentials, addressing the knowledge-gap and shortcut-choice drivers of first-party instances, but the effect is fallible and a large share of CWE-798 instances arrive in third-party components, firmware, and COTS products where the organization's training does not reach.
- CWE-80partialprevents — Training helps some developers learn proper output encoding for script-related tags, but the effect is a minority one: training is fallible, not all developers receive adequate depth on encoding specifics, and A.6.3 is broader awareness rather than the secure-coding practice A.8.28 mandates, so the bulk of XSS instances still arise.
- CWE-807partialprevents — Training developers about not trusting client-side inputs (cookies, form fields, environment variables) addresses the knowledge gap that produces this weakness, but CWE-807 is fundamentally an architectural/design flaw where the protection mechanism is built on untrusted inputs, and even trained developers can still introduce this pattern; the effect is real but a minority one, similar to A.6.3 vs CWE-598.
- CWE-81partialprevents — Training developers about XSS and proper output encoding in error pages reduces some instances of this code-level defect, but the effect is a minority one — the actual prevention comes from secure coding practice, code review, and testing, and trained developers remain fallible, consistent with the A.8.28 vs CWE-79 (XSS) and A.6.3 vs CWE-598 anchors.
- CWE-82partialprevents — Training developers about XSS risks in HTML output, including IMG tag attributes, reduces but does not eliminate this implementation defect; the practice is fallible and a different clause (A.8.28 secure coding) carries the stronger effect, mirroring the A.8.28 -> CWE-79 anchor at the same rung.
- CWE-820partialprevents — A.6.3's technical-team training can include secure coding practices covering concurrency primitives, so educated developers avoid some synchronization mistakes, but most instances still arise because synchronization is a specialized topic and even trained developers make concurrency errors.
- CWE-821partialprevents — A.6.3's training of technical teams can reduce incorrect synchronization defects by building concurrency and secure-coding skill, but synchronization bugs are subtle and even trained developers introduce them, so training moves only a minority of instances.
- CWE-829partialprevents — Training can make developers aware of the risks of including functionality from untrusted sources (libraries, widgets, third-party code), which prevents some instances where developers would otherwise pull in unvetted dependencies; but the decision is often driven by functional need and time pressure, and even trained developers routinely include third-party code without fully vetting its control sphere, so a substantial remainder of instances still arises.
- CWE-830partialprevents — Training can educate developers about the risks of including untrusted third-party web widgets and scripts, addressing the knowledge gap noted in CWE-830's description ('programmers are not aware that a dependency exists'), but most inclusions are deliberate architectural choices for business reasons (analytics, social integration) that training alone does not prevent.
- CWE-836partialprevents — Training can teach developers that accepting client-supplied hashes for authentication is insecure (a knowledge gap similar to the CWE-598 anchor), but this is a specialized architectural decision where general awareness reaches only a minority of instances.
- CWE-838partialprevents — Training can teach developers about output encoding contexts and the need to match encoding to the downstream component, but CWE-838 is a nuanced technical choice (e.g., HTML entity vs attribute encoding) where the wrong but closely-related encoding is selected; education raises awareness but does not fully prevent the specific context-dependent mistake, leaving a nameable remainder of instances where developers still pick the wrong encoding.
- CWE-84partialprevents — Training developers about encoded URI scheme attacks (a specific XSS variant) reduces but does not eliminate this implementation defect; the A.6.3 vs CWE-598 anchor sets the rung for developer-introduced weaknesses at partial, and CWE-84 is a comparable code-level flaw where education helps a minority of instances.
- CWE-842partialprevents — Training makes administrators aware of least-privilege principles and the security implications of incorrect group membership, reducing some instances, but most group-assignment errors arise from complex hierarchies, default configurations, and procedural gaps that training alone does not reach.
- CWE-86partialprevents — Training raises awareness of input validation and XSS risks, which keeps some instances of invalid-character neutralization defects from being written, but the specific null-byte and identifier-bypass technique is a narrow technical issue where most instances arise from developers who lack the specialized knowledge training cannot reliably convey.
- CWE-87partialprevents — Training developers about XSS risks and proper neutralization techniques can reduce instances of incomplete denylists like the one CWE-87 describes, but the practice is fallible and the strongest control is secure coding/testing (A.8.28/A.8.29), so only a minority of instances are prevented.
- CWE-88partialprevents — Training developers about secure command construction and argument handling reduces argument injection instances, but the practice is fallible and most such flaws still slip through, matching the same partial rung A.6.3 and A.8.28 hold on other developer-introduced injection flaws.
- CWE-89partialprevents — A.6.3's education and training for technical teams reduces the odds that developers write unneutralised SQL, but as a fallible human practice covering only part of the developer population it keeps a minority of injection defects from ever arising, in line with the owner's partial grade for training against developer-introduced weaknesses such as CWE-598 and CWE-79.
- CWE-9partialprevents — A.6.3's training of technical teams on configuring security can inform developers about proper EJB method permission design, but CWE-9 is a specific J2EE deployment-descriptor misconfiguration where training alone leaves a nameable remainder of instances arising from incomplete understanding of the J2EE security model or inattention to access-control granularity.
- CWE-90partialprevents — Training technical teams in proper input neutralization for LDAP queries can prevent some instances of LDAP injection, but developers are fallible and the strongest controls for this code-level defect are secure coding (A.8.28) and security testing (A.8.29); training moves a minority of instances, consistent with the A.6.3 vs CWE-598 anchor.
- CWE-914partialprevents — Training technical teams on secure coding practices (the education-and-training half of A.6.3) reduces the odds a developer reaches for extract()/import_request_variables() or similar dynamic-variable constructs, but the practice is fallible and the pattern can be subtle (e.g., buried in include files), so only a minority of instances are kept from arising.
- CWE-916partialprevents — Training can teach developers about proper password hashing schemes (bcrypt, scrypt, Argon2, salting, iteration counts), reducing some instances of CWE-916, but the decision is technical and requires specific cryptographic knowledge that general awareness training does not reliably convey, and developers remain fallible.
- CWE-921partialprevents — Training can teach developers and architects to recognize storage mechanisms lacking access control and to choose appropriate alternatives, reducing instances where sensitive data lands in globally-readable storage; however, functional requirements (portability, cross-app sharing, user accessibility) often drive the choice, and training alone does not fully prevent the architecture/design omission.
- CWE-924partialprevents — Training developers in secure communication practices helps them implement message integrity checks (TLS, MACs, signatures), but the practice is fallible and the strongest control for this implementation-level weakness is security testing (A.8.29), not awareness.
- CWE-926partialprevents — Training on Android secure development practices can teach developers to set `android:exported=false` and apply permission restrictions, but this is a narrow technical detail that only reaches developers who receive Android-specific security training, and the auto-export default in older Android versions makes it easy to overlook even with awareness.
- CWE-927partialprevents — A.6.3's education and training programme for technical teams can teach Android developers that implicit intents expose sensitive data to any registered receiver, but this is a specific API-level pattern that requires detailed secure-coding knowledge; even trained developers make mistakes, and not all training programmes cover Android intent security, so only a minority of instances are prevented.
- CWE-93partialprevents — Training developers on input neutralization helps some avoid CRLF injection, but it is a specific implementation defect requiring technical knowledge applied during coding, and developers remain fallible; consistent with A.6.3 vs CWE-598 at partial.
- CWE-939partialprevents — Training developers about authorization principles and secure URL scheme handling can reduce instances of this defect, but the effect is a minority one because the weakness is a specific code-level authorization omission that requires deliberate implementation choices, and training is fallible.
- CWE-94partialprevents — Training technical teams in secure coding practices (per A.6.3's education and training guidance) helps developers avoid constructing code from untrusted input without neutralization, but the effect is a minority one because the clause mandates a general awareness/training practice rather than a specific secure-coding mechanism, and developers remain fallible.
- CWE-95partialprevents — Training teaches developers the dangers of eval() with untrusted input and safer alternatives (e.g., ast.literal_eval), so a minority of instances are avoided, but the practice is fallible and the weakness is introduced at code-writing time where many other factors compete, matching the A.8.28 -> CWE-79 / CWE-502 partial rung.
- CWE-96partialprevents — Training developers about input neutralization and the dangers of allowing user input to flow into executable resources reduces instances of static code injection, but developers are fallible and the strongest control for this implementation defect is security testing (A.8.29) or secure coding practice (A.8.28), consistent with the A.6.3 -> CWE-598 and A.8.28 -> CWE-79 anchors.
- CWE-97partialprevents — Training developers about input neutralization reduces some instances of SSI injection, but the specific technical knowledge required to recognize and properly neutralize SSI directives is a minority effect of general awareness training, consistent with the A.6.3 -> CWE-598 partial anchor and the A.8.28 -> CWE-79 partial anchor on a closely related input-neutralization weakness.
Mitigated MITRE ATT&CK techniques (3331)
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
- T1204mostlyprevents — Trained users are more likely to recognize and avoid executing malicious files, links, or images delivered through social engineering, thereby limiting user-driven execution of adversary payloads.
- T1566mostlyprevents — Personnel who regularly receive awareness training on phishing indicators and reporting procedures are less likely to open malicious attachments or click malicious links, reducing the success rate of phishing campaigns.
- T1598mostlyprevents — Security awareness reduces the chance that employees will disclose sensitive organizational information when targeted by information-gathering phishing attempts.
- T1027.006partialprevents — Training can reduce the rate at which personnel open suspicious HTML files or accept unexpected browser-initiated downloads, but HTML smuggling is specifically engineered to appear benign (benign MIME types, normal download attributes) so users have limited surface to recognize, and the technique cannot be moved to zero by awareness alone.
- T1027.012partialprevents — Training reduces the rate at which personnel invoke suspicious LNK files delivered as phishing payloads, but cannot move that rate to zero, and the technique's post-compromise use (malicious scripts executing LNK files on an infected host) is entirely outside the human-mechanism control's reach.
- T1027.017partialprevents — Training can make users more cautious about unexpected SVG files and aware that SVGs can contain executable scripts, lowering the rate at which they open or interact with them, but cannot move that rate to zero since users must still handle SVGs for legitimate work and the technique exploits the file's image-like appearance.
- T1036.001partialprevents — Awareness training can teach users to verify digital signatures and be skeptical of files that appear signed but fail validation, reducing the rate at which users are deceived; however, the technique also targets security tools and analysts (not user-trainable), and even trained users can be fooled by sophisticated signature mimicry, so the reduction is a rate and not a closure.
- T1036.002partialprevents — Training users to recognize RTLO characters and understand how file names can be visually reversed directly addresses the user-facing deception the technique relies on, lowering the rate at which they execute disguised files; it cannot move that rate to zero, and the technique also targets defenders' tools (e.g., regedit) where user awareness is not the mechanism, leaving a bounded remainder.
- T1036.006partialprevents — Training can raise awareness about file extensions, suspicious filenames, and the risks of double-clicking files, measurably lowering the rate at which users execute disguised binaries; however, the technique is specifically designed to look benign (a trailing space is visually undetectable), so a trained workforce still occasionally falls for it, and the reduction is a rate rather than a closure — the same shape the owner ruled for A.6.3 vs T1566.001.
- T1036.007partialprevents — Training can teach users to recognize double extensions and verify true file types before opening, measurably lowering the rate at which they are deceived, but cannot move that rate to zero — the same shape as the A.6.3 vs T1566.001 anchor.
- T1036.008partialprevents — Training can make users more cautious about files with mismatched extensions or unusual properties, partially reducing the user-facing deception aspect, but the technique is primarily a technical manipulation of file headers/extensions to bypass validation checks and is often used in automated transfers where no user is in the loop.
- T1052partialprevents — Training reduces the rate at which personnel insert unknown or found removable media, which is the user-introduced path for T1052, but cannot move that rate to zero and does not reach the adversary-introduced path (air-gapped compromise, pre-existing access) where no user decision is in the loop.
- T1052.001partialprevents — Training makes personnel aware of policies against introducing unauthorized USB devices and of their personal accountability, which measurably lowers the rate at which they would do so, but cannot physically block USB ports, cannot stop determined insiders, and cannot prevent malware from automatically writing to a USB when one is inserted — the same shape as the A.6.3 vs T1566.001 anchor.
- T1056partialprevents — Training can reduce the rate at which personnel enter credentials into deceptive capture portals (T1056.003 Web Portal Capture), but cannot prevent transparent input-capture mechanisms such as Credential API Hooking (T1056.004) or keylogging, where the user is not in the loop and no user-visible artifact exists to be trained on — so only a slice of the technique's surface is addressed.
- T1056.002partialprevents — Training can teach users to recognize spoofed credential dialogs (unexpected prompts, unverified sources, mismatched context), measurably lowering the rate at which they enter credentials into a fake prompt, but cannot move that rate to zero — a trained user still occasionally complies, and the delivery mechanism is untouched.
- T1059.005partialprevents — Training reduces the rate at which users enable macros or open VBA-bearing documents, which is one common vector for T1059.005, but the technique also runs via paths with no human in the loop (HTA-served VBScript, direct script execution, COM/Native API abuse), so the technique is not prevented across its full surface.
- T1078.001partialprevents — Training can make administrators and users aware of the need to change default credentials and avoid using default accounts, which has a measurable preventive effect, but the mechanism is awareness rather than enforcement, and many default accounts sit on systems outside the trainee's reach (cloud provider defaults, vendor appliances, integrated-service accounts like vpxuser), so what is prevented is a slice rather than the bulk — and the bulk of prevention belongs to A.8.9 configuration management, which takes `full` on this same technique.
- T1078.003partialprevents — Training reduces the human-controllable surface of local account abuse — password hygiene, not sharing credentials, administrators configuring local accounts securely and recognising misuse — but cannot prevent the technical core of the technique (credential dumping, exploitation, password reuse across systems the user does not control), so the preventive effect is a slice rather than a closure.
- T1078.004partialprevents — Training reduces the rate at which personnel fall for phishing that yields cloud credentials and reinforces password/credential hygiene, but cannot prevent brute force, federation abuse, misconfiguration exploitation, or the actual use of valid accounts once obtained — the core of T1078.004 sits outside the human-mechanism loop.
- T1091partialprevents — Training reduces the rate at which personnel insert unknown media or execute files from it, but cannot move that rate to zero and does not address the non-human vectors (Autorun execution, firmware modification, mobile-device auto-mount) that execute without user decision.
- T1110.003partialprevents — Training can influence password selection (reducing use of common passwords like 'Password01') and encourage reporting of suspicious activity, but password spraying is an automated attack against authentication systems that does not require user interaction, so the preventive effect is indirect and limited compared to techniques where the human is the delivery mechanism.
- T1110.004partialprevents — Training can reduce password reuse across services — the core vulnerability credential stuffing exploits — by making users aware of the risk and encouraging unique passwords or password managers, but it cannot move reuse to zero, and credential stuffing remains fully effective against users who reuse passwords regardless of training.
- T1127.002partialprevents — Training can reduce the rate at which users click 'Install' on unexpected ClickOnce popups (the user-execution path), but the technique also executes without user interaction via rundll32 abuse and startup-folder placement, and even trained users still install — so the reduction is a slice, not a closure.
- T1137partialprevents — Training reduces the rate at which users enable macros in untrusted documents, install suspicious add-ins, or configure malicious Outlook rules, but cannot prevent the technique entirely because the persistence mechanisms can be deployed without user action once an attacker has system access, and training cannot reach every user or every deployment vector.
- T1137.001partialprevents — Training can shape how technical staff configure Office macro policies, trusted locations and template security, and can make users less likely to enable macros or ignore suspicious template behaviour, but the technique is a post-compromise persistence action where the adversary modifies template files directly — training neither stops the file modification nor reaches the configurations on every endpoint, so the preventive effect is a slice rather than a closure.
- T1176partialprevents — Training can lower the rate at which personnel install malicious extensions or fall for social engineering that delivers them, but cannot move that rate to zero, and the technique also runs via compromised marketplaces and by adversaries who already have system access — neither of which a user is in the loop for.
- T1176.001partialprevents — Training can reduce the rate at which personnel install malicious extensions from app stores or via social engineering, but several execution paths bypass the user entirely (silent preference-file modification, post-compromise installation, server-side update URL manipulation), so the technique cannot be prevented completely.
- T1176.002partialprevents — Developers are the human-in-the-loop for installing IDE extensions, and A.6.3's education/training for technical teams can teach them to vet extension sources, review permissions, and recognize supply-chain risks — measurably lowering the rate of malicious installations, but not eliminating them because developers legitimately need extensions, marketplaces themselves can be compromised, side-loading bypasses vetting, and benign extensions can be abused for tunneling.
- T1187partialprevents — Training can reduce the rate at which users open malicious attachments containing resource links and make them wary of placing .SCF/.LNK files on shared paths, addressing some delivery vectors; however, the core mechanism — automatic SMB/WebDAV authentication triggered by system behavior such as icon rendering — is not addressable through awareness, and the EfsRpcOpenFileRaw variant has no user component at all, leaving a substantial remainder.
- T1189partialprevents — Training can reduce the user-assisted slice of drive-by compromise — users heeding browser warnings, declining to enable scripting or allow push notifications on suspicious sites, and not ignoring security dialogs — but cannot prevent the automatic exploitation path where scripts execute and exploit vulnerable browsers without user action, leaving a substantial remainder the control cannot reach.
- T1195.001partialprevents — Training developers to recognize typosquatted packages, vet CI/CD actions, and review dependency configurations can reduce the rate at which they introduce compromised supply chain components, but cannot prevent compromises of already-trusted packages, sophisticated attacks passing review, or automated dependency updates pulling malicious code — the human is in the loop for some installation decisions but not for the technique's full surface.
- T1200partialprevents — Awareness training can include guidance on not connecting unknown hardware and reporting suspicious devices, which reduces the rate at which personnel facilitate hardware additions, but the technique can be executed covertly by an adversary with physical access without any user cooperation, so the prevention is a slice rather than a closure.
- T1203partialprevents — Training reduces the rate at which users open malicious documents or click links that trigger client-side exploits (the Office and third-party application vectors requiring user action), but cannot prevent drive-by browser exploits that need no user action, cannot patch the underlying software vulnerabilities, and cannot reach the technical exploitation itself — the same shape as the A.6.3 vs T1566.001 anchor at `prevents` partial.
- T1204.001partialprevents — Training measurably lowers the rate at which a user clicks a malicious link, but cannot move that rate to zero — the same shape the owner ruled for A.6.3 vs T1566.001, and the user is the control surface here just as in spearphishing.
- T1204.002partialprevents — Training measurably lowers the rate at which a user opens a malicious file, but cannot move that rate to zero — the same shape the owner ruled for A.6.3 vs T1566.001, since T1204.002 is the user-execution step of the same chain.
- T1204.003partialprevents — Training can lower the rate at which users pull and deploy untrusted or backdoored images by raising awareness of supply-chain risks and verification practices, but cannot move that rate to zero — developers routinely deploy images for legitimate reasons, and the technique is explicitly designed to mimic legitimate resources, so what is prevented is a slice rather than the bulk.
- T1204.004partialprevents — The user is the mechanism in T1204.004 — they must actively copy and paste the malicious code — so awareness and training can teach recognition of ClickFix lures (fake CAPTCHAs, fake error messages) and measurably lower the rate at which personnel paste, but cannot reduce it to zero, matching the shape of the A.6.3 vs T1566.001 anchor.
- T1204.005partialprevents — Training can teach developers to verify package sources, recognize typosquatting, and review dependencies before installation, measurably reducing the rate of malicious library installation, but cannot eliminate it since developers must install packages to work and sophisticated malicious packages evade casual inspection — the same shape as the A.6.3 vs T1566.001 anchor.
- T1213.005partialprevents — Training can reduce what personnel put into chat (credentials, source code, incident-response discussions), shrinking the value of what an adversary mines, but it cannot remove data already in chat history, cannot stop an adversary with valid credentials from accessing the platform, and does not touch the messaging infrastructure itself — the technique still runs against existing content, so the reduction is a rate, not a closure.
- T1218.001partialprevents — T1218.001 requires user execution of a CHM file, so awareness/training can reduce the rate at which personnel open suspicious compiled help files, but cannot move that rate to zero — the same human-mechanism shape the owner ruled partial for A.6.3 vs T1566.001.
- T1221partialprevents — Training about document handling and recognizing suspicious files can reduce the rate at which users open documents containing template injections, since the technique requires the user to open the document for the malicious template to fetch and execute; however, the technique's core mechanism is automatic once the document is opened, and a trained workforce still opens such documents, so the reduction is a rate rather than a closure.
- T1528partialprevents — Training can reduce the rate at which personnel fall for OAuth consent phishing (the social-engineering vector where a user grants a malicious app token access), but the technique's dominant vectors — stealing service-account tokens from compromised containers, CI/CD pipelines, or Managed Identity endpoints via IMDS — are technical compromises with no user in the loop, so awareness cannot reach them.
- T1530partialprevents — A.6.3's training of technical teams on configuring and maintaining security (including cloud storage) can prevent misconfiguration-based access vectors, and general password/credential hygiene training reduces some credential leakage, but the technique also executes via stolen credentials, API exploitation, and insider access that training cannot reach.
- T1534partialprevents — Training reduces the rate at which personnel click, open, or reply to internal spearphishing by teaching recognition of phishing indicators regardless of sender trust, but cannot move that rate to zero — a trained workforce still falls for messages from compromised internal accounts, and the trusted-internal context can even blunt the training's effect.
- T1539partialprevents — Training reduces the rate at which personnel fall for the user-execution and phishing/AitM vectors (e.g. running malicious JavaScript, authenticating through adversary proxies like Evilginx2), but cannot prevent the malware-on-host and network-traffic vectors where no human decision is in the loop, and even on the human-touching vectors the reduction is a rate rather than a closure.
- T1546.016partialprevents — Training can reduce the rate at which users install untrusted applications and grant elevated permissions, but cannot eliminate it; the technique exploits legitimate-looking installers where the malicious content is hidden in scripts the user cannot inspect, so the reduction is a rate, not a closure.
- T1548.004partialprevents — Training can reduce the rate at which users enter credentials when prompted by unexpected or suspicious applications, but cannot prevent the technique entirely — users must still enter credentials for legitimate operations, and the technique also works by modifying legitimate programs that already use the API, where the user has no visible cue that anything is wrong.
- T1550.001partialprevents — Training can reduce the rate at which users grant OAuth tokens to malicious applications or fall for token-stealing consent flows, but the technique has many vectors where the user is not in the loop (token theft from compromised systems, API credential theft, service-to-service token abuse), and even on the user-facing vectors training lowers rather than eliminates the risk.
- T1552partialprevents — Training in secure credential handling (e.g., not hardcoding secrets, using credential managers, proper key storage) reduces the rate at which credentials are left in plaintext files, shell history, registry, or other insecure locations, but cannot eliminate the practice: legacy code, third-party applications, system-level credential stores, and historical configurations all leave credentials reachable, and the technique is post-compromise so the adversary searches the system directly rather than relying on user action.
- T1552.001partialprevents — Training can teach users, developers and administrators not to store credentials insecurely in files, configuration files or source code, reducing what the technique finds; however, it cannot eliminate credentials stored in system files, legacy configurations, third-party applications or by personnel who do not retain the training, so the technique still runs and still finds credentials that exist.
- T1552.003partialprevents — Training can teach users not to type credentials on the command line (or to use credential managers, environment variables, or `history -c` after sensitive entries), measurably reducing the rate at which credentials land in shell history files — but it cannot eliminate the behavior, since users still type credentials for convenience, in scripts, or under time pressure, leaving a non-trivial remainder of history files that contain usable secrets.
- T1552.008partialprevents — Training reduces the rate at which personnel share credentials in chat/collaboration tools, addressing the user-behavior vector of the technique, but cannot eliminate it and does not address the non-user vectors (adversary access to chat servers, admin portals, or compromised integration tools that extract credentials automatically).
- T1553.005partialprevents — Training can reduce the rate at which personnel mount or execute contents of suspicious container files, but the technique is a technical bypass that strips the very MOTW/SmartScreen warnings training typically relies on, and users have legitimate reasons to mount ISOs/VHDs, so the rate reduction is partial rather than approaching closure.
- T1557.004partialprevents — Training can teach users to verify SSIDs, disable auto-connect, use VPNs, and recognize suspicious captive portals, measurably lowering the rate at which they connect to evil twin networks; however, devices auto-connect to Preferred Network Lists without user action, and trained users still occasionally connect, so the reduction is a rate rather than a closure.
- T1559.002partialprevents — Training can reduce the rate at which personnel enable DDE in malicious Office documents or CSV files delivered via phishing, but cannot move that rate to zero, and the DCOM-based remote invocation vector operates entirely outside any human-in-the-loop step where awareness could intervene.
- T1566.001partialdetects — awareness training on recognizing phishing, reporting events, and baseline controls surfaces the technique when users notice and report it, but the control does not instrument or guarantee detection of delivery or execution
- T1566.001partialprevents — awareness/education/training on responsibilities, policies, basic procedures (e.g. event reporting, password security), and recognizing social engineering lowers the odds users open malicious attachments or fall for the lures, but does not stop the technique from being attempted or executed by those who ignore it
- T1566.002partialprevents — Spearphishing links require the user to actively click or paste a URL, so the human is the mechanism; training measurably lowers the click rate but cannot move it to zero, which is the same shape the owner ruled for A.6.3 vs T1566.001.
- T1566.003partialprevents — Training measurably lowers the rate at which personnel engage with unsolicited social-media or personal-webmail contact that pivots to malicious content on a work device, but cannot move that rate to zero — the human remains the delivery surface and the channel is non-enterprise, so the reduction is a slice rather than a closure.
- T1566.004partialprevents — Training measurably lowers the rate at which personnel comply with a vishing caller's instructions (e.g., divulging credentials, installing remote tools, accepting MFA prompts), but cannot move that rate to zero; the human is the mechanism and the reduction is a rate, not a closure, matching the A.6.3 vs T1566.001 anchor.
- T1586partialprevents — Training on password security, phishing recognition, and credential hygiene can reduce the rate at which employee or partner accounts are compromised via phishing-for-information or credential reuse/brute forcing, but cannot address purchased credentials, paid insiders, or compromise of accounts belonging to people outside the organization's training reach, leaving the technique's other vectors intact.
- T1586.003partialprevents — Training addresses the phishing-for-credentials vector by reducing the rate at which personnel surrender cloud account credentials, but cannot prevent credential purchases from third parties, password spraying against cloud services, or technical theft of application access tokens — multiple compromise paths sit outside the human-mechanism surface, so prevention is a slice rather than a closure.
- T1589partialprevents — Training reduces the rate at which personnel fall for elicitation, overshare on social media, or respond to phishing-for-information attempts, but cannot prevent the many non-human vectors of T1589 (active scanning of authentication services, scraping public sources, third-party breaches, search of victim-owned websites) where no human is in the loop.
- T1590.003partialprevents — Training addresses one slice of the technique — the elicitation vector where personnel might disclose network trust information — but the bulk of T1590.003 operates on public/open sources (open technical databases, websites, DNS/certificates) where no human is in the loop, so the rate reduction is a slice rather than a closure.
- T1591partialprevents — Training personnel on information handling responsibilities and social-media discipline can reduce elicitation success and oversharing of org structure, roles and operations, but T1591 largely runs against public/external sources (websites, social media, SEC filings, OSINT) that training does not reach, so the technique still executes against the organization.
- T1591.002partialprevents — Training can reduce the rate at which personnel disclose business-relationship details through social media, victim-owned websites, or elicitation, but cannot prevent adversaries from gathering this information from public sources, registries, or other open datasets where no human action is involved.
- T1591.003partialprevents — Training can reduce the rate at which personnel volunteer business tempo details through elicitation or careless social media/website posts, but cannot prevent the adversary from inferring tempo from publicly observable patterns (shipping notifications, posted hours, third-party sources) — the same shape as the A.6.3 vs T1566.001 anchor.
- T1591.004partialprevents — Training reduces the rate at which personnel overshare role information on social media or respond to elicitation, but cannot prevent the technique entirely because public sources, third-party data, and untrained or forgetful personnel remain available vectors.
- T1592partialprevents — Training reduces personnel oversharing on social media, responding to phishing-for-information, and exposing host details on victim-owned sites, but cannot prevent the bulk of T1592 — active scanning, User-Agent harvesting, and queries to public technical databases — which have no human in the loop.
- T1592.002partialprevents — Training addresses the human-mediated vectors of T1592.002 — phishing-for-information, oversharing in job postings/resumes/purchase invoices, and metadata leakage in published documents — by lowering the rate at which personnel disclose or expose host-software details, but it does not reach the active scanning vector (T1595) or adversary-compromised sites harvesting visitor host data, which are external to the trained behaviour.
- T1592.003partialprevents — Training can reduce the rate at which personnel reveal firmware details when elicited (phishing for information) or post them in job postings/resumes, but the technique also succeeds through passive observation of public sources (network maps, assessment reports, purchase invoices) that training cannot reach, so the technique is not stopped.
- T1598.001partialprevents — Training measurably lowers the rate at which personnel respond to social-engineering lures delivered via third-party services, but cannot eliminate it; the third-party delivery channel sits outside enterprise controls where banners or filtering would reinforce the training, leaving a larger remainder than for enterprise-channel spearphishing.
- T1598.002partialprevents — Training reduces the rate at which personnel comply with the spearphishing request (filling in forms, returning files, entering credentials into fake portals), but cannot move that rate to zero — the same shape as the A.6.3 vs T1566.001 anchor, since the delivery mechanism and user-interaction requirement are analogous.
- T1598.003partialprevents — Training reduces the rate at which personnel click malicious links in spearphishing messages but cannot move it to zero, matching the shape of the A.6.3 vs T1566.001 anchor on the same control.
- T1598.004partialprevents — Training measurably lowers the rate at which personnel divulge sensitive information to voice-based social engineering, since the human is the control surface for this technique; however, vishing is designed to exploit urgency and trust, and a trained workforce still occasionally complies, so the reduction is a rate rather than a closure.
- T1621partialprevents — Training teaches users to recognize and refuse unexpected or repeated MFA prompts and to report them, measurably lowering the approval rate, but cannot move it to zero — users under sustained fatigue still occasionally accept, and the technique's delivery infrastructure is untouched.
- T1657partialprevents — Training reduces the rate at which personnel fall for the social-engineering components of financial theft (BEC, pig butchering, phishing for credentials leading to fraudulent transfers) but cannot move it to zero, and has no effect on the technical-theft components (bank hacking, cryptocurrency exploitation) where no human is in the loop.
- T1667partialdetects — A.6.3 trains users to recognize anomalous security events and report them through proper channels; a user experiencing email bombing would notice the inbox flood and a trained user is more likely to interpret it as a security incident and report it (especially given the technique's use as a precursor to vishing follow-on attacks). However, the user-visible artifact is so obvious that the training's marginal contribution to *noticing* the flood is small, and detection still depends entirely on the user choosing to report — the clause provides no technical sensing mechanism.
- T1671partialprevents — Training can reduce the rate at which users grant OAuth consent to suspicious applications, which is one vector of T1671, but the technique's primary paths — adversary-controlled accounts registering apps, admin-level consent grants, and service principal manipulation — do not require a user decision that training can influence, so the technique is reduced, not prevented.
- T1677partialprevents — Training on secure CI/CD practices, PR review discipline, and recognition of suspicious pipeline patterns can reduce the rate at which developers write insecure CI configurations or approve malicious fork PRs, but the technique is largely technical — pipeline triggers, secrets scoping, branch protection, and self-hosted runner hardening are not addressed by awareness, and the Public Pipeline Execution scenario can fire without any human in the loop.
- T1684partialprevents — T1684's mechanism requires a human to be persuaded into action, and A.6.3's awareness/training measurably lowers the rate at which personnel comply with social engineering requests; the reduction is a rate, not a closure, and sophisticated multi-channel attacks still succeed against trained users, matching the shape of the A.6.3 vs T1566.001 and at-2 vs T1566 anchors.
- T1684.001partialprevents — Impersonation requires a human to be deceived into acting on a false identity, so training that teaches verification of requests, recognition of urgency cues, and out-of-band confirmation measurably lowers the rate at which personnel comply — the same shape as the A.6.3 vs T1566.001 anchor, where the human is the control surface and the reduction is a rate, not a closure.
- T1684.002partialprevents — Training helps users recognize spoofed sender identities and helps technical staff implement proper DMARC/SPF/DKIM, reducing the success rate of email spoofing, but cannot prevent the spoofed email from being sent and delivered — the technique still executes, mirroring the A.6.3 vs T1566.001 anchor's shape on a human-mechanism control.
- T1697partialprevents — Training reduces the rate at which personnel are socially engineered into revealing ASPs via phishing, but cannot eliminate it, and the other vectors (generating an ASP on an already-compromised account, stealing stored ASPs from a system) are largely outside the human-awareness mechanism's reach.
Prevented OWASP Web Top 10 (2025) risks (2)
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).
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.