CVE-2026-22793: 
Homebrew vulnerability analysis and mitigation

CVE-2026-22793 is a critical code injection vulnerability in the ECharts Markdown plugin of 5ire, a cross-platform desktop AI assistant and Model Context Protocol (MCP) client. The flaw allows any user capable of submitting ECharts code blocks to execute arbitrary JavaScript in the renderer context, potentially leading to Remote Code Execution (RCE) and full host system compromise in Electron environments. All versions prior to 0.15.3 are affected. The vulnerability was published on January 21, 2026, with a patch released the same day in version 0.15.3. It carries a CVSS v3.1 base score of 9.6 (Critical) (GitHub Advisory, Red Hat CVE).

The root cause is classified as CWE-94 (Improper Control of Generation of Code / Code Injection). The vulnerability resides in the parseOption function within useECharts.ts, which uses JavaScript's new Function() constructor to dynamically evaluate user-supplied ECharts option strings — a pattern equivalent to eval() on untrusted input. An attacker crafts a malicious ECharts code block (e.g., embedded in a chat message or shared document) that, when rendered, executes arbitrary JavaScript in the Electron renderer process. In environments where Electron's privileged electron.mcp API is exposed to the renderer, this JavaScript execution can invoke system-level commands, escalating to full RCE. The published PoC demonstrates launching calc.exe via electron.mcp.activate() (GitHub Advisory).

Successful exploitation grants an attacker arbitrary JavaScript execution in the Electron renderer context, which — when privileged APIs such as electron.mcp are accessible — escalates to full Remote Code Execution on the host system. The scope is changed (CVSS S:C), meaning the impact extends beyond the vulnerable component to the underlying operating system, with high confidentiality, integrity, and availability impact. An attacker could exfiltrate sensitive data, install persistent malware, pivot to other systems on the local network, or fully compromise the host machine (GitHub Advisory).

A public proof-of-concept is included in the official security advisory, demonstrating RCE via a crafted ECharts code block that invokes electron.mcp.activate() to spawn calc.exe. No authentication is required, though user interaction is needed (a user must render the malicious ECharts block). There is currently no evidence of in-the-wild exploitation or threat actor attribution. The EPSS score is approximately 0.214%, and the vulnerability is not listed in the CISA KEV catalog (GitHub Advisory).

1. Identify target: Locate a 5ire installation running version 0.15.1 or earlier where the attacker can submit content (e.g., via shared AI conversation, MCP tool output, or collaborative session).
2. Craft malicious ECharts block: Prepare a Markdown ECharts code block containing an immediately-invoked JavaScript function that calls privileged Electron APIs:

   ```echarts
   {a: (function() {
     electron.mcp.activate({key:'poc', command:'cmd.exe', args:['/c calc.exe']})
   })()}
   ```

3. Deliver payload: Submit the malicious code block in a context where the target user's 5ire client will render it (e.g., a chat message, AI response injection, or shared document).
4. Trigger rendering: When the victim's 5ire client renders the ECharts block, the parseOption function evaluates the payload using new Function(), executing the embedded JavaScript in the renderer process.
5. Achieve RCE: The JavaScript invokes electron.mcp.activate() (or other exposed privileged APIs), spawning arbitrary system commands on the victim's host — enabling reverse shells, data exfiltration, or persistence (GitHub Advisory).

• Network: Unexpected outbound connections from the 5ire Electron process to unknown external hosts following rendering of ECharts content; unusual DNS queries initiated by the application process.
• Process: Unexpected child processes spawned by the 5ire Electron renderer (e.g., cmd.exe, powershell.exe, bash, sh, calc.exe, curl, wget) with the 5ire process as parent.
• Logs: Application logs showing errors or unusual activity in useECharts.ts or ECharts option parsing; Electron crash reports or renderer process exceptions related to new Function evaluation.
• File System: New or modified files in the 5ire application data directory or user profile directories created by the Electron process; unexpected scripts or executables dropped in temp directories.
• Registry (Windows): New scheduled tasks, run keys, or services created by the 5ire process or its children following ECharts content rendering (GitHub Advisory).

The vendor has released version 0.15.3, which patches this vulnerability by removing the unsafe new Function() usage in the ECharts option parser. All users should immediately upgrade to 5ire v0.15.3 or later. As a temporary workaround for environments that cannot immediately patch, administrators should restrict untrusted users from submitting ECharts code blocks and review/restrict the exposure of privileged Electron APIs (such as electron.mcp) in the renderer process to reduce the attack surface (GitHub Release, GitHub Advisory).

The vulnerability was reported by security researcher c2an1 and disclosed via GitHub's security advisory program. Coverage appeared across vulnerability tracking platforms including CVEFeed, VulnDB, Vulners, and the EU's ENISA EUVD database shortly after disclosure. A technical write-up was published by The Hacker Wire and InfinitSec, and the Spanish national cybersecurity authority (CCN-CERT) also catalogued the vulnerability. Community discussion was noted on Bluesky. No major vendor statements beyond the patch release have been identified (GitHub Advisory).