CVE-2025-62496
HighCVSS 8.8Exploitation Probability (EPSS)
Low risk40th percentile - higher than 40% of all known CVEs
Summary
A vulnerability in the QuickJS engine when creating a BigInt from a string with an excessively large number of digits. The bit count calculation causes an integer overflow, leading to an underestimated buffer size and a heap out-of-bounds write.
Risk Assessment
It can lead to memory corruption, application crash, or potential code execution if QuickJS processes untrusted input. Affects applications embedding QuickJS.
Recommendation
Update QuickJS to a patched version or limit the size of input passed to the BigInt parser. Avoid processing untrusted strings of extreme length.
Other vulnerabilities in QuickJS
See all- CVE-2026-88378Critical
QuickJS commit 04be24600 contains a heap out-of-bounds write condition in JS_ReadFunctionTag().
- CVE-2025-12745Medium
In QuickJS up to commit eb2c89087def1829ed99630cb14b549d7a98408c, the function js_array_buffer_slice in quickjs.c causes a buffer over-read. The attack requires local execution, and the exploit is publicly available.
- CVE-2025-62495High
An integer overflow vulnerability in the QuickJS regular expression engine (libregexp) due to inconsistent representation of the bytecode buffer size. A large or complex regular expression can cause the size to wrap around and lead to an out-of-bounds write.
- CVE-2025-62494High
A type confusion vulnerability exists in the QuickJS engine's handling of the string addition (+) operation. During conversion of the right-hand operand, a callback can change the type of the left-hand operand, leading to a type mismatch and potential out-of-bounds memory access.
- CVE-2025-62493Medium
A vulnerability in the QuickJS engine's BigInt string conversion logic (js_bigint_to_string1) stems from an incorrect calculation of the required number of digits, leading to reading memory past the allocated BigInt structure. In certain edge cases, the conversion loop reads data spanning two limbs, causing an out-of-bounds read.
- CVE-2025-62492Medium
A floating-point arithmetic precision error exists in QuickJS's implementation of TypedArray.prototype.indexOf() when a negative fromIndex argument is supplied. When the value is extremely small (e.g., -1e-20), adding the array length can lose precision and yield an index equal to the length, causing an out-of-bounds read of one element. This may lead to information disclosure of adjacent memory.
- CVE-2025-62491High
A use-after-free exists in the QuickJS engine's standard library when iterating over the global list of unhandled rejected promises (rejected_promise_list). A malicious property getter on an Error object can call catch() on the same rejected promise, which removes and frees the current list entry while the loop continues using the freed pointer.
- CVE-2025-62490High
In QuickJS's js_print_object, printing an array fetches the length and then loops over it, but printing a value is not side-effect free. An attacker-defined callback can run during js_print_value and resize the array, causing a use-after-free; a second instance occurs when printing Map or Set objects whose records list can be modified during js_print_value.
Original NVD description (English source)
A vulnerability exists in the QuickJS engine's BigInt string parsing logic (js_bigint_from_string) when attempting to create a BigInt from a string with an excessively large number of digits. The function calculates the necessary number of bits (n_bits) required to store the BigInt using the formula: $$\text{n\_bits} = (\text{n\_digits} \times 27 + 7) / 8 \quad (\text{for radix 10})$$ * For large input strings (e.g., $79,536,432$ digits or more for base 10), the intermediate calculation $(\text{n\_digits} \times 27 + 7)$ exceeds the maximum value of a standard signed 32-bit integer, resulting in an Integer Overflow. * The resulting n_bits value becomes unexpectedly small or even negative due to this wrap-around. * This flawed n_bits is then used to compute n_limbs, the number of memory "limbs" needed for the BigInt object. Since n_bits is too small, the calculated n_limbs is also significantly underestimated. * The function proceeds to allocate a JSBigInt object using this underestimated n_limbs. * When the function later attempts to write the actual BigInt data into the allocated object, the small buffer size is quickly exceeded, leading to a Heap Out-of-Bounds Write as data is written past the end of the allocated r->tab array.
Vulnerability data from NVD (NIST) · CISA KEV · EPSS