Merge pull request #519 from matrix-org/rav/async_crypto/algorithms

Make methods in crypto/algorithms async

spec/unit/crypto/algorithms/megolm.spec.js

@@ -119,29 +119,32 @@ describe("MegolmDecryption", function() {
                 },
             };
 
-            expect(megolmDecryption.hasKeysForKeyRequest(keyRequest))
-                .toBe(true);
-
-            // set up some pre-conditions for the share call
-            const deviceInfo = {};
-            mockCrypto.getStoredDevice.andReturn(deviceInfo);
-
-            const awaitEnsureSessions = new Promise((res, rej) => {
-                mockOlmLib.ensureOlmSessionsForDevices.andCall(() => {
-                    res();
-                    return Promise.resolve({'@alice:foo': {'alidevice': {
-                        sessionId: 'alisession',
-                    }}});
+            return megolmDecryption.hasKeysForKeyRequest(
+                keyRequest,
+            ).then((hasKeys) => {
+                expect(hasKeys).toBe(true);
+
+                // set up some pre-conditions for the share call
+                const deviceInfo = {};
+                mockCrypto.getStoredDevice.andReturn(deviceInfo);
+
+                const awaitEnsureSessions = new Promise((res, rej) => {
+                    mockOlmLib.ensureOlmSessionsForDevices.andCall(() => {
+                        res();
+                        return Promise.resolve({'@alice:foo': {'alidevice': {
+                            sessionId: 'alisession',
+                        }}});
+                    });
                 });
-            });
 
-            mockBaseApis.sendToDevice = expect.createSpy();
+                mockBaseApis.sendToDevice = expect.createSpy();
 
-            // do the share
-            megolmDecryption.shareKeysWithDevice(keyRequest);
+                // do the share
+                megolmDecryption.shareKeysWithDevice(keyRequest);
 
-            // it's asynchronous, so we have to wait a bit
-            return awaitEnsureSessions.then(() => {
+                // it's asynchronous, so we have to wait a bit
+                return awaitEnsureSessions;
+            }).then(() => {
                 // check that it called encryptMessageForDevice with
                 // appropriate args.
                 expect(mockOlmLib.encryptMessageForDevice.calls.length)

src/crypto/algorithms/base.js

@@ -20,6 +20,8 @@ limitations under the License.
  * @module
  */
 
+import Promise from 'bluebird';
+
 /**
  * map of registered encryption algorithm classes. A map from string to {@link
  * module:crypto/algorithms/base.EncryptionAlgorithm|EncryptionAlgorithm} class
@@ -143,11 +145,11 @@ class DecryptionAlgorithm {
      * Determine if we have the keys necessary to respond to a room key request
      *
      * @param {module:crypto~IncomingRoomKeyRequest} keyRequest
-     * @return {boolean} true if we have the keys and could (theoretically) share
+     * @return {Promise<boolean>} true if we have the keys and could (theoretically) share
      *  them; else false.
      */
     hasKeysForKeyRequest(keyRequest) {
-        return false;
+        return Promise.resolve(false);
     }
 
     /**

src/crypto/algorithms/megolm.js

@@ -166,7 +166,7 @@ MegolmEncryption.prototype._ensureOutboundSession = function(devicesInRoom) {
     // Updates `session` to hold the final OutboundSessionInfo.
     //
     // returns a promise which resolves once the keyshare is successful.
-    function prepareSession(oldSession) {
+    async function prepareSession(oldSession) {
         session = oldSession;
 
         // need to make a brand new session?
@@ -184,7 +184,7 @@ MegolmEncryption.prototype._ensureOutboundSession = function(devicesInRoom) {
 
         if (!session) {
             console.log(`Starting new megolm session for room ${self._roomId}`);
-            session = self._prepareNewSession();
+            session = await self._prepareNewSession();
         }
 
         // now check if we need to share with any devices
@@ -245,7 +245,7 @@ MegolmEncryption.prototype._ensureOutboundSession = function(devicesInRoom) {
  *
  * @return {module:crypto/algorithms/megolm.OutboundSessionInfo} session
  */
-MegolmEncryption.prototype._prepareNewSession = function() {
+MegolmEncryption.prototype._prepareNewSession = async function() {
     const sessionId = this._olmDevice.createOutboundGroupSession();
     const key = this._olmDevice.getOutboundGroupSessionKey(sessionId);
 
@@ -535,16 +535,14 @@ utils.inherits(MegolmDecryption, base.DecryptionAlgorithm);
  * `algorithms.DecryptionError` if there is a problem decrypting the event.
  */
 MegolmDecryption.prototype.decryptEvent = function(event) {
-    return Promise.try(() => {
-        this._decryptEvent(event, true);
-    });
+    return this._decryptEvent(event, true);
 };
 
 
 // helper for the real decryptEvent and for _retryDecryption. If
 // requestKeysOnFail is true, we'll send an m.room_key_request when we fail
 // to decrypt the event due to missing megolm keys.
-MegolmDecryption.prototype._decryptEvent = function(event, requestKeysOnFail) {
+MegolmDecryption.prototype._decryptEvent = async function(event, requestKeysOnFail) {
     const content = event.getWireContent();
 
     if (!content.sender_key || !content.session_id ||
@@ -721,7 +719,7 @@ MegolmDecryption.prototype.onRoomKeyEvent = function(event) {
 /**
  * @inheritdoc
  */
-MegolmDecryption.prototype.hasKeysForKeyRequest = function(keyRequest) {
+MegolmDecryption.prototype.hasKeysForKeyRequest = async function(keyRequest) {
     const body = keyRequest.requestBody;
 
     return this._olmDevice.hasInboundSessionKeys(

src/crypto/algorithms/olm.js

@@ -172,7 +172,7 @@ OlmDecryption.prototype.decryptEvent = async function(event) {
     let payloadString;
 
     try {
-        payloadString = this._decryptMessage(deviceKey, message);
+        payloadString = await this._decryptMessage(deviceKey, message);
     } catch (e) {
         throw new base.DecryptionError(
             "Bad Encrypted Message", {
@@ -235,7 +235,9 @@ OlmDecryption.prototype.decryptEvent = async function(event) {
  *
  * @return {string} payload, if decrypted successfully.
  */
-OlmDecryption.prototype._decryptMessage = function(theirDeviceIdentityKey, message) {
+OlmDecryption.prototype._decryptMessage = async function(
+    theirDeviceIdentityKey, message,
+) {
     const sessionIds = this._olmDevice.getSessionIdsForDevice(theirDeviceIdentityKey);
 
     // try each session in turn.

src/crypto/index.js

@@ -1131,7 +1131,7 @@ Crypto.prototype._processReceivedRoomKeyRequest = async function(req) {
         return;
     }
 
-    if (!decryptor.hasKeysForKeyRequest(req)) {
+    if (!await decryptor.hasKeysForKeyRequest(req)) {
         console.log(
             `room key request for unknown session ${roomId} / ` +
                 body.session_id,