Skip to main content

braces EUVDEUVD-2026-82983

| CVE-2026-93687 HIGH
Uncontrolled Recursion (CWE-674)
2026-09-18 VulnCheck GHSA-vfj7-8cjw-p6xm
8.7
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Reach app endpoint accepting brace/glob input
  2. Delivery
    Submit deeply nested pattern under char limit
  3. Exploit
    Recursive AST walker exceeds call stack
  4. Execution
    Uncaught RangeError crashes Node.js process
  5. Impact
    Service 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
1 public PoC No patch listed yet 0.4% exploitation probability (EPSS)

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

Alert me

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

braces 0 ≤3.0.3

Affected Packages

npm braces no fix

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

Vendor (VulnCheck) PRIMARY 8.7 HIGH
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
vuln.today AI 7.5 HIGH

Unauthenticated attacker input reaching braces expansion triggers unrecoverable process crash; pure availability impact, no confidentiality or integrity effect.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.4%
Top 65% exploitable
Prevalence
Ubiquitous
braces is a core transitive dependency of micromatch/chokidar across the npm ecosystem
Threat Intel
1
1 sources
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA MSRC Vendor GitHub

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 HIGH
CISA KEV No
Public POC Yes
EPSS 0.4%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

64
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

Vendor StatusVendor

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