Open source video conferencing app powered by LiveKit. Built with Django and React.
🔒️(backend) issue room access tokens via a POST join endpoint
briquet4e953da22682
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 836ee41d..56181412 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -22,6 +22,7 @@ and this project adheres to- ⬆️(backend) update python dependencies- ⬆️(agents) update python dependencies- ⬆️(summary) update python dependencies+- 🔒️(backend) issue room access tokens via POST rooms/{id}/join/ only### Fixeddiff --git a/UPGRADE.md b/UPGRADE.mdindex 6854fe5c..71d274a9 100644--- a/UPGRADE.md+++ b/UPGRADE.md@@ -16,6 +16,24 @@ the following command inside your docker container:## [Unreleased]++### Room access tokens moved to POST /join/++LiveKit access tokens are no longer returned when reading a room. They are henceforth issued by a dedicated `POST+/api/v1.0/rooms/{id}/join/` endpoint, which receives the display name in its JSON body. Display names therefore no+longer appear in URLs and token retrieval by logged-in users is now protected against CSRF.++- `GET /api/v1.0/rooms/{id}/` no longer returns the `livekit` block, and neither do the list, create and update+responses+- The `username` field of `POST /api/v1.0/rooms/{id}/request-entry/` is now limited to 255 characters+- When the caller may enter the room directly, the response contains the room data plus a `livekit` block+- When the caller must go through the lobby, the response has no `livekit` block+- Session-authenticated callers must send the CSRF token (`X-CSRFToken` header and `csrftoken` cookie)+- Every join returning a `livekit` block mints a new token, valid for 6 hours, and anonymous callers get a new+participant identity each time.+- Joining again returns no `livekit` block to callers admitted through the lobby.+- Unregistered rooms are always entered directly: joining one always returns a `livekit` block.+## v1.37.0### Crisp support chat replaced by the La Suite support formdiff --git a/src/backend/core/api/serializers.py b/src/backend/core/api/serializers.pyindex 8bbf89b8..6357332a 100644--- a/src/backend/core/api/serializers.py+++ b/src/backend/core/api/serializers.py@@ -27,9 +27,12 @@ from timezone_field.rest_framework import TimeZoneSerializerFieldfrom core import models, utilsfrom core.api.exceptions import ensure_room_not_deleted+from core.services.lobby import LobbyServicelogger = logging.getLogger(__name__)+DISPLAY_NAME_MAX_LENGTH = 255+class UserSerializer(serializers.ModelSerializer):"""Serialize users."""@@ -170,17 +173,18 @@ class RoomSerializer(serializers.ModelSerializer):return valuedef to_representation(self, instance):- """- Add users only for administrator users.- Add LiveKit credentials for public instance or related users/groups- """+ """Add accesses only for administrator and owner users."""output = super().to_representation(instance)request = self.context.get("request")if not request:return output- role = instance.get_role(request.user)+ if "role" in self.context:+ role = self.context["role"]+ else:+ role = instance.get_role(request.user)+is_admin_or_owner = models.RoleChoices.check_administrator_role(role) or models.RoleChoices.check_owner_role(role)@@ -193,26 +197,9 @@ class RoomSerializer(serializers.ModelSerializer):)output["accesses"] = access_serializer.data- should_access_room = (- (- instance.access_level == models.RoomAccessLevel.TRUSTED- and request.user.is_authenticated- )- or role is not None- or instance.is_public- )-- if should_access_room:- room_id = f"{instance.id!s}"- username = request.query_params.get("username", None)- output["livekit"] = utils.generate_livekit_config(- room_id=room_id,- user=request.user,- username=username,- configuration=output["configuration"],- role=role,- )- else:+ if not LobbyService.can_bypass_lobby(+ room=instance, user=request.user, role=role+ ):del output["pin_code"]return output@@ -355,10 +342,23 @@ class StartRecordingSerializer(BaseValidationOnlySerializer):return value+class JoinRoomSerializer(BaseValidationOnlySerializer):+ """Validate the data sent to join a room."""++ username = serializers.CharField(+ required=False,+ allow_blank=True,+ allow_null=True,+ max_length=DISPLAY_NAME_MAX_LENGTH,+ help_text="Display name in the room. The default name is used when it "+ "is missing, null or blank.",+ )++class RequestEntrySerializer(BaseValidationOnlySerializer):"""Validate request entry data."""- username = serializers.CharField(required=True)+ username = serializers.CharField(required=True, max_length=DISPLAY_NAME_MAX_LENGTH)participant_id = serializers.CharField(required=False, allow_null=True, max_length=128)@@ -675,7 +675,9 @@ class RaiseHandSerializer(BaseValidationOnlySerializer):class RenameParticipantSerializer(BaseValidationOnlySerializer):"""Serializer for renaming a participant in a room."""- name = serializers.CharField(min_length=1, max_length=255, allow_blank=False)+ name = serializers.CharField(+ min_length=1, max_length=DISPLAY_NAME_MAX_LENGTH, allow_blank=False+ )class ExternalProcessEventSerializer(BaseValidationOnlySerializer):diff --git a/src/backend/core/api/viewsets.py b/src/backend/core/api/viewsets.pyindex 97fee504..75c6aa38 100644--- a/src/backend/core/api/viewsets.py+++ b/src/backend/core/api/viewsets.py@@ -309,35 +309,36 @@ class RoomViewSet( # pylint: disable=too-many-public-methodsensure_room_not_deleted(obj)return obj+ def _get_object_or_unregistered_slug(self):+ """Return the requested room, or the slug of an unregistered room."""+ try:+ return self.get_object(), None+ except Http404:+ slug = slugify(self.kwargs["pk"])+ if not settings.ALLOW_UNREGISTERED_ROOMS or not slug:+ raise+ return None, slug++ @staticmethod+ def _get_unregistered_room_data(slug):+ """Describe an unregistered room, which only exists by its slug."""+ return {+ "id": None,+ "slug": slug,+ "is_administrable": False,+ "access_level": RoomAccessLevel.PUBLIC,+ }+def retrieve(self, request, *args, **kwargs):"""Allow unregistered rooms when activated.- For unregistered rooms we only return a null id and the livekit room and token.+ LiveKit credentials are never returned: they are obtained by joining."""- try:- instance = self.get_object()- except Http404:- if not settings.ALLOW_UNREGISTERED_ROOMS:- raise- slug = slugify(self.kwargs["pk"])- username = request.query_params.get("username", None)- data = {- "id": None,- "slug": slug,- "is_administrable": False,- "access_level": RoomAccessLevel.PUBLIC,- "livekit": {- "url": settings.LIVEKIT_CONFIGURATION["url"],- "room": slug,- "token": utils.generate_token(- room=slug, user=request.user, username=username- ),- },- }- else:- data = self.get_serializer(instance).data+ room, slug = self._get_object_or_unregistered_slug()+ if room is None:+ return drf_response.Response(self._get_unregistered_room_data(slug))- return drf_response.Response(data)+ return drf_response.Response(self.get_serializer(room).data)def list(self, request, *args, **kwargs):"""Limit listed rooms to the ones related to the authenticated user."""@@ -572,6 +573,55 @@ class RoomViewSet( # pylint: disable=too-many-public-methods{"message": f"Recording stopped for room {room.slug}."})+ @decorators.action(+ detail=True,+ methods=["post"],+ url_path="join",+ permission_classes=[],+ )+ def join(self, request, pk=None): # pylint: disable=unused-argument+ """+ Join a room, getting LiveKit credentials when allowed to enter directly.++ The response contains the room with a livekit object holding the url,+ room and token to connect with when the requester may enter without+ going through the lobby. Otherwise, it has no livekit object and the+ client should request entry through the lobby.++ Unregistered rooms, when allowed, are always joined directly.+ """++ serializer = serializers.JoinRoomSerializer(data=request.data)+ serializer.is_valid(raise_exception=True)+ username = serializer.validated_data.get("username") or None++ room, slug = self._get_object_or_unregistered_slug()+ if room is None:+ return drf_response.Response(+ {+ **self._get_unregistered_room_data(slug),+ "livekit": utils.generate_livekit_config(+ room_id=slug, user=request.user, username=username+ ),+ }+ )++ role = room.get_role(request.user)+ data = self.get_serializer(+ room, context={**self.get_serializer_context(), "role": role}+ ).data++ if LobbyService.can_bypass_lobby(room=room, user=request.user, role=role):+ data["livekit"] = utils.generate_livekit_config(+ room_id=str(room.id),+ user=request.user,+ username=username,+ configuration=data["configuration"],+ role=role,+ )++ return drf_response.Response(data)+@decorators.action(detail=True,methods=["post"],diff --git a/src/backend/core/tests/rooms/test_api_rooms_create.py b/src/backend/core/tests/rooms/test_api_rooms_create.pyindex 51ac78d2..ff0a5d58 100644--- a/src/backend/core/tests/rooms/test_api_rooms_create.py+++ b/src/backend/core/tests/rooms/test_api_rooms_create.py@@ -66,6 +66,8 @@ def test_api_rooms_create_authenticated(reset_cache):assert room.name == "my room"assert room.slug == "my-room"assert room.accesses.filter(role="owner", user=user).exists() is True+ assert "livekit" not in response.json()+ assert response.json()["pin_code"] == room.pin_coderooms_data = cache.keys("room-creation-callback_*")assert not rooms_data@@ -495,3 +497,4 @@ def test_api_rooms_create_authenticated_with_user_access_token():assert response.status_code == 201room = Room.objects.get()assert room.accesses.filter(role="owner", user=user).exists()+ assert "livekit" not in response.json()diff --git a/src/backend/core/tests/rooms/test_api_rooms_join.py b/src/backend/core/tests/rooms/test_api_rooms_join.pynew file mode 100644index 00000000..a52a1818--- /dev/null+++ b/src/backend/core/tests/rooms/test_api_rooms_join.py@@ -0,0 +1,558 @@+"""+Test rooms API endpoints in the Meet core app: join.+"""++# pylint: disable=redefined-outer-name++from unittest import mock++from django.conf import settings+from django.contrib.auth.models import AnonymousUser+from django.utils.crypto import get_random_string++import jwt+import pytest+from faker import Faker+from rest_framework.test import APIClient++from ...factories import (+ RoomFactory,+ UserFactory,+ UserResourceAccessFactory,+)+from ...models import RoleChoices, RoomAccessLevel+from ..utils import generate_user_access_token++fake = Faker()+pytestmark = pytest.mark.django_db++livekit_token = fake.sha256()++ANONYMOUS = "anonymous"+NO_ROLE = "no-role"++# Who may join a room directly, without going through the lobby+# room.get_role(user) returns None both for an anonymous user and for an+# authenticated user without access, hence the NO_ROLE+ACCESS_MATRIX = [+ (RoomAccessLevel.PUBLIC, ANONYMOUS, True),+ (RoomAccessLevel.TRUSTED, ANONYMOUS, False),+ (RoomAccessLevel.RESTRICTED, ANONYMOUS, False),+ (RoomAccessLevel.PUBLIC, NO_ROLE, True),+ (RoomAccessLevel.TRUSTED, NO_ROLE, True),+ (RoomAccessLevel.RESTRICTED, NO_ROLE, False),+ *[+ (access_level, role, True)+ for access_level in RoomAccessLevel+ for role in RoleChoices+ ],+]+++def decode_token(token):+ """Decode a LiveKit access token for inspection."""+ return jwt.decode(+ token,+ settings.LIVEKIT_CONFIGURATION["api_secret"],+ algorithms=["HS256"],+ )+++def join_url(room_id):+ """Return the url to join a room."""+ return f"/api/v1.0/rooms/{room_id!s}/join/"+++ ("access_level", "requester", "can_join_directly"), ACCESS_MATRIX+)[email protected]("core.utils.generate_token", return_value=livekit_token)+def test_api_rooms_join_access(mock_token, access_level, requester, can_join_directly):+ """+ Joining a room should return LiveKit credentials and the pin code only to+ users who may enter without going through the lobby, and the accesses+ only to the room's administrators and owners.+ """+ room = RoomFactory(+ access_level=access_level,+ configuration={"can_publish_sources": ["camera"]},+ )+ client = APIClient()+ user = AnonymousUser()+ username = fake.user_name()++ role = None+ if requester != ANONYMOUS:+ user = UserFactory()+ client.force_login(user)+ if requester != NO_ROLE:+ role = requester+ UserResourceAccessFactory(resource=room, user=user, role=role)++ response = client.post(join_url(room.id), {"username": username}, format="json")++ assert response.status_code == 200+ content = response.json()++ accesses = content.pop("accesses", None)++ if role in (RoleChoices.ADMIN, RoleChoices.OWNER):+ assert {access["id"] for access in accesses} == {+ str(access.id) for access in room.accesses.all()+ }+ else:+ assert accesses is None++ expected = {+ "id": str(room.id),+ "name": room.name,+ "slug": room.slug,+ "configuration": {"can_publish_sources": ["camera"]},+ "access_level": str(access_level),+ }+ if can_join_directly:+ expected["pin_code"] = room.pin_code+ expected["livekit"] = {+ "url": settings.LIVEKIT_CONFIGURATION["url"],+ "room": str(room.id),+ "token": livekit_token,+ }+ assert content == expected++ if can_join_directly:+ mock_token.assert_called_once_with(+ room=str(room.id),+ user=user,+ username=username,+ color=None,+ sources=["camera"],+ role=role,+ participant_id=None,+ )+ else:+ mock_token.assert_not_called()++[email protected]("core.utils.generate_token", return_value=livekit_token)+def test_api_rooms_join_by_slug(mock_token):+ """It should be possible to join a room by its slug, not normalized."""+ room = RoomFactory(name="Réunion", access_level=RoomAccessLevel.PUBLIC)++ response = APIClient().post(join_url("Réunion"), {}, format="json")++ assert response.status_code == 200+ assert response.json()["id"] == str(room.id)+ assert response.json()["livekit"]["room"] == str(room.id)+ mock_token.assert_called_once()++[email protected]("core.utils.generate_token", return_value=livekit_token)+def test_api_rooms_join_members_num_queries(mock_token, django_assert_num_queries):+ """The role of the requester should only be looked up once."""+ user = UserFactory()+ room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)+ UserResourceAccessFactory(resource=room, user=user, role=RoleChoices.MEMBER)+ client = APIClient()+ client.force_login(user)++ with django_assert_num_queries(3):+ response = client.post(join_url(room.id), {}, format="json")++ assert response.status_code == 200+ assert "livekit" in response.json()+ assert mock_token.call_args.kwargs["role"] == RoleChoices.MEMBER++[email protected]("role", [RoleChoices.ADMIN, RoleChoices.OWNER])[email protected]("core.utils.generate_token", return_value=livekit_token)+def test_api_rooms_join_administrators_num_queries(+ mock_token, role, django_assert_num_queries+):+ """Only the accesses should be queried on top of the role for administrators."""+ user = UserFactory()+ room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)+ UserResourceAccessFactory(resource=room, user=user, role=role)+ client = APIClient()+ client.force_login(user)++ with django_assert_num_queries(4):+ response = client.post(join_url(room.id), {}, format="json")++ assert response.status_code == 200+ assert "livekit" in response.json()+ assert "accesses" in response.json()+ assert mock_token.call_args.kwargs["role"] == role+++def test_api_rooms_join_get_not_allowed():+ """Joining a room should only be possible with a POST request."""+ room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)++ response = APIClient().get(join_url(room.id))++ assert response.status_code == 405++[email protected]("authenticated", [False, True])[email protected]("core.utils.generate_token", return_value=livekit_token)+def test_api_rooms_join_unregistered_allowed(mock_token, authenticated, settings):+ """+ Joining an unregistered room should return LiveKit credentials for the+ room named after the slug, when unregistered rooms are allowed.+ """+ settings.ALLOW_UNREGISTERED_ROOMS = True+ client = APIClient()+ user = AnonymousUser()+ username = fake.user_name()+ if authenticated:+ user = UserFactory()+ client.force_login(user)++ response = client.post(+ join_url("unregistered-room"), {"username": username}, format="json"+ )++ assert response.status_code == 200+ assert response.json() == {+ "id": None,+ "slug": "unregistered-room",+ "access_level": "public",+ "is_administrable": False,+ "livekit": {+ "url": settings.LIVEKIT_CONFIGURATION["url"],+ "room": "unregistered-room",+ "token": livekit_token,+ },+ }+ mock_token.assert_called_once_with(+ room="unregistered-room",+ user=user,+ username=username,+ color=None,+ sources=None,+ role=None,+ participant_id=None,+ )++[email protected]("core.utils.generate_token", return_value=livekit_token)+def test_api_rooms_join_unregistered_allowed_not_normalized(mock_token, settings):+ """+ Joining an unregistered room by a slug that is not normalized should use+ the LiveKit room named after the url-safe slug.+ """+ settings.ALLOW_UNREGISTERED_ROOMS = True++ response = APIClient().post(join_url("Réunion"), {}, format="json")++ assert response.status_code == 200+ assert response.json() == {+ "id": None,+ "slug": "reunion",+ "access_level": "public",+ "is_administrable": False,+ "livekit": {+ "url": settings.LIVEKIT_CONFIGURATION["url"],+ "room": "reunion",+ "token": livekit_token,+ },+ }+ mock_token.assert_called_once_with(+ room="reunion",+ user=AnonymousUser(),+ username=None,+ color=None,+ sources=None,+ role=None,+ participant_id=None,+ )+++def test_api_rooms_join_unregistered_token_claims(settings):+ """The token of an unregistered room should be scoped to it and carry the name."""+ settings.ALLOW_UNREGISTERED_ROOMS = True+ username = fake.user_name()++ response = APIClient().post(+ join_url("unregistered-room"), {"username": username}, format="json"+ )++ assert response.status_code == 200+ claims = decode_token(response.json()["livekit"]["token"])+ assert claims["name"] == username+ assert claims["video"]["room"] == "unregistered-room"++[email protected]("core.utils.generate_token", return_value=livekit_token)+def test_api_rooms_join_unregistered_not_allowed(mock_token, settings):+ """+ Joining an unregistered room should return a 404 if unregistered rooms+ are not allowed.+ """+ settings.ALLOW_UNREGISTERED_ROOMS = False++ response = APIClient().post(join_url("unregistered-room"), {}, format="json")++ assert response.status_code == 404+ assert response.json() == {"detail": "No Room matches the given query."}+ mock_token.assert_not_called()++[email protected]("lookup", ["---", "!!!", "_"])[email protected]("core.utils.generate_token", return_value=livekit_token)+def test_api_rooms_join_unregistered_empty_slug(mock_token, lookup, settings):+ """+ Joining an unregistered room whose slug is empty once normalized should+ return a 404 rather than credentials for a room with no name.+ """+ settings.ALLOW_UNREGISTERED_ROOMS = True++ response = APIClient().post(join_url(lookup), {}, format="json")++ assert response.status_code == 404+ assert response.json() == {"detail": "No Room matches the given query."}+ mock_token.assert_not_called()++[email protected]("allow_unregistered_rooms", [True, False])[email protected]("lookup", ["id", "slug"])[email protected]("core.utils.generate_token", return_value=livekit_token)+def test_api_rooms_join_soft_deleted(+ mock_token, lookup, allow_unregistered_rooms, settings+):+ """+ Joining a soft-deleted room should return a 410, and never fall back+ to an unregistered room with the same slug.+ """+ settings.ALLOW_UNREGISTERED_ROOMS = allow_unregistered_rooms+ room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)+ room.soft_delete()++ response = APIClient().post(join_url(getattr(room, lookup)), {}, format="json")++ assert response.status_code == 410+ assert response.json() == {"detail": "This room has been deleted."}+ mock_token.assert_not_called()+++ ("payload", "expected_username"),+ [+ ({"username": "Jean Bon"}, "Jean Bon"),+ ({"username": " Jean Bon "}, "Jean Bon"),+ ({"username": "x" * 255}, "x" * 255),+ ({}, None),+ ({"username": None}, None),+ ({"username": ""}, None),+ ({"username": " "}, None),+ ],+)[email protected]("core.utils.generate_token", return_value=livekit_token)+def test_api_rooms_join_username(mock_token, payload, expected_username):+ """+ The trimmed display name should be passed on to the token, a missing or+ blank one leaving the default name to the token generation.+ """+ room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)++ response = APIClient().post(join_url(room.id), payload, format="json")++ assert response.status_code == 200+ assert response.json()["livekit"]["token"] == livekit_token+ assert mock_token.call_args.kwargs["username"] == expected_username++[email protected]("core.utils.generate_token", return_value=livekit_token)+def test_api_rooms_join_username_too_long(mock_token):+ """A display name exceeding 255 characters should be rejected."""+ room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)++ response = APIClient().post(+ join_url(room.id), {"username": "a" * 256}, format="json"+ )++ assert response.status_code == 400+ assert response.json() == {+ "username": ["Ensure this field has no more than 255 characters."]+ }+ mock_token.assert_not_called()++[email protected]("core.utils.generate_token", return_value=livekit_token)+def test_api_rooms_join_username_in_query_string_ignored(mock_token):+ """The display name should only be read from the request body."""+ room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)+ username = fake.user_name()++ response = APIClient().post(+ f"{join_url(room.id)}?username={username}", {}, format="json"+ )++ assert response.status_code == 200+ assert mock_token.call_args.kwargs["username"] is None+++def test_api_rooms_join_token_claims_anonymous():+ """The token should carry the submitted display name and be scoped to the room."""+ room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)+ username = fake.user_name()++ response = APIClient().post(+ join_url(room.id), {"username": username}, format="json"+ )++ assert response.status_code == 200+ claims = decode_token(response.json()["livekit"]["token"])+ assert claims["name"] == username+ assert claims["video"]["room"] == str(room.id)+ assert claims["video"]["roomAdmin"] is False+++def test_api_rooms_join_token_claims_anonymous_default_name():+ """An anonymous user joining without a display name should get the default one."""+ room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)++ response = APIClient().post(join_url(room.id), {"username": ""}, format="json")++ assert response.status_code == 200+ claims = decode_token(response.json()["livekit"]["token"])+ assert claims["name"] == "Anonymous"+++def test_api_rooms_join_token_claims_owner():+ """The token of an owner should carry the submitted name and the room admin grant."""+ username = fake.user_name()+ user = UserFactory(full_name=fake.name())+ room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, users=[(user, "owner")])+ client = APIClient()+ client.force_login(user)++ response = client.post(join_url(room.id), {"username": username}, format="json")++ assert response.status_code == 200+ claims = decode_token(response.json()["livekit"]["token"])+ assert claims["name"] == username+ assert claims["sub"] == str(user.sub)+ assert claims["video"]["roomAdmin"] is True+++def test_api_rooms_join_display_name_edit_disabled(settings):+ """+ An authenticated user should keep their account's name when display name+ edition is disabled, whatever name they submit.+ """+ settings.AUTHENTICATED_PARTICIPANTS_CAN_EDIT_DISPLAY_NAME = False+ full_name = f"{fake.first_name()} {fake.last_name()}"+ user = UserFactory(full_name=full_name)+ room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)+ client = APIClient()+ client.force_login(user)++ response = client.post(join_url(room.id), {"username": "Impostor"}, format="json")++ assert response.status_code == 200+ claims = decode_token(response.json()["livekit"]["token"])+ assert claims["name"] == full_name+++def test_api_rooms_join_display_name_edit_disabled_anonymous(settings):+ """Anonymous users should still choose their display name when edition is disabled."""+ settings.AUTHENTICATED_PARTICIPANTS_CAN_EDIT_DISPLAY_NAME = False+ username = fake.user_name()+ room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)++ response = APIClient().post(+ join_url(room.id), {"username": username}, format="json"+ )++ assert response.status_code == 200+ claims = decode_token(response.json()["livekit"]["token"])+ assert claims["name"] == username+++def test_api_rooms_join_session_without_csrf_token():+ """A session-authenticated request without a CSRF token should be rejected."""+ user = UserFactory()+ room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)+ client = APIClient(enforce_csrf_checks=True)+ client.force_login(user)++ response = client.post(join_url(room.id), {"username": "Jane"}, format="json")++ assert response.status_code == 403+ assert response.json()["detail"].startswith("CSRF Failed")+++def test_api_rooms_join_session_with_csrf_token():+ """A session-authenticated request with a valid CSRF token should be accepted."""+ user = UserFactory()+ room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)+ client = APIClient(enforce_csrf_checks=True)+ client.force_login(user)+ csrf_secret = get_random_string(32)+ client.cookies[settings.CSRF_COOKIE_NAME] = csrf_secret++ response = client.post(+ join_url(room.id),+ {"username": "Jane"},+ format="json",+ HTTP_X_CSRFTOKEN=csrf_secret,+ )++ assert response.status_code == 200+ assert "livekit" in response.json()+++def test_api_rooms_join_session_with_csrf_token_foreign_origin():+ """A session-authenticated request from a foreign origin should be rejected."""+ user = UserFactory()+ room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)+ client = APIClient(enforce_csrf_checks=True)+ client.force_login(user)+ csrf_secret = get_random_string(32)+ client.cookies[settings.CSRF_COOKIE_NAME] = csrf_secret++ response = client.post(+ join_url(room.id),+ {"username": "Jane"},+ format="json",+ HTTP_X_CSRFTOKEN=csrf_secret,+ HTTP_ORIGIN="https://evil.example",+ )++ assert response.status_code == 403+ assert response.json()["detail"].startswith("CSRF Failed: Origin checking failed")+++def test_api_rooms_join_anonymous_without_csrf_token():+ """+ An anonymous request carries no ambient credential, so it should not be+ subject to CSRF checks.+ """+ room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)+ client = APIClient(enforce_csrf_checks=True)++ response = client.post(join_url(room.id), {"username": "Anonymous"}, format="json")++ assert response.status_code == 200+ assert "livekit" in response.json()+++def test_api_rooms_join_user_access_token_without_csrf_token():+ """+ A request authenticated with a user access token carries no ambient+ credential, so it should not be subject to CSRF checks.+ """+ username = fake.user_name()+ user = UserFactory()+ room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED, users=[(user, "owner")])+ client = APIClient(enforce_csrf_checks=True)+ client.credentials(HTTP_AUTHORIZATION=f"Bearer {generate_user_access_token(user)}")++ response = client.post(join_url(room.id), {"username": username}, format="json")++ assert response.status_code == 200+ assert response.json()["pin_code"] == room.pin_code+ assert "accesses" in response.json()+ claims = decode_token(response.json()["livekit"]["token"])+ assert claims["sub"] == str(user.sub)diff --git a/src/backend/core/tests/rooms/test_api_rooms_list.py b/src/backend/core/tests/rooms/test_api_rooms_list.pyindex 87af67f2..bfa8ca28 100644--- a/src/backend/core/tests/rooms/test_api_rooms_list.py+++ b/src/backend/core/tests/rooms/test_api_rooms_list.py@@ -61,6 +61,7 @@ def test_api_rooms_list_authenticated():}results_id = {result["id"] for result in results}assert expected_ids == results_id+ assert all("livekit" not in result for result in results)@mock.patch.object(PageNumberPagination, "get_page_size", return_value=2)@@ -172,3 +173,4 @@ def test_api_rooms_list_authenticated_with_user_access_token():assert response.status_code == 200assert response.data["count"] == 1assert response.data["results"][0]["id"] == str(room.id)+ assert "livekit" not in response.data["results"][0]diff --git a/src/backend/core/tests/rooms/test_api_rooms_lobby.py b/src/backend/core/tests/rooms/test_api_rooms_lobby.pyindex 5027fb7e..75e41b10 100644--- a/src/backend/core/tests/rooms/test_api_rooms_lobby.py+++ b/src/backend/core/tests/rooms/test_api_rooms_lobby.py@@ -2,7 +2,7 @@Test rooms API endpoints in the Meet core app: lobby functionality."""-# pylint: disable=W0621,W0613,W0212+# pylint: disable=W0621,W0613,W0212,too-many-linesimport uuidfrom unittest import mock@@ -360,6 +360,40 @@ def test_request_entry_invalid_data():assert response.status_code == 400+def test_request_entry_username_too_long():+ """Should return 400 for a username exceeding 255 characters."""+ room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)+ client = APIClient()++ with mock.patch.object(utils, "notify_participants") as mock_notify:+ response = client.post(+ f"/api/v1.0/rooms/{room.id}/request-entry/",+ {"username": "a" * 256},+ )++ assert response.status_code == 400+ assert response.json() == {+ "username": ["Ensure this field has no more than 255 characters."]+ }+ mock_notify.assert_not_called()+ assert not LobbyService()._index_members(room.id)+++def test_request_entry_username_at_max_length():+ """Should accept a username of exactly 255 characters."""+ room = RoomFactory(access_level=RoomAccessLevel.RESTRICTED)+ client = APIClient()++ with mock.patch.object(utils, "notify_participants", return_value=None):+ response = client.post(+ f"/api/v1.0/rooms/{room.id}/request-entry/",+ {"username": "a" * 255},+ )++ assert response.status_code == 200+ assert response.json()["username"] == "a" * 255++def test_request_entry_room_not_found():"""Should return 404 for non-existent room."""client = APIClient()diff --git a/src/backend/core/tests/rooms/test_api_rooms_rename_toggle.py b/src/backend/core/tests/rooms/test_api_rooms_rename_toggle.pyindex dfbb297f..54969857 100644--- a/src/backend/core/tests/rooms/test_api_rooms_rename_toggle.py+++ b/src/backend/core/tests/rooms/test_api_rooms_rename_toggle.py@@ -366,6 +366,22 @@ def test_rename_participant_name_too_long(room, token):assert "name" in response.data+def test_rename_participant_name_at_max_length(mock_livekit_client, room, token):+ """Test rename accepts a name of exactly 255 characters."""+ client = APIClient()+ url = reverse("rooms-rename", kwargs={"pk": room.id})+ response = client.post(+ url,+ {"name": "a" * 255},+ format="json",+ HTTP_AUTHORIZATION=f"X-LiveKit-Token {token}",+ )++ assert response.status_code == status.HTTP_200_OK+ call_kwargs = mock_livekit_client.room.update_participant.call_args+ assert call_kwargs[0][0].name == "a" * 255++def test_rename_participant_forbidden_without_token(room):"""Test rename returns 403 when no LiveKit token is provided."""client = APIClient()diff --git a/src/backend/core/tests/rooms/test_api_rooms_retrieve.py b/src/backend/core/tests/rooms/test_api_rooms_retrieve.pyindex f7efe561..3621be75 100644--- a/src/backend/core/tests/rooms/test_api_rooms_retrieve.py+++ b/src/backend/core/tests/rooms/test_api_rooms_retrieve.py@@ -1,11 +1,8 @@-"""-Test rooms API endpoints in the Meet core app: retrieve.-"""+"""Test rooms API endpoints in the Meet core app: retrieve."""import randomfrom unittest import mock-from django.contrib.auth.models import AnonymousUserfrom django.test.utils import override_settingsfrom django.utils import timezone as dj_timezone@@ -112,18 +109,11 @@ def test_api_rooms_retrieve_anonymous_private_slug_not_normalized():@override_settings(ALLOW_UNREGISTERED_ROOMS=True)-@override_settings(- LIVEKIT_CONFIGURATION={- "api_key": "key",- "api_secret": "secret",- "url": "test_url_value",- }-)@mock.patch("core.utils.generate_token", return_value="foo")def test_api_rooms_retrieve_anonymous_unregistered_allowed(mock_token):"""- Retrieving an unregistered room should return a Livekit token- if unregistered rooms are allowed.+ Retrieving an unregistered room should describe it if unregistered rooms+ are allowed, without any LiveKit token: those are obtained by joining."""client = APIClient()response = client.get("/api/v1.0/rooms/unregistered-room/")@@ -134,31 +124,17 @@ def test_api_rooms_retrieve_anonymous_unregistered_allowed(mock_token):"slug": "unregistered-room","access_level": "public","is_administrable": False,- "livekit": {- "url": "test_url_value",- "room": "unregistered-room",- "token": "foo",- },}- mock_token.assert_called_once_with(- room="unregistered-room", user=AnonymousUser(), username=None- )+ mock_token.assert_not_called()@override_settings(ALLOW_UNREGISTERED_ROOMS=True)-@override_settings(- LIVEKIT_CONFIGURATION={- "api_key": "key",- "api_secret": "secret",- "url": "test_url_value",- }-)@mock.patch("core.utils.generate_token", return_value="foo")def test_api_rooms_retrieve_anonymous_unregistered_allowed_not_normalized(mock_token):"""Getting an unregistered room by a slug that is not normalized should work- and use the Livekit room on the url-safe name.+ and return the url-safe slug."""client = APIClient()response = client.get("/api/v1.0/rooms/Réunion/")@@ -169,16 +145,9 @@ def test_api_rooms_retrieve_anonymous_unregistered_allowed_not_normalized(mock_t"slug": "reunion","access_level": "public","is_administrable": False,- "livekit": {- "url": "test_url_value",- "room": "reunion",- "token": "foo",- },}- mock_token.assert_called_once_with(- room="reunion", user=AnonymousUser(), username=None- )+ mock_token.assert_not_called()@override_settings(ALLOW_UNREGISTERED_ROOMS=False)@@ -193,6 +162,20 @@ def test_api_rooms_retrieve_anonymous_unregistered_not_allowed():assert response.json() == {"detail": "No Room matches the given query."}+@override_settings(ALLOW_UNREGISTERED_ROOMS=True)[email protected]("lookup", ["---", "!!!", "_"])+def test_api_rooms_retrieve_anonymous_unregistered_empty_slug(lookup):+ """+ Retrieving an unregistered room whose slug is empty once normalized should+ return a 404.+ """+ client = APIClient()+ response = client.get(f"/api/v1.0/rooms/{lookup}/")++ assert response.status_code == 404+ assert response.json() == {"detail": "No Room matches the given query."}++@pytest.mark.parametrize("allow_unregistered_rooms", [True, False])@pytest.mark.parametrize("lookup", ["id", "slug"])@mock.patch("core.utils.generate_token", return_value="foo")@@ -216,52 +199,33 @@ def test_api_rooms_retrieve_soft_deleted(@mock.patch("core.utils.generate_token", return_value="foo")-@override_settings(- LIVEKIT_CONFIGURATION={- "api_key": "key",- "api_secret": "secret",- "url": "test_url_value",- }-)def test_api_rooms_retrieve_anonymous_public(mock_token):"""- Anonymous users should be able to retrieve a room with a token provided, if the room is public.+ Anonymous users should be able to retrieve a public room with its pin code,+ but should not be given any token: those are obtained by joining."""room = RoomFactory(access_level=RoomAccessLevel.PUBLIC)client = APIClient()response = client.get(f"/api/v1.0/rooms/{room.id!s}/")assert response.status_code == 200- expected_name = f"{room.id!s}"assert response.json() == {"configuration": {},"access_level": str(room.access_level),"id": str(room.id),- "livekit": {- "url": "test_url_value",- "room": expected_name,- "token": "foo",- },"name": room.name,"pin_code": room.pin_code,"slug": room.slug,}- mock_token.assert_called_once()+ mock_token.assert_not_called()@mock.patch("core.utils.generate_token", return_value="foo")-@override_settings(- LIVEKIT_CONFIGURATION={- "api_key": "key",- "api_secret": "secret",- "url": "test_url_value",- }-)def test_api_rooms_retrieve_authenticated_public(mock_token):"""- Authenticated users should be allowed to retrieve a room and get a token for a room to- which they are not related, provided the room is public.+ Authenticated users should be allowed to retrieve a public room to which+ they are not related, with its pin code but without any token.They should not see related users."""room = RoomFactory(@@ -278,44 +242,23 @@ def test_api_rooms_retrieve_authenticated_public(mock_token):)assert response.status_code == 200- expected_name = f"{room.id!s}"assert response.json() == {"configuration": {"can_publish_sources": ["camera"]},"access_level": str(room.access_level),"id": str(room.id),- "livekit": {- "url": "test_url_value",- "room": expected_name,- "token": "foo",- },"name": room.name,"pin_code": room.pin_code,"slug": room.slug,}- mock_token.assert_called_once_with(- room=expected_name,- user=user,- username=None,- color=None,- sources=["camera"],- role=None,- participant_id=None,- )+ mock_token.assert_not_called()@mock.patch("core.utils.generate_token", return_value="foo")-@override_settings(- LIVEKIT_CONFIGURATION={- "api_key": "key",- "api_secret": "secret",- "url": "test_url_value",- }-)def test_api_rooms_retrieve_authenticated_trusted(mock_token):"""- Authenticated users should be allowed to retrieve a room and get a token for a room to- which they are not related, provided the room has a trusted access_level.+ Authenticated users should be allowed to retrieve a trusted room to which+ they are not related, with its pin code but without any token.They should not see related users."""room = RoomFactory(access_level=RoomAccessLevel.TRUSTED)@@ -329,30 +272,16 @@ def test_api_rooms_retrieve_authenticated_trusted(mock_token):)assert response.status_code == 200- expected_name = f"{room.id!s}"assert response.json() == {"configuration": {},"access_level": str(room.access_level),"id": str(room.id),- "livekit": {- "url": "test_url_value",- "room": expected_name,- "token": "foo",- },"name": room.name,"pin_code": room.pin_code,"slug": room.slug,}- mock_token.assert_called_once_with(- room=expected_name,- user=user,- username=None,- color=None,- sources=None,- role=None,- participant_id=None,- )+ mock_token.assert_not_called()def test_api_rooms_retrieve_authenticated():@@ -381,13 +310,6 @@ def test_api_rooms_retrieve_authenticated():@mock.patch("core.utils.generate_token", return_value="foo")-@override_settings(- LIVEKIT_CONFIGURATION={- "api_key": "key",- "api_secret": "secret",- "url": "test_url_value",- }-)def test_api_rooms_retrieve_members(mock_token, django_assert_num_queries, settings):"""Users who are members of a room should not be allowed to see related users.@@ -415,40 +337,19 @@ def test_api_rooms_retrieve_members(mock_token, django_assert_num_queries, settiassert "accesses" not in content_dict- expected_name = str(room.id)assert content_dict == {"configuration": {"can_publish_sources": ["camera"]},"access_level": str(room.access_level),"id": str(room.id),- "livekit": {- "url": "test_url_value",- "room": expected_name,- "token": "foo",- },"name": room.name,"pin_code": room.pin_code,"slug": room.slug,}- mock_token.assert_called_once_with(- room=expected_name,- user=user,- username=None,- color=None,- sources=["camera"],- role=str(RoleChoices.MEMBER),- participant_id=None,- )+ mock_token.assert_not_called()@mock.patch("core.utils.generate_token", return_value="foo")-@override_settings(- LIVEKIT_CONFIGURATION={- "api_key": "key",- "api_secret": "secret",- "url": "test_url_value",- }-)def test_api_rooms_retrieve_administrators(mock_token, django_assert_num_queries, settings):@@ -511,30 +412,16 @@ def test_api_rooms_retrieve_administrators(],key=lambda x: x["id"],)- expected_name = str(room.id)assert content_dict == {"access_level": str(room.access_level),"id": str(room.id),"configuration": {},- "livekit": {- "url": "test_url_value",- "room": expected_name,- "token": "foo",- },"name": room.name,"pin_code": room.pin_code,"slug": room.slug,}- mock_token.assert_called_once_with(- room=expected_name,- user=user,- username=None,- color=None,- sources=None,- role=str(user_access.role),- participant_id=None,- )+ mock_token.assert_not_called()@pytest.mark.parametrize("access_level", RoomAccessLevel)@@ -567,3 +454,77 @@ def test_api_rooms_retrieve_authenticated_with_user_access_token():assert response.data["id"] == str(room.id)assert response.data["pin_code"] == room.pin_codeassert "accesses" in response.data+ assert "livekit" not in response.data++[email protected]("access_level", RoomAccessLevel)[email protected]("role", [None, *RoleChoices])[email protected]("core.utils.generate_token", return_value="foo")+def test_api_rooms_retrieve_never_returns_livekit_credentials(+ mock_token, role, access_level+):+ """Retrieving a room should never mint a LiveKit token."""+ room = RoomFactory(access_level=access_level)+ user = UserFactory()+ if role is not None:+ UserResourceAccessFactory(resource=room, user=user, role=role)+ client = APIClient()+ client.force_login(user)++ response = client.get(f"/api/v1.0/rooms/{room.id!s}/")++ assert response.status_code == 200+ assert "livekit" not in response.json()+ mock_token.assert_not_called()++[email protected]("access_level", RoomAccessLevel)[email protected]("core.utils.generate_token", return_value="foo")+def test_api_rooms_retrieve_anonymous_never_returns_livekit_credentials(+ mock_token, access_level+):+ """An anonymous user should never get a LiveKit token by retrieving a room."""+ room = RoomFactory(access_level=access_level)++ response = APIClient().get(f"/api/v1.0/rooms/{room.id!s}/")++ assert response.status_code == 200+ assert "livekit" not in response.json()+ mock_token.assert_not_called()+++ ("access_level", "authenticated", "role", "pin_code_exposed"),+ [+ (RoomAccessLevel.PUBLIC, False, None, True),+ (RoomAccessLevel.TRUSTED, False, None, False),+ (RoomAccessLevel.RESTRICTED, False, None, False),+ (RoomAccessLevel.PUBLIC, True, None, True),+ (RoomAccessLevel.TRUSTED, True, None, True),+ (RoomAccessLevel.RESTRICTED, True, None, False),+ (RoomAccessLevel.RESTRICTED, True, RoleChoices.MEMBER, True),+ (RoomAccessLevel.RESTRICTED, True, RoleChoices.ADMIN, True),+ (RoomAccessLevel.RESTRICTED, True, RoleChoices.OWNER, True),+ ],+)+def test_api_rooms_retrieve_pin_code_exposure(+ access_level, authenticated, role, pin_code_exposed+):+ """+ The pin code should only be exposed to users who may join the room+ without going through the lobby.+ """+ room = RoomFactory(access_level=access_level)+ client = APIClient()+ if authenticated:+ user = UserFactory()+ if role is not None:+ UserResourceAccessFactory(resource=room, user=user, role=role)+ client.force_login(user)++ response = client.get(f"/api/v1.0/rooms/{room.id!s}/")++ assert response.status_code == 200+ assert ("pin_code" in response.json()) is pin_code_exposed+ if pin_code_exposed:+ assert response.json()["pin_code"] == room.pin_codediff --git a/src/backend/core/tests/rooms/test_api_rooms_update.py b/src/backend/core/tests/rooms/test_api_rooms_update.pyindex 9f5c5a96..17bc2b32 100644--- a/src/backend/core/tests/rooms/test_api_rooms_update.py+++ b/src/backend/core/tests/rooms/test_api_rooms_update.py@@ -113,6 +113,7 @@ def test_api_rooms_update_administrators(mock_update_metadata):format="json",)assert response.status_code == 200+ assert "livekit" not in response.json()room.refresh_from_db()assert room.name == "New name"assert room.slug == "new-name"@@ -467,6 +468,7 @@ def test_api_rooms_update_authenticated_with_user_access_token(privileged_role):room.accesses.filter(user=user).update(role=privileged_role)response = client.patch(f"/api/v1.0/rooms/{room.id!s}/", {"name": "new name"})assert response.status_code == 200+ assert "livekit" not in response.json()room.refresh_from_db()assert room.name == "new name"