: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.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
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.pyindex 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 uuidimport base64import hashlibimport secretsimport dataclasses-from datetime import UTC, datetimefrom typing import TYPE_CHECKINGfrom urllib.parse import quote_plus@@ -11,11 +12,17 @@ from posthog.test.base import APIBaseTestfrom unittest.mock import patchfrom django.core.cache import cache-from django.test import override_settingsfrom django.utils import timezone+import jwt+from cryptography.hazmat.primitives.asymmetric import rsafrom 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 AvailableFeaturefrom posthog.models.organization import OrganizationMembershipfrom 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.pyindex 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_authenticationfrom ee.api.agentic_provisioning.analytics import capture_provisioning_eventfrom ee.api.agentic_provisioning.authentication import ProvisioningAuthenticationfrom 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_configACCOUNT_REQUESTS_URL = "/api/agentic/provisioning/account_requests"VALID_CODE_CHALLENGE = "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM"@@ -39,7 +39,7 @@ class TestAccountRequests(ProvisioningTestBase):return payloaddef _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.pyindex 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 Userfrom ee.api.agentic_provisioning.constants import AUTH_CODE_CACHE_PREFIX, PENDING_AUTH_CACHE_PREFIXfrom 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 == 200diff --git a/ee/api/agentic_provisioning/test/test_client_registration.py b/ee/api/agentic_provisioning/test/test_client_registration.pyindex 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 jsonimport time-from datetime import timedeltafrom ipaddress import ip_addressfrom unittest.mock import patchfrom django.core.cache import cachefrom django.test import override_settings-from django.utils import timezoneimport jwtfrom 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_configREGISTRATION_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 Trueassert body["client_id"] == CIMD_URLassert 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 Trueassert 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 thediff --git a/ee/api/agentic_provisioning/test/test_e2e_flow.py b/ee/api/agentic_provisioning/test/test_e2e_flow.pyindex 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 ActivityLogfrom posthog.models.oauth import OAuthApplicationfrom 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_configTOKEN_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 == 200assert 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 tokenres = 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 == 200new_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 == 200data = 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 == 200token_data = res.json()diff --git a/ee/api/agentic_provisioning/test/test_limits.py b/ee/api/agentic_provisioning/test/test_limits.pyindex 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 parameterizedfrom posthog.models.oauth import OAuthApplicationfrom 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_configLIMITS_URL = "/api/agentic/provisioning/limits"@@ -40,7 +33,7 @@ class TestLimitsEndpoint(ProvisioningTestBase):assert res.status_code == 200body = 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"] == 50assert 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 == 200body = 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 == 401diff --git a/ee/api/agentic_provisioning/test/test_oauth_token.py b/ee/api/agentic_provisioning/test/test_oauth_token.pyindex 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 AccessControlfrom ee.api.agentic_provisioning.constants import AUTH_CODE_CACHE_PREFIXfrom 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 == 200def 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 == 401assert 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 == 200def 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.contentassert 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 == 401assert 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.pyindex 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 ProvisioningErrorfrom ee.api.agentic_provisioning.ratelimits import FLAT_MULTIPLIERS, charge_partner, registered_budgetsfrom 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.pyindex 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 jsonimport time-from contextlib import nullcontextfrom 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, OAuthApplicationfrom 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_configACCOUNT_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.pyindex 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, timedeltafrom ipaddress import ip_address-import time_machinefrom unittest.mock import MagicMock, patch-from django.conf import settingsfrom django.core.cache import cache as real_cache-from django.test import override_settingsfrom parameterized import parameterizedfrom rest_framework.parsers import JSONParser@@ -25,9 +20,9 @@ from posthog.models.user import Userfrom ee.api.agentic_provisioning.authentication import ProvisioningAuthenticationfrom 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 == 401assert 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 == 400assert "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_signingif 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):email = "[email protected]"_, 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.pyindex 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 == 200assert 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 == 200assert 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.pyindex 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.pyindex 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 OAuthApplicationfrom ee.api.agentic_provisioning.analytics import capture_provisioning_eventfrom ee.api.agentic_provisioning.exceptions import ProvisioningError@@ -94,7 +94,6 @@ class ClientRegistrationView(ProvisioningAPIView):and app.provisioning.can_create_accountsand 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 appdef _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)+ returnif 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.pyindex 51fd35908654..98ce967cb94f 100644--- a/posthog/admin/admins/oauth_admin.py+++ b/posthog/admin/admins/oauth_admin.py@@ -8,7 +8,6 @@ from django import formsfrom django.contrib import admin, messagesfrom django.contrib.admin import helpersfrom django.template.response import TemplateResponse-from django.utils import timezonefrom django.utils.html import format_htmlfrom 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_untilfor 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.instanceafter = 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-nesearch_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.pyindex 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 timedeltaimport time_machinefrom posthog.test.base import BaseTest@@ -6,19 +6,15 @@ from unittest.mock import patchfrom django.contrib.admin import AdminSitefrom django.contrib.auth.hashers import check_password-from django.test import RequestFactory, override_settings+from django.test import RequestFactoryfrom django.utils import timezonefrom parameterized import parameterizedfrom 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"] = deadlineform = self._provisioning_form(app, **fields)assert form.is_valid() is not expects_error, form.errorsassert (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.pyindex 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) -> "ProvisioningConfithe 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.pyindex 5bd094f3bd10..9728e5ccc6ba 100644--- a/posthog/models/oauth.py+++ b/posthog/models/oauth.py@@ -1,6 +1,6 @@import enumimport uuid-from datetime import datetime, timedelta+from datetime import timedeltafrom typing import TYPE_CHECKING, castfrom 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: ignoredef 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-@propertydef provisioning_signing(self) -> ProvisioningSigning:provisioning = self.provisioning@@ -375,12 +362,6 @@ class OAuthApplication(ModelActivityMixin, AbstractApplication): # type: ignoreprovisioning.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.GRACEreturn ProvisioningSigning.REQUIRED@propertydiff --git a/posthog/models/oauth_provisioning.py b/posthog/models/oauth_provisioning.pyindex 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, datetimefrom enum import StrEnumfrom 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 parsedreturn 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 booldiff --git a/posthog/settings/utils.py b/posthog/settings/utils.pyindex 9da0576fd13c..fa112d01e042 100644--- a/posthog/settings/utils.py+++ b/posthog/settings/utils.py@@ -1,6 +1,5 @@import osfrom collections.abc import Callable-from datetime import UTC, datetimefrom typing import Any, Optionalfrom 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.pyindex e31ed356106b..f54f7d114791 100644--- a/posthog/settings/web.py+++ b/posthog/settings/web.py@@ -1,7 +1,7 @@# Web app specific settings/middleware/apps setupimport osimport json-from datetime import UTC, datetime, timedelta+from datetime import timedeltafrom django.core.exceptions import ImproperlyConfigured@@ -13,13 +13,7 @@ from posthog.openapi.enum_names import ChoicesEnumNameOverridesfrom posthog.run_mode import derive_run_modefrom posthog.scopes import get_scope_descriptionsfrom 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_boolfrom posthog.utils_cors import CORS_ALLOWED_TRACING_HEADERSlogger = 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.htmldeleted file mode 100644index 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>- › <a href="{% url 'admin:app_list' app_label=opts.app_label %}">{{ opts.app_config.verbose_name }}</a>- › <a href="{% url opts|admin_urlname:'changelist' %}">{{ opts.verbose_name_plural|capfirst }}</a>- › {% 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 %}