livekit-client 2.5.8 → 2.5.10

package/src/e2ee/worker/FrameCryptor.test.ts

@@ -60,6 +60,21 @@ class TestUnderlyingSink<T> implements UnderlyingSink<T> {
 function prepareParticipantTestDecoder(
   participantIdentity: string,
   partialKeyProviderOptions: Partial<KeyProviderOptions>,
+) {
+  return prepareParticipantTest('decode', participantIdentity, partialKeyProviderOptions);
+}
+
+function prepareParticipantTestEncoder(
+  participantIdentity: string,
+  partialKeyProviderOptions: Partial<KeyProviderOptions>,
+) {
+  return prepareParticipantTest('encode', participantIdentity, partialKeyProviderOptions);
+}
+
+function prepareParticipantTest(
+  mode: 'encode' | 'decode',
+  participantIdentity: string,
+  partialKeyProviderOptions: Partial<KeyProviderOptions>,
 ): {
   keys: ParticipantKeyHandler;
   cryptor: FrameCryptor;
@@ -80,12 +95,7 @@ function prepareParticipantTestDecoder(
 
   const input = new TestUnderlyingSource<RTCEncodedVideoFrame>();
   const output = new TestUnderlyingSink<RTCEncodedVideoFrame>();
-  cryptor.setupTransform(
-    'decode',
-    new ReadableStream(input),
-    new WritableStream(output),
-    'testTrack',
-  );
+  cryptor.setupTransform(mode, new ReadableStream(input), new WritableStream(output), 'testTrack');
 
   return { keys, cryptor, input, output };
 }
@@ -93,10 +103,6 @@ function prepareParticipantTestDecoder(
 describe('FrameCryptor', () => {
   const participantIdentity = 'testParticipant';
 
-  afterEach(() => {
-    encryptionEnabledMap.clear();
-  });
-
   it('identifies server injected frame correctly', () => {
     const frameTrailer = new TextEncoder().encode('LKROCKS');
     const frameData = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, ...frameTrailer]).buffer;
@@ -113,154 +119,346 @@ describe('FrameCryptor', () => {
     expect(isFrameServerInjected(frameData.buffer, frameTrailer)).toBe(false);
   });
 
-  it('passthrough if participant encryption disabled', async () => {
-    vitest.useFakeTimers();
-    try {
-      const { input, output } = prepareParticipantTestDecoder(participantIdentity, {});
+  describe('encode', () => {
+    afterEach(() => {
+      encryptionEnabledMap.clear();
+    });
 
-      // disable encryption for participant
-      encryptionEnabledMap.set(participantIdentity, false);
+    it('passthrough if participant encryption disabled', async () => {
+      vitest.useFakeTimers();
+      try {
+        const { input, output } = prepareParticipantTestEncoder(participantIdentity, {});
 
-      const frame = mockEncryptedRTCEncodedVideoFrame(1);
+        // disable encryption for participant
+        encryptionEnabledMap.set(participantIdentity, false);
 
-      input.write(frame);
-      await vitest.advanceTimersToNextTimerAsync();
+        const frame = mockRTCEncodedVideoFrame(new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]));
 
-      expect(output.chunks).toEqual([frame]);
-    } finally {
-      vitest.useRealTimers();
-    }
-  });
+        input.write(frame);
+        await vitest.advanceTimersToNextTimerAsync();
 
-  it('passthrough for empty frame', async () => {
-    vitest.useFakeTimers();
-    try {
-      const { input, output } = prepareParticipantTestDecoder(participantIdentity, {});
+        expect(output.chunks).toEqual([frame]);
+      } finally {
+        vitest.useRealTimers();
+      }
+    });
 
-      // empty frame
-      const frame = mockRTCEncodedVideoFrame(new Uint8Array(0));
+    it('passthrough for empty frame', async () => {
+      vitest.useFakeTimers();
+      try {
+        const { input, output } = prepareParticipantTestEncoder(participantIdentity, {});
 
-      input.write(frame);
-      await vitest.advanceTimersToNextTimerAsync();
+        // empty frame
+        const frame = mockRTCEncodedVideoFrame(new Uint8Array(0));
 
-      expect(output.chunks).toEqual([frame]);
-    } finally {
-      vitest.useRealTimers();
-    }
-  });
+        input.write(frame);
+        await vitest.advanceTimersToNextTimerAsync();
+
+        expect(output.chunks).toEqual([frame]);
+      } finally {
+        vitest.useRealTimers();
+      }
+    });
+
+    it('immediately drops frame and emits error if no key set', async () => {
+      vitest.useFakeTimers();
+      try {
+        const { cryptor, input, output } = prepareParticipantTestEncoder(participantIdentity, {});
+
+        const errorListener = vitest.fn();
+        cryptor.on(CryptorEvent.Error, errorListener);
+
+        const frame = mockRTCEncodedVideoFrame(new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]));
 
-  it('drops frames when invalid key', async () => {
-    vitest.useFakeTimers();
-    try {
-      const { keys, input, output } = prepareParticipantTestDecoder(participantIdentity, {
-        failureTolerance: 0,
-      });
+        input.write(frame);
+        await vitest.advanceTimersToNextTimerAsync();
 
-      expect(keys.hasValidKey).toBe(true);
+        expect(output.chunks).toEqual([]);
+        expect(errorListener).toHaveBeenCalled();
+      } finally {
+        vitest.useRealTimers();
+      }
+    });
+
+    it('encrypts frame', async () => {
+      vitest.useFakeTimers();
+      try {
+        const { keys, input, output } = prepareParticipantTestEncoder(participantIdentity, {});
+
+        await keys.setKey(await createKeyMaterialFromString('key1'), 1);
 
-      await keys.setKey(await createKeyMaterialFromString('password'), 0);
+        const plainTextData = new Uint8Array([
+          1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+        ]);
+        const frame = mockRTCEncodedVideoFrame(plainTextData);
 
-      input.write(mockEncryptedRTCEncodedVideoFrame(1));
-      await vitest.advanceTimersToNextTimerAsync();
+        input.write(frame);
+        await vitest.waitFor(() => expect(output.chunks).toHaveLength(1));
 
-      expect(output.chunks).toEqual([]);
-      expect(keys.hasValidKey).toBe(false);
+        expect(output.chunks).toEqual([frame]);
+        expect(frame.data.byteLength).toBeGreaterThan(16);
 
-      // this should still fail as keys are all marked as invalid
-      input.write(mockEncryptedRTCEncodedVideoFrame(0));
-      await vitest.advanceTimersToNextTimerAsync();
+        // first bytes are unencrypted
+        expect(new Uint8Array(frame.data.slice(0, 10))).toEqual(plainTextData.subarray(0, 10));
 
-      expect(output.chunks).toEqual([]);
-      expect(keys.hasValidKey).toBe(false);
-    } finally {
-      vitest.useRealTimers();
-    }
+        // remainder should not be the same
+        expect(new Uint8Array(frame.data.slice(10, 16))).not.toEqual(
+          plainTextData.subarray(10, 16),
+        );
+
+        const frameTrailer = new Uint8Array(frame.data.slice(frame.data.byteLength - 2));
+        // IV length
+        expect(frameTrailer[0]).toEqual(IV_LENGTH);
+        // key index
+        expect(frameTrailer[1]).toEqual(1);
+      } finally {
+        vitest.useRealTimers();
+      }
+    });
   });
 
-  it('marks key invalid after too many failures', async () => {
-    const { keys, cryptor, input } = prepareParticipantTestDecoder(participantIdentity, {
-      failureTolerance: 1,
+  describe('decode', () => {
+    afterEach(() => {
+      encryptionEnabledMap.clear();
     });
 
-    expect(keys.hasValidKey).toBe(true);
+    it('passthrough if participant encryption disabled', async () => {
+      vitest.useFakeTimers();
+      try {
+        const { input, output } = prepareParticipantTestDecoder(participantIdentity, {});
 
-    await keys.setKey(await createKeyMaterialFromString('password'), 0);
+        // disable encryption for participant
+        encryptionEnabledMap.set(participantIdentity, false);
 
-    vitest.spyOn(keys, 'getKeySet');
-    vitest.spyOn(keys, 'decryptionFailure');
+        const frame = mockEncryptedRTCEncodedVideoFrame(1);
 
-    const errorListener = vitest.fn().mockImplementation((e) => {
-      console.log('error', e);
+        input.write(frame);
+        await vitest.advanceTimersToNextTimerAsync();
+
+        expect(output.chunks).toEqual([frame]);
+      } finally {
+        vitest.useRealTimers();
+      }
     });
-    cryptor.on(CryptorEvent.Error, errorListener);
 
-    input.write(mockEncryptedRTCEncodedVideoFrame(1));
+    it('passthrough for empty frame', async () => {
+      vitest.useFakeTimers();
+      try {
+        const { input, output } = prepareParticipantTestDecoder(participantIdentity, {});
 
-    await vitest.waitFor(() => expect(keys.decryptionFailure).toHaveBeenCalled());
-    expect(errorListener).toHaveBeenCalled();
-    expect(keys.decryptionFailure).toHaveBeenCalledTimes(1);
-    expect(keys.getKeySet).toHaveBeenCalled();
-    expect(keys.getKeySet).toHaveBeenLastCalledWith(1);
-    expect(keys.hasValidKey).toBe(true);
+        // empty frame
+        const frame = mockRTCEncodedVideoFrame(new Uint8Array(0));
 
-    vitest.clearAllMocks();
+        input.write(frame);
+        await vitest.advanceTimersToNextTimerAsync();
 
-    input.write(mockEncryptedRTCEncodedVideoFrame(1));
+        expect(output.chunks).toEqual([frame]);
+      } finally {
+        vitest.useRealTimers();
+      }
+    });
 
-    await vitest.waitFor(() => expect(keys.decryptionFailure).toHaveBeenCalled());
-    expect(errorListener).toHaveBeenCalled();
-    expect(keys.decryptionFailure).toHaveBeenCalledTimes(1);
-    expect(keys.getKeySet).toHaveBeenCalled();
-    expect(keys.getKeySet).toHaveBeenLastCalledWith(1);
-    expect(keys.hasValidKey).toBe(false);
+    it('immediately drops frames when key marked invalid', async () => {
+      vitest.useFakeTimers();
+      try {
+        const { keys, input, output } = prepareParticipantTestDecoder(participantIdentity, {
+          failureTolerance: 0,
+        });
 
-    vitest.clearAllMocks();
+        keys.decryptionFailure();
 
-    // this should still fail as keys are all marked as invalid
-    input.write(mockEncryptedRTCEncodedVideoFrame(0));
+        input.write(mockEncryptedRTCEncodedVideoFrame(1));
+        await vitest.advanceTimersToNextTimerAsync();
 
-    await vitest.waitFor(() => expect(keys.getKeySet).toHaveBeenCalled());
-    // decryptionFailure() isn't called in this case
-    expect(keys.getKeySet).toHaveBeenCalled();
-    expect(keys.getKeySet).toHaveBeenLastCalledWith(0);
-    expect(keys.hasValidKey).toBe(false);
-  });
+        expect(output.chunks).toEqual([]);
 
-  it('mark as valid when a new key is set on same index', async () => {
-    const { keys, input } = prepareParticipantTestDecoder(participantIdentity, {
-      failureTolerance: 0,
-    });
+        keys.decryptionFailure();
 
-    const material = await createKeyMaterialFromString('password');
-    await keys.setKey(material, 0);
+        input.write(mockEncryptedRTCEncodedVideoFrame(0));
+        await vitest.advanceTimersToNextTimerAsync();
 
-    expect(keys.hasValidKey).toBe(true);
+        expect(output.chunks).toEqual([]);
+      } finally {
+        vitest.useRealTimers();
+      }
+    });
 
-    input.write(mockEncryptedRTCEncodedVideoFrame(1));
+    it('calls decryptionFailure on missing key and emits error', async () => {
+      vitest.useFakeTimers();
+      try {
+        const { cryptor, keys, input } = prepareParticipantTestDecoder(participantIdentity, {});
+
+        const errorListener = vitest.fn();
+        cryptor.on(CryptorEvent.Error, errorListener);
+        vitest.spyOn(keys, 'decryptionFailure');
+
+        // no key is set at this index
+        input.write(mockEncryptedRTCEncodedVideoFrame(1));
+        await vitest.advanceTimersToNextTimerAsync();
+
+        expect(keys.decryptionFailure).toHaveBeenCalledTimes(1);
+        expect(keys.decryptionFailure).toHaveBeenCalledWith(1);
+        expect(errorListener).toHaveBeenCalled();
+      } finally {
+        vitest.useRealTimers();
+      }
+    });
 
-    expect(keys.hasValidKey).toBe(false);
+    it('immediately drops frame if no key', async () => {
+      vitest.useFakeTimers();
+      try {
+        const { input, output } = prepareParticipantTestDecoder(participantIdentity, {});
 
-    await keys.setKey(material, 0);
+        vitest.spyOn(crypto.subtle, 'decrypt');
 
-    expect(keys.hasValidKey).toBe(true);
-  });
+        input.write(mockEncryptedRTCEncodedVideoFrame(1));
+        await vitest.advanceTimersToNextTimerAsync();
 
-  it('mark as valid when a new key is set on new index', async () => {
-    const { keys, input } = prepareParticipantTestDecoder(participantIdentity, {
-      failureTolerance: 0,
+        expect(crypto.subtle.decrypt).not.toHaveBeenCalled();
+        expect(output.chunks).toEqual([]);
+      } finally {
+        vitest.useRealTimers();
+      }
     });
 
-    const material = await createKeyMaterialFromString('password');
-    await keys.setKey(material, 0);
+    it('calls decryptionFailure with incorrect key and emits error', async () => {
+      vitest.useFakeTimers();
+      try {
+        const { cryptor, keys, input, output } = prepareParticipantTestDecoder(
+          participantIdentity,
+          { ratchetWindowSize: 0 },
+        );
+
+        vitest.spyOn(crypto.subtle, 'decrypt');
+        vitest.spyOn(keys, 'decryptionFailure');
+        const errorListener = vitest.fn();
+        cryptor.on(CryptorEvent.Error, errorListener);
+
+        await keys.setKey(await createKeyMaterialFromString('incorrect key'), 1);
+
+        const frame = mockRTCEncodedVideoFrame(
+          new Uint8Array([
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 254, 96, 91, 111, 187, 132, 31, 12, 207, 136, 17, 221,
+            233, 116, 174, 6, 50, 37, 214, 71, 119, 196, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255,
+            199, 51, 12, 1,
+          ]),
+        );
+        // global.RTCEncodedAudioFrame = vitest.fn();
+        input.write(frame);
+        await vitest.waitFor(() => expect(keys.decryptionFailure).toHaveBeenCalled());
+
+        expect(crypto.subtle.decrypt).toHaveBeenCalled();
+        expect(output.chunks).toEqual([]);
+        expect(errorListener).toHaveBeenCalled();
+        expect(keys.decryptionFailure).toHaveBeenCalledTimes(1);
+        expect(keys.decryptionFailure).toHaveBeenCalledWith(1);
+      } finally {
+        vitest.useRealTimers();
+      }
+    });
+
+    it('decrypts frame with correct key', async () => {
+      vitest.useFakeTimers();
+      try {
+        const { keys, input, output } = prepareParticipantTestDecoder(participantIdentity, {});
+
+        vitest.spyOn(keys, 'decryptionSuccess');
 
-    expect(keys.hasValidKey).toBe(true);
+        await keys.setKey(await createKeyMaterialFromString('key1'), 1);
 
-    input.write(mockEncryptedRTCEncodedVideoFrame(1));
+        const frame = mockRTCEncodedVideoFrame(
+          new Uint8Array([
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 254, 96, 91, 111, 187, 132, 31, 12, 207, 136, 17, 221,
+            233, 116, 174, 6, 50, 37, 214, 71, 119, 196, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255,
+            199, 51, 12, 1,
+          ]),
+        );
+        input.write(frame);
+        await vitest.waitFor(() => expect(output.chunks).toHaveLength(1));
 
-    expect(keys.hasValidKey).toBe(false);
+        expect(output.chunks).toEqual([frame]);
 
-    await keys.setKey(material, 1);
+        expect(keys.decryptionSuccess).toHaveBeenCalledTimes(1);
+        expect(keys.decryptionSuccess).toHaveBeenCalledWith(1);
 
-    expect(keys.hasValidKey).toBe(true);
+        expect(frame.data.byteLength).toBe(16);
+
+        expect(new Uint8Array(frame.data)).toEqual(
+          new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]),
+        );
+      } finally {
+        vitest.useRealTimers();
+      }
+    });
+
+    it('recovers from delayed use of rotated key', async () => {
+      vitest.useFakeTimers();
+      try {
+        // 1. we (the local participant) have just joined a room and do not have the existing key (index 0) for the existing/remote participant
+        const { keys, input, output } = prepareParticipantTestDecoder(participantIdentity, {
+          failureTolerance: 1,
+          ratchetWindowSize: 0,
+        });
+        vitest.spyOn(keys, 'decryptionFailure');
+
+        // 2. we receive some frames from the existing participant encrypted with the existing key 0 that we don't have
+        input.write(mockEncryptedRTCEncodedVideoFrame(0));
+        input.write(mockEncryptedRTCEncodedVideoFrame(0));
+        input.write(mockEncryptedRTCEncodedVideoFrame(0));
+        input.write(mockEncryptedRTCEncodedVideoFrame(0));
+
+        // 3. we should have marked key at index 0 as invalid by now and dropped all the frames
+        await vitest.waitFor(() => expect(keys.decryptionFailure).toHaveBeenCalledTimes(2));
+        expect(keys.hasInvalidKeyAtIndex(0)).toBe(true);
+        expect(output.chunks).toEqual([]);
+
+        // 4. the existing participant then notices that we have joined the room and generates a new key (with a new key index 1)
+        // and distributes it out of band to us
+        await keys.setKey(await createKeyMaterialFromString('key1'), 1);
+
+        // 5. the existing participant waits a period of time before using the new key and continues sending media using the previous key 0.
+        // we receive these frames and should drop them as we still don't have the key.
+        input.write(mockEncryptedRTCEncodedVideoFrame(0));
+        input.write(mockEncryptedRTCEncodedVideoFrame(0));
+        input.write(mockEncryptedRTCEncodedVideoFrame(0));
+        input.write(mockEncryptedRTCEncodedVideoFrame(0));
+
+        await vitest.advanceTimersToNextTimerAsync();
+        expect(output.chunks).toEqual([]);
+
+        // 6. the existing participant moves over to the new key index 1 and we start to receive frames for index 1 that we
+        // should be able to decrypt even though we had the previous failures.
+        input.write(
+          mockRTCEncodedVideoFrame(
+            new Uint8Array([
+              1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 254, 96, 91, 111, 187, 132, 31, 12, 207, 136, 17, 221,
+              233, 116, 174, 6, 50, 37, 214, 71, 119, 196, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255,
+              199, 51, 12, 1,
+            ]),
+          ),
+        );
+
+        input.write(
+          mockRTCEncodedVideoFrame(
+            new Uint8Array([
+              99, 2, 3, 4, 5, 6, 7, 8, 9, 10, 154, 108, 209, 239, 253, 33, 72, 111, 13, 125, 10,
+              101, 28, 209, 141, 162, 0, 238, 189, 254, 66, 156, 255, 255, 255, 255, 0, 0, 0, 0,
+              255, 255, 96, 247, 12, 1,
+            ]),
+          ),
+        );
+
+        await vitest.waitFor(() => expect(output.chunks.length).toEqual(2));
+
+        expect(new Uint8Array(output.chunks[0].data)).toEqual(
+          new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]),
+        );
+        expect(new Uint8Array(output.chunks[1].data)).toEqual(
+          new Uint8Array([99, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]),
+        );
+      } finally {
+        vitest.useRealTimers();
+      }
+    });
   });
 });

package/src/e2ee/worker/FrameCryptor.ts

@@ -357,10 +357,15 @@ export class FrameCryptor extends BaseFrameCryptor {
     const data = new Uint8Array(encodedFrame.data);
     const keyIndex = data[encodedFrame.data.byteLength - 1];
 
-    if (this.keys.getKeySet(keyIndex) && this.keys.hasValidKey) {
+    if (this.keys.hasInvalidKeyAtIndex(keyIndex)) {
+      // drop frame
+      return;
+    }
+
+    if (this.keys.getKeySet(keyIndex)) {
       try {
         const decodedFrame = await this.decryptFrame(encodedFrame, keyIndex);
-        this.keys.decryptionSuccess();
+        this.keys.decryptionSuccess(keyIndex);
         if (decodedFrame) {
           return controller.enqueue(decodedFrame);
         }
@@ -369,13 +374,13 @@ export class FrameCryptor extends BaseFrameCryptor {
           // emit an error if the key handler thinks we have a valid key
           if (this.keys.hasValidKey) {
             this.emit(CryptorEvent.Error, error);
-            this.keys.decryptionFailure();
+            this.keys.decryptionFailure(keyIndex);
           }
         } else {
           workerLogger.warn('decoding frame failed', { error });
         }
       }
-    } else if (!this.keys.getKeySet(keyIndex) && this.keys.hasValidKey) {
+    } else {
       // emit an error if the key index is out of bounds but the key handler thinks we still have a valid key
       workerLogger.warn(`skipping decryption due to missing key at index ${keyIndex}`);
       this.emit(
@@ -386,7 +391,7 @@ export class FrameCryptor extends BaseFrameCryptor {
           this.participantIdentity,
         ),
       );
-      this.keys.decryptionFailure();
+      this.keys.decryptionFailure(keyIndex);
     }
   }