Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessExecute untrusted JavaScript in embedding app
-
ExploitLoop Atomics.store with detaching valueOf
-
ExecutionLeak BigInt on each RangeError
-
ImpactExhaust heap causing denial of service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Resource cleanup, leak prevention
|
| Exploitation Conditions | Requires the attacker to execute arbitrary JavaScript inside an application that embeds QuickJS-NG; it is not exploitable against an engine that does not run untrusted scripts. The concrete trigger is a BigInt64Array or BigUint64Array backed by a SharedArrayBuffer (or a resizable ArrayBuffer) and a call to Atomics.store whose value argument carries a valueOf callback that detaches the buffer (ab.transfer()) or shrinks it (ab.resize(0)) during the JS_ToBigInt64 conversion, causing the converted BigInt to leak when the function returns the RangeError/TypeError. Limiting factors: impact is only gradual memory exhaustion that needs many iterations in a long-running process, there is no confidentiality or integrity impact and no code execution, and versions at or after 0.16.0 are not affected. |
| Impact | This is a moderate-severity denial-of-service issue (vendor CVSS 4.0 6.9, VA:L only) and should be treated as a scheduled fix rather than an emergency, consistent with the 'this_month' decision label. The CVSS 4.0 vector (AV:N/AC:L/PR:N/UI:N) indicates no special complexity or privileges once an attacker can run JavaScript in the engine, and the included regression test confirms the trigger is a deterministic valueOf side effect rather than a timing-sensitive race, so AC:L is well supported. However, real-world exposure is gated entirely by whether the embedding application runs attacker-controlled JavaScript - that is the true threat model, not a network service exploitable by default. No KEV listing and no EPSS score are provided in the input, so there is no signal of active or widespread exploitation; a public PoC reference exists only as the vendor's regression test, which demonstrates the fault path but is not verified as a weaponized exploit. Note a mechanism discrepancy: the GHSA 'Attack Path' text describes a concurrent worker/race condition, whereas the CVE description and the shipped test show a single-threaded valueOf that detaches (transfer) or shrinks (resize) the buffer - the deterministic valueOf path is the better-supported reading. Net: a genuine but bounded DoS, worth patching promptly where untrusted JS is executed, but not a high-urgency, broadly-exploitable flaw. |
| Exploit ScenarioDerived | An application that embeds QuickJS-NG to run untrusted or attacker-supplied JavaScript (e.g. a server-side scripting sandbox or an IoT device) is targeted. The attacker repeatedly calls Atomics.store on a BigInt64Array/BigUint64Array whose backing buffer is detached or resized to zero inside a valueOf callback, leaking one BigInt allocation per RangeError until the long-running process exhausts memory. The vendor's regression test demonstrates the exact trigger, but no weaponized exploit is confirmed in the available data. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 02, 2026
Heap memory exhaustion in QuickJS-NG versions before 0.16.0 lets JavaScript executed by an embedding host drain the process one BigInt allocation at a time: each Atomics.store() call on a BigInt64Array or BigUint64Array whose backing buffer is detached (ab.transfer()) or shrunk (ab.resize(0)) during value coercion leaks the converted BigInt instead of freeing it. An attacker able to run scripts inside a QuickJS-NG host - server-side script runners, plugin sandboxes, IoT firmware - can loop that pattern to cause denial of service in long-running processes; there is no confidentiality or integrity impact and no code execution. Vendor CVSS 4.0 is 6.9 with availability impact Low only, the priority label is 'this_month' rather than emergency, and no public exploit code or CISA KEV entry was identified at time of analysis; the fix ships in release 0.16.0.
RemediationAI
Upgrade QuickJS-NG to 0.16.0 or later (release tag https://github.com/quickjs-ng/quickjs/releases/tag/v0.16.0), which contains commit 62951e1bc68711d37aad986ff84ef0fe17038a7e adding the missing JS_FreeValue() calls in js_atomics_store() along with the regression test tests/atomics-store-leak.js; downstream embedders should rebuild against this tag rather than shipping their own patch. The supplied evidence describes no workaround other than updating, so exposure reduction has to come from the deployment model: exploitation presupposes that untrusted JavaScript runs inside the QuickJS-NG host, so keeping untrusted or third-party scripts out of the engine (or confining them to hosts that do not process untrusted input) removes the trigger, at the cost of losing the scripting capability for those callers. Because the impact is gradual memory exhaustion requiring many iterations in a long-running process, externally imposed process memory limits and periodic restarts bound the damage but do not fix the leak - leaked BigInt objects are never reclaimed by the garbage collector, so the process still degrades toward those limits. Note that the fix commit includes a JavaScript test that reproduces the leak path; treat that file as a trigger reference when validating deployments, not as production exploit code.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
QuickJS-NG is a fork of Fabrice Bellard's QuickJS engine, implemented in C in quickjs.c, and is embedded in applications that need to evaluate JavaScript with a small footprint. The flaw is in js_atomics_store(), the implementation behind the ECMAScript Atomics.store() built-in. For BigInt64Array and BigUint64Array targets, the engine converts the supplied value via JS_ToBigInt64(), which allocates a BigInt object; the subsequent typed_array_is_detached() check can fail because the value conversion is observable - a valueOf() callback can call ArrayBuffer.prototype.transfer() or resize(0) on the SharedArrayBuffer or resizable ArrayBuffer before the check runs. When that happens the function throws RangeError/TypeError and returns early without freeing the converted BigInt, a CWE-401 (Missing Release of Memory after Effective Lifetime) per-call leak that is never reclaimed by the garbage collector. The upstream fix in commit 62951e1bc68711d37aad986ff84ef0fe17038a7e adds JS_FreeValue(ctx, ret) on both early-return paths and introduces tests/atomics-store-leak.js covering the detached-buffer and shrunk-resizable-buffer cases.
Know when Quickjs Ng gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
Deterministic valueOf-side-effect trigger (AC:L), no privileges beyond the baseline ability to run JS in the engine (PR:N), and only gradual availability impact with no confidentiality or integrity loss (C:N/I:N/A:L).
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
QuickJS-NG before 0.16.0 contains a memory leak vulnerability in js_atomics_store() in quickjs.c that fails to free the converted value when returning a RangeError. Attackers running JavaScript can repeatedly call Atomics.store with a valueOf that detaches or shrinks the buffer to exhaust heap memory and cause denial of service.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
More in Quickjs Ng
View allquickjs-ng through 0.9.0 has a missing length check in JS_ReadString for a string, leading to a heap-based buffer overfl
quickjs-ng through 0.9.0 has an incorrect size calculation in JS_ReadBigInt for a BigInt, leading to a heap-based buffer
Heap-based buffer overflow in QuickJS up to version 0.11.0 within the js_typed_array_constructor function allows unauthe
A vulnerability was found in quickjs-ng QuickJS up to 0.8.0. Rated medium severity (CVSS 5.3), this vulnerability is rem
Heap buffer overflow in QuickJS-NG releases before 0.16.0 gives JavaScript code a path to memory corruption on 32-bit ho
Heap buffer overflow in QuickJS-NG before 0.16.0 allows JavaScript code executed by the embedding application to drive a
Use-after-free in QuickJS up to version 0.11.0 within the Atomics Ops Handler allows remote attackers to trigger memory
Heap-based buffer overflow in QuickJS up to version 0.11.0 within the js_typed_array_sort function allows remote attacke
Heap-based buffer overflow in QuickJS up to version 0.11.0 within the js_typed_array_constructor_ta function allows remo
EUVD-2026-115200
GHSA-48fx-7fjq-qgg4
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB