Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessInject prompt via untrusted content
-
DeliverySupply IPv6-bracketed or mapped-form private URL
-
ExploitSSRF guard skips private-IP checks
-
ExecutionHTTP client strips brackets, connects to internal host
-
PersistInternal service response captured
-
ImpactSensitive data returned to model context
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 | Exploitation requires the ability to influence the URL argument passed to the mcp-fetch tool, which in practice means injecting content - typically via prompt injection in externally fetched text, user-supplied prompts, or adversarial documents - that directs the model to invoke the fetch tool with a crafted URL. The mcp-fetch server must be network-reachable to the internal targets (e.g., the instance must be running on a cloud VM for the 169.254.169.254 metadata endpoint to be accessible). No authentication to mcp-fetch itself is required per the CVSS 4.0 PR:N metric. Exploitation is strictly a confidentiality impact - reading internal service responses; no write or availability impact is described. Exploitation is limited to environments where mcp-fetch actively processes untrusted or attacker-influenced content; air-gapped or fully trusted-input deployments are not practically exploitable. |
| Impact | The CVSS 4.0 vector AV:N/AC:L/AT:N/PR:N/UI:N/VC:H scoring 8.7 reflects the reality that no prerequisites are required beyond the ability to inject a URL argument into the model's tool call - consistent with typical prompt-injection workflows against AI agents. Real-world exploitability is strongly context-dependent: deployments where mcp-fetch processes untrusted user input or externally fetched content (the classic prompt-injection vector) on a cloud-hosted instance face meaningful exposure to metadata endpoint exfiltration (e.g., AWS IMDSv1 at 169.254.169.254), which can yield instance credentials. In tightly controlled deployments where tool arguments are fully trusted, risk is substantially lower. The absence of a CISA KEV listing and no confirmed active exploitation reduce urgency. EPSS data is not present in the available intelligence. The product's niche deployment footprint (MCP AI-agent tooling) meaningfully limits the aggregate exposed population compared to mainstream infrastructure software, despite the technical severity being high. The dual-flaw nature - bracket bypass plus IPv4-mapped prefix blind spot - suggests the SSRF guard was not subjected to IPv6 edge-case testing, and any partial fix addressing only one path would leave the other open. |
| Exploit ScenarioDerived | An attacker embeds a prompt-injection instruction inside a web page or document that an AI agent using mcp-fetch is directed to fetch. The injected instruction directs the model to call the fetch tool with the URL http://[::ffff:169.254.169.254]/latest/meta-data/iam/security-credentials/ - a cloud metadata endpoint expressed in IPv4-mapped IPv6 form with brackets. The SSRF guard skips the private-address check due to the bracket parsing flaw, reports the target safe, and the HTTP client connects to the metadata service, returning IAM credentials into the model's context. A public issue report at https://github.com/kazuph/mcp-fetch/issues/16 documents the bypass logic. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 26, 2026
Server-Side Request Forgery in mcp-fetch through version 1.6.3 allows unauthenticated attackers who can influence model tool arguments to bypass the SSRF guard entirely and reach loopback, private, and link-local network endpoints including cloud instance metadata services. The bypass exploits a parsing gap: the guard tests the bracketed IPv6 literal string such as [::1] against Node.js's net.isIP(), which returns zero for bracketed input, causing the private-address branch to be skipped; the HTTP client later strips the brackets and connects normally. A secondary flaw in isPrivateIPv6 - no handling of the ::ffff: IPv4-mapped prefix - provides an independent bypass path for IPv4 targets expressed in mapped form. No public exploit code or CISA KEV listing exists at time of analysis, though a public issue report documenting the flaw is open on the upstream repository.
RemediationAI
No vendor-released patched version is identified in the available data; monitor the upstream repository at https://github.com/kazuph/mcp-fetch and the open issue at https://github.com/kazuph/mcp-fetch/issues/16 for a fix release. Until a code-level fix is available, deploy mcp-fetch in a network segment with outbound firewall or security-group rules blocking access to RFC 1918 private ranges (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16), loopback (127.0.0.0/8), and link-local addresses (169.254.0.0/16, including the AWS/GCP metadata endpoint at 169.254.169.254); note that this control is ineffective if mcp-fetch legitimately requires access to internal hosts. Where mcp-fetch is not needed, removing the tool from the model's available tool set eliminates the attack surface entirely with no functional trade-off. For cloud deployments specifically, enabling IMDSv2 (requiring session-oriented token-based access) on AWS instances reduces the impact of metadata endpoint exposure even if the SSRF guard is bypassed, since a simple GET to 169.254.169.254 without the token header will return a 401.
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
mcp-fetch is a Node.js MCP (Model Context Protocol) server package available on npm as @kazuph/mcp-fetch, designed to give AI models a URL-fetching tool capability. Its SSRF guard function isSafeUrl extracts the hostname from Node.js's URL parser, which for an IPv6 literal such as http://[::1]/ returns the bracketed string [::1]. That string is then evaluated by net.isIP(), which returns 0 for any non-canonical or bracketed input, causing the entire private-address-check branch to be bypassed (CWE-918: Server-Side Request Forgery). The DNS-resolution fallback then receives the bracketed hostname, which is not a valid DNS name, so no addresses are returned and the target is incorrectly reported safe. The underlying HTTP client subsequently follows RFC 3986 and strips the brackets before connecting, reaching the actual address. A second, independent defect in isPrivateIPv6 - absence of a case matching the ::ffff: prefix - means that IPv4 addresses expressed as IPv4-mapped IPv6 addresses would also evade the guard even if the bracket issue were corrected. The full affected CPE scope is cpe:2.3:a:kazuph:mcp-fetch:*:*:*:*:*:*:*:*.
Know when Mcp Fetch 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:H/VI:N/VA:N/SC:N/SI:N/SA:N
Network-reachable via prompt injection, no credentials required, scope changes to internal hosts; confidentiality-only impact with no integrity or availability consequence described.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
mcp-fetch checks a fetch target against its SSRF guard without removing the brackets that surround an IPv6 literal. isSafeUrl reads the hostname from the parsed URL, which for a literal such as http://[::1]/ yields the bracketed string, and then tests it with net.isIP. That call returns zero for a bracketed value, so the branch holding the private-address checks is skipped entirely. The guard falls back to resolving the hostname, the bracketed string is not a resolvable name, no addresses are returned, and the target is reported safe. The HTTP client then strips the brackets and connects. Because the address may be given in IPv4-mapped form, the same path reaches any IPv4 target the loopback and private checks were meant to exclude, including link-local metadata endpoints. isPrivateIPv6 also has no case for the ::ffff: prefix, so the mapped form would still pass even if the brackets were removed. The fetch target is supplied as a tool argument, so an attacker who can influence what the model requests can read internal responses back into the model context.
Executive ViewAI
mcp-fetch, an LLM tool integration library, contains a network security bypass allowing unauthenticated attackers who can manipulate model inputs to access cloud credentials and private infrastructure, creating direct risk of account compromise for organizations using versions 1.6.3 or earlier.
No vendor-released patch identified at time of analysis. Interim mitigations: disable mcp-fetch tool usage if not operationally critical; enforce strict network isolation preventing mcp-fetch from reaching cloud metadata services (AWS IMDS, GCP metadata API, Azure instance metadata); implement firewall and security group rules blocking access to private network ranges and link-local addresses; restrict LLM input sources to trusted applications and users only; implement application-level logging and monitoring for SSRF-pattern requests targeting 169.254.169.254, ::1, and other metadata service endpoints.
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.
EUVD-2026-66386
GHSA-mqq2-4r9w-4h99
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB