Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify gated Nuxt route (routeRules/appMiddleware)
-
DeliveryCraft percent-encoded path variant
-
ExploitRoute-rule key mismatch skips rule
-
ExecutionappMiddleware bypassed during SSR
-
ImpactReceive protected page and SSR data
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V4 - API and Web Service Interpretation consistency
|
| Exploitation Conditions | Exploitation requires the target Nuxt application to gate pages using routeRules and/or appMiddleware on routes that contain dynamic or catch-all parameters, and the attacker must request a percent-encoded form of the protected path so the route-rule key (compared against the raw path) fails to match while route resolution decodes the parameter to the protected page. It applies to server-side rendering and the app-manifest rules (redirect, appLayout, ssr, prerender, and cache/isr/swr-derived payload flags). Affected versions are Nuxt 3.11.0 through 3.21.4 and 4.4.4; apps on patched releases, apps not using route-level gating, or routes without dynamic/catch-all parameters are not exposed. No end-user interaction or attacker authentication is required, but the vulnerability is inert without the specific gating configuration. |
| Impact | This is a genuine but moderate-priority authorization-bypass/information-disclosure flaw rather than a critical issue. The CVSS vector (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N, base 6.5) indicates remote, low-complexity, unauthenticated exploitation with no user interaction - attractive signals for an attacker. However, exploitability is heavily conditioned on the victim application: it only matters when the app relies on Nuxt routeRules/appMiddleware to gate pages that use dynamic or catch-all route parameters, so real-world impact depends on deployment choices, not default behavior. No EPSS score, KEV listing, or public POC was supplied in the input, so there is no evidence of active exploitation or automated weaponization at this time: exploitation status is 'no public exploit identified at time of analysis.' CWE-436 (interpretation conflict) is consistent with the described parser/matcher mismatch between the raw request path and the decoded route parameters. The impact rating is CONFIRMED by the description as confidentiality-biased (gated page plus SSR data disclosure) with some integrity effect via altered app-manifest rules (redirect, appLayout, ssr, prerender, cache/isr/swr payload flags); availability is unaffected. Net: a real but configuration-dependent priority - patch promptly on Nuxt apps that use route-level gating, lower urgency otherwise. |
| Exploit ScenarioDerived | An unauthenticated attacker targets a Nuxt app that protects certain SSR pages via appMiddleware/routeRules on dynamic or catch-all routes. By requesting a percent-encoded variant of the protected path (e.g. encoding a path segment), the route-rule key comparison misses the intended rule while route resolution still decodes the parameter to the protected page, so the server renders and returns the gated page and its SSR data. No public exploit was provided in the input, but the technique is simple to reproduce by hand once the gated path is known. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Broken access control in Nuxt (3.11.0 through 3.21.4 and 4.4.4) lets unauthenticated remote attackers retrieve pages that routeRules and appMiddleware are meant to gate, by requesting a percent-encoded form of a protected path that contains a dynamic or catch-all parameter. Route-rule keys are compared against the raw request path, while Vue Router decodes the parameter during route resolution, so the gating rule never matches and the page plus its SSR data payload is returned to the requester; the same mismatch also breaks redirect, appLayout, ssr, prerender and cache/isr/swr-derived payload rules in the app manifest. CVSS 3.1 is 6.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N) - moderate, limited confidentiality and integrity impact - and no public exploit code or confirmed active exploitation was identified at time of analysis; exposure is limited to applications that actually gate dynamic/catch-all routes via route-level rules.
RemediationAI
Vendor-released patch: upgrade to the fixed Nuxt release - the advisory GHSA-6gq8-jgmh-3ffp (https://github.com/nuxt/nuxt/security/advisories/GHSA-6gq8-jgmh-3ffp) states fixes in 3.21.4 and 4.4.4, while the linked release tags are v3.21.11 (https://github.com/nuxt/nuxt/releases/tag/v3.21.11) and v4.5.2 (https://github.com/nuxt/nuxt/releases/tag/v4.5.2); verify the exact patched version against the advisory, and note the fix is carried by commits 81f86ac5ee82bb1a9b887e59f3bc84624d711497 (route-rule path normalization) and 9123ed850c468a7424a868c20d0d49a5507d32e5. Until upgraded, do not rely on routeRules or appMiddleware as an authorization boundary for dynamic/catch-all routes: move gating into a Nitro server middleware or server route hook that runs before rendering and evaluates the decoded pathname (decode the path segment with decodeURI/decodeURIComponent, then compare against the allow/deny list), which is effective but adds per-request overhead and must be maintained alongside route config. As a compensating control, reject or normalize requests whose path contains percent-encoded segments for gated prefixes at the reverse proxy or WAF (for example, block %-encoded octets under /admin and /api), trading off legitimate encoded or non-ASCII URLs that clients may send. Also review reliance on route-rule-driven redirect, ssr, prerender and cache/isr/swr flags for anything security-sensitive, since all of them share this mismatch; caching rules in particular may serve gated SSR payloads to unauthenticated clients. No vendor patch alternatives or complete workarounds beyond path normalization are documented at time of analysis.
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 root cause is CWE-436 (Interpretation Conflict): two layers of the Nuxt stack interpret the same request path differently. At build time Nuxt compiles routeRules keys into matcher functions that were evaluated against the verbatim, still percent-encoded request URL, and at runtime the app-manifest lookup (redirect, appLayout, ssr, prerender, and payload flags derived from cache, isr and swr) used the same raw string. Vue Router, however, decodes dynamic (:param) and catch-all (:param(.*)*) segments before resolving the route, so /%70rotected resolves to /protected and renders the gated page with server-side data while the rule authored for /protected fails to fire. The upstream fix (commits 81f86ac5ee82bb1a9b887e59f3bc84624d711497 and 9123ed850c468a7424a868c20d0d49a5507d32e5) adds a shared normalizeRouteRulePath helper and an inlined decodeRoutePath function so keys and lookup paths are both decoded before matching; decoding deliberately precedes case folding (otherwise percent-encoded non-ASCII characters would never fold), reserved characters such as %2F and %3F are left encoded so decoding cannot introduce extra path segments, and only the pathname is decoded so the query string is not double-decoded. The supplied CPE (cpe:2.3:a:nuxt:nuxt:*:*:*:*:*:*:*:*) is a wildcard version range and does not by itself distinguish vulnerable from patched builds.
Know when Nuxt 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
AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N
Remote unauthenticated request with a crafted encoded path (AV:N/AC:L/PR:N/UI:N); discloses gated page/SSR data (C:L) and alters manifest routing rules (I:L); no availability impact.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Nuxt is an open-source web development framework for Vue.js. From 3.11.0 until 3.21.4 and 4.4.4, Nuxt compares route-rule keys with the raw request path while route resolution decodes dynamic and catch-all parameters, allowing a percent-encoded segment to resolve to a protected page without matching the routeRules entry intended for that path. As a result, appMiddleware can be skipped during server rendering and an unauthenticated requester can receive the gated page and its SSR data. The same mismatch affects app-manifest rules including redirect, appLayout, ssr, prerender, and payload flags derived from cache, isr, and swr. This vulnerability is fixed in 4.4.4 and 3.21.4.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Code Injection in GitHub repository nuxt/nuxt prior to 3.5.3. Rated critical severity (CVSS 9.8), this vulnerability is
Nuxt is a free and open-source framework to create full-stack web applications and websites with Vue.js. Rated high seve
Nuxt is a free and open-source framework to create full-stack web applications and websites with Vue.js. Rated high seve
Nuxt is a free and open-source framework to create full-stack web applications and websites with Vue.js. Rated high seve
Unauthenticated server-side request forgery in Nuxt OG Image (the npm package nuxt-og-image) 6.0.2 through 6.6.x allows
A vulnerability in Nuxt DevTools has been fixed in version **2.6.4***. Rated medium severity (CVSS 6.9), this vulnerabil
Nuxt is a free and open-source framework to create full-stack web applications and websites with Vue.js. Rated medium se
Cross-site Scripting (XSS) - Generic in GitHub repository nuxt/framework prior to 3.2.1. Rated medium severity (CVSS 6.1
Cross-site Scripting (XSS) - Reflected in GitHub repository nuxt/framework prior to v3.0.0-rc.13. Rated medium severity
Use of Hard-coded Credentials in GitHub repository nuxtlabs/github-module prior to 1.6.2. Rated critical severity (CVSS
Authentication/authorization bypass in Clerk's official JavaScript SDKs (@clerk/nextjs, @clerk/nuxt, @clerk/astro, and t
Route-rule middleware bypass in Nuxt 3.11.0-3.21.6 and 4.0.0-4.4.6 allows remote attackers to evade routeRules-defined p
EUVD-2026-107414
GHSA-6gq8-jgmh-3ffp
NVD
CVE.org
EPSS
Exploit-DB