GHSA-3G82-77XR-68X5

Vulnerability from github – Published: 2026-11-20 14:40 – Updated: 2026-11-20 14:40
VLAI
Summary
js-toml allows uncontrolled recursion in `load()` leading `RangeError` (stack exhaustion) on deeply nested input
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:

  1. Denial of Service. A tiny payload (≈2 KB) reliably aborts parsing. In any service that parses user-supplied TOML, an unhandled RangeError can crash the worker/process (500 / restart loop).
  2. Error-contract violation. The library signals invalid input via SyntaxParseError (see src/load/exception.ts; the entire test suite asserts SyntaxParseError). Consumers that follow this contract —

js try { load(input); } catch (e) { if (e instanceof SyntaxParseError) return badRequest(); throw e; // unexpected -> propagates }

— will re-throw the RangeError instead 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-toml can force load() to throw a non-SyntaxParseError error.
  • 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:

  1. Parser (recursive descent). src/load/parser.ts — array / inlineTable rules recurse through value for each nesting level.
  2. Interpreter (tree walk). src/load/interpreter.ts — assignValue, createTable, getOrCreateArray recurse per dotted-key segment, and cleanInternalProperties recurses 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 thrown RangeError from stack exhaustion is converted into a SyntaxParseError, 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.

Show details on source website

{
  "affected": [
    {
      "package": {
        "ecosystem": "npm",
        "name": "js-toml"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "1.1.3"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2026-63386"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-400",
      "CWE-674"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2026-11-20T14:40:45Z",
    "nvd_published_at": "2026-09-22T19:16:44Z",
    "severity": "MODERATE"
  },
  "details": "## Summary\n\n`load()` parses untrusted TOML using a recursive-descent parser (Chevrotain) and a\nrecursive tree-walking interpreter. Neither the parser nor the interpreter enforces a\nmaximum nesting / key depth. A small, attacker-controlled document with deep nesting\n(arrays, inline tables) or a long dotted key drives recursion past the V8 call-stack\nlimit, and `load()` throws an **uncaught `RangeError: Maximum call stack size exceeded`**.\n\nThis is a problem for two reasons:\n\n1. **Denial of Service.** A tiny payload (\u22482 KB) reliably aborts parsing. In any\n   service that parses user-supplied TOML, an unhandled `RangeError` can crash the\n   worker/process (500 / restart loop).\n2. **Error-contract violation.** The library signals invalid input via\n   `SyntaxParseError` (see `src/load/exception.ts`; the entire test suite asserts\n   `SyntaxParseError`). Consumers that follow this contract \u2014\n\n   ```js\n   try { load(input); }\n   catch (e) {\n     if (e instanceof SyntaxParseError) return badRequest();\n     throw e; // unexpected -\u003e propagates\n   }\n   ```\n\n   \u2014 will **re-throw** the `RangeError` instead of treating the input as malformed,\n   turning malformed input into an unexpected fatal error.\n\n## Impact\n\n- Unauthenticated attacker who can supply a TOML string to an application using\n  `js-toml` can force `load()` to throw a non-`SyntaxParseError` error.\n- If the error is not caught by a generic handler, the Node.js process terminates\n  (availability impact).\n- Even when caught generically, the documented/expected error type contract is broken,\n  which can bypass input-validation branches that key off `SyntaxParseError`.\n\nNo confidentiality or integrity impact. The error is thrown synchronously and is\ncatchable, so a consumer that catches *all* exceptions is not crashed \u2014 this is why the\nseverity is assessed Low\u2013Medium rather than High.\n\n## Affected code / root cause\n\nThere is no depth bound anywhere in the parse pipeline. Recursion occurs in (at least)\ntwo independent places:\n\n1. **Parser (recursive descent).** `src/load/parser.ts` \u2014 `array` / `inlineTable`\n   rules recurse through `value` for each nesting level.\n2. **Interpreter (tree walk).** `src/load/interpreter.ts` \u2014\n   `assignValue`, `createTable`, `getOrCreateArray` recurse per dotted-key segment, and\n   `cleanInternalProperties` recurses per object depth.\n\nBecause there is no configurable or hard limit, the recursion depth is bounded only by\nthe V8 stack, and overflow surfaces as a raw `RangeError`.\n\n## Steps to reproduce (PoC)\n\nEnvironment used: Node.js v20, `js-toml@1.1.2`.\n\n```js\nimport { load, SyntaxParseError } from \u0027js-toml\u0027;\n\nfunction probe(label, toml) {\n  try {\n    load(toml);\n    console.log(`[OK]            ${label}`);\n  } catch (e) {\n    const expected = e instanceof SyntaxParseError;\n    console.log(`[${e.constructor.name}${expected ? \u0027\u0027 : \u0027 (UNEXPECTED)\u0027}] ${label}: ${String(e.message).split(\u0027\\n\u0027)[0]}`);\n  }\n}\n\n// 1) Deeply nested arrays  (~2 KB payload)\nprobe(\u0027nested array depth 1000\u0027, \u0027x = \u0027 + \u0027[\u0027.repeat(1000) + \u0027]\u0027.repeat(1000));\n\n// 2) Deeply nested inline tables\nlet v = \u00271\u0027;\nfor (let i = 0; i \u003c 1000; i++) v = `{ a = ${v} }`;\nprobe(\u0027nested inline table depth 1000\u0027, \u0027x = \u0027 + v);\n\n// 3) Deep dotted key (interpreter recursion)\nconst key = Array.from({ length: 5000 }, (_, i) =\u003e \u0027a\u0027 + i).join(\u0027.\u0027);\nprobe(\u0027dotted key depth 5000\u0027, `${key} = 1`);\n```\n\n### Observed output\n\n```\n[RangeError (UNEXPECTED)] nested array depth 1000: Maximum call stack size exceeded\n[RangeError (UNEXPECTED)] nested inline table depth 1000: Maximum call stack size exceeded\n[RangeError (UNEXPECTED)] dotted key depth 5000: Maximum call stack size exceeded\n```\n\nEach case throws `RangeError`, **not** `SyntaxParseError`. Overflow occurs in single-digit\nmilliseconds, so it is not a CPU-exhaustion issue \u2014 it is an immediate, deterministic abort.\n\nNotes on thresholds (machine-dependent; exact numbers vary by stack size):\n- Nested arrays / inline tables overflow at roughly **depth ~1000** (parser recursion).\n- Dotted keys overflow at roughly **depth ~5000** (interpreter recursion); depth 1000 still succeeds.\n\n## Suggested remediation\n\nEnforce an explicit, documented maximum nesting/key depth and surface violations as\n`SyntaxParseError` (consistent with all other invalid-input handling). For example:\n\n- Track current depth in the parser/interpreter and throw `SyntaxParseError`\n  (e.g. `\"Maximum nesting depth exceeded\"`) once a configurable limit (e.g. 100\u20131000)\n  is reached, **before** the native stack overflows.\n- As a defensive backstop, wrap the top-level `load()` body so that a thrown\n  `RangeError` from stack exhaustion is converted into a `SyntaxParseError`, guaranteeing\n  the documented error contract holds for all malformed input.\n\nA configurable limit (with a safe default) is preferable so legitimate deep documents can\nopt into a higher bound.\n\n## Disclosure\n\nReported privately via GitHub Security Advisory. Happy to provide additional reproducers\nor test against a candidate patch.",
  "id": "GHSA-3g82-77xr-68x5",
  "modified": "2026-11-20T14:40:45Z",
  "published": "2026-11-20T14:40:45Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/sunnyadn/js-toml/security/advisories/GHSA-3g82-77xr-68x5"
    },
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-63386"
    },
    {
      "type": "WEB",
      "url": "https://github.com/sunnyadn/js-toml/commit/4e10acf1f99ff3cb443c58b8f0a57664e41e87c6"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/sunnyadn/js-toml"
    },
    {
      "type": "WEB",
      "url": "https://github.com/sunnyadn/js-toml/releases/tag/v1.1.3"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L",
      "type": "CVSS_V3"
    }
  ],
  "summary": "js-toml allows uncontrolled recursion in `load()` leading `RangeError` (stack exhaustion) on deeply nested input"
}



Log in or create an account to share your comment.




Tags
Taxonomy of the tags.


Loading…

Loading…

Loading…

Drag nodes to arrange them. Double-click a related vulnerability to open it, or a source to visit its link. The Physics button on the left tunes the layout and the simulation; the legend at the bottom left hides or shows nodes by kind and by sighting type.

Forecast uses a logistic model when the trend is rising, or an exponential decay model when the trend is falling. Fitted via linearized least squares.

Sightings

Author Source Type Date Other

Nomenclature

  • Seen: The vulnerability was mentioned, discussed, or observed by the user.
  • Confirmed: The vulnerability has been validated from an analyst's perspective.
  • Published Proof of Concept: A public proof of concept is available for this vulnerability.
  • Exploited: The vulnerability was observed as exploited by the user who reported the sighting.
  • Patched: The vulnerability was observed as successfully patched by the user who reported the sighting.
  • Not exploited: The vulnerability was not observed as exploited by the user who reported the sighting.
  • Not confirmed: The user expressed doubt about the validity of the vulnerability.
  • Not patched: The vulnerability was not observed as successfully patched by the user who reported the sighting.
Vulnerability timeline

Sightings and recorded dates, grouped by day · UTC

JSON
How durations are calculated

Following the VTEM framework (Black Hat USA 2015), time to patch starts when the vendor or a coordinator was informed, total time to patch at discovery, and disclosure to patch at public disclosure; vendor response time runs from the report to its acknowledgement. Time to exploit and time unpatched start at the earliest discovery or report, falling back to public disclosure. Unpatched time ends at the first recorded patch, or the calculation time when no patch is recorded. Exploitation to patch shows the interval between those two events; a published proof of concept is a public exploit, not exploitation.

Each result shows its source dates. A negative interval means the end event came first; when date-only inputs leave the order open, the result says so. Date-only inputs are approximate. The earliest evidence wins: KEV report dates and sightings are labelled as such. Records describing another vulnerability are listed but never calculated from, and a PoC alone does not establish exploitation. Missing patch evidence does not prove that no patch exists. Filters below change the event list only.

Events included in the timeline

Loading timeline…


    Loading…

    Loading…

    Loading…

    Related by attack behaviour

    Vulnerabilities whose description is nearest to this one in the vector space of the CIRCL/vulnerability-attack-technique-biencoder model. This is a similarity search over the bi-encoder space (plain cosine), not a classification, and it has no measured accuracy.