Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify Nuxt 4.x application with cached authenticated route
-
DeliveryConfirm /_payload.json endpoint exists for target page
-
ExploitWait for legitimate authenticated user to warm the runtime payload cache
-
ExecutionSend unauthenticated GET /<page>/_payload.json
-
PersistReceive prior user's full SSR payload JSON
-
ImpactExtract sensitive data (profile, tokens, billing)
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V3 - Web Frontend Security Cache-Control for sensitive pages
|
| Exploitation Conditions | All three conditions must be simultaneously true for exploitation: (1) The application runs nuxt 4.4.0-4.5.0 - Nuxt 3.x and v5 are not vulnerable. (2) At least one page is covered by a |
| Impact | The NVD CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N, score 7.5) accurately captures the attacker's perspective: a single unauthenticated GET request to a known path with no authentication or interaction yields high-confidentiality-impact data. The practical attack complexity is genuinely low for any live application - the cache-warming prerequisite (an authenticated user must have visited the page since last cache expiry) is a passive condition that is almost always already met in production. No EPSS score or CISA KEV listing was provided in the available data, so exploitation probability and confirmed active exploitation cannot be quantified from this dataset. No public exploit code has been identified; however, the patch commit adds a fully functional regression test fixture that demonstrates the exact exploitation path, meaning a working proof-of-concept can be trivially constructed from the advisory alone. Risk is materially elevated for Nuxt 4.x deployments that use routeRules caching on authenticated pages with user-specific SSR data; applications without such a configuration are not affected regardless of upgrade status. |
| Exploit ScenarioDerived | An attacker targets a Nuxt 4.4.x-4.5.0 application where |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 05, 2026
Cross-user SSR payload disclosure in Nuxt 4.x allows unauthenticated network attackers to retrieve another authenticated user's full server-side rendered data by fetching /<page>/_payload.json after any authenticated user has warmed a cached route. The runtime cache:nuxt:payload storage introduced in nuxt 4.4.0 keyed payloads by URL path alone - omitting cookie, authorization header, or cache.varies dimensions - causing the renderer to serve one user's SSR data (including useFetch/useAsyncData results such as profile, tenant, billing, and token-like values) to any subsequent requester. No public exploit identified at time of analysis; vendor-released patch is available as nuxt@4.5.1.
RemediationAI
Vendor-released patch: nuxt@4.5.1. Upgrading to this version reintroduces the import.meta.prerender gate so that runtime /_payload.json requests always follow the full render path, re-evaluating route middleware, routeRules.appMiddleware, and page guards per request. After upgrading, purge any CDN or platform-level cache that may already hold protected payloads, as stale entries remain exploitable until evicted. If immediate upgrade is not feasible, set experimental.payloadExtraction: false in nuxt.config (reporter-validated): this causes /_payload.json endpoints to return 404 while pages continue serving inline payloads in the HTML response, eliminating the attack surface at the cost of slightly larger HTML responses. A second workaround is to remove cache, swr, or isr routeRules from any page that renders user-specific SSR data. As defense-in-depth, configure the proxy or CDN to require authentication for all requests matching /**/_payload.json - note this does not fix the root cause but limits external exposure without application changes. Release notes and patch commit are at https://github.com/nuxt/nuxt/releases/tag/v4.5.1 and https://github.com/nuxt/nuxt/commit/ac9b41a36b62296a117862254ee7d2b21a2a5203.
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
CWE-524 (Use of Cache Containing Sensitive Information) describes the root cause precisely: sensitive SSR payloads were persisted in a shared in-process store (cache:nuxt:payload) indexed by request path only, with no user-identity dimension in the cache key. The feature was introduced in Nuxt 4.x when runtime payload extraction for routeRules cache/swr/isr was added (#34410). In Nuxt 3.x, payload cache reads and writes were gated behind import.meta.prerender, confining them to static prerendering where per-user variation is not a concern. The 4.x renderer dropped that gate, enabling runtime payload caching. The affected package is pkg:npm/nuxt versions 4.4.0 through 4.5.0. The _payload.json endpoint exists on every page covered by a caching routeRule and is served by Nitro's renderer handler; the HTML response path was unaffected because it was correctly varied - only the detached payload endpoint bypassed auth.
Know when the next one hits your stack
- 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:H/I:N/A:N
Attacker's own request requires no authentication and no user interaction; cache warming by a legitimate user is a passive prerequisite that does not elevate AC; full SSR data exposure yields C:H with no integrity or availability impact.
Primary rating from Vendor (https://github.com/nuxt/nuxt).
CVSS VectorVendor: https://github.com/nuxt/nuxt
DescriptionCVE.org
Impact
When a page is covered by routeRules cache / swr / isr, Nuxt enables runtime payload extraction and serves /<page>/_payload.json. On affected versions the renderer stored the SSR payload in the shared cache:nuxt:payload storage under a path-only key (no cookie, authorization, or cache.varies dimension) and, on a later payload request, returned the cached entry before route middleware / page guards ran again.
As a result, once any authenticated user warms a protected, cached page, a subsequent GET /<page>/_payload.json from an unauthenticated client or a different authenticated user receives the first user's payload: the full SSR data for that route, including anything loaded via useFetch / useAsyncData (for example /api/me: profile, tenant, billing, token-like values). The HTML response stays correctly varied and protected; only the extracted payload leaks. Both cross-user (A warms, B receives A) and unauthenticated disclosure are exploitable. cache.varies does not mitigate it, because the payload cache ignores varies.
Introduced when runtime payload extraction landed for cached routes (#34410); the regression is specific to the 4.x line, where the runtime cache:nuxt:payload storage was added and the import.meta.prerender gate on the payload-cache read/writes was dropped. The 3.x line shipped the same feature with the gate intact and is not affected.
Patches
Fixed in nuxt@4.5.1. Runtime payload-cache reads and writes are again confined to prerendering (import.meta.prerender); at runtime, /<page>/_payload.json follows the normal render path so route middleware, routeRules.appMiddleware, and page guards run for the current request. main / v5 and the 3.x line already had this property, so 3.x is not affected.
Workarounds
- Set
experimental.payloadExtraction: false(reporter-validated): the standalone/_payload.jsonendpoint returns 404 and the page still serves a 200 with an inline payload. - Do not apply
cache/swr/isrto authenticated pages that render user-specific SSR data. - As defense-in-depth, require authentication for
/**/_payload.jsonat a proxy / CDN. - After upgrading, purge any CDN / platform cache that may already hold protected payloads.
Executive ViewAI
Nuxt versions 4.0 through 4.5.0 contain a cross-user data disclosure vulnerability permitting unauthenticated attackers to retrieve cached server-rendered data belonging to other users, including profiles, billing information, and sensitive tokens. Organizations operating Nuxt 4.x applications face immediate risk of customer data exposure and potential regulatory violations.
Apply vendor patch.
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.
EUVD-2026-53646
GHSA-wm8w-6qjm-cv43
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB