Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach exposed Execute Endpoint
-
DeliveryInject metacharacters into command/shell arg
-
Exploitsubprocess.run executes payload
-
ExecutionArbitrary commands run as server user
-
ImpactHost compromise
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 | Requires that the AnyTool 0.1.0 local_server Execute Endpoint (anytool/local_server/main.py) be network-reachable by the attacker; per the CVSS vector this is unauthenticated (PR:N) with no user interaction (UI:N) and low complexity. The concrete prerequisite is that the 'command'/'shell' argument accepted by the Execute Endpoint reaches subprocess.run, so any deployment exposing that endpoint on an accessible interface is exploitable. Primary limiting factor is exposure/deployment: this is an early-stage research tool typically run locally, so risk depends on whether the local_server is bound to a reachable network interface rather than loopback-only. |
| Impact | The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) describes a remotely reachable, low-complexity, unauthenticated OS command injection - the highest-exposure profile possible - yet VulDB rated only 6.9 by scoring impact conservatively as VC:L/VI:L/VA:L. That impact rating understates a CWE-78 flaw where user-controlled 'command'/'shell' arguments flow into subprocess.run: successful command injection typically yields full code execution on the host, warranting HIGH confidentiality/integrity/availability rather than LOW. Exploitation status is 'publicly available exploit code exists' (POC referenced in GitHub issue #6); there is no EPSS score and no CISA KEV listing, so there is 'no public exploit identified' as actively exploited in the wild - treat as POC-available but not confirmed weaponized. The controlling limiter is not the vulnerability mechanics (which are trivial) but deployment footprint: AnyTool 0.1.0 is an early-version niche open-source research/agent tool from HKUDS, so real-world exposure is small. Net: technically a serious unauthenticated RCE-class bug, but priority is moderated by rarity and the absence of active-exploitation signals. The E:P (Proof-of-Concept) exploit maturity in the vendor vector aligns with the POC-available finding. |
| Exploit ScenarioDerived | An attacker locates an exposed AnyTool local_server Execute Endpoint and sends a crafted request whose 'command' or 'shell' argument embeds shell metacharacters or additional commands. Because subprocess.run executes the attacker-influenced string without sanitization and no authentication is required, the injected commands run in the context of the server process, giving arbitrary command execution on the host. A public proof-of-concept exists in GitHub issue #6, lowering the skill barrier. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 30, 2026
Unauthenticated OS command injection in HKUDS AnyTool 0.1.0 lets a remote attacker execute arbitrary shell commands on the host running the tool, because the Execute Endpoint in anytool/local_server/main.py passes attacker-controlled 'command'/'shell' arguments directly into subprocess.run. Per the CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) the endpoint requires no credentials or user interaction, so any deployment that exposes the local_server on a reachable interface - rather than loopback-only - is directly exploitable. Publicly available exploit code exists, and the project was notified via GitHub issue #6 but has not responded; no vendor patch has been identified at time of analysis. VulDB scored this 6.9 by rating impact conservatively as VC:L/VI:L/VA:L, while our independent assessment (CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) treats shell-level compromise of the host as high impact - treat the practical risk as higher than the published 6.9 suggests.
RemediationAI
No vendor-released patch identified at time of analysis: the maintainers were notified via https://github.com/HKUDS/AnyTool/issues/6 but had not responded, so upgrading is not yet an option - verify periodically against https://github.com/HKUDS/AnyTool/ and the VulDB advisory https://vuldb.com/vuln/411510 for a fixed release before assuming safety. In the meantime, the highest-value control is exposure reduction: bind the AnyTool local_server strictly to 127.0.0.1 (loopback) rather than 0.0.0.0, or block its listening port at the host and network firewall, which removes the remote attack path entirely at the cost of losing remote access to the tool. If the endpoint must remain reachable, place it behind an authenticating reverse proxy and network ACLs limited to trusted hosts - this mitigates PR:N exposure but does nothing against an attacker who gains a foothold on an allowed host. At the code level, avoid shell interpretation when calling subprocess.run (drop shell=True and pass an argument list) and enforce a strict allowlist of permitted binaries and flags on the Execute Endpoint; this preserves functionality but will break legitimate commands outside the allowlist, so it requires tuning. As a defense-in-depth measure, run AnyTool in a container or sandbox with a read-only root filesystem, dropped capabilities and no host mounts, so a successful injection yields limited post-exploitation capability - note this constrains but does not prevent command execution inside the sandbox. Given that public exploit code exists, prioritize these measures for any instance reachable beyond localhost.
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 flaw is a classic CWE-78 OS command injection in Python. AnyTool is an early-stage research agent toolkit from the HKU Data Intelligence Lab (HKUDS) that exposes a 'local_server' component whose Execute Endpoint accepts a command/shell parameter and forwards it to subprocess.run in anytool/local_server/main.py. When the argument is used with shell interpretation (e.g., shell=True or unvalidated string assembly), shell metacharacters such as ';', '&&' or backticks let a caller append arbitrary commands that execute with the privileges of the AnyTool process. The CPE cpe:2.3:a:hkuds:anytool:*:*:*:*:*:*:*:* indicates the affected product line with no version constraint applied in the CPE itself, but the description and issue report pin the issue to 0.1.0. Because this is an agent/tool-execution framework, the endpoint exists specifically to run commands, so the injection surface is the intended feature rather than an incidental parser bug - meaning trivial input validation bypasses are likely and generic 'sanitize the input' guidance may be insufficient. The attack requires only network reachability of the Execute Endpoint; per the vector (PR:N, UI:N, AC:L, AT:N) there are no authentication or interaction barriers in front of the vulnerable call.
Know when Anytool 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:N/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N/E:P
Unauthenticated network-reachable endpoint (PR:N/UI:N/AC:L) feeding user input into subprocess.run yields full OS command execution, so C/I/A:H.
Primary rating from Vendor (VulDB).
CVSS VectorVendor: VulDB
Lifecycle Timeline
2DescriptionCVE.org
A vulnerability was identified in HKUDS AnyTool 0.1.0. Affected is the function subprocess.run of the file anytool/local_server/main.py of the component Execute Endpoint. The manipulation of the argument command/shell leads to os command injection. It is possible to initiate the attack remotely. The exploit is publicly available and might be used. The project was informed of the problem early through an issue report but has not responded yet.
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-89574
GHSA-6cjx-pvcp-jvqq
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB