π₯π₯π₯ Open-source Jira, Linear, Monday, and ClickUp alternative. Plane is a modern project management platform to manage tasks, sprints, docs, and triage.
TypeScript boardsbug-trackerdjangodockerganttissue-trackerjirajira-alternativekanbanlinearpostgresqlproduct-managementproject-managementproject-planningpythonreactredistypesciptvitework-management
fix: replace IS_SELF_MANAGED with WEBHOOK_ALLOWED_IPS allowlist (#8884)
sriram veeraghantaa8a16c8ba0b5
diff --git a/apps/api/plane/app/serializers/webhook.py b/apps/api/plane/app/serializers/webhook.pyindex 74ebde8920..c5d0dd41e9 100644--- a/apps/api/plane/app/serializers/webhook.py+++ b/apps/api/plane/app/serializers/webhook.py@@ -3,90 +3,55 @@# See the LICENSE file for details.# Python imports-import socket-import ipaddress+import loggingfrom urllib.parse import urlparse# Third party importsfrom rest_framework import serializers+# Django imports+from django.conf import settings+# Module importsfrom .base import DynamicBaseSerializerfrom plane.db.models import Webhook, WebhookLogfrom plane.db.models.webhook import validate_domain, validate_schema+from plane.utils.ip_address import validate_url++logger = logging.getLogger(__name__)class WebhookSerializer(DynamicBaseSerializer):url = serializers.URLField(validators=[validate_schema, validate_domain])- def create(self, validated_data):- url = validated_data.get("url", None)-- # Extract the hostname from the URL- hostname = urlparse(url).hostname- if not hostname:- raise serializers.ValidationError({"url": "Invalid URL: No hostname found."})-- # Resolve the hostname to IP addresses+ def _validate_webhook_url(self, url):+ """Validate a webhook URL against SSRF and disallowed domain rules."""try:- ip_addresses = socket.getaddrinfo(hostname, None)- except socket.gaierror:- raise serializers.ValidationError({"url": "Hostname could not be resolved."})-- if not ip_addresses:- raise serializers.ValidationError({"url": "No IP addresses found for the hostname."})+ validate_url(url, allowed_ips=settings.WEBHOOK_ALLOWED_IPS)+ except ValueError as e:+ logger.warning("Webhook URL validation failed for %s: %s", url, e)+ raise serializers.ValidationError({"url": "Invalid or disallowed webhook URL."})- for addr in ip_addresses:- ip = ipaddress.ip_address(addr[4][0])- if ip.is_private or ip.is_loopback or ip.is_reserved or ip.is_link_local:- raise serializers.ValidationError({"url": "URL resolves to a blocked IP address."})+ hostname = (urlparse(url).hostname or "").rstrip(".").lower()- # Additional validation for multiple request domains and their subdomainsrequest = self.context.get("request")- disallowed_domains = ["plane.so"] # Add your disallowed domains here+ disallowed_domains = ["plane.so"]if request:- request_host = request.get_host().split(":")[0] # Remove port if present+ request_host = request.get_host().split(":")[0].rstrip(".").lower()disallowed_domains.append(request_host)- # Check if hostname is a subdomain or exact match of any disallowed domainif any(hostname == domain or hostname.endswith("." + domain) for domain in disallowed_domains):raise serializers.ValidationError({"url": "URL domain or its subdomain is not allowed."})+ def create(self, validated_data):+ url = validated_data.get("url", None)+ self._validate_webhook_url(url)return Webhook.objects.create(**validated_data)def update(self, instance, validated_data):url = validated_data.get("url", None)if url:- # Extract the hostname from the URL- hostname = urlparse(url).hostname- if not hostname:- raise serializers.ValidationError({"url": "Invalid URL: No hostname found."})-- # Resolve the hostname to IP addresses- try:- ip_addresses = socket.getaddrinfo(hostname, None)- except socket.gaierror:- raise serializers.ValidationError({"url": "Hostname could not be resolved."})-- if not ip_addresses:- raise serializers.ValidationError({"url": "No IP addresses found for the hostname."})-- for addr in ip_addresses:- ip = ipaddress.ip_address(addr[4][0])- if ip.is_private or ip.is_loopback or ip.is_reserved or ip.is_link_local:- raise serializers.ValidationError({"url": "URL resolves to a blocked IP address."})-- # Additional validation for multiple request domains and their subdomains- request = self.context.get("request")- disallowed_domains = ["plane.so"] # Add your disallowed domains here- if request:- request_host = request.get_host().split(":")[0] # Remove port if present- disallowed_domains.append(request_host)-- # Check if hostname is a subdomain or exact match of any disallowed domain- if any(hostname == domain or hostname.endswith("." + domain) for domain in disallowed_domains):- raise serializers.ValidationError({"url": "URL domain or its subdomain is not allowed."})-+ self._validate_webhook_url(url)return super().update(instance, validated_data)class Meta:diff --git a/apps/api/plane/bgtasks/webhook_task.py b/apps/api/plane/bgtasks/webhook_task.pyindex 6543c3845b..89d9875767 100644--- a/apps/api/plane/bgtasks/webhook_task.py+++ b/apps/api/plane/bgtasks/webhook_task.py@@ -52,6 +52,7 @@ from plane.db.models import (from plane.license.utils.instance_value import get_email_configurationfrom plane.utils.email import generate_plain_text_from_htmlfrom plane.utils.exception_logger import log_exception+from plane.utils.ip_address import validate_urlfrom plane.settings.mongo import MongoConnection@@ -325,6 +326,9 @@ def webhook_send_task(returntry:+ # Re-validate the webhook URL at send time to prevent DNS-rebinding attacks+ validate_url(webhook.url, allowed_ips=settings.WEBHOOK_ALLOWED_IPS)+# Send the webhook eventresponse = requests.post(webhook.url, headers=headers, json=payload, timeout=30)diff --git a/apps/api/plane/settings/common.py b/apps/api/plane/settings/common.pyindex 9d651bd1b4..d90ee10f89 100644--- a/apps/api/plane/settings/common.py+++ b/apps/api/plane/settings/common.py@@ -5,6 +5,8 @@"""Global Settings"""# Python imports+import ipaddress+import loggingimport osfrom urllib.parse import urlparsefrom urllib.parse import urljoin@@ -32,6 +34,21 @@ DEBUG = int(os.environ.get("DEBUG", "0"))# Self-hosted modeIS_SELF_MANAGED = True+# Webhook IP allowlist β comma-separated IPs or CIDR ranges that are allowed as+# webhook targets even if they resolve to private networks.+# Example: "10.0.0.0/8,192.168.1.0/24,172.16.0.5"+_webhook_allowed_ips_raw = os.environ.get("WEBHOOK_ALLOWED_IPS", "")+WEBHOOK_ALLOWED_IPS = []+_logger = logging.getLogger("plane")+for _cidr in _webhook_allowed_ips_raw.split(","):+ _cidr = _cidr.strip()+ if not _cidr:+ continue+ try:+ WEBHOOK_ALLOWED_IPS.append(ipaddress.ip_network(_cidr, strict=False))+ except ValueError:+ _logger.warning("WEBHOOK_ALLOWED_IPS: skipping invalid entry %r", _cidr)+# Allowed HostsALLOWED_HOSTS = os.environ.get("ALLOWED_HOSTS", "*").split(",")diff --git a/apps/api/plane/tests/unit/bg_tasks/test_work_item_link_task.py b/apps/api/plane/tests/unit/bg_tasks/test_work_item_link_task.pyindex 2838260e89..67c61c6cca 100644--- a/apps/api/plane/tests/unit/bg_tasks/test_work_item_link_task.py+++ b/apps/api/plane/tests/unit/bg_tasks/test_work_item_link_task.py@@ -2,9 +2,12 @@# SPDX-License-Identifier: AGPL-3.0-only# See the LICENSE file for details.+import ipaddress+import pytestfrom unittest.mock import patch, MagicMockfrom plane.bgtasks.work_item_link_task import safe_get, validate_url_ip+from plane.utils.ip_address import validate_urldef _make_response(status_code=200, headers=None, is_redirect=False, content=b""):@@ -43,6 +46,49 @@ class TestValidateUrlIp:validate_url_ip("https://example.com") # Should not raise+class TestValidateUrlAllowlist:+ """Test validate_url allowlist permits specific private IPs."""++ def test_allowlist_permits_private_ip(self):+ allowed = [ipaddress.ip_network("192.168.1.0/24")]+ with patch("plane.utils.ip_address.socket.getaddrinfo") as mock_dns:+ mock_dns.return_value = [(None, None, None, None, ("192.168.1.50", 0))]+ validate_url("http://example.com", allowed_ips=allowed) # Should not raise++ def test_allowlist_does_not_permit_other_private_ip(self):+ allowed = [ipaddress.ip_network("192.168.1.0/24")]+ with patch("plane.utils.ip_address.socket.getaddrinfo") as mock_dns:+ mock_dns.return_value = [(None, None, None, None, ("10.0.0.1", 0))]+ with pytest.raises(ValueError, match="private/internal"):+ validate_url("http://example.com", allowed_ips=allowed)++ def test_allowlist_permits_loopback_when_explicitly_allowed(self):+ allowed = [ipaddress.ip_network("127.0.0.0/8")]+ with patch("plane.utils.ip_address.socket.getaddrinfo") as mock_dns:+ mock_dns.return_value = [(None, None, None, None, ("127.0.0.1", 0))]+ validate_url("http://example.com", allowed_ips=allowed) # Should not raise++ def test_allowlist_permits_matching_ipv4_with_mixed_version_networks(self):+ allowed = [+ ipaddress.ip_network("2001:db8::/32"),+ ipaddress.ip_network("192.168.1.0/24"),+ ]+ with patch("plane.utils.ip_address.socket.getaddrinfo") as mock_dns:+ mock_dns.return_value = [(None, None, None, None, ("192.168.1.50", 0))]+ validate_url("http://example.com", allowed_ips=allowed) # Should not raise++ def test_allowlist_blocks_non_matching_ipv4_with_mixed_version_networks(self):+ allowed = [+ ipaddress.ip_network("2001:db8::/32"),+ ipaddress.ip_network("192.168.1.0/24"),+ ]+ with patch("plane.utils.ip_address.socket.getaddrinfo") as mock_dns:+ mock_dns.return_value = [(None, None, None, None, ("10.0.0.1", 0))]+ with pytest.raises(ValueError, match="private/internal"):+ validate_url("http://example.com", allowed_ips=allowed)++@pytest.mark.unitclass TestSafeGet:"""Test safe_get follows redirects safely and blocks SSRF."""diff --git a/apps/api/plane/utils/ip_address.py b/apps/api/plane/utils/ip_address.pyindex 3a0f171d79..4102ad6f4c 100644--- a/apps/api/plane/utils/ip_address.py+++ b/apps/api/plane/utils/ip_address.py@@ -2,6 +2,52 @@# SPDX-License-Identifier: AGPL-3.0-only# See the LICENSE file for details.+# Python imports+import ipaddress+import socket+from urllib.parse import urlparse+++def validate_url(url, allowed_ips=None):+ """+ Validate that a URL doesn't resolve to a private/internal IP address (SSRF protection).++ Args:+ url: The URL to validate.+ allowed_ips: Optional list of ipaddress.ip_network objects. IPs falling within+ these networks are permitted even if they are private/loopback/reserved.+ Typically sourced from the WEBHOOK_ALLOWED_IPS setting.++ Raises:+ ValueError: If the URL is invalid or resolves to a blocked IP.+ """+ parsed = urlparse(url)+ hostname = parsed.hostname++ if not hostname:+ raise ValueError("Invalid URL: No hostname found")++ if parsed.scheme not in ("http", "https"):+ raise ValueError("Invalid URL scheme. Only HTTP and HTTPS are allowed")++ try:+ addr_info = socket.getaddrinfo(hostname, None)+ except socket.gaierror:+ raise ValueError("Hostname could not be resolved")++ if not addr_info:+ raise ValueError("No IP addresses found for the hostname")++ for addr in addr_info:+ ip = ipaddress.ip_address(addr[4][0])+ if ip.is_private or ip.is_loopback or ip.is_reserved or ip.is_link_local:+ if allowed_ips and any(+ network.version == ip.version and ip in network for network in allowed_ips+ ):+ continue+ raise ValueError("Access to private/internal networks is not allowed")++def get_client_ip(request):x_forwarded_for = request.META.get("HTTP_X_FORWARDED_FOR")if x_forwarded_for: