/

CVE-2026-27706

Severity:

HIGH RISK

(7.7)

SSRF in Plane 'Add Link' Feature

CVE-2026-27706

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Network Access and Data Exfiltration

Severity:

HIGH RISK

(7.7)

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 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.

Sources

SourceLink
github.comgithub.com/makeplane/plane/releases/tag/v1.2.2
github.comgithub.com/makeplane/plane/security/advisories/GHSA-jcc6-f9v6-f7jw

Frequently asked

questions

Yes, but it requires an authenticated user account on the Plane instance.

Once logged in, an attacker can exploit the link-adding functionality to coerce the server into making internal HTTP requests, even though those internal resources are not directly routable from the attacker's machine.

No. The vulnerability can be exploited with general user privileges.

Any account that can use the "Add Link" feature and supply arbitrary URLs is in a position to trigger SSRF behavior.

The most robust fix is to centralize and strictly control all server-initiated HTTP requests that rely on user input.

This typically involves enforcing an outbound allowlist, blocking private and metadata address ranges, normalizing and validating URLs before use, and minimizing the exposure of raw response bodies to end users.

Prevention requires a combination of design and process:

  • Treat all user-provided URLs as untrusted and subject them to strict validation and policy checks.
  • Use network segmentation and egress controls to prevent application servers from freely reaching internal services and metadata endpoints.
  • Incorporate SSRF-specific review items into code review checklists and security testing.
  • Employ automated analysis or security testing tools that can identify risky URL-fetching patterns during development.
Find out what's already
exploitable in your codebase.