CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-128074

CVE-2026-128074: Regular Expression Denial of Service in Nuxt SSR Payload URL Generation

Alon Barad
Alon Barad
Software Engineer

Nov 16, 2026·11 min read·2 visits

Executive Summary (TL;DR)

Unanchored regular expressions used to strip trailing slashes in Nuxt 4.6.0–4.6.3 exhibit quadratic time complexity when processing paths with repeated slashes and a non-slash suffix. Unauthenticated remote attackers can exploit this flaw to block the Node.js event loop and cause a denial of service on SSR endpoints.

CVE-2026-128074 is an algorithmic complexity and Regular Expression Denial of Service (ReDoS) vulnerability in Nuxt versions 4.6.0 through 4.6.3. The flaw resides in the server-side rendering (SSR) runtime components responsible for payload URL generation and experimental early 404 route evaluation. By sending unauthenticated HTTP requests containing long sequences of repeated forward slashes followed by a non-slash character, an attacker can force the V8 regular expression engine into quadratic O(N^2) backtracking, blocking the single-threaded Node.js event loop and degrading application availability.

Vulnerability Overview

Nuxt is an open-source full-stack web framework built on Vue.js and Nitro for server-side rendering (SSR), static site generation, and hybrid rendering strategies. Within the Nuxt SSR architecture, the server runtime intercepts incoming HTTP requests to normalize paths, evaluate route rules, and construct internal URLs for fetching page payload data (_payload.json or _payload.js). These normalization routines execute directly on the primary Node.js execution thread before route caching or rendering takes place.

