js-toml allows uncontrolled recursion in `load()` leading `RangeError` (stack exhaustion) on deeply nested input
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 —jstry { 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 candidate patch.
Affected software
Click a technology to see all vulnerabilities affecting it.
| Platform | Package | Vulnerable versions | Fixed in |
|---|---|---|---|
| npm package | js-toml | < 1.1.3 | 1.1.3 |
References
- CVSS vector
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L- Weakness (CWE)
CWE-400, CWE-674- Platform
- npm
- Package
js-toml- Disclosed
- 20.11.2026
- Updated
- 20.11.2026 16:17
Sources and licenses
OSV / GitHub Advisory Database - GHSA-3g82-77xr-68x5 - CC BY 4.0
Vulnerability history: js-toml
All published vulnerabilities of this package (npm package), newest first. Shows whether this is a one-off slip or a package that needs watching.
- Total entries
- 4
- First → latest
- 08.2025 11.2026
- Without a fix
- 0
- Exploited in attacks
- 0
Severity breakdown
- High 2
- Medium 2
Disclosures per year
- 2025: 1
- 2026: 3
-
js-toml allows uncontrolled recursion in `load()` leading `RangeError` (stack exhaustion) on deeply nested input this entry
Know which vulnerabilities affect your application
With the DockRay integration and software inventory enabled, DockRay checks reported component versions against known vulnerabilities and notifies you about confirmed matches. Coverage depends on the supported technology and available advisory data.