Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach app endpoint accepting brace/glob input
-
DeliverySubmit deeply nested pattern under char limit
-
ExploitRecursive AST walker exceeds call stack
-
ExecutionUncaught RangeError crashes Node.js process
-
ImpactService denial of availability
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Recursion depth limits
|
| Exploitation Conditions | Requires an application that passes attacker-controlled strings into braces' expansion/compilation (the braces(), expand(), or compile() paths whose recursive AST walkers lack depth guards). The malicious input is a brace pattern with deep nesting kept under braces' internal character limit, so length-based input validation does not block it. Exploitation is limited to environments where such untrusted brace/glob input is reachable (e.g. via a web parameter or filename processed through micromatch/chokidar-style globbing); braces itself is a library with no network listener, and impact is confined to crashing the Node.js process (availability only). No authentication or user interaction is required on the vulnerable code path per the CVSS vector. |
| Impact | The vendor CVSS 4.0 score of 8.7 is driven entirely by VA:H (availability) with VC:N/VI:N - this is a pure denial-of-service, not a confidentiality or code-execution issue, so the headline 'High/Critical' number overstates real-world impact for most deployments. The vector (AV:N/AC:L/AT:N/PR:N/UI:N) claims unauthenticated remote reachability, but that only holds when an application actually forwards attacker-controlled strings into braces' expand/compile path; braces is a library, not a listening service, so exploitability is entirely conditional on how the consuming application wires untrusted input. There is no EPSS score, no CISA KEV listing, and no explicit proof-of-concept exploit provided - only a GitHub issue (#70) and a VulnCheck advisory - so this is 'no public exploit identified at time of analysis' despite the high CVSS. My independent 3.1 assessment is ~7.5 (A:H only). Net: a real but bounded availability risk whose priority hinges on whether a given service exposes brace-pattern parsing to untrusted input, not a widespread active-exploitation emergency. The 'Buffer Overflow' tag is misleading - this is recursive stack exhaustion (CWE-674), not a memory-corruption buffer overflow. |
| Exploit ScenarioDerived | An attacker sends a deeply nested brace pattern (e.g. many stacked '{...}' levels) kept under braces' character limit to an application that expands user-supplied glob/brace strings. The recursive AST walkers in parse/compile/expand exceed the JavaScript call-stack depth, throwing an uncaught RangeError that terminates the Node.js process. No public PoC is provided beyond the referenced GitHub issue, and no authentication or user interaction is required where the input path is reachable. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 18, 2026
Stack exhaustion in the Node.js 'braces' library (micromatch) through 3.0.3 lets unauthenticated remote attackers crash the hosting Node.js process by supplying brace patterns nested deeply enough to overflow the call stack - for example long chains of '{{{{...}}}}' kept just under the library's internal character-length limit, so length-based input validation does not block the payload. Exploitation requires an application path that forwards attacker-controlled strings into braces' recursive AST walkers (the braces(), expand(), or compile() paths referenced at parse.js L38-40, expand.js L102-105, and compile.js L49-53), such as a web parameter or filename routed through micromatch/chokidar-style globbing; the result is an uncaught RangeError that terminates the process. Per the supplied CVSS vector (PR:N/UI:N) no authentication or user interaction is needed on the vulnerable code path, and the CVSS 4.0 score of 8.7 is driven entirely by availability (VA:H) with no confidentiality or integrity impact; no public exploit code was identified at time of analysis.
RemediationAI
No vendor-released patch or fixed version was identified at time of analysis, so track https://github.com/micromatch/braces/issues/70 and https://www.vulncheck.com/advisories/braces-through-3.0.3-stack-overflow-via-deeply-nested-patterns and upgrade to the first braces release that adds recursion-depth guards as soon as it is published; because braces is usually transitive, pin or override the version in your lockfile and re-scan micromatch/chokidar dependency chains. Until a fix ships, the most effective control is to reject deep nesting before the pattern ever reaches braces: compute the maximum brace-nesting depth of any untrusted input (for example by counting consecutive '{' depth or the longest run of unclosed opening braces) and reject anything above a small threshold such as 10-20 levels, since the length-based limit that the library already enforces clearly does not stop the payload - the trade-off is that legitimate but very deeply nested machine-generated patterns will be refused. Apply this validation at the boundary where the string enters the process (HTTP parameter, filename, job payload) rather than inside the glob call. As a defense-in-depth containment measure, run brace/glob expansion for untrusted input inside a worker thread or child process with a capped stack and restart policy, so a RangeError kills only the worker and not the whole application - this costs an extra process/thread per expansion. Wrapping the expansion call in try/catch for RangeError can keep a single crash from propagating, but it does not prevent repeated CPU/stack churn from a persistent attacker and should not be treated as a fix. Raising Node's --stack-size only increases the nesting depth required and consumes additional memory, trading a smaller denial-of-service payload for larger resource use, so it is not a durable mitigation. If the untrusted input does not genuinely need brace expansion, prefer an allowlist of fixed, developer-defined patterns or a non-recursive globbing library, and restrict endpoints that accept arbitrary glob syntax to authenticated or trusted callers.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in npm
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The 'braces' package implements Bash-style brace expansion used by micromatch and downstream globbing/CLI tooling in the Node.js ecosystem. Processing a pattern like 'a{b,c}d' proceeds in three stages: parse.js builds an abstract syntax tree of brace groups, expand.js walks that tree to enumerate the expanded set, and compile.js emits a regular expression for the non-expanding path. All three walkers are recursive with no explicit recursion-depth guard, which is the CWE-674 (Uncontrolled Recursion) root cause; the only apparent bounding is an internal character-length limit. Because nesting depth grows the AST/call depth roughly linearly, an attacker can pack hundreds or thousands of nested brace groups into a string that remains well within the length limit, exhausting V8's default call stack and raising 'RangeError: Maximum call stack size exceeded'. The exception occurs inside library code and is typically not caught by callers, so it propagates as an uncaught exception and takes down the entire Node.js process - significant because Node.js is effectively single-threaded at the application level and any concurrent requests, jobs, or watchers handled by that process are lost. The CPE cpe:2.3:a:micromatch:braces:*:*:*:*:*:*:*:* confirms the affected component is the micromatch-maintained braces package rather than a network-facing service; braces exposes no listener itself, so real exploitability depends on the embedding application (web frameworks and file-watching stacks that pass untrusted glob/brace strings into it) and the assessed impact remains availability-only (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H).
Know when Braces gets its next vulnerability
- 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Unauthenticated attacker input reaching braces expansion triggers unrecoverable process crash; pure availability impact, no confidentiality or integrity effect.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
braces through 3.0.3 contains a stack overflow vulnerability in the recursive AST walkers that lack depth guards. Attackers can supply deeply nested brace patterns under the character limit to exhaust the call stack and terminate the Node.js process with an uncaught RangeError.
Blast Radius
ecosystem impact- 301,301 npm packages depend on braces (6,050 direct, 295,380 indirect)
Ecosystem-wide dependent count for version 3.0.3.
Technical POC Analysis
Evidence note: the gist supplied as SOURCE (konard/be3c0bf9...) is an unrelated "solution draft log" for link-foundation/package-registry-manager PR #34.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Latest POC
1 public PoC link from github
Sign in to open the public PoC links collected for this CVE.
Executive ViewAI
The Node.js 'braces' library, used by micromatch and other packages for pattern matching, is affected by a stack exhaustion vulnerability in versions through 3.0.3 that allows unauthenticated remote attackers to crash the hosting Node.js process. This creates a denial-of-service risk for any application that forwards untrusted input into globbing or brace expansion functions, potentially causing service outages and operational disruption. Leadership should prioritize mitigation due to the high availability impact and the current absence of a vendor patch.
Implement strict input validation to reject nested brace patterns and limit input length; deploy a web application firewall (WAF) with rules to block malicious patterns; run Node.js processes with memory limits and automatic restart; avoid passing untrusted input to braces/micromatch functions; consider using a safe alternative library such as 'picomatch' or 'minimatch' with appropriate configurations; and monitor for crashes and apply the vendor patch as soon as it becomes available.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
EUVD-2026-82983
GHSA-vfj7-8cjw-p6xm
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB