Skip to main content

QuickJS-NG EUVDEUVD-2026-115200

| CVE-2026-120440 MEDIUM
Memory Leak (CWE-401)
2026-11-02 VulnCheck GHSA-48fx-7fjq-qgg4
6.9
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Execute untrusted JavaScript in embedding app
  2. Exploit
    Loop Atomics.store with detaching valueOf
  3. Execution
    Leak BigInt on each RangeError
  4. Impact
    Exhaust 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.5% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

QuickJS-NG 0 <0.16.0

Affected Packages

euvd quickjs_ng fix: 0.16.0

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

Vendor (VulnCheck) PRIMARY 6.9 MEDIUM
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
vuln.today AI 5.3 MEDIUM

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).

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

EPSS Score
0.5%
Top 59% exploitable
Prevalence
Low
niche embeddable JS engine fork, limited production footprint
Social Media
1
Sightings
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.5%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

34
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +34
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy