matrix-js-sdk 34.2.0 → 34.3.0-rc.0

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

@@ -1374,7 +1374,7 @@ export class RustCrypto extends TypedEventEmitter {
     var _this50 = this;
     if (this.stopped) return;
     this.logger.debug("Got update for session ".concat(key.senderKey.toBase64(), "|").concat(key.sessionId, " in ").concat(key.roomId.toString()));
-    var pendingList = this.eventDecryptor.getEventsPendingRoomKey(key);
+    var pendingList = this.eventDecryptor.getEventsPendingRoomKey(key.roomId.toString(), key.sessionId);
     if (pendingList.length === 0) return;
     this.logger.debug("Retrying decryption on events:", pendingList.map(e => "".concat(e.getId())));
 
@@ -1396,6 +1396,35 @@ export class RustCrypto extends TypedEventEmitter {
     }
   }
 
+  /**
+   * Callback for `OlmMachine.registerRoomKeyWithheldCallback`.
+   *
+   * Called by the rust sdk whenever we are told that a key has been withheld. We see if we had any events that
+   * failed to decrypt for the given session, and update their status if so.
+   *
+   * @param withheld - Details of the withheld sessions.
+   */
+  onRoomKeysWithheld(withheld) {
+    var _this51 = this;
+    return _asyncToGenerator(function* () {
+      for (var session of withheld) {
+        _this51.logger.debug("Got withheld message for session ".concat(session.sessionId, " in ").concat(session.roomId.toString()));
+        var pendingList = _this51.eventDecryptor.getEventsPendingRoomKey(session.roomId.toString(), session.sessionId);
+        if (pendingList.length === 0) return;
+
+        // The easiest way to update the status of the event is to have another go at decrypting it.
+        _this51.logger.debug("Retrying decryption on events:", pendingList.map(e => "".concat(e.getId())));
+        for (var ev of pendingList) {
+          ev.attemptDecryption(_this51, {
+            isRetry: true
+          }).catch(_e => {
+            // It's somewhat expected that we still can't decrypt here.
+          });
+        }
+      }
+    })();
+  }
+
   /**
    * Callback for `OlmMachine.registerUserIdentityUpdatedCallback`
    *
@@ -1405,16 +1434,16 @@ export class RustCrypto extends TypedEventEmitter {
    * @param userId - the user with the updated identity
    */
   onUserIdentityUpdated(userId) {
-    var _this51 = this;
+    var _this52 = this;
     return _asyncToGenerator(function* () {
-      var newVerification = yield _this51.getUserVerificationStatus(userId.toString());
-      _this51.emit(CryptoEvent.UserTrustStatusChanged, userId.toString(), newVerification);
+      var newVerification = yield _this52.getUserVerificationStatus(userId.toString());
+      _this52.emit(CryptoEvent.UserTrustStatusChanged, userId.toString(), newVerification);
 
       // If our own user identity has changed, we may now trust the key backup where we did not before.
       // So, re-check the key backup status and enable it if available.
-      if (userId.toString() === _this51.userId) {
-        _this51.emit(CryptoEvent.KeysChanged, {});
-        yield _this51.checkKeyBackupAndEnable();
+      if (userId.toString() === _this52.userId) {
+        _this52.emit(CryptoEvent.KeysChanged, {});
+        yield _this52.checkKeyBackupAndEnable();
       }
     })();
   }
@@ -1430,10 +1459,10 @@ export class RustCrypto extends TypedEventEmitter {
    * @param userIds - an array of user IDs of users whose devices have updated.
    */
   onDevicesUpdated(userIds) {
-    var _this52 = this;
+    var _this53 = this;
     return _asyncToGenerator(function* () {
-      _this52.emit(CryptoEvent.WillUpdateDevices, userIds, false);
-      _this52.emit(CryptoEvent.DevicesUpdated, userIds, false);
+      _this53.emit(CryptoEvent.WillUpdateDevices, userIds, false);
+      _this53.emit(CryptoEvent.DevicesUpdated, userIds, false);
     })();
   }
 
@@ -1450,11 +1479,11 @@ export class RustCrypto extends TypedEventEmitter {
    * @param value - the secret value
    */
   handleSecretReceived(name, value) {
-    var _this53 = this;
+    var _this54 = this;
     return _asyncToGenerator(function* () {
-      _this53.logger.debug("onReceiveSecret: Received secret ".concat(name));
+      _this54.logger.debug("onReceiveSecret: Received secret ".concat(name));
       if (name === "m.megolm_backup.v1") {
-        return yield _this53.backupManager.handleBackupSecretReceived(value);
+        return yield _this54.backupManager.handleBackupSecretReceived(value);
         // XXX at this point we should probably try to download the backup and import the keys,
         // or at least retry for the current decryption failures?
         // Maybe add some signaling when a new secret is received, and let clients handle it?
@@ -1472,11 +1501,11 @@ export class RustCrypto extends TypedEventEmitter {
    * @param name - The name of the secret received.
    */
   checkSecrets(name) {
-    var _this54 = this;
+    var _this55 = this;
     return _asyncToGenerator(function* () {
-      var pendingValues = yield _this54.olmMachine.getSecretsFromInbox(name);
+      var pendingValues = yield _this55.olmMachine.getSecretsFromInbox(name);
       for (var value of pendingValues) {
-        if (yield _this54.handleSecretReceived(name, value)) {
+        if (yield _this55.handleSecretReceived(name, value)) {
           // If we have a valid secret for that name there is no point of processing the other secrets values.
           // It's probably the same secret shared by another device.
           break;
@@ -1484,7 +1513,7 @@ export class RustCrypto extends TypedEventEmitter {
       }
 
       // Important to call this after handling the secrets as good hygiene.
-      yield _this54.olmMachine.deleteSecretsFromInbox(name);
+      yield _this55.olmMachine.deleteSecretsFromInbox(name);
     })();
   }
 
@@ -1495,7 +1524,7 @@ export class RustCrypto extends TypedEventEmitter {
    * @param event - live event
    */
   onLiveEventFromSync(event) {
-    var _this55 = this;
+    var _this56 = this;
     return _asyncToGenerator(function* () {
       // Ignore state event or remote echo
       // transaction_id is provided in case of remote echo {@link https://spec.matrix.org/v1.7/client-server-api/#local-echo}
@@ -1504,7 +1533,7 @@ export class RustCrypto extends TypedEventEmitter {
         var _ref4 = _asyncToGenerator(function* (evt) {
           // Process only verification event
           if (isVerificationEvent(event)) {
-            yield _this55.onKeyVerificationEvent(evt);
+            yield _this56.onKeyVerificationEvent(evt);
           }
         });
         return function processEvent(_x) {
@@ -1538,14 +1567,14 @@ export class RustCrypto extends TypedEventEmitter {
    * @param event - a key validation request event.
    */
   onKeyVerificationEvent(event) {
-    var _this56 = this;
+    var _this57 = this;
     return _asyncToGenerator(function* () {
       var roomId = event.getRoomId();
       if (!roomId) {
         throw new Error("missing roomId in the event");
       }
-      _this56.logger.debug("Incoming verification event ".concat(event.getId(), " type ").concat(event.getType(), " from ").concat(event.getSender()));
-      yield _this56.olmMachine.receiveVerificationEvent(JSON.stringify({
+      _this57.logger.debug("Incoming verification event ".concat(event.getId(), " type ").concat(event.getType(), " from ").concat(event.getSender()));
+      yield _this57.olmMachine.receiveVerificationEvent(JSON.stringify({
         event_id: event.getId(),
         type: event.getType(),
         sender: event.getSender(),
@@ -1554,12 +1583,12 @@ export class RustCrypto extends TypedEventEmitter {
         origin_server_ts: event.getTs()
       }), new RustSdkCryptoJs.RoomId(roomId));
       if (event.getType() === EventType.RoomMessage && event.getContent().msgtype === MsgType.KeyVerificationRequest) {
-        _this56.onIncomingKeyVerificationRequest(event.getSender(), event.getId());
+        _this57.onIncomingKeyVerificationRequest(event.getSender(), event.getId());
       }
 
       // that may have caused us to queue up outgoing requests, so make sure we send them.
-      _this56.outgoingRequestsManager.doProcessOutgoingRequests().catch(e => {
-        _this56.logger.warn("onKeyVerificationRequest: Error processing outgoing requests", e);
+      _this57.outgoingRequestsManager.doProcessOutgoingRequests().catch(e => {
+        _this57.logger.warn("onKeyVerificationRequest: Error processing outgoing requests", e);
       });
     })();
   }
@@ -1571,9 +1600,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Used during migration from legacy js-crypto to update local trust if needed.
    */
   getOwnIdentity() {
-    var _this57 = this;
+    var _this58 = this;
     return _asyncToGenerator(function* () {
-      return yield _this57.olmMachine.getIdentity(new RustSdkCryptoJs.UserId(_this57.userId));
+      return yield _this58.olmMachine.getIdentity(new RustSdkCryptoJs.UserId(_this58.userId));
     })();
   }
 }
@@ -1585,24 +1614,24 @@ class EventDecryptor {
     /**
      * Events which we couldn't decrypt due to unknown sessions / indexes.
      *
-     * Map from senderKey to sessionId to Set of MatrixEvents
+     * Map from roomId to sessionId to Set of MatrixEvents
      */
     _defineProperty(this, "eventsPendingKey", new MapWithDefault(() => new MapWithDefault(() => new Set())));
   }
   attemptEventDecryption(event) {
-    var _this58 = this;
+    var _this59 = this;
     return _asyncToGenerator(function* () {
       // add the event to the pending list *before* attempting to decrypt.
       // then, if the key turns up while decryption is in progress (and
       // decryption fails), we will schedule a retry.
       // (fixes https://github.com/vector-im/element-web/issues/5001)
-      _this58.addEventToPendingList(event);
+      _this59.addEventToPendingList(event);
       try {
-        var res = yield _this58.olmMachine.decryptRoomEvent(stringifyEvent(event), new RustSdkCryptoJs.RoomId(event.getRoomId()));
+        var res = yield _this59.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.
-        _this58.removeEventFromPendingList(event);
+        _this59.removeEventFromPendingList(event);
         return {
           clearEvent: JSON.parse(res.event),
           claimedEd25519Key: res.senderClaimedEd25519Key,
@@ -1611,7 +1640,7 @@ class EventDecryptor {
         };
       } catch (err) {
         if (err instanceof RustSdkCryptoJs.MegolmDecryptionError) {
-          _this58.onMegolmDecryptionError(event, err, yield _this58.perSessionBackupDownloader.getServerBackupInfo());
+          _this59.onMegolmDecryptionError(event, err, yield _this59.perSessionBackupDownloader.getServerBackupInfo());
         } else {
           throw new DecryptionError(DecryptionFailureCode.UNKNOWN_ERROR, "Unknown error");
         }
@@ -1678,7 +1707,7 @@ class EventDecryptor {
     }
   }
   getEncryptionInfoForEvent(event) {
-    var _this59 = this;
+    var _this60 = this;
     return _asyncToGenerator(function* () {
       if (!event.getClearContent() || event.isDecryptionFailure()) {
         // not successfully decrypted
@@ -1692,8 +1721,8 @@ class EventDecryptor {
           shieldReason: null
         };
       }
-      var encryptionInfo = yield _this59.olmMachine.getRoomEventEncryptionInfo(stringifyEvent(event), new RustSdkCryptoJs.RoomId(event.getRoomId()));
-      return rustEncryptionInfoToJsEncryptionInfo(_this59.logger, encryptionInfo);
+      var encryptionInfo = yield _this60.olmMachine.getRoomEventEncryptionInfo(stringifyEvent(event), new RustSdkCryptoJs.RoomId(event.getRoomId()));
+      return rustEncryptionInfoToJsEncryptionInfo(_this60.logger, encryptionInfo);
     })();
   }
 
@@ -1701,27 +1730,24 @@ class EventDecryptor {
    * Look for events which are waiting for a given megolm session
    *
    * Returns a list of events which were encrypted by `session` and could not be decrypted
-   *
-   * @param session -
    */
-  getEventsPendingRoomKey(session) {
-    var senderPendingEvents = this.eventsPendingKey.get(session.senderKey.toBase64());
-    if (!senderPendingEvents) return [];
-    var sessionPendingEvents = senderPendingEvents.get(session.sessionId);
+  getEventsPendingRoomKey(roomId, sessionId) {
+    var roomPendingEvents = this.eventsPendingKey.get(roomId);
+    if (!roomPendingEvents) return [];
+    var sessionPendingEvents = roomPendingEvents.get(sessionId);
     if (!sessionPendingEvents) return [];
-    var roomId = session.roomId.toString();
-    return [...sessionPendingEvents].filter(ev => ev.getRoomId() === roomId);
+    return [...sessionPendingEvents];
   }
 
   /**
    * Add an event to the list of those awaiting their session keys.
    */
   addEventToPendingList(event) {
-    var content = event.getWireContent();
-    var senderKey = content.sender_key;
-    var sessionId = content.session_id;
-    var senderPendingEvents = this.eventsPendingKey.getOrCreate(senderKey);
-    var sessionPendingEvents = senderPendingEvents.getOrCreate(sessionId);
+    var roomId = event.getRoomId();
+    // We shouldn't have events without a room id here.
+    if (!roomId) return;
+    var roomPendingEvents = this.eventsPendingKey.getOrCreate(roomId);
+    var sessionPendingEvents = roomPendingEvents.getOrCreate(event.getWireContent().session_id);
     sessionPendingEvents.add(event);
   }
 
@@ -1729,20 +1755,19 @@ class EventDecryptor {
    * Remove an event from the list of those awaiting their session keys.
    */
   removeEventFromPendingList(event) {
-    var content = event.getWireContent();
-    var senderKey = content.sender_key;
-    var sessionId = content.session_id;
-    var senderPendingEvents = this.eventsPendingKey.get(senderKey);
-    if (!senderPendingEvents) return;
-    var sessionPendingEvents = senderPendingEvents.get(sessionId);
+    var roomId = event.getRoomId();
+    if (!roomId) return;
+    var roomPendingEvents = this.eventsPendingKey.getOrCreate(roomId);
+    if (!roomPendingEvents) return;
+    var sessionPendingEvents = roomPendingEvents.get(event.getWireContent().session_id);
     if (!sessionPendingEvents) return;
     sessionPendingEvents.delete(event);
 
     // also clean up the higher-level maps if they are now empty
     if (sessionPendingEvents.size === 0) {
-      senderPendingEvents.delete(sessionId);
-      if (senderPendingEvents.size === 0) {
-        this.eventsPendingKey.delete(senderKey);
+      roomPendingEvents.delete(event.getWireContent().session_id);
+      if (roomPendingEvents.size === 0) {
+        this.eventsPendingKey.delete(roomId);
       }
     }
   }