livekit-client 1.11.4 → 1.12.1

package/src/e2ee/utils.ts

@@ -0,0 +1,127 @@
+import { videoCodecs } from '../room/track/options';
+import type { VideoCodec } from '../room/track/options';
+import { ENCRYPTION_ALGORITHM } from './constants';
+
+export function isE2EESupported() {
+  return isInsertableStreamSupported() || isScriptTransformSupported();
+}
+
+export function isScriptTransformSupported() {
+  // @ts-ignore
+  return typeof window.RTCRtpScriptTransform !== 'undefined';
+}
+
+export function isInsertableStreamSupported() {
+  return (
+    typeof window.RTCRtpSender !== 'undefined' &&
+    // @ts-ignore
+    typeof window.RTCRtpSender.prototype.createEncodedStreams !== 'undefined'
+  );
+}
+
+export function isVideoFrame(
+  frame: RTCEncodedAudioFrame | RTCEncodedVideoFrame,
+): frame is RTCEncodedVideoFrame {
+  return 'type' in frame;
+}
+
+export async function importKey(
+  keyBytes: Uint8Array | ArrayBuffer,
+  algorithm: string | { name: string } = { name: ENCRYPTION_ALGORITHM },
+  usage: 'derive' | 'encrypt' = 'encrypt',
+) {
+  // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/importKey
+  return crypto.subtle.importKey(
+    'raw',
+    keyBytes,
+    algorithm,
+    false,
+    usage === 'derive' ? ['deriveBits', 'deriveKey'] : ['encrypt', 'decrypt'],
+  );
+}
+
+export async function createKeyMaterialFromString(password: string) {
+  let enc = new TextEncoder();
+
+  const keyMaterial = await crypto.subtle.importKey(
+    'raw',
+    enc.encode(password),
+    {
+      name: 'PBKDF2',
+    },
+    false,
+    ['deriveBits', 'deriveKey'],
+  );
+
+  return keyMaterial;
+}
+
+function getAlgoOptions(algorithmName: string, salt: string) {
+  const textEncoder = new TextEncoder();
+  const encodedSalt = textEncoder.encode(salt);
+  switch (algorithmName) {
+    case 'HKDF':
+      return {
+        name: 'HKDF',
+        salt: encodedSalt,
+        hash: 'SHA-256',
+        info: new ArrayBuffer(128),
+      };
+    case 'PBKDF2': {
+      return {
+        name: 'PBKDF2',
+        salt: encodedSalt,
+        hash: 'SHA-256',
+        iterations: 100000,
+      };
+    }
+    default:
+      throw new Error(`algorithm ${algorithmName} is currently unsupported`);
+  }
+}
+
+/**
+ * Derives a set of keys from the master key.
+ * See https://tools.ietf.org/html/draft-omara-sframe-00#section-4.3.1
+ */
+export async function deriveKeys(material: CryptoKey, salt: string) {
+  const algorithmOptions = getAlgoOptions(material.algorithm.name, salt);
+
+  // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/deriveKey#HKDF
+  // https://developer.mozilla.org/en-US/docs/Web/API/HkdfParams
+  const encryptionKey = await crypto.subtle.deriveKey(
+    algorithmOptions,
+    material,
+    {
+      name: ENCRYPTION_ALGORITHM,
+      length: 128,
+    },
+    false,
+    ['encrypt', 'decrypt'],
+  );
+
+  return { material, encryptionKey };
+}
+
+export function createE2EEKey(): Uint8Array {
+  return window.crypto.getRandomValues(new Uint8Array(32));
+}
+
+export function mimeTypeToVideoCodecString(mimeType: string) {
+  const codec = mimeType.split('/')[1].toLowerCase() as VideoCodec;
+  if (!videoCodecs.includes(codec)) {
+    throw Error(`Video codec not supported: ${codec}`);
+  }
+  return codec;
+}
+
+/**
+ * Ratchets a key. See
+ * https://tools.ietf.org/html/draft-omara-sframe-00#section-4.3.5.1
+ */
+export async function ratchet(material: CryptoKey, salt: string): Promise<ArrayBuffer> {
+  const algorithmOptions = getAlgoOptions(material.algorithm.name, salt);
+
+  // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/deriveBits
+  return crypto.subtle.deriveBits(algorithmOptions, material, 256);
+}

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

@@ -0,0 +1,21 @@
+/**
+ * @jest-environment node
+ */
+import { isFrameServerInjected } from './FrameCryptor';
+
+describe('FrameCryptor', () => {
+  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;
+
+    expect(isFrameServerInjected(frameData, frameTrailer)).toBe(true);
+  });
+  it('identifies server non server injected frame correctly', () => {
+    const frameTrailer = new TextEncoder().encode('LKROCKS');
+    const frameData = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, ...frameTrailer, 10]);
+
+    expect(isFrameServerInjected(frameData.buffer, frameTrailer)).toBe(false);
+    frameData.fill(0);
+    expect(isFrameServerInjected(frameData.buffer, frameTrailer)).toBe(false);
+  });
+});