CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-128076

CVE-2026-128076: Delimiter Injection and Island Prop Hash Collision in Nuxt

Amit Schendel
Amit Schendel
Senior Security Researcher

Nov 16, 2026·13 min read·2 visits

Executive Summary (TL;DR)

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.

Vulnerability Overview

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).

Root Cause Analysis

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.

Code Analysis

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.

Exploitation Methodology

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.

Scenario 1: CDN / Reverse Proxy Cache Poisoning

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.

  1. The attacker identifies a target island component (e.g., UserProfileIsland) and determines the legitimate prop structure used on a public page, computing its corresponding <hash>.
  2. The attacker crafts a colliding prop payload that injects properties or alters values while maintaining the exact same <hash>.
  3. The attacker sends an HTTP GET request to /__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).
  4. The Nuxt backend validates that the provided props match <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.
  5. The CDN stores this response under the cache key /__nuxt_island/UserProfileIsland_<hash>.json.
  6. When subsequent users visit the application and request the legitimate island, the CDN serves the poisoned payload.

Scenario 2: Static Prerender Tampering (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.

  1. If the application renders user-submitted content (such as forum posts, comments, or profile links) that influences the URLs or query parameters crawled during a build, an attacker submits a link that triggers an island render with colliding props.
  2. If the crawler visits the attacker-controlled route prior to visiting the legitimate route that shares the same island hash, Nitro writes the attacker's rendered island output to disk at /__nuxt_island/<Name>_<hash>.json.
  3. When the crawler subsequently processes the legitimate page, Nuxt reuses the existing prerendered artifact on disk matching <hash>, permanently embedding the substituted content into the static build.

Scenario 3: Escalation to Cross-Site Scripting (XSS)

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.

Impact Assessment

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.

Remediation and Mitigation

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.4

After 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:

  1. Configure Complete CDN Cache Keys: Ensure that reverse proxies and CDNs do not cache /__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";
}
  1. Eliminate Unsafe HTML Sinks in Islands: Audit all .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.
  2. Strict Input Validation on Island Props: Validate and restrict the structure and character set of any external query parameters, route parameters, or request bodies before passing them into <NuxtIsland :props="...">. Reject inputs containing unexpected structural delimiter sequences such as ', or ":".

Official Patches

NuxtOfficial GitHub Security Advisory for GHSA-hf59-9xwc-2g4p / CVE-2026-128076
NuxtOfficial patch commit in nuxt/nuxt repository
NuxtNuxt v4.6.4 release notes containing the fix

Fix Analysis (1)

Technical Appendix

CVSS Score
3.1/ 10
CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:L/A:N
EPSS Probability
0.12%
Top 98% most exploited

Affected Systems

nuxt (npm package)@nuxt/nitro-server (npm package)

Affected Versions Detail

Product
Affected Versions
Fixed Version
nuxt
Nuxt
>= 3.21.6, < 4.0.04.6.4
nuxt
Nuxt
>= 4.4.6, < 4.6.44.6.4
@nuxt/nitro-server
Nuxt
>= 3.21.6, < 4.0.04.6.4
@nuxt/nitro-server
Nuxt
>= 4.4.6, < 4.6.44.6.4
AttributeDetail
CVE IDCVE-2026-128076 (GHSA-hf59-9xwc-2g4p)
Vulnerability ClassCWE-116 (Improper Encoding or Escaping of Output) / CWE-349
Attack VectorNetwork (AV:N) with High Complexity (AC:H)
CVSS v3.1 Score3.1 Low (CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:L/A:N)
EPSS Score0.12% (1.67th Percentile)
Primary ImpactWeb Cache Poisoning, Prerender Tampering, and Potential XSS
Exploit StatusProof of Concept (Unit Test Verified)
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1189Drive-by Compromise
Initial Access
T1059.007Command and Scripting Interpreter: JavaScript
Execution
T1565.002Data Manipulation: Transmitted Data Manipulation
Defense Evasion
CWE-116
Improper Encoding or Escaping of Output

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.

Known Exploits & Detection

GitHub Commit Unit TestsOfficial regression tests demonstrating prop value and object key delimiter collisions in getIslandHash.

Vulnerability Timeline

Fix authored and committed to the nuxt/nuxt repository (commit 6f1b93c643355688bc9e2d7434723f7fd3f25092).
2026-10-27
CVE-2026-128076 published by GitHub CNA and GitHub Security Advisory GHSA-hf59-9xwc-2g4p released alongside Nuxt v4.6.4.
2026-11-13
Vulnerability indexed in the National Vulnerability Database (NVD).
2026-11-13
EPSS score initialized at 0.00116.
2026-11-16

References & Sources

  • [1]GitHub Security Advisory GHSA-hf59-9xwc-2g4p
  • [2]Official Fix Commit 6f1b93c643355688bc9e2d7434723f7fd3f25092
  • [3]Nuxt Release v4.6.4
  • [4]CVE.org Record: CVE-2026-128076
  • [5]NVD Vulnerability Detail: CVE-2026-128076
  • [6]CVE List V5 Source Entry
Related Vulnerabilities
CVE-2026-46342

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 2 hours ago•CVE-2026-128072
3.1

CVE-2026-128072: DNS Rebinding and Origin Validation Error in Nuxt Webpack and Rspack Development Builders

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.

Amit Schendel
Amit Schendel
4 views•13 min read
•2 days ago•CVE-2026-128087
3.7

CVE-2026-128087: Premature Key Exchange Callback Invocation Prior to Host Key Verification in russh

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.

Amit Schendel
Amit Schendel
8 views•10 min read
•2 days ago•CVE-2026-128082
7.5

CVE-2026-128082: Uncontrolled Recursion and Denial of Service in AutoMapper via Constructor Parameter Mapping

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.

Amit Schendel
Amit Schendel
9 views•11 min read
•2 days ago•CVE-2026-128080
5.8

CVE-2026-128080: Sensitive Query Parameter Disclosure on Incoming Server Spans in OpenTelemetry JavaScript (@opentelemetry/instrumentation-http)

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.

Alon Barad
Alon Barad
8 views•10 min read
•2 days ago•CVE-2026-128089
7.5

CVE-2026-128089: Uncontrolled Resource Consumption in dnspython WKS Record Parser

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.

Amit Schendel
Amit Schendel
10 views•10 min read
•2 days ago•CVE-2026-126347
3.1

CVE-2026-126347: Open Redirect via Triple-Slash Redirect Paths in Tornado RedirectHandler

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.

Alon Barad
Alon Barad
8 views•11 min read