Severity:

HIGH RISK

(7.3)

SSRF in ShadowCloneLabs GlutamateMCPServers

CVE-2026-7094

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal network access and data exposure via server-side requests

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 puppeteer_navigate component of ShadowCloneLabs GlutamateMCPServers allows an attacker to control the url parameter used for outbound requests.

Under certain conditions, this may let remote attackers coerce the server into making arbitrary HTTP/S requests to internal or external endpoints, potentially exposing internal services or enabling pivot attacks.

Affected context

This issue arises in deployments where GlutamateMCPServers exposes an interface (API, job handler, or plugin entry point) that forwards a url argument into the puppeteer_navigate logic in src/puppeteer/index.ts.

When that argument is insufficiently validated or constrained, the application can be tricked into requesting arbitrary locations, including internal network resources or cloud metadata endpoints, depending on network topology and firewall rules.

The actual impact will vary based on how the puppeteer navigation is wired into the rest of the system and what the server can reach from its network environment.

Exploit preconditions

  • Attack surface: Any external interface that accepts or influences the url parameter used by puppeteer_navigate (e.g., HTTP API endpoints, task queues, plugin calls).
  • Required access: Remote ability to submit or modify the url input; no direct file system or shell access is required.
  • Trigger point: The server-side call to the puppeteer navigation routine in src/puppeteer/index.ts that initiates browser or HTTP navigation based on the provided url.
  • Why exploitation is possible: The application appears to trust user-controlled or indirectly controlled url values without enforcing strict allowlists, scheme checks, or network segmentation, enabling outbound calls to attacker-chosen targets.

Why this happens

The vulnerability stems from a lack of robust validation and constraint on a user-influenced URL parameter prior to being used for server-initiated requests.

Conceptually, this aligns with CWE-918: Server-Side Request Forgery (SSRF), where an application takes external input and uses it to construct or initiate outbound connections as if the server itself were the client.

In this pattern, the server's network position, authentication context, and trust relationships are implicitly extended to the attacker-controlled destination, because no strong policy limits what hosts, ports, or protocols the navigation logic may contact.

Potential impact

  • May allow an attacker to reach internal-only HTTP/S services that are not exposed to the public internet.
  • Could enable probing of internal network topology (port scanning, service enumeration) via error messages and timing behavior.
  • May expose sensitive metadata services (e.g., cloud instance metadata endpoints) that can leak credentials or configuration secrets.
  • Can be used as a pivot point for further attacks, including authentication bypass against internal administrative interfaces.
  • Might allow partial data exfiltration from internal services that respond over HTTP/S when queried by the server.

General mitigation guidance

Effective mitigation generally focuses on constraining where the server is allowed to connect and reducing trust in user-provided URLs:

  • Introduce strict allowlists of permitted domains and paths for any URL used by puppeteer_navigate, rejecting or normalizing all other destinations.
  • Enforce scheme restrictions (e.g., limit to https where appropriate) and block access to internal IP ranges, link-local addresses, and known metadata endpoints.
  • Implement layered network controls such as egress filtering, network segmentation, and firewall rules so that the server cannot directly reach sensitive internal services.
  • Normalize and parse URLs using hardened libraries and check the resolved host after DNS resolution to prevent DNS rebinding or host header tricks.
  • Run the puppeteer component with least-privilege networking and credentials, ensuring it has minimal access to internal infrastructure and secrets.

How teams detect issues like this

Organizations can approach detection of this SSRF pattern through a mix of code-focused and operational techniques:

  • Static analysis and code review: Flag any code paths where external input (request parameters, job payloads, configuration fields) is passed into URL constructors or puppeteer navigation functions without allowlists or host validation.
  • Policy enforcement: Define secure coding guidelines that prohibit unconstrained outbound requests based on user input and enforce these rules via pre-commit hooks or CI checks.
  • Runtime monitoring: Log outbound HTTP/S requests from the application, including target hosts and URLs, and alert on anomalous destinations such as internal IP ranges or unexpected domains.
  • Synthetic testing: Incorporate SSRF-focused security tests into QA and security assessments, using controlled endpoints to observe whether the server attempts connections it should not.

Sources

SourceLink
github.comgithub.com/BruceJqs/public_exp/issues/7
github.comgithub.com/ShadowCloneLabs/GlutamateMCPServers/
github.comgithub.com/ShadowCloneLabs/GlutamateMCPServers/issues/8
vuldb.comvuldb.com/submit/800725
vuldb.comvuldb.com/vuln/359669
vuldb.comvuldb.com/vuln/359669/cti

Frequently asked

questions

Yes, it can be, as long as an attacker can influence the url argument consumed by the puppeteer_navigate logic through a remotely accessible interface. The exploit does not require local server access.

The attacker typically needs only the ability to submit or manipulate requests to the relevant API or entry point that forwards the url parameter. No shell access or direct network routing control is required.

The most robust approach is to strictly limit where the server can connect by enforcing domain and path allowlists in the application, combined with network-level egress controls that block connections to internal or sensitive addresses regardless of input.

Treat all externally influenced URLs as untrusted, apply strong validation and normalization before use, ensure outbound requests are constrained by both application logic and network policy, and include SSRF-specific checks in code review and automated security testing pipelines.

Find out what's already
exploitable in your codebase.