@unwanted/matrix-sdk-mini 34.12.0-1

package/lib/crypto/EncryptionSetup.js

@@ -0,0 +1,356 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/*
+Copyright 2021 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 { logger } from "../logger.js";
+import { MatrixEvent } from "../models/event.js";
+import { createCryptoStoreCacheCallbacks } from "./CrossSigning.js";
+import { IndexedDBCryptoStore } from "./store/indexeddb-crypto-store.js";
+import { Method, ClientPrefix } from "../http-api/index.js";
+import { ClientEvent } from "../client.js";
+import { TypedEventEmitter } from "../models/typed-event-emitter.js";
+/**
+ * Builds an EncryptionSetupOperation by calling any of the add.. methods.
+ * Once done, `buildOperation()` can be called which allows to apply to operation.
+ *
+ * This is used as a helper by Crypto to keep track of all the network requests
+ * and other side-effects of bootstrapping, so it can be applied in one go (and retried in the future)
+ * Also keeps track of all the private keys created during bootstrapping, so we don't need to prompt for them
+ * more than once.
+ */
+export class EncryptionSetupBuilder {
+  /**
+   * @param accountData - pre-existing account data, will only be read, not written.
+   * @param delegateCryptoCallbacks - crypto callbacks to delegate to if the key isn't in cache yet
+   */
+  constructor(accountData, delegateCryptoCallbacks) {
+    _defineProperty(this, "accountDataClientAdapter", void 0);
+    _defineProperty(this, "crossSigningCallbacks", void 0);
+    _defineProperty(this, "ssssCryptoCallbacks", void 0);
+    _defineProperty(this, "crossSigningKeys", void 0);
+    _defineProperty(this, "keySignatures", void 0);
+    _defineProperty(this, "keyBackupInfo", void 0);
+    _defineProperty(this, "sessionBackupPrivateKey", void 0);
+    this.accountDataClientAdapter = new AccountDataClientAdapter(accountData);
+    this.crossSigningCallbacks = new CrossSigningCallbacks();
+    this.ssssCryptoCallbacks = new SSSSCryptoCallbacks(delegateCryptoCallbacks);
+  }
+
+  /**
+   * Adds new cross-signing public keys
+   *
+   * @param authUpload - Function called to await an interactive auth
+   * flow when uploading device signing keys.
+   * Args:
+   *     A function that makes the request requiring auth. Receives
+   *     the auth data as an object. Can be called multiple times, first with
+   *     an empty authDict, to obtain the flows.
+   * @param keys - the new keys
+   */
+  addCrossSigningKeys(authUpload, keys) {
+    this.crossSigningKeys = {
+      authUpload,
+      keys
+    };
+  }
+
+  /**
+   * Adds the key backup info to be updated on the server
+   *
+   * Used either to create a new key backup, or add signatures
+   * from the new MSK.
+   *
+   * @param keyBackupInfo - as received from/sent to the server
+   */
+  addSessionBackup(keyBackupInfo) {
+    this.keyBackupInfo = keyBackupInfo;
+  }
+
+  /**
+   * Adds the session backup private key to be updated in the local cache
+   *
+   * Used after fixing the format of the key
+   *
+   */
+  addSessionBackupPrivateKeyToCache(privateKey) {
+    this.sessionBackupPrivateKey = privateKey;
+  }
+
+  /**
+   * Add signatures from a given user and device/x-sign key
+   * Used to sign the new cross-signing key with the device key
+   *
+   */
+  addKeySignature(userId, deviceId, signature) {
+    if (!this.keySignatures) {
+      this.keySignatures = {};
+    }
+    var userSignatures = this.keySignatures[userId] || {};
+    this.keySignatures[userId] = userSignatures;
+    userSignatures[deviceId] = signature;
+  }
+  setAccountData(type, content) {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      yield _this.accountDataClientAdapter.setAccountData(type, content);
+    })();
+  }
+
+  /**
+   * builds the operation containing all the parts that have been added to the builder
+   */
+  buildOperation() {
+    var accountData = this.accountDataClientAdapter.values;
+    return new EncryptionSetupOperation(accountData, this.crossSigningKeys, this.keyBackupInfo, this.keySignatures);
+  }
+
+  /**
+   * Stores the created keys locally.
+   *
+   * This does not yet store the operation in a way that it can be restored,
+   * but that is the idea in the future.
+   */
+  persist(crypto) {
+    var _this2 = this;
+    return _asyncToGenerator(function* () {
+      // store private keys in cache
+      if (_this2.crossSigningKeys) {
+        var cacheCallbacks = createCryptoStoreCacheCallbacks(crypto.cryptoStore, crypto.olmDevice);
+        for (var type of ["master", "self_signing", "user_signing"]) {
+          var _cacheCallbacks$store;
+          logger.log("Cache ".concat(type, " cross-signing private key locally"));
+          var privateKey = _this2.crossSigningCallbacks.privateKeys.get(type);
+          yield (_cacheCallbacks$store = cacheCallbacks.storeCrossSigningKeyCache) === null || _cacheCallbacks$store === void 0 ? void 0 : _cacheCallbacks$store.call(cacheCallbacks, type, privateKey);
+        }
+        // store own cross-sign pubkeys as trusted
+        yield crypto.cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ACCOUNT], txn => {
+          crypto.cryptoStore.storeCrossSigningKeys(txn, _this2.crossSigningKeys.keys);
+        });
+      }
+      // store session backup key in cache
+      if (_this2.sessionBackupPrivateKey) {
+        yield crypto.storeSessionBackupPrivateKey(_this2.sessionBackupPrivateKey);
+      }
+    })();
+  }
+}
+
+/**
+ * Can be created from EncryptionSetupBuilder, or
+ * (in a follow-up PR, not implemented yet) restored from storage, to retry.
+ *
+ * It does not have knowledge of any private keys, unlike the builder.
+ */
+export class EncryptionSetupOperation {
+  /**
+   */
+  constructor(accountData, crossSigningKeys, keyBackupInfo, keySignatures) {
+    this.accountData = accountData;
+    this.crossSigningKeys = crossSigningKeys;
+    this.keyBackupInfo = keyBackupInfo;
+    this.keySignatures = keySignatures;
+  }
+
+  /**
+   * Runs the (remaining part of, in the future) operation by sending requests to the server.
+   */
+  apply(crypto) {
+    var _this3 = this;
+    return _asyncToGenerator(function* () {
+      var baseApis = crypto.baseApis;
+      // upload cross-signing keys
+      if (_this3.crossSigningKeys) {
+        var _this3$crossSigningKe, _this3$crossSigningKe2;
+        var keys = {};
+        for (var [name, key] of Object.entries(_this3.crossSigningKeys.keys)) {
+          keys[name + "_key"] = key;
+        }
+
+        // We must only call `uploadDeviceSigningKeys` from inside this auth
+        // helper to ensure we properly handle auth errors.
+        yield (_this3$crossSigningKe = (_this3$crossSigningKe2 = _this3.crossSigningKeys).authUpload) === null || _this3$crossSigningKe === void 0 ? void 0 : _this3$crossSigningKe.call(_this3$crossSigningKe2, authDict => {
+          return baseApis.uploadDeviceSigningKeys(authDict !== null && authDict !== void 0 ? authDict : undefined, keys);
+        });
+
+        // pass the new keys to the main instance of our own CrossSigningInfo.
+        crypto.crossSigningInfo.setKeys(_this3.crossSigningKeys.keys);
+      }
+      // set account data
+      if (_this3.accountData) {
+        for (var [type, content] of _this3.accountData) {
+          yield baseApis.setAccountData(type, content);
+        }
+      }
+      // upload first cross-signing signatures with the new key
+      // (e.g. signing our own device)
+      if (_this3.keySignatures) {
+        yield baseApis.uploadKeySignatures(_this3.keySignatures);
+      }
+      // need to create/update key backup info
+      if (_this3.keyBackupInfo) {
+        if (_this3.keyBackupInfo.version) {
+          // session backup signature
+          // The backup is trusted because the user provided the private key.
+          // Sign the backup with the cross signing key so the key backup can
+          // be trusted via cross-signing.
+          yield baseApis.http.authedRequest(Method.Put, "/room_keys/version/" + _this3.keyBackupInfo.version, undefined, {
+            algorithm: _this3.keyBackupInfo.algorithm,
+            auth_data: _this3.keyBackupInfo.auth_data
+          }, {
+            prefix: ClientPrefix.V3
+          });
+        } else {
+          // add new key backup
+          yield baseApis.http.authedRequest(Method.Post, "/room_keys/version", undefined, _this3.keyBackupInfo, {
+            prefix: ClientPrefix.V3
+          });
+        }
+        // tell the backup manager to re-check the keys now that they have been (maybe) updated
+        yield crypto.backupManager.checkKeyBackup();
+      }
+    })();
+  }
+}
+
+/**
+ * Catches account data set by SecretStorage during bootstrapping by
+ * implementing the methods related to account data in MatrixClient
+ */
+class AccountDataClientAdapter extends TypedEventEmitter {
+  /**
+   * @param existingValues - existing account data
+   */
+  constructor(existingValues) {
+    super();
+    this.existingValues = existingValues;
+    //
+    _defineProperty(this, "values", new Map());
+  }
+
+  /**
+   * @returns the content of the account data
+   */
+  getAccountDataFromServer(type) {
+    return Promise.resolve(this.getAccountData(type));
+  }
+
+  /**
+   * @returns the content of the account data
+   */
+  getAccountData(type) {
+    var modifiedValue = this.values.get(type);
+    if (modifiedValue) {
+      return modifiedValue;
+    }
+    var existingValue = this.existingValues.get(type);
+    if (existingValue) {
+      return existingValue.getContent();
+    }
+    return null;
+  }
+  setAccountData(type, content) {
+    var lastEvent = this.values.get(type);
+    this.values.set(type, content);
+    // ensure accountData is emitted on the next tick,
+    // as SecretStorage listens for it while calling this method
+    // and it seems to rely on this.
+    return Promise.resolve().then(() => {
+      var event = new MatrixEvent({
+        type,
+        content
+      });
+      this.emit(ClientEvent.AccountData, event, lastEvent);
+      return {};
+    });
+  }
+}
+
+/**
+ * Catches the private cross-signing keys set during bootstrapping
+ * by both cache callbacks (see createCryptoStoreCacheCallbacks) as non-cache callbacks.
+ * See CrossSigningInfo constructor
+ */
+class CrossSigningCallbacks {
+  constructor() {
+    _defineProperty(this, "privateKeys", new Map());
+  }
+  // cache callbacks
+  getCrossSigningKeyCache(type, expectedPublicKey) {
+    return this.getCrossSigningKey(type, expectedPublicKey);
+  }
+  storeCrossSigningKeyCache(type, key) {
+    this.privateKeys.set(type, key);
+    return Promise.resolve();
+  }
+
+  // non-cache callbacks
+  getCrossSigningKey(type, expectedPubkey) {
+    var _this$privateKeys$get;
+    return Promise.resolve((_this$privateKeys$get = this.privateKeys.get(type)) !== null && _this$privateKeys$get !== void 0 ? _this$privateKeys$get : null);
+  }
+  saveCrossSigningKeys(privateKeys) {
+    for (var [type, privateKey] of Object.entries(privateKeys)) {
+      this.privateKeys.set(type, privateKey);
+    }
+  }
+}
+
+/**
+ * Catches the 4S private key set during bootstrapping by implementing
+ * the SecretStorage crypto callbacks
+ */
+class SSSSCryptoCallbacks {
+  constructor(delegateCryptoCallbacks) {
+    this.delegateCryptoCallbacks = delegateCryptoCallbacks;
+    _defineProperty(this, "privateKeys", new Map());
+  }
+  getSecretStorageKey(_ref, name) {
+    var _this4 = this;
+    return _asyncToGenerator(function* () {
+      var _this4$delegateCrypto;
+      var {
+        keys
+      } = _ref;
+      for (var keyId of Object.keys(keys)) {
+        var privateKey = _this4.privateKeys.get(keyId);
+        if (privateKey) {
+          return [keyId, privateKey];
+        }
+      }
+      // if we don't have the key cached yet, ask
+      // for it to the general crypto callbacks and cache it
+      if (_this4 !== null && _this4 !== void 0 && (_this4$delegateCrypto = _this4.delegateCryptoCallbacks) !== null && _this4$delegateCrypto !== void 0 && _this4$delegateCrypto.getSecretStorageKey) {
+        var result = yield _this4.delegateCryptoCallbacks.getSecretStorageKey({
+          keys
+        }, name);
+        if (result) {
+          var [_keyId, _privateKey] = result;
+          _this4.privateKeys.set(_keyId, _privateKey);
+        }
+        return result;
+      }
+      return null;
+    })();
+  }
+  addPrivateKey(keyId, keyInfo, privKey) {
+    var _this$delegateCryptoC, _this$delegateCryptoC2;
+    this.privateKeys.set(keyId, privKey);
+    // Also pass along to application to cache if it wishes
+    (_this$delegateCryptoC = this.delegateCryptoCallbacks) === null || _this$delegateCryptoC === void 0 || (_this$delegateCryptoC2 = _this$delegateCryptoC.cacheSecretStorageKey) === null || _this$delegateCryptoC2 === void 0 || _this$delegateCryptoC2.call(_this$delegateCryptoC, keyId, keyInfo, privKey);
+  }
+}
+//# sourceMappingURL=EncryptionSetup.js.map

package/lib/crypto/EncryptionSetup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EncryptionSetup.js","names":["logger","MatrixEvent","createCryptoStoreCacheCallbacks","IndexedDBCryptoStore","Method","ClientPrefix","ClientEvent","TypedEventEmitter","EncryptionSetupBuilder","constructor","accountData","delegateCryptoCallbacks","_defineProperty","accountDataClientAdapter","AccountDataClientAdapter","crossSigningCallbacks","CrossSigningCallbacks","ssssCryptoCallbacks","SSSSCryptoCallbacks","addCrossSigningKeys","authUpload","keys","crossSigningKeys","addSessionBackup","keyBackupInfo","addSessionBackupPrivateKeyToCache","privateKey","sessionBackupPrivateKey","addKeySignature","userId","deviceId","signature","keySignatures","userSignatures","setAccountData","type","content","_this","_asyncToGenerator","buildOperation","values","EncryptionSetupOperation","persist","crypto","_this2","cacheCallbacks","cryptoStore","olmDevice","_cacheCallbacks$store","log","concat","privateKeys","get","storeCrossSigningKeyCache","call","doTxn","STORE_ACCOUNT","txn","storeCrossSigningKeys","storeSessionBackupPrivateKey","apply","_this3","baseApis","_this3$crossSigningKe","_this3$crossSigningKe2","name","key","Object","entries","authDict","uploadDeviceSigningKeys","undefined","crossSigningInfo","setKeys","uploadKeySignatures","version","http","authedRequest","Put","algorithm","auth_data","prefix","V3","Post","backupManager","checkKeyBackup","existingValues","Map","getAccountDataFromServer","Promise","resolve","getAccountData","modifiedValue","existingValue","getContent","lastEvent","set","then","event","emit","AccountData","getCrossSigningKeyCache","expectedPublicKey","getCrossSigningKey","expectedPubkey","_this$privateKeys$get","saveCrossSigningKeys","getSecretStorageKey","_ref","_this4","_this4$delegateCrypto","keyId","result","addPrivateKey","keyInfo","privKey","_this$delegateCryptoC","_this$delegateCryptoC2","cacheSecretStorageKey"],"sources":["../../src/crypto/EncryptionSetup.ts"],"sourcesContent":["/*\nCopyright 2021 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 { logger } from \"../logger.ts\";\nimport { MatrixEvent } from \"../models/event.ts\";\nimport { createCryptoStoreCacheCallbacks, ICacheCallbacks } from \"./CrossSigning.ts\";\nimport { IndexedDBCryptoStore } from \"./store/indexeddb-crypto-store.ts\";\nimport { Method, ClientPrefix } from \"../http-api/index.ts\";\nimport { Crypto, ICryptoCallbacks } from \"./index.ts\";\nimport { ClientEvent, ClientEventHandlerMap, CrossSigningKeys, ISignedKey, KeySignatures } from \"../client.ts\";\nimport { IKeyBackupInfo } from \"./keybackup.ts\";\nimport { TypedEventEmitter } from \"../models/typed-event-emitter.ts\";\nimport { AccountDataClient, SecretStorageKeyDescription } from \"../secret-storage.ts\";\nimport { BootstrapCrossSigningOpts, CrossSigningKeyInfo } from \"../crypto-api/index.ts\";\n\ninterface ICrossSigningKeys {\n    authUpload: BootstrapCrossSigningOpts[\"authUploadDeviceSigningKeys\"];\n    keys: Record<\"master\" | \"self_signing\" | \"user_signing\", CrossSigningKeyInfo>;\n}\n\n/**\n * Builds an EncryptionSetupOperation by calling any of the add.. methods.\n * Once done, `buildOperation()` can be called which allows to apply to operation.\n *\n * This is used as a helper by Crypto to keep track of all the network requests\n * and other side-effects of bootstrapping, so it can be applied in one go (and retried in the future)\n * Also keeps track of all the private keys created during bootstrapping, so we don't need to prompt for them\n * more than once.\n */\nexport class EncryptionSetupBuilder {\n    public readonly accountDataClientAdapter: AccountDataClientAdapter;\n    public readonly crossSigningCallbacks: CrossSigningCallbacks;\n    public readonly ssssCryptoCallbacks: SSSSCryptoCallbacks;\n\n    private crossSigningKeys?: ICrossSigningKeys;\n    private keySignatures?: KeySignatures;\n    private keyBackupInfo?: IKeyBackupInfo;\n    private sessionBackupPrivateKey?: Uint8Array;\n\n    /**\n     * @param accountData - pre-existing account data, will only be read, not written.\n     * @param delegateCryptoCallbacks - crypto callbacks to delegate to if the key isn't in cache yet\n     */\n    public constructor(accountData: Map<string, MatrixEvent>, delegateCryptoCallbacks?: ICryptoCallbacks) {\n        this.accountDataClientAdapter = new AccountDataClientAdapter(accountData);\n        this.crossSigningCallbacks = new CrossSigningCallbacks();\n        this.ssssCryptoCallbacks = new SSSSCryptoCallbacks(delegateCryptoCallbacks);\n    }\n\n    /**\n     * Adds new cross-signing public keys\n     *\n     * @param authUpload - Function called to await an interactive auth\n     * flow when uploading device signing keys.\n     * Args:\n     *     A function that makes the request requiring auth. Receives\n     *     the auth data as an object. Can be called multiple times, first with\n     *     an empty authDict, to obtain the flows.\n     * @param keys - the new keys\n     */\n    public addCrossSigningKeys(authUpload: ICrossSigningKeys[\"authUpload\"], keys: ICrossSigningKeys[\"keys\"]): void {\n        this.crossSigningKeys = { authUpload, keys };\n    }\n\n    /**\n     * Adds the key backup info to be updated on the server\n     *\n     * Used either to create a new key backup, or add signatures\n     * from the new MSK.\n     *\n     * @param keyBackupInfo - as received from/sent to the server\n     */\n    public addSessionBackup(keyBackupInfo: IKeyBackupInfo): void {\n        this.keyBackupInfo = keyBackupInfo;\n    }\n\n    /**\n     * Adds the session backup private key to be updated in the local cache\n     *\n     * Used after fixing the format of the key\n     *\n     */\n    public addSessionBackupPrivateKeyToCache(privateKey: Uint8Array): void {\n        this.sessionBackupPrivateKey = privateKey;\n    }\n\n    /**\n     * Add signatures from a given user and device/x-sign key\n     * Used to sign the new cross-signing key with the device key\n     *\n     */\n    public addKeySignature(userId: string, deviceId: string, signature: ISignedKey): void {\n        if (!this.keySignatures) {\n            this.keySignatures = {};\n        }\n        const userSignatures = this.keySignatures[userId] || {};\n        this.keySignatures[userId] = userSignatures;\n        userSignatures[deviceId] = signature;\n    }\n\n    public async setAccountData(type: string, content: object): Promise<void> {\n        await this.accountDataClientAdapter.setAccountData(type, content);\n    }\n\n    /**\n     * builds the operation containing all the parts that have been added to the builder\n     */\n    public buildOperation(): EncryptionSetupOperation {\n        const accountData = this.accountDataClientAdapter.values;\n        return new EncryptionSetupOperation(accountData, this.crossSigningKeys, this.keyBackupInfo, this.keySignatures);\n    }\n\n    /**\n     * Stores the created keys locally.\n     *\n     * This does not yet store the operation in a way that it can be restored,\n     * but that is the idea in the future.\n     */\n    public async persist(crypto: Crypto): Promise<void> {\n        // store private keys in cache\n        if (this.crossSigningKeys) {\n            const cacheCallbacks = createCryptoStoreCacheCallbacks(crypto.cryptoStore, crypto.olmDevice);\n            for (const type of [\"master\", \"self_signing\", \"user_signing\"]) {\n                logger.log(`Cache ${type} cross-signing private key locally`);\n                const privateKey = this.crossSigningCallbacks.privateKeys.get(type);\n                await cacheCallbacks.storeCrossSigningKeyCache?.(type, privateKey);\n            }\n            // store own cross-sign pubkeys as trusted\n            await crypto.cryptoStore.doTxn(\"readwrite\", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {\n                crypto.cryptoStore.storeCrossSigningKeys(txn, this.crossSigningKeys!.keys);\n            });\n        }\n        // store session backup key in cache\n        if (this.sessionBackupPrivateKey) {\n            await crypto.storeSessionBackupPrivateKey(this.sessionBackupPrivateKey);\n        }\n    }\n}\n\n/**\n * Can be created from EncryptionSetupBuilder, or\n * (in a follow-up PR, not implemented yet) restored from storage, to retry.\n *\n * It does not have knowledge of any private keys, unlike the builder.\n */\nexport class EncryptionSetupOperation {\n    /**\n     */\n    public constructor(\n        private readonly accountData: Map<string, object>,\n        private readonly crossSigningKeys?: ICrossSigningKeys,\n        private readonly keyBackupInfo?: IKeyBackupInfo,\n        private readonly keySignatures?: KeySignatures,\n    ) {}\n\n    /**\n     * Runs the (remaining part of, in the future) operation by sending requests to the server.\n     */\n    public async apply(crypto: Crypto): Promise<void> {\n        const baseApis = crypto.baseApis;\n        // upload cross-signing keys\n        if (this.crossSigningKeys) {\n            const keys: Partial<CrossSigningKeys> = {};\n            for (const [name, key] of Object.entries(this.crossSigningKeys.keys)) {\n                keys[((name as keyof ICrossSigningKeys[\"keys\"]) + \"_key\") as keyof CrossSigningKeys] = key;\n            }\n\n            // We must only call `uploadDeviceSigningKeys` from inside this auth\n            // helper to ensure we properly handle auth errors.\n            await this.crossSigningKeys.authUpload?.((authDict) => {\n                return baseApis.uploadDeviceSigningKeys(authDict ?? undefined, keys as CrossSigningKeys);\n            });\n\n            // pass the new keys to the main instance of our own CrossSigningInfo.\n            crypto.crossSigningInfo.setKeys(this.crossSigningKeys.keys);\n        }\n        // set account data\n        if (this.accountData) {\n            for (const [type, content] of this.accountData) {\n                await baseApis.setAccountData(type, content);\n            }\n        }\n        // upload first cross-signing signatures with the new key\n        // (e.g. signing our own device)\n        if (this.keySignatures) {\n            await baseApis.uploadKeySignatures(this.keySignatures);\n        }\n        // need to create/update key backup info\n        if (this.keyBackupInfo) {\n            if (this.keyBackupInfo.version) {\n                // session backup signature\n                // The backup is trusted because the user provided the private key.\n                // Sign the backup with the cross signing key so the key backup can\n                // be trusted via cross-signing.\n                await baseApis.http.authedRequest(\n                    Method.Put,\n                    \"/room_keys/version/\" + this.keyBackupInfo.version,\n                    undefined,\n                    {\n                        algorithm: this.keyBackupInfo.algorithm,\n                        auth_data: this.keyBackupInfo.auth_data,\n                    },\n                    { prefix: ClientPrefix.V3 },\n                );\n            } else {\n                // add new key backup\n                await baseApis.http.authedRequest(Method.Post, \"/room_keys/version\", undefined, this.keyBackupInfo, {\n                    prefix: ClientPrefix.V3,\n                });\n            }\n            // tell the backup manager to re-check the keys now that they have been (maybe) updated\n            await crypto.backupManager.checkKeyBackup();\n        }\n    }\n}\n\n/**\n * Catches account data set by SecretStorage during bootstrapping by\n * implementing the methods related to account data in MatrixClient\n */\nclass AccountDataClientAdapter\n    extends TypedEventEmitter<ClientEvent.AccountData, ClientEventHandlerMap>\n    implements AccountDataClient\n{\n    //\n    public readonly values = new Map<string, MatrixEvent>();\n\n    /**\n     * @param existingValues - existing account data\n     */\n    public constructor(private readonly existingValues: Map<string, MatrixEvent>) {\n        super();\n    }\n\n    /**\n     * @returns the content of the account data\n     */\n    public getAccountDataFromServer<T extends { [k: string]: any }>(type: string): Promise<T | null> {\n        return Promise.resolve(this.getAccountData(type));\n    }\n\n    /**\n     * @returns the content of the account data\n     */\n    public getAccountData<T extends { [k: string]: any }>(type: string): T | null {\n        const modifiedValue = this.values.get(type);\n        if (modifiedValue) {\n            return modifiedValue as unknown as T;\n        }\n        const existingValue = this.existingValues.get(type);\n        if (existingValue) {\n            return existingValue.getContent<T>();\n        }\n        return null;\n    }\n\n    public setAccountData(type: string, content: any): Promise<{}> {\n        const lastEvent = this.values.get(type);\n        this.values.set(type, content);\n        // ensure accountData is emitted on the next tick,\n        // as SecretStorage listens for it while calling this method\n        // and it seems to rely on this.\n        return Promise.resolve().then(() => {\n            const event = new MatrixEvent({ type, content });\n            this.emit(ClientEvent.AccountData, event, lastEvent);\n            return {};\n        });\n    }\n}\n\n/**\n * Catches the private cross-signing keys set during bootstrapping\n * by both cache callbacks (see createCryptoStoreCacheCallbacks) as non-cache callbacks.\n * See CrossSigningInfo constructor\n */\nclass CrossSigningCallbacks implements ICryptoCallbacks, ICacheCallbacks {\n    public readonly privateKeys = new Map<string, Uint8Array>();\n\n    // cache callbacks\n    public getCrossSigningKeyCache(type: string, expectedPublicKey: string): Promise<Uint8Array | null> {\n        return this.getCrossSigningKey(type, expectedPublicKey);\n    }\n\n    public storeCrossSigningKeyCache(type: string, key: Uint8Array): Promise<void> {\n        this.privateKeys.set(type, key);\n        return Promise.resolve();\n    }\n\n    // non-cache callbacks\n    public getCrossSigningKey(type: string, expectedPubkey: string): Promise<Uint8Array | null> {\n        return Promise.resolve(this.privateKeys.get(type) ?? null);\n    }\n\n    public saveCrossSigningKeys(privateKeys: Record<string, Uint8Array>): void {\n        for (const [type, privateKey] of Object.entries(privateKeys)) {\n            this.privateKeys.set(type, privateKey);\n        }\n    }\n}\n\n/**\n * Catches the 4S private key set during bootstrapping by implementing\n * the SecretStorage crypto callbacks\n */\nclass SSSSCryptoCallbacks {\n    private readonly privateKeys = new Map<string, Uint8Array>();\n\n    public constructor(private readonly delegateCryptoCallbacks?: ICryptoCallbacks) {}\n\n    public async getSecretStorageKey(\n        { keys }: { keys: Record<string, SecretStorageKeyDescription> },\n        name: string,\n    ): Promise<[string, Uint8Array] | null> {\n        for (const keyId of Object.keys(keys)) {\n            const privateKey = this.privateKeys.get(keyId);\n            if (privateKey) {\n                return [keyId, privateKey];\n            }\n        }\n        // if we don't have the key cached yet, ask\n        // for it to the general crypto callbacks and cache it\n        if (this?.delegateCryptoCallbacks?.getSecretStorageKey) {\n            const result = await this.delegateCryptoCallbacks.getSecretStorageKey({ keys }, name);\n            if (result) {\n                const [keyId, privateKey] = result;\n                this.privateKeys.set(keyId, privateKey);\n            }\n            return result;\n        }\n        return null;\n    }\n\n    public addPrivateKey(keyId: string, keyInfo: SecretStorageKeyDescription, privKey: Uint8Array): void {\n        this.privateKeys.set(keyId, privKey);\n        // Also pass along to application to cache if it wishes\n        this.delegateCryptoCallbacks?.cacheSecretStorageKey?.(keyId, keyInfo, privKey);\n    }\n}\n"],"mappings":"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","ignoreList":[]}