/

CVE-2026-39843

Severity:

HIGH RISK

(7.7)

Server-Side Request Forgery (SSRF) in Plane Favicon Fetcher

CVE-2026-39843

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Full-Read SSRF to Internal Network Resources

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

Plane's link handling feature contained an incomplete fix that still allowed full-read Server-Side Request Forgery (SSRF) via the favicon fetching logic.

An authenticated low-privilege user could submit an HTML page URL whose favicon URL redirects to a private IP, causing the server to make internal HTTP requests and expose their responses.

Affected context

This vulnerability affects Plane deployments using versions from 0.28.0 up to, but not including, 1.3.0 where the "Add link" feature is available to authenticated users.

The issue specifically resides in the server-side favicon fetching path, which follows HTTP redirects without applying the same network and URL validation logic that protects the main page URL.

The risk is most pronounced in environments where Plane can reach internal services, metadata endpoints, or other non-public network resources that should not be exposed to regular application users.

Exploit preconditions

  • Attack surface: Plane's "Add link" functionality that fetches metadata and favicons for supplied URLs.
  • Required access: Authenticated account with low privileges and the ability to create or edit items containing external links.
  • Trigger point: Supplying an HTML page URL whose associated favicon URL (or its redirect chain) ultimately resolves to a private or otherwise internal IP address.
  • Why exploitation is possible: The favicon fetching code uses requests.get(favicon_url, ...) with default redirect-following and without enforcing proper SSRF defenses or consistent URL validation, allowing the server to follow redirects into internal networks.

Why this happens

The underlying bug is an incomplete application of SSRF defenses to all outbound HTTP requests.

While redirects for the main page URL were validated to prevent access to internal IPs, the favicon retrieval helper fetch_and_encode_favicon() continued to use a generic HTTP client (requests.get) that automatically followed redirects without applying the same IP range checks or host validation.

This maps directly to CWE-918: Server-Side Request Forgery (SSRF), where attackers can influence server-side HTTP requests to reach unintended internal or protected resources due to inconsistent or missing network egress validation.

Potential impact

  • The server may fetch and return the contents of internal HTTP services not directly exposed to users.
  • Attackers could read sensitive data from cloud instance metadata endpoints if reachable from the Plane server.
  • Internal application dashboards, APIs, or configuration endpoints could be probed and exfiltrated through the SSRF channel.
  • SSRF responses might be used to aid further attacks such as lateral movement, internal service enumeration, or chaining with other vulnerabilities.

General mitigation guidance

Effective mitigation focuses on consistently enforcing SSRF defenses on all outbound HTTP requests made on behalf of user-supplied URLs.

Common defensive patterns include:

  • Normalizing and validating all URLs prior to any HTTP request, including assets like favicons, Open Graph images, and redirects.
  • Denying access by default to private, link-local, loopback, and metadata IP ranges (e.g., RFC1918, 169.254.169.254) and enforcing explicit allowlists for external domains.
  • Disabling or tightly controlling automatic redirect-following, or re-validating each redirected URL before issuing a subsequent request.
  • Using network-level egress controls (such as firewall rules or container network policies) to prevent the application from reaching sensitive internal services.
  • Applying the principle of least privilege to network access, restricting the server's ability to connect to arbitrary hosts and ports.

How teams detect issues like this

Detection typically involves both code-centric and operational approaches:

  • Static analysis rules that flag outbound HTTP calls (e.g., requests.get, fetch) where URLs can be influenced by user input and lack IP/host validation or redirect checks.
  • Code review practices that treat any server-side URL fetching (metadata scraping, favicon retrieval, link preview generation) as high-risk and require consistent SSRF protection patterns.
  • Automated policy checks in CI/CD that block new code introducing unvalidated outbound requests or inconsistent URL validation handling across helper functions.
  • Runtime monitoring and logging of outbound HTTP requests from the application, with alerts for connections to private or unexpected IP ranges, unusual domains, or high-volume internal traffic.

Sources

SourceLink
github.comgithub.com/makeplane/plane/security/advisories/GHSA-9fr2-pprw-pp9j

Frequently asked

questions

It is exploitable by any authenticated user who can access the "Add link" feature, even with low privileges. The attacker controls external URLs but leverages the server's internal network position to reach otherwise inaccessible resources.

The attacker needs a valid account on the Plane instance and the ability to submit or edit items that trigger server-side metadata or favicon fetching. No administrative access is required.

Apply uniform SSRF protections to all server-side HTTP requests made from user-influenced URLs, including asset fetches and redirects. This generally means validating every URL and redirect target against strict allowlists, blocking private IP ranges, and avoiding blind redirect-following.

Establish a reusable, centralized URL-fetching utility that encapsulates all SSRF defenses (IP blocking, host validation, redirect handling, and timeouts), and mandate its use across the codebase. Combine this with network-level egress restrictions and security review checklists for any new functionality that performs server-side HTTP requests based on user input.

Find out what's already
exploitable in your codebase.