livekit-client 2.22.3 → 2.23.0

package/dist/livekit-client.e2ee.worker.mjs

@@ -4790,7 +4790,7 @@ var RoomEvent;
    * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
    * All participants in the room will receive the messages sent to the room.
    *
-   * args: (payload: NonSharedUint8Array, participant: [[Participant]], kind: [[DataPacket_Kind]], topic?: string)
+   * args: (payload: NonSharedUint8Array, participant: [[Participant]] | undefined, kind: [[DataPacket_Kind]], topic?: string, encryptionType?: Encryption_Type, participantIdentity?: string)
    */
   RoomEvent["DataReceived"] = "dataReceived";
   /**
@@ -5148,6 +5148,7 @@ var EngineEvent;
   EngineEvent["Joined"] = "joined";
   EngineEvent["TokenRefreshed"] = "tokenRefreshed";
   EngineEvent["ServerRegionsReported"] = "serverRegionsReported";
+  EngineEvent["RequestSubscribedCodecRefresh"] = "requestSubscribedCodecRefresh";
 })(EngineEvent || (EngineEvent = {}));
 var TrackEvent;
 (function (TrackEvent) {
@@ -6585,8 +6586,14 @@ function isH265SliceNALU(naluType) {
  * @returns Detected codec type
  */
 function detectCodecFromNALUs(data, naluIndices) {
+  // h264 runs to completion first. Several non-slice h264 NALUs read as h265 slice types
+  // (AUD 0x09 -> STSA_N, SEI 0x06 -> TSA_R), so interleaving the two checks lets one of
+  // those outrank the real h264 slice that follows it. The reverse cannot happen: h265
+  // header bytes are even at nuh_layer_id 0, so they never mask to an h264 slice type.
   for (const naluIndex of naluIndices) {
     if (isH264SliceNALU(parseH264NALUType(data[naluIndex]))) return 'h264';
+  }
+  for (const naluIndex of naluIndices) {
     if (isH265SliceNALU(parseH265NALUType(data[naluIndex]))) return 'h265';
   }
   return 'unknown';
@@ -6664,12 +6671,21 @@ function findNALUIndices(stream) {
 /**
  * Process NALU data for frame encryption, detecting codec and finding unencrypted bytes
  * @param data Frame data
- * @param knownCodec Known codec from other sources (optional)
+ * @param knownCodec Codec from other sources, used only when the bytes are inconclusive (optional)
  * @returns NALU processing result
  */
 function processNALUsForEncryption(data, knownCodec) {
   const naluIndices = findNALUIndices(data);
-  const detectedCodec = knownCodec !== null && knownCodec !== void 0 ? knownCodec : detectCodecFromNALUs(data, naluIndices);
+  // The bytes outrank knownCodec, which can be the codec the client asked for rather than the
+  // one that was negotiated. Parsing the wrong one mis-slices without raising anything: the
+  // offset lands before the real slice header, so the header itself gets encrypted.
+  // That holds in one direction only. An h264 access unit carrying no slice NALU but carrying
+  // an AUD or SEI that reads as an h265 slice now slices there instead of throwing. No real
+  // WebRTC access unit can reach it, because every one of them carries a type 1 or 5 slice.
+  let detectedCodec = detectCodecFromNALUs(data, naluIndices);
+  if (detectedCodec === 'unknown') {
+    detectedCodec = knownCodec !== null && knownCodec !== void 0 ? knownCodec : 'unknown';
+  }
   if (detectedCodec === 'unknown') {
     return {
       unencryptedBytes: 0,
@@ -6687,6 +6703,44 @@ function processNALUsForEncryption(data, knownCodec) {
     requiresNALUProcessing: true
   };
 }
+/**
+ * Rewrite every 3-byte Annex B start code (00 00 01) in `data` to the 4-byte form (00 00 00 01).
+ *
+ * WebRTC's H.264/H.265 depacketizer always reconstructs NALUs with 4-byte start codes, regardless
+ * of what the encoder emitted. Some encoders (e.g. Intel Quick Sync) emit 3-byte start codes, so
+ * the unencrypted header a receiver sees would differ from what the sender authenticated as
+ * AES-GCM additionalData. Normalizing on the sender makes both sides agree.
+ *
+ * Returns `data` unchanged (same instance) when it contains no 3-byte start codes.
+ */
+function normalizeAnnexBStartCodes(data) {
+  const shortStartCodes = [];
+  for (let i = 0; i + 2 < data.length;) {
+    if (data[i + 2] === 0) {
+      i += 1;
+      continue;
+    }
+    if (data[i + 2] === 1 && data[i] === 0 && data[i + 1] === 0 && (i === 0 || data[i - 1] !== 0)) {
+      shortStartCodes.push(i);
+    }
+    // data[i + 2] is non-zero, so no start code can begin at i + 1 or i + 2 either.
+    i += 3;
+  }
+  if (shortStartCodes.length === 0) {
+    return data;
+  }
+  // The new array is zero-filled, so the one-byte gap left before each short start code becomes
+  // the inserted leading 00.
+  const result = new Uint8Array(data.length + shortStartCodes.length);
+  let from = 0;
+  for (let inserted = 0; inserted < shortStartCodes.length; inserted++) {
+    const to = shortStartCodes[inserted];
+    result.set(data.subarray(from, to), from + inserted);
+    from = to;
+  }
+  result.set(data.subarray(from), from + shortStartCodes.length);
+  return result;
+}
 
 /**
  * Create a crypto hash using Web Crypto API for secure comparison operations
@@ -7060,7 +7114,12 @@ class FrameCryptor extends BaseFrameCryptor {
         const iv = this.makeIV((_a = encodedFrame.getMetadata().synchronizationSource) !== null && _a !== void 0 ? _a : -1, encodedFrame.timestamp);
         let frameInfo = this.getUnencryptedBytes(encodedFrame);
         // Thіs is not encrypted and contains the VP8 payload descriptor or the Opus TOC byte.
-        const frameHeader = new Uint8Array(encodedFrame.data, 0, frameInfo.unencryptedBytes);
+        let frameHeader = new Uint8Array(encodedFrame.data, 0, frameInfo.unencryptedBytes);
+        if (frameInfo.requiresNALUProcessing) {
+          // The receiver's depacketizer rebuilds NALUs with 4-byte start codes, so authenticate (and
+          // send) the header in that form or decryption fails for encoders emitting 3-byte ones.
+          frameHeader = normalizeAnnexBStartCodes(frameHeader);
+        }
         // Frame trailer contains the R|IV_LENGTH and key index
         const frameTrailer = new Uint8Array(2);
         frameTrailer[0] = IV_LENGTH;
@@ -7076,7 +7135,7 @@ class FrameCryptor extends BaseFrameCryptor {
           const cipherText = yield crypto.subtle.encrypt({
             name: ENCRYPTION_ALGORITHM,
             iv,
-            additionalData: new Uint8Array(encodedFrame.data, 0, frameHeader.byteLength)
+            additionalData: frameHeader
           }, encryptionKey, new Uint8Array(encodedFrame.data, frameInfo.unencryptedBytes));
           let newDataWithoutHeader = new Uint8Array(cipherText.byteLength + iv.byteLength + frameTrailer.byteLength);
           newDataWithoutHeader.set(new Uint8Array(cipherText)); // add ciphertext.
@@ -7385,7 +7444,7 @@ class FrameCryptor extends BaseFrameCryptor {
         };
       }
     } catch (e) {
-      this.logNALUFallbackOnce(fallbackKey, payloadType, e);
+      this.logNALUFallbackOnce(fallbackKey, frame, payloadType, detectedCodec, e);
     }
     // Fallback to VP8 handling
     return {
@@ -7397,14 +7456,18 @@ class FrameCryptor extends BaseFrameCryptor {
    * Logs a NALU processing fallback at most once per (participant, trackId, payloadType) tuple,
    * so a persistent bad state doesn't flood the console (Firefox doesn't filter debug).
    */
-  logNALUFallbackOnce(fallbackKey, payloadType, error) {
+  logNALUFallbackOnce(fallbackKey, frame, payloadType, detectedCodec, error) {
     if (this.loggedNALUFallbacks.has(fallbackKey)) {
       return;
     }
     this.loggedNALUFallbacks.add(fallbackKey);
     workerLogger.warn('NALU processing failed, falling back to VP8 handling', Object.assign({
       error,
-      payloadType
+      payloadType,
+      detectedCodec,
+      frameType: frame.type,
+      byteLength: frame.data.byteLength,
+      firstBytes: Array.from(new Uint8Array(frame.data, 0, Math.min(16, frame.data.byteLength))).map(b => b.toString(16).padStart(2, '0')).join(' ')
     }, this.logContext));
   }
   /**