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
pageobject provides access topage.context().browser()._browserType.launchServer(...). _browserTypeandlaunchServerare 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
pageorbrowserinstances) 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.

