CVE-2026-63386: js-toml allows uncontrolled recursion in `load()` leading `RangeError` (stack exhaustion) on deeply nested input
Medium CVSS 5.3
- OSV id
- GHSA-3g82-77xr-68x5
- Also known as
- CVE-2026-63386
- Published
- Last modified
Affected packages
| Package | Affected versions | Fixed in |
|---|---|---|
| js-toml npm |
< 1.1.3 | 1.1.3 |
How to fix it
Upgrade js-toml to 1.1.3 or later.
npm install js-toml@1.1.3
# if it is an indirect dependency: npm update js-toml (or npm audit fix)
- If it is an indirect dependency, upgrade the package that depends on it, or force the version with "overrides" (npm), "resolutions" (Yarn) or "pnpm.overrides" (pnpm) in package.json.
- Check the changelog for breaking changes (especially across major versions), update the lockfile with the package manager, and run your tests.
Not sure whether your project uses an affected version? Check your lockfile below for free.
Details
Summary
load() parses untrusted TOML using a recursive-descent parser (Chevrotain) and a
recursive tree-walking interpreter. Neither the parser nor the interpreter enforces a
maximum nesting / key depth. A small, attacker-controlled document with deep nesting
(arrays, inline tables) or a long dotted key drives recursion past the V8 call-stack
limit, and load() throws an uncaught RangeError: Maximum call stack size exceeded.
This is a problem for two reasons:
- Denial of Service. A tiny payload (≈2 KB) reliably aborts parsing. In any
service that parses user-supplied TOML, an unhandled
RangeErrorcan crash the worker/process (500 / restart loop). Error-contract violation. The library signals invalid input via
SyntaxParseError(seesrc/load/exception.ts; the entire test suite assertsSyntaxParseError). Consumers that follow this contract —try { load(input); } catch (e) { if (e instanceof SyntaxParseError) return badRequest(); throw e; // unexpected -> propagates }— will re-throw the
RangeErrorinstead of treating the input as malformed, turning malformed input into an unexpected fatal error.
Impact
- Unauthenticated attacker who can supply a TOML string to an application using
js-tomlcan forceload()to throw a non-SyntaxParseErrorerror. - If the error is not caught by a generic handler, the Node.js process terminates (availability impact).
- Even when caught generically, the documented/expected error type contract is broken,
which can bypass input-validation branches that key off
SyntaxParseError.
No confidentiality or integrity impact. The error is thrown synchronously and is catchable, so a consumer that catches all exceptions is not crashed — this is why the severity is assessed Low–Medium rather than High.
Affected code / root cause
There is no depth bound anywhere in the parse pipeline. Recursion occurs in (at least) two independent places:
- Parser (recursive descent).
src/load/parser.ts—array/inlineTablerules recurse throughvaluefor each nesting level. - Interpreter (tree walk).
src/load/interpreter.ts—assignValue,createTable,getOrCreateArrayrecurse per dotted-key segment, andcleanInternalPropertiesrecurses per object depth.
Because there is no configurable or hard limit, the recursion depth is bounded only by
the V8 stack, and overflow surfaces as a raw RangeError.
Steps to reproduce (PoC)
Environment used: Node.js v20, js-toml@1.1.2.
import { load, SyntaxParseError } from 'js-toml';
function probe(label, toml) {
try {
load(toml);
console.log(`[OK] ${label}`);
} catch (e) {
const expected = e instanceof SyntaxParseError;
console.log(`[${e.constructor.name}${expected ? '' : ' (UNEXPECTED)'}] ${label}: ${String(e.message).split('\n')[0]}`);
}
}
// 1) Deeply nested arrays (~2 KB payload)
probe('nested array depth 1000', 'x = ' + '['.repeat(1000) + ']'.repeat(1000));
// 2) Deeply nested inline tables
let v = '1';
for (let i = 0; i < 1000; i++) v = `{ a = ${v} }`;
probe('nested inline table depth 1000', 'x = ' + v);
// 3) Deep dotted key (interpreter recursion)
const key = Array.from({ length: 5000 }, (_, i) => 'a' + i).join('.');
probe('dotted key depth 5000', `${key} = 1`);
Observed output
[RangeError (UNEXPECTED)] nested array depth 1000: Maximum call stack size exceeded
[RangeError (UNEXPECTED)] nested inline table depth 1000: Maximum call stack size exceeded
[RangeError (UNEXPECTED)] dotted key depth 5000: Maximum call stack size exceeded
Each case throws RangeError, not SyntaxParseError. Overflow occurs in single-digit
milliseconds, so it is not a CPU-exhaustion issue — it is an immediate, deterministic abort.
Notes on thresholds (machine-dependent; exact numbers vary by stack size):
- Nested arrays / inline tables overflow at roughly depth ~1000 (parser recursion).
- Dotted keys overflow at roughly depth ~5000 (interpreter recursion); depth 1000 still succeeds.
Suggested remediation
Enforce an explicit, documented maximum nesting/key depth and surface violations as
SyntaxParseError (consistent with all other invalid-input handling). For example:
- Track current depth in the parser/interpreter and throw
SyntaxParseError(e.g."Maximum nesting depth exceeded") once a configurable limit (e.g. 100–1000) is reached, before the native stack overflows. - As a defensive backstop, wrap the top-level
load()body so that a thrownRangeErrorfrom stack exhaustion is converted into aSyntaxParseError, guaranteeing the documented error contract holds for all malformed input.
A configurable limit (with a safe default) is preferable so legitimate deep documents can opt into a higher bound.
Disclosure
Reported privately via GitHub Security Advisory. Happy to provide additional reproducers or test against a candida
References
- GHSA-3g82-77xr-68x5 on OSV.dev
- Web: https://github.com/sunnyadn/js-toml/security/advisories/GHSA-3g82-77xr-68x5
- Advisory: https://nvd.nist.gov/vuln/detail/CVE-2026-63386
- Web: https://github.com/sunnyadn/js-toml/commit/4e10acf1f99ff3cb443c58b8f0a57664e41e87c6
- Package: https://github.com/sunnyadn/js-toml
- Web: https://github.com/sunnyadn/js-toml/releases/tag/v1.1.3
Am I affected?
Upload or paste your lockfile. We check every package version in it against OSV.dev, this advisory included, and email you the vulnerable ones with the version that fixes them. Free, and no account needed.
About this data
Source: GitHub Advisory Database via OSV.dev (CC-BY 4.0). Severity comes from the advisory's own rating when it has one, else from its CVSS score.