Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver malicious diagram to victim
-
DeliveryTrigger renderer XSS in drawio webapp
-
ExploitGain script execution in file:// origin
-
ExecutionCall readFile IPC with target path
-
PersistMain process returns file bytes
-
ImpactExfiltrate sensitive local files
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Path canonicalization, traversal prevention
MITRE ATT&CK
2 techniques across 2 tactics: Discovery, Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires attacker-controlled script already running in draw.io Desktop's app file:// origin, which per the advisory means a reachable renderer XSS in the drawio webapp (the AT:P attack requirement) and a victim actively opening a malicious diagram file (UI:A). Only then can the un-gated readFile, getFileDrafts, getBkpFile, fileStat, isFileWritable, checkFileExists, and watchFile IPC actions be abused. The readable set is further limited by readFile's checkFileContent sniff, which admits only files whose leading bytes match the diagram/JSON/HTML/PDF/PNG/JPEG/WebP/zip/mx* allowlist or whose extension is .mmd/.mermaid (so JSON/INI/TOML configs beginning with '{' or '[' pass), and by the lexical appBaseDir prefix block that merely excludes the install directory; getFileDrafts/getBkpFile are limited to .$<base>.dtmp/.bkp sibling name patterns. Limiting factors for defenders: attack is local (AV:L), needs a chained XSS, needs user interaction, and yields read-only disclosure - it cannot write or modify files. The only complete fix is updating to 31.4.4; the vendor states there is no user-facing mitigation for the read-side gap beyond opening diagrams only from trusted sources and keeping the app and its webapp submodule updated. |
| Impact | This is a genuine but conditional confidentiality flaw, not a drive-by emergency. The vendor-supplied CVSS 4.0 vector (CVSS:4.0/AV:L/AC:L/AT:P/PR:N/UI:A/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N = 5.6 Medium) is internally consistent with the advisory: AV:L and AT:P/UI:A reflect that exploitation is not remote-unauthenticated against draw.io itself - it is a local primitive that only becomes reachable once an attacker already has script execution in the app's file:// origin, which the advisory states requires a separate renderer XSS in the drawio webapp plus the user opening a malicious diagram. VC:H with VI:N/VA:N correctly captures a read-only disclosure with no write/integrity or availability impact (the companion write-side handlers remain protected by assertWritablePath). No EPSS score, no CISA KEV listing, and no SSVC automatable/technical-impact breakdown were supplied; the only priority signal is the vuln.today Decision label 'this_month', which aligns with a Medium-severity, precondition-gated issue rather than act_now/emergency. The advisory includes a step-by-step proof-of-concept for the main-process read primitive but does not package a working end-to-end exploit (the enabling renderer XSS is explicitly out of scope of this defect). Net: a real, worth-patching authorization-asymmetry bug, but its practical risk is bounded by needing a chained XSS and user interaction, so it is a planned-patch priority, not a widespread-exploitation crisis. Missing data to note: no EPSS and no KEV status were provided, so exploitation-probability cannot be quantified. |
| Exploit ScenarioDerived | An attacker first achieves script execution in draw.io Desktop's file:// origin via a renderer XSS in the drawio webapp, typically by getting the victim to open a malicious diagram file. From that origin the attacker calls the preload bridge's readFile IPC action with an absolute path to a sensitive local file (e.g. a JSON config whose first byte is '{'), and the Electron main process returns its bytes verbatim because the read side lacks the blessed-path check the write side enforces. The vendor advisory documents this as a working proof-of-concept of the primitive, though the enabling XSS is a separate precondition. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 22, 2026
draw.io Desktop 31.4.2 and earlier can disclose the contents of arbitrary local files to script running in the app's own file:// origin, because the Electron main-process read handlers (readFile, getFileDrafts, getBkpFile, fileStat, isFileWritable, checkFileExists, watchFile) never apply the blessed-path authorization that the write handlers enforce. Exploitation is conditional: it requires attacker-controlled script already executing in that origin - per the advisory, a renderer XSS in the drawio webapp reached when a victim opens a malicious diagram - and the readable set is bounded by a content sniff that admits files beginning with '{' or '[' plus known diagram/media formats, or .mmd/.mermaid extensions; the impact is read-only disclosure, with no write, modification, or denial of service. The advisory publishes a PoC of the readFile IPC primitive; it is not verified as working exploit code, and no confirmed active exploitation is reported. Version 31.4.4 contains the vendor-released patch.
RemediationAI
Vendor-released patch: 31.4.4 - upgrade draw.io Desktop to 31.4.4 or later (release notes at https://github.com/jgraph/drawio-desktop/releases/tag/v31.4.4; the fix commit is 9c933514b8bcc90a91d88c685525a8885de4027e). The patch adds an assertReadablePath authorization for the read, stat and watch IPC handlers that realpath-canonicalises the requested path and requires blessed-path membership (or the draft/backup sibling carve-out), and introduces a configReadablePaths set so local libraries, templates and fonts declared in the user's configuration remain readable without widening what the renderer may write. The vendor states there is no user-facing mitigation for the read-side gap on unpatched installs; the only practical reductions in exposure are opening diagram files only from trusted sources (the renderer XSS entry point depends on the victim opening a malicious diagram) and keeping both the application and its bundled webapp submodule current. Because the disclosure is read-only, a compromised renderer cannot use this flaw to alter or delete local files even when the vulnerable build is still in use.
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
draw.io Desktop is an Electron application whose main process exposes a renderer-callable IPC surface through a preload bridge (window.electron.request with an action name and path). The defect is an authorization asymmetry: write-side actions (saveFile, writeFile, saveDraft, deleteFile) call assertWritablePath, which realpath-canonicalises the requested path and requires membership in blessedPaths - the set of paths the user authorized through OS chrome such as the file picker, file associations or argv. The read-side actions in the affected releases are gated only by validateSender, a frame.url.startsWith(codeUrl) origin-prefix check that the code's own comment acknowledges a renderer-side XSS would pass. For readFile alone there is additionally a magic-byte content sniff (checkFileContent) that accepts any file whose leading bytes match the diagram/JSON/HTML/PDF/PNG/JPEG/WebP/zip/mx* allowlist - notably any file starting with '{' or '[' - plus a lexical path.resolve(filename).startsWith(appBaseDir) exclusion that only keeps the application install directory out and does not canonicalise symlinks. This maps to CWE-22 (improper limitation of a pathname to a restricted directory) as the root cause, with CWE-200 (exposure of sensitive information) as the resulting impact class; the sibling handlers getFileDrafts and getBkpFile read .$<base>[_N].dtmp and .$<base>.bkp/~$<base>.bkp siblings with no content sniff and no directory check, and fileStat, isFileWritable, checkFileExists and watchFile act as un-gated metadata and existence oracles. The CPE cpe:2.3:a:jgraph:drawio-desktop:*:*:*:*:*:*:*:* covers the Electron desktop build prior to the fix, which introduces an assertReadablePath check that realpath-canonicalises read/stat/watch targets, plus a separate configReadablePaths set for local libraries, templates and fonts declared in the user's configuration (jgraph/drawio-desktop#1278) that is never consulted by the write path.
Know when Drawio Desktop 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:L/AC:L/AT:P/PR:N/UI:A/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N
Local primitive reachable only via a chained renderer XSS and opened malicious file, so AV:L, AC:H and UI:R; read-only disclosure gives C:H with I:N/A:N.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
draw.io Desktop is the official Electron build of draw.io. Prior to 31.4.4, draw.io Desktop is vulnerable to arbitrary local-file disclosure through the Electron main process's read-side IPC handlers. The readFile, getFileDrafts, getBkpFile, fileStat, isFileWritable, checkFileExists, and watchFile actions operate on a renderer-chosen filesystem path with no blessed-path (assertWritablePath) authorization. The only gates are validateSender - a URL-prefix origin check - plus, for readFile alone, a content "sniff" and a lexical appBaseDir prefix block. The write-side handlers (saveFile, writeFile, saveDraft, deleteFile) are all protected by assertWritablePath; the read side is not. The result is a read/write authorization asymmetry: any frame executing in the app's file:// origin can read the contents of local files that the same origin is explicitly forbidden to write. This issue is fixed in version 31.4.4.
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
Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.
EUVD-2026-108231
NVD
CVE.org
EPSS
GitHub
VulDB
Exploit-DB