matrix-js-sdk 28.1.0 → 28.2.0-rc.1

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

@@ -31,25 +31,29 @@ var _backup = require("./backup");
 var _ReEmitter = require("../ReEmitter");
 var _randomstring = require("../randomstring");
 var _errors = require("../errors");
+var _base = require("../common-crypto/base64");
+var _algorithms = require("../crypto/algorithms");
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } /*
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         Copyright 2022-2023 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.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         */
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } /*
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Copyright 2022-2023 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.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
 const ALL_VERIFICATION_METHODS = ["m.sas.v1", "m.qr_code.scan.v1", "m.qr_code.show.v1", "m.reciprocate.v1"];
+const KEY_BACKUP_CHECK_RATE_LIMIT = 5000; // ms
+
 /**
  * An implementation of {@link CryptoBackend} using the Rust matrix-sdk-crypto.
  *
@@ -69,24 +73,22 @@ class RustCrypto extends _typedEventEmitter.TypedEventEmitter {
   secretStorage, /** Crypto callbacks provided by the application */
   cryptoCallbacks) {
     super();
-    this.olmMachine = olmMachine;
-    this.http = http;
-    this.userId = userId;
-    this.secretStorage = secretStorage;
-    this.cryptoCallbacks = cryptoCallbacks;
     (0, _defineProperty2.default)(this, "globalErrorOnUnknownDevices", false);
     (0, _defineProperty2.default)(this, "_trustCrossSignedDevices", true);
     /** whether {@link stop} has been called */
     (0, _defineProperty2.default)(this, "stopped", false);
     /** whether {@link outgoingRequestLoop} is currently running */
     (0, _defineProperty2.default)(this, "outgoingRequestLoopRunning", false);
+    /**
+     * whether we check the outgoing requests queue again after the current check finishes.
+     *
+     * This should never be `true` unless `outgoingRequestLoopRunning` is also true.
+     */
+    (0, _defineProperty2.default)(this, "outgoingRequestLoopOneMoreLoop", false);
     /** mapping of roomId → encryptor class */
     (0, _defineProperty2.default)(this, "roomEncryptors", {});
-    (0, _defineProperty2.default)(this, "eventDecryptor", void 0);
-    (0, _defineProperty2.default)(this, "keyClaimManager", void 0);
-    (0, _defineProperty2.default)(this, "outgoingRequestProcessor", void 0);
-    (0, _defineProperty2.default)(this, "crossSigningIdentity", void 0);
-    (0, _defineProperty2.default)(this, "backupManager", void 0);
+    (0, _defineProperty2.default)(this, "sessionLastCheckAttemptedTime", {});
+    // When did we last try to check the server for a given session id?
     (0, _defineProperty2.default)(this, "reemitter", new _ReEmitter.TypedReEmitter(this));
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //
@@ -98,18 +100,51 @@ class RustCrypto extends _typedEventEmitter.TypedEventEmitter {
      * The verification methods we offer to the other side during an interactive verification.
      */
     (0, _defineProperty2.default)(this, "_supportedVerificationMethods", ALL_VERIFICATION_METHODS);
+    this.olmMachine = olmMachine;
+    this.http = http;
+    this.userId = userId;
+    this.secretStorage = secretStorage;
+    this.cryptoCallbacks = cryptoCallbacks;
     this.outgoingRequestProcessor = new _OutgoingRequestProcessor.OutgoingRequestProcessor(olmMachine, http);
     this.keyClaimManager = new _KeyClaimManager.KeyClaimManager(olmMachine, this.outgoingRequestProcessor);
-    this.eventDecryptor = new EventDecryptor(olmMachine);
+    this.eventDecryptor = new EventDecryptor(olmMachine, this);
     this.backupManager = new _backup.RustBackupManager(olmMachine, http, this.outgoingRequestProcessor);
     this.reemitter.reEmit(this.backupManager, [_crypto2.CryptoEvent.KeyBackupStatus, _crypto2.CryptoEvent.KeyBackupSessionsRemaining, _crypto2.CryptoEvent.KeyBackupFailed]);
+    this.crossSigningIdentity = new _CrossSigningIdentity.CrossSigningIdentity(olmMachine, this.outgoingRequestProcessor, secretStorage);
+  }
 
-    // Fire if the cross signing keys are imported from the secret storage
-    const onCrossSigningKeysImport = async () => {
-      const newVerification = await this.getUserVerificationStatus(this.userId);
-      this.emit(_crypto2.CryptoEvent.UserTrustStatusChanged, this.userId, newVerification);
-    };
-    this.crossSigningIdentity = new _CrossSigningIdentity.CrossSigningIdentity(olmMachine, this.outgoingRequestProcessor, secretStorage, onCrossSigningKeysImport);
+  /**
+   * Attempts to retrieve a session from a key backup, if enough time
+   * has elapsed since the last check for this session id.
+   */
+  async queryKeyBackupRateLimited(targetRoomId, targetSessionId) {
+    const backupKeys = await this.olmMachine.getBackupKeys();
+    if (!backupKeys.decryptionKey) return;
+    const version = backupKeys.backupVersion;
+    const now = new Date().getTime();
+    if (!this.sessionLastCheckAttemptedTime[targetSessionId] || now - this.sessionLastCheckAttemptedTime[targetSessionId] > KEY_BACKUP_CHECK_RATE_LIMIT) {
+      this.sessionLastCheckAttemptedTime[targetSessionId] = now;
+      const path = (0, _utils.encodeUri)("/room_keys/keys/$roomId/$sessionId", {
+        $roomId: targetRoomId,
+        $sessionId: targetSessionId
+      });
+      const res = await this.http.authedRequest(_httpApi.Method.Get, path, {
+        version
+      }, undefined, {
+        prefix: _httpApi.ClientPrefix.V3
+      });
+      if (this.stopped) return;
+      const backupDecryptor = new _backup.RustBackupDecryptor(backupKeys.decryptionKey);
+      if (res) {
+        const sessionsToImport = {};
+        sessionsToImport[targetSessionId] = res;
+        const keys = await backupDecryptor.decryptSessions(sessionsToImport);
+        for (const k of keys) {
+          k.room_id = targetRoomId;
+        }
+        await this.importRoomKeys(keys);
+      }
+    }
   }
 
   /**
@@ -167,6 +202,12 @@ class RustCrypto extends _typedEventEmitter.TypedEventEmitter {
     }
     return await this.eventDecryptor.attemptEventDecryption(event);
   }
+
+  /**
+   * Implementation of (deprecated) {@link MatrixClient#getEventEncryptionInfo}.
+   *
+   * @param event - event to inspect
+   */
   getEventEncryptionInfo(event) {
     var _event$getSenderKey;
     // TODO: make this work properly. Or better, replace it.
@@ -245,7 +286,7 @@ class RustCrypto extends _typedEventEmitter.TypedEventEmitter {
         stage: "load_keys",
         failures: 0
       };
-      opts === null || opts === void 0 || (_opts$progressCallbac = opts.progressCallback) === null || _opts$progressCallbac === void 0 ? void 0 : _opts$progressCallbac.call(opts, importOpt);
+      opts === null || opts === void 0 || (_opts$progressCallbac = opts.progressCallback) === null || _opts$progressCallbac === void 0 || _opts$progressCallbac.call(opts, importOpt);
     });
   }
 
@@ -555,7 +596,7 @@ class RustCrypto extends _typedEventEmitter.TypedEventEmitter {
     }
     const secretStorageKeyObject = await this.secretStorage.addKey(_secretStorage.SECRET_STORAGE_ALGORITHM_V1_AES, secretStorageKey.keyInfo);
     await this.secretStorage.setDefaultKeyId(secretStorageKeyObject.keyId);
-    (_this$cryptoCallbacks = (_this$cryptoCallbacks2 = this.cryptoCallbacks).cacheSecretStorageKey) === null || _this$cryptoCallbacks === void 0 ? void 0 : _this$cryptoCallbacks.call(_this$cryptoCallbacks2, secretStorageKeyObject.keyId, secretStorageKeyObject.keyInfo, secretStorageKey.privateKey);
+    (_this$cryptoCallbacks = (_this$cryptoCallbacks2 = this.cryptoCallbacks).cacheSecretStorageKey) === null || _this$cryptoCallbacks === void 0 || _this$cryptoCallbacks.call(_this$cryptoCallbacks2, secretStorageKeyObject.keyId, secretStorageKeyObject.keyInfo, secretStorageKey.privateKey);
   }
 
   /**
@@ -620,6 +661,13 @@ class RustCrypto extends _typedEventEmitter.TypedEventEmitter {
     };
   }
 
+  /**
+   * Implementation of {@link CryptoApi.getEncryptionInfoForEvent}.
+   */
+  async getEncryptionInfoForEvent(event) {
+    return this.eventDecryptor.getEncryptionInfoForEvent(event);
+  }
+
   /**
    * Returns to-device verification requests that are already in progress for the given user id.
    *
@@ -772,7 +820,7 @@ class RustCrypto extends _typedEventEmitter.TypedEventEmitter {
    * @param key - the backup decryption key
    */
   async storeSessionBackupPrivateKey(key) {
-    const base64Key = Buffer.from(key).toString("base64");
+    const base64Key = (0, _base.encodeBase64)(key);
 
     // TODO get version from backupManager
     await this.olmMachine.saveBackupDecryptionKey(RustSdkCryptoJs.BackupDecryptionKey.fromBase64(base64Key), "");
@@ -848,6 +896,24 @@ class RustCrypto extends _typedEventEmitter.TypedEventEmitter {
     obj.signatures = Object.fromEntries(sigs.entries());
   }
 
+  /**
+   * Implementation of {@link CryptoBackend#getBackupDecryptor}.
+   */
+  async getBackupDecryptor(backupInfo, privKey) {
+    if (backupInfo.algorithm != "m.megolm_backup.v1.curve25519-aes-sha2") {
+      throw new Error(`getBackupDecryptor Unsupported algorithm ${backupInfo.algorithm}`);
+    }
+    const authData = backupInfo.auth_data;
+    if (!(privKey instanceof Uint8Array)) {
+      throw new Error(`getBackupDecryptor expects Uint8Array`);
+    }
+    const backupDecryptionKey = RustSdkCryptoJs.BackupDecryptionKey.fromBase64((0, _base.encodeBase64)(privKey));
+    if (authData.public_key != backupDecryptionKey.megolmV1PublicKey.publicKeyBase64) {
+      throw new Error(`getBackupDecryptor key mismatch error`);
+    }
+    return new _backup.RustBackupDecryptor(backupDecryptionKey);
+  }
+
   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   //
   // SyncCryptoCallbacks implementation
@@ -1031,6 +1097,19 @@ class RustCrypto extends _typedEventEmitter.TypedEventEmitter {
     }
   }
 
+  /**
+   * Callback for `OlmMachine.registerUserIdentityUpdatedCallback`
+   *
+   * Called by the rust-sdk whenever there is an update to any user's cross-signing status. We re-check their trust
+   * status and emit a `UserTrustStatusChanged` event.
+   *
+   * @param userId - the user with the updated identity
+   */
+  async onUserIdentityUpdated(userId) {
+    const newVerification = await this.getUserVerificationStatus(userId.toString());
+    this.emit(_crypto2.CryptoEvent.UserTrustStatusChanged, userId.toString(), newVerification);
+  }
+
   /**
    * Handle a live event received via /sync.
    * See {@link ClientEventHandlerMap#event}
@@ -1077,6 +1156,7 @@ class RustCrypto extends _typedEventEmitter.TypedEventEmitter {
     if (!roomId) {
       throw new Error("missing roomId in the event");
     }
+    _logger.logger.debug(`Incoming verification event ${event.getId()} type ${event.getType()} from ${event.getSender()}`);
     await this.olmMachine.receiveVerificationEvent(JSON.stringify({
       event_id: event.getId(),
       type: event.getType(),
@@ -1085,6 +1165,9 @@ class RustCrypto extends _typedEventEmitter.TypedEventEmitter {
       content: event.getContent(),
       origin_server_ts: event.getTs()
     }), new RustSdkCryptoJs.RoomId(roomId));
+
+    // that may have caused us to queue up outgoing requests, so make sure we send them.
+    this.outgoingRequestLoop();
   }
 
   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1093,24 +1176,51 @@ class RustCrypto extends _typedEventEmitter.TypedEventEmitter {
   //
   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-  async outgoingRequestLoop() {
+  /** start the outgoing request loop if it is not already running */
+  outgoingRequestLoop() {
     if (this.outgoingRequestLoopRunning) {
+      // The loop is already running, but we have reason to believe that there may be new items in the queue.
+      //
+      // There is potential for a race whereby the item is added *after* `OlmMachine.outgoingRequests` checks
+      // the queue, but *before* it returns. In such a case, the item could sit there unnoticed for some time.
+      //
+      // In order to circumvent the race, we set a flag which tells the loop to go round once again even if the
+      // queue appears to be empty.
+      this.outgoingRequestLoopOneMoreLoop = true;
       return;
     }
+    // fire off the loop in the background
+    this.outgoingRequestLoopInner().catch(e => {
+      _logger.logger.error("Error processing outgoing-message requests from rust crypto-sdk", e);
+    });
+  }
+  async outgoingRequestLoopInner() {
+    /* istanbul ignore if */
+    if (this.outgoingRequestLoopRunning) {
+      throw new Error("Cannot run two outgoing request loops");
+    }
     this.outgoingRequestLoopRunning = true;
     try {
       while (!this.stopped) {
+        // we clear the "one more loop" flag just before calling `OlmMachine.outgoingRequests()`, so we can tell
+        // if `this.outgoingRequestLoop()` was called while `OlmMachine.outgoingRequests()` was running.
+        this.outgoingRequestLoopOneMoreLoop = false;
+        _logger.logger.debug("Calling OlmMachine.outgoingRequests()");
         const outgoingRequests = await this.olmMachine.outgoingRequests();
-        if (outgoingRequests.length == 0 || this.stopped) {
-          // no more messages to send (or we have been told to stop): exit the loop
+        if (this.stopped) {
+          // we've been told to stop while `outgoingRequests` was running: exit the loop without processing
+          // any of the returned requests (anything important will happen next time the client starts.)
+          return;
+        }
+        if (outgoingRequests.length === 0 && !this.outgoingRequestLoopOneMoreLoop) {
+          // `OlmMachine.outgoingRequests` returned no messages, and there was no call to
+          // `this.outgoingRequestLoop()` while it was running. We can stop the loop for a while.
           return;
         }
         for (const msg of outgoingRequests) {
           await this.outgoingRequestProcessor.makeOutgoingRequest(msg);
         }
       }
-    } catch (e) {
-      _logger.logger.error("Error processing outgoing-message requests from rust crypto-sdk", e);
     } finally {
       this.outgoingRequestLoopRunning = false;
     }
@@ -1118,14 +1228,15 @@ class RustCrypto extends _typedEventEmitter.TypedEventEmitter {
 }
 exports.RustCrypto = RustCrypto;
 class EventDecryptor {
-  constructor(olmMachine) {
-    this.olmMachine = olmMachine;
+  constructor(olmMachine, crypto) {
     /**
      * Events which we couldn't decrypt due to unknown sessions / indexes.
      *
      * Map from senderKey to sessionId to Set of MatrixEvents
      */
     (0, _defineProperty2.default)(this, "eventsPendingKey", new _utils.MapWithDefault(() => new _utils.MapWithDefault(() => new Set())));
+    this.olmMachine = olmMachine;
+    this.crypto = crypto;
   }
   async attemptEventDecryption(event) {
     _logger.logger.info("Attempting decryption of event", event);
@@ -1134,24 +1245,63 @@ class EventDecryptor {
     // decryption fails), we will schedule a retry.
     // (fixes https://github.com/vector-im/element-web/issues/5001)
     this.addEventToPendingList(event);
-    const res = await this.olmMachine.decryptRoomEvent(JSON.stringify({
-      event_id: event.getId(),
-      type: event.getWireType(),
-      sender: event.getSender(),
-      state_key: event.getStateKey(),
-      content: event.getWireContent(),
-      origin_server_ts: event.getTs()
-    }), new RustSdkCryptoJs.RoomId(event.getRoomId()));
-
-    // Success. We can remove the event from the pending list, if
-    // that hasn't already happened.
-    this.removeEventFromPendingList(event);
-    return {
-      clearEvent: JSON.parse(res.event),
-      claimedEd25519Key: res.senderClaimedEd25519Key,
-      senderCurve25519Key: res.senderCurve25519Key,
-      forwardingCurve25519KeyChain: res.forwardingCurve25519KeyChain
-    };
+    try {
+      const res = await this.olmMachine.decryptRoomEvent(stringifyEvent(event), new RustSdkCryptoJs.RoomId(event.getRoomId()));
+
+      // Success. We can remove the event from the pending list, if
+      // that hasn't already happened.
+      this.removeEventFromPendingList(event);
+      return {
+        clearEvent: JSON.parse(res.event),
+        claimedEd25519Key: res.senderClaimedEd25519Key,
+        senderCurve25519Key: res.senderCurve25519Key,
+        forwardingCurve25519KeyChain: res.forwardingCurve25519KeyChain
+      };
+    } catch (err) {
+      // We need to map back to regular decryption errors (used for analytics for example)
+      // The DecryptionErrors are used by react-sdk so is implicitly part of API, but poorly typed
+      if (err instanceof RustSdkCryptoJs.MegolmDecryptionError) {
+        const content = event.getWireContent();
+        let jsError;
+        switch (err.code) {
+          case RustSdkCryptoJs.DecryptionErrorCode.MissingRoomKey:
+            {
+              jsError = new _algorithms.DecryptionError("MEGOLM_UNKNOWN_INBOUND_SESSION_ID", "The sender's device has not sent us the keys for this message.", {
+                session: content.sender_key + "|" + content.session_id
+              });
+              this.crypto.queryKeyBackupRateLimited(event.getRoomId(), event.getWireContent().session_id);
+              break;
+            }
+          case RustSdkCryptoJs.DecryptionErrorCode.UnknownMessageIndex:
+            {
+              jsError = new _algorithms.DecryptionError("OLM_UNKNOWN_MESSAGE_INDEX", "The sender's device has not sent us the keys for this message at this index.", {
+                session: content.sender_key + "|" + content.session_id
+              });
+              this.crypto.queryKeyBackupRateLimited(event.getRoomId(), event.getWireContent().session_id);
+              break;
+            }
+          // We don't map MismatchedIdentityKeys for now, as there is no equivalent in legacy.
+          // Just put it on the `UNABLE_TO_DECRYPT` bucket.
+          default:
+            {
+              jsError = new _algorithms.DecryptionError("UNABLE_TO_DECRYPT", err.description, {
+                session: content.sender_key + "|" + content.session_id
+              });
+              break;
+            }
+        }
+        throw jsError;
+      }
+      throw new _algorithms.DecryptionError("UNABLE_TO_DECRYPT", "Unknown error");
+    }
+  }
+  async getEncryptionInfoForEvent(event) {
+    if (!event.getClearContent()) {
+      // not successfully decrypted
+      return null;
+    }
+    const encryptionInfo = await this.olmMachine.getRoomEventEncryptionInfo(stringifyEvent(event), new RustSdkCryptoJs.RoomId(event.getRoomId()));
+    return rustEncryptionInfoToJsEncryptionInfo(encryptionInfo);
   }
 
   /**
@@ -1204,4 +1354,53 @@ class EventDecryptor {
     }
   }
 }
+function stringifyEvent(event) {
+  return JSON.stringify({
+    event_id: event.getId(),
+    type: event.getWireType(),
+    sender: event.getSender(),
+    state_key: event.getStateKey(),
+    content: event.getWireContent(),
+    origin_server_ts: event.getTs()
+  });
+}
+function rustEncryptionInfoToJsEncryptionInfo(encryptionInfo) {
+  if (encryptionInfo === undefined) {
+    // not decrypted here
+    return null;
+  }
+
+  // TODO: use strict shield semantics.
+  const shieldState = encryptionInfo.shieldState(false);
+  let shieldColour;
+  switch (shieldState.color) {
+    case RustSdkCryptoJs.ShieldColor.Grey:
+      shieldColour = _cryptoApi.EventShieldColour.GREY;
+      break;
+    case RustSdkCryptoJs.ShieldColor.None:
+      shieldColour = _cryptoApi.EventShieldColour.NONE;
+      break;
+    default:
+      shieldColour = _cryptoApi.EventShieldColour.RED;
+  }
+  let shieldReason;
+  if (shieldState.message === null) {
+    shieldReason = null;
+  } else if (shieldState.message === "Encrypted by an unverified user.") {
+    shieldReason = _cryptoApi.EventShieldReason.UNVERIFIED_IDENTITY;
+  } else if (shieldState.message === "Encrypted by a device not verified by its owner.") {
+    shieldReason = _cryptoApi.EventShieldReason.UNSIGNED_DEVICE;
+  } else if (shieldState.message === "The authenticity of this encrypted message can't be guaranteed on this device.") {
+    shieldReason = _cryptoApi.EventShieldReason.AUTHENTICITY_NOT_GUARANTEED;
+  } else if (shieldState.message === "Encrypted by an unknown or deleted device.") {
+    shieldReason = _cryptoApi.EventShieldReason.UNKNOWN_DEVICE;
+  } else {
+    _logger.logger.warn(`Unknown shield state message '${shieldState.message}'`);
+    shieldReason = _cryptoApi.EventShieldReason.UNKNOWN;
+  }
+  return {
+    shieldColour,
+    shieldReason
+  };
+}
 //# sourceMappingURL=rust-crypto.js.map