@unwanted/matrix-sdk-mini 34.12.0-1

package/lib/rust-crypto/backup.js

@@ -0,0 +1,837 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/*
+Copyright 2023 - 2024 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import * as RustSdkCryptoJs from "@matrix-org/matrix-sdk-crypto-wasm";
+import { logger } from "../logger.js";
+import { ClientPrefix, MatrixError, Method } from "../http-api/index.js";
+import { TypedEventEmitter } from "../models/typed-event-emitter.js";
+import { encodeUri, logDuration } from "../utils.js";
+import { sleep } from "../utils.js";
+import { CryptoEvent } from "../crypto-api/index.js";
+
+/** Authentification of the backup info, depends on algorithm */
+
+/**
+ * Holds information of a created keybackup.
+ * Useful to get the generated private key material and save it securely somewhere.
+ */
+
+/**
+ * @internal
+ */
+export class RustBackupManager extends TypedEventEmitter {
+  constructor(olmMachine, http, outgoingRequestProcessor) {
+    super();
+    this.olmMachine = olmMachine;
+    this.http = http;
+    this.outgoingRequestProcessor = outgoingRequestProcessor;
+    /** Have we checked if there is a backup on the server which we can use */
+    _defineProperty(this, "checkedForBackup", false);
+    /**
+     * The latest backup version on the server, when we last checked.
+     *
+     * If there was no backup on the server, `null`. If our attempt to check resulted in an error, `undefined`.
+     *
+     * Note that the backup was not necessarily verified.
+     */
+    _defineProperty(this, "serverBackupInfo", undefined);
+    _defineProperty(this, "activeBackupVersion", null);
+    _defineProperty(this, "stopped", false);
+    /** whether {@link backupKeysLoop} is currently running */
+    _defineProperty(this, "backupKeysLoopRunning", false);
+    _defineProperty(this, "keyBackupCheckInProgress", null);
+  }
+
+  /**
+   * Tells the RustBackupManager to stop.
+   * The RustBackupManager is scheduling background uploads of keys to the backup, this
+   * call allows to cancel the process when the client is stoppped.
+   */
+  stop() {
+    this.stopped = true;
+  }
+
+  /**
+   * Get the backup version we are currently backing up to, if any
+   */
+  getActiveBackupVersion() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      if (!(yield _this.olmMachine.isBackupEnabled())) return null;
+      return _this.activeBackupVersion;
+    })();
+  }
+
+  /**
+   * Return the details of the latest backup on the server, when we last checked.
+   *
+   * This normally returns a cached value, but if we haven't yet made a request to the server, it will fire one off.
+   * It will always return the details of the active backup if key backup is enabled.
+   *
+   * If there was no backup on the server, `null`. If our attempt to check resulted in an error, `undefined`.
+   */
+  getServerBackupInfo() {
+    var _this2 = this;
+    return _asyncToGenerator(function* () {
+      // Do a validity check if we haven't already done one. The check is likely to fail if we don't yet have the
+      // backup keys -- but as a side-effect, it will populate `serverBackupInfo`.
+      yield _this2.checkKeyBackupAndEnable(false);
+      return _this2.serverBackupInfo;
+    })();
+  }
+
+  /**
+   * Determine if a key backup can be trusted.
+   *
+   * @param info - key backup info dict from {@link MatrixClient#getKeyBackupVersion}.
+   */
+  isKeyBackupTrusted(info) {
+    var _this3 = this;
+    return _asyncToGenerator(function* () {
+      var signatureVerification = yield _this3.olmMachine.verifyBackup(info);
+      var backupKeys = yield _this3.olmMachine.getBackupKeys();
+      var decryptionKey = backupKeys === null || backupKeys === void 0 ? void 0 : backupKeys.decryptionKey;
+      var backupMatchesSavedPrivateKey = !!decryptionKey && backupInfoMatchesBackupDecryptionKey(info, decryptionKey);
+      return {
+        matchesDecryptionKey: backupMatchesSavedPrivateKey,
+        trusted: signatureVerification.trusted()
+      };
+    })();
+  }
+
+  /**
+   * Re-check the key backup and enable/disable it as appropriate.
+   *
+   * @param force - whether we should force a re-check even if one has already happened.
+   */
+  checkKeyBackupAndEnable(force) {
+    if (!force && this.checkedForBackup) {
+      return Promise.resolve(null);
+    }
+
+    // make sure there is only one check going on at a time
+    if (!this.keyBackupCheckInProgress) {
+      this.keyBackupCheckInProgress = this.doCheckKeyBackup().finally(() => {
+        this.keyBackupCheckInProgress = null;
+      });
+    }
+    return this.keyBackupCheckInProgress;
+  }
+
+  /**
+   * Handles a backup secret received event and store it if it matches the current backup version.
+   *
+   * @param secret - The secret as received from a `m.secret.send` event for secret `m.megolm_backup.v1`.
+   * @returns true if the secret is valid and has been stored, false otherwise.
+   */
+  handleBackupSecretReceived(secret) {
+    var _this4 = this;
+    return _asyncToGenerator(function* () {
+      var _backupCheck$backupIn;
+      // Currently we only receive the decryption key without any key backup version. It is important to
+      // check that the secret is valid for the current version before storing it.
+      // We force a check to ensure to have the latest version. We also want to check that the backup is trusted
+      // as we don't want to store the secret if the backup is not trusted, and eventually import megolm keys later from an untrusted backup.
+      var backupCheck = yield _this4.checkKeyBackupAndEnable(true);
+      if (!(backupCheck !== null && backupCheck !== void 0 && (_backupCheck$backupIn = backupCheck.backupInfo) !== null && _backupCheck$backupIn !== void 0 && _backupCheck$backupIn.version) || !backupCheck.trustInfo.trusted) {
+        // There is no server-side key backup, or the backup is not signed by a trusted cross-signing key or trusted own device.
+        // This decryption key is useless to us.
+        logger.warn("handleBackupSecretReceived: Received a backup decryption key, but there is no trusted server-side key backup");
+        return false;
+      }
+      try {
+        var backupDecryptionKey = RustSdkCryptoJs.BackupDecryptionKey.fromBase64(secret);
+        var privateKeyMatches = backupInfoMatchesBackupDecryptionKey(backupCheck.backupInfo, backupDecryptionKey);
+        if (!privateKeyMatches) {
+          logger.warn("handleBackupSecretReceived: Private decryption key does not match the public key of the current remote backup.");
+          // just ignore the secret
+          return false;
+        }
+        logger.info("handleBackupSecretReceived: A valid backup decryption key has been received and stored in cache.");
+        yield _this4.saveBackupDecryptionKey(backupDecryptionKey, backupCheck.backupInfo.version);
+        return true;
+      } catch (e) {
+        logger.warn("handleBackupSecretReceived: Invalid backup decryption key", e);
+      }
+      return false;
+    })();
+  }
+  saveBackupDecryptionKey(backupDecryptionKey, version) {
+    var _this5 = this;
+    return _asyncToGenerator(function* () {
+      yield _this5.olmMachine.saveBackupDecryptionKey(backupDecryptionKey, version);
+      // Emit an event that we have a new backup decryption key, so that the sdk can start
+      // importing keys from backup if needed.
+      _this5.emit(CryptoEvent.KeyBackupDecryptionKeyCached, version);
+    })();
+  }
+
+  /**
+   * Import a list of room keys previously exported by exportRoomKeys
+   *
+   * @param keys - a list of session export objects
+   * @param opts - options object
+   * @returns a promise which resolves once the keys have been imported
+   */
+  importRoomKeys(keys, opts) {
+    var _this6 = this;
+    return _asyncToGenerator(function* () {
+      yield _this6.importRoomKeysAsJson(JSON.stringify(keys), opts);
+    })();
+  }
+
+  /**
+   * Import a list of room keys previously exported by exportRoomKeysAsJson
+   *
+   * @param jsonKeys - a JSON string encoding a list of session export objects,
+   *    each of which is an IMegolmSessionData
+   * @param opts - options object
+   * @returns a promise which resolves once the keys have been imported
+   */
+  importRoomKeysAsJson(jsonKeys, opts) {
+    var _this7 = this;
+    return _asyncToGenerator(function* () {
+      yield _this7.olmMachine.importExportedRoomKeys(jsonKeys, (progress, total) => {
+        var _opts$progressCallbac;
+        var importOpt = {
+          total: Number(total),
+          successes: Number(progress),
+          stage: "load_keys",
+          failures: 0
+        };
+        opts === null || opts === void 0 || (_opts$progressCallbac = opts.progressCallback) === null || _opts$progressCallbac === void 0 || _opts$progressCallbac.call(opts, importOpt);
+      });
+    })();
+  }
+
+  /**
+   * Implementation of {@link CryptoBackend#importBackedUpRoomKeys}.
+   */
+  importBackedUpRoomKeys(keys, backupVersion, opts) {
+    var _this8 = this;
+    return _asyncToGenerator(function* () {
+      var keysByRoom = new Map();
+      for (var key of keys) {
+        var roomId = new RustSdkCryptoJs.RoomId(key.room_id);
+        if (!keysByRoom.has(roomId)) {
+          keysByRoom.set(roomId, new Map());
+        }
+        keysByRoom.get(roomId).set(key.session_id, key);
+      }
+      yield _this8.olmMachine.importBackedUpRoomKeys(keysByRoom, (progress, total, failures) => {
+        var _opts$progressCallbac2;
+        var importOpt = {
+          total: Number(total),
+          successes: Number(progress),
+          stage: "load_keys",
+          failures: Number(failures)
+        };
+        opts === null || opts === void 0 || (_opts$progressCallbac2 = opts.progressCallback) === null || _opts$progressCallbac2 === void 0 || _opts$progressCallbac2.call(opts, importOpt);
+      }, backupVersion);
+    })();
+  }
+  /** Helper for `checkKeyBackup` */
+  doCheckKeyBackup() {
+    var _this9 = this;
+    return _asyncToGenerator(function* () {
+      logger.log("Checking key backup status...");
+      var backupInfo;
+      try {
+        backupInfo = yield _this9.requestKeyBackupVersion();
+      } catch (e) {
+        logger.warn("Error checking for active key backup", e);
+        _this9.serverBackupInfo = undefined;
+        return null;
+      }
+      _this9.checkedForBackup = true;
+      if (backupInfo && !backupInfo.version) {
+        logger.warn("active backup lacks a useful 'version'; ignoring it");
+        backupInfo = undefined;
+      }
+      _this9.serverBackupInfo = backupInfo;
+      var activeVersion = yield _this9.getActiveBackupVersion();
+      if (!backupInfo) {
+        if (activeVersion !== null) {
+          logger.log("No key backup present on server: disabling key backup");
+          yield _this9.disableKeyBackup();
+        } else {
+          logger.log("No key backup present on server: not enabling key backup");
+        }
+        return null;
+      }
+      var trustInfo = yield _this9.isKeyBackupTrusted(backupInfo);
+      if (!trustInfo.trusted) {
+        if (activeVersion !== null) {
+          logger.log("Key backup present on server but not trusted: disabling key backup");
+          yield _this9.disableKeyBackup();
+        } else {
+          logger.log("Key backup present on server but not trusted: not enabling key backup");
+        }
+      } else {
+        if (activeVersion === null) {
+          logger.log("Found usable key backup v".concat(backupInfo.version, ": enabling key backups"));
+          yield _this9.enableKeyBackup(backupInfo);
+        } else if (activeVersion !== backupInfo.version) {
+          logger.log("On backup version ".concat(activeVersion, " but found version ").concat(backupInfo.version, ": switching."));
+          // This will remove any pending backup request, remove the backup key and reset the backup state of each room key we have.
+          yield _this9.disableKeyBackup();
+          // Enabling will now trigger re-upload of all the keys
+          yield _this9.enableKeyBackup(backupInfo);
+        } else {
+          logger.log("Backup version ".concat(backupInfo.version, " still current"));
+        }
+      }
+      return {
+        backupInfo,
+        trustInfo
+      };
+    })();
+  }
+  enableKeyBackup(backupInfo) {
+    var _this10 = this;
+    return _asyncToGenerator(function* () {
+      // we know for certain it must be a Curve25519 key, because we have verified it and only Curve25519
+      // keys can be verified.
+      //
+      // we also checked it has a valid `version`.
+      yield _this10.olmMachine.enableBackupV1(backupInfo.auth_data.public_key, backupInfo.version);
+      _this10.activeBackupVersion = backupInfo.version;
+      _this10.emit(CryptoEvent.KeyBackupStatus, true);
+      _this10.backupKeysLoop();
+    })();
+  }
+
+  /**
+   * Restart the backup key loop if there is an active trusted backup.
+   * Doesn't try to check the backup server side. To be called when a new
+   * megolm key is known locally.
+   */
+  maybeUploadKey() {
+    var _this11 = this;
+    return _asyncToGenerator(function* () {
+      if (_this11.activeBackupVersion != null) {
+        _this11.backupKeysLoop();
+      }
+    })();
+  }
+  disableKeyBackup() {
+    var _this12 = this;
+    return _asyncToGenerator(function* () {
+      yield _this12.olmMachine.disableBackup();
+      _this12.activeBackupVersion = null;
+      _this12.emit(CryptoEvent.KeyBackupStatus, false);
+    })();
+  }
+  backupKeysLoop() {
+    var _arguments = arguments,
+      _this13 = this;
+    return _asyncToGenerator(function* () {
+      var maxDelay = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : 10000;
+      if (_this13.backupKeysLoopRunning) {
+        logger.log("Backup loop already running");
+        return;
+      }
+      _this13.backupKeysLoopRunning = true;
+      logger.log("Backup: Starting keys upload loop for backup version:".concat(_this13.activeBackupVersion, "."));
+
+      // wait between 0 and `maxDelay` seconds, to avoid backup
+      // requests from different clients hitting the server all at
+      // the same time when a new key is sent
+      var delay = Math.random() * maxDelay;
+      yield sleep(delay);
+      try {
+        // number of consecutive network failures for exponential backoff
+        var numFailures = 0;
+        // The number of keys left to back up. (Populated lazily: see more comments below.)
+        var remainingToUploadCount = null;
+        // To avoid computing the key when only a few keys were added (after a sync for example),
+        // we compute the count only when at least two iterations are needed.
+        var isFirstIteration = true;
+        while (!_this13.stopped) {
+          // Get a batch of room keys to upload
+          var request = null;
+          try {
+            request = yield logDuration(logger, "BackupRoomKeys: Get keys to backup from rust crypto-sdk", /*#__PURE__*/_asyncToGenerator(function* () {
+              return yield _this13.olmMachine.backupRoomKeys();
+            }));
+          } catch (err) {
+            logger.error("Backup: Failed to get keys to backup from rust crypto-sdk", err);
+          }
+          if (!request || _this13.stopped || !_this13.activeBackupVersion) {
+            logger.log("Backup: Ending loop for version ".concat(_this13.activeBackupVersion, "."));
+            if (!request) {
+              // nothing more to upload
+              _this13.emit(CryptoEvent.KeyBackupSessionsRemaining, 0);
+            }
+            return;
+          }
+          try {
+            yield _this13.outgoingRequestProcessor.makeOutgoingRequest(request);
+            numFailures = 0;
+            if (_this13.stopped) break;
+
+            // Key count performance (`olmMachine.roomKeyCounts()`) can be pretty bad on some configurations.
+            // In particular, we detected on some M1 macs that when the object store reaches a threshold, the count
+            // performance stops growing in O(n) and suddenly becomes very slow (40s, 60s or more).
+            // For reference, the performance drop occurs around 300-400k keys on the platforms where this issue is observed.
+            // Even on other configurations, the count can take several seconds.
+            // This will block other operations on the database, like sending messages.
+            //
+            // This is a workaround to avoid calling `olmMachine.roomKeyCounts()` too often, and only when necessary.
+            // We don't call it on the first loop because there could be only a few keys to upload, and we don't want to wait for the count.
+            if (!isFirstIteration && remainingToUploadCount === null) {
+              try {
+                var keyCount = yield _this13.olmMachine.roomKeyCounts();
+                remainingToUploadCount = keyCount.total - keyCount.backedUp;
+              } catch (err) {
+                logger.error("Backup: Failed to get key counts from rust crypto-sdk", err);
+              }
+            }
+            if (remainingToUploadCount !== null) {
+              _this13.emit(CryptoEvent.KeyBackupSessionsRemaining, remainingToUploadCount);
+              var keysCountInBatch = _this13.keysCountInBatch(request);
+              // `OlmMachine.roomKeyCounts` is called only once for the current backupKeysLoop. But new
+              // keys could be added during the current loop (after a sync for example).
+              // So the count can get out of sync with the real number of remaining keys to upload.
+              // Depending on the number of new keys imported and the time to complete the loop,
+              // this could result in multiple events being emitted with a remaining key count of 0.
+              remainingToUploadCount = Math.max(remainingToUploadCount - keysCountInBatch, 0);
+            }
+          } catch (err) {
+            numFailures++;
+            logger.error("Backup: Error processing backup request for rust crypto-sdk", err);
+            if (err instanceof MatrixError) {
+              var errCode = err.data.errcode;
+              if (errCode == "M_NOT_FOUND" || errCode == "M_WRONG_ROOM_KEYS_VERSION") {
+                logger.log("Backup: Failed to upload keys to current vesion: ".concat(errCode, "."));
+                try {
+                  yield _this13.disableKeyBackup();
+                } catch (error) {
+                  logger.error("Backup: An error occurred while disabling key backup:", error);
+                }
+                _this13.emit(CryptoEvent.KeyBackupFailed, err.data.errcode);
+                // There was an active backup and we are out of sync with the server
+                // force a check server side
+                _this13.backupKeysLoopRunning = false;
+                _this13.checkKeyBackupAndEnable(true);
+                return;
+              } else if (err.isRateLimitError()) {
+                // wait for that and then continue?
+                try {
+                  var waitTime = err.getRetryAfterMs();
+                  if (waitTime && waitTime > 0) {
+                    yield sleep(waitTime);
+                    continue;
+                  }
+                } catch (error) {
+                  logger.warn("Backup: An error occurred while retrieving a rate-limit retry delay", error);
+                } // else go to the normal backoff
+              }
+            }
+
+            // Some other errors (mx, network, or CORS or invalid urls?) anyhow backoff
+            // exponential backoff if we have failures
+            yield sleep(1000 * Math.pow(2, Math.min(numFailures - 1, 4)));
+          }
+          isFirstIteration = false;
+        }
+      } finally {
+        _this13.backupKeysLoopRunning = false;
+      }
+    })();
+  }
+
+  /**
+   * Utility method to count the number of keys in a backup request, in order to update the remaining keys count.
+   * This should be the chunk size of the backup request for all requests but the last, but we don't have access to it
+   * (it's static in the Rust SDK).
+   * @param batch - The backup request to count the keys from.
+   *
+   * @returns The number of keys in the backup request.
+   */
+  keysCountInBatch(batch) {
+    var parsedBody = JSON.parse(batch.body);
+    return countKeysInBackup(parsedBody);
+  }
+
+  /**
+   * Get information about a key backup from the server
+   * - If version is provided, get information about that backup version.
+   * - If no version is provided, get information about the latest backup.
+   *
+   * @param version - The version of the backup to get information about.
+   * @returns Information object from API or null if there is no active backup.
+   */
+  requestKeyBackupVersion(version) {
+    var _this14 = this;
+    return _asyncToGenerator(function* () {
+      return yield requestKeyBackupVersion(_this14.http, version);
+    })();
+  }
+
+  /**
+   * Creates a new key backup by generating a new random private key.
+   *
+   * If there is an existing backup server side it will be deleted and replaced
+   * by the new one.
+   *
+   * @param signObject - Method that should sign the backup with existing device and
+   * existing identity.
+   * @returns a KeyBackupCreationInfo - All information related to the backup.
+   */
+  setupKeyBackup(signObject) {
+    var _this15 = this;
+    return _asyncToGenerator(function* () {
+      // Clean up any existing backup
+      yield _this15.deleteAllKeyBackupVersions();
+      var randomKey = RustSdkCryptoJs.BackupDecryptionKey.createRandomKey();
+      var pubKey = randomKey.megolmV1PublicKey;
+      var authData = {
+        public_key: pubKey.publicKeyBase64
+      };
+      yield signObject(authData);
+      var res = yield _this15.http.authedRequest(Method.Post, "/room_keys/version", undefined, {
+        algorithm: pubKey.algorithm,
+        auth_data: authData
+      }, {
+        prefix: ClientPrefix.V3
+      });
+      yield _this15.saveBackupDecryptionKey(randomKey, res.version);
+      return {
+        version: res.version,
+        algorithm: pubKey.algorithm,
+        authData: authData,
+        decryptionKey: randomKey
+      };
+    })();
+  }
+
+  /**
+   * Deletes all key backups.
+   *
+   * Will call the API to delete active backup until there is no more present.
+   */
+  deleteAllKeyBackupVersions() {
+    var _this16 = this;
+    return _asyncToGenerator(function* () {
+      var _yield$_this16$reques, _yield$_this16$reques2;
+      // there could be several backup versions. Delete all to be safe.
+      var current = (_yield$_this16$reques = (_yield$_this16$reques2 = yield _this16.requestKeyBackupVersion()) === null || _yield$_this16$reques2 === void 0 ? void 0 : _yield$_this16$reques2.version) !== null && _yield$_this16$reques !== void 0 ? _yield$_this16$reques : null;
+      while (current != null) {
+        var _yield$_this16$reques3, _yield$_this16$reques4;
+        yield _this16.deleteKeyBackupVersion(current);
+        current = (_yield$_this16$reques3 = (_yield$_this16$reques4 = yield _this16.requestKeyBackupVersion()) === null || _yield$_this16$reques4 === void 0 ? void 0 : _yield$_this16$reques4.version) !== null && _yield$_this16$reques3 !== void 0 ? _yield$_this16$reques3 : null;
+      }
+
+      // XXX: Should this also update Secret Storage and delete any existing keys?
+    })();
+  }
+
+  /**
+   * Deletes the given key backup.
+   *
+   * @param version - The backup version to delete.
+   */
+  deleteKeyBackupVersion(version) {
+    var _this17 = this;
+    return _asyncToGenerator(function* () {
+      logger.debug("deleteKeyBackupVersion v:".concat(version));
+      var path = encodeUri("/room_keys/version/$version", {
+        $version: version
+      });
+      yield _this17.http.authedRequest(Method.Delete, path, undefined, undefined, {
+        prefix: ClientPrefix.V3
+      });
+    })();
+  }
+
+  /**
+   * Creates a new backup decryptor for the given private key.
+   * @param decryptionKey - The private key to use for decryption.
+   */
+  createBackupDecryptor(decryptionKey) {
+    return new RustBackupDecryptor(decryptionKey);
+  }
+
+  /**
+   * Restore a key backup.
+   *
+   * @param backupVersion - The version of the backup to restore.
+   * @param backupDecryptor - The backup decryptor to use to decrypt the keys.
+   * @param opts - Options for the restore.
+   * @returns The total number of keys and the total imported.
+   */
+  restoreKeyBackup(backupVersion, backupDecryptor, opts) {
+    var _this18 = this;
+    return _asyncToGenerator(function* () {
+      var _opts$progressCallbac3;
+      var keyBackup = yield _this18.downloadKeyBackup(backupVersion);
+      opts === null || opts === void 0 || (_opts$progressCallbac3 = opts.progressCallback) === null || _opts$progressCallbac3 === void 0 || _opts$progressCallbac3.call(opts, {
+        stage: "load_keys"
+      });
+      return _this18.importKeyBackup(keyBackup, backupVersion, backupDecryptor, opts);
+    })();
+  }
+
+  /**
+   * Call `/room_keys/keys` to download the key backup (room keys) for the given backup version.
+   * https://spec.matrix.org/v1.12/client-server-api/#get_matrixclientv3room_keyskeys
+   *
+   * @param backupVersion
+   * @returns The key backup response.
+   */
+  downloadKeyBackup(backupVersion) {
+    return this.http.authedRequest(Method.Get, "/room_keys/keys", {
+      version: backupVersion
+    }, undefined, {
+      prefix: ClientPrefix.V3
+    });
+  }
+
+  /**
+   * Import the room keys from a `/room_keys/keys` call.
+   * Calls `opts.progressCallback` with the progress of the import.
+   *
+   * @param keyBackup - The response from the server containing the keys to import.
+   * @param backupVersion - The version of the backup info.
+   * @param backupDecryptor - The backup decryptor to use to decrypt the keys.
+   * @param opts - Options for the import.
+   *
+   * @returns The total number of keys and the total imported.
+   *
+   * @private
+   */
+  importKeyBackup(keyBackup, backupVersion, backupDecryptor, opts) {
+    var _this19 = this;
+    return _asyncToGenerator(function* () {
+      // We have a full backup here, it can get quite big, so we need to decrypt and import it in chunks.
+
+      var CHUNK_SIZE = 200;
+      // Get the total count as a first pass
+      var totalKeyCount = countKeysInBackup(keyBackup);
+      var totalImported = 0;
+      var totalFailures = 0;
+
+      /**
+       * This method is called when we have enough chunks to decrypt.
+       * It will decrypt the chunks and try to import the room keys.
+       * @param roomChunks
+       */
+      var handleChunkCallback = /*#__PURE__*/function () {
+        var _ref2 = _asyncToGenerator(function* (roomChunks) {
+          var _opts$progressCallbac4;
+          var currentChunk = [];
+          var _loop = function* _loop(roomId) {
+            // Decrypt the sessions for the given room
+            var decryptedSessions = yield backupDecryptor.decryptSessions(roomChunks.get(roomId));
+            // Add the decrypted sessions to the current chunk
+            decryptedSessions.forEach(session => {
+              // We set the room_id for each session
+              session.room_id = roomId;
+              currentChunk.push(session);
+            });
+          };
+          for (var roomId of roomChunks.keys()) {
+            yield* _loop(roomId);
+          }
+
+          // We have a chunk of decrypted keys: import them
+          try {
+            yield _this19.importBackedUpRoomKeys(currentChunk, backupVersion);
+            totalImported += currentChunk.length;
+          } catch (e) {
+            totalFailures += currentChunk.length;
+            // We failed to import some keys, but we should still try to import the rest?
+            // Log the error and continue
+            logger.error("Error importing keys from backup", e);
+          }
+          opts === null || opts === void 0 || (_opts$progressCallbac4 = opts.progressCallback) === null || _opts$progressCallbac4 === void 0 || _opts$progressCallbac4.call(opts, {
+            total: totalKeyCount,
+            successes: totalImported,
+            stage: "load_keys",
+            failures: totalFailures
+          });
+        });
+        return function handleChunkCallback(_x) {
+          return _ref2.apply(this, arguments);
+        };
+      }();
+      var groupChunkCount = 0;
+      var chunkGroupByRoom = new Map();
+
+      // Iterate over the rooms and sessions to group them in chunks
+      // And we call the handleChunkCallback when we have enough chunks to decrypt
+      for (var [roomId, roomData] of Object.entries(keyBackup.rooms)) {
+        // If there are no sessions for the room, skip it
+        if (!roomData.sessions) continue;
+
+        // Initialize a new chunk group for the current room
+        chunkGroupByRoom.set(roomId, {});
+        for (var [sessionId, session] of Object.entries(roomData.sessions)) {
+          // We set previously the chunk group for the current room, so we can safely get it
+          var sessionsForRoom = chunkGroupByRoom.get(roomId);
+          sessionsForRoom[sessionId] = session;
+          groupChunkCount += 1;
+          // If we have enough chunks to decrypt, call the block callback
+          if (groupChunkCount >= CHUNK_SIZE) {
+            // We have enough chunks to decrypt
+            yield handleChunkCallback(chunkGroupByRoom);
+            // Reset the chunk group
+            chunkGroupByRoom = new Map();
+            // There might be remaining keys for that room, so add back an entry for the current room.
+            chunkGroupByRoom.set(roomId, {});
+            groupChunkCount = 0;
+          }
+        }
+      }
+
+      // Handle remaining chunk if needed
+      if (groupChunkCount > 0) {
+        yield handleChunkCallback(chunkGroupByRoom);
+      }
+      return {
+        total: totalKeyCount,
+        imported: totalImported
+      };
+    })();
+  }
+}
+
+/**
+ * Checks if the provided backup info matches the given private key.
+ *
+ * @param info - The backup info to check.
+ * @param backupDecryptionKey - The `BackupDecryptionKey` private key to check against.
+ * @returns `true` if the private key can decrypt the backup, `false` otherwise.
+ */
+function backupInfoMatchesBackupDecryptionKey(info, backupDecryptionKey) {
+  var _info$auth_data;
+  if (info.algorithm !== "m.megolm_backup.v1.curve25519-aes-sha2") {
+    logger.warn("backupMatchesPrivateKey: Unsupported backup algorithm", info.algorithm);
+    return false;
+  }
+  return ((_info$auth_data = info.auth_data) === null || _info$auth_data === void 0 ? void 0 : _info$auth_data.public_key) === backupDecryptionKey.megolmV1PublicKey.publicKeyBase64;
+}
+
+/**
+ * Implementation of {@link BackupDecryptor} for the rust crypto backend.
+ */
+export class RustBackupDecryptor {
+  constructor(decryptionKey) {
+    _defineProperty(this, "decryptionKey", void 0);
+    _defineProperty(this, "sourceTrusted", void 0);
+    this.decryptionKey = decryptionKey;
+    this.sourceTrusted = false;
+  }
+
+  /**
+   * Implements {@link BackupDecryptor#decryptSessions}
+   */
+  decryptSessions(ciphertexts) {
+    var _this20 = this;
+    return _asyncToGenerator(function* () {
+      var keys = [];
+      for (var [sessionId, sessionData] of Object.entries(ciphertexts)) {
+        try {
+          var decrypted = JSON.parse(_this20.decryptionKey.decryptV1(sessionData.session_data.ephemeral, sessionData.session_data.mac, sessionData.session_data.ciphertext));
+          decrypted.session_id = sessionId;
+          keys.push(decrypted);
+        } catch (e) {
+          logger.log("Failed to decrypt megolm session from backup", e, sessionData);
+        }
+      }
+      return keys;
+    })();
+  }
+
+  /**
+   * Implements {@link BackupDecryptor#free}
+   */
+  free() {
+    this.decryptionKey.free();
+  }
+}
+
+/**
+ * Fetch a key backup info from the server.
+ *
+ * If `version` is provided, calls `GET /room_keys/version/$version` and gets the backup info for that version.
+ * See https://spec.matrix.org/v1.12/client-server-api/#get_matrixclientv3room_keysversionversion.
+ *
+ * If not, calls `GET /room_keys/version` and gets the latest backup info.
+ * See https://spec.matrix.org/v1.12/client-server-api/#get_matrixclientv3room_keysversion
+ *
+ * @param http
+ * @param version - the specific version of the backup info to fetch
+ * @returns The key backup info or null if there is no backup.
+ */
+export function requestKeyBackupVersion(_x2, _x3) {
+  return _requestKeyBackupVersion.apply(this, arguments);
+}
+
+/**
+ * Checks if the provided decryption key matches the public key of the key backup info.
+ *
+ * @param decryptionKey - The decryption key to check.
+ * @param keyBackupInfo - The key backup info to check against.
+ * @returns `true` if the decryption key matches the key backup info, `false` otherwise.
+ */
+function _requestKeyBackupVersion() {
+  _requestKeyBackupVersion = _asyncToGenerator(function* (http, version) {
+    try {
+      var path = version ? encodeUri("/room_keys/version/$version", {
+        $version: version
+      }) : "/room_keys/version";
+      return yield http.authedRequest(Method.Get, path, undefined, undefined, {
+        prefix: ClientPrefix.V3
+      });
+    } catch (e) {
+      if (e.errcode === "M_NOT_FOUND") {
+        return null;
+      } else {
+        throw e;
+      }
+    }
+  });
+  return _requestKeyBackupVersion.apply(this, arguments);
+}
+export function decryptionKeyMatchesKeyBackupInfo(decryptionKey, keyBackupInfo) {
+  var authData = keyBackupInfo.auth_data;
+  return authData.public_key === decryptionKey.megolmV1PublicKey.publicKeyBase64;
+}
+
+/**
+ * Counts the total number of keys present in a key backup.
+ * @param keyBackup - The key backup to count the keys from.
+ * @returns The total number of keys in the backup.
+ */
+function countKeysInBackup(keyBackup) {
+  var count = 0;
+  for (var {
+    sessions
+  } of Object.values(keyBackup.rooms)) {
+    count += Object.keys(sessions).length;
+  }
+  return count;
+}
+
+/**
+ * Response from GET `/room_keys/keys` endpoint.
+ * See https://spec.matrix.org/latest/client-server-api/#get_matrixclientv3room_keyskeys
+ */
+//# sourceMappingURL=backup.js.map