A.8.18 Technological
Use of privileged utility programs
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 (17)
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-7partialcovers — A.8.18 specifically addresses restricting privileged utilities (a narrow slice of prohibited/restricted software and functions), while CM-7's least-functionality requirement is far broader across all ports, protocols, services, and non-privileged software.
Aligned NIST CSF 2.0 outcomes (24)
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.AA-05domain mandateimplements — A.8.18's technical restrictions on privileged utilities (including approval, authorization and least-privilege use) give operational effect to the access-permission management and enforcement outcome named in PR.AA-05; the link is by subject membership in the access-control domain rather than by explicit citation of the CSF subcategory.
Related OWASP ASVS 5.0 requirements (10)
Application-security verification requirements (OWASP ASVS 5.0) this ISO control aligns with; links open the ASVS chapter. Our analysis (mostly llm_verified) — many ISO controls have no ASVS counterpart.
Direction: ← other covers this;
→ this covers other (F/M/P = full / mostly /
partial). gov = governs / implements (a mandate, not coverage).
Related weaknesses / CWE (3248)
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-1125partialremoves — A.8.18 item (f) explicitly mandates removing or disabling unnecessary utility programs, and items (g) and (h) further reduce their availability — a direct removal action on the utility-program portion of the attack surface. CWE-1125 is broader than utility programs (it covers input points, output points, APIs, and other vectors), so the remainder is nameable and bounded: attack surface elements outside the privileged-utility scope are untouched.
- CWE-1125partialblocks — A.8.18 reduces attack surface by removing/disabling unnecessary utility programs and limiting their availability, which blocks exploitation through that specific vector class; however, CWE-1125 is a quantitative measure of the overall attack surface, and the control addresses only utility programs capable of overriding system/application controls, leaving other attack vectors (network inputs, APIs, services) untouched.
- CWE-15partialblocks — Use of privileged utility programs is controlled to prevent misuse of configuration tools.
- CWE-250partialblocks — A.8.18 addresses utility programs capable of overriding system/application controls — a subset of CWE-250 where the program itself holds privileges higher than needed for normal operation. For that subset, the clause restricts who may invoke the program (trusted authorized users with authentication, documented authorization levels, ad hoc approval, segregation from application traffic, and full logging), which denies exploitation to unauthorized actors. The underlying weakness — the utility program still holding unnecessary privileges — is not removed, and any authorized user can still exploit it, so the block is partial; non-utility-program instances of CWE-250 (application code running with excess privileges) are outside the clause's scope entirely.
- CWE-419partialblocks — A.8.18's segregation of network communications for utility programs (g) and authentication/authorization requirements (b, c) provide some blocking by isolating administrative utility traffic and restricting who can use it, but the clause does not mandate channel protection (encryption, integrity) and only covers utility programs rather than all primary administrative channels, so the unprotected channel remains exploitable in significant remainder.
- CWE-778partialremoves — A.8.18 explicitly requires logging all use of privileged utility programs, so where that logging was absent it removes that slice of CWE-778, but it does not reach insufficient logging for other security-critical events.
Mitigated MITRE ATT&CK techniques (2324)
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
- T1003partialdetects — A.8.18 item (i) requires logging of all use of utility programs, which surfaces credential dumping when it is performed via a utility program (e.g., Mimikatz, pwdump, gsecdump) treated as such; however, T1003 also encompasses techniques that use built-in OS mechanisms (comsvcs.dll, MiniDumpWriteDump, LSASS memory reads via debug privileges) that are not 'utility programs' in the A.8.18 sense, and the logging captures USE rather than credential-dumping activity specifically, so detection is a slice rather than coverage of the technique.
- T1003partialprevents — A.8.18 constrains utility programs capable of overriding system controls — a category that captures many credential-dumping tools (Mimikatz, ProcDump, pwdump, gsecdump) — by removing unnecessary ones, limiting availability, requiring authorization, and logging use; however, the technique also runs through custom malware, in-process memory reads, and built-in OS facilities (debugging privileges, /proc/pid/mem) that are not 'utility programs' the clause reaches, leaving a substantial remainder.
- T1003.001partialprevents — A.8.18 prevents the slice of T1003.001 that relies on third-party utility programs (procdump, mimikatz) by removing/disabling unnecessary utilities, restricting use to authorized users, and logging invocation, but it does not reach the built-in Windows mechanisms (comsvcs.dll, rundll32.exe, WER) or SSP DLL registry manipulation, nor does it stop an authorized administrator from performing the dump.
- T1003.002partialprevents — A.8.18(f) removes or disables unnecessary utility programs, which would eliminate third-party credential dumping tools like Mimikatz, gsecdump, secretsdump.py and pwdumpx.exe, but the technique also uses built-in Windows utilities (reg.exe) and in-memory techniques that do not require a separately installed tool, and the control does not address the SYSTEM-level access the technique presupposes — so what is prevented is a slice of the technique's toolset, not the bulk.
- T1003.003partialdetects — A.8.18's logging requirement (item i) for utility program use would detect the technique when executed via ntdsutil.exe, secretsdump.py, Invoke-NinjaCopy or similar tools explicitly named in T1003.003, but the technique can also be carried out through direct file-system access to NTDS.dit or Volume Shadow Copy methods that fall outside A.8.18's scope of 'privileged utility programs,' leaving a bounded remainder undetected.
- T1003.003partialprevents — A.8.18 restricts, logs and authorizes utility programs capable of overriding system controls, which directly addresses ntdsutil.exe and similar tools listed in the technique, but the technique has multiple vectors (direct NTDS.dit file access, Volume Shadow Copy, third-party tools like secretsdump.py, memory extraction) that fall outside the control's scope of utility program governance.
- T1003.004partialprevents — A.8.18 restricts and logs use of utility programs like Mimikatz that are primary tools for extracting LSA secrets, but the technique can also be executed with built-in Windows utilities (reg.exe, standard APIs) once SYSTEM access is obtained, and the control does not protect the credential storage itself or prevent the SYSTEM-level access the technique presupposes.
- T1003.005partialprevents — A.8.18 restricts utility programs (Mimikatz, secretsdump.py, tdbdump, Linikatz) through authorization, logging, and removal of unnecessary instances, which constrains the tool layer of T1003.005; however, the technique requires SYSTEM/root access (not controlled here) and can be executed with built-in utilities like Reg.exe, so the cached credentials remain reachable to any sufficiently privileged actor and the control addresses only a slice of the attack surface.
- T1003.008partialdetects — A.8.18 item (i) requires logging of all use of utility programs, which captures the canonical execution path of T1003.008 via `cat`, `unshadow` and similar utilities reading /etc/passwd and /etc/shadow; however, the technique can also be executed via shell built-ins, direct memory access, or exploitation that bypass utility programs entirely, and the clause's scope of 'privileged utility programs' may not uniformly cover basic utilities like `cat`, leaving a named remainder.
- T1003.008partialprevents — A.8.18 directly addresses the mechanism T1003.008 uses — utility programs like `cat` and `unshadow` — by restricting who may run them, requiring authentication and authorization, removing unnecessary utilities, and logging use; however, `cat` is essential and cannot be removed, and the technique presupposes root access to read `/etc/shadow`, which A.8.18 does not control (that belongs to A.8.2), so a root-level actor bypasses the restriction and the prevention is a slice rather than the bulk.
- T1006partialprevents — A.8.18 directly governs utility programs (NinjaCopy, vssadmin, wbadmin, esentutl) that T1006 relies on, and removing/disabling unnecessary utilities (f) plus restricting availability (h) and requiring authentication (b) prevents a real slice of the technique; however, built-in Windows utilities the technique commonly uses cannot be removed without breaking the system, and adversaries can bring their own tools, so the platform-required remainder stays reachable.
- T1007partialprevents — A.8.18 restricts who can use utility programs through authentication, authorization, and least-privilege, and (f) calls for removing unnecessary utilities — measures that can prevent non-administrator accounts from running `sc`, `tasklist`, `systemctl`, `net`, `schtasks`, `crontab`. But these are core OS utilities that typically cannot be removed without breaking the system, and an adversary who has compromised an authorized (especially privileged) account can still invoke them, so the technique is not fully prevented.
- T1012partialprevents — A.8.18 can restrict or remove the `reg.exe` utility specifically named in T1012, but the technique explicitly notes 'other means to access the Registry exist' (PowerShell, WMI, .NET methods, direct API calls), so removing one utility closes a slice rather than the technique.
- T1021.008partialprevents — A.8.18 restricts privileged utility programs to trusted users and requires authentication, which prevents an adversary from using a cloud-native console as a utility to pivot, but the control governs local programs and does not reach the cloud provider's own console mechanisms that the technique exploits.
- T1027.004partialprevents — A.8.18(f) requires removing or disabling unnecessary utility programs, and compilers like csc.exe/GCC are unnecessary on most production systems, so the technique is prevented there; however, on developer workstations and build servers where compilers are legitimately required, the technique remains viable, and an adversary who has compromised an authorized developer account retains access — the same shape as the CM-7 / T1059 anchor where the interpreters the platform requires cannot be removed.
- T1036.003partialprevents — A.8.18 partially prevents T1036.003 through removal of unnecessary utilities (f), authentication/authorization requirements (b, c, d) that identify the user regardless of what the binary is called, and segregation (g); however, the technique is specifically designed to evade the name-based logging (i) and authorization controls A.8.18 establishes, so the renaming itself is not stopped.
- T1037.002partialdetects — A.8.18's logging requirement (i) captures use of the `defaults` utility that modifies the loginwindow.plist, surfacing the mechanism by which the login hook is established; however, the clause logs utility program use generally rather than specifically monitoring login hook persistence, and the technique can also be executed by direct file modification outside the logged utility path.
- T1037.002partialprevents — A.8.18 restricts and logs use of the `defaults` privileged utility that T1037.002 depends on, and can disable unnecessary utilities, but the technique still runs for any administrator authorized to use the utility, so the control reduces rather than eliminates the attack surface.
- T1040partialprevents — A.8.18 restricts utility programs (sniffing tools like tcpdump/Wireshark) by limiting use, removing unnecessary ones, and requiring authorization, which prevents the utility-program-based subset of network sniffing on general systems; however, it does not address promiscuous-mode capability itself, span ports, cloud traffic mirroring services, or built-in network device CLI capture commands, which are the other vectors the technique enumerates.
- T1047partialdetects — A.8.18's logging requirement (item i) records use of utility programs including WMI, creating the data substrate for detecting abuse, but the control's primary purpose is preventive restriction and it does not mandate analysis or alerting on those logs, so detection is a side effect rather than the control's function.
- T1047partialprevents — A.8.18's authentication, authorization and logging requirements can prevent unauthorized users from invoking WMI, but WMI is a built-in Windows infrastructure that cannot be removed (guidance (f) only applies to unnecessary utilities), and the technique is reachable through multiple interfaces (wmic.exe, PowerShell, COM APIs, VBScript) that the control's restrictions on 'utility programs' do not uniformly cover, so a slice of the technique is prevented while the bulk remains reachable.
- T1048partialprevents — A.8.18 restricts, removes, and logs utility programs (Net, FTP, curl) that T1048 commonly abuses, but cannot eliminate utilities needed for legitimate operation, and does not reach cloud/SaaS exfiltration paths via web consoles or cloud APIs that T1048 also covers.
- T1049partialprevents — A.8.18 restricts utility programs (netstat, lsof, net use, net session, who, w, network device CLIs) to authorized users with logging and authentication, which prevents unauthorized adversaries from running them; however, many of these utilities are built into the OS or are the primary management interface on network devices and cannot be removed without breaking the system, and an adversary who has compromised an authorized account retains access — so the technique is constrained, not closed.
- T1053partialprevents — A.8.18's guidance (f) removing/disabling unnecessary utility programs and (h) limiting availability to authorized change windows can prevent T1053 where task scheduling is removed or time-bound, but task scheduling is a platform-required utility that cannot be removed in most deployments, and the authorization mechanisms (a-d) constrain who may use it rather than preventing the technique from running -- so what is prevented is a slice, not the bulk.
- T1053.002partialprevents — A.8.18 restricts utility program access to trusted users and removes unnecessary utilities, which can prevent at from being available to adversaries, but the at utility is often a legitimate system tool that cannot be removed without breaking functionality, leaving it accessible to authorized users who may be compromised.
- T1053.003partialdetects — A.8.18 item (i) mandates logging of all use of utility programs, and cron is a utility program, so the control creates a record of cron invocations and crontab modifications that can be reviewed for abuse; however, the clause mandates capture rather than analysis or alerting, cron has extensive legitimate use that makes abuse detection dependent on log review quality, and the control does not require correlation or thresholds — so what is detected is a slice of the technique's footprint, not the bulk.
- T1053.003partialprevents — A.8.18 restricts who may use utility programs like cron (via cron.allow/cron.deny and authorization levels), which prevents unprivileged or unauthorized users from scheduling jobs, but cron is a core system utility that cannot be removed or disabled without breaking the platform, and any user the control permits — including root — remains able to create cron jobs if compromised, leaving a bounded but real remainder.
- T1053.005partialprevents — A.8.18 can constrain who is authorized to use the Task Scheduler through clauses (a)-(d) and log its use under (i), but the Task Scheduler is a core Windows component that cannot be removed or disabled without breaking the OS — analogous to the cm-7 vs T1059 anchor where required interpreters cannot be removed. Adversaries with code execution can also reach the scheduler through multiple vectors (schtasks, WMI, PowerShell, .NET wrappers) that bypass utility-level authorization, so what is prevented is a slice rather than the bulk.
- T1053.006partialdetects — A.8.18(i) requires logging of utility program use, which would capture `systemctl` invocations to activate or manage timers, but the core of T1053.006 — creation of `.timer`/`.service` unit files and their scheduled execution by the systemd daemon — is not utility program use and falls outside the logging scope, so only the activation slice is surfaced.
- T1055.009partialprevents — A.8.18 restricts utility programs (the technique explicitly uses `dd` to overwrite /proc/[pid]/mem, and requires privileged /proc access), so removing/disabling unnecessary utilities, limiting availability, and logging/authenticating use constrain the technique; however, the /proc filesystem is a kernel interface rather than a utility, alternative tools can perform the overwrite, and authorized privileged users retain the capability, so prevention is partial rather than full.
- T1059.001partialdetects — A.8.18's guidance item (i) requires logging of all use of utility programs, and PowerShell is exactly the kind of privileged utility this clause targets, so its execution is logged and observable. The extent is partial because the logging captures authorized use of the utility program interface but does not reliably surface fileless invocation through the .NET System.Management.Automation assembly, and it records use without distinguishing malicious from legitimate activity.
- T1059.001partialprevents — A.8.18 constrains PowerShell through authentication, authorization, logging, and limiting availability, preventing unauthorized use, but PowerShell is a core OS component that cannot be removed or disabled — the technique still runs under controlled conditions, mirroring the cm-7 vs T1059 anchor where the interpreter the platform requires cannot be removed.
- T1059.003partialprevents — A.8.18 constrains use of utility programs through authentication, authorization levels, ad hoc approval, limited availability and logging, which restricts who can run cmd and when, but the core removal mechanism (f) does not apply because the Windows command shell is a required system component that cannot be disabled — mirroring the cm-7 anchor where interpreters the platform requires stay reachable and what is prevented is a slice, not the bulk.
- T1059.004partialprevents — A.8.18's authentication, authorization, segregation-of-duties and logging provisions can prevent unauthorized Unix shell use, but the shell is the primary command prompt on Linux/macOS/ESXi and cannot be removed or disabled without breaking the system, so the technique remains fully available to authorized users — the same shape as CM-7 vs T1059.
- T1059.006partialprevents — A.8.18(f) calls for removing or disabling unnecessary utility programs, which can include Python on systems where it is not required, and (a)/(b) constrain who may use utility programs through authentication and authorization — but Python is typically required for platform operation (especially on Linux/macOS) and is not the kind of privileged utility A.8.18 primarily targets, so what is prevented is a slice rather than the bulk.
- T1059.008partialdetects — A.8.18 item (i) requires logging of all use of utility programs, and network device CLI qualifies as a utility program capable of overriding system and application controls, so its use is captured in logs that can be reviewed for malicious activity; however, the clause mandates logging rather than analysis, the scope is limited to utility programs (not all CLI activity on the device), and the control is primarily preventive, so detection is a slice of the technique's surface rather than a complete view.
- T1059.008partialprevents — A.8.18's authentication, authorization and access-limitation clauses constrain who can invoke the network device CLI and what they can run, but the CLI is the primary administrative interface and cannot be removed or disabled without rendering the device unmanageable — so the technique remains executable by any authorized or compromised account, mirroring the cm-7 vs T1059 shape where a required interpreter cannot be taken away.
- T1059.009partialprevents — A.8.18 restricts local utility programs (CLIs, PowerShell modules) that access cloud APIs through authentication, authorization, logging and removal of unnecessary utilities, but the technique's core vectors — browser-based cloud shells, SDKs embedded in applications, and abuse via stolen Application Access Tokens or Web Session Cookies — operate outside the control's scope, so only a slice of the access methods is constrained.
- T1059.010partialprevents — A.8.18 restricts utility programs to trusted users and removes unnecessary ones, which can prevent AutoHotKey/AutoIT from being available to execute, but the technique can still run if the scripting engine is a permitted utility or is introduced by an adversary with authorized access.
- T1059.011partialprevents — A.8.18 can remove, disable or segregate unnecessary Lua interpreters (per guidance f, g, h), preventing the technique where the interpreter is not required; but Lua is frequently embedded in applications, network devices and games where it cannot be removed without breaking legitimate functionality, and those embedded interpreters are precisely the ones adversaries most abuse, so what is prevented is a slice rather than the bulk.
- T1059.012partialdetects — A.8.18 item (i) mandates logging of all utility program use, which captures hypervisor CLI invocations like esxcli and vim-cmd, creating the records from which abuse can be surfaced; however, the clause does not require analysis, correlation or alerting on those logs, so detection of malicious use versus authorized administrative activity depends on whatever reviews them, and the logging alone cannot distinguish the two.
- T1059.012partialprevents — A.8.18 restricts who can use utility programs capable of overriding system controls through authentication, authorization levels, and limiting availability — hypervisor CLIs are exactly such utilities — but the tool must remain available for legitimate ESXi administration, so it cannot be removed; an adversary who has compromised an authorized account or escalated privileges can still invoke esxcli/vim-cmd, leaving a bounded remainder the control cannot reach.
- T1059.013partialprevents — A.8.18's authentication, authorization, and user-limitation requirements prevent unauthorized adversaries from invoking the Docker CLI, kubectl, or container APIs, but the container CLI is necessary infrastructure that cannot be removed or disabled, and authorized users (or compromised credentials) can still abuse these tools — the same shape as CM-7 vs T1059.
- T1070partialprevents — A.8.18 prevents some instances of T1070 by removing or disabling unnecessary utility programs (f), restricting use to trusted authorized users (a, b, d), and limiting availability (h) — but cannot prevent the technique entirely because many utilities needed for indicator removal (e.g., wevtutil, auditpol, built-in log-clearing commands) are legitimate and necessary, and authorized users can still abuse their access to perform T1070.
- T1070.004partialdetects — A.8.18(i) requires logging of all use of utility programs, which surfaces file deletion performed via privileged utilities (e.g., SDelete), but the technique explicitly calls out built-in interpreter functions (del, rm, unlink) as a primary vector, and those are not utility programs under A.8.18's scope, so a substantial share of T1070.004 activity falls outside the logging requirement.
- T1070.005partialdetects — A.8.18 item (i) requires logging of utility program use, which would capture `net use /delete` invocations on systems where the control is implemented; however, the scope is limited to privileged utility programs (the /delete operation on a user's own share connection may not qualify), logging alone does not equal detection without review, and the technique is explicitly anti-forensic so the adversary may also tamper with the very logs that would surface it.
- T1070.005partialprevents — A.8.18 restricts utility programs like `net use` through authorization, authentication, logging, and limited availability, which constrains who can execute share-connection removal; however, an adversary operating under a compromised authorized account or with ad hoc authorization can still perform the action, so prevention is partial rather than complete.
- T1070.008partialprevents — A.8.18 restricts, authenticates and logs use of utility programs like ExchangePowerShell, mail, and AppleScript, preventing unauthorized users from running them to clear mailbox data; however, authorized administrators retain the ability to abuse their access, and the technique can be executed through direct API calls or database access outside the utility-program scope, leaving a substantial remainder.
- T1070.009partialdetects — A.8.18's logging of utility program use (item i) would surface T1070.009 actions performed via privileged utilities, but the technique is most commonly executed with built-in OS commands (sc delete, reg delete, rm, service removal) that fall outside A.8.18's scope of utility programs capable of overriding system and application controls.
- T1072partialprevents — A.8.18 restricts privileged utility access to trusted users and requires logging, which prevents some unauthorized use of deployment tools, but the tools must remain available for legitimate administration and an adversary with valid admin credentials is not stopped.
- T1098partialprevents — A.8.18 can block or restrict access to privileged utility programs commonly used for account and group modification, but account manipulation can also be performed through directory, API, or already-authorized account channels outside those utilities, so prevention is only partial.
- T1098.007partialdetects — A.8.18 requires logging of all use of utility programs, which would capture the execution of commands like `net localgroup` or `usermod` if they are classified as privileged utilities, but the control's scope is limited to programs capable of overriding system controls and does not guarantee logging of all group modification methods.
- T1098.007partialprevents — A.8.18 restricts and logs use of utility programs (net.exe, usermod) through authentication, authorization, and access limitation, which prevents unauthorized users from executing the technique; however, the utilities are required for system administration and cannot be removed, so authorized users (or compromised admin accounts) can still add accounts to groups, leaving a bounded remainder where the technique succeeds.
- T1105partialprevents — A.8.18's clauses (f) removing unnecessary utility programs, (a/b/c) restricting use to authorized users with authentication, and (h) limiting availability directly constrain the utility-based transfer mechanisms named in T1105 (curl, wget, scp, sftp, tftp, rsync, finger, certutil), but the technique also runs through PowerShell, native OS commands, application protocol handlers (search-ms), package managers, and cloud sync services that A.8.18 does not reach, leaving a meaningful remainder.
- T1112partialdetects — A.8.18's logging requirement (item i) for utility program use would surface registry modifications performed through logged utilities like reg.exe, but T1112 can also be executed via direct Windows API calls from running processes, PowerShell, remote access tools, and other paths that fall outside the scope of 'utility program' logging, so detection covers a slice rather than the technique's full execution surface.
- T1112partialprevents — A.8.18 can remove or disable specific registry-editing utilities (reg.exe, regedit.exe) and restrict their use to authorized users, preventing that path; but T1112 is broader — any program with appropriate permissions can call the Win32 Registry APIs, and remote modification via SMB/RPC does not require a local utility program, so the technique is not fully prevented.
- T1127partialprevents — A.8.18(f) requires removing or disabling unnecessary utility programs, and (a)/(h) restrict availability to authorized users for limited durations, which prevents T1127 where developer utilities are not legitimately needed; however, developer utilities that the platform or development function requires cannot be removed, and those are precisely the signed, trusted utilities T1127 abuses, mirroring the cm-7 vs T1059 anchor where required interpreters stay reachable.
- T1127.001partialdetects — A.8.18 requires logging of all use of utility programs, which would capture MSBuild execution, but detection depends on the organization's monitoring scope and analysis of those logs, not on the logging requirement itself.
- T1127.001partialprevents — A.8.18 constrains utility use through trusted-user limits, authorization, segregation and removal of unnecessary utilities, but MSBuild is often a required platform component for legitimate development and cannot simply be removed; the technique exploits that legitimate functionality, so what is prevented is a slice (unauthorized or ad-hoc use by unprivileged actors) rather than the bulk.
- T1127.003partialprevents — A.8.18 can prevent the technique where JamPlus is unnecessary and gets removed/disabled per (f), but on developer workstations where the build utility is legitimately required, the control's restrictions (authorized users, authentication, logging) do not stop an authorized developer from authoring a malicious .jam file that JamPlus then executes as designed — the abuse is the tool doing its job, so the prevention is a slice limited to environments where the utility can be removed.
- T1136partialprevents — A.8.18 restricts privileged utility programs (limiting users, requiring auth, logging, removing unnecessary ones), which blocks a slice of T1136 executions that rely on such tools, but the technique primarily runs through standard system commands (net user, PowerShell cmdlets), cloud APIs, and direct directory manipulation that are not 'utility programs' in the A.8.18 sense, so the prevented share is small.
- T1136partialdetects — A.8.18's logging requirement (item i) captures use of privileged utility programs, so an adversary creating accounts via tools like net user, useradd, or similar utilities leaves a logged trail that can be correlated to detect the account creation; however, the logging is scoped to utility program invocation rather than to account-creation events, and T1136 can be executed through cloud APIs, identity provider consoles, IaC pipelines, and direct directory calls that bypass utility programs entirely, leaving the control with no observation surface for those paths.
- T1136.001partialdetects — A.8.18's logging requirement (item i) captures use of utility programs such as `net user /add`, `useradd`, and `dscl -create`, which are the primary methods described for T1136.001, but the technique can also be executed via exploitation of firewall or management consoles (not covered), and the logging records utility invocation rather than the account-creation event itself, requiring log analysis to identify the malicious activity.
- T1136.001partialprevents — A.8.18 removes or disables unnecessary utility programs and limits their use to trusted, authorized users, which prevents some local account creation via those utilities, but adversaries can still create accounts through other means such as built-in OS commands or exploited applications.
- T1136.002partialprevents — A.8.18 restricts privileged utility programs to trusted users and requires logging, which prevents unauthorized domain account creation by those without access, but does not stop an adversary who has already compromised a trusted user's credentials from using the same utilities.
- T1140partialdetects — A.8.18 item (i) requires logging of all use of utility programs, which provides a forensic trail that can be analyzed to detect use of utilities like certutil, copy /b, or type for deobfuscation; however, the clause mandates logging rather than active monitoring/alerting, the detection depends on downstream log analysis, and not all utilities abused in T1140 fall within the 'privileged utility programs' scope the clause addresses.
- T1140partialprevents — A.8.18 can prevent some instances of T1140 by removing or disabling unnecessary utilities (f) and restricting who may run them (a-d), but the technique commonly relies on built-in utilities like certutil, copy /b, and type that are typically needed for legitimate operations and cannot be removed, and it can also use built-in functionality of the malware itself — neither of which A.8.18 reaches.
- T1197partialdetects — A.8.18's logging requirement (item i) for utility program use would capture BITSAdmin and PowerShell invocations that create BITS jobs, enabling detection of those vectors; however, BITS abuse also occurs via direct COM access and through applications using BITS legitimately, and the logging surfaces the use without flagging malicious intent, so detection is a slice rather than comprehensive coverage.
- T1197partialprevents — A.8.18 can restrict, log, and require authorization for BITSAdmin (a utility program within scope), and item (f) supports removing it where unnecessary, but BITS jobs can also be created via PowerShell cmdlets and COM interfaces, and the BITS service itself is a system component that cannot be disabled without breaking legitimate functionality, so only a slice of the technique's vectors is closed.
- T1202partialprevents — A.8.18 restricts utility programs to trusted users, removes unnecessary ones, and segregates them, which prevents some indirect execution paths, but the technique can still abuse utilities that remain available to authorized users or are not classified as privileged.
- T1216partialprevents — A.8.18 restricts and can disable utility programs capable of overriding system and application controls, and T1216's proxy-execution binaries/scripts (regsvr32, mshta, wmic, etc.) can be read as falling under that scope; limiting authorized users, removing unnecessary instances and segregating them from application traffic reduces the technique's reach, but the scripts are often default Windows components required for legitimate operation and the technique has many signed-script variants, so the control cannot fully prevent it.
- T1216.001partialprevents — A.8.18's guidance to remove or disable unnecessary utility programs (f), restrict use to authorized users (a, b, c, d), and log use (i) can prevent T1216.001 where PubPrn.vbs is removed or its execution is restricted to a tightly controlled set of users; however, PubPrn.vbs is a Microsoft-signed system script often required for legitimate printing, the technique specifically bypasses signature validation and application control, and A.8.18 does not address the underlying cscript.exe execution path, so a meaningful slice of implementations will still permit the abuse.
- T1216.002partialprevents — A.8.18(f) permits removing or disabling unnecessary utility programs, and (h) limits availability, so where SyncAppvPublishingServer.vbs is treated as unnecessary or restricted the technique cannot run; however, the script is a Microsoft-signed System32 component commonly required for App-V, so most implementations will not remove it, and the control's other clauses (limiting to trusted users, logging) constrain rather than prevent execution by an authorized user.
- T1218partialprevents — A.8.18 removes or disables unnecessary utility programs and limits availability to authorized users, which prevents some trusted binaries from being available for proxy execution, but the operating system's own signed binaries cannot be removed without breaking the platform, so the technique remains reachable through what must stay.
- T1218.002partialprevents — A.8.18's restrictions on utility programs (logging, authentication, authorization, limiting availability) can constrain who may invoke control.exe and register .cpl files, but control.exe is a core Windows component that cannot be removed or disabled per (f), and the technique exploits its legitimate proxy-execution functionality, so the prevention is a slice rather than a closure.
- T1218.003partialdetects — Item (i) requires logging of all use of utility programs, and CMSTP is a utility program, so its invocation is recorded and observable in logs; however, A.8.18 is primarily a preventive control (limiting use, authorization, removal) and the logging is for accountability rather than active monitoring or alerting on malicious patterns, so detection is passive and bounded.
- T1218.003partialprevents — A.8.18's guidance (f) removing/disabling unnecessary utility programs and (a,b,c,d) restricting use to authorized users can prevent CMSTP abuse where the binary is removed or tightly controlled, but CMSTP.exe is a built-in Windows component often needed for legitimate Connection Manager functionality, so it frequently remains available; even restricted access can be abused by authorized users, and the technique is specifically designed to bypass application control defenses.
- T1218.004partialprevents — A.8.18(f) requires removing or disabling unnecessary utility programs, so where InstallUtil is not needed it can be removed and the technique cannot run; however, InstallUtil is part of the .NET framework and is commonly required for legitimate application deployment, so on systems where it must remain the technique can still execute under authorized use, leaving a substantial remainder the control cannot reach.
- T1218.005partialdetects — A.8.18 item (i) requires logging of all use of utility programs, and mshta.exe is a utility program, so its execution leaves an audit trail that can be reviewed to detect anomalous or unauthorized use; however, logging is only one of nine guidance items in a primarily preventive clause, and the control mandates the record but not the analysis or alerting that would constitute full detection.
- T1218.005partialprevents — A.8.18 directly targets utility programs capable of overriding system/application controls, and mshta.exe is exactly such a utility; clauses (a), (d), (f), (h), (i) constrain its use, and (f) can remove it where deemed unnecessary. But mshta is a built-in Windows utility with legitimate HTA use cases that often cannot be removed without breaking functionality, and adversaries with code execution can still invoke it where it remains available — so what is prevented is a slice, not the bulk.
- T1218.007partialprevents — A.8.18 constrains who may invoke utility programs and requires authorization, authentication and logging, but msiexec is a native, signed Windows component required for legitimate installation, so item (f) cannot remove it; the technique still executes when invoked by an authorized user or via abuse paths the clause does not close, leaving a bounded remainder analogous to the CM-7 vs T1059 anchor.
- T1218.008partialprevents — A.8.18 directly targets utility programs capable of overriding system/application controls, and odbcconf.exe is exactly such a utility; clauses (a), (b), (f), and (i) constrain who may run it, require removal of unnecessary instances, and log all use, so where the binary is removed or access is restricted to authorized users the technique cannot run -- but odbcconf.exe is a signed Microsoft component often needed for legitimate ODBC configuration, so it cannot universally be removed, and an authorized user can still abuse it, leaving the bulk of the technique reachable.
- T1218.009partialdetects — A.8.18's guideline (i) requires logging of all use of utility programs, and Regsvcs/Regasm are utility programs, so their execution leaves a logged trail that enables detection; however, the control is primarily preventive (restricting who can use these utilities), logging is one of nine guidelines, and the control does not mandate active monitoring or alerting on those logs — that is A.8.16's role — so detection is a side-effect of one clause rather than the control's function.
- T1218.009partialprevents — A.8.18's removal/disablement of unnecessary utilities and restriction to trusted users can prevent Regsvcs/Regasm from being available for abuse, but the utilities are legitimate Windows components that may be required and therefore cannot be universally removed.
- T1218.010partialprevents — A.8.18 can constrain regsvr32 use through authorization, logging, and limiting availability to trusted users, but regsvr32 is a required Windows utility that cannot be removed or disabled, and the technique is specifically designed to abuse legitimate signed binaries that bypass application control — the same shape as cm-7 vs T1059, where the required interpreter stays and what is removed is a slice.
- T1218.012partialprevents — A.8.18's restrictions on utility programs (limiting use, authentication, logging, removing unnecessary ones) can apply to verclsid.exe, but it is a native Windows OS component that cannot be removed without breaking the platform, and the technique is specifically designed to abuse signed native binaries that bypass application control — so what is prevented is a slice, not the bulk.
- T1218.013partialdetects — A.8.18's logging requirement (item i) captures invocations of utility programs including mavinject.exe, creating records that could be reviewed to surface abuse, but the clause does not mandate review or alerting, and the technique is specifically designed to evade detection by abusing a Microsoft-signed binary, so logging alone yields a slice rather than comprehensive detection.
- T1218.013partialprevents — A.8.18's clauses (a)-(f) and (h) directly target utility programs capable of overriding system and application controls — mavinject.exe is exactly such a utility — so removing/disabling it (f), restricting it to authorized users (a, b, c, d), and time-limiting its availability (h) can prevent the technique in implementations where App-V is not used; however, mavinject.exe is a Microsoft-signed system binary whose removal is often impractical or blocked by Windows integrity protections, and access restrictions do not stop an authorized user from abusing it, leaving a bounded remainder where the binary remains and the technique is still possible.
- T1218.014partialprevents — A.8.18 can restrict who is permitted to invoke mmc.exe, log its use, and in narrow deployments remove or disable MMC where it is deemed unnecessary, which prevents some instances of the abuse; however MMC is a Microsoft-signed binary the platform generally requires for administration, so it usually remains available, and authorized users can still open malicious .msc files or run MMC commands, leaving the technique reachable.
- T1219partialprevents — A.8.18 reduces the attack surface by removing unnecessary remote access tools (f), restricting availability (h), and requiring authentication/authorization (b, c, d), but cannot prevent an adversary with compromised credentials from abusing legitimate, authorized remote access tools — which is precisely the technique's core mechanism — and built-in tools like RDP or Chrome Remote Desktop often cannot be removed without breaking operations.
- T1219.002partialdetects — A.8.18 item (i) requires logging of all use of utility programs, which creates records that surface remote desktop software activity if classified as a utility program; however, the control is primarily preventive (access control, authorization, removal), the logging is recording rather than analysis, and coverage depends on whether the remote desktop software is classified as a privileged utility program under the organization's implementation.
- T1219.002partialprevents — A.8.18 can prevent some instances of T1219.002 by removing or disabling unnecessary remote desktop software per guidance (f), and by limiting availability per (h), but the technique commonly persists because remote desktop tools are often deemed necessary for support, built-in features (Chrome Remote Desktop, Zoom) may not be classifiable as removable utility programs, and authorized installations remain usable by adversaries who compromise legitimate credentials.
- T1220partialprevents — A.8.18 directly targets utility programs capable of overriding system and application controls, which is exactly what T1220 abuses (msxsl.exe and wmic). Removing or disabling unnecessary utilities (f) can fully prevent the msxsl.exe variant since it is not installed by default, but wmic is a built-in Windows tool that cannot realistically be removed, and restricting its use (a, b, c, d) only limits who can invoke it rather than preventing invocation by an authorized or compromised account.
- T1222partialdetects — A.8.18's logging requirement (item i) records use of utility programs, and T1222 is commonly executed via utilities like icacls, chmod, chown and takeown — so a meaningful share of the technique leaves an audit trail. The remainder is bounded but real: T1222 can be performed through direct API/syscalls (SetSecurityInfo, chmod()) without invoking a 'utility program' as the clause frames it, and A.8.18 mandates the LOG, not the ANALYSIS or alerting that turns a log into a detection.
- T1222partialprevents — A.8.18 restricts and logs use of utility programs capable of overriding system controls — chmod, icacls, Set-Acl and similar are exactly such utilities — so unauthorized use of these tools to modify ACLs is prevented; the remainder is that authorized users can still perform the technique, and the technique can be executed through direct system calls, APIs, or malware that bypasses the utility-program layer entirely.
- T1222.001partialdetects — A.8.18 item (i) requires logging of all use of utility programs, and the commands central to T1222.001 (icacls, cacls, takeown, attrib) are system utilities capable of overriding access controls, so their invocation would be captured in such logs; however, the clause mandates logging rather than analysis or alerting, coverage depends on whether these specific tools are classified as utility programs in the implementation, and the control's primary purpose is preventive (limiting use, authentication, authorization, removal), so detection is a side effect rather than the control's function.
- T1222.001partialprevents — A.8.18 restricts and logs use of utility programs like icacls, cacls, takeown, and attrib, preventing unauthorized users from running them, but these are built-in Windows utilities required for legitimate system administration and cannot be removed or disabled — so authorized administrators can still execute the technique, leaving a bounded remainder similar to the cm-7 vs T1059 anchor.
- T1222.002partialdetects — A.8.18(i) requires logging of all use of utility programs, and chmod/chown fall within that scope if treated as utilities capable of overriding access controls, so invocations are recorded; however, the control mandates capture rather than analysis or alerting, and these are commonly used legitimate utilities, so the record alone does not distinguish malicious from benign use without downstream correlation.
- T1222.002partialprevents — A.8.18 restricts and logs use of utility programs like chmod/chown that can override access controls, preventing unauthorized users from invoking them, but these are essential system utilities that cannot be removed or disabled, and the technique typically executes under an already-compromised account where the control's authorization requirements do not stop the invocation.
- T1482partialprevents — A.8.18 can remove, disable, or restrict privileged utilities such as Nltest, but domain trust data remains enumerable through LDAP, .NET, and Win32 API calls, so it only blocks a utility-based slice of the technique.
- T1484.001partialprevents — A.8.18 restricts utility programs capable of overriding system and application controls, and tools used for GPO modification (PowerShell AD cmdlets, scripts like New-GPOImmediateTask, direct file editors of SYSVOL) can be classed as such utility programs — limiting authorized users, removing unnecessary tools, and logging use partially prevents the technique. However, the primary vector is AD write permissions on GPO objects themselves, which A.8.18 does not address, and many GPO modification capabilities are built into standard administrative tools that cannot be removed without breaking domain administration.
- T1489partialprevents — A.8.18 restricts privileged utility programs (e.g., psExec, remote admin tools) that can override system controls, so where stopping a service requires such a utility and that utility is removed, disabled or access-controlled, the technique cannot run; but T1489 has many vectors outside the clause's scope — built-in commands (net stop, sc, Stop-Service), direct process termination, cloud APIs like DisableAPIServiceAccess, and authorized users acting within their rights — so what is prevented is a slice, not the bulk.
- T1490partialprevents — A.8.18 directly addresses the mechanism T1490 exploits (utility programs like vssadmin.exe, wbadmin.exe, bcdedit.exe) by restricting use to authorized users, requiring authentication, removing unnecessary utilities, and logging use — but the utilities are often legitimately required for system administration, so they cannot be removed wholesale, and an adversary who has compromised an administrator's credentials can still invoke them; the control reduces the attack surface without closing it.
- T1491.001partialdetects — A.8.18's logging of utility program use (item i) surfaces the invocation of privileged tools that an adversary might use to perform defacement (e.g., editing web content, changing login banners or wallpaper), but it detects the tool use rather than the defacement outcome, and only catches the subset of defacements performed through logged utilities — not defacement via application-level access, scripts, or direct file modification outside the utility scope.
- T1495partialprevents — A.8.18 restricts, logs, and authorizes utility programs capable of overriding system controls, which includes firmware-flashing utilities, so unauthorized firmware corruption via those tools is prevented; however, firmware corruption has many vectors outside utility-program scope (vulnerability exploits, supply-chain compromise, hardware-level attacks, built-in OS commands), so the control addresses a slice rather than the bulk of the technique.
- T1505.002partialprevents — A.8.18's requirements for authorization, authentication, removal of unnecessary utility programs, and limitation of availability provide a preventive framework against unauthorized transport agents, but the technique requires Exchange admin access to register the .NET assembly, which typically allows bypassing these governance controls; the clause governs authorized use more effectively than it prevents malicious installation by a sufficiently privileged adversary.
- T1505.004partialprevents — A.8.18's restrictions on who may install/use utility programs, its authentication and authorization requirements, and its logging of all use create friction against unauthorized installation of IIS components, but the control governs USE rather than blocking installation of malicious code, and an adversary operating under a compromised authorized account or via the web application's own deployment path can still register ISAPI extensions, filters, or modules.
- T1505.006partialprevents — A.8.18 governs utility programs like `esxcli` that install VIBs, requiring authorization, logging, and limiting availability — which prevents unauthorized users from installing VIBs and ensures all installations are recorded. However, the technique requires privileged ESXi access to begin with, and A.8.18 does not prevent a privileged user (or an attacker who has compromised one) from installing a malicious VIB within their authority, nor does it stop the `--force` bypass of acceptance levels.
- T1531partialdetects — A.8.18(i) requires logging of all use of utility programs, and T1531 frequently executes through utilities (net, Set-LocalUser, Set-ADAccountPassword, passwd, esxcli), so their invocation is captured; however, T1531 also occurs via Group Policy, SaaS admin consoles, and direct authentication-system manipulation outside the utility-program scope, and the logs record use rather than the specific account-removal effect, requiring correlation to identify the technique.
- T1531partialprevents — A.8.18 restricts and authorizes use of the very utility programs (net, Set-LocalUser, Set-ADAccountPassword, passwd, esxcli) that adversaries use for T1531, and removes unnecessary ones, which prevents unauthorized execution; but authorized administrators can still use them, the technique can be performed via non-utility means (Group Policy, SaaS admin consoles), and a compromised authorized account bypasses the restriction, so the technique is constrained rather than blocked.
- T1542.001partialprevents — A.8.18 restricts privileged utility programs (firmware flashing tools fall within its scope) through authentication, authorization, removal of unnecessary utilities, and logging, which prevents the software-mediated path to firmware modification by unauthorized users; however, the technique can also be executed via physical access, supply chain compromise, OS-level update mechanisms, or exploits that bypass utility-program controls, so a meaningful slice is prevented but not the whole technique.
- T1542.003partialprevents — A.8.18 restricts, authenticates and logs use of privileged utilities (e.g., low-level disk tools) that could write to MBR/VBR/ESP, closing one installation path, but it does not address physical access, boot from external media, or UEFI firmware attacks — so the technique still has reachable vectors the control does not cover.
- T1542.004partialprevents — A.8.18 removes or disables unnecessary utility programs and limits availability to authorized users, which can prevent an adversary from loading unauthorized ROMMON firmware, but the control does not eliminate the boot loader itself or block all paths to firmware modification on a network device.
- T1543partialdetects — A.8.18's logging requirement (i) captures use of privileged utility programs, which surfaces the subset of T1543 where an adversary creates or modifies a system process via a utility (e.g., sc.exe, systemctl), but the technique also executes through direct API calls, config-file edits, or other paths outside the utility-program scope, and the logged event is the utility's invocation rather than the resulting service change.
- T1543partialprevents — A.8.18 restricts, logs, and removes utility programs capable of overriding system controls, which closes off utility-mediated paths to creating or modifying services/daemons/agents; however, T1543 can also be executed through built-in OS commands (sc.exe, systemctl, launchctl), direct file/registry manipulation, and API calls, none of which A.8.18 reaches.
- T1543.002partialprevents — A.8.18 restricts who can use privileged utility programs (like systemctl) and requires authentication, authorization, and logging for their use, which constrains the utility-mediated path to creating or modifying systemd services; however, systemctl is a required system tool that cannot be removed, and the technique can be executed by directly writing .service files, placing symlinks, or using systemd generators without invoking the controlled utility, so a meaningful slice of the attack surface remains reachable.
- T1543.003partialprevents — A.8.18 constrains the use of utility programs like sc.exe and PnPUtil.exe (one execution path for T1543.003) through authorization, logging, and availability limits, but the technique can also be executed via direct Windows API calls (CreateServiceW, ZwLoadDriver) and direct registry modification, which bypass utility-program controls entirely.
- T1543.003partialdetects — A.8.18(i) requires logging of all use of utility programs, which surfaces the sc.exe and PnPUtil.exe execution paths of T1543.003, but the technique also runs via direct registry modification, CreateServiceW/ZwLoadDriver/ZwSetValueKey API calls, and BYOVD driver loading — none of which are utility program invocations and therefore fall outside the control's logging scope.
- T1543.005partialdetects — A.8.18's logging requirement (item i) records use of utility programs, so authorized container tooling (docker, podman, kubelet) classified as utility programs leaves an audit trail when invoked, which surfaces some instances of the technique; however, the control is fundamentally preventive (limiting access, removing unnecessary utilities, segregation), the logging covers USE rather than modification of the services themselves, and scope is set by what the organization classifies as a utility program rather than mandated depth of instrumentation.
- T1543.005partialprevents — A.8.18 removes or disables unnecessary utility programs and limits availability to authorized users, which can prevent an adversary from using container management tools like Docker or Podman to create persistent services, but the control does not eliminate the risk where the tools are legitimately required and an authorized user is the adversary.
- T1546.001partialprevents — A.8.18 removes or disables unnecessary utility programs and limits their use to trusted users, which can prevent the adversary from using assoc or reg to modify file associations, but the technique can also be executed via registry APIs or scripts that do not require a privileged utility program.
- T1546.003partialdetects — A.8.18 item (i) requires logging of all use of utility programs, and WMI tooling (wmiprvse.exe, mofcomp.exe, WMI command-line use) falls within that scope, so subscription creation leaves traces in the logs the clause mandates; but the logging is scoped to accountability of authorized use rather than to the specific artifacts of a malicious subscription (event filters, consumers, bindings), and a conformant implementation focused on who-used-what rather than what-was-created will surface only a slice of the technique.
- T1546.003partialprevents — A.8.18 restricts utility programs like mofcomp.exe through authorization, logging, and limited availability, which constrains one execution path for WMI event subscriptions, but WMI is a core Windows component that cannot be removed or disabled, and subscriptions can be created through PowerShell, scripts, or the WMI API directly, so the technique is not fully prevented.
- T1546.008partialprevents — A.8.18(f) (removing or disabling unnecessary utility programs) can prevent the technique where accessibility features are deemed unnecessary and removed, eliminating the binary the adversary replaces; however, the clause governs USE of utility programs rather than binary replacement at the login screen, accessibility features are often retained for legitimate reasons, and the technique's core mechanism (replacing sethc.exe/utilman.exe or hijacking via IFEO) is not directly addressed by the clause's authentication, authorization, or logging controls.
- T1546.011partialdetects — A.8.18's logging requirement (item i) captures use of privileged utilities, and sdbinst.exe — the primary shim installer requiring admin rights — falls within that scope, so installation of malicious shims surfaces in logs; however, the control is general-purpose rather than shim-specific, execution of already-installed shims is not detected, and detection depends on whether sdbinst.exe is classified and logged as a privileged utility in the implementation.
- T1546.011partialprevents — A.8.18 restricts who can use utility programs like sdbinst.exe, requires authorization and logging, and can limit availability — but the shim infrastructure is built into Windows and cannot be removed, and the technique already requires administrator privileges, so an authorized (or compromised-admin) user can still install shims; the control constrains the surface without closing it.
- T1546.012partialdetects — A.8.18's logging of utility program use (item i) and authentication requirements would surface the execution of an IFEO-injected debugger when it runs, but the control does not monitor the Registry modifications that establish the IFEO Debugger values in the first place — the core persistence/privilege-escalation setup occurs outside the control's logging scope.
- T1546.012partialprevents — A.8.18 restricts utility programs capable of overriding system controls (debuggers like ntsd.exe, GFlags), so removing/disabling those utilities and limiting their use to authorized users blocks the GFlags-based path; however, IFEO injection can also be performed by directly modifying Registry values without invoking a utility program, which A.8.18 does not address.
- T1546.013partialprevents — A.8.18's restrictions on utility program use (limiting trusted users, requiring authentication/authorization, limiting availability, logging) can constrain who may invoke PowerShell and under what conditions, which removes some attack surface for profile-based persistence; however, the technique's core mechanism is unauthorized modification of the profile.ps1 file itself, which A.8.18 does not address — file-integrity, write-access controls, and profile-content restrictions are outside the clause's scope, and the profile can be edited with tools other than PowerShell.
- T1547.006partialdetects — A.8.18's logging requirement (i) captures utility program use, which includes kernel module loading tools (insmod, modprobe, kextload), creating records that enable detection of malicious LKMs/kexts; however, the clause only mandates logging, not analysis, and LKM rootkits explicitly feature log tampering, so the detection signal is real but bounded.
- T1547.006partialprevents — A.8.18's authorization requirements (b, d), removal of unnecessary utility programs (f), and limitation of availability (h) constrain who can load kernel modules and reduce attack surface, but kernel modules are fundamental to OS operation (device drivers, filesystem modules) and cannot be removed wholesale, so a meaningful slice of the technique's surface remains when an attacker holds the privileges needed to load modules.
- T1547.012partialprevents — A.8.18(f) removing or disabling unnecessary utility programs prevents the technique where the print spooler service is not required, but in environments that need printing the control only constrains who may install print processors (a, b, c, d) without stopping a privileged user from registering a malicious DLL, so the technique remains reachable on systems that retain the spooler.
- T1548partialprevents — Restricting and logging privileged utility programs directly limits an adversary's ability to abuse elevation mechanisms such as sudo, UAC bypasses, or setuid binaries.
- T1548partialdetects — A.8.18's logging requirement (item i) records use of privileged utility programs, which surfaces a subset of T1548 — those sub-techniques that abuse utilities to escalate — but T1548 also includes UAC bypass via token manipulation, exploitation of elevation-mechanism vulnerabilities, and other paths that do not involve a utility program at all, so the logging sees only a slice of the technique.
- T1548.001partialdetects — A.8.18's logging requirement (item i) captures use of utility programs such as chmod and find, and execution of setuid binaries, which surfaces parts of the technique; however, the clause does not mandate monitoring of file permission changes themselves or the resulting privilege escalation, so the underlying setuid/setgid abuse is not comprehensively detected.
- T1548.001partialprevents — A.8.18's guidance on removing or disabling unnecessary utility programs (f), limiting use to trusted authorized users (a), and authentication/authorization procedures (b) addresses part of the attack surface — specifically unnecessary setuid/setgid binaries that can be removed or restricted — but does not reach the technique fully: adversaries can still set the bits on their own malware if they have write access, and necessary setuid binaries (passwd, mount, etc.) remain in place and may be vulnerable, which is a remainder the control does not cover.
- T1548.002partialprevents — A.8.18's guidance on removing or disabling unnecessary utility programs (f), limiting their availability (h), and requiring authentication/authorization for their use (b) can constrain some UAC bypass vectors that rely on specific utilities, but many T1548.002 techniques exploit auto-elevated core Windows utilities (eventvwr.exe, rundll32.exe, etc.) that cannot be removed without breaking the system, and the control does not specifically address UAC mechanisms or process injection into trusted processes.
- T1548.003partialprevents — A.8.18 limits utility program access to trusted users and requires authentication, which constrains who can run sudo and reduces the chance of a misconfigured sudoers file, but it does not eliminate the technique because authorized users and their cached credentials remain available for abuse.
- T1548.004partialprevents — A.8.18 can reduce the attack surface by removing or disabling unnecessary programs that call AuthorizationExecuteWithPrivileges (clause f), limiting availability (h), and restricting use to trusted authorized users (a,b), but the API is a built-in macOS system feature, legitimate programs that use it can be modified to abuse it, and the technique relies on user credential entry which A.8.18 does not address — so what is prevented is a slice, not the bulk.
- T1550.003partialprevents — A.8.18 prevents the utility-program vector of Pass the Ticket by removing/disabling unnecessary utilities (f), restricting use to authorized users (a), and requiring authentication for utility programs (b) — which removes offensive tools like Mimikatz/Rubeus from the estate — but the technique can still be executed through built-in Windows tools (klist, PowerShell) and native Kerberos APIs that the control does not reach.
- T1553partialprevents — A.8.18 restricts, logs and removes privileged utility programs that could be used to subvert trust controls (e.g. tools that modify certificate stores, registry trust entries, or Mark-of-the-Web), but T1553 has many vectors that do not require utility programs — registry modification, file/directory permission changes, and stolen/forged code-signing certificates can all subvert trust from a normal user context, so only a slice of the technique is closed off.
- T1553.001partialprevents — A.8.18 restricts or removes utility programs such as xattr or curl that can override or avoid Gatekeeper's quarantine and signing checks, but the technique also succeeds through logic errors, unchecked file types, and previously opened application bundles, so prevention is only a slice.
- T1553.004partialprevents — A.8.18 can prevent some instances by removing unnecessary certificate-management utilities (f) and limiting their availability to authorized change windows (h), but the platform typically requires these utilities (certutil, security add-trusted-cert, update-ca-certificates) for legitimate operation, and once an adversary has administrative access on a compromised system they can invoke them — so what is removed is a slice rather than the bulk, mirroring the cm-7 anchor's shape.
- T1553.006partialdetects — A.8.18(i) requires logging of all use of utility programs, which surfaces the common execution paths for T1553.006 (bcdedit.exe, csrutil, GUI utilities), but the technique also proceeds via registry modification, debug/recovery boot, and kernel-memory manipulation — none of which are utility-program invocations and so fall outside A.8.18's logging scope.
- T1553.006partialprevents — A.8.18 directly addresses the utility-program vector of T1553.006 (e.g., bcdedit.exe, csrutil) by restricting, authorizing, segregating and logging use of such utilities, but the technique also executes via registry modification, debug/recovery mode boot, and kernel-memory exploitation through vulnerable drivers — none of which A.8.18 reaches.
- T1554partialprevents — A.8.18 restricts and logs use of privileged utility programs, which addresses one vector an adversary could use to patch or replace binaries, but T1554 can be accomplished through standard file operations, built-in OS commands, or custom tooling that fall outside the clause's scope of 'utility programs capable of overriding system and application controls.'
- T1555.001partialprevents — A.8.18 restricts and logs use of the `security` command-line utility (the primary vector for `security dump-keychain`), but the technique can also read Keychain files directly from `~/Library/Keychains/` and only requires the user's login password, neither of which A.8.18 addresses.
- T1555.004partialprevents — A.8.18 directly constrains the utility-program vectors of T1555.004 — `vaultcmd.exe`, `rundll32.exe keymgr.dll KRShowKeyMgr`, and password-recovery tools are exactly the kind of privileged utilities the clause targets, and removing/disabling unnecessary ones, restricting use to authorized users, and logging invocation all block those paths; however, the technique also succeeds via direct file reads of `.vcrd`/`Policy.vpol` and via Windows APIs such as `CredEnumerateA` callable from any process, which A.8.18 does not reach, so only a slice of the technique's mechanisms is prevented.
- T1556partialprevents — A.8.18 restricts and logs use of utility programs capable of overriding system controls, which constrains one common vector for T1556 (using privileged utilities to modify LSASS, PAM, SAM, etc.), but the technique has many execution paths A.8.18 does not reach — direct file modification, malicious module loading into authentication processes, identity provider / cloud authentication tampering, and network device authentication changes — so only a slice of the technique is prevented.
- T1556.004partialprevents — A.8.18 restricts utility program access to trusted users and requires removal of unnecessary ones, which reduces the attack surface for implanting a modified system image, but the technique can still be executed by an authorized user with legitimate utility access or through a compromised supply chain before the device reaches the organization.
- T1558partialdetects — A.8.18's logging of utility program use (item i) catches the slice of T1558 that uses built-in utilities like klist to enumerate cached Kerberos tickets, but the technique's bulk — Kerberoasting, golden/silver ticket forging, and tools like Mimikatz/Rubeus — operates through APIs and dedicated offensive tools that fall outside the clause's utility-program scope.
- T1560.001partialdetects — A.8.18 item (i) requires logging of all use of utility programs within its scope, creating an audit trail that can surface archiving-utility invocations; however, the control mandates logging rather than analysis or alerting, the scope is limited to 'privileged utility programs' (which may not include all general-purpose archiving tools like tar, zip, or 7-Zip), and the actual detection work depends on A.8.16 monitoring analyzing those logs.
- T1560.001partialprevents — A.8.18 can remove or disable unnecessary utility programs (clause f) and limit availability to authorized windows (h), which prevents use of third-party archivers like 7-Zip, WinRAR or WinZip where they are not business-required; however, the technique's primary tools — tar, zip, diantz, makecab, xcopy, certutil — are preinstalled system utilities that cannot be removed without breaking the platform, and authorization-based restrictions (b, c, d) do not stop an adversary operating as a privileged user, so the bulk of the technique's capability remains reachable.
- T1561partialprevents — A.8.18 prevents the subset of T1561 that uses privileged utility programs (disk editors, debuggers, etc.) by removing, disabling, segregating and tightly authorizing them, but disk wipe is most commonly executed via native OS commands, malware, or network device CLI — none of which are utility programs in the A.8.18 sense — so what is prevented is a slice rather than the bulk.
- T1561.001partialprevents — A.8.18 constrains legitimate disk utility programs through removal of unnecessary utilities, restricted authorization, authentication, and logging, but does not prevent adversary-supplied tools (e.g., RawDisk drivers), malware-based wiping, or physical-access scenarios from performing the technique.
- T1561.002partialprevents — A.8.18 restricts utility programs capable of overriding system controls (disk tools, format commands, partition editors), so the utility-based variant of T1561.002 — e.g. the `format` CLI on network devices or legitimate disk utilities used by an insider — is constrained by limited authorized users, authentication, logging and removal of unnecessary utilities. The dominant mechanism, however, is malware (Shamoon-class) that writes directly to MBR/partition tables without going through a utility program, and A.8.18 does not reach that path.
- T1563.002partialdetects — A.8.18 item (i) requires logging of all use of utility programs, and tscon.exe (the mechanism for T1563.002) is a system utility capable of overriding session controls, so its invocation leaves an audit trail that enables detection; however, the control mandates logging rather than active monitoring or alerting, and only covers utility programs explicitly placed in scope, leaving a bounded remainder.
- T1563.002partialprevents — A.8.18 governs utility programs like tscon.exe (the specific tool used in T1563.002) through restriction to authorized users, removal of unnecessary utilities, and segregation — so where tscon is removed or tightly controlled the named vector is blocked. However, the technique presupposes SYSTEM-level access (which A.8.18 does not address) and can be performed with alternative tools or red-team frameworks, so the control prevents a slice of the technique rather than the capability.
- T1564.002partialprevents — A.8.18 restricts and logs use of utility programs (dscl, chflags, gsettings, reg.exe) that the technique relies on, preventing unauthorized users from running them, but authorized administrators retain access and the technique can also be executed via direct plist/registry/gsettings file manipulation outside the utility-program scope.
- T1564.006partialprevents — A.8.18 prevents some vectors of T1564.006 by restricting, logging, and removing unnecessary virtualization utilities (e.g., QEMU, VirtualBox binaries) and requiring authorization for ad hoc use, but it cannot prevent use of native OS virtualization features (Hyper-V, Windows Sandbox) that are built into the platform, nor adversary-dropped virtualization binaries that bypass the 'remove unnecessary utilities' guidance entirely.
- T1564.013partialprevents — A.8.18 restricts and authorizes use of privileged utilities like mount, which prevents unauthorized users from executing bind mounts, but the technique specifically requires sudo (already-privileged) access, so an authorized privileged user is not stopped from using mount with bind options to hide artifacts — the control governs who may use the utility, not how the bind-mount abuse pattern is prevented.
- T1564.014partialprevents — A.8.18 restricts and logs utility programs like `xattr`, `setfattr`, and `getfattr` that the technique explicitly relies on, and removing or disabling them blocks that specific path; however, the technique can be executed via custom code or direct syscalls without those utilities, and non-privileged users can manipulate xattrs in the `user.` namespace, so the control addresses only the utility-program surface of a broader capability.
- T1565partialprevents — A.8.18 restricts privileged utility programs that can bypass application controls, preventing the subset of T1565 that relies on such utilities to manipulate data outside normal application paths, but data manipulation can equally occur through authorized application access, application exploitation, or stolen credentials — pathways A.8.18 does not address.
- T1565.001partialprevents — A.8.18 constrains the path where an adversary uses a privileged utility program (disk editor, DB admin tool, etc.) to bypass application controls and manipulate stored data — limiting users, requiring auth, logging use, and disabling unnecessary utilities. It does not address stored data manipulation performed through normal application functionality, compromised application credentials, or direct database access, so the prevention covers a slice of the technique rather than the bulk.
- T1565.003partialprevents — A.8.18 constrains the utility-program pathway (debuggers, file tools, privileged utilities) that an adversary would commonly use to alter application binaries or manipulate runtime data, but T1565.003 can also be executed by direct binary modification, default file association changes, and masquerading — none of which require a utility program — so the technique is reduced, not eliminated.
- T1569partialprevents — A.8.18 restricts utility programs to trusted users and removes unnecessary ones, which prevents some abuse of system services, but the technique can also use built-in services that cannot be removed without breaking the system.
- T1569.001partialprevents — A.8.18 restricts who can use privileged utilities like launchctl and logs their use, but launchctl is a required macOS system utility that cannot be removed or disabled, so the technique remains executable by any compromised account with sufficient privilege; the control constrains the attack surface without eliminating it.
- T1569.002partialdetects — A.8.18's logging requirement (item i) captures the invocation of utility programs like sc.exe, PsExec, and Net — the primary tools for T1569.002 — so their use is surfaced in logs; however, the logging is scoped to authorized-use accountability rather than threat alerting, does not cover direct API calls to the service control manager, and does not itself analyze or flag malicious patterns, leaving a bounded remainder of the technique undetected.
- T1569.002partialprevents — A.8.18 can restrict utility programs that interface with the service control manager (sc.exe, PsExec) via authorization, removal of unnecessary utilities, and logging, but the service control manager itself (services.exe) is a core Windows component that cannot be removed, and adversaries can call its API directly without using any utility program the clause covers.
- T1569.003partialprevents — A.8.18 restricts who may invoke utility programs through authentication, authorization levels, and logging, which prevents unauthorized users from running systemctl; however, systemctl is the primary interface for systemd and cannot be removed or disabled without breaking the OS, so the technique remains fully available to any account the adversary has compromised — the same shape as cm-7 vs T1059, where the platform-required utility is what adversaries use and what the control cannot remove.
- T1570partialprevents — A.8.18 restricts utility programs (scp, rsync, curl, sftp, ftp) through limited authorized users, authentication, removal of unnecessary utilities, and time-bound availability, which constrains the subset of T1570 that relies on those tools; however, the technique also operates over SMB/Windows Admin Shares, RDP, and web services like Dropbox/OneDrive, none of which are utility programs under A.8.18's scope, so a substantial portion of the technique's vectors remain reachable.
- T1600.002partialprevents — A.8.18 constrains who can use the privileged utility programs (configuration commands, system image tools) that would disable crypto hardware on network devices — limiting use to trusted, authorized users with authentication, authorization levels, and logging — which prevents the technique for non-privileged compromise paths. But the utilities must remain available for legitimate administration, and an adversary who has already gained the necessary privileged access can still execute the technique under an authenticated, logged identity, so the prevention is a reduction in attack surface rather than an elimination.
- T1601partialprevents — A.8.18 limits privileged utility access to trusted users and requires segregation, logging, and removal of unnecessary utilities, which reduces the attack surface for modifying a system image, but the technique can still be executed by an authorized user with legitimate access or through an unremoved utility.
- T1601.001partialdetects — A.8.18's logging of utility program use (item i) would capture some instances where privileged utilities are invoked to modify a network device's system image, but the technique has multiple execution paths that bypass this entirely — native debug commands in the unaltered OS, standard management protocols (TFTP/FTP/SCP/console), and boot loader / ROMMONkit manipulation — none of which are 'utility programs' in the A.8.18 sense, and the technique operates at the OS image level below where utility program logging reaches.
- T1601.001partialprevents — A.8.18 restricts privileged utility access to trusted users and requires logging, which prevents unauthorized use of the standard device-operator procedures needed to modify the system image, but an adversary with administrative access or a compromised bootloader can still perform the technique.
- T1601.002partialprevents — A.8.18 constrains the use of privileged utility programs through limited authorized users, authentication, removal of unnecessary utilities, and time-bound availability, which blocks unauthorized use of tools that could perform the downgrade; however, the technique can also be executed through vendor management interfaces or direct file manipulation outside the utility-program scope, and an authorized user performing the downgrade is logged rather than prevented, so the control addresses a slice of the vectors rather than the technique's full mechanism.
- T1602.002partialprevents — A.8.18's restrictions on utility programs (authentication, authorization, removal of unnecessary tools, limiting availability, logging) constrain the misuse of management protocols like SNMP and SMI to dump configurations, but the clause is scoped to host systems and built-in network device management protocols often cannot be removed, and exploitation of vulnerabilities in these tools is outside the control's mechanism.
- T1606partialprevents — A.8.18 restricts, removes, and logs privileged utility programs, which blocks only the subset of T1606 that depends on running privileged utilities such as zmprov, while leaving credential forging from stolen secrets, private keys, or direct API calls outside its scope.
- T1609partialprevents — A.8.18 restricts privileged utility programs to trusted users, requires authentication, and logs all use, which constrains the adversary's ability to execute container administration commands, but the control does not eliminate the technique because authorized users and the administration services themselves remain available.
- T1610partialprevents — A.8.18 treats container deployment tools (docker, kubectl, Kubernetes APIs) as utility programs capable of overriding system controls, so restricting them to authorized users with authentication, documented authorization levels, and ad hoc approval prevents unauthorized container deployment; however, the technique still runs when an authorized user is compromised or acting maliciously, and the container runtime/orchestration must remain available for legitimate operations, so what is prevented is the unauthorized slice rather than the technique itself.
- T1612partialdetects — A.8.18 item (i) mandates logging of all use of privileged utility programs, and the Docker daemon fits the clause's scope as a program capable of overriding system and application controls; logging the Docker API would capture the build request, but the logs record the API call rather than the Dockerfile contents or the malicious payload, and whether the daemon is actually placed under A.8.18's logging requirement depends on implementation scope.
- T1612partialprevents — A.8.18's controls on privileged utility programs (authentication, authorization levels, limiting availability, logging) directly apply to the Docker API as a privileged utility, and can prevent unauthorized users from issuing build requests; however, Docker is often a required utility in container environments and the build API is a core function, so authorized users can still abuse their access — the same shape as cm-7 vs T1059, where the required interpreter cannot be removed.
- T1651partialprevents — A.8.18 restricts privileged utility access to a minimum set of trusted, authorized users and requires removal of unnecessary utilities, which reduces the attack surface for T1651, but the technique can still be executed by any adversary who compromises one of the remaining authorized identities or the cloud management service itself.
- T1653partialprevents — A.8.18 directly constrains abuse of privileged utility programs like powercfg by limiting use to authorized users, requiring authentication, and logging all use, which prevents the utility-based vector of T1653; however, the technique also encompasses direct configuration-setting changes and deletion of shutdown-related files, which A.8.18 does not address.
- T1654partialprevents — A.8.18 restricts and logs use of utility programs like wevtutil.exe, PowerShell, and CollectGuestLogs.exe — the primary host-binary mechanisms T1654 names — so unauthorized use of those tools is constrained, but the control does not reach log access via direct file reads, SIEM queries, cloud APIs, or abuse by an authorized user who passes the clause's own checks.
- T1675partialprevents — A.8.18 governs utility programs capable of overriding system controls — ESXi administration commands fit this category — and its clauses on authentication, authorization levels, trusted-user limitation, and removal of unnecessary utilities constrain who can invoke the vSphere APIs and similar admin paths; however, the tools must remain available for legitimate ESXi administration, so they cannot be eliminated, and compromised admin credentials or exploitation of the admin services themselves bypass the control's preventive effect, leaving a real remainder.
- T1685partialprevents — A.8.18's restrictions on utility programs (removing unnecessary ones, limiting availability, restricting to authorized users) constrain the slice of T1685 that uses debugging tools, legitimate drivers, or privileged utilities to disable security mechanisms, but the technique is broader — adversaries can stop services, kill processes, modify registry keys, and tamper with ETW/logging pipelines through built-in OS commands and APIs that fall outside the 'utility program' scope A.8.18 governs.
- T1685.001partialprevents — A.8.18 directly constrains `auditpol.exe` and similar privileged utilities by restricting use to authorized users, requiring authentication, and mandating logging of their use — which addresses the auditpol vector of T1685.001. However, the technique has multiple execution paths (direct registry modification of EventLog keys, `sc config`, `Set-Service`, PowerShell cmdlets) that are not utility programs in the A.8.18 sense, and an authorized administrator can still abuse their access, so the control prevents a slice rather than the technique.
- T1685.004partialprevents — A.8.18's restrictions on utility programs (auditctl, systemctl, kill) and its logging requirement address the utility-program vector of the technique, but the technique also uses direct config-file editing (/etc/audit/audit.rules, audit.conf) and library-function hooking, which the control does not cover; further, the technique is specifically designed to disable the audit system that would log utility use, so a root-level adversary defeats the control's own logging mechanism.
- T1685.005partialdetects — A.8.18 item (i) requires logging of all use of utility programs, so invocation of `wevtutil cl` to clear logs leaves a record — that is detection. But the technique can also be performed via PowerShell (a scripting interpreter, not a utility program in the clause's sense) or by direct deletion of .evtx files, neither of which A.8.18's logging covers, and the detection record itself sits in the very logs the technique is designed to erase.
- T1685.005partialprevents — A.8.18 restricts privileged utility programs to trusted users and requires logging of their use, which reduces the set of actors who can run wevtutil or Remove-EventLog, but an authorized user with legitimate need can still clear logs and the control does not block direct file deletion.
- T1685.006partialdetects — A.8.18 item (i) requires logging all use of utility programs, which would capture invocation of log-clearing utilities, but detection is bounded: only actions routed through classified utility programs are caught (not standard shell commands like `rm` or `truncate` used to wipe logs), the utility-use log itself may sit in the same `/var/log/` estate the technique targets, and the clause mandates logging without mandating review or alerting on those entries.
- T1685.006partialprevents — A.8.18 restricts utility program use to a minimum of trusted, authorized users with documented authorization levels and removes unnecessary utilities, which prevents unauthorized actors from using log-clearing utilities; however, an authorized user can still execute the technique, and basic shell commands (rm, truncate, echo) used to clear /var/log/ entries are not 'privileged utility programs' in the clause's sense, so the technique remains reachable.
- T1686partialdetects — A.8.18's logging requirement (item i) captures use of utility programs, which would record activity by tools like esxcli, netsh, or iptables that adversaries use to modify firewalls, but the control's scope is limited to utility programs and does not cover all vectors for T1686 (e.g., direct service manipulation, registry edits, or GUI-based changes outside the utility-program framing).
- T1686partialprevents — A.8.18 restricts who can use utility programs capable of overriding system controls (firewall-modifying tools like netsh, iptables, esxcli fit this category) through authentication, authorization, removal of unnecessary utilities, and limited availability, which constrains the technique; however, built-in OS administration tools are often required for legitimate operation and cannot be removed, and the technique explicitly presupposes the adversary has gathered sufficient privileges, so authorized or compromised administrators can still execute it.
- T1686.003partialprevents — A.8.18 can remove or disable unnecessary utility programs and restrict use of necessary ones (netsh, PowerShell, regedit) to a minimum set of authorized users with logging and ad hoc authorization, but the utilities required to modify the Windows host firewall are core system administration tools that cannot realistically be removed, and authorized administrators can still invoke them — so what is prevented is a slice (unnecessary utilities, unauthorized users) rather than the technique itself.
- T1689partialprevents — A.8.18 removes or disables unnecessary utility programs and limits their availability to authorized users, which can prevent an adversary from executing a downgrade-capable utility, but it does not prevent downgrade attacks that exploit built-in backward compatibility or network protocol negotiation without a utility program.
Prevented OWASP Web Top 10 (2025) risks (5)
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.18 limits privileged utilities that can override access controls (via authz, segregation, removal, logging), which stops some Broken Access Control vectors (esp. those relying on privileged bypasses), but leaves the bulk of A01 members (IDOR, path traversal, CSRF, missing function-level checks) untouched.
- A02partialblocks — A.8.18's restrictions on privileged utilities (authorization, segregation, removal/disabling, limited availability) directly close many misconfiguration vectors that expose attack surface via overly permissive or unnecessary tools, but leave the broader category (weak defaults, incomplete hardening, cloud/framework settings) mostly untouched.
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.