@unwanted/matrix-sdk-mini 34.12.0-1

package/lib/rust-crypto/libolm_migration.d.ts

@@ -0,0 +1,81 @@
+import * as RustSdkCryptoJs from "@matrix-org/matrix-sdk-crypto-wasm";
+import { Logger } from "../logger.ts";
+import { CryptoStore } from "../crypto/store/base.ts";
+import { IHttpOpts, MatrixHttpApi } from "../http-api/index.ts";
+import { RustCrypto } from "./rust-crypto.ts";
+/**
+ * Determine if any data needs migrating from the legacy store, and do so.
+ *
+ * This migrates the base account data, and olm and megolm sessions. It does *not* migrate the room list, which should
+ * happen after an `OlmMachine` is created, via {@link migrateRoomSettingsFromLegacyCrypto}.
+ *
+ * @param args - Arguments object.
+ */
+export declare function migrateFromLegacyCrypto(args: {
+    /** A `Logger` instance that will be used for debug output. */
+    logger: Logger;
+    /**
+     * Low-level HTTP interface: used to make outgoing requests required by the rust SDK.
+     * We expect it to set the access token, etc.
+     */
+    http: MatrixHttpApi<IHttpOpts & {
+        onlyData: true;
+    }>;
+    /** Store to migrate data from. */
+    legacyStore: CryptoStore;
+    /** Pickle key for `legacyStore`. */
+    legacyPickleKey?: string;
+    /** Local user's User ID. */
+    userId: string;
+    /** Local user's Device ID. */
+    deviceId: string;
+    /** Rust crypto store to migrate data into. */
+    storeHandle: RustSdkCryptoJs.StoreHandle;
+    /**
+     * A callback which will receive progress updates on migration from `legacyStore`.
+     *
+     * Called with (-1, -1) to mark the end of migration.
+     */
+    legacyMigrationProgressListener?: (progress: number, total: number) => void;
+}): Promise<void>;
+/**
+ * Determine if any room settings need migrating from the legacy store, and do so.
+ *
+ * @param args - Arguments object.
+ */
+export declare function migrateRoomSettingsFromLegacyCrypto({ logger, legacyStore, olmMachine, }: {
+    /** A `Logger` instance that will be used for debug output. */
+    logger: Logger;
+    /** Store to migrate data from. */
+    legacyStore: CryptoStore;
+    /** OlmMachine to store the new data on. */
+    olmMachine: RustSdkCryptoJs.OlmMachine;
+}): Promise<void>;
+/**
+ * Check if the user's published identity (ie, public cross-signing keys) was trusted by the legacy session,
+ * and if so mark it as trusted in the Rust session if needed.
+ *
+ * By default, if the legacy session didn't have the private MSK, the migrated session will revert to unverified,
+ * even if the user has verified the session in the past.
+ *
+ * This only occurs if the private MSK was not cached in the crypto store (USK and SSK private keys won't help
+ * to establish trust: the trust is rooted in the MSK).
+ *
+ * Rust crypto will only consider the current session as trusted if we import the private MSK itself.
+ *
+ * We could prompt the user to verify the session again, but it's probably better to just mark the user identity
+ * as locally verified if it was before.
+ *
+ * See https://github.com/element-hq/element-web/issues/27079
+ *
+ * @param args - Argument object.
+ */
+export declare function migrateLegacyLocalTrustIfNeeded(args: {
+    /** The legacy crypto store that is migrated. */
+    legacyCryptoStore: CryptoStore;
+    /** The migrated rust crypto stack. */
+    rustCrypto: RustCrypto;
+    /** The logger to use */
+    logger: Logger;
+}): Promise<void>;
+//# sourceMappingURL=libolm_migration.d.ts.map

package/lib/rust-crypto/libolm_migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"libolm_migration.d.ts","sourceRoot":"","sources":["../../src/rust-crypto/libolm_migration.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,eAAe,MAAM,oCAAoC,CAAC;AAEtE,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,WAAW,EAA0C,MAAM,yBAAyB,CAAC;AAE9F,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAIhE,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAO9C;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAAC,IAAI,EAAE;IAChD,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,IAAI,EAAE,aAAa,CAAC,SAAS,GAAG;QAAE,QAAQ,EAAE,IAAI,CAAA;KAAE,CAAC,CAAC;IAEpD,kCAAkC;IAClC,WAAW,EAAE,WAAW,CAAC;IAEzB,oCAAoC;IACpC,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,4BAA4B;IAC5B,MAAM,EAAE,MAAM,CAAC;IAEf,8BAA8B;IAC9B,QAAQ,EAAE,MAAM,CAAC;IAEjB,8CAA8C;IAC9C,WAAW,EAAE,eAAe,CAAC,WAAW,CAAC;IAEzC;;;;OAIG;IACH,+BAA+B,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/E,GAAG,OAAO,CAAC,IAAI,CAAC,CAmFhB;AAgMD;;;;GAIG;AACH,wBAAsB,mCAAmC,CAAC,EACtD,MAAM,EACN,WAAW,EACX,UAAU,GACb,EAAE;IACC,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAC;IAEf,kCAAkC;IAClC,WAAW,EAAE,WAAW,CAAC;IAEzB,2CAA2C;IAC3C,UAAU,EAAE,eAAe,CAAC,UAAU,CAAC;CAC1C,GAAG,OAAO,CAAC,IAAI,CAAC,CA8ChB;AAuBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,+BAA+B,CAAC,IAAI,EAAE;IACxD,gDAAgD;IAChD,iBAAiB,EAAE,WAAW,CAAC;IAC/B,sCAAsC;IACtC,UAAU,EAAE,UAAU,CAAC;IACvB,wBAAwB;IACxB,MAAM,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CA+ChB"}

package/lib/rust-crypto/libolm_migration.js

