livekit-client 2.0.1 → 2.0.3

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

@@ -987,6 +987,13 @@ class FrameCryptor extends BaseFrameCryptor {
     this.sifTrailer = (_a = opts.sifTrailer) !== null && _a !== void 0 ? _a : Uint8Array.from([]);
     this.sifGuard = new SifGuard();
   }
+  get logContext() {
+    return {
+      identity: this.participantIdentity,
+      trackId: this.trackId,
+      fallbackCodec: this.videoCodec
+    };
+  }
   /**
    * Assign a different participant to the cryptor.
    * useful for transceiver re-use
@@ -999,6 +1006,7 @@ class FrameCryptor extends BaseFrameCryptor {
     this.sifGuard.reset();
   }
   unsetParticipant() {
+    workerLogger.debug('unsetting participant', this.logContext);
     this.participantIdentity = undefined;
   }
   isEnabled() {
@@ -1035,6 +1043,11 @@ class FrameCryptor extends BaseFrameCryptor {
       });
       this.videoCodec = codec;
     }
+    workerLogger.debug('Setting up frame cryptor transform', Object.assign({
+      operation,
+      passedTrackId: trackId,
+      codec
+    }, this.logContext));
     const transformFn = operation === 'encode' ? this.encodeFunction : this.decodeFunction;
     const transformStream = new TransformStream({
       transform: transformFn.bind(this)
@@ -1046,6 +1059,9 @@ class FrameCryptor extends BaseFrameCryptor {
     this.trackId = trackId;
   }
   setSifTrailer(trailer) {
+    workerLogger.debug('setting SIF trailer', Object.assign(Object.assign({}, this.logContext), {
+      trailer
+    }));
     this.sifTrailer = trailer;
   }
   /**
@@ -1089,6 +1105,7 @@ class FrameCryptor extends BaseFrameCryptor {
       if (encryptionKey) {
         const iv = this.makeIV((_a = encodedFrame.getMetadata().synchronizationSource) !== null && _a !== void 0 ? _a : -1, encodedFrame.timestamp);
         let frameInfo = this.getUnencryptedBytes(encodedFrame);
+        workerLogger.debug('frameInfo for encoded frame', Object.assign(Object.assign({}, frameInfo), this.logContext));
         // 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);
         // Frame trailer contains the R|IV_LENGTH and key index
@@ -1125,6 +1142,7 @@ class FrameCryptor extends BaseFrameCryptor {
           workerLogger.error(e);
         }
       } else {
+        workerLogger.debug('failed to decrypt, emitting error', this.logContext);
         this.emit(CryptorEvent.Error, new CryptorError("encryption key missing for encoding", CryptorErrorReason.MissingKey));
       }
     });
@@ -1140,10 +1158,12 @@ class FrameCryptor extends BaseFrameCryptor {
       if (!this.isEnabled() ||
       // skip for decryption for empty dtx frames
       encodedFrame.data.byteLength === 0) {
+        workerLogger.debug('skipping empty frame', this.logContext);
         this.sifGuard.recordUserFrame();
         return controller.enqueue(encodedFrame);
       }
       if (isFrameServerInjected(encodedFrame.data, this.sifTrailer)) {
+        workerLogger.debug('enqueue SIF', this.logContext);
         this.sifGuard.recordSif();
         if (this.sifGuard.isSifAllowed()) {
           encodedFrame.data = encodedFrame.data.slice(0, encodedFrame.data.byteLength - this.sifTrailer.byteLength);
@@ -1162,6 +1182,7 @@ class FrameCryptor extends BaseFrameCryptor {
           const decodedFrame = yield this.decryptFrame(encodedFrame, keyIndex);
           this.keys.decryptionSuccess();
           if (decodedFrame) {
+            workerLogger.debug('enqueue decrypted frame', this.logContext);
             return controller.enqueue(decodedFrame);
           }
         } catch (error) {
@@ -1199,6 +1220,7 @@ class FrameCryptor extends BaseFrameCryptor {
         throw new TypeError("no encryption key found for decryption of ".concat(this.participantIdentity));
       }
       let frameInfo = this.getUnencryptedBytes(encodedFrame);
+      workerLogger.debug('frameInfo for decoded frame', Object.assign(Object.assign({}, frameInfo), this.logContext));
       // Construct frame trailer. Similar to the frame header described in
       // https://tools.ietf.org/html/draft-omara-sframe-00#section-4.2
       // but we put it at the end.
@@ -1361,6 +1383,9 @@ class FrameCryptor extends BaseFrameCryptor {
     // @ts-expect-error payloadType is not yet part of the typescript definition and currently not supported in Safari
     const payloadType = frame.getMetadata().payloadType;
     const codec = payloadType ? this.rtpMap.get(payloadType) : undefined;
+    workerLogger.debug('reading codec from frame', Object.assign({
+      codec
+    }, this.logContext));
     return codec;
   }
 }
@@ -1548,18 +1573,21 @@ class ParticipantKeyHandler extends eventsExports.EventEmitter {
   }
   /**
    * takes in a key material with `deriveBits` and `deriveKey` set as key usages
-   * and derives encryption keys from the material and sets it on the key ring buffer
+   * and derives encryption keys from the material and sets it on the key ring buffers
    * together with the material
    * also updates the currentKeyIndex
    */
