Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver malicious Markdown to victim
-
DeliveryVictim views message in TUUI
-
ExploitECharts code block executes arbitrary JS
-
ExecutionJS calls exposed IPC process-spawn
-
ImpactExecute arbitrary OS commands on host
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Output encoding, context-aware escaping
MITRE ATT&CK
2 techniques across 2 tactics: Initial Access, Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the victim to open/view an attacker-crafted Markdown message inside the TUUI desktop client on a version prior to 1.3.4; the malicious payload must be an ECharts code block, which the pre-patch Markdown renderer executed as live JavaScript under a CSP permitting 'unsafe-eval'. Full RCE additionally depends on the app's exposed IPC interface that permits spawning processes - the bridge the injected JS pivots to. Limiting factors: active user interaction is mandatory (UI:A / UI:R - no drive-by against an idle client), and the affected product has a very small user base, so exploitation is inherently targeted rather than opportunistic. The fix (removing ECharts, setting no-echarts, dropping unsafe-eval from the CSP) closes both the script-execution and the delivery path. |
| Impact | This is a genuinely high-impact flaw whose real-world priority is tempered by its narrow deployment footprint and interaction requirement. The vendor CVSS 4.0 vector (8.9) reflects unauthenticated network reach (PR:N) leading to full host compromise (VC:H/VI:H/VA:H plus subsequent-system SC:H/SI:H/SA:H), but crucially requires active user interaction (UI:A) and carries AC:H/AT:P - the attacker depends on the victim opening a crafted Markdown message and on preconditions being met. EPSS is low at 0.43% (62th percentile), the CVE is NOT in CISA KEV, and no public exploit was identified in the provided intelligence (the VulDB entry is an advisory, not exploit code). SSVC-style reading: exploitation=none observed, automatable=no (needs social-engineering delivery to a specific victim), technical impact=total. The signals are internally consistent - a severe technical impact gated behind user interaction and a very small install base - so this reads as a real bug worth patching promptly for TUUI users, not a mass-exploitation emergency. The source diff strongly corroborates the mechanism: the fix removes the ECharts dependency, sets no-echarts on the Markdown renderer, and hardens the CSP from script-src 'self' 'unsafe-eval' to 'self', confirming the arbitrary-JS-in-ECharts-then-IPC-to-process-spawn chain described. |
| Exploit ScenarioDerived | An attacker crafts a Markdown message containing a malicious ECharts code block and gets it in front of a TUUI user (e.g., via an MCP server response, shared chat content, or a document the victim pastes/opens in the client). When the victim views the message, the renderer executes attacker JavaScript, which reaches the exposed IPC process-spawn interface to run arbitrary system commands on the host. No public exploit code was identified at time of analysis, though the vendor commit clearly reveals the vulnerable component and fix. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Sep 25, 2026
Remote code execution in TUUI, the AI-QL desktop MCP client, affects every release prior to 1.3.4: the Markdown rendering component executes arbitrary JavaScript delivered inside ECharts code blocks, and the injected script pivots through the application's exposed IPC interface to spawn arbitrary system processes on the victim's machine. An unauthenticated remote attacker achieves this simply by getting the victim to open a crafted Markdown message in the client - active user interaction is mandatory, so there is no drive-by against an idle client - with the pre-patch CSP's 'unsafe-eval' allowance making the script execution trivially reliable. Risk is tempered in practice by EPSS 0.43% (roughly the 62nd percentile), the absence of any public exploit code or CISA KEV confirmation at time of analysis, and TUUI's very small user base, which makes exploitation targeted rather than opportunistic; a vendor-released fix ships in version 1.3.4.
Earlier versions of this analysis (1)
RemediationAI
Upgrade to TUUI 1.3.4, the exact vendor-released fix version, available from the project's release page at https://github.com/AI-QL/tuui/releases/tag/v1.3.4; the patched build is documented in the GitHub security advisory https://github.com/AI-QL/tuui/security/advisories/GHSA-qjhq-rgmr-6c3g and the fixing commit is https://github.com/AI-QL/tuui/commit/f673fa5b4d76e8236c7d9506d0727875cfa79cc1. If immediate upgrade across a fleet is not possible, the same commit shows which compensating controls actually break the attack chain and can be applied manually to a pre-1.3.4 build: disable ECharts rendering for Markdown blocks (the fix's no-echarts default, which stops fenced charts from ever being evaluated as JavaScript, at the cost of losing rendered chart output in documents), and tighten the content security policy in src/renderer/index.html from script-src 'self' 'unsafe-eval' to script-src 'self' (which blocks dynamically evaluated payloads but may break other renderer features that relied on eval-style code generation). Because the payload only fires when a malicious Markdown message is opened inside the client, a practical short-term mitigation is to treat untrusted Markdown/chart content as hostile - do not open or preview documents from unverified sources in TUUI - and to review the exposed IPC surface that permits process spawning, restricting which IPC channels the renderer may invoke, though any such change is a code-level modification rather than a configuration toggle and carries the risk of breaking legitimate MCP tool integrations. Patching to 1.3.4 remains the only complete remediation, as it closes both the script-execution sink and the delivery path.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
TUUI is a cross-platform desktop application (an Electron-style client with a Vue renderer under src/renderer/) that acts as a unified desktop client for MCP tooling, and its Markdown pipeline is the flawed component. The root cause class is CWE-79, improper neutralization of input during web page generation (cross-site scripting), but here it escalates from script execution to full RCE because of two design choices that compound. First, the MarkdownCard.vue component registered ECharts as a live rendering plugin (a config block mapping echarts: { instance: echarts }), so fenced code blocks tagged as ECharts were not rendered as inert markup but handed to the ECharts library and evaluated as live JavaScript; the index.html meta CSP explicitly permitted this by including script-src 'self' 'unsafe-eval'. Second, the application exposes an IPC interface that can spawn processes - the bridge the injected JavaScript uses to translate in-page execution into arbitrary command execution on the host. The CPE string cpe:2.3:a:aiql:tuui:*:*:*:*:*:*:*:* confirms the affected product is the AI-QL TUUI application package across all versions before 1.3.4, matching EUVD's 'tuui < 1.3.4' range. The vendor's fix (commit f673fa5b4d76e8236c7d9506d0727875cfa79cc1) removes the ECharts dependency from package.json and package-lock.json, strips the echarts instance registration and import from MarkdownCard.vue in favour of a no-echarts default, and hardens the CSP to script-src 'self' - eliminating both the JavaScript execution sink and the delivery mechanism simultaneously.
Know when Tuui gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:A/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H
Remote delivery of a crafted message with no auth (PR:N) but mandatory victim view (UI:R); sandboxed renderer escaping to OS command execution is a scope change (S:C) yielding full host compromise.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
6DescriptionCVE.org
TUUI is a desktop MCP client designed as a tool unitary utility integration. Prior to 1.3.4, a critical Remote Code Execution (RCE) vulnerability exists in Tuui due to an unsafe Cross-Site Scripting (XSS) flaw in the Markdown rendering component. Tuui allows the execution of arbitrary JavaScript within ECharts code blocks. Combined with an exposed IPC interface that allows spawning processes, an attacker can execute arbitrary system commands on the victim's machine simply by having them view a malicious Markdown message. This vulnerability is fixed in 1.3.4.
Executive ViewAI
A remote code execution vulnerability in TUUI, AI-QL's desktop MCP client, affects every release prior to 1.3.4 and lets a crafted Markdown message execute arbitrary code on an employee's workstation, potentially spawning system-level processes under the user's context. Exploitation requires the victim to actively open the malicious content, and the product's small install base makes this a targeted rather than opportunistic threat, with no public exploit code or confirmed active exploitation at time of analysis. Leadership should care because a successful compromise hands an attacker full control of an endpoint, creating a launch point for credential theft and lateral movement into corporate systems.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Cross-Site Scripting occurs when an application accepts untrusted data and sends it to a web browser without proper validation or encoding.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
EUVD-2025-201459
NVD
CVE.org
EPSS
GitHub
VulDB
Exploit-DB