livekit-client 1.14.1 → 1.14.2

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

@@ -12,7 +12,7 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
-/* global Reflect, Promise */
+/* global Reflect, Promise, SuppressedError, Symbol */
 
 
 function __awaiter(thisArg, _arguments, P, generator) {
@@ -23,7 +23,12 @@ function __awaiter(thisArg, _arguments, P, generator) {
         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
-}
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -793,28 +798,6 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 }
 var eventsExports = events.exports;
 
-var AudioPresets;
-(function (AudioPresets) {
-  AudioPresets.telephone = {
-    maxBitrate: 12000
-  };
-  AudioPresets.speech = {
-    maxBitrate: 20000
-  };
-  AudioPresets.music = {
-    maxBitrate: 32000
-  };
-  AudioPresets.musicStereo = {
-    maxBitrate: 48000
-  };
-  AudioPresets.musicHighQuality = {
-    maxBitrate: 64000
-  };
-  AudioPresets.musicHighQualityStereo = {
-    maxBitrate: 96000
-  };
-})(AudioPresets || (AudioPresets = {}));
-
 function isVideoFrame(frame) {
   return 'type' in frame;
 }
@@ -1183,8 +1166,8 @@ class FrameCryptor extends BaseFrameCryptor {
         }
       } else if (!this.keys.getKeySet(keyIndex) && this.keys.hasValidKey) {
         // emit an error in case 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');
-        this.emit(CryptorEvent.Error, new CryptorError("missing key at index for participant ".concat(this.participantIdentity), CryptorErrorReason.MissingKey));
+        workerLogger.warn("skipping decryption due to missing key at index ".concat(keyIndex));
+        this.emit(CryptorEvent.Error, new CryptorError("missing key at index ".concat(keyIndex, " for participant ").concat(this.participantIdentity), CryptorErrorReason.MissingKey));
       }
     });
   }
@@ -1242,7 +1225,7 @@ class FrameCryptor extends BaseFrameCryptor {
           if (ratchetOpts.ratchetCount < this.keyProviderOptions.ratchetWindowSize) {
             workerLogger.debug("ratcheting key attempt ".concat(ratchetOpts.ratchetCount, " of ").concat(this.keyProviderOptions.ratchetWindowSize, ", for kind ").concat(encodedFrame instanceof RTCEncodedAudioFrame ? 'audio' : 'video'));
             let ratchetedKeySet;
-            if (keySet === this.keys.getKeySet(keyIndex)) {
+            if ((initialMaterial !== null && initialMaterial !== void 0 ? initialMaterial : keySet) === this.keys.getKeySet(keyIndex)) {
               // only ratchet if the currently set key is still the same as the one used to decrypt this frame
               // if not, it might be that a different frame has already ratcheted and we try with that one first
               const newMaterial = yield this.keys.ratchetKey(keyIndex, false);
@@ -1253,22 +1236,21 @@ class FrameCryptor extends BaseFrameCryptor {
               encryptionKey: ratchetedKeySet === null || ratchetedKeySet === void 0 ? void 0 : ratchetedKeySet.encryptionKey
             });
             if (frame && ratchetedKeySet) {
-              this.keys.setKeySet(ratchetedKeySet, keyIndex, true);
-              // decryption was successful, set the new key index to reflect the ratcheted key set
-              this.keys.setCurrentKeyIndex(keyIndex);
+              // before updating the keys, make sure that the keySet used for this frame is still the same as the currently set key
+              // if it's not, a new key might have been set already, which we don't want to override
+              if ((initialMaterial !== null && initialMaterial !== void 0 ? initialMaterial : keySet) === this.keys.getKeySet(keyIndex)) {
+                this.keys.setKeySet(ratchetedKeySet, keyIndex, true);
+                // decryption was successful, set the new key index to reflect the ratcheted key set
+                this.keys.setCurrentKeyIndex(keyIndex);
+              }
             }
             return frame;
           } else {
             /**
-             * Since the key it is first send and only afterwards actually used for encrypting, there were
-             * situations when the decrypting failed due to the fact that the received frame was not encrypted
-             * yet and ratcheting, of course, did not solve the problem. So if we fail RATCHET_WINDOW_SIZE times,
-             * we come back to the initial key.
+             * Because we only set a new key once decryption has been successful,
+             * we can be sure that we don't need to reset the key to the initial material at this point
+             * as the key has not been updated on the keyHandler instance
              */
-            if (initialMaterial) {
-              workerLogger.debug('resetting to initial material');
-              this.keys.setKeyFromMaterial(initialMaterial.material, keyIndex);
-            }
             workerLogger.warn('maximum ratchet attempts exceeded');
             throw new CryptorError("valid key missing for participant ".concat(this.participantIdentity), CryptorErrorReason.InvalidKey);
           }
@@ -1562,12 +1544,11 @@ class ParticipantKeyHandler extends eventsExports.EventEmitter {
     let keyIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
     let emitRatchetEvent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     return __awaiter(this, void 0, void 0, function* () {
-      workerLogger.debug('setting new key');
-      if (keyIndex >= 0) {
-        this.currentKeyIndex = keyIndex % this.cryptoKeyRing.length;
-      }
+      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, this.currentKeyIndex, emitRatchetEvent);
+      this.setKeySet(keySet, newIndex >= 0 ? newIndex : this.currentKeyIndex, emitRatchetEvent);
+      if (newIndex >= 0) this.currentKeyIndex = newIndex;
     });
   }
   setKeySet(keySet, keyIndex) {
@@ -1643,7 +1624,7 @@ onmessage = ev => {
         workerLogger.warn('set shared key');
         setSharedKey(data.key, data.keyIndex);
       } else if (data.participantIdentity) {
-        workerLogger.warn("set participant sender key ".concat(data.participantIdentity));
+        workerLogger.warn("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');