Open source video conferencing app powered by LiveKit. Built with Django and React.
⚡️(backend) hash application secrets with SHA-256
lebaudantoine0450c74f5305
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex ea36375f..88ac5a5c 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -8,6 +8,10 @@ and this project adheres to## [Unreleased]+### Changed++- ⚡️(backend) hash application secrets with SHA-256+## [1.34.0] - 2026-10-07### Addeddiff --git a/src/backend/core/external_api/viewsets.py b/src/backend/core/external_api/viewsets.pyindex d61d095f..545ebec5 100644--- a/src/backend/core/external_api/viewsets.py+++ b/src/backend/core/external_api/viewsets.py@@ -4,7 +4,6 @@ import copyfrom logging import getLoggerfrom django.conf import settings-from django.contrib.auth.hashers import check_passwordfrom django.core.exceptions import ValidationErrorfrom django.core.validators import validate_email@@ -74,7 +73,7 @@ class ApplicationViewSet(viewsets.ViewSet):except models.Application.DoesNotExist as e:raise drf_exceptions.AuthenticationFailed("Invalid credentials") from e- if not check_password(client_secret, application.client_secret):+ if not application.check_client_secret(client_secret):raise drf_exceptions.AuthenticationFailed("Invalid credentials")if not application.is_active:diff --git a/src/backend/core/fields.py b/src/backend/core/fields.pyindex 2b3d6ddc..4c165397 100644--- a/src/backend/core/fields.py+++ b/src/backend/core/fields.py@@ -7,6 +7,8 @@ from logging import getLoggerfrom django.contrib.auth.hashers import identify_hasher, make_passwordfrom django.db import models+from .hashers import CLIENT_SECRET_HASH_PATTERN+logger = getLogger(__name__)@@ -24,6 +26,14 @@ class SecretField(models.CharField):secret = getattr(model_instance, self.attname)+ if CLIENT_SECRET_HASH_PATTERN.fullmatch(secret):+ logger.debug(+ "%s: %s is already hashed with sha256.",+ model_instance,+ self.attname,+ )+ return secret+try:hasher = identify_hasher(secret)logger.debug(diff --git a/src/backend/core/hashers.py b/src/backend/core/hashers.pynew file mode 100644index 00000000..cd42dff7--- /dev/null+++ b/src/backend/core/hashers.py@@ -0,0 +1,46 @@+"""Application secrets only: keep fast hashing out of PASSWORD_HASHERS.++Secrets must be securely randomly generated, not human-chosen.+"""++import hashlib+import re++from django.contrib.auth.hashers import check_password+from django.utils.crypto import constant_time_compare+from django.utils.encoding import force_bytes++CLIENT_SECRET_HASH_ALGORITHM = "sha256" # noqa: S105+CLIENT_SECRET_HASH_VERSION = "v0" # noqa: S105+CLIENT_SECRET_HASH_PREFIX = (+ f"{CLIENT_SECRET_HASH_ALGORITHM}${CLIENT_SECRET_HASH_VERSION}$"+)++# Accept only the versioned format: sha256$v0$<digest>.+CLIENT_SECRET_HASH_PATTERN = re.compile(+ rf"{re.escape(CLIENT_SECRET_HASH_PREFIX)}(?P<digest>[0-9a-f]{{64}})"+)+++def _digest(raw_secret):+ """Return the hex SHA-256 digest of a raw secret."""+ return hashlib.sha256(force_bytes(raw_secret)).hexdigest()+++def hash_client_secret(raw_secret):+ """Hash a machine-generated application secret without key stretching."""+ return f"{CLIENT_SECRET_HASH_PREFIX}{_digest(raw_secret)}"+++def verify_client_secret(raw_secret, encoded):+ """Verify the versioned application format or a legacy Django password hash."""+ if raw_secret is None:+ return False++ match = CLIENT_SECRET_HASH_PATTERN.fullmatch(encoded)++ # Legacy path+ if not match:+ return check_password(raw_secret, encoded)++ return constant_time_compare(match["digest"], _digest(raw_secret))diff --git a/src/backend/core/migrations/0025_application_client_secret_sha256.py b/src/backend/core/migrations/0025_application_client_secret_sha256.pynew file mode 100644index 00000000..bf13b116--- /dev/null+++ b/src/backend/core/migrations/0025_application_client_secret_sha256.py@@ -0,0 +1,19 @@+"""Add a separate fast hash while preserving legacy credentials for rollback."""++from django.db import migrations, models+++class Migration(migrations.Migration):+ dependencies = [+ ("core", "0024_room_last_started_at"),+ ]++ operations = [+ migrations.AddField(+ model_name="application",+ name="client_secret_sha256",+ field=models.CharField(+ max_length=255, null=True, blank=True+ ),+ ),+ ]diff --git a/src/backend/core/models.py b/src/backend/core/models.pyindex 8fe51940..8d4d13a3 100644--- a/src/backend/core/models.py+++ b/src/backend/core/models.py@@ -14,6 +14,7 @@ from typing import List, Optionalfrom django.conf import settingsfrom django.contrib.auth import models as auth_modelsfrom django.contrib.auth.base_user import AbstractBaseUser+from django.contrib.auth.hashers import identify_hasherfrom django.contrib.postgres.fields import ArrayFieldfrom django.core import mail, validatorsfrom django.core.exceptions import PermissionDenied, ValidationError@@ -25,7 +26,7 @@ from django.utils.translation import gettext_lazy as _from lasuite.tools.email import get_domain_from_emailfrom timezone_field import TimeZoneField-from . import fields, utils+from . import fields, hashers, utilsfrom .recording.enums import FileExtensionfrom .validators import sub_validator@@ -824,6 +825,9 @@ class Application(BaseModel):default=utils.generate_client_secret,help_text=_("Hashed on Save. Copy it now if this is a new secret."),)+ client_secret_sha256 = models.CharField(+ max_length=255, null=True, blank=True, editable=False+ )scopes = ArrayField(models.CharField(max_length=50, choices=ApplicationScope.choices),default=list,@@ -839,6 +843,63 @@ class Application(BaseModel):def __str__(self):return f"{self.name!s}"+ def save(self, *args, **kwargs):+ """Populate the fast hash on creation when the raw secret is available."""+ if self._state.adding:+ # Prevent hashing an existing hash instead of the original secret+ try:+ if not hashers.CLIENT_SECRET_HASH_PATTERN.fullmatch(self.client_secret):+ identify_hasher(self.client_secret)+ except ValueError:+ # SecretField.pre_save hashes the legacy field after this method+ self.client_secret_sha256 = hashers.hash_client_secret(+ self.client_secret+ )++ return super().save(*args, **kwargs)++ def rotate_client_secret(self):+ """Persist a new generated secret and return its raw value to the caller.++ This is the only supported rotation path while both credential fields coexist.+ Direct writes may leave a stale fast hash that still accepts the revoked secret,+ while saving a stale instance may restore previous credentials.++ This transitional risk is accepted until the legacy field is removed+ and rotation writes only the fast hash.+ """+ secret = utils.generate_client_secret()+ self.client_secret = secret+ self.client_secret_sha256 = hashers.hash_client_secret(secret)+ self.save(update_fields=["client_secret", "client_secret_sha256"])+ return secret++ def check_client_secret(self, raw_secret):+ """Verify the secret and lazily populate its fast hash for future logins."""+ if self.client_secret_sha256 is not None:+ return hashers.verify_client_secret(raw_secret, self.client_secret_sha256)++ original_hash = self.client_secret+ if not hashers.verify_client_secret(raw_secret, original_hash):+ return False++ encoded = hashers.hash_client_secret(raw_secret)+ updated = Application.objects.filter(+ pk=self.pk, client_secret=original_hash, client_secret_sha256__isnull=True+ ).update(client_secret_sha256=encoded)++ if updated:+ self.client_secret_sha256 = encoded+ return True++ try:+ self.refresh_from_db()+ except Application.DoesNotExist:+ return False++ current_hash = self.client_secret_sha256 or self.client_secret+ return hashers.verify_client_secret(raw_secret, current_hash)+def can_delegate_email(self, email):"""Check if this application can delegate the given email."""diff --git a/src/backend/core/tests/test_application_secret_hashers.py b/src/backend/core/tests/test_application_secret_hashers.pynew file mode 100644index 00000000..5bc26b49--- /dev/null+++ b/src/backend/core/tests/test_application_secret_hashers.py@@ -0,0 +1,350 @@+"""Application hashing and migration of existing credentials."""++import hashlib+from unittest import mock++from django.contrib.auth.hashers import check_password, identify_hasher, make_password+from django.db import connection+from django.test.utils import CaptureQueriesContext+from django.utils.crypto import get_random_string++import pytest+from rest_framework.test import APIClient++from core import hashers+from core.factories import ApplicationFactory, UserFactory+from core.models import Application++pytestmark = pytest.mark.django_db++[email protected]("secret", ["short", "a" * 128, b"byte-secret"])+def test_application_hash(secret):+ """Application hashes verify correctly but are not accepted for user passwords."""+ encoded = hashers.hash_client_secret(secret)+ raw = secret.encode() if isinstance(secret, str) else secret+ algorithm, version, digest = encoded.split("$")+ assert algorithm == "sha256"+ assert version == "v0"+ assert digest == hashlib.sha256(raw).hexdigest()+ assert hashers.hash_client_secret(secret) == encoded+ assert hashers.verify_client_secret(secret, encoded)+ assert not hashers.verify_client_secret("wrong", encoded)+ assert not hashers.verify_client_secret(None, encoded)+ assert not hashers.verify_client_secret(secret, "sha256$invalid")+ assert not hashers.verify_client_secret(secret, "sha256$v1$" + digest)+ assert not check_password(secret, encoded)+ with pytest.raises(ValueError):+ identify_hasher(encoded)+ assert not make_password(raw.decode()).startswith("sha256$")++[email protected]("algorithm", ["pbkdf2_sha256", "md5"])+def test_token_migrates_legacy_secret_once(algorithm):+ """The same client secret works before and after migration, with no later writes."""+ secret = get_random_string(128)+ user = UserFactory()+ legacy = make_password(secret, hasher=algorithm)+ app = ApplicationFactory(client_secret=legacy)+ app.refresh_from_db()++ assert app.client_secret == legacy+ assert app.client_secret_sha256 is None+ payload = {+ "client_id": app.client_id,+ "client_secret": secret,+ "grant_type": "client_credentials",+ "scope": user.email,+ }+ client = APIClient()+ response = client.post(+ "/external-api/v1.0/application/token/", payload, format="json"+ )+ assert response.status_code == 200+ app.refresh_from_db()+ migrated = app.client_secret_sha256+ assert check_password(secret, app.client_secret)+ assert hashers.CLIENT_SECRET_HASH_PATTERN.fullmatch(migrated)["digest"]+ assert hashers.verify_client_secret(secret, migrated)+ with CaptureQueriesContext(connection) as queries:+ response = client.post(+ "/external-api/v1.0/application/token/", payload, format="json"+ )+ assert response.status_code == 200+ assert not any(q["sql"].lstrip().startswith("UPDATE") for q in queries)+ app.refresh_from_db()+ assert app.client_secret_sha256 == migrated+ assert app.client_secret == legacy+++def test_wrong_secret_does_not_migrate():+ """Failed authentication leaves a production PBKDF2 hash untouched."""+ user = UserFactory()+ legacy = make_password(get_random_string(128), hasher="pbkdf2_sha256")+ app = ApplicationFactory(client_secret=legacy)+ response = APIClient().post(+ "/external-api/v1.0/application/token/",+ {+ "client_id": app.client_id,+ "client_secret": "wrong",+ "grant_type": "client_credentials",+ "scope": user.email,+ },+ format="json",+ )+ assert response.status_code == 401+ app.refresh_from_db()+ assert app.client_secret == legacy+ assert app.client_secret_sha256 is None+++def test_migration_preserves_concurrent_rotation():+ """Migration must not restore a secret rotated after verification."""+ secret = get_random_string(128)+ app = ApplicationFactory(+ client_secret=make_password(secret, hasher="pbkdf2_sha256")+ )+ replacement = make_password(get_random_string(128), hasher="pbkdf2_sha256")++ def verify_then_rotate(raw, encoded):+ verified = check_password(raw, encoded)+ Application.objects.filter(pk=app.pk).update(client_secret=replacement)+ return verified++ with mock.patch.object(hashers, "check_password", side_effect=verify_then_rotate):+ assert app.check_client_secret(secret) is False++ app.refresh_from_db()+ assert app.client_secret == replacement+ assert app.client_secret_sha256 is None+++def test_migration_preserves_concurrent_migration():+ """Authentication succeeds when another request migrates the same secret."""+ secret = get_random_string(128)+ app = ApplicationFactory(+ client_secret=make_password(secret, hasher="pbkdf2_sha256")+ )+ migrated = hashers.hash_client_secret(secret)++ def verify_then_migrate(raw, encoded):+ verified = check_password(raw, encoded)+ Application.objects.filter(pk=app.pk).update(client_secret_sha256=migrated)+ return verified++ with mock.patch.object(hashers, "check_password", side_effect=verify_then_migrate):+ assert app.check_client_secret(secret) is True++ app.refresh_from_db()+ assert app.client_secret_sha256 == migrated+++def test_migration_preserves_concurrent_deletion():+ """Authentication fails when the application is deleted after verification."""+ secret = get_random_string(128)+ app = ApplicationFactory(+ client_secret=make_password(secret, hasher="pbkdf2_sha256")+ )++ def verify_then_delete(raw, encoded):+ verified = check_password(raw, encoded)+ Application.objects.filter(pk=app.pk).delete()+ return verified++ with mock.patch.object(hashers, "check_password", side_effect=verify_then_delete):+ assert app.check_client_secret(secret) is False++ assert not Application.objects.filter(pk=app.pk).exists()+++ "secret",+ [+ "sha256$my-secret",+ "sha256$" + "a" * 63,+ "sha256$" + "a" * 64,+ "sha256$" + "g" * 64,+ "sha256$" + "a" * 64 + "\n",+ "sha256$$" + "a" * 64,+ "sha256$short$" + "a" * 64,+ "sha256$" + "b" * 22 + "$" + "g" * 64,+ "sha256$" + "b" * 22 + "$" + "a" * 64,+ "sha256$v0$" + "g" * 64,+ "sha256$v0$" + "a" * 63,+ "sha256$v1$" + "a" * 64,+ ],+)+def test_prefixed_plaintext_is_hashed(secret):+ """A prefix alone must not cause a raw secret to bypass hashing."""+ assert not hashers.CLIENT_SECRET_HASH_PATTERN.fullmatch(secret)+ app = ApplicationFactory(client_secret=secret)+ app.refresh_from_db()+ encoded = app.client_secret_sha256+ assert encoded != secret+ assert hashers.CLIENT_SECRET_HASH_PATTERN.fullmatch(encoded)["digest"]+ assert app.check_client_secret(secret)+ app.name = "Updated application"+ app.save()+ app.refresh_from_db()+ assert app.client_secret_sha256 == encoded+++def test_unsalted_secret_is_rejected():+ """Only salted SHA-256 hashes are accepted."""+ secret = get_random_string(128)+ encoded = f"sha256${hashlib.sha256(secret.encode()).hexdigest()}"++ assert hashers.CLIENT_SECRET_HASH_PATTERN.fullmatch(encoded) is None+ assert not hashers.verify_client_secret(secret, encoded)+++def test_new_application_supports_legacy_verification(settings):+ """A rollback can authenticate applications created by the new release."""+ settings.PASSWORD_HASHERS = [+ "django.contrib.auth.hashers.PBKDF2PasswordHasher",+ ]+ secret = get_random_string(128)+ app = ApplicationFactory(client_secret=secret)+ app.refresh_from_db()+ assert app.client_secret.startswith("pbkdf2_sha256$")+ assert check_password(secret, app.client_secret)+ assert hashers.verify_client_secret(secret, app.client_secret_sha256)+ with mock.patch.object(hashers, "check_password", side_effect=AssertionError):+ assert app.check_client_secret(secret)+ assert not app.check_client_secret("wrong")+++def test_unrelated_save_preserves_both_hashes():+ """Saving an application's metadata does not change either credential hash."""+ app = ApplicationFactory()+ original = (app.client_secret, app.client_secret_sha256)+ app.name = "Renamed"+ app.save()+ app.refresh_from_db()+ assert (app.client_secret, app.client_secret_sha256) == original+++def test_creation_with_legacy_hash_defers_fast_hash_until_login():+ """An imported Django hash is preserved, never treated as the raw secret."""+ secret = get_random_string(128)+ legacy = make_password(secret, hasher="pbkdf2_sha256")+ app = ApplicationFactory(client_secret=legacy)+ app.refresh_from_db()+ assert app.client_secret == legacy+ assert app.client_secret_sha256 is None+ assert not app.check_client_secret(legacy)+ assert app.check_client_secret(secret)+ app.refresh_from_db()+ assert app.client_secret == legacy+ assert hashers.verify_client_secret(secret, app.client_secret_sha256)+++def test_metadata_only_save_does_not_rotate_secret():+ """A secret excluded from update_fields must not change either stored hash."""+ app = ApplicationFactory()+ original = (app.client_secret, app.client_secret_sha256)+ app.client_secret = get_random_string(128)+ app.name = "Renamed"+ app.save(update_fields=["name"])+ app.refresh_from_db()+ assert (app.client_secret, app.client_secret_sha256) == original+++def test_empty_update_fields_does_not_rotate_secret():+ """Django's explicit no-op save must not update either credential field."""+ app = ApplicationFactory()+ original = (app.client_secret, app.client_secret_sha256)+ app.client_secret = get_random_string(128)+ with CaptureQueriesContext(connection) as queries:+ app.save(update_fields=[])+ assert not any(q["sql"].lstrip().startswith("UPDATE") for q in queries)+ app.refresh_from_db()+ assert (app.client_secret, app.client_secret_sha256) == original+++def test_creation_with_salted_hash_skips_fast_hash():+ """An existing salted hash must not be hashed again as plaintext."""+ encoded = hashers.hash_client_secret(get_random_string(128))+ app = ApplicationFactory(client_secret=encoded)+ app.refresh_from_db()+ assert app.client_secret == encoded+ assert app.client_secret_sha256 is None++[email protected]("legacy_only", [False, True])+def test_rotate_client_secret_updates_both_hashes(legacy_only, settings):+ """Rotation revokes the old secret for both current and rollback releases."""+ settings.PASSWORD_HASHERS = [+ "django.contrib.auth.hashers.PBKDF2PasswordHasher",+ ]+ secret = get_random_string(128)+ app = ApplicationFactory(+ client_secret=make_password(secret) if legacy_only else secret+ )++ replacement = app.rotate_client_secret()++ assert replacement != secret+ assert len(replacement) == settings.APPLICATION_CLIENT_SECRET_LENGTH+ assert app.check_client_secret(replacement)+ assert not app.check_client_secret(secret)+ app.refresh_from_db()+ assert app.client_secret.startswith("pbkdf2_sha256$")+ assert check_password(replacement, app.client_secret)+ assert not check_password(secret, app.client_secret)+ assert hashers.verify_client_secret(replacement, app.client_secret_sha256)+ assert not app.check_client_secret(secret)+ assert app.client_secret != replacement+ assert app.client_secret_sha256 != replacement+++def test_rotate_client_secret_preserves_metadata():+ """Rotation persists only the credential fields, not other pending changes."""+ app = ApplicationFactory()+ original_name = app.name+ original_client_id = app.client_id+ app.name = "Unsaved metadata"++ app.rotate_client_secret()++ app.refresh_from_db()+ assert app.name == original_name+ assert app.client_id == original_client_id+++def test_rotate_client_secret_repeatedly_revokes_previous_secrets():+ """Only the latest generated secret remains valid after successive rotations."""+ original = get_random_string(128)+ app = ApplicationFactory(client_secret=original)+ first = app.rotate_client_secret()+ second = app.rotate_client_secret()++ app.refresh_from_db()+ assert len({original, first, second}) == 3+ assert app.check_client_secret(second)+ assert check_password(second, app.client_secret)+ for revoked in (original, first):+ assert not app.check_client_secret(revoked)+ assert not check_password(revoked, app.client_secret)+++def test_token_endpoint_rejects_rotated_secret():+ """New token requests reject the revoked secret and accept its replacement."""+ secret = get_random_string(128)+ app = ApplicationFactory(client_secret=secret)+ user = UserFactory()+ client = APIClient()+ payload = {+ "client_id": app.client_id,+ "client_secret": secret,+ "grant_type": "client_credentials",+ "scope": user.email,+ }+ endpoint = "/external-api/v1.0/application/token/"+ assert client.post(endpoint, payload, format="json").status_code == 200++ replacement = app.rotate_client_secret()++ assert client.post(endpoint, payload, format="json").status_code == 401+ payload["client_secret"] = replacement+ assert client.post(endpoint, payload, format="json").status_code == 200diff --git a/src/backend/core/tests/test_external_api_token.py b/src/backend/core/tests/test_external_api_token.pyindex d0505c53..a4e15122 100644--- a/src/backend/core/tests/test_external_api_token.py+++ b/src/backend/core/tests/test_external_api_token.py@@ -7,17 +7,20 @@ Tests for external API /token endpointfrom unittest import mockfrom urllib.parse import urlencode+from django.contrib.auth.hashers import check_password+import jwtimport pytestfrom freezegun import freeze_timefrom rest_framework.test import APIClient+from core import hashersfrom core.factories import (ApplicationDomainFactory,ApplicationFactory,UserFactory,)-from core.models import ApplicationScope, User+from core.models import Application, ApplicationScope, Userfrom core.services import provisional_user_servicepytestmark = pytest.mark.django_db@@ -28,15 +31,13 @@ def test_api_applications_generate_token_application_disabled(settings):settings.APPLICATION_ENABLED = Falseuser = UserFactory(email="[email protected]")+ plain_secret = "test-secret-123"application = ApplicationFactory(+ client_secret=plain_secret,is_active=True,scopes=[ApplicationScope.ROOMS_LIST],)- plain_secret = "test-secret-123"- application.client_secret = plain_secret- application.save()-client = APIClient()response = client.post("/external-api/v1.0/application/token/",@@ -55,16 +56,13 @@ def test_api_applications_generate_token_application_disabled(settings):def test_api_applications_generate_token_success(settings):"""Valid credentials should return a JWT token."""UserFactory(email="[email protected]")+ plain_secret = "test-secret-123"application = ApplicationFactory(+ client_secret=plain_secret,is_active=True,scopes=[ApplicationScope.ROOMS_LIST, ApplicationScope.ROOMS_CREATE],)- # Store plain secret before it's hashed- plain_secret = "test-secret-123"- application.client_secret = plain_secret- application.save()-client = APIClient()response = client.post("/external-api/v1.0/application/token/",@@ -95,15 +93,13 @@ def test_api_applications_generate_token_form_urlencoded(settings):token endpoints, so that standard OAuth 2.0 client libraries workout of the box."""UserFactory(email="[email protected]")+ plain_secret = "test-secret-123"application = ApplicationFactory(+ client_secret=plain_secret,is_active=True,scopes=[ApplicationScope.ROOMS_LIST, ApplicationScope.ROOMS_CREATE],)- plain_secret = "test-secret-123"- application.client_secret = plain_secret- application.save()-client = APIClient()response = client.post("/external-api/v1.0/application/token/",@@ -170,11 +166,8 @@ def test_api_applications_generate_token_form_urlencoded_missing_fields():def test_api_applications_generate_token_form_urlencoded_invalid_grant_type():"""An unsupported grant_type sent as form-urlencoded should return 400."""user = UserFactory(email="[email protected]")- application = ApplicationFactory(is_active=True)-plain_secret = "test-secret-123"- application.client_secret = plain_secret- application.save()+ application = ApplicationFactory(client_secret=plain_secret, is_active=True)client = APIClient()response = client.post(@@ -198,15 +191,13 @@ def test_api_applications_generate_token_form_urlencoded_special_characters():"""Percent-encoded reserved characters ("&", "=", "+", "%") in theclient_secret should survive form-urlencoded decoding."""UserFactory(email="[email protected]")+ plain_secret = "s3cr3t&with=special+chars%42"application = ApplicationFactory(+ client_secret=plain_secret,is_active=True,scopes=[ApplicationScope.ROOMS_LIST],)- plain_secret = "s3cr3t&with=special+chars%42"- application.client_secret = plain_secret- application.save()-client = APIClient()response = client.post("/external-api/v1.0/application/token/",@@ -279,14 +270,54 @@ def test_api_applications_generate_token_invalid_client_secret():assert "Invalid credentials" in str(response.data)+def test_token_unknown_client_id_with_valid_secret():+ """A valid secret cannot authenticate an unknown client ID."""+ secret = "application-a-secret"+ ApplicationFactory(client_secret=secret)+ user = UserFactory()++ response = APIClient().post(+ "/external-api/v1.0/application/token/",+ {+ "client_id": "unknown-client-id",+ "client_secret": secret,+ "grant_type": "client_credentials",+ "scope": user.email,+ },+ format="json",+ )++ assert response.status_code == 401+ assert "Invalid credentials" in str(response.data)+++def test_token_rejects_secret_owned_by_another_application():+ """Application A's secret cannot authenticate application B."""+ secret_a = "application-a-secret"+ ApplicationFactory(client_secret=secret_a)+ application_b = ApplicationFactory(client_secret="application-b-secret")+ user = UserFactory()++ response = APIClient().post(+ "/external-api/v1.0/application/token/",+ {+ "client_id": application_b.client_id,+ "client_secret": secret_a,+ "grant_type": "client_credentials",+ "scope": user.email,+ },+ format="json",+ )++ assert response.status_code == 401+ assert "Invalid credentials" in str(response.data)++def test_api_applications_generate_token_inactive_application():"""Inactive application should return 401."""user = UserFactory(email="[email protected]")- application = ApplicationFactory(is_active=False)-plain_secret = "test-secret-123"- application.client_secret = plain_secret- application.save()+ application = ApplicationFactory(client_secret=plain_secret, is_active=False)client = APIClient()response = client.post(@@ -328,11 +359,8 @@ def test_api_applications_generate_token_inactive_application_wrong_secret():def test_api_applications_generate_token_invalid_email_format():"""Invalid email format should return 400."""- application = ApplicationFactory(is_active=True)-plain_secret = "test-secret-123"- application.client_secret = plain_secret- application.save()+ application = ApplicationFactory(client_secret=plain_secret, is_active=True)client = APIClient()response = client.post(@@ -353,12 +381,9 @@ def test_api_applications_generate_token_invalid_email_format():def test_api_applications_generate_token_domain_not_authorized():"""Application without domain authorization should return 403."""user = UserFactory(email="[email protected]")- application = ApplicationFactory(is_active=True)- ApplicationDomainFactory(application=application, domain="allowed.com")-plain_secret = "test-secret-123"- application.client_secret = plain_secret- application.save()+ application = ApplicationFactory(client_secret=plain_secret, is_active=True)+ ApplicationDomainFactory(application=application, domain="allowed.com")client = APIClient()response = client.post(@@ -379,16 +404,14 @@ def test_api_applications_generate_token_domain_not_authorized():def test_api_applications_generate_token_domain_authorized():"""Application with domain authorization should succeed."""user = UserFactory(email="[email protected]")+ plain_secret = "test-secret-123"application = ApplicationFactory(+ client_secret=plain_secret,is_active=True,scopes=[ApplicationScope.ROOMS_LIST],)ApplicationDomainFactory(application=application, domain="allowed.com")- plain_secret = "test-secret-123"- application.client_secret = plain_secret- application.save()-client = APIClient()response = client.post("/external-api/v1.0/application/token/",@@ -407,11 +430,8 @@ def test_api_applications_generate_token_domain_authorized():def test_api_applications_generate_token_user_not_found():"""Non-existent user should return 404."""- application = ApplicationFactory(is_active=True)-plain_secret = "test-secret-123"- application.client_secret = plain_secret- application.save()+ application = ApplicationFactory(client_secret=plain_secret, is_active=True)client = APIClient()response = client.post(@@ -434,15 +454,13 @@ def test_api_applications_token_payload_structure(settings):"""Generated token should have correct payload structure."""user = UserFactory(email="[email protected]")+ plain_secret = "test-secret-123"application = ApplicationFactory(+ client_secret=plain_secret,is_active=True,scopes=[ApplicationScope.ROOMS_LIST, ApplicationScope.ROOMS_CREATE],)- plain_secret = "test-secret-123"- application.client_secret = plain_secret- application.save()-client = APIClient()response = client.post("/external-api/v1.0/application/token/",@@ -487,15 +505,13 @@ def test_api_applications_token_new_user(settings):assert len(User.objects.all()) == 0+ plain_secret = "test-secret-123"application = ApplicationFactory(+ client_secret=plain_secret,is_active=True,scopes=[ApplicationScope.ROOMS_LIST, ApplicationScope.ROOMS_CREATE],)- plain_secret = "test-secret-123"- application.client_secret = plain_secret- application.save()-client = APIClient()response = client.post("/external-api/v1.0/application/token/",@@ -545,15 +561,13 @@ def test_api_applications_token_existing_user(settings):assert len(User.objects.all()) == 1+ plain_secret = "test-secret-123"application = ApplicationFactory(+ client_secret=plain_secret,is_active=True,scopes=[ApplicationScope.ROOMS_LIST, ApplicationScope.ROOMS_CREATE],)- plain_secret = "test-secret-123"- application.client_secret = plain_secret- application.save()-client = APIClient()response = client.post("/external-api/v1.0/application/token/",@@ -598,12 +612,10 @@ def test_api_applications_token_new_user_race_condition(mock_get_by_email, settisettings.OIDC_FALLBACK_TO_EMAIL_FOR_IDENTIFICATION = Truesettings.OIDC_USER_SUB_FIELD_IMMUTABLE = False+ plain_secret = "test-secret-123"application = ApplicationFactory(- is_active=True, scopes=[ApplicationScope.ROOMS_LIST]+ client_secret=plain_secret, is_active=True, scopes=[ApplicationScope.ROOMS_LIST])- plain_secret = "test-secret-123"- application.client_secret = plain_secret- application.save()email = "[email protected]"@@ -653,12 +665,10 @@ def test_api_applications_token_new_user_race_condition_unrecoverable(settings.OIDC_FALLBACK_TO_EMAIL_FOR_IDENTIFICATION = Truesettings.OIDC_USER_SUB_FIELD_IMMUTABLE = False+ plain_secret = "test-secret-123"application = ApplicationFactory(- is_active=True, scopes=[ApplicationScope.ROOMS_LIST]+ client_secret=plain_secret, is_active=True, scopes=[ApplicationScope.ROOMS_LIST])- plain_secret = "test-secret-123"- application.client_secret = plain_secret- application.save()client = APIClient()response = client.post(@@ -674,3 +684,183 @@ def test_api_applications_token_new_user_race_condition_unrecoverable(assert response.status_code == 409assert mock_get_or_create.call_count == 1+++def test_token_populates_fast_hash_and_stops_using_legacy_hash():+ """First login migrates; subsequent logins use only the fast hash."""+ secret = "application-secret"++ application = ApplicationFactory(client_secret=secret)+ Application.objects.filter(pk=application.pk).update(client_secret_sha256=None)+ application.refresh_from_db()++ original_hash = application.client_secret++ user = UserFactory()+ payload = {+ "client_id": application.client_id,+ "client_secret": secret,+ "grant_type": "client_credentials",+ "scope": user.email,+ }+ client = APIClient()++ with mock.patch.object(+ hashers, "check_password", wraps=hashers.check_password+ ) as legacy_verifier:+ response = client.post(+ "/external-api/v1.0/application/token/", payload, format="json"+ )++ assert response.status_code == 200+ legacy_verifier.assert_called_once_with(secret, original_hash)++ application.refresh_from_db()++ migrated_hash = application.client_secret_sha256+ assert hashers.CLIENT_SECRET_HASH_PATTERN.fullmatch(migrated_hash)+ assert hashers.verify_client_secret(secret, migrated_hash)+ assert application.client_secret == original_hash++ # Fail immediately if a subsequent login tries the legacy verifier.+ with mock.patch.object(+ hashers,+ "check_password",+ side_effect=AssertionError("Legacy hash must no longer be used"),+ ):+ response = client.post(+ "/external-api/v1.0/application/token/", payload, format="json"+ )++ assert response.status_code == 200+ application.refresh_from_db()+ assert application.client_secret_sha256 == migrated_hash+ assert application.client_secret == original_hash+++def test_token_failed_login_leaves_legacy_credentials_untouched():+ """An incorrect secret neither migrates nor changes the legacy hash."""++ application = ApplicationFactory(client_secret="application-secret")+ Application.objects.filter(pk=application.pk).update(client_secret_sha256=None)+ application.refresh_from_db()++ original_hash = application.client_secret+ user = UserFactory()++ response = APIClient().post(+ "/external-api/v1.0/application/token/",+ {+ "client_id": application.client_id,+ "client_secret": "wrong-secret",+ "grant_type": "client_credentials",+ "scope": user.email,+ },+ format="json",+ )++ assert response.status_code == 401+ application.refresh_from_db()+ assert application.client_secret == original_hash+ assert application.client_secret_sha256 is None+++def test_token_concurrent_successful_logins_preserve_first_migration():+ """Both logins succeed; the later migration preserves the first hash."""+ secret = "application-secret"+ application = ApplicationFactory(client_secret=secret)+ Application.objects.filter(pk=application.pk).update(client_secret_sha256=None)+ application.refresh_from_db()++ original_hash = application.client_secret+ user = UserFactory()+ payload = {+ "client_id": application.client_id,+ "client_secret": secret,+ "grant_type": "client_credentials",+ "scope": user.email,+ }+ legacy_verifier = hashers.check_password+ winning_hashes = []++ def verify_then_complete_other_login(raw_secret, encoded):+ verified = legacy_verifier(raw_secret, encoded)++ # Complete another login before this request writes its migration.+ # Restore the real verifier to avoid recursively invoking this callback.+ with mock.patch.object(hashers, "check_password", new=legacy_verifier):+ other_response = APIClient().post(+ "/external-api/v1.0/application/token/", payload, format="json"+ )++ assert other_response.status_code == 200+ application.refresh_from_db()+ winning_hashes.append(application.client_secret_sha256)+ return verified++ with mock.patch.object(+ hashers, "check_password", side_effect=verify_then_complete_other_login+ ) as verifier:+ response = APIClient().post(+ "/external-api/v1.0/application/token/", payload, format="json"+ )++ assert response.status_code == 200+ verifier.assert_called_once_with(secret, original_hash)+ application.refresh_from_db()+ assert application.client_secret_sha256 == winning_hashes[0]+ assert hashers.verify_client_secret(secret, application.client_secret_sha256)+ assert application.client_secret == original_hash+++def test_token_authenticates_after_rollback():+ """Legacy authentication still works after the fast hash is discarded."""+ secret = "application-secret"+ application = ApplicationFactory(client_secret=secret)+ Application.objects.filter(pk=application.pk).update(client_secret_sha256=None)+ application.refresh_from_db()++ original_hash = application.client_secret++ user = UserFactory()+ payload = {+ "client_id": application.client_id,+ "client_secret": secret,+ "grant_type": "client_credentials",+ "scope": user.email,+ }+ client = APIClient()++ # Authenticate with the new implementation and migrate the hash.+ response = client.post(+ "/external-api/v1.0/application/token/", payload, format="json"+ )++ assert response.status_code == 200++ application.refresh_from_db()++ assert hashers.verify_client_secret(secret, application.client_secret_sha256)+ assert application.client_secret == original_hash++ Application.objects.filter(pk=application.pk).update(client_secret_sha256=None)++ def legacy_check(instance, raw_secret):+ return check_password(raw_secret, instance.client_secret)++ # Simulate the old release's verification using only the legacy field.+ with mock.patch.object(+ Application,+ "check_client_secret",+ autospec=True,+ side_effect=legacy_check,+ ) as verifier:+ response = client.post(+ "/external-api/v1.0/application/token/", payload, format="json"+ )++ assert response.status_code == 200+ verifier.assert_called_once()+ application.refresh_from_db()+ assert application.client_secret == original_hash+ assert application.client_secret_sha256 is Nonediff --git a/src/backend/core/tests/test_models_applications.py b/src/backend/core/tests/test_models_applications.pyindex dd6cf9ed..8363852d 100644--- a/src/backend/core/tests/test_models_applications.py+++ b/src/backend/core/tests/test_models_applications.py@@ -6,12 +6,12 @@ Unit tests for the Application and ApplicationDomain modelsfrom unittest import mock-from django.contrib.auth.hashers import check_passwordfrom django.core.exceptions import ValidationErrorimport pytestfrom core.factories import ApplicationDomainFactory, ApplicationFactory+from core.hashers import verify_client_secretfrom core.models import Application, ApplicationDomain, ApplicationScopepytestmark = pytest.mark.django_db@@ -98,8 +98,8 @@ def test_models_application_client_secret_hashed_on_save():# Secret should be hashed, not plainassert application.client_secret != plain_secret- # Should verify with check_password- assert check_password(plain_secret, application.client_secret) is True+ # Should verify with the application credential policy+ assert verify_client_secret(plain_secret, application.client_secret) is Truedef test_models_application_client_secret_preserves_existing_hash():diff --git a/src/backend/meet/settings.py b/src/backend/meet/settings.pyindex f39a633b..128b6202 100755--- a/src/backend/meet/settings.py+++ b/src/backend/meet/settings.py@@ -1070,7 +1070,7 @@ class Base(Configuration):environ_prefix=None,)APPLICATION_CLIENT_SECRET_LENGTH = values.PositiveIntegerValue(- 128,+ 50,environ_name="APPLICATION_CLIENT_SECRET_LENGTH",environ_prefix=None,)@@ -1432,6 +1432,20 @@ class Base(Configuration):stacklevel=2,)+ # Secrets use a 62-character alphanumeric charset (~5.95 bits/char).+ # 43 characters provide at least 256 bits of entropy; 42 provide ~250 bits.+ if cls.APPLICATION_CLIENT_SECRET_LENGTH < 43:+ warnings.warn(+ f"APPLICATION_CLIENT_SECRET_LENGTH={cls.APPLICATION_CLIENT_SECRET_LENGTH} "+ "is below the recommended 43 characters (256 bits of entropy). "+ "Application secrets use a fast hash and rely on high entropy to "+ "resist offline guessing if the database leaks. "+ "Please set APPLICATION_CLIENT_SECRET_LENGTH to at least 43.",+ # We use UserWarning to make sure it shows up in production deployment+ UserWarning,+ stacklevel=2,+ )+# The SENTRY_DSN setting should be available to activate sentry for an environmentif cls.SENTRY_DSN is not None:sentry_sdk.init(@@ -1517,6 +1531,7 @@ class Test(Base):)PASSWORD_HASHERS = ["django.contrib.auth.hashers.MD5PasswordHasher",+ "django.contrib.auth.hashers.PBKDF2PasswordHasher",]USE_SWAGGER = TrueEXTERNAL_API_ENABLED = True