@@ -0,0 +1,459 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+/*
+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 { MigrationState } from "../crypto/store/base.js";
+import { IndexedDBCryptoStore } from "../crypto/store/indexeddb-crypto-store.js";
+import { requestKeyBackupVersion } from "./backup.js";
+import { sleep } from "../utils.js";
+import { encodeBase64 } from "../base64.js";
+import decryptAESSecretStorageItem from "../utils/decryptAESSecretStorageItem.js";
+/**
+ * Determine if any data needs migrating from the legacy store, and do so.
+ *
+ * This migrates the base account data, and olm and megolm sessions. It does *not* migrate the room list, which should
+ * happen after an `OlmMachine` is created, via {@link migrateRoomSettingsFromLegacyCrypto}.
+ *
+ * @param args - Arguments object.
+ */
+export function migrateFromLegacyCrypto(_x) {
+  return _migrateFromLegacyCrypto.apply(this, arguments);
+}
+function _migrateFromLegacyCrypto() {
+  _migrateFromLegacyCrypto = _asyncToGenerator(function* (args) {
+    var _args$legacyMigration2;
+    var {
+      logger,
+      legacyStore
+    } = args;
+
+    // initialise the rust matrix-sdk-crypto-wasm, if it hasn't already been done
+    yield RustSdkCryptoJs.initAsync();
+
+    // enable tracing in the rust-sdk
+    new RustSdkCryptoJs.Tracing(RustSdkCryptoJs.LoggerLevel.Debug).turnOn();
+    if (!(yield legacyStore.containsData())) {
+      // This store was never used. Nothing to migrate.
+      return;
+    }
+    yield legacyStore.startup();
+    var accountPickle = null;
+    yield legacyStore.doTxn("readonly", [IndexedDBCryptoStore.STORE_ACCOUNT], txn => {
+      legacyStore.getAccount(txn, acctPickle => {
+        accountPickle = acctPickle;
+      });
+    });
+    if (!accountPickle) {
+      // This store is not properly set up. Nothing to migrate.
+      logger.debug("Legacy crypto store is not set up (no account found). Not migrating.");
+      return;
+    }
+    var migrationState = yield legacyStore.getMigrationState();
+    if (migrationState >= MigrationState.MEGOLM_SESSIONS_MIGRATED) {
+      // All migration is done for now. The room list comes later, once we have an OlmMachine.
+      return;
+    }
+    var nOlmSessions = yield countOlmSessions(logger, legacyStore);
+    var nMegolmSessions = yield countMegolmSessions(logger, legacyStore);
+    var totalSteps = 1 + nOlmSessions + nMegolmSessions;
+    logger.info("Migrating data from legacy crypto store. ".concat(nOlmSessions, " olm sessions and ").concat(nMegolmSessions, " megolm sessions to migrate."));
+    var stepsDone = 0;
+    function onProgress(steps) {
+      var _args$legacyMigration;
+      stepsDone += steps;
+      (_args$legacyMigration = args.legacyMigrationProgressListener) === null || _args$legacyMigration === void 0 || _args$legacyMigration.call(args, stepsDone, totalSteps);
+    }
+    onProgress(0);
+    var pickleKey = new TextEncoder().encode(args.legacyPickleKey);
+    if (migrationState === MigrationState.NOT_STARTED) {
+      logger.info("Migrating data from legacy crypto store. Step 1: base data");
+      yield migrateBaseData(args.http, args.userId, args.deviceId, legacyStore, pickleKey, args.storeHandle, logger);
+      migrationState = MigrationState.INITIAL_DATA_MIGRATED;
+      yield legacyStore.setMigrationState(migrationState);
+    }
+    onProgress(1);
+    if (migrationState === MigrationState.INITIAL_DATA_MIGRATED) {
+      logger.info("Migrating data from legacy crypto store. Step 2: olm sessions (".concat(nOlmSessions, " sessions to migrate)."));
+      yield migrateOlmSessions(logger, legacyStore, pickleKey, args.storeHandle, onProgress);
+      migrationState = MigrationState.OLM_SESSIONS_MIGRATED;
+      yield legacyStore.setMigrationState(migrationState);
+    }
+    if (migrationState === MigrationState.OLM_SESSIONS_MIGRATED) {
+      logger.info("Migrating data from legacy crypto store. Step 3: megolm sessions (".concat(nMegolmSessions, " sessions to migrate)."));
+      yield migrateMegolmSessions(logger, legacyStore, pickleKey, args.storeHandle, onProgress);
+      migrationState = MigrationState.MEGOLM_SESSIONS_MIGRATED;
+      yield legacyStore.setMigrationState(migrationState);
+    }
+
+    // Migration is done.
+    (_args$legacyMigration2 = args.legacyMigrationProgressListener) === null || _args$legacyMigration2 === void 0 || _args$legacyMigration2.call(args, -1, -1);
+    logger.info("Migration from legacy crypto store complete");
+  });
+  return _migrateFromLegacyCrypto.apply(this, arguments);
+}
+function migrateBaseData(_x2, _x3, _x4, _x5, _x6, _x7, _x8) {
+  return _migrateBaseData.apply(this, arguments);
+}
+function _migrateBaseData() {
+  _migrateBaseData = _asyncToGenerator(function* (http, userId, deviceId, legacyStore, pickleKey, storeHandle, logger) {
+    var migrationData = new RustSdkCryptoJs.BaseMigrationData();
+    migrationData.userId = new RustSdkCryptoJs.UserId(userId);
+    migrationData.deviceId = new RustSdkCryptoJs.DeviceId(deviceId);
+    yield legacyStore.doTxn("readonly", [IndexedDBCryptoStore.STORE_ACCOUNT], txn => legacyStore.getAccount(txn, a => {
+      migrationData.pickledAccount = a !== null && a !== void 0 ? a : "";
+    }));
+    var recoveryKey = yield getAndDecryptCachedSecretKey(legacyStore, pickleKey, "m.megolm_backup.v1");
+
+    // If we have a backup recovery key, we need to try to figure out which backup version it is for.
+    // All we can really do is ask the server for the most recent version and check if the cached key we have matches.
+    // It is possible that the backup has changed since last time his session was opened.
+    if (recoveryKey) {
+      var backupCallDone = false;
+      var backupInfo = null;
+      while (!backupCallDone) {
+        try {
+          backupInfo = yield requestKeyBackupVersion(http);
+          backupCallDone = true;
+        } catch (e) {
+          logger.info("Failed to get backup version during migration, retrying in 2 seconds", e);
+          // Retry until successful, use simple constant delay
+          yield sleep(2000);
+        }
+      }
+      if (backupInfo && backupInfo.algorithm == "m.megolm_backup.v1.curve25519-aes-sha2") {
+        // check if the recovery key matches, as the active backup version may have changed since the key was cached
+        // and the migration started.
+        try {
+          var _backupInfo$auth_data;
+          var decryptionKey = RustSdkCryptoJs.BackupDecryptionKey.fromBase64(recoveryKey);
+          var publicKey = (_backupInfo$auth_data = backupInfo.auth_data) === null || _backupInfo$auth_data === void 0 ? void 0 : _backupInfo$auth_data.public_key;
+          var isValid = decryptionKey.megolmV1PublicKey.publicKeyBase64 == publicKey;
+          if (isValid) {
+            migrationData.backupVersion = backupInfo.version;
+            migrationData.backupRecoveryKey = recoveryKey;
+          } else {
+            logger.debug("The backup key to migrate does not match the active backup version", "Cached pub key: ".concat(decryptionKey.megolmV1PublicKey.publicKeyBase64), "Active pub key: ".concat(publicKey));
+          }
+        } catch (e) {
+          logger.warn("Failed to check if the backup key to migrate matches the active backup version", e);
+        }
+      }
+    }
+    migrationData.privateCrossSigningMasterKey = yield getAndDecryptCachedSecretKey(legacyStore, pickleKey, "master");
+    migrationData.privateCrossSigningSelfSigningKey = yield getAndDecryptCachedSecretKey(legacyStore, pickleKey, "self_signing");
+    migrationData.privateCrossSigningUserSigningKey = yield getAndDecryptCachedSecretKey(legacyStore, pickleKey, "user_signing");
+    yield RustSdkCryptoJs.Migration.migrateBaseData(migrationData, pickleKey, storeHandle);
+  });
+  return _migrateBaseData.apply(this, arguments);
+}
+function countOlmSessions(_x9, _x10) {
+  return _countOlmSessions.apply(this, arguments);
+}
+function _countOlmSessions() {
+  _countOlmSessions = _asyncToGenerator(function* (logger, legacyStore) {
+    logger.debug("Counting olm sessions to be migrated");
+    var nSessions;
+    yield legacyStore.doTxn("readonly", [IndexedDBCryptoStore.STORE_SESSIONS], txn => legacyStore.countEndToEndSessions(txn, n => nSessions = n));
+    return nSessions;
+  });
+  return _countOlmSessions.apply(this, arguments);
+}
+function countMegolmSessions(_x11, _x12) {
+  return _countMegolmSessions.apply(this, arguments);
+}
+function _countMegolmSessions() {
+  _countMegolmSessions = _asyncToGenerator(function* (logger, legacyStore) {
+    logger.debug("Counting megolm sessions to be migrated");
+    return yield legacyStore.countEndToEndInboundGroupSessions();
+  });
+  return _countMegolmSessions.apply(this, arguments);
+}
+function migrateOlmSessions(_x13, _x14, _x15, _x16, _x17) {
+  return _migrateOlmSessions.apply(this, arguments);
+}
+function _migrateOlmSessions() {
+  _migrateOlmSessions = _asyncToGenerator(function* (logger, legacyStore, pickleKey, storeHandle, onBatchDone) {
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      var batch = yield legacyStore.getEndToEndSessionsBatch();
+      if (batch === null) return;
+      logger.debug("Migrating batch of ".concat(batch.length, " olm sessions"));
+      var migrationData = [];
+      for (var session of batch) {
+        var pickledSession = new RustSdkCryptoJs.PickledSession();
+        pickledSession.senderKey = session.deviceKey;
+        pickledSession.pickle = session.session;
+        pickledSession.lastUseTime = pickledSession.creationTime = new Date(session.lastReceivedMessageTs);
+        migrationData.push(pickledSession);
+      }
+      yield RustSdkCryptoJs.Migration.migrateOlmSessions(migrationData, pickleKey, storeHandle);
+      yield legacyStore.deleteEndToEndSessionsBatch(batch);
+      onBatchDone(batch.length);
+    }
+  });
+  return _migrateOlmSessions.apply(this, arguments);
+}
+function migrateMegolmSessions(_x18, _x19, _x20, _x21, _x22) {
+  return _migrateMegolmSessions.apply(this, arguments);
+}
+/**
+ * Determine if any room settings need migrating from the legacy store, and do so.
+ *
+ * @param args - Arguments object.
+ */
+function _migrateMegolmSessions() {
+  _migrateMegolmSessions = _asyncToGenerator(function* (logger, legacyStore, pickleKey, storeHandle, onBatchDone) {
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      var batch = yield legacyStore.getEndToEndInboundGroupSessionsBatch();
+      if (batch === null) return;
+      logger.debug("Migrating batch of ".concat(batch.length, " megolm sessions"));
+      var migrationData = [];
+      for (var session of batch) {
+        var _sessionData$keysClai;
+        var sessionData = session.sessionData;
+        var pickledSession = new RustSdkCryptoJs.PickledInboundGroupSession();
+        pickledSession.pickle = sessionData.session;
+        pickledSession.roomId = new RustSdkCryptoJs.RoomId(sessionData.room_id);
+        pickledSession.senderKey = session.senderKey;
+        pickledSession.senderSigningKey = (_sessionData$keysClai = sessionData.keysClaimed) === null || _sessionData$keysClai === void 0 ? void 0 : _sessionData$keysClai["ed25519"];
+        pickledSession.backedUp = !session.needsBackup;
+
+        // The Rust SDK `imported` flag is used to indicate the authenticity status of a Megolm
+        // session, which tells us whether we can reliably tell which Olm device is the owner
+        // (creator) of the session.
+        //
+        // If `imported` is true, then we have no cryptographic proof that the session is owned
+        // by the device with the identity key `senderKey`.
+        //
+        // Only Megolm sessions received directly from the owning device via an encrypted
+        // `m.room_key` to-device message should have `imported` flag set to false. Megolm
+        // sessions received by any other currently available means (i.e. from a
+        // `m.forwarded_room_key`, from v1 asymmetric server-side key backup, imported from a
+        // file, etc) should have the `imported` flag set to true.
+        //
+        // Messages encrypted with such Megolm sessions will have a grey shield in the UI
+        // ("Authenticity of this message cannot be guaranteed").
+        //
+        // However, we don't want to bluntly mark all sessions as `imported` during migration
+        // because users will suddenly start seeing all their historic messages decorated with a
+        // grey shield, which would be seen as a non-actionable regression.
+        //
+        // In the legacy crypto stack, the flag encoding similar information was called
+        // `InboundGroupSessionData.untrusted`. The value of this flag was set as follows:
+        //
+        // - For outbound Megolm sessions created by our own device, `untrusted` is `undefined`.
+        // - For Megolm sessions received via a `m.room_key` to-device message, `untrusted` is
+        //   `undefined`.
+        // - For Megolm sessions received via a `m.forwarded_room_key` to-device message,
+        //   `untrusted` is `true`.
+        // - For Megolm sessions imported from a (v1 asymmetric / "legacy") server-side key
+        //   backup, `untrusted` is `true`.
+        // - For Megolm sessions imported from a file, untrusted is `undefined`.
+        //
+        // The main difference between the legacy crypto stack and the Rust crypto stack is that
+        // the Rust stack considers sessions imported from a file as `imported` (not
+        // authenticated). This is because the Megolm session export file format does not
+        // encode this authenticity information.
+        //
+        // Given this migration is only a one-time thing, we make a concession to accept the
+        // loss of information in this case, to avoid degrading UX in a non-actionable way.
+        pickledSession.imported = sessionData.untrusted === true;
+        migrationData.push(pickledSession);
+      }
+      yield RustSdkCryptoJs.Migration.migrateMegolmSessions(migrationData, pickleKey, storeHandle);
+      yield legacyStore.deleteEndToEndInboundGroupSessionsBatch(batch);
+      onBatchDone(batch.length);
+    }
+  });
+  return _migrateMegolmSessions.apply(this, arguments);
+}
+export function migrateRoomSettingsFromLegacyCrypto(_x23) {
+  return _migrateRoomSettingsFromLegacyCrypto.apply(this, arguments);
+}
+function _migrateRoomSettingsFromLegacyCrypto() {
+  _migrateRoomSettingsFromLegacyCrypto = _asyncToGenerator(function* (_ref) {
+    var {
+      logger,
+      legacyStore,
+      olmMachine
+    } = _ref;
+    if (!(yield legacyStore.containsData())) {
+      // This store was never used. Nothing to migrate.
+      return;
+    }
+    var migrationState = yield legacyStore.getMigrationState();
+    if (migrationState >= MigrationState.ROOM_SETTINGS_MIGRATED) {
+      // We've already migrated the room settings.
+      return;
+    }
+    var rooms = {};
+    yield legacyStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ROOMS], txn => {
+      legacyStore.getEndToEndRooms(txn, result => {
+        rooms = result;
+      });
+    });
+    logger.debug("Migrating ".concat(Object.keys(rooms).length, " sets of room settings"));
+    for (var [roomId, legacySettings] of Object.entries(rooms)) {
+      try {
+        var rustSettings = new RustSdkCryptoJs.RoomSettings();
+        if (legacySettings.algorithm !== "m.megolm.v1.aes-sha2") {
+          logger.warn("Room ".concat(roomId, ": ignoring room with invalid algorithm ").concat(legacySettings.algorithm));
+          continue;
+        }
+        rustSettings.algorithm = RustSdkCryptoJs.EncryptionAlgorithm.MegolmV1AesSha2;
+        rustSettings.sessionRotationPeriodMs = legacySettings.rotation_period_ms;
+        rustSettings.sessionRotationPeriodMessages = legacySettings.rotation_period_msgs;
+        yield olmMachine.setRoomSettings(new RustSdkCryptoJs.RoomId(roomId), rustSettings);
+
+        // We don't attempt to clear out the settings from the old store, or record where we've gotten up to,
+        // which means that if the app gets restarted while we're in the middle of this migration, we'll start
+        // again from scratch. So be it. Given that legacy crypto loads the whole room list into memory on startup
+        // anyway, we know it can't be that big.
+      } catch (e) {
+        logger.warn("Room ".concat(roomId, ": ignoring settings ").concat(JSON.stringify(legacySettings), " which caused error ").concat(e));
+      }
+    }
+    logger.debug("Completed room settings migration");
+    yield legacyStore.setMigrationState(MigrationState.ROOM_SETTINGS_MIGRATED);
+  });
+  return _migrateRoomSettingsFromLegacyCrypto.apply(this, arguments);
+}
+function getAndDecryptCachedSecretKey(_x24, _x25, _x26) {
+  return _getAndDecryptCachedSecretKey.apply(this, arguments);
+}
+/**
+ * Check if the user's published identity (ie, public cross-signing keys) was trusted by the legacy session,
+ * and if so mark it as trusted in the Rust session if needed.
+ *
+ * By default, if the legacy session didn't have the private MSK, the migrated session will revert to unverified,
+ * even if the user has verified the session in the past.
+ *
+ * This only occurs if the private MSK was not cached in the crypto store (USK and SSK private keys won't help
+ * to establish trust: the trust is rooted in the MSK).
+ *
+ * Rust crypto will only consider the current session as trusted if we import the private MSK itself.
+ *
+ * We could prompt the user to verify the session again, but it's probably better to just mark the user identity
+ * as locally verified if it was before.
+ *
+ * See https://github.com/element-hq/element-web/issues/27079
+ *
+ * @param args - Argument object.
+ */
+function _getAndDecryptCachedSecretKey() {
+  _getAndDecryptCachedSecretKey = _asyncToGenerator(function* (legacyStore, legacyPickleKey, name) {
+    var key = yield new Promise(resolve => {
+      legacyStore.doTxn("readonly", [IndexedDBCryptoStore.STORE_ACCOUNT], txn => {
+        legacyStore.getSecretStorePrivateKey(txn, resolve, name);
+      });
+    });
+    if (key && key.ciphertext && key.iv && key.mac) {
+      return yield decryptAESSecretStorageItem(key, legacyPickleKey, name);
+    } else if (key instanceof Uint8Array) {
+      // This is a legacy backward compatibility case where the key was stored in clear.
+      return encodeBase64(key);
+    } else {
+      return undefined;
+    }
+  });
+  return _getAndDecryptCachedSecretKey.apply(this, arguments);
+}
+export function migrateLegacyLocalTrustIfNeeded(_x27) {
+  return _migrateLegacyLocalTrustIfNeeded.apply(this, arguments);
+}
+
+/**
+ * Checks if the legacy store has a trusted public master key, and returns it if so.
+ *
+ * @param legacyStore - The legacy store to check.
+ *
+ * @returns `null` if there were no cross signing keys or if they were not trusted. The trusted public master key if it was.
+ */
+function _migrateLegacyLocalTrustIfNeeded() {
+  _migrateLegacyLocalTrustIfNeeded = _asyncToGenerator(function* (args) {
+    var {
+      legacyCryptoStore,
+      rustCrypto,
+      logger
+    } = args;
+    // Get the public cross-signing identity from rust.
+    var rustOwnIdentity = yield rustCrypto.getOwnIdentity();
+    if (!rustOwnIdentity) {
+      // There are no cross-signing keys published server side, so nothing to do here.
+      return;
+    }
+    if (rustOwnIdentity.isVerified()) {
+      // The rust session already trusts the keys, so again, nothing to do.
+      return;
+    }
+    var legacyLocallyTrustedMSK = yield getLegacyTrustedPublicMasterKeyBase64(legacyCryptoStore);
+    if (!legacyLocallyTrustedMSK) {
+      // The user never verified their identity in the legacy session, so nothing to do.
+      return;
+    }
+    var mskInfo = JSON.parse(rustOwnIdentity.masterKey);
+    if (!mskInfo.keys || Object.keys(mskInfo.keys).length === 0) {
+      // This should not happen, but let's be safe
+      logger.error("Post Migration | Unexpected error: no master key in the rust session.");
+      return;
+    }
+    var rustSeenMSK = Object.values(mskInfo.keys)[0];
+    if (rustSeenMSK && rustSeenMSK == legacyLocallyTrustedMSK) {
+      logger.info("Post Migration: Migrating legacy trusted MSK: ".concat(legacyLocallyTrustedMSK, " to locally verified."));
+      // Let's mark the user identity as locally verified as part of the migration.
+      yield rustOwnIdentity.verify();
+      // As well as marking the MSK as trusted, `OlmMachine.verify` returns a
+      // `SignatureUploadRequest` which will publish a signature of the MSK using
+      // this device. In this case, we ignore the request: since the user hasn't
+      // actually re-verified the MSK, we don't publish a new signature. (`.verify`
+      // doesn't store the signature, and if we drop the request here it won't be
+      // retried.)
+      //
+      // Not publishing the signature is consistent with the behaviour of
+      // matrix-crypto-sdk when the private key is imported via
+      // `importCrossSigningKeys`, and when the identity is verified via interactive
+      // verification.
+      //
+      // [Aside: device signatures on the MSK are not considered by the rust-sdk to
+      // establish the trust of the user identity so in any case, what we actually do
+      // here is somewhat moot.]
+    }
+  });
+  return _migrateLegacyLocalTrustIfNeeded.apply(this, arguments);
+}
+function getLegacyTrustedPublicMasterKeyBase64(_x28) {
+  return _getLegacyTrustedPublicMasterKeyBase.apply(this, arguments);
+}
+function _getLegacyTrustedPublicMasterKeyBase() {
+  _getLegacyTrustedPublicMasterKeyBase = _asyncToGenerator(function* (legacyStore) {
+    var maybeTrustedKeys = null;
+    yield legacyStore.doTxn("readonly", "account", txn => {
+      legacyStore.getCrossSigningKeys(txn, keys => {
+        // can be an empty object after resetting cross-signing keys, see storeTrustedSelfKeys
+        var msk = keys === null || keys === void 0 ? void 0 : keys.master;
+        if (msk && Object.keys(msk.keys).length != 0) {
+          // `msk.keys` is an object with { [`ed25519:${pubKey}`]: pubKey }
+          maybeTrustedKeys = Object.values(msk.keys)[0];
+        }
+      });
+    });
+    return maybeTrustedKeys;
+  });
+  return _getLegacyTrustedPublicMasterKeyBase.apply(this, arguments);
+}
+//# sourceMappingURL=libolm_migration.js.map