-  setKeyFromMaterial(material) {
-    let keyIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  setKeyFromMaterial(material, keyIndex) {
     let emitRatchetEvent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     return __awaiter(this, void 0, void 0, function* () {
-      const newIndex = keyIndex >= 0 ? keyIndex % this.cryptoKeyRing.length : -1;
-      workerLogger.debug("setting new key with index ".concat(newIndex));
       const keySet = yield deriveKeys(material, this.keyProviderOptions.ratchetSalt);
-      this.setKeySet(keySet, newIndex >= 0 ? newIndex : this.currentKeyIndex, emitRatchetEvent);
+      const newIndex = keyIndex >= 0 ? keyIndex % this.cryptoKeyRing.length : this.currentKeyIndex;
+      workerLogger.debug("setting new key with index ".concat(keyIndex), {
+        usage: material.usages,
+        algorithm: material.algorithm,
+        ratchetSalt: this.keyProviderOptions.ratchetSalt
+      });
+      this.setKeySet(keySet, newIndex, emitRatchetEvent);
       if (newIndex >= 0) this.currentKeyIndex = newIndex;
     });
   }
@@ -1594,7 +1622,6 @@ const participantKeys = new Map();
 let sharedKeyHandler;
 let isEncryptionEnabled = false;
 let useSharedKey = false;
-let sharedKey;
 let sifTrailer;
 let keyProviderOptions = KEY_PROVIDER_DEFAULTS;
 workerLogger.setDefaultLevel('info');
@@ -1633,17 +1660,16 @@ onmessage = ev => {
       break;
     case 'setKey':
       if (useSharedKey) {
-        workerLogger.warn('set shared key');
         setSharedKey(data.key, data.keyIndex);
       } else if (data.participantIdentity) {
-        workerLogger.warn("set participant sender key ".concat(data.participantIdentity, " index ").concat(data.keyIndex));
+        workerLogger.info("set participant sender key ".concat(data.participantIdentity, " index ").concat(data.keyIndex));
         getParticipantKeyHandler(data.participantIdentity).setKey(data.key, data.keyIndex);
       } else {
         workerLogger.error('no participant Id was provided and shared key usage is disabled');
       }
       break;
     case 'removeTransform':
-      unsetCryptorParticipant(data.trackId);
+      unsetCryptorParticipant(data.trackId, data.participantIdentity);
       break;
     case 'updateCodec':
       getTrackCryptor(data.participantIdentity, data.trackId).setVideoCodec(data.codec);
@@ -1709,9 +1735,6 @@ function getParticipantKeyHandler(participantIdentity) {
   let keys = participantKeys.get(participantIdentity);
   if (!keys) {
     keys = new ParticipantKeyHandler(participantIdentity, keyProviderOptions);
-    if (sharedKey) {
-      keys.setKey(sharedKey);
-    }
     keys.on(KeyHandlerEvent.KeyRatcheted, emitRatchetedKeys);
     participantKeys.set(participantIdentity, keys);
   }
@@ -1719,20 +1742,32 @@ function getParticipantKeyHandler(participantIdentity) {
 }
 function getSharedKeyHandler() {
   if (!sharedKeyHandler) {
+    workerLogger.debug('creating new shared key handler');
     sharedKeyHandler = new ParticipantKeyHandler('shared-key', keyProviderOptions);
   }
   return sharedKeyHandler;
 }
-function unsetCryptorParticipant(trackId) {
-  var _a;
-  (_a = participantCryptors.find(c => c.getTrackId() === trackId)) === null || _a === void 0 ? void 0 : _a.unsetParticipant();
+function unsetCryptorParticipant(trackId, participantIdentity) {
+  const cryptor = participantCryptors.find(c => c.getParticipantIdentity() === participantIdentity && c.getTrackId() === trackId);
+  if (!cryptor) {
+    workerLogger.warn('Could not unset participant on cryptor', {
+      trackId,
+      participantIdentity
+    });
+  } else {
+    cryptor.unsetParticipant();
+  }
 }
 function setEncryptionEnabled(enable, participantIdentity) {
+  workerLogger.debug("setting encryption enabled for all tracks of ".concat(participantIdentity), {
+    enable
+  });
   encryptionEnabledMap.set(participantIdentity, enable);
 }
 function setSharedKey(key, index) {
-  workerLogger.debug('setting shared key');
-  sharedKey = key;
+  workerLogger.info('set shared key', {
+    index
+  });
   getSharedKeyHandler().setKey(key, index);
 }
 function setupCryptorErrorEvents(cryptor) {