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-128071

CVE-2026-128071: Route-Rule Authorization Bypass via Encoded Slashes in Nuxt

Amit Schendel
Amit Schendel
Senior Security Researcher

Nov 16, 2026·11 min read·2 visits

Executive Summary (TL;DR)

An interpretation conflict between Nuxt's route-rule matcher and catch-all page routing allows unauthenticated attackers to bypass path-based security rules (`routeRules`) by substituting literal forward slashes (`/`) with URL-encoded slashes (`%2F`) in HTTP request paths. Upgrading to Nuxt 4.6.4 resolves the issue.

CVE-2026-128071 is a route-rule authorization bypass and security policy circumvention vulnerability in the Nuxt web framework, affecting `nuxt`, `@nuxt/nitro-server`, and `@nuxt/vite-server` prior to version 4.6.4. Serving as an incomplete fix for GHSA-6gq8-jgmh-3ffp, the flaw arises from an interpretation conflict between Nuxt's route-rule matching logic and Vue Router's catch-all route parameter decoding. When processing an incoming HTTP request containing percent-encoded forward slashes (`%2F` or `%2f`), the route-rule evaluation engine preserves the encoded sequence as a single path segment, failing to match prefix-based rules such as `/admin/**`. However, when the request is subsequently dispatched to a catch-all page route (`app/pages/[...slug].vue`) or a multi-segment parameter handler, the parameters are URL-decoded into literal slash delimiters. This discrepancy allows unauthenticated remote attackers to bypass route-level redirects, authentication middleware (`appMiddleware`), security headers, proxy configurations, and rendering constraints (`ssr: false`, `noScripts`), while the catch-all page resolves and renders the protected resource.

Vulnerability Overview

Nuxt is an open-source full-stack web framework built on Vue.js and the Nitro server engine. A core feature of Nuxt 3 and Nuxt 4 is the routeRules configuration in nuxt.config.ts, which allows developers to define path-specific routing behaviors, server-side redirects, custom HTTP security headers, reverse proxy rules, rendering modes (ssr, noScripts), and application-level middleware (appMiddleware). These rules are evaluated at runtime by both the server engine (@nuxt/nitro-server and @nuxt/vite-server) and the client-side router to enforce access controls and security postures across route hierarchies.

CVE-2026-128071 (tracked also as GitHub Security Advisory GHSA-f3x9-2chm-73c8) is an interpretation conflict (CWE-436) and incorrect authorization vulnerability (CWE-863) affecting nuxt versions >= 3.0.0 to < 4.6.4, @nuxt/nitro-server versions >= 3.20.0, < 4.0.0 and >= 4.2.0, < 4.6.4, and @nuxt/vite-server versions >= 4.6.0 to < 4.6.4. The vulnerability stems from an incomplete remediation of an earlier path normalization flaw (GHSA-6gq8-jgmh-3ffp). Specifically, the internal route-rule matching engine leaves percent-encoded forward slashes (%2F and %2f) intact when evaluating incoming request paths, whereas catch-all page routes decode those sequences into standard path parameters.

Because of this parsing discrepancy, an unauthenticated remote attacker can craft HTTP requests containing %2F in place of standard / delimiters to evade prefix-based routeRules. When the request bypasses the route-rule matcher, Nuxt fails to apply configured redirects, authentication middleware, or security headers. Once the request reaches a catch-all page component (such as app/pages/[...slug].vue) or a custom multi-segment route, the decoded parameters are used to look up and render the underlying content, exposing restricted resources.

The scope of this vulnerability is specific to applications that combine path-based routeRules with catch-all or multi-segment dynamic page routes that resolve content from decoded route parameters. Static page routes (e.g., app/pages/admin/index.vue), single-segment dynamic routes (e.g., app/pages/users/[id].vue), and Nitro server handlers (server/api/* and server/routes/*) are not affected because they do not exhibit the same parameter decoding mismatch.

Root Cause Analysis

The root cause of CVE-2026-128071 lies in how Nuxt normalizes URL paths prior to querying its internal radix tree matcher (radix3 / rou3) versus how Vue Router extracts parameters for catch-all routes. In Nuxt, route rules defined in nuxt.config.ts are compiled into a route matcher table. When an HTTP request arrives, the runtime invokes getRouteRules() or resolveRouteRules(), which passes the request path through normalizeRouteRulePath(path) before querying the matcher.

Prior to version 4.6.4, normalizeRouteRulePath() decoded unreserved characters and dot segments (%2e / %2E to prevent path traversal via encoded dots) and applied case-folding when case-insensitive routing was enabled. However, it intentionally preserved percent-encoded reserved delimiters, most notably %2F and %2f. This design decision was originally intended to prevent ambiguity between structural path separators and encoded data within single-segment route parameters.

While preserving %2F is safe for static routes and single-segment parameters, it breaks down when a request falls through to a catch-all page route (app/pages/[...slug].vue) or a custom route with a multi-segment parameter (:path(.*)). During page routing, the router extracts the path segments and runs URL decoding on the captured parameter values. For a custom multi-segment parameter, the decoded string directly contains admin/secret. For a repeatable catch-all array parameter where developers join segments (route.params.slug.join('/')), the resulting string also resolves to admin/secret.

Consequently, a request to /admin%2Fsecret is evaluated by the route-rule engine as a single top-level segment named admin%2Fsecret. It fails to traverse the /admin/ branch in the radix tree and misses any rules attached to /admin/** or /admin/secret. Yet, when the request is handed off to the page component, the decoded parameter matches the exact identifier of the protected resource, completely bypassing the security controls defined in routeRules.

Code Analysis

The vulnerability was remediated in commit 084396b101e3b4d3545e86ff80dc313496bc87c0 by introducing dual-path evaluation for requests containing encoded slashes. Rather than unconditionally decoding %2F inside normalizeRouteRulePath()—which would break legitimate single-segment rules expecting encoded slashes to remain within a single segment—the patch introduces a dedicated helper function named matchAllRouteRules() in packages/nuxt/src/core/utils/index.ts.

/**
 * Collect the route rules `match` returns for a route path and, if its path portion contains
 * an encoded slash (`%2F`), for the path with each encoded slash as a separator, since a page
 * route param spanning several segments decodes to the same value either way. Rules keep the
 * order `match` returns them in, and rules matched only through encoded slashes come last.
 *
 * Inlined by source into compiled matchers, so it must not reference anything outside itself.
 *
 * @internal
 */
export function matchAllRouteRules<T> (match: (path: string) => T[], path: string): T[] {
  // 1. Evaluate route rules against the original path (preserving %2F)
  const matches = match(path)
  if (typeof path !== 'string') { return matches }
  
  // 2. Replace all %2f / %2F occurrences in the pathname portion (excluding query string) with '/'
  const split = path.replace(/^[^?]*/, pathname => pathname.replace(/%2f/gi, '/'))
  if (split === path) { return matches }
  
  // 3. Evaluate route rules against the decoded-slash path and append unique matches
  for (const rules of match(split)) {
    if (!matches.includes(rules)) { matches.push(rules) }
  }
  return matches
}

The matchAllRouteRules function wraps the underlying matcher callback across all runtime and build-time route-rule resolvers, including packages/nitro-server/src/runtime/utils/route-rules.ts, packages/nuxt/src/core/utils/route-rules.ts, and the generated client/server templates in packages/nuxt/src/core/templates.ts.

--- a/packages/nitro-server/src/runtime/utils/route-rules.ts
+++ b/packages/nitro-server/src/runtime/utils/route-rules.ts
@@ -6,7 +6,7 @@ import { createRouter, toRouteMatcher } from 'radix3'
 import type { RouteMatcher } from 'radix3'
 import { withoutBase } from 'ufo'
 
-import { normalizeRouteRulePath } from '#internal/nuxt/route-rules.mjs'
+import { matchAllRouteRules, normalizeRouteRulePath } from '#internal/nuxt/route-rules.mjs'
 
 let matcher: RouteMatcher | undefined
 
@@ -26,7 +26,7 @@ function getMatcher (): RouteMatcher {
  * and case-folded unless routing is `sensitive`.
  */
 export function matchRouteRules (path: string): NitroRouteRules {
-  return defu({}, ...getMatcher().matchAll(normalizeRouteRulePath(path)).reverse()) as NitroRouteRules
+  return defu({}, ...matchAllRouteRules(path => getMatcher().matchAll(normalizeRouteRulePath(path)), path).reverse()) as NitroRouteRules
 }

When matchRouteRules(path) is called, matchAllRouteRules first collects all matching rule objects for the normalized path with %2F intact. Next, it strips the query string via /^[^?]*/ and replaces all case-insensitive %2f sequences in the pathname with literal / characters. If the modified split path differs from the original path, the matcher runs a second time on split (which again passes through normalizeRouteRulePath(split), resolving any newly exposed dot segments like /x/..%2Fadmin%2Fy into /admin/y).

Any rules matched during this second pass that were not already present in the matches array are appended to the end of the list. Because the caller subsequently reverses the array and merges the configurations using defu({}, ...matches.reverse()), rules matched via the decoded slash path take precedence over generic root rules (/**). This ensures that security restrictions on specific subpaths (such as /admin/**) are strictly applied even when accessed via %2F.

Exploitation

Exploiting CVE-2026-128071 requires no authentication or specialized tooling; an attacker only needs network access to a vulnerable Nuxt application that utilizes routeRules to protect paths served by a catch-all or multi-segment page component. Consider a Nuxt application that uses a catch-all route (app/pages/[...slug].vue) to render documents fetched from an internal content management system or database, while protecting administrative documents via nuxt.config.ts:

// nuxt.config.ts
export default defineNuxtConfig({
  routeRules: {
    '/admin/**': {
      appMiddleware: ['require-auth'],
      redirect: { to: '/login', statusCode: 307 },
      headers: { 'X-Robots-Tag': 'noindex', 'Cache-Control': 'no-store' }
    },
    '/content/admin/secret': {
      appMiddleware: ['require-admin']
    }
  }
})

Suppose the catch-all page component app/pages/[...slug].vue resolves the requested document path by joining the slug parameter array:

<script setup lang="ts">
const route = useRoute()
const slugArray = Array.isArray(route.params.slug) ? route.params.slug : [route.params.slug]
const documentPath = slugArray.join('/')
 
// Fetches '/admin/dashboard' or '/content/admin/secret' when '%2F' is decoded into the param
const { data: doc } = await useFetch(`/api/documents`, {
  query: { path: documentPath }
})
</script>

Under normal conditions, an unauthenticated request to GET /admin/dashboard matches the /admin/** route rule. The Nitro server immediately intercepts the request and returns a 307 Temporary Redirect to /login, or executes the require-auth middleware during SSR before the page component is rendered.

To bypass these controls, an attacker substitutes the slash delimiter following the protected prefix with %2F or %2f, or chains encoded path traversal sequences that only become active once %2F is treated as a separator:

GET /admin%2Fdashboard HTTP/1.1
Host: vulnerable-nuxt-app.example.com
GET /content/admin%2Fsecret HTTP/1.1
Host: vulnerable-nuxt-app.example.com
GET /public/..%2Fadmin%2Fdashboard HTTP/1.1
Host: vulnerable-nuxt-app.example.com

In all three cases on versions prior to 4.6.4, the route-rule matcher fails to match /admin/** or /content/admin/secret. No redirect is issued, the require-auth and require-admin middlewares are omitted from the execution pipeline, and the Cache-Control: no-store header is not set. The request proceeds to app/pages/[...slug].vue, where route.params.slug contains the decoded slash (['admin/dashboard']), resulting in documentPath evaluating to 'admin/dashboard' and exposing the restricted content.

Impact Assessment

The severity of CVE-2026-128071 is rated as Medium with a CVSS v3.1 base score of 6.5 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N). The vulnerability is remotely exploitable over the network without authentication or user interaction (AV:N/AC:L/PR:N/UI:N). The primary impacts are unauthorized access to restricted application pages (Confidentiality: Low) and the circumvention of security policies and rendering constraints (Integrity: Low).

Specifically, any of the following routeRules properties configured on a path prefix or multi-segment path can be bypassed when the underlying page is served by a catch-all or multi-segment dynamic route:

  • Access Control & Redirection (appMiddleware, redirect): Route-level authentication guards and mandatory redirects (e.g., redirecting unauthenticated users or deprecated endpoints) are skipped.
  • Security Headers (headers, cors, csurf): Custom HTTP response headers such as Content-Security-Policy, X-Frame-Options, Strict-Transport-Security, and Cache-Control defined via routeRules are not applied to the response.
  • Rendering & Execution Policies (ssr, noScripts, appLayout): Rules that disable server-side rendering (ssr: false) for sensitive client-only views or strip scripts (noScripts: true) can be bypassed, altering how the page is rendered on the server.
  • Request Proxying (proxy): Path-based proxy rules configured in routeRules will fail to trigger if the request falls through to a local catch-all page instead.

> [!NOTE] > Impact is strictly bounded by how the target application's page components consume route parameters. Notice that route.path inside Vue Router remains encoded (/admin%2Fdashboard), whereas route.params contains the decoded value (admin/dashboard). Applications that rely exclusively on static file-based routing, single-segment parameters, or route.path for resource lookups are not impacted.

Remediation & Mitigation

The definitive remediation for CVE-2026-128071 is to upgrade nuxt, @nuxt/nitro-server, and @nuxt/vite-server to version 4.6.4 or later. Version 4.6.4 incorporates commit 084396b101e3b4d3545e86ff80dc313496bc87c0, which ensures that matchAllRouteRules evaluates both the raw normalized path and the slash-decoded pathname, preventing any discrepancy between route-rule resolution and catch-all parameter decoding.

# Upgrade Nuxt using npm
npm install nuxt@^4.6.4
 
# Upgrade Nuxt using pnpm
pnpm update nuxt@^4.6.4
 
# Upgrade Nuxt using yarn
yarn upgrade nuxt@^4.6.4

After updating package.json, inspect your package lockfile (package-lock.json, pnpm-lock.yaml, or yarn.lock) to verify that transitive dependencies @nuxt/nitro-server and @nuxt/vite-server have also resolved to 4.6.4 or higher. If older versions remain pinned in the lockfile, run npx nuxi upgrade --force or refresh the lockfile.

For environments where an immediate framework upgrade is not feasible, security teams can deploy defense-in-depth mitigations at the reverse proxy / Web Application Firewall (WAF) layer and within application code:

  1. Reject Encoded Slashes at the Edge: Configure upstream reverse proxies (NGINX, Envoy, HAProxy) or WAFs (Cloudflare, AWS WAF) to block or reject incoming HTTP requests containing %2F or %2f within the URI path portion ($request_uri prior to query string).
  2. Enforce Component-Level Middleware: Do not rely exclusively on path-based routeRules in nuxt.config.ts to protect catch-all routes. Instead, attach authentication middleware directly to the catch-all page component using definePageMeta({ middleware: ['auth'] }) or validate the decoded route.params inside a global route middleware.
  3. Validate Parameter Segments: In [...slug].vue pages, validate that individual elements of route.params.slug do not contain literal / characters (which indicate that a %2F sequence was decoded into a single segment element).

Official Patches

NuxtOfficial Git commit patching route rule matching for paths with encoded slashes
NuxtNuxt v4.6.4 release notes and distribution tag
GitHub Security AdvisoryOfficial GitHub Security Advisory GHSA-f3x9-2chm-73c8

Fix Analysis (1)

Technical Appendix

CVSS Score
6.5/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N
EPSS Probability
0.27%
Top 81% most exploited

Affected Systems

nuxt@nuxt/nitro-server@nuxt/vite-server

Affected Versions Detail

Product
Affected Versions
Fixed Version
nuxt
nuxt
>= 3.0.0, < 4.6.44.6.4
@nuxt/nitro-server
nuxt
>= 3.20.0, < 4.0.0 and >= 4.2.0, < 4.6.44.6.4
@nuxt/vite-server
nuxt
>= 4.6.0, < 4.6.44.6.4
AttributeDetail
Vulnerability IDCVE-2026-128071 / GHSA-f3x9-2chm-73c8
Weakness ClassCWE-436 (Interpretation Conflict) / CWE-863 (Incorrect Authorization)
Attack VectorNetwork (HTTP/HTTPS request with %2F in URL path)
CVSS v3.1 Score6.5 Medium (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N)
EPSS Score0.27% (19.12th Percentile)
Security ImpactBypass of routeRules (redirects, appMiddleware, headers, SSR/noScripts rules) on catch-all routes
Exploit StatusProof-of-Concept in upstream unit tests
Patched VersionNuxt 4.6.4

MITRE ATT&CK Mapping

T1068Exploitation for Privilege Escalation
Privilege Escalation
CWE-436
Interpretation Conflict

The product receives input from an upstream component or passes input to a downstream component, but the two components interpret the input differently, resulting in an inconsistent security state that allows route-rule authorization and policy checks to be bypassed.

Known Exploits & Detection

GitHubOfficial upstream fix commit containing Vitest unit test cases demonstrating route-rule bypass payloads using %2F and ..%2F sequences.

Vulnerability Timeline

Fix authored and committed to the Nuxt repository (084396b101e3b4d3545e86ff80dc313496bc87c0)
2026-10-27
GitHub Security Advisory GHSA-f3x9-2chm-73c8 and CVE-2026-128071 published alongside Nuxt v4.6.4 release
2026-11-13
Advisory metadata updated across NVD and OSV databases
2026-11-15
EPSS score initialized at 0.00268 (19.12th percentile)
2026-11-16

References & Sources

  • [1]GitHub Security Advisory GHSA-f3x9-2chm-73c8
  • [2]Nuxt Patch Commit 084396b101e3b4d3545e86ff80dc313496bc87c0
  • [3]Nuxt v4.6.4 Release Notes
  • [4]NVD - CVE-2026-128071
  • [5]CVE.org Record - CVE-2026-128071
  • [6]CVEListV5 JSON Record - CVE-2026-128071
  • [7]Wiz Vulnerability Database - CVE-2026-128071

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

•20 minutes ago•CVE-2026-128118
7.5

CVE-2026-128118: Server-Only Module Guard Bypass and Secret Exposure in SvelteKit

CVE-2026-128118 (GHSA-m9j8-jcmv-hp69) is an information disclosure vulnerability affecting the SvelteKit framework (@sveltejs/kit) from version 3.0.0 through 3.1.0. A design flaw in the build-time Vite module guard plugin (plugin_guard) failed to register src/params.js as a client entry point and implemented a fail-open validation model. Consequently, server-only modules and private environment variables imported directly or dynamically within parameter matchers were compiled into publicly accessible client-side JavaScript bundles without triggering a build error.

Amit Schendel
Amit Schendel
0 views•10 min read
•about 2 hours ago•CVE-2026-128134
7.8

CVE-2026-128134: Local Code Execution via Untrusted Search Path in NLTK dependencygraph

In Natural Language Toolkit (NLTK) versions prior to 3.10.4, the nltk.parse.dependencygraph.dot2img function resolves the Graphviz dot binary through the system PATH using find_binary('dot') and invokes it directly via subprocess.run() instead of routing execution through nltk.pathsec.spawn_trusted(). This omission bypasses file ownership validation, directory writability checks, and dynamic loader environment scrubbing. On multi-user POSIX systems where a victim's PATH contains a directory writable by a local low-privileged attacker, the attacker can plant a malicious dot binary that executes under the victim's privileges when dependency graphs are rendered.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 3 hours 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
5 views•9 min read
•about 4 hours ago•CVE-2026-128074
6.9

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

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.

Alon Barad
Alon Barad
4 views•11 min read
•about 5 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
5 views•10 min read
•about 6 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