/

CVE-2026-45313

Severity:

HIGH RISK

(7.7)

Privilege Escalation (CWE-284) via Sandboxie GUI Hooks

CVE-2026-45313

Deferred

Vulnerability type

Category:

Privilege Escalation

CWE:

CWE-284

Impact:

Sandbox Escape and Arbitrary Code Execution as SYSTEM

Severity:

HIGH RISK

(7.7)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A privilege escalation flaw in Sandboxie-Plus allows a sandboxed process to inject code into an unsandboxed host process via improperly validated GUI hook requests.

When attacker-controlled thread and function pointers are accepted without verification and executed as SYSTEM, a sandbox escape with arbitrary code execution becomes possible.

Affected context

This vulnerability arises in Sandboxie-Plus deployments on Windows where GUI hook registration requests from sandboxed processes are handled by the core service.

It is relevant when:

  • The Sandboxie service processes GUI_WND_HOOK_REGISTER messages
  • The service trusts thread handles and function addresses passed from sandboxed clients
  • The service runs with elevated (SYSTEM) privileges and can interact with host processes

In such configurations, insufficient validation of cross-process hooks creates an unintended escalation path.

Exploit preconditions

  • Attack surface: Inter-process communication between sandboxed processes and the Sandboxie-Plus core GUI server service.
  • Required access: Ability to run code inside a sandboxed process that can send GUI_WND_HOOK_REGISTER requests to the service.
  • Trigger point: The GuiServer::WndHookRegisterSlave and GuiServer::WndHookNotifySlave routines when they accept attacker-supplied hthread/hproc and later call OpenThread and QueueUserAPC as SYSTEM.
  • Why exploitation is possible: The service fails to verify that the provided thread belongs to the sandboxed process or that the function pointer resides in the caller's address space, allowing arbitrary APC injection into an unsandboxed host process.

Why this happens

The root cause is a failure to enforce proper authorization and validation on security-sensitive cross-process operations.

The GUI hook registration path stores attacker-supplied thread handles and function pointers without confirming process ownership or address space boundaries.

Later, these values are used by a SYSTEM-privileged service to open threads and queue APCs, effectively performing code injection on behalf of the attacker.

This behavior aligns with CWE-284: Improper Access Control, where privileged functionality is exposed without ensuring that only intended, authorized subjects can influence it.

Potential impact

  • A sandboxed process may escape its confinement and execute arbitrary code in an unsandboxed host process.
  • Attackers could gain SYSTEM-level execution within the Windows environment.
  • Security boundaries enforced by the sandbox can be bypassed, undermining isolation guarantees.
  • Compromise of other user or system processes that are not intended to be controlled by sandboxed code.

General mitigation guidance

Mitigation centers on tightening access control and validation around privileged IPC and hook registration mechanisms.

Recommended patterns include:

  • Validating that any thread handle used by a privileged service belongs to the requesting sandboxed process and is within the expected security boundary.
  • Ensuring function pointers and APC targets are constrained to the caller's address space or a controlled, vetted set of entry points.
  • Designing sandbox services so that high-privilege operations cannot be parameterized by untrusted clients, or are mediated through strict policy checks.
  • Applying least-privilege principles to services, limiting interaction with host processes where possible and segregating sensitive operations into more constrained components.

How teams detect issues like this

Detection typically focuses on identifying insecure access control patterns in sandbox or IPC services.

Approaches can include:

  • Static analysis rules that flag uses of OpenThread, QueueUserAPC, or similar APIs when parameters derive from untrusted IPC inputs without explicit validation.
  • Code review practices that scrutinize any service code running as SYSTEM that accepts thread handles, process IDs, or function pointers from lower-privileged clients.
  • Policy enforcement that requires explicit ownership checks before cross-process operations, documented in security design reviews.
  • Runtime monitoring for anomalous APC injections or cross-sandbox thread manipulations that may indicate abuse of GUI or IPC hooks.

Sources

SourceLink
github.comgithub.com/sandboxie-plus/Sandboxie/releases/tag/v1.17.6
github.comgithub.com/sandboxie-plus/Sandboxie/security/advisories/GHSA-rmv3-fhg3-75xh

Frequently asked

questions

Exploitation generally requires local code execution inside a sandboxed process. Remote attackers would first need a way to run code within the sandbox before abusing the flawed GUI hook mechanism.

The attacker needs the ability to start or control a sandboxed process that can communicate with the Sandboxie-Plus GUI server. From there, crafted GUI_WND_HOOK_REGISTER requests can attempt to induce the privileged service to inject code into unsandboxed host processes.

The safest pattern is to enforce strict access control and validation on all parameters used for privileged cross-process operations. Only threads and addresses that are proven to belong to the requesting process and conform to a defined security policy should be accepted, and arbitrary client-supplied function pointers should be avoided.

Prevention involves designing sandbox services with clear trust boundaries, never allowing untrusted clients to influence high-privilege operations without rigorous checks. Apply least privilege, validate ownership of handles and pointers, isolate sensitive functionality behind hardened interfaces, and incorporate security-focused code review and automated checks for misuse of cross-process APIs.

Find out what's already
exploitable in your codebase.