Severity:

HIGH RISK

(7.3)

SSRF in mcp-data-vis HTTP Request Handler

CVE-2026-7146

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Network Pivoting and Access to Internal/Protected Resources

Severity:

HIGH RISK

(7.3)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A server-side request forgery (SSRF) flaw in the mcp-data-vis web scraper allows attackers to abuse the HTTP request handler, implemented with axios in src/servers/web-scraper/server.js, to make arbitrary outbound requests from the server.

When user-controlled input is used to construct backend HTTP requests without proper validation or restriction, remote attackers may pivot through the server to reach internal services or external targets the attacker cannot directly access.

Affected context

This vulnerability arises in deployments of the mcp-data-vis project that expose the web-scraper server component.

The server accepts parameters that influence outbound HTTP requests (for example, target URLs or query paths) and uses axios to perform these requests on the server side.

In affected configurations, there are insufficient checks on where the server is allowed to connect, meaning that untrusted client input can directly shape outbound HTTP requests to arbitrary destinations.

Exploit preconditions

  • Attack surface: Publicly reachable web-scraper HTTP endpoint(s) in mcp-data-vis.
  • Required access: Remote network access to the server endpoint that triggers axios-based HTTP requests; no elevated privileges are assumed.
  • Trigger point: Sending crafted request parameters (commonly URL or host fields) that the HTTP Request Handler passes to axios to initiate outbound connections.
  • Why exploitation is possible: The handler forwards user-controlled values into axios without robust allowlisting, host/IP restrictions, or scheme validation, allowing requests to arbitrary or internal resources.

Why this happens

The core issue is a classic server-side request forgery pattern, mapped to CWE-918.

The HTTP Request Handler trusts user-controlled input when building axios requests, effectively turning the server into a proxy on behalf of the attacker.

Without strict validation of destination hosts, IP ranges, and protocols, the server can be coerced into connecting to internal network services, metadata endpoints, or other sensitive resources that are not directly exposed to the attacker.

This reflects an insecure design where backend HTTP clients are directly parameterized by untrusted user input.

Potential impact

  • May allow access to internal network services that are otherwise firewalled from the internet.
  • Could enable interaction with cloud provider metadata services, potentially exposing credentials or configuration data.
  • Can be used to bypass IP-based allowlists or network segmentation controls by routing traffic through the vulnerable server.
  • May facilitate port scanning of internal infrastructure, aiding reconnaissance for further attacks.
  • Could lead to data exfiltration from internal HTTP-accessible endpoints.

General mitigation guidance

Effective mitigation focuses on decoupling untrusted input from backend HTTP destinations and restricting where the server is allowed to connect:

  • Introduce strict allowlists of permitted target domains, paths, or APIs for all axios calls that depend on user input.
  • Block requests to private and link-local address ranges (e.g., RFC1918, 127.0.0.0/8, ::1, metadata service IPs) at the application layer and/or via network policy.
  • Enforce scheme and port validation, rejecting non-HTTP(S) schemes and unexpected ports.
  • Normalize and re-validate URLs after parsing to prevent obfuscation tricks (such as encoded IPs or redirects).
  • Design HTTP handlers so that user input selects from predefined resources instead of specifying raw URLs wherever possible.
  • Apply least-privilege network egress controls (e.g., firewall rules, service mesh policies) to constrain server-initiated traffic.

How teams detect issues like this

Organizations can detect and manage SSRF risks in code and at runtime through a combination of approaches:

  • Static analysis: Configure rules to flag patterns where user-controllable data flows into axios (or other HTTP client) URL/host parameters without validation or allowlisting.
  • Code review: During review, pay special attention to web-scraping or proxy-like endpoints that construct URLs from request parameters; look for the absence of host/IP range checks and hardcoded domain constraints.
  • Security tests: Add targeted unit and integration tests that attempt connections to reserved IPs, metadata endpoints, and internal hostnames through the HTTP Request Handler.
  • Network monitoring and policies: Monitor egress traffic from the application for anomalous destinations and enforce outbound firewall or service mesh policies that block access to internal-only or sensitive infrastructure endpoints.

Sources

SourceLink
github.comgithub.com/AlejandroArciniegas/mcp-data-vis/
github.comgithub.com/AlejandroArciniegas/mcp-data-vis/issues/1
vuldb.comvuldb.com/submit/801895
vuldb.comvuldb.com/vuln/359745
vuldb.comvuldb.com/vuln/359745/cti

Frequently asked

questions

Yes. The attack is performed remotely by sending crafted requests to the exposed web-scraper endpoint that controls the backend axios calls.

An attacker only needs network access to the affected HTTP Request Handler; no local access or prior authentication is inherently required, unless the deployment adds its own access controls.

The most robust fix is to avoid letting arbitrary user input define outbound request destinations.

Instead, restrict backend HTTP requests to a tightly controlled set of domains or resources, enforce host/IP and scheme validation, and block internal or metadata address ranges.

Treat all user-influenced URLs and hosts as untrusted, design APIs so that clients choose from predefined endpoints rather than providing raw URLs, and complement application-level controls with strict egress network policies and recurring security reviews focused on outbound HTTP calls.

Find out what's already
exploitable in your codebase.