A.8.24 Technological
Use of cryptography
Structured attributes from ISO/IEC 27002:2022 — control type · CIA properties · cybersecurity concept · operational capability · security domain. What do these mean?
Mapped NIST 800-53 r5 controls (18)
Our reading (mostly llm_verified) of how this ISO control and each NIST 800-53 control relate. Not an ISO or NIST product.
Direction: ← other covers this;
→ this covers other (F/M/P = full / mostly /
partial). gov = governs / implements (a mandate, not coverage).
Why these map — rationale
- SC-12fullcovers — A.8.24's mandate to ensure proper and effective use of cryptography according to all relevant requirements directly accounts for the entirety of SC-12's requirement to establish and manage keys when cryptography is used.
- SC-13fullcovers — SC-13's entire requirement (selecting and implementing the exact cryptography required per use case) is completely accounted for inside the broader mandate of A.8.24 to ensure proper and effective use of cryptography per business, security, legal and regulatory needs.
- SC-28mostlycovers — A.8.24's mandate to select and apply cryptography for confidentiality/integrity directly accounts for the bulk of SC-28's protection-at-rest requirement when cryptography is the chosen mechanism, but leaves a residual where non-cryptographic protections (e.g., OS-level access controls or physical media controls) could satisfy SC-28 without invoking cryptography.
- SC-8mostlycovers — A.8.24's mandate to select and apply cryptography per requirements (including confidentiality/integrity) accounts for the bulk of SC-8's protection objective, but leaves a residual on the specific transmission-focused mechanisms, parameters, and boundary enforcement that SC-8 requires beyond general crypto policy.
Aligned NIST CSF 2.0 outcomes (18)
NIST CSF 2.0 outcomes this ISO control aligns with — our analysis (mostly llm_verified).
Direction: ← other covers this;
→ this covers other (F/M/P = full / mostly /
partial). gov = governs / implements (a mandate, not coverage).
Why these map — rationale
- PR.DS-01domain mandateimplements — A.8.24 operationalizes data-at-rest protection (via mandated cryptography) within PR.DS-01's domain, but the outcome does not name cryptography specifically — access control and physical protection also serve it
- PR.DS-02domain mandateimplements — A.8.24 operationalizes protection of data-in-transit confidentiality and integrity (core parts of the PR.DS-02 outcome) via its mandated cryptographic controls, which sit inside that protection domain even though the CSF outcome does not name cryptography explicitly
Related OWASP ASVS 5.0 requirements (12)
Application-security verification requirements (OWASP ASVS 5.0) this ISO control aligns with; links open the ASVS chapter. Our analysis (mostly llm_verified) — many ISO controls have no ASVS counterpart.
Direction: ← other covers this;
→ this covers other (F/M/P = full / mostly /
partial). gov = governs / implements (a mandate, not coverage).
Why these map — rationale
- V11.1.1mostlycovers — The ISO control's requirement for a documented cryptographic policy and lifecycle directly implements the ASVS mandate for a documented key-management policy and lifecycle.
- V11.1.2mostlycovers — Mandating an inventory of algorithms, keys and certificates satisfies the ASVS requirement to maintain and regularly update a cryptographic inventory.
Related weaknesses / CWE (2564)
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-13fullremoves — A.8.24 well implemented mandates cryptography to protect the confidentiality of information held on storage media (guidance item c) and according to business requirements (purpose clause); a plaintext password in an ASP.NET configuration file is sensitive information stored in cleartext, and applying the clause encrypts it, so the weakness stops being present — the same logic the owner applied to CWE-311 and CWE-312, of which CWE-13 is a specific instance.
- CWE-1428fullremoves — A.8.24's guidance item (c) explicitly mandates cryptography for information 'transmitted over networks', and the purpose clause covers confidentiality and integrity of information. Implementing A.8.24 where it was not applied before requires HTTP services to be replaced with HTTPS, removing the CWE-1428 weakness. This is the same textual basis (purpose clause, general guidance, item c) the owner cited for A.8.24 removes CWE-311/312 = full, applied to the in-transit case.
- CWE-256fullremoves — A.8.24 well implemented mandates cryptographic protection of stored information, and passwords are stored information whose confidentiality requires protection; the clause's broad cryptography mandate (purpose clause, guidance on algorithms and usage practices) reaches password hashing as a cryptographic technique, so applying it where passwords were previously stored in plaintext removes the weakness with no remainder, consistent with the owner's `full` rulings on A.8.24 -> CWE-311 and CWE-312.
- CWE-260fullremoves — A.8.24 well implemented mandates encryption of sensitive information at rest, and passwords in configuration files are sensitive information; applying the clause to a system with cleartext passwords in config files encrypts them so they are no longer accessible to actors without the key, removing the weakness entirely, consistent with the owner's prior `full` rulings on A.8.24 `removes` for CWE-311 and CWE-312.
- CWE-261fullremoves — A.8.24 well implemented mandates proper cryptographic protection of sensitive information including passwords; CWE-261 is the absence of that protection (trivial encoding like Base64 instead of proper hashing), so applying the clause replaces the weak encoding with proper cryptography and the weakness stops being present, parallel to the owner's A.8.24 -> CWE-311 and A.8.24 -> CWE-312 `removes` = `full` rulings.
- CWE-311fullremoves — created from the owner's anchor; an owner grade is a row and does not wait for an instrument (Mythos 2026-09-29T15:58Z).
- CWE-312fullremoves — created from the owner's anchor; an owner grade is a row and does not wait for an instrument (Mythos 2026-09-29T15:58Z).
- CWE-313fullblocks — Cryptography control directly mandates encryption of sensitive data at rest.
- CWE-313fullremoves — Implementing A.8.24’s mandated cryptography for stored sensitive information encrypts existing cleartext files or disk data, so the cleartext-storage weakness ceases to be present.
- CWE-314fullblocks — Cryptographic controls directly prevent cleartext storage of sensitive registry data.
- CWE-314fullremoves — A.8.24 mandates encryption of sensitive information at rest, so applying it to a system where cleartext registry data previously existed encrypts that data, removing the weakness entirely.
- CWE-315fullblocks — Mandates use of cryptography to protect sensitive data, directly preventing cleartext cookie storage.
- CWE-315fullremoves — A.8.24 mandates encryption of stored sensitive information, and the owner's prior ruling on the parent category CWE-312 (Cleartext Storage of Sensitive Information) at `full` applies here: cookies are a storage mechanism, so encrypting the cookie value or removing the sensitive data from the cookie eliminates the cleartext weakness entirely, with no remainder.
- CWE-318fullremoves — A well-implemented A.8.24 requires cryptographic protection for sensitive information at rest, so applying it to an executable containing cleartext secrets replaces that cleartext storage and removes the CWE-318 condition.
- CWE-319fullremoves — A.8.24's guidance item (c) explicitly names cryptography for protection of information 'transmitted over networks', so a well-implemented clause mandates encryption of data in transit; the cleartext transmission weakness stops being present, parallel to the owner's A.8.24 removes CWE-311/CWE-312 = full rulings on the same clause text.
- CWE-329fullblocks — Mandates proper cryptographic controls including IV generation, directly preventing predictable-IV CBC weaknesses.
- CWE-353fullremoves — A.8.24's purpose explicitly covers integrity of transmitted information and item (c) names transmitted data; well implemented, it mandates cryptographic integrity protection (e.g., HMAC, AEAD) for data in transit, so a transmission that previously lacked any integrity check acquires one and the weakness stops being present, consistent with the owner's `full` grades for A.8.24 `removes` on CWE-311 and CWE-312.
- CWE-419fullremoves — A.8.24 mandates cryptographic protection of information transmitted over networks (guidance item c), and CWE-419 is the absence of proper protection on a primary channel; implementing the clause against an existing unprotected channel adds the mandated cryptographic protection, so the weakness stops being present — the same logic the owner applied to A.8.24 vs CWE-311 and CWE-312.
- CWE-5fullremoves — A.8.24 mandates cryptography for information transmitted over networks (guidance item c), so well implemented it requires HTTPS/SSL for data in transit, which removes the J2EE misconfiguration that permits plaintext transmission — the same logic the owner applied to A.8.24 removes CWE-311 and CWE-312 at full.
- CWE-523fullremoves — A.8.24 well implemented mandates cryptography for transmitted information (guidance item c), so applying it to a system where credentials previously traveled in cleartext requires TLS/HTTPS on the login path and the unprotected-transport weakness stops being present — the same reading that graded A.8.24 removes CWE-311 and CWE-312 at full.
- CWE-526fullremoves — A.8.24 mandates cryptography to protect sensitive information according to its classification, and CWE-526 is the specific case of cleartext (unencrypted) sensitive data stored in an environment variable; implementing the clause encrypts that data and the 'unencrypted sensitive information in an environment variable' weakness no longer exists, consistent with the owner's full grade for A.8.24 vs CWE-311 and CWE-312.
- CWE-555fullremoves — A.8.24 well implemented mandates cryptographic protection of sensitive information at rest (guidance items b, c, f), and a password in a J2EE configuration file is sensitive information held on storage media; applying the clause requires the password to be encrypted or stored in a cryptographic keystore, so the plaintext-password weakness stops being present, consistent with the owner's full ruling on A.8.24 -> CWE-312 (cleartext storage of sensitive information).
- CWE-924fullremoves — A.8.24 mandates cryptographic protection of integrity for transmitted information (PURPOSE clause names integrity; item (c) names transmitted information; item (f) names approved cryptographic solutions and usage practices). CWE-924 is the absence of message-integrity protection in a communication channel. Applying the clause where it was not applied before requires the developer to implement cryptographic integrity protection (MAC, digital signature, authenticated channel), and the weakness stops being present — the same logic the owner used for A.8.24 removes CWE-311/CWE-312 = full.
- CWE-1204mostlyblocks — Mandates correct use of cryptography, directly requiring strong, unpredictable IV generation for primitives that need it.
- CWE-1204mostlyprevents — A.8.24(f) requires approved cryptographic solutions and usage practices, which well implemented would specify IV generation requirements (CSPRNG, uniqueness) and mandate libraries that handle IVs correctly, so in code the organization designs and builds weak IVs are not generated; the remainder is third-party/COTS components and cases where developers misuse approved APIs by supplying their own IVs.
- CWE-1240mostlyblocks — Mandates approved cryptographic controls, directly preventing use of risky or non-compliant implementations.
- CWE-1240mostlyremoves — A.8.24 mandates approved cryptographic algorithms, cipher strength, solutions and usage practices (guidance item f), so applying it where it was not applied before requires existing non-approved or non-compliant implementations to be brought into compliance — the algorithm-choice core of CWE-1240 (MD5, DES, Dual_EC_DRBG, weak cipher suites) is removed. The bounded remainder is implementation-correctness defects in otherwise-approved algorithms (e.g., the ChaCha20 nonce-reduction bug, entropy flaws in a DRBG), which A.8.24's standards mandate does not directly reach — that is a nameable slice the clause does not cover.
- CWE-1240mostlyprevents — A.8.24's policy names approved cryptographic algorithms, standards, and usage practices (guidance items b and f), so in code the organization designs or builds a risky or non-standard primitive is not chosen; the remainder is third-party, COTS, legacy, and hardware implementations that arrive with their primitive choices already made, consistent with the A.8.24 vs CWE-328 anchor.
- CWE-1241mostlyremoves — A.8.24 mandates the use of cryptography, including algorithm selection and key management, but it does not retroactively replace a predictable PRNG algorithm already implemented in a device or system; the weakness remains present until the code or hardware is changed.
- CWE-1241mostlyprevents — A.8.24's guidance item (f) requires approved cryptographic algorithms, solutions and usage practices, which a well-implemented policy extends to RNG selection for cryptographic purposes (mandating CSPRNGs and prohibiting predictable PRNGs like mt_rand or LFSR for crypto use), so in first-party code the weakness is not introduced; the bounded remainder is third-party/COTS components and implementation-phase substitutions driven by unforeseen constraints, parallel to the CWE-328 anchor.
- CWE-1291mostlyprevents — A.8.24's key management guidance explicitly requires generating keys for different cryptographic systems and different applications, so a well-implemented policy mandates separate keys for debug and production signing; the remainder is third-party firmware, legacy components, and cases where business decisions (e.g., silicon real estate constraints) override the policy.
- CWE-13mostlyprevents — A well-implemented cryptography policy under A.8.24 specifies that credentials must be encrypted at rest using approved methods, so a developer following the policy would not write plaintext passwords into ASP.NET configuration files in first-party code; the remainder is bounded and nameable — third-party components, legacy code, and developers who fail to apply the policy's encryption requirement to configuration-file storage.
- CWE-1394mostlyremoves — A.8.24's key management section explicitly mandates generating keys for cryptographic systems and changing/updating keys, so applying it where it was not applied before requires replacing default keys with properly generated ones — the default-key weakness stops being present. The bounded remainder is third-party products and embedded systems where key replacement is not technically possible, which is nameable but does not vanish.
- CWE-1394mostlyprevents — A.8.24's key management section requires secure key generation procedures and approved cryptographic practices, so systems the organization designs or builds would not use default cryptographic keys; the bounded remainder is third-party products that ship with default keys, which A.8.24 does not reach (changing vendor defaults after installation is A.8.9's territory, as the CWE-1394 anchor on that clause shows).
- CWE-1428mostlyprevents — A.8.24 well implemented mandates HTTPS for network-transmitted information (guidance item c) and approved cryptographic solutions/usage practices (item f), so systems the organization designs and builds do not rely on HTTP; the bounded remainder is third-party, COTS and legacy components that arrive with HTTP already chosen, plus content-generation cases (e.g. links emitted without the https:// prefix) that are coding-practice rather than cryptography-policy concerns.
- CWE-256mostlyblocks — A.8.24's purpose, guidance (b,c), and key management rules mandate applying cryptography to protect stored sensitive information (including passwords) per classification, which stops plaintext-storage exploitation; the bounded remainder is non-cryptographic password stores (e.g. memory-only or non-classified) where the clause's rules on 'when using' do not force encryption.
- CWE-256mostlyprevents — A.8.24 well implemented mandates cryptographic protection of stored sensitive information including credentials, so first-party code under the clause does not store passwords in plaintext; the bounded remainder is third-party components and legacy code that arrive with plaintext credentials already present, which the clause cannot redesign.
- CWE-261mostlyblocks — Requires appropriate use of cryptography, indirectly discouraging weak encoding schemes.
- CWE-261mostlyprevents — A well-implemented A.8.24 policy names approved cryptographic algorithms and usage practices for protecting secrets, so in code the organization designs or builds a trivial encoding (base64) is never chosen where a proper password hash is required; the remainder is bounded and nameable — third-party, COTS and legacy components that arrive with their password-handling choices already made, mirroring the A.8.24 -> CWE-328 anchor.
- CWE-294mostlyblocks — Cryptographic protections (e.g., nonces, timestamps, message authentication codes) make captured authentication messages unusable for replay.
- CWE-294mostlyprevents — A.8.24 well implemented mandates cryptographic authentication mechanisms with anti-replay protections (nonces, timestamps, challenge-response), so in systems the organization designs capture-replay is prevented at the design stage; the bounded remainder is third-party, COTS and legacy components whose authentication design is already fixed.
- CWE-300mostlyblocks — Cryptography provides channel integrity and can support endpoint authentication.
- CWE-313mostlyprevents — A.8.24 well implemented mandates encryption of sensitive information held on storage media, so in anything the organization designs or builds, sensitive data is not stored in cleartext in files or on disk; the remainder is bounded and nameable — third-party components, COTS, and legacy systems that arrive with their storage choices already made, mirroring the A.8.24 -> CWE-328 anchor's reasoning.
- CWE-314mostlyprevents — A.8.24 well implemented mandates encryption of sensitive information at rest per its classification, so new first-party development and contracted third-party development would encrypt sensitive data before storing it in the registry, preventing the weakness from arising; the remainder is third-party components used as-is that already store sensitive data in cleartext in the registry, which the policy cannot redesign.
- CWE-315mostlyprevents — A well-implemented cryptography policy under A.8.24 mandates encryption of sensitive information wherever it is held or transmitted, which reaches cookies as a storage mechanism; developers building under the policy do not write code that stores sensitive values in cleartext in cookies. The remainder is bounded and nameable: third-party components, COTS libraries, and legacy code that arrive with the cleartext-cookie pattern already baked in, which the policy can refuse at procurement but cannot redesign.
- CWE-318mostlyblocks — Cryptographic controls directly prevent cleartext storage of sensitive data in executables.
- CWE-319mostlyprevents — A.8.24 well implemented mandates cryptography for transmitted sensitive information (guidance item c explicitly covers information transmitted over networks), so a system designed under it does not transmit sensitive data in cleartext; the remainder is bounded and nameable -- hardware-specific channels (JTAG, internal buses) explicitly noted in CWE-319, and third-party/legacy products that ship with cleartext transmission by design.
- CWE-321mostlyprevents — A.8.24's key management section explicitly mandates proper key generation, storage, distribution, and lifecycle processes — the antithesis of hard-coding keys into products — so a well-implemented cryptography policy prevents hard-coded keys in anything the organization designs or builds; the bounded remainder is third-party, COTS, and legacy components that arrive with keys already embedded, mirroring the CWE-328 anchor.
- CWE-322mostlyblocks — Use of cryptography mandates authenticated key-exchange mechanisms, directly addressing the lack of entity authentication.
- CWE-322mostlyremoves — A.8.24 mandates approved cryptographic solutions and usage practices (guidance item f), so a well-implemented policy requires authenticated key exchange (e.g., TLS with certificate verification) as the standard, and applying it where it was not applied before replaces unauthenticated key exchange with authenticated protocols, removing the flaw; the remainder is systems where the organization adopted A.8.24 but the approved standards did not specifically require entity authentication during key exchange, or where legacy implementations cannot be retrofitted without redesign.
- CWE-323mostlyblocks — Mandates proper cryptographic key and nonce management, directly preventing nonce/key-pair reuse.
- CWE-324mostlyprevents — A.8.24's key management section directly mandates activation/deactivation dates for keys (item l) and rules on when to change keys (item e), so a system designed under a well-implemented clause does not use expired keys; the remainder is bounded and nameable — implementation defects in code that fails to check expiration (as in the CWE-324 demonstrative example) and third-party components with their own key lifecycles.
- CWE-328mostlyprevents — A.8.24's policy, algorithm selection (b,f), and key management directly require strong hashes meeting security expectations, preventing weak-hash use in most approved cryptographic contexts, but leaves a bounded remainder for non-crypto uses of hashing (e.g. data structures, non-security checksums) where the clause has no mandate.
- CWE-329mostlyprevents — A.8.24's guidance item (f) requires approved cryptographic algorithms, cipher strength, solutions and USAGE PRACTICES, so a well-implemented policy specifies how IVs are to be generated (CSPRNG, no reuse, no fixed values) and developers following it do not introduce predictable-IV CBC code; the bounded remainder is third-party, COTS and legacy components whose IV handling is already baked in, mirroring the A.8.24 -> CWE-328 anchor.
- CWE-330mostlyblocks — Cryptographic controls require use of approved, sufficiently random values for keys and nonces.
- CWE-331mostlyblocks — Mandates use of cryptography that must rely on sufficient entropy sources.
- CWE-331mostlyremoves — A.8.24 mandates approved cryptographic algorithms, cipher strength, and key generation methods (items b, d, f, and the Key Management section), so applying it to a system that previously lacked such a policy requires replacing weak PRNGs and predictable seeds with approved cryptographic randomness sources, removing most instances of CWE-331; the bounded remainder is code where an approved PRNG is still seeded predictably or where randomness is used outside the cryptographic scope the policy reaches.
- CWE-331mostlyprevents — A.8.24 well implemented names approved cryptographic algorithms, practices and key-management methods, which naturally extends to approved RNGs and entropy sources; in code the organization designs or builds, an insufficient-entropy choice is not made, paralleling the A.8.24 -> CWE-328 anchor. The bounded remainder is third-party, COTS and legacy components whose RNG choices are already baked in, which the policy reaches only at procurement.
- CWE-332mostlyprevents — A well-implemented cryptography policy under A.8.24 names approved cryptographic solutions and usage practices, which would specify CSPRNGs and approved entropy sources for cryptographic purposes, preventing most instances of CWE-332 in first-party code; the bounded remainder is third-party and COTS components whose RNG choices are already made, and cases where non-cryptographic RNGs are used for purposes later fed into cryptographic operations.
- CWE-334mostlyblocks — Cryptographic controls require adequate key/seed entropy, directly mitigating small random-value spaces.
- CWE-335mostlyprevents — A well-implemented A.8.24 cryptography policy sets approved algorithms, key generation and usage practices, so in-house code should use cryptographically secure seeds rather than predictable ones, leaving mainly third-party, COTS or legacy components with already-made seeding choices as the nameable remainder.
- CWE-336mostlyprevents — A well-implemented cryptography policy under A.8.24 names approved PRNGs and usage practices including proper seeding, so in code the organization designs and builds the same-seed defect is not introduced; the bounded remainder is third-party, COTS and legacy components whose seeding choices are already baked in, mirroring the A.8.24 -> CWE-328 anchor.
- CWE-337mostlyprevents — A well-implemented cryptography policy under A.8.24 names approved PRNGs and seeding practices as part of its cryptographic usage standards (guidance item f), so in first-party code a developer never seeds a PRNG with a predictable value like process ID or system time when cryptographic randomness is required; the remainder is bounded and nameable -- third-party, COTS, and legacy components that arrive with their seeding choices already made, mirroring the CWE-328 anchor.
- CWE-338mostlyblocks — Mandates use of approved cryptographic controls, directly requiring cryptographically strong RNGs.
- CWE-338mostlyprevents — A.8.24's guidance item (f) requires approved cryptographic algorithms, solutions and usage practices, so a well-implemented cryptography policy names the approved PRNGs for security contexts and developers following it do not choose rand()/mt_rand() for tokens, keys or session IDs; the remainder is bounded and nameable -- third-party, COTS and legacy components that arrive with their PRNG choices already made, mirroring the A.8.24 -> CWE-328 anchor.
- CWE-340mostlyblocks — Cryptographic controls require use of approved, sufficiently random algorithms and key-generation methods, directly mitigating predictable number/identifier weaknesses.
- CWE-341mostlyblocks — Cryptographic controls replace predictable values with high-entropy, non-guessable material.
- CWE-353mostlyblocks — Cryptographic controls can provide integrity verification for transmitted data.
- CWE-354mostlyblocks — Cryptographic controls mandate integrity mechanisms whose correct validation directly prevents CWE-354.
- CWE-419mostlyprevents — A.8.24 mandates cryptography (including authenticity and integrity, per its purpose clause) for transmitted information, so a primary channel for administration designed under a well-implemented cryptography policy is required to be protected; the remainder is third-party, COTS and legacy components whose channel design the policy does not reach.
- CWE-5mostlyprevents — A.8.24 well implemented mandates encryption for information transmitted over networks (item c) and approved cryptographic standards (item f), so a J2EE application developed under this policy is configured to require HTTPS at all entry points; the remainder is third-party J2EE components and legacy applications that arrive with their transport configuration already set, which the policy can refuse at procurement but cannot redesign.
- CWE-523mostlyblocks — Requires use of cryptography, directly enabling encryption of credentials in transit.
- CWE-523mostlyprevents — A.8.24's guidance item (c) explicitly covers cryptography for information 'transmitted over networks,' and item (f) mandates approved cryptographic solutions and usage practices; a well-implemented cryptography policy requires TLS/HTTPS for credential transmission, so login pages under the policy do not transmit credentials in cleartext and the weakness does not arise. The remainder is bounded and nameable: systems and components that fall outside the policy's scope or fail to comply with it (legacy applications, third-party login flows, shadow IT).
- CWE-526mostlyprevents — A.8.24 well implemented mandates encryption of sensitive information wherever stored, so a system designed under the policy would not introduce cleartext sensitive data into environment variables in the first place; the remainder is bounded and nameable -- environment variables as a specific storage location are not explicitly named in the clause's guidance (which calls out devices, storage media and network transmission), and third-party components that arrive with their own environment-variable usage are outside the policy's reach at design time.
- CWE-649mostlyprevents — A.8.24's purpose explicitly covers authenticity and integrity alongside confidentiality, and a well-implemented cryptography policy mandates approved usage practices (item f) that require integrity protection when encryption is applied to security-relevant inputs (e.g., AEAD modes, signed tokens), so code the organization designs does not acquire the encryption-without-integrity pattern; the remainder is third-party, COTS and legacy components whose design choices are already made, bounded by the component inventory.
- CWE-656mostlyblocks — Mandates use of cryptography whose strength is independent of secrecy of design or keys.
- CWE-757mostlyremoves — A well-implemented cryptography policy requires approved strong algorithms and disables legacy cipher/protocol options, so existing configurable algorithm-downgrade flaws are removed, though implementation-level negotiation defects in third-party or unconfigurable products remain.
- CWE-757mostlyprevents — A.8.24(f) requires approved cryptographic algorithms, cipher strength and usage practices, which a well-implemented policy extends to negotiation logic (mandating strongest-available selection or prohibiting support for weak algorithms), so first-party protocols and procured components do not acquire the downgrade weakness; the remainder is third-party/COTS/legacy components whose negotiation logic is already fixed.
- CWE-759mostlyblocks — Use of cryptography requires appropriate cryptographic controls including salting for password hashing.
- CWE-759mostlyremoves — A.8.24's guidance item (f) mandates approved cryptographic usage practices, which a well-implemented policy extends to salting requirements for password hashing; applying the clause to a system using unsalted hashes requires the code to be updated to add salts, removing the weakness in first-party code. The remainder is bounded and nameable: third-party authentication components that arrive with their hashing implementation already fixed, and legacy password stores where old unsalted hashes persist until users re-authenticate.
- CWE-759mostlyprevents — A.8.24's guidance item (f) requires approved cryptographic algorithms, cipher strength, solutions and USAGE PRACTICES, so a well-implemented cryptography policy specifies salting as a required practice for password hashing, preventing unsalted hashes in first-party code; the remainder is third-party, COTS and legacy components that arrive with their hashing choices already made, bounded by the component inventory.
- CWE-760mostlyblocks — Use of cryptography requires appropriate cryptographic controls including proper salting, largely mitigating predictable-salt weaknesses.
- CWE-760mostlyprevents — A.8.24's guidance item (f) names approved cryptographic solutions and usage practices, which well implemented specifies that salts must be cryptographically random and unpredictable, so in code the organization designs or builds a predictable salt is never chosen; the bounded remainder is third-party/COTS/legacy components whose salt generation is already fixed, parallel to the A.8.24 -> CWE-328 anchor.
- CWE-780mostlyblocks — Mandates proper use of cryptography, directly requiring OAEP with RSA.
- CWE-780mostlyprevents — A.8.24's guidance item (f) requires approved cryptographic algorithms, cipher strength, cryptographic solutions and USAGE PRACTICES, so a well-implemented cryptography policy names OAEP as the required padding for RSA, preventing the weakness in code the organization designs or builds; the remainder is third-party, COTS and legacy components that arrive with their padding choices already made, bounded by the component inventory.
- CWE-916mostlyremoves — A.8.24 mandates approved cryptographic algorithms, strengths and usage practices, so a well-implemented policy specifies strong password hashing (slow KDFs, salting), and applying it to existing first-party authentication code replaces weak hashes; the bounded remainder is third-party/COTS authentication components and legacy systems where the organization does not control the hashing implementation, mirroring the CWE-328 anchor's named remainder.
- CWE-916mostlyprevents — A.8.24 guidance item (f) requires approved cryptographic algorithms, cipher strength, cryptographic solutions and USAGE PRACTICES, so a well-implemented cryptography policy names password hashing algorithms (bcrypt, scrypt, Argon2, PBKDF2) with sufficient work factors and salting, preventing the weakness in first-party code; the remainder is bounded and nameable -- third-party, COTS and legacy components that arrive with their password hashing already implemented, mirroring the A.8.24 -> CWE-328 anchor.
- CWE-921mostlyblocks — A.8.24 well implemented mandates encryption (and with it authenticity/integrity protection via authenticated encryption) for sensitive data held on storage media, which blocks the read and modify exploitation of CWE-921 even though the underlying storage mechanism still lacks access control; the remainder is bounded by key compromise, implementation flaws, and cases where cryptography is not applied to the specific data store.
- CWE-924mostlyprevents — A.8.24's purpose explicitly covers authenticity and integrity, and guidance items (c) and (f) mandate cryptographic protection (authenticated encryption, MACs, signatures) for transmitted information, so systems the organization designs do not acquire the weakness; the bounded remainder is third-party, COTS and legacy components that arrive without message-integrity protection, which the clause cannot redesign.
- CWE-1204partialremoves — A.8.24 mandates cryptographic standards and usage practices (clause item f) that would specify proper IV generation, so applying it where it was not applied before leads to fixes in some cases; however, the control is a policy/standards mandate and does not itself review or rewrite code, so existing weak-IV implementations are only removed where the standards are specific enough to catch them and where development effort follows — a minority of instances, with a nameable remainder in legacy code and in subtle implementation defects the standards do not reach.
- CWE-1254partialprevents — A.8.24's guidance on approved cryptographic solutions and usage practices can mandate constant-time comparison functions and approved cryptographic libraries, preventing the weakness in code the organization writes; however, this is a code-level implementation detail where secure coding (A.8.28) and security testing (A.8.29) carry more direct effect, and third-party components remain outside the clause's reach.
- CWE-1291partialremoves — A.8.24 mandates the proper use of cryptography, including key management, but CWE-1291 is a design/implementation flaw where the same key is used for both debug and production; the clause does not retroactively replace an already-deployed key or remove the flaw from existing signed images.
- CWE-1301partialblocks — A.8.24 well implemented encrypts sensitive data on hardware, so even if data remanence allows recovery of 'deleted' data, the recovered material is ciphertext useless without the key — exploitation is blocked for that subset. The remainder is bounded and nameable: data not classified as requiring encryption, keys stored on the same media, and the data-removal process itself which the clause does not redesign.
- CWE-1323partialblocks — Cryptography can be applied to encrypt trace data at rest or in transit.
- CWE-1330partialblocks — A.8.24 mandates cryptography use and key management (including destruction), and CWE-1330 explicitly identifies cryptographic erase as a mitigation — so well-implemented encryption plus key destruction blocks exploitation of remanence for covered data. But A.8.24 is a policy/guidance clause that mandates the practice; the actual cryptographic erase is a product design choice, and not all memory at a representative organisation falls under the policy or implements it correctly, leaving a nameable remainder.
- CWE-1392partialremoves — A.8.24's key management section requires generating keys for cryptographic systems and applications through proper procedures, which would cause default cryptographic keys to be replaced when the control is applied to a system that previously lacked it; however, A.8.24 does not address default passwords, which are the other half of CWE-1392, so only a portion of the weakness is removed.
- CWE-1392partialprevents — A.8.24's key management section requires the organization to generate keys for their cryptographic systems rather than rely on defaults, which prevents the cryptographic-key portion of CWE-1392 (e.g., default master encryption keys, static SSL keys, default secret keys) in systems the organization builds; however, the clause does not reach default passwords (SSH, admin) which are the other major component of CWE-1392, and it does not address changing defaults in third-party products the organization installs — that is A.8.9's territory, as the CWE-1394 anchor shows.
- CWE-219partialblocks — A.8.24 mandates encryption of sensitive data at rest, so a well-implemented clause would have the file under the web root encrypted, denying the attacker readable sensitive data when they fetch it — the main exploitation (confidentiality impact) is blocked. But the weakness itself (file placed under the web document root with insufficient access control) is not addressed by a cryptography clause: the file remains accessible, metadata and filenames can still leak, and the storage-location defect is untouched, so a nameable remainder survives.
- CWE-220partialblocks — A.8.24 well implemented mandates encryption of sensitive data per its classification, so data stored under the FTP root that is properly classified as sensitive is encrypted and the confidentiality impact is blocked for that slice; the access-control defect (file present under FTP root with insufficient access control) is untouched, and data not classified as sensitive enough to require encryption remains readable, which is the nameable remainder.
- CWE-257partialprevents — A well-implemented cryptography policy under A.8.24 can specify approved practices for credential storage (e.g., requiring one-way hashing rather than reversible encryption, and disallowing reversible compression as a password verifier), which prevents some instances of CWE-257; however, the clause's primary mechanism is encryption for confidentiality/integrity, not authentication-credential storage, so coverage is limited to what the topic-specific policy chooses to address.
- CWE-295partialblocks — Requiring issuance and validation of public-key certificates under an approved policy reduces the chance that certificates with improper validation will be trusted.
- CWE-295partialprevents — A.8.24's guidance item (f) names 'cryptographic solutions and usage practices' as part of what the cryptography policy should cover, so a well-implemented policy can require proper certificate validation as a usage practice; however, the clause's primary scope is algorithms, key management and encryption of information, and the dominant prevention for CWE-295 sits with secure coding (A.8.28) and security testing (A.8.29), leaving A.8.24's contribution as a minority slice.
- CWE-296partialprevents — A.8.24 mandates approved cryptographic practices and standards (guidance item f), which would include proper certificate chain validation as a required usage practice, so a system under a well-implemented policy is directed to follow the chain correctly; however, the weakness is an implementation defect in code, and the policy sets the standard without enforcing correct implementation, leaving third-party libraries and developer mistakes as a nameable remainder.
- CWE-299partialprevents — A.8.24's guidance on approved 'usage practices' can mandate certificate revocation checking as part of the cryptographic policy, but the weakness is an implementation defect (not calling SSL_get_verify_results, mishandling OCSP responses, not checking return values) that survives the policy mandate — the same practice-not-mechanism reading that graded A.8.28 vs CWE-79 at `partial`, and weaker than A.8.24 vs CWE-328 because revocation checking is a more complex implementation act than choosing an approved hash.
- CWE-301partialprevents — CWE-301 is a flaw in authentication protocol design (the same key used in both directions, no identity binding in the challenge); A.8.24 governs cryptographic algorithms, key management and approved usage practices, not the logic of authentication protocols, so a system under the clause can still be designed with a reflection-vulnerable protocol.
- CWE-316partialblocks — Cryptographic controls can mandate encryption of sensitive data in memory, directly reducing cleartext exposure.
- CWE-321partialblocks — Key-management controls that govern generation, rotation and protection of keys make the use of embedded hard-coded cryptographic keys less likely and easier to detect.
- CWE-321partialremoves — A.8.24's key management section mandates proper generation, distribution, storage, retirement and destruction of keys, which implies hard-coded keys must be replaced with properly managed ones — but the clause has no mechanism for finding hard-coded keys in code or for the code modification itself, so removal is contingent on the key being identified through other means.
- CWE-324partialremoves — A.8.24’s key management rules require changing/updating keys and setting activation/deactivation dates, so applying it to an environment with expired keys rotates or deactivates them and the weakness stops being present.
- CWE-325partialprevents — A.8.24 specifies approved cryptographic algorithms, standards and usage practices, so where developers follow the policy and use approved complete implementations the missing step does not arise; but the weakness is fundamentally an implementation defect (omitting a step for performance or by misunderstanding), and a policy clause does not directly review or test code, leaving a nameable remainder in custom implementations.
- CWE-326partialblocks — Requiring the organization to define and enforce minimum cryptographic strength prevents deployment of insufficient key lengths or weak ciphers that can be brute-forced.
- CWE-332partialblocks — Mandates use of cryptography that must rely on cryptographically strong RNGs, directly addressing insufficient entropy.
- CWE-332partialremoves — A.8.24 mandates approved cryptographic solutions and usage practices, which a well-implemented policy would extend to approved PRNGs with sufficient entropy, so applying it to existing code requires replacing non-approved PRNGs and removes that share of the weakness; however, the clause does not specifically address entropy levels, not all entropy issues are fixed by switching to an approved PRNG (seeding, failure modes, usage context), and the mandate reaches only what the policy explicitly names, leaving a nameable remainder.
- CWE-334partialremoves — A.8.24 mandates approved cryptographic algorithms, cipher strength and key management standards (items b, d, f), which would require adequate random value spaces in cryptographic contexts; however, fixing existing CWE-334 instances requires code changes (e.g., enlarging session ID length, switching to a CSPRNG with adequate output), and many CWE-334 instances are non-cryptographic (filenames, user IDs, SYN cookies) where A.8.24's scope does not reach, so only a minority of instances are removed.
- CWE-334partialprevents — A.8.24's guidance items (b) and (f) require establishing the type, strength and quality of cryptographic algorithms and the standards for cryptographic solutions and usage practices, which a well-implemented policy extends to random-value generation (approved RNGs, minimum entropy/key sizes); in first-party cryptographic code the random space is then sufficient, and the remainder is bounded and nameable -- third-party/COTS components and non-cryptographic random identifiers (simple sequential IDs) that fall outside the cryptography policy's scope.
- CWE-338partialremoves — A.8.24 mandates standards for cryptographic algorithms and practices (items b and f), which would require strong PRNGs in security contexts; well implemented, this leads to replacement of some weak PRNGs during code review or updates, but the clause is a policy/standards mandate and does not itself perform code changes, so existing instances in unmaintained or unreviewed code remain — unlike CWE-311/312 where applying encryption is a direct configuration act, replacing a weak PRNG is a code-change act the clause does not directly perform.
- CWE-339partialblocks — Mandates use of cryptography that must rely on cryptographically strong PRNGs with adequate seed entropy.
- CWE-341partialprevents — A.8.24's guidance item (f) on approved cryptographic solutions and usage practices, together with the key management section's requirements for secure key generation, covers the cryptographic contexts where predictability matters (session IDs, keys, nonces, tokens) — a well-implemented policy names approved CSPRNGs and seeding practices so developers do not introduce predictable values in those uses. The bounded remainder is the non-cryptographic uses of predictable values (filenames, DNS query IDs, other identifiers outside the cryptography policy's scope), which the clause does not reach.
- CWE-342partialblocks — Cryptographic controls require use of approved, unpredictable RNGs, directly mitigating predictable-value weaknesses.
- CWE-343partialblocks — Cryptographic controls require use of approved, unpredictable RNGs, directly mitigating predictable value sequences.
- CWE-347partialprevents — A.8.24 mandates approved cryptographic solutions and usage practices, which can require signature verification in code the organization writes, but the actual prevention of the code defect (calling or correctly using a verification API) depends on implementation rigor and does not reach third-party components or code that misuses approved cryptographic libraries.
- CWE-354partialprevents — A.8.24 mandates approved cryptographic standards and usage practices, which in cryptographic contexts (authenticated encryption, MAC verification, digital signatures) include integrity validation, so the weakness does not arise when developers use approved primitives; however, CWE-354 also covers non-cryptographic checksum validation and custom integrity-check implementations outside the clause's cryptographic scope, leaving a meaningful remainder.
- CWE-358partialblocks — Use of cryptography control depends on correct implementation of standardized cryptographic checks.
- CWE-359partialremoves — A.8.24 well implemented mandates encryption of stored and transmitted information, so applying it to PPI previously held in cleartext removes the exposure for that subset; the remainder is the broader class of CWE-359 instances where exposure occurs through non-cryptographic channels — logs, error messages, EXIF metadata, overly broad permissions, intentional sharing — which cryptography does not reach.
- CWE-359partialblocks — A.8.24's cryptography blocks exploitation of CWE-359 where PII is exposed through direct theft of encrypted storage, backups, or network interception, but does not block exploitation through access-control bypass, API flaws returning plaintext PII, plaintext logging, EXIF leakage, or other vectors where the attacker reaches plaintext data through application-layer paths the clause does not govern.
- CWE-360partialblocks — Cryptography can protect event integrity and authenticity but is not explicitly required by the control for this purpose.
- CWE-419partialblocks — Cryptography can protect confidentiality and integrity of the primary channel.
- CWE-471partialblocks — A.8.24 mandates cryptography for integrity protection (signatures, MACs, authenticated encryption), which blocks MAID where applied to the assumed-immutable data (e.g., signed cookies, MAC'd hidden form fields), but MAID also arises from in-memory mutation, buffer overflows overwriting validated state, and mutable data structures where cryptography is not the relevant control, leaving a nameable remainder.
- CWE-530partialblocks — A.8.24 mandates encryption of sensitive information, which would block an attacker from reading the contents of an exposed backup file if the file is encrypted at rest; however, the clause does not address backup file storage locations directly, not all backup content is necessarily classified as requiring cryptographic protection, and metadata (filenames, sizes, structure) remains visible even when content is encrypted.
- CWE-539partialblocks — A.8.24 well implemented establishes that sensitive information be protected by cryptography, which when applied to cookie contents would block the exploitation (reading the cookie file yields ciphertext); however, the clause does not specifically mandate cookie encryption, and the application to cookies is a design choice, leaving a nameable remainder of instances where sensitive cookie data is not encrypted under the policy.
- CWE-599partialblocks — Mandates proper use of cryptography including certificate validation, directly addressing the missing SSL_get_verify_result() check.
- CWE-649partialblocks — Cryptographic controls must include integrity mechanisms (e.g., MACs, signatures) to detect tampering of protected data.
- CWE-649partialremoves — A.8.24's purpose and guidance (authenticity/integrity, approved cryptographic solutions and usage practices) provide the framework for mandating authenticated encryption or equivalent integrity-protected modes, so applying a well-implemented policy to existing code requires retrofitting encrypted inputs to add integrity checks, which removes the encryption-based instances of CWE-649; however, the clause does not reach obfuscation-based instances (obfuscation is not cryptography), and the specific identification of which inputs are security-relevant and require integrity is a design/implementation activity the policy mandate does not automatically perform, leaving a nameable remainder.
- CWE-693partialremoves — A.8.24 mandates proper cryptographic protections and therefore removes existing CWE-693 instances where the failed or missing protection mechanism is cryptographic, but it does not remove the many non-cryptographic protection-mechanism failures covered by CWE-693, so it addresses only a minority of the class.
- CWE-693partialprevents — A.8.24 prevents the cryptographic subset of CWE-693 (e.g., weak algorithm choice, missing key protection, insufficient cipher strength) by mandating approved algorithms, key management, and usage practices, but CWE-693 is a class-level weakness covering all protection mechanisms — access control, sandboxing, content inspection, ACLs, virtualization — the vast majority of which are non-cryptographic and outside A.8.24's reach.
- CWE-798partialprevents — A.8.24's key management guidance (generation, storage, distribution through proper processes) prevents hard-coded cryptographic keys in first-party code, but the clause addresses cryptography, not authentication credentials, so the password variant of CWE-798 is untouched; third-party and COTS components with embedded credentials are also outside its reach.
- CWE-916partialblocks — Requires appropriate use of cryptography, which encompasses selecting strong hashing algorithms for passwords.
- CWE-923partialblocks — Cryptography can protect channels but does not guarantee correct endpoint identity without additional controls.
Mitigated MITRE ATT&CK techniques (2638)
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
- T1040mostlyprevents — Requiring encryption of data in transit and proper key protection reduces the value an attacker gains from passively capturing network packets.
- T1557mostlyprevents — Mandating approved cryptographic algorithms and key-management procedures for network traffic makes it harder for an adversary to intercept and manipulate traffic in order to steal credentials.
- T1565.002mostlyprevents — A.8.24's cryptography with integrity/authenticity protection (authenticated encryption, MACs, digital signatures) directly prevents in-transit manipulation where applied — modified data is rejected by the receiver — but the clause sets requirements for proper use rather than mandating universal coverage of all transmissions, and endpoint compromise can allow manipulation before encryption or after decryption.
- T1005partialprevents — A.8.24's encryption-at-rest provisions prevent the *readability* of sensitive content found on local systems, but the technique's discovery half — file enumeration, filename inspection, metadata extraction, and locating files of interest by name/location — still runs against encrypted blobs, and process memory may hold plaintext depending on implementation, so the technique is reduced, not stopped.
- T1020.001partialprevents — Encryption in transit protects the content of duplicated traffic from being useful to the adversary, but does not stop the duplication itself — the technique still runs and the adversary still receives a copy of the traffic, with only headers, volumes and metadata remaining readable, similar to the bounded remainder named for A.8.24 vs T1040.
- T1039partialprevents — A.8.24 can prevent the *collection* half of T1039 where files on network shares are encrypted at rest with keys held outside the compromised user's reach (e.g., application-layer encryption or managed file encryption), but it does not prevent the *search* half — file names, directory structure, share enumeration and metadata remain visible — and the clause sets a framework keyed to data classification rather than mandating encryption of every share, so transparent encryption schemes (EFS, user-held keys) leave the technique fully viable.
- T1052partialprevents — Encryption at rest with proper key management can render exfiltrated data unreadable, preventing the technique's goal in many cases, but cryptography does not stop the physical act of copying to a removable medium and is limited in air-gapped scenarios where data must be in plaintext for use, leaving a meaningful remainder where the technique still succeeds.
- T1110partialprevents — A.8.24 governs the use of cryptography to protect information confidentiality, authenticity and integrity, and key management for that cryptography; it does not address authentication mechanisms, credential storage, or password strength, so the brute-force technique can still be executed against authentication services regardless of how A.8.24 is implemented.
- T1110.002partialprevents — A.8.24's requirements on cryptographic algorithm type, strength and quality apply to credential storage: strong, salted, iterated password hashing (bcrypt, scrypt, Argon2, PBKDF2) makes cracking computationally infeasible, so where the policy is applied to password storage the technique is largely prevented. The grade is partial because the clause addresses cryptography generally rather than mandating credential-storage specifics, weak passwords remain crackable even under strong hashing, and pre-existing hashes created under weaker algorithms survive the policy.
- T1114partialprevents — Encryption at rest with sound key management prevents an adversary who reaches a mail store from reading email content, but the collection itself still runs, metadata (sender, recipient, subject, timestamps) typically remains in cleartext, and the clause governs cryptography generally rather than mandating email-at-rest encryption everywhere — so the technique is degraded, not stopped.
- T1114.001partialprevents — A.8.24 can protect email data at rest through encryption (full-disk encryption, encrypted .ost/.pst stores), but the technique specifically targets local files that Outlook must decrypt to render, so once the adversary has user-level access to a running session the cryptographic protection is bypassed for the duration of that session — partial coverage of the offline/secondary-copy case, not the primary mechanism.
- T1195partialprevents — Cryptography — particularly code signing and integrity verification — can prevent tampered software from being accepted and executed, but it does not prevent the supply chain manipulation itself from occurring, and it fails when signing infrastructure is compromised, when compromise happens before signing, or when signature verification is not consistently applied across all distribution channels and dependencies.
- T1212partialprevents — A.8.24 mandates cryptographic standards that, when implemented, prevent the replay-attack variant of T1212 (nonces, timestamps, authenticated channels) and reduce exposure of credentials in transit, but it does not prevent software-vulnerability exploitation for credential access broadly — MS14-068-style flaws and cloud token bugs are implementation defects that cryptography policy cannot reach.
- T1213.006partialprevents — A.8.24's encryption-at-rest and key management can render data extracted from databases unreadable without keys, but it does not prevent the adversary from accessing or querying the database itself, and database service accounts or compromised credentials often hold decryption capability, so the technique still runs and often still yields plaintext.
- T1530partialprevents — A.8.24's encryption-at-rest with proper key management can render cloud-stored data unreadable to an adversary who accesses storage via misconfiguration or stolen credentials, but most cloud storage relies on provider-managed keys where the service decrypts for any authenticated caller, and the technique is fundamentally an access-control failure that cryptography only partially mitigates as a secondary layer.
- T1539partialprevents — Cryptography prevents cookie theft from disk (encrypted cookie stores) and from network sniffing (TLS), but does not prevent memory scraping (cookies must be plaintext in process memory to be used) or AitM attacks where the adversary terminates TLS with a valid certificate, leaving significant vectors open.
- T1542.001partialprevents — A.8.24's cryptographic framework can be applied to firmware integrity via signed firmware and secure boot (UEFI/BIOS verification), which would prevent unauthorized modification, but the control's specific requirements focus on data confidentiality, mobile/transit protection, and key management rather than mandating firmware integrity verification — so prevention is enabled by the framework but not directly required for this technique.
- T1552partialprevents — Enforcing encryption of sensitive information on endpoints and storage media limits an attacker’s ability to locate and read credentials stored in files or configuration stores.
- T1552.004partialprevents — A.8.24's key management guidance (secure storage, physical protection of key equipment, protection against unauthorized disclosure) can prevent the technique from finding usable private keys when properly implemented via HSMs, TPMs or encrypted key stores, but the search itself still runs, many implementations retain keys in files (SSH keys, certificates) for the system to function, and the clause provides guidance rather than universal mandates on storage form.
- T1553partialprevents — A.8.24's key management provisions (secure generation, storage, distribution and protection of cryptographic keys) make it harder for adversaries to steal code-signing private keys, which is one path into T1553; however, the control does not address trust-store manipulation, root certificate installation, SIP/trust-provider hijacking, or Mark-of-the-Web bypass, so only a slice of the technique is reached.
- T1555partialprevents — A.8.24 mandates strong cryptography and proper key management, which protects credentials at rest in password stores (e.g. encrypted password manager vaults, browser credential databases) against offline extraction, but T1555 spans vectors that bypass cryptography: memory dumping of already-decrypted credentials, accessing cloud vaults through legitimate APIs with stolen session tokens, and extracting credentials from active sessions where the store has decrypted them for use — so cryptography reduces the attack surface without closing it.
- T1557.004partialprevents — A.8.24 requires encryption for data in transit and mandates certificate validation, which prevents the adversary from reading or manipulating the traffic of a client that enforces those protections, but the control does not prevent the client from connecting to the evil twin access point in the first place.
- T1558partialprevents — A.8.24's requirements for cryptographic algorithm strength and key management constrain parts of T1558 — particularly Kerberoasting, which depends on weak ticket encryption (RC4) — but the control does not prevent ticket theft from compromised host memory or forgery via credential replay, so the preventive effect is a slice rather than the bulk.
- T1558.003partialprevents — A.8.24 mandates cryptographic standards and approved algorithms/cipher strength, which can prevent the RC4 etype 23 variant of Kerberoasting by requiring stronger encryption types; however, the control sets general cryptography policy rather than directly configuring Kerberos, and AES-based Kerberoasting against weak service account passwords remains feasible, so prevention is partial.
- T1558.004partialprevents — A.8.24(f) can mandate strong Kerberos encryption types (AES rather than RC4), making the offline cracking component harder, but the technique's core vulnerability — accounts with preauthentication disabled — is a configuration issue outside A.8.24's scope, and the attack still works against strong algorithms given a weak password.
- T1565partialprevents — Cryptographic integrity controls (signatures, MACs, hashes verified before use) genuinely prevent undetected data manipulation where applied, but A.8.24 mandates appropriate use based on classification rather than universal application, and many manipulation targets (application data, databases, runtime state) lack cryptographic integrity protection or have verification that is not enforced before the data is acted upon.
- T1565.001partialprevents — A.8.24's framework for cryptographic integrity protection (MACs, digital signatures, authenticated encryption) prevents stored data manipulation from succeeding where applied — the modification occurs but is rejected by integrity verification, so the technique's goal of influencing outcomes is not achieved. However, the clause sets policy and key-management requirements rather than mandating integrity protection for all stored data, and not all data at rest will be covered, leaving a substantial remainder where manipulation succeeds.
- T1600.001partialprevents — A.8.24 mandates minimum cipher strengths and approved algorithms, which establishes the standard that weak crypto is unacceptable, but the technique operates on already-compromised network devices where the adversary modifies configuration directly — A.8.24 sets the policy and standards but does not itself prevent an attacker with device access from altering cryptographic parameters, leaving a bounded remainder that other controls (configuration management, system integrity) must close.
- T1601partialprevents — A.8.24's cryptography framework supports firmware/code-signing and integrity verification, which can prevent unauthorized modification of a network device's OS image at boot or storage level, but the clause is general guidance on cryptographic use rather than a specific mandate for signed network-device firmware, and in-memory modifications during runtime can bypass integrity checks that only run at load time.
- T1602partialprevents — Cryptography can protect configuration repository data in transit (e.g., SNMPv3 with privacy, HTTPS, SSH) and at rest, so collected material is unreadable where implemented, but the technique is about the collection action itself which cryptography does not stop, and many configuration repositories transmit in cleartext by default.
- T1602.001partialprevents — A.8.24 requires encryption of information in transit, which can protect SNMP community strings and MIB data from passive interception, but SNMPv3 with encryption is not mandated and the control does not address SNMP configuration or access control, leaving MIB dumps possible over unencrypted or weakly-configured SNMP.
- T1606partialprevents — A.8.24's cryptographic signing and key management prevent forgery of cryptographically-protected tokens and cookies when properly implemented, but T1606 explicitly includes non-cryptographic paths (abuse of legitimate APIs like AWS AssumeRole/GetFederationToken and Zimbra's zmprov gdpak) that bypass cryptographic protection entirely, and A.8.24 is a governance/policy control mandating practice rather than a technical implementation that guarantees it.
- T1606.001partialprevents — A.8.24's key management (generation, protection, distribution, revocation) can prevent cookie forgery where cookies are cryptographically signed and the signing secret is properly safeguarded, but the control does not mandate cookie signing specifically, many web applications use standardized cookie formats that do not require cryptographic secrets, and the technique often proceeds by obtaining the signing key through other means — so cryptography use reduces but does not eliminate the technique's viability.
- T1606.002partialprevents — A.8.24's key management (secure generation, storage, protection against unauthorized disclosure, and revocation of compromised keys) directly prevents the main path where an adversary steals the token-signing private key to forge SAML tokens, but the technique also succeeds when the adversary has sufficient permissions to establish a new federation trust with their own AD FS server and generate a trusted signing certificate — a path A.8.24 does not address, since it governs cryptographic key handling rather than federation trust configuration or identity-provider administrative controls.
- T1649partialprevents — A.8.24's key management requirements (generation, storage, revocation, compromised-key handling, physical protection of key equipment) directly address protection of CA private keys and certificate keys against theft and unauthorized use, but the technique's major vectors — AD CS misconfigurations, certificate enrollment rights abuse, SAN/EKU manipulation, and theft of certificate files from endpoint stores — fall outside the clause's scope of cryptography use and key management.
- T1659partialprevents — A.8.24 requires encryption in transit which prevents content injection from the middle or side on protected channels, but the control does not mandate encryption for all network traffic and cannot prevent injection on unencrypted or compromised upstream channels.
- T1669partialprevents — A.8.24's cryptographic standards (WPA2/WPA3 with strong key management) prevent unauthorized access to secured Wi-Fi networks, but the technique explicitly includes open Wi-Fi networks (no crypto to apply), abuse of valid accounts on secured networks (crypto is bypassed by legitimate credentials), physical proximity, and dual-homed system compromise — none of which cryptography addresses.
- T1684.001partialprevents — A.8.24's authenticity provisions (digital signatures, certificates, key management) provide mechanisms that can verify sender identity and make forgery harder, but the control is general guidance on cryptographic use rather than a mandate for comprehensive authentication of all communications, and impersonation fundamentally exploits human trust that cryptography alone cannot fully close.
- T1684.002partialprevents — A.8.24 covers cryptographic mechanisms like DKIM digital signatures that verify email authenticity, which is one necessary component against header spoofing; however, the control does not mandate DMARC policy enforcement (p=quarantine/reject), so spoofed emails with valid-looking signatures or weak DMARC policies (p=none) still reach victims, and adversaries can bypass via Direct Send and other non-cryptographic vectors.
- T1689partialprevents — A.8.24's requirements for cryptographic standards, algorithm strength, and approved usage practices (clause f) can prevent the cryptographic-protocol subset of T1689 (e.g., SSL stripping, HTTPS→HTTP downgrade) by mandating strong protocols and disallowing weak ones, but the control does not address non-cryptographic downgrade vectors such as PowerShell version rollback or boot manager downgrade, which constitute a substantial portion of the technique.
Prevented OWASP Web Top 10 (2025) risks (1)
OWASP Web Top 10 (2025) risk categories this ISO control helps prevent or mitigate — our analysis (mostly llm_verified).
Direction: ← other covers this;
→ this covers other (F/M/P = full / mostly /
partial). gov = governs / implements (a mandate, not coverage).
Why these map — rationale
- A04mostlyblocks — A.8.24's purpose and guidance directly mandate identifying protection needs then selecting/using appropriate algorithms, key management, and approved practices, which closes the bulk of absent/weak/misused cryptography that the A04 class names; the bounded remainder is legacy data already at rest with no re-encryption trigger and cases where the approved algorithm is later broken.
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.