rtc: E2E ratchet key on new joiners

BillCarsonFr · BillCarsonFr · commit f4770991ce2c · 2025-04-25T14:50:10.000+02:00
diff --git a/src/matrixrtc/EncryptionManager.ts b/src/matrixrtc/EncryptionManager.ts
@@ -45,6 +45,13 @@ export interface IEncryptionManager {
      * objects containing encryption keys and their associated timestamps.
      */
     getEncryptionKeys(): Map<string, Array<{ key: Uint8Array; timestamp: number }>>;
+
+    /**
+     * The ratcheting is done on the decoding layer, the encryption manager asks for a key to be ratcheted, then
+     * the lower layer will emit the ratcheted key to the encryption manager.
+     * This is called after the key a ratchet request has been performed.
+     */
+    onOwnKeyRatcheted(key: ArrayBuffer, keyIndex: number | undefined): void;
 }
 
 /**
@@ -100,6 +107,10 @@ export class EncryptionManager implements IEncryptionManager {
         this.logger = (parentLogger ?? rootLogger).getChild(`[EncryptionManager]`);
     }
 
+    public onOwnKeyRatcheted(key: ArrayBuffer, keyIndex: number | undefined): void {
+        this.logger.warn("Ratcheting key is not implemented in EncryptionManager");
+    }
+
     public getEncryptionKeys(): Map<string, Array<{ key: Uint8Array; timestamp: number }>> {
         return this.encryptionKeys;
     }
diff --git a/src/matrixrtc/MatrixRTCSession.ts b/src/matrixrtc/MatrixRTCSession.ts
@@ -28,7 +28,7 @@ import { MembershipManager } from "./NewMembershipManager.ts";
 import { EncryptionManager, type IEncryptionManager } from "./EncryptionManager.ts";
 import { LegacyMembershipManager } from "./LegacyMembershipManager.ts";
 import { logDurationSync } from "../utils.ts";
-import { type Statistics } from "./types.ts";
+import { type ParticipantId, type Statistics } from "./types.ts";
 import { RoomKeyTransport } from "./RoomKeyTransport.ts";
 import type { IMembershipManager } from "./IMembershipManager.ts";
 import { RTCEncryptionManager } from "./RTCEncryptionManager.ts";
@@ -49,6 +49,9 @@ export enum MatrixRTCSessionEvent {
     JoinStateChanged = "join_state_changed",
     // The key used to encrypt media has changed
     EncryptionKeyChanged = "encryption_key_changed",
+    // Request ratcheting the current encryption key. When done `onOwnKeyRatcheted` will be called with the
+    // ratcheted material.
+    EncryptionKeyQueryRatchetStep = "encryption_key_ratchet_step",
     /** The membership manager had to shut down caused by an unrecoverable error */
     MembershipManagerError = "membership_manager_error",
 }
@@ -65,6 +68,7 @@ export type MatrixRTCSessionEventHandlerMap = {
         participantId: string,
     ) => void;
     [MatrixRTCSessionEvent.MembershipManagerError]: (error: unknown) => void;
+    [MatrixRTCSessionEvent.EncryptionKeyQueryRatchetStep]: (participantId: string, keyIndex: number) => void;
 };
 
 export interface MembershipConfig {
@@ -424,6 +428,13 @@ export class MatrixRTCSession extends TypedEventEmitter<
                             participantId,
                         );
                     },
+                    (participantId: ParticipantId, encryptionKeyIndex: number) => {
+                        this.emit(
+                            MatrixRTCSessionEvent.EncryptionKeyQueryRatchetStep,
+                            participantId,
+                            encryptionKeyIndex,
+                        );
+                    },
                     this.logger,
                 );
             } else {
@@ -522,6 +533,10 @@ export class MatrixRTCSession extends TypedEventEmitter<
         });
     }
 
+    public onOwnKeyRatcheted(material: ArrayBuffer, keyIndex?: number): void {
+        this.encryptionManager?.onOwnKeyRatcheted(material, keyIndex);
+    }
+
     /**
      * A map of keys used to encrypt and decrypt (we are using a symmetric
      * cipher) given participant's media. This also includes our own key
diff --git a/src/matrixrtc/RTCEncryptionManager.ts b/src/matrixrtc/RTCEncryptionManager.ts
@@ -20,7 +20,7 @@ import { type CallMembership } from "./CallMembership.ts";
 import { decodeBase64, encodeBase64 } from "../base64.ts";
 import { type IKeyTransport, type KeyTransportEventListener, KeyTransportEvents } from "./IKeyTransport.ts";
 import { logger as rootLogger, type Logger } from "../logger.ts";
-import { sleep } from "../utils.ts";
+import { defer, type IDeferred, sleep } from "../utils.ts";
 import type { InboundEncryptionSession, ParticipantDeviceInfo, ParticipantId, Statistics } from "./types.ts";
 import { getParticipantId, KeyBuffer } from "./utils.ts";
 import {
@@ -75,6 +75,8 @@ export class RTCEncryptionManager implements IEncryptionManager {
 
     private logger: Logger;
 
+    private currentRatchetRequest: IDeferred<{ key: ArrayBuffer; keyIndex: number }> | null = null;
+
     public constructor(
         private userId: string,
         private deviceId: string,
@@ -86,9 +88,10 @@ export class RTCEncryptionManager implements IEncryptionManager {
             encryptionKeyIndex: number,
             participantId: ParticipantId,
         ) => void,
+        private ratchetKey: (participantId: ParticipantId, encryptionKeyIndex: number) => void,
         parentLogger?: Logger,
     ) {
-        this.logger = (parentLogger ?? rootLogger).getChild(`[EncryptionManager]`);
+        this.logger = (parentLogger ?? rootLogger).getChild(`[RTCEncryptionManager]`);
     }
 
     public getEncryptionKeys(): Map<string, Array<{ key: Uint8Array; timestamp: number }>> {
@@ -163,7 +166,9 @@ export class RTCEncryptionManager implements IEncryptionManager {
     }
 
     public onNewKeyReceived: KeyTransportEventListener = (userId, deviceId, keyBase64Encoded, index, timestamp) => {
-        this.logger.debug(`Received key over transport ${userId}:${deviceId} at index ${index}`);
+        this.logger.debug(
+            `Received key over transport ${userId}:${deviceId} at index ${index} key: ${keyBase64Encoded}`,
+        );
 
         // We received a new key, notify the video layer of this new key so that it can decrypt the frames properly.
         const participantId = getParticipantId(userId, deviceId);
@@ -216,7 +221,13 @@ export class RTCEncryptionManager implements IEncryptionManager {
         // get current memberships
         const toShareWith: ParticipantDeviceInfo[] = this.getMemberships()
             .filter((membership) => {
-                return membership.sender != undefined;
+                return (
+                    membership.sender != undefined &&
+                    !(
+                        // filter me out
+                        (membership.sender == this.userId && membership.deviceId == this.deviceId)
+                    )
+                );
             })
             .map((membership) => {
                 return {
@@ -272,13 +283,37 @@ export class RTCEncryptionManager implements IEncryptionManager {
             toDistributeTo = toShareWith;
             outboundKey = newOutboundKey;
         } else if (anyJoined.length > 0) {
-            // keep the same key
-            // XXX In the future we want to distribute a ratcheted key not the current one
+            if (this.outboundSession!.sharedWith.length > 0) {
+                // This key was already shared with someone, we need to ratchet it
+                // We want to ratchet the current key and only distribute the ratcheted key to the new joiners
+                // This needs to send some async messages, so we need to wait for the ratchet to finish
+                const deferredKey = defer<{ key: ArrayBuffer; keyIndex: number }>();
+                this.currentRatchetRequest = deferredKey;
+                this.logger.info(`Query ratcheting key index:${this.outboundSession!.keyId} ...`);
+                this.ratchetKey(getParticipantId(this.userId, this.deviceId), this.outboundSession!.keyId);
+                const res = await Promise.race([deferredKey.promise, sleep(1000)]);
+                if (res === undefined) {
+                    // TODO: we might want to rotate the key instead?
+                    this.logger.error("Ratchet key timed out sharing the same key for now :/");
+                } else {
+                    const { key, keyIndex } = await deferredKey.promise;
+                    this.logger.info(
+                        `... Ratcheting done key index:${keyIndex} key:${encodeBase64(new Uint8Array(key))}`,
+                    );
+                    this.outboundSession!.key = new Uint8Array(key);
+                    this.onEncryptionKeysChanged(
+                        this.outboundSession!.key,
+                        this.outboundSession!.keyId,
+                        getParticipantId(this.userId, this.deviceId),
+                    );
+                }
+            }
             toDistributeTo = anyJoined;
             outboundKey = this.outboundSession!;
         } else {
-            // no changes
-            return;
+            // No one joined or left, it could just be the first key, keep going
+            toDistributeTo = [];
+            outboundKey = this.outboundSession!;
         }
 
         try {
@@ -318,4 +353,10 @@ export class RTCEncryptionManager implements IEncryptionManager {
         globalThis.crypto.getRandomValues(key);
         return key;
     }
+
+    public onOwnKeyRatcheted(key: ArrayBuffer, keyIndex: number | undefined): void {
+        this.logger.debug(`Own key ratcheted for key index:${keyIndex} key:${encodeBase64(new Uint8Array(key))}`);
+
+        this.currentRatchetRequest?.resolve({ key, keyIndex: keyIndex! });
+    }
 }
