Skip to content

Security Independently confirmed2 publishers 3 min read Published Updated

isolated-vm's ExternalCopy type confusion turns the sandbox into a path to the host

A time-of-check/time-of-use bug in the library many platforms use to run untrusted JavaScript lets guest code reach the host process. Fixes are in 6.2.0 and 7.0.1, and there is still no CVE.

The Watch · Security desk

Send a correction

What happened

  • A critical-severity type confusion in the isolated-vm Node.js library could allow threat actors to achieve remote code execution on the host system; the bug impacts ExternalCopy and was detailed by EndorLabs.
  • Through isolated-vm, developers can access the V8 JavaScript engine's Isolate interface to build completely isolated JavaScript environments.
  • Each Isolate is a completely separated V8 instance with its own heap memory, execution state and garbage collector, enabling multiple sandboxed JavaScript instances on one machine without a container or virtual machine.
  • isolated-vm is widely used for executing untrusted JavaScript code within a V8 Isolate.
  • ExternalCopy is the function used to copy data across Isolates; it serializes the data in one Isolate and reconstructs it in the other instance.

Why it matters

If your product runs customer-supplied JavaScript inside isolated-vm, the isolation you were charging for has been nominal. EndorLabs has disclosed a critical-severity type confusion in the library's ExternalCopy function that can end in remote code execution on the host system [1].

isolated-vm gives Node.js developers access to V8's Isolate interface, so each sandboxed script gets its own heap, execution state and garbage collector without a container or a VM around it [2][3]. That cheapness is the point, and it is why the library is widely used to execute untrusted JavaScript [4]. It is also why the failure matters: for many embedders, the C++ binding is the entire boundary.

The bug sits in the data path between Isolates. ExternalCopy serializes a value in one Isolate and reconstructs it in the other [5]. As a performance optimisation it accepts a transferList: large ArrayBuffers are named, and the backing memory is moved by detaching the buffer from the source and handing it to the destination [6]. During reconstruction the code walked the byte array list twice, and the second pass trusted what the first pass had seen [7]. Because an element of the transfer_list JavaScript array can be defined as a getter, the two walks need not return the same value, and an attacker can use that time-of-check/time-of-use gap to get an attacker-controlled pointer dereferenced [8].

The ExternalCopy constructor itself is only reachable from the host, which sounds like a containment argument until you read the next step: a guest can go through ivm.Reference, the mechanism the host uses to expose anything at all into the sandbox, to assemble the malicious transferList and fire the bug [9]. Outcomes run from a crash of the host process to control-flow hijack, which is where the RCE claim comes from [10].

The advisory is blunt about the blast radius. "Any embedder that runs untrusted code in an isolate and shares even one Reference into it is affected. Host code that passes a caller-influenced array as transferList is affected directly, without any guest," it reads [14]. So there are two populations here: sandbox operators who thought a single shared Reference was a harmless convenience, and host code with no guest anywhere near it that forwards a caller-influenced array into a transfer [16].

Patches are in isolated-vm 6.2.0 and 7.0.1, and the fix is to stop user JavaScript running during the copy at all rather than to sanity-check the re-read [11]. That is the right shape of fix, because as EndorLabs puts it, the vulnerability "lived in the native glue code," a layer written in a memory-unsafe language that manipulates raw V8 handles and backing-store pointers and re-reads attacker-controlled JavaScript objects mid-operation, where "a single unchecked cast on a re-read value was enough to turn a correct isolation primitive into a full escape" [12].

The awkward part for defenders: the bug has not been assigned a CVE identifier [13]. Dependency tooling keyed to CVE feeds has nothing to match on, so the check reduces to reading the isolated-vm version in your lockfile against 6.2.0 and 7.0.1 [15]. Also audit your own host code for any transferList built from caller input, since that path does not need a hostile guest to be a problem [16].

Clarity's read

What the record supports and how the coverage leans. The claims behind it follow.

Reality

Evidence72
Adoption62
Hype gap+12
Incentives
Not scored
Confidence74
Why these scores

