A low integrity process is a heavily restricted Windows process intended to limit damage if compromised. It cannot normally write to protected system locations or interact freely with higher-integrity components. However, if it can influence trusted IPC paths, it can still become a launch point for sandbox escape.
What a low integrity process is
A low integrity process is a Windows process running with a restricted integrity level, so the operating system treats it as less trusted than medium- or high-integrity code. It is designed to limit what the process can modify, helping contain damage if the process is compromised or misused.
In practice, the integrity label is a containment boundary, not a guarantee of safety. A low integrity process can still read certain data, communicate through allowed channels, and influence higher-trust components if those components accept its input without adequate validation.
Why Windows uses low integrity boundaries
Integrity levels are part of Windows’ mandatory access control model. They are especially useful for browsers, previewers, renderers, and other software that may handle untrusted content, because they reduce the chance that a compromise immediately turns into system-wide write access.
That protection is strongest when the process is kept away from sensitive file locations, registry locations, and privileged IPC paths. The practical goal is to make the process safe enough to handle risky input while sharply limiting its ability to alter the host environment.
Low integrity is therefore about damage containment. It does not replace application security, sandboxing discipline, or careful design of the channels that connect isolated code to trusted components.
How low integrity processes still become dangerous
The main weakness is not the integrity label itself, but the trust placed in anything the process can reach. If a higher-integrity component accepts messages, files, or commands from a low integrity source without proper validation, the isolation can be weakened or bypassed.
This is why trusted IPC paths matter. A low integrity process may be blocked from direct writes, yet still influence a broker, helper, or service that performs privileged actions on its behalf. In that case, the security of the boundary depends on the receiving component’s input handling and authorization logic.
For a broader view of how trust boundaries and least-privilege containment fit into security architecture, see NIST Cybersecurity Framework 2.0 and NIST SP 800-207 Zero Trust Architecture.
Where low integrity fits in a Windows defence model
Low integrity works best as one layer in a defense-in-depth design. It is useful for reducing the blast radius of untrusted code, but it should be paired with application hardening, strict broker design, and strong separation between untrusted renderers and privileged operations.
That same logic applies to security monitoring and control baselines. A process that is intentionally low trust should be treated as a containment boundary, not as a permission to relax review of its inputs, outputs, or connected services. For control mapping and operational baselines, NIST SP 800-53 Rev 5 Security and Privacy Controls gives a useful reference point for access control, system integrity, audit, and configuration management.
If the low integrity process is part of software or browser-delivered content handling, supply-chain and build integrity also matter. SLSA and OpenSSF are relevant when you need assurance that the code entering that boundary is itself built and maintained with strong integrity controls.
Risk and Threat Considerations
Low integrity reduces direct write power, but it does not eliminate compromise. The most important risk is sandbox escape through trusted IPC, where a low trust process reaches a higher trust helper that assumes its caller is benign. That turns a containment mechanism into an entry point for privilege gain or persistence.
Failure mechanism: A compromised low integrity process abuses a trusted message path, file handoff, or helper interface, and the receiving component performs privileged work on its behalf.
Impact: Attackers can pivot from a restricted process into broader system access, tamper with data, or chain the issue into deeper compromise of the host or user session.
Standards & Framework Alignment
This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.
NIST CSF 2.0, NIST SP 800-53 Rev 5 and CIS Controls v8 set the governance and control requirements practitioners need to meet.
| Framework | Control / Reference | Relevance |
|---|---|---|
| NIST CSF 2.0 | PR.AA-05 — Identity Management, Authentication and Access Control | Low integrity boundaries depend on tightly controlled access paths between trust levels. |
| Recommendation — Enforce least-privilege access on helper paths that cross integrity boundaries. | ||
| NIST SP 800-53 Rev 5 | AC-6 — Least Privilege | The term is fundamentally about limiting what a compromised process can do. |
| SI-10 — Information Input Validation | Trusted IPC from low integrity processes must be validated before privileged action. | |
| AU-2 — Event Logging | Compromise of restricted processes is best detected with auditable activity trails. | |
| Recommendation — Constrain low integrity components to the minimum permissions needed. Validate all inputs arriving from lower-trust processes before acting on them. Log brokered actions and boundary crossings for post-incident review. | ||
| CIS Controls v8 | CIS-4 — Secure Configuration of Enterprise Assets and Software | Low integrity protection relies on secure Windows configuration and hardened trust boundaries. |
| Recommendation — Harden Windows components and trust paths that handle untrusted content. | ||
Practitioner Guidance
Why practitioners should care: Treat low integrity as a boundary that only works when every bridge out of it is intentionally designed. The key question is not whether the process is restricted, but whether the components it can still influence are equally disciplined about validation and authorization.
What to watch for: Review IPC brokers, helper services, file transfer paths, and any component that accepts input from a low integrity process. If those paths can trigger privileged actions, the integrity boundary is thinner than it looks.
Practitioner takeaway: A low integrity process is only as safe as the trust decisions around it, so the surrounding interfaces deserve the same scrutiny as the sandbox itself.
Related resources from NHI Mgmt Group
- What breaks when a low-integrity Windows process can activate a higher-integrity component?
- What breaks when low-integrity sandbox boundaries are composed with launch and URI handlers?
- Why do low integrity processes still create meaningful privilege escalation risk?
- What happens when organisations use low-code automation beyond the SOC without clear process ownership?
Deepen Your Knowledge
Free weekly newsletter
Subscribe to the NHI & AI Identity Journal
The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.
Bonus 33% off our NHI Course when you subscribe.
Reviewed and updated by the NHIMG editorial team on October 31, 2026.
NHI Mgmt Group — the #1 independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org