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-53722

CVE-2026-53722: Reflected DOM-based Cross-Site Scripting (XSS) in Nuxt <NuxtLink>

Amit Schendel
Amit Schendel
Senior Security Researcher

Jun 16, 2026·6 min read·113 visits

Executive Summary (TL;DR)

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.

Vulnerability Overview

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.

Root Cause Analysis

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.

Code Analysis

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.

Exploitation Methodology

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>

Impact Assessment

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.

Remediation and Mitigation Guidance

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.

Official Patches

NuxtCore Patch commit on main branch implementing sanitizeExternalHref
NuxtCherry-picked patch commit on v3 branch

Fix Analysis (2)

Technical Appendix

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

Affected Systems

Nuxt Framework v3 (before version 3.21.7)Nuxt Framework v4 (before version 4.4.7)

Affected Versions Detail

Product
Affected Versions
Fixed Version
Nuxt
Nuxt
< 3.21.73.21.7
Nuxt
Nuxt
>= 4.0.0, < 4.4.74.4.7
AttributeDetail
CWE IDCWE-79
Attack VectorNetwork
CVSS Score5.4 (Medium)
EPSS Score0.00198
ImpactReflected DOM-based Cross-Site Scripting (XSS)
Exploit StatusProof-of-Concept (PoC)
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1189Drive-by Compromise
Initial Access
T1185Browser Session Hijacking
Collection
CWE-79
Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')

Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')

Known Exploits & Detection

GitHub Security AdvisoryVulnerability disclosure with proof-of-concept guidelines for application maintainers.

References & Sources

  • [1]Nuxt Security Advisory GHSA-934w-87qh-qr26
  • [2]CVE-2026-53722 Official Record

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

•31 minutes ago•CVE-2026-86046
7.1

CVE-2026-86046: Arbitrary File Write via Path Traversal in termux-sync Restore Workflow

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.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 2 hours ago•CVE-2026-129296
6.5

CVE-2026-129296: Path Traversal in SpamScope mail-parser Attachment Extraction

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.

Amit Schendel
Amit Schendel
2 views•9 min read
•about 3 hours ago•CVE-2026-129295
7.5

CVE-2026-129295: Polynomial Regular Expression Denial of Service (ReDoS) in SpamScope mail-parser

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.

Amit Schendel
Amit Schendel
2 views•10 min read
•about 4 hours ago•CVE-2026-129297
7.5

CVE-2026-129297: Sender IP Address Spoofing in SpamScope mail-parser

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.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 5 hours ago•CVE-2026-129299
6.5

CVE-2026-129299: Uncaught Exceptions and Silent Header Loss via Reflective Attribute Dispatch in SpamScope mail-parser

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.

Amit Schendel
Amit Schendel
3 views•11 min read
•about 5 hours ago•CVE-2026-129236
7.2

CVE-2026-129236: Command-Line Argument Injection in Kubeshark MCP Server

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.

Alon Barad
Alon Barad
6 views•11 min read