Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessInfluence agent tool calls via prompt injection
-
ExploitInject shell metacharacters into tool parameters
-
ExecutionReach asyncio.create_subprocess_shell unsanitized
-
ImpactExecute arbitrary commands as MCP server 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 a running esp-mcp instance (through commit 28afddf) wired to an LLM agent whose tool calls an attacker can influence - typically via prompt injection - such that attacker-controlled shell metacharacters reach the target, port, project_path, or project_name parameters that esp-mcp passes to asyncio.create_subprocess_shell (main.py line 80). Limiting factors: the CVSS vector is AV:L (local), the agent must actually expose these tools and accept attacker-influenced input, and PR:L indicates some privilege/access to the MCP tool interface is needed; there is no network-facing default-configuration path and no fixed version is identified in the supplied data, so updating guidance cannot be stated from this input. |
| Impact | Signals are mixed and point to a real but non-urgent, narrowly-scoped issue. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:L/UI:N) describes a local, low-complexity flaw requiring some privilege and no user interaction, with high impact to confidentiality, integrity and availability of the vulnerable system (VC:H/VI:H/VA:H) and no subsequent-system impact (SC/SI/SA:N); CVSS score is 8.5 (High). The vuln.today Decision label is this_week, i.e. prioritize but not an emergency. No EPSS score and no KEV status were supplied, so exploitation probability and active-exploitation status cannot be quantified from this data; absence of KEV means there is no confirmation of in-the-wild use. A VulnCheck advisory and a GitHub issue (#49) are referenced, but the input does not flag confirmed working exploit code, so this should be treated as public technical disclosure rather than a verified weaponized exploit. The key tension is the AV:L (local) rating versus the real trigger: exploitation is driven by prompt injection into an LLM agent's tool calls, meaning the 'local' vector actually masks an indirect, attacker-influenced input path through the agent - verify this framing against the VulnCheck advisory. Overall this is a genuine command-injection flaw worth patching promptly, but the real-world footprint of the affected product sharply limits aggregate risk. |
| Exploit ScenarioDerived | An attacker who can influence an LLM agent's inputs (e.g., via prompt injection in a document or web content the agent processes) induces the agent to call an esp-mcp tool with shell metacharacters embedded in the target, port, project_path, or project_name parameter. Because these values are passed to asyncio.create_subprocess_shell without sanitization, the injected commands execute as the MCP server user. Public advisory and issue references describe the flaw, but the input does not confirm verified working exploit code. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
OS command injection in the esp-mcp MCP server (all versions through commit 28afddf9ff41ada117bb45fd49b526d3bf89749e) lets an attacker who can influence LLM agent tool calls - typically through prompt injection - place shell metacharacters into the target, port, project_path or project_name parameters, which are handed to asyncio.create_subprocess_shell at main.py line 80; the injected commands then execute as the user running the MCP server. The assessed vector is CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (8.5), so exploitation presupposes low-privileged access to the tool interface plus an agent deployment that actually exposes these tools and accepts attacker-influenced input, rather than a network-reachable default path; no public exploit has been identified at time of analysis and no fixed version is identified in the supplied data. Overall risk signals are mixed, indicating a real but non-urgent and narrowly-scoped issue that should be scheduled for this week rather than treated as an emergency.
RemediationAI
No vendor-released patch or fixed version is identified in the supplied data, so upgrading cannot be prescribed from this input; the authoritative place to track status is upstream issue https://github.com/horw/esp-mcp/issues/49 and the project repository https://github.com/horw/esp-mcp, with the VulnCheck advisory at https://www.vulncheck.com/advisories/esp-mcp-through-commit-28afddf-os-command-injection-via-mcp-tool-parameters as secondary tracking. Until a fix is published, the exposure is bounded by the assessed prerequisites rather than by generic hardening: an esp-mcp instance is only reachable through this flaw when it is wired to an LLM agent whose tool calls an attacker can influence, so deployments that do not expose the affected tools (those taking target, port, project_path or project_name) to untrusted content or untrusted prompt sources should disable or withhold those tool definitions from the agent, accepting the loss of that functionality as the trade-off. Equally, because the vector is AV:L with PR:L, the practical blast radius is the privilege of the account running the MCP server, so running esp-mcp under a dedicated low-privilege identity whose environment contains no sensitive credentials limits the consequences of a successful injection but does not prevent it. Note that these are deployment-level exposure reductions only; the injection sink at main.py line 80 remains until the upstream code stops routing these parameters through asyncio.create_subprocess_shell.
Affected VersionsENISA
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
esp-mcp is a Python Model Context Protocol server that exposes ESP-related operations as agent tools. The root cause is CWE-78 (Improper Neutralization of Special Elements used in an OS Command), which in this codebase manifests as argument strings - target, port, project_path and project_name - being passed into asyncio.create_subprocess_shell; because that API always runs the command through a system shell, values containing shell metacharacters are interpreted by the shell instead of being treated as inert data. The vulnerable sink is documented at main.py line 80 of commit 28afddf9ff41ada117bb45fd49b526d3bf89749e, and the CPE string cpe:2.3:a:horw:esp-mcp:*:*:*:*:*:*:*:* indicates no version restriction was applied, i.e. the entire esp-mcp code line up to and including that commit is in scope. The delivery path is indirect: an LLM agent decides to invoke the tool, so an attacker who can shape the model's tool-call arguments (for example via prompt injection in content the agent processes) supplies the malicious parameter values without ever touching the MCP server directly. The precise conditions under which hostile input reaches those four parameters in a given deployment are not described in the available sources; what is confirmed is the sink and the parameter list, while which tools are enabled, how arguments are assembled, and whether any validation exists are unverified from this input.
Know when Esp Mcp 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:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Trigger is local via the MCP tool interface (AV:L) with some access required (PR:L), no user interaction, and command execution as the server user yields full host CIA impact (C/I/A:H).
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
esp-mcp through commit 28afddf contains an OS command injection vulnerability that allows attackers to run arbitrary commands by supplying shell metacharacters in MCP tool parameters. Attackers influencing agent tool calls through prompt injection can inject metacharacters into target, port, project_path, or project_name values passed to asyncio.create_subprocess_shell, executing commands as the MCP server user.
Executive ViewAI
The esp-mcp MCP server, used to enable LLM agent tool calls, contains an OS command injection vulnerability (CVE-2026-117567) that allows an authenticated low-privileged attacker to execute arbitrary commands via prompt injection. This impacts organizations deploying this server, potentially leading to data compromise and system integrity loss. Leadership should prioritize patching within the week given the high severity but limited exploitability.
No vendor patch is available. Interim mitigations include restricting access to the MCP server to trusted users, implementing strict input validation to reject shell metacharacters in affected parameters, running the server with least privilege, and monitoring tool call logs for suspicious activity.
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-110845
GHSA-3w6w-vpcf-fv9h
NVD
CVE.org
EPSS
Exploit-DB