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.

