Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAttacker injects HTML payload into markdown source or AI chat response
-
DeliveryVictim opens malicious content in FlyEnv interface
-
ExploitVue v-html directive renders unsanitized HTML into DOM
-
ExecutionInjected script executes in Electron renderer with Node.js integration active
-
PersistScript accesses fs and child_process APIs
-
ImpactExfiltrate credentials or achieve persistent local code execution
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 that the victim opens and views content within FlyEnv's markdown rendering or AI chat interface that has been influenced by the attacker. Specifically, the attacker must be able to inject arbitrary HTML into a markdown source file rendered by FlyEnv (e.g., a project documentation file, a README, or any markdown FlyEnv processes) or into AI chat responses displayed within the application. No authentication is required on the attacker's side; however, the victim must actively open and view the malicious content within the FlyEnv UI (UI:P in CVSS 4.0 terms). Exploitation is restricted to FlyEnv versions prior to 4.18.0. The critical amplifying condition is that FlyEnv's Electron renderer process runs with Node.js API access enabled - without this, the XSS would be contained to the renderer sandbox. Exploitation is further limited by the need to influence a content source the target developer actually opens in FlyEnv, requiring either social engineering, a supply chain compromise of a dependency's documentation, or control over an AI API endpoint the application queries. |
| Impact | The official CVSS 4.0 score of 5.3 reflects conservative subsequent-system impact metrics (SC:L/SI:L/SA:N), but this materially underestimates real-world severity for Electron applications where renderer-process XSS is functionally equivalent to local code execution - even a mid-sized municipal IT team in mielec relying on FlyEnv in their developer workflow should treat this as a high-priority upgrade rather than a routine medium finding. The attack vector is Network with no privileges required and only passive user interaction (viewing rendered content), removing significant delivery friction. A publicly available exploit at GitHub issue #809 eliminates the research barrier for opportunistic attackers. KEV status is not confirmed by CISA, and no EPSS score was provided in available intelligence, so exploitation breadth cannot be quantified from those signals. The realistic threat is targeted rather than mass exploitation: an attacker who can poison a markdown documentation source or manipulate an AI chat API response can achieve full local system access on the victim developer's machine - a high-value pivot point for software supply chain compromise scenarios. The official CVSS score likely reflects a conservative interpretation of the Electron threat model; defenders should apply their own higher-severity weighting for environments where developer machines are high-value targets. |
| Exploit ScenarioDerived | An attacker who controls or compromises a markdown documentation source consumed by FlyEnv - such as a project README in a developer's local repository - embeds a crafted script tag in the markdown. When the developer opens FlyEnv and views the rendered documentation, the unsanitized HTML executes JavaScript in the Electron renderer process with active Node.js integration. The script calls child_process.exec to spawn a reverse shell or fs.readFileSync to exfiltrate SSH private keys and stored credentials, with a publicly available proof-of-concept at https://github.com/xpf0000/FlyEnv/issues/809 demonstrating this execution path. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 10, 2026
Stored XSS in FlyEnv before 4.18.0 allows remote attackers to execute arbitrary JavaScript in the Electron renderer process by injecting unsanitized HTML through markdown sources or AI chat messages rendered via Vue v-html directives. Because FlyEnv's Electron renderer operates with Node.js API integration active, exploitation escalates beyond conventional XSS to effective local code execution with unrestricted filesystem access on the developer's machine. A publicly available exploit exists at GitHub issue #809, and vendor-released patch v4.18.0 addresses the flaw.
RemediationAI
Upgrade FlyEnv to version 4.18.0 immediately; the release is available at https://github.com/xpf0000/FlyEnv/releases/tag/v4.18.0 and the underlying fix is documented in commit 68fd6d7b200273ad0a8bce09424b8bd87134cfb6 and PR #810. If immediate upgrade is not feasible, disable or avoid using FlyEnv's markdown rendering and AI chat features entirely until the patch is applied, accepting loss of those functional capabilities as the trade-off. As a defense-in-depth measure regardless of patch status, consider applying OS-level filesystem restrictions (macOS TCC policies, AppArmor profiles on Linux, or Windows integrity levels) to limit FlyEnv's access to sensitive directories such as SSH key stores and credential files, reducing the blast radius of a successful exploit. Additional advisory context is available from VulnCheck at https://www.vulncheck.com/advisories/flyenv-cross-site-scripting-via-v-html.
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
FlyEnv (CPE: cpe:2.3:a:xpf0000:flyenv:*:*:*:*:*:*:*:*) is a developer environment management desktop application built on Electron and Vue.js. Electron embeds a Chromium renderer alongside a Node.js runtime; when nodeIntegration is enabled in the renderer process, client-side script execution gains access to the full Node.js API surface - including fs, child_process, and net - capabilities far beyond those available inside a standard browser sandbox. The root cause is CWE-79 (Improper Neutralization of Input During Web Page Generation), specifically the unsafe use of Vue's v-html directive to inject raw HTML derived from markdown rendering and AI chat responses without prior sanitization. Any HTML tags, inline event handlers, or script elements embedded in that content are passed directly to the DOM and execute with the renderer's elevated privileges. The fix was delivered in commit 68fd6d7b200273ad0a8bce09424b8bd87134cfb6 via PR #810, implementing sanitization before content reaches v-html.
Know when Flyenv 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:L/AT:N/PR:N/UI:P/VC:N/VI:N/VA:N/SC:L/SI:L/SA:N
Network-delivered content requires no attacker privileges; scope changes because Electron Node.js integration gives the injected script high confidentiality and integrity access beyond the renderer.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
FlyEnv before 4.18.0 fails to sanitize HTML from markdown rendering and AI chat content passed to Vue v-html directives. Attackers can inject malicious scripts through markdown sources or chat messages that execute in the Electron renderer process with access to Node.js APIs and the filesystem.
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.
EUVD-2026-55796
GHSA-w92g-j683-fhvq
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB