# Copyright 2019 The Matrix.org Foundation C.I.C. # # 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 Collection, Optional, cast from unittest import TestCase from unittest.mock import AsyncMock, Mock, patch from twisted.internet.defer import Deferred from twisted.test.proto_helpers import MemoryReactor from synapse.api.constants import EventTypes from synapse.api.errors import ( AuthError, Codes, LimitExceededError, NotFoundError, SynapseError, ) from synapse.api.room_versions import RoomVersions from synapse.events import EventBase, make_event_from_dict from synapse.federation.federation_base import event_from_pdu_json from synapse.federation.federation_client import SendJoinResult from synapse.logging.context import LoggingContext, run_in_background from synapse.rest import admin from synapse.rest.client import login, room from synapse.server import HomeServer from synapse.storage.databases.main.events_worker import EventCacheEntry from synapse.util import Clock from synapse.util.stringutils import random_string from tests import unittest from tests.test_utils import event_injection logger = logging.getLogger(__name__) def generate_fake_event_id() -> str: return "$fake_" + random_string(43) class FederationTestCase(unittest.FederatingHomeserverTestCase): servlets = [ admin.register_servlets, login.register_servlets, room.register_servlets, ] def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer: hs = self.setup_test_homeserver() self.handler = hs.get_federation_handler() self.store = hs.get_datastores().main return hs def test_exchange_revoked_invite(self) -> None: user_id = self.register_user("kermit", "test") tok = self.login("kermit", "test") room_id = self.helper.create_room_as(room_creator=user_id, tok=tok) # Send a 3PID invite event with an empty body so it's considered as a revoked one. invite_token = "sometoken" self.helper.send_state( room_id=room_id, event_type=EventTypes.ThirdPartyInvite, state_key=invite_token, body={}, tok=tok, ) d = self.handler.on_exchange_third_party_invite_request( event_dict={ "type": EventTypes.Member, "room_id": room_id, "sender": user_id, "state_key": "@someone:example.org", "content": { "membership": "invite", "third_party_invite": { "display_name": "alice", "signed": { "mxid": "@alice:localhost", "token": invite_token, "signatures": { "magic.forest": { "ed25519:3": "fQpGIW1Snz+pwLZu6sTy2aHy/DYWWTspTJRPyNp0PKkymfIsNffysMl6ObMMFdIJhk6g6pwlIqZ54rxo8SLmAg" } }, }, }, }, }, ) failure = self.get_failure(d, AuthError).value self.assertEqual(failure.code, 403, failure) self.assertEqual(failure.errcode, Codes.FORBIDDEN, failure) self.assertEqual(failure.msg, "You are not invited to this room.") def test_rejected_message_event_state(self) -> None: """ Check that we store the state group correctly for rejected non-state events. Regression test for https://github.com/matrix-org/synapse/issues/6289. """ OTHER_SERVER = "otherserver" OTHER_USER = "@otheruser:" + OTHER_SERVER # create the room user_id = self.register_user("kermit", "test") tok = self.login("kermit", "test") room_id = self.helper.create_room_as(room_creator=user_id, tok=tok) room_version = self.get_success(self.store.get_room_version(room_id)) # pretend that another server has joined join_event = self._build_and_send_join_event(OTHER_SERVER, OTHER_USER, room_id) # check the state group sg = self.get_success( self.store._get_state_group_for_event(join_event.event_id) ) # build and send an event which will be rejected ev = event_from_pdu_json( { "type": EventTypes.Message, "content": {}, "room_id": room_id, "sender": "@yetanotheruser:" + OTHER_SERVER, "depth": cast(int, join_event["depth"]) + 1, "prev_events": [join_event.event_id], "auth_events": [], "origin_server_ts": self.clock.time_msec(), }, room_version, ) with LoggingContext("send_rejected"): d = run_in_background( self.hs.get_federation_event_handler().on_receive_pdu, OTHER_SERVER, ev ) self.get_success(d) # that should have been rejected e = self.get_success(self.store.get_event(ev.event_id, allow_rejected=True)) self.assertIsNotNone(e.rejected_reason) # ... and the state group should be the same as before sg2 = self.get_success(self.store._get_state_group_for_event(ev.event_id)) self.assertEqual(sg, sg2) def test_rejected_state_event_state(self) -> None: """ Check that we store the state group correctly for rejected state events. Regression test for https://github.com/matrix-org/synapse/issues/6289. """ OTHER_SERVER = "otherserver" OTHER_USER = "@otheruser:" + OTHER_SERVER # create the room user_id = self.register_user("kermit", "test") tok = self.login("kermit", "test") room_id = self.helper.create_room_as(room_creator=user_id, tok=tok) room_version = self.get_success(self.store.get_room_version(room_id)) # pretend that another server has joined join_event = self._build_and_send_join_event(OTHER_SERVER, OTHER_USER, room_id) # check the state group sg = self.get_success( self.store._get_state_group_for_event(join_event.event_id) ) # build and send an event which will be rejected ev = event_from_pdu_json( { "type": "org.matrix.test", "state_key": "test_key", "content": {}, "room_id": room_id, "sender": "@yetanotheruser:" + OTHER_SERVER, "depth": cast(int, join_event["depth"]) + 1, "prev_events": [join_event.event_id], "auth_events": [], "origin_server_ts": self.clock.time_msec(), }, room_version, ) with LoggingContext("send_rejected"): d = run_in_background( self.hs.get_federation_event_handler().on_receive_pdu, OTHER_SERVER, ev ) self.get_success(d) # that should have been rejected e = self.get_success(self.store.get_event(ev.event_id, allow_rejected=True)) self.assertIsNotNone(e.rejected_reason) # ... and the state group should be the same as before sg2 = self.get_success(self.store._get_state_group_for_event(ev.event_id)) self.assertEqual(sg, sg2) def test_backfill_with_many_backward_extremities(self) -> None: """ Check that we can backfill with many backward extremities. The goal is to make sure that when we only use a portion of backwards extremities(the magic number is more than 5), no errors are thrown. Regression test, see https://github.com/matrix-org/synapse/pull/11027 """ # create the room user_id = self.register_user("kermit", "test") tok = self.login("kermit", "test") room_id = self.helper.create_room_as(room_creator=user_id, tok=tok) room_version = self.get_success(self.store.get_room_version(room_id)) # we need a user on the remote server to be a member, so that we can send # extremity-causing events. remote_server_user_id = f"@user:{self.OTHER_SERVER_NAME}" self.get_success( event_injection.inject_member_event( self.hs, room_id, remote_server_user_id, "join" ) ) send_result = self.helper.send(room_id, "first message", tok=tok) ev1 = self.get_success( self.store.get_event(send_result["event_id"], allow_none=False) ) current_state = self.get_success( self.store.get_events_as_list( ( self.get_success(self.store.get_partial_current_state_ids(room_id)) ).values() ) ) # Create "many" backward extremities. The magic number we're trying to # create more than is 5 which corresponds to the number of backward # extremities we slice off in `_maybe_backfill_inner` federation_event_handler = self.hs.get_federation_event_handler() auth_events = [ ev for ev in current_state if (ev.type, ev.state_key) in {("m.room.create", ""), ("m.room.member", remote_server_user_id)} ] for _ in range(8): event = make_event_from_dict( self.add_hashes_and_signatures_from_other_server( { "origin_server_ts": 1, "type": "m.room.message", "content": { "msgtype": "m.text", "body": "message connected to fake event", }, "room_id": room_id, "sender": remote_server_user_id, "prev_events": [ ev1.event_id, # We're creating an backward extremity each time thanks # to this fake event generate_fake_event_id(), ], "auth_events": [ev.event_id for ev in auth_events], "depth": ev1.depth + 1, }, room_version, ), room_version, ) # we poke this directly into _process_received_pdu, to avoid the # federation handler wanting to backfill the fake event. state_handler = self.hs.get_state_handler() context = self.get_success( state_handler.compute_event_context( event, state_ids_before_event={ (e.type, e.state_key): e.event_id for e in current_state }, partial_state=False, ) ) self.get_success( federation_event_handler._process_received_pdu( self.OTHER_SERVER_NAME, event, context, ) ) # we should now have 8 backwards extremities. backwards_extremities = self.get_success( self.store.db_pool.simple_select_list( "event_backward_extremities", keyvalues={"room_id": room_id}, retcols=["event_id"], ) ) self.assertEqual(len(backwards_extremities), 8) current_depth = 1 limit = 100 with LoggingContext("receive_pdu"): # Make sure backfill still works d = run_in_background( self.hs.get_federation_handler().maybe_backfill, room_id, current_depth, limit, ) self.get_success(d) def test_backfill_ignores_known_events(self) -> None: """ Tests that events that we already know about are ignored when backfilling. """ # Set up users user_id = self.register_user("kermit", "test") tok = self.login("kermit", "test") other_server = "otherserver" other_user = "@otheruser:" + other_server # Create a room to backfill events into room_id = self.helper.create_room_as(room_creator=user_id, tok=tok) room_version = self.get_success(self.store.get_room_version(room_id)) # Build an event to backfill event = event_from_pdu_json( { "type": EventTypes.Message, "content": {"body": "hello world", "msgtype": "m.text"}, "room_id": room_id, "sender": other_user, "depth": 32, "prev_events": [], "auth_events": [], "origin_server_ts": self.clock.time_msec(), }, room_version, ) # Ensure the event is not already in the DB self.get_failure( self.store.get_event(event.event_id), NotFoundError, ) # Backfill the event and check that it has entered the DB. # We mock out the FederationClient.backfill method, to pretend that a remote # server has returned our fake event. federation_client_backfill_mock = AsyncMock(return_value=[event]) self.hs.get_federation_client().backfill = federation_client_backfill_mock # type: ignore[method-assign] # We also mock the persist method with a side effect of itself. This allows us # to track when it has been called while preserving its function. persist_events_and_notify_mock = Mock( side_effect=self.hs.get_federation_event_handler().persist_events_and_notify ) self.hs.get_federation_event_handler().persist_events_and_notify = ( # type: ignore[method-assign] persist_events_and_notify_mock ) # Small side-tangent. We populate the event cache with the event, even though # it is not yet in the DB. This is an invalid scenario that can currently occur # due to not properly invalidating the event cache. # See https://github.com/matrix-org/synapse/issues/13476. # # As a result, backfill should not rely on the event cache to check whether # we already have an event in the DB. # TODO: Remove this bit when the event cache is properly invalidated. cache_entry = EventCacheEntry( event=event, redacted_event=None, ) self.store._get_event_cache.set_local((event.event_id,), cache_entry) # We now call FederationEventHandler.backfill (a separate method) to trigger # a backfill request. It should receive the fake event. self.get_success( self.hs.get_federation_event_handler().backfill( other_user, room_id, limit=10, extremities=[], ) ) # Check that our fake event was persisted. persist_events_and_notify_mock.assert_called_once() persist_events_and_notify_mock.reset_mock() # Now we repeat the backfill, having the homeserver receive the fake event # again. self.get_success( self.hs.get_federation_event_handler().backfill( other_user, room_id, limit=10, extremities=[], ), ) # This time, we expect no event persistence to have occurred, as we already # have this event. persist_events_and_notify_mock.assert_not_called() @unittest.override_config( {"rc_invites": {"per_user": {"per_second": 0.5, "burst_count": 3}}} ) def test_invite_by_user_ratelimit(self) -> None: """Tests that invites from federation to a particular user are actually rate-limited. """ other_server = "otherserver" other_user = "@otheruser:" + other_server # create the room user_id = self.register_user("kermit", "test") tok = self.login("kermit", "test") def create_invite() -> EventBase: room_id = self.helper.create_room_as(room_creator=user_id, tok=tok) room_version = self.get_success(self.store.get_room_version(room_id)) return event_from_pdu_json( { "type": EventTypes.Member, "content": {"membership": "invite"}, "room_id": room_id, "sender": other_user, "state_key": "@user:test", "depth": 32, "prev_events": [], "auth_events": [], "origin_server_ts": self.clock.time_msec(), }, room_version, ) for _ in range(3): event = create_invite() self.get_success( self.handler.on_invite_request( other_server, event, event.room_version, ) ) event = create_invite() self.get_failure( self.handler.on_invite_request( other_server, event, event.room_version, ), exc=LimitExceededError, ) def _build_and_send_join_event( self, other_server: str, other_user: str, room_id: str ) -> EventBase: join_event = self.get_success( self.handler.on_make_join_request(other_server, room_id, other_user) ) # the auth code requires that a signature exists, but doesn't check that # signature... go figure. join_event.signatures[other_server] = {"x": "y"} with LoggingContext("send_join"): d = run_in_background( self.hs.get_federation_event_handler().on_send_membership_event, other_server, join_event, ) self.get_success(d) # sanity-check: the room should show that the new user is a member r = self.get_success(self.store.get_partial_current_state_ids(room_id)) self.assertEqual(r[(EventTypes.Member, other_user)], join_event.event_id) return join_event class EventFromPduTestCase(TestCase): def test_valid_json(self) -> None: """Valid JSON should be turned into an event.""" ev = event_from_pdu_json( { "type": EventTypes.Message, "content": {"bool": True, "null": None, "int": 1, "str": "foobar"}, "room_id": "!room:test", "sender": "@user:test", "depth": 1, "prev_events": [], "auth_events": [], "origin_server_ts": 1234, }, RoomVersions.V6, ) self.assertIsInstance(ev, EventBase) def test_invalid_numbers(self) -> None: """Invalid values for an integer should be rejected, all floats should be rejected.""" for value in [ -(2**53), 2**53, 1.0, float("inf"), float("-inf"), float("nan"), ]: with self.assertRaises(SynapseError): event_from_pdu_json( { "type": EventTypes.Message, "content": {"foo": value}, "room_id": "!room:test", "sender": "@user:test", "depth": 1, "prev_events": [], "auth_events": [], "origin_server_ts": 1234, }, RoomVersions.V6, ) def test_invalid_nested(self) -> None: """List and dictionaries are recursively searched.""" with self.assertRaises(SynapseError): event_from_pdu_json( { "type": EventTypes.Message, "content": {"foo": [{"bar": 2**56}]}, "room_id": "!room:test", "sender": "@user:test", "depth": 1, "prev_events": [], "auth_events": [], "origin_server_ts": 1234, }, RoomVersions.V6, ) class PartialJoinTestCase(unittest.FederatingHomeserverTestCase): def test_failed_partial_join_is_clean(self) -> None: """ Tests that, when failing to partial-join a room, we don't get stuck with a partial-state flag on a room. """ fed_handler = self.hs.get_federation_handler() fed_client = fed_handler.federation_client room_id = "!room:example.com" EVENT_CREATE = make_event_from_dict( { "room_id": room_id, "type": "m.room.create", "sender": "@kristina:example.com", "state_key": "", "depth": 0, "content": {"creator": "@kristina:example.com", "room_version": "10"}, "auth_events": [], "origin_server_ts": 1, }, room_version=RoomVersions.V10, ) EVENT_CREATOR_MEMBERSHIP = make_event_from_dict( { "room_id": room_id, "type": "m.room.member", "sender": "@kristina:example.com", "state_key": "@kristina:example.com", "content": {"membership": "join"}, "depth": 1, "prev_events": [EVENT_CREATE.event_id], "auth_events": [EVENT_CREATE.event_id], "origin_server_ts": 1, }, room_version=RoomVersions.V10, ) EVENT_INVITATION_MEMBERSHIP = make_event_from_dict( { "room_id": room_id, "type": "m.room.member", "sender": "@kristina:example.com", "state_key": "@alice:test", "content": {"membership": "invite"}, "depth": 2, "prev_events": [EVENT_CREATOR_MEMBERSHIP.event_id], "auth_events": [ EVENT_CREATE.event_id, EVENT_CREATOR_MEMBERSHIP.event_id, ], "origin_server_ts": 1, }, room_version=RoomVersions.V10, ) membership_event = make_event_from_dict( { "room_id": room_id, "type": "m.room.member", "sender": "@alice:test", "state_key": "@alice:test", "content": {"membership": "join"}, "prev_events": [EVENT_INVITATION_MEMBERSHIP.event_id], }, RoomVersions.V10, ) mock_make_membership_event = AsyncMock( return_value=( "example.com", membership_event, RoomVersions.V10, ) ) mock_send_join = AsyncMock( return_value=SendJoinResult( membership_event, "example.com", state=[ EVENT_CREATE, EVENT_CREATOR_MEMBERSHIP, EVENT_INVITATION_MEMBERSHIP, ], auth_chain=[ EVENT_CREATE, EVENT_CREATOR_MEMBERSHIP, EVENT_INVITATION_MEMBERSHIP, ], partial_state=True, servers_in_room={"example.com"}, ) ) with patch.object( fed_client, "make_membership_event", mock_make_membership_event ), patch.object(fed_client, "send_join", mock_send_join): # Join and check that our join event is rejected # (The join event is rejected because it doesn't have any signatures) join_exc = self.get_failure( fed_handler.do_invite_join(["example.com"], room_id, "@alice:test", {}), SynapseError, ) self.assertIn("Join event was rejected", str(join_exc)) store = self.hs.get_datastores().main # Check that we don't have a left-over partial_state entry. self.assertFalse( self.get_success(store.is_partial_state_room(room_id)), f"Stale partial-stated room flag left over for {room_id} after a" f" failed do_invite_join!", ) def test_duplicate_partial_state_room_syncs(self) -> None: """ Tests that concurrent partial state syncs are not started for the same room. """ is_partial_state = True end_sync: "Deferred[None]" = Deferred() async def is_partial_state_room(room_id: str) -> bool: return is_partial_state async def sync_partial_state_room( initial_destination: Optional[str], other_destinations: Collection[str], room_id: str, ) -> None: nonlocal end_sync try: await end_sync finally: end_sync = Deferred() mock_is_partial_state_room = Mock(side_effect=is_partial_state_room) mock_sync_partial_state_room = Mock(side_effect=sync_partial_state_room) fed_handler = self.hs.get_federation_handler() store = self.hs.get_datastores().main with patch.object( fed_handler, "_sync_partial_state_room", mock_sync_partial_state_room ), patch.object(store, "is_partial_state_room", mock_is_partial_state_room): # Start the partial state sync. fed_handler._start_partial_state_room_sync("hs1", {"hs2"}, "room_id") self.assertEqual(mock_sync_partial_state_room.call_count, 1) # Try to start another partial state sync. # Nothing should happen. fed_handler._start_partial_state_room_sync("hs3", {"hs2"}, "room_id") self.assertEqual(mock_sync_partial_state_room.call_count, 1) # End the partial state sync is_partial_state = False end_sync.callback(None) # The partial state sync should not be restarted. self.assertEqual(mock_sync_partial_state_room.call_count, 1) # The next attempt to start the partial state sync should work. is_partial_state = True fed_handler._start_partial_state_room_sync("hs3", {"hs2"}, "room_id") self.assertEqual(mock_sync_partial_state_room.call_count, 2) def test_partial_state_room_sync_restart(self) -> None: """ Tests that partial state syncs are restarted when a second partial state sync was deduplicated and the first partial state sync fails. """ is_partial_state = True end_sync: "Deferred[None]" = Deferred() async def is_partial_state_room(room_id: str) -> bool: return is_partial_state async def sync_partial_state_room( initial_destination: Optional[str], other_destinations: Collection[str], room_id: str, ) -> None: nonlocal end_sync try: await end_sync finally: end_sync = Deferred() mock_is_partial_state_room = Mock(side_effect=is_partial_state_room) mock_sync_partial_state_room = Mock(side_effect=sync_partial_state_room) fed_handler = self.hs.get_federation_handler() store = self.hs.get_datastores().main with patch.object( fed_handler, "_sync_partial_state_room", mock_sync_partial_state_room ), patch.object(store, "is_partial_state_room", mock_is_partial_state_room): # Start the partial state sync. fed_handler._start_partial_state_room_sync("hs1", {"hs2"}, "room_id") self.assertEqual(mock_sync_partial_state_room.call_count, 1) # Fail the partial state sync. # The partial state sync should not be restarted. end_sync.errback(Exception("Failed to request /state_ids")) self.assertEqual(mock_sync_partial_state_room.call_count, 1) # Start the partial state sync again. fed_handler._start_partial_state_room_sync("hs1", {"hs2"}, "room_id") self.assertEqual(mock_sync_partial_state_room.call_count, 2) # Deduplicate another partial state sync. fed_handler._start_partial_state_room_sync("hs3", {"hs2"}, "room_id") self.assertEqual(mock_sync_partial_state_room.call_count, 2) # Fail the partial state sync. # It should restart with the latest parameters. end_sync.errback(Exception("Failed to request /state_ids")) self.assertEqual(mock_sync_partial_state_room.call_count, 3) mock_sync_partial_state_room.assert_called_with( initial_destination="hs3", other_destinations={"hs2"}, room_id="room_id", )