Jun 16, 2026·6 min read·113 visits
Nuxt `<NuxtLink>` components prior to versions 3.21.7 and 4.4.7 fail to sanitize URL schemes, enabling DOM-based XSS when binding untrusted, attacker-controlled navigation targets.
A reflected DOM-based Cross-Site Scripting (XSS) vulnerability was identified in Nuxt's core <NuxtLink> component. Prior to the patched versions, the component failed to validate or sanitize the target URI schemes before directly rendering them into the 'href' attribute of native HTML anchor elements. An attacker who controls the input bound to the 'to' or 'href' properties can inject executable URI schemes, such as 'javascript:' or 'data:', leading to arbitrary script execution in the context of the user's browser session.
The <NuxtLink> component is a foundational element within the Nuxt framework used for managing internal and external application navigation. It abstracts Vue Router routing mechanisms and standard native anchor HTML elements. When determining the routing target, <NuxtLink> dynamically evaluates whether the destination is an internal route or an external link.
The attack surface exists when applications dynamically bind untrusted data—such as user-supplied inputs, query parameters, or raw database records—directly to the :to or :href properties of a <NuxtLink> instance. If the bound target is identified as an external address, the framework traditionally rendered the value verbatim.
This behavior results in a Document Object Model (DOM) Cross-Site Scripting vulnerability under CWE-79 (Improper Neutralization of Input During Web Page Generation) and CWE-83 (Improper Neutralization of Script in Attributes). Attackers can execute arbitrary JavaScript payloads within the target browser because browsers natively parse and execute specific URI schemes directly inside anchor attributes.
The underlying technical flaw stems from how <NuxtLink> differentiates between internal and external paths. If a path contains a protocol separator, the framework classifies the routing target as external. Once flagged as external, the framework mapped the raw path string to the rendered native <a> element's href attribute without sanitizing the protocol prefix.
Modern browser rendering engines natively execute executable protocol schemes like javascript:, data:, or vbscript: when a user clicks the respective link. Because the framework assumed all external links were network-based web targets (such as http: or https:), it did not apply standard scheme checks.
An attacker can trigger this condition by supplying a crafted link target containing an active script scheme. The application retrieves this target from state variables or URL search parameters and passes it to <NuxtLink>. This action bypasses default framework-level output escaping because Vue.js considers bindings to attribute fields as secure strings.
In the vulnerable state, external routes were passed directly into the computed path engine. The application resolved path objects and returned them unmodified to the template compiler. The framework omitted sanitization filters at the integration point between the reactive link logic and the native element configuration.
The official security advisory addresses this behavior by introducing sanitizeExternalHref within packages/nuxt/src/app/components/nuxt-link.ts inside commit 0103ce06fbbbdfa079a7f020ef8ce00121eac4a3. The helper utility parses potential targets and rejects executable schemes:
/**
* Reject URL strings that would resolve to a script-capable protocol when used as the
* `href` of an anchor element. Returns the value unchanged when safe, or `null`.
*/
function sanitizeExternalHref (value: string): string | null {
// Strips Unicode control characters and ASCII whitespace
let candidate = value.replace(/[\u0000-\u001f\s]+/g, '')
while (candidate.toLowerCase().startsWith('view-source:')) {
candidate = candidate.slice('view-source:'.length)
}
const colon = candidate.indexOf(':')
if (colon > 0 && isScriptProtocol(candidate.slice(0, colon + 1))) {
return null
}
return value
}This implementation uses isScriptProtocol from the ufo dependency to validate against a protocol blocklist consisting of javascript:, data:, vbscript:, and blob:. If the check fails, the framework sets the computed href property to null and intercepts navigation dynamically:
async navigate (_e?: MouseEvent) {
if (href.value === null) {
if (import.meta.dev) {
console.warn(`[${componentName}] refused to navigate to a URL with a script-capable protocol.`)
}
return;
}
await navigateTo(href.value, { replace: unref(props.replace), external: isExternal.value || hasTarget.value })
}While this sanitization blocks standard exploits, validation bypasses are theoretically possible if downstream parser logic differs from the browser's normalization rules. For example, if the browser normalizes full-width Unicode colons (\uff1a) into standard ASCII colons (:) after the component's scheme check runs, the payload could execute successfully.
To execute this attack, an attacker must locate an application route that parses parameters from the location query or dynamic client state and processes them into <NuxtLink>. The target application pattern usually resembles this layout:
<!-- Vulnerable Application Implementation -->
<template>
<NuxtLink :to="$route.query.continueUrl">Proceed to Destination</NuxtLink>
</template>The attacker crafts a malicious link targeting the vulnerable route, appending the exploit payload as a query parameter. An example exploit string is:
https://example.com/login?continueUrl=javascript:alert(document.domain)
When the victim visits the constructed link and interacts with the navigation anchor, the browser executes the Javascript payload. This execution operates with the privileges of the active session context. A second vector utilizes standard data URIs to execute a same-tab phishing overlay, which replaces the viewport context with a forged authentication prompt:
https://example.com/login?continueUrl=data:text/html,<h1>Session%20Expired</h1>
The security impact of CVE-2026-53722 depends on the session context of the authenticated user. Because the script executes in the context of the application's origin, the attacker can access sensitive client-side data. This includes session tokens stored in localStorage or sessionStorage and browser cookies not flagged with HttpOnly attributes.
An attacker can use this access to capture user inputs, alter page elements, or issue API requests on behalf of the victim. If the vulnerable application handles administrative or backend management tasks, exploitation can lead to administrative account takeover or data exposure.
This vulnerability has been assigned a CVSS v3.1 score of 5.4, reflecting medium severity due to the requirement for user interaction. Its CVSS v4.0 score is 5.1, recognizing the network delivery vector and low complexity, but limiting the severity because it requires active user interaction.
The primary remediation strategy is upgrading the Nuxt framework to patched versions containing the sanitization library. Applications running on the Nuxt 3 branch must upgrade to version 3.21.7 or later. Applications on the Nuxt 4 branch must upgrade to version 4.4.7 or later.
If upgrading is not immediately feasible, developers should implement custom sanitization filters. All dynamic parameters bound to <NuxtLink> components must be validated against an allowlist of permitted target schemes:
function sanitizeRouteInput(target: string): string {
if (!target) return '/'
// Enforce relative paths or standard HTTP/S protocols
const isSafe = /^(https?:\/\/|\/)/i.test(target.trim())
return isSafe ? target : '/'
}Integrate this sanitization function directly into application templates to prevent arbitrary scheme binding:
<NuxtLink :to="sanitizeRouteInput($route.query.continueUrl)">Proceed</NuxtLink>Additionally, implementing a strict Content Security Policy (CSP) with restriction directives such as script-src 'self' and disabling 'unsafe-inline' will mitigate runtime impact if a bypass is discovered.
CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:L/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
Nuxt Nuxt | < 3.21.7 | 3.21.7 |
Nuxt Nuxt | >= 4.0.0, < 4.4.7 | 4.4.7 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-79 |
| Attack Vector | Network |
| CVSS Score | 5.4 (Medium) |
| EPSS Score | 0.00198 |
| Impact | Reflected DOM-based Cross-Site Scripting (XSS) |
| Exploit Status | Proof-of-Concept (PoC) |
| KEV Status | Not Listed |
Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
A path traversal vulnerability (CWE-22) in termux-sync prior to version 1.2.4 allows an attacker to overwrite arbitrary files within the Termux environment during the backup restoration process. The flaw stems from the application trusting attacker-controlled extraction paths defined in the backup's manifest.json file, failing to validate archive members against directory traversal sequences during tar extraction, and using unsanitized backup names when constructing temporary directories. If a user restores a malicious backup archive from local storage, shared folders, GitHub, or Google Drive, an attacker can overwrite sensitive configuration files such as shell startup scripts or local binaries, resulting in arbitrary code execution under the privileges of the Termux user.
SpamScope mail-parser versions 3.8.0 prior to 4.6.0 contain a path traversal vulnerability (CWE-22) within the write_attachments() and write_sample() functions. The library passes untrusted attachment filenames directly into os.path.join() without stripping directory components, validating path containment, or verifying symbolic links. An attacker can send a crafted email containing relative path traversal sequences or absolute filesystem paths in the Content-Disposition header to write or overwrite arbitrary files accessible to the parsing process.
A Regular Expression Denial of Service (ReDoS) vulnerability exists in SpamScope mail-parser versions 4.2.0 prior to 4.6.1. Two separate regular expressions evaluated during standard email header parsing exhibit quadratic to cubic backtracking complexity when processing headers padded with whitespace or angle brackets. An unauthenticated remote attacker can exploit this flaw by sending a small, RFC-compliant email message, causing parsing worker threads or processes to stall at 100% CPU utilization for extended periods.
CVE-2026-129297 is an origin validation vulnerability (CWE-345) in the Python library mail-parser prior to version 4.6.2. The MailParser.get_server_ipaddress() method fails to properly isolate MTA-recorded client IP addresses from sender-controlled text within email Received headers. Due to naive substring delimiter matching, appearance-based regular expression scanning, and fail-open header traversal, remote attackers can spoof their originating IP address to bypass email security controls, blocklists, and anti-spam attribution.
CVE-2026-129299 (GHSA-24mq-4vc6-2prf) is a parsing and serialization flaw in SpamScope mail-parser prior to version 4.6.2. The library uses reflective Python attribute resolution (getattr) over untrusted email header names and applies caller convenience transformations (such as underscore-to-hyphen folding and _json/_raw suffix stripping) directly to wire headers. An unauthenticated remote attacker can send crafted emails that trigger uncaught TypeError exceptions during JSON serialization or cause security-relevant headers and body content to be silently dropped without setting defect indicators.
CVE-2026-129236 is a command-line argument injection vulnerability (CWE-88) in Kubeshark, an eBPF-based network observability tool for Kubernetes. Located within the Model Context Protocol (MCP) server implementation in cmd/mcpRunner.go, the flaw occurs when handling the start_kubeshark tool request. When the MCP server runs with the --allow-destructive flag, the callStartKubeshark function appends the caller-supplied pod_regex parameter directly to the kubeshark tap argument slice without an end-of-options (--) delimiter. Because Kubeshark uses the Cobra and pflag libraries for command-line parsing, any pod_regex value prefixed with a hyphen is interpreted as a CLI flag rather than a positional regular expression. An attacker capable of influencing MCP tool arguments, such as through indirect prompt injection against a connected Large Language Model (LLM) agent, can inject the --set flag to override Helm chart values like tap.docker.registry. Because Kubeshark deploys its worker DaemonSet with privileged security contexts and host networking enabled, redirecting the container image registry allows arbitrary code execution as root across all Kubernetes cluster nodes.