Open source video conferencing app powered by LiveKit. Built with Django and React.
✨(backend) add delegation mechanism to external app /token endpoint
lebaudantoine1f3d0f9239b7
diff --git a/env.d/development/common.dist b/env.d/development/common.distindex e52186a5..52f33f12 100644--- a/env.d/development/common.dist+++ b/env.d/development/common.dist@@ -65,3 +65,7 @@ ROOM_TELEPHONY_ENABLED=TrueFRONTEND_USE_FRENCH_GOV_FOOTER=FalseFRONTEND_USE_PROCONNECT_BUTTON=False++# External Applications+APPLICATION_JWT_AUDIENCE=http://localhost:8071/external-api/v1.0/+APPLICATION_JWT_SECRET_KEY=devKeydiff --git a/src/backend/core/external_api/authentication.py b/src/backend/core/external_api/authentication.pynew file mode 100644index 00000000..9b8efd47--- /dev/null+++ b/src/backend/core/external_api/authentication.py@@ -0,0 +1,109 @@+"""Authentication Backends for external application to the Meet core app."""++import logging++from django.conf import settings+from django.contrib.auth import get_user_model++import jwt+from rest_framework import authentication, exceptions++User = get_user_model()+logger = logging.getLogger(__name__)+++class ApplicationJWTAuthentication(authentication.BaseAuthentication):+ """JWT authentication for application-delegated API access.++ Validates JWT tokens issued to applications that are acting on behalf+ of users. Tokens must include user_id, client_id, and delegation flag.+ """++ def authenticate(self, request):+ """Extract and validate JWT from Authorization header.++ Returns:+ Tuple of (user, payload) if authentication successful, None otherwise+ """+ auth_header = authentication.get_authorization_header(request).split()++ if not auth_header or auth_header[0].lower() != b"bearer":+ return None++ if len(auth_header) != 2:+ logger.warning("Invalid token header format")+ raise exceptions.AuthenticationFailed("Invalid token header.")++ try:+ token = auth_header[1].decode("utf-8")+ except UnicodeError as e:+ logger.warning("Token decode error: %s", e)+ raise exceptions.AuthenticationFailed("Invalid token encoding.") from e++ return self.authenticate_credentials(token)++ def authenticate_credentials(self, token):+ """Validate JWT token and return authenticated user.++ Args:+ token: JWT token string++ Returns:+ Tuple of (user, payload)++ Raises:+ AuthenticationFailed: If token is invalid, expired, or user not found+ """+ # Decode and validate JWT+ try:+ payload = jwt.decode(+ token,+ settings.APPLICATION_JWT_SECRET_KEY,+ algorithms=[settings.APPLICATION_JWT_ALG],+ issuer=settings.APPLICATION_JWT_ISSUER,+ audience=settings.APPLICATION_JWT_AUDIENCE,+ )+ except jwt.ExpiredSignatureError as e:+ logger.warning("Token expired")+ raise exceptions.AuthenticationFailed("Token expired.") from e+ except jwt.InvalidIssuerError as e:+ logger.warning("Invalid JWT issuer: %s", e)+ raise exceptions.AuthenticationFailed("Invalid token.") from e+ except jwt.InvalidAudienceError as e:+ logger.warning("Invalid JWT audience: %s", e)+ raise exceptions.AuthenticationFailed("Invalid token.") from e+ except jwt.InvalidTokenError as e:+ logger.warning("Invalid JWT token: %s", e)+ raise exceptions.AuthenticationFailed("Invalid token.") from e++ user_id = payload.get("user_id")+ client_id = payload.get("client_id")+ is_delegated = payload.get("delegated", False)++ if not user_id:+ logger.warning("Missing 'user_id' in JWT payload")+ raise exceptions.AuthenticationFailed("Invalid token claims.")++ if not client_id:+ logger.warning("Missing 'client_id' in JWT payload")+ raise exceptions.AuthenticationFailed("Invalid token claims.")++ if not is_delegated:+ logger.warning("Token is not marked as delegated")+ raise exceptions.AuthenticationFailed("Invalid token type.")++ try:+ user = User.objects.get(id=user_id)+ except User.DoesNotExist as e:+ logger.warning("User not found: %s", user_id)+ raise exceptions.AuthenticationFailed("User not found.") from e++ if not user.is_active:+ logger.warning("Inactive user attempted authentication: %s", user_id)+ raise exceptions.AuthenticationFailed("User account is disabled.")++ return (user, payload)++ def authenticate_header(self, request):+ """Return authentication scheme for WWW-Authenticate header."""+ return "Bearer"diff --git a/src/backend/core/external_api/serializers.py b/src/backend/core/external_api/serializers.pynew file mode 100644index 00000000..4d4d3057--- /dev/null+++ b/src/backend/core/external_api/serializers.py@@ -0,0 +1,18 @@+"""Serializers for the external API of the Meet core app."""++# pylint: disable=abstract-method++from rest_framework import serializers++from core.api.serializers import BaseValidationOnlySerializer++OAUTH2_GRANT_TYPE_CLIENT_CREDENTIALS = "client_credentials"+++class ApplicationJwtSerializer(BaseValidationOnlySerializer):+ """Validate OAuth2 JWT token request data."""++ client_id = serializers.CharField(write_only=True)+ client_secret = serializers.CharField(write_only=True)+ grant_type = serializers.ChoiceField(choices=[OAUTH2_GRANT_TYPE_CLIENT_CREDENTIALS])+ scope = serializers.CharField(write_only=True)diff --git a/src/backend/core/external_api/viewsets.py b/src/backend/core/external_api/viewsets.pynew file mode 100644index 00000000..a36e4a08--- /dev/null+++ b/src/backend/core/external_api/viewsets.py@@ -0,0 +1,131 @@+"""External API endpoints"""++from datetime import datetime, timedelta, timezone+from logging import getLogger++from django.conf import settings+from django.contrib.auth.hashers import check_password+from django.core.exceptions import ValidationError+from django.core.validators import validate_email++import jwt+from rest_framework import decorators, viewsets+from rest_framework import (+ exceptions as drf_exceptions,+)+from rest_framework import (+ response as drf_response,+)+from rest_framework import (+ status as drf_status,+)++from core import models++from . import serializers++logger = getLogger(__name__)+++class ApplicationViewSet(viewsets.GenericViewSet):+ """API endpoints for application authentication and token generation."""++ @decorators.action(+ detail=False,+ methods=["post"],+ url_path="token",+ url_name="token",+ )+ def generate_jwt_access_token(self, request, *args, **kwargs):+ """Generate JWT access token for application delegation.++ Validates application credentials and generates a JWT token scoped+ to a specific user email, allowing the application to act on behalf+ of that user.++ Note: The 'scope' parameter accepts an email address to identify the user+ being delegated. This design allows applications to obtain user-scoped tokens+ for delegation purposes. The scope field is intentionally generic and can be+ extended to support other values in the future.++ Reference: https://stackoverflow.com/a/27711422+ """+ serializer = serializers.ApplicationJwtSerializer(data=request.data)+ serializer.is_valid(raise_exception=True)++ client_id = serializer.validated_data["client_id"]+ client_secret = serializer.validated_data["client_secret"]++ try:+ application = models.Application.objects.get(client_id=client_id)+ except models.Application.DoesNotExist as e:+ raise drf_exceptions.AuthenticationFailed("Invalid credentials") from e++ if not application.active:+ raise drf_exceptions.AuthenticationFailed("Application is inactive")++ if not check_password(client_secret, application.client_secret):+ raise drf_exceptions.AuthenticationFailed("Invalid credentials")++ email = serializer.validated_data["scope"]+ try:+ validate_email(email)+ except ValidationError:+ return drf_response.Response(+ {+ "error": "Scope should be a valid email address.",+ },+ status=drf_status.HTTP_400_BAD_REQUEST,+ )++ if not application.can_delegate_email(email):+ logger.warning(+ "Application %s denied delegation for %s",+ application.client_id,+ email,+ )+ return drf_response.Response(+ {+ "error": "This application is not authorized for this email domain.",+ },+ status=drf_status.HTTP_403_FORBIDDEN,+ )++ try:+ user = models.User.objects.get(email=email)+ except models.User.DoesNotExist as e:+ raise drf_exceptions.NotFound(+ {+ "error": "User not found.",+ }+ ) from e++ now = datetime.now(timezone.utc)+ scope = " ".join(application.scopes or [])++ payload = {+ "iss": settings.APPLICATION_JWT_ISSUER,+ "aud": settings.APPLICATION_JWT_AUDIENCE,+ "iat": now,+ "exp": now + timedelta(seconds=settings.APPLICATION_JWT_EXPIRATION_SECONDS),+ "client_id": client_id,+ "scope": scope,+ "user_id": str(user.id),+ "delegated": True,+ }++ token = jwt.encode(+ payload,+ settings.APPLICATION_JWT_SECRET_KEY,+ algorithm=settings.APPLICATION_JWT_ALG,+ )++ return drf_response.Response(+ {+ "access_token": token,+ "token_type": settings.APPLICATION_JWT_TOKEN_TYPE,+ "expires_in": settings.APPLICATION_JWT_EXPIRATION_SECONDS,+ "scope": scope,+ },+ status=drf_status.HTTP_200_OK,+ )diff --git a/src/backend/core/tests/test_external_api_token.py b/src/backend/core/tests/test_external_api_token.pynew file mode 100644index 00000000..e37ca179--- /dev/null+++ b/src/backend/core/tests/test_external_api_token.py@@ -0,0 +1,275 @@+"""+Tests for external API /token endpoint+"""++# pylint: disable=W0621++import jwt+import pytest+from freezegun import freeze_time+from rest_framework.test import APIClient++from core.factories import (+ ApplicationDomainFactory,+ ApplicationFactory,+ UserFactory,+)+from core.models import ApplicationScope++pytestmark = pytest.mark.django_db+++def test_api_applications_generate_token_success(settings):+ """Valid credentials should return a JWT token."""+ settings.APPLICATION_JWT_SECRET_KEY = "devKey"+ user = UserFactory(email="[email protected]")+ application = ApplicationFactory(+ 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/",+ {+ "client_id": application.client_id,+ "client_secret": plain_secret,+ "grant_type": "client_credentials",+ "scope": user.email,+ },+ format="json",+ )++ assert response.status_code == 200+ assert "access_token" in response.data++ response.data.pop("access_token")++ assert response.data == {+ "token_type": "Bearer",+ "expires_in": settings.APPLICATION_JWT_EXPIRATION_SECONDS,+ "scope": "rooms:list rooms:create",+ }+++def test_api_applications_generate_token_invalid_client_id():+ """Invalid client_id should return 401."""+ user = UserFactory(email="[email protected]")++ client = APIClient()+ response = client.post(+ "/external-api/v1.0/application/token/",+ {+ "client_id": "invalid-client-id",+ "client_secret": "some-secret",+ "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_invalid_client_secret():+ """Invalid client_secret should return 401."""+ user = UserFactory(email="[email protected]")+ application = ApplicationFactory(active=True)++ client = APIClient()+ response = client.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+ 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(active=False)++ plain_secret = "test-secret-123"+ application.client_secret = plain_secret+ application.save()++ client = APIClient()+ response = client.post(+ "/external-api/v1.0/application/token/",+ {+ "client_id": application.client_id,+ "client_secret": plain_secret,+ "grant_type": "client_credentials",+ "scope": user.email,+ },+ format="json",+ )++ assert response.status_code == 401+ assert "Application is inactive" in str(response.data)+++def test_api_applications_generate_token_invalid_email_format():+ """Invalid email format should return 400."""+ application = ApplicationFactory(active=True)++ plain_secret = "test-secret-123"+ application.client_secret = plain_secret+ application.save()++ client = APIClient()+ response = client.post(+ "/external-api/v1.0/application/token/",+ {+ "client_id": application.client_id,+ "client_secret": plain_secret,+ "grant_type": "client_credentials",+ "scope": "not-an-email",+ },+ format="json",+ )++ assert response.status_code == 400+ assert "scope should be a valid email address." in str(response.data).lower()+++def test_api_applications_generate_token_domain_not_authorized():+ """Application without domain authorization should return 403."""+ user = UserFactory(email="[email protected]")+ application = ApplicationFactory(active=True)+ 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/",+ {+ "client_id": application.client_id,+ "client_secret": plain_secret,+ "grant_type": "client_credentials",+ "scope": user.email,+ },+ format="json",+ )++ assert response.status_code == 403+ assert "not authorized for this email domain" in str(response.data)+++def test_api_applications_generate_token_domain_authorized(settings):+ """Application with domain authorization should succeed."""+ settings.APPLICATION_JWT_SECRET_KEY = "devKey"+ user = UserFactory(email="[email protected]")+ application = ApplicationFactory(+ 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/",+ {+ "client_id": application.client_id,+ "client_secret": plain_secret,+ "grant_type": "client_credentials",+ "scope": user.email,+ },+ format="json",+ )++ assert response.status_code == 200+ assert "access_token" in response.data+++def test_api_applications_generate_token_user_not_found():+ """Non-existent user should return 404."""+ application = ApplicationFactory(active=True)++ plain_secret = "test-secret-123"+ application.client_secret = plain_secret+ application.save()++ client = APIClient()+ response = client.post(+ "/external-api/v1.0/application/token/",+ {+ "client_id": application.client_id,+ "client_secret": plain_secret,+ "grant_type": "client_credentials",+ "scope": "[email protected]",+ },+ format="json",+ )++ assert response.status_code == 404+ assert "User not found" in str(response.data)+++@freeze_time("2023-01-15 12:00:00")+def test_api_applications_token_payload_structure(settings):+ """Generated token should have correct payload structure."""+ settings.APPLICATION_JWT_SECRET_KEY = "devKey"+ user = UserFactory(email="[email protected]")+ application = ApplicationFactory(+ 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/",+ {+ "client_id": application.client_id,+ "client_secret": plain_secret,+ "grant_type": "client_credentials",+ "scope": user.email,+ },+ format="json",+ )++ # Decode token to verify payload+ token = response.data["access_token"]+ payload = jwt.decode(+ token,+ settings.APPLICATION_JWT_SECRET_KEY,+ algorithms=[settings.APPLICATION_JWT_ALG],+ issuer=settings.APPLICATION_JWT_ISSUER,+ audience=settings.APPLICATION_JWT_AUDIENCE,+ )++ assert payload == {+ "iss": settings.APPLICATION_JWT_ISSUER,+ "aud": settings.APPLICATION_JWT_AUDIENCE,+ "client_id": application.client_id,+ "exp": 1673787600,+ "iat": 1673784000,+ "user_id": str(user.id),+ "delegated": True,+ "scope": "rooms:list rooms:create",+ }diff --git a/src/backend/core/urls.py b/src/backend/core/urls.pyindex 13236d3c..6603e393 100644--- a/src/backend/core/urls.py+++ b/src/backend/core/urls.py@@ -7,6 +7,7 @@ from lasuite.oidc_login.urls import urlpatterns as oidc_urlsfrom rest_framework.routers import DefaultRouterfrom core.api import get_frontend_configuration, viewsets+from core.external_api import viewsets as external_viewsets# - Main endpointsrouter = DefaultRouter()@@ -19,6 +20,11 @@ router.register(# - External APIexternal_router = DefaultRouter()+external_router.register(+ "application",+ external_viewsets.ApplicationViewSet,+ basename="external_application",+)urlpatterns = [path(diff --git a/src/backend/meet/settings.py b/src/backend/meet/settings.pyindex be552570..cea40dff 100755--- a/src/backend/meet/settings.py+++ b/src/backend/meet/settings.py@@ -676,6 +676,34 @@ class Base(Configuration):environ_name="APPLICATION_CLIENT_SECRET_LENGTH",environ_prefix=None,)+ APPLICATION_JWT_SECRET_KEY = SecretFileValue(+ None, environ_name="APPLICATION_JWT_SECRET_KEY", environ_prefix=None+ )+ APPLICATION_JWT_ALG = values.Value(+ "HS256",+ environ_name="APPLICATION_JWT_ALG",+ environ_prefix=None,+ )+ APPLICATION_JWT_ISSUER = values.Value(+ "lasuite-meet",+ environ_name="APPLICATION_JWT_ISSUER",+ environ_prefix=None,+ )+ APPLICATION_JWT_AUDIENCE = values.Value(+ None,+ environ_name="APPLICATION_JWT_AUDIENCE",+ environ_prefix=None,+ )+ APPLICATION_JWT_EXPIRATION_SECONDS = values.PositiveIntegerValue(+ 3600,+ environ_name="APPLICATION_JWT_EXPIRATION_SECONDS",+ environ_prefix=None,+ )+ APPLICATION_JWT_TOKEN_TYPE = values.Value(+ "Bearer",+ environ_name="APPLICATION_JWT_TOKEN_TYPE",+ environ_prefix=None,+ )# pylint: disable=invalid-name@property