Nov 16, 2026·10 min read·2 visits
Nuxt versions 3.0.0 to 4.6.3 fail to mark auto-wrapped SSR exceptions as unhandled in production, exposing sensitive internal error messages, upstream URLs, and API tokens in the client-side __NUXT_DATA__ payload.
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.
CVE-2026-128075 (also tracked as GHSA-96x6-fvhx-49hg) is an information disclosure vulnerability classified under CWE-209 (Generation of Error Message Containing Sensitive Information) affecting the nuxt npm package from version 3.0.0 up to, but excluding, 4.6.4. Nuxt is an open-source full-stack web application framework built on Vue.js and the Nitro server engine that supports universal Server-Side Rendering (SSR).
During the SSR execution lifecycle, Nuxt evaluates Vue component setup functions, application plugins, and route middleware on the server prior to returning HTML to the client. When an exception occurs during this rendering phase, Nuxt intercepts the error, transitions to the error handling pipeline, renders the configured error layout (such as a custom error.vue component), and serializes the application state into a <script id="__NUXT_DATA__" type="application/json"> payload embedded in the HTML document for client-side hydration.
In vulnerable versions of Nuxt, unhandled non-HTTP exceptions thrown during SSR—such as failed $fetch requests to internal microservices or rejected database queries—are automatically wrapped via the createError utility without setting the unhandled: true flag on the resulting error object. Because Nuxt and the underlying H3 HTTP framework treat any error lacking unhandled: true as an explicit, developer-intended public error, the production SSR serializer outputs the raw message and data properties directly to the client.
This behavior bypasses visual masking implemented in custom error.vue components. Unauthenticated remote attackers who can trigger an unhandled runtime exception during SSR can inspect the __NUXT_DATA__ script block or request a JSON response to extract sensitive backend data, including internal service hostnames, query-string API keys, and raw upstream response bodies.
The root cause of CVE-2026-128075 lies in an environment-specific disparity within Nuxt's error normalization function createErrorFromThrown, located in packages/nuxt/src/app/error.ts. In Nuxt's architecture, errors raised during execution fall into two categories: explicit HTTP errors intentionally instantiated by developers via createError() or showError(), and unexpected runtime exceptions (such as network failures in ofetch / $fetch or standard JavaScript Error instances).
Under the error semantics enforced by H3 and Nitro, an error object containing unhandled: true indicates an unexpected server failure. During production rendering, the serializer strips sensitive properties (message, stack, and data) from unhandled errors before writing them into the HTTP response or the __NUXT_DATA__ hydration payload, substituting generic status text such as Internal Server Error. Conversely, errors where unhandled is false or undefined are treated as sanitized application errors safe for public client consumption.
Prior to version 4.6.4, createErrorFromThrown was conditionally defined using the compile-time flag import.meta.dev. In development mode (import.meta.dev === true), createErrorFromThrown executed custom wrapper logic to inspect the thrown object and attach contextual metadata. In production builds (import.meta.dev === false), however, createErrorFromThrown was compiled as a direct alias to createError.
Furthermore, several core runtime files—including packages/nuxt/src/app/entry.ts, packages/nuxt/src/app/components/nuxt-root.vue, and packages/nuxt/src/pages/runtime/plugins/router.ts—invoked createError(err) directly inside catch blocks rather than calling createErrorFromThrown(err). When an unhandled exception was passed to createError(), the utility constructed a new H3 error object copying the original message and data properties while leaving unhandled undefined. When ofetch ($fetch) fails an HTTP request, its error message contains the full request method, target URL (including query parameters), and HTTP status, while its data property holds the parsed upstream response body. Because unhandled was not set to true, Nuxt serialized all of these internal properties directly into the client response.
The vulnerability was resolved in commit 8c56b71e4d0377c5c047799078db09c6b3d4fde5 by refactoring createErrorFromThrown to execute uniformly across both development and production environments, introducing an explicit check for authentic H3 HTTP errors, and replacing direct createError calls in SSR catch blocks.
Prior to the patch, packages/nuxt/src/app/error.ts bypassed wrapper validation in production by aliasing createErrorFromThrown directly to createError:
// Vulnerable code in packages/nuxt/src/app/error.ts (Prior to 4.6.4)
export const createErrorFromThrown: (thrown: unknown, context?: ThrownContext) => NuxtError = import.meta.dev
? function createErrorFromThrown (thrown: unknown, context?: ThrownContext): NuxtError {
const error = createError(thrown as string | Error | NuxtErrorDetails)
// Development-only context tagging omitted in production
return error
}
: createError as (thrown: unknown) => NuxtErrorIn the patched version of packages/nuxt/src/app/error.ts, the import.meta.dev conditional assignment is removed from the function signature. A new helper function isHTTPError checks whether the thrown instance was constructed by H3's createError (verified via the constructor.__h3_error__ property). If createError wraps a raw error that was not already an H3 HTTP error, error.unhandled = true is explicitly assigned:
// Patched code in packages/nuxt/src/app/error.ts (4.6.4)
function isHTTPError (value: unknown): boolean {
return value instanceof Error && (value.constructor as { __h3_error__?: unknown })?.__h3_error__ === true
}
export function createErrorFromThrown (thrown: unknown, context?: ThrownContext): NuxtError {
const error = createError(thrown as string | Error | NuxtErrorDetails)
// If the thrown value was not already a NuxtError or H3 HTTP error, mark it as unhandled
if (error !== thrown && !isHTTPError(thrown)) {
error.unhandled = true
}
if (import.meta.dev) {
const key = Object.keys(error).find(k => k.startsWith('__nuxt_error')) || ('__nuxt_error_at_' + Date.now())
Object.defineProperty(error, key, {
value: context || {},
enumerable: false,
configurable: true,
writable: true,
})
}
return error
}The commit also updated error catch handlers across the application lifecycle (entry.ts, nuxt-root.vue, server-component.ts, router.ts, and composables/error.ts) to consistently invoke createErrorFromThrown instead of createError:
// Patched code in packages/nuxt/src/app/entry.ts
const vueApp = createApp(RootComponent)
vueApp.config.errorHandler = (err, instance, info) => {
const error = createErrorFromThrown(err, { instance, info, type: 'vue:errorHandler' })
// ...
}Additionally, packages/nuxt/src/runtime/server/renderer/error.ts was updated via a describeError helper to ensure that during production rendering (!import.meta.dev), any error flagged as unhandled or carrying a 500 status code has its status text masked as 'Internal Server Error', preventing raw exception strings from leaking into the rendered fallback response.
> [!NOTE]
> Assessment of Fix Completeness: The fix completely resolves the auto-wrapping leak for unhandled SSR exceptions in Nuxt 4.6.4+. However, developers must note that errors explicitly passed to createError() by application code, as well as errors captured in the reactive return state of useFetch() or useAsyncData(), remain serialized into __NUXT_DATA__ by design.
Exploiting CVE-2026-128075 requires no authentication (PR:N) or user interaction (UI:N). The sole prerequisite is a target Nuxt application (versions >= 3.0.0, < 4.6.4) operating with Server-Side Rendering enabled where an attacker can induce an unhandled non-HTTP exception during the execution of a page, plugin, or route middleware.
A common vulnerable pattern occurs when a server-rendered Vue component or route middleware uses Nuxt's global $fetch utility (powered by ofetch) to query an internal microservice using route parameters and server-side runtime secrets:
<!-- pages/users/[id].vue -->
<script setup lang="ts">
const route = useRoute()
const config = useRuntimeConfig()
// Performs an SSR request to an internal service with a secret query parameter.
// If the upstream returns 404/500/502 or fails DNS resolution, $fetch throws a FetchError.
const userProfile = await $fetch(
`http://users-service.internal.local/api/v1/users/${route.params.id}?apiKey=${config.internalUsersApiKey}`
)
</script>
<template>
<div>User: {{ userProfile.name }}</div>
</template>502 Bad Gateway or 404 Not Found) or trigger a backend database driver exception:GET /users/invalid-id-99999 HTTP/1.1
Host: target-application.example.com
Accept: text/html__NUXT_DATA__: When $fetch rejects the promise, Nuxt catches the FetchError and passes it to createError(). Because unhandled is not set to true, Nuxt serializes the full error object into the HTML document's hydration script. Even if the application renders a sanitized error.vue template visually displaying "Something went wrong", inspecting the HTML source reveals the leaked credentials and internal topology:<script id="__NUXT_DATA__" type="application/json">
[
["Reactive", 1],
{ "data": 2, "state": 3, "once": 4, "_errors": 5, "serverRendered": true, "path": "/users/invalid-id-99999", "error": 6 },
{},
{},
["Set"],
{},
{
"url": "/users/invalid-id-99999",
"statusCode": 502,
"statusMessage": "Bad Gateway",
"message": "[GET] \"http://users-service.internal.local/api/v1/users/invalid-id-99999?apiKey=sk_prod_98f76a54b321c0\": 502 Bad Gateway",
"data": {
"internalErrorCode": "UPSTREAM_DB_TIMEOUT",
"dbNode": "10.240.12.88:5432"
}
}
]
</script>Alternatively, if the attacker sends the request with an Accept: application/json header, Nuxt's error renderer returns the serialized JSON error object directly in the HTTP response body.
CVE-2026-128075 is rated 5.3 (Medium) under CVSS v3.1 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N). The vulnerability directly compromises confidentiality (C:L) without providing direct primitives for data modification (I:N) or denial of service (A:N).
The primary security impact is the unauthorized disclosure of sensitive server-side context to unauthenticated clients. Depending on what operations fail during SSR, leaked error objects can expose:
$fetch (which embeds the full request URL inside error.message)..svc.cluster.local), and internal port numbers.error.data.It is important to note the architectural boundaries of this vulnerability. Errors explicitly constructed by developers via createError() or showError() are intended for client visibility and are unaffected. Similarly, errors returned as part of the reactive state of useFetch() or useAsyncData() (const { error } = await useFetch(...)) are stored in component state and serialized into __NUXT_DATA__ by design; developers must avoid passing server secrets in URLs directly to useFetch. Finally, standalone Nitro API routes (server/api/* and server/routes/*) use Nitro's native error handler rather than the Vue SSR page renderer and are not affected by this flaw.
According to FIRST EPSS metrics, CVE-2026-128075 has an EPSS score of 0.00311 (0.31%, 24.31st percentile), and it is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog.
The definitive remediation for applications on the Nuxt 4 release line is to upgrade the nuxt package to version 4.6.4 or later, which incorporates commit 8c56b71e4d0377c5c047799078db09c6b3d4fde5:
npm install nuxt@^4.6.4
# or
pnpm update nuxt@^4.6.4
# or
yarn upgrade nuxt@^4.6.4> [!WARNING]
> Nuxt 3 End-of-Life Notice: The Nuxt 3.x release branch (>= 3.0.0, < 4.0.0) has reached End-of-Life (EOL) and will not receive an official backported patch. Organizations running Nuxt 3 that cannot immediately migrate to Nuxt >= 4.6.4 must implement a server-side workaround.
Option 1: Global Nitro Error Hook Plugin
Deploy a Nitro server plugin at server/plugins/hide-error-details.ts to intercept errors before serialization. This hook inspects error.cause to determine whether the original exception was a non-H3 error auto-wrapped by Nuxt, and explicitly sets unhandled: true while clearing data:
// server/plugins/hide-error-details.ts
export default defineNitroPlugin((nitroApp) => {
nitroApp.hooks.hook('error', (error) => {
const cause = (error as { cause?: unknown }).cause
if (cause instanceof Error && !(cause.constructor as { __h3_error__?: boolean }).__h3_error__) {
Object.assign(error, { unhandled: true, data: undefined })
}
})
})Option 2: Explicit Application-Level Catching
Wrap internal $fetch calls and sensitive SSR operations in try/catch blocks within page setup scripts, plugins, and middleware, throwing sanitized createError instances without propagating the raw upstream error object:
try {
await $fetch(internalUpstreamUrl)
} catch {
throw createError({
statusCode: 502,
statusMessage: 'Upstream service unavailable'
})
}Security teams should audit SSR data-fetching logic for any upstream requests that pass sensitive credentials in URL query parameters rather than HTTP headers, and rotate any API keys or internal tokens that may have been exposed in production SSR error responses prior to patching.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
nuxt Nuxt | >= 3.0.0, < 4.0.0 | None (End-of-Life; upgrade to 4.6.4) |
nuxt Nuxt | >= 4.0.0, < 4.6.4 | 4.6.4 |
| Attribute | Detail |
|---|---|
| CVE ID | CVE-2026-128075 (GHSA-96x6-fvhx-49hg) |
| Weakness Class | CWE-209: Generation of Error Message Containing Sensitive Information |
| CVSS v3.1 Score | 5.3 Medium (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N) |
| EPSS Score | 0.31% (24.31st Percentile) |
| Affected Versions | nuxt >= 3.0.0, < 4.6.4 |
| Patched Version | nuxt 4.6.4 (Nuxt 3 is EOL) |
| Attack Vector | Unauthenticated Network HTTP Request triggering SSR Exception |
| CISA KEV Status | Not Listed |
The product generates an error message that includes sensitive information about its environment, users, or associated data, allowing remote attackers to extract internal endpoints, architecture topology, or query-string credentials.
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.
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.
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.
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.
An information exposure vulnerability in the @opentelemetry/instrumentation-http package for OpenTelemetry JavaScript versions 0.204.0 prior to 0.222.0 causes incoming HTTP server spans to record raw, unredacted query string parameters under the url.query attribute. While outgoing client spans applied built-in and user-configured query parameter redaction, incoming server spans bypassed this sanitization completely, resulting in the transmission of sensitive credentials such as pre-signed cloud URLs and API tokens to external observability backends.
CVE-2026-128089 is an uncontrolled resource consumption vulnerability in the dnspython toolkit for Python, affecting all versions prior to 2.9.2. When parsing Well-Known Service (WKS) records from text via dns.rdtypes.IN.WKS.WKS.from_text(), the parser fails to validate that numeric service port identifiers fall within the RFC 1035 valid range of 0 through 65535. An attacker capable of supplying untrusted zone files or RDATA text strings containing an arbitrarily large service port integer can force the parser to allocate an unbounded bitmap array using an inefficient linear append loop, resulting in severe CPU exhaustion, application hangs, or Out-Of-Memory (OOM) process termination.