In Nuxt versions 4.6.0 through 4.6.3, the path normalization logic in packages/nuxt/src/runtime/server/renderer/url.ts and packages/nuxt/src/runtime/server/renderer/early-404.ts relies on regular expressions (/\/*$/ and /\/+$/) to strip trailing slashes from request paths. This implementation introduces an Inefficient Regular Expression Complexity vulnerability (CWE-1333). Because these regular expressions are only anchored at the end of the string ($) and use greedy quantifiers (+ and *), they exhibit polynomial $O(N^2)$ time complexity when evaluating strings that contain long sequences of slashes followed by a non-slash character.

The attack surface encompasses any publicly accessible Nuxt SSR deployment utilizing specific caching or routing features. Specifically, applications are exposed if they configure route rules with Incremental Static Regeneration (isr), Stale-While-Revalidate (swr), or cache, as these features invoke routeToPayloadURL during request processing. Applications are also exposed if they enable the experimental.early404 configuration flag, which invokes matchesPageRoute on incoming requests.

When an unauthenticated attacker submits an HTTP request with a crafted URI path containing tens or hundreds of thousands of consecutive slashes terminated by a non-slash character, the V8 regular expression engine enters a catastrophic backtracking loop. Because Node.js executes JavaScript and regular expression evaluations synchronously on a single-threaded event loop, this computation halts all concurrent request processing, starving I/O callbacks and causing a denial of service.

Root Cause Analysis

The root cause of CVE-2026-128074 is the use of left-unanchored regular expressions with greedy quantifiers to remove trailing characters from user-controlled URI paths. In early-404.ts, the runtime defines const TRAILING_SLASHES_RE = /\/+$/, while url.ts defines const TRAILING_SLASHES_RE = /\/*$/. Both expressions intend to match contiguous sequences of forward slashes situated strictly at the end of the input string and replace them with either an empty string or a single slash.

When the V8 regular expression engine (Irregexp) evaluates an expression that is not anchored to the start of the string (^), it attempts to find a match starting at index 0, then index 1, and continues advancing through every character index until a match succeeds or the end of the string is reached. When the engine encounters a contiguous block of $N$ slashes followed by a non-slash character (for example, /known followed by $N$ slashes and the character 'x'), it begins matching at the first slash in the sequence. The greedy quantifier (+ or *) consumes all $N$ slashes up to the 'x' character.

Once all slashes are consumed, the engine attempts to match the end-of-string assertion ($). Because the next character is 'x' rather than the end of the string, the assertion fails. Standard backtracking then forces the quantifier to step back one character at a time across all $N$ slashes, checking for $ at each step and failing every time. Once all possibilities starting at the first slash are exhausted, the outer scan loop of the regex engine advances its starting position to the second slash in the sequence and repeats the entire greedy consumption and backtracking cycle across the remaining $N-1$ slashes.

This behavior repeats for every slash index from $1$ to $N$. The total number of character comparisons performed by the engine follows the triangular series $\sum_{i=1}^{N} i = \frac{N(N+1)}{2}$, yielding a quadratic time complexity of $O(N^2)$. For an input containing $200,000$ consecutive slashes followed by a single non-slash character, the engine executes approximately $2 \times 10^{10}$ operations before concluding that no trailing slashes exist at the end of the string.

Code Analysis

The vulnerability was introduced in commit 49da92fe0dc0cf97bd218167da822e2827232380 and affected two distinct modules within the Nuxt server renderer runtime. In packages/nuxt/src/runtime/server/renderer/early-404.ts, the function matchesPageRoute checked whether an incoming pathname matched a known page route by stripping /_payload.json suffixes and removing trailing slashes via path.replace(TRAILING_SLASHES_RE, ''). In packages/nuxt/src/runtime/server/renderer/url.ts, the function routeToPayloadURL normalized both baseURL and request.pathname using replace(TRAILING_SLASHES_RE, '/').

In commit 97424dd21c59b60cc7ece28576e15069ca0fdbc4, the Nuxt maintainers remediated the issue by removing TRAILING_SLASHES_RE from both files and introducing a deterministic helper function named withoutTrailingSlashes. Instead of invoking the regular expression engine, this function scans the string backward from its final character index.

diff --git a/packages/nuxt/src/runtime/server/renderer/early-404.ts b/packages/nuxt/src/runtime/server/renderer/early-404.ts
index eb86f4a..7090885 100644
--- a/packages/nuxt/src/runtime/server/renderer/early-404.ts
+++ b/packages/nuxt/src/runtime/server/renderer/early-404.ts
@@ -1,7 +1,7 @@
 import { NUXT_PAGE_MATCHER } from 'nuxt/internal/renderer-config'
 import type { NuxtRendererOptions, RendererEvent } from './runtime'
+import { withoutTrailingSlashes } from './url'
 
-const TRAILING_SLASHES_RE = /\/+$/
 const PAYLOAD_SUFFIX = '/_payload.json'
 
 /**
@@ -17,7 +17,7 @@ function matchesPageRoute (pathname: string): boolean {
     path = path.slice(0, -PAYLOAD_SUFFIX.length) || '/'
   }
   if (path.length > 1) {
-    path = path.replace(TRAILING_SLASHES_RE, '') || '/'
+    // Replaced quadratic regex with linear reverse scan
+    path = withoutTrailingSlashes(path) || '/'
   }
   if (path.includes('%')) {
     try {
diff --git a/packages/nuxt/src/runtime/server/renderer/url.ts b/packages/nuxt/src/runtime/server/renderer/url.ts
index e999fc9..305df7c 100644
--- a/packages/nuxt/src/runtime/server/renderer/url.ts
+++ b/packages/nuxt/src/runtime/server/renderer/url.ts
@@ -23,13 +23,21 @@ export function payloadRequestToRoute (path: string, filename = '_payload.json')
 }
 
 const LEADING_SLASHES_RE = /^\/+
-const TRAILING_SLASHES_RE = /\/*$/
+
+/** Strip every trailing `/` from a path. */
+export function withoutTrailingSlashes (path: string): string {
+  let end = path.length
+  // Scan backwards from the end of the string in O(k) time
+  while (end > 0 && path[end - 1] === '/') {
+    end--
+  }
+  return path.slice(0, end)
+}
 
 /** The same-origin `_payload.json` (or `_payload.js`) URL for a page route, tagged with the build id. */
 export function routeToPayloadURL (baseURL: string, path: string, buildId: string, filename = '_payload.json'): string {
   const request = parseRequestPath(path)
-  const base = new URL(baseURL.replace(TRAILING_SLASHES_RE, '/'), 'http://localhost')
-  const route = request.pathname.replace(LEADING_SLASHES_RE, '').replace(TRAILING_SLASHES_RE, '/')
+  const base = new URL(withoutTrailingSlashes(baseURL) + '/', 'http://localhost')
+  const route = withoutTrailingSlashes(request.pathname.replace(LEADING_SLASHES_RE, '')) + '/'
   const url = new URL('./' + (route === '/' ? '' : route) + filename, base)
   url.search = request.search
   url.searchParams.set(PAYLOAD_BUILD_ID_PARAM, buildId)

An evaluation of the patch confirms that the fix is complete and eliminates the algorithmic complexity weakness on this code path. In withoutTrailingSlashes, the while loop starts at end = path.length and inspects path[end - 1]. When presented with the previously pathological input (/foo + $200,000$ slashes + 'x'), path[end - 1] evaluates to 'x', causing the loop condition path[end - 1] === '/' to fail on the very first iteration in $O(1)$ constant time. Even when the string ends exclusively with $k$ slashes, the loop executes at most $k$ times, guaranteeing strict $O(N)$ worst-case linear time complexity. Additionally, the remaining regular expression LEADING_SLASHES_RE = /^\/+/ is anchored to the beginning of the string with ^, preventing the regex engine from advancing across indices if a mismatch occurs.

Exploitation

Exploiting CVE-2026-128074 requires no authentication, session state, or specialized client tooling. The sole prerequisite is that the target Nuxt application is running in SSR mode with either caching/regeneration route rules (isr, swr, or cache) configured or experimental.early404 enabled, and that intermediate network proxies do not normalize or truncate the request URI before forwarding it to the Node.js origin server.

To trigger the quadratic backtracking behavior, the attacker constructs an HTTP GET request where the path starts with a valid or arbitrary route prefix, continues with tens of thousands of repeated forward slashes (/), and terminates with a non-slash character (such as x). If the path ends with a slash, the regular expression matches on its first pass in linear time; the trailing non-slash character is mandatory to force the $ anchor to fail and trigger backtracking across every slash position.

> [!NOTE] > The maximum number of slashes an attacker can deliver in a single request is bounded by the HTTP server's maximum URI or header size limit. In Node.js, --max-http-header-size defaults to 16 KB (approx. 16,384 bytes), though reverse proxies or custom Node.js flags often raise this limit to 64 KB or 256 KB.

The following Node.js proof-of-concept script demonstrates how a client can measure event-loop blocking latency by sending a 150,000-byte slash sequence to a vulnerable endpoint:

const http = require('http');
 
// Construct a payload of 150,000 consecutive slashes followed by 'x'
const slashRun = '/'.repeat(150000);
const maliciousPath = `/api/cached${slashRun}x`;
 
const options = {
  hostname: 'localhost',
  port: 3000,
  path: maliciousPath,
  method: 'GET'
};
 
console.time('RequestDuration');
const req = http.request(options, (res) => {
  console.log(`Response Status: ${res.statusCode}`);
  res.on('data', () => {});
  res.on('end', () => {
    console.timeEnd('RequestDuration');
  });
});
 
req.on('error', (e) => {
  console.error(`Request error: ${e.message}`);
});
 
req.end();

When the vulnerable Nuxt server processes this request, CPU utilization on the Node.js worker thread spikes to 100%. By pipelining or concurrently issuing multiple requests of this structure, an attacker can continuously saturate the event loop, causing health check failures, upstream gateway timeouts (HTTP 502/504), and complete service unavailability for legitimate users.

Impact Assessment

The primary security impact of CVE-2026-128074 is degradation or loss of application availability. The vulnerability does not allow unauthorized read access to application memory or files (Confidentiality: None), nor does it permit modification of server state or code execution (Integrity: None). Under CVSS v4.0, the vulnerability is assigned a base score of 6.9 (Medium) with the vector CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N.

The Availability impact is rated Low (VA:L) in the CVSS v4.0 vector because the resource exhaustion is bounded by the maximum URI length permitted by the underlying HTTP server or reverse proxy. Under Node.js default settings (16 KB header limit), a single request containing roughly 16,000 slashes forces approximately $1.28 \times 10^8$ regex iterations, blocking the thread for tens to hundreds of milliseconds per request. However, in deployments where header size limits are increased or where an attacker transmits a steady stream of concurrent requests, the cumulative blocking time prevents the Node.js event loop from servicing normal traffic.

Static sites generated via nuxt generate and client-only single-page applications (ssr: false) are completely unaffected because the vulnerable server renderer code paths are not active at runtime. Similarly, standard SSR applications that do not utilize isr, swr, or cache route rules and leave experimental.early404 disabled (its default state) do not invoke the affected functions.

From a threat intelligence perspective, the Exploit Prediction Scoring System (EPSS) assigns CVE-2026-128074 a score of 0.00291 (0.291%), placing it in the 22nd percentile of evaluated vulnerabilities. The vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog, and while regression tests in the patch commit provide a clear proof of concept, no weaponized exploitation in the wild has been recorded.

Remediation

The definitive remediation for CVE-2026-128074 is to upgrade the nuxt package to version 4.6.4 or later. Version 4.6.4 incorporates commit 97424dd21c59b60cc7ece28576e15069ca0fdbc4, replacing the vulnerable regular expressions with the linear-time withoutTrailingSlashes string scanner.

Administrators and developers can apply the upgrade using their project's package manager:

# Using npm
npm install nuxt@^4.6.4
 
# Using pnpm
pnpm add nuxt@^4.6.4
 
# Using yarn
yarn add nuxt@^4.6.4

If immediate upgrading is not feasible, organizations can apply configuration and infrastructure mitigations to neutralize the attack vector. If the application relies on the experimental early 404 feature, set experimental.early404 to false in nuxt.config.ts:

export default defineNuxtConfig({
  experimental: {
    early404: false
  }
})

At the network edge, reverse proxies and Web Application Firewalls (WAFs) should be configured to normalize consecutive slashes before forwarding requests to the Node.js backend, or to block requests containing abnormal runs of slashes. In NGINX, ensure the merge_slashes on; directive is enabled in the http or server block (this is enabled by default in standard NGINX configurations), which collapses multiple consecutive slashes into a single slash prior to upstream proxying.

Official Patches

NuxtCommit replacing unanchored trailing slash regexes with linear-time withoutTrailingSlashes helper
NuxtNuxt v4.6.4 release containing the security fix
GitHubOfficial GitHub Security Advisory GHSA-r9jc-w898-3fv6

Fix Analysis (1)

Technical Appendix

CVSS Score
6.9/ 10
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
EPSS Probability
0.29%
Top 78% most exploited

Affected Systems

Nuxt SSR applications (versions 4.6.0 through 4.6.3) using isr, swr, or cache route rulesNuxt SSR applications (versions 4.6.0 through 4.6.3) with experimental.early404 enabled

Affected Versions Detail

Product
Affected Versions
Fixed Version
nuxt
Nuxt
>= 4.6.0, < 4.6.44.6.4
AttributeDetail
CVE IDCVE-2026-128074 (GHSA-r9jc-w898-3fv6)
Weakness ClassCWE-1333: Inefficient Regular Expression Complexity
CVSS v4.0 Score6.9 Medium (CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N)
Attack VectorNetwork (Unauthenticated HTTP GET Request)
Affected VersionsNuxt >= 4.6.0, < 4.6.4
Patched VersionNuxt 4.6.4
EPSS Score0.291% (22nd Percentile)
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1499Endpoint Denial of Service
Impact
T1499.004Application or System Exploitation
Impact
CWE-1333
Inefficient Regular Expression Complexity

The product uses a regular expression with an inefficient, possibly exponential or polynomial worst-case computational complexity that consumes excessive CPU cycles when processing crafted input.

Known Exploits & Detection

GitHubOfficial patch commit containing regression tests demonstrating the 200,000-slash ReDoS trigger pattern.

Vulnerability Timeline

Fix authored and committed (97424dd21c59b60cc7ece28576e15069ca0fdbc4) by Daniel Roe
2026-10-27
Nuxt v4.6.4 released containing the fix
2026-11-13
GitHub Security Advisory GHSA-r9jc-w898-3fv6 and CVE-2026-128074 published
2026-11-13
Vulnerability indexed in the National Vulnerability Database (NVD)
2026-11-13

References & Sources

  • [1]GitHub Security Advisory: GHSA-r9jc-w898-3fv6
  • [2]Nuxt Patch Commit: fix(nuxt): strip trailing slashes in linear time
  • [3]Nuxt Release v4.6.4
  • [4]NVD Record: CVE-2026-128074
  • [5]CVE.org Record: CVE-2026-128074
  • [6]CVE List v5 Record: CVE-2026-128074

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•41 minutes ago•CVE-2026-119790
6.3

CVE-2026-119790: Cross-Request Cache Poisoning and Information Disclosure via Race Condition in Next.js

A race condition in Next.js versions 16.3.0 through 16.4.4 allows cross-request cache poisoning and unauthorized information disclosure across root parameters. When an application invokes the same `'use cache'` function both directly during rendering and wrapped inside `unstable_cache()`, a concurrent `unstable_cache()` request arriving during a cold start cache fill joins the in-flight execution. Because the `unstable_cache()` execution context lacks root parameter tracking, the parameter mismatch verification fails, causing `unstable_cache()` to persist root-parameter-scoped data under a global cache key.

Alon Barad
Alon Barad
1 views•9 min read
•about 3 hours ago•CVE-2026-128075
5.3

CVE-2026-128075: Sensitive Information Disclosure via Unhandled SSR Errors in Nuxt

CVE-2026-128075 (GHSA-96x6-fvhx-49hg) is an information disclosure vulnerability in the Nuxt framework affecting versions 3.0.0 prior to 4.6.4. During Server-Side Rendering (SSR), unhandled non-HTTP exceptions thrown within pages, plugins, or route middleware are automatically wrapped using createError without being flagged as unhandled. Consequently, the production SSR serializer treats these internal exceptions as deliberate public HTTP errors and embeds their raw message and data properties—which frequently contain internal URLs, API credentials, and upstream response payloads—directly into the client-accessible __NUXT_DATA__ hydration state and JSON error responses.

Alon Barad
Alon Barad
4 views•10 min read
•about 4 hours ago•CVE-2026-128076
3.1

CVE-2026-128076: Delimiter Injection and Island Prop Hash Collision in Nuxt

CVE-2026-128076 is an improper encoding and delimiter injection vulnerability in the Nuxt framework affecting Server Components (NuxtIsland). The flaw serves as an incomplete fix for CVE-2026-46342, where the underlying object hashing routine fails to escape structural delimiters in property keys and string values. This enables attackers to craft distinct sets of component properties that resolve to an identical `/__nuxt_island/<Name>_<hash>.json` route path. In deployments relying on static prerendering or path-only CDN caching, this hash collision permits cache poisoning, content substitution, and Cross-Site Scripting (XSS) if island props flow into unescaped HTML sinks.

Amit Schendel
Amit Schendel
4 views•13 min read
•about 5 hours ago•CVE-2026-128072
3.1

CVE-2026-128072: DNS Rebinding and Origin Validation Error in Nuxt Webpack and Rspack Development Builders

CVE-2026-128072 (GHSA-x2wv-5868-p7v2) is an origin validation vulnerability (CWE-346) in the Nuxt framework affecting the development middleware of @nuxt/webpack-builder and @nuxt/rspack-builder. Prior to version 4.6.4, the internal same-origin verification logic evaluated Sec-Fetch-Site, Origin, and Referer headers without first validating that the HTTP Host header belonged to an authorized hostname allowlist. This flaw allows a remote attacker to execute a DNS rebinding attack against a developer's local workstation, bypassing same-origin protections to read compiled client-side JavaScript chunks, inline source maps, local filesystem paths, and embedded client configuration values.

Amit Schendel
Amit Schendel
4 views•13 min read
•2 days ago•CVE-2026-128087
3.7

CVE-2026-128087: Premature Key Exchange Callback Invocation Prior to Host Key Verification in russh

CVE-2026-128087 (GHSA-9264-jvgf-6w2f) is an incorrect behavior order (CWE-696) and improper authorization (CWE-863) vulnerability in the russh Rust SSH library, affecting versions 0.55.0 through 0.65.0. During the initial SSH key exchange (KEX) handshake, the client state machine invokes the client::Handler::kex_done() callback—providing the negotiated raw shared secret bytes—prior to validating the remote server's host key or certificate via check_server_key(). Consequently, an untrusted or rogue SSH server can complete cryptographic key agreement and force a connecting client to execute side-effecting application logic inside kex_done() before the server's identity is checked and rejected.

Amit Schendel
Amit Schendel
9 views•10 min read
•2 days ago•CVE-2026-128082
7.5

CVE-2026-128082: Uncontrolled Recursion and Denial of Service in AutoMapper via Constructor Parameter Mapping

CVE-2026-128082 (GHSA-6vhm-j9h7-f9gh) is an uncontrolled recursion vulnerability (CWE-674) in AutoMapper, a convention-based object-object mapper for .NET. When mapping nested or self-referential types into destination models that rely on parameterized constructors, C# positional records, or recursive ConstructUsing expressions, AutoMapper evaluates child constructor arguments prior to incrementing the parent's recursion depth counter. This ordering flaw bypasses both explicit MaxDepth limits and the default depth limit of 64. An unauthenticated remote attacker can supply deeply nested input payloads to affected endpoints, exhausting the thread call stack and triggering an uncatchable System.StackOverflowException that terminates the hosting .NET process.

Amit Schendel
Amit Schendel
9 views•11 min read