Skip to main content

Nuxt EUVDEUVD-2026-53646

| CVE-2026-71316 HIGH
Use of Cache Containing Sensitive Information (CWE-524)
2026-08-05 https://github.com/nuxt/nuxt GHSA-wm8w-6qjm-cv43
7.5
CVSS 3.1 · Vendor: https://github.com/nuxt/nuxt
View

Attack ChainAIDerived

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

  1. Access
    Identify Nuxt 4.x application with cached authenticated route
  2. Delivery
    Confirm /_payload.json endpoint exists for target page
  3. Exploit
    Wait for legitimate authenticated user to warm the runtime payload cache
  4. Execution
    Send unauthenticated GET /<page>/_payload.json
  5. Persist
    Receive prior user's full SSR payload JSON
  6. Impact
    Extract 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 routeRules directive specifying cache, swr, or isr - pages without these rules never populate the payload cache and are not affected. (3) Those cached pages render user-specific SSR data via useFetch or useAsyncData. Additionally, the cache must have been warmed by at least one authenticated user since the last expiry - this is a passive prerequisite that is naturally met in any active production application. The cache.varies configuration does NOT limit exploitation because the payload cache explicitly ignores the varies dimension. The HTML response path is not affected; only requests to the detached /_payload.json endpoint are vulnerable. Cross-user leakage (user A's data to user B) and unauthenticated disclosure are both independently exploitable attack modes.

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 /dashboard is a routeRules-cached page that calls useFetch('/api/me') to load profile and billing data. After any authenticated user navigates to /dashboard, the attacker - with no session or credentials - sends GET /dashboard/_payload.json and immediately receives the first user's full SSR payload, including their name, email, tenant ID, billing tier, and any bearer tokens surfaced by the API. No special tooling is required beyond a standard HTTP client; the response is a plaintext JSON object.

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

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

Alert me

AnalysisAIv1 – 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

nuxt 4.4.0, < 4.5.1

Affected Packages

npm nuxt fix: 4.5.1

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

Vendor (https://github.com/nuxt/nuxt) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
vuln.today AI 7.5 HIGH

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N

Primary rating from Vendor (https://github.com/nuxt/nuxt).

CVSS VectorVendor: https://github.com/nuxt/nuxt

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

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.json endpoint returns 404 and the page still serves a 200 with an inline payload.
  • Do not apply cache / swr / isr to authenticated pages that render user-specific SSR data.
  • As defense-in-depth, require authentication for /**/_payload.json at a proxy / CDN.
  • After upgrading, purge any CDN / platform cache that may already hold protected payloads.

Executive ViewAI

Why It Matters

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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.3%
Top 78% exploitable
Prevalence
Medium
popular Vue.js full-stack meta-framework, growing enterprise adoption
Threat Intel
1
1 sources
Social Media
1
Sightings
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA CIRCL GitHub VulDB

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 No
EPSS 0.3%
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
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

38
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy