Open source video conferencing app powered by LiveKit. Built with Django and React.
✨(backend) add application model with secure secret handling
lebaudantoine3fd5a4404c75
diff --git a/src/backend/core/admin.py b/src/backend/core/admin.pyindex d16e90ad..9c7272e4 100644--- a/src/backend/core/admin.py+++ b/src/backend/core/admin.py@@ -1,5 +1,6 @@"""Admin classes and registrations for core app."""+from django import formsfrom django.contrib import adminfrom django.contrib.auth import admin as auth_adminfrom django.utils.translation import gettext_lazy as _@@ -150,3 +151,66 @@ class RecordingAdmin(admin.ModelAdmin):return _("Multiple owners")return str(owners[0].user)+++class ApplicationDomainInline(admin.TabularInline):+ """Inline admin for managing allowed domains per application."""++ model = models.ApplicationDomain+ extra = 0+++class ApplicationAdminForm(forms.ModelForm):+ """Custom form for Application admin with multi-select scopes."""++ scopes = forms.MultipleChoiceField(+ choices=models.ApplicationScope.choices,+ widget=forms.CheckboxSelectMultiple,+ required=False,+ )++ def __init__(self, *args, **kwargs):+ super().__init__(*args, **kwargs)+ if self.instance.pk and self.instance.scopes:+ self.fields["scopes"].initial = self.instance.scopes++[email protected](models.Application)+class ApplicationAdmin(admin.ModelAdmin):+ """Admin interface for managing applications and their permissions."""++ form = ApplicationAdminForm++ list_display = ("id", "name", "client_id", "get_scopes_display")+ fields = [+ "name",+ "id",+ "created_at",+ "updated_at",+ "scopes",+ "client_id",+ "client_secret",+ ]+ readonly_fields = ["id", "created_at", "updated_at"]+ inlines = [ApplicationDomainInline]++ def get_readonly_fields(self, request, obj=None):+ """Make client_id and client_secret readonly after creation."""+ if obj: # Editing existing object+ return self.readonly_fields + ["client_id", "client_secret"]+ return self.readonly_fields++ def get_fields(self, request, obj=None):+ """Hide client_secret after creation."""+ fields = super().get_fields(request, obj)+ if obj:+ return [f for f in fields if f != "client_secret"]+ return fields++ def get_scopes_display(self, obj):+ """Display scopes in list view."""+ if obj.scopes:+ return ", ".join(obj.scopes)+ return _("No scopes")++ get_scopes_display.short_description = _("Scopes")diff --git a/src/backend/core/factories.py b/src/backend/core/factories.pyindex 8f019f80..43f4fdfc 100644--- a/src/backend/core/factories.py+++ b/src/backend/core/factories.py@@ -9,7 +9,7 @@ from django.utils.text import slugifyimport factory.fuzzyfrom faker import Faker-from core import models+from core import models, utilsfake = Faker()@@ -117,3 +117,39 @@ class TeamRecordingAccessFactory(factory.django.DjangoModelFactory):recording = factory.SubFactory(RecordingFactory)team = factory.Sequence(lambda n: f"team{n}")role = factory.fuzzy.FuzzyChoice(models.RoleChoices.values)+++class ApplicationFactory(factory.django.DjangoModelFactory):+ """Create fake applications for testing."""++ class Meta:+ model = models.Application++ name = factory.Faker("company")+ active = True+ client_id = factory.LazyFunction(utils.generate_client_id)+ client_secret = factory.LazyFunction(utils.generate_client_secret)+ scopes = []++ class Params:+ """Factory traits for common application configurations."""++ with_all_scopes = factory.Trait(+ scopes=[+ models.ApplicationScope.ROOMS_LIST,+ models.ApplicationScope.ROOMS_RETRIEVE,+ models.ApplicationScope.ROOMS_CREATE,+ models.ApplicationScope.ROOMS_UPDATE,+ models.ApplicationScope.ROOMS_DELETE,+ ]+ )+++class ApplicationDomainFactory(factory.django.DjangoModelFactory):+ """Create fake application domains for testing."""++ class Meta:+ model = models.ApplicationDomain++ domain = factory.Faker("domain_name")+ application = factory.SubFactory(ApplicationFactory)diff --git a/src/backend/core/fields.py b/src/backend/core/fields.pynew file mode 100644index 00000000..2b3d6ddc--- /dev/null+++ b/src/backend/core/fields.py@@ -0,0 +1,43 @@+"""+Core application fields+"""++from logging import getLogger++from django.contrib.auth.hashers import identify_hasher, make_password+from django.db import models++logger = getLogger(__name__)+++class SecretField(models.CharField):+ """CharField that automatically hashes secrets before saving.++ Use for API keys, client secrets, or tokens that should never be stored+ in plain text. Already-hashed values are preserved to prevent double-hashing.++ Inspired by: https://github.com/django-oauth-toolkit/django-oauth-toolkit+ """++ def pre_save(self, model_instance, add):+ """Hash the secret if not already hashed, otherwise preserve it."""++ secret = getattr(model_instance, self.attname)++ try:+ hasher = identify_hasher(secret)+ logger.debug(+ "%s: %s is already hashed with %s.",+ model_instance,+ self.attname,+ hasher,+ )+ except ValueError:+ logger.debug(+ "%s: %s is not hashed; hashing it now.", model_instance, self.attname+ )+ hashed_secret = make_password(secret)+ setattr(model_instance, self.attname, hashed_secret)+ return hashed_secret++ return super().pre_save(model_instance, add)diff --git a/src/backend/core/migrations/0015_application_and_more.py b/src/backend/core/migrations/0015_application_and_more.pynew file mode 100644index 00000000..260b18d4--- /dev/null+++ b/src/backend/core/migrations/0015_application_and_more.py@@ -0,0 +1,52 @@+# Generated by Django 5.2.6 on 2025-10-02 20:55++import core.utils+import django.db.models.deletion+import uuid+from django.db import migrations, models+++class Migration(migrations.Migration):++ dependencies = [+ ('core', '0014_room_pin_code'),+ ]++ operations = [+ migrations.CreateModel(+ name='Application',+ fields=[+ ('id', models.UUIDField(default=uuid.uuid4, editable=False, help_text='primary key for the record as UUID', primary_key=True, serialize=False, verbose_name='id')),+ ('created_at', models.DateTimeField(auto_now_add=True, help_text='date and time at which a record was created', verbose_name='created on')),+ ('updated_at', models.DateTimeField(auto_now=True, help_text='date and time at which a record was last updated', verbose_name='updated on')),+ ('name', models.CharField(help_text='Descriptive name for this application.', max_length=255, verbose_name='Application name')),+ ('active', models.BooleanField(default=True)),+ ('client_id', models.CharField(default=core.utils.generate_client_id, max_length=100, unique=True)),+ ('client_secret', core.fields.SecretField(blank=True, default=core.utils.generate_client_secret, help_text='Hashed on Save. Copy it now if this is a new secret.', max_length=255)),+ ('scopes', django.contrib.postgres.fields.ArrayField(base_field=models.CharField(choices=[('rooms:create', 'Create rooms'), ('rooms:list', 'List rooms'), ('rooms:retrieve', 'Retrieve room details'), ('rooms:update', 'Update rooms'), ('rooms:delete', 'Delete rooms')], max_length=50), blank=True, default=list, size=None)),+ ],+ options={+ 'verbose_name': 'Application',+ 'verbose_name_plural': 'Applications',+ 'db_table': 'meet_application',+ 'ordering': ('-created_at',),+ },+ ),+ migrations.CreateModel(+ name='ApplicationDomain',+ fields=[+ ('id', models.UUIDField(default=uuid.uuid4, editable=False, help_text='primary key for the record as UUID', primary_key=True, serialize=False, verbose_name='id')),+ ('created_at', models.DateTimeField(auto_now_add=True, help_text='date and time at which a record was created', verbose_name='created on')),+ ('updated_at', models.DateTimeField(auto_now=True, help_text='date and time at which a record was last updated', verbose_name='updated on')),+ ('domain', models.CharField(help_text='Email domain this application can act on behalf of.', max_length=253, validators=[django.core.validators.DomainNameValidator(accept_idna=False, message='Enter a valid domain')], verbose_name='Domain')),+ ('application', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='allowed_domains', to='core.application')),+ ],+ options={+ 'verbose_name': 'Application domain',+ 'verbose_name_plural': 'Application domains',+ 'db_table': 'meet_application_domain',+ 'ordering': ('domain',),+ 'unique_together': {('application', 'domain')},+ },+ ),+ ]diff --git a/src/backend/core/models.py b/src/backend/core/models.pyindex b92b9291..89ff11cd 100644--- a/src/backend/core/models.py+++ b/src/backend/core/models.py@@ -11,6 +11,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.postgres.fields import ArrayFieldfrom django.core import mail, validatorsfrom django.core.exceptions import PermissionDenied, ValidationErrorfrom django.db import models@@ -18,8 +19,10 @@ from django.utils import timezonefrom django.utils.text import capfirst, slugifyfrom django.utils.translation import gettext_lazy as _+from lasuite.tools.email import get_domain_from_emailfrom timezone_field import TimeZoneField+from . import fields, utilsfrom .recording.enums import FileExtensionlogger = getLogger(__name__)@@ -717,3 +720,101 @@ class RecordingAccess(BaseAccess):Compute and return abilities for a given user on the recording access."""return self._get_abilities(self.recording, user)+++class ApplicationScope(models.TextChoices):+ """Available permission scopes for application operations."""++ ROOMS_CREATE = "rooms:create", _("Create rooms")+ ROOMS_LIST = "rooms:list", _("List rooms")+ ROOMS_RETRIEVE = "rooms:retrieve", _("Retrieve room details")+ ROOMS_UPDATE = "rooms:update", _("Update rooms")+ ROOMS_DELETE = "rooms:delete", _("Delete rooms")+++class Application(BaseModel):+ """External application for API authentication and authorization.++ Represents a third-party integration or automated system that accesses+ the API using OAuth2-style client credentials (client_id/client_secret).+ Supports scoped permissions and optional domain restrictions for delegation.+ """++ name = models.CharField(+ max_length=255,+ verbose_name=_("Application name"),+ help_text=_("Descriptive name for this application."),+ )+ active = models.BooleanField(default=True)+ client_id = models.CharField(+ max_length=100, unique=True, default=utils.generate_client_id+ )+ client_secret = fields.SecretField(+ max_length=255,+ blank=True,+ default=utils.generate_client_secret,+ help_text=_("Hashed on Save. Copy it now if this is a new secret."),+ )+ scopes = ArrayField(+ models.CharField(max_length=50, choices=ApplicationScope.choices),+ default=list,+ blank=True,+ )++ class Meta:+ db_table = "meet_application"+ ordering = ("-created_at",)+ verbose_name = _("Application")+ verbose_name_plural = _("Applications")++ def __str__(self):+ return f"{self.name!s}"++ def can_delegate_email(self, email):+ """Check if this application can delegate the given email."""++ if not self.allowed_domains.exists():+ return True # No domain restrictions++ domain = get_domain_from_email(email)+ return self.allowed_domains.filter(domain__iexact=domain).exists()+++class ApplicationDomain(BaseModel):+ """Domain authorized for application delegation."""++ domain = models.CharField(+ max_length=253, # Max domain length per RFC 1035+ validators=[+ validators.DomainNameValidator(+ accept_idna=False,+ message=_("Enter a valid domain"),+ )+ ],+ verbose_name=_("Domain"),+ help_text=_("Email domain this application can act on behalf of."),+ )++ application = models.ForeignKey(+ "Application",+ on_delete=models.CASCADE,+ related_name="allowed_domains",+ )++ class Meta:+ db_table = "meet_application_domain"+ ordering = ("domain",)+ verbose_name = _("Application domain")+ verbose_name_plural = _("Application domains")+ unique_together = [("application", "domain")]++ def __str__(self):+ """Return string representation of the domain."""++ return self.domain++ def save(self, *args, **kwargs):+ """Save the domain after normalizing to lowercase."""++ self.domain = self.domain.lower().strip()+ super().save(*args, **kwargs)diff --git a/src/backend/core/tests/test_models_applications.py b/src/backend/core/tests/test_models_applications.pynew file mode 100644index 00000000..035738c0--- /dev/null+++ b/src/backend/core/tests/test_models_applications.py@@ -0,0 +1,331 @@+"""+Unit tests for the Application and ApplicationDomain models+"""++# pylint: disable=W0613++from unittest import mock++from django.contrib.auth.hashers import check_password+from django.core.exceptions import ValidationError++import pytest++from core.factories import ApplicationDomainFactory, ApplicationFactory+from core.models import Application, ApplicationDomain, ApplicationScope++pytestmark = pytest.mark.django_db+++# Application Model Tests+++def test_models_application_str():+ """The str representation should be the name."""+ application = ApplicationFactory(name="My Integration")+ assert str(application) == "My Integration"+++def test_models_application_name_maxlength():+ """The name field should be at most 255 characters."""+ ApplicationFactory(name="a" * 255)++ with pytest.raises(ValidationError) as excinfo:+ ApplicationFactory(name="a" * 256)++ assert "Ensure this value has at most 255 characters (it has 256)." in str(+ excinfo.value+ )+++def test_models_application_active_default():+ """An application should be active by default."""+ application = Application.objects.create(name="Test App")+ assert application.active is True+++def test_models_application_scopes_default():+ """Scopes should default to empty list."""+ application = Application.objects.create(name="Test App")+ assert application.scopes == []+++def test_models_application_client_id_auto_generated():+ """Client ID should be automatically generated on creation."""+ application = ApplicationFactory()+ assert application.client_id is not None+ assert len(application.client_id) > 0+++def test_models_application_client_id_unique():+ """Client IDs should be unique."""+ app1 = ApplicationFactory()++ with pytest.raises(ValidationError) as excinfo:+ ApplicationFactory(client_id=app1.client_id)++ assert "Application with this Client id already exists." in str(excinfo.value)+++def test_models_application_client_id_length(settings):+ """Client ID should match configured length."""++ app1 = ApplicationFactory()+ assert len(app1.client_id) == 40 # default value++ settings.APPLICATION_CLIENT_ID_LENGTH = 20++ app2 = ApplicationFactory()+ assert len(app2.client_id) == 20+++def test_models_application_client_secret_auto_generated():+ """Client secret should be automatically generated and hashed on creation."""+ application = ApplicationFactory()++ assert application.client_secret is not None+ assert len(application.client_secret) > 0+++def test_models_application_client_secret_hashed_on_save():+ """Client secret should be hashed when saved."""+ plain_secret = "my-plain-secret"++ with mock.patch(+ "core.models.utils.generate_client_secret", return_value=plain_secret+ ):+ application = ApplicationFactory(client_secret=plain_secret)++ # Secret should be hashed, not plain+ assert application.client_secret != plain_secret+ # Should verify with check_password+ assert check_password(plain_secret, application.client_secret) is True+++def test_models_application_client_secret_preserves_existing_hash():+ """Re-saving should not re-hash an already hashed secret."""+ application = ApplicationFactory()+ original_hash = application.client_secret++ # Update another field and save+ application.name = "Updated Name"+ application.save()++ # Hash should remain unchanged+ assert application.client_secret == original_hash+++def test_models_application_updates_preserve_client_id():+ """Application updates should preserve existing client_id."""+ application = ApplicationFactory()+ original_client_id = application.client_id++ application.name = "Updated Name"+ application.save()++ assert application.client_id == original_client_id+++def test_models_application_scopes_valid_choices():+ """Only valid scope choices should be accepted."""+ application = ApplicationFactory(+ scopes=[+ ApplicationScope.ROOMS_LIST,+ ApplicationScope.ROOMS_CREATE,+ ApplicationScope.ROOMS_RETRIEVE,+ ]+ )++ assert len(application.scopes) == 3+ assert ApplicationScope.ROOMS_LIST in application.scopes+++def test_models_application_scopes_invalid_choice():+ """Invalid scope choices should raise validation error."""+ with pytest.raises(ValidationError) as excinfo:+ ApplicationFactory(scopes=["invalid:scope"])++ assert "is not a valid choice" in str(excinfo.value)+++def test_models_application_can_delegate_email_no_restrictions():+ """Application with no domain restrictions can delegate any email."""+ application = ApplicationFactory()++ assert application.can_delegate_email("[email protected]") is True+ assert application.can_delegate_email("[email protected]") is True+++def test_models_application_can_delegate_email_allowed_domain():+ """Application can delegate email from allowed domain."""+ application = ApplicationFactory()+ ApplicationDomainFactory(application=application, domain="example.com")++ assert application.can_delegate_email("[email protected]") is True+++def test_models_application_can_delegate_email_denied_domain():+ """Application cannot delegate email from non-allowed domain."""+ application = ApplicationFactory()+ ApplicationDomainFactory(application=application, domain="example.com")++ assert application.can_delegate_email("[email protected]") is False+++def test_models_application_can_delegate_email_case_insensitive():+ """Domain matching should be case-insensitive."""+ application = ApplicationFactory()+ ApplicationDomainFactory(application=application, domain="example.com")++ assert application.can_delegate_email("[email protected]") is True+ assert application.can_delegate_email("[email protected]") is True+++def test_models_application_can_delegate_email_multiple_domains():+ """Application with multiple allowed domains should check all."""+ application = ApplicationFactory()+ ApplicationDomainFactory(application=application, domain="example.com")+ ApplicationDomainFactory(application=application, domain="other.org")++ assert application.can_delegate_email("[email protected]") is True+ assert application.can_delegate_email("[email protected]") is True+ assert application.can_delegate_email("[email protected]") is False+++# ApplicationDomain Model Tests+++def test_models_application_domain_str():+ """The str representation should be the domain."""+ domain = ApplicationDomainFactory(domain="example.com")+ assert str(domain) == "example.com"+++def test_models_application_domain_ordering():+ """Domains should be returned ordered by domain name."""+ application = ApplicationFactory()+ ApplicationDomainFactory(application=application, domain="zulu.com")+ ApplicationDomainFactory(application=application, domain="alpha.com")+ ApplicationDomainFactory(application=application, domain="beta.com")++ domains = ApplicationDomain.objects.all()+ assert domains[0].domain == "alpha.com"+ assert domains[1].domain == "beta.com"+ assert domains[2].domain == "zulu.com"+++ "valid_domain",+ [+ "example.com",+ "sub.example.com",+ "deep.sub.example.com",+ "example-with-dash.com",+ "123.example.com",+ ],+)+def test_models_application_domain_valid_domain(valid_domain):+ """Valid domain names should be accepted."""+ ApplicationDomainFactory(domain=valid_domain)+++ "invalid_domain",+ [+ "not a domain",+ "example..com",+ "-example.com",+ "example-.com",+ "example.com-",+ ],+)+def test_models_application_domain_invalid_domain(invalid_domain):+ """Invalid domain names should raise validation error."""++ with pytest.raises(ValidationError):+ ApplicationDomainFactory(domain=invalid_domain)+++def test_models_application_domain_lowercase_on_save():+ """Domain should be normalized to lowercase on save."""+ domain = ApplicationDomainFactory(domain="EXAMPLE.COM")++ assert domain.domain == "example.com"+++def test_models_application_domain_strip_whitespace_on_save():+ """Domain should strip whitespace on save."""+ domain = ApplicationDomainFactory(domain=" example.com ")++ assert domain.domain == "example.com"+++def test_models_application_domain_combined_normalization():+ """Domain should strip and lowercase in one operation."""+ domain = ApplicationDomainFactory(domain=" EXAMPLE.COM ")++ assert domain.domain == "example.com"+++def test_models_application_domain_unique_together():+ """Same domain cannot be added twice to same application."""+ application = ApplicationFactory()+ ApplicationDomainFactory(application=application, domain="example.com")++ with pytest.raises(ValidationError) as excinfo:+ ApplicationDomainFactory(application=application, domain="example.com")++ assert "Application domain with this Application and Domain already exists." in str(+ excinfo.value+ )+++def test_models_application_domain_same_domain_different_apps():+ """Same domain can belong to different applications."""+ app1 = ApplicationFactory()+ app2 = ApplicationFactory()++ ApplicationDomainFactory(application=app1, domain="example.com")+ ApplicationDomainFactory(application=app2, domain="example.com")++ assert app1.allowed_domains.count() == 1+ assert app2.allowed_domains.count() == 1+++def test_models_application_domain_cascade_delete():+ """Deleting application should delete its domains."""+ application = ApplicationFactory()+ ApplicationDomainFactory(application=application, domain="example.com")+ ApplicationDomainFactory(application=application, domain="other.com")++ assert ApplicationDomain.objects.count() == 2++ application.delete()++ assert ApplicationDomain.objects.count() == 0+++def test_models_application_domain_related_name():+ """Domains should be accessible via application.allowed_domains."""+ application = ApplicationFactory()+ domain1 = ApplicationDomainFactory(application=application, domain="example.com")+ domain2 = ApplicationDomainFactory(application=application, domain="other.com")++ assert list(application.allowed_domains.all()) == [domain1, domain2]+++def test_models_application_domain_filters_delegation():+ """Adding/removing domains should affect can_delegate_email."""+ application = ApplicationFactory()++ # No restrictions initially+ assert application.can_delegate_email("[email protected]") is True++ # Add domain restriction+ domain = ApplicationDomainFactory(application=application, domain="example.com")+ assert application.can_delegate_email("[email protected]") is True+ assert application.can_delegate_email("[email protected]") is False++ # Remove domain restriction+ domain.delete()+ assert application.can_delegate_email("[email protected]") is Truediff --git a/src/backend/core/utils.py b/src/backend/core/utils.pyindex 92f16eaa..8f62bd56 100644--- a/src/backend/core/utils.py+++ b/src/backend/core/utils.py@@ -8,6 +8,7 @@ Utils functions used in the core appimport hashlibimport jsonimport random+import stringfrom typing import List, Optionalfrom uuid import uuid4@@ -240,3 +241,42 @@ async def notify_participants(room_name: str, notification_data: dict):raise NotificationError("Failed to notify room participants") from efinally:await lkapi.aclose()+++ALPHANUMERIC_CHARSET = string.ascii_letters + string.digits+++def generate_secure_token(length: int = 30, charset: str = ALPHANUMERIC_CHARSET) -> str:+ """Generate a cryptographically secure random token.++ Uses SystemRandom for proper entropy, suitable for OAuth tokens+ and API credentials that must be non-guessable.++ Inspired by: https://github.com/oauthlib/oauthlib/blob/master/oauthlib/common.py++ Args:+ length: Token length in characters (default: 30)+ charset: Character set to use for generation++ Returns:+ Cryptographically secure random token+ """+ return "".join(secrets.choice(charset) for _ in range(length))+++def generate_client_id() -> str:+ """Generate a unique client ID for application authentication.++ Returns:+ Random client ID string+ """+ return generate_secure_token(settings.APPLICATION_CLIENT_ID_LENGTH)+++def generate_client_secret() -> str:+ """Generate a secure client secret for application authentication.++ Returns:+ Cryptographically secure client secret+ """+ return generate_secure_token(settings.APPLICATION_CLIENT_SECRET_LENGTH)diff --git a/src/backend/meet/settings.py b/src/backend/meet/settings.pyindex 51d10e88..31b64ec2 100755--- a/src/backend/meet/settings.py+++ b/src/backend/meet/settings.py@@ -664,6 +664,18 @@ class Base(Configuration):environ_prefix=None,)+ # External Applications+ APPLICATION_CLIENT_ID_LENGTH = values.PositiveIntegerValue(+ 40,+ environ_name="APPLICATION_CLIENT_ID_LENGTH",+ environ_prefix=None,+ )+ APPLICATION_CLIENT_SECRET_LENGTH = values.PositiveIntegerValue(+ 128,+ environ_name="APPLICATION_CLIENT_SECRET_LENGTH",+ environ_prefix=None,+ )+# pylint: disable=invalid-name@propertydef ENVIRONMENT(self):