Summary
A full read SSRF vulnerability in Plane's "Add Link" feature allows an authenticated user to coerce the server into issuing arbitrary HTTP GET requests to internal network targets and external endpoints.
When abused, this behavior can expose sensitive data from internal services and cloud metadata endpoints, turning a basic project management action into an internal data exfiltration channel.
Affected context
The vulnerability arises within Plane's web application when users add external links to content.
In vulnerable versions, the server accepts a user-controlled URL and performs outbound HTTP GET requests on behalf of the user without sufficient restriction or isolation.
This becomes risky in deployments where the Plane server has network visibility into internal services, cloud provider metadata endpoints, or other non-public systems that are not directly accessible from the attacker's environment.
Exploit preconditions
- Attack surface: HTTP(S) interface of the Plane application, specifically the "Add Link" endpoint or workflow.
- Required access: Authenticated account with general user privileges (no administrative permissions required).
- Trigger point: Supplying a crafted URL when adding a link, which the server then fetches.
- Why exploitation is possible: The server-side HTTP client trusts user-supplied URLs and performs GET requests without robust destination validation (e.g., no allowlist, insufficient blocklist, missing metadata/IP range protections), then returns or exposes the full response body to the attacker.
Why this happens
This issue is an instance of CWE-918: Server-Side Request Forgery (SSRF).
The core problem is that user-provided URLs are treated as trustworthy destinations for server-initiated HTTP requests.
The application does not adequately constrain where the server may connect, allowing an attacker to pivot through the server's more privileged network position.
As a result, the server becomes a proxy into internal networks and cloud metadata endpoints, and the application returns the full response body to the user, completing the data exfiltration path.
Potential impact
- Attackers may read sensitive data from internal microservices that are not exposed to the public internet.
- Internal admin or debugging interfaces may be queried, potentially revealing configuration secrets, logs, or system status.
- Cloud provider metadata endpoints can be accessed, which may expose access tokens, instance credentials, or configuration values.
- Network topology information and internal host discovery can be inferred from response variations and error messages.
- Sensitive application configuration (e.g., database connection details, API keys) exposed by internal services can be harvested for follow-on attacks.
General mitigation guidance
Mitigation typically focuses on constraining server-initiated HTTP requests and reducing the trust placed in user-controlled URLs.
Recommended defensive patterns include:
- Implementing strict allowlists for outbound requests (e.g., only permitting well-known public domains that are required for functionality).
- Blocking access to private IP ranges, loopback addresses, link-local ranges, and cloud metadata IPs at the application layer and, where possible, at the network layer.
- Normalizing and re-resolving hostnames to IP addresses before enforcement, to avoid DNS rebinding and bypasses.
- Using a dedicated, locked-down egress proxy or microservice for URL fetching, with limited network reach and policy-based filtering.
- Avoiding reflection of full raw responses to end users; instead, extract only the minimal, non-sensitive data necessary for the feature.
- Applying the principle of least privilege to the Plane server's network access and credentials so that compromise yields minimal internal visibility.
How teams detect issues like this
Effective detection focuses on both code patterns and runtime behavior:
- Static analysis or code review rules that flag server-side HTTP clients being invoked with user-controlled URLs without prior validation, canonicalization, or allowlist checks.
- Reviewing "Add Link" and similar helper utilities for patterns where full response bodies are returned to the client or logged without sanitization.
- Runtime monitoring of outbound HTTP traffic from the Plane server, especially requests targeting:
- RFC1918 private address spaces
- Loopback (127.0.0.0/8) and link-local ranges
- Known cloud metadata IPs (e.g., 169.254.169.254)
- Alerting on unusual spikes in outbound requests or requests to non-standard ports and internal hostnames originating from the application.
- Incorporating SSRF-focused security tests into CI/CD pipelines, such as automated checks that attempt to request internal or metadata endpoints through link-fetching functionality.

