# Copyright 2023 The Matrix.org Foundation. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import logging from typing import TYPE_CHECKING, Optional, Tuple from twisted.web.server import Request from synapse import event_auth from synapse.api.constants import EventTypes, HistoryVisibility, Membership from synapse.api.errors import ( AuthError, Codes, MissingClientTokenError, UnstableSpecAuthError, ) from synapse.appservice import ApplicationService from synapse.logging.opentracing import trace from synapse.types import Requester if TYPE_CHECKING: from synapse.server import HomeServer logger = logging.getLogger(__name__) class BaseAuth: """Common base class for all auth implementations.""" def __init__(self, hs: "HomeServer"): self.hs = hs self.store = hs.get_datastores().main self._storage_controllers = hs.get_storage_controllers() async def check_user_in_room( self, room_id: str, requester: Requester, allow_departed_users: bool = False, ) -> Tuple[str, Optional[str]]: """Check if the user is in the room, or was at some point. Args: room_id: The room to check. requester: The user making the request, according to the access token. current_state: Optional map of the current state of the room. If provided then that map is used to check whether they are a member of the room. Otherwise the current membership is loaded from the database. allow_departed_users: if True, accept users that were previously members but have now departed. Raises: AuthError if the user is/was not in the room. Returns: The current membership of the user in the room and the membership event ID of the user. """ user_id = requester.user.to_string() ( membership, member_event_id, ) = await self.store.get_local_current_membership_for_user_in_room( user_id=user_id, room_id=room_id, ) if membership: if membership == Membership.JOIN: return membership, member_event_id # XXX this looks totally bogus. Why do we not allow users who have been banned, # or those who were members previously and have been re-invited? if allow_departed_users and membership == Membership.LEAVE: forgot = await self.store.did_forget(user_id, room_id) if not forgot: return membership, member_event_id raise UnstableSpecAuthError( 403, "User %s not in room %s" % (user_id, room_id), errcode=Codes.NOT_JOINED, ) @trace async def check_user_in_room_or_world_readable( self, room_id: str, requester: Requester, allow_departed_users: bool = False ) -> Tuple[str, Optional[str]]: """Checks that the user is or was in the room or the room is world readable. If it isn't then an exception is raised. Args: room_id: room to check user_id: user to check allow_departed_users: if True, accept users that were previously members but have now departed Returns: Resolves to the current membership of the user in the room and the membership event ID of the user. If the user is not in the room and never has been, then `(Membership.JOIN, None)` is returned. """ try: # check_user_in_room will return the most recent membership # event for the user if: # * The user is a non-guest user, and was ever in the room # * The user is a guest user, and has joined the room # else it will throw. return await self.check_user_in_room( room_id, requester, allow_departed_users=allow_departed_users ) except AuthError: visibility = await self._storage_controllers.state.get_current_state_event( room_id, EventTypes.RoomHistoryVisibility, "" ) if ( visibility and visibility.content.get("history_visibility") == HistoryVisibility.WORLD_READABLE ): return Membership.JOIN, None raise AuthError( 403, "User %r not in room %s, and room previews are disabled" % (requester.user, room_id), ) async def validate_appservice_can_control_user_id( self, app_service: ApplicationService, user_id: str ) -> None: """Validates that the app service is allowed to control the given user. Args: app_service: The app service that controls the user user_id: The author MXID that the app service is controlling Raises: AuthError: If the application service is not allowed to control the user (user namespace regex does not match, wrong homeserver, etc) or if the user has not been registered yet. """ # It's ok if the app service is trying to use the sender from their registration if app_service.sender == user_id: pass # Check to make sure the app service is allowed to control the user elif not app_service.is_interested_in_user(user_id): raise AuthError( 403, "Application service cannot masquerade as this user (%s)." % user_id, ) # Check to make sure the user is already registered on the homeserver elif not (await self.store.get_user_by_id(user_id)): raise AuthError( 403, "Application service has not registered this user (%s)" % user_id ) async def is_server_admin(self, requester: Requester) -> bool: """Check if the given user is a local server admin. Args: requester: user to check Returns: True if the user is an admin """ raise NotImplementedError() async def check_can_change_room_list( self, room_id: str, requester: Requester ) -> bool: """Determine whether the user is allowed to edit the room's entry in the published room list. Args: room_id user """ is_admin = await self.is_server_admin(requester) if is_admin: return True await self.check_user_in_room(room_id, requester) # We currently require the user is a "moderator" in the room. We do this # by checking if they would (theoretically) be able to change the # m.room.canonical_alias events power_level_event = ( await self._storage_controllers.state.get_current_state_event( room_id, EventTypes.PowerLevels, "" ) ) auth_events = {} if power_level_event: auth_events[(EventTypes.PowerLevels, "")] = power_level_event send_level = event_auth.get_send_level( EventTypes.CanonicalAlias, "", power_level_event ) user_level = event_auth.get_user_power_level( requester.user.to_string(), auth_events ) return user_level >= send_level @staticmethod def has_access_token(request: Request) -> bool: """Checks if the request has an access_token. Returns: False if no access_token was given, True otherwise. """ # This will always be set by the time Twisted calls us. assert request.args is not None query_params = request.args.get(b"access_token") auth_headers = request.requestHeaders.getRawHeaders(b"Authorization") return bool(query_params) or bool(auth_headers) @staticmethod def get_access_token_from_request(request: Request) -> str: """Extracts the access_token from the request. Args: request: The http request. Returns: The access_token Raises: MissingClientTokenError: If there isn't a single access_token in the request """ # This will always be set by the time Twisted calls us. assert request.args is not None auth_headers = request.requestHeaders.getRawHeaders(b"Authorization") query_params = request.args.get(b"access_token") if auth_headers: # Try the get the access_token from a "Authorization: Bearer" # header if query_params is not None: raise MissingClientTokenError( "Mixing Authorization headers and access_token query parameters." ) if len(auth_headers) > 1: raise MissingClientTokenError("Too many Authorization headers.") parts = auth_headers[0].split(b" ") if parts[0] == b"Bearer" and len(parts) == 2: return parts[1].decode("ascii") else: raise MissingClientTokenError("Invalid Authorization header.") else: # Try to get the access_token from the query params. if not query_params: raise MissingClientTokenError() return query_params[0].decode("ascii")