A.8.9 Technological
Configuration management
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 (22)
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
- CM-2mostlycovers — Both controls establish and maintain secure baseline configurations for systems and components throughout their lifecycle.
- CM-3mostlycovers — Both require formal change control processes and logging for all configuration modifications to hardware, software, and services.
- CM-6mostlycovers — Both mandate defining, applying, and periodically reviewing standardized secure configuration settings across organizational assets.
- CM-7mostlycovers — A.8.9's mandate to maintain correct security settings and prevent unauthorized/incorrect configuration changes accounts for the bulk of CM-7's least-functionality and restriction requirements, but leaves a residual on the explicit configuration of 'only essential capabilities' (the first CM-7 objective) that is narrower than A.8.9's general correctness focus.
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.PS-01fullcovers — The ISO control's mandate to define, enforce, record, and monitor secure configuration baselines for hardware, software, services, and networks directly implements the CSF outcome of establishing and applying configuration management practices.
- ID.AM-08domain mandateimplements — A.8.9 operationalizes secure configuration management across the full asset life cycle that ID.AM-08 names; the link is within the asset-management domain but the outcome does not explicitly name configuration management.
- ID.RA-07domain mandateimplements — A.8.9's operational process of managing and securing configuration changes directly gives effect to the governance outcome of managing, risk-assessing, recording and tracking changes and exceptions within the risk-assessment domain
Related OWASP ASVS 5.0 requirements (13)
Application-security verification requirements (OWASP ASVS 5.0) this ISO control aligns with; links open the ASVS chapter. Our analysis (mostly llm_verified) — many ISO controls have no ASVS counterpart.
Direction: ← other covers this;
→ this covers other (F/M/P = full / mostly /
partial). gov = governs / implements (a mandate, not coverage).
Related weaknesses / CWE (3270)
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-1392fullremoves — A.8.9 item (f) explicitly requires changing vendor default authentication information immediately after installation, so applying the clause to a system where it was previously absent removes the default credentials that constitute CWE-1392.
- CWE-1393fullremoves — A.8.9's guidance item (f) explicitly requires changing vendor default passwords immediately after installation, so applying the control to a system with existing default passwords removes the weakness entirely.
- CWE-1394fullprevents — Enforces secure configuration baselines that should replace default keys.
- CWE-1394fullremoves — Graded full by the owner: the clause requires vendor default authentication information to be changed immediately after installation and other default security settings to be reviewed, with monitoring that compares actual settings with the target and enforces it.
- CWE-1394fullfinds — Graded full by the owner: the clause has vendor default authentication information changed and other default security settings reviewed, and monitors actual settings against the target, so default keys and credentials left in place are found.
- CWE-11mostlyblocks — Configuration management directly requires disabling debug builds and removing diagnostic information from production releases.
- CWE-11mostlyremoves — A.8.9's standard templates specify secure ASP.NET configurations (debug="false" for production), and its monitoring/enforcement mechanism detects and corrects deviations from the target template, removing the flaw in most cases; the remainder includes build-time debug flags not captured in runtime configuration files and systems outside the configuration management scope.
- CWE-11mostlyprevents — A.8.9's standard templates for secure configuration would specify debug=false for production ASP.NET deployments, and monitoring against those templates would catch deviations before they reach production; the remainder is nameable — third-party ASP.NET components that ship with debug enabled, build pipelines that bypass the configuration baseline, and organizations whose templates do not specifically address the debug compilation flag.
- CWE-11mostlyfinds — A.8.9's monitoring mechanism explicitly compares actual configurations against defined target templates and addresses deviations, which is exactly the mechanism that surfaces a debug='true' setting in web.config when the template specifies debug='false'; the remainder is ASP.NET applications outside the managed configuration set (third-party, unmanaged, or shadow deployments) where no comparison is performed.
- CWE-1188mostlyblocks — Mandating secure baseline templates and immediate replacement of vendor defaults directly stops systems from being deployed with insecure factory settings that attackers can exploit.
- CWE-1188mostlyfinds — 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-1190mostlyblocks — Configuration management enforces secure boot ordering and DMA enablement timing.
- CWE-12mostlyblocks — Configuration management directly requires proper configuration of error handling to avoid information disclosure.
- CWE-12mostlyremoves — A.8.9's standard templates would include secure ASP.NET settings (customErrors mode='On'), and its monitoring/correction loop detects deviations from the template and applies corrective actions, which removes the existing misconfiguration where the Web.config is under the managed configuration set; the bounded remainder is ASP.NET applications outside the managed configuration scope (third-party hosted, shadow IT, legacy).
- CWE-12mostlyfinds — A.8.9's monitoring section explicitly compares actual configurations against defined target templates and addresses deviations; if the standard template specifies the secure ASP.NET customErrors setting, configuration monitoring surfaces instances where it is Off or missing, which is the CWE-12 weakness. The remainder is bounded: templates that do not enumerate ASP.NET-specific settings, or monitoring that does not reach every Web.config in the estate.
- CWE-1295mostlyblocks — Configuration management can disable debug flags, providing partial mitigation without covering the control's broader scope.
- CWE-13mostlyfinds — A.8.9's monitoring of configurations compares actual settings against defined target templates and explicitly includes evaluating password strengths, so a well-implemented programme with templates drawn from public guidance (which prohibits plaintext credential storage) will detect plaintext passwords in configuration files as deviations; the remainder is configurations outside the monitored scope or templates that do not explicitly address this case.
- CWE-1327mostlyremoves — A.8.9's mechanism — standard templates, configuration monitoring, and corrective action on deviations — directly addresses CWE-1327, whose mode of introduction is System Configuration; when applied to a system where a service is bound to 0.0.0.0, monitoring detects the deviation from the template's specified binding and corrective action changes it, removing the weakness. The remainder is bounded and nameable: bindings hardcoded in application code rather than exposed as configuration settings, which A.8.9 does not reach.
- CWE-1327mostlyfinds — A.8.9's monitoring section explicitly compares actual configurations against defined target templates and flags deviations; binding to 0.0.0.0 is a directly checkable configuration property, so a well-implemented programme with templates that restrict bind addresses would surface most instances. The remainder is services outside the managed configuration set and templates that do not specify bind-address restrictions.
- CWE-1392mostlyblocks — The requirement to replace vendor default authentication information immediately after installation directly counters the use of default credentials that attackers commonly target.
- CWE-1392mostlyfinds — A.8.9's monitoring component explicitly compares actual configurations against target templates, evaluates password strengths, and reviews configuration settings on a regular basis — default credentials in systems under configuration management are surfaced as deviations from the template (which specifies non-default credentials) and as weak passwords. The remainder is bounded and nameable: default credentials hardcoded in firmware or third-party components outside the managed configuration inventory, and systems not under configuration management.
- CWE-1393mostlyblocks — Configuration management processes typically enforce changing defaults during hardening.
- CWE-1393mostlyfinds — A.8.9's standard templates explicitly require changing vendor default passwords (item f) and its monitoring section mandates comparing actual configurations against target templates and evaluating password strengths, so default passwords in systems under configuration management are found as deviations; the remainder is systems outside the managed configuration scope and cases where detecting that a password IS the vendor default (rather than merely weak) requires specific vendor-default knowledge.
- CWE-1434mostlyremoves — A.8.9's core mechanism — defining secure configuration templates, monitoring actual settings against the template, and enforcing corrections — directly addresses CWE-1434, which is a configuration weakness in inference parameters (temperature, Top P, Top K). Applied to a system with insecure parameter settings, the control identifies deviations from the secure template and corrects them, removing the misconfiguration. The remainder is bounded and nameable: parameters baked in at training time rather than deployment, and context-specific optimal values that a generic template cannot fully capture, where empirical testing rather than configuration management is needed.
- CWE-15mostlyblocks — Configuration management directly prevents external tampering with system settings.
- CWE-211mostlyblocks — A.8.9's secure configuration baseline and enforcement can set production runtimes to suppress detailed external error messages, blocking the sensitive-information leak for most CWE-211 instances, though unmanaged or configuration-ignoring legacy components keep some leaks possible.
- CWE-250mostlyblocks — The control explicitly calls for minimizing privileged identities and disabling unnecessary accounts, thereby reducing the number of processes that run with unnecessary privileges.
- CWE-258mostlyblocks — Configuration management processes would normally detect and correct insecure empty-password settings.
- CWE-258mostlyremoves — Configuration management templates and monitoring detect and correct empty passwords in configuration files, but some configuration files may not be covered by standard templates.
- CWE-258mostlyfinds — A.8.9's monitoring section explicitly requires evaluating password strengths and comparing actual configurations against target templates, which surfaces empty passwords in managed configuration files; the bounded remainder is configurations outside the organization's managed scope (third-party application configs, embedded settings not covered by templates).
- CWE-276mostlyblocks — Standard templates that restrict access to utility programs and host parameter settings prevent the assignment of overly permissive default permissions on critical resources.
- CWE-276mostlyremoves — A.8.9's configuration monitoring compares actual configurations against defined target templates and requires deviations to be addressed through automatic enforcement or corrective actions; applied to a system where it was not applied before, this mechanism detects and corrects most instances of incorrect file permissions. The remainder is bounded: files outside the monitored configuration set or permissions not specified in the template are not caught.
- CWE-276mostlyprevents — A.8.9's standard templates define secure configurations including file permissions, and the change-management and monitoring processes enforce them, so first-party installations and post-installation hardening do not produce world-writable files; the bounded remainder is third-party installers whose permission choices are made by the vendor and arrive already set, which the template governs only by post-install correction rather than by preventing the install-time act.
- CWE-276mostlyfinds — A.8.9's monitoring activity compares actual configurations against defined target templates and addresses deviations, so installed files with incorrect permissions are surfaced as configuration drift on systems under management; the remainder is systems outside the managed configuration set or templates that do not specify file permissions.
- CWE-433mostlyblocks — Configuration management ensures correct server settings for content types but is broader than this specific weakness.
- CWE-453mostlyblocks — Configuration management enforces secure default values and prevents insecure initialization.
- CWE-489mostlyblocks — Configuration management can disable or remove debug features through hardened baselines.
- CWE-5mostlyremoves — A.8.9's mechanism of defining secure configuration templates, monitoring actual configurations against targets, and correcting deviations directly addresses the misconfiguration that allows unencrypted data transmission in J2EE applications; when applied to a system with this weakness, it detects and corrects the configuration deviation. The bounded remainder is the code-level manifestation noted in CWE-5 (programmer-created relative links that do not switch from HTTP to HTTPS), which is a code defect rather than a configuration item and falls outside A.8.9's reach.
- CWE-5mostlyfinds — A.8.9's monitoring compares actual configurations against target templates, so a J2EE deployment configured to allow HTTP where the template requires HTTPS/SSL is detected as a deviation; the remainder is the code-level manifestation (programmer-authored relative links that do not switch to HTTPS), which is a source-code defect rather than a configuration setting and is not visible to configuration monitoring.
- CWE-520mostlyfinds — Configuration management's monitoring component compares actual configurations against defined target templates, and a well-implemented programme's template would address .NET impersonation (a standard item in hardening guidance like CIS); deviations where impersonation is enabled against policy are surfaced. The remainder is configurations where the template does not specifically address impersonation, or where the setting is policy-compliant but the underlying NTFS permissions make it unsafe — a nameable slice the configuration-comparison reach does not cover.
- CWE-528mostlyremoves — A.8.9's mechanism — defining secure configuration templates, monitoring actual vs. target configurations, and enforcing corrections — directly addresses CWE-528, which manifests primarily as a misconfiguration of where core dumps are written and who can access them; applying the clause where it was not applied before corrects the core-dump location/permissions and removes the weakness for systems under management, with the remainder being systems outside the configuration management scope and any pre-existing core dump artifacts that enforcement may not delete.
- CWE-529mostlyremoves — A.8.9's mechanism — define secure configuration templates, monitor actual configurations against them, and address deviations through enforcement or corrective action — directly targets the misconfiguration that is CWE-529 (ACL files stored in an accessible directory). Applied where it was not applied before, the monitoring step detects the file-location deviation from the template and the corrective-action step moves the files, removing the weakness. The remainder is bounded and nameable: systems outside the managed configuration set, templates that do not specify ACL file locations, and third-party/COTS components whose file placement the organization cannot change.
- CWE-529mostlyprevents — Configuration management defines and enforces secure file, directory, and service access templates along with monitoring, which prevents most ACL-file exposure from arising, though application-specific ACL files placed outside the managed configuration baseline can still be exposed.
- CWE-536mostlyblocks — A well-implemented configuration management process can set and enforce secure servlet-container or application-server configuration such as custom error pages and disabled verbose stack traces, blocking most CWE-536 exposures, though error details emitted directly by application code or unmanaged deployments remain.
- CWE-548mostlyremoves — A.8.9's mechanism — secure configuration templates that disable directory indexing, monitoring actual vs. target configurations, and correcting deviations — directly removes existing directory-listing exposures when applied to a previously unmanaged system; the remainder is systems or services outside the managed configuration scope (shadow IT, unmanaged third-party services) where the clause's monitoring never reaches.
- CWE-548mostlyprevents — A.8.9's standard templates for secure configuration would specify disabling directory listing on web servers, and monitoring against the template catches deviations, so most instances never arise; the remainder is application-level directory listing behaviors and custom code that enables indexing, which a web-server configuration template does not reach.
- CWE-548mostlyfinds — A.8.9's monitoring activity compares actual configurations against defined target templates, and a standard template for web servers would specify directory listing disabled; deviations are detected, so most instances of this configuration-level weakness are found. The bounded remainder is directory listings enabled at the application layer rather than the web server, and third-party components outside the configuration management scope.
- CWE-552mostlyremoves — A.8.9's configuration monitoring and deviation correction removes the configuration-based instances of CWE-552 (cloud storage misconfigurations like 'Allow Blob Public Access' = true, IAM policies granting allUsers access, web server directory permissions), which constitute the bulk of modern instances; the remainder is the code/architecture-level instances (files placed under web root by design) that configuration management does not reach.
- CWE-556mostlyremoves — A.8.9's monitoring and corrective actions remove existing misconfigurations when the secure template disallows identity impersonation, but configurations outside the managed set may persist.
- CWE-556mostlyprevents — A.8.9's standard templates for secure configuration would specify ASP.NET settings including whether and how identity impersonation is used, and newly installed systems built from those templates would not acquire this misconfiguration; monitoring against the template catches deviations. The remainder is bounded: legacy ASP.NET applications configured before the template existed, applications outside the managed configuration set, and custom deployments that deviate from the template.
- CWE-556mostlyfinds — A.8.9's monitoring compares actual configurations against defined target templates, and identity impersonation is a configuration setting in ASP.NET config files; a secure template would specify the impersonation setting, so deviations are surfaced as findings. The remainder is ASP.NET applications outside the managed configuration scope and templates that do not specifically address impersonation.
- CWE-6mostlyremoves — A.8.9's template-and-monitor mechanism directly addresses configuration misconfigurations: a well-implemented standard template specifies the correct session ID length (16 bytes/128 bits), monitoring detects deviations from the target, and corrective actions change the setting, so the weakness stops being present. The remainder is bounded and nameable — application servers where the session ID length cannot be changed from its default (the CWE example itself notes this is true for many servers), and J2EE-specific deployment-descriptor settings that fall outside the template's coverage at a representative organization.
- CWE-6mostlyprevents — A.8.9's standard templates for secure software configuration would specify the required session ID length (128 bits) for J2EE applications, and new deployments following the template would not acquire this weakness; monitoring against the template catches deviations. The remainder is bounded: third-party or COTS application servers where the organization does not control the deployment descriptor, and legacy systems configured before the template was applied.
- CWE-6mostlyfinds — A.8.9's monitoring section explicitly compares actual configurations against defined target templates and addresses deviations, and CWE-6 is a configuration setting (session-ID length in a J2EE deployment descriptor) that a well-built template would specify at 128 bits, so deviations to 8 bytes would be surfaced; the remainder is bounded and nameable -- templates that do not cover this specific J2EE session property, or configurations managed outside the standard template set.
- CWE-756mostlyfinds — Configuration management's monitoring compares actual configurations against defined target templates, and a well-implemented template would include custom error page settings (e.g., ASP.NET <customErrors>, Java web.xml error-page elements); deviations are detected as findings. The remainder is bounded and nameable: code-level custom error handling implemented outside configuration files, third-party applications whose configurations the organization does not manage, and templates that omit this specific setting.
- CWE-9mostlyfinds — A.8.9's monitoring compares actual configurations against target templates, and EJB deployment descriptors are configurations in scope; a well-implemented template at a J2EE-using organization would specify that the ANYONE role should not be granted on EJB methods, so deviations are surfaced as configuration drift. The remainder is bounded and nameable: EJB applications outside the managed configuration set, or specific method permissions not enumerated in the template.
- CWE-942mostlyremoves — A.8.9's mechanism — defining secure configuration templates, monitoring actual configurations against the target, and addressing deviations through automatic enforcement or corrective action — directly targets configuration-level weaknesses like a permissive cross-domain policy file. Well implemented, the template specifies restrictive cross-domain policy settings, monitoring detects the permissive deviation, and enforcement corrects it, removing the flaw. The remainder is bounded: cross-domain policies embedded in unmanaged third-party components or hardcoded in first-party code rather than expressed as configuration fall outside the clause's reach.
- CWE-1021partialremoves — A.8.9's configuration templates and monitoring can enforce HTTP headers (X-Frame-Options, CSP frame-ancestors) that are the primary clickjacking mitigation, removing existing header-misconfiguration instances; however, code-level frame-busting logic and applications with context-dependent framing requirements are outside configuration management's reach, leaving a nameable remainder.
- CWE-1125partialprevents — A.8.9's standard templates directly require disabling or restricting unnecessary functions and services, disabling unused identities, and restricting powerful utilities — all of which reduce attack surface at the configuration layer. But CWE-1125 is introduced in Architecture/Design and Implementation, where the number of input/output points, endpoints, and exposed interfaces is decided; configuration management reaches what is enabled after the fact, not the design choices that determine the surface in the first place, leaving a nameable remainder.
- CWE-1125partialremoves — A.8.9's guidance items (b) disabling unnecessary identities, (c) disabling or restricting unnecessary functions and services, and (d) restricting access to powerful utility programs directly remove existing attack vectors when applied to a system that previously lacked these configurations; however, attack surface also encompasses architectural decisions, code-level input points, and API exposure that configuration management cannot reach, leaving a nameable remainder.
- CWE-12partialprevents — A.8.9's mechanism (secure configuration templates plus monitoring/enforcement against those templates) reaches CWE-12 only when the organization's baseline template explicitly includes the ASP.NET <customErrors> setting, which is a choice the implementer makes rather than something the clause mandates; a representative organization with ASP.NET applications would likely include it, but the control is technology-agnostic and the template content is not guaranteed.
- CWE-1240partialfinds — Configuration management's monitoring compares actual configurations to target templates, so it finds CWE-1240 instances that manifest as configuration choices (enabled weak cipher suites, configured weak hash algorithms like MD5, default crypto settings) — a real but minority share of the class, since most CWE-1240 instances are embedded in code-level implementations (custom primitives, DRBG entropy bugs, nonce handling) that configuration monitoring does not see.
- CWE-1256partialblocks — A.8.9's guidance items (c) disabling/restricting unnecessary functions and services and (d) restricting access to powerful utility programs and host parameter settings can be applied to limit which software can reach power/clock management and RAPL interfaces, partially blocking exploitation; the hardware design weakness itself remains, and the clause is not specifically aimed at these interfaces, so the effect is a minority one.
- CWE-13partialremoves — A.8.9's template-plus-monitoring-plus-corrective-action mechanism can detect and remove plaintext passwords from ASP.NET config files where the organization's configuration scope includes application config files and templates prohibit the practice, but this is not the clause's primary reach (it targets system/infrastructure configurations) and depends on implementation choices, so only a minority of instances are removed.
- CWE-1314partialblocks — Configuration management enforces write-protection and integrity checks on parametric/sensor calibration data.
- CWE-1428partialremoves — A.8.9 removes CWE-1428 where the weakness is a configuration choice (e.g., a service configured to listen on HTTP rather than HTTPS) by enforcing secure-configuration templates that require HTTPS, but it does not reach instances where the weakness is baked into code or design (hardcoded `http://` URLs, architectural assumptions that HTTP will be used, or requirements that omit encryption) — and the CWE's modes of introduction place most instances in those latter phases.
- CWE-1428partialprevents — A.8.9's standard templates and monitoring can require HTTPS and disable HTTP at the infrastructure/configuration layer (web servers, load balancers, services), preventing the weakness there, but it does not reach the architecture, requirements, implementation, or content-generation introduction points where HTTP is chosen in code, design, or generated links.
- CWE-1428partialfinds — A.8.9 monitors actual configurations against defined target templates and would find instances where a service, network endpoint, or system is configured to use HTTP instead of HTTPS (e.g., web server listener, API endpoint, default service configuration), but the majority of CWE-1428 instances are baked into product code (hardcoded URLs, API design choices, application logic) which configuration monitoring does not read.
- CWE-1434partialprevents — A.8.9's general mechanism (define standard configuration templates, monitor actual configurations against them, address deviations) is applicable to AI/ML model configurations, so a well-implemented programme that includes inference parameters in its templates would prevent some instances; however, A.8.9's specific guidance items (privileged access, default passwords, unused services, etc.) do not address AI/ML inference parameters, and the 'correct' values are context-dependent and require empirical testing rather than configuration management, leaving a nameable remainder the clause does not reach.
- CWE-1434partialfinds — A.8.9's monitoring mechanism compares actual configurations against defined target templates, so if an organization has defined acceptable ranges for AI/ML inference parameters (temperature, Top P, Top K) in its configuration baseline, deviations would be detected; however, this is a specialized weakness that CWE itself notes is under-reported with no clear CVE examples, and representative organizations vary widely in whether their configuration templates extend to ML model inference parameters, leaving a substantial share of instances outside the managed configuration set.
- CWE-207partialremoves — Graded partial by the owner: configuration management, applied after deployment as well as before, can change many identifying characteristics such as service ports and login prompts, but others, such as default network stack values like TCP window size and IP TTL, are hard or impossible to change.
- CWE-207partialfinds — Graded partial by the owner: configuration management reads system configurations, so it finds the identifying characteristics that are configurable, such as service ports and login prompts, but not those that are hard or impossible to change.
- CWE-207partialprevents — Graded partial by the owner: configuration management, applied before or after deployment, can change many identifying characteristics such as service ports and login prompts, but others, such as default network stack values like TCP window size and IP TTL, are hard or impossible to change.
- CWE-209partialremoves — A.8.9's templates and configuration enforcement can remove configuration-level instances of CWE-209 (e.g., disabling verbose error pages, suppressing debug output, setting generic error responses), but cannot reach the majority of instances where application code explicitly constructs error messages containing sensitive data — those require code changes the clause does not perform.
- CWE-215partialblocks — Configuration management defines and enforces secure baselines but does not inspect or remove debugging code that may already be present in a production system, so the weakness can still be exploited.
- CWE-219partialblocks — A.8.9's standard templates and configuration monitoring can enforce web server hardening (denying direct HTTP access to sensitive file types/paths under the document root), which blocks the primary exploitation vector for CWE-219; however, the underlying file placement remains, and other access paths (local file inclusion, backup exposure, secondary misconfigurations) are not addressed by configuration management alone.
- CWE-250partialremoves — Configuration management can remove unnecessary privileges that are configurable (e.g., service accounts, setuid bits, default accounts), but cannot remove code-level unnecessary privilege flaws that require software changes.
- CWE-250partialprevents — A.8.9's standard templates explicitly require minimizing privileged identities, disabling unnecessary identities, and restricting access to powerful utility programs, which addresses the system/service configuration slice of CWE-250; however, the weakness is largely an application design and implementation defect (code that fails to drop privileges, setuid programs, applications requesting excessive permissions) that configuration management does not reach.
- CWE-250partialfinds — A.8.9's standard templates explicitly require minimizing privileged identities and disabling unnecessary ones, and its monitoring compares actual configurations to those templates, so it finds configuration-level instances of CWE-250 (services running as root, unnecessary setuid programs, excess privileged accounts); however, it does not reach code-level instances where a program raises privileges at runtime and fails to drop them, nor architectural decisions about required privilege levels, which constitute a substantial share of the class.
- CWE-256partialfinds — A.8.9's configuration monitoring compares actual configurations to defined templates and reviews security-related parameters, so it can detect plaintext passwords stored in configuration files, registry keys, and connection strings — a meaningful share of CWE-256 instances as the observed examples show. It does not reach plaintext passwords embedded in source code, compiled binaries, or runtime memory, which is a nameable remainder outside its configuration scope.
- CWE-257partialfinds — A.8.9's monitoring compares actual configurations against target templates, so a template specifying one-way hashing would flag recoverable-format password storage in configuration files (cleartext in properties/connection strings, reversible-encryption mode in system password stores) as deviations; however, the majority of CWE-257 instances live in application source code (compression-based verification, custom reversible encryption), which configuration management does not read.
- CWE-263partialremoves — A.8.9's standard-template and monitoring/enforcement mechanism reaches password aging as a configurable security setting and can change a long expiration to a shorter one defined in the template, removing the weakness where the setting is configurable and the organization's template specifies an appropriate period; the remainder is nameable — products with hardcoded expiration periods, and organizations whose templates define long expirations as 'secure' (e.g., for compliance reasons) — so the effect is real but bounded.
- CWE-263partialprevents — A.8.9 establishes standard templates for secure configuration and its monitoring section explicitly mentions evaluating password strengths, so a well-implemented configuration management programme will include password-expiration settings in its templates and prevent most instances of an excessively long period from being deployed; the remainder is that the actual policy on what counts as an appropriate expiration period is set by the access/authentication policy (A.5.15 et seq.), not by configuration management, and A.8.9 inherits rather than dictates that value.
- CWE-284partialfinds — A.8.9's configuration monitoring reaches the configuration-level subset of CWE-284 — default credentials (template item f), unnecessary privileged identities (item a), disabled functions not actually disabled (item c) — but the bulk of CWE-284 is code-level authorization and authentication logic defects that configuration monitoring does not see.
- CWE-306partialfinds — A.8.9's monitoring compares actual configurations against defined templates and can detect deviations such as a service configured to allow anonymous access or a default setting that permits unauthenticated use (e.g., CVE-2020-13927-style cases), but CWE-306 is primarily an architecture-and-design omission — missing authentication in custom code, protocols, or APIs — which configuration management does not read; the remainder (the bulk of the class) is outside its reach.
- CWE-307partialfinds — Configuration monitoring can detect deviations where authentication lockout/throttling settings exist but are configured too loosely or disabled against the target template, but the majority of CWE-307 instances are products whose authentication code simply lacks rate-limiting functionality — a design/code absence that configuration comparison does not reach.
- CWE-312partialfinds — A.8.9's configuration monitoring compares actual settings against target templates, so it detects cleartext storage when it manifests as a configuration deviation (e.g., database/S3/Azure storage without encryption enabled, cleartext credentials in config files, unencrypted registry keys), but it does not reach code-level instances where the product's code stores data in cleartext regardless of configuration (cookies, memory buffers, temporary files, code-written log entries) — a substantial share of the CWE-312 class.
- CWE-313partialfinds — A.8.9's monitoring compares actual configurations against target templates and evaluates password strengths, so a well-implemented programme detects cleartext secrets in configuration files (a meaningful slice of CWE-313, as several observed CVEs sit in config/properties files); the remainder is bounded and nameable — cleartext sensitive data in non-configuration files such as log files, data files, and arbitrary application storage, which configuration management does not scan.
- CWE-319partialremoves — A.8.9's configuration management can remove some instances of cleartext transmission by reconfiguring services to use encrypted channels, disabling cleartext protocols, and applying templates that require encryption, but it cannot address instances hardcoded in application code or inherent to the product's design where no configuration change can add encryption.
- CWE-319partialfinds — A.8.9's monitoring compares actual configurations against secure templates and surfaces deviations, so it finds CWE-319 instances that manifest as configurable settings (e.g., cloud storage with secure-transfer disabled, services bound to HTTP instead of HTTPS, devices with default cleartext protocols) — but the majority of CWE-319 instances are hardcoded in application code, embedded in protocol design, or live in hardware channels, none of which configuration monitoring reaches.
- CWE-319partialprevents — A.8.9's standard templates and monitoring can enforce service-level settings that require encrypted transmission (e.g., enableHttpsTrafficOnly, TLS-only flags, disabled cleartext protocols), preventing configuration-level instances of CWE-319; however, the majority of cleartext-transmission weaknesses are design decisions hardcoded in application code or protocol choices (the Java URL example, PLC/OT protocol choices, hardcoded HTTP clients), which configuration management does not reach.
- CWE-334partialfinds — A.8.9 monitors configurations against target templates and can detect deviations in configuration-level randomness parameters (e.g., session ID length, key sizes specified in deployment descriptors as in the CWE-334 demonstrative example), but the majority of CWE-334 instances are code-level (PRNG implementation, entropy sources, seed predictability) which A.8.9's configuration-comparison reach does not inspect.
- CWE-419partialremoves — A.8.9's templates can mandate protection of administrative channels (e.g., requiring TLS, disabling plaintext admin protocols), so applying configuration management to a system where the channel was configurable-but-unprotected removes that subset of instances; however, CWE-419 is rooted in an architecture/design omission, and products that fundamentally lack channel-protection capability cannot be remediated by any configuration change, leaving a nameable remainder outside the control's reach.
- CWE-419partialfinds — Configuration monitoring compares actual settings against defined templates, so it can detect instances where channel protection (TLS, authentication, access restrictions) is missing or misconfigured as a setting deviation; however, CWE-419 is introduced at Architecture and Design and Implementation phases, and design-level channel weaknesses where the protection mechanism itself is absent or flawed are outside configuration monitoring's reach.
- CWE-427partialblocks — Configuration management can enforce approved search-path settings but does not inherently prevent the weakness.
- CWE-433partialremoves — A.8.9's configuration templates can specify web server rules (handlers, blocked extensions, restrictions on serving raw content), and applying such templates to an existing system removes instances where the weakness is a server-side configuration gap. The remainder is the development-side half of the weakness — the choice to place raw or sensitive files under the web document root — which configuration management does not reach, since that is a code/deployment decision governed by secure coding rather than by configuration baselines.
- CWE-433partialprevents — A.8.9's standard templates and configuration monitoring can require web server handler mappings for all extensions in use, addressing the server-side half of the weakness; however, the root cause — storing raw content (e.g. .inc files with credentials) under the web document root — is a development and file-placement decision that configuration management touches but does not fully control.
- CWE-497partialblocks — A.8.9's standard templates and monitoring can configure production systems to disable debug mode, suppress verbose error pages, and restrict diagnostic output, blocking some exploitation paths for CWE-497; however, the underlying code defects (stack traces, environment variables, system paths printed by application code) remain present and many instances—particularly in custom code and third-party components—are not reachable through configuration settings alone.
- CWE-520partialremoves — A.8.9's standard-template and monitoring mechanism reaches software configurations including .NET application settings, so where a template specifies secure impersonation settings, monitoring detects deviations and corrective action removes the misconfiguration; the remainder is bounded by templates that do not address this specific .NET setting and by contexts where impersonation is retained with compensating NTFS controls the clause does not evaluate.
- CWE-520partialprevents — A.8.9's standard templates can specify impersonation settings (e.g., disabled by default) and its monitoring catches deviations, preventing many instances; however, the weakness can be introduced at architecture/design or via code-level decisions that configuration management does not review, and some applications legitimately require impersonation, so blanket prevention is not possible.
- CWE-521partialfinds — A.8.9's monitoring section explicitly names 'evaluate password strengths' and compares actual configurations to target templates, so weak password policies that deviate from a hardened template are surfaced; however, CWE-521 also covers design-level absence of strong-password requirements (no policy at all, or a fundamentally weak policy baked into the product), which is not a configuration deviation and falls outside the configuration-comparison reach.
- CWE-523partialremoves — A.8.9's configuration templates can require HTTPS/TLS for authentication endpoints and its monitoring/enforcement loop can detect and correct deviations, so applying it to a system that previously lacked it removes CWE-523 instances that are purely missing HTTPS configuration; the remainder is bounded and nameable -- CWE-523 also arises from improper HTTPS implementation (expired/invalid certificates, mixed content, login forms posting to HTTP from HTTPS pages, application-layer credential handling) that configuration management alone does not reach, and the clause's reach is configuration rather than the application-layer design the weakness is attributed to.
- CWE-525partialblocks — Configuration management can mandate secure browser cache settings across the estate.
- CWE-526partialprevents — A.8.9's secure configuration templates and monitoring can prevent operators from placing unencrypted secrets in environment variables, but it does not reach the product's design and implementation choices that use and expose those variables, so the weakness still arises in code-introduced cases.
- CWE-527partialremoves — A.8.9's configuration monitoring and deviation-correction mechanism can remove instances where the exposure stems from a system configuration (e.g., a web server document root serving a .git directory), but the weakness also arises from archive composition, insecure transfer, and improper sharing permissions, which sit outside the clause's configuration-management reach.
- CWE-527partialblocks — A.8.9's standard templates and configuration monitoring can block exploitation via web server misconfigurations that serve .git/.svn/CVS directories (a common CWE-527 vector), but the weakness also arises through archives, backups, and shared storage that configuration management does not comprehensively reach.
- CWE-528partialfinds — Configuration monitoring compares actual settings against target templates, so a template that addresses core dump generation, location, or directory permissions will surface deviations; the remainder is bounded and nameable — systems whose templates omit core-dump settings, unmanaged systems, and instances where the exposure stems from a design omission the template never captured.
- CWE-529partialblocks — Configuration management can enforce ACL file permissions but does not address the weakness directly.
- CWE-529partialfinds — A.8.9's monitoring compares actual configurations against defined target templates and addresses deviations, so where the secure configuration template explicitly specifies storage locations and access permissions for sensitive files like ACLs, deviations are surfaced; however, CWE-529 is fundamentally about file/directory permissions on specific data files, which is not the primary focus of configuration management monitoring (which targets system/service security settings, privileged access, disabled functions, password strengths), so only a minority of instances are caught when the template happens to cover this artefact.
- CWE-535partialblocks — Configuration management can suppress shell error display (e.g., disabling verbose error reporting, configuring custom error handlers, restricting shell access), which blocks exploitation through the visible error channel, but the underlying unhandled-exception code defect remains and many error paths (custom error pages that still leak detail, accessible logs, debug modes) are outside what configuration alone reaches.
- CWE-540partialblocks — Configuration management can harden server and repository settings so source-code files such as .inc or backup files are not served to users, but it cannot block exploitation of sensitive data embedded in client-side code, HTML comments, or rendered pages where access is intended.
- CWE-541partialblocks — A.8.9's standard templates for secure configuration of software and services could include web server hardening that blocks direct serving of include files (e.g., .inc) or restricts access to include directories, but this is implementation-dependent and the weakness is primarily a coding defect (storing credentials in include files) that configuration management does not reach.
- CWE-550partialremoves — A.8.9's standard templates and configuration enforcement can suppress server-level error message display (custom error pages, disabling debug mode, generic production responses), which removes the visible manifestation of the weakness at the server tier; however, the underlying code defect — the application logic that places sensitive information into error messages — is not rewritten by configuration management, and application-level error handling, internal logs, and stack traces that bypass server configuration remain as a nameable remainder.
- CWE-550partialblocks — Configuration management templates can include settings that suppress verbose error messages at the web/application server level (production mode, custom error pages, disabled debug output), which blocks exploitation even where the underlying code still generates sensitive details; however, custom application code that explicitly embeds sensitive data in error messages is outside the reach of configuration templates, leaving a nameable remainder.
- CWE-552partialprevents — A.8.9's standard templates include access controls for files, directories and cloud storage, and the clause permits automatic enforcement of the target template, so a well-implemented system prevents most misconfigurations that would expose files/directories to external parties; the remainder is bounded and nameable — files/directories in components or services outside the managed template set, or configurations changed outside the change-management process before the next monitoring cycle.
- CWE-552partialfinds — A.8.9's monitoring of actual configurations against defined templates directly surfaces the configuration-level instances of CWE-552 — cloud storage public-access flags, web-server directory permissions, and file/directory access modes — which constitute the bulk of the weakness class; the remainder is application-level decisions about which files to package under a web root or into archives, which a configuration baseline does not reach.
- CWE-600partialblocks — A.8.9's configuration templates for software (including Servlet containers) can be set to suppress detailed error responses in production, blocking the specific exploitation of stack-trace disclosure; however, the clause's enumerated guidance items (a–h) do not address error-page configuration, the code defect (missing catch block) remains, and only a well-implemented template reaches this — a minority of instances.
- CWE-613partialremoves — A.8.9's configuration templates can specify session timeout values (e.g., web server, application server session-timeout settings) and enforce them on operational systems, removing configuration-level instances of CWE-613 such as the demonstrative web.xml `<session-timeout>-1</session-timeout>` case. However, many CWE-613 instances are code-level defects — SDKs that never set token expiration, custom session handlers without expiration logic, or improper logout invalidation — which configuration management cannot rewrite, leaving a nameable remainder of the weakness class untouched.
- CWE-613partialprevents — A.8.9 item (g) on time-out facilities and the standard-templates/monitoring mechanism can enforce session-timeout settings where they exist as configuration (e.g., web.xml session-timeout), preventing the 'no timeout configured' variant; but the weakness also covers code-level session lifecycle issues — sessions not invalidated on logout, session fixation, flawed expiration logic — which configuration management does not reach.
- CWE-613partialfinds — A.8.9 monitors configurations against target templates and would catch session-timeout values that deviate from a secure baseline (e.g., session-timeout = -1 in web.xml), but it does not read code, so it misses the larger share of CWE-613 instances that live in session-management logic — sessions not invalidated on logout, session fixation, custom token handling without expiry — which are code-level defects outside configuration management's reach.
- CWE-62partialblocks — Configuration management can block some hard-link exploitation through hardening such as least privilege, disabling unnecessary services, restricting access to powerful utilities, and setting host parameters like kernel hard-link protection, but it does not stop a required vulnerable program from following hard links in code.
- CWE-693partialfinds — A.8.9's configuration monitoring reaches protection mechanism failures that manifest as configuration deviations (missing or insufficient security settings, default-disabled protections), but its reach is runtime configuration comparison, not source inspection or behavioral testing, so it does not find the code-level and architectural instances where a mechanism exists but is not applied in some path.
- CWE-7partialprevents — A.8.9's standard templates for secure software configuration could include web application server settings that govern error page behavior, and a well-implemented programme would likely catch some instances, but the custom error page is an application-level setting (in web.xml or equivalent) that typically falls outside the infrastructure-focused templates the clause mandates, and the clause does not name error pages explicitly.
- CWE-7partialfinds — A.8.9's monitoring compares actual configurations to defined target templates and addresses deviations, so a missing custom error page is found when the secure configuration template for J2EE applications explicitly includes custom error page settings; however, A.8.9's monitoring reach is primarily system/infrastructure-level (maintenance utilities, enterprise management tools), and application-level misconfigurations like CWE-7 are not always within the managed configuration set or explicitly covered in templates, leaving a nameable remainder of instances the programme does not see.
- CWE-708partialremoves — A.8.9's template-and-monitor mechanism can detect and correct existing ownership deviations for statically configured resources (installed files, configuration files in known locations) where ownership is specified in the secure template, but CWE-708 is predominantly a code-defect class — code that creates resources with wrong ownership at runtime — which A.8.9 does not reach, so only a minority of instances are removed.
- CWE-756partialremoves — A.8.9's mechanism (standard templates applied to systems, with deviations corrected) can remove CWE-756 where the organization's template includes custom error page configuration for web applications, since the weakness is a configuration issue squarely within the clause's scope of 'software' configurations. However, the explicit template items listed in the clause (privileged access, identity disabling, function restriction, clock sync, default auth changes, timeouts, licensing) are system-level settings and do not name error page handling, so coverage depends on organizational implementation choices rather than being guaranteed by the clause's text.
- CWE-756partialprevents — A.8.9's standard templates and monitoring can include custom error page configuration (e.g., ASP.NET <customErrors>, Java container settings) based on publicly available guidance, preventing the weakness for systems under its management, but the control's enumerated items (a)-(h) do not specifically address custom error pages, so prevention depends on the organization's templates including this item, leaving applications outside the managed configuration set or configured before the template was updated as a nameable remainder.
- CWE-757partialfinds — A.8.9 monitors configurations against target templates and would find instances where a system is configured to permit weak algorithms (e.g., SSL/TLS cipher lists that allow downgrade), but it does not read protocol negotiation logic, so the majority of CWE-757 instances — those embedded in the implementation's negotiation behavior regardless of configuration — are outside its reach.
- CWE-757partialblocks — A.8.9 can block exploitation of algorithm downgrade by enforcing configuration templates that disable weak algorithms (e.g., restricting TLS cipher suites), but the underlying code defect in the negotiation logic remains, and configuration enforcement does not reach all instances — protocols with hardcoded negotiation behavior, third-party components, or configurations outside the managed template set are not addressed.
- CWE-774partialblocks — A.8.9's standard templates can include OS-level resource limits (ulimits) under guidance item (d) on host parameter settings, which would block the catastrophic exploitation of file descriptor exhaustion at the system level; however, the application-level flaw (the code not imposing its own limits) remains present, and the clause's primary focus is configuration baselines rather than resource throttling, so only a portion of exploitation paths are blocked.
- CWE-778partialremoves — A.8.9 enforces configuration templates and can address CWE-778 instances that are configuration-driven (e.g., Azure storage logging settings, WCF serviceSecurityAudit, default service configurations), so applying it where it was not applied before removes those existing flaws; however, code-level logging omissions (e.g., the Java example where the developer simply did not write a log statement) are outside configuration management's reach, leaving a nameable remainder.
- CWE-778partialprevents — A.8.9's templates and configuration monitoring can require logging to be enabled and properly configured (addressing the configuration-related subset of CWE-778, such as Azure's default-disabled logging or the WCF audit-suppression case), but the weakness is fundamentally about the product's recording behaviour — code that lacks logging calls or omits important event details cannot be fixed by configuration management, so the code-level majority of instances is outside A.8.9's reach.
- CWE-778partialfinds — A.8.9's configuration monitoring compares actual settings to target templates, so it finds configuration-level instances of CWE-778 (logging disabled or set to insufficient levels, as in the Azure and WCF examples), but it does not reach code-level instances where the code itself fails to log or omits important details (as in the Java and CVE-2008-4315 examples); since CWE-778 spans both, A.8.9 finds a minority share.
- CWE-782partialblocks — A.8.9 can harden device, service, and identity configurations and disable or restrict unnecessary functions, which blocks some exposure of a vulnerable IOCTL, but it does not enforce the IOCTL's internal per-request access control, so any required or still-reachable interface remains exploitable.
- CWE-842partialremoves — A.8.9's monitoring-and-correction mechanism (compare actual to target template, address deviations) removes instances where incorrect group membership is a configuration deviation captured in the template and detected by monitoring; it does not remove product-code defects that place users into wrong groups (CVE-2007-3260, CVE-2002-0080) or cases where group membership is not tracked as a configuration item.
- CWE-842partialfinds — A.8.9's monitoring compares actual configurations against target templates and addresses deviations, so it can find group-membership assignments that deviate from a defined template; however, templates rarely enumerate individual user group memberships, many CWE-842 instances are product bugs (the product itself assigns users to wrong groups) rather than configuration states, and the 'incorrect' is often a security-policy violation invisible to template comparison — leaving a nameable remainder the clause does not reach.
- CWE-9partialremoves — A.8.9's monitoring/configuring section requires deviations from target templates to be addressed by automatic enforcement or manual corrective action, which is a removal mechanism for existing misconfigurations; however, EJB method permissions in deployment descriptors are a specific application-level concern that may or may not be covered by the organization's configuration templates, and the deployment descriptor is typically baked into the application archive requiring redeployment rather than runtime correction.
- CWE-942partialprevents — A.8.9's standard templates provision could include secure CSP/cross-domain policy configurations as part of defined secure configurations for web services, preventing the permissive policy from being written; however, the clause's enumerated template items (a–h) all address OS/service-level settings (privileged identities, default passwords, timeouts, etc.), not web security policies, so coverage depends on the organization's implementation choices rather than being mandated by the clause.
- CWE-97partialblocks — Configuration management can block SSI exploitation by establishing templates that disable SSI processing at the web server level (per guidance item c on disabling unnecessary functions/services), so directives are never executed regardless of the code defect; however, this only applies where SSI is disabled, many applications legitimately require SSI, and the application-level neutralization defect remains, leaving a nameable remainder of exploitable instances.
- CWE-98partialblocks — A.8.9's standard templates can include PHP runtime hardening (allow_url_include=Off, open_basedir, disable_functions) that blocks the remote-inclusion variant of CWE-98, but local file inclusion via path traversal and configurations outside the template remain exploitable, leaving a nameable remainder.
Mitigated MITRE ATT&CK techniques (3266)
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
- T1078.001fullprevents — A.8.9 explicitly requires changing vendor default authentication information (e.g. passwords) immediately after installation, defining/reviewing secure configuration templates that disable unnecessary accounts/identities and restrict privileges, and enforcing those templates over the asset lifetime, which stops most default-account abuse vectors named in the technique.
- T1037.003mostlydetects — A.8.9 requires configurations to be monitored, recorded and compared against standard templates, so an unauthorized network logon script assignment would surface as a configuration deviation, though script content changes that leave the assignment unchanged can evade this detection.
- T1098.003mostlydetects — A.8.9's configuration monitoring compares actual cloud IAM configurations against defined templates and flags additional roles or permissions as deviations, though periodic review rather than continuous alerting leaves a detection window.
- T1530mostlyprevents — A.8.9 directly addresses the misconfiguration vector that T1530's own description identifies as the common problem (public access, overly-broad access, anonymous access) by mandating secure configuration templates for cloud services and monitoring deviations; however, it does not prevent the credential-leakage vector explicitly named in the technique, leaving a bounded remainder.
- T1543mostlyprevents — Requiring documented, change-controlled configurations for system services and processes limits an adversary’s ability to create or modify persistent system-level processes without detection.
- T1543mostlydetects — A.8.9 explicitly requires monitoring configurations with management tools, regular reviews, comparison against secure templates, and addressing deviations, which surfaces unauthorized or anomalous creation/modification of system processes/services/daemons (the core of T1543) on managed assets.
- T1543.003mostlydetects — A.8.9 explicitly requires monitoring configurations with management tools, regular reviews, comparison against secure templates, and addressing deviations, which surfaces unauthorized or anomalous Windows service creations/modifications (including Registry changes) after they occur.
- T1552.006mostlyprevents — A.8.9 requires disabling unnecessary or insecure identities and changing vendor default authentication information immediately after installation, which directly prevents the embedded credentials that T1552.006 exploits from being present in Group Policy Preferences in the first place.
- T1556.005mostlyprevents — A.8.9's standard templates explicitly require reviewing and disabling insecure default security-related parameters (clause f), and `AllowReversiblePasswordEncryption` is disabled by default — a baseline that enforces this and monitors for deviations prevents the technique from being exploitable in the steady state. The remainder is that an adversary with sufficient privileges (e.g., via FGPP or Set-ADUser) can re-enable the property, and legacy software requirements may necessitate enabling it, so the control cannot reach `full`.
- T1557.001mostlyprevents — A.8.9's guidance to disable or restrict unnecessary functions and services directly enables disabling LLMNR/NBT-NS via Group Policy/configuration baselines, which removes the poisoning surface; mDNS is harder to disable fully, configuration drift can re-enable services, and coverage depends on implementation across all systems, so the prevention is strong but not complete.
- T1559.002mostlyprevents — A.8.9's standard templates can disable DDE via registry keys (Microsoft's own ADV170021 recommends this), and the clause's monitoring and enforcement keep that setting in place; however, the DDE protocol still exists in the Windows/Office binaries and can be re-enabled by configuration drift, by applications that require it, or by an actor with sufficient privileges, so the prevention is not the complete removal that earned A.8.9 vs T1078.001 a `full`.
- T1569mostlyprevents — Templates that disable or tightly control system services and utilities constrain adversaries from leveraging service execution as a stealthy or persistent execution mechanism.
- T1569mostlydetects — A.8.9's monitoring of configurations, comparison against secure templates, and review of activities/deviations (including disabled services, unnecessary functions, privileged access, and change logs) surfaces abuse of system services/daemons both at setup and in operation across the covered platforms.
- T1574.009mostlyprevents — A.8.9's secure-configuration templates, restriction of unnecessary services/functions, and monitoring-with-automatic-enforcement directly address the misconfiguration that enables T1574.009 (unquoted service/shortcut paths); a well-implemented baseline that mandates quoted paths and detects deviations leaves little room for the technique, but the clause does not enumerate path quoting explicitly and third-party software installations can reintroduce the weakness outside the template's reach.
- T1574.011mostlyprevents — A.8.9's standard templates explicitly require restricting access to host parameter settings and minimizing privileged access rights, which when properly implemented would specify tight ACLs on HKLM\SYSTEM\CurrentControlSet\Services keys, removing the permissions weakness the technique exploits; the monitoring and deviation-correction clauses catch drift, but the control is a framework that sets requirements rather than mandating every specific registry key's ACL, so a bounded remainder of implementations leaves some service keys reachable.
- T1600.001mostlydetects — A.8.9's monitoring component explicitly compares actual configurations against defined target templates and addresses deviations, which is the mechanism that surfaces an unauthorized reduction in cipher key size on a network device; the bounded remainder is that detection depends on the target template specifying the expected key strength and on the network device being within the scope of the configuration monitoring tools, and a deeply compromised device image (T1601) could in some cases evade the comparison.
- T1602.002mostlydetects — A.8.9's monitoring of configurations with management tools, regular reviews, deviation detection against templates, and logging of changes directly surfaces an adversary's access or export of a network device configuration (via SNMP, SMI, or similar), which is observable as anomalous configuration activity on the monitored asset.
- T1685.001mostlydetects — A.8.9's monitoring of configurations, comparison against secure templates, and review of activities/deviations (including via system management tools and logs of changes) surfaces unauthorized or anomalous modifications to EventLog service, registry keys, auditpol settings, or related configs that implement the technique.
- T1685.002mostlydetects — A.8.9's configuration monitoring compares actual cloud service settings against defined secure templates, so disabling or modifying cloud logging surfaces as an unauthorized configuration deviation, though periodic review and the need for logging settings to be templated leave it short of complete.
- T1686mostlydetects — A.8.9's configuration monitoring — comparing actual configurations against defined target templates and logging configuration changes — detects firewall rule modifications and disabling as configuration deviations in most implementations where firewall configs are part of the standard templates; the remainder is scope (firewall configs not included in monitored templates) and evasion by sufficiently privileged adversaries who can tamper with the monitoring itself.
- T1686.001mostlyprevents — A.8.9 mandates standard templates that disable unnecessary services and restrict access, and monitors configurations to enforce the defined target, so a cloud firewall rule that deviates from the template is either prevented from being introduced or automatically reverted; the remainder is the window between a manual change and the next monitoring review where the deviation exists before correction.
- T1686.003mostlydetects — A.8.9 explicitly requires monitoring configurations with management tools, regular reviews, comparison against target templates, and addressing deviations, which surfaces unauthorized firewall changes on Windows hosts as configuration drift.
- T1686.003mostlyrecovers — Configuration management processes and tools automatically or manually enforce the defined target configuration, restoring the Windows host firewall settings to their approved baseline after an adversary modifies them.
- T1003partialprevents — A.8.9's templates can restrict access to powerful utility programs, minimize privileged identities, and configure credential-protection settings (e.g., WDigest, LSASS protection), which constrains T1003, but the OS must still store credentials in memory for legitimate use, so an adversary with admin access can often dump them regardless of configuration — a named remainder, not a closure.
- T1003.001partialprevents — Configuration management can disable WDigest, configure Credential Guard, restrict access to debugging/dumping tools, and limit who holds the SYSTEM or debug privileges the technique requires, but LSASS must run and process credentials for the system to function, and an attacker with sufficient privileges can still read its memory using built-in Windows tools, so the technique is constrained rather than eliminated.
- T1003.003partialprevents — A.8.9 can restrict access to powerful utilities (ntdsutil.exe), limit privileged identities, and harden ACLs on NTDS.dit, but the file must exist for AD to function and any account with legitimate DC admin rights can still extract it, so the technique is constrained rather than eliminated.
- T1003.004partialprevents — Configuration management reduces the attack surface for LSA Secrets dumping by minimizing privileged identities (item a), restricting access to powerful utilities (item d), and disabling unnecessary services that would store credentials in LSA secrets, but it cannot prevent the technique once SYSTEM access is obtained since LSA secrets are a fundamental Windows mechanism readable by any SYSTEM-level process.
- T1003.005partialprevents — A.8.9 can reduce the attack surface by minimizing privileged access (limiting who can reach SYSTEM/sudo), restricting powerful utilities like Mimikatz/secretsdump, and reducing the number of cached credentials stored, but cached domain credentials are a required feature for offline authentication and cannot be eliminated without breaking functionality, so once SYSTEM access is obtained the technique remains viable.
- T1003.006partialprevents — A.8.9's provisions for disabling unnecessary identities and restricting access to powerful utilities can remove some attack surface (stale accounts with replication rights, unnecessary service accounts), but DCSync abuses a legitimate AD replication API and fundamentally requires Domain Admin/Enterprise Admin membership — accounts that are typically necessary and cannot be removed by configuration management alone.
- T1003.007partialprevents — Configuration management reduces the attack surface by limiting privileged accounts (minimizing who can read other processes' /proc memory) and by configuring services to minimize cleartext credential storage, but the proc filesystem is a fundamental kernel interface that cannot be removed or disabled, and any process can always read its own virtual memory, so the technique remains available to a sufficiently privileged adversary.
- T1003.008partialprevents — Configuration management can enforce restrictive permissions on /etc/shadow (root-only readable), minimize privileged identities, and restrict access to utility programs, which prevents non-root reads and reduces attack surface; however, the files must exist for the system to function, and a root-level adversary — the primary scenario for this technique — can still read them regardless of configuration, so prevention is partial.
- T1005partialprevents — A.8.9 can disable or restrict unnecessary functions, services and powerful utility programs that aid local data search, but it cannot remove the built-in OS interpreters and file-reading tools (cmd, PowerShell, cat, grep) that T1005 explicitly relies on, and it does not address the access prerequisite that makes the search possible.
- T1006partialprevents — Configuration management can restrict specific utilities used for direct volume access (vssadmin, wbadmin, esentutl), apply least privilege to limit who can perform raw disk operations, and disable unnecessary functions — but the technique exploits a fundamental OS capability (raw volume I/O) that legitimate admin operations require, and adversaries can write custom code or use other built-in tools, so the technique cannot be fully prevented.
- T1011partialprevents — Configuration management can disable unused or insecure network interfaces (Bluetooth, cellular modems, secondary WiFi adapters) and restrict host parameters, which prevents exfiltration over those specific mediums; however, the technique spans many alternative channels, some of which may be legitimately required (primary WiFi, wired secondary NICs), and configuration management does not address physical-proximity access or runtime enforcement against an adversary who has already compromised the host.
- T1011.001partialprevents — A.8.9 includes disabling or restricting unnecessary functions and services, so where Bluetooth is disabled on systems where it is not needed the technique cannot run; however, Bluetooth is often a required function (peripherals, mobile devices), the technique presupposes prior compromise, and even restricted Bluetooth configurations may still permit exfiltration to a paired device within range, so the prevention is a slice rather than a closure.
- T1014partialprevents — Configuration management reduces rootkit attack surface by disabling unnecessary services, restricting powerful utilities, and minimizing privileged access, but cannot prevent rootkits that gain kernel-level access through exploits or other vectors, since the technique operates below the layer configuration management governs.
- T1018partialprevents — Configuration management can restrict some discovery utilities (ping, net view) via host firewall rules, Group Policy, and disabling unnecessary services, and can apply network segmentation that limits what is discoverable, but the underlying OS functionality (ARP cache, hosts file, built-in network utilities) is required for normal operation and cannot be removed without breaking the system, so the technique still runs through alternative means.
- T1020.001partialdetects — A.8.9's configuration monitoring compares actual configurations against target templates and logs changes, so enabling traffic mirroring where the baseline excludes it surfaces as a deviation; however, abuse of legitimately configured mirroring features, malicious firmware/ROM modifications (ROMMONkit, Patch System Image), and cloud mirroring set up within an approved template are not visible to configuration-comparison monitoring, leaving a substantial remainder.
- T1020.001partialprevents — A.8.9 prevents the configuration-based vectors of T1020.001 by disabling unnecessary traffic mirroring features, restricting who can modify network device and cloud configurations, and monitoring for unauthorized configuration changes — but it does not reach firmware-level abuse (ROMMONkit, system image patching) which sits below the configuration layer, and cloud traffic mirroring APIs depend on IAM controls outside A.8.9's scope.
- T1021partialprevents — A.8.9 can disable or restrict unnecessary remote services (SSH, RDP, VNC) and change vendor defaults, which prevents the technique where those services can be removed; but in enterprise environments remote services are typically required for legitimate administration, and configuration management does not address the valid-credential precondition the technique exploits, so where the service must remain enabled the technique still runs.
- T1021.001partialprevents — A.8.9's templates can disable or restrict RDP on systems where it is not required (workstations, user endpoints) and can restrict which accounts may use it, but RDP is a legitimately required service on servers and admin hosts and cannot be removed there — and those are the systems the technique targets, so what is prevented is a slice rather than the bulk.
- T1021.002partialprevents — Configuration management can disable admin shares (C$, ADMIN$, IPC$) via security templates and restrict which accounts hold administrator privileges, removing the specific vector the technique names; however, SMB is a core Windows protocol that cannot be eliminated on systems requiring it, non-admin file shares remain abusable for lateral movement, and valid credentials on any account with share access still permit the technique's broader use of remote network shares.
- T1021.003partialprevents — A.8.9 can restrict DCOM through secure templates (disabling unnecessary functions/services, restricting access to powerful utilities, ACL hardening of COM objects), but DCOM is a core Windows component often required for legitimate operations and cannot be fully removed without breaking functionality; the technique also depends on valid accounts, which is outside this control's scope, so what is prevented is a slice rather than the bulk.
- T1021.004partialprevents — A.8.9 can disable SSH where not needed and harden its configuration (restrict to specific users, disable password auth, enforce key-based), but where SSH is legitimately required for administration the technique still runs against valid credentials — configuration management constrains the surface but cannot prevent a valid account from authenticating over a service the organisation has chosen to keep enabled.
- T1021.005partialprevents — Configuration management can disable or restrict VNC where it is not needed and harden its authentication, but VNC is often a legitimately required remote-access tool, and the technique explicitly relies on valid accounts — so where VNC is operationally required, properly configured VNC remains usable by anyone holding valid credentials, and configuration management cannot prevent that.
- T1021.006partialdetects — A.8.9's configuration monitoring can detect deviations from the secure template (e.g., WinRM enabled when the template requires it disabled, or unauthorized changes to WinRM configuration), but it does not detect the actual use of WinRM by an adversary with valid credentials — the core of T1021.006 — which requires authentication, session, or command-execution telemetry that A.8.9 does not provide.
- T1021.006partialprevents — A.8.9's templates can disable or restrict the WinRM service on systems where it is not needed, and can remove default accounts that might be abused, but where WinRM is legitimately required for administration and the adversary holds valid (non-default) credentials, the technique still runs — so prevention is a slice, not the bulk.
- T1021.008partialprevents — Configuration management can disable or restrict cloud-native VM access services (Azure Serial Console, EC2 Instance Connect, Systems Manager) and limit which accounts may use them, but the technique specifically leverages valid accounts and these services are often needed for legitimate operations, so the technique can still execute against authorized identities and the control cannot reach full prevention.
- T1025partialprevents — A.8.9's configuration baseline can disable or restrict removable media access (under 'disabling unnecessary functions and services' and restricting powerful utilities), which prevents T1025 from running where implemented; however, the clause does not specifically mandate this, removable media access is often required for business, and the adversary is already on the system and may re-enable or bypass the restriction.
- T1027.004partialprevents — A.8.9's guidance to disable or restrict unnecessary functions and services can remove compilers from systems where they are not legitimately needed (servers, user workstations), preventing the technique there; however, developer systems require compilers, and adversaries can bundle their own compilation frameworks, so the technique remains executable on a meaningful slice of the estate.
- T1036.004partialdetects — A.8.9's monitoring of configurations against target templates detects the existence of new or changed tasks/services as deviations from the baseline, but it does not semantically analyze whether a task/service name is designed to appear legitimate — the masquerading aspect itself is not what configuration comparison surfaces, only the unauthorized configuration item is.
- T1036.007partialprevents — A.8.9's configuration management framework could be used to set the Windows shell policy that hides known file extensions to disabled, which would prevent the masquerading, but the control does not explicitly mandate this specific setting and the technique is a display-behavior issue rather than a service or function the clause directly addresses.
- T1036.010partialdetects — A.8.9's monitoring of configurations against target templates can detect unauthorized account creation as a deviation from the defined baseline, but it does not specifically detect the masquerading nature of the name choice — an account named to match a legitimate service account or use a generic trustworthy name may not be flagged if similar names exist in the template, and the clause's mechanism is configuration-comparison rather than identity-behavior analysis.
- T1037partialdetects — A.8.9's monitoring component compares actual configurations against target templates and addresses deviations, so unauthorized additions to boot/logon script locations covered by the template are detected as configuration drift; however, the clause sets scope through the template rather than mandating coverage of every startup mechanism, and not all T1037 sub-techniques or locations (e.g. user-level logon hooks, network device boot configs) are necessarily enumerated, leaving a bounded remainder.
- T1037partialprevents — A.8.9's standard templates can disable unnecessary identities and restrict unnecessary functions, which may block some initialization script mechanisms, but the control cannot prevent scripts required for legitimate administrative functions from being abused.
- T1037partialrecovers — Configuration management tools can automatically revert unauthorized modifications to managed boot and logon scripts back to their defined baseline, though malicious scripts placed in unmanaged user profiles may not be overwritten.
- T1037.001partialdetects — A.8.9's monitoring clause compares actual configurations against defined target templates and addresses deviations, so a baseline that includes the UserInitMprLogonScript Registry key would surface an unauthorized addition; however, the clause sets scope through the organization's chosen templates rather than mandating Registry coverage, so a fully conformant implementation focused on network and OS service configs would miss this Registry-based persistence.
- T1037.001partialprevents — Configuration management can restrict who may modify the UserInitMprLogonScript registry key, monitor for unauthorized additions, and enforce templates that lock down logon-script settings, but the logon-script mechanism itself is a legitimate Windows feature that cannot be removed, so an attacker with appropriate access can still establish persistence via this path.
- T1037.002partialdetects — A.8.9's monitoring clause explicitly compares actual configurations against target templates and addresses deviations, which would surface unauthorized changes to com.apple.loginwindow.plist if that file is in the monitored baseline; however, the clause sets a process rather than mandating specific files, and login hooks are deprecated in macOS 10.11+, so faithful implementations may not include this plist in their template scope, leaving detection dependent on implementation choice.
- T1037.002partialprevents — A.8.9's configuration management can prevent a login hook by enforcing a secure baseline that removes the plist or restricts write access, but the technique is deprecated and the control's monitoring and review processes are more likely to detect deviations than to prevent the initial modification on every system.
- T1037.003partialprevents — Configuration management can restrict who can create or modify logon scripts (privileged access controls, change management) and detect unauthorized additions via baseline comparison, but logon scripts are a legitimate AD/GPO feature that cannot be removed without breaking operations, and any admin permitted to author scripts retains the capability — so the technique is constrained, not closed off.
- T1037.004partialprevents — A.8.9's configuration templates, monitoring, and automatic enforcement of target configurations can constrain and detect unauthorized modifications to RC scripts, but the technique requires root privileges which A.8.9 does not control, and RC scripts are often necessary for system operation so they cannot simply be disabled like default accounts can.
- T1037.005partialdetects — A.8.9's monitoring of configurations compares actual state against defined target templates and addresses deviations, so unauthorized additions to /Library/StartupItems would surface as configuration drift if that directory is included in the baseline; however, the clause sets the scope of what is monitored rather than mandating coverage of every persistence location, and the deprecated nature of StartupItems means it is often outside the standard template.
- T1037.005partialprevents — A.8.9's configuration templates can disable unnecessary startup items and restrict write access to the StartupItems directory, but the control's scope is broad and does not guarantee this specific mechanism is addressed on every macOS system.
- T1039partialprevents — Configuration management can disable or restrict unnecessary file-sharing services, restrict access to powerful utility programs used to browse shares, and apply least-privilege templates that limit which systems mount network shares, but it cannot prevent the technique when the compromised system legitimately requires share access — the adversary inherits those permissions and the share-side ACLs (not local configuration) govern what is reachable.
- T1040partialprevents — Configuration management can disable promiscuous mode on endpoints, restrict packet-capture utilities, and harden network device configurations to limit span-port abuse, but it cannot prevent sniffing that occurs via compromised network infrastructure, cloud traffic-mirroring services, or AiTM positions, and it does not address encryption of traffic in transit (which is A.8.24's domain).
- T1047partialprevents — A.8.9 can restrict some WMI attack vectors — disabling remote WMI (DCOM/port 135, WinRM/5985-5986), restricting wmic.exe execution, and limiting who can invoke WMI — but WMI is a core Windows administration infrastructure the platform requires and cannot be removed, and adversaries can reach it through PowerShell, COM APIs, and wbemtool.exe, so what is prevented is a slice rather than the technique itself.
- T1048partialprevents — A.8.9's templates can disable or restrict unnecessary protocols and services (e.g., FTP, SMB, telnet) and powerful utilities, removing those specific exfiltration channels, but the technique's core vectors — HTTP/S, DNS, and cloud/web console APIs — are essential services that configuration management cannot disable, so only a slice of the technique is prevented.
- T1048.003partialprevents — A.8.9's templates can disable or restrict unnecessary protocols and services (e.g., FTP, Telnet, SMB) and constrain powerful utilities used to stage exfiltration, but the protocols most commonly abused here (HTTP, DNS) are typically required for legitimate operations and cannot be removed, so the technique is reduced rather than eliminated.
- T1052partialprevents — A.8.9's template requirements include disabling or restricting unnecessary functions and services, which can be applied to disable USB ports and removable storage, preventing the technique's execution on configured systems; however, the clause is general-purpose rather than specifically aimed at physical media, physical-access scenarios can bypass configuration controls, and the technique spans multiple physical media types not all uniformly addressed by standard templates.
- T1052.001partialprevents — Configuration management can disable or restrict USB ports and removable storage through endpoint configuration (Group Policy, MDM, registry settings), which prevents the technique, but the control is general-purpose and does not specifically mandate USB restriction; USB is often a legitimate function that cannot simply be disabled, and air-gapped scenarios specifically involve USB use, so the prevention is a slice the implementer chooses rather than a complete mechanism.
- T1053partialdetects — A.8.9's configuration monitoring compares actual configurations against target templates and addresses deviations, so unauthorized scheduled tasks can be surfaced as configuration drift if scheduled tasks are within the monitored baseline; however, detection is incidental to the control's primary purpose of ensuring correct configuration, and an implementation that does not include scheduled tasks in its baseline — or that reviews periodically rather than continuously — is fully conformant yet sees nothing of the abuse.
- T1053partialprevents — A.8.9 can restrict access to scheduling utilities, disable unnecessary scheduling services, and harden scheduler configurations, but task scheduling is a core OS function that cannot be entirely removed — administrators legitimately need it, and adversaries with admin-level access (which T1053 explicitly requires for remote scheduling) can still use it, so what is prevented is a constrained slice rather than the technique itself.
- T1053.002partialprevents — A.8.9's templates can disable or restrict the `at` utility (a powerful utility program) and configure `at.allow`/`at.deny`, which prevents the technique via that binary; however, the technique has alternative paths (WMI `Win32_ScheduledJob`, `schtasks`) that configuration management does not directly address, and `at` may be needed for legitimate scheduled tasks on systems where it cannot be fully removed.
- T1053.003partialdetects — A.8.9's configuration monitoring compares actual configurations against target templates and logs configuration changes; if crontab files are included in the monitored baseline, unauthorized cron entries surface as deviations, but the control's scope is set by what the organization chooses to baseline rather than mandating cron-specific monitoring, so detection is a slice rather than a bounded remainder of a working mechanism.
- T1053.003partialprevents — Configuration management can restrict cron access (cron.allow/cron.deny, file integrity monitoring on crontab files, restricting privileged access per A.8.9's guidance on disabling unnecessary identities and restricting powerful utilities), but cron is a core OS utility that cannot be removed from Linux/macOS/ESXi systems, and adversaries with sufficient privileges can still create cron jobs — the same shape as CM-7 vs T1059.
- T1053.005partialdetects — A.8.9's monitoring of configurations against target templates can surface unauthorized scheduled task creation as a deviation, but the control's scope is configuration settings rather than security event detection, and the technique's 'hidden' task methods (SD registry value deletion, metadata tampering) evade standard enumeration that configuration monitoring relies on.
- T1053.005partialprevents — Configuration management can restrict who may create scheduled tasks (via security templates, group policy, and disabling/limiting the schtasks utility and Task Scheduler access), preventing unauthorized users from abusing the technique, but the Task Scheduler is a core Windows component required for legitimate operation and reachable from SYSTEM/administrator contexts and via WMI/PowerShell, so the capability cannot be removed and a bounded remainder of uses persists.
- T1053.006partialdetects — A.8.9's monitoring of configurations against defined templates can detect unauthorized .timer files appearing in monitored paths like /etc/systemd/system/ or /usr/lib/systemd/system, but the scope is set by what the organization includes in its baseline rather than mandated by the clause; user-level timers in ~/.config/systemd/user/ and modifications to existing authorized timers fall outside what a conformant implementation necessarily sees.
- T1053.006partialprevents — Configuration management can restrict write access to systemd timer paths, define baselines excluding unauthorized timers, and monitor for deviations, but systemd is a core OS component whose timer mechanism cannot be removed — analogous to the CM-7 vs T1059 anchor where the platform-required mechanism stays reachable, so what is prevented is a slice rather than the bulk.
- T1053.007partialdetects — A.8.9's monitoring of configurations against target templates can detect an unauthorized CronJob as a deviation from the approved Kubernetes configuration baseline, but the control's scope is configuration settings and security parameters rather than comprehensive resource-creation monitoring, so detection depends on whether container orchestration resources fall within the implemented configuration management scope.
- T1053.007partialprevents — Configuration management restricts who can create CronJobs (privileged access minimization), applies security policies that can block unauthorized job creation, and monitors for deviations — but the scheduling functionality is core to Kubernetes and cannot be removed without breaking the platform, and an attacker with sufficient privileges can still create jobs, so what is prevented is a slice rather than the bulk.
- T1055.008partialprevents — A.8.9 can restrict ptrace through Yama LSM (ptrace_scope), CAP_SYS_PTRACE removal, and security-module profiles, but ptrace is a fundamental Linux kernel feature that cannot be fully disabled without breaking legitimate debugging and system functions, and a sufficiently privileged actor can still invoke it.
- T1055.009partialprevents — Configuration management can restrict access to tools like dd, apply /proc mount restrictions (e.g., hidepid), and limit capabilities, but /proc is fundamental to Linux operation and cannot be removed, and the technique can use various utilities beyond dd, so what is prevented is a slice rather than the bulk.
- T1056.001partialdetects — Configuration management's monitoring of configuration drift can surface keyloggers that require installation of new drivers, services, or registry modifications as deviations from the baseline template, but cannot detect keylogging that operates purely in memory, via API hooking without persistent artifacts, or by reading hardware buffers without leaving a configuration trace.
- T1056.003partialdetects — A.8.9's monitoring configurations clause compares actual configurations against defined target templates and addresses deviations, which can surface unauthorized modifications to a web portal's code or service configuration that enable credential capture; however, the clause's scope is system/service configuration baselines rather than application-layer code integrity, so detection depends on whether the portal's files and scripts fall within the monitored configuration set, leaving a bounded remainder.
- T1056.003partialprevents — Configuration management restricts administrative access to web portals, enforces change management that can block unauthorized modifications to login pages, and monitors for configuration deviations — reducing the surface for the post-compromise installation path. It does not prevent exploitation of vulnerabilities in the web service itself, so a meaningful remainder of the technique (initial compromise via exploitation) survives.
- T1059partialprevents — Enforcing minimal, hardened command interpreters and scripting environments limits the execution avenues available to adversaries who rely on interactive shells or scripting languages.
- T1059.001partialprevents — A.8.9's standard templates include 'disabling or restricting unnecessary functions and services,' which directly applies to PowerShell — where it is not needed, configuration management can remove or constrain it (Constrained Language Mode, execution policy, WDAC/AppLocker, disabling PowerShell v2). However, PowerShell is deeply integrated into Windows and required by many management and system functions, so it cannot be fully removed from systems that depend on it, and adversaries most often abuse it precisely where it must remain — the same shape the CM-7 anchor names for T1059.
- T1059.002partialprevents — A.8.9's configuration management can restrict AppleScript execution vectors (e.g., MDM profiles limiting osascript, permissions on the interpreter, restricting script execution paths), but AppleScript is deeply integrated into macOS, the technique can execute via native APIs (NSAppleScript, OSAScript) without invoking osascript, and many legitimate applications depend on it — so the control addresses a slice of the execution surface rather than the technique as a whole.
- T1059.003partialprevents — A.8.9's guidance on disabling/restricting unnecessary functions and services and restricting access to powerful utility programs can be deployed to constrain cmd.exe (e.g., via Group Policy or AppLocker policies managed through configuration baselines), but cmd.exe is a core Windows component that cannot be removed from the build, so the technique remains available to administrators, system processes, and any identities the configuration does not reach.
- T1059.004partialprevents — A.8.9 can disable or restrict unnecessary shells (e.g., zsh, ksh, fish) and constrain access to powerful utilities, but the primary shell the OS requires (sh/bash) cannot be removed without breaking the system, and that is the shell adversaries most use — the same shape as the CM-7 anchor on T1059.
- T1059.005partialprevents — A.8.9's guidance to disable or restrict unnecessary functions and services lets an implementation remove VBScript or VBA where the business does not need them, but VB is deeply integrated into Windows and Office and the interpreters the platform requires cannot be removed -- those are the ones adversaries most use, so what is removed is a slice rather than the bulk with a bounded remainder, matching the cm-7 / T1059 anchor shape.
- T1059.006partialprevents — A.8.9's standard templates include 'disabling or restricting unnecessary functions and services,' so where Python is not required and is removed from the baseline configuration the technique cannot run; however, Python is often required by the OS or applications (especially on Linux/macOS), and adversaries can install their own interpreter, so what is prevented is a slice rather than the bulk.
- T1059.007partialprevents — Configuration management can disable or restrict some JavaScript execution paths (browser JS policies, removing Node.js where unused, restricting JScript), but the interpreters most adversaries use — browser JS engines, Windows Script engine, macOS JXA — are integral to the platform and cannot be removed, so what is prevented is a slice rather than the bulk, matching the CM-7 / T1059 shape.
- T1059.008partialdetects — A.8.9's configuration monitoring (comparing actual to target templates, logging changes) detects the configuration-modifying subset of T1059.008 — disabling security features, altering startup parameters, changing device behavior — but does not detect CLI abuse that produces no persistent configuration change (one-off commands, real-time traffic manipulation), and the monitoring is periodic rather than real-time.
- T1059.008partialprevents — A.8.9 can disable unnecessary scripting interpreters, restrict access to powerful utilities, change vendor defaults, and constrain management-plane access (e.g., disabling telnet, enforcing SSH with keys, AAA, role-based command privileges), but the network device CLI itself is the device's primary administrative interface and cannot be removed — the technique's core mechanism remains available to anyone with administrative access, so what is prevented is a constrained slice rather than the technique itself.
- T1059.008partialrecovers — A.8.9 restores unauthorized changes to the device's configuration baseline, but the CLI can also be abused to execute payloads, manipulate live traffic, or exfiltrate data, which configuration management cannot undo.
- T1059.009partialprevents — Configuration management can disable or restrict unnecessary cloud CLI tools, SDKs and PowerShell modules, and can enforce templates that limit which binaries are installed, but the cloud APIs themselves and browser-based cloud shells are required for legitimate operations and cannot be removed, and valid credentials bypass configuration controls entirely.
- T1059.010partialprevents — A.8.9's guidance on disabling or restricting unnecessary functions and services can remove the AutoHotKey/AutoIT interpreters from standard builds where they are not business-required, preventing script-based execution; however, the technique also encompasses compiled `.exe` payloads that bypass interpreter restrictions, and A.8.9 is a general configuration baseline rather than a mandate for application whitelisting, so a bounded remainder of execution paths survives.
- T1059.011partialprevents — A.8.9 can disable unnecessary functions/services and restrict powerful utilities, which removes standalone Lua interpreters and unused Lua-embedded applications; however, Lua is frequently embedded in applications the platform requires (network device firmware, games, Redis, Wireshark, etc.), and those embedded interpreters cannot be removed without breaking the host application — the same shape as the CM-7 vs T1059 anchor.
- T1059.012partialprevents — Configuration management can restrict access to the hypervisor CLI, configure logging, and apply some restrictions on CLI functions, but the hypervisor CLI is required management infrastructure that cannot be removed without breaking the system, so the technique remains available to anyone with legitimate access — the same shape as cm-7 vs T1059, where required interpreters cannot be removed.
- T1059.013partialprevents — Configuration management can restrict access to container management tools (Docker CLI, kubectl), enforce authentication on the Docker API, apply least privilege to identities that can invoke these tools, and disable unnecessary container runtimes — but the tools themselves are required for legitimate container operations and cannot be removed, so what is prevented is a slice of the attack surface rather than the bulk, mirroring the CM-7 vs T1059 shape.
- T1068partialprevents — A.8.9 reduces the attack surface for privilege escalation by disabling unnecessary services and functions, restricting powerful utilities, and minimizing privileged identities, but it does not patch vulnerabilities in software that must remain running — and the kernel, drivers, and required services are precisely where T1068 operates, including BYOVD which bypasses configuration entirely.
- T1069.003partialprevents — Configuration management can reduce the attack surface by disabling unnecessary identities, minimizing privileged accounts, and restricting access to management tools — but cloud group enumeration is a core platform function that cannot be disabled without breaking the cloud environment, so an authenticated user with appropriate permissions can still enumerate groups they are authorized to see.
- T1070.007partialdetects — A.8.9's monitoring of configurations against target templates detects unauthorized changes to network configuration settings (firewall rules, proxy settings) that adversaries make to enable or conceal malicious connections, but it does not detect the clearing of connection history artifacts (RDP history entries, log entries) which is the primary mechanism of T1070.007.
- T1070.009partialdetects — A.8.9's configuration monitoring compares actual configurations against defined target templates and logs configuration changes, so removal of services, executables, registry keys, or accounts used for persistence would surface as deviations — but only where those artifacts were tracked in the configuration baseline, and the control detects the deviation, not the malicious intent behind clearing persistence.
- T1071.002partialprevents — A.8.9 can disable or restrict unnecessary file transfer protocols (FTP, TFTP, FTPS) via standard templates and configuration enforcement, preventing their use for C2 where they are not business-required, but SMB and other file transfer protocols are often essential for operations and cannot be removed, leaving the technique reachable on the protocols the environment requires.
- T1071.003partialprevents — Configuration management can disable or restrict mail protocols on systems that do not legitimately need them (per template item c, disabling unnecessary functions and services), preventing the technique on that subset; but mail protocols are a business requirement on mail servers and user workstations, where configuration management cannot disable them and the technique remains usable for C2.
- T1071.005partialprevents — A.8.9 covers network and service configuration, so where pub/sub brokers/services are not business-required they can be disabled or restricted, removing the local mechanism the technique abuses; however, in environments that legitimately use MQTT/XMPP/AMQP/STOMP, configuration management cannot remove the protocols and does not address the C2 abuse pattern itself, leaving the technique reachable.
- T1078partialprevents — A.8.9 prevents specific vectors of T1078 — disabling unused/inactive identities, removing default accounts, and minimizing privileged access — but cannot prevent the compromise and abuse of legitimate, active accounts that adversaries obtain through credential theft, phishing, or other means outside configuration management's scope.
- T1078.001partialdetects — A.8.9's monitoring of configurations, comparison against templates, and review of deviations (including default accounts, passwords, and privileged identities) surfaces misuse or persistence of default accounts after the fact, but only for monitored assets and only when the deviation is observable in configuration state rather than the initial abuse event itself.
- T1078.002partialprevents — A.8.9 can disable unnecessary domain accounts and minimize privileged domain identities per its standard-template guidance, removing part of the attack surface, but domain accounts must exist for the organization to function and the technique is fundamentally about abuse of legitimate credentials obtained via credential dumping or password reuse — neither of which configuration management reaches.
- T1078.003partialdetects — A.8.9's configuration monitoring detects deviations from baseline templates, so creation of unauthorized local accounts, re-enabling of disabled accounts, or privilege changes to local accounts surface as configuration drift; however, the core abuse of T1078.003 — an adversary using already-configured valid local account credentials to authenticate, dump credentials, or move laterally — produces no configuration change and is not observed by configuration management.
- T1078.003partialprevents — A.8.9 can disable unnecessary, unused or insecure local accounts and apply security templates (password policies, restricted privileges) that shrink the attack surface, but local accounts that are intentionally configured for users, services, remote support or administration must continue to exist and remain abusable through credential theft or dumping — the technique's mechanism is credential abuse of legitimate accounts, not exploitation of defaults, so configuration management cannot remove the target the way it can for T1078.001.
- T1078.004partialprevents — Configuration management prevents a slice of cloud account abuse by removing unnecessary or default cloud identities, enforcing MFA and strong authentication on configured accounts, restricting privileged role assignments, and detecting misconfigured role/policy settings — but it cannot prevent an adversary from compromising a legitimately configured and necessary cloud account through phishing, credential theft, or federation abuse, which is the bulk of T1078.004's mechanism.
- T1087partialprevents — Configuration management reduces the account surface (disabling unnecessary identities, restricting powerful utilities, hardening templates) so fewer accounts exist to enumerate and fewer tools are available, but accounts must exist for the system to function and an adversary with code execution can still run native enumeration commands against them, so the technique is constrained rather than prevented.
- T1087.004partialprevents — Configuration management disables unused/insecure identities (template item b) and restricts access to powerful utilities (item d), shrinking the enumeration surface and the set of accounts that exist to be listed, but the technique uses legitimate cloud administration tooling (Azure CLI, AWS CLI, GCP CLI, MSOL cmdlets) that an organization needs for normal operations, so it cannot be removed and authenticated enumeration of active accounts cannot be fully prevented.
- T1091partialprevents — A.8.9's standard templates can disable Autorun and restrict removable media execution policies, which removes the automatic-execution vector of T1091, but the clause cannot prevent users from manually executing renamed malware on removable media, firmware-level attacks on the media itself, or USB-connected mobile device infections — so a meaningful slice is prevented but the broader technique remains reachable.
- T1092partialprevents — A.8.9's template items (disabling unnecessary functions/services, restricting powerful utilities) can be applied to disable autorun, block automatic execution from removable media, and restrict USB device classes, which removes the easiest variants of the technique; however, the technique's core requires physical media transfer and manual execution on a compromised host, which configuration management of software/services/networks does not reach.
- T1095partialprevents — A.8.9's templates can disable or restrict unnecessary protocols and services (e.g., ICMP where not needed, VMCI in ESXi, unused UDP services), but the technique's core protocols are fundamental to IP networking and cannot be removed without breaking the platform, so what is prevented is a slice rather than the bulk.
- T1098partialdetects — A.8.9's monitoring of configurations against target templates and review of activities can detect deviations in account settings (privilege levels, group memberships, credential parameters), but the clause's scope is configuration-state comparison rather than real-time behavioral detection, and account manipulation that operates within defined configurations or uses legitimate change channels is not surfaced.
- T1098partialprevents — A.8.9 reduces the attack surface for account manipulation by disabling unnecessary accounts, restricting access to powerful utility programs, and enforcing least-privilege configurations, but it cannot prevent an adversary who already holds sufficient permissions from manipulating accounts they have access to — the technique presupposes the access is already present.
- T1098.001partialdetects — A.8.9's monitoring clause compares actual configurations against defined target templates and surfaces deviations, so an organization that baselines cloud identity configurations (expected SSH keys, access keys, service principals) would detect adversary-added credentials as configuration drift; however, the clause sets scope by what the organization defines as in-scope configurations rather than mandating cloud identity monitoring, so an implementation monitoring only OS/network templates is fully conformant and sees nothing of credential additions.
- T1098.001partialprevents — A.8.9 can restrict which identities hold privileged rights and define secure configurations for cloud services (limiting who can add credentials, disabling unnecessary identity-related features), but it cannot prevent an adversary who has already compromised an account with sufficient permissions from using that account's legitimate IAM rights to add new credentials through standard cloud APIs.
- T1098.002partialdetects — A.8.9's configuration monitoring compares actual configurations against target templates and addresses deviations, and the clause explicitly includes 'services (e.g. cloud services)' in scope, so an implementation that baselines mailbox delegate settings would surface unauthorized additions as configuration drift; however, the standard templates enumerate system-level concerns (privileged identities, disabled accounts, vendor defaults, time-outs) rather than email permission specifics, so detection depends on whether the organization's template actually enumerates allowed delegate states.
- T1098.002partialprevents — A.8.9's guidance on minimizing privileged identities and monitoring configuration changes constrains who can grant delegate permissions and surfaces deviations, but the technique abuses legitimate administrative functionality that an authorized account can still exercise, so configuration management reduces rather than eliminates the attack surface.
- T1098.003partialprevents — A.8.9 establishes secure configuration baselines for cloud services and can restrict who has privileges to modify IAM policies (via minimizing privileged identities and restricting access to powerful utility programs), and can enforce target configurations automatically — but it does not prevent an adversary with valid, sufficiently-privileged credentials from adding roles through authorized API calls, since the technique operates within the permissions the compromised identity already holds; the control's main contribution here is baseline restriction and deviation detection rather than blocking the action.
- T1098.004partialdetects — A.8.9's monitoring section requires actual configurations to be compared against target templates and deviations addressed, so unauthorized additions to authorized_keys are detectable as configuration drift when the file is in the monitored baseline; however, scope is organizationally determined, cloud-API modifications (GCloud add-metadata, Azure PATCH) may bypass file-based configuration monitoring, and the technique is designed for stealthy persistence, so detection is a slice rather than a bounded remainder of a mechanism that mostly works.
- T1098.004partialprevents — Configuration management defines secure SSH baselines (e.g., disabling PermitRootLogin, restricting PubkeyAuthentication) and monitors for deviations in sshd_config and authorized_keys files, which constrains the technique's surface and can trigger automatic enforcement; however, the technique can still execute because authorized_keys modifications are user-level changes that monitoring surfaces after the fact rather than blocks, and the clause's primary mechanism is detective/corrective rather than preventive.
- T1098.005partialprevents — A.8.9's configuration management framework can be applied to harden MFA/IdP systems against device registration abuse (e.g., disabling self-enrollment, requiring admin approval, configuring conditional access policies), but the control is general and does not inherently address identity-provider device registration; the technique exploits a legitimate feature that configuration choices may or may not restrict, so prevention depends on specific template decisions rather than the control's mechanism.
- T1098.006partialdetects — A.8.9's monitoring of configurations against target templates and logging of configuration changes can detect unauthorized RBAC modifications (RoleBinding/ClusterRoleBinding creation, ABAC policy changes) as deviations from the baseline, but detection depends on whether Kubernetes RBAC configurations are within the monitored configuration scope and whether deviations are actively flagged, which the clause does not mandate at the depth required for comprehensive detection of this technique.
- T1098.006partialprevents — Configuration management constrains the attack surface by minimizing identities with privileged access, restricting access to powerful utilities, and defining secure baseline templates for Kubernetes RBAC, but it does not prevent an adversary who has compromised an account with sufficient permissions from creating RoleBindings or ClusterRoleBindings — the technique can still execute against any identity that retains the necessary rights.
- T1098.007partialdetects — A.8.9's monitoring of configurations against target templates can surface unauthorized group membership changes (a configuration deviation), but detection depends on what the template specifies and the review is periodic rather than real-time, so it catches a slice of instances rather than the technique broadly.
- T1098.007partialprevents — A.8.9's guidance explicitly calls for restricting access to powerful utility programs (the `net localgroup`, `net group`, `usermod` commands used here) and minimizing privileged identities, which constrains the technique's execution paths; however, group membership modification is a legitimate administrative function that cannot be fully removed, so an adversary with admin access can still perform it.
- T1105partialprevents — A.8.9's templates can disable or restrict unnecessary functions, services and powerful utility programs (curl, wget, PowerShell, certutil, etc.) that T1105 commonly abuses, so where those tools are removed from the build the technique cannot run; however, many of these utilities are required for legitimate operation and cannot be removed, and the technique is flexible enough to use alternate protocols, installers, package managers and web services, leaving a substantial remainder.
- T1110partialprevents — A.8.9 prevents specific brute-force vectors by removing default credentials, disabling unused/insecure identities, and restricting unnecessary services — but it does not address the core mechanism of password guessing against valid accounts with weak secrets, which is the domain of A.8.5 (authentication strength, lockout, MFA).
- T1110.001partialprevents — A.8.9's standard templates mandate changing vendor default passwords and disabling unnecessary/insecure identities, and its monitoring clause requires evaluating password strengths — all of which close specific guessing vectors. But the clause does not mandate account lockout, rate limiting, MFA, or password complexity policies (those live in A.8.5/A.5.17), so guessing against non-default, enabled accounts with weak passwords remains possible.
- T1110.002partialprevents — A.8.9 enforces password strength requirements and changes default authentication information, which raises the computational cost of cracking and can render weak hashes infeasible to break, but the cracking itself runs on adversary-controlled systems and the clause sets a strength-evaluation requirement rather than mandating a universal floor, so sufficiently long or complex passwords can still be cracked given enough resources.
- T1110.003partialprevents — A.8.9 reduces the attack surface for password spraying by disabling unnecessary accounts and restricting unnecessary services (e.g., Telnet, FTP, exposed management ports), but it does not prevent the technique from being attempted against accounts and services that must exist, and it does not address the password strength or authentication mechanism itself (which is A.8.5's lane).
- T1112partialdetects — A.8.9 requires monitoring configurations and comparing actual configurations against defined target templates, which surfaces unauthorized Registry modifications where the Registry is within the monitored configuration scope, but the clause determines scope rather than mandating Registry-level instrumentation, so an implementation monitoring only application and network configurations is fully conformant and sees nothing of a Registry key change.
- T1112partialprevents — Configuration management restricts who has admin-level access (a key requirement for many registry modifications), can disable unnecessary services that facilitate remote registry modification, and enforces templates that limit registry-modifying utilities — but the registry is a fundamental Windows component that cannot be removed or disabled, so the technique still runs and only unauthorized or malicious instances are constrained, not the technique itself.
- T1114.003partialdetects — A.8.9's configuration monitoring compares actual configurations against target templates and addresses deviations, so unauthorized email forwarding rules can be surfaced when email settings are part of the monitored baseline; however, detection depends on implementation scope (whether mail-system configurations are included) and may miss hidden rules created via MAPI, leaving a bounded remainder.
- T1123partialprevents — A.8.9's guidance on disabling or restricting unnecessary functions, services, and identities, and on restricting access to powerful utilities, can be applied to disable microphones, restrict which applications may access audio devices, or block audio-capture APIs — but the control is general-purpose configuration hygiene, not specific to audio capture, and many systems require functioning microphones for legitimate use, so the technique is constrained rather than eliminated.
- T1125partialprevents — A.8.9 can disable unnecessary cameras and restrict which applications have device access through secure configuration templates, but cameras and video applications required for legitimate business use remain enabled and accessible, and the control does not address malware that exploits legitimate applications' camera permissions.
- T1127partialprevents — A.8.9's standard templates explicitly call for disabling or restricting unnecessary functions/services and restricting access to powerful utility programs, which directly removes or constrains the developer utilities T1127 abuses on systems where they are not legitimately needed; however, on developer workstations and build servers where these utilities are required for legitimate work, configuration management cannot eliminate them, and those are precisely the systems the technique targets.
- T1127.001partialprevents — A.8.9 includes 'disabling or restricting unnecessary functions and services' and standard templates that can be configured to block MSBuild.exe where it is not required, preventing the technique on those systems; however, MSBuild is a legitimate Windows utility needed on development and build systems, so it cannot be removed from systems that require it, and the technique is specifically designed to bypass application control by abusing a signed Microsoft binary.
- T1127.002partialprevents — A.8.9's templates can restrict or disable ClickOnce via Group Policy/software restriction policies (disabling unnecessary functions and services, restricting powerful utilities), but ClickOnce is a built-in Windows feature that often must remain enabled for legitimate business use, and the technique has multiple abuse vectors (user execution, rundll32, startup folder placement) that configuration alone cannot fully close.
- T1127.003partialprevents — A.8.9's standard templates include disabling or restricting unnecessary functions, services and powerful utility programs, so where JamPlus is not required for legitimate development work configuration management can prevent its installation or restrict its execution; however, in developer environments where JamPlus is legitimately needed the control cannot remove it, and the technique specifically subverts application control rather than exploiting a misconfiguration, so the prevention is a slice rather than the bulk.
- T1129partialprevents — Configuration management can constrain T1129 by hardening module-loading paths (e.g., SafeDLLSearchMode, disabling remote UNC DLL loading, restricting dlopen paths, applying application-whitelisting/WDAC), but the OS module loader is a fundamental capability that cannot be removed without breaking the platform, so the technique still runs against local modules and legitimate processes.
- T1133partialdetects — A.8.9's configuration monitoring (comparing actual to target templates, reviewing for deviations) can detect unauthorized installation or modification of remote services — new VPN endpoints, enabled RDP, changed authentication settings on remote gateways — but cannot detect an adversary using an already-correctly-configured remote service with valid credentials, which is the technique's primary path.
- T1133partialprevents — Configuration management can disable unnecessary remote services, restrict access to them, and enforce secure configurations (e.g., requiring authentication on exposed services, changing defaults), but it cannot prevent adversaries from using legitimately required remote services (VPNs, Citrix, RDP) with valid stolen credentials, which is the technique's primary vector.
- T1134partialprevents — Configuration management reduces the attack surface for token manipulation by limiting privileged identities (item a), disabling unnecessary accounts and services (items b, c), and restricting powerful utilities (item d), but the underlying Windows token APIs are core OS functionality that cannot be removed without breaking the system, so the technique remains executable by code already running on the host.
- T1134.001partialprevents — A.8.9 reduces the attack surface for token theft by minimizing privileged identities and restricting access to powerful utility programs, but it cannot prevent the Windows API calls (DuplicateToken, ImpersonateLoggedOnUser) from executing against any token the adversary can reach — tokens are fundamental to Windows operation and cannot be removed the way default accounts can.
- T1134.002partialprevents — A.8.9 reduces the attack surface for T1134.002 by minimizing privileged identities, disabling unnecessary accounts, and restricting access to powerful utility programs, but it cannot disable the underlying Windows APIs (CreateProcessWithTokenW, runas) that the technique requires for legitimate operations, so an attacker who compromises a remaining privileged account or obtains a token can still execute the technique.
- T1135partialprevents — Configuration management can disable unnecessary file-sharing services and remove unneeded shares via standard templates, so the discovery query finds nothing on those systems; however, business-required shares remain discoverable, the discovery action itself still executes, and the clause sets a configuration baseline rather than mandating removal of all sharing.
- T1136partialdetects — A.8.9 requires logging all configuration changes and monitoring actual configurations against defined target templates, so a newly created account would be a logged change and a deviation from a template that enumerates expected accounts; however, the clause's purpose is configuration management rather than security monitoring, the templates need not enumerate specific accounts, and the monitoring is periodic rather than real-time, so detection is incidental and bounded by implementation specifics.
- T1136.001partialdetects — A.8.9's monitoring section requires comparing actual configurations against defined target templates and addressing deviations, which would surface an unauthorized local account as a configuration drift — but detection is periodic ('regular basis') rather than real-time, and depends on the template enumerating accounts; the clause's primary focus is configuration settings, not account-creation events.
- T1136.001partialprevents — A.8.9 can constrain the attack surface by restricting access to powerful utility programs (including user management commands), minimizing privileged identities, and enforcing templates that flag unauthorized account creation, but it cannot fully prevent a sufficiently privileged actor from creating a new local account — the technique's premise is that the adversary already holds the access needed, and account creation is a legitimate administrative function that cannot be removed the way a default account can.
- T1136.002partialdetects — A.8.9's monitoring of configurations against defined templates can surface new domain accounts as deviations from the authorized identity baseline (the clause explicitly addresses identity configurations, including disabling unnecessary identities), but its primary monitoring scope is system security settings rather than identity events, so the bulk of detection for T1136.002 falls to logging and security monitoring controls.
- T1136.002partialprevents — A.8.9's guidance to minimize privileged access rights and restrict access to powerful utility programs constrains who can create domain accounts and what tools they can use, but it does not prevent an adversary who has already obtained sufficient privileges from executing `net user /add /domain`; the technique can still run, so prevention is partial rather than full.
- T1136.003partialdetects — A.8.9's monitoring-configurations clause compares actual configurations against defined target templates and addresses deviations, so a newly created cloud account that is not in the approved identity baseline is a deviation that configuration monitoring can surface; however, the technique explicitly notes adversaries may create accounts scoped to reduce detection chance, and configuration management's coverage of cloud identity configurations depends on implementation scope, so detection is a slice rather than a bounded remainder of a mechanism that mostly works.
- T1136.003partialprevents — A.8.9's templates can restrict account-creation privileges, disable unnecessary service accounts, and require change-management approval before new identities are provisioned, which constrains a slice of T1136.003; but the clause governs system configuration rather than cloud identity lifecycle, so an adversary with sufficient tenant access can still create accounts outside the template's reach.
- T1137partialdetects — A.8.9 monitors configurations against target templates and addresses deviations, which surfaces unauthorized additions to Office (add-ins, template macros, Outlook rules) as configuration drift, but the clause mandates periodic review rather than real-time detection, and the scope of what is managed is set by the organization — Office startup persistence mechanisms not captured in the baseline template go unseen.
- T1137partialprevents — A.8.9's standard templates can disable macros by default, restrict add-in installation, and harden Outlook against rules/forms/Home Page persistence, and its monitoring can detect deviations — but Office must remain functional, users with rights can change configurations, and multiple persistence mechanisms exist, so the technique is constrained rather than prevented.
- T1137.001partialprevents — A.8.9's standard templates can disable or restrict unnecessary functions and services, which includes macros, but the control sets a configuration baseline rather than universally blocking template modification, and an adversary with write access to the template path can still insert a malicious macro.
- T1137.002partialdetects — A.8.9's monitoring-configurations clause compares actual configurations against target templates and flags deviations, so an Office Test registry key added outside the baseline is a detectable configuration change; however, the control's scope is set by what the organization chooses to include in its templates, and registry-level persistence keys are not universally enumerated, so detection is a slice rather than a mechanism that mostly works.
- T1137.002partialprevents — A.8.9 establishes baselines that would not include the Office Test Registry key (not present by default) and monitors for deviations, with automatic enforcement as an explicit option; this can break the persistence mechanism by detecting and removing the key. However, the control does not prevent the adversary from creating the key in the first place or stop the malicious DLL from executing at least once before detection/correction, and the prevention depends on the baseline explicitly covering this key and on automatic enforcement being implemented.
- T1137.003partialprevents — A.8.9's standard templates and restriction of unnecessary functions/services can disable or restrict custom Outlook forms via security baselines (e.g., Outlook security settings, registry policies), but the feature is often needed for legitimate business use, the technique requires prior compromise to populate the mailbox, and a sufficiently privileged adversary can alter the configuration that was meant to block it.
- T1137.004partialdetects — A.8.9's monitoring of configurations against target templates can detect the unauthorized registry change that sets a malicious Outlook Home Page, since the technique is fundamentally a configuration deviation, but extent depends on whether Outlook client settings are in the monitored scope and whether the standard template explicitly addresses the Home Page feature — neither is guaranteed by the clause.
- T1137.004partialprevents — A.8.9's standard templates and 'disabling or restricting unnecessary functions and services' provide a mechanism to disable the legacy Outlook Home Page feature or block custom URL loading via configuration policy, which would prevent the technique; however, the control is general rather than specific to this feature, the Home Page may be retained for legitimate use, and an adversary with sufficient access to set registry/Home Page values may still bypass configuration enforcement, leaving a bounded remainder.
- T1137.005partialprevents — Configuration management can constrain the technique's impact by hardening the host (making initial compromise harder) and by enforcing application-control or script-blocking policies that prevent the code execution triggered by a malicious rule, but it does not directly prevent the creation of malicious Outlook rules themselves, since rule authoring is a legitimate user-level mailbox feature that standard templates do not reach.
- T1137.006partialdetects — A.8.9's monitoring of configurations against target templates can surface unauthorized Office add-ins as configuration deviations, and the clause requires logging configuration changes — but detection is incidental to the control's primary purpose of ensuring correct configuration, depends on add-ins being in the monitored baseline, and is periodic review rather than real-time security monitoring, so it catches a slice of instances rather than the technique broadly.
- T1137.006partialprevents — Configuration management provides the mechanism to restrict or disable Office add-in loading through secure templates and policy enforcement, but the control is general and does not specifically mandate blocking add-ins; whether the technique is prevented depends on the specific configuration choices made within the framework.
- T1140partialprevents — A.8.9's template guidance to disable or restrict unnecessary functions, services and powerful utility programs can constrain some vectors for T1140 (e.g. blocking certutil where it is not needed), but the technique runs through core OS utilities and in-process malware decoding that configuration management cannot remove without breaking the platform, leaving the bulk of the technique reachable.
- T1176partialdetects — A.8.9's configuration monitoring compares actual configurations against defined target templates and flags deviations, so unauthorized or malicious extensions can be detected where the baseline explicitly restricts extension installation; however, the clause determines scope through the configuration template rather than mandating that extensions be tracked, and an implementation focused on OS/service settings rather than application-level extensions is fully conformant yet sees nothing of T1176.
- T1176partialprevents — A.8.9's standard templates and 'disabling or restricting unnecessary functions and services' can be applied to enforce extension allowlists and block unauthorized extension installation, but the control's primary focus is system configuration rather than application extension management; the technique's vectors—abuse of benign extensions, social engineering of users with install rights, and extensions required for legitimate browser/IDE function—remain reachable, so what is prevented is a slice rather than the bulk.
- T1176.001partialdetects — A.8.9's monitoring of configurations against target templates can detect unauthorized browser extensions and modified preference files when browser extensions are included in the configuration baseline, but the clause sets scope through the baseline rather than mandating browser extension monitoring, so a fully conformant implementation that omits browser extensions from its templates detects nothing of this technique.
- T1176.001partialprevents — A.8.9's configuration templates can disable or restrict unnecessary browser extensions and enforce approved configurations, but the technique's social engineering and silent file manipulation vectors bypass configuration enforcement, leaving a reachable remainder.
- T1176.002partialdetects — A.8.9's configuration monitoring compares actual configurations against target templates and addresses deviations, so an implementation whose baseline includes allowed/denied IDE extensions can detect unauthorized ones; however, the clause sets scope by what the organization defines as its configuration baseline rather than mandating IDE-extension coverage, and what it surfaces is a configuration deviation rather than the malicious behaviour of the extension itself.
- T1176.002partialprevents — A.8.9's template guidance includes 'disabling or restricting unnecessary functions and services' and its monitoring clause can enforce extension allowlists, so a properly scoped configuration baseline can block unauthorized IDE extensions; however, the technique has multiple vectors (marketplace installs, side-loading, abuse of legitimate extensions like Remote SSH) and most organizations must permit some extensions for development, so the control provides a preventive mechanism that requires specific implementation choices rather than universally blocking the technique.
- T1185partialprevents — Configuration management can restrict browser extensions, limit privileged access (e.g., SeDebugPrivilege required for some hijacking), and apply hardened browser baselines, but it cannot prevent the technique's exploitation of inherent browser functionality and code injection vectors that operate within the browser's normal execution context.
- T1187partialprevents — A.8.9's standard templates include disabling or restricting unnecessary functions and services and changing default authentication parameters, which can be applied to harden NTLM/SMB client behavior, disable outbound WebDAV, or restrict EFSRPC — but the clause does not mandate these specific configurations, and SMB is essential in most enterprise environments, so what is prevented is a slice determined by the implementer's choices rather than a bounded remainder of a mechanism that mostly works.
- T1189partialprevents — Configuration management can disable unnecessary browser plugins and services and apply hardened browser templates, removing a slice of the drive-by attack surface, but it cannot remove the browser itself (which users require) and cannot patch browser vulnerabilities, so the primary exploit vectors remain reachable.
- T1190partialprevents — A.8.9 prevents the misconfiguration slice of T1190 — default credentials, unnecessary exposed services, weak security settings — by enforcing standard templates, disabling unused functions, and changing vendor defaults, but it does not address software bugs, code-level vulnerabilities (OWASP/CWE top issues), or zero-days, which are the other major vectors in this technique.
- T1197partialprevents — A.8.9 can restrict access to BITSAdmin and constrain PowerShell execution policies, and can disable BITS where not strictly needed, but BITS is a core Windows component required for legitimate functions (Windows Update, etc.) and the COM interface remains reachable from any process with code execution, so the technique cannot be eliminated — only a slice of its vectors is closed.
- T1200partialdetects — A.8.9's configuration monitoring (system management tools, asset inventories, deviation detection) can surface new hardware appearing on the estate as a configuration change, but the clause's primary mechanism targets software/service settings rather than physical device insertion, leaving passive or unregistered hardware additions (e.g., inline keystroke loggers, DMA devices that don't register) outside its detection scope.
- T1200partialprevents — Configuration management can disable or restrict ports (USB, Thunderbolt, FireWire) and enforce device-control policies that block a slice of hardware-addition vectors, but it cannot prevent the technique broadly: physical access is the gating prerequisite, and many vectors (rogue wireless APs, inline network taps, hardware keyloggers between keyboard and port) operate independently of the target system's configuration.
- T1202partialprevents — A.8.9's templates can disable or restrict unnecessary utilities (Forfiles, Scriptrunner.exe, pcalua.exe) and limit access to powerful host utilities, removing a slice of the indirect-execution surface, but many abused binaries (WSL, ssh.exe, built-in Windows utilities) are OS components that cannot be removed without breaking functionality, so the technique remains reachable through the remainder.
- T1203partialprevents — Configuration management can reduce attack surface by disabling unnecessary functions, restricting powerful utilities, and applying hardening templates to client applications, but it does not patch code vulnerabilities — the core mechanism of T1203 — and the client applications typically must remain functional, so the technique remains exploitable against the residual surface.
- T1204partialprevents — A.8.9's guidance on disabling unnecessary functions/services and restricting access to powerful utility programs constrains the execution surface (e.g., blocking script interpreters, disabling autorun, restricting file handlers), but T1204's mechanism is the deceived user, and configuration management cannot prevent a user from being tricked into running a legitimate-looking payload or a tool the platform requires.
- T1204.002partialprevents — Configuration management can constrain execution paths (disabling risky file types like .scr/.cpl, enforcing macro-disable policies, application whitelisting) but cannot prevent the user from opening a file in the first place, and the file types users routinely open (.doc, .pdf, .xls) must remain openable for legitimate work, so what is removed is a slice of execution vectors rather than the technique itself.
- T1204.003partialdetects — A.8.9's monitoring-configurations clause compares actual deployed configurations against target templates and addresses deviations, so unexpected services, packages, accounts or parameter changes introduced by a backdoored image can surface. But T1204.003 is specifically designed to look legitimate — the malicious payload can sit in a binary or script that does not register as a configuration deviation — and A.8.9 is not a malware-detection control, so a well-crafted image matches the template while still being malicious.
- T1204.003partialprevents — A.8.9's scope explicitly includes cloud services and could encompass configuration policies restricting image sources, requiring signed/verified images, or mandating image scanning as part of deployment templates, but the clause's core mechanism is about system configuration settings rather than image provenance or integrity, so it addresses only a slice of what enables the technique.
- T1204.004partialprevents — A.8.9's guidance on disabling or restricting unnecessary functions and services and restricting access to powerful utility programs can constrain some interpreters, but T1204.004 specifically targets the interpreters users need (PowerShell, cmd, terminal) which cannot be removed, so what is restricted is a slice rather than the bulk, and the social engineering vector itself is untouched.
- T1205partialprevents — Configuration management can disable unnecessary services, restrict access to packet-capture utilities, and turn off Wake-on-LAN where not needed, removing built-in vectors for traffic signaling; however, the technique can be implemented by an adversary post-compromise on legitimate services using magic values, so the baseline cannot eliminate the technique entirely.
- T1205.002partialprevents — A.8.9 can restrict installation of libpcap/Winpcap where not needed and limit access to powerful utilities (clause items c, d), reducing the attack surface, but the technique also uses standard library functions like `setsockopt` with `SO_ATTACH_FILTER` and an adversary with elevated permissions can install what they need, so configuration management cannot fully prevent socket filter installation.
- T1207partialdetects — A.8.9's monitoring-configurations clause compares actual configurations against target templates and logs configuration changes, so a rogue DC (new server object, new nTDSDSA object in the AD Configuration partition) is a deviation the framework is built to surface; however, T1207 specifically bypasses system logging and SIEM, requires Administrator privileges that can be used to suppress or alter the configuration record, and the clause sets a framework rather than mandating AD-specific baseline depth, so detection is a slice of well-implemented deployments rather than a guaranteed outcome.
- T1207partialprevents — A.8.9's guidance on minimizing privileged identities and disabling unused accounts reduces the attack surface for obtaining the Administrator privileges or KRBTGT hash the technique requires, but it cannot prevent a rogue DC registration once an attacker already holds those privileges, and the technique specifically bypasses the configuration-monitoring and logging controls A.8.9 mandates.
- T1210partialprevents — Configuration management disables or restricts unnecessary services and changes default authentication, removing the attack surface for exploitation of those services; however, services that must remain enabled for business reasons (SMB, RDP, web servers, etc.) cannot be removed, and A.8.9 addresses configuration rather than patching the underlying software vulnerabilities those services carry.
- T1212partialprevents — Configuration management reduces the attack surface by disabling unnecessary services, restricting powerful utilities, and removing default authentication, which prevents exploitation of those specific vectors; however, it does not fix the underlying programming errors in software that must remain running, so exploitation of vulnerabilities in required services is not prevented.
- T1213partialprevents — Configuration management can prevent the misconfiguration vector of T1213 (overly-broad access, public exposure, default sharing settings on repositories like SharePoint, Confluence, RDS) by enforcing secure templates and disabling unnecessary functions, but it cannot prevent authorized users from mining repositories they are legitimately permitted to access, which is the technique's other main path.
- T1213.006partialprevents — Configuration management can disable unnecessary database services, restrict access to database utilities, and enforce hardened templates (including changed default credentials), which prevents a slice of database access vectors; however, the technique targets databases the organization legitimately operates and needs accessible, so adversaries with valid credentials or exploiting application-layer paths still reach the data, and the clause governs configuration rather than data-access authorization.
- T1216partialprevents — Configuration management can restrict or disable unnecessary script proxies (e.g., via standard templates that disable unused functions/services and apply application control policies), but T1216 specifically abuses Microsoft-signed scripts that are default on Windows and often required for legitimate operation, so the bulk of the technique's surface cannot be removed without breaking the platform.
- T1216.001partialprevents — A.8.9's guidance on disabling or restricting unnecessary functions and services, and restricting access to powerful utility programs, provides a framework that could be used to constrain PubPrn.vbs execution through configuration baselines, but the control does not directly target script execution and the mechanism is indirect — PubPrn.vbs is a Microsoft-signed system script whose restriction depends on implementation choices rather than being mandated by the clause.
- T1216.002partialprevents — A.8.9's template guidance to disable or restrict unnecessary functions and services can remove App-V (and thus SyncAppvPublishingServer.vbs) where the feature is not business-required, but on systems where App-V is legitimately in use the signed proxy remains available and configuration management does not address LOLBin abuse patterns.
- T1218partialprevents — A.8.9 can restrict or disable some binaries through secure configuration templates (e.g., AppLocker/WDAC-style policies, removing unnecessary utilities), but T1218 specifically abuses Microsoft-signed binaries that are default and required for OS operation (rundll32, regsvr32, mshta, etc.) — these cannot be removed without breaking the system, mirroring the CM-7 vs T1059 anchor's `partial` reasoning.
- T1218.001partialprevents — A.8.9's guidance to disable or restrict unnecessary functions and services can be applied to hh.exe and CHM support, removing the technique's execution path on systems where HTML Help is not needed; however, many systems legitimately require hh.exe for help documentation, and the technique can bypass application control on unpatched systems, so what is prevented is a slice rather than the bulk.
- T1218.002partialprevents — Configuration management can restrict abuse of control.exe through allowlisting, WDAC/AppLocker policies, and GPO restrictions on .cpl execution, but control.exe is a core Windows component that cannot be removed, the technique has multiple invocation vectors (command line, API, double-click), and CPL files are documented to bypass file-extension allowlists — so what is prevented is a slice, not the bulk.
- T1218.003partialprevents — A.8.9's guidance to disable or restrict unnecessary functions, services and powerful utility programs allows CMSTP.exe to be removed or blocked via configuration templates where it is not needed for legitimate Connection Manager profiles, but the binary is a Microsoft-signed Windows component that many environments require for VPN connectivity, so where it is needed the technique still runs against the same configuration baseline.
- T1218.004partialprevents — A.8.9's template guidance includes disabling or restricting unnecessary functions and services, so where InstallUtil is not required for legitimate .NET operations it can be removed or constrained via configuration; however, the utility is a signed Microsoft component often needed for legitimate software installation, and the clause sets a framework rather than mandating a specific block, so what is removed is a slice with a bounded remainder of systems where the binary must remain.
- T1218.005partialprevents — A.8.9's standard templates include disabling or restricting unnecessary functions and services, so configuration management can disable or AppLocker/WDAC-restrict mshta.exe where it is not needed; however, mshta.exe is a built-in Windows utility that cannot be fully removed, and environments that legitimately process HTA files must keep it functional, leaving a bounded remainder where the technique remains viable — the same shape as cm-7 vs T1059.
- T1218.007partialprevents — Configuration management can disable the AlwaysInstallElevated policy (removing the SYSTEM-privilege escalation path) and enforce application-control templates that restrict msiexec.exe to signed/admin-approved MSI sources, but msiexec.exe is a required Windows component that cannot be removed without breaking the OS, so the technique still runs for non-elevated abuse paths.
- T1218.009partialprevents — A.8.9's standard templates include disabling or restricting unnecessary functions, services and powerful utility programs, so on systems where Regsvcs/Regasm are not needed the technique can be blocked by removing or restricting the binaries; however, these are signed Microsoft utilities required on developer machines and .NET COM environments, and A.8.9 does not mandate their removal where they are needed, so the technique still runs on the systems where the utilities must remain available.
- T1218.010partialprevents — A.8.9's guidance on disabling/restricting unnecessary functions and services and restricting access to powerful utility programs can be applied to Regsvr32.exe through application control configurations, but Regsvr32 is a legitimate Windows component often required for normal operations and the technique is specifically designed to bypass application control via COM scriptlets, so what is prevented is a slice rather than the bulk.
- T1218.011partialprevents — A.8.9(d) explicitly calls for restricting access to powerful utility programs, and rundll32.exe qualifies, so configuration baselines (AppLocker/WDAC policies, GPO restrictions on rundll32 invocation) can constrain the technique; however, rundll32.exe is a required Windows component used for legitimate Control Panel items, DLL loading, and shell operations, so it cannot be removed without breaking the platform, and the technique is explicitly designed to exploit exactly this allowlist reality.
- T1218.012partialprevents — A.8.9's guidance on disabling or restricting unnecessary functions and services, combined with secure configuration templates and monitoring, can address verclsid.exe by removing/disabling the binary where unused or by enforcing application control policies that block its abuse; however, verclsid.exe is a native, signed Windows binary that may be required for legitimate shell-extension functionality, and the clause is general configuration management rather than a specific LOLBIN restriction mandate, so what is removed is a slice of the attack surface rather than the bulk.
- T1218.014partialprevents — Configuration management can restrict MMC execution through AppLocker, WDAC, or Group Policy (per the clause's 'disabling or restricting unnecessary functions and services'), but MMC is a legitimate signed Windows administrative tool that cannot be universally removed on systems where administrators need it, leaving the technique reachable in those contexts.
- T1218.015partialprevents — Configuration management can restrict some attack vectors (command-line arguments like --disable-gpu-sandbox, disabling unnecessary Electron features, application control policies) but cannot prevent the technique entirely because Electron applications are legitimate and commonly required (Signal, Slack, Teams), and the technique abuses their inherent functionality rather than exploiting misconfigurations.
- T1219partialdetects — A.8.9's configuration monitoring can detect the installation or enabling of remote access software as a deviation from the baseline template, but it does not detect the runtime abuse of already-installed legitimate remote access tools (TeamViewer, RDP, Chrome Remote Desktop, EDR response features), which is the core of T1219 and involves no configuration change.
- T1219partialprevents — Configuration management can disable or restrict unnecessary remote access tools and harden configurations of those that remain (e.g., requiring MFA, restricting allowed tools), but cannot remove the remote access software the organization legitimately needs for IT support, remote work, or EDR response features — and T1219 specifically notes adversaries abuse those legitimate tools, so what is prevented is a slice rather than the bulk.
- T1219.001partialprevents — Configuration management can restrict installation of unnecessary IDEs, disable tunneling features, and block unauthorized extensions, but where IDEs are legitimately required for development work the tunneling capability is built into the tool and cannot be removed without breaking the business function — the same shape as CM-7 vs T1059, where what is removed is a slice rather than the bulk.
- T1219.002partialdetects — Configuration monitoring compares actual system state against target templates, so unauthorized installations of remote desktop software (VNC, TeamViewer, AnyDesk, etc.) are detectable as configuration deviations; however, the technique explicitly relies on software that is often application-control-approved, and configuration management monitors state rather than behavior, so malicious use of an authorized RMM tool produces no deviation to detect.
- T1219.002partialprevents — Configuration management can block installation of unauthorized remote desktop software and disable built-in remote access features, but the technique explicitly relies on legitimate tools (VNC, TeamViewer, AnyDesk, Chrome Remote Desktop) that organizations commonly permit for IT support, so what is removed is a slice rather than the bulk — the same shape as CM-7 vs T1059.
- T1219.003partialdetects — A.8.9's configuration monitoring can surface unauthorized hardware additions (new KVM devices not in the asset/configuration baseline) and deviations in device configuration, but the technique's core — using legitimately permitted remote access hardware for C2 — is largely invisible to configuration management because the hardware may be policy-allowed and the malicious use is a runtime behavior, not a configuration state.
- T1219.003partialprevents — A.8.9 can disable or restrict unnecessary services and restrict network configurations, which addresses software-based remote access channels, but T1219.003 specifically involves physically installed hardware (IP-based KVM devices) that operates independently of software configuration and is designed to bypass software security solutions, so configuration management cannot reach the core mechanism.
- T1220partialprevents — A.8.9's templates can remove msxsl.exe where unneeded and restrict wmic via configuration policy, but the technique has multiple vectors including built-in Windows tools the platform requires and the adversary's ability to side-load msxsl.exe, so what configuration management removes is a slice rather than the bulk.
- T1222partialdetects — A.8.9's monitoring clause compares actual configurations against target templates and addresses deviations, so where file/directory permissions are within the monitored configuration baseline, unauthorized changes are surfaced; the extent is partial because the clause's scope is set by the organization's chosen templates and many implementations focus on system/service-level configurations rather than granular file ACLs.
- T1222partialprevents — A.8.9's guidance on restricting access to powerful utility programs, minimizing privileged identities, and automatically enforcing target configurations constrains who can modify file/directory permissions and can prevent unauthorized changes from persisting, but the technique can still be executed by any account with sufficient privileges and the control's primary mechanism is monitoring and deviation correction rather than blocking the action itself.
- T1222partialrecovers — A.8.9's automatic enforcement or manual correction of configuration deviations restores baselined file and directory permissions altered by the adversary, but leaves modifications to non-baselined files unrecovered.
- T1222.001partialdetects — A.8.9's configuration monitoring (comparing actual vs target templates, logging configuration changes) can detect unauthorized DACL modifications if file/directory permissions are included in the monitored baseline, but the standard templates enumerated in the clause focus on system-level settings (privileged identities, services, defaults) rather than fine-grained ACLs, so detection depends on implementation scope and is not inherent to the control.
- T1222.001partialprevents — Configuration management can restrict access to the utilities used (icacls, cacls, takeown, attrib) and enforce least privilege on who may modify ACLs, but these are built-in Windows tools that cannot be removed without breaking the OS, so the technique remains runnable by any account with sufficient privilege — a slice of prevention, not the bulk.
- T1222.002partialdetects — A.8.9's configuration monitoring compares actual configurations against target templates and addresses deviations, so file permission changes on assets tracked in the baseline (e.g., critical system files whose ACLs are part of the secure template) can be surfaced as deviations; however, the clause's scope is system-level configuration management rather than file-integrity or ACL monitoring, so chmod/chown on files outside the tracked baseline, and changes between scheduled reviews, are not caught.
- T1222.002partialprevents — A.8.9 restricts access to powerful utility programs and enforces standard permission templates, which constrains who can run chmod/chown and what changes are permitted, but the underlying utilities are essential system tools that cannot be removed, so an adversary with sufficient privilege can still execute the technique.
- T1484partialdetects — A.8.9 explicitly requires monitoring of configurations, comparison against target templates, and review of deviations (including via system management tools and logs of changes), which surfaces unauthorized or anomalous modifications to domain/tenant policy settings such as GPOs or trust relationships; however, this is limited to post-change detection on managed assets and does not address pre-modification reconnaissance, temporary changes that are reverted, or modifications outside the organization's monitored estate.
- T1484partialprevents — A.8.9 restricts who holds privileged or administrator rights and can automatically enforce target configurations, which prevents some instances of unauthorized domain/tenant policy modification; however, the technique explicitly requires 'sufficient permissions,' so adversaries with legitimate admin access can still execute it, and the control's primary contribution here is detection and reversion rather than prevention of execution.
- T1484partialrecovers — A.8.9's monitoring and 'automatic enforcement of the defined target configuration' can revert unauthorized domain/tenant policy changes, restoring the configuration state; however, it does not undo the downstream impact realised while the malicious policy was in effect (e.g. already-pushed scheduled tasks, forged tokens, rogue federation trusts), and the adversary may self-revert before detection, so recovery is partial.
- T1484.001partialdetects — A.8.9's monitoring of configurations against target templates and detection of deviations can surface unauthorized GPO modifications as configuration drift, but the clause's primary purpose is preventive (establishing and enforcing secure baselines), the scope of what is monitored is implementation-dependent, and the detection is of deviations generally rather than adversarial GPO abuse specifically.
- T1484.001partialprevents — A.8.9 establishes secure baseline GPO configurations, restricts who has write access through standard templates and privileged-access minimisation, and requires changes to follow change management — so adversaries without delegated GPO-write rights cannot run the technique. It does not reach `mostly` because GPOs are essential to AD and cannot be removed (unlike the default-account case), and the technique specifically targets delegated permissions, meaning an adversary who has compromised an account with write access still executes it.
- T1484.002partialdetects — A.8.9's monitoring clause compares actual configurations against target templates and addresses deviations, so trust modifications on AD or identity-provider configurations CAN be surfaced if those trust objects are part of the monitored baseline; the extent is partial because the clause sets a general configuration-monitoring requirement rather than mandating trust relationships as a monitored item, and detection depends on implementation scope.
- T1484.002partialprevents — A.8.9's change management process and privileged access minimization provide preventive effect against unauthorized trust modifications, but trust relationships are necessary for the environment to function and cannot be removed like default accounts; an adversary with sufficient privileges can still execute the technique, so the prevention is partial rather than full.
- T1485.001partialdetects — A.8.9 requires monitoring configurations and comparing actual configurations against defined templates, which would surface a lifecycle policy change as a deviation, but the monitoring is periodic review rather than real-time alerting, so detection is a scheduled check and not an immediate observation.
- T1485.001partialprevents — A.8.9 constrains the attack surface through least privilege on identities with bucket-policy permissions, change-management gating of configuration changes, and monitoring of configuration drift, but the permissions required to modify lifecycle policies must exist for legitimate administration, so an adversary who compromises a sufficiently privileged identity can still execute the API call.
- T1489partialdetects — A.8.9's 'Monitoring configurations' clause compares actual configurations against target templates and addresses deviations, so a stopped service is a detectable configuration drift; however, the clause's monitoring is periodic and oriented toward security settings (passwords, parameters, privileges) rather than service availability, and real-time or comprehensive service-state detection belongs more naturally to A.8.16/A.8.15.
- T1489partialrecovers — A.8.9's monitoring-and-correction clause detects deviations from the target configuration and addresses them by automatic enforcement or manual corrective action; a stopped service is a deviation from a configured 'running' state, so the control can restore it. But the control's purpose is security configuration rather than service availability, the recovery depends on whether service states are within the managed configuration set, and the corrective action is often manual rather than immediate — so the recovery is real but incidental, not the control's primary act.
- T1490partialdetects — A.8.9's configuration monitoring compares actual state against target templates and surfaces deviations, so disabling recovery features (shadow copies, WinRE, backup catalog) would register as a configuration drift if those settings are in the template — but the detection is periodic state-comparison rather than real-time action observation, depends on template coverage of recovery-feature settings, and catches the effect of T1490 rather than the technique itself.
- T1491.001partialdetects — A.8.9's monitoring component compares actual configurations against defined target templates and addresses deviations, so defacement (wallpaper replacement, altered login banners, modified internal web content) constitutes configuration drift that the clause's monitoring would surface — but only where those items are tracked in the baseline, the comparison is typically periodic rather than continuous, and the clause's primary focus is security settings rather than arbitrary content, leaving a meaningful slice undetected.
- T1491.001partialrecovers — Configuration management's automatic enforcement of target templates restores defaced system settings like login messages and desktop wallpapers, but does not recover modified internal website content.
- T1491.002partialprevents — Configuration management prevents a meaningful slice of external defacement by hardening web server configurations, disabling unnecessary services, changing default credentials, and restricting access to configuration files — but it does not address application-layer vulnerabilities, stolen credentials, or zero-day exploits that are common defacement vectors, so the technique can still run.
- T1495partialprevents — A.8.9's restrictions on powerful utility programs, host parameter settings, and unnecessary services can limit access to firmware-flashing tools and reduce the attack surface, but firmware corruption operates below the OS configuration layer (UEFI/BIOS flash, supply chain, physical access) that A.8.9 governs, so the preventive effect is a slice rather than a mechanism that mostly works.
- T1496.001partialdetects — A.8.9's configuration monitoring can detect unauthorized software installations, unauthorized services, and configuration drift that often accompany compute hijacking (mining software, rogue containers, modified settings), but it monitors configuration state rather than resource consumption, which is the core of T1496.001 — so it catches a slice of the technique's footprint, not the technique itself.
- T1496.004partialdetects — A.8.9 monitors configurations and detects deviations from target templates, so it can surface the subset of T1496.004 where the adversary first enables a cloud service or alters service configuration to facilitate hijacking; it does not detect the core activity of using an already-compromised SaaS application for spam, LLMjacking, or quota exhaustion, which leaves most of the technique unobserved.
- T1496.004partialprevents — Configuration management can prevent some instances by disabling unused SaaS identities, restricting which identities can enable cloud services, and detecting unauthorized configuration changes that enable new services — but the technique's core path of abusing already-compromised legitimate credentials against services the victim actively uses is not addressed by A.8.9, which governs configuration rather than credential compromise.
- T1499partialprevents — Configuration management reduces attack surface by disabling unnecessary services, restricting powerful utilities, and applying hardening templates, which prevents some endpoint DoS vectors (e.g., exploits of unneeded services, default-config weaknesses), but it cannot prevent resource-exhaustion attacks or application-layer exploits against required services, so the class as a whole is only partially prevented.
- T1499.004partialprevents — Configuration management can disable unnecessary services and apply hardening that reduces the exploitable attack surface, preventing crashes of services that can be removed or restricted, but it cannot prevent exploitation of vulnerabilities in services that must remain running — the core of T1499.004 is code-level flaws in required software, which configuration does not address.
- T1505partialdetects — A.8.9's monitoring of configurations against defined target templates and logging of configuration changes can surface unauthorized server component installations as deviations from the baseline, but the clause's scope is set by what the organization includes in its configuration management — a baseline that does not enumerate expected server software components is fully conformant and detects nothing of T1505, so what is caught is a slice the implementer chose rather than a bounded remainder of a mechanism that mostly works.
- T1505partialprevents — A.8.9's standard templates can disable or restrict unnecessary server extensibility features and monitor for unauthorized component installations, which constrains T1505, but the technique abuses legitimate extensibility that many server applications require to function and an attacker with sufficient privileges can still install components, so the attack surface is reduced rather than eliminated.
- T1505.001partialdetects — A.8.9's monitoring of configuration changes can detect enabling of dangerous SQL Server features (xp_cmdshell, CLR integration) that adversaries enable to execute OS commands via stored procedures, and can flag deviations from approved database server configurations, but it does not directly detect the creation or modification of malicious stored procedures themselves, which are application-level database objects below the configuration-management scope.
- T1505.001partialprevents — Configuration management can disable dangerous extensions like xp_cmdshell and CLR integration, restrict who has privileged access to create or modify stored procedures, and detect unauthorized configuration changes — but stored procedures are a core database feature that cannot be removed, and a database administrator can still craft malicious procedures within legitimate functionality, so what is prevented is a slice rather than the technique itself.
- T1505.002partialdetects — A.8.9's monitoring component compares actual configurations against target templates and logs configuration changes, so a registered transport agent would be a deviation if the Exchange baseline includes the approved agent set — but the clause sets a general framework rather than mandating transport-agent-specific monitoring, and an implementation that baselines OS/network settings but not Exchange components is fully conformant yet sees nothing of this technique.
- T1505.002partialprevents — A.8.9's standard templates require minimizing privileged access and disabling unnecessary identities, and its change-management process gates configuration changes — so restricting who can register Exchange transport agents and requiring approval for Exchange configuration changes provides real preventive effect. However, transport agents are a legitimate Exchange feature that cannot be removed without breaking mail flow, and an actor with sufficient administrative access can still register a malicious agent, with configuration monitoring surfacing it after the fact rather than blocking it.
- T1505.003partialprevents — Configuration management can constrain web shell placement and execution through secure templates that restrict writable directories, limit script execution paths, disable unnecessary web server functions, and apply least privilege to web server processes, but it cannot prevent the application-level vulnerabilities through which web shells are typically uploaded, and the web server must remain functional, so the preventive effect is a slice rather than a closure.
- T1505.004partialdetects — A.8.9's monitoring-configurations clause compares actual configurations against defined target templates and addresses deviations, which is the mechanism that would surface an unauthorized ISAPI extension, filter or IIS module as a configuration drift. The grade is partial because the control is general-purpose: detecting T1505.004 requires the implementation to have defined an IIS-specific baseline that enumerates allowed components and to actually monitor IIS servers against it, and a sufficiently disguised or signed component can evade template-based comparison.
- T1505.004partialprevents — A.8.9's templates, change management (8.32), privileged-access minimization, and configuration monitoring constrain and gate the installation of IIS components, but the technique requires admin-level access to install ISAPI extensions/filters or modules, and configuration management is a procedural control that does not technically prevent a privileged actor from dropping a malicious DLL into the IIS pipeline — it restricts and detects rather than eliminates the technique.
- T1505.005partialprevents — A.8.9 establishes baselines, monitors for deviations, and can enforce configuration integrity (including file/registry changes to termsrv.dll or ServiceDll), but it does not mandate disabling Terminal Services or specifically target this DLL; prevention depends on whether the template restricts modification of system service DLLs and whether automatic enforcement is in place, leaving a bounded remainder where the technique runs against a conformant implementation.
- T1505.005partialrecovers — Configuration management tools can automatically revert unauthorized modifications to the ServiceDll registry key back to the approved baseline, but typically do not restore patched OS binaries like termsrv.dll.
- T1505.006partialdetects — A.8.9's 'Monitoring configurations' clause requires actual configurations to be compared against defined target templates and deviations addressed, so an unauthorized VIB installation, a change to the host acceptance level, or new firewall rules/startup tasks would surface as configuration deviations — but the clause sets scope and template content rather than mandating ESXi-specific depth, and VIBs masquerading as PartnerSupported by modifying the XML descriptor may not register as a deviation against a template that permits signed packages.
- T1505.006partialprevents — A.8.9 restricts privileged access, mandates change management for configuration changes, and monitors for deviations from baseline — all of which constrain who can install VIBs and surface unauthorized installations — but VIBs are a legitimate ESXi administrative function that cannot be removed, and a sufficiently privileged administrator can still install a malicious VIB through (or around) the change process, so what is prevented is a slice rather than the technique itself.
- T1525partialprevents — A.8.9's standard templates and access-restriction guidance (minimizing privileged identities, restricting access to powerful utilities, enforcing defined configurations for services including cloud services) can prevent unauthorized pushes to image registries and enforce use of approved/signed images, but the technique presupposes the adversary already has environment access and may have compromised an identity with legitimate push permissions, which configuration management alone does not stop.
- T1529partialprevents — Configuration management restricts who can invoke shutdown/reboot (minimizing privileged identities, restricting access to powerful utility programs, disabling unnecessary identities), but the underlying capability is a core OS function that cannot be removed without breaking the system, so the technique remains executable by anyone with sufficient access — analogous to the CM-7 vs T1059 anchor where required platform functions cannot be eliminated.
- T1535partialdetects — A.8.9's configuration monitoring compares actual configurations against defined target templates and addresses deviations, so if approved cloud regions are part of the configuration baseline, resource creation in unused regions surfaces as a deviation; however, the clause does not mandate that cloud region usage be included in the template, and the technique is specifically designed to exploit regions the organization has not configured monitoring for, so detection depends on implementation scope.
- T1535partialprevents — A.8.9's standard templates for cloud services can include approved-region restrictions and its monitoring can detect deviations, but the technique runs via compromised cloud-management credentials and specifically targets regions outside the organization's normal configuration scope, so configuration management constrains rather than eliminates the attack surface.
- T1537partialprevents — Configuration management can constrain the attack surface by disabling unnecessary cloud sharing/sync features, restricting cross-account permissions, and applying least-privilege templates to cloud identities, but T1537 uses legitimate cloud provider APIs and native mechanisms (sharing links, SAS URIs, backup transfers) that are often required for normal operations, so configuration cannot fully prevent the technique.
- T1538partialprevents — Configuration management can reduce the attack surface by disabling unnecessary cloud service accounts, restricting dashboard access via least privilege, and limiting exposed services, but it does not prevent the use of stolen valid credentials to access a dashboard — the technique's core mechanism is credential misuse, which configuration management alone cannot stop.
- T1542partialprevents — A.8.9's standard templates can disable unnecessary firmware features and enforce secure boot configurations, but the control operates primarily at the OS and application layers and cannot prevent an adversary with physical or privileged access from overwriting firmware or boot drivers that are required for the system to function.
- T1542.001partialdetects — A.8.9 monitors configurations and detects deviations from target templates, and firmware is within its stated scope of 'hardware'; however, the control sets scope rather than mandating instrumentation depth, so an implementation monitoring only OS-level configurations is fully conformant and sees nothing of firmware tampering, and sophisticated UEFI/BIOS modifications can evade standard system management tools.
- T1542.001partialprevents — A.8.9's scope includes hardware and can enforce restrictions that close some firmware-modification vectors (disabling OS-level firmware update utilities, restricting access to flashing tools, securing firmware management interfaces), but the control operates at the configuration layer above firmware and cannot reach hardware-level attacks, physical access, or sophisticated low-level exploits that bypass OS controls — so it prevents a slice of the technique's pathways rather than the technique itself.
- T1542.002partialprevents — A.8.9 can configure secure boot, TPM, firmware integrity checks and restrict access to firmware update utilities, which constrains the technique, but firmware modification occurs below the OS and outside the reach of standard configuration templates and system management tools, so what is prevented is a slice rather than the technique itself.
- T1542.003partialprevents — A.8.9's secure configuration templates can disable unnecessary functions and restrict access to powerful utilities, which reduces the attack surface for bootkit installation, but bootkits operate below the OS and can persist despite configuration hardening, leaving a significant remainder.
- T1542.004partialdetects — A.8.9 requires monitoring configurations and comparing actual configurations to defined target templates, which can surface an unauthorized ROMMON image change, but the technique's own description notes it is 'difficult to detect' and the control's monitoring scope depends on implementation depth, so what is caught is a slice rather than a bounded remainder.
- T1542.004partialprevents — A.8.9 mandates disabling unnecessary services and restricting access to powerful utilities and host parameter settings, which can prevent remote ROMMONkit via TFTP or restrict boot modes, but the control operates at the configuration layer above the firmware layer and does not address firmware integrity, local ROMMON replacement, or attacks via other vectors.
- T1542.005partialdetects — A.8.9's monitoring of configurations (comparing actual vs target templates, logging changes) can detect the unauthorized manipulation of the network device's boot configuration pointing to a malicious TFTP server, but only where network devices and their boot settings fall within the monitored configuration scope; the actual loading of the unauthorized image is not directly surfaced by configuration comparison alone.
- T1542.005partialprevents — A.8.9's configuration templates and monitoring can enforce the boot order and restrict the TFTP server address, but the technique abuses a legitimate netbooting function that many network devices require, so the control constrains rather than eliminates the vector.
- T1543.001partialdetects — A.8.9's configuration monitoring mechanism (comparing actual configurations against target templates and flagging deviations) can surface unauthorized .plist files in LaunchAgent directories if those paths are included in the organization's monitored configuration baseline, but the clause sets scope through the organization's own template definitions rather than mandating specific coverage of persistence directories, so detection depends on implementation choices.
- T1543.001partialprevents — A.8.9 establishes baseline templates and monitors for deviations, which can restrict or detect unauthorized launch agents, but the technique's user-writable directories (~/Library/LaunchAgents) remain inherently writable and the control's monitoring/auto-enforcement acts after the deviation occurs, so the technique can still execute even where configuration management is fully implemented.
- T1543.002partialdetects — A.8.9 requires monitoring configurations and comparing actual configurations against defined templates, which can surface unauthorized systemd service files or modifications, but the monitoring scope is set by the organization's requirements rather than mandating specific file-integrity monitoring depth, so detection is a slice the implementer chooses rather than a bounded remainder of a mechanism that mostly works.
- T1543.002partialprevents — A.8.9's baseline enforcement, restriction of privileged access, and deviation monitoring can prevent unauthorized systemd service creation in many cases, but the control is general configuration management rather than a specific guard against this technique: adversaries with sufficient privileges can still create or modify .service files, use systemd generators, or place symlinks, and the clause's change-management process can legitimate persistence if not specifically scoped against it.
- T1543.003partialprevents — Configuration management prevents some instances by restricting access to service-management utilities (sc.exe, PnPUtil.exe), enforcing change management that catches unauthorized service creation/modification, and monitoring for deviations from approved service configurations; however, the Windows Service infrastructure is required for OS operation and cannot be removed, and an actor with admin/SYSTEM privileges retains multiple vectors (Registry edits, Native API, direct service creation) that configuration management alone does not block.
- T1543.004partialdetects — A.8.9's 'Monitoring configurations' clause requires actual configurations to be compared with defined target templates and deviations addressed, which surfaces unauthorized additions or modifications to Launch Daemon plist files when those files are within the monitored baseline; extent is partial because the clause sets scope by what the organization includes in its configuration templates, and a baseline that omits /Library/LaunchDaemons/ or treats plist contents as out-of-scope is fully conformant yet sees nothing of this technique.
- T1543.004partialprevents — A.8.9's guidance on restricting privileged access, disabling unnecessary services, and monitoring configuration deviations against target templates constrains who can write to /Library/LaunchDaemons/ and surfaces unauthorized plist files, but Launch Daemons are a legitimate macOS mechanism that cannot be removed, and the technique requires elevated privileges which, once obtained, allow installation despite configuration controls.
- T1543.005partialdetects — A.8.9's monitoring component compares actual configurations against defined target templates and flags deviations, which would surface unauthorized modifications to kubelet, Docker/Podman daemon settings, or new DaemonSets not in the baseline; however, the clause's detection scope is bounded by what the configuration template actually enumerates, and runtime container creation or changes that mimic legitimate orchestration activity may not register as deviations, leaving a slice rather than the bulk detected.
- T1543.005partialprevents — A.8.9 can disable or restrict unnecessary container services (Docker, Podman, kubelet) where they are not business-required, removing the attack surface entirely; but in containerized environments these services are typically required and must remain, and the technique exploits existing services rather than requiring new installation, so a bounded slice is prevented while the common case persists.
- T1546partialprevents — Configuration management can disable or restrict unnecessary trigger mechanisms (WMI subscriptions, launchd, cron, cloud event functions) and restrict access to the utilities that create them, but many event-trigger mechanisms are core OS functionality that cannot be removed without breaking the platform, so a meaningful slice of T1546 remains reachable.
- T1546.001partialdetects — A.8.9's monitoring clause compares actual configurations against target templates and addresses deviations, so if file association registry keys are included in the secure configuration baseline, changes to them are surfaced; however, the clause sets a framework rather than mandating file associations specifically, leaving scope implementation-dependent, similar to the A.8.16/T1055 partial anchor.
- T1546.001partialprevents — A.8.9 can prevent unauthorized file association changes by restricting Registry write access and enforcing standard configuration baselines that include file handlers, but the technique's mechanism (Registry modification of HKEY_CLASSES_ROOT) is a legitimate OS function that must remain available to authorized administrators, and file associations are not always enumerated in standard templates, so a meaningful slice of changes cannot be prevented.
- T1546.002partialdetects — A.8.9's configuration monitoring compares actual settings against target templates and surfaces deviations, so unauthorized changes to screensaver registry values (SCRNSAVE.exe, ScreenSaveActive, ScreenSaveTimeout) are detectable when those keys are part of the baseline; the remainder is that detection depends on the baseline including these specific settings and on the change being a deviation rather than a permitted configuration, which is not guaranteed.
- T1546.002partialprevents — A.8.9's standard templates can disable or restrict unnecessary functions and services, which could include blocking the screensaver mechanism entirely, but the technique's registry-based persistence can still be established through other means or on systems where screensavers are required.
- T1546.003partialprevents — Configuration management can restrict who has the privileges needed to create WMI event subscriptions (via minimizing privileged identities and restricting access to powerful utilities) and can disable or restrict WMI where not needed, but WMI is a core Windows component that cannot be removed without breaking the platform, and administrators with legitimate access can still create malicious subscriptions — so what is prevented is a slice, not the bulk.
- T1546.004partialdetects — A.8.9's monitoring section compares actual configurations against target templates and addresses deviations, which would surface modifications to shell config files (e.g. .bashrc, /etc/profile) when those files are included in the configuration baseline; the extent is partial because the clause sets scope via the organization's defined templates rather than mandating that shell startup files be monitored, and the detection is of deviation from baseline rather than of malicious intent.
- T1546.004partialprevents — Configuration management establishes baselines for shell config files, monitors them for unauthorized changes, and can automatically enforce the target configuration to revert deviations, which prevents the persistence aspect of the technique; however, the shell config files are necessary for system function and cannot be eliminated, the malicious commands still execute in the window before detection/remediation, and an attacker with sufficient privileges can disable the control, so prevention is partial rather than full.
- T1546.007partialdetects — A.8.9's monitoring of configurations against defined target templates can detect unauthorized additions to the Netsh registry keys as configuration deviations, but the scope depends on what the templates include — an implementation whose baseline omits HKLM\SOFTWARE\Microsoft\Netsh is fully conformant and sees nothing of this technique.
- T1546.007partialprevents — Configuration management can restrict access to netsh.exe as a powerful utility program and monitor registry deviations from baseline templates, but the technique requires HKLM write access which an attacker with sufficient privileges retains; netsh.exe is a built-in utility that cannot be removed without breaking network functionality, so the prevention is a slice rather than a closure.
- T1546.008partialdetects — A.8.9 requires monitoring configurations and comparing actual configurations against defined target templates, which can surface unauthorized changes to accessibility feature binaries or registry pointers, but the monitoring scope is set by the organization's requirements rather than mandating the depth of host-level file integrity monitoring needed to catch every instance.
- T1546.008partialprevents — A.8.9's standard templates can disable unnecessary accessibility features and restrict access to powerful utility programs, but the technique can still succeed by modifying registry pointers or using Image File Execution Options Injection without replacing the binary, leaving a reachable remainder.
- T1546.009partialdetects — A.8.9's configuration monitoring compares actual configurations against defined target templates and addresses deviations, so a Registry key modification like AppCertDLLs can be surfaced if the organization's baseline includes that key as a security-relevant setting; however, the clause sets scope via the organization's templates rather than mandating Registry instrumentation, and a conformant implementation focused on other configuration domains would not detect this specific persistence mechanism.
- T1546.009partialprevents — A.8.9's guidance to disable unnecessary identities and restrict unnecessary functions can prevent the AppCertDLLs key from being set if the adversary's access is limited, but it does not directly block the loading mechanism itself, leaving a path for privileged actors or misconfigurations.
- T1546.010partialprevents — A.8.9's standard templates can disable the AppInit_DLLs registry value or the feature itself, preventing the technique from running on systems where the configuration is enforced, but the control does not guarantee this setting is applied universally or cannot be bypassed.
- T1546.011partialdetects — A.8.9 requires logging all configuration changes and comparing actual configurations against defined target templates, so a shim installation via sdbinst.exe would surface as a logged change and a potential deviation — but the control detects unauthorized configuration changes generally, not application shimming specifically, and whether shims are caught depends on whether the standard template excludes them and whether monitoring reaches the shim database locations.
- T1546.011partialprevents — A.8.9 can restrict the Application Compatibility service, block sdbinst.exe via execution policies, and enforce least privilege on the admin rights needed to install shims, but the shimming infrastructure is core to Windows backward compatibility and cannot be removed without breaking legitimate applications, so the technique remains reachable in many configurations.
- T1546.012partialdetects — A.8.9's monitoring of configurations against target templates can surface IFEO registry modifications as deviations, but the clause sets scope through the organization's chosen baseline rather than mandating coverage of these specific keys, so an implementation conformant with A.8.9 that omits IFEO registry paths from its template detects nothing of this technique.
- T1546.012partialprevents — A.8.9 mandates disabling unnecessary identities and restricting unnecessary functions, which can prevent the IFEO Registry keys from being set if the adversary lacks the required privileges, but it does not prevent a privileged actor from making the change.
- T1546.013partialdetects — A.8.9's monitoring section requires comparing actual configurations against target templates and addressing deviations, so unauthorized modifications to PowerShell profiles are detectable as configuration drift if profiles fall within the monitored baseline; extent is partial because inclusion of PowerShell profile files in the configuration template is an implementation choice, and the control surfaces the deviation rather than identifying malicious intent.
- T1546.013partialprevents — Configuration management can enforce ACLs on profile.ps1 files, restrict who may modify them, and monitor for deviations, which prevents unauthorized profile tampering in many cases; however, PowerShell is typically a required Windows component and users commonly retain write access to their own profile directories, so where the adversary obtains that access the technique still runs.
- T1546.013partialrecovers — A.8.9's monitoring and automatic enforcement of target configurations can detect a modified PowerShell profile and restore it to the defined baseline, removing the persistence mechanism; however, recovery is contingent on the profile being within the configuration baseline scope and does not address other persistence footholds the adversary may have established.
- T1546.014partialdetects — A.8.9's configuration monitoring compares actual configurations against target templates and addresses deviations, so an emond rule file placed in /etc/emond.d/rules/ is detectable if that path and the emond daemon are within the monitored baseline; the clause sets scope rather than mandating that emond specifically be included, so detection depends on implementation choice.
- T1546.014partialprevents — Configuration management can monitor /etc/emond.d/rules/ for unauthorized rule files, restrict access to that directory, and potentially disable or restrict the emond service if deemed unnecessary, but emond is a default macOS system service typically left running, and the technique can still execute if an adversary obtains write access to the rules directory before configuration monitoring catches the deviation.
- T1546.015partialdetects — A.8.9's monitoring-of-configurations clause compares actual configurations against defined target templates and addresses deviations, which is a detection mechanism for unauthorized configuration changes including Registry modifications; however, whether COM object Registry entries fall inside the monitored baseline is implementation-dependent, so what is caught is a slice the implementer chose rather than a bounded remainder of a mechanism that mostly works.
- T1546.015partialprevents — A.8.9's least-functionality and template-enforcement provisions can disable or restrict unnecessary COM objects so they cannot be hijacked, but the technique specifically targets COM objects that are 'used frequently enough' for normal system operation — those cannot be removed without breaking the system, mirroring the cm-7 vs T1059 anchor where required interpreters stay reachable.
- T1546.017partialdetects — A.8.9's monitoring clause compares actual configurations against target templates and surfaces deviations, which would catch unauthorized additions or modifications to udev rule files if those files are within the monitored configuration baseline; the extent is partial because the control's scope is set by what the organization includes in its baseline, and udev rule directories are not universally mandated for monitoring.
- T1546.017partialprevents — A.8.9 can restrict write access to udev rule directories and enforce baseline configurations that flag unauthorized changes, but the technique explicitly requires root permissions and configuration management does not prevent a root-level actor from modifying these files — udev itself cannot be disabled as it is a core Linux subsystem.
- T1546.018partialprevents — A.8.9 can define secure configuration baselines that restrict or monitor Python startup mechanisms (e.g., controlling write access to site-packages, detecting unauthorized .pth files or sitecustomize.py), but it does not inherently prevent the technique: Python is often required for legitimate operations and cannot simply be removed, and restricting write access to Python directories is more directly an access control concern (A.8.2/A.8.3) than configuration management itself.
- T1547partialdetects — A.8.9's monitoring of configurations, comparison against secure templates, and review of deviations (including privileged identities, unnecessary services, and changes) can surface some T1547 artifacts such as unauthorized autostart entries or registry/boot changes after they occur, but this is limited to post-placement detection on managed assets and does not cover kernel modifications, pre-compromise adversary setup on network devices, or all platforms/mechanisms in the technique.
- T1547partialprevents — A.8.9 establishes secure configuration baselines that disable or restrict unnecessary autostart mechanisms, restrict privileged access to modify them, and detect deviations, which constrains the attack surface; however, some autostart mechanisms must remain functional for system operation, the technique spans many vectors across platforms (Registry, LaunchAgents, systemd, kernel extensions), and an adversary with sufficient privileges can still configure autostart entries, so the technique is reduced but not eliminated.
- T1547.001partialdetects — A.8.9's monitoring of configurations against defined templates and its change-management logging would surface unauthorized additions to registry run keys and startup folders as deviations, but detection is periodic and depends on the template explicitly covering these locations, and the clause's purpose is configuration drift rather than threat detection.
- T1547.001partialprevents — A.8.9's configuration monitoring and enforcement can detect and revert unauthorized registry run key or startup folder additions, but the control does not prevent an adversary with sufficient privileges from writing to these locations in the first place.
- T1547.002partialdetects — A.8.9's monitoring clause requires actual configurations to be compared against defined target templates and deviations addressed, and the LSA Authentication Packages registry value is a configuration item that can be included in such templates; however, the control sets a general mechanism whose scope depends on what the templates enumerate, so detection of this specific persistence mechanism is a slice of what the monitoring covers rather than a guaranteed catch.
- T1547.002partialprevents — A.8.9 can define the legitimate authentication packages in a baseline and auto-enforce the target configuration, which would revert a malicious LSA registry entry before it takes effect at boot; however, the registry write itself is not blocked, and there is a timing window between the write and the next configuration check during which the persistence could survive, so what is prevented is a slice rather than the bulk.
- T1547.003partialdetects — A.8.9's configuration monitoring compares actual state against target templates and addresses deviations; an unauthorized new subkey under W32Time\TimeProviders\ would be a detectable drift if the baseline includes those registry keys, but detection is conditional on baseline scope, typically periodic rather than real-time, and surfaces a configuration change rather than malicious intent.
- T1547.003partialprevents — A.8.9's guidance to disable or restrict unnecessary functions and services can prevent the technique where W32Time is disabled, and minimizing privileged access and monitoring registry deviations constrains the attack surface; however, W32Time is required on domain-joined systems and the technique specifically requires administrator privileges, so the control cannot fully prevent it across all configurations.
- T1547.004partialdetects — A.8.9's monitoring component compares actual configurations against target templates and addresses deviations, so if the Winlogon registry keys are included in the configuration baseline, unauthorized modifications enabling T1547.004 would be surfaced as configuration drift; however, the clause sets scope by what the organization chooses to baseline, and implementations that do not enumerate these specific registry keys — or that monitor only periodically rather than at the moment of change — will miss the technique, leaving a nameable remainder rather than a bounded one.
- T1547.004partialprevents — A.8.9's configuration management can prevent this technique by enforcing a secure baseline that restricts write access to the Winlogon registry keys, but the control's scope is broad and does not guarantee this specific hardening on every system.
- T1547.005partialdetects — A.8.9's monitoring section requires comparing actual configurations against target templates and addressing deviations, which provides a mechanism that can surface unauthorized SSP registry additions if those keys are in the monitored baseline; however, the clause sets the framework rather than mandating SSP keys specifically, so an implementation monitoring other configuration items is fully conformant and sees nothing of this technique.
- T1547.005partialprevents — A.8.9 establishes baselines for registry configurations (including the SSP keys), restricts privileged access, and monitors for deviations with potential automatic enforcement, which constrains the technique; however, the SSP mechanism is built into Windows and cannot be removed, and an attacker with sufficient privileges can still attempt the modification, so the prevention is a slice rather than a closure.
- T1547.006partialdetects — A.8.9's monitoring of configurations against target templates can detect unauthorized kernel modules when they are included in the configuration baseline, but the clause sets scope through defined templates rather than mandating kernel-module coverage, so an implementation tracking only higher-level configurations is fully conformant and sees nothing of an LKM/kext load.
- T1547.006partialprevents — A.8.9's templates can disable or restrict module-loading utilities (insmod, modprobe, kextload), enforce module-signing requirements, and restrict access to powerful system utilities, which constrains the technique; however, the technique operates at Ring 0 where a privileged adversary can often bypass configuration controls, and many systems require kernel modules for basic operation, so the prevention is a slice rather than a closure.
- T1547.007partialprevents — Configuration management can restrict write access to the ~/Library/Preferences/ByHost plist files, enforce secure templates that disable the 'Reopen windows' feature via MDM/configuration profiles, and monitor/alert on deviations — but the technique operates at the user-preferences level on macOS, which standard system configuration baselines may not fully reach, and the GUI-driven checkbox behavior is not directly controlled by A.8.9's templates.
- T1547.008partialdetects — A.8.9's monitoring component compares actual configurations against defined target templates and logs configuration changes, so an added or replaced LSASS driver is a configuration deviation the process can surface — but only where driver-level configuration is in the monitored scope, which the clause leaves to the implementer rather than mandating.
- T1547.008partialprevents — A.8.9's standard templates can restrict who may install or modify drivers and can lock down LSASS-related configuration, and its monitoring surfaces unauthorized driver additions, but the clause addresses general configuration hardening rather than the specific LSASS driver-loading mechanism, so prevention is a slice of the attack surface rather than a complete block.
- T1547.009partialprevents — A.8.9 establishes baseline configurations and monitors for deviations, which can restrict write access to startup folders and detect unauthorized shortcut creation, but it does not directly prohibit the action — users with configuration-change rights can still create shortcuts, and the clause's mechanism is baseline enforcement and deviation correction rather than blocking the initial write, so the technique can still run.
- T1547.010partialdetects — A.8.9's configuration monitoring compares actual configurations against defined target templates, so a new subkey or modified Driver value under HKLM\SYSTEM\CurrentControlSet\Control\Print\Monitors would be a detectable deviation if the template enumerates expected port monitor entries; however, the clause sets the scope through the organization's chosen templates rather than mandating coverage of this specific registry path, so detection depends on what the implementer defined and is incidental to drift detection rather than a designed-in capability for this technique.
- T1547.010partialprevents — A.8.9's guidance to disable or restrict unnecessary functions and services directly enables disabling the print spooler where it is not required, which prevents the technique; but where the print spooler is needed (common in many environments), restricting registry write permissions to Print\Monitors is a partial mitigation that admin-level actors can still bypass, leaving a named remainder.
- T1547.012partialdetects — A.8.9's configuration monitoring (comparing actual configurations against target templates and tracking configuration changes) can surface the addition of a new print processor as a deviation — the registry key under Control\Print\Environments and a DLL in the print-processor directory are configuration artifacts within scope — but detection depends on the comprehensiveness of the system management tools and whether registry/file-system changes in system directories are covered, which the clause does not mandate.
- T1547.012partialprevents — A.8.9's standard templates require disabling or restricting unnecessary functions and services and minimizing privileged access (SeLoadDriverPrivilege is needed to install print processors), so where the print spooler service is disabled as unnecessary or the privilege is restricted the technique cannot run; however, many systems legitimately require the print spooler service and A.8.9 does not mandate its removal, so the technique remains viable on those systems.
- T1547.013partialdetects — A.8.9's monitoring clause compares actual configurations against defined target templates and logs configuration changes, which can surface unauthorized additions or modifications to XDG Autostart `.desktop` files when those paths are included in the baseline; detection is partial because the control sets a general framework rather than mandating these specific directories, so an implementation that omits `/etc/xdg/autostart` and `~/.config/autostart` from its monitored template sees nothing of this technique.
- T1547.013partialprevents — Configuration management can define baselines for XDG autostart directories, monitor for unauthorized .desktop file additions, and enforce deviations through automated tools, but user-writable paths (~/.config/autostart) and masquerading limit how completely the technique can be prevented.
- T1547.014partialdetects — A.8.9's monitoring of configurations and comparison of actual against target templates can detect unauthorized additions to Active Setup registry keys as configuration deviations, but the clause sets a general framework rather than mandating Active Setup specifically — detection depends on whether those registry paths are included in the monitored configuration baseline.
- T1547.014partialprevents — Configuration management can restrict write access to the Active Setup registry keys via permissions and Group Policy, monitor for unauthorized changes, and alert on deviations from the baseline, but Active Setup is a built-in Windows mechanism required for legitimate logon-time execution, so it cannot be fully disabled without breaking the OS, and a sufficiently privileged adversary can still modify the keys.
- T1547.015partialdetects — A.8.9's configuration monitoring compares actual configurations against target templates and flags deviations, so unauthorized login items included in the baseline would be surfaced; however, detection depends on whether login items are scoped into the template, and SMF-based login items are hidden from System Preferences and may evade configuration-comparison tools that read user-visible state.
- T1547.015partialprevents — A.8.9's standard templates and configuration monitoring can restrict login item additions (e.g., via MDM configuration profiles locking down user environments and detecting deviations), but login items are a legitimate macOS feature that cannot be fully eliminated, and the technique can be executed through AppleScript, Native API calls, or Service Management Framework that may bypass template enforcement, leaving a meaningful remainder.
- T1548partialdetects — A.8.9's monitoring of configuration changes and deviations from secure templates detects the subset of T1548 that involves weakening elevation controls through configuration changes (e.g., disabling UAC, modifying sudoers), but does not detect exploitation of vulnerabilities in elevation mechanisms, social-engineering a user to approve elevation, or abuse of an already-misconfigured system without further change.
- T1548partialprevents — Configuration management can constrain T1548 by setting secure templates for elevation mechanisms (UAC level, sudoers policy, removing unnecessary privileged identities, disabling unnecessary services that enable elevation), but the elevation mechanisms themselves are core OS features that cannot be removed, and many T1548 sub-techniques exploit vulnerabilities or design features of those mechanisms rather than misconfigurations, leaving a substantial remainder.
- T1548.001partialdetects — A.8.9's configuration monitoring (comparing actual configurations against target templates and flagging deviations) can surface unauthorized setuid/setgid bit changes on binaries when file permissions are within the monitored baseline, but detection is scope-dependent on what the template covers and does not reach the discovery of pre-existing setuid binaries or the actual abuse/execution of those binaries.
- T1548.001partialprevents — A.8.9's configuration templates can disable unnecessary setuid/setgid binaries and restrict the ability to set these bits, but the technique also abuses existing legitimate setuid binaries that the organization must keep for operational reasons, so prevention is a slice rather than complete.
- T1548.002partialprevents — Configuration management can enforce the highest UAC level via standard templates, which blocks bypass methods that rely on lower UAC settings, but many documented UAC bypasses (auto-elevating COM objects, trusted-process injection, credential-based lateral movement) work regardless of UAC configuration, leaving a substantial remainder the control cannot reach.
- T1548.003partialdetects — A.8.9's configuration monitoring can detect unauthorized modifications to /etc/sudoers (e.g., NOPASSWD entries, disabling tty_tickets) when the file is in the configuration baseline, but cannot detect abuse of legitimate sudo caching within timestamp_timeout or exploitation of pre-existing misconfigurations that involve no configuration change.
- T1548.003partialprevents — A.8.9's configuration templates can disable unnecessary identities and restrict powerful utilities, which can prevent sudo caching abuse, but the technique also exploits legitimate sudo configurations that the control's least-functionality guidance does not fully eliminate.
- T1548.004partialprevents — A.8.9 can restrict which programs are permitted to execute and limit powerful utility programs via standard templates, which constrains the surface for AuthorizationExecuteWithPrivileges abuse, but the API is built into macOS and cannot be removed, and the technique's core mechanism — a user voluntarily entering credentials when prompted, including by a modified legitimate program — is not something configuration management can stop.
- T1548.005partialprevents — A.8.9's standard templates, change management, and configuration monitoring directly address the misconfigured permission structures (overly broad JIT access, impersonation rights, PassRole grants) that enable this technique, but cannot prevent abuse of legitimately configured just-in-time or impersonation features by a compromised or malicious privileged account.
- T1548.006partialdetects — Configuration monitoring can detect deviations in TCC database integrity or SIP-disabled state if those are part of the monitored baseline, but the core technique—abusing already-granted permissions via process injection or loading alternate TCC databases via environment variables—operates below the configuration-drift surface A.8.9 monitors.
- T1548.006partialprevents — A.8.9's standard templates can include macOS hardening that enables SIP (blocking direct TCC database manipulation) and restricts access to tools like Launchctl and environment-variable manipulation, but the control is platform-general and does not specifically address TCC; abuse of legitimately granted TCC permissions via process injection or trusted-app execution falls outside what configuration management can prevent.
- T1550partialprevents — Configuration management can disable specific credential-caching mechanisms (e.g., WDigest, LM hash storage), restrict services that expose hashes, and limit privileged accounts that elevate the value of stolen material, but it cannot remove the underlying mechanism: Kerberos tickets, SSO tokens and similar alternate material are generated by the system as a necessary part of authentication, so the technique's core vectors remain reachable.
- T1550.001partialprevents — Configuration management can constrain token-based authentication through secure OAuth configurations (scopes, lifetimes, refresh policies, conditional access, disabling unnecessary service identities), but cannot prevent the technique because tokens are fundamental to modern cloud/SaaS architectures and a stolen valid token remains usable regardless of baseline hardening — the technique exploits valid credentials, not misconfigurations.
- T1550.002partialprevents — Configuration management can disable unnecessary accounts, restrict NTLM usage, disable LM hash storage, and limit privileged identities — all of which reduce the attack surface for PtH — but the technique exploits the hash-based authentication protocol itself, so as long as NTLM or similar mechanisms remain enabled for compatibility, valid hashes can still be reused for lateral movement.
- T1552partialprevents — Configuration management can mandate secure credential storage in standard templates (e.g., restricting file permissions on credential stores, configuring applications to use secure credential vaults, disabling shell history recording of sensitive commands, restricting access to powerful utilities), but cannot prevent all forms of unsecured credentials — user-created files, hardcoded credentials in application code, and historical artifacts in logs/backups sit outside what configuration templates govern.
- T1552.001partialprevents — A.8.9 establishes secure configuration templates and monitors for deviations, which can prevent credentials from being stored in standardized configuration files (e.g., mandating secret management instead of plaintext secrets in config), but the technique also covers user-created credential files, source code with embedded passwords, container deployment logs, and shared credential stores that configuration management does not reach.
- T1552.002partialprevents — A.8.9's standard templates can restrict access to powerful utility programs (including registry query tools) and configure systems to minimize insecure credential storage, reducing the technique's success; however, the clause does not specifically mandate registry credential hygiene, the search action itself can still execute, and credentials stored by legitimate applications or pre-existing configurations remain findable, so the prevention is partial rather than complete.
- T1552.003partialprevents — A.8.9's standard-template guidance includes disabling or restricting unnecessary functions and services, which can be applied to disable shell history (HISTSIZE=0, HISTFILE=/dev/null, restrictive permissions on history files, disabling persistent PowerShell history), so a well-implemented configuration baseline can prevent the technique; but the clause is general and does not mandate this specific configuration, shell history is often retained as a useful feature, and the technique's root cause — users typing credentials on the command line — is a user-behavior issue configuration management does not reach.
- T1552.004partialprevents — A.8.9's guidance to disable unnecessary identities and change vendor defaults can prevent private keys from being present or accessible, but it does not address keys that are legitimately required or stored insecurely by design.
- T1552.005partialprevents — Configuration management can enforce IMDSv2 (token-based access) and restrict metadata service settings, mitigating the SSRF vector, but the metadata API is a fundamental cloud service that cannot be disabled on a running instance, so an adversary with code execution on the instance can still query it directly.
- T1552.007partialprevents — Configuration management can restrict access to container APIs (disabling remote Docker daemon access, enforcing authentication, applying least-privilege to service accounts, restricting unnecessary functions), which constrains the technique, but the APIs are functional necessities that cannot be removed and credentials stored in the environment remain reachable to anyone with valid API access, so the technique is reduced rather than eliminated.
- T1553partialdetects — A.8.9 monitors configurations against target templates and detects deviations, so configuration-based trust subversion (registry changes, permission modifications, certificate store alterations) is caught as drift from the baseline; however, the clause's scope is set by what the organization includes in its templates, and T1553 also encompasses non-configuration vectors (stealing existing code-signing certificates, runtime subversion) that leave no configuration artifact for A.8.9 to surface.
- T1553partialprevents — Configuration management can lock down trust-related settings (certificate stores, registry keys controlling Mark-of-the-Web/SmartScreen, code-signing policy) and restrict access to tools that modify them, preventing some subversion paths; it cannot prevent adversaries from stealing code-signing certificates externally or from subverting trust once they hold sufficient privileges to alter the locked-down configuration.
- T1553.001partialprevents — Configuration management can enforce Gatekeeper policy levels via MDM/configuration profiles and restrict user override of notarization, but the core bypass techniques — manipulating quarantine flags, writing to previously opened applications, exploiting logic errors, and using files from sources that don't set the quarantine flag — operate below the configuration layer and are not prevented by enforcing a secure baseline.
- T1553.003partialdetects — A.8.9's configuration monitoring against defined target templates can detect unauthorized Registry modifications to SIP/trust provider keys when those specific Cryptography Registry paths are included in the baseline, but coverage is implementation-dependent (the templates are organization-defined) and the DLL search order hijacking variant explicitly bypasses Registry-based detection.
- T1553.003partialprevents — Configuration management establishes baselines for registry values governing SIP and trust provider components and can enforce correct values, blocking the registry-modification variants; however, the technique explicitly notes the hijack is also achievable via DLL search order hijacking without touching the registry, and the clause's 'should be addressed' language (allowing manual analysis rather than automatic enforcement) leaves the preventive effect dependent on implementation choices.
- T1553.003partialrecovers — A.8.9 includes the automatic or manual enforcement of target configurations to correct deviations, which restores tampered registry keys to their authorized state, but this recovery is limited to the settings explicitly defined in the baseline.
- T1553.004partialdetects — A.8.9's configuration monitoring compares actual configurations against target templates and logs configuration changes, which can detect unauthorized root certificate installations if the trusted certificate store is included in the baseline; however, the clause sets scope through the baseline rather than mandating specific instrumentation of certificate stores, so an implementation that omits certificate stores from its monitored baseline is fully conformant and sees nothing of this technique.
- T1553.004partialprevents — A.8.9 restricts access to powerful utilities and host parameter settings, monitors configuration changes, and detects deviations from baseline — all of which constrain certificate-store writes and surface unauthorized installations. But the certificate store is a necessary system component that admins must be able to modify for legitimate purposes, so the technique cannot be eliminated the way a default account can; a compromised admin or a process running with sufficient rights still installs the root certificate.
- T1553.005partialprevents — A.8.9's configuration templates can disable or restrict unnecessary functions and services, which could include blocking the execution of container file formats that bypass MOTW, but the control does not directly enforce MOTW inheritance or address the underlying NTFS limitation, leaving many bypass paths open.
- T1553.006partialdetects — A.8.9's monitoring clause requires actual configurations to be compared against target templates and deviations addressed, which surfaces changes to code signing policies when those settings are part of the monitored baseline; however, the clause sets the requirement rather than mandating that code signing specifically be in scope, and kernel-memory modifications (e.g. g_CiOptions) and debug-mode reboots can bypass standard configuration monitoring, leaving a bounded remainder.
- T1553.006partialprevents — A.8.9 establishes secure configuration templates that would include code signing enforcement, monitors for deviations, and routes changes through change management — preventing unauthorized or accidental policy modifications. However, the technique specifically targets these settings with elevated privileges (bcdedit, registry, kernel memory, recovery mode), and configuration management does not remove the underlying capability to modify signing policies once an adversary holds those privileges, so the prevention is partial rather than full.
- T1554partialrecovers — Configuration management can automatically enforce defined target configurations to revert unauthorized changes, but this only restores binaries that are explicitly managed and monitored by the configuration baseline.
- T1555partialprevents — A.8.9 can disable or restrict unnecessary credential storage mechanisms (browser password saving, unused credential caches), restrict access to credential stores via least-privilege configuration, and change default authentication information — measurably shrinking the attack surface for T1555. But credential storage is inherent to system function, memory-based extraction (LSASS, Mimikatz) is largely outside configuration's reach, and an adversary with sufficient privileges can often reach legitimate stores regardless of configuration, so the technique is reduced, not eliminated.
- T1555.003partialprevents — Configuration management can prevent the file-based variant by configuring browsers to not store credentials and restricting access to credential store files via standard templates, but cannot fully prevent memory-based extraction of credentials from browser processes or bypasses by adversaries with sufficient privileges to read protected files.
- T1555.004partialprevents — Configuration management can restrict execution of credential enumeration tools (vaultcmd.exe, rundll32.exe keymgr.dll) via application control, lock down file system permissions on credential locker directories, and apply policies limiting credential storage, but the Credential Manager is a built-in Windows feature that cannot be removed, multiple vectors (direct file read, CredEnumerate API, password recovery tools) remain reachable, and an actor with sufficient privilege bypasses the controls.
- T1556partialdetects — A.8.9's configuration monitoring compares actual settings against defined templates and addresses deviations, so configuration-level modifications to authentication processes (e.g., altered PAM modules, modified authentication-related registry entries, installed rogue authentication plugins) are detectable; however, in-memory patching of LSASS, hooking of authentication functions, and other runtime manipulations of the authentication process leave no configuration artifact for the template comparison to surface, so the clause's mechanism catches a slice rather than the bulk.
- T1556partialprevents — A.8.9 establishes secure baselines for authentication components, restricts access to powerful utilities and host parameters, and monitors for configuration deviations, which constrains some vectors of T1556 (e.g., disabling unnecessary authentication services, restricting who can modify authentication-related settings); however, the core of T1556 — runtime modification of authentication processes via code injection into LSASS, replacement of PAM modules, or installation of malicious authentication plugins — is not what configuration management primarily addresses, and an adversary with sufficient privileges can still tamper with running authentication processes outside the change-management process.
- T1556.002partialdetects — A.8.9 requires logging all configuration changes and comparing actual configurations against target templates, so a malicious password filter DLL registration would be a logged change and a deviation from baseline; however, detection depends on whether the organization's configuration baseline and monitoring scope include the LSA authentication subsystem's password filter configuration, which the clause does not mandate.
- T1556.002partialprevents — A.8.9's baseline enforcement and configuration monitoring can detect and reject unauthorized additions to the password filter notification packages, but the technique requires privileged access to register the DLL in the first place, which configuration management does not prevent — it constrains the configuration change rather than the access that enables it.
- T1556.003partialdetects — A.8.9 requires monitoring configurations and comparing actual configurations against defined templates, which would surface an unauthorized modification to PAM components, but the control's monitoring scope is set by business and security requirements rather than mandating file-integrity monitoring at the depth needed to catch every PAM patch.
- T1556.003partialprevents — A.8.9's standard templates, access restrictions on powerful utilities and host parameter settings, and change-management requirements make unauthorized PAM modification harder, but PAM must exist for authentication and the control's core mechanism is monitoring deviations rather than blocking modification by an actor with sufficient privileges, so the technique still runs in many cases.
- T1556.003partialrecovers — A.8.9's 'automatic enforcement of the defined target configuration' capability can restore modified PAM files to their known-good state after T1556.003 alters them, but this depends on the configuration management system being configured for automatic (not just manual) enforcement and on PAM files being within its scope; the control's primary purpose is prevention and detection, and recovery is a secondary capability that does not address credentials already harvested or backdoors already exploited.
- T1556.005partialdetects — A.8.9's configuration monitoring (comparing actual to target templates) and change management logging provide a framework that could detect deviations in the AllowReversiblePasswordEncryption property, but only if the organization includes this specific AD setting in their secure configuration templates and monitoring scope — which the control does not mandate, so a fully conformant implementation could omit it.
- T1556.006partialdetects — A.8.9's monitoring clause compares actual configurations against defined target templates and flags deviations, which catches unauthorized changes to MFA settings, Conditional Access Policies, and hosts-file redirects when those items are in the configuration scope; however, the clause sets scope through the organization's templates rather than mandating MFA-specific items, and the technique includes abuse of legitimate features (e.g., Conditional Access exclusions) and binary patching of MFA programs that may not register as configuration deviations depending on implementation.
- T1556.006partialprevents — A.8.9's configuration management framework directly addresses the technique's mechanism (unauthorized MFA configuration changes) through standard templates, change management, and monitoring with automatic enforcement, but the clause is general configuration management rather than MFA-specific, and the actual prevention depends on implementation depth and whether the adversary has sufficient privileges to bypass change management.
- T1556.006partialrecovers — Configuration management can automatically revert unauthorized changes to system-level MFA policies and configuration files, but it does not restore user-level state such as rogue MFA device registrations.
- T1556.007partialdetects — A.8.9's configuration monitoring (comparing actual vs target templates, logging configuration changes, reviewing deviations) can surface file-based modifications such as AD FS configuration file tampering and new PTA agent registrations, but does not detect in-memory DLL injection into running authentication processes or runtime patching of authentication services that leaves no configuration artifact.
- T1556.007partialprevents — A.8.9's change management, restricted privileged access to authentication infrastructure, and configuration monitoring/drift detection constrain and surface unauthorized modifications to PTA agents, AD FS configuration files, and related hybrid identity components, but it cannot prevent the initial compromise of an on-premises server hosting the PTA agent, in-memory DLL injection into running authentication processes, or use of stolen Global Admin credentials to register a new PTA agent — the technique's core vectors operate below or outside what configuration baselines reach.
- T1556.008partialdetects — A.8.9's configuration monitoring compares actual configurations against defined target templates and flags deviations, so a malicious network provider DLL registered in the Registry would be a configuration change detectable IF the relevant Registry paths are within the organization's defined baseline; the clause sets scope rather than mandating this specific Registry path, so detection is a slice the implementer chose rather than a bounded remainder of a mechanism that mostly works.
- T1556.008partialprevents — A.8.9's change management process and configuration monitoring can catch and block unauthorized registry modifications that register a malicious network provider DLL, but the clause addresses general configuration management rather than specifically mandating restrictions on credential provider registrations, so an organization fully conformant with A.8.9 need not prevent this technique.
- T1556.009partialdetects — A.8.9's monitoring section requires comparing actual configurations against target templates and logging all configuration changes, which can detect modifications to conditional access policies if those policies are included in the configuration baseline; however, the clause is general configuration management whose scope is set by implementation choices, and it does not specifically mandate that identity-provider conditional access policies be in that baseline or monitored at the depth needed to catch subtle policy weakening (e.g., adding trusted IP ranges).
- T1556.009partialprevents — Configuration management restricts who can modify conditional access policies (minimizing privileged identities, change management process) and establishes secure baselines, but the policies must remain modifiable for legitimate administration, so an adversary who compromises an admin identity or bypasses the change workflow can still execute the technique.
- T1557partialprevents — A.8.9 can prevent specific AiTM vectors through configuration (disabling LLMNR/mDNS, enforcing secure DNS, removing legacy protocols that enable downgrade attacks, restricting unnecessary network services), but cannot prevent the broader class — ARP poisoning, network-layer MitM, and protocol abuse at the infrastructure level are outside configuration management's reach and require network architecture controls.
- T1557.002partialprevents — A.8.9 covers network configuration and could include switch-level mitigations like Dynamic ARP Inspection, port security, and ARP ACLs that prevent cache poisoning, but the standard guidance items (disabling unused services, restricting utilities, default passwords, timeouts) do not address Layer 2 protocol attacks, and ARP itself cannot be disabled as it is fundamental to IPv4 — so prevention depends on specific network infrastructure configuration choices that the clause permits but does not mandate.
- T1557.003partialprevents — Configuration management can disable or restrict unnecessary DHCP server functionality on endpoints (per A.8.9c), preventing a compromised system from being repurposed as a rogue DHCP server, but it does not reach the case where an adversary introduces a new device onto the network or controls the L2 infrastructure — that requires DHCP snooping, port security, or NAC, which are outside A.8.9's scope.
- T1557.004partialprevents — A.8.9's configuration baseline can harden Wi-Fi clients (disable auto-connect, enforce 802.1X/certificate validation, restrict unnecessary wireless interfaces) so managed devices refuse the rogue AP, but the clause is general and does not specifically mandate wireless-client hardening, and the adversary's rogue AP still exists and operates regardless of the organization's configuration posture.
- T1558partialprevents — Configuration management reduces the Kerberoasting surface by disabling unnecessary service accounts and restricting powerful utilities, but cannot prevent ticket theft from memory or ticket forgery when an adversary holds key material — the technique still runs against the remaining accounts and the Kerberos protocol itself is unchanged.
- T1558.003partialprevents — A.8.9 can reduce Kerberoasting exposure by disabling unnecessary service accounts, enforcing strong passwords on those that remain, and configuring Kerberos to disable RC4 etype 23, but it cannot eliminate the technique: service accounts with SPNs are required for many services, the clause is general configuration management rather than Kerberos-specific hardening, and any authenticated domain user can still request TGS tickets against accounts that legitimately exist.
- T1558.004partialprevents — A.8.9's configuration templates can disable unnecessary or insecure identities and enforce preauthentication requirements, but the technique exploits accounts where preauthentication is already disabled, and configuration management cannot guarantee every account is properly configured across the domain.
- T1559partialprevents — Configuration management can disable or restrict some IPC mechanisms (e.g. DDE, certain COM/DCOM launch permissions, unused RPC endpoints) via standard templates, but the core IPC mechanisms (sockets, pipes, COM) are essential OS functionality and cannot be removed without breaking the platform, so only a slice of the technique's surface is closed off.
- T1559.001partialprevents — Configuration management can restrict some COM abuse vectors (e.g. disabling DCOM for remote execution, applying ACLs to specific COM objects, restricting unnecessary COM components), but COM is a fundamental Windows IPC mechanism required by the OS itself and many legitimate applications, so the local execution surface cannot be removed by configuration alone — the same shape as CM-7 against required interpreters.
- T1560partialprevents — Configuration management can restrict access to third-party archiving utilities (7zip, WinRAR) and disable unnecessary compression/encryption tools via standard templates and application control, but cannot remove built-in OS capabilities (gzip, tar, Compress-Archive, native crypto APIs) or custom implementations that the platform itself requires, so a slice of the technique is prevented rather than the bulk.
- T1560.001partialprevents — Configuration management can remove or restrict third-party archive utilities (7-Zip, WinRAR, WinZip) and apply application control policies, but the technique's built-in vectors — tar, zip, makecab, certutil, xcopy — are integral to the OS and cannot be disabled without breaking the platform, leaving the bulk of the technique reachable.
- T1563partialprevents — A.8.9 can disable unnecessary remote services (telnet, legacy RDP configurations), enforce session timeouts, restrict access to remote service endpoints, and apply hardening templates that limit hijacking vectors, but it cannot prevent hijacking of legitimate sessions on remote services the organization must keep enabled (SSH, RDP), since the technique exploits already-authenticated sessions rather than the configuration itself.
- T1563.001partialprevents — Configuration management can disable or restrict SSH agent forwarding, enforce strict sshd settings (e.g., AllowAgentForwarding no, PermitRootLogin no), and lock down agent socket permissions, materially shrinking the attack surface; but legitimate SSH sessions must continue to exist, the technique can still succeed via direct compromise of the agent process or socket, and root access renders configuration controls moot, so the technique is not eliminated.
- T1563.002partialprevents — Configuration management can reduce the attack surface by restricting RDP service availability where not business-required, limiting which accounts hold System-level privileges, and restricting access to powerful utilities — but RDP is commonly a business requirement, tscon.exe is a native system binary that cannot be removed without breaking the OS, and the technique requires System permissions which is governed by access control rather than configuration templates, so a meaningful slice is prevented but not the bulk.
- T1564.002partialdetects — A.8.9's monitoring section requires comparing actual configurations against target templates and addressing deviations, which would surface hidden-user changes (plist, registry, gsettings) if user account attributes are in the baseline; but the clause sets a framework whose scope is determined by what the organization includes in its templates, so detection of this specific technique depends on implementation choices rather than being guaranteed by the control itself.
- T1564.002partialprevents — A.8.9 provides the framework (standard templates, monitoring, automatic enforcement of target configurations) that can prevent hidden users if the baseline explicitly includes anti-hiding settings (e.g., Hide500Users=FALSE, IsHidden=0, SpecialAccounts/UserList entries) and deviations are auto-reverted; however, the clause does not mandate these specific settings, the technique spans multiple platforms with distinct hiding mechanisms, and an adversary with sufficient privileges to modify configurations may bypass or alter the baseline itself.
- T1564.003partialdetects — A.8.9's configuration monitoring can detect persistent configuration changes that enable hidden windows (e.g., unauthorized registry edits to WindowPosition subkeys, modifications to macOS plist files with apple.awt.UIElement), but it does not detect runtime concealment mechanisms like PowerShell -WindowStyle Hidden flags, CreateDesktop() API calls, or in-memory hidden desktop sessions, which leave no configuration artifact to compare against a template.
- T1564.003partialprevents — Configuration management can restrict some underlying mechanisms (PowerShell execution policies, registry editing privileges, certain scripting features) that enable hidden windows, but the technique exploits legitimate OS display features across many vectors (PowerShell flags, plist tags, CreateDesktop API, LOLBins) that configuration baselines do not directly address, so what is prevented is a slice rather than the bulk.
- T1564.006partialdetects — Configuration monitoring can detect unauthorized virtualization software installations (e.g., dropped VirtualBox binaries), unauthorized VMs appearing in managed infrastructure, and deviations from templates that disable or restrict virtualization — but the technique is specifically designed to evade configuration-based detection: it leverages already-enabled native virtualization (Hyper-V), creates VMs outside standard management tools (ESXi `/bin/vmx` bypassing vCenter), and the malicious activity itself runs inside the guest where host-side configuration monitoring has no visibility.
- T1564.006partialprevents — A.8.9's guidance to disable or restrict unnecessary functions and services and to restrict access to powerful utility programs can prevent some vectors of T1564.006 (e.g., disabling Hyper-V or Windows Sandbox where not business-required, restricting VM management tools), but the technique has multiple paths the control cannot reach — adversaries can drop QEMU/VirtualBox binaries, leverage built-in features the platform requires, or create VMs on ESXi hosts they already administer — so only a slice of the technique is prevented.
- T1564.007partialprevents — A.8.9 includes 'disabling or restricting unnecessary functions and services,' so a configuration baseline that disables VBA macros in Office would prevent the stomped p-code from executing; however, the technique itself (hiding malicious p-code by overwriting source) is not a misconfiguration issue and can still be performed even under strict configuration management, and A.8.9's primary scope is configuration management broadly rather than application-level macro policy.
- T1564.008partialdetects — A.8.9 monitors configurations and compares actual against target templates, so creation or modification of inbox rules is a configuration change that can be surfaced as a deviation — but only where email rule settings are part of the monitored baseline, and the clause detects the rule existing, not its malicious intent or the hiding behavior it enables.
- T1564.008partialprevents — Configuration management can restrict PowerShell execution paths (blocking New-InboxRule/Set-InboxRule cmdlets) and apply mailbox policies limiting rule creation, but the technique can still be executed through normal email client interfaces and webmail by an adversary with valid credentials, which configuration management does not address.
- T1564.012partialprevents — A.8.9 can constrain the configuration space by defining templates that minimize AV/file-scanner exclusions, restricting who may modify exclusion lists, and monitoring for unauthorized configuration changes — but it cannot eliminate the technique because many exclusions are vendor defaults baked into security products and others are operationally necessary, so the excluded paths adversaries target remain reachable.
- T1564.013partialprevents — A.8.9's guidance on minimizing privileged identities and restricting access to powerful utility programs can constrain who may invoke `mount`/bind mounts, but bind mounts are a legitimate kernel feature used by containers and chroot environments, so they cannot be removed wholesale; the technique is not a misconfiguration the clause directly targets, only a slice of it is closed by tightened sudo and mount restrictions.
- T1565.003partialdetects — A.8.9's configuration monitoring compares actual configurations against defined target templates and addresses deviations, which detects the subset of T1565.003 instances that involve modifying application binaries, file associations, or other persistent configuration items; it does not detect in-memory runtime manipulation that leaves no configuration trace, and the monitoring is periodic rather than continuous.
- T1565.003partialprevents — A.8.9 constrains the attack surface for runtime data manipulation by minimizing privileged access, restricting powerful utilities, and enforcing baseline configurations that detect unauthorized changes to binaries and system files, but it does not eliminate the technique — an adversary with sufficient privileges can still alter application binaries or runtime data, and the clause governs configuration rather than application/data integrity directly.
- T1566.001partialprevents — A.8.9 can configure endpoints to block or restrict execution of common attachment-borne payloads (e.g., disabling Office macros by default, restricting script interpreters, application allowlisting via security templates), so some spearphishing attachments fail to execute even after the user opens them; however, the technique's core mechanism — email delivery and user opening — is untouched, and configuration alone does not stop attachments that exploit unpatched vulnerabilities or that the user is socially engineered into executing past protections.
- T1567.002partialprevents — A.8.9's templates can disable or restrict cloud storage client applications and unnecessary services, and its monitoring can detect deviations, but the control does not inherently mandate blocking cloud storage egress; legitimate business use of services like Dropbox or Google Drive is commonly permitted, and browser-based exfiltration to these services remains viable where the browser is a required function.
- T1569.001partialprevents — A.8.9 can restrict access to launchctl (sudo rules, file permissions), disable unnecessary LaunchAgents/Daemons, and apply least-functionality templates, but launchctl is a required macOS system utility that cannot be removed, so the technique remains available to any user with sufficient privilege — the same shape as CM-7 vs T1059.
- T1569.002partialprevents — A.8.9 can constrain T1569.002 by restricting which identities have service-creation privileges, disabling unnecessary services, and limiting access to tools like sc.exe and PsExec, but the Windows Service Control Manager is a core OS component that cannot be removed, so an attacker with administrative access can still use it to execute payloads — the technique's mechanism remains available to those with the rights configuration management cannot take away.
- T1569.003partialprevents — Configuration management can restrict access to systemctl via privileged access controls and disable unnecessary systemd services, but systemctl is a core component of the Linux init system that cannot be removed without breaking the OS, so any privileged user can still invoke it -- the same shape as CM-7 vs T1059, where the platform-required interpreter cannot be removed and what is restricted is a slice.
- T1570partialprevents — A.8.9 can disable unnecessary services, restrict access to admin shares, and limit powerful utility programs (scp, rsync, curl, ftp), preventing some lateral tool transfer vectors, but the core mechanisms adversaries use (SMB, RDP, native file utilities) are typically required for legitimate operations and cannot be removed, so what is prevented is a slice rather than the bulk.
- T1571partialdetects — A.8.9's configuration monitoring (comparing actual to target templates, logging changes) can surface unauthorized modifications to port/protocol pairings on victim systems, but only the configuration-change variant of T1571; adversary-side use of non-standard ports from their own infrastructure produces no configuration drift on the estate to detect.
- T1571partialprevents — A.8.9 can enforce standard port configurations via templates (restricting unnecessary services, locking host parameter settings) and detect deviations through configuration monitoring, which constrains the victim-side variant of T1571; however, the technique's primary form — the adversary choosing non-standard ports on infrastructure they control — is outside the organization's configuration scope, so prevention is partial.
- T1572partialprevents — Configuration management can disable unnecessary protocols (e.g., SMB, RDP) that adversaries might tunnel, restrict installation of tunneling utilities, and enforce egress filtering via standard templates, but the technique is specifically designed to encapsulate traffic within protocols that must remain enabled for legitimate use (SSH for administration, HTTPS for web traffic, DNS for resolution), so a meaningful slice of tunneling vectors survives any conformant configuration baseline.
- T1574partialdetects — A.8.9's configuration monitoring compares actual state against defined templates and addresses deviations, which surfaces configuration-based hijack vectors (PATH manipulation, Registry poisoning, file directory tampering) but does not detect in-memory execution-flow hijacks and operates on periodic review rather than real-time observation of the technique in flight.
- T1574partialprevents — Configuration management constrains a meaningful slice of T1574 by enforcing secure permissions on service binaries and registry keys (mitigating .010/.011), restricting write access to PATH and library directories (mitigating .007/.009), and monitoring for configuration deviations, but it cannot prevent the core mechanism of execution-flow hijacking when the OS itself loads code from locations the technique poisons (DLL search order, side-loading, COR_PROFILER, kernel callback tables) — those exploit OS execution mechanics that configuration templates do not reach.
- T1574.001partialprevents — Configuration management can reduce the DLL-hijack attack surface by disabling unnecessary applications and services (clause c), restricting write access to DLL search paths via access controls in templates, and applying hardening baselines (e.g., SafeDLLSearchMode, KnownDLLs, WDAC) — but the DLL loading mechanism itself is required for the platform to function, and adversaries target the applications that must load DLLs, so what is removed is a slice rather than the bulk with a bounded remainder.
- T1574.004partialprevents — Configuration management can restrict write access to dylib search paths, enforce file integrity monitoring on application directories, and configure hardened runtime settings, but it cannot fully prevent the technique because dylib hijacking exploits the dynamic loader's runtime search behavior and application build characteristics (weak linking, @rpath resolution) that configuration baselines reach only partially.
- T1574.005partialprevents — Configuration management sets secure file permissions on binaries and system directories and restricts access to utility programs, which prevents the static-permissions variant of T1574.005, but cannot fully prevent third-party installers from dynamically creating weak-permission subdirectories in %TEMP% during their own execution — a slice is removed, not the bulk.
- T1574.006partialdetects — A.8.9's monitoring of configuration changes and comparison against target templates can detect persistent manifestations such as modifications to /etc/ld.so.preload or system-wide environment files, but the core mechanism of T1574.006 — runtime setting of LD_PRELOAD/DYLD_INSERT_LIBRARIES in a process environment — falls outside the clause's scope of persistent configuration baselines.
- T1574.006partialprevents — Configuration management can establish secure templates that disable or restrict LD_PRELOAD/DYLD_INSERT_LIBRARIES, restrict access to powerful utility programs, and monitor for configuration deviations, but the dynamic linker is a core OS component that must remain functional, so the technique cannot be fully prevented — analogous to the cm-7 vs T1059 anchor where required platform components cannot be removed.
- T1574.007partialdetects — A.8.9's configuration monitoring compares actual configurations against target templates and logs changes, so unauthorized modifications to the PATH environment variable are detectable when PATH is included in the monitored configuration baseline; however, the technique also succeeds by placing a malicious binary in a directory already on the PATH without altering the variable itself, and that file-system vector is outside A.8.9's configuration-comparison mechanism.
- T1574.007partialprevents — A.8.9's template guidance disables unnecessary identities and restricts unnecessary functions, which can remove the write access an adversary needs to place a malicious binary in a PATH directory, but the control does not prevent modification of the PATH variable itself or block execution from directories the system legitimately requires.
- T1574.008partialprevents — Configuration management can restrict write access to program directories, configure PATHEXT to limit executable extensions, and restrict access to powerful utility programs, but it does not directly address the core mechanism of T1574.008 — programs that call other programs without full paths and Windows' default search order behavior — which is fundamentally a program-design and OS-behavior issue rather than a configuration issue.
- T1574.010partialprevents — A.8.9 mandates secure configuration templates that minimize privileges and disable unnecessary identities, which reduces the attack surface for service file permission weaknesses, but it cannot guarantee that all service binary paths are correctly permissioned across every system.
- T1574.011partialdetects — A.8.9's monitoring of configurations against target templates can surface deviations in service Registry permissions if those are included in the baseline, and logged configuration changes would record modifications to service Registry entries; however, detection is contingent on the template specifically covering service Registry ACLs and on the monitoring depth, which the clause does not mandate, so the coverage is a slice rather than a mechanism that mostly works.
- T1574.012partialdetects — A.8.9's monitoring of configuration deviations can detect persistent COR_PROFILER abuse (Registry entries for system/user-scope environment variables, COM object registrations) when those are part of the secure baseline, but cannot detect in-memory process-scope COR_PROFILER that leaves no persistent configuration artifact, and the clause sets monitoring requirements rather than mandating instrumentation of these specific variables.
- T1574.012partialprevents — Configuration management can constrain COR_PROFILER abuse by restricting who may modify system/user environment variables and the registry keys that set it, by monitoring for unauthorized configuration changes, and by enforcing templates that lock down these settings — but the .NET CLR itself is required for legitimate applications and cannot be removed, and process-scope COR_PROFILER can be set in-memory without touching persistent configuration, so the technique remains reachable.
- T1574.014partialdetects — A.8.9's configuration monitoring compares actual configurations against target templates and surfaces deviations, so tampering with .NET `.config` files or environment variables that define runtime settings is detectable as a configuration drift; however, the in-memory AppDomain creation vector (loading a malicious assembly into a custom application domain inside a process) is a runtime behavior outside configuration management's observation surface, leaving that portion of the technique unseen.
- T1574.014partialprevents — A.8.9's restriction of write access to configuration files, monitoring of config changes, and enforcement of baseline templates blocks the .config/environment-variable tampering variant of AppDomainManager hijacking, but does not reach the in-process variant where an attacker with code execution creates a custom application domain to load a malicious assembly — that path requires code-signing or application-control controls, not configuration management.
- T1578partialdetects — A.8.9's monitoring clause compares actual configurations against target templates and logs configuration changes, so unauthorized modifications to cloud compute infrastructure that deviate from the defined template would surface as detectable deviations. However, the control's scope is configuration settings rather than all cloud resource lifecycle events, monitoring is periodic rather than continuous, and modifications that fall within approved parameters (e.g., creating instances in an allowed region/size) would not register as deviations, leaving a bounded remainder.
- T1578partialprevents — A.8.9 explicitly covers cloud services and can restrict unnecessary compute services, minimize privileged identities, and enforce secure configuration templates that limit what modifications are permissible — but T1578 is performed by an adversary who has already obtained permissions to modify infrastructure, and configuration management cannot prevent a compromised identity from using those permissions to make authorized-looking changes; the preventive effect is real but bounded by what templates and identity minimization can stop versus what valid credentials can still do.
- T1578partialrecovers — A.8.9 mandates the correction of configuration deviations, which reverts unauthorized modifications to cloud compute settings and instances, though it cannot restore deleted snapshots or lost data.
- T1578.001partialprevents — Configuration management reduces the attack surface by enforcing least privilege on snapshot-creation permissions, disabling unnecessary identities, and monitoring for configuration drift that grants new privileges, but it cannot eliminate the capability entirely because snapshot creation is a legitimate cloud function some identities must retain, and an adversary leveraging already-obtained permissions operates within the configured baseline.
- T1578.002partialdetects — A.8.9's monitoring of configurations against target templates can detect an unauthorized cloud instance as a deviation from the expected configuration baseline, and the clause explicitly includes cloud services in scope, but detection depends on implementation choices about what configurations to monitor and the control's primary focus is configuration settings of existing assets rather than asset-creation events.
- T1578.003partialdetects — A.8.9 requires monitoring configurations and comparing actual configurations against defined templates, which would surface the deletion of a cloud instance as a configuration deviation, but the control's monitoring scope is limited to the organization's own estate and does not guarantee visibility into the cloud provider's deletion logs or forensic artifacts before they are removed.
- T1578.004partialdetects — A.8.9 requires logging of all configuration changes and monitoring configurations against target templates, so a cloud instance revert performed via management APIs would be recorded as a configuration change and surface as a deviation from the current state; however, the technique is specifically designed to evade detection by restoring a 'clean' snapshot, and configuration management detects the change without necessarily flagging the malicious intent behind a revert that brings the instance back to a known-good template.
- T1578.004partialprevents — A.8.9's identity-related sub-items (minimizing privileged identities, disabling unnecessary or insecure identities, restricting access to powerful utilities) constrain who can call cloud management APIs to revert instances, but the clause's primary mechanism is configuration templating and change control of the instance itself, not governance of cloud-control-plane credentials, so the preventive effect is indirect and bounded.
- T1578.005partialdetects — A.8.9 requires monitoring configurations and comparing actual configurations against defined templates, which would surface unauthorized modifications to cloud compute settings, but the control's monitoring scope is determined by business and security requirements rather than mandating continuous real-time detection of every configuration change across all cloud services.
- T1578.005partialprevents — A.8.9's change management process, access restrictions on privileged identities, standard templates, and automatic enforcement of target configurations can block unauthorized modifications to cloud compute settings, but the technique assumes the adversary already holds credentials with some modification rights in the cloud environment, and A.8.9 cannot eliminate that access without breaking legitimate cloud administration—so a slice of the technique is prevented while the remainder (changes made by compromised admin identities or via cloud provider APIs that bypass the on-premise change process) is not.
- T1599partialprevents — A.8.9's secure configuration templates for network devices (disabling unnecessary services, restricting access to configuration utilities and host parameter settings, monitoring for deviations) directly harden the boundary devices T1599 targets and constrain the adversary's ability to reconfigure them, but the control does not prevent the initial compromise of the device — the prerequisite for the technique — which depends on other controls (patching, access control, credential management).
- T1599.001partialdetects — A.8.9 requires monitoring configurations with tools, regular reviews, and comparison against secure templates to detect deviations (including unauthorized NAT changes on network devices), but this is limited to post-change detection on managed assets and does not address pre-modification adversary activity, custom NAT via T1601.001, or non-configuration indicators of the technique.
- T1599.001partialprevents — A.8.9 establishes secure configuration baselines for network devices and can auto-enforce target configurations, which constrains unauthorized NAT modifications; however, the technique presupposes the adversary has already compromised the boundary device, and an attacker with administrative control can disable or bypass the enforcement mechanism, so the prevention is real but bounded by the prior compromise.
- T1600partialdetects — A.8.9 monitors configurations against defined templates and detects deviations, so changes to encryption settings (cipher suites, key lengths, crypto module enablement) on network devices are visible as configuration drift if those parameters are in the baseline; however, T1600 can manifest through image-level compromise (T1601) where the device reports a configuration that no longer reflects its actual state, and the clause's scope is set by what the template includes rather than mandating depth of instrumentation.
- T1600partialprevents — Configuration management enforces strong encryption baselines, restricts who can change crypto settings, and detects deviations — preventing configuration-level weakening such as cipher downgrades or key-space reductions — but cannot prevent deeper attacks like firmware/system image replacement or hardware tampering that compromise the device's encryption capability below the configuration layer.
- T1600.001partialprevents — A.8.9 establishes secure configuration templates requiring strong encryption and monitors for deviations, so a weakened key size would be detected and could be auto-reverted or corrected; however, the technique still executes on a compromised device and the control does not prevent the attacker from issuing the CLI change in the first place, only from the weakened state persisting.
- T1601partialdetects — A.8.9's monitoring of configurations and detection of deviations from target templates can surface unauthorized changes to system images where file integrity or image hash verification is part of the configuration baseline, but the clause sets scope rather than mandating image-level instrumentation; in-memory modifications at runtime and OS image changes on network devices that fall outside the monitored configuration set are not caught.
- T1601partialprevents — A.8.9's change management process and standard templates can prevent unauthorized stored modifications to network device OS images by requiring all changes to follow controlled procedures, and monitoring can compare actual configurations against baselines; however, the technique explicitly includes in-memory modifications during runtime that bypass change management, and A.8.9's scope is configuration settings rather than OS image integrity verification, leaving a substantial remainder where the technique can still execute.
- T1601.001partialdetects — A.8.9's monitoring of configurations and comparison against target templates can detect some instances of system image modification in storage (e.g., via image integrity checks or unauthorized file changes logged through change management), but it does not reliably detect runtime memory patching, boot loader manipulation, or adversary use of legitimate operator procedures to swap images, which the technique explicitly relies on.
- T1601.001partialprevents — A.8.9 restricts privileged access, enforces change management for software/images, and monitors configurations for unauthorized deviations, which prevents the standard-procedure vector (uploading a modified image via TFTP/FTP/SCP) that requires administrative access. However, it does not reach boot loader compromise (ROMMONkit) or in-memory patching via debug commands, which operate below the configuration layer the clause governs.
- T1601.002partialdetects — A.8.9's monitoring clause compares actual configurations against target templates and logs configuration changes, so an OS version downgrade on a managed network device should surface as a deviation; however, the technique specifically replaces the OS file in storage on embedded devices, which standard configuration management tools (focused on running config) may not see, and network devices are often less completely under configuration management than servers, leaving a bounded remainder.
- T1601.002partialprevents — A.8.9's configuration monitoring and enforcement can detect and revert an unauthorized image downgrade, but the control does not physically prevent the adversary from loading the older image onto the device in the first place.
- T1602partialdetects — A.8.9's monitoring of configurations (assessing activities performed, comparing actual to target templates, reviewing access) can surface unauthorized queries or changes to configuration repositories, but its primary purpose is configuration integrity rather than detecting data collection from those repositories, and passive reads (e.g., SNMP polling) leave little the clause is designed to catch.
- T1602partialprevents — A.8.9 addresses several mechanisms relevant to T1602 — restricting access to management utilities, changing vendor default authentication (e.g., default SNMP community strings), disabling unnecessary identities, and monitoring configuration changes — but it does not comprehensively prevent adversaries from collecting data from configuration repositories, which can still occur via stolen credentials, exploitation of management protocols, or other vectors outside the clause's scope.
- T1602.001partialprevents — A.8.9's configuration templates can disable SNMP or restrict access to the MIB, but the control's scope is the organization's own devices and does not prevent an adversary from querying an exposed SNMP service that was left enabled.
- T1602.002partialprevents — A.8.9's standard templates disable unnecessary identities and change vendor defaults, which removes the credentials SNMP and SMI need to access the configuration, but the control does not eliminate the configuration file itself or block all management protocols, so the technique is constrained rather than closed.
- T1606.002partialdetects — A.8.9's monitoring of configurations can detect configuration-level indicators such as changes to token-signing certificates, new federation trusts, or AD FS configuration changes, but the core technique — forging tokens offline with a stolen private key and presenting them to services — produces no configuration deviation on the estate and is therefore not visible to configuration management.
- T1609partialprevents — Configuration management can restrict access to container administration services (Docker daemon socket, Kubernetes API, kubelet) by enforcing authentication, disabling anonymous access, applying RBAC, and restricting which identities may invoke exec/entrypoint commands — but the services themselves are required for legitimate operations and cannot be removed, so an adversary with access to a privileged or compromised identity can still execute the technique.
- T1610partialdetects — A.8.9 logs configuration changes and monitors for deviations from standard templates, so a container deployment is recorded as a change and misconfigurations (privileged mode, missing network rules, unrestricted capabilities) are surfaced as drift; however, a container matching the approved template while running a malicious payload is not detected, and the clause's scope is configuration drift rather than container-aware threat detection.
- T1610partialprevents — A.8.9 can disable or restrict container runtimes, management APIs (Docker, Kubernetes), and related services where they are not needed, and can enforce access controls and security policies that constrain who may deploy containers and how — but where containers are legitimate infrastructure, the technique still runs within configured bounds, and a compliant deployment can still be adversary-controlled.
- T1611partialprevents — Configuration management establishes secure container/VM templates that can prevent configuration-based escape vectors (privileged containers, host filesystem mounts, unnecessary capabilities, exposed docker.sock), but cannot prevent vulnerability-based escapes (kernel exploits, hypervisor CVEs) or all kernel-level abuse paths that require features the platform needs.
- T1612partialprevents — A.8.9's templates can disable or restrict unnecessary functions and services (item c) and restrict access to powerful utilities (item d), so where Docker build is not required the API can be locked down and the technique cannot run; where containers are legitimately needed, the build capability must remain and the technique still executes, which is the bounded remainder that keeps this at partial rather than mostly.
- T1613partialprevents — Configuration management can disable the Kubernetes dashboard, restrict API access via network policies and RBAC, and remove unnecessary container services, but the container platform's APIs must remain functional for legitimate workloads, so an adversary with any valid access can still query them to discover resources.
- T1619partialprevents — Configuration management can enforce least privilege on identities, disable unused service accounts, and restrict unnecessary functions per its guidance (a, b, c), which constrains who can call ListObjectsV2/List Blobs APIs; however, the technique uses legitimate cloud provider APIs needed for normal operations, so configuration management cannot fully prevent an adversary with valid, appropriately-scoped credentials from enumerating objects — that prevention lives in IAM/access controls, not configuration management.
- T1621partialprevents — A.8.9's configuration management can include MFA hardening (number matching, disabling push for SSPR, restricting MFA methods) which reduces the attack surface for T1621, but the clause is general and does not specifically mandate MFA push-notification controls; the technique's core is user acceptance of the push, which configuration alone cannot eliminate.
- T1647partialdetects — A.8.9's configuration monitoring (comparing actual configurations against defined target templates and flagging deviations) can detect unauthorized plist modifications when those files fall within the monitored configuration baseline, but the clause sets scope rather than mandating that plist files specifically be included, so detection is implementation-dependent.
- T1647partialprevents — A.8.9 establishes baseline configurations and can auto-enforce target templates, so unauthorized plist modifications within the managed scope would be detected and reverted; however, plist files are necessary for macOS operation and cannot be removed (unlike default accounts), the clause sets a framework rather than mandating plist-specific coverage, and the scope of which plist files are managed depends on implementation — leaving a nameable remainder of modifications that succeed before enforcement or that fall outside the configured baseline.
- T1648partialdetects — A.8.9's configuration monitoring (comparing actual configurations against target templates and flagging deviations) can surface unauthorized serverless resources as configuration drift, but it does not detect serverless functions that are themselves properly configured and merely abused for malicious purposes, nor does it reach the runtime behaviour of those functions.
- T1648partialprevents — Configuration management can constrain serverless execution by disabling unused serverless services, restricting which identities may create functions, and applying least privilege to IAM roles (including PassRole), but the services adversaries abuse are typically business-required and cannot be removed, so what is prevented is a slice of the attack surface rather than the technique itself.
- T1649partialprevents — A.8.9's configuration baselines can harden AD CS and certificate services (tightening enrollment permissions, restricting EKU/SAN values, securing CA private key storage, disabling unnecessary certificate templates), removing the misconfiguration enablers the technique explicitly names; however, it does not prevent theft of legitimately issued certificates from properly configured stores, nor forging when CA private keys are compromised through other means.
- T1651partialprevents — A.8.9 can restrict or disable unnecessary cloud management agents/services and apply least-privilege templates to identities permitted to invoke RunCommand/Runbooks, but the services are often required for legitimate operations and cannot be blanket-disabled, and once an adversary holds administrative or delegated-admin access configuration management does not stop them from invoking the legitimate management plane.
- T1653partialprevents — A.8.9 mandates disabling unnecessary functions and enforcing secure configurations, which can prevent the adversary from altering power settings, but the control does not guarantee that power settings are locked down on every system, leaving a bounded remainder.
- T1666partialdetects — A.8.9's configuration monitoring (comparing actual configurations against target templates, logging all configuration changes) can detect modifications to cloud resource hierarchies if those hierarchies are included in the configuration baseline and monitored via cloud-native tools (e.g., AWS Config, Azure Policy), but the clause sets requirements rather than mandating specific instrumentation depth, and T1666 is explicitly designed to evade defenses using legitimate API calls that may appear as authorized changes.
- T1666partialprevents — Configuration management restricts who holds privileged identities and enforces templates that can limit unauthorized modifications to cloud hierarchies, but the technique explicitly involves adversaries who already hold appropriate permissions (e.g., compromised Global Administrator accounts or authorized insiders), and A.8.9's access restrictions cannot prevent action by parties who legitimately possess those rights.
- T1669partialprevents — A.8.9 enforces secure Wi-Fi configurations (changing default AP credentials, disabling insecure protocols/services, restricting management access), which prevents exploitation of misconfigured wireless infrastructure, but it cannot prevent use of valid accounts on secured networks, physical-proximity attacks, or bridging through compromised third-party dual-homed systems.
- T1671partialdetects — A.8.9's 'Monitoring configurations' clause compares actual configurations against target templates and addresses deviations, and 'services (e.g. cloud services)' is explicitly in scope, so an implementation that includes SaaS tenant configuration (OAuth application registrations, consent grants) in its baseline can surface a new or modified integration as a configuration drift event; however, the clause sets scope rather than mandating that OAuth integrations be in it, so detection depends on the implementer including SaaS application governance in the monitored configuration set, and many conformant implementations would not.
- T1675partialprevents — Configuration management can restrict access to ESXi administration services and APIs, disable unnecessary VMware Tools Daemon instances, and limit privileged identities, but the technique abuses functionality that is often required for legitimate VM management, so the services cannot be fully removed and the technique cannot be fully prevented.
- T1677partialdetects — A.8.9's configuration monitoring (logging changes, comparing actual to target templates) detects unauthorized modifications to CI configuration files themselves (Direct Pipeline Execution), but does not detect malicious code injected into files referenced by the CI config (Indirect) nor malicious pull requests from forks (Public), which are code changes rather than configuration changes.
- T1677partialprevents — Configuration management constrains direct modification of CI configuration files through change control, restricted privileged access, and standard templates, but cannot prevent indirect pipeline execution (injection into referenced files outside strict config scope) or public pipeline execution (malicious pull requests from forks exploiting legitimate triggers like pull_request_target), so the technique remains broadly exploitable despite the controls A.8.9 enforces.
- T1684.002partialprevents — A.8.9 mandates disabling unnecessary identities and changing vendor defaults, which removes some accounts an adversary could spoof, but email header spoofing does not require a compromised account and the control does not enforce DMARC/SPF/DKIM, so the technique is constrained only at the margin.
- T1685partialdetects — A.8.9's configuration monitoring (comparing actual to target templates, reviewing configuration settings, logging changes) can detect deviations in tool configuration files, Registry keys, and service states that T1685 produces, but the detection is bounded by monitoring scope and periodicity, and is itself vulnerable to the technique — an adversary disabling the configuration monitoring tools blinds the very mechanism that would detect them.
- T1685partialprevents — Configuration management provides preventive effect through restricting access to tool configurations, enforcing change management on security-tool settings, and disabling unnecessary services that could be abused, but an adversary with sufficient privileges can still stop services, kill processes, or use legitimate drivers to bypass protections, so the technique is not fully prevented.
- T1685.001partialprevents — A.8.9's purpose explicitly includes preventing unauthorized configuration changes, and its automatic enforcement of target templates can block unauthorized modifications to EventLog settings; however, the technique specifically notes that Administrator privilege enables broader registry and service modifications, and configuration management systems themselves run with admin rights and can be targeted or bypassed, leaving a meaningful remainder the control cannot reach.
- T1685.002partialprevents — A.8.9's monitoring and enforcement of secure configurations can prevent an adversary from having the permissions needed to disable cloud logging, but it cannot guarantee prevention because the control's scope is the organization's own configuration baseline, not the adversary's ability to obtain sufficient permissions through other means.
- T1685.004partialdetects — A.8.9 requires monitoring configurations and comparing them to defined templates, which can surface unauthorized changes to auditd configuration files or service state, but the control's monitoring scope is set by the organization's requirements rather than mandating specific file-integrity or process-monitoring depth, so detection is a chosen slice rather than a bounded remainder.
- T1685.004partialprevents — Configuration management can reduce the attack surface by minimizing privileged identities and can enforce/restart auditd configuration via templates and monitoring, but the technique specifically targets the audit system itself and requires only root privileges — which configuration management cannot revoke from legitimate administrators and cannot prevent a root-level actor from killing auditd, hooking its libraries, or modifying rules before re-enforcement runs.
- T1685.005partialprevents — A.8.9 can restrict access to wevtutil, lock down PowerShell, set ACLs on event log files, and minimize admin privileges — all of which constrain the mechanisms T1685.005 uses — but it cannot remove the capability entirely because legitimate administrators need log-clearing access and an adversary who has already obtained sufficient privileges can change configurations or use alternative paths (GUI, direct file deletion), so the technique is constrained rather than prevented.
- T1686partialprevents — A.8.9 establishes secure configuration baselines that can include firewall settings, restricts access to configuration tools, and can enforce target configurations automatically — all of which constrain an adversary's ability to tamper with firewall rules. But the technique specifically requires sufficient privileges to modify firewall services, and configuration management is a process control whose preventive effect depends on implementation depth: privileged actors can still alter rules, and the clause's strength lies in detection of deviations rather than real-time blocking of privileged changes.
- T1686.001partialdetects — A.8.9's monitoring of configurations, comparison against templates, and review of deviations (including changes to firewall/security group rules) can surface unauthorized firewall modifications in IaaS after they occur, but only for configurations inside the organization's defined scope and tooling; the technique's pre-compromise acquisition of permissions and many cloud-native changes sit outside that slice.
- T1686.002partialdetects — A.8.9 explicitly requires monitoring configurations with management tools, regular reviews, comparison against target templates, and addressing deviations, which surfaces unauthorized firewall rule changes or ACL modifications on network devices.
- T1686.002partialprevents — A.8.9's standard templates define secure firewall baselines, its change management requires authorization for configuration changes, and its monitoring with auto-enforcement of target configurations can revert unauthorized rule modifications — preventing the technique from succeeding where implemented. But the clause does not mandate auto-enforcement (manual analysis is an alternative), privileged access to network devices remains reachable via valid accounts or exploited vulnerabilities, and the technique can still be attempted; what is prevented is a slice, not the bulk.
- T1686.002partialrecovers — A.8.9's monitoring and automatic enforcement of target configurations can detect deviations in firewall rules and restore them to the defined baseline, which is a genuine recovery action for the altered configuration state; however, this is a secondary function of a primarily preventive control, the restoration depends on the configuration management system itself remaining uncompromised, and any lateral movement or C2 established during the window between deviation and restoration is not undone.
- T1686.003partialprevents — A.8.9 establishes a secure baseline for firewall configuration and its monitoring clause can auto-enforce that baseline, reverting adversary modifications so the firewall does not remain disabled or altered; however, the adversary's modification action (netsh, registry edit, etc.) still executes, and the technique can succeed where auto-enforcement is itself disabled, where the adversary acts within a window before reversion, or where privileged access bypasses the configuration baseline.
- T1687partialprevents — Configuration management restricts who can alter security-tool settings, monitors for unauthorized configuration changes, and enforces hardening templates that close configuration-based attack surface, but it does not fix code vulnerabilities in the security software itself — the core mechanism of T1687 is exploiting programming errors, which configuration management neither patches nor removes.
- T1687partialrecovers — A.8.9's monitoring and automatic enforcement of target configurations can detect and revert configuration-level impairments (disabled services, altered rules, changed settings) caused by T1687, but it does not address the underlying exploited vulnerability itself, so the recovery is limited to the configuration layer.
- T1688partialdetects — A.8.9's monitoring component compares actual configurations against defined templates and addresses deviations, so unauthorized changes to BCD stores and registry values that enable safe mode abuse are detectable when those specific configurations fall within the monitored baseline; the extent is partial because the clause sets scope rather than mandating coverage of boot configuration and safe-mode-related registry keys, and the actual safe mode boot event itself is not what configuration monitoring observes.
- T1688partialprevents — A.8.9's guidance on restricting access to powerful utility programs (bcdedit), minimizing privileged identities, and monitoring configuration deviations provides some preventive effect against unauthorized BCD modifications, but the underlying OS capability to boot into safe mode cannot be removed by configuration management, and an adversary with sufficient privileges can still execute the technique.
- T1689partialdetects — A.8.9's monitoring of actual configurations against target templates can detect downgrade attacks that manifest as configuration deviations (e.g., a boot manager reverted to a vulnerable version, a security setting weakened), but many downgrade attacks exploit backward compatibility without altering the stored configuration — protocol downgrades (HTTPS→HTTP) and runtime use of older PowerShell versions leave the template-compliant configuration intact, so the monitoring mechanism sees nothing.
- T1689partialprevents — Configuration management can require minimum software versions in standard templates (e.g., mandating PowerShell 5+ with SBL), disable backward-compatible functions, and monitor for deviations that would enable downgrade, but it cannot prevent protocol-level downgrade attacks (SSL stripping) or stop a sufficiently privileged adversary from manipulating configurations to enable older versions.
- T1690partialdetects — A.8.9's monitoring of configurations against target templates can detect persistent changes to command-history logging settings (e.g., modified .bashrc, system-wide HISTFILE/HISTCONTROL defaults, PSReadLine profile changes), but the technique can also be executed via runtime session commands (unset HISTFILE, export HISTFILESIZE=0, Set-PSReadLineOption) that do not alter the persistent configuration baseline the clause compares against, leaving those instances unobserved.
- T1690partialprevents — A.8.9's configuration templates can disable unnecessary identities and restrict access to powerful utility programs, which can include setting HISTFILESIZE=0 or restricting PSReadLine options, but the technique's core mechanism—manipulating environment variables or PowerShell settings within a user's own session—is not fully prevented because users with legitimate shell access can often override these settings.
- T1697partialprevents — A.8.9's configuration templates can disable unnecessary identities and change default authentication information, which removes or hardens the accounts ASPs target, but ASPs can still be generated for accounts that remain active and the control does not address social engineering or compromise of already-generated ASPs.
- T1700partialprevents — Configuration management can restrict which tools and services AI agents have access to (disabling unnecessary functions, restricting access to powerful utilities), limiting the exfiltration paths available to a prompt-injected agent, but it does not address the prompt injection vector itself and cannot prevent an agent with legitimately configured data/tool access from being manipulated to misuse those sanctioned capabilities.
Prevented OWASP Web Top 10 (2025) risks (13)
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
- A01partialblocks — A.8.9's secure configuration templates and enforcement (e.g. minimizing privileged accounts, disabling unnecessary functions/services, restricting powerful utilities, changing defaults) directly block several A01 members that arise from insecure defaults or overly permissive setups, but leave untouched many others (e.g. missing authorization checks, IDOR, CSRF, path traversal) that are not configuration defects.
- A07partialblocks — A.8.9's secure-configuration templates and enforcement directly close several authentication-failure vectors (default credentials, privileged accounts, unused services, session timeouts, clock sync for replay protection) when applied at install and maintained; they leave the dominant credential-stuffing, weak-reset, and session-management logic flaws untouched.
- A08partialblocks — A.8.9's secure configuration templates, enforcement of baselines, disabling of insecure functions/services, and monitoring/deviation correction directly prevent many integrity failures (e.g. unsigned updates via enforced secure defaults and change control, CI/CD paths via config management of build pipelines, insecure deserialization via disabled unsafe features), but leave real gaps in the class such as runtime trust of signed-but-malicious code or supply-chain data tampering outside configuration enforcement.
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.