Skip to main content

Vendure CVE-2026-63460

| EUVDEUVD-2026-81667 HIGH
Inefficient Regular Expression Complexity (ReDoS) (CWE-1333)
2026-09-17 GitHub_M GHSA-jgm3-qmp2-c4p7
7.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Reach public Shop GraphQL products query
  2. Delivery
    Submit StringOperators.regex with nested-quantifier pattern
  3. Exploit
    SQLite JS UDF evaluates regex synchronously
  4. Execution
    Event loop blocks on catastrophic backtracking
  5. Impact
    Repeat to sustain storefront/admin outage

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V2 - Validation and Business Logic Regex complexity limits
MITRE ATT&CK

1 technique across 1 tactic: Impact

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitable only when the Vendure instance runs on the better-sqlite3 or sqljs database driver, which register a synchronous JavaScript REGEXP UDF evaluated on the Node.js event loop; deployments on PostgreSQL or MySQL/MariaDB are NOT exploitable because the pattern is delegated to the database engine. Given a SQLite backend, no other conditions apply: the ShopProductsResolver.products query has no @Allow decorator and the default access-control strategy treats an empty permission set as public, so exploitation is remote and fully unauthenticated with no user interaction, using a filter like {regex: '(a+)+$'}. The primary limiting factor is that SQLite is typically a development/testing backend rather than production, sharply narrowing the exposed population.

Impact

The CVSS 3.1 vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, base 7.5) describes a clean unauthenticated, network-reachable, low-complexity availability-only impact, which matches the description: the ShopProductsResolver.products query carries no @Allow decorator and is publicly reachable, and a single nested-quantifier pattern via StringOperators.regex blocks the Node.js event loop. However, the raw 7.5 significantly overstates real-world priority because exploitation is strictly gated on the SQLite driver (better-sqlite3 or sqljs), which the vendor explicitly notes is normally a development/testing backend - production deployments on PostgreSQL or MySQL/MariaDB delegate the regex to the database engine and are unaffected. No EPSS score, no CISA KEV listing, and no formally published exploit are present in the provided data, so there is no public exploit identified at time of analysis; the availability signal is real but the deployment gating makes this a lower operational priority than the score implies. Note also the input Tags include 'PostgreSQL', which is the explicitly UNAFFECTED database - a potentially misleading label. Confidence in the technical mechanism is high because vendor source code (the SQLite UDF at list-query-builder.ts) and the fixing commit are provided.

Exploit ScenarioDerived

An attacker sends an unauthenticated GraphQL query to the public Shop API's products resolver with a filter such as {regex: '(a+)+$'} against a string field, only effective if the target runs the better-sqlite3 or sqljs driver. The synchronous SQLite REGEXP user-defined function evaluates the catastrophically backtracking pattern on the Node.js event loop, freezing all request processing; repeated requests sustain a complete denial of service of both storefront and admin APIs. No standalone weaponized exploit is published, though the fix's own test suite demonstrates the trigger pattern.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.4% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Sep 17, 2026

Unauthenticated denial of service in Vendure (open-source headless commerce platform) versions up to and including 3.6.4 lets a remote attacker freeze the Node.js event loop by supplying a catastrophically backtracking regular expression to the publicly reachable Shop GraphQL products query through StringOperators.regex, rendering both the storefront and admin API unavailable; repeated requests can sustain the outage. The flaw is only reachable on instances running the better-sqlite3 or sqljs SQLite drivers, which register a synchronous JavaScript REGEXP user-defined function on the event loop, whereas PostgreSQL and MySQL/MariaDB deployments push the pattern to the database engine and are unaffected. CVSS 3.1 rates it 7.5 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), and no public exploit code was identified at time of analysis; vendor-released patch: 3.6.5.

RemediationAI

Upgrade to Vendure 3.6.5, which adds an assertSafeRegexFilter() check that rejects regex filter patterns with nested unbounded quantifiers (star height >= 2) and patterns exceeding the maximum permitted length, returning a UserInputError instead of passing them to the SQLite REGEXP UDF; the release is at https://github.com/vendurehq/vendure/releases/tag/v3.6.5 and the fix commit is https://github.com/vendurehq/vendure/commit/f74cbbb0b9a50b5b0131822835fe7ee9b71b42c9. If an immediate upgrade is not possible, migrate the instance to PostgreSQL or MySQL/MariaDB, where the pattern is evaluated by the database engine and the event-loop blocking path does not exist - this is the most robust workaround but carries data-migration cost and application retesting. Alternatively, restrict or block unauthenticated access to the Shop GraphQL products query at a reverse proxy or API gateway (e.g., prohibit anonymous POSTs containing StringOperators.regex filters), accepting the trade-off of breaking legitimate storefront filtering clients; or apply strict rate limiting and request timeouts in front of the GraphQL endpoint, which reduces sustained DoS but does not prevent a single blocking pattern from stalling the event loop. Note that pattern-length or complexity sanitisation implemented downstream (WAF) is fragile against ReDoS and should only be treated as a stopgap, and SQLite remains a development/testing backend in most deployments, sharply narrowing the affected population.

Affected VersionsENISA

vendure < 3.6.5

Affected Packages

npm @vendure/core fix: 3.6.5
npm vendure/core fix: 3.6.5
euvd vendure fix: 3.6.5

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 3 packages in npm, euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

This is a classic CWE-1333 inefficient regular expression complexity (ReDoS) issue occurring inside a database abstraction layer. Vendure's ListQueryBuilder registers a REGEXP implementation for SQLite backends: for better-sqlite3 it installs a JavaScript function via databaseConnection.function('regexp', ...) and for sqljs via create_function('regexp', ...). That function takes the caller-supplied pattern verbatim and executes new RegExp(pattern, 'i').test(value) synchronously on the Node.js event loop. parse-filter-params.ts routes StringOperators.regex operands directly into that parameter without length limits, timeouts, or safe-regex validation, so a nested-quantifier pattern such as (a+)+$ triggers exponential backtracking that blocks the single-threaded event loop and stalls all concurrent request processing. Reachability is unauthenticated because ShopProductsResolver.products carries no @Allow decorator and Vendure's default entity access-control strategy returns true when the required permission set is empty, making the query public. The fix in 3.6.5 introduces an assertSafeRegexFilter() guard in parse-filter-params.ts that rejects patterns exhibiting star height of two or more (nested unbounded quantifiers) and patterns exceeding a maximum length, as shown by the accompanying unit and e2e tests and the new i18n error messages for over-length and unsafe patterns. The CPE string cpe:2.3:a:vendurehq:vendure:*:*:*:*:*:*:*:* reflects that the affected range is the entire Vendure distribution prior to the fixed release, not a single component.

Know when Vendure 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 (GitHub_M) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

Remote, unauthenticated, low-complexity event-loop-blocking DoS on a public GraphQL query with availability-only impact; SQLite-only gating is a deployment condition, not a base metric.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

2
Patch available
Sep 17, 2026 - 16:02 EUVD
CVE Published
Sep 17, 2026 - 14:38 cve.org
HIGH 7.5

DescriptionCVE.org

Vendure is an open-source headless commerce platform. Prior to 3.6.5, the public Shop GraphQL API allows an unauthenticated caller to supply a catastrophically backtracking pattern through StringOperators.regex. packages/core/src/service/helpers/list-query-builder/parse-filter-params.ts passes the raw pattern to the REGEXP implementation registered by packages/core/src/service/helpers/list-query-builder/list-query-builder.ts, and better-sqlite3 and sqljs evaluate it synchronously in the Node.js event loop. ShopProductsResolver.products is publicly reachable, so one nested-quantifier pattern can block request processing and make the storefront and admin API unavailable, while repeated requests can sustain denial of service. PostgreSQL and MySQL or MariaDB deployments do not execute this regular expression in the Node.js event loop. This issue is fixed in version 3.6.5.

Technical POC Analysis

CWE-1333 (Inefficient Regular Expression Complexity).

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

Vendure, the open-source headless commerce platform, is exposed to an unauthenticated denial-of-service condition that can render both the customer-facing storefront and the administrative console unavailable to all users. The exposure is limited to deployments running the SQLite-based drivers (better-sqlite3 or sqljs) at version 3.6.4 or earlier; PostgreSQL and MySQL/MariaDB deployments are not affected. Because the affected systems are revenue-generating storefronts and order-management consoles, leadership should treat this as a continuity-of-business risk rather than a data-breach risk.

Business Impact: High
Compensating Controls

Advisory text references a vendor-released patch (Vendure 3.6.5) while the structured patch-status field reports no patch available; verify the 3.6.5 release with the vendor and apply it as the primary remediation. Until the upgrade is confirmed deployed, interim mitigations are: enforce WAF/edge filtering or rate limiting on the public Shop GraphQL products query including the StringOperators.regex argument; disable or block the regex string operator in the GraphQL schema/configuration; apply strict request timeouts and per-client concurrency limits to the Shop GraphQL endpoint; and restrict or proxy admin API access to trusted networks. Migrating affected instances to PostgreSQL or MySQL/MariaDB removes the exposure because those drivers evaluate patterns in the database rather than on the Node.js event loop.

Threat Intelligence Overview

EPSS Score
0.4%
Top 65% exploitable
Prevalence
Low
niche open-source headless commerce framework; vulnerable path further limited to SQLite backends
Threat Intel
1
1 sources
Exploit
POC
Public exploit code exists
Data Quality
5 sources
Confidence: Medium
EUVD NVD CVE.org EPSS Vulnrichment GHSA 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 Yes
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

58
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +38
PoC: +20
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