Claim ledger

Ranked by verification strength, evidence, and original report placement.

  1. [1]

    A critical-severity type confusion in the isolated-vm Node.js library could allow threat actors to achieve remote code execution on the host system; the bug impacts ExternalCopy and was detailed by EndorLabs.

    Reported Supported Source: EndorLabs, via SecurityWeekView cited source
  2. [2]

    Through isolated-vm, developers can access the V8 JavaScript engine's Isolate interface to build completely isolated JavaScript environments.

    Reported SupportedView cited source
  3. [3]

    Each Isolate is a completely separated V8 instance with its own heap memory, execution state and garbage collector, enabling multiple sandboxed JavaScript instances on one machine without a container or virtual machine.

    Reported SupportedView cited source
  4. [4]

    isolated-vm is widely used for executing untrusted JavaScript code within a V8 Isolate.

    Reported SupportedView cited source
  5. [5]

    ExternalCopy is the function used to copy data across Isolates; it serializes the data in one Isolate and reconstructs it in the other instance.

    Reported SupportedView cited source
  6. [6]

    For performance optimisation ExternalCopy uses a transferList: large ArrayBuffers are listed and the underlying memory is transferred by detaching the buffer from the source and handing it to the destination.

    Reported SupportedView cited source
  7. [7]

    When data was transferred, the reconstructor iterated over the byte array list twice, with the second pass trusting the first walk.

    Reported SupportedView cited source
  8. [8]

    Because iterating the transfer_list JavaScript array would not return the same value for an element defined as a getter on each pass, an attacker could abuse the time-of-check/time-of-use weakness to dereference an attacker-controlled pointer.

    Reported SupportedView cited source
  9. [9]

    According to EndorLabs, the ExternalCopy constructor is only accessible from the host, but a guest can target ivm.Reference, the mechanism through which the host exposes anything to the sandbox, to build the malicious transferList and trigger the vulnerability.

    Reported Supported Source: EndorLabsView cited source
  10. [10]

    Successful exploitation leads to a crash (denial of service) or control-flow hijack of the host process, which potentially enables remote code execution on the host.

    Reported SupportedView cited source
  11. [11]

    Patches for the vulnerability were included in isolated-vm versions 6.2.0 and 7.0.1, to prevent user JavaScript from running during the copy.

    Reported SupportedView cited source
  12. [12]

    EndorLabs notes that the vulnerability "lived in the native glue code": the C++ binding that serializes values across the boundary, written in a memory-unsafe language, manipulating raw V8 handles and backing-store pointers and re-reading attacker-controlled JavaScript objects in the middle of a security-sensitive operation, and that "a single unchecked cast on a re-read value was enough to turn a correct isolation primitive into a full escape."

    Reported Supported Source: EndorLabsView cited source
  13. [13]

    The type confusion bug has yet to be assigned a CVE identifier.

    Reported SupportedView cited source
  14. [14]

    An isolated-vm advisory states: "Any embedder that runs untrusted code in an isolate and shares even one Reference into it is affected. Host code that passes a caller-influenced array as transferList is affected directly, without any guest."

    Reported Supported Source: isolated-vm advisoryView cited source
  15. [15]

    With no CVE identifier assigned, identifying exposure comes down to comparing the installed isolated-vm version against the patched releases 6.2.0 and 7.0.1.

    Derived Supported
  16. [16]

    The affected set has two disjoint entry conditions: an embedder running untrusted code that has shared at least one Reference into the isolate, or host code that passes a caller-influenced array as transferList, which needs no guest at all.

    Derived Supported

Sources

2 independent publishers whose own reporting we read for this story.

  1. securityweek.com

    1 article · August 21, 2026

    Critical Isolated-vm Vulnerability Leads to RCE on Host
  2. thehackernews.com

    1 article · August 20, 2026

    Isolated-vm Flaw Lets Sandboxed JavaScript Escape to Host for Potential RCE

Topics and entities

Topics

Entities