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.

19.9 KB
Raw Blame
import uuid
from datetime import timedelta
from urllib.parse import urlencode

from unittest.mock import patch

from django.core.cache import cache
from django.utils import timezone

from parameterized import parameterized

from posthog.api.id_jag import JWT_BEARER_GRANT_TYPE
from posthog.api.oauth.client_assertion import PRIVATE_KEY_REQUIRED_MESSAGE
from posthog.constants import AvailableFeature
from posthog.models.oauth import OAuthAccessToken, OAuthApplication, OAuthRefreshToken
from posthog.models.organization import OrganizationMembership
from posthog.models.team.team import Team

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,
)

TOKEN_URL = "/api/agentic/oauth/token"
OAUTH_TOKEN_URL = "/oauth/token/"


class TestOAuthTokenExchange(ProvisioningTestBase):
    def _set_app_ceiling(self, scopes: list[str]) -> None:
        OAuthApplication.objects.filter(id=self.partner.id).update(scopes=scopes)

    def _mint_code_with_overrides(self, scopes: list[str] | None = None, **overrides) -> tuple[str, str]:
        code, verifier = self._mint_auth_code(scopes=scopes)
        key = f"{AUTH_CODE_CACHE_PREFIX}{code}"
        data = cache.get(key)
        for field, value in overrides.items():
            if value is None:
                data.pop(field, None)
            else:
                data[field] = value
        cache.set(key, data, timeout=300)
        return code, verifier

    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_auth(partner),
            },
        )

    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_auth(partner)},
        )

    def _stamp_session_revoke(self, when=None) -> None:
        OAuthApplication.objects.filter(id=self.partner.id).update(sessions_revoked_at=when or timezone.now())

    def _public_partner(self, **provisioning: bool) -> OAuthApplication:
        return OAuthApplication.objects.create(
            client_id="pkce-token-partner",
            name="PKCE Token Partner",
            client_secret="",
            client_type=OAuthApplication.CLIENT_PUBLIC,
            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 _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
        data = res.json()
        assert data["token_type"] == "bearer"
        assert data["access_token"].startswith("pha_")
        assert data["refresh_token"].startswith("phr_")
        assert data["expires_in"] > 0
        assert "scope" not in data
        assert data["account"]["id"] == str(self.organization.id)
        assert len(data["account"]["available_teams"]) >= 1
        team_entry = data["account"]["available_teams"][0]
        assert "id" in team_entry
        assert "name" in team_entry
        assert "organization_id" in team_entry

    def test_available_teams_exclude_acl_restricted_teams(self):
        self.organization.available_product_features = [
            {"key": AvailableFeature.ACCESS_CONTROL, "name": AvailableFeature.ACCESS_CONTROL},
        ]
        self.organization.save()
        self.organization_membership.level = OrganizationMembership.Level.MEMBER
        self.organization_membership.save()

        restricted_team = Team.objects.create_with_data(
            initiating_user=self.user, organization=self.organization, name="Restricted team"
        )
        AccessControl.objects.create(
            team=restricted_team,
            access_level="none",
            resource="project",
            resource_id=str(restricted_team.id),
        )

        data = self._request_bearer_token().json()
        listed = data["account"]["available_teams"]

        assert self.team.id in [team["id"] for team in listed]
        assert restricted_team.id not in [team["id"] for team in listed]
        assert restricted_team.name not in [team["name"] for team in listed]

    def test_code_is_single_use(self):
        code, verifier = self._mint_auth_code()
        assert self._exchange_code(code, verifier).status_code == 200
        res = self._exchange_code(code, verifier)
        assert res.status_code == 400
        assert res.json()["error"] == "invalid_grant"

    @parameterized.expand(
        [
            (
                "invalid_code",
                {"grant_type": "authorization_code", "code": "nonexistent", "code_verifier": "x"},
                "invalid_grant",
            ),
            ("missing_code", {"grant_type": "authorization_code"}, "invalid_request"),
            ("unsupported_grant_type", {"grant_type": "client_credentials"}, "unsupported_grant_type"),
            ("invalid_refresh_token", {"grant_type": "refresh_token", "refresh_token": "phr_invalid"}, "invalid_grant"),
        ]
    )
    def test_rejected_grants(self, _name, params, error):
        res = self._post_api(TOKEN_URL, params)
        assert res.status_code == 400
        assert res.json()["error"] == error

    def test_code_without_challenge_requires_authentication(self):
        code, verifier = self._mint_code_with_overrides(code_challenge=None, code_challenge_method=None)
        res = self._exchange_code(code, verifier)
        assert res.status_code == 401
        assert res.json() == {"error": "invalid_request", "error_description": "Authentication required"}

    def test_missing_code_verifier_returns_401(self):
        code, _verifier = self._mint_auth_code()
        res = self._post_api(TOKEN_URL, {"grant_type": "authorization_code", "code": code})
        assert res.status_code == 401
        assert res.json()["error_description"] == "code_verifier is required for PKCE"

    @parameterized.expand(
        [
            ("missing_credentials", None),
            ("wrong_secret", "not-the-real-secret"),
        ]
    )
    def test_confidential_partner_without_valid_secret_cannot_exchange_code(self, _name, secret):
        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_auth(partner, secret=secret))

        res = self._post_api(TOKEN_URL, body)

        assert res.status_code == 401
        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, partner).status_code == 200

    def test_confidential_partner_without_valid_secret_cannot_refresh(self):
        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_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, 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(can_create_accounts=False))

        res = self._post_api(TOKEN_URL, {"grant_type": "authorization_code", "code": code, "code_verifier": verifier})

        assert res.status_code == 200
        assert res.json()["access_token"].startswith("pha_")

    @parameterized.expand(
        [
            ("public_code_exchange", True, {}, "authorization_code", TOKEN_URL, 401),
            ("public_refresh", True, {}, "refresh_token", TOKEN_URL, 401),
            ("client_secret_refresh", False, {}, "refresh_token", TOKEN_URL, 401),
            (
                "paying_public_refresh",
                True,
                {"can_create_accounts": False, "pays_for_customers": True},
                "refresh_token",
                TOKEN_URL,
                401,
            ),
            ("public_refresh_at_oauth_token", True, {}, "refresh_token", OAUTH_TOKEN_URL, 401),
            ("client_secret_refresh_at_oauth_token", False, {}, "refresh_token", OAUTH_TOKEN_URL, 401),
            ("exempt_public_refresh", True, {"can_create_accounts": False}, "refresh_token", TOKEN_URL, 200),
            (
                "exempt_public_refresh_at_oauth_token",
                True,
                {"can_create_accounts": False},
                "refresh_token",
                OAUTH_TOKEN_URL,
                200,
            ),
            # The Wizard's production shape: a client secret, and no account creation.
            ("exempt_client_secret_refresh", False, {"can_create_accounts": False}, "refresh_token", TOKEN_URL, 200),
            (
                "exempt_client_secret_refresh_at_oauth_token",
                False,
                {"can_create_accounts": False},
                "refresh_token",
                OAUTH_TOKEN_URL,
                200,
            ),
        ]
    )
    def test_unsigned_token_request(
        self,
        _name: str,
        public: bool,
        capabilities: dict[str, bool],
        grant_type: str,
        url: str,
        expected_status: int,
    ) -> None:
        # 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 patch("posthoganalytics.capture") as capture:
            res = self._post_api(url, body)

        assert res.status_code == expected_status, res.json()
        tags = {call.kwargs.get("properties", {}).get("provisioning_signing") for call in capture.call_args_list}
        assert ("refused" if expected_status == 401 else "unsigned_exempt") in tags
        if expected_status == 401:
            assert res.json()["error"] == "invalid_client"
            assert res.json()["error_description"] == PRIVATE_KEY_REQUIRED_MESSAGE

    @parameterized.expand([("public", True), ("client_secret", False)])
    def test_refused_partner_can_still_revoke_its_tokens(self, _name: str, public: bool) -> None:
        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)

        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):
        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"

    def test_pkce_mismatch_returns_400_without_consuming_code(self):
        code, verifier = self._mint_auth_code()
        res = self._exchange_code(code, "wrong_verifier_" + "a" * 32)
        assert res.status_code == 400
        assert res.json()["error"] == "invalid_grant"
        # Verification runs before the code is consumed, so a failed attempt must not burn it.
        assert self._exchange_code(code, verifier).status_code == 200

    @parameterized.expand([("unknown_partner", str(uuid.uuid4())), ("missing_partner", "")])
    def test_code_without_resolvable_partner_returns_invalid_grant(self, _name, partner_id):
        code, verifier = self._mint_code_with_overrides(partner_id=partner_id)
        res = self._exchange_code(code, verifier)
        assert res.status_code == 400
        assert res.json() == {
            "error": "invalid_grant",
            "error_description": "Unknown application for this authorization code",
        }

    def test_code_with_empty_scopes_rejected(self):
        code, verifier = self._mint_auth_code(scopes=[])
        res = self._exchange_code(code, verifier)
        assert res.status_code == 400
        assert res.json()["error"] == "invalid_scope"

    def test_omitted_request_scopes_resolve_to_app_ceiling(self):
        verifier, challenge = self._pkce_pair()
        res = self._post_as_partner(
            "/api/agentic/provisioning/account_requests",
            data={
                "id": "req_scopeless",
                "email": "[email protected]",
                "code_challenge": challenge,
                "code_challenge_method": "S256",
            },
        )
        assert res.status_code == 200
        code = res.json()["oauth"]["code"]

        exchange = self._exchange_code(code, verifier)
        assert exchange.status_code == 200
        token = OAuthAccessToken.objects.get(token=exchange.json()["access_token"])
        assert set(token.scope.split()) == set(TEST_PARTNER_SCOPES)

    def test_refresh_token_rotation_is_single_use(self):
        first = self._request_bearer_token().json()
        res = self._refresh(first["refresh_token"])
        assert res.status_code == 200
        rotated = res.json()
        assert rotated["access_token"].startswith("pha_")
        assert rotated["refresh_token"].startswith("phr_")
        assert rotated["access_token"] != first["access_token"]
        assert rotated["refresh_token"] != first["refresh_token"]

        replay = self._refresh(first["refresh_token"])
        assert replay.status_code == 400
        assert replay.json()["error"] == "invalid_grant"

    def test_direct_mint_within_ceiling_grants_requested_scopes(self):
        self._set_app_ceiling(["query:read", "project:read"])
        code, verifier = self._mint_auth_code(scopes=["query:read"])
        res = self._exchange_code(code, verifier)
        assert res.status_code == 200
        token = OAuthAccessToken.objects.get(token=res.json()["access_token"])
        assert token.scope == "query:read"

    def test_direct_mint_outside_ceiling_returns_invalid_scope(self):
        self._set_app_ceiling(["query:read"])
        code, verifier = self._mint_auth_code(scopes=["query:read", "insight:write"])
        res = self._exchange_code(code, verifier)
        assert res.status_code == 400
        assert res.json()["error"] == "invalid_scope"

    def test_refresh_narrows_to_tightened_ceiling(self):
        self._set_app_ceiling(["query:read", "insight:write"])
        first = self._request_bearer_token(scopes=["query:read", "insight:write"]).json()

        self._set_app_ceiling(["query:read"])
        res = self._refresh(first["refresh_token"])
        assert res.status_code == 200
        token = OAuthAccessToken.objects.get(token=res.json()["access_token"])
        assert token.scope == "query:read"

    def test_refresh_rejected_when_scopes_outside_ceiling(self):
        self._set_app_ceiling(["insight:write"])
        first = self._request_bearer_token(scopes=["insight:write"]).json()

        self._set_app_ceiling(["query:read"])
        res = self._refresh(first["refresh_token"])
        assert res.status_code == 400
        assert res.json()["error"] == "invalid_grant"

    def test_refresh_rejected_when_token_predates_session_revoke(self):
        # Stamp without sweeping, simulating a refresh token the bulk revoke missed.
        first = self._request_bearer_token().json()
        self._stamp_session_revoke()

        tokens_before = OAuthAccessToken.objects.count()
        res = self._refresh(first["refresh_token"])
        assert res.status_code == 400
        body = res.json()
        assert body["error"] == "invalid_grant"
        assert "revoked" in body["error_description"]
        assert OAuthAccessToken.objects.count() == tokens_before

    def test_refresh_rejected_when_user_deactivated(self):
        first = self._request_bearer_token().json()

        self.user.is_active = False
        self.user.save()

        res = self._refresh(first["refresh_token"])
        assert res.status_code == 400
        assert res.json()["error"] == "invalid_grant"

    def test_refresh_allowed_when_token_postdates_session_revoke(self):
        self._stamp_session_revoke(timezone.now() - timedelta(hours=1))
        first = self._request_bearer_token()
        assert first.status_code == 200

        res = self._refresh(first.json()["refresh_token"])
        assert res.status_code == 200

    @parameterized.expand(
        [
            ("issued_before_revoke", -120, 400),
            ("missing_issued_at", None, 400),
            ("issued_after_revoke", 120, 200),
        ]
    )
    def test_code_exchange_against_session_revoke_stamp(self, _name, issued_offset_seconds, expected_status):
        issued_at = (
            (timezone.now() + timedelta(seconds=issued_offset_seconds)).isoformat()
            if issued_offset_seconds is not None
            else None
        )
        code, verifier = self._mint_code_with_overrides(issued_at=issued_at)
        self._stamp_session_revoke()

        res = self._exchange_code(code, verifier)
        assert res.status_code == expected_status
        if expected_status == 400:
            assert res.json()["error"] == "invalid_grant"