Skip to content

armgit / meet

Public Imported from GitHub
0

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.md
index 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
### Fixed
diff --git a/UPGRADE.md b/UPGRADE.md
index 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 form
diff --git a/src/backend/core/api/serializers.py b/src/backend/core/api/serializers.py
index 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 TimeZoneSerializerField
from core import models, utils
from core.api.exceptions import ensure_room_not_deleted
+from core.services.lobby import LobbyService
logger = logging.getLogger(__name__)
+DISPLAY_NAME_MAX_LENGTH = 255
+
class UserSerializer(serializers.ModelSerializer):
"""Serialize users."""
@@ -170,17 +173,18 @@ class RoomSerializer(serializers.ModelSerializer):
return value
def 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.py
index 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-methods
ensure_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.py
index 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_code
rooms_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 == 201
room = 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.py
new file mode 100644
index 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.py
index 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 == 200
assert response.data["count"] == 1
assert 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.py
index 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-lines
import uuid
from 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.py
index 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.py
index 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 random
from unittest import mock
-from django.contrib.auth.models import AnonymousUser
from django.test.utils import override_settings
from 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, setti
assert "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_code
assert "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_code
diff --git a/src/backend/core/tests/rooms/test_api_rooms_update.py b/src/backend/core/tests/rooms/test_api_rooms_update.py
index 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"