Allow IAS SSO without email and provide explicit identity linking

This commit is contained in:
Aleksandr Meshchryakov
2026-09-28 13:59:19 +02:00
parent 13511771a2
commit 951abfb843
10 changed files with 351 additions and 17 deletions

View File

@@ -1,6 +1,7 @@
import os
import tempfile
from datetime import UTC, datetime, timedelta
from io import StringIO
from urllib.parse import parse_qs, urlencode, urlsplit
import jwt
@@ -8,6 +9,8 @@ from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import ec
from django.apps import apps
from django.contrib.auth import get_user_model
from django.core.management import call_command
from django.core.management.base import CommandError
from django.test import SimpleTestCase, override_settings
from rest_framework.test import APIClient, APITestCase
@@ -315,9 +318,177 @@ class SsoCallbackViewTest(APITestCase):
self.assertFalse(User.objects.exists())
def test_multiple_users_can_login_without_email(self):
for index, email in enumerate((None, "", " ", "missing")):
claims = self._claims(
user_id=9000 + index,
username=f"noemail{index}",
email=email,
jti=f"noemail-{index}",
)
if email == "missing":
claims.pop("email")
response = self._post_callback(self._encode_claims(claims))
self.assertEqual(response.status_code, 303)
user = User.objects.get(username=f"noemail{index}")
self.assertIsNone(user.email)
self.assertFalse(user.is_verified)
self.assertFalse(user.has_usable_password())
self.assertEqual(self.client.get("/api/v1/users/me/").status_code, 200)
self.assertEqual(User.objects.filter(email__isnull=True).count(), 4)
def test_email_less_identity_reuses_account_and_preserves_existing_email(self):
self.assertEqual(self._post_callback(self._token()).status_code, 303)
user = User.objects.get(username="test30")
response = self._post_callback(self._token(email=None, jti="without-email"))
self.assertEqual(response.status_code, 303)
user.refresh_from_db()
self.assertEqual(user.email, "test30@example.com")
self.assertTrue(user.is_verified)
self.assertEqual(User.objects.count(), 1)
self.assertEqual(self.client.session["_auth_user_id"], str(user.pk))
def test_email_less_account_can_receive_email_on_later_login(self):
self.assertEqual(self._post_callback(self._token(email=None)).status_code, 303)
response = self._post_callback(self._token(jti="email-added"))
self.assertEqual(response.status_code, 303)
user = User.objects.get(username="test30")
self.assertEqual(user.email, "test30@example.com")
self.assertTrue(user.is_verified)
self.assertEqual(User.objects.count(), 1)
def test_email_less_token_cannot_claim_existing_local_admin(self):
user = UserFactory.create_user(username="test30", is_staff=True)
original_email = user.email
response = self._post_callback(self._token(email=None))
self.assertEqual(response.status_code, 403)
self.assertNotIn("_auth_user_id", self.client.session)
user.refresh_from_db()
self.assertEqual(user.email, original_email)
self.assertTrue(user.is_staff)
self.assertFalse(apps.get_model("user", "SsoIdentity").objects.exists())
def test_email_less_identity_cannot_take_another_username(self):
self.assertEqual(self._post_callback(self._token(email=None)).status_code, 303)
UserFactory.create_user(username="occupied")
response = self._post_callback(
self._token(email=None, username="occupied", jti="name-collision")
)
self.assertEqual(response.status_code, 403)
self.assertTrue(User.objects.filter(username="test30").exists())
def test_email_less_token_still_requires_signature_and_one_time_use(self):
token = self._token(email=None)
invalid = self._encode_claims(
self._claims(email=None), key=ec.generate_private_key(ec.SECP256R1())
)
self.assertEqual(self._post_callback(invalid).status_code, 403)
self.assertFalse(User.objects.exists())
self.assertEqual(self._post_callback(token).status_code, 303)
self.assertEqual(self._post_callback(token).status_code, 403)
def test_invalid_provided_email_is_rejected(self):
for email in (123, [], "not-an-email", "x" * 250 + "@example.com"):
response = self._post_callback(self._token(email=email))
self.assertEqual(response.status_code, 403)
self.assertFalse(User.objects.exists())
def _link(self, user, subject="2564", **options):
call_command(
"link_sso_identity",
user_id=user.pk,
expected_username=user.username,
subject=subject,
stdout=StringIO(),
**options,
)
def test_explicit_link_allows_email_less_login_and_keeps_local_permissions(self):
user = UserFactory.create_user(
username="test30", is_staff=True, is_verified=False
)
original_email = user.email
self._link(user, dry_run=True)
identity_model = apps.get_model("user", "SsoIdentity")
self.assertFalse(identity_model.objects.exists())
self._link(user)
self._link(user)
self.assertIsNone(identity_model.objects.get(user=user).last_authenticated_at)
response = self._post_callback(self._token(email=None))
self.assertEqual(response.status_code, 303)
user.refresh_from_db()
self.assertEqual(user.email, original_email)
self.assertFalse(user.is_verified)
self.assertTrue(user.is_staff)
self.assertIsNotNone(
identity_model.objects.get(user=user).last_authenticated_at
)
self.assertEqual(self.client.session["_auth_user_id"], str(user.pk))
def test_explicit_link_refuses_reassignment_and_invalid_local_target(self):
user = UserFactory.create_user(username="test30")
other = UserFactory.create_user(username="other")
self._link(user)
with self.assertRaises(CommandError):
self._link(other)
with self.assertRaises(CommandError):
self._link(user, subject="different")
with self.assertRaises(CommandError):
call_command(
"link_sso_identity",
user_id=other.pk,
expected_username="mismatch",
subject="different",
stdout=StringIO(),
)
other.is_active = False
other.save()
with self.assertRaises(CommandError):
self._link(other, subject="different")
self.assertEqual(apps.get_model("user", "SsoIdentity").objects.count(), 1)
def test_repeated_email_less_login_uses_same_identity_after_username_change(self):
self.assertEqual(self._post_callback(self._token(email=None)).status_code, 303)
original = User.objects.get(username="test30")
self.assertEqual(
self._post_callback(
self._token(email=None, username="renamed", jti="renamed-token")
).status_code,
303,
)
self.assertEqual(User.objects.get(username="renamed").pk, original.pk)
self.assertEqual(User.objects.count(), 1)
def test_later_email_collision_does_not_modify_identity(self):
self.assertEqual(self._post_callback(self._token(email=None)).status_code, 303)
UserFactory.create_user(username="other", email="test30@example.com")
self.assertEqual(
self._post_callback(self._token(jti="email-conflict")).status_code, 403
)
self.assertIsNone(User.objects.get(username="test30").email)
def test_email_less_login_rejects_missing_security_claims(self):
for claim in (
"iss",
"exp",
"iat",
"jti",
"token_type",
"sso_target",
"user_id",
"username",
):
claims = self._claims(email=None)
claims.pop(claim)
with self.subTest(claim=claim):
self.assertEqual(
self._post_callback(self._encode_claims(claims)).status_code, 403
)
self.assertFalse(User.objects.exists())
def test_rejects_missing_required_claim(self):
claims = self._claims()
claims.pop("email")
claims.pop("user_id")
response = self._post_callback(self._encode_claims(claims))