Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSupply malicious tool URL in call template
-
DeliveryBypass prefix check or absent WSS validation
-
ExploitPlugin connects to internal/metadata endpoint
-
ExecutionConfigured auth headers forwarded outbound
-
ImpactAPI keys and OAuth tokens exfiltrated
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V4 - API and Web Service URL allowlisting, SSRF prevention
MITRE ATT&CK
2 techniques across 2 tactics: Initial Access, Credential Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The application must use the utcp-gql (GraphQL) or utcp-websocket plugin at version <=1.1.0 and process a tool or manual call-template URL that the attacker can control (via register_manual or call_tool). For utcp-gql the attacker needs DNS control over an external domain so a bypass hostname (e.g. http://127.0.0.1.attacker.example or http://localhost.evil.com) satisfies the startswith prefix check and resolves to an internal/metadata address; utcp-websocket performs no URL validation at all, so any ws/wss URL works. Exploitation is limited by the need for the victim system to ingest the attacker-supplied URL (UI:P) and, for the GraphQL path, attacker-controlled DNS resolution (AC:H/AT:P). Impact is amplified only when auth headers (API keys/OAuth tokens) are configured on the call template. |
| Impact | This is a genuine but low-urgency SSRF (CWE-918). The vendor CVSS 4.0 score of 2.3 is deliberately low, driven by AC:H (the bypass requires the attacker to control DNS for a domain like attacker.example so a hostname such as http://127.0.0.1.attacker.example resolves to an internal target), AT:P (present attack requirement - a specific injectable call-template URL path), UI:P (the victim system must register/process the attacker-supplied tool or manual), and only Low confidentiality/integrity impact. No EPSS score is provided, there is no CISA KEV listing, and no public exploit was identified - so this is neither actively exploited nor widely automatable. The GHSA advisory contains detailed root-cause mechanics (exact vulnerable startswith check, file/line references) but not a packaged exploit. The signals are internally consistent: low CVSS, no KEV, no POC, niche product all point to a low real-world priority. The one factor that raises impact above pure blind SSRF is credential leakage: both plugins attach the call template's configured auth headers, so a forced outbound connection can exfiltrate API keys and OAuth tokens to an attacker-controlled host - worth patching promptly for anyone running these specific plugins. |
| Exploit ScenarioDerived | An application built on python-utcp loads a tool manual or call template whose URL the attacker influences; using the GraphQL plugin the attacker supplies http://127.0.0.1.attacker.example/graphql (which passes the flawed startswith prefix check), or via the WebSocket plugin any URL (no validation at all). When the plugin connects, it targets internal services or cloud metadata (e.g. 169.254.169.254) and forwards the configured auth headers, leaking API keys and OAuth tokens to the attacker's host. No standalone public exploit exists, though the advisory documents the bypass mechanics in full. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 27, 2026
Server-side request forgery in the UTCP Python GraphQL (utcp-gql) and WebSocket (utcp-websocket) plugins at 1.1.0 and earlier lets unauthenticated attackers (CVSS 4.0 vector PR:N, and the assessed 3.1 vector AV:N/AC:H/PR:N/UI:R/S:C/C:L/I:L/A:N) force the host to open outbound connections to internal services and cloud metadata endpoints such as 169.254.169.254. utcp-gql still relies on a startswith prefix check for http://localhost and http://127.0.0.1, so crafted hostnames like http://127.0.0.1.attacker.example or http://localhost.evil.com satisfy the check and then resolve to any address the attacker's DNS returns, while utcp-websocket performs no URL validation at all despite docstrings claiming it enforces 'WSS or localhost only'. Both plugins attach the call template's configured auth headers to the outbound connection, so a successful SSRF also exfiltrates configured API keys and OAuth tokens to the attacker-controlled host; risk is genuine but low urgency, exploitation requires the victim to ingest an attacker-supplied tool or manual call-template URL (UI:P/UI:R) and, for the GraphQL path, attacker-controlled DNS resolution, and no public exploit identified at time of analysis (no CISA KEV entry, no POC reported).
RemediationAI
Vendor-released patch: upgrade utcp-gql and utcp-websocket to 1.1.1 (python-utcp 1.1.1), which applies the CVE-2026-44661 ensure_secure_url()/is_secure_url() hostname-aware validation to both plugins (fix commit fc3268e2a62e1181f91a63faf0a9bcee7639db29; advisory GHSA-ppx3-28rw-8fpf). If immediate upgrade is not possible, apply targeted compensating controls rather than generic hardening: strictly allowlist the hostnames/schemes accepted by register_manual and call_tool so no user- or template-supplied URL reaches AIOHTTPTransport or the WebSocket client, and reject anything that is not an exact loopback literal (127.0.0.1, ::1, localhost) or an explicitly trusted HTTPS host - hostname/prefix string checks cannot be made safe here, so exact-match or resolved-IP validation is required. Block outbound egress from the process to link-local 169.254.169.254/169.254.0.0-16, RFC1918 ranges, and loopback where the plugin is not meant to reach them, and enforce IMDSv2 or disable the instance metadata service on cloud hosts - trade-off is that legitimate internal tool endpoints will also be blocked unless explicitly exempted, and metadata hardening may affect unrelated instance-role consumers. Stop attaching API keys/OAuth tokens to call templates that can reference non-trusted URLs, and rotate any credentials that may already have been sent to an attacker-controlled host. Each mitigation is a partial control, since the root cause is the missing hostname-aware URL validation in the plugin code.
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
CVE-2026-101061 is a CWE-918 server-side request forgery caused by an incomplete fix of CVE-2026-44661 (commit 5b16e43), which introduced the ensure_secure_url()/is_secure_url() helpers in utcp_http/_security.py and wired them only into the three HTTP-family plugins (http, streamable_http, sse). The commit message referred to 'replacing the duplicated prefix check', and the new docstring explicitly warned that URLs whose hostname starts with localhost/127.0.0.1 but is not actually loopback (http://localhost.evil.com, http://127.0.0.1.attacker.example) slipped past the earlier startswith check - yet that vulnerable check survives in plugins/communication_protocols/gql/src/utcp_gql/gql_communication_protocol.py line 43 (_enforce_https_or_localhost), called on manual_call_template.url in register_manual (line 102) and on tool_call_template.url in call_tool (line 181), before the URL is handed to AIOHTTPTransport for a live GraphQL request. Because 'http://127.0.0.1.attacker.example/graphql'.startswith('http://127.0.0.1') is True, an attacker with DNS control over the suffix domain can make the hostname resolve to 127.0.0.1, RFC1918 space, or the cloud metadata address 169.254.169.254. The WebSocket plugin takes the mirror-image failure: it performs no URL validation at all, so arbitrary ws/wss URLs are accepted despite documentation promising WSS/localhost-only enforcement. The SSRF is amplified into credential disclosure because both plugins propagate the call template's configured API keys and OAuth tokens as auth headers on the outbound connection to the attacker-controlled endpoint. The listed CPE (cpe:2.3:a:universal-tool-calling-protocol:python-utcp) and EUVD-2026-87986 both track the python-utcp package line at 0 to <1.1.1.
Know when Python Utcp 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:H/AT:P/PR:N/UI:P/VC:L/VI:L/VA:N/SC:L/SI:L/SA:N
Remote and unauthenticated but AC:H (needs attacker DNS control / bypass crafting) and UI:R (victim must load the malicious tool URL); S:C as the SSRF reaches internal systems and leaks headers, with Low C/I and no availability impact.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
1DescriptionCVE.org
utcp-gql before 1.1.1 and utcp-websocket before 1.1.1 contain server-side request forgery vulnerabilities due to incomplete application of CVE-2026-44661 fixes. The GraphQL plugin uses a vulnerable prefix check allowing bypass URLs like http://127.0.0.1.attacker.example, while the WebSocket plugin performs no URL validation despite documented security requirements. Attackers can force connections to internal services and cloud metadata endpoints by supplying malicious tool URLs in call templates, and receive configured API keys and OAuth tokens sent to attacker-controlled hosts.
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
Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.
More in Python Utcp
View allpython-utcp versions before 1.1.4 allow server-side request forgery through the utcp-http plugin's HttpCommunicationProt
Credential exfiltration and server-side request forgery in utcp-http 1.1.3 and earlier allow an attacker who supplies a
Server-side request forgery in python-utcp (utcp-http) before 1.1.12 allows an unauthenticated remote attacker to cause
Server-side request forgery in python-utcp 1.1.0's utcp-gql and utcp-websocket components allows remote low-privileged a
Cleartext MCP server connections in utcp-mcp (the MCP plugin of python-utcp) through 1.1.2 allow a plain-HTTP or plain-W
EUVD-2026-87986
GHSA-gx2c-cr72-v8vv
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB