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.

