Skip to main content

js-toml EUVDEUVD-2026-84801

| CVE-2026-63386 MEDIUM
Uncontrolled Recursion (CWE-674)
2026-09-22 security-advisories@github.com
5.3
CVSS 3.1 · Vendor: github
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Identify service parsing untrusted TOML via js-toml
  2. Delivery
    Craft deeply nested arrays/inline tables or long dotted key
  3. Exploit
    Submit payload to load()
  4. Execution
    Exhaust V8 call stack, raw RangeError thrown
  5. Impact
    Narrow 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.5% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

js-toml < 1.1.3

Affected Packages

euvd js_toml fix: 1.1.3

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

Vendor (github) PRIMARY 5.3 MEDIUM
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
vuln.today AI 5.3 MEDIUM

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N

Primary rating from Vendor (github).

CVSS VectorVendor: github

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
Low

Lifecycle Timeline

1
Patch available
Sep 22, 2026 - 20:18 EUVD

DescriptionCVE.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

EPSS Score
0.5%
Top 58% exploitable
Prevalence
Low
niche open-source JavaScript TOML parser, limited npm adoption
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.5%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact· derived
Medium

Priority Score

27
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +26
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy