AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.
feat(backend): allow regex on CORS allowed origins (#11336)
Ubbee68896a25a1e
diff --git a/autogpt_platform/backend/backend/server/rest_api.py b/autogpt_platform/backend/backend/server/rest_api.pyindex 30f0c8b5f5..4d455a0680 100644--- a/autogpt_platform/backend/backend/server/rest_api.py+++ b/autogpt_platform/backend/backend/server/rest_api.py@@ -43,6 +43,7 @@ from backend.integrations.providers import ProviderNamefrom backend.monitoring.instrumentation import instrument_fastapifrom backend.server.external.api import external_appfrom backend.server.middleware.security import SecurityHeadersMiddleware+from backend.server.utils.cors import build_cors_paramsfrom backend.util import jsonfrom backend.util.cloud_storage import shutdown_cloud_storage_handlerfrom backend.util.exceptions import (@@ -303,9 +304,14 @@ async def health():class AgentServer(backend.util.service.AppProcess):def run(self):+ cors_params = build_cors_params(+ settings.config.backend_cors_allow_origins,+ settings.config.app_env,+ )+server_app = starlette.middleware.cors.CORSMiddleware(app=app,- allow_origins=settings.config.backend_cors_allow_origins,+ **cors_params,allow_credentials=True,allow_methods=["*"], # Allows all methodsallow_headers=["*"], # Allows all headersdiff --git a/autogpt_platform/backend/backend/server/test_helpers.py b/autogpt_platform/backend/backend/server/test_helpers.pyindex 98073f0992..c6ba333a2e 100644--- a/autogpt_platform/backend/backend/server/test_helpers.py+++ b/autogpt_platform/backend/backend/server/test_helpers.py@@ -1,7 +1,8 @@"""Helper functions for improved test assertions and error handling."""import json-from typing import Any, Dict, Optional+from contextlib import contextmanager+from typing import Any, Dict, Iterator, Optionaldef assert_response_status(@@ -107,3 +108,24 @@ def assert_mock_called_with_partial(mock_obj: Any, **expected_kwargs: Any) -> Noassert (actual_kwargs[key] == expected_value), f"Mock called with {key}={actual_kwargs[key]}, expected {expected_value}"+++@contextmanager+def override_config(settings: Any, attribute: str, value: Any) -> Iterator[None]:+ """Temporarily override a config attribute for testing.++ Warning: Directly mutates settings.config. If config is reloaded or cached+ elsewhere during the test, side effects may leak. Use with caution in+ parallel tests or when config is accessed globally.++ Args:+ settings: The settings object containing .config+ attribute: The config attribute name to override+ value: The temporary value to set+ """+ original = getattr(settings.config, attribute)+ setattr(settings.config, attribute, value)+ try:+ yield+ finally:+ setattr(settings.config, attribute, original)diff --git a/autogpt_platform/backend/backend/server/utils/cors.py b/autogpt_platform/backend/backend/server/utils/cors.pynew file mode 100644index 0000000000..b8a230eb83--- /dev/null+++ b/autogpt_platform/backend/backend/server/utils/cors.py@@ -0,0 +1,67 @@+from __future__ import annotations++import re+from typing import List, Sequence, TypedDict++from backend.util.settings import AppEnvironment+++class CorsParams(TypedDict):+ allow_origins: List[str]+ allow_origin_regex: str | None+++def build_cors_params(origins: Sequence[str], app_env: AppEnvironment) -> CorsParams:+ allow_origins: List[str] = []+ regex_patterns: List[str] = []++ if app_env == AppEnvironment.PRODUCTION:+ for origin in origins:+ if origin.startswith("regex:"):+ pattern = origin[len("regex:") :]+ pattern_lower = pattern.lower()+ if "localhost" in pattern_lower or "127.0.0.1" in pattern_lower:+ raise ValueError(+ f"Production environment cannot allow localhost origins via regex: {pattern}"+ )+ try:+ compiled = re.compile(pattern)+ test_urls = [+ "http://localhost:3000",+ "http://127.0.0.1:3000",+ "https://localhost:8000",+ "https://127.0.0.1:8000",+ ]+ for test_url in test_urls:+ if compiled.search(test_url):+ raise ValueError(+ f"Production regex pattern matches localhost/127.0.0.1: {pattern}"+ )+ except re.error:+ pass+ continue++ lowered = origin.lower()+ if "localhost" in lowered or "127.0.0.1" in lowered:+ raise ValueError(+ "Production environment cannot allow localhost origins"+ )++ for origin in origins:+ if origin.startswith("regex:"):+ regex_patterns.append(origin[len("regex:") :])+ else:+ allow_origins.append(origin)++ allow_origin_regex = None+ if regex_patterns:+ if len(regex_patterns) == 1:+ allow_origin_regex = f"^(?:{regex_patterns[0]})$"+ else:+ combined_pattern = "|".join(f"(?:{pattern})" for pattern in regex_patterns)+ allow_origin_regex = f"^(?:{combined_pattern})$"++ return {+ "allow_origins": allow_origins,+ "allow_origin_regex": allow_origin_regex,+ }diff --git a/autogpt_platform/backend/backend/server/utils/cors_test.py b/autogpt_platform/backend/backend/server/utils/cors_test.pynew file mode 100644index 0000000000..94b3f17cfc--- /dev/null+++ b/autogpt_platform/backend/backend/server/utils/cors_test.py@@ -0,0 +1,62 @@+import pytest++from backend.server.utils.cors import build_cors_params+from backend.util.settings import AppEnvironment+++def test_build_cors_params_splits_regex_patterns() -> None:+ origins = [+ "https://app.example.com",+ "regex:https://.*\\.example\\.com",+ ]++ result = build_cors_params(origins, AppEnvironment.LOCAL)++ assert result["allow_origins"] == ["https://app.example.com"]+ assert result["allow_origin_regex"] == "^(?:https://.*\\.example\\.com)$"+++def test_build_cors_params_combines_multiple_regex_patterns() -> None:+ origins = [+ "regex:https://alpha.example.com",+ "regex:https://beta.example.com",+ ]++ result = build_cors_params(origins, AppEnvironment.DEVELOPMENT)++ assert result["allow_origins"] == []+ assert result["allow_origin_regex"] == (+ "^(?:(?:https://alpha.example.com)|(?:https://beta.example.com))$"+ )+++def test_build_cors_params_blocks_localhost_literal_in_production() -> None:+ with pytest.raises(ValueError):+ build_cors_params(["http://localhost:3000"], AppEnvironment.PRODUCTION)+++def test_build_cors_params_blocks_localhost_regex_in_production() -> None:+ with pytest.raises(ValueError):+ build_cors_params(["regex:https://.*localhost.*"], AppEnvironment.PRODUCTION)+++def test_build_cors_params_blocks_case_insensitive_localhost_regex() -> None:+ with pytest.raises(ValueError, match="localhost origins via regex"):+ build_cors_params(["regex:https://(?i)LOCALHOST.*"], AppEnvironment.PRODUCTION)+++def test_build_cors_params_blocks_regex_matching_localhost_at_runtime() -> None:+ with pytest.raises(ValueError, match="matches localhost"):+ build_cors_params(["regex:https?://.*:3000"], AppEnvironment.PRODUCTION)+++def test_build_cors_params_allows_vercel_preview_regex() -> None:+ result = build_cors_params(+ ["regex:https://autogpt-git-[a-z0-9-]+\\.vercel\\.app"],+ AppEnvironment.PRODUCTION,+ )++ assert result["allow_origins"] == []+ assert result["allow_origin_regex"] == (+ "^(?:https://autogpt-git-[a-z0-9-]+\\.vercel\\.app)$"+ )diff --git a/autogpt_platform/backend/backend/server/ws_api.py b/autogpt_platform/backend/backend/server/ws_api.pyindex 902b71b0ce..f55bdf284a 100644--- a/autogpt_platform/backend/backend/server/ws_api.py+++ b/autogpt_platform/backend/backend/server/ws_api.py@@ -22,6 +22,7 @@ from backend.server.model import (WSSubscribeGraphExecutionRequest,WSSubscribeGraphExecutionsRequest,)+from backend.server.utils.cors import build_cors_paramsfrom backend.util.retry import continuous_retryfrom backend.util.service import AppProcessfrom backend.util.settings import AppEnvironment, Config, Settings@@ -315,9 +316,13 @@ async def health():class WebsocketServer(AppProcess):def run(self):logger.info(f"CORS allow origins: {settings.config.backend_cors_allow_origins}")+ cors_params = build_cors_params(+ settings.config.backend_cors_allow_origins,+ settings.config.app_env,+ )server_app = CORSMiddleware(app=app,- allow_origins=settings.config.backend_cors_allow_origins,+ **cors_params,allow_credentials=True,allow_methods=["*"],allow_headers=["*"],diff --git a/autogpt_platform/backend/backend/server/ws_api_test.py b/autogpt_platform/backend/backend/server/ws_api_test.pyindex c9c27eb086..51a4722fb1 100644--- a/autogpt_platform/backend/backend/server/ws_api_test.py+++ b/autogpt_platform/backend/backend/server/ws_api_test.py@@ -8,11 +8,13 @@ from pytest_snapshot.plugin import Snapshotfrom backend.data.user import DEFAULT_USER_IDfrom backend.server.conn_manager import ConnectionManager+from backend.server.test_helpers import override_config+from backend.server.ws_api import AppEnvironment, WebsocketServer, WSMessage, WSMethod+from backend.server.ws_api import app as websocket_appfrom backend.server.ws_api import (- WSMessage,- WSMethod,handle_subscribe,handle_unsubscribe,+ settings,websocket_router,)@@ -29,6 +31,47 @@ def mock_manager() -> AsyncMock:return AsyncMock(spec=ConnectionManager)+def test_websocket_server_uses_cors_helper(mocker) -> None:+ cors_params = {+ "allow_origins": ["https://app.example.com"],+ "allow_origin_regex": None,+ }+ mocker.patch("backend.server.ws_api.uvicorn.run")+ cors_middleware = mocker.patch(+ "backend.server.ws_api.CORSMiddleware", return_value=object()+ )+ build_cors = mocker.patch(+ "backend.server.ws_api.build_cors_params", return_value=cors_params+ )++ with override_config(+ settings, "backend_cors_allow_origins", cors_params["allow_origins"]+ ), override_config(settings, "app_env", AppEnvironment.LOCAL):+ WebsocketServer().run()++ build_cors.assert_called_once_with(+ cors_params["allow_origins"], AppEnvironment.LOCAL+ )+ cors_middleware.assert_called_once_with(+ app=websocket_app,+ allow_origins=cors_params["allow_origins"],+ allow_origin_regex=cors_params["allow_origin_regex"],+ allow_credentials=True,+ allow_methods=["*"],+ allow_headers=["*"],+ )+++def test_websocket_server_blocks_localhost_in_production(mocker) -> None:+ mocker.patch("backend.server.ws_api.uvicorn.run")++ with override_config(+ settings, "backend_cors_allow_origins", ["http://localhost:3000"]+ ), override_config(settings, "app_env", AppEnvironment.PRODUCTION):+ with pytest.raises(ValueError):+ WebsocketServer().run()++@pytest.mark.asyncioasync def test_websocket_router_subscribe(mock_websocket: AsyncMock, mock_manager: AsyncMock, snapshot: Snapshot, mockerdiff --git a/autogpt_platform/backend/backend/util/settings.py b/autogpt_platform/backend/backend/util/settings.pyindex 4ba7a2cf40..4a59df760c 100644--- a/autogpt_platform/backend/backend/util/settings.py+++ b/autogpt_platform/backend/backend/util/settings.py@@ -1,5 +1,6 @@import jsonimport os+import refrom enum import Enumfrom typing import Any, Dict, Generic, List, Set, Tuple, Type, TypeVar@@ -427,34 +428,62 @@ class Config(UpdateTrackingModel["Config"], BaseSettings):description="Maximum message size limit for communication with the message bus",)- backend_cors_allow_origins: List[str] = Field(default=["http://localhost:3000"])+ backend_cors_allow_origins: List[str] = Field(+ default=["http://localhost:3000"],+ description="Allowed Origins for CORS. Supports exact URLs (http/https) or entries prefixed with "+ '"regex:" to match via regular expression.',+ )@field_validator("backend_cors_allow_origins")@classmethoddef validate_cors_allow_origins(cls, v: List[str]) -> List[str]:- out = []- port = None- has_localhost = False- has_127_0_0_1 = False- for url in v:- url = url.strip()- if url.startswith(("http://", "https://")):- if "localhost" in url:- port = url.split(":")[2]- has_localhost = True- if "127.0.0.1" in url:- port = url.split(":")[2]- has_127_0_0_1 = True- out.append(url)- else:- raise ValueError(f"Invalid URL: {url}")-- if has_127_0_0_1 and not has_localhost:- out.append(f"http://localhost:{port}")- if has_localhost and not has_127_0_0_1:- out.append(f"http://127.0.0.1:{port}")-- return out+ validated: List[str] = []+ localhost_ports: set[str] = set()+ ip127_ports: set[str] = set()++ for raw_origin in v:+ origin = raw_origin.strip()+ if origin.startswith("regex:"):+ pattern = origin[len("regex:") :]+ if not pattern:+ raise ValueError("Invalid regex pattern: pattern cannot be empty")+ try:+ re.compile(pattern)+ except re.error as exc:+ raise ValueError(+ f"Invalid regex pattern '{pattern}': {exc}"+ ) from exc+ validated.append(origin)+ continue++ if origin.startswith(("http://", "https://")):+ if "localhost" in origin:+ try:+ port = origin.split(":")[2]+ localhost_ports.add(port)+ except IndexError as exc:+ raise ValueError(+ "localhost origins must include an explicit port, e.g. http://localhost:3000"+ ) from exc+ if "127.0.0.1" in origin:+ try:+ port = origin.split(":")[2]+ ip127_ports.add(port)+ except IndexError as exc:+ raise ValueError(+ "127.0.0.1 origins must include an explicit port, e.g. http://127.0.0.1:3000"+ ) from exc+ validated.append(origin)+ continue++ raise ValueError(f"Invalid URL or regex origin: {origin}")++ for port in ip127_ports - localhost_ports:+ validated.append(f"http://localhost:{port}")+ for port in localhost_ports - ip127_ports:+ validated.append(f"http://127.0.0.1:{port}")++ return validated@classmethoddef settings_customise_sources(