Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

feat(provisioning): require signing with no unsigned grace period (#124883)

Rafael Audibertf28cb398375b
diff --git a/ee/api/agentic_provisioning/test/base.py b/ee/api/agentic_provisioning/test/base.py
index 8a88d0bd08fb..2f51e908ca43 100644
--- a/ee/api/agentic_provisioning/test/base.py
+++ b/ee/api/agentic_provisioning/test/base.py
@@ -1,9 +1,10 @@
import json
+import time
+import uuid
import base64
import hashlib
import secrets
import dataclasses
-from datetime import UTC, datetime
from typing import TYPE_CHECKING
from urllib.parse import quote_plus
@@ -11,11 +12,17 @@ from posthog.test.base import APIBaseTest
from unittest.mock import patch
from django.core.cache import cache
-from django.test import override_settings
from django.utils import timezone
+import jwt
+from cryptography.hazmat.primitives.asymmetric import rsa
from rest_framework.test import APIClient
+from posthog.api.oauth.client_assertion import (
+ AGENTIC_TOKEN_ENDPOINT_PATH,
+ CLIENT_ASSERTION_TYPE_JWT_BEARER,
+ expected_assertion_audiences,
+)
from posthog.constants import AvailableFeature
from posthog.models.organization import OrganizationMembership
from posthog.models.team.team import Team
@@ -34,6 +41,22 @@ TEST_PARTNER_CLIENT_ID = "test_partner_client_id"
# requests to present it.
TEST_PARTNER_CLIENT_SECRET = "test_partner_client_secret"
+# The test partner can create accounts, so it has to sign its requests with a private key.
+TEST_PARTNER_JWKS_URI = "https://partner.example.com/.well-known/jwks.json"
+TEST_PARTNER_KID = "test-partner-key"
+# Generated once at import: RSA keygen is slow, and no test mutates the key.
+TEST_PARTNER_KEY = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+TEST_PARTNER_JWKS = {
+ "keys": [
+ {
+ **json.loads(jwt.algorithms.RSAAlgorithm.to_jwk(TEST_PARTNER_KEY.public_key())),
+ "kid": TEST_PARTNER_KID,
+ "use": "sig",
+ "alg": "RS256",
+ }
+ ]
+}
+
# Broad ceiling so token exchanges in tests aren't rejected by the per-app scope cap.
TEST_PARTNER_SCOPES = [
"query:read",
@@ -59,18 +82,6 @@ TEST_PARTNER_PROVISIONING: dict[str, bool] = {
}
-# Signing depends on the clock, so tests pin the window rather than age against the real dates.
-SIGNING_WINDOW_IN_THE_FUTURE = datetime(2100, 1, 1, tzinfo=UTC)
-SIGNING_WINDOW_IN_THE_PAST = datetime(2000, 1, 1, tzinfo=UTC)
-
-
-def signing_required() -> override_settings:
- return override_settings(
- PROVISIONING_SIGNING_REQUIRED_SINCE=SIGNING_WINDOW_IN_THE_PAST,
- PROVISIONING_UNSIGNED_GRACE_UNTIL=SIGNING_WINDOW_IN_THE_PAST,
- )
-
-
def provisioning_config(**overrides) -> dict:
"""The stored form of the test partner's config. Goes into ``_provisioning_config``."""
from posthog.models.oauth_provisioning import ProvisioningConfig
@@ -93,14 +104,15 @@ def patched_budget(view_cls, method: str, endpoint: str, budget, *, multipliers=
return patch.dict(budgets, {endpoint: dataclasses.replace(budgets[endpoint], **changes)})
-@override_settings(
- PROVISIONING_SIGNING_REQUIRED_SINCE=SIGNING_WINDOW_IN_THE_FUTURE,
- PROVISIONING_UNSIGNED_GRACE_UNTIL=SIGNING_WINDOW_IN_THE_FUTURE,
-)
class ProvisioningTestBase(APIBaseTest):
def setUp(self):
super().setUp()
self.client = APIClient()
+ jwks_fetch = patch(
+ "posthog.api.oauth.client_assertion.fetch_client_json_document", return_value=(TEST_PARTNER_JWKS, None)
+ )
+ jwks_fetch.start()
+ self.addCleanup(jwks_fetch.stop)
self.partner = self._ensure_partner_app()
def _ensure_partner_app(self):
@@ -110,8 +122,9 @@ class ProvisioningTestBase(APIBaseTest):
client_id=TEST_PARTNER_CLIENT_ID,
defaults={
"name": "Test Provisioning Partner",
- "client_secret": TEST_PARTNER_CLIENT_SECRET,
+ "client_secret": "",
"client_type": OAuthApplication.CLIENT_CONFIDENTIAL,
+ "jwks_uri": TEST_PARTNER_JWKS_URI,
"authorization_grant_type": OAuthApplication.GRANT_AUTHORIZATION_CODE,
"redirect_uris": "https://partner.example.com/callback",
"algorithm": "RS256",
@@ -146,9 +159,30 @@ class ProvisioningTestBase(APIBaseTest):
def _post_with_bearer(self, url: str, data: dict | None = None, token: str = "", **kwargs):
return self._post_api(url, data, HTTP_AUTHORIZATION=f"Bearer {token}", **kwargs)
- def _client_credentials(self, partner=None, secret: str | None = None) -> dict[str, str]:
- """The client_secret_post form: credentials merged into the request body."""
+ def _client_assertion(self, partner=None) -> str:
+ partner = partner or self.partner
+ now = int(time.time())
+ claims = {
+ "iss": partner.client_id,
+ "sub": partner.client_id,
+ "aud": expected_assertion_audiences(AGENTIC_TOKEN_ENDPOINT_PATH)[0],
+ # Each assertion is single use, so every request needs its own jti.
+ "jti": str(uuid.uuid4()),
+ "iat": now,
+ "exp": now + 60,
+ }
+ return jwt.encode(claims, TEST_PARTNER_KEY, algorithm="RS256", headers={"kid": TEST_PARTNER_KID})
+
+ def _client_auth(self, partner=None, secret: str | None = None) -> dict[str, str]:
+ """The body fields that authenticate the partner: a signed assertion for a private_key_jwt
+ partner, and the client_secret_post form for a partner registered with a secret."""
partner = partner or self.partner
+ if partner.uses_private_key_jwt_auth:
+ return {
+ "client_id": partner.client_id,
+ "client_assertion": self._client_assertion(partner),
+ "client_assertion_type": CLIENT_ASSERTION_TYPE_JWT_BEARER,
+ }
return {
"client_id": partner.client_id,
"client_secret": TEST_PARTNER_CLIENT_SECRET if secret is None else secret,
@@ -160,8 +194,8 @@ class ProvisioningTestBase(APIBaseTest):
raw = f"{quote_plus(partner.client_id)}:{quote_plus(TEST_PARTNER_CLIENT_SECRET if secret is None else secret)}"
return f"Basic {base64.b64encode(raw.encode()).decode()}"
- def _post_with_client_secret(self, url: str, data: dict | None = None, partner=None, **kwargs):
- return self._post_api(url, {**(data or {}), **self._client_credentials(partner)}, **kwargs)
+ def _post_as_partner(self, url: str, data: dict | None = None, partner=None, **kwargs):
+ return self._post_api(url, {**(data or {}), **self._client_auth(partner)}, **kwargs)
def _pkce_pair(self) -> tuple[str, str]:
verifier = secrets.token_urlsafe(48)
@@ -204,8 +238,8 @@ class ProvisioningTestBase(APIBaseTest):
data = {"grant_type": "authorization_code", "code": code, "code_verifier": verifier}
# A confidential partner has to authenticate at the token endpoint; a public one
# exchanges on the code_verifier alone.
- if partner.uses_client_secret_auth:
- data.update(self._client_credentials(partner, secret=secret))
+ if partner.requires_client_authentication:
+ data.update(self._client_auth(partner, secret=secret))
return self.client.post("/api/agentic/oauth/token", data=data)
def _get_bearer_token(self) -> str:
diff --git a/ee/api/agentic_provisioning/test/test_account_requests.py b/ee/api/agentic_provisioning/test/test_account_requests.py
index d54a1247c457..466f017d9764 100644
--- a/ee/api/agentic_provisioning/test/test_account_requests.py
+++ b/ee/api/agentic_provisioning/test/test_account_requests.py
@@ -21,7 +21,7 @@ from posthog.test.authentication_checks import covers_authentication
from ee.api.agentic_provisioning.analytics import capture_provisioning_event
from ee.api.agentic_provisioning.authentication import ProvisioningAuthentication
from ee.api.agentic_provisioning.constants import AUTH_CODE_CACHE_PREFIX, PENDING_AUTH_CACHE_PREFIX
-from ee.api.agentic_provisioning.test.base import ProvisioningTestBase, provisioning_config
+from ee.api.agentic_provisioning.test.base import TEST_PARTNER_JWKS_URI, ProvisioningTestBase, provisioning_config
ACCOUNT_REQUESTS_URL = "/api/agentic/provisioning/account_requests"
VALID_CODE_CHALLENGE = "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM"
@@ -39,7 +39,7 @@ class TestAccountRequests(ProvisioningTestBase):
return payload
def _post_account_request(self, payload):
- return self._post_with_client_secret(ACCOUNT_REQUESTS_URL, payload)
+ return self._post_as_partner(ACCOUNT_REQUESTS_URL, payload)
def test_no_identified_partner_returns_401(self):
res = self._post_api(ACCOUNT_REQUESTS_URL, self._account_request_payload())
@@ -244,7 +244,8 @@ class TestPKCEPartnerExistingUserConsent(ProvisioningTestBase):
client_id="pkce-test-partner",
name="PKCE Test Partner",
client_secret="",
- client_type=OAuthApplication.CLIENT_PUBLIC,
+ client_type=OAuthApplication.CLIENT_CONFIDENTIAL,
+ jwks_uri=TEST_PARTNER_JWKS_URI,
authorization_grant_type=OAuthApplication.GRANT_AUTHORIZATION_CODE,
redirect_uris="https://partner.example.com/callback",
algorithm="RS256",
@@ -256,7 +257,7 @@ class TestPKCEPartnerExistingUserConsent(ProvisioningTestBase):
)
def _post_as_pkce_partner(self, data: dict):
- return self._post_api(ACCOUNT_REQUESTS_URL, data)
+ return self._post_as_partner(ACCOUNT_REQUESTS_URL, data, partner=self.pkce_partner)
def _account_request_payload(self, **overrides):
payload = {
diff --git a/ee/api/agentic_provisioning/test/test_authorize.py b/ee/api/agentic_provisioning/test/test_authorize.py
index 7512c5e0b412..0ce1bd4e4e1a 100644
--- a/ee/api/agentic_provisioning/test/test_authorize.py
+++ b/ee/api/agentic_provisioning/test/test_authorize.py
@@ -16,7 +16,7 @@ from posthog.models.user import User
from ee.api.agentic_provisioning.constants import AUTH_CODE_CACHE_PREFIX, PENDING_AUTH_CACHE_PREFIX
from ee.api.agentic_provisioning.test.base import (
- TEST_PARTNER_CLIENT_SECRET,
+ TEST_PARTNER_JWKS_URI,
TEST_PARTNER_SCOPES,
ProvisioningTestBase,
provisioning_config,
@@ -65,8 +65,9 @@ class AuthorizeTestBase(ProvisioningTestBase):
return OAuthApplication.objects.create(
client_id="authorize-skip-consent-partner",
name="Skip Consent Partner",
- client_secret=TEST_PARTNER_CLIENT_SECRET,
+ client_secret="",
client_type=OAuthApplication.CLIENT_CONFIDENTIAL,
+ jwks_uri=TEST_PARTNER_JWKS_URI,
authorization_grant_type=OAuthApplication.GRANT_AUTHORIZATION_CODE,
redirect_uris=PARTNER_CALLBACK,
algorithm="RS256",
@@ -215,7 +216,7 @@ class TestAgenticAuthorize(AuthorizeTestBase):
"grant_type": "authorization_code",
"code": code,
"code_verifier": verifier,
- **self._client_credentials(partner),
+ **self._client_auth(partner),
},
)
assert token_res.status_code == 200
diff --git a/ee/api/agentic_provisioning/test/test_client_registration.py b/ee/api/agentic_provisioning/test/test_client_registration.py
index 2c9fab9405da..7af18a63f8e1 100644
--- a/ee/api/agentic_provisioning/test/test_client_registration.py
+++ b/ee/api/agentic_provisioning/test/test_client_registration.py
@@ -1,13 +1,11 @@
import json
import time
-from datetime import timedelta
from ipaddress import ip_address
from unittest.mock import patch
from django.core.cache import cache
from django.test import override_settings
-from django.utils import timezone
import jwt
from cryptography.hazmat.primitives.asymmetric import rsa
@@ -21,12 +19,7 @@ from posthog.api.oauth.client_assertion import (
)
from posthog.models.oauth import OAuthApplication
-from ee.api.agentic_provisioning.test.base import (
- TEST_PARTNER_SCOPES,
- ProvisioningTestBase,
- provisioning_config,
- signing_required,
-)
+from ee.api.agentic_provisioning.test.base import TEST_PARTNER_SCOPES, ProvisioningTestBase, provisioning_config
REGISTRATION_URL = "/api/agentic/provisioning/client_registration"
ACCOUNT_REQUESTS_URL = "/api/agentic/provisioning/account_requests"
@@ -162,69 +155,32 @@ class TestClientRegistration(ProvisioningTestBase):
def test_reports_diagnostics_for_a_private_key_jwt_partner(self):
self._make_partner()
- with signing_required():
- res = self._register({"client_id": CIMD_URL})
+ res = self._register({"client_id": CIMD_URL})
assert res.status_code == 200, res.json()
body = res.json()
assert body["registered"] is True
assert body["client_id"] == CIMD_URL
assert body["token_endpoint_auth_method"] == "private_key_jwt"
- assert body["capabilities"] == {
- "account_requests": True,
- "unsigned_requests": False,
- "unsigned_requests_allowed_until": None,
- }
+ assert body["capabilities"] == {"account_requests": True, "unsigned_requests": False}
checks = {check["name"]: check for check in body["checks"]}
assert checks["jwks"]["ok"] is True
assert KID in checks["jwks"]["detail"]
- @parameterized.expand(
- [
- ("during_grace", True, True),
- ("after_grace", True, False),
- # The row predates the requirement, but the partnership starts with this registration.
- ("promoted_after_the_requirement", False, True),
- ]
- )
- def test_reports_whether_a_partner_without_a_key_may_still_call_unsigned(
- self, _name: str, already_a_partner: bool, grace_ongoing: bool
- ) -> None:
- app = self._make_partner(
+ @parameterized.expand([("already_a_partner", True), ("promoted_by_this_registration", False)])
+ def test_reports_that_a_partner_without_a_key_must_sign(self, _name: str, already_a_partner: bool) -> None:
+ self._make_partner(
client_type=OAuthApplication.CLIENT_PUBLIC, jwks_uri=None, is_provisioning_partner=already_a_partner
)
- OAuthApplication.objects.filter(pk=app.pk).update(created=timezone.now() - timedelta(days=14))
- grace_until = timezone.now() + timedelta(days=7 if grace_ongoing else -1)
- in_grace = already_a_partner and grace_ongoing
- with override_settings(
- PROVISIONING_SIGNING_REQUIRED_SINCE=timezone.now() - timedelta(days=7),
- PROVISIONING_UNSIGNED_GRACE_UNTIL=grace_until,
- ):
- res = self._register({"client_id": CIMD_URL}, document=self._document(signs=False))
+ res = self._register({"client_id": CIMD_URL}, document=self._document(signs=False))
assert res.status_code == 200, res.json()
body = res.json()
assert body["token_endpoint_auth_method"] == "none"
jwks = {check["name"]: check for check in body["checks"]}["jwks"]
- if in_grace:
- assert jwks == {
- "name": "jwks",
- "ok": True,
- "detail": f"Unsigned requests allowed until {grace_until.isoformat()}. {PRIVATE_KEY_REQUIRED_MESSAGE}",
- }
- assert body["capabilities"] == {
- "account_requests": True,
- "unsigned_requests": True,
- "unsigned_requests_allowed_until": grace_until.isoformat(),
- }
- else:
- assert jwks == {"name": "jwks", "ok": False, "detail": PRIVATE_KEY_REQUIRED_MESSAGE}
- assert body["capabilities"] == {
- "account_requests": False,
- "unsigned_requests": False,
- "unsigned_requests_allowed_until": None,
- }
+ assert jwks == {"name": "jwks", "ok": False, "detail": PRIVATE_KEY_REQUIRED_MESSAGE}
+ assert body["capabilities"] == {"account_requests": False, "unsigned_requests": False}
def test_brand_new_partner_is_confidential_on_its_first_registration(self):
# No pre-existing row: this is the client_id's first ever contact with PostHog, so the
diff --git a/ee/api/agentic_provisioning/test/test_e2e_flow.py b/ee/api/agentic_provisioning/test/test_e2e_flow.py
index 016dd9d88fd8..eca7c685f1d9 100644
--- a/ee/api/agentic_provisioning/test/test_e2e_flow.py
+++ b/ee/api/agentic_provisioning/test/test_e2e_flow.py
@@ -7,7 +7,7 @@ from posthog.models.activity_logging.activity_log import ActivityLog
from posthog.models.oauth import OAuthApplication
from posthog.models.user import User
-from ee.api.agentic_provisioning.test.base import ProvisioningTestBase, provisioning_config
+from ee.api.agentic_provisioning.test.base import TEST_PARTNER_JWKS_URI, ProvisioningTestBase, provisioning_config
TOKEN_URL = "/api/agentic/oauth/token"
@@ -26,7 +26,7 @@ class TestE2EProvisioningFlow(ProvisioningTestBase):
"code_challenge_method": "S256",
"expires_at": (timezone.now() + timedelta(minutes=10)).isoformat(),
}
- res = self._post_with_client_secret("/api/agentic/provisioning/account_requests", data=account_request)
+ res = self._post_as_partner("/api/agentic/provisioning/account_requests", data=account_request)
assert res.status_code == 200
assert res.json()["type"] == "oauth"
auth_code = res.json()["oauth"]["code"]
@@ -38,7 +38,7 @@ class TestE2EProvisioningFlow(ProvisioningTestBase):
"grant_type": "authorization_code",
"code": auth_code,
"code_verifier": verifier,
- **self._client_credentials(),
+ **self._client_auth(),
},
)
assert res.status_code == 200
@@ -107,7 +107,7 @@ class TestE2EProvisioningFlow(ProvisioningTestBase):
# 7. Refresh the token
res = self._post_api(
TOKEN_URL,
- {"grant_type": "refresh_token", "refresh_token": refresh_token, **self._client_credentials()},
+ {"grant_type": "refresh_token", "refresh_token": refresh_token, **self._client_auth()},
)
assert res.status_code == 200
new_access_token = res.json()["access_token"]
@@ -124,11 +124,12 @@ class TestE2EProvisioningFlow(ProvisioningTestBase):
def test_pkce_existing_user_consent_e2e(self):
"""E2E: PKCE partner with existing user goes through browser consent flow."""
- OAuthApplication.objects.create(
+ partner = OAuthApplication.objects.create(
client_id="pkce-e2e-partner",
name="PKCE E2E Partner",
client_secret="",
- client_type=OAuthApplication.CLIENT_PUBLIC,
+ client_type=OAuthApplication.CLIENT_CONFIDENTIAL,
+ jwks_uri=TEST_PARTNER_JWKS_URI,
authorization_grant_type=OAuthApplication.GRANT_AUTHORIZATION_CODE,
redirect_uris="https://partner.example.com/callback",
algorithm="RS256",
@@ -158,7 +159,7 @@ class TestE2EProvisioningFlow(ProvisioningTestBase):
"code_challenge_method": "S256",
"expires_at": (timezone.now() + timedelta(minutes=10)).isoformat(),
}
- res = self._post_api("/api/agentic/provisioning/account_requests", account_request)
+ res = self._post_as_partner("/api/agentic/provisioning/account_requests", account_request, partner=partner)
assert res.status_code == 200
data = res.json()
assert data["type"] == "requires_auth"
@@ -184,8 +185,10 @@ class TestE2EProvisioningFlow(ProvisioningTestBase):
auth_code = parse_qs(parsed_callback.query)["code"][0]
# 4. Partner exchanges auth code for tokens using PKCE
- res = self._post_api(
- TOKEN_URL, {"grant_type": "authorization_code", "code": auth_code, "code_verifier": verifier}
+ res = self._post_as_partner(
+ TOKEN_URL,
+ {"grant_type": "authorization_code", "code": auth_code, "code_verifier": verifier},
+ partner=partner,
)
assert res.status_code == 200
token_data = res.json()
diff --git a/ee/api/agentic_provisioning/test/test_limits.py b/ee/api/agentic_provisioning/test/test_limits.py
index f2aa8a26ae85..e3e797423054 100644
--- a/ee/api/agentic_provisioning/test/test_limits.py
+++ b/ee/api/agentic_provisioning/test/test_limits.py
@@ -1,16 +1,9 @@
-from contextlib import nullcontext
-
from parameterized import parameterized
from posthog.models.oauth import OAuthApplication
from ee.api.agentic_provisioning.ratelimits import describe_budgets
-from ee.api.agentic_provisioning.test.base import (
- TEST_PARTNER_CLIENT_SECRET,
- ProvisioningTestBase,
- provisioning_config,
- signing_required,
-)
+from ee.api.agentic_provisioning.test.base import ProvisioningTestBase, provisioning_config
LIMITS_URL = "/api/agentic/provisioning/limits"
@@ -40,7 +33,7 @@ class TestLimitsEndpoint(ProvisioningTestBase):
assert res.status_code == 200
body = res.json()
assert body["tier"] == "jwks"
- assert body["tier_basis"] == {"client_authentication": "client_secret_post", "attested": False}
+ assert body["tier_basis"] == {"client_authentication": "private_key_jwt", "attested": False}
# account_requests declares (5, 10); the JWKS tier multiplies by 5.
assert body["endpoints"]["account_requests"]["per_hour"] == 50
assert body["endpoints"]["account_requests"]["burst"] == 25
@@ -53,10 +46,7 @@ class TestLimitsEndpoint(ProvisioningTestBase):
def test_client_authenticated_partner_sees_its_overrides(self):
self.partner.update_provisioning_rate_limits(resource_creates=7, deep_links=-1)
- res = self.client.post(
- LIMITS_URL,
- {"client_id": self.partner.client_id, "client_secret": TEST_PARTNER_CLIENT_SECRET},
- )
+ res = self.client.post(LIMITS_URL, self._client_auth())
assert res.status_code == 200
body = res.json()
@@ -72,8 +62,7 @@ class TestLimitsEndpoint(ProvisioningTestBase):
# GET has nowhere to carry client authentication, so the verb is gone. If it
# comes back, the bare client_id path comes back with it.
("get_with_client_id", "get", True, False, 405),
- # Its grace lets it call unsigned elsewhere, but a client_id still proves nothing.
- ("bare_client_id_of_a_switched_partner_in_grace", "post", True, True, 401),
+ ("bare_client_id_of_a_private_key_jwt_partner", "post", True, True, 401),
]
)
def test_caller_without_proof_is_rejected(
@@ -89,18 +78,20 @@ class TestLimitsEndpoint(ProvisioningTestBase):
@parameterized.expand(
[
("deactivated", {"active": False}, False),
- ("grace_ended_without_a_private_key", {}, True),
+ ("dropped_its_private_key", {}, True),
]
)
def test_bearer_is_rejected_after_partner_changes(
- self, _name: str, change: dict[str, bool], grace_ended: bool
+ self, _name: str, change: dict[str, bool], drop_key: bool
) -> None:
token = self._request_bearer_token().json()["access_token"]
if change:
self.partner.update_provisioning(**change)
+ if drop_key:
+ self.partner.jwks_uri = None
+ self.partner.save(update_fields=["jwks_uri"])
- with signing_required() if grace_ended else nullcontext():
- res = self.client.post(LIMITS_URL, HTTP_AUTHORIZATION=f"Bearer {token}")
+ res = self.client.post(LIMITS_URL, HTTP_AUTHORIZATION=f"Bearer {token}")
assert res.status_code == 401
diff --git a/ee/api/agentic_provisioning/test/test_oauth_token.py b/ee/api/agentic_provisioning/test/test_oauth_token.py
index ae20c855ed8a..a49a70f40a5b 100644
--- a/ee/api/agentic_provisioning/test/test_oauth_token.py
+++ b/ee/api/agentic_provisioning/test/test_oauth_token.py
@@ -20,10 +20,10 @@ from products.access_control.backend.models.access_control import AccessControl
from ee.api.agentic_provisioning.constants import AUTH_CODE_CACHE_PREFIX
from ee.api.agentic_provisioning.test.base import (
+ TEST_PARTNER_CLIENT_SECRET,
TEST_PARTNER_SCOPES,
ProvisioningTestBase,
provisioning_config,
- signing_required,
)
TOKEN_URL = "/api/agentic/oauth/token"
@@ -46,21 +46,21 @@ class TestOAuthTokenExchange(ProvisioningTestBase):
cache.set(key, data, timeout=300)
return code, verifier
- def _exchange_code(self, code: str, verifier: str):
+ def _exchange_code(self, code: str, verifier: str, partner: OAuthApplication | None = None):
return self._post_api(
TOKEN_URL,
{
"grant_type": "authorization_code",
"code": code,
"code_verifier": verifier,
- **self._client_credentials(),
+ **self._client_auth(partner),
},
)
- def _refresh(self, refresh_token: str):
+ def _refresh(self, refresh_token: str, partner: OAuthApplication | None = None):
return self._post_api(
TOKEN_URL,
- {"grant_type": "refresh_token", "refresh_token": refresh_token, **self._client_credentials()},
+ {"grant_type": "refresh_token", "refresh_token": refresh_token, **self._client_auth(partner)},
)
def _stamp_session_revoke(self, when=None) -> None:
@@ -80,6 +80,20 @@ class TestOAuthTokenExchange(ProvisioningTestBase):
_provisioning_config=provisioning_config(active=True, **provisioning),
)
+ def _client_secret_partner(self, **provisioning: bool) -> OAuthApplication:
+ return OAuthApplication.objects.create(
+ client_id="client-secret-token-partner",
+ name="Client Secret Token Partner",
+ client_secret=TEST_PARTNER_CLIENT_SECRET,
+ client_type=OAuthApplication.CLIENT_CONFIDENTIAL,
+ authorization_grant_type=OAuthApplication.GRANT_AUTHORIZATION_CODE,
+ redirect_uris="https://partner.example.com/callback",
+ algorithm="RS256",
+ scopes=TEST_PARTNER_SCOPES,
+ is_provisioning_partner=True,
+ _provisioning_config=provisioning_config(active=True, **provisioning),
+ )
+
def test_valid_code_exchange_returns_tokens(self):
res = self._request_bearer_token()
assert res.status_code == 200
@@ -164,10 +178,11 @@ class TestOAuthTokenExchange(ProvisioningTestBase):
]
)
def test_confidential_partner_without_valid_secret_cannot_exchange_code(self, _name, secret):
- code, verifier = self._mint_auth_code()
+ partner = self._client_secret_partner(can_create_accounts=False)
+ code, verifier = self._mint_auth_code(partner=partner)
body = {"grant_type": "authorization_code", "code": code, "code_verifier": verifier}
if secret is not None:
- body.update(self._client_credentials(secret=secret))
+ body.update(self._client_auth(partner, secret=secret))
res = self._post_api(TOKEN_URL, body)
@@ -175,29 +190,30 @@ class TestOAuthTokenExchange(ProvisioningTestBase):
assert res.json()["error"] == "invalid_client"
# Client authentication runs before the code is consumed, so a rejected attempt must
# leave the caller able to retry with the right secret.
- assert self._exchange_code(code, verifier).status_code == 200
+ assert self._exchange_code(code, verifier, partner).status_code == 200
def test_confidential_partner_without_valid_secret_cannot_refresh(self):
- refresh_token = self._request_bearer_token().json()["refresh_token"]
+ partner = self._client_secret_partner(can_create_accounts=False)
+ refresh_token = self._request_bearer_token(partner=partner).json()["refresh_token"]
res = self._post_api(
TOKEN_URL,
{
"grant_type": "refresh_token",
"refresh_token": refresh_token,
- **self._client_credentials(secret="not-the-real-secret"),
+ **self._client_auth(partner, secret="not-the-real-secret"),
},
)
assert res.status_code == 401
assert res.json()["error"] == "invalid_client"
# The rejected refresh must not have revoked the caller's only token.
- assert self._refresh(refresh_token).status_code == 200
+ assert self._refresh(refresh_token, partner).status_code == 200
def test_pkce_partner_exchanges_code_without_a_secret(self):
# PKCE partners are public clients: code_verifier is their only client authentication,
# so requiring a secret from confidential partners must not reach them.
- code, verifier = self._mint_auth_code(partner=self._public_partner())
+ code, verifier = self._mint_auth_code(partner=self._public_partner(can_create_accounts=False))
res = self._post_api(TOKEN_URL, {"grant_type": "authorization_code", "code": code, "code_verifier": verifier})
@@ -240,7 +256,7 @@ class TestOAuthTokenExchange(ProvisioningTestBase):
),
]
)
- def test_unsigned_token_request_after_grace(
+ def test_unsigned_token_request(
self,
_name: str,
public: bool,
@@ -249,21 +265,19 @@ class TestOAuthTokenExchange(ProvisioningTestBase):
url: str,
expected_status: int,
) -> None:
- if public:
- partner = self._public_partner(**capabilities)
- else:
- partner = self.partner
- if capabilities:
- partner.update_provisioning(**capabilities)
- credentials = self._client_credentials(partner) if not public else {"client_id": partner.client_id}
+ # Starts exempt so it can hold a refresh token, as a partner granted a capability later would.
+ exempt = {"can_create_accounts": False}
+ partner = self._public_partner(**exempt) if public else self._client_secret_partner(**exempt)
+ credentials = self._client_auth(partner) if not public else {"client_id": partner.client_id}
if grant_type == "authorization_code":
code, verifier = self._mint_auth_code(partner=partner)
body = {"grant_type": grant_type, "code": code, "code_verifier": verifier, **credentials}
else:
refresh_token = self._request_bearer_token(partner=partner).json()["refresh_token"]
body = {"grant_type": grant_type, "refresh_token": refresh_token, **credentials}
+ partner.update_provisioning(**{"can_create_accounts": True, **capabilities})
- with signing_required(), patch("posthoganalytics.capture") as capture:
+ with patch("posthoganalytics.capture") as capture:
res = self._post_api(url, body)
assert res.status_code == expected_status, res.json()
@@ -275,26 +289,27 @@ class TestOAuthTokenExchange(ProvisioningTestBase):
@parameterized.expand([("public", True), ("client_secret", False)])
def test_refused_partner_can_still_revoke_its_tokens(self, _name: str, public: bool) -> None:
- partner = self._public_partner() if public else self.partner
- credentials = {"client_id": partner.client_id} if public else self._client_credentials(partner)
+ exempt = {"can_create_accounts": False}
+ partner = self._public_partner(**exempt) if public else self._client_secret_partner(**exempt)
+ credentials = {"client_id": partner.client_id} if public else self._client_auth(partner)
refresh_token = self._request_bearer_token(partner=partner).json()["refresh_token"]
+ partner.update_provisioning(can_create_accounts=True)
- with signing_required():
- res = self._post_api(
- "/oauth/revoke/",
- urlencode({"token": refresh_token, "token_type_hint": "refresh_token", **credentials}).encode(),
- content_type="application/x-www-form-urlencoded",
- )
+ res = self._post_api(
+ "/oauth/revoke/",
+ urlencode({"token": refresh_token, "token_type_hint": "refresh_token", **credentials}).encode(),
+ content_type="application/x-www-form-urlencoded",
+ )
assert res.status_code == 200, res.content
assert not OAuthRefreshToken.objects.filter(token=refresh_token, revoked__isnull=True).exists()
def test_refused_partner_gets_a_401_from_the_jwt_bearer_grant(self):
- with signing_required():
- res = self._post_api(
- OAUTH_TOKEN_URL,
- {"grant_type": JWT_BEARER_GRANT_TYPE, "assertion": "not-an-id-jag", **self._client_credentials()},
- )
+ partner = self._client_secret_partner()
+ res = self._post_api(
+ OAUTH_TOKEN_URL,
+ {"grant_type": JWT_BEARER_GRANT_TYPE, "assertion": "not-an-id-jag", **self._client_auth(partner)},
+ )
assert res.status_code == 401
assert res.json()["error"] == "invalid_client"
@@ -325,7 +340,7 @@ class TestOAuthTokenExchange(ProvisioningTestBase):
def test_omitted_request_scopes_resolve_to_app_ceiling(self):
verifier, challenge = self._pkce_pair()
- res = self._post_with_client_secret(
+ res = self._post_as_partner(
"/api/agentic/provisioning/account_requests",
data={
"id": "req_scopeless",
diff --git a/ee/api/agentic_provisioning/test/test_partner_rate_limits.py b/ee/api/agentic_provisioning/test/test_partner_rate_limits.py
index 33cd3daebadd..23f3699c2ae8 100644
--- a/ee/api/agentic_provisioning/test/test_partner_rate_limits.py
+++ b/ee/api/agentic_provisioning/test/test_partner_rate_limits.py
@@ -19,6 +19,7 @@ from ee.api.agentic_provisioning.exceptions import ProvisioningError
from ee.api.agentic_provisioning.ratelimits import FLAT_MULTIPLIERS, charge_partner, registered_budgets
from ee.api.agentic_provisioning.test.base import (
TEST_PARTNER_CLIENT_SECRET,
+ TEST_PARTNER_JWKS_URI,
ProvisioningTestBase,
patched_budget,
provisioning_config,
@@ -55,8 +56,9 @@ class TestPartnerRateLimits(ProvisioningTestBase):
self.partner_app = OAuthApplication.objects.create(
client_id=PARTNER_CLIENT_ID,
name="Rate Limit Test Partner",
- client_secret=TEST_PARTNER_CLIENT_SECRET,
+ client_secret="",
client_type=OAuthApplication.CLIENT_CONFIDENTIAL,
+ jwks_uri=TEST_PARTNER_JWKS_URI,
authorization_grant_type=OAuthApplication.GRANT_AUTHORIZATION_CODE,
redirect_uris="https://partner.example.com/callback",
algorithm="RS256",
@@ -166,7 +168,7 @@ class TestPartnerRateLimits(ProvisioningTestBase):
"grant_type": "authorization_code",
"code": code,
"code_verifier": code_verifier,
- **self._client_credentials(self.partner_app),
+ **self._client_auth(self.partner_app),
}
).encode()
res = self.client.post(
@@ -208,7 +210,7 @@ class TestPartnerRateLimits(ProvisioningTestBase):
{
"grant_type": "refresh_token",
"refresh_token": "test_refresh_token_1",
- **self._client_credentials(self.partner_app),
+ **self._client_auth(self.partner_app),
}
).encode()
res = self.client.post(
diff --git a/ee/api/agentic_provisioning/test/test_private_key_jwt_partner.py b/ee/api/agentic_provisioning/test/test_private_key_jwt_partner.py
index d62ba18f59f0..6a799a5c9a62 100644
--- a/ee/api/agentic_provisioning/test/test_private_key_jwt_partner.py
+++ b/ee/api/agentic_provisioning/test/test_private_key_jwt_partner.py
@@ -1,6 +1,5 @@
import json
import time
-from contextlib import nullcontext
from unittest.mock import MagicMock, patch
@@ -15,12 +14,7 @@ from posthog.api.oauth.client_assertion import CLIENT_ASSERTION_TYPE_JWT_BEARER,
from posthog.models.oauth import OAuthAccessToken, OAuthApplication
from posthog.models.user import User
-from ee.api.agentic_provisioning.test.base import (
- TEST_PARTNER_SCOPES,
- ProvisioningTestBase,
- provisioning_config,
- signing_required,
-)
+from ee.api.agentic_provisioning.test.base import TEST_PARTNER_SCOPES, ProvisioningTestBase, provisioning_config
ACCOUNT_REQUESTS_URL = "/api/agentic/provisioning/account_requests"
TOKEN_URL = "/api/agentic/oauth/token"
@@ -97,30 +91,27 @@ class TestPrivateKeyJwtPartner(ProvisioningTestBase):
@parameterized.expand(
[
- # The client_id is public, so presenting it alone must not authenticate a key-based partner,
- # even while partners that have not switched yet are still in grace.
- ("during_grace", {}, False, 401),
- ("after_grace", {}, True, 401),
- ("cannot_create_accounts_or_pay", {"can_create_accounts": False}, False, 401),
+ # The client_id is public, so presenting it alone must not authenticate a key-based partner.
+ ("creates_accounts", {}, 401),
+ ("cannot_create_accounts_or_pay", {"can_create_accounts": False}, 401),
]
)
def test_account_request_without_an_assertion(
- self, _name: str, capabilities: dict[str, bool], grace_ended: bool, expected_status: int
+ self, _name: str, capabilities: dict[str, bool], expected_status: int
) -> None:
if capabilities:
self.jwt_partner.update_provisioning(**capabilities)
- with signing_required() if grace_ended else nullcontext():
- res = self._post_api(
- ACCOUNT_REQUESTS_URL,
- {
- "id": "req_jwt_bare",
- "email": "[email protected]",
- "client_id": PARTNER_CLIENT_ID,
- "code_challenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM",
- "code_challenge_method": "S256",
- },
- )
+ res = self._post_api(
+ ACCOUNT_REQUESTS_URL,
+ {
+ "id": "req_jwt_bare",
+ "email": "[email protected]",
+ "client_id": PARTNER_CLIENT_ID,
+ "code_challenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM",
+ "code_challenge_method": "S256",
+ },
+ )
assert res.status_code == expected_status, res.json()
if not capabilities:
@@ -153,14 +144,13 @@ class TestPrivateKeyJwtPartner(ProvisioningTestBase):
@parameterized.expand(
[
- ("unsigned_during_grace", False, None, 401),
- ("unsigned_after_grace", True, None, 401),
- ("signed_by_another_key_during_grace", False, CLIENT_ASSERTION_TYPE_JWT_BEARER, 401),
- ("signed_by_another_key_without_a_type_during_grace", False, "", 401),
+ ("unsigned", None, 401),
+ ("signed_by_another_key", CLIENT_ASSERTION_TYPE_JWT_BEARER, 401),
+ ("signed_by_another_key_without_a_type", "", 401),
]
)
def test_token_exchange_assertion(
- self, _name: str, grace_ended: bool, forged_assertion_type: str | None, expected_status: int
+ self, _name: str, forged_assertion_type: str | None, expected_status: int
) -> None:
code, verifier = self._mint_auth_code(partner=self.jwt_partner)
body = {"grant_type": "authorization_code", "code": code, "code_verifier": verifier}
@@ -170,8 +160,7 @@ class TestPrivateKeyJwtPartner(ProvisioningTestBase):
client_assertion_type=forged_assertion_type,
)
- with signing_required() if grace_ended else nullcontext():
- res = self._post(TOKEN_URL, body)
+ res = self._post(TOKEN_URL, body)
assert res.status_code == expected_status, res.json()
if expected_status == 200:
@@ -189,10 +178,7 @@ class TestPrivateKeyJwtPartner(ProvisioningTestBase):
)
assert retry.status_code == 200, retry.json()
- @parameterized.expand([("during_grace", False, 401, "refused"), ("after_grace", True, 401, "refused")])
- def test_unsigned_refresh_at_the_oauth_token_endpoint(
- self, _name: str, grace_ended: bool, expected_status: int, expected_signing: str
- ) -> None:
+ def test_unsigned_refresh_at_the_oauth_token_endpoint(self) -> None:
code, verifier = self._mint_auth_code(partner=self.jwt_partner)
tokens = self._post(
TOKEN_URL,
@@ -200,7 +186,7 @@ class TestPrivateKeyJwtPartner(ProvisioningTestBase):
)
assert tokens.status_code == 200, tokens.json()
- with signing_required() if grace_ended else nullcontext(), patch("posthoganalytics.capture") as capture:
+ with patch("posthoganalytics.capture") as capture:
res = self._post_api(
OAUTH_TOKEN_URL,
{
@@ -210,9 +196,9 @@ class TestPrivateKeyJwtPartner(ProvisioningTestBase):
},
)
- assert res.status_code == expected_status, res.json()
+ assert res.status_code == 401, res.json()
signing = {call.kwargs.get("properties", {}).get("provisioning_signing") for call in capture.call_args_list}
- assert expected_signing in signing
+ assert "refused" in signing
@parameterized.expand([("non_paying", False), ("paying", True)])
@patch("posthoganalytics.capture")
diff --git a/ee/api/agentic_provisioning/test/test_provisioning_auth.py b/ee/api/agentic_provisioning/test/test_provisioning_auth.py
index e1e0b27c73e4..3741ae428578 100644
--- a/ee/api/agentic_provisioning/test/test_provisioning_auth.py
+++ b/ee/api/agentic_provisioning/test/test_provisioning_auth.py
@@ -1,14 +1,9 @@
import json
-from contextlib import nullcontext
-from datetime import UTC, datetime, timedelta
from ipaddress import ip_address
-import time_machine
from unittest.mock import MagicMock, patch
-from django.conf import settings
from django.core.cache import cache as real_cache
-from django.test import override_settings
from parameterized import parameterized
from rest_framework.parsers import JSONParser
@@ -25,9 +20,9 @@ from posthog.models.user import User
from ee.api.agentic_provisioning.authentication import ProvisioningAuthentication
from ee.api.agentic_provisioning.test.base import (
TEST_PARTNER_CLIENT_SECRET,
+ TEST_PARTNER_JWKS_URI,
ProvisioningTestBase,
provisioning_config,
- signing_required,
)
WIZARD_CLIENT_ID = "test-wizard-client"
@@ -41,8 +36,9 @@ class TestProvisioningAuthentication(ProvisioningTestBase):
self.wizard_app = OAuthApplication.objects.create(
client_id=WIZARD_CLIENT_ID,
name="PostHog Wizard",
- client_secret=TEST_PARTNER_CLIENT_SECRET,
+ client_secret="",
client_type=OAuthApplication.CLIENT_CONFIDENTIAL,
+ jwks_uri=TEST_PARTNER_JWKS_URI,
authorization_grant_type=OAuthApplication.GRANT_AUTHORIZATION_CODE,
redirect_uris="http://localhost:8239/callback",
algorithm="RS256",
@@ -52,6 +48,18 @@ class TestProvisioningAuthentication(ProvisioningTestBase):
active=True, can_create_accounts=True, can_provision_resources=True
),
)
+ # A client secret is enough only for a partner that neither creates accounts nor pays.
+ self.secret_partner = OAuthApplication.objects.create(
+ client_id="test-client-secret-partner",
+ name="Client Secret Partner",
+ client_secret=TEST_PARTNER_CLIENT_SECRET,
+ client_type=OAuthApplication.CLIENT_CONFIDENTIAL,
+ authorization_grant_type=OAuthApplication.GRANT_AUTHORIZATION_CODE,
+ redirect_uris="https://partner.example.com/callback",
+ algorithm="RS256",
+ is_provisioning_partner=True,
+ _provisioning_config=provisioning_config(active=True, can_create_accounts=False),
+ )
def _wizard_account_request(self, request_id: str, email: str, challenge: str):
return self._post_api(
@@ -61,7 +69,7 @@ class TestProvisioningAuthentication(ProvisioningTestBase):
"email": email,
"code_challenge": challenge,
"code_challenge_method": "S256",
- **self._client_credentials(self.wizard_app),
+ **self._client_auth(self.wizard_app),
},
)
@@ -72,7 +80,7 @@ class TestProvisioningAuthentication(ProvisioningTestBase):
"grant_type": "authorization_code",
"code": code,
"code_verifier": verifier,
- **self._client_credentials(partner or self.wizard_app),
+ **self._client_auth(partner or self.wizard_app),
},
)
@@ -82,22 +90,23 @@ class TestProvisioningAuthentication(ProvisioningTestBase):
def test_client_secret_partner_identified(self, transport):
payload = {"id": f"req_secret_{transport}", "email": f"{transport}[email protected]"}
if transport == "body":
- res = self._post_with_client_secret("/api/agentic/provisioning/account_requests", payload)
+ res = self._post_as_partner("/api/agentic/provisioning/account_requests", payload, self.secret_partner)
else:
res = self._post_api(
"/api/agentic/provisioning/account_requests",
- {**payload, "client_id": self.partner.client_id},
- HTTP_AUTHORIZATION=self._basic_auth_header(),
+ {**payload, "client_id": self.secret_partner.client_id},
+ HTTP_AUTHORIZATION=self._basic_auth_header(self.secret_partner),
)
- assert res.status_code == 200
- assert res.json()["type"] == "oauth"
+ # Past authentication to the capability check, which a partner that cannot create accounts fails.
+ assert res.status_code == 403, res.json()
+ assert res.json()["error"]["code"] == "forbidden"
@parameterized.expand([("proven by its secret", True), ("public client id only", False)])
def test_partner_is_recorded_by_id_only_when_it_proved_itself(self, _name, confidential):
if confidential:
- partner = self.partner
- data = self._client_credentials(partner)
+ partner = self.secret_partner
+ data = self._client_auth(partner)
else:
partner = OAuthApplication.objects.create(
client_id="activity-log-public-partner",
@@ -107,7 +116,7 @@ class TestProvisioningAuthentication(ProvisioningTestBase):
redirect_uris="https://partner.example.com/callback",
algorithm="RS256",
is_provisioning_partner=True,
- _provisioning_config=provisioning_config(),
+ _provisioning_config=provisioning_config(can_create_accounts=False),
)
data = {"client_id": partner.client_id}
request = Request(APIRequestFactory().post("/", data, format="json"), parsers=[JSONParser()])
@@ -133,7 +142,7 @@ class TestProvisioningAuthentication(ProvisioningTestBase):
{
"id": "req_bad_secret",
"email": "[email protected]",
- "client_id": self.partner.client_id,
+ "client_id": self.secret_partner.client_id,
"client_secret": secret,
},
)
@@ -148,7 +157,7 @@ class TestProvisioningAuthentication(ProvisioningTestBase):
{
"id": "req_no_secret",
"email": "[email protected]",
- "client_id": self.partner.client_id,
+ "client_id": self.secret_partner.client_id,
"code_challenge": "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM",
"code_challenge_method": "S256",
},
@@ -168,11 +177,12 @@ class TestProvisioningAuthentication(ProvisioningTestBase):
assert res.json()["error"]["code"] == "unauthorized"
def test_inactive_client_secret_partner_rejected(self):
- self.partner.update_provisioning(active=False)
+ self.secret_partner.update_provisioning(active=False)
- res = self._post_with_client_secret(
+ res = self._post_as_partner(
"/api/agentic/provisioning/account_requests",
{"id": "req_inactive_secret", "email": "[email protected]"},
+ self.secret_partner,
)
assert res.status_code == 401
assert res.json()["error"]["code"] == "unauthorized"
@@ -330,21 +340,23 @@ class TestProvisioningAuthentication(ProvisioningTestBase):
@parameterized.expand(
[
("cannot_provision_resources", {"can_provision_resources": False}, False, 403),
- ("grace_ended_without_a_private_key", {}, True, 401),
+ ("dropped_its_private_key", {}, True, 401),
# The Wizard's production shape: a client secret, and no account creation.
- ("grace_ended_for_a_partner_that_cannot_create_accounts", {"can_create_accounts": False}, True, 200),
+ ("dropped_its_private_key_but_cannot_create_accounts", {"can_create_accounts": False}, True, 200),
]
)
def test_bearer_after_partner_changes(
- self, _name: str, change: dict[str, bool], grace_ended: bool, expected_status: int
+ self, _name: str, change: dict[str, bool], drop_key: bool, expected_status: int
) -> None:
token = self._get_bearer_token()
if change:
self.partner.update_provisioning(**change)
+ if drop_key:
+ self.partner.jwks_uri = None
+ self.partner.save(update_fields=["jwks_uri"])
- with signing_required() if grace_ended else nullcontext():
- res = self._post_with_bearer("/api/agentic/provisioning/resources", {}, token=token)
+ res = self._post_with_bearer("/api/agentic/provisioning/resources", {}, token=token)
assert res.status_code == expected_status
# --- CIMD URL-based PKCE identification ---
@@ -363,7 +375,7 @@ class TestProvisioningAuthentication(ProvisioningTestBase):
is_cimd_client=True,
is_provisioning_partner=True,
_provisioning_config=provisioning_config(
- active=True, can_create_accounts=True, can_provision_resources=True
+ active=True, can_create_accounts=False, can_provision_resources=True
),
)
@@ -378,8 +390,9 @@ class TestProvisioningAuthentication(ProvisioningTestBase):
"code_challenge_method": "S256",
},
)
- assert res.status_code == 200
- assert res.json()["type"] == "oauth"
+ # Past authentication to the capability check: an unknown client_id would be a 401.
+ assert res.status_code == 403, res.json()
+ assert res.json()["error"]["code"] == "forbidden"
@patch("posthog.api.oauth.cimd.refresh_cimd_metadata_task")
def test_cimd_url_inactive_partner_rejected(self, mock_refresh):
@@ -459,24 +472,18 @@ class TestProvisioningAuthentication(ProvisioningTestBase):
"email": "[email protected]",
"code_challenge": "some_challenge",
"code_challenge_method": "plain",
- **self._client_credentials(self.wizard_app),
+ **self._client_auth(self.wizard_app),
},
)
assert res.status_code == 400
assert "S256" in res.json()["error"]["message"]
-@override_settings(
- PROVISIONING_SIGNING_REQUIRED_SINCE=datetime(2026, 10, 15, tzinfo=UTC),
- PROVISIONING_UNSIGNED_GRACE_UNTIL=datetime(2026, 10, 21, 16, tzinfo=UTC),
-)
-class TestUnsignedProvisioningGrace(ProvisioningTestBase):
- def _public_partner(
- self, *, client_id: str = "grace-public-partner", capabilities: dict[str, bool] | None = None
- ) -> OAuthApplication:
+class TestUnsignedProvisioning(ProvisioningTestBase):
+ def _public_partner(self, *, capabilities: dict[str, bool] | None = None) -> OAuthApplication:
return OAuthApplication.objects.create(
- client_id=client_id,
- name="Grace partner",
+ client_id="unsigned-public-partner",
+ name="Unsigned partner",
client_type=OAuthApplication.CLIENT_PUBLIC,
authorization_grant_type=OAuthApplication.GRANT_AUTHORIZATION_CODE,
redirect_uris="https://partner.example.com/callback",
@@ -506,28 +513,6 @@ class TestUnsignedProvisioningGrace(ProvisioningTestBase):
assert res.json()["error"] == {"code": "unauthorized", "message": PRIVATE_KEY_REQUIRED_MESSAGE}
assert not User.objects.filter(email=email).exists()
- @parameterized.expand(
- [
- ("before_the_cutoff", timedelta(seconds=-1), "unsigned_grace"),
- ("after_the_cutoff", timedelta(seconds=1), "refused"),
- ]
- )
- def test_partner_that_predates_the_requirement_calls_unsigned_until_the_cutoff(
- self, name: str, offset: timedelta, expected_signing: str
- ) -> None:
- with time_machine.travel(settings.PROVISIONING_SIGNING_REQUIRED_SINCE - timedelta(days=1), tick=False):
- partner = self._public_partner()
- email = f"grace-{name}@example.com"
-
- with time_machine.travel(settings.PROVISIONING_UNSIGNED_GRACE_UNTIL + offset, tick=False):
- res, signing = self._account_request(partner, email)
-
- assert signing == expected_signing
- if expected_signing == "refused":
- self._assert_refused(res, email)
- else:
- assert res.status_code == 200, res.json()
-
@parameterized.expand(
[
("creates_accounts", {}, 401, "refused"),
@@ -536,13 +521,12 @@ class TestUnsignedProvisioningGrace(ProvisioningTestBase):
("neither", {"can_create_accounts": False}, 403, "unsigned_exempt"),
]
)
- def test_partner_created_after_the_requirement_signs_from_its_first_request(
+ def test_partner_that_must_sign_is_refused_unsigned(
self, name: str, capabilities: dict[str, bool], expected_status: int, expected_signing: str
) -> None:
email = f"new-partner-{name}@example.com"
- with time_machine.travel(settings.PROVISIONING_SIGNING_REQUIRED_SINCE + timedelta(hours=1), tick=False):
- partner = self._public_partner(capabilities=capabilities)
- res, signing = self._account_request(partner, email)
+ partner = self._public_partner(capabilities=capabilities)
+ res, signing = self._account_request(partner, email)
assert signing == expected_signing
if expected_status == 401:
@@ -551,29 +535,6 @@ class TestUnsignedProvisioningGrace(ProvisioningTestBase):
assert res.status_code == expected_status, res.json()
assert res.json()["error"]["code"] == "forbidden"
- @parameterized.expand(
- [
- ("predates_the_requirement", timedelta(days=-1)),
- ("created_after_the_requirement", timedelta(hours=1)),
- ]
- )
- def test_override_extends_one_partners_grace(self, _name: str, created_relative_to_requirement: timedelta) -> None:
- created_at = settings.PROVISIONING_SIGNING_REQUIRED_SINCE + created_relative_to_requirement
- with time_machine.travel(created_at, tick=False):
- extended = self._public_partner()
- other = self._public_partner(client_id="grace-other-partner")
- extended.update_provisioning(
- unsigned_allowed_until=settings.PROVISIONING_UNSIGNED_GRACE_UNTIL + timedelta(days=7)
- )
-
- with time_machine.travel(settings.PROVISIONING_UNSIGNED_GRACE_UNTIL + timedelta(days=1), tick=False):
- extended_res, extended_signing = self._account_request(extended, "[email protected]")
- other_res, _ = self._account_request(other, "[email protected]")
-
- assert extended_res.status_code == 200, extended_res.json()
- assert extended_signing == "unsigned_grace"
- self._assert_refused(other_res, "[email protected]")
-
CIMD_PROV_URL = "https://partner.example.com/.well-known/oauth-client-metadata.json"
@@ -585,7 +546,8 @@ def _make_cimd_metadata(url: str = CIMD_PROV_URL, **overrides) -> dict:
"redirect_uris": ["http://127.0.0.1:3000/callback"],
"grant_types": ["authorization_code"],
"response_types": ["code"],
- "token_endpoint_auth_method": "none",
+ "token_endpoint_auth_method": "private_key_jwt",
+ "jwks_uri": TEST_PARTNER_JWKS_URI,
"com.posthog": {"provisioning": True},
}
metadata.update(overrides)
@@ -630,18 +592,17 @@ class TestCimdProvisioningRegistration(ProvisioningTestBase):
assert app.provisioning.can_provision_resources
_, challenge = self._pkce_pair()
- res = self.client.post(
+ res = self._post_as_partner(
"/api/agentic/provisioning/account_requests",
- data={
+ {
"id": "req_cimd_auto",
"email": "[email protected]",
- "client_id": CIMD_PROV_URL,
"code_challenge": challenge,
"code_challenge_method": "S256",
},
- content_type="application/json",
+ partner=app,
)
- assert res.status_code == 200
+ assert res.status_code == 200, res.json()
assert res.json()["type"] == "oauth"
@patch("posthog.api.oauth.cimd.requests.Session.get")
@@ -663,28 +624,28 @@ class TestCimdProvisioningRegistration(ProvisioningTestBase):
# A later agentic provisioning auth request must propagate the edit — the bug was that
# this raw-lookup path never refreshed, so the ceiling stayed frozen at registration.
_, challenge = self._pkce_pair()
- res = self.client.post(
+ res = self._post_as_partner(
"/api/agentic/provisioning/account_requests",
- data={
+ {
"id": "req_cimd_refresh_e2e",
"email": "[email protected]",
- "client_id": CIMD_PROV_URL,
"code_challenge": challenge,
"code_challenge_method": "S256",
},
- content_type="application/json",
+ partner=app,
)
- assert res.status_code == 200
+ assert res.status_code == 200, res.json()
app.refresh_from_db()
assert app.scopes == ["insight:read", "dashboard:read"]
@patch("posthog.api.oauth.cimd.refresh_cimd_metadata_task")
def test_partner_rate_limit_enforced_after_threshold(self, mock_refresh, _url_mock):
- OAuthApplication.objects.create(
+ partner = OAuthApplication.objects.create(
name="Rate Limit Test CIMD",
client_secret="",
- client_type=OAuthApplication.CLIENT_PUBLIC,
+ client_type=OAuthApplication.CLIENT_CONFIDENTIAL,
+ jwks_uri=TEST_PARTNER_JWKS_URI,
authorization_grant_type=OAuthApplication.GRANT_AUTHORIZATION_CODE,
redirect_uris="http://127.0.0.1:3000/callback",
algorithm="RS256",
@@ -702,21 +663,19 @@ class TestCimdProvisioningRegistration(ProvisioningTestBase):
_, challenge = self._pkce_pair()
def post_account_request(email: str):
- return self.client.post(
+ return self._post_as_partner(
"/api/agentic/provisioning/account_requests",
- data={
+ {
"id": f"req_{email}",
"email": email,
- "client_id": CIMD_PROV_URL,
"code_challenge": challenge,
"code_challenge_method": "S256",
},
- content_type="application/json",
+ partner=partner,
)
assert post_account_request("[email protected]").status_code == 200
- partner = OAuthApplication.objects.get(client_id=CIMD_PROV_URL)
partner.update_provisioning_rate_limits(account_requests=2)
assert post_account_request("[email protected]").status_code == 200
@@ -795,7 +754,8 @@ class TestCimdProvisioningRegistration(ProvisioningTestBase):
OAuthApplication.objects.create(
name=f"Existing CIMD {i}",
client_secret="",
- client_type=OAuthApplication.CLIENT_PUBLIC,
+ client_type=OAuthApplication.CLIENT_CONFIDENTIAL,
+ jwks_uri=TEST_PARTNER_JWKS_URI,
authorization_grant_type=OAuthApplication.GRANT_AUTHORIZATION_CODE,
redirect_uris="http://127.0.0.1:3000/callback",
algorithm="RS256",
@@ -808,25 +768,25 @@ class TestCimdProvisioningRegistration(ProvisioningTestBase):
)
url = f"https://{base_domain}/path-0/metadata.json"
- res = self.client.post(
+ res = self._post_as_partner(
"/api/agentic/provisioning/account_requests",
- data={
+ {
"id": "req_existing_domain",
"email": "[email protected]",
- "client_id": url,
"code_challenge": challenge,
"code_challenge_method": "S256",
},
- content_type="application/json",
+ partner=OAuthApplication.objects.get(client_id=url),
)
- assert res.status_code == 200
+ assert res.status_code == 200, res.json()
@patch("posthog.api.oauth.cimd.refresh_cimd_metadata_task")
def test_self_serve_org_named_after_client_name(self, mock_refresh, _url_mock):
- OAuthApplication.objects.create(
+ partner = OAuthApplication.objects.create(
name="Partner App",
client_secret="",
- client_type=OAuthApplication.CLIENT_PUBLIC,
+ client_type=OAuthApplication.CLIENT_CONFIDENTIAL,
+ jwks_uri=TEST_PARTNER_JWKS_URI,
authorization_grant_type=OAuthApplication.GRANT_AUTHORIZATION_CODE,
redirect_uris="http://127.0.0.1:3000/callback",
algorithm="RS256",
@@ -840,16 +800,15 @@ class TestCimdProvisioningRegistration(ProvisioningTestBase):
_, challenge = self._pkce_pair()
- self.client.post(
+ self._post_as_partner(
"/api/agentic/provisioning/account_requests",
- data={
+ {
"id": "req_cimd_org",
"email": email,
- "client_id": CIMD_PROV_URL,
"code_challenge": challenge,
"code_challenge_method": "S256",
},
- content_type="application/json",
+ partner=partner,
)
user = User.objects.get(email=email)
diff --git a/ee/api/agentic_provisioning/test/test_region_proxy.py b/ee/api/agentic_provisioning/test/test_region_proxy.py
index 92fe90b09f06..593ca9ad063c 100644
--- a/ee/api/agentic_provisioning/test/test_region_proxy.py
+++ b/ee/api/agentic_provisioning/test/test_region_proxy.py
@@ -223,7 +223,7 @@ class TestDecoratorIntegration(ProvisioningTestBase):
"configuration": {"region": "EU"},
"scopes": ["query:read"],
}
- res = self._post_with_client_secret("/api/agentic/provisioning/account_requests", data=payload)
+ res = self._post_as_partner("/api/agentic/provisioning/account_requests", data=payload)
assert res.status_code == 200
assert res.json()["type"] == "oauth"
@@ -234,7 +234,7 @@ class TestDecoratorIntegration(ProvisioningTestBase):
"configuration": {"region": "US"},
"scopes": ["query:read"],
}
- res = self._post_with_client_secret("/api/agentic/provisioning/account_requests", data=payload)
+ res = self._post_as_partner("/api/agentic/provisioning/account_requests", data=payload)
assert res.status_code == 200
assert res.json()["type"] == "oauth"
@@ -429,7 +429,7 @@ class TestCrossRegionLoopback(ProvisioningTestBase):
"scopes": ["query:read"],
}
- res = self._post_with_client_secret("/api/agentic/provisioning/account_requests", data=payload)
+ res = self._post_as_partner("/api/agentic/provisioning/account_requests", data=payload)
assert mock_request.called, "US instance should have proxied to EU"
assert captured["host"] == "eu.posthog.com"
@@ -511,7 +511,7 @@ class TestCrossRegionLoopback(ProvisioningTestBase):
"configuration": {"region": "EU"},
"scopes": ["query:read"],
}
- self._post_with_client_secret("/api/agentic/provisioning/account_requests", data=payload)
+ self._post_as_partner("/api/agentic/provisioning/account_requests", data=payload)
assert call_count["n"] == 1, (
f"proxy should fire exactly once (US→EU); got {call_count['n']} — loop header not respected"
diff --git a/ee/api/agentic_provisioning/test/test_scope_hydration.py b/ee/api/agentic_provisioning/test/test_scope_hydration.py
index a99ab4f84069..82d947e7ed49 100644
--- a/ee/api/agentic_provisioning/test/test_scope_hydration.py
+++ b/ee/api/agentic_provisioning/test/test_scope_hydration.py
@@ -48,7 +48,7 @@ class TestPartnerTokenScopeHydration(ProvisioningTestBase):
def _refresh(self, refresh_token: str):
return self._post_api(
TOKEN_URL,
- {"grant_type": "refresh_token", "refresh_token": refresh_token, **self._client_credentials()},
+ {"grant_type": "refresh_token", "refresh_token": refresh_token, **self._client_auth()},
)
def test_issuance_hydrates_with_previously_provisioned_teams(self):
diff --git a/ee/api/agentic_provisioning/views/client_registration.py b/ee/api/agentic_provisioning/views/client_registration.py
index d200d3254ae6..d49a038d044a 100644
--- a/ee/api/agentic_provisioning/views/client_registration.py
+++ b/ee/api/agentic_provisioning/views/client_registration.py
@@ -37,7 +37,7 @@ from posthog.api.oauth.client_assertion import (
describe_jwks,
verify_client_assertion,
)
-from posthog.models.oauth import OAuthApplication, ProvisioningSigning
+from posthog.models.oauth import OAuthApplication
from ee.api.agentic_provisioning.analytics import capture_provisioning_event
from ee.api.agentic_provisioning.exceptions import ProvisioningError
@@ -94,7 +94,6 @@ class ClientRegistrationView(ProvisioningAPIView):
and app.provisioning.can_create_accounts
and not app.cannot_meet_provisioning_signature,
"unsigned_requests": not app.requires_provisioning_signature,
- "unsigned_requests_allowed_until": _unsigned_requests_allowed_until(app),
},
"checks": checks,
}
@@ -152,20 +151,9 @@ class ClientRegistrationView(ProvisioningAPIView):
return app
def _check_jwks(self, app: OAuthApplication, checks: list[dict[str, Any]]) -> None:
- if not app.uses_private_key_jwt_auth:
- signing = app.provisioning_signing
- if signing is ProvisioningSigning.REQUIRED:
- _record(checks, "jwks", False, PRIVATE_KEY_REQUIRED_MESSAGE)
- return
- if signing is ProvisioningSigning.GRACE:
- _record(
- checks,
- "jwks",
- True,
- f"Unsigned requests allowed until {_unsigned_requests_allowed_until(app)}. "
- f"{PRIVATE_KEY_REQUIRED_MESSAGE}",
- )
- return
+ if app.cannot_meet_provisioning_signature:
+ _record(checks, "jwks", False, PRIVATE_KEY_REQUIRED_MESSAGE)
+ return
if not app.jwks_uri:
# Not a failure: a public client legitimately publishes no keys. Reported so the
@@ -221,13 +209,6 @@ def _not_a_partner_detail(app: OAuthApplication, *, document_read: bool) -> str:
return "This client is not enabled for agentic provisioning"
-def _unsigned_requests_allowed_until(app: OAuthApplication) -> str | None:
- allowed_until = app.provisioning_unsigned_allowed_until
- if allowed_until is None or app.provisioning_signing is not ProvisioningSigning.GRACE:
- return None
- return allowed_until.isoformat()
-
-
def _record(checks: list[dict[str, Any]], name: str, ok: bool, detail: str) -> None:
checks.append({"name": name, "ok": ok, "detail": detail})
diff --git a/posthog/admin/admins/oauth_admin.py b/posthog/admin/admins/oauth_admin.py
index 51fd35908654..98ce967cb94f 100644
--- a/posthog/admin/admins/oauth_admin.py
+++ b/posthog/admin/admins/oauth_admin.py
@@ -8,7 +8,6 @@ from django import forms
from django.contrib import admin, messages
from django.contrib.admin import helpers
from django.template.response import TemplateResponse
-from django.utils import timezone
from django.utils.html import format_html
from oauth2_provider.generators import generate_client_id, generate_client_secret
@@ -24,15 +23,14 @@ from posthog.models.oauth_provisioning import PROVISIONING_CAPABILITIES, UNLIMIT
# Derived from the pydantic schema so a capability added there shows up here automatically.
PROVISIONING_FIELD_PREFIX = "provisioning_"
PROVISIONING_RATE_LIMIT_PREFIX = "provisioning_rate_limit_"
-UNSIGNED_ALLOWED_UNTIL_FIELD = f"{PROVISIONING_FIELD_PREFIX}unsigned_allowed_until"
SIGNING_CAPABILITY_FIELDS = tuple(
f"{PROVISIONING_FIELD_PREFIX}{name}" for name in ("pays_for_customers", "can_create_accounts")
)
def _provisioning_form_fields() -> dict[str, forms.Field]:
- """One form field per capability, plus the unsigned-requests deadline. Rate-limit
- override fields are generated per request in ``get_form`` from the endpoint registry."""
+ """One form field per capability. Rate-limit override fields are generated per request
+ in ``get_form`` from the endpoint registry."""
fields: dict[str, forms.Field] = {}
for name in PROVISIONING_CAPABILITIES:
fields[f"{PROVISIONING_FIELD_PREFIX}{name}"] = forms.BooleanField(
@@ -40,11 +38,6 @@ def _provisioning_form_fields() -> dict[str, forms.Field]:
label=name.replace("_", " "),
help_text=ProvisioningConfig.model_fields[name].description or "",
)
- fields[UNSIGNED_ALLOWED_UNTIL_FIELD] = forms.DateTimeField(
- required=False,
- label="unsigned allowed until",
- help_text=ProvisioningConfig.model_fields["unsigned_allowed_until"].description or "",
- )
return fields
@@ -120,7 +113,6 @@ class OAuthApplicationForm(forms.ModelForm):
config = self.instance.provisioning if self.instance.pk else ProvisioningConfig()
for name in PROVISIONING_CAPABILITIES:
self.fields[f"{PROVISIONING_FIELD_PREFIX}{name}"].initial = getattr(config, name)
- self.fields[UNSIGNED_ALLOWED_UNTIL_FIELD].initial = config.unsigned_allowed_until
for field_name in self._rate_limit_field_names():
endpoint = field_name.removeprefix(PROVISIONING_RATE_LIMIT_PREFIX)
self.fields[field_name].initial = config.rate_limits.get(endpoint)
@@ -143,11 +135,6 @@ class OAuthApplicationForm(forms.ModelForm):
)
def _provisioning_after_save(self, cleaned: dict) -> ProvisioningConfig:
- # Built while self.instance still holds the stored row, which is the only point the promotion is visible.
- before = self.instance
- promoted = not before.is_provisioning_partner and cleaned.get(
- "is_provisioning_partner", before.is_provisioning_partner
- )
return ProvisioningConfig(
**{name: bool(cleaned.get(f"{PROVISIONING_FIELD_PREFIX}{name}")) for name in PROVISIONING_CAPABILITIES},
rate_limits={
@@ -155,8 +142,6 @@ class OAuthApplicationForm(forms.ModelForm):
for field_name in self._rate_limit_field_names()
if (value := cleaned.get(field_name)) is not None
},
- unsigned_allowed_until=cleaned.get(UNSIGNED_ALLOWED_UNTIL_FIELD),
- partner_since=timezone.now() if promoted else before.provisioning.partner_since,
)
def _reject_partner_that_cannot_sign(self, cleaned: dict, provisioning: ProvisioningConfig) -> None:
@@ -170,7 +155,6 @@ class OAuthApplicationForm(forms.ModelForm):
"""
before = self.instance
after = OAuthApplication(
- created=before.created,
is_provisioning_partner=cleaned.get("is_provisioning_partner", before.is_provisioning_partner),
client_type=cleaned.get("client_type", before.client_type),
jwks_uri=cleaned.get("jwks_uri", before.jwks_uri),
@@ -183,8 +167,7 @@ class OAuthApplicationForm(forms.ModelForm):
self.add_error(
field_name,
"A provisioning partner that can create accounts or pays for its customers must sign its "
- "requests with a private key. Make it a confidential client with a jwks_uri first, or set "
- "a date it may send unsigned requests until.",
+ "requests with a private key. Make it a confidential client with a jwks_uri first.",
)
def clean(self):
@@ -216,20 +199,6 @@ for _field_name, _form_field in _provisioning_form_fields().items():
OAuthApplicationForm.base_fields[_field_name] = _form_field
-class UnsignedProvisioningDeadlineForm(forms.Form):
- unsigned_allowed_until = forms.DateTimeField(
- label="Allow unsigned requests until",
- help_text="In UTC, for example 2026-11-02 16:00. Replaces the shared grace period for the selected partners.",
- )
-
- def clean_unsigned_allowed_until(self):
- value = self.cleaned_data["unsigned_allowed_until"]
- # A past date would end the partner's grace at once, which is not what this action is for.
- if value <= timezone.now():
- raise forms.ValidationError("Choose a date in the future.")
- return value
-
-
class ProvisioningCapabilityFilter(admin.SimpleListFilter):
"""Filter partners by a granted capability.
@@ -281,7 +250,7 @@ class OAuthApplicationAdmin(admin.ModelAdmin): # nosemgrep: admin-modeladmin-ne
search_fields = ("name", "client_id", "user__email", "organization__name")
autocomplete_fields = ("user", "organization")
ordering = ("name",)
- actions = ("revoke_all_sessions", "regenerate_client_secret", "allow_unsigned_provisioning_until")
+ actions = ("revoke_all_sessions", "regenerate_client_secret")
@admin.action(description="Generate a new client secret")
def regenerate_client_secret(self, request, queryset):
@@ -331,38 +300,6 @@ class OAuthApplicationAdmin(admin.ModelAdmin): # nosemgrep: admin-modeladmin-ne
}
return TemplateResponse(request, "admin/posthog/oauthapplication/revoke_all_sessions_confirm.html", context)
- @admin.action(description="Allow unsigned provisioning requests until a date")
- def allow_unsigned_provisioning_until(self, request, queryset):
- form = UnsignedProvisioningDeadlineForm(request.POST if request.POST.get("apply") else None)
- if form.is_valid():
- until = form.cleaned_data["unsigned_allowed_until"]
- updated = 0
- for application in queryset:
- if not application.is_provisioning_partner:
- self.message_user(
- request,
- f"{application.name}: skipped, it is not a provisioning partner.",
- level=messages.ERROR,
- )
- continue
- application.update_provisioning(unsigned_allowed_until=until)
- updated += 1
- self.message_user(
- request, f"{updated} partner(s) may send unsigned provisioning requests until {until.isoformat()}."
- )
- return None
- context = {
- **self.admin_site.each_context(request),
- "title": "Allow unsigned provisioning requests until a date",
- "form": form,
- "queryset": queryset,
- "opts": self.model._meta,
- "action_checkbox_name": helpers.ACTION_CHECKBOX_NAME,
- }
- return TemplateResponse(
- request, "admin/posthog/oauthapplication/allow_unsigned_provisioning_until.html", context
- )
-
def view_on_site(self, obj: OAuthApplication):
code_verifier = "test"
digest = hashlib.sha256(code_verifier.encode("utf-8")).digest()
diff --git a/posthog/admin/test_oauth_admin.py b/posthog/admin/test_oauth_admin.py
index 52eb9cf19f5b..2a6f1a18d7ff 100644
--- a/posthog/admin/test_oauth_admin.py
+++ b/posthog/admin/test_oauth_admin.py
@@ -1,4 +1,4 @@
-from datetime import UTC, datetime, timedelta
+from datetime import timedelta
import time_machine
from posthog.test.base import BaseTest
@@ -6,19 +6,15 @@ from unittest.mock import patch
from django.contrib.admin import AdminSite
from django.contrib.auth.hashers import check_password
-from django.test import RequestFactory, override_settings
+from django.test import RequestFactory
from django.utils import timezone
from parameterized import parameterized
from posthog.admin.admins.oauth_admin import OAuthApplicationAdmin
-from posthog.models.oauth import OAuthAccessToken, OAuthApplication, OAuthRefreshToken, ProvisioningSigning
+from posthog.models.oauth import OAuthAccessToken, OAuthApplication, OAuthRefreshToken
-LONG_AGO = datetime(2000, 1, 1, tzinfo=UTC)
-
-# Every app a test creates is past its grace period, whatever the real date, unless the test says otherwise.
-@override_settings(PROVISIONING_SIGNING_REQUIRED_SINCE=LONG_AGO, PROVISIONING_UNSIGNED_GRACE_UNTIL=LONG_AGO)
class TestOAuthApplicationAdmin(BaseTest):
def setUp(self):
super().setUp()
@@ -148,15 +144,6 @@ class TestOAuthApplicationAdmin(BaseTest):
"pays_for_customers",
False,
),
- (
- "public_partner_with_a_later_unsigned_deadline",
- OAuthApplication.CLIENT_PUBLIC,
- None,
- True,
- {"unsigned_allowed_until": "2100-01-01T00:00:00+00:00"},
- "pays_for_customers",
- False,
- ),
]
)
def test_partner_that_must_sign_needs_a_private_key(
@@ -186,102 +173,12 @@ class TestOAuthApplicationAdmin(BaseTest):
fields["is_provisioning_partner"] = "on"
if jwks_uri:
fields["jwks_uri"] = jwks_uri
- if deadline := stored_config.get("unsigned_allowed_until"):
- fields["provisioning_unsigned_allowed_until"] = deadline
form = self._provisioning_form(app, **fields)
assert form.is_valid() is not expects_error, form.errors
assert (f"provisioning_{ticked_capability}" in form.errors) is expects_error
- def test_saving_the_form_keeps_the_signing_dates(self):
- app = self._rate_limit_app()
- partner_since = datetime(2026, 10, 16, tzinfo=UTC)
- app.update_provisioning(unsigned_allowed_until=datetime(2100, 1, 1, tzinfo=UTC), partner_since=partner_since)
-
- form = self._provisioning_form(app, provisioning_unsigned_allowed_until="2100-01-01 00:00:00")
- assert form.is_valid(), form.errors
- form.save()
-
- app.refresh_from_db()
- assert app.provisioning.unsigned_allowed_until == datetime(2100, 1, 1, tzinfo=UTC)
- assert app.provisioning.partner_since == partner_since
-
- def _signing_partner(self, client_id: str, **overrides) -> OAuthApplication:
- return OAuthApplication.objects.create(
- name=f"Signing Partner {client_id}",
- client_id=client_id,
- client_type=OAuthApplication.CLIENT_PUBLIC,
- authorization_grant_type=OAuthApplication.GRANT_AUTHORIZATION_CODE,
- redirect_uris="https://example.com/callback",
- algorithm="RS256",
- **{"is_provisioning_partner": True, "_provisioning_config": {"can_create_accounts": True}, **overrides},
- )
-
- @parameterized.expand([("already_a_partner", True, False), ("promoted_by_this_edit", False, True)])
- def test_old_app_promoted_to_partner_must_sign_from_the_promotion(
- self, _name: str, already_a_partner: bool, expects_error: bool
- ) -> None:
- app = self._signing_partner("promoted_old_app", is_provisioning_partner=already_a_partner)
- OAuthApplication.objects.filter(pk=app.pk).update(created=datetime(2001, 1, 1, tzinfo=UTC))
- app.refresh_from_db()
-
- with override_settings(
- PROVISIONING_SIGNING_REQUIRED_SINCE=datetime(2002, 1, 1, tzinfo=UTC),
- PROVISIONING_UNSIGNED_GRACE_UNTIL=datetime(2100, 1, 1, tzinfo=UTC),
- ):
- form = self._provisioning_form(
- app, is_provisioning_partner="on", provisioning_active="on", provisioning_can_create_accounts="on"
- )
- assert form.is_valid() is not expects_error, form.errors
-
- assert ("provisioning_can_create_accounts" in form.errors) is expects_error
-
- def test_allow_unsigned_action_extends_the_selected_partners_grace(self):
- selected = self._signing_partner("allow_unsigned_selected")
- not_selected = self._signing_partner("allow_unsigned_not_selected")
- not_a_partner = self._signing_partner("allow_unsigned_not_a_partner", is_provisioning_partner=False)
- until = datetime(2100, 1, 8, 12, 0, tzinfo=UTC)
-
- request = RequestFactory().post(
- "/", {"apply": "yes", "unsigned_allowed_until": until.strftime("%Y-%m-%d %H:%M:%S")}
- )
- with patch.object(self.admin, "message_user"):
- response = self.admin.allow_unsigned_provisioning_until(
- request=request, queryset=OAuthApplication.objects.filter(id__in=[selected.id, not_a_partner.id])
- )
-
- assert response is None
- for app in (selected, not_selected, not_a_partner):
- app.refresh_from_db()
- assert selected.provisioning.unsigned_allowed_until == until.replace(microsecond=0)
- assert selected.provisioning_signing is ProvisioningSigning.GRACE
- assert not_selected.provisioning_signing is ProvisioningSigning.REQUIRED
- assert not_a_partner.provisioning.unsigned_allowed_until is None
-
- @parameterized.expand(
- [
- ("no_date_yet", None),
- # A past date would end the partner's grace at once.
- ("date_in_the_past", "2001-01-01 00:00:00"),
- ]
- )
- def test_allow_unsigned_action_asks_for_a_future_date(self, _name: str, until: str | None) -> None:
- partner = self._signing_partner("allow_unsigned_needs_a_date")
-
- self.user.is_staff = True
- request = RequestFactory().post("/", {"apply": "yes", "unsigned_allowed_until": until} if until else {})
- request.user = self.user
- response = self.admin.allow_unsigned_provisioning_until(
- request=request, queryset=OAuthApplication.objects.filter(id=partner.id)
- )
-
- assert response.status_code == 200
- assert "allow_unsigned_provisioning_until.html" in response.template_name
- assert response.context_data["form"].is_bound is bool(until)
- partner.refresh_from_db()
- assert partner.provisioning.unsigned_allowed_until is None
-
@parameterized.expand(
[
("client_secret", OAuthApplication.CLIENT_CONFIDENTIAL, None, True),
diff --git a/posthog/api/oauth/cimd.py b/posthog/api/oauth/cimd.py
index 59d99e91e37b..26957775bcc4 100644
--- a/posthog/api/oauth/cimd.py
+++ b/posthog/api/oauth/cimd.py
@@ -995,12 +995,7 @@ def _cimd_provisioning_defaults_for(app: OAuthApplication) -> "ProvisioningConfi
the same thing.
"""
return app.provisioning.model_copy(
- update={
- "active": True,
- "can_create_accounts": True,
- "can_provision_resources": True,
- "partner_since": timezone.now(),
- }
+ update={"active": True, "can_create_accounts": True, "can_provision_resources": True}
)
diff --git a/posthog/models/oauth.py b/posthog/models/oauth.py
index 5bd094f3bd10..9728e5ccc6ba 100644
--- a/posthog/models/oauth.py
+++ b/posthog/models/oauth.py
@@ -1,6 +1,6 @@
import enum
import uuid
-from datetime import datetime, timedelta
+from datetime import timedelta
from typing import TYPE_CHECKING, cast
from urllib.parse import urlparse
@@ -73,7 +73,6 @@ class TokenEndpointAuthMethod(enum.Enum):
class ProvisioningSigning(enum.Enum):
NOT_REQUIRED = "not_required"
- GRACE = "grace"
REQUIRED = "required"
def request_tag(self, *, signed: bool) -> str:
@@ -81,7 +80,6 @@ class ProvisioningSigning(enum.Enum):
return "signed"
return {
ProvisioningSigning.NOT_REQUIRED: "unsigned_exempt",
- ProvisioningSigning.GRACE: "unsigned_grace",
ProvisioningSigning.REQUIRED: "refused",
}[self]
@@ -357,17 +355,6 @@ class OAuthApplication(ModelActivityMixin, AbstractApplication): # type: ignore
def uses_private_key_jwt_auth(self) -> bool:
return self.token_endpoint_auth_method is TokenEndpointAuthMethod.PRIVATE_KEY_JWT
- @property
- def provisioning_unsigned_allowed_until(self) -> datetime | None:
- provisioning = self.provisioning
- if provisioning.unsigned_allowed_until is not None:
- return provisioning.unsigned_allowed_until
- # Rows promoted before partner_since was recorded fall back to their creation date.
- became_partner = provisioning.partner_since or self.created or timezone.now()
- if became_partner < settings.PROVISIONING_SIGNING_REQUIRED_SINCE:
- return settings.PROVISIONING_UNSIGNED_GRACE_UNTIL
- return None
-
@property
def provisioning_signing(self) -> ProvisioningSigning:
provisioning = self.provisioning
@@ -375,12 +362,6 @@ class OAuthApplication(ModelActivityMixin, AbstractApplication): # type: ignore
provisioning.can_create_accounts or provisioning.pays_for_customers
):
return ProvisioningSigning.NOT_REQUIRED
- # Grace covers partners that have not switched yet. Once a partner publishes a key it signs from then on.
- if self.uses_private_key_jwt_auth:
- return ProvisioningSigning.REQUIRED
- allowed_until = self.provisioning_unsigned_allowed_until
- if allowed_until is not None and timezone.now() < allowed_until:
- return ProvisioningSigning.GRACE
return ProvisioningSigning.REQUIRED
@property
diff --git a/posthog/models/oauth_provisioning.py b/posthog/models/oauth_provisioning.py
index df7d59accd75..037c04add255 100644
--- a/posthog/models/oauth_provisioning.py
+++ b/posthog/models/oauth_provisioning.py
@@ -17,7 +17,6 @@ to an operator as a capability that was granted.
from __future__ import annotations
-from datetime import UTC, datetime
from enum import StrEnum
from pydantic import BaseModel, ConfigDict, Field, field_validator
@@ -89,18 +88,6 @@ class ProvisioningConfig(BaseModel):
),
)
- # Staff-only, so support can move one partner's deadline without a deploy.
- unsigned_allowed_until: datetime | None = Field(
- default=None,
- description=(
- "Until when this partner may send provisioning requests without a private_key_jwt signature. "
- "Replaces the shared grace period for this partner. Blank uses the shared grace period."
- ),
- )
-
- # Stamped at promotion, because the app row can predate the partnership by any amount.
- partner_since: datetime | None = None
-
# Per-endpoint hourly overrides, keyed by rate-limit endpoint name. An absent key
# means the tier-derived budget applies; UNLIMITED_OVERRIDE disables the limit.
# Every value stored here is admin-authored: the self-serve tiers are derived at
@@ -126,14 +113,6 @@ class ProvisioningConfig(BaseModel):
limits[str(key)] = UNLIMITED_OVERRIDE if parsed <= 0 else parsed
return limits
- @field_validator("unsigned_allowed_until", "partner_since")
- @classmethod
- def _read_naive_datetime_as_utc(cls, value: datetime | None) -> datetime | None:
- # Compared with the aware current time on every request, where a naive value would raise.
- if value is None or value.tzinfo is not None:
- return value
- return value.replace(tzinfo=UTC)
-
PROVISIONING_CAPABILITIES: tuple[str, ...] = tuple(
name for name, info in ProvisioningConfig.model_fields.items() if info.annotation is bool
diff --git a/posthog/settings/utils.py b/posthog/settings/utils.py
index 9da0576fd13c..fa112d01e042 100644
--- a/posthog/settings/utils.py
+++ b/posthog/settings/utils.py
@@ -1,6 +1,5 @@
import os
from collections.abc import Callable
-from datetime import UTC, datetime
from typing import Any, Optional
from django.core.exceptions import ImproperlyConfigured
@@ -13,7 +12,6 @@ __all__ = [
"get_from_env",
"get_list",
"str_to_bool",
- "str_to_utc_datetime",
]
@@ -70,12 +68,6 @@ def get_from_env(
return value
-def str_to_utc_datetime(value: str) -> datetime:
- # Read without an offset as UTC, so the value compares with the aware datetimes Django produces.
- parsed = datetime.fromisoformat(value)
- return parsed if parsed.tzinfo else parsed.replace(tzinfo=UTC)
-
-
def get_list(text: str) -> list[str]:
if not text:
return []
diff --git a/posthog/settings/web.py b/posthog/settings/web.py
index e31ed356106b..f54f7d114791 100644
--- a/posthog/settings/web.py
+++ b/posthog/settings/web.py
@@ -1,7 +1,7 @@
# Web app specific settings/middleware/apps setup
import os
import json
-from datetime import UTC, datetime, timedelta
+from datetime import timedelta
from django.core.exceptions import ImproperlyConfigured
@@ -13,13 +13,7 @@ from posthog.openapi.enum_names import ChoicesEnumNameOverrides
from posthog.run_mode import derive_run_mode
from posthog.scopes import get_scope_descriptions
from posthog.settings.base_variables import BASE_DIR, CLOUD_DEPLOYMENT, DEBUG, TEST
-from posthog.settings.utils import (
- generate_rsa_private_key_pem,
- get_from_env,
- get_list,
- str_to_bool,
- str_to_utc_datetime,
-)
+from posthog.settings.utils import generate_rsa_private_key_pem, get_from_env, get_list, str_to_bool
from posthog.utils_cors import CORS_ALLOWED_TRACING_HEADERS
logger = structlog.get_logger(__name__)
@@ -1308,14 +1302,6 @@ OAUTH2_PROVIDER_REFRESH_TOKEN_MODEL = "posthog.OAuthRefreshToken"
OAUTH2_PROVIDER_ID_TOKEN_MODEL = "posthog.OAuthIDToken"
OAUTH2_PROVIDER_GRANT_MODEL = "posthog.OAuthGrant"
-# A provisioning partner whose app predates the signing requirement may call unsigned until the grace period ends.
-PROVISIONING_SIGNING_REQUIRED_SINCE: datetime = get_from_env(
- "PROVISIONING_SIGNING_REQUIRED_SINCE", datetime(2026, 10, 16, tzinfo=UTC), type_cast=str_to_utc_datetime
-)
-PROVISIONING_UNSIGNED_GRACE_UNTIL: datetime = get_from_env(
- "PROVISIONING_UNSIGNED_GRACE_UNTIL", datetime(2026, 10, 23, 16, tzinfo=UTC), type_cast=str_to_utc_datetime
-)
-
ID_JAG_ACCESS_TOKEN_TTL_SECONDS: int = get_from_env("ID_JAG_ACCESS_TOKEN_TTL_SECONDS", 60 * 60 * 2, type_cast=int)
ID_JAG_CLOCK_SKEW_SECONDS: int = get_from_env("ID_JAG_CLOCK_SKEW_SECONDS", 30, type_cast=int)
# IdPs issue ID-JAGs for immediate use (5 minutes is typical); the cap leaves headroom above that.
diff --git a/posthog/templates/admin/posthog/oauthapplication/allow_unsigned_provisioning_until.html b/posthog/templates/admin/posthog/oauthapplication/allow_unsigned_provisioning_until.html
deleted file mode 100644
index 9d258f6ae8d5..000000000000
--- a/posthog/templates/admin/posthog/oauthapplication/allow_unsigned_provisioning_until.html
+++ /dev/null
@@ -1,40 +0,0 @@
-{% extends "admin/base_site.html" %}
-{% load i18n l10n admin_urls %}
-{% block breadcrumbs %}
- <div class="breadcrumbs">
- <a href="{% url 'admin:index' %}">{% translate 'Home' %}</a>
- &rsaquo; <a href="{% url 'admin:app_list' app_label=opts.app_label %}">{{ opts.app_config.verbose_name }}</a>
- &rsaquo; <a href="{% url opts|admin_urlname:'changelist' %}">{{ opts.verbose_name_plural|capfirst }}</a>
- &rsaquo; {% translate 'Allow unsigned provisioning requests' %}
- </div>
-{% endblock %}
-{% block content %}
- <p>Until the date you choose, the selected partners may send provisioning requests without a private_key_jwt signature. After it, they have to sign every request. The date replaces the shared grace period for these partners only.</p>
- <ul>
- {% for obj in queryset %}<li>{{ obj }}</li>{% endfor %}
- </ul>
- <form method="post">
- {% csrf_token %}
- {% for obj in queryset %}
- <input type="hidden"
- name="{{ action_checkbox_name }}"
- value="{{ obj.pk|unlocalize }}">
- {% endfor %}
- <fieldset class="module aligned">
- {% for field in form %}
- <div class="form-row field-{{ field.name }}">
- {{ field.errors }}
- {{ field.label_tag }} {{ field }}
- {% if field.help_text %}
- <div class="help">{{ field.help_text }}</div>
- {% endif %}
- </div>
- {% endfor %}
- </fieldset>
- <input type="hidden" name="action" value="allow_unsigned_provisioning_until">
- <input type="hidden" name="apply" value="yes">
- <input type="submit" value="Allow unsigned requests" class="default">
- <a href="{% url opts|admin_urlname:'changelist' %}"
- class="button cancel-link">Cancel</a>
- </form>
-{% endblock %}