Add test for state_key size

tests/federation_room_get_missing_events_test.go

@@ -5,6 +5,7 @@ import (
  "encoding/json"
  "fmt"
  "net/http"
+ "strings"
  "testing"
  "time"
 
@@ -454,3 +455,132 @@ func TestInboundCanReturnMissingEvents(t *testing.T) {
  })
  }
 }
+
+// This test verifies that an event with a too large state_key can be used as a prev_event
+// it is returned by a call to /get_missing_events and should pass event size checks.
+// TODO: Do the same checks for type, user_id and sender
+func TestOutboundFederationEventSizeGetMissingEvents(t *testing.T) {
+ deployment := Deploy(t, b.BlueprintAlice)
+ defer deployment.Destroy(t)
+
+ alice := deployment.Client(t, "hs1", "@alice:hs1")
+
+ srv := federation.NewServer(t, deployment,
+ federation.HandleKeyRequests(),
+ federation.HandleMakeSendJoinRequests(),
+ // Handle any transactions that the homeserver may send when connecting to another homeserver (such as presence)
+ federation.HandleTransactionRequests(nil, nil),
+ )
+ cancel := srv.Listen()
+ defer cancel()
+
+ // register a handler for /get_missing_events, via a shim so that we can
+ // behave differently as the test progresses.
+ var onGetMissingEvents func(w http.ResponseWriter, req *http.Request)
+ srv.Mux().HandleFunc("/_matrix/federation/v1/get_missing_events/{roomID}", func(w http.ResponseWriter, req *http.Request) {
+ onGetMissingEvents(w, req)
+ }).Methods("POST")
+
+ ver := alice.GetDefaultRoomVersion(t)
+ charlie := srv.UserID("charlie")
+ room := srv.MustMakeRoom(t, ver, federation.InitialRoomEvents(ver, charlie))
+ roomAlias := srv.MakeAliasMapping("flibble", room.RoomID)
+ // join the room
+ alice.JoinRoom(t, roomAlias, nil)
+
+ latestEvent := room.Timeline[len(room.Timeline)-1]
+
+ // Sign this bad event which has a too large stateKey
+ // Synapse always enforced 255 codepoints, but accepts events > 255 bytes.
+ // Dendrite would fail to parse this event because it enforced 255 bytes, breaking older rooms.
+ stateKey := strings.Repeat("💥", 70) // 280 bytes, 70 codepoints
+ badEvent := b.Event{
+ Type: "my.room.breaker",
+ StateKey: &stateKey,
+ Sender: charlie,
+ Content: map[string]interface{}{},
+ }
+ content, err := json.Marshal(badEvent.Content)
+ if err != nil {
+ t.Fatalf("failed to marshal badEvent content %+v", badEvent.Content)
+ }
+ eb := gomatrixserverlib.EventBuilder{
+ Sender: badEvent.Sender,
+ Depth: int64(room.Depth + 1), // depth starts at 1
+ Type: badEvent.Type,
+ StateKey: badEvent.StateKey,
+ Content: content,
+ RoomID: room.RoomID,
+ PrevEvents: room.ForwardExtremities,
+ }
+ stateNeeded, err := gomatrixserverlib.StateNeededForEventBuilder(&eb)
+ if err != nil {
+ t.Fatalf("failed to work out auth_events : %s", err)
+ }
+ eb.AuthEvents = room.AuthEvents(stateNeeded)
+
+ signedBadEvent, err := eb.Build(time.Now(), gomatrixserverlib.ServerName(srv.ServerName()), srv.KeyID, srv.Priv, ver)
+ switch e := err.(type) {
+ case nil:
+ case gomatrixserverlib.EventValidationError:
+ // ignore for now
+ t.Logf("EventValidationError: %v", e)
+ default:
+ t.Fatalf("failed to sign event: %s: %s", err, signedBadEvent.JSON())
+ }
+ room.AddEvent(signedBadEvent)
+
+ // send the first "good" event, referencing the broken event as a prev_event
+ sentEvent := srv.MustCreateEvent(t, room, b.Event{
+ Type: "m.room.message",
+ Sender: charlie,
+ Content: map[string]interface{}{
+ "body": "Message 2",
+ },
+ })
+ room.AddEvent(sentEvent)
+
+ waiter := NewWaiter()
+ onGetMissingEvents = func(w http.ResponseWriter, req *http.Request) {
+ defer waiter.Finish()
+ must.MatchRequest(t, req, match.HTTPRequest{
+ JSON: []match.JSON{
+ match.JSONKeyEqual("earliest_events", []interface{}{latestEvent.EventID()}),
+ match.JSONKeyEqual("latest_events", []interface{}{sentEvent.EventID()}),
+ },
+ })
+ // return the bad event, which should result in the transaction failing.
+ w.WriteHeader(200)
+ res := struct {
+ Events []*gomatrixserverlib.Event `json:"events"`
+ }{
+ Events: []*gomatrixserverlib.Event{signedBadEvent},
+ }
+ var responseBytes []byte
+ responseBytes, err = json.Marshal(&res)
+ must.NotError(t, "failed to marshal response", err)
+ w.Write(responseBytes)
+ }
+
+ fedClient := srv.FederationClient(deployment)
+ resp, err := fedClient.SendTransaction(context.Background(), gomatrixserverlib.Transaction{
+ TransactionID: "wut",
+ Origin: gomatrixserverlib.ServerName(srv.ServerName()),
+ Destination: gomatrixserverlib.ServerName("hs1"),
+ PDUs: []json.RawMessage{
+ sentEvent.JSON(),
+ },
+ })
+ waiter.Wait(t, 5*time.Second)
+ must.NotError(t, "SendTransaction errored", err)
+ if len(resp.PDUs) != 1 {
+ t.Fatalf("got %d errors, want 1", len(resp.PDUs))
+ }
+ _, ok := resp.PDUs[sentEvent.EventID()]
+ if !ok {
+ t.Fatalf("wrong PDU returned from send transaction, got %v want %s", resp.PDUs, sentEvent.EventID())
+ }
+
+ // Alice should receive the sent event, even though the "bad" event has a too large state key
+ alice.MustSyncUntil(t, client.SyncReq{}, client.SyncTimelineHasEventID(room.RoomID, sentEvent.EventID()))
+}