CVE-2025-62496

  1. OpenCVE
  2. Vulnerabilities (CVE)
  3. CVE-2025-62496
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.

8.8 /10

CVSS v3 : HIGH

V3 Legend

Vector :

Exploitability : 2.8 / Impact : 5.9

Attack Vector ADJACENT_NETWORK

Attack Complexity LOW

Privileges Required NONE

User Interaction NONE

Confidentiality Impact HIGH

Integrity Impact HIGH

Availability Impact HIGH

Scope UNCHANGED

References
Link Resource
https://bellard.org/quickjs/Changelog Release Notes
https://issuetracker.google.com/434193016 Exploit Issue Tracking
Configurations

Configuration 1 (hide)

cpe:2.3:a:quickjs_project:quickjs:*:*:*:*:*:*:*:*
History

19 Oct 2026, 17:10

Type Values Removed Values Added
Summary
  • (es) Una vulnerabilidad existe en la lógica de análisis de cadenas BigInt del motor QuickJS (js_bigint_from_string) al intentar crear un BigInt a partir de una cadena con un número excesivamente grande de dígitos. La función calcula el número necesario de bits (n_bits) requerido para almacenar el BigInt utilizando la fórmula: $$\text{n\_bits} = (\text{n\_digits} \times 27 + 7) / 8 \quad (\text{para base 10})$$ * Para cadenas de entrada grandes (por ejemplo, $79,536,432$ dígitos o más para base 10), el cálculo intermedio $(\text{n\_digits} \times 27 + 7)$ excede el valor máximo de un entero con signo estándar de 32 bits, lo que resulta en un desbordamiento de entero. * El valor resultante de n_bits se vuelve inesperadamente pequeño o incluso negativo debido a este ajuste cíclico. * Este n_bits defectuoso se utiliza entonces para calcular n_limbs, el número de 'limbs' de memoria necesarios para el objeto BigInt. Dado que n_bits es demasiado pequeño, el n_limbs calculado también se subestima significativamente. * La función procede a asignar un objeto JSBigInt utilizando este n_limbs subestimado. * Cuando la función intenta posteriormente escribir los datos reales del BigInt en el objeto asignado, el pequeño tamaño del búfer se excede rápidamente, lo que lleva a una escritura fuera de límites en el heap a medida que los datos se escriben más allá del final del array r -> tab asignado.
Information

Published : 2025-10-16 16:15

Updated : 2026-10-19 17:10

NVD link : CVE-2025-62496

Mitre link : CVE-2025-62496

CVE.ORG link : CVE-2025-62496

JSON object : View

Products Affected

quickjs_project

  • quickjs
CWE
CWE-190

Integer Overflow or Wraparound