Severity:

HIGH RISK

(7.3)

SSRF in CloudBase-MCP open-url API Endpoint

CVE-2026-7221

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Network pivoting via backend HTTP requests, potentially leading to data exposure, internal service interaction, or further compromise

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) vulnerability in TencentCloudBase CloudBase-MCP's open-url API endpoint allows attackers to manipulate the req.body.url parameter to make arbitrary HTTP requests from the server.

When exposed to untrusted callers, this can be abused to reach internal services, cloud metadata endpoints, or other restricted network locations that are not directly accessible from the internet.

Affected context

The vulnerability exists in the openUrl function within mcp/src/interactive-server.ts, which backs the open-url API endpoint in CloudBase-MCP up to version 2.17.0.

The issue manifests when the endpoint accepts a url value from req.body.url and uses it to initiate server-side HTTP requests without sufficient validation, restriction, or sanitization.

Risk is elevated when:

  • The endpoint is reachable from untrusted networks or multi-tenant environments
  • The server has network access to internal services, management interfaces, or cloud metadata endpoints
  • There is no strong allowlist or network-level egress control restricting outbound connections from the server

Exploit preconditions

  • Attack surface: HTTP (or HTTPS) access to the open-url API endpoint of the CloudBase-MCP interactive server.
  • Required access: Ability to send requests to the vulnerable endpoint (e.g., authenticated user, tenant, or in some deployments, unauthenticated if misconfigured).
  • Trigger point: Supplying a crafted req.body.url value that points to attacker-chosen targets, including internal IPs, hostnames, or cloud metadata services.
  • Why exploitation is possible: The backend logic trusts the user-supplied url parameter and forwards requests without enforcing strict host or scheme restrictions, allowing an attacker to leverage the server's network position to reach otherwise inaccessible resources.

Why this happens

This is a classic CWE-918: Server-Side Request Forgery issue where user-controlled input is used directly as the target of a server-initiated HTTP request.

The openUrl function likely treats req.body.url as a benign external URL and passes it into HTTP client code without robust validation, host allowlisting, or network segmentation.

In abstract terms, the insecure pattern is:

  • Accepting a URL or endpoint from the client
  • Using it to drive server-side network calls
  • Failing to constrain where the server is allowed to connect (e.g., internal address ranges, metadata services, loopback interfaces).

Potential impact

  • May allow access to internal HTTP services that are not exposed to the public internet.
  • Could enable interaction with cloud provider metadata services, potentially leaking credentials or configuration.
  • Can facilitate network reconnaissance of internal hosts and services from the server's vantage point.
  • Might enable exploitation of other internal vulnerabilities by sending crafted requests to internal endpoints.
  • Could bypass IP-based access controls or firewall rules that trust traffic originating from the application server.

General mitigation guidance

Effective mitigation typically combines strict output constraints on server-side HTTP requests with network-level protections:

  • Apply a default-deny, allowlisted set of destinations for any feature that makes outbound HTTP(S) calls based on user input (e.g., only specific domains or well-defined API endpoints).
  • Enforce URL validation rules: restrict to safe schemes (e.g., https), disallow IP literals, and block private, loopback, and link-local address ranges.
  • Introduce a proxy or egress gateway through which all outbound requests must pass, with centralized policies governing reachable hosts and paths.
  • Separate sensitive internal services and metadata endpoints onto network segments that are not reachable from application servers whenever feasible.
  • Minimize the need for fully dynamic user-controlled URLs; where possible, map user choices to predefined, server-side URL templates instead of free-form addresses.

How teams detect issues like this

Organizations can detect and manage SSRF risks through layered review and monitoring:

  • Static analysis: Flag usage patterns where untrusted input is passed into HTTP client libraries (e.g., axios, fetch, request) as a URL or host parameter without validation or allowlisting.
  • Code review signals: Watch for API endpoints that accept arbitrary URLs or hosts, "URL opener" utilities, or generic proxy-like features; ensure they enforce strict destination controls.
  • Security testing: Use dynamic application security testing (DAST) or manual penetration testing to probe URL-taking endpoints with internal IPs, localhost, and metadata URLs to verify protections.
  • Logging and monitoring: Instrument outbound HTTP calls with detailed logging of destinations; establish anomaly detection for requests to internal IP ranges or unusual endpoints.
  • Automated code scanning tools and CI policies can be configured to detect URL-based SSRF patterns and require security sign-off for such features.

Sources

SourceLink
github.comgithub.com/TencentCloudBase/CloudBase-MCP/
github.comgithub.com/TencentCloudBase/CloudBase-MCP/commit/3f678a1e7bd400cd76469d61024097d4920dc6b5
github.comgithub.com/TencentCloudBase/CloudBase-MCP/issues/509
github.comgithub.com/TencentCloudBase/CloudBase-MCP/pull/510
github.comgithub.com/TencentCloudBase/CloudBase-MCP/releases/tag/v2.17.1
vuldb.comvuldb.com/submit/802230
vuldb.comvuldb.com/vuln/359821
vuldb.comvuldb.com/vuln/359821/cti

Frequently asked

questions

Exploitability depends on how exposed the open-url endpoint is and what the server can reach on the network.

In environments where the endpoint is accessible to untrusted users and the server has access to internal or cloud management networks, the practical risk is significant.

The attacker needs the ability to send HTTP requests to the vulnerable open-url API endpoint and control the url parameter.

This might require an authenticated account, a tenant in a shared environment, or just network access if the endpoint is publicly reachable.

The safest pattern is to avoid making arbitrary outbound requests based on user input.

If the feature is required, enforce strict allowlisting of destinations or URL templates, block internal address ranges, and validate schemes to limit the reachable surface.

At design time, treat any user-controlled URL or host as highly sensitive and avoid creating generic "open this URL for me" endpoints.

Combine URL validation and allowlists with network segmentation and egress controls, and define security review gates for any feature that uses user input to drive server-side network calls.

Find out what's already
exploitable in your codebase.