package/lib/rust-crypto/libolm_migration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"libolm_migration.js","names":["RustSdkCryptoJs","MigrationState","IndexedDBCryptoStore","requestKeyBackupVersion","sleep","encodeBase64","decryptAESSecretStorageItem","migrateFromLegacyCrypto","_x","_migrateFromLegacyCrypto","apply","arguments","_asyncToGenerator","args","_args$legacyMigration2","logger","legacyStore","initAsync","Tracing","LoggerLevel","Debug","turnOn","containsData","startup","accountPickle","doTxn","STORE_ACCOUNT","txn","getAccount","acctPickle","debug","migrationState","getMigrationState","MEGOLM_SESSIONS_MIGRATED","nOlmSessions","countOlmSessions","nMegolmSessions","countMegolmSessions","totalSteps","info","concat","stepsDone","onProgress","steps","_args$legacyMigration","legacyMigrationProgressListener","call","pickleKey","TextEncoder","encode","legacyPickleKey","NOT_STARTED","migrateBaseData","http","userId","deviceId","storeHandle","INITIAL_DATA_MIGRATED","setMigrationState","migrateOlmSessions","OLM_SESSIONS_MIGRATED","migrateMegolmSessions","_x2","_x3","_x4","_x5","_x6","_x7","_x8","_migrateBaseData","migrationData","BaseMigrationData","UserId","DeviceId","a","pickledAccount","recoveryKey","getAndDecryptCachedSecretKey","backupCallDone","backupInfo","e","algorithm","_backupInfo$auth_data","decryptionKey","BackupDecryptionKey","fromBase64","publicKey","auth_data","public_key","isValid","megolmV1PublicKey","publicKeyBase64","backupVersion","version","backupRecoveryKey","warn","privateCrossSigningMasterKey","privateCrossSigningSelfSigningKey","privateCrossSigningUserSigningKey","Migration","_x9","_x10","_countOlmSessions","nSessions","STORE_SESSIONS","countEndToEndSessions","n","_x11","_x12","_countMegolmSessions","countEndToEndInboundGroupSessions","_x13","_x14","_x15","_x16","_x17","_migrateOlmSessions","onBatchDone","batch","getEndToEndSessionsBatch","length","session","pickledSession","PickledSession","senderKey","deviceKey","pickle","lastUseTime","creationTime","Date","lastReceivedMessageTs","push","deleteEndToEndSessionsBatch","_x18","_x19","_x20","_x21","_x22","_migrateMegolmSessions","getEndToEndInboundGroupSessionsBatch","_sessionData$keysClai","sessionData","PickledInboundGroupSession","roomId","RoomId","room_id","senderSigningKey","keysClaimed","backedUp","needsBackup","imported","untrusted","deleteEndToEndInboundGroupSessionsBatch","migrateRoomSettingsFromLegacyCrypto","_x23","_migrateRoomSettingsFromLegacyCrypto","_ref","olmMachine","ROOM_SETTINGS_MIGRATED","rooms","STORE_ROOMS","getEndToEndRooms","result","Object","keys","legacySettings","entries","rustSettings","RoomSettings","EncryptionAlgorithm","MegolmV1AesSha2","sessionRotationPeriodMs","rotation_period_ms","sessionRotationPeriodMessages","rotation_period_msgs","setRoomSettings","JSON","stringify","_x24","_x25","_x26","_getAndDecryptCachedSecretKey","name","key","Promise","resolve","getSecretStorePrivateKey","ciphertext","iv","mac","Uint8Array","undefined","migrateLegacyLocalTrustIfNeeded","_x27","_migrateLegacyLocalTrustIfNeeded","legacyCryptoStore","rustCrypto","rustOwnIdentity","getOwnIdentity","isVerified","legacyLocallyTrustedMSK","getLegacyTrustedPublicMasterKeyBase64","mskInfo","parse","masterKey","error","rustSeenMSK","values","verify","_x28","_getLegacyTrustedPublicMasterKeyBase","maybeTrustedKeys","getCrossSigningKeys","msk","master"],"sources":["../../src/rust-crypto/libolm_migration.ts"],"sourcesContent":["/*\nCopyright 2023-2024 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport * as RustSdkCryptoJs from \"@matrix-org/matrix-sdk-crypto-wasm\";\n\nimport { Logger } from \"../logger.ts\";\nimport { CryptoStore, MigrationState, SecretStorePrivateKeys } from \"../crypto/store/base.ts\";\nimport { IndexedDBCryptoStore } from \"../crypto/store/indexeddb-crypto-store.ts\";\nimport { IHttpOpts, MatrixHttpApi } from \"../http-api/index.ts\";\nimport { requestKeyBackupVersion } from \"./backup.ts\";\nimport { IRoomEncryption } from \"../crypto/RoomList.ts\";\nimport { CrossSigningKeyInfo, Curve25519AuthData } from \"../crypto-api/index.ts\";\nimport { RustCrypto } from \"./rust-crypto.ts\";\nimport { KeyBackupInfo } from \"../crypto-api/keybackup.ts\";\nimport { sleep } from \"../utils.ts\";\nimport { encodeBase64 } from \"../base64.ts\";\nimport decryptAESSecretStorageItem from \"../utils/decryptAESSecretStorageItem.ts\";\nimport { AESEncryptedSecretStoragePayload } from \"../@types/AESEncryptedSecretStoragePayload.ts\";\n\n/**\n * Determine if any data needs migrating from the legacy store, and do so.\n *\n * This migrates the base account data, and olm and megolm sessions. It does *not* migrate the room list, which should\n * happen after an `OlmMachine` is created, via {@link migrateRoomSettingsFromLegacyCrypto}.\n *\n * @param args - Arguments object.\n */\nexport async function migrateFromLegacyCrypto(args: {\n    /** A `Logger` instance that will be used for debug output. */\n    logger: Logger;\n\n    /**\n     * Low-level HTTP interface: used to make outgoing requests required by the rust SDK.\n     * We expect it to set the access token, etc.\n     */\n    http: MatrixHttpApi<IHttpOpts & { onlyData: true }>;\n\n    /** Store to migrate data from. */\n    legacyStore: CryptoStore;\n\n    /** Pickle key for `legacyStore`. */\n    legacyPickleKey?: string;\n\n    /** Local user's User ID. */\n    userId: string;\n\n    /** Local user's Device ID. */\n    deviceId: string;\n\n    /** Rust crypto store to migrate data into. */\n    storeHandle: RustSdkCryptoJs.StoreHandle;\n\n    /**\n     * A callback which will receive progress updates on migration from `legacyStore`.\n     *\n     * Called with (-1, -1) to mark the end of migration.\n     */\n    legacyMigrationProgressListener?: (progress: number, total: number) => void;\n}): Promise<void> {\n    const { logger, legacyStore } = args;\n\n    // initialise the rust matrix-sdk-crypto-wasm, if it hasn't already been done\n    await RustSdkCryptoJs.initAsync();\n\n    // enable tracing in the rust-sdk\n    new RustSdkCryptoJs.Tracing(RustSdkCryptoJs.LoggerLevel.Debug).turnOn();\n\n    if (!(await legacyStore.containsData())) {\n        // This store was never used. Nothing to migrate.\n        return;\n    }\n\n    await legacyStore.startup();\n\n    let accountPickle: string | null = null;\n    await legacyStore.doTxn(\"readonly\", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {\n        legacyStore.getAccount(txn, (acctPickle) => {\n            accountPickle = acctPickle;\n        });\n    });\n    if (!accountPickle) {\n        // This store is not properly set up. Nothing to migrate.\n        logger.debug(\"Legacy crypto store is not set up (no account found). Not migrating.\");\n        return;\n    }\n\n    let migrationState = await legacyStore.getMigrationState();\n\n    if (migrationState >= MigrationState.MEGOLM_SESSIONS_MIGRATED) {\n        // All migration is done for now. The room list comes later, once we have an OlmMachine.\n        return;\n    }\n\n    const nOlmSessions = await countOlmSessions(logger, legacyStore);\n    const nMegolmSessions = await countMegolmSessions(logger, legacyStore);\n    const totalSteps = 1 + nOlmSessions + nMegolmSessions;\n    logger.info(\n        `Migrating data from legacy crypto store. ${nOlmSessions} olm sessions and ${nMegolmSessions} megolm sessions to migrate.`,\n    );\n\n    let stepsDone = 0;\n    function onProgress(steps: number): void {\n        stepsDone += steps;\n        args.legacyMigrationProgressListener?.(stepsDone, totalSteps);\n    }\n    onProgress(0);\n\n    const pickleKey = new TextEncoder().encode(args.legacyPickleKey);\n\n    if (migrationState === MigrationState.NOT_STARTED) {\n        logger.info(\"Migrating data from legacy crypto store. Step 1: base data\");\n        await migrateBaseData(args.http, args.userId, args.deviceId, legacyStore, pickleKey, args.storeHandle, logger);\n\n        migrationState = MigrationState.INITIAL_DATA_MIGRATED;\n        await legacyStore.setMigrationState(migrationState);\n    }\n    onProgress(1);\n\n    if (migrationState === MigrationState.INITIAL_DATA_MIGRATED) {\n        logger.info(\n            `Migrating data from legacy crypto store. Step 2: olm sessions (${nOlmSessions} sessions to migrate).`,\n        );\n        await migrateOlmSessions(logger, legacyStore, pickleKey, args.storeHandle, onProgress);\n\n        migrationState = MigrationState.OLM_SESSIONS_MIGRATED;\n        await legacyStore.setMigrationState(migrationState);\n    }\n\n    if (migrationState === MigrationState.OLM_SESSIONS_MIGRATED) {\n        logger.info(\n            `Migrating data from legacy crypto store. Step 3: megolm sessions (${nMegolmSessions} sessions to migrate).`,\n        );\n        await migrateMegolmSessions(logger, legacyStore, pickleKey, args.storeHandle, onProgress);\n\n        migrationState = MigrationState.MEGOLM_SESSIONS_MIGRATED;\n        await legacyStore.setMigrationState(migrationState);\n    }\n\n    // Migration is done.\n    args.legacyMigrationProgressListener?.(-1, -1);\n    logger.info(\"Migration from legacy crypto store complete\");\n}\n\nasync function migrateBaseData(\n    http: MatrixHttpApi<IHttpOpts & { onlyData: true }>,\n    userId: string,\n    deviceId: string,\n    legacyStore: CryptoStore,\n    pickleKey: Uint8Array,\n    storeHandle: RustSdkCryptoJs.StoreHandle,\n    logger: Logger,\n): Promise<void> {\n    const migrationData = new RustSdkCryptoJs.BaseMigrationData();\n    migrationData.userId = new RustSdkCryptoJs.UserId(userId);\n    migrationData.deviceId = new RustSdkCryptoJs.DeviceId(deviceId);\n\n    await legacyStore.doTxn(\"readonly\", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) =>\n        legacyStore.getAccount(txn, (a) => {\n            migrationData.pickledAccount = a ?? \"\";\n        }),\n    );\n\n    const recoveryKey = await getAndDecryptCachedSecretKey(legacyStore, pickleKey, \"m.megolm_backup.v1\");\n\n    // If we have a backup recovery key, we need to try to figure out which backup version it is for.\n    // All we can really do is ask the server for the most recent version and check if the cached key we have matches.\n    // It is possible that the backup has changed since last time his session was opened.\n    if (recoveryKey) {\n        let backupCallDone = false;\n        let backupInfo: KeyBackupInfo | null = null;\n        while (!backupCallDone) {\n            try {\n                backupInfo = await requestKeyBackupVersion(http);\n                backupCallDone = true;\n            } catch (e) {\n                logger.info(\"Failed to get backup version during migration, retrying in 2 seconds\", e);\n                // Retry until successful, use simple constant delay\n                await sleep(2000);\n            }\n        }\n        if (backupInfo && backupInfo.algorithm == \"m.megolm_backup.v1.curve25519-aes-sha2\") {\n            // check if the recovery key matches, as the active backup version may have changed since the key was cached\n            // and the migration started.\n            try {\n                const decryptionKey = RustSdkCryptoJs.BackupDecryptionKey.fromBase64(recoveryKey);\n                const publicKey = (backupInfo.auth_data as Curve25519AuthData)?.public_key;\n                const isValid = decryptionKey.megolmV1PublicKey.publicKeyBase64 == publicKey;\n                if (isValid) {\n                    migrationData.backupVersion = backupInfo.version;\n                    migrationData.backupRecoveryKey = recoveryKey;\n                } else {\n                    logger.debug(\n                        \"The backup key to migrate does not match the active backup version\",\n                        `Cached pub key: ${decryptionKey.megolmV1PublicKey.publicKeyBase64}`,\n                        `Active pub key: ${publicKey}`,\n                    );\n                }\n            } catch (e) {\n                logger.warn(\"Failed to check if the backup key to migrate matches the active backup version\", e);\n            }\n        }\n    }\n\n    migrationData.privateCrossSigningMasterKey = await getAndDecryptCachedSecretKey(legacyStore, pickleKey, \"master\");\n    migrationData.privateCrossSigningSelfSigningKey = await getAndDecryptCachedSecretKey(\n        legacyStore,\n        pickleKey,\n        \"self_signing\",\n    );\n    migrationData.privateCrossSigningUserSigningKey = await getAndDecryptCachedSecretKey(\n        legacyStore,\n        pickleKey,\n        \"user_signing\",\n    );\n    await RustSdkCryptoJs.Migration.migrateBaseData(migrationData, pickleKey, storeHandle);\n}\n\nasync function countOlmSessions(logger: Logger, legacyStore: CryptoStore): Promise<number> {\n    logger.debug(\"Counting olm sessions to be migrated\");\n    let nSessions: number;\n    await legacyStore.doTxn(\"readonly\", [IndexedDBCryptoStore.STORE_SESSIONS], (txn) =>\n        legacyStore.countEndToEndSessions(txn, (n) => (nSessions = n)),\n    );\n    return nSessions!;\n}\n\nasync function countMegolmSessions(logger: Logger, legacyStore: CryptoStore): Promise<number> {\n    logger.debug(\"Counting megolm sessions to be migrated\");\n    return await legacyStore.countEndToEndInboundGroupSessions();\n}\n\nasync function migrateOlmSessions(\n    logger: Logger,\n    legacyStore: CryptoStore,\n    pickleKey: Uint8Array,\n    storeHandle: RustSdkCryptoJs.StoreHandle,\n    onBatchDone: (batchSize: number) => void,\n): Promise<void> {\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n        const batch = await legacyStore.getEndToEndSessionsBatch();\n        if (batch === null) return;\n\n        logger.debug(`Migrating batch of ${batch.length} olm sessions`);\n        const migrationData: RustSdkCryptoJs.PickledSession[] = [];\n        for (const session of batch) {\n            const pickledSession = new RustSdkCryptoJs.PickledSession();\n            pickledSession.senderKey = session.deviceKey!;\n            pickledSession.pickle = session.session!;\n            pickledSession.lastUseTime = pickledSession.creationTime = new Date(session.lastReceivedMessageTs!);\n            migrationData.push(pickledSession);\n        }\n\n        await RustSdkCryptoJs.Migration.migrateOlmSessions(migrationData, pickleKey, storeHandle);\n        await legacyStore.deleteEndToEndSessionsBatch(batch);\n        onBatchDone(batch.length);\n    }\n}\n\nasync function migrateMegolmSessions(\n    logger: Logger,\n    legacyStore: CryptoStore,\n    pickleKey: Uint8Array,\n    storeHandle: RustSdkCryptoJs.StoreHandle,\n    onBatchDone: (batchSize: number) => void,\n): Promise<void> {\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n        const batch = await legacyStore.getEndToEndInboundGroupSessionsBatch();\n        if (batch === null) return;\n\n        logger.debug(`Migrating batch of ${batch.length} megolm sessions`);\n        const migrationData: RustSdkCryptoJs.PickledInboundGroupSession[] = [];\n        for (const session of batch) {\n            const sessionData = session.sessionData!;\n\n            const pickledSession = new RustSdkCryptoJs.PickledInboundGroupSession();\n            pickledSession.pickle = sessionData.session;\n            pickledSession.roomId = new RustSdkCryptoJs.RoomId(sessionData.room_id);\n            pickledSession.senderKey = session.senderKey;\n            pickledSession.senderSigningKey = sessionData.keysClaimed?.[\"ed25519\"];\n            pickledSession.backedUp = !session.needsBackup;\n\n            // The Rust SDK `imported` flag is used to indicate the authenticity status of a Megolm\n            // session, which tells us whether we can reliably tell which Olm device is the owner\n            // (creator) of the session.\n            //\n            // If `imported` is true, then we have no cryptographic proof that the session is owned\n            // by the device with the identity key `senderKey`.\n            //\n            // Only Megolm sessions received directly from the owning device via an encrypted\n            // `m.room_key` to-device message should have `imported` flag set to false. Megolm\n            // sessions received by any other currently available means (i.e. from a\n            // `m.forwarded_room_key`, from v1 asymmetric server-side key backup, imported from a\n            // file, etc) should have the `imported` flag set to true.\n            //\n            // Messages encrypted with such Megolm sessions will have a grey shield in the UI\n            // (\"Authenticity of this message cannot be guaranteed\").\n            //\n            // However, we don't want to bluntly mark all sessions as `imported` during migration\n            // because users will suddenly start seeing all their historic messages decorated with a\n            // grey shield, which would be seen as a non-actionable regression.\n            //\n            // In the legacy crypto stack, the flag encoding similar information was called\n            // `InboundGroupSessionData.untrusted`. The value of this flag was set as follows:\n            //\n            // - For outbound Megolm sessions created by our own device, `untrusted` is `undefined`.\n            // - For Megolm sessions received via a `m.room_key` to-device message, `untrusted` is\n            //   `undefined`.\n            // - For Megolm sessions received via a `m.forwarded_room_key` to-device message,\n            //   `untrusted` is `true`.\n            // - For Megolm sessions imported from a (v1 asymmetric / \"legacy\") server-side key\n            //   backup, `untrusted` is `true`.\n            // - For Megolm sessions imported from a file, untrusted is `undefined`.\n            //\n            // The main difference between the legacy crypto stack and the Rust crypto stack is that\n            // the Rust stack considers sessions imported from a file as `imported` (not\n            // authenticated). This is because the Megolm session export file format does not\n            // encode this authenticity information.\n            //\n            // Given this migration is only a one-time thing, we make a concession to accept the\n            // loss of information in this case, to avoid degrading UX in a non-actionable way.\n            pickledSession.imported = sessionData.untrusted === true;\n\n            migrationData.push(pickledSession);\n        }\n\n        await RustSdkCryptoJs.Migration.migrateMegolmSessions(migrationData, pickleKey, storeHandle);\n        await legacyStore.deleteEndToEndInboundGroupSessionsBatch(batch);\n        onBatchDone(batch.length);\n    }\n}\n\n/**\n * Determine if any room settings need migrating from the legacy store, and do so.\n *\n * @param args - Arguments object.\n */\nexport async function migrateRoomSettingsFromLegacyCrypto({\n    logger,\n    legacyStore,\n    olmMachine,\n}: {\n    /** A `Logger` instance that will be used for debug output. */\n    logger: Logger;\n\n    /** Store to migrate data from. */\n    legacyStore: CryptoStore;\n\n    /** OlmMachine to store the new data on. */\n    olmMachine: RustSdkCryptoJs.OlmMachine;\n}): Promise<void> {\n    if (!(await legacyStore.containsData())) {\n        // This store was never used. Nothing to migrate.\n        return;\n    }\n\n    const migrationState = await legacyStore.getMigrationState();\n\n    if (migrationState >= MigrationState.ROOM_SETTINGS_MIGRATED) {\n        // We've already migrated the room settings.\n        return;\n    }\n\n    let rooms: Record<string, IRoomEncryption> = {};\n\n    await legacyStore.doTxn(\"readwrite\", [IndexedDBCryptoStore.STORE_ROOMS], (txn) => {\n        legacyStore.getEndToEndRooms(txn, (result) => {\n            rooms = result;\n        });\n    });\n\n    logger.debug(`Migrating ${Object.keys(rooms).length} sets of room settings`);\n    for (const [roomId, legacySettings] of Object.entries(rooms)) {\n        try {\n            const rustSettings = new RustSdkCryptoJs.RoomSettings();\n\n            if (legacySettings.algorithm !== \"m.megolm.v1.aes-sha2\") {\n                logger.warn(`Room ${roomId}: ignoring room with invalid algorithm ${legacySettings.algorithm}`);\n                continue;\n            }\n            rustSettings.algorithm = RustSdkCryptoJs.EncryptionAlgorithm.MegolmV1AesSha2;\n            rustSettings.sessionRotationPeriodMs = legacySettings.rotation_period_ms;\n            rustSettings.sessionRotationPeriodMessages = legacySettings.rotation_period_msgs;\n            await olmMachine.setRoomSettings(new RustSdkCryptoJs.RoomId(roomId), rustSettings);\n\n            // We don't attempt to clear out the settings from the old store, or record where we've gotten up to,\n            // which means that if the app gets restarted while we're in the middle of this migration, we'll start\n            // again from scratch. So be it. Given that legacy crypto loads the whole room list into memory on startup\n            // anyway, we know it can't be that big.\n        } catch (e) {\n            logger.warn(`Room ${roomId}: ignoring settings ${JSON.stringify(legacySettings)} which caused error ${e}`);\n        }\n    }\n\n    logger.debug(`Completed room settings migration`);\n    await legacyStore.setMigrationState(MigrationState.ROOM_SETTINGS_MIGRATED);\n}\n\nasync function getAndDecryptCachedSecretKey(\n    legacyStore: CryptoStore,\n    legacyPickleKey: Uint8Array,\n    name: string,\n): Promise<string | undefined> {\n    const key = await new Promise<any>((resolve) => {\n        legacyStore.doTxn(\"readonly\", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {\n            legacyStore.getSecretStorePrivateKey(txn, resolve, name as keyof SecretStorePrivateKeys);\n        });\n    });\n\n    if (key && key.ciphertext && key.iv && key.mac) {\n        return await decryptAESSecretStorageItem(key as AESEncryptedSecretStoragePayload, legacyPickleKey, name);\n    } else if (key instanceof Uint8Array) {\n        // This is a legacy backward compatibility case where the key was stored in clear.\n        return encodeBase64(key);\n    } else {\n        return undefined;\n    }\n}\n\n/**\n * Check if the user's published identity (ie, public cross-signing keys) was trusted by the legacy session,\n * and if so mark it as trusted in the Rust session if needed.\n *\n * By default, if the legacy session didn't have the private MSK, the migrated session will revert to unverified,\n * even if the user has verified the session in the past.\n *\n * This only occurs if the private MSK was not cached in the crypto store (USK and SSK private keys won't help\n * to establish trust: the trust is rooted in the MSK).\n *\n * Rust crypto will only consider the current session as trusted if we import the private MSK itself.\n *\n * We could prompt the user to verify the session again, but it's probably better to just mark the user identity\n * as locally verified if it was before.\n *\n * See https://github.com/element-hq/element-web/issues/27079\n *\n * @param args - Argument object.\n */\nexport async function migrateLegacyLocalTrustIfNeeded(args: {\n    /** The legacy crypto store that is migrated. */\n    legacyCryptoStore: CryptoStore;\n    /** The migrated rust crypto stack. */\n    rustCrypto: RustCrypto;\n    /** The logger to use */\n    logger: Logger;\n}): Promise<void> {\n    const { legacyCryptoStore, rustCrypto, logger } = args;\n    // Get the public cross-signing identity from rust.\n    const rustOwnIdentity = await rustCrypto.getOwnIdentity();\n    if (!rustOwnIdentity) {\n        // There are no cross-signing keys published server side, so nothing to do here.\n        return;\n    }\n    if (rustOwnIdentity.isVerified()) {\n        // The rust session already trusts the keys, so again, nothing to do.\n        return;\n    }\n\n    const legacyLocallyTrustedMSK = await getLegacyTrustedPublicMasterKeyBase64(legacyCryptoStore);\n    if (!legacyLocallyTrustedMSK) {\n        // The user never verified their identity in the legacy session, so nothing to do.\n        return;\n    }\n\n    const mskInfo: CrossSigningKeyInfo = JSON.parse(rustOwnIdentity.masterKey);\n    if (!mskInfo.keys || Object.keys(mskInfo.keys).length === 0) {\n        // This should not happen, but let's be safe\n        logger.error(\"Post Migration | Unexpected error: no master key in the rust session.\");\n        return;\n    }\n    const rustSeenMSK = Object.values(mskInfo.keys)[0];\n\n    if (rustSeenMSK && rustSeenMSK == legacyLocallyTrustedMSK) {\n        logger.info(`Post Migration: Migrating legacy trusted MSK: ${legacyLocallyTrustedMSK} to locally verified.`);\n        // Let's mark the user identity as locally verified as part of the migration.\n        await rustOwnIdentity!.verify();\n        // As well as marking the MSK as trusted, `OlmMachine.verify` returns a\n        // `SignatureUploadRequest` which will publish a signature of the MSK using\n        // this device. In this case, we ignore the request: since the user hasn't\n        // actually re-verified the MSK, we don't publish a new signature. (`.verify`\n        // doesn't store the signature, and if we drop the request here it won't be\n        // retried.)\n        //\n        // Not publishing the signature is consistent with the behaviour of\n        // matrix-crypto-sdk when the private key is imported via\n        // `importCrossSigningKeys`, and when the identity is verified via interactive\n        // verification.\n        //\n        // [Aside: device signatures on the MSK are not considered by the rust-sdk to\n        // establish the trust of the user identity so in any case, what we actually do\n        // here is somewhat moot.]\n    }\n}\n\n/**\n * Checks if the legacy store has a trusted public master key, and returns it if so.\n *\n * @param legacyStore - The legacy store to check.\n *\n * @returns `null` if there were no cross signing keys or if they were not trusted. The trusted public master key if it was.\n */\nasync function getLegacyTrustedPublicMasterKeyBase64(legacyStore: CryptoStore): Promise<string | null> {\n    let maybeTrustedKeys: string | null = null;\n    await legacyStore.doTxn(\"readonly\", \"account\", (txn) => {\n        legacyStore.getCrossSigningKeys(txn, (keys) => {\n            // can be an empty object after resetting cross-signing keys, see storeTrustedSelfKeys\n            const msk = keys?.master;\n            if (msk && Object.keys(msk.keys).length != 0) {\n                // `msk.keys` is an object with { [`ed25519:${pubKey}`]: pubKey }\n                maybeTrustedKeys = Object.values(msk.keys)[0];\n            }\n        });\n    });\n\n    return maybeTrustedKeys;\n}\n"],"mappings":"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","ignoreList":[]}