/

CVE-2026-30242

Severity:

HIGH RISK

(8.5)

SSRF in Plane Webhook URL Validation

CVE-2026-30242

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Network Access and Data Exfiltration via SSRF

Severity:

HIGH RISK

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

Plane's webhook URL validation previously only rejected loopback addresses, allowing administrators to register webhooks that point to internal/private network targets.

When these webhooks fired, the Plane server would issue HTTP requests to those internal addresses and store the full responses, enabling server-side request forgery (SSRF) with full response read-back against internal services.

Affected context

The vulnerability occurs in Plane instances that expose webhook configuration and processing.

Specifically, it affects environments where:

  • Workspace users with ADMIN role can create or edit webhook URLs, and
  • The Plane server has network connectivity to internal services or metadata endpoints (e.g., 10.x.x.x, 172.16.x.x, 192.168.x.x, 169.254.169.254).

The problem arises because webhook URL validation in plane/app/serializers/webhook.py only checked for loopback addresses, not broader private or link-local ranges, making it possible to direct webhook callbacks to internal resources reachable from the server.

Exploit preconditions

  • Attack surface: Webhook creation or configuration interface in Plane.
  • Required access: Workspace ADMIN role (or any role that can define webhook URLs).
  • Network context: The Plane server must be able to reach internal or restricted network targets (e.g., internal APIs, cloud metadata endpoints) from its network environment.
  • Trigger point: An event that causes the configured webhook to fire (e.g., issue updates, project changes) and sends an outbound request to the attacker-controlled URL.
  • Why exploitation is possible: URL validation only rejected loopback (127.0.0.0/8) addresses, but did not guard against other non-public IP ranges or internal hostnames. As a result, an attacker with ADMIN privileges can register webhook URLs that point to internal IP addresses, causing the server to perform requests on their behalf and store the full responses.

Why this happens

This issue stems from incomplete validation of outbound webhook destinations, falling under CWE-918: Server-Side Request Forgery (SSRF).

The code in plane/app/serializers/webhook.py only checked whether the resolved IP was a loopback address (ip.is_loopback), treating all other addresses as safe.

It did not enforce a denylist or allowlist for internal-only ranges, link-local interfaces, or sensitive metadata endpoints.

Conceptually, this is an insecure pattern where a server component:

  • Accepts user-influenced URLs, and
  • Uses its own network privileges to make HTTP requests to those URLs, and
  • Returns or stores the responses in a way the attacker can access.

Without strict control over which targets are reachable, attackers can pivot through the server to reach internal services that are otherwise not directly exposed.

Potential impact

  • Attackers with ADMIN access may scan internal network ranges accessible from the Plane server.
  • They may issue HTTP requests to internal APIs, admin panels, or configuration endpoints and read the full responses via stored webhook results.
  • They may access cloud provider instance metadata services (e.g., 169.254.169.254) and potentially retrieve credentials or tokens.
  • They can enumerate internal services and infer network topology from response behavior and timing.
  • They may use SSRF as a component in more complex attack chains, such as credential theft, configuration disclosure, or lateral movement to other systems.

General mitigation guidance

Mitigation focuses on constraining where webhook callbacks are allowed to go and reducing the trust placed in user-supplied URLs.

Common defensive patterns include:

  • Implementing strict outbound URL validation that:
  • Denies private, link-local, loopback, and metadata address ranges by default, and
  • Optionally resolves hostnames to IPs and revalidates after DNS resolution.
  • Using an allowlist of approved domains or hostnames for webhook destinations, rather than allowing arbitrary URLs.
  • Enforcing application-layer restrictions on outbound HTTP clients, such as:
  • Limiting supported schemes (e.g., only https),
  • Disabling redirects or re-validating redirect targets against the same policies.
  • Isolating the component that makes webhook calls into a network segment with restricted outbound access, so it cannot reach internal control planes or sensitive services.
  • Storing only minimal, sanitized response data from webhook callbacks, or avoiding returning the full raw response to end users when not necessary.

How teams detect issues like this

Organizations can look for this class of issue through a mix of code-level and behavioral detection:

  • Static analysis and code review:
  • Identify code paths where user-controlled or admin-controlled URLs are used to trigger server-side HTTP requests.
  • Check for robust validation of hostnames and IP addresses, including resolution-time checks.
  • Flag patterns where only loopback is filtered and other private ranges are allowed.
  • Configuration and policy checks:
  • Enforce policies requiring domain allowlists for outbound webhook calls.
  • Verify that HTTP client libraries are configured with SSRF-safe defaults (e.g., disabled access to known metadata IPs).
  • Runtime and log analysis:
  • Monitor outbound traffic from the Plane server to unexpected internal IP ranges.
  • Analyze webhook-related logs for destinations in RFC1918 spaces or metadata endpoints.
  • Set up anomaly detection for unusual patterns of webhook failures or unexpected internal connections.

Automated security testing tools and SSRF-focused scanners can also help identify URLs or endpoints that allow user-controlled SSRF in pre-production environments.

Sources

SourceLink
github.comgithub.com/makeplane/plane/releases/tag/v1.2.3
github.comgithub.com/makeplane/plane/security/advisories/GHSA-fpx8-73gf-7x73

Frequently asked

questions

Exploitation requires a user with a workspace ADMIN role (or equivalent permissions to configure webhooks) within the Plane application. It is not exploitable by anonymous users without such access. However, once an attacker has that role, they can drive SSRF from anywhere they can reach the Plane UI or API.

No. The attacker does not need direct network access to internal services. They only need the Plane server to have that access. The SSRF occurs because the server issues HTTP requests on behalf of the attacker to internal targets that are reachable from the server's network environment.

The safest pattern is to strictly limit webhook destinations. This usually means implementing an allowlist of approved domains or services, denying all private and link-local IP ranges (including cloud metadata endpoints), and validating both the original URL and its resolved IP address before making the request.

When designing features that make outbound requests based on user-provided URLs, treat the target as untrusted input. Apply comprehensive URL and DNS validation, limit outbound connectivity via network controls, avoid exposing raw responses back to users unless necessary, and include SSRF-specific checks in code review and automated testing processes.

Find out what's already
exploitable in your codebase.