Phase 7: E2EE support

Implements PLAN.md Phase 7: the server half of end-to-end encryption.
Devices upload identity, one-time and fallback keys; other devices query
and claim them, across servers too, and every one-time key is handed out
exactly once. Cross-signing, signature uploads, device list tracking and
server-side key backup complete the set.

internal/keyserver is the component. Keys are stored in canonical JSON
so that re-uploading the same key is a byte comparison, and signatures
uploaded later are kept apart from the key they sign and merged in on
read, so a key's own JSON stays what its owner uploaded. Device keys must
be for the caller's own device; cross-signing keys must be the
uploader's, carry the right usage and, for self- and user-signing keys,
be signed by the master key. Signatures are verified against the key as
stored. Replacing a master key asks for the password; a first upload or
an upload of the keys already stored does not, as the spec allows. A
signature of another user's master key is shown only to the user who
made it and never federated.

Every write that changes what /keys/query answers moves the device list
stream in the same transaction, one position per device, and wakes the
syncs of everyone sharing a room. The stream is the sixth field of a sync
token; older tokens still parse. The syncapi works out device_lists
changed and left from the stream and from membership moves in the
window, skipping invites and knocks, and reports
device_one_time_keys_count and device_unused_fallback_key_types, the
latter as [] when empty. GET /keys/changes uses the same logic.

Over federation: /user/keys/query, /user/keys/claim and
/user/devices/{userId}, and m.device_list_update and m.signing_key_update
both ways. Remote keys are not cached; an update about a remote user
sharing a room moves them in the stream so local clients re-query.
Device display names are not sent to other servers. With federation off,
remote users are reported in failures at once.

Deleting a device deletes its keys, through a new userapi
DeviceObserver. Key backup keeps the better copy of each session by the
spec's rule, never reuses a deleted version's number, and answers writes
to a stale version with M_WRONG_ROOM_KEYS_VERSION.

Storage is migration 0008 for sqlite and postgres, with a PocketBase
stub. The Complement target sets gain the key, device list, fallback,
cross-signing and backup tests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

server/internal/setup/server.go

@@ -21,6 +21,7 @@ import (
 	"github.com/dariuszjaniak/warp/server/internal/federation"
 	"github.com/dariuszjaniak/warp/server/internal/federationapi"
 	"github.com/dariuszjaniak/warp/server/internal/httputil"
+	"github.com/dariuszjaniak/warp/server/internal/keyserver"
 	"github.com/dariuszjaniak/warp/server/internal/matrix/signing"
 	"github.com/dariuszjaniak/warp/server/internal/mediaapi"
 	"github.com/dariuszjaniak/warp/server/internal/metrics"
@@ -46,6 +47,7 @@ type Server struct {
 	users     *userapi.API
 	rooms     *roomserver.API
 	sync      *syncapi.API
+	keys      *keyserver.API
 	media     *mediaapi.API
 	clientAPI *clientapi.ClientAPI
 	adminAPI  *adminapi.AdminAPI
@@ -273,10 +275,32 @@ func New(ctx context.Context, cfg *config.Config, opts Options) (*Server, error)
 		emit.add(queue)
 		s.fedModule = federationapi.NewModule(queue, log)
 
+		// The keyserver comes with the rooms too: device list tracking is
+		// "who shares a room with whom", and the sync it reports through
+		// is the roomserver's. It tells other servers about key changes
+		// through the same queue as everything else, and hears about
+		// deleted devices from the userapi.
+		s.keys, err = keyserver.New(keyserver.Options{
+			ServerName: cfg.Global.ServerName,
+			Store:      s.db.Keys(),
+			Rooms:      s.rooms,
+			Notifier:   notifier,
+			Devices:    s.users,
+			Remote:     s.fedClient,
+			Outbound:   queue,
+			Logger:     log,
+		})
+		if err != nil {
+			_ = s.closeDB()
+			return nil, err
+		}
+		s.users.SetDeviceObserver(s.keys)
+
 		s.sync, err = syncapi.New(syncapi.Options{
 			ServerName:      cfg.Global.ServerName,
 			Rooms:           s.rooms,
 			Accounts:        s.users,
+			Keys:            s.keys,
 			Store:           s.db.Sync(),
 			Notifier:        notifier,
 			PresenceEnabled: cfg.Sync.Presence,
@@ -299,6 +323,7 @@ func New(ctx context.Context, cfg *config.Config, opts Options) (*Server, error)
 			Profiles:   s.users,
 			Store:      s.db.Federation(),
 			Media:      s.media,
+			UserKeys:   s.keys,
 			Logger:     log,
 		})
 		if err != nil {
@@ -306,7 +331,7 @@ func New(ctx context.Context, cfg *config.Config, opts Options) (*Server, error)
 			return nil, err
 		}
 	} else {
-		log.Warn("started without a signing key: rooms and /sync are unavailable")
+		log.Warn("started without a signing key: rooms, /sync and end-to-end encryption are unavailable")
 	}
 
 	// The interfaces below are left nil rather than set to a nil pointer
@@ -325,6 +350,7 @@ func New(ctx context.Context, cfg *config.Config, opts Options) (*Server, error)
 		Users:                s.users,
 		Rooms:                s.rooms,
 		Sync:                 s.sync,
+		Keys:                 s.keys,
 		Media:                s.media,
 		LegacyMediaDownloads: cfg.Media.LegacyUnauthenticatedDownloads,
 		Settings:             settingsService,
@@ -414,6 +440,10 @@ func (s *Server) Rooms() *roomserver.API { return s.rooms }
 // without a signing key.
 func (s *Server) Sync() *syncapi.API { return s.sync }
 
+// Keys exposes the keyserver, or nil when the server started without a
+// signing key.
+func (s *Server) Keys() *keyserver.API { return s.keys }
+
 // Media exposes the media repository.
 func (s *Server) Media() *mediaapi.API { return s.media }