Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft note filename with embedded double quote
-
DeliveryDeliver file into victim's VNote notebook
-
ExploitVictim opens note (auto or Open With)
-
ExecutionInjected args reach vim/gvim -c sink
-
ImpactArbitrary command execution as user
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization OS command sanitization, avoid shell exec
MITRE ATT&CK
2 techniques across 1 tactic: 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 ALL of the following: (1) a vulnerable VNote install prior to 4.3.0 running on Linux or macOS (Windows is not cited as affected because the double-quote filename vector is POSIX-specific); (2) the victim has configured an external program in SessionConfig::ExternalProgram whose arguments can execute commands - explicitly the vim/gvim '-c' option or an equivalent flag (this is a non-default, user-chosen configuration and the primary limiting factor); (3) an attacker-controlled note whose POSIX filename contains a double quote that terminates the quoted path and appends attacker arguments; and (4) user interaction - the victim must open that note, via either the automatic path (viewareacontroller.cpp openBuffer) or the 'Open With' path (notebooknodecontroller.cpp openNodesWithCommand). The high attack complexity, required user interaction, and dependency on a command-capable external opener substantially limit realistic exploitation despite the full-impact outcome. |
| Impact | This is a genuine but conditional code-execution flaw, not a drop-everything emergency. The CVSS 3.1 vector (AV:L/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H, base 7.0 High) already tells the real story: full C/I/A impact (arbitrary command execution as the user, CWE-78) but gated behind local attack vector, high attack complexity, and required user interaction. Exploitation is not 'remote and automatic' - it depends on the victim running VNote < 4.3.0 on Linux or macOS AND having configured an external program that accepts a command-executing argument (e.g. vim/gvim -c), which is a non-default, user-specific condition. No EPSS score, SSVC decision data, KEV entry, or public POC was provided in the input, so there is no signal of active or widespread exploitation - consistent with a hard-to-automate, config-dependent client-side bug. Note a minor internal tension: CVSS marks AV:L (local), but the malicious note file could plausibly be delivered over a network (shared/synced notebook) before being opened locally; the 'local' label reflects the point of exploitation (opening the file), not necessarily how the file arrives - verify delivery assumptions against your deployment. Net: a real, patch-worthy High for VNote users, but low practical priority for most fleets given the niche product and the multiple preconditions. |
| Exploit ScenarioDerived | An attacker crafts a note file whose POSIX filename embeds a double quote plus injected arguments (e.g. a filename that closes the quoted path and appends '-c ":!<command>"') and gets it into the victim's VNote notebook. When the victim - who has configured gvim/vim (or another argument-executing program) as an external opener - opens the note automatically or via 'Open With', VNote's fetchCommand reparses the string and passes the injected flags to the program, running arbitrary commands as the user. No public exploit code was identified at time of analysis, and the high complexity plus required user interaction make this a targeted rather than mass-exploitable scenario. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 13, 2026
Command injection in the VNote note-taking application before version 4.3.0 lets an attacker-controlled note filename execute arbitrary commands as the victim user on Linux and macOS, but only when the victim opens that note and has configured an external program whose arguments are command-capable, such as vim/gvim's -c option. The root cause is SessionConfig::ExternalProgram::fetchCommand, which wraps the note path in double quotes and hands the whole string to QProcess::start(const QString&), so a double quote inside a POSIX filename terminates the quoted path and appends attacker-chosen arguments to the configured program. The vendor fixed the issue in 4.3.0; no public exploit identified at time of analysis, and the CVSS 3.1 vector (AV:L/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H, base 7.0) reflects full impact on confidentiality, integrity and availability once the narrow exploitation prerequisites are met.
RemediationAI
Upgrade to VNote 4.3.0 or later - the vendor-released fix is available at https://github.com/vnotex/vnote/releases/tag/v4.3.0, and the specific patch is commit 4abaacdb8dd110d279f3290ad7e69f20b2604602 (advisory GHSA-6m2r-wm6v-c8qp). That fix converts fetchCommand() to fetchCommandArgs(), which parses the configured template into an argument list before substituting the note path, and routes launches through QProcess::startDetached(program, args) so filenames are never re-split into new arguments. Until upgrading, the most effective workaround is to stop using external programs whose flags can execute commands: replace any 'vim %1' or 'gvim -c ... %1' entry in the ExternalProgram configuration with a non-shell-capable opener invoked with no command flag, accepting the loss of the editor's startup-command convenience; simply adding or removing quote characters in the template does not fix the flaw because the path is still attacker-influenced. Alternatively, avoid the two reachable paths - the automatic external-program open in viewareacontroller.cpp and the Open With action in notebooknodecontroller.cpp - by not configuring an external program at all, at the cost of removing the feature. Treat note filenames containing double quotes as untrusted and avoid opening such files from untrusted notebooks on Linux or macOS; this is a detection/avoidance measure, not a fix, and is easy to defeat. Applying the 4.3.0 upgrade is the only remediation that eliminates the vulnerability.
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
The issue is a CWE-78 OS command injection caused by string-based process launching in Qt. SessionConfig::ExternalProgram stores a user-configured command template containing a %1 placeholder for the note file; the vulnerable fetchCommand() replaced %1 with a double-quoted copy of the path and returned one QString. That string was passed through ProcessUtils::startDetached() to QProcess::start(const QString&), an overload that re-splits its argument using shell-like quoting rules before exec. Because substitution happened before tokenization, a note filename containing a double quote (a legal character on POSIX filesystems, which is why Linux and macOS are affected while Windows is not cited) closes the quoted path and makes the rest of the filename parse as extra argv elements for the configured program; if that program can execute commands from an argument - the advisory names vim and gvim with -c - arbitrary code runs with the user's privileges (CVSS vector indicates no privileges required, PR:N, with local access and user interaction). The 4.3.0 fix replaces fetchCommand() with fetchCommandArgs(), which tokenizes the user template via ProcessUtils::parseCombinedArgString() first and only then substitutes %1 into a single token, and adds a startDetached(program, args) overload backed by QProcess::startDetached(program, args), so the path can never be re-split. Both reachable call sites - the automatic open path in src/controllers/viewareacontroller.cpp (openBuffer) and the Open With path in src/controllers/notebooknodecontroller.cpp (openNodesWithCommand) - were updated to pass argv explicitly, and regression tests such as testFetchCommandArgs_injectionInert cover the injection case. The affected configuration is non-default: the victim must deliberately have chosen an external program whose arguments are command-capable.
Know when the next one hits your stack
- 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
AV:L/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H
Triggered by opening a local file (AV:L); depends on a non-default command-capable external program plus a crafted filename (AC:H); attacker needs no victim privileges (PR:N) but the user must open the note (UI:R); command execution as user gives full C/I/A.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
2DescriptionCVE.org
VNote is a note-taking platform. Prior to 4.3.0, SessionConfig::ExternalProgram::fetchCommand wraps a note path in double quotes and substitutes it into a command string that QProcess::start(const QString&) reparses into arguments through ProcessUtils::startDetached. The automatic path in src/controllers/viewareacontroller.cpp and the Open With path in src/controllers/notebooknodecontroller.cpp both reach this sink. On Linux and macOS, an attacker-controlled double quote in a POSIX note filename can terminate the quoted path and add arguments to the victim's configured external program. If the configured program supports an argument that executes commands, such as the vim or gvim -c option, the injected arguments can execute arbitrary commands as the user. This issue is fixed in version 4.3.0.
Articles & Coverage 1
Technical POC Analysis
CWE-78 (per the CVE record; the advisory also assigns CWE-88, argument injection).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
VNote note-taking application versions prior to 4.3.0 contain a command injection flaw that lets a specially crafted note filename execute arbitrary commands as the logged-in user on Linux and macOS once that note is opened and an external program with argument-level command capability (such as vim/gvim's -c option) has been configured. Exploitation requires local access, a specific user configuration, and the victim opening the malicious note, so organization-wide exposure is narrow, but any endpoint meeting those prerequisites faces full compromise of that user's confidentiality, integrity and availability. Leadership should treat this as a focused remediation task for the developer and power-user macOS/Linux workstation population running VNote.
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
OS command injection occurs when an application passes unsanitized user input directly into system shell commands.
EUVD-2026-100523
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB