@livekit/react-native 2.4.3 → 2.5.1

package/src/e2ee/RNE2EEManager.ts

@@ -0,0 +1,199 @@
+import {
+  RTCFrameCryptorAlgorithm,
+  RTCFrameCryptorFactory,
+  RTCRtpReceiver,
+  type RTCFrameCryptor,
+  type RTCRtpSender,
+} from '@livekit/react-native-webrtc';
+import {
+  LocalParticipant,
+  LocalTrackPublication,
+  ParticipantEvent,
+  RemoteParticipant,
+  RemoteTrackPublication,
+  RoomEvent,
+  type Room,
+  type BaseE2EEManager,
+  type E2EEManagerCallbacks,
+  EncryptionEvent,
+} from 'livekit-client';
+import type RNKeyProvider from './RNKeyProvider';
+import type RTCEngine from 'livekit-client/dist/src/room/RTCEngine';
+import EventEmitter from 'events';
+import type TypedEventEmitter from 'typed-emitter';
+
+/**
+ * @experimental
+ */
+export default class RNE2EEManager
+  extends (EventEmitter as new () => TypedEventEmitter<E2EEManagerCallbacks>)
+  implements BaseE2EEManager
+{
+  private room?: Room;
+  private frameCryptors: Map<string, RTCFrameCryptor> = new Map();
+  private keyProvider: RNKeyProvider;
+  private algorithm: RTCFrameCryptorAlgorithm =
+    RTCFrameCryptorAlgorithm.kAesGcm;
+
+  private encryptionEnabled: boolean = false;
+
+  constructor(keyProvider: RNKeyProvider) {
+    super();
+    this.keyProvider = keyProvider;
+    this.encryptionEnabled = false;
+  }
+
+  setup(room: Room) {
+    if (this.room !== room) {
+      this.room = room;
+      this.setupEventListeners(room);
+    }
+  }
+
+  private setupEventListeners(room: Room) {
+    room.localParticipant
+      .on(ParticipantEvent.LocalTrackPublished, async (publication) => {
+        this.setupE2EESender(publication, room.localParticipant);
+      })
+      .on(ParticipantEvent.LocalTrackUnpublished, async (publication) => {
+        let frameCryptor = this.findTrackCryptor(publication.trackSid);
+        if (frameCryptor) {
+          this.frameCryptors.delete(publication.trackSid);
+          await frameCryptor.setEnabled(false);
+          await frameCryptor.dispose();
+        }
+      });
+
+    room
+      .on(RoomEvent.TrackSubscribed, (_track, pub, participant) => {
+        this.setupE2EEReceiver(pub, participant);
+      })
+      .on(
+        RoomEvent.TrackUnsubscribed,
+        async (_track, publication, _participant) => {
+          let frameCryptor = this.findTrackCryptor(publication.trackSid);
+          if (frameCryptor) {
+            this.frameCryptors.delete(publication.trackSid);
+            await frameCryptor.setEnabled(false);
+            await frameCryptor.dispose();
+          }
+        }
+      );
+  }
+
+  private async setupE2EESender(
+    publication: LocalTrackPublication,
+    participant: LocalParticipant
+  ) {
+    if (!publication.isEncrypted) {
+      return;
+    }
+
+    var frameCryptor = this.findTrackCryptor(publication.trackSid);
+
+    if (!frameCryptor) {
+      frameCryptor = this.createFrameCryptorForSender(
+        publication.track!.sender,
+        participant.identity
+      );
+
+      this.frameCryptors.set(publication.trackSid, frameCryptor);
+      frameCryptor.setEnabled(true);
+      frameCryptor.setKeyIndex(
+        this.keyProvider.getLatestKeyIndex(participant.identity)
+      );
+    }
+  }
+
+  private async setupE2EEReceiver(
+    publication: RemoteTrackPublication,
+    participant: RemoteParticipant
+  ) {
+    if (!publication.isEncrypted) {
+      return;
+    }
+
+    var frameCryptor = this.findTrackCryptor(publication.trackSid);
+
+    if (!frameCryptor) {
+      frameCryptor = this.createFrameCryptorForReceiver(
+        publication.track!.receiver,
+        participant.identity
+      );
+
+      this.frameCryptors.set(publication.trackSid, frameCryptor);
+      frameCryptor.setEnabled(true);
+      frameCryptor.setKeyIndex(
+        this.keyProvider.getLatestKeyIndex(participant.identity)
+      );
+    }
+  }
+
+  setSifTrailer(trailer: Uint8Array): void {
+    this.keyProvider.setSifTrailer(trailer);
+  }
+
+  // Utility methods
+  //////////////////////
+
+  private findTrackCryptor(trackId: string): RTCFrameCryptor | undefined {
+    return this.frameCryptors.get(trackId);
+  }
+
+  private createFrameCryptorForSender(
+    sender: RTCRtpSender,
+    participantId: string
+  ): RTCFrameCryptor {
+    return RTCFrameCryptorFactory.createFrameCryptorForRtpSender(
+      participantId,
+      sender,
+      this.algorithm,
+      this.keyProvider.rtcKeyProvider
+    );
+  }
+
+  private createFrameCryptorForReceiver(
+    receiver: RTCRtpReceiver,
+    participantId: string
+  ): RTCFrameCryptor {
+    return RTCFrameCryptorFactory.createFrameCryptorForRtpReceiver(
+      participantId,
+      receiver,
+      this.algorithm,
+      this.keyProvider.rtcKeyProvider
+    );
+  }
+
+  setupEngine(_engine: RTCEngine): void {
+    // No-op
+  }
+  setParticipantCryptorEnabled(
+    enabled: boolean,
+    participantIdentity: string
+  ): void {
+    if (
+      this.encryptionEnabled !== enabled &&
+      participantIdentity === this.room?.localParticipant.identity
+    ) {
+      this.encryptionEnabled = enabled;
+      this.emit(
+        EncryptionEvent.ParticipantEncryptionStatusChanged,
+        enabled,
+        this.room!.localParticipant
+      );
+    } else {
+      const participant =
+        this.room?.getParticipantByIdentity(participantIdentity);
+      if (!participant) {
+        throw TypeError(
+          `couldn't set encryption status, participant not found ${participantIdentity}`
+        );
+      }
+      this.emit(
+        EncryptionEvent.ParticipantEncryptionStatusChanged,
+        enabled,
+        participant
+      );
+    }
+  }
+}

package/src/e2ee/RNKeyProvider.ts

@@ -0,0 +1,116 @@
+import { BaseKeyProvider, type KeyProviderOptions } from 'livekit-client';
+import {
+  RTCFrameCryptorFactory,
+  RTCKeyProvider,
+  type RTCKeyProviderOptions,
+} from '@livekit/react-native-webrtc';
+
+const defaultRatchetSalt = 'LKFrameEncryptionKey';
+const defaultMagicBytes = 'LK-ROCKS';
+const defaultRatchetWindowSize = 16;
+const defaultFailureTolerance = -1;
+const defaultKeyRingSize = 16;
+const defaultDiscardFrameWhenCryptorNotReady = false;
+
+/**
+ * Options for construction an RNKeyProvider
+ */
+export type RNKeyProviderOptions = KeyProviderOptions & {
+  uncryptedMagicBytes?: string | Uint8Array;
+};
+
+/**
+ * @experimental
+ */
+export default class RNKeyProvider extends BaseKeyProvider {
+  private latestSetIndex: Map<string, number> = new Map();
+  private nativeKeyProvider: RTCKeyProvider;
+
+  constructor(options: Partial<RNKeyProviderOptions>) {
+    const opts: RTCKeyProviderOptions & KeyProviderOptions = {
+      sharedKey: options.sharedKey ?? true,
+      ratchetSalt: options.ratchetSalt ?? defaultRatchetSalt,
+      ratchetWindowSize: options.ratchetWindowSize ?? defaultRatchetWindowSize,
+      failureTolerance: options.failureTolerance ?? defaultFailureTolerance,
+      keyRingSize: options.keyringSize ?? defaultKeyRingSize,
+      keyringSize: options.keyringSize ?? defaultKeyRingSize,
+      discardFrameWhenCryptorNotReady: defaultDiscardFrameWhenCryptorNotReady,
+    };
+
+    let magicBytes = options.uncryptedMagicBytes ?? defaultMagicBytes;
+    if (typeof magicBytes === 'string') {
+      magicBytes = new TextEncoder().encode(magicBytes);
+    }
+    opts.uncryptedMagicBytes = magicBytes;
+
+    super(opts);
+
+    this.nativeKeyProvider =
+      RTCFrameCryptorFactory.createDefaultKeyProvider(opts);
+  }
+
+  getLatestKeyIndex(participantId: string) {
+    return this.latestSetIndex.get(participantId) ?? 0;
+  }
+
+  /**
+   * Accepts a passphrase that's used to create the crypto keys.
+   * @param key
+   */
+  async setSharedKey(key: string | Uint8Array, keyIndex?: number) {
+    return this.nativeKeyProvider.setSharedKey(key, keyIndex);
+  }
+
+  async ratchetSharedKey(keyIndex?: number) {
+    this.nativeKeyProvider.ratchetSharedKey(keyIndex);
+  }
+
+  /**
+   * Accepts a passphrase that's used to create the crypto keys for a participant's stream.
+   * @param key
+   */
+  async setKey(
+    participantId: string,
+    key: string | Uint8Array,
+    keyIndex?: number
+  ) {
+    if (this.getOptions().sharedKey) {
+      return this.setSharedKey(key, keyIndex);
+    }
+
+    this.latestSetIndex.set(participantId, keyIndex ?? 0);
+    return this.nativeKeyProvider.setKey(participantId, key, keyIndex);
+  }
+
+  override async ratchetKey(participantIdentity?: string, keyIndex?: number) {
+    if (!this.getOptions().sharedKey && participantIdentity) {
+      this.nativeKeyProvider.ratchetKey(participantIdentity, keyIndex);
+    } else {
+      this.ratchetSharedKey(keyIndex);
+    }
+  }
+
+  async setSifTrailer(trailer: Uint8Array) {
+    return this.nativeKeyProvider.setSifTrailer(trailer);
+  }
+
+  /**
+   * @internal
+   */
+  get rtcKeyProvider() {
+    return this.nativeKeyProvider;
+  }
+
+  dispose() {
+    this.nativeKeyProvider.dispose();
+  }
+}
+
+// /**
+//  * Define the `onxxx` event handlers.
+//  */
+// const proto = RNExternalE2EEKeyProvider.prototype;
+
+// defineEventAttribute(proto, KeyProviderEvent.SetKey);
+// defineEventAttribute(proto, KeyProviderEvent.RatchetRequest);
+// defineEventAttribute(proto, KeyProviderEvent.KeyRatcheted);

package/src/hooks/useE2EEManager.ts

@@ -0,0 +1,49 @@
+import RNE2EEManager from '../e2ee/RNE2EEManager';
+import { log, RNKeyProvider } from '..';
+import { useEffect, useState } from 'react';
+import type { RNKeyProviderOptions } from '../e2ee/RNKeyProvider';
+
+export type UseRNE2EEManagerOptions = {
+  keyProviderOptions?: RNKeyProviderOptions;
+  sharedKey: string | Uint8Array;
+};
+
+export interface RNE2EEManagerState {
+  keyProvider: RNKeyProvider;
+  e2eeManager: RNE2EEManager;
+}
+
+/**
+ * @experimental
+ */
+export function useRNE2EEManager(
+  options: UseRNE2EEManagerOptions
+): RNE2EEManagerState {
+  let [keyProvider] = useState(
+    () => new RNKeyProvider(options.keyProviderOptions ?? {})
+  );
+  let [e2eeManager] = useState(() => new RNE2EEManager(keyProvider));
+
+  useEffect(() => {
+    let setup = async () => {
+      try {
+        await keyProvider.setSharedKey(options.sharedKey);
+      } catch (error) {
+        log.warn('unable to set shared key', error);
+      }
+    };
+    setup();
+    return () => {};
+  }, [keyProvider, options.sharedKey]);
+
+  useEffect(() => {
+    return () => {
+      keyProvider.dispose();
+    };
+  }, [keyProvider]);
+
+  return {
+    keyProvider,
+    e2eeManager,
+  };
+}

package/src/hooks.ts

@@ -41,3 +41,5 @@ export type {
 } from '@livekit/components-react';
 
 export type { ReceivedDataMessage } from '@livekit/components-core';
+export * from './hooks/useE2EEManager';
+export type { UseRNE2EEManagerOptions } from './hooks/useE2EEManager';

package/src/index.tsx

@@ -15,6 +15,8 @@ import type { AudioConfiguration } from './audio/AudioSession';
 import { PixelRatio, Platform } from 'react-native';
 import { type LiveKitReactNativeInfo } from 'livekit-client';
 import type { LogLevel, SetLogLevelOptions } from './logger';
+import RNE2EEManager from './e2ee/RNE2EEManager';
+import RNKeyProvider, { type RNKeyProviderOptions } from './e2ee/RNKeyProvider';
 
 /**
  * Registers the required globals needed for LiveKit to work.
@@ -107,6 +109,8 @@ export * from './audio/AudioManager';
 
 export {
   AudioSession,
+  RNE2EEManager,
+  RNKeyProvider,
   AndroidAudioTypePresets,
   getDefaultAppleAudioConfigurationForMode,
 };
@@ -120,4 +124,5 @@ export type {
   AudioTrackState,
   LogLevel,
   SetLogLevelOptions,
+  RNKeyProviderOptions,
 };