: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
import time
import base64
import hashlib
import secrets
from typing import Any
import pytest
import time_machine
from posthog.test.base import BaseTest
from unittest.mock import MagicMock, patch
from django.http import HttpResponse, HttpResponseRedirect
from django.test import RequestFactory, override_settings
import jwt
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa
from parameterized import parameterized
from posthog.admin.oauth2 import AdminOAuth2Middleware, _get_email_from_id_token, admin_oauth2_callback
from posthog.models import User
from posthog.session.backend import SessionStore
# Any path under the prefix exercises the middleware branch; no route has to exist.
ADMIN_API_PATH = "/admin/api/example/"
class JWTTestHelper:
"""Helper class for creating test JWT tokens."""
def __init__(self):
self.private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
self.public_key = self.private_key.public_key()
self.test_kid = "test_key_id"
def _int_to_base64url(self, value: int) -> str:
byte_length = (value.bit_length() + 7) // 8
value_bytes = value.to_bytes(byte_length, byteorder="big")
return base64.urlsafe_b64encode(value_bytes).decode("ascii").rstrip("=")
def get_mock_jwks(self) -> dict:
public_numbers = self.public_key.public_numbers()
n = self._int_to_base64url(public_numbers.n)
e = self._int_to_base64url(public_numbers.e)
return {"keys": [{"kid": self.test_kid, "kty": "RSA", "use": "sig", "alg": "RS256", "n": n, "e": e}]}
def create_id_token(self, payload: dict[str, Any], kid: str | None = None) -> str:
headers = {"kid": kid or self.test_kid}
private_key_pem = self.private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.PKCS8,
encryption_algorithm=serialization.NoEncryption(),
)
return jwt.encode(payload, private_key_pem, algorithm="RS256", headers=headers)
class TestGetEmailFromIdToken(BaseTest):
"""Tests for _get_email_from_id_token function with iat and hd validation."""
def setUp(self):
super().setUp()
self.jwt_helper = JWTTestHelper()
self.base_payload = {
"iss": "https://accounts.google.com",
"aud": "test_client_id",
"email": "[email protected]",
"email_verified": True,
"iat": int(time.time()),
"exp": int(time.time()) + 3600,
"nonce": "test_nonce",
"hd": "posthog.com",
}
def _get_email_with_mocked_jwks(self, token: str, allowed_domains: list[str] | None = None) -> tuple[str, dict]:
if allowed_domains is None:
allowed_domains = ["posthog.com"]
with patch("jwt.PyJWKClient") as mock_client:
mock_jwks_client = MagicMock()
mock_signing_key = MagicMock()
mock_signing_key.key = self.jwt_helper.public_key
mock_jwks_client.get_signing_key_from_jwt.return_value = mock_signing_key
mock_client.return_value = mock_jwks_client
with override_settings(
ADMIN_AUTH_GOOGLE_OAUTH2_KEY="test_client_id",
ADMIN_AUTH_GOOGLE_ALLOWED_DOMAINS=allowed_domains,
):
return _get_email_from_id_token(token)
@parameterized.expand(
[
("fresh_token", 0, True),
("one_minute_old", -60, True),
("just_under_5_minutes", -299, True),
("just_over_5_minutes", -301, False),
("ten_minutes_old", -600, False),
# Future tokens are rejected by PyJWT (no clock skew allowed)
("1_second_future", 1, False),
("30_seconds_future", 30, False),
]
)
# Freeze so the token iat and the validation now() share one instant.
@time_machine.travel("2025-01-01T00:00:00Z", tick=False)
def test_iat_bounds_checking(self, name, iat_offset, expected_success):
payload = {**self.base_payload, "iat": int(time.time()) + iat_offset}
token = self.jwt_helper.create_id_token(payload)
email, token_payload = self._get_email_with_mocked_jwks(token)
if expected_success:
self.assertEqual(email, "[email protected]")
self.assertEqual(token_payload.get("email"), "[email protected]")
else:
self.assertEqual(email, "")
self.assertEqual(token_payload, {})
@parameterized.expand(
[
("matching_single_domain", "posthog.com", ["posthog.com"], True),
("non_matching_domain", "other.com", ["posthog.com"], False),
("personal_gmail", None, ["posthog.com"], False),
("matching_first_of_multiple", "posthog.com", ["posthog.com", "other.com"], True),
("matching_second_of_multiple", "other.com", ["posthog.com", "other.com"], True),
("not_matching_any", "evil.com", ["posthog.com", "other.com"], False),
]
)
def test_hosted_domain_validation(self, name, hd, allowed_domains, expected_success):
payload = {**self.base_payload}
if hd is None:
payload.pop("hd", None)
else:
payload["hd"] = hd
token = self.jwt_helper.create_id_token(payload)
email, token_payload = self._get_email_with_mocked_jwks(token, allowed_domains)
if expected_success:
self.assertEqual(email, "[email protected]")
else:
self.assertEqual(email, "")
self.assertEqual(token_payload, {})
def test_hd_validation_skipped_when_no_allowed_domains(self):
"""When ADMIN_AUTH_GOOGLE_ALLOWED_DOMAINS is empty, any domain should work."""
payload = {**self.base_payload}
payload.pop("hd", None) # Personal Gmail
token = self.jwt_helper.create_id_token(payload)
email, _ = self._get_email_with_mocked_jwks(token, allowed_domains=[])
self.assertEqual(email, "[email protected]")
def test_unverified_email_rejected(self):
payload = {**self.base_payload, "email_verified": False}
token = self.jwt_helper.create_id_token(payload)
email, token_payload = self._get_email_with_mocked_jwks(token)
self.assertEqual(email, "")
self.assertEqual(token_payload, {})
def test_email_normalized_to_lowercase(self):
payload = {**self.base_payload, "email": "[email protected]"}
token = self.jwt_helper.create_id_token(payload)
email, _ = self._get_email_with_mocked_jwks(token)
self.assertEqual(email, "[email protected]")
class TestNonceValidation(BaseTest):
"""Tests for nonce validation in admin_oauth2_callback."""
def setUp(self):
super().setUp()
self.factory = RequestFactory()
self.jwt_helper = JWTTestHelper()
self.user = User.objects.create_and_join(
organization=self.organization,
email="[email protected]",
password="testpassword",
)
self.user.is_staff = True
self.user.save()
def _create_request_with_session(self, code: str, state: str) -> Any:
request = self.factory.get(f"/admin/oauth2/callback?code={code}&state={state}")
request.user = self.user
request.session = SessionStore()
return request
def _mock_token_exchange(self, id_token: str):
return patch("posthog.admin.oauth2._exchange_code_for_token", return_value={"id_token": id_token})
def _mock_get_email(self, email: str, payload: dict):
return patch("posthog.admin.oauth2._get_email_from_id_token", return_value=(email, payload))
@staticmethod
def _assert_redirects_to_admin(response: HttpResponse) -> HttpResponseRedirect:
assert isinstance(response, HttpResponseRedirect)
assert response.status_code == 302
assert response.url == "/admin/"
return response
def test_valid_nonce_accepted(self):
nonce = secrets.token_urlsafe(32)
state = secrets.token_urlsafe(32)
request = self._create_request_with_session("auth_code", state)
request.session[AdminOAuth2Middleware.SESSION_STATE_KEY] = state
request.session[AdminOAuth2Middleware.SESSION_NONCE_KEY] = nonce
with self._mock_get_email("[email protected]", {"nonce": nonce, "email": "[email protected]"}):
with self._mock_token_exchange("fake_token"):
with override_settings(ADMIN_OAUTH2_COOKIE_SECURE=False):
response = admin_oauth2_callback(request)
response = self._assert_redirects_to_admin(response)
# Nonce should be cleared from session
self.assertNotIn(AdminOAuth2Middleware.SESSION_NONCE_KEY, request.session)
# Verify success: verification secret should be set
self.assertIn(AdminOAuth2Middleware.SESSION_VERIFICATION_SECRET_KEY, request.session)
# Verify success: verification cookie should be set
self.assertIn(AdminOAuth2Middleware.COOKIE_NAME, response.cookies)
def test_nonce_mismatch_rejected(self):
state = secrets.token_urlsafe(32)
session_nonce = secrets.token_urlsafe(32)
token_nonce = secrets.token_urlsafe(32) # Different nonce
request = self._create_request_with_session("auth_code", state)
request.session[AdminOAuth2Middleware.SESSION_STATE_KEY] = state
request.session[AdminOAuth2Middleware.SESSION_NONCE_KEY] = session_nonce
with self._mock_get_email("[email protected]", {"nonce": token_nonce, "email": "[email protected]"}):
with self._mock_token_exchange("fake_token"):
response = admin_oauth2_callback(request)
response = self._assert_redirects_to_admin(response)
# Verify rejection: no verification secret should be set
self.assertNotIn(AdminOAuth2Middleware.SESSION_VERIFICATION_SECRET_KEY, request.session)
# Verify rejection: no verification cookie should be set
self.assertNotIn(AdminOAuth2Middleware.COOKIE_NAME, response.cookies)
def test_missing_nonce_in_token_rejected(self):
state = secrets.token_urlsafe(32)
session_nonce = secrets.token_urlsafe(32)
request = self._create_request_with_session("auth_code", state)
request.session[AdminOAuth2Middleware.SESSION_STATE_KEY] = state
request.session[AdminOAuth2Middleware.SESSION_NONCE_KEY] = session_nonce
# Token payload without nonce
with self._mock_get_email("[email protected]", {"email": "[email protected]"}):
with self._mock_token_exchange("fake_token"):
response = admin_oauth2_callback(request)
response = self._assert_redirects_to_admin(response)
# Verify rejection: no verification secret should be set
self.assertNotIn(AdminOAuth2Middleware.SESSION_VERIFICATION_SECRET_KEY, request.session)
# Verify rejection: no verification cookie should be set
self.assertNotIn(AdminOAuth2Middleware.COOKIE_NAME, response.cookies)
class TestRedirectIncludesNonce(BaseTest):
"""Tests that the OAuth redirect includes nonce parameter."""
def setUp(self):
super().setUp()
self.factory = RequestFactory()
self.user = User.objects.create_and_join(
organization=self.organization,
email="[email protected]",
password="testpassword",
)
self.user.is_staff = True
self.user.save()
@override_settings(
ADMIN_AUTH_GOOGLE_OAUTH2_KEY="test_client_id",
ADMIN_AUTH_GOOGLE_OAUTH2_SECRET="test_secret",
ADMIN_OAUTH2_COOKIE_SECURE=False,
)
def test_redirect_includes_nonce_param(self):
request = self.factory.get("/admin/")
request.user = self.user
request.session = SessionStore()
request.META["HTTP_HOST"] = "localhost"
middleware = AdminOAuth2Middleware(get_response=lambda r: HttpResponse())
response = middleware._redirect_to_oauth2(request)
assert isinstance(response, HttpResponseRedirect)
# Check nonce is in the redirect URL
self.assertIn("nonce=", response.url)
# Check nonce is stored in session
self.assertIn(AdminOAuth2Middleware.SESSION_NONCE_KEY, request.session)
# Check the nonce in URL matches session
session_nonce = request.session[AdminOAuth2Middleware.SESSION_NONCE_KEY]
self.assertIn(f"nonce={session_nonce}", response.url)
class TestAllowedDomainsSettings:
"""Tests for ADMIN_AUTH_GOOGLE_ALLOWED_DOMAINS parsing."""
@pytest.mark.parametrize(
"env_value,expected",
[
("posthog.com", ["posthog.com"]),
("a.com,b.com", ["a.com", "b.com"]),
("a.com,b.com,c.com", ["a.com", "b.com", "c.com"]),
],
)
def test_allowed_domains_parsing(self, env_value, expected):
result = [d.strip() for d in env_value.split(",") if d.strip()]
assert result == expected
@pytest.mark.parametrize(
"env_value,expected",
[
("", []),
("a.com,,b.com", ["a.com", "b.com"]),
(",a.com,", ["a.com"]),
(",,", []),
],
)
def test_empty_entries_filtered(self, env_value, expected):
result = [d.strip() for d in env_value.split(",") if d.strip()]
assert result == expected
@pytest.mark.parametrize(
"env_value,expected",
[
("posthog.com, example.com", ["posthog.com", "example.com"]),
(" posthog.com , example.com ", ["posthog.com", "example.com"]),
(" a.com , b.com ", ["a.com", "b.com"]),
],
)
def test_whitespace_stripped(self, env_value, expected):
result = [d.strip() for d in env_value.split(",") if d.strip()]
assert result == expected
class TestMiddlewareVerification(BaseTest):
"""Tests for the middleware verification flow."""
def setUp(self):
super().setUp()
self.factory = RequestFactory()
self.user = User.objects.create_and_join(
organization=self.organization,
email="[email protected]",
password="testpassword",
)
self.user.is_staff = True
self.user.save()
@override_settings(
ADMIN_AUTH_GOOGLE_OAUTH2_KEY="test_client_id",
ADMIN_AUTH_GOOGLE_OAUTH2_SECRET="test_secret",
ADMIN_OAUTH2_COOKIE_SECURE=False,
)
def test_valid_verification_passes(self):
request = self.factory.get("/admin/")
request.user = self.user
request.session = SessionStore()
# Set up valid verification
verification_secret = secrets.token_urlsafe(32)
request.session[AdminOAuth2Middleware.SESSION_VERIFICATION_SECRET_KEY] = verification_secret
request.session[AdminOAuth2Middleware.SESSION_VERIFICATION_HASH_KEY] = AdminOAuth2Middleware._get_client_hash(
request
)
secret_hash = hashlib.sha256(verification_secret.encode()).hexdigest()
request.COOKIES[AdminOAuth2Middleware.COOKIE_NAME] = secret_hash
middleware = AdminOAuth2Middleware(get_response=lambda r: HttpResponse("OK"))
response = middleware(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"OK")
@override_settings(
ADMIN_AUTH_GOOGLE_OAUTH2_KEY="test_client_id",
ADMIN_AUTH_GOOGLE_OAUTH2_SECRET="test_secret",
ADMIN_OAUTH2_COOKIE_SECURE=False,
)
def test_cookie_mismatch_redirects_to_oauth(self):
request = self.factory.get("/admin/")
request.user = self.user
request.session = SessionStore()
request.META["HTTP_HOST"] = "localhost"
# Set up verification with wrong cookie
verification_secret = secrets.token_urlsafe(32)
request.session[AdminOAuth2Middleware.SESSION_VERIFICATION_SECRET_KEY] = verification_secret
request.session[AdminOAuth2Middleware.SESSION_VERIFICATION_HASH_KEY] = AdminOAuth2Middleware._get_client_hash(
request
)
request.COOKIES[AdminOAuth2Middleware.COOKIE_NAME] = "wrong_hash"
middleware = AdminOAuth2Middleware(get_response=lambda r: HttpResponse("OK"))
response = middleware(request)
# Should redirect to Google OAuth
self.assertEqual(response.status_code, 302)
assert isinstance(response, HttpResponseRedirect)
self.assertIn("accounts.google.com", response.url)
@override_settings(
ADMIN_AUTH_GOOGLE_OAUTH2_KEY="test_client_id",
ADMIN_AUTH_GOOGLE_OAUTH2_SECRET="test_secret",
ADMIN_OAUTH2_COOKIE_SECURE=False,
)
def test_api_admin_unverified_returns_403(self):
# No /admin/api/ route exists right now, but the middleware still branches on that
# prefix (ee/middleware.py) to answer 403 instead of redirecting to Google. The
# middleware is called directly here, so the branch is covered without a route.
request = self.factory.get(ADMIN_API_PATH)
request.user = self.user
request.session = SessionStore()
middleware = AdminOAuth2Middleware(get_response=lambda r: HttpResponse("OK"))
response = middleware(request)
self.assertEqual(response.status_code, 403)
@override_settings(
ADMIN_AUTH_GOOGLE_OAUTH2_KEY="test_client_id",
ADMIN_AUTH_GOOGLE_OAUTH2_SECRET="test_secret",
ADMIN_OAUTH2_COOKIE_SECURE=False,
)
def test_api_admin_verified_passes(self):
request = self.factory.get(ADMIN_API_PATH)
request.user = self.user
request.session = SessionStore()
verification_secret = secrets.token_urlsafe(32)
request.session[AdminOAuth2Middleware.SESSION_VERIFICATION_SECRET_KEY] = verification_secret
request.session[AdminOAuth2Middleware.SESSION_VERIFICATION_HASH_KEY] = AdminOAuth2Middleware._get_client_hash(
request
)
secret_hash = hashlib.sha256(verification_secret.encode()).hexdigest()
request.COOKIES[AdminOAuth2Middleware.COOKIE_NAME] = secret_hash
middleware = AdminOAuth2Middleware(get_response=lambda r: HttpResponse("OK"))
response = middleware(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"OK")