Nov 16, 2026·13 min read·2 visits
An unescaped object serialization format in Nuxt's `getIslandHash` function allows attackers to inject structural delimiters into island component props, generating hash collisions on `/__nuxt_island` endpoints. This leads to web cache poisoning, static prerender tampering, and potential Cross-Site Scripting (XSS) in versions prior to 4.6.4.
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.
Nuxt provides a server-only component architecture known as Server Components, implemented via the <NuxtIsland> component. Unlike standard universal Vue components that hydrate and execute in both server and client environments, islands execute exclusively on the server and return pre-rendered HTML payloads to the client. To facilitate dynamic fetching, static prerendering, and HTTP caching, Nuxt exposes dedicated internal endpoints formatted as /__nuxt_island/<ComponentName>_<hash>.json.
Each unique invocation of a server island is identified by a cryptographic hash included in its route path. This hash is computed from a tuple containing the component name, the passed properties (props), the execution context, and the source identifier. The architecture assumes that any variation in the input properties will yield a distinct hash, thereby isolating the cached or prerendered output of one component state from another.
CVE-2026-128076 (also tracked as GHSA-hf59-9xwc-2g4p) stems from an incomplete fix for a prior vulnerability, CVE-2026-46342. In the previous patch, Nuxt introduced the getIslandHash function utilizing the hash() utility from the ohash package to bind island routes to their exact properties. However, the custom object serializer within ohash does not escape structural delimiters such as single quotes ('), colons (:), or commas (,) when converting JavaScript objects into intermediate string representations prior to hashing.
Classified under CWE-116 (Improper Encoding or Escaping of Output) and CWE-349 (Acceptance of Extraneous Untrusted Data With Trusted Data), this serialization flaw allows an unauthenticated attacker to trigger deterministic hash collisions. By injecting delimiter sequences into a single untrusted string property or key, an attacker can construct a property object whose serialized representation matches that of a different, multi-property invocation. When combined with static site generation (nuxt generate) or upstream Content Delivery Networks (CDNs) that cache island endpoints by URL path alone, attackers can poison cached component responses or achieve Cross-Site Scripting (XSS).
The root cause of CVE-2026-128076 lies in the non-canonical serialization routine performed by ohash when invoked by getIslandHash in packages/nuxt/src/app/island-hash.ts. When hash([input.name, props, input.context ?? {}, input.source]) executes, ohash recursively walks the input array and its nested objects to produce a flat string before computing the final digest. Rather than adhering to strict JSON formatting rules with backslash-escaped quotation marks, ohash concatenates object keys and values using unescaped structural tokens.
Specifically, ohash formats object key-value pairs as key:'string_value' and separates adjacent properties with commas (key1:'val1',key2:'val2'). Because the serializer does not escape single quotes embedded within string_value or colons and commas within key, the boundary between data literals and structural syntax is not preserved. Any string value containing the sequence ',nextKey:' is indistinguishable in the serialized output from an actual closing quote, a property separator, and a subsequent object key.
To illustrate this collision mechanism, consider an island component named X that accepts two properties: html and note. A legitimate invocation with an empty html string and a specific note value is structured as follows:
// Invocation 1: Discrete properties
{
html: '',
note: '<img src=x onerror="document.body.dataset.collision=\'executed\'">'
}An attacker who controls only the html property can inject the delimiter sequence ',note:' followed by the payload into that single property:
// Invocation 2: Single property with injected delimiters
{
html: "',note:'<img src=x onerror=\"document.body.dataset.collision='executed'\">"
}When ohash serializes both objects within the island tuple, both inputs collapse into the exact same intermediate character sequence:
[X,{html:'',note:'<img src=x onerror="document.body.dataset.collision=\'executed\'">'},{},undefined]The exact same delimiter confusion applies to object keys. If an application permits user-influenced keys within a props object, the object { a: 1, b: 2 } serializes to {a:1,b:2}, which collides directly with an object containing a single synthetic key: { 'a:1,b': 2 }. Because the digest algorithm operates on this ambiguous string representation, both distinct runtime objects produce an identical /__nuxt_island/X_<hash>.json identifier.
prior to Nuxt v4.6.4, the getIslandHash implementation in packages/nuxt/src/app/island-hash.ts passed the raw array of component metadata directly to ohash's hash() function. If input.props was passed as a serialized JSON string, it was first parsed back into a JavaScript object via parseSerializedProps(input.props) before being handed off to the vulnerable hash() serializer.
// Vulnerable implementation in packages/nuxt/src/app/island-hash.ts
import { hash } from 'ohash'
export function getIslandHash (input: {
name: string
props?: unknown
context?: Record<string, any>
source?: string
}): string {
const props = typeof input.props === 'string' ? parseSerializedProps(input.props) : (input.props ?? {})
// VULNERABLE: hash() uses ohash's custom serializer which fails to escape quotes and delimiters
return hash([input.name, props, input.context ?? {}, input.source]).replace(/[-_]/g, '')
}In commit 6f1b93c643355688bc9e2d7434723f7fd3f25092, the Nuxt maintainers remediated the vulnerability by replacing hash() with digest() from ohash and introducing a custom canonicalJSON() serialization helper. Instead of relying on ohash to serialize JavaScript objects into strings, canonicalJSON() leverages native JSON.stringify() combined with a replacer function that lexicographically sorts object keys.
File: packages/nuxt/src/app/island-hash.ts
@@ -1,4 +1,4 @@
-import { hash } from 'ohash'
+import { digest } from 'ohash'
/**
* Strip Vue scoped-style attributes (`data-v-*`) from island props before hashing
@@ -50,7 +50,16 @@ export function getIslandHash (input: {
source?: string
}): string {
const props = typeof input.props === 'string' ? parseSerializedProps(input.props) : (input.props ?? {})
- return hash([input.name, props, input.context ?? {}, input.source]).replace(/[-_]/g, '')
+ // FIXED: Pre-serialize the input tuple using strict JSON escaping with sorted keys before hashing
+ return digest(canonicalJSON([input.name, props, input.context ?? {}, input.source])).replace(/[-_]/g, '')
+}
+
+function canonicalJSON (value: unknown): string {
+ return JSON.stringify(value, (_key, val) => {
+ if (val === null || typeof val !== 'object' || Array.isArray(val)) {
+ return val
+ }
+ // Ensure deterministic key ordering across equivalent objects
+ return Object.fromEntries(Object.keys(val).sort().map(key => [key, val[key]]))
+ })
}The patch addresses both determinism and structural ambiguity. First, the JSON.stringify replacer checks whether the current value val is a non-null, non-array object; if so, it extracts all keys via Object.keys(val), sorts them alphabetically using .sort(), and reconstructs the object via Object.fromEntries(). This guarantees that { a: 1, b: 2 } and { b: 2, a: 1 } produce identical JSON strings.
Second, JSON.stringify enforces strict RFC 8259 string escaping. Any double quotes ("), backslashes (\), or control characters inside property keys or string values are escaped prior to being enclosed in double quotes. When evaluating the previously colliding inputs under canonicalJSON(), { html: '', note: 'payload' } serializes to {"html":"","note":"payload"}, whereas { html: "',note:'payload" } serializes to {"html":"',note:'payload"}. Because the structural delimiters in the latter are encapsulated within a single JSON string literal, digest() computes two completely distinct hashes.
> [!NOTE]
> Fix Completeness Assessment: The combination of JSON.stringify() and recursive key sorting provides a complete defense against delimiter injection for standard JSON data types (strings, numbers, booleans, arrays, and plain objects). A minor edge case exists if non-JSON-serializable primitives (such as undefined, BigInt, Map, Set, or RegExp) are passed directly into props in memory without prior JSON serialization, as JSON.stringify omits undefined keys and serializes Map/Set as {}. However, because Nuxt island props must already be JSON-serializable to traverse the network boundary via parseSerializedProps and serializeIslandProps, this constraint aligns with the component model and leaves no practical variant attack surface.
Exploiting CVE-2026-128076 requires specific architectural preconditions, reflected in its High Attack Complexity (AC:H) rating. An attacker must target a Nuxt application that utilizes <NuxtIsland> or Server Components, accepts user-controllable input into at least one island prop, and relies on either static prerendering (nuxt generate) or an upstream HTTP caching layer (such as a CDN or reverse proxy) that keys cached responses exclusively on the request path /__nuxt_island/<Name>_<hash>.json.
In production deployments fronted by CDNs (e.g., Cloudflare, Fastly, AWS CloudFront) or reverse proxies (e.g., Nginx, Varnish), operators frequently configure caching rules for static-like JSON endpoints. Because Nuxt appends the prop hash to the URL path (/__nuxt_island/<Name>_<hash>.json), edge configurations often assume the path itself uniquely identifies the resource and ignore query parameters (?props=...) in the cache key.
UserProfileIsland) and determines the legitimate prop structure used on a public page, computing its corresponding <hash>.<hash>./__nuxt_island/UserProfileIsland_<hash>.json containing the crafted props in the query string or request payload before the legitimate resource is cached (or immediately after cache expiration).<hash> via the flawed getIslandHash function. Because the hash matches, the server renders the component using the attacker's colliding props and returns the response./__nuxt_island/UserProfileIsland_<hash>.json.nuxt generate)During static site generation, Nuxt's Nitro crawler traverses internal links to prerender pages and saves their corresponding island JSON payloads to disk under /__nuxt_island/<Name>_<hash>.json.
/__nuxt_island/<Name>_<hash>.json.<hash>, permanently embedding the substituted content into the static build.If an island component contains multiple props—where one prop (html) is safely escaped using standard Vue text interpolation ({{ props.html }}), while another prop (note) is normally populated by trusted internal logic and rendered via an unescaped sink (v-html="props.note")—delimiter confusion allows the attacker to cross the trust boundary.
<!-- Server Island Component: X.server.vue -->
<template>
<div class="island-container">
<span>{{ props.html }}</span>
<!-- Sink assumed to only receive trusted internal values -->
<div v-html="props.note" />
</div>
</template>By supplying html: "',note:'<img src=x onerror=alert(document.domain)>" in a cache-poisoning request, or by poisoning a route where note contains executable markup, the cached response substitutes the rendered HTML of the island, executing arbitrary JavaScript in the browser context of any victim who loads the poisoned component.
CVE-2026-128076 is assigned a CVSS v3.1 base score of 3.1 (Low) with the vector CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:L/A:N. While the vulnerability is network-accessible without authentication (AV:N/PR:N), its baseline severity is constrained by the requirement for specific deployment architectures (AC:H) and user interaction (UI:R), as a victim user or build crawler must request the colliding endpoint to observe the poisoned state.
The primary impact of the vulnerability is Integrity loss (I:L) through web cache poisoning and static build artifact substitution. Attackers who successfully trigger a collision can replace legitimate server component outputs with arbitrary component states, defacing specific sections of an application or displaying spoofed UI elements to end users.
In scenarios where a server component passes any property into an unsafe DOM sink (such as Vue's v-html directive or direct innerHTML assignments), the impact escalates to stored or reflected Cross-Site Scripting (XSS). Under an XSS condition, an attacker can execute arbitrary JavaScript within the victim's browser session under the application's origin, enabling session hijacking, unauthorized API actions, or credential harvesting.
Current threat intelligence indicates low active exploitation risk in the wild. The Exploit Prediction Scoring System (EPSS) assigns CVE-2026-128076 a score of 0.00116 (0.12% probability), placing it in the 1.67th percentile of all scored vulnerabilities. The vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog, and while functional proof-of-concept test cases exist in the public Nuxt repository commit history, no automated weaponized exploit tooling has been observed.
The definitive remediation for CVE-2026-128076 is to upgrade the nuxt and @nuxt/nitro-server packages to version 4.6.4 or later, which incorporates the canonicalJSON serialization fix. Note that while versions in the >= 3.21.6, < 4.0.0 range are affected, the official fix was released in v4.6.4; organizations running affected 3.x releases should upgrade to the patched 4.6.4+ release line or apply workarounds if an immediate major version upgrade is not feasible.
# 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.4After updating package.json, administrators should inspect their lockfiles (package-lock.json, pnpm-lock.yaml, or yarn.lock) to verify that both nuxt and @nuxt/nitro-server resolve to 4.6.4 or higher, and trigger a clean rebuild and cache purge across all prerendered deployments and edge CDNs.
For environments where an immediate framework upgrade cannot be performed, security teams should implement the following defense-in-depth mitigations:
/__nuxt_island/* endpoints based solely on the URL path. Configure the caching layer to include the full query string ($args or $query_string) in the cache key so that requests with differing ?props= parameters are stored in separate cache buckets.# Example Nginx configuration ensuring query strings are included in the cache key
location /__nuxt_island/ {
proxy_pass http://nuxt_upstream;
proxy_cache my_cache;
# Include $request_uri (which contains query parameters) or $args explicitly
proxy_cache_key "$scheme$request_method$host$request_uri";
}.server.vue components and <NuxtIsland> targets for usage of v-html. Replace raw HTML bindings with standard Vue mustache interpolation ({{ prop }}) or sanitize the input on the server using a strict HTML sanitizer (such as DOMPurify or sanitize-html) prior to rendering.<NuxtIsland :props="...">. Reject inputs containing unexpected structural delimiter sequences such as ', or ":".CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:L/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
nuxt Nuxt | >= 3.21.6, < 4.0.0 | 4.6.4 |
nuxt Nuxt | >= 4.4.6, < 4.6.4 | 4.6.4 |
@nuxt/nitro-server Nuxt | >= 3.21.6, < 4.0.0 | 4.6.4 |
@nuxt/nitro-server Nuxt | >= 4.4.6, < 4.6.4 | 4.6.4 |
| Attribute | Detail |
|---|---|
| CVE ID | CVE-2026-128076 (GHSA-hf59-9xwc-2g4p) |
| Vulnerability Class | CWE-116 (Improper Encoding or Escaping of Output) / CWE-349 |
| Attack Vector | Network (AV:N) with High Complexity (AC:H) |
| CVSS v3.1 Score | 3.1 Low (CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:L/A:N) |
| EPSS Score | 0.12% (1.67th Percentile) |
| Primary Impact | Web Cache Poisoning, Prerender Tampering, and Potential XSS |
| Exploit Status | Proof of Concept (Unit Test Verified) |
| CISA KEV Status | Not Listed |
The software prepares a structured message for communication with another component, but encoding or escaping of the data is either missing or done incorrectly, allowing structural delimiter characters within data values to alter the message logic.
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.
CVE-2026-126347 (GHSA-5cjw-f85j-cv6r) is an open redirect vulnerability (CWE-601) in Tornado, an asynchronous Python networking library and web framework. The flaw resides in tornado.web.RedirectHandler when dynamic URL redirection templates incorporate unvalidated user input. Due to a parser differential between RFC 3986 (used by Python's urllib.parse.urlsplit) and the WHATWG URL Standard (used by modern web browsers), inputs containing three or more leading slashes bypass Tornado 6.6.0's validation logic, allowing unauthenticated attackers to redirect users to arbitrary external domains.