python-utcp CVE-2025-14542
HIGHAttack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessVictim trusts remote Manual Endpoint
-
DeliveryProvider serves benign HTTP manual
-
ExploitProvider later swaps in malicious CLI manual
-
ExecutionClient fetches and registers tools
-
ImpactArbitrary OS commands execute on client host
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V14 - Data Protection Trust boundary enforcement
|
| Exploitation Conditions | Exploitation requires the UTCP client to fetch its tool Manual from an attacker-controlled or later-compromised remote Manual Endpoint that the operator has configured and trusts, and it leverages protocol escalation - a manual served over one protocol (e.g. HTTP) registering CLI-protocol tools that execute OS commands via the CLI plugin. Limiting factors that reduce realistic risk: the victim must first trust the provider and then invoke the swapped tool (UI:R), the trust-then-switch sequence raises attack complexity (AC:H), and the behavior is neutralized in fixed builds where allowed_communication_protocols defaults to the manual's own protocol type, filtering out and rejecting foreign-protocol tools at both registration and call time. Clients that only consume their own or fully trusted first-party manual endpoints are not practically exposed. |
| Impact | Scored CVSS 7.5 (HIGH) with vector AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H. The network attack vector and lack of required privileges (PR:N) sound alarming, but two metrics materially reduce real-world risk: AC:H reflects the multi-stage time-of-check/time-of-use trust abuse (the provider must first earn trust with a benign manual, then swap in a malicious one), and UI:R means the victim client must actually fetch and invoke the tampered tool. No EPSS score, no CISA KEV entry, and no public POC are present in the provided data, so by the precision rules this is 'no public exploit identified at time of analysis' - not active exploitation. The input Tag labels this 'Information Disclosure,' but the JFrog advisory title (python-utcp-untrusted-manual-command-execution) and the fix - which adds protocol restrictions to stop an HTTP manual from invoking CLI tools - make clear the true impact is arbitrary OS command execution on the client host, consistent with C:H/I:H/A:H and CWE-501 (Trust Boundary Violation). Net assessment: a genuine design-level flaw for anyone consuming third-party/untrusted UTCP manual endpoints, but practical exploitation is gated on the victim trusting a malicious or compromised provider rather than being a mass-exploitable remote bug. CONFLICT TO NOTE: the 'Information Disclosure' tag understates and mischaracterizes the command-execution impact documented by the vendor. |
| Exploit ScenarioDerived | A developer configures a UTCP client to consume a remote Manual Endpoint from a third-party provider, which initially serves a benign HTTP tool manual and earns the client's trust. The provider (or an attacker who later compromises it) swaps the manual for one that registers CLI-protocol tools; when the client fetches and invokes a tool, attacker-chosen OS commands execute on the client host via protocol escalation. No public exploit code is identified at time of analysis, though the JFrog research advisory documents the technique in detail. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
Protocol escalation in the Universal Tool Calling Protocol (UTCP) Python client allows a malicious or later-compromised remote Manual Endpoint to execute arbitrary operating-system commands on the client host. Because the client trusts the provider's JSON tool specification, a provider can serve a benign HTTP-based Manual to establish trust and then swap it for a Manual that registers CLI-protocol tools, which the CLI plugin executes as shell commands (CWE-501, trust boundary violation). Scored CVSS 7.5 (HIGH) with vector AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H - reachable by unauthenticated remote attackers but requiring the victim to trust the provider and invoke the swapped tool; no public exploit identified at time of analysis, though an upstream fix is available.
RemediationAI
Upstream fix available (PR/commit); released patched version not independently confirmed - deploy the python-utcp build containing commit 2dc9c02df72cad3770c934959325ec344b441444 and validate against https://github.com/universal-tool-calling-protocol/python-utcp/commit/2dc9c02df72cad3770c934959325ec344b441444 plus the advisory at https://research.jfrog.com/vulnerabilities/python-utcp-untrusted-manual-command-execution-jfsa-2025-001648329/. On patched builds, leave allowed_communication_protocols at its secure default (it mirrors the Manual's own call_template_type) and only widen it - for example to ["http", "cli"] - when a specific integration genuinely needs multiple protocols, accepting that this re-opens the escalation path for that Manual. Because pre-fix releases do not support the field at all, there is no configuration-only workaround on vulnerable code: the practical compensating controls are to consume Manuals exclusively from first-party or cryptographically trusted endpoints, to treat any third-party Manual Endpoint as untrusted code execution input (which effectively forbids the feature), and to run the UTCP client inside a restricted sandbox - non-root user, read-only filesystem mounts, no network egress beyond allow-listed endpoints, and no access to cloud credentials or host sockets - so that a swapped Manual's CLI commands cannot reach sensitive resources. Pinning Manual contents or applying endpoint-side integrity checks (signing or hashing the Manual and rejecting changes after initial trust establishment) mitigates the trust-then-switch sequence, but each of these adds operational overhead and must be re-validated whenever a provider legitimately updates its Manual.
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in pypi
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
UTCP (Universal Tool Calling Protocol) is a tool-calling framework in which a client fetches a JSON 'Manual' describing available tools from a remote Manual Endpoint, then registers those tools locally. Each Manual declares a call_template_type (for example http, cli, mcp, websocket), and the corresponding plugin handles execution - critically, the CLI plugin runs commands in a single subprocess (Bash on Unix, PowerShell on Windows) and supports multi-step command sequences, environment variables and argument placeholders, giving any registered CLI tool effective shell access. The root cause is CWE-501, a trust boundary violation: the client did not constrain which communication protocols a Manual was permitted to register tools for, so an HTTP-facing Manual could advertise tools implemented over the CLI protocol and have them silently registered and later executed. The upstream fix introduces an allowed_communication_protocols field that defaults to the Manual's own call_template_type, so an http Manual may only register http tools unless an operator explicitly widens the list. The fix enforces this at two points: during register_manual() foreign-protocol tools are filtered out with a warning, and at call time any tool whose protocol is not permitted raises ValueError.
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:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H
Remote manual endpoint (AV:N) with no client auth (PR:N); the trust-then-switch sequence and required victim tool invocation drive AC:H and UI:R, and CLI command execution yields full C/I/A.
Primary rating from Vendor (jfrog).
CVSS VectorVendor: jfrog
DescriptionCVE.org
The vulnerability arises when a client fetches a tools’ JSON specification, known as a Manual, from a remote Manual Endpoint. While a provider may initially serve a benign manual (e.g., one defining an HTTP tool call), earning the clients’ trust, a malicious provider can later change the manual to exploit the client.
Executive ViewAI
The Universal Tool Calling Protocol (UTCP) Python client contains a high-severity trust boundary vulnerability (CVE-2025-14542) that allows a malicious or compromised remote Manual Endpoint to execute arbitrary operating-system commands on the client host. Organizations using this client to integrate with third-party tool providers are at risk of full system compromise, data theft, and lateral movement, as the attack requires only that a user trusts and invokes a swapped tool. No vendor-released patch identified at time of analysis, and leadership should prioritize immediate mitigation because the vulnerability is remotely reachable without authentication, though user interaction is required.
No vendor-released patch identified at time of analysis. Interim mitigations include: disabling the CLI-protocol plugin where not required; restricting Manual Endpoint trust to a static allowlist of verified providers; implementing application allowlisting and endpoint detection and response (EDR) rules to block unexpected shell command execution from the UTCP client; enforcing network segmentation and egress filtering; and monitoring for anomalous child processes spawned by the Python interpreter. Additionally, user awareness training should caution against invoking tools from untrusted providers.
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.
NVD
CVE.org
EPSS
GitHub
Exploit-DB