Skip to main content

mcp-fetch CVE-2026-80347

| EUVDEUVD-2026-66386 HIGH
Server-Side Request Forgery (SSRF) (CWE-918)
2026-08-26 VulnCheck GHSA-mqq2-4r9w-4h99
8.7
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Inject prompt via untrusted content
  2. Delivery
    Supply IPv6-bracketed or mapped-form private URL
  3. Exploit
    SSRF guard skips private-IP checks
  4. Execution
    HTTP client strips brackets, connects to internal host
  5. Persist
    Internal service response captured
  6. Impact
    Sensitive 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

mcp-fetch 0 ≤1.6.3

Affected Packages

euvd mcp_fetch no fix

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

Vendor (VulnCheck) PRIMARY 8.7 HIGH
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
vuln.today AI 8.6 HIGH

Network-reachable via prompt injection, no credentials required, scope changes to internal hosts; confidentiality-only impact with no integrity or availability consequence described.

3.1 AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:N/VA:N/SC:H/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
None
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.3%
Top 80% exploitable
Prevalence
Low
niche npm package for MCP AI agent workflows
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GitHub VulDB

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.3%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Out-of-Cycle
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy