Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify service parsing untrusted TOML via js-toml
-
DeliveryCraft deeply nested arrays/inline tables or long dotted key
-
ExploitSubmit payload to load()
-
ExecutionExhaust V8 call stack, raw RangeError thrown
-
ImpactNarrow SyntaxParseError handler rethrows, worker/process terminates (DoS)
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Recursion depth limits
|
| Exploitation Conditions | Exploitation requires an application that (1) uses js-toml prior to 1.1.3, (2) passes attacker-controlled TOML input to load(), and (3) handles parse failures by catching only the documented SyntaxParseError rather than all exceptions. The attacker supplies deeply nested arrays, deeply nested inline tables, or a long dotted/table-header key exceeding the recursive parser's safe depth (the fix defaults the new bound to 100). The key limiting factor is condition (3): because the RangeError is synchronous and catchable, any consumer using a broad try/catch is unaffected, so the DoS only materializes in services with narrow SyntaxParseError-only error handling. No authentication or user interaction is required (PR:N/UI:N). |
| Impact | This is a genuine but low-severity denial-of-service issue, correctly scored at CVSS 5.3 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L). The CVSS signals are internally consistent: remote, low-complexity, no privileges or user interaction, availability-only impact (A:L). CWE-674 (uncontrolled recursion) matches the described unbounded recursive descent in parser.ts/interpreter.ts exhausting the V8 call stack. No EPSS score, no CISA KEV listing, and no public exploit are present in the input, so exploitation status is 'no public exploit identified at time of analysis' - though the triviality of crafting deeply nested TOML makes a working PoC easy to produce. Crucially, the vendor advisory itself notes the thrown exception is synchronous and catchable: an application that catches all exceptions (not just SyntaxParseError) is unaffected, and the fix converts the RangeError into the documented SyntaxParseError. This is a real but minor hardening/robustness issue, not an urgent priority; realistic impact is limited to worker/process crashes in services that both parse attacker-controlled TOML and narrowly catch only SyntaxParseError. No confidentiality or integrity exposure exists. |
| Exploit ScenarioDerived | An application uses js-toml's load() to parse TOML supplied by an untrusted client (e.g. an uploaded config or API payload) and its error handler catches only SyntaxParseError. An attacker submits a tiny TOML document with deeply nested arrays/inline tables or a very long dotted key, overflowing the V8 call stack and producing an uncaught RangeError that crashes the worker or process. No public exploit is identified, but the malicious input is trivial to construct. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 22, 2026
Denial of service in js-toml prior to 1.1.3 arises when load() processes attacker-controlled TOML with deeply nested arrays, deeply nested inline tables, or excessively long dotted/table-header keys, exhausting the V8 call stack and throwing a raw RangeError rather than the documented SyntaxParseError. The impact is limited to availability: applications that catch only SyntaxParseError and rethrow everything else can have a worker or process terminated, while consumers with broad exception handling are unaffected. No authentication or user interaction is required (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L, score 5.3), the flaw does not affect confidentiality or integrity, and there is no public exploit identified at time of analysis - vendor-released patch: 1.1.3.
RemediationAI
Upgrade js-toml to 1.1.3 or later (vendor-released patch: 1.1.3), available from the release tag https://github.com/sunnyadn/js-toml/releases/tag/v1.1.3, which contains commit 4e10acf1f99ff3cb443c58b8f0a57664e41e87c6 and the advisory GHSA-3g82-77xr-68x5. After upgrading, the library enforces DEFAULT_MAX_DEPTH of 100 and throws DepthLimitError (a SyntaxParseError subclass) for over-deep input; if a legitimate workload needs deeper documents, raise the bound via load(toml, { maxDepth: n }), accepting that values too close to the environment's native stack capacity reintroduce overflow risk - the fix's catch-block converts residual RangeErrors into SyntaxParseError as a backstop, but that backstop should not be relied on as the primary control. If immediate upgrade is not possible, the highest-value compensating control is to broaden consumer error handling around load() to catch all exceptions rather than only SyntaxParseError, which fully neutralizes the DoS at the cost of masking other unexpected parser errors that should still be logged and monitored. Defense-in-depth options include rejecting or truncating untrusted TOML beyond a reasonable byte size and pre-scanning input for excessive '[' / '{' nesting or dotted-key segment counts, with the trade-off that content-based filtering is heuristic, can produce false positives on large legitimate configs, and adds parsing overhead. Because exploitation depends on a narrow SyntaxParseError-only handler, code review of parse call sites should be prioritized alongside the dependency update.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The root cause is CWE-674 (Uncontrolled Recursion). js-toml implements a recursive-descent TOML parser in src/load/parser.ts and a CST-walking interpreter in src/load/interpreter.ts; neither bounded the depth of array/inline-table nesting nor the number of dotted-key/table-header segments before version 1.1.3. Because each nesting level or key segment consumes native V8 stack frames, sufficiently deep input overflows the stack and surfaces as a raw RangeError instead of the library's SyntaxParseError contract. The 1.1.3 fix introduces a token-stream pre-scan (checkNestingDepth) that counts ArrayOpen/InlineTableOpen versus their close tokens and rejects input exceeding a maxDepth bound, plus a checkKeyDepth guard in the interpreter applied at each key-handling site, and a catch-block backstop that converts any residual RangeError into SyntaxParseError. The default limit, DEFAULT_MAX_DEPTH, is 100 - far above realistic TOML documents yet safely below the native stack threshold - and is exposed as a LoadOptions.maxDepth option (also exported along with the new DepthLimitError, itself a SyntaxParseError subclass). Direct interpreter use remains unbounded by default for backward compatibility, so the guard is only effective when input flows through load(). The exception is synchronous and catchable, which is why the practical exposure depends on the consumer's error-handling breadth rather than on any cryptographic or memory-safety weakness.
Know when the next one hits your stack
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
Remote unauthenticated attacker-controlled TOML triggers stack exhaustion with no interaction; availability-only and limited (A:L) since the exception is catchable and crash-scoped, no C/I impact.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
1DescriptionCVE.org
js-toml is a TOML parser for JavaScript. Prior to 1.1.3, load() does not bound nesting or dotted-key depth in the recursive parser at src/load/parser.ts or the interpreter at src/load/interpreter.ts, so deeply nested arrays, deeply nested inline tables, or long dotted keys can exhaust the V8 call stack and throw a raw RangeError instead of the documented SyntaxParseError. Applications that parse attacker-controlled TOML and handle only SyntaxParseError can rethrow the unexpected exception, which can terminate a worker or process and cause denial of service. The exception is synchronous and catchable by consumers that handle all exceptions, and the issue does not affect confidentiality or integrity. This issue is fixed in version 1.1.3.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
EUVD-2026-84801
NVD
CVE.org
EPSS
GitHub
Exploit-DB