/

CVE-2026-33396

Severity:

CRITICAL RISK

(9.9)

Remote Code Execution via Sandbox Escape in OneUptime

CVE-2026-33396

Analyzed

Vulnerability type

Category:

Remote Code Execution via Sandbox Escape

CWE:

CWE-78, CWE-184, CWE-693

Impact:

Remote Command Execution by Low-Privileged Authenticated Users

Severity:

CRITICAL RISK

(9.9)

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

OneUptime's Synthetic Monitor feature executes user-supplied Playwright scripts inside a Node.js VM sandbox that relies on a denylist to block dangerous properties and methods.

Because this denylist is incomplete, a low-privileged ProjectMember can traverse Playwright internals and call launchServer(...), leading to arbitrary command execution on the Probe container or host.

Affected context

This vulnerability affects OneUptime deployments that:

  • Enable Synthetic Monitors using Playwright-based scripts
  • Allow ProjectMember-level users to create or modify custom Playwright code
  • Execute that code on Probe containers or hosts through VMRunner.runCodeInNodeVM

The issue appears when user-controlled scripts run with a live page object and the sandbox relies on an incomplete denylist instead of a robust isolation boundary.

Exploit preconditions

  • Attack surface: Synthetic Monitor Playwright script execution interface exposed through the OneUptime application.
  • Required access: Authenticated access with at least ProjectMember permissions in a project where Synthetic Monitors can be configured or edited.
  • Trigger point: Submission or modification of a Playwright-based synthetic test that is subsequently executed on a Probe.
  • Why exploitation is possible:
  • The sandbox uses a denylist to block selected properties and methods but does not cover all dangerous pathways.
  • The live page object provides access to page.context().browser()._browserType.launchServer(...).
  • _browserType and launchServer are not blocked, enabling the attacker to start arbitrary processes and achieve command execution on the Probe environment.

Why this happens

The core issue is a sandbox escape stemming from an incomplete denylist-based security control, mapped to CWE-184: Incomplete List of Disallowed Inputs and CWE-693: Protection Mechanism Failure.

Instead of establishing a minimal, explicitly allowed surface (allowlist) or using a stronger isolation primitive, the implementation attempts to prevent abuse by enumerating disallowed properties and methods on a live Playwright page object.

This design leaves alternative, unblocked methods—such as accessing internal _browserType properties and invoking launchServer(...)—still reachable from user-defined scripts.

Once that method is accessible, it can be leveraged to spawn arbitrary processes, aligning with CWE-78: Improper Neutralization of Special Elements used in an OS Command when attacker-controlled values are passed to process launch routines.

Potential impact

  • Execution of arbitrary commands on the Probe container or underlying host.
  • Full compromise of the Probe runtime environment, including access to credentials, environment variables, and local configuration.
  • Lateral movement from the Probe to other internal services, depending on network topology and trust boundaries.
  • Interference with monitoring and observability data, including falsifying synthetic checks or exfiltrating collected information.
  • Use of the Probe infrastructure as a pivot point for broader infrastructure attacks.

General mitigation guidance

Effective mitigation focuses on replacing fragile denylist-based sandboxing with stronger isolation and explicit allowlists:

  • Prefer strict allowlist-based APIs: expose only a narrow, curated interface to user scripts instead of passing through full Playwright objects.
  • Run untrusted synthetic scripts inside hardened isolated worker environments (e.g., separate containers, dedicated unprivileged OS users, or locked-down sandboxes) with minimal permissions and no direct access to system-level process creation APIs.
  • Avoid exposing internal or private fields (such as _browserType) to user code, and wrap browser automation behind stable, security-reviewed abstractions.
  • Apply least-privilege and defense-in-depth: restrict network egress from Probe runners, minimize filesystem access, and separate secrets used for infrastructure management from those available to synthetic execution.
  • Treat any user-supplied monitoring logic as untrusted, and design the execution layer so that a compromise of the scripting environment cannot directly translate into host compromise.

How teams detect issues like this

Detection can combine code-centric and runtime-focused approaches:

  • Static analysis & code review:
  • Flag any use of denylist-based property or method blocking for sandboxing untrusted code.
  • Identify paths where powerful objects (e.g., full Playwright page or browser instances) are exposed directly to user scripts.
  • Search for internal/private properties (like _browserType) being accessible or not explicitly wrapped.
  • Policy enforcement:
  • Enforce security guidelines that require allowlist-based sandboxes and isolation boundaries for untrusted script execution.
  • Integrate automated tooling in CI to highlight sandboxing constructs and require explicit security sign-off.
  • Runtime monitoring:
  • Monitor Probe containers/hosts for unusual process launches initiated from synthetic monitoring workflows.
  • Capture and analyze logs related to synthetic script execution, flagging unexpected calls to Playwright's browser-launching or server-starting functions.

Automated application security testing and dynamic analysis can also help simulate malicious synthetic scripts and detect unexpected command execution behavior.

Sources

SourceLink
github.comgithub.com/OneUptime/oneuptime/commit/e8e4ee3ff0740eb131045ab3d67453141c46178a
github.comgithub.com/OneUptime/oneuptime/security/advisories/GHSA-cqpg-phpp-9jjg

Frequently asked

questions

Exploitation is limited to authenticated users who can define or modify Synthetic Monitor Playwright scripts, but within that scope it is highly impactful: a low-privileged ProjectMember can achieve command execution on Probe infrastructure.

The attacker needs valid credentials and project membership with permissions to configure or edit Synthetic Monitor scripts. No direct shell or container access is required; the attack is carried out through the application's monitoring interface.

The most robust fix is to redesign the execution model so that user code runs against a tightly controlled, allowlisted API in a strongly isolated environment, rather than relying on a denylist of forbidden properties on a powerful object like a live Playwright page.

Treat any user-defined automation or scripting as untrusted, use strong isolation (dedicated sandboxes, least privileges, network and filesystem restrictions), expose only minimal, vetted capabilities via allowlists, and enforce these patterns through secure coding guidelines, reviews, and automated checks in the development pipeline.

Find out what's already
exploitable in your codebase.