A.8.31 Technological
Separation of development, test and production environments
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 (16)
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).
Aligned NIST CSF 2.0 outcomes (17)
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).
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).
Why these map — rationale
- V13.2.4mostlycovers — Requiring explicit rules and authorization for moving code between development and production implements the same objective as maintaining an allow-list of permitted external or cross-environment resources.
Related weaknesses / CWE (3239)
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-509partialblocks — Separation of environments blocks malicious code from spreading across development, test, and production boundaries, but it does not stop replication among production systems or to external targets once the code is active in production.
- CWE-531partialblocks — A.8.31 mandates separation of test environments from production and access controls on those environments (guidance items a, c in the second list), which blocks exploitation of sensitive information embedded in test code by keeping it out of production and restricting who can reach it; however, the weakness itself remains present in the test code, authorized developers and testers can still read the sensitive data, and access control failures expose it, so the blocking is real but partial.
Mitigated MITRE ATT&CK techniques (2550)
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
- T1027.004partialprevents — A.8.31(e) requires that compilers and development tools not be accessible from production systems when not required, which removes the standard compilation path (ilasm.exe, csc.exe, GCC/MinGW) the technique relies on; however, the technique description explicitly accommodates a bundled compiler and execution framework delivered with the payload, so the adversary retains a viable execution path that the control does not reach.
- T1059partialprevents — A.8.31 prevents a slice of T1059 vectors — development tools (compilers, editors, utility programs) are not accessible from production systems (item e), and unauthorized code deployment from dev to prod is restricted (item b) — but the built-in interpreters adversaries most commonly abuse (PowerShell, cmd.exe, bash, Python) are part of the production OS and remain fully available, so the bulk of the technique is untouched.
- T1072partialprevents — A.8.31 mandates access control, authorization rules for deployment, monitoring of changes, and segregation of access rights between environments — all of which constrain an adversary's ability to abuse deployment tools. However, the clause's primary purpose is separating dev/test/prod environments to protect production from development activities, not securing the deployment infrastructure itself against adversary control; the deployment tools (SCCM, Intune, etc.) sit in production administration, outside the clause's main scope, so the preventive effect is a slice rather than the bulk.
- T1080partialdetects — A.8.31's guidance includes 'monitoring of change to the environment and code stored therein' and 'secure monitoring of the environments' for dev/test environments, which can detect tainting of internal code repositories (explicitly named in T1080); however, the control's monitoring scope is bounded to development and test environments, so tainting of network drives and shared content in production environments — the broader and more common T1080 vector — falls outside what this control observes.
- T1080partialprevents — A.8.31's access control, segregation of access rights, and monitoring of changes to environment and code stored therein make it harder for an adversary to taint shared content in development/test environments and code repositories, but the technique can still be attempted against network drives and shared locations outside the clause's scope, and the clause's primary purpose is protecting production from dev/test activities rather than preventing external content tainting.
- T1127partialprevents — A.8.31 item (e) explicitly requires that compilers, editors and other development tools or utility programs not be accessible from production systems when not required, which directly targets T1127's mechanism of abusing trusted developer utilities on production hosts; however, the technique still works where developer utilities are legitimately required on production, on developer workstations that are themselves the target, and where separation is implemented as a policy rather than enforced, so the prevention is a meaningful reduction of the attack surface rather than a closure.
- T1127.001partialprevents — A.8.31 item (e) directly targets this by requiring that compilers and development tools not be accessible from production systems when not required, which removes MSBuild from production endpoints where the proxy-execution bypass would otherwise work; the bounded remainder is that MSBuild is legitimately required on build, CI/CD and deployment infrastructure, and the technique still runs on development systems, so what is removed is a slice rather than the bulk.
- T1127.003partialprevents — A.8.31 item (e) keeps compilers, editors and other development tools/utility programs out of production systems when not required, which removes JamPlus as an execution proxy on production estates; however, JamPlus is a legitimate build utility that belongs in development environments, and the clause's separation of dev/test/prod does nothing to prevent its abuse within the dev environment where it is supposed to exist.
- T1176.002partialprevents — A.8.31's separation of dev/test/prod environments limits the blast radius of a malicious IDE extension by keeping it out of production systems and preventing direct access to production data (item g), but it does not prevent the extension from being installed or executing in the development environment, nor does it stop credential-based pivoting from a compromised developer workstation to production.
- T1195partialdetects — A.8.31 includes monitoring of changes to the environment and code stored therein, plus detailed logging and real-time monitoring for unauthorized changes, which can surface supply chain compromise that manifests as tampering within the organization's own development/test environments or code; however, T1195 also encompasses compromise of upstream dependencies, third-party update mechanisms, source repositories the org does not own, and counterfeit products — none of which fall within A.8.31's monitoring scope.
- T1195partialprevents — A.8.31 prevents some vectors of supply chain compromise — testing changes in staging before production (c), deployment authorization rules (b), separation of dev/test from production (a), and access controls can catch or block malicious code introduced via updates or compromised dev tools from reaching production — but the upstream manipulation (vendor products, source repositories, distribution channels, shipment interdiction) happens before the product reaches the organization and is outside the control's reach.
- T1195.001partialdetects — A.8.31's monitoring of changes to the environment and code stored therein (item d) and secure monitoring of environments (item e) can surface some downstream effects of a compromised dependency operating within the organization's build pipeline or dev environment (e.g., unauthorized changes, malicious code execution), but the core compromise — manipulation of packages at registries, typosquatting, and compromise of external CI/CD components — happens on infrastructure outside A.8.31's monitoring scope, so detection is a slice rather than coverage of the technique.
- T1195.002partialdetects — A.8.31 includes monitoring of changes to the environment and code (d), secure monitoring of the environments (e), and detailed logging/real-time monitoring for unauthorized changes in exceptional situations — these can detect supply-chain compromise that manifests as unauthorized modification within the organization's own dev/test/prod environments, but cannot detect upstream compromise (e.g., malicious code injected into a vendor's release or update mechanism before it reaches the organization), so the detection is bounded to the within-estate portion of the technique.
- T1195.002partialprevents — A.8.31's separation, deployment authorization, staging testing, and review/approval requirements prevent the slice of supply-chain compromise that would occur through unauthorized changes pushed through the organization's own dev-to-prod pipeline (insider or compromised developer account), but the clause does not reach upstream or vendor-side compromise of source code, build systems, or distribution mechanisms that occur outside the organization's controlled environments.
- T1210partialprevents — A.8.31 separates dev/test from production into different domains with controlled access, which limits lateral movement paths between environments, but it does not prevent exploitation of remote services within production itself — the core mechanism of T1210 (vulnerability exploitation in services like SMB, RDP, vCenter) is untouched by environment separation.
- T1213.001partialprevents — A.8.31's item (g) directly restricts copying sensitive information into development and testing systems unless equivalent controls are provided, and the access-control and monitoring requirements limit who can reach a dev/test Confluence instance; however, the control's purpose is to protect production from dev/test compromise (not the reverse), it does not prevent adversaries from mining whatever data legitimately resides in a separated dev/test Confluence, and production Confluence instances are unaffected by the separation rule.
- T1213.003partialprevents — A.8.31's access controls, monitoring of code/environment changes, and restriction on copying sensitive information into dev/test environments (unless equivalent controls exist) provide partial prevention against adversaries accessing code repositories, but the control's primary purpose is environment separation rather than specifically defending code repositories from intrusion, and it does not address authentication strength, network segmentation for repository access, or credential hygiene in code.
- T1213.006partialprevents — A.8.31 item (g) directly prevents sensitive production data from being copied into development and test environments unless equivalent controls are in place, which removes a slice of the database-mining surface (dev/test databases holding production data). It does not address the primary vector of T1213.006, which is adversaries querying production databases directly, so the bulk of the technique remains reachable.
- T1219.001partialprevents — A.8.31's item (e) — keeping compilers, editors and other development tools inaccessible from production systems when not required — prevents IDE tunneling from running on production endpoints, and the domain separation limits its reach as a pivot. It does not prevent the technique on developer workstations, which is the primary surface the technique targets, so the prevention is a slice rather than the bulk.
- T1505partialprevents — A.8.31 prevents the deployment-pipeline vector of T1505 by separating environments, controlling authorization for dev-to-prod deployment, and restricting dev tools from production, but it does not stop an adversary with production access from directly installing a malicious component or abusing already-present legitimate extensibility features.
- T1525partialprevents — A.8.31's separation of environments, access controls on those environments, and deployment-authorization rules (items a, b, c in the second list) constrain an adversary in a dev/test environment from pushing a malicious image into a production registry, and the change-monitoring requirement surfaces unauthorized modifications; however, the clause does not address image-signing, registry-specific integrity controls, or the case where the adversary already holds production credentials, so the prevention is a slice rather than a closure.
- T1554partialprevents — A.8.31 constrains the development-to-production pipeline (deployment authorization, dev tools not accessible from production, segregation of access rights, monitoring of changes) which blocks several vectors for binary compromise, but it does not prevent an attacker with direct production access from modifying binaries on production systems — that remainder is the technique's other half.
- T1565.001partialprevents — A.8.31's segregation of duties (no single person changes both dev and prod without review), deployment authorization rules, and monitoring of environment/code changes constrain some vectors of stored data manipulation—particularly those requiring code to move from dev to prod—but the control's core purpose is protecting production from development/test compromise, not preventing adversaries with production access from directly manipulating data at rest.
- T1570partialprevents — A.8.31's separation of dev/test/prod into distinct domains with controlled access creates boundaries that impede cross-environment lateral tool transfer, but T1570 primarily operates within a compromised environment (SMB shares, RDP, native file transfer tools) where the clause's environment-separation mechanism does not apply.
- T1610partialprevents — A.8.31's environment separation, deployment authorization rules, and access controls between dev/test/prod prevent an adversary with only dev or test access from deploying containers into production, but the control does not stop an actor who already holds production credentials from invoking container deployment APIs, so the prevention is a boundary effect rather than a direct block on the technique.
- T1612partialprevents — A.8.31's restriction on development tools (including compilers/builders) being inaccessible from production systems when not required can prevent T1612 on production hosts, but the technique can still execute on development or test hosts where Docker and build tools are legitimately present, and the control does not address the Docker API surface itself.
- T1677partialdetects — A.8.31 includes monitoring of changes to the environment and code stored therein, plus explicit mention of detecting unauthorized changes, which surfaces direct and indirect pipeline poisoning; however, monitoring is a supporting element to the clause's primary prevention-through-separation purpose, and public pipeline execution from forks may evade change-monitoring scoped to the internal environment.
- T1677partialprevents — A.8.31's access control to environments, monitoring of changes to environment and code, segregation of access rights, and review/approval requirements for changes between dev and prod partially constrain who can modify CI configurations and inject malicious code, but the control's core purpose is environment separation to protect production, not securing the CI/CD pipeline itself, so the technique can still operate within the build environment.
Prevented OWASP Web Top 10 (2025) risks (6)
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.31's separation of environments, deployment rules, access segregation, and testing requirements prevent many Broken Access Control defects (e.g. path traversal or IDOR arising from shared/dev data, missing checks from un-reviewed prod changes, or CSRF via test bleed) but leave the dominant logical-authorization-decision failures (CWE-862/863/284) untouched.
- A02partialblocks — A.8.31's separation of environments, rules for deployment, testing prior to prod, non-production of dev tools, and secure config/patching/access controls in dev/test directly prevent many classes of weak defaults and exposed attack surface from reaching production, but not all (e.g. runtime server/framework misconfigs or incomplete hardening that arise independently in prod).
- A08partialblocks — A.8.31's separation of environments, deployment rules, testing-before-prod mandates, dev-tool isolation, and change-review requirements directly block multiple CI/CD compromise paths and unsigned-update vectors that are core to A08:2025, but leave insecure deserialization and other runtime integrity failures 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.