/

CVE-2026-30834

Severity:

HIGH RISK

(7.5)

SSRF in PinchTab /download Endpoint

CVE-2026-30834

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Network and Local File/Data Exposure via SSRF

Severity:

HIGH RISK

(7.5)

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) issue in the PinchTab /download endpoint allows an API user to coerce the PinchTab server into fetching arbitrary URLs on their behalf.

When exploited, this can expose internal network services and local system resources by returning the full server-side response content to the attacker.

Affected context

This vulnerability manifests in PinchTab deployments where AI agents or other clients can call the /download HTTP endpoint with user-controlled URL parameters.

The PinchTab server runs as an HTTP service that has its own network and filesystem reach, which may include access to internal-only services, cloud metadata endpoints, or local resources not directly reachable from the agent's environment.

The risk is most pronounced when PinchTab is deployed inside sensitive network segments, alongside internal HTTP services, or on hosts with privileged access to local files and administrative interfaces.

Exploit preconditions

  • Attack surface: The PinchTab /download HTTP endpoint exposed to AI agents or any API client
  • Required access: Ability to invoke the PinchTab API (logical/API-level access; no need for system-level compromise)
  • Trigger point: Supplying an attacker-controlled URL or path parameter to the /download endpoint that the server then fetches
  • Why exploitation is possible: The backend logic accepts arbitrary URLs and forwards requests from the server context without robust validation or restriction of target hosts, schemes, or resources, returning the raw response to the caller

Why this happens

The underlying flaw aligns with CWE-918: Server-Side Request Forgery (SSRF), where a server component initiates outbound network requests based on user-provided input without sufficient validation.

In this case, the /download endpoint appears to treat the user-supplied URL as fully trusted, allowing PinchTab to act as a proxy for arbitrary destinations, including internal services and local resources.

Because the response data is reflected back to the caller, the endpoint effectively exposes the server's network and filesystem vantage point, turning a convenience feature into a powerful data exfiltration channel.

Potential impact

  • Access to internal HTTP services that are not directly exposed to the internet
  • Discovery and enumeration of internal network endpoints, ports, and services
  • Retrieval of sensitive configuration data or administrative interfaces exposed only on internal networks
  • Potential access to cloud instance metadata endpoints, enabling credential theft and privilege escalation in hosted environments
  • Reading of local system files or pseudo-HTTP resources reachable from the server process (depending on implementation)
  • Use of the PinchTab server as a pivot point for further attacks within the internal network

General mitigation guidance

Effective mitigation typically focuses on reducing the trust and reach of server-initiated requests, while constraining what user-supplied URLs can trigger:

  • Implement strict allowlists for outbound destinations, restricting /download to a curated set of domains or paths required for normal operation.
  • Enforce robust URL validation, disallowing private IP ranges, loopback addresses, link-local addresses, and non-HTTP(S) schemes.
  • Normalize and re-parse URLs before enforcement to avoid bypasses via encoding tricks, redirects, or DNS rebinding.
  • Apply network-level egress controls (firewall rules or service meshes) so that the PinchTab server cannot freely access internal services not meant to be reached.
  • Run the service under least-privilege accounts and with minimized local filesystem access so that even if SSRF occurs, the blast radius is constrained.
  • Design endpoints to avoid returning raw responses from internal requests when not strictly necessary, instead returning filtered or summarized data.

How teams detect issues like this

Detection often involves combining code-level analysis with runtime monitoring:

  • Use static analysis or manual code review to identify endpoints that:
  • Accept user-controlled URLs or hostnames
  • Invoke generic HTTP clients or file access APIs from server-side code
  • Return the full downstream response body directly to the caller
  • Define secure coding policies that flag outbound HTTP requests constructed from unsanitized user input, and enforce these policies through CI-integrated linters or SAST tools.
  • Monitor logs for unusual /download usage patterns, such as:
  • Requests targeting internal IP ranges (10.x.x.x, 172.16/12, 192.168.x.x), localhost, or link-local addresses
  • Unexpected domains or metadata service endpoints (e.g., common cloud provider metadata hosts)
  • Repeated errors indicative of port scanning or internal service discovery attempts.
  • Implement anomaly detection on outbound traffic from the PinchTab host or container to spot access to atypical destinations or ports.

Sources

SourceLink
github.comgithub.com/pinchtab/pinchtab/security/advisories/GHSA-rw8p-c6hf-q3pg

Frequently asked

questions

Exploitability depends on who can access the PinchTab API. Any entity (such as an AI agent, service, or user) that can call the /download endpoint with arbitrary URLs can potentially leverage SSRF, but external attackers must first gain that API access.

No system-level privileges are required. The attacker only needs logical/API-level access to supply URLs to /download; the attack then executes within the privilege and network context of the PinchTab server process.

The most robust pattern is to restrict /download to a tightly controlled set of destinations via allowlists and strong URL validation, combined with network egress controls. Avoid designs where arbitrary user-controlled URLs can be fetched and returned verbatim by the server.

Treat any feature that makes server-initiated HTTP requests as security-sensitive. Apply a layered approach: strict input validation and normalization of URLs, allowlists for hosts and IP ranges, blocking of private/loopback ranges, controlled egress at the network layer, and code review rules that highlight user-driven outbound requests.

Find out what's already
exploitable in your codebase.