@wireapp/core 46.24.1 → 46.24.3

package/lib/messagingProtocols/mls/MLSService/MLSService.js

@@ -19,12 +19,16 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MLSService = exports.MLSServiceEvents = exports.optionalToUint8Array = void 0;
+const http_1 = require("@wireapp/api-client/lib/http");
+const TimeUtil_1 = require("@wireapp/commons/lib/util/TimeUtil");
 const bazinga64_1 = require("bazinga64");
 const commons_1 = require("@wireapp/commons");
 const core_crypto_1 = require("@wireapp/core-crypto");
+const priority_queue_1 = require("@wireapp/priority-queue");
 const ClientMLSError_1 = require("./ClientMLSError");
 const CoreCryptoMLSError_1 = require("./CoreCryptoMLSError");
 const conversation_1 = require("../../../conversation");
+const messageSender_1 = require("../../../conversation/message/messageSender");
 const fullyQualifiedClientIdUtils_1 = require("../../../util/fullyQualifiedClientIdUtils");
 const numberToHex_1 = require("../../../util/numberToHex");
 const TaskScheduler_1 = require("../../../util/TaskScheduler");
@@ -48,7 +52,6 @@ var MLSServiceEvents;
     MLSServiceEvents["NEW_EPOCH"] = "newEpoch";
     MLSServiceEvents["MLS_CLIENT_MISMATCH"] = "mlsClientMismatch";
     MLSServiceEvents["NEW_CRL_DISTRIBUTION_POINTS"] = "newCrlDistributionPoints";
-    MLSServiceEvents["MLS_EVENT_DISTRIBUTED"] = "mlsEventDistributed";
 })(MLSServiceEvents || (exports.MLSServiceEvents = MLSServiceEvents = {}));
 class MLSService extends commons_1.TypedEventEmitter {
     apiClient;
@@ -59,27 +62,18 @@ class MLSService extends commons_1.TypedEventEmitter {
     _config;
     textEncoder = new TextEncoder();
     textDecoder = new TextDecoder();
+    conflictBackoffQueue = new priority_queue_1.PriorityQueue({
+        maxRetries: 10,
+        retryDelay: 500,
+        maxRetryDelay: TimeUtil_1.TimeInMillis.SECOND * 32,
+        shouldRetry: error => error instanceof http_1.BackendError && error.code === http_1.StatusCode.CONFLICT,
+    });
     constructor(apiClient, coreCryptoClient, coreDatabase, recurringTaskScheduler) {
         super();
         this.apiClient = apiClient;
         this.coreCryptoClient = coreCryptoClient;
         this.coreDatabase = coreDatabase;
         this.recurringTaskScheduler = recurringTaskScheduler;
-        const mlsTransport = {
-            sendCommitBundle: this._uploadCommitBundle,
-            // Info: This is not used for now, but we need to implement it to be able to use the mls transport
-            sendMessage: async () => {
-                return 'success';
-            },
-        };
-        const epochObserver = {
-            epochChanged: async (groupId, epoch) => {
-                const groupIdStr = bazinga64_1.Encoder.toBase64(groupId).asString;
-                this.emit(MLSServiceEvents.NEW_EPOCH, { epoch, groupId: groupIdStr });
-            },
-        };
-        void this.coreCryptoClient.registerEpochObserver(epochObserver);
-        void this.coreCryptoClient.provideTransport(mlsTransport);
     }
     /**
      * return true if the MLS service if configured and ready to be used
@@ -109,7 +103,13 @@ class MLSService extends commons_1.TypedEventEmitter {
             ...defaultConfig,
             ...filteredMLSConfig,
         };
-        await this.coreCryptoClient.transaction(cx => cx.mlsInit((0, MLSId_1.generateMLSDeviceId)(userId, client.id), this.config.ciphersuites, this.config.nbKeyPackages));
+        await this.coreCryptoClient.mlsInit((0, MLSId_1.generateMLSDeviceId)(userId, client.id), this.config.ciphersuites, this.config.nbKeyPackages);
+        await this.coreCryptoClient.registerCallbacks({
+            // All authorization/membership rules are enforced on backend
+            clientIsExistingGroupUser: async () => true,
+            authorize: async () => true,
+            userAuthorize: async () => true,
+        });
         try {
             const ccClientSignature = await this.getCCClientSignatureString();
             const mlsDeviceStatus = (0, Helper_1.getMLSDeviceStatus)(client, this.config.defaultCiphersuite, ccClientSignature);
@@ -151,26 +151,47 @@ class MLSService extends commons_1.TypedEventEmitter {
             ? core_crypto_1.CredentialType.X509
             : core_crypto_1.CredentialType.Basic;
     }
-    _uploadCommitBundle = async ({ commit, groupInfo, welcome, }) => {
-        // We need to lock the incoming mls messages queue while we are uploading the commit bundle
-        // it's possible that we will be sent some mls messages before we receive the response from backend and accept a commit locally.
-        const bundlePayload = new Uint8Array([...commit, ...groupInfo.payload, ...(welcome || [])]);
+    uploadCommitBundle = async (groupId, commitBundle, { isExternalCommit = false, regenerateCommitBundle } = {}) => {
         try {
-            const response = await this.apiClient.api.conversation.postMlsCommitBundle(bundlePayload);
-            if (response.failed_to_send) {
-                this.logger.warn(`Failed to send commit bundle to backend`);
-                return 'retry';
-            }
-            const { events, time } = response;
-            this.emit(MLSServiceEvents.MLS_EVENT_DISTRIBUTED, { events, time });
-            return 'success';
+            return await this._uploadCommitBundle(groupId, async () => commitBundle, isExternalCommit);
         }
         catch (error) {
-            return {
-                abort: { reason: error instanceof Error ? error.message : 'unknown error' },
-            };
+            if (error instanceof http_1.BackendError && error.code === http_1.StatusCode.CONFLICT && regenerateCommitBundle) {
+                return this.conflictBackoffQueue.add(async () => this._uploadCommitBundle(groupId, regenerateCommitBundle, isExternalCommit));
+            }
+            throw error;
         }
     };
+    _uploadCommitBundle = async (groupId, generateCommitBundle, isExternalCommit) => {
+        const groupIdStr = bazinga64_1.Encoder.toBase64(groupId).asString;
+        // We need to lock the incoming mls messages queue while we are uploading the commit bundle
+        // it's possible that we will be sent some mls messages before we receive the response from backend and accept a commit locally.
+        return (0, messageAdd_1.withLockedMLSMessagesQueue)(groupIdStr, async () => {
+            const { commit, groupInfo, welcome } = await generateCommitBundle();
+            const bundlePayload = new Uint8Array([...commit, ...groupInfo.payload, ...(welcome || [])]);
+            try {
+                const response = await this.apiClient.api.conversation.postMlsCommitBundle(bundlePayload);
+                if (isExternalCommit) {
+                    await this.coreCryptoClient.mergePendingGroupFromExternalCommit(groupId);
+                }
+                else {
+                    await this.coreCryptoClient.commitAccepted(groupId);
+                }
+                const newEpoch = await this.getEpoch(groupId);
+                this.emit(MLSServiceEvents.NEW_EPOCH, { epoch: newEpoch, groupId: groupIdStr });
+                return response;
+            }
+            catch (error) {
+                if (isExternalCommit) {
+                    await this.coreCryptoClient.clearPendingGroupFromExternalCommit(groupId);
+                }
+                else {
+                    await this.coreCryptoClient.clearPendingCommit(groupId);
+                }
+                throw error;
+            }
+        });
+    };
     /**
      * Will add users to an existing MLS group and send a commit bundle to backend.
      * Cannot be called with an empty array of keys.
@@ -183,8 +204,23 @@ class MLSService extends commons_1.TypedEventEmitter {
         if (keyPackages.length < 1) {
             throw new Error('Empty list of keys provided to addUsersToExistingConversation');
         }
-        const crlNewDistributionPoints = await this.coreCryptoClient.transaction(cx => cx.addClientsToConversation(groupIdBytes, keyPackages));
-        this.dispatchNewCrlDistributionPoints(crlNewDistributionPoints);
+        // TODO: handle federation error when sending a commit bundle to backend like we do in ProteusService
+        const response = await this.processCommitAction(groupIdBytes, async () => {
+            const commitBundle = await this.coreCryptoClient.addClientsToConversation(groupIdBytes, keyPackages);
+            this.dispatchNewCrlDistributionPoints(commitBundle);
+            return commitBundle;
+        });
+        const failedUsers = response.failed;
+        const failures = failedUsers
+            ? [
+                {
+                    users: failedUsers,
+                    backends: failedUsers.map(({ domain }) => domain),
+                    reason: conversation_1.AddUsersFailureReasons.UNREACHABLE_BACKENDS,
+                },
+            ]
+            : [];
+        return { ...response, failures };
     }
     /**
      * Will return a list of client ids which are already in the group at core crypto level
@@ -266,55 +302,90 @@ class MLSService extends commons_1.TypedEventEmitter {
         const groupIdBytes = typeof groupId === 'string' ? bazinga64_1.Decoder.fromBase64(groupId).asBytes : groupId;
         return this.coreCryptoClient.conversationEpoch(groupIdBytes);
     }
+    async newProposal(proposalType, args) {
+        return this.coreCryptoClient.newProposal(proposalType, args);
+    }
     async joinByExternalCommit(getGroupInfo) {
         const credentialType = await this.getCredentialType();
-        const groupInfo = await getGroupInfo();
-        const welcomeBundle = await this.coreCryptoClient.transaction(cx => cx.joinByExternalCommit(groupInfo, credentialType));
-        await this.dispatchNewCrlDistributionPoints(welcomeBundle.crlNewDistributionPoints);
-        if (welcomeBundle.id) {
+        const generateCommit = async () => {
+            const groupInfo = await getGroupInfo();
+            const joinRequest = await this.coreCryptoClient.joinByExternalCommit(groupInfo, credentialType);
+            this.dispatchNewCrlDistributionPoints(joinRequest);
+            const { conversationId, ...commitBundle } = joinRequest;
+            return { groupId: conversationId, commitBundle };
+        };
+        const { commitBundle, groupId } = await generateCommit();
+        const mlsResponse = await this.uploadCommitBundle(groupId, commitBundle, {
+            isExternalCommit: true,
+            regenerateCommitBundle: async () => (await generateCommit()).commitBundle,
+        });
+        if (mlsResponse) {
             //after we've successfully joined via external commit, we schedule periodic key material renewal
-            const groupIdStr = bazinga64_1.Encoder.toBase64(welcomeBundle.id).asString;
+            const groupIdStr = bazinga64_1.Encoder.toBase64(groupId).asString;
             await this.scheduleKeyMaterialRenewal(groupIdStr);
         }
+        return mlsResponse;
     }
     async exportSecretKey(groupId, keyLength) {
         const groupIdBytes = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
         const key = await this.coreCryptoClient.exportSecretKey(groupIdBytes, keyLength);
         return bazinga64_1.Encoder.toBase64(key).asString;
     }
-    dispatchNewCrlDistributionPoints(crlNewDistributionPoints) {
+    dispatchNewCrlDistributionPoints(payload) {
+        const { crlNewDistributionPoints } = payload;
         if (crlNewDistributionPoints && crlNewDistributionPoints.length > 0) {
             this.emit(MLSServiceEvents.NEW_CRL_DISTRIBUTION_POINTS, crlNewDistributionPoints);
         }
     }
     async processWelcomeMessage(welcomeMessage) {
-        const welcomeBundle = await this.coreCryptoClient.transaction(cx => cx.processWelcomeMessage(welcomeMessage));
-        this.dispatchNewCrlDistributionPoints(welcomeBundle.crlNewDistributionPoints);
+        const welcomeBundle = await this.coreCryptoClient.processWelcomeMessage(welcomeMessage);
+        this.dispatchNewCrlDistributionPoints(welcomeBundle);
         return welcomeBundle.id;
     }
     async decryptMessage(conversationId, payload) {
-        try {
-            const decryptedMessage = await this.coreCryptoClient.transaction(cx => cx.decryptMessage(conversationId, payload));
-            this.dispatchNewCrlDistributionPoints(decryptedMessage.crlNewDistributionPoints);
-            return decryptedMessage;
-        }
-        catch (error) {
-            // According to CoreCrypto JS doc on .decryptMessage method, we should ignore some errors (corecrypto handle them internally)
-            if ((0, CoreCryptoMLSError_1.shouldMLSDecryptionErrorBeIgnored)(error)) {
-                return {
-                    hasEpochChanged: false,
-                    isActive: false,
-                };
+        return await this.coreCryptoClient.transaction(async (cx) => {
+            try {
+                const decryptedMessage = await cx.decryptMessage(conversationId, payload);
+                this.dispatchNewCrlDistributionPoints(decryptedMessage);
+                return decryptedMessage;
             }
-            return undefined;
-        }
+            catch (error) {
+                // According to CoreCrypto JS doc on .decryptMessage method, we should ignore some errors (corecrypto handle them internally)
+                if ((0, CoreCryptoMLSError_1.shouldMLSDecryptionErrorBeIgnored)(error)) {
+                    return {
+                        hasEpochChanged: false,
+                        isActive: false,
+                        proposals: [],
+                    };
+                }
+                throw error;
+            }
+        });
     }
     async encryptMessage(conversationId, message) {
-        return this.coreCryptoClient.transaction(cx => cx.encryptMessage(conversationId, message));
+        return this.coreCryptoClient.encryptMessage(conversationId, message);
+    }
+    /**
+     * Will wrap a coreCrypto call that generates a CommitBundle and do all the necessary work so that commitbundle is handled the right way.
+     * It does:
+     *   - commit the pending proposal
+     *   - then generates the commitBundle with the given function
+     *   - uploads the commitBundle to backend
+     *   - warns coreCrypto that the commit was successfully processed
+     * @param groupId
+     * @param generateCommit The function that will generate a coreCrypto CommitBundle
+     */
+    async processCommitAction(groupId, generateCommit) {
+        const groupIdStr = bazinga64_1.Encoder.toBase64(groupId).asString;
+        return (0, messageSender_1.sendMessage)(async () => {
+            await this.commitPendingProposals(groupIdStr);
+            const commitBundle = await generateCommit();
+            return this.uploadCommitBundle(groupId, commitBundle, { regenerateCommitBundle: generateCommit });
+        });
     }
-    async updateKeyingMaterial(groupId) {
+    updateKeyingMaterial(groupId) {
         const groupIdBytes = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
-        await this.coreCryptoClient.transaction(cx => cx.updateKeyingMaterial(groupIdBytes));
+        return this.processCommitAction(groupIdBytes, () => this.coreCryptoClient.updateKeyingMaterial(groupIdBytes));
     }
     /**
      * Will create an empty conversation inside of coreCrypto.
@@ -342,7 +413,7 @@ class MLSService extends commons_1.TypedEventEmitter {
             ciphersuite: this.config.defaultCiphersuite,
         };
         const credentialType = await this.getCredentialType();
-        return this.coreCryptoClient.transaction(cx => cx.createConversation(groupIdBytes, credentialType, configuration));
+        return this.coreCryptoClient.createConversation(groupIdBytes, credentialType, configuration);
     }
     /**
      * Will create a conversation inside of coreCrypto, add users to it or update the keying material if empty key packages list is provided.
@@ -366,17 +437,19 @@ class MLSService extends commons_1.TypedEventEmitter {
         }));
         if (keyPackages.length <= 0) {
             // If there are no clients to add, just update the keying material
-            await this.updateKeyingMaterial(groupId);
+            const response = await this.updateKeyingMaterial(groupId);
             await this.scheduleKeyMaterialRenewal(groupId);
-            return keysClaimingFailures;
+            return { ...response, failures: keysClaimingFailures };
         }
+        const response = await this.addUsersToExistingConversation(groupId, keyPackages);
         // We schedule a periodic key material renewal
         await this.scheduleKeyMaterialRenewal(groupId);
         /**
          * @note If we can't fetch a user's key packages then we can not add them to mls conversation
          * so we're adding them to the list of failed users.
          */
-        return keysClaimingFailures;
+        response.failures = [...keysClaimingFailures, ...response.failures];
+        return response;
     }
     /**
      * Will create a 1:1 conversation inside of coreCrypto, try claiming key packages for user and (if succesfull) add them to the MLS group.
@@ -399,10 +472,14 @@ class MLSService extends commons_1.TypedEventEmitter {
             const { keyPackages: selfKeyPackages, failures: selfKeysClaimingFailures } = await this.getKeyPackagesPayload([
                 { ...selfUser.user, skipOwnClientId: selfUser.client },
             ]);
-            await this.addUsersToExistingConversation(groupId, [...otherUserKeyPackages, ...selfKeyPackages]);
+            const response = await this.addUsersToExistingConversation(groupId, [
+                ...otherUserKeyPackages,
+                ...selfKeyPackages,
+            ]);
             // We schedule a periodic key material renewal
             await this.scheduleKeyMaterialRenewal(groupId);
-            return [...otherUserKeysClaimingFailures, ...selfKeysClaimingFailures];
+            response.failures = [...otherUserKeysClaimingFailures, ...selfKeysClaimingFailures, ...response.failures];
+            return response;
         }
         catch (error) {
             await this.wipeConversation(groupId);
@@ -448,7 +525,7 @@ class MLSService extends commons_1.TypedEventEmitter {
      */
     removeClientsFromConversation(groupId, clientIds) {
         const groupIdBytes = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
-        return this.coreCryptoClient.transaction(cx => cx.removeClientsFromConversation(groupIdBytes, clientIds.map(id => this.textEncoder.encode(id))));
+        return this.processCommitAction(groupIdBytes, () => this.coreCryptoClient.removeClientsFromConversation(groupIdBytes, clientIds.map(id => this.textEncoder.encode(id))));
     }
     /**
      * Will check if mls group exists in corecrypto.
@@ -469,11 +546,11 @@ class MLSService extends commons_1.TypedEventEmitter {
     }
     async clientValidKeypackagesCount() {
         const credentialType = await this.getCredentialType();
-        return this.coreCryptoClient.transaction(cx => cx.clientValidKeypackagesCount(this.config.defaultCiphersuite, credentialType));
+        return this.coreCryptoClient.clientValidKeypackagesCount(this.config.defaultCiphersuite, credentialType);
     }
     async clientKeypackages(amountRequested) {
         const credentialType = await this.getCredentialType();
-        return this.coreCryptoClient.transaction(cx => cx.clientKeypackages(this.config.defaultCiphersuite, credentialType, amountRequested));
+        return this.coreCryptoClient.clientKeypackages(this.config.defaultCiphersuite, credentialType, amountRequested);
     }
     /**
      * Will send an empty commit into a group (renew key material)
@@ -620,7 +697,7 @@ class MLSService extends commons_1.TypedEventEmitter {
             return;
         }
         const groupIdBytes = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
-        return this.coreCryptoClient.transaction(cx => cx.wipeConversation(groupIdBytes));
+        return this.coreCryptoClient.wipeConversation(groupIdBytes);
     }
     /**
      * If there are pending proposals, we need to either process them,
@@ -663,7 +740,10 @@ class MLSService extends commons_1.TypedEventEmitter {
     async commitPendingProposals(groupId, shouldRetry = true) {
         const groupIdBytes = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
         try {
-            await this.coreCryptoClient.transaction(cx => cx.commitPendingProposals(groupIdBytes));
+            const commitBundle = await this.coreCryptoClient.commitPendingProposals(groupIdBytes);
+            if (commitBundle) {
+                await this.uploadCommitBundle(groupIdBytes, commitBundle);
+            }
             await this.cancelPendingProposalsTask(groupId);
         }
         catch (error) {
@@ -671,6 +751,11 @@ class MLSService extends commons_1.TypedEventEmitter {
                 throw error;
             }
             this.logger.warn('Failed to commit proposals, clearing the pending commit and retrying', error);
+            // If we failed to commit the proposals, we need to clear the pending commit and retry
+            // this is to avoid a situation where we are stuck with pending proposals that we can't commit.
+            // If there's nothing to clear the methods might throw an error, which we can ignore.
+            await this.coreCryptoClient.clearPendingCommit(groupIdBytes).catch(() => undefined);
+            await this.coreCryptoClient.clearPendingGroupFromExternalCommit(groupIdBytes).catch(() => undefined);
             return this.commitPendingProposals(groupId, false);
         }
     }
@@ -739,20 +824,32 @@ class MLSService extends commons_1.TypedEventEmitter {
      * @param oAuthIdToken The OAuth id token if the user is already authenticated
      * @returns AcmeChallenge if the user is not authenticated, true if the user is authenticated
      */
-    async enrollE2EI(discoveryUrl, user, client, nbPrekeys, certificateTtl, getOAuthToken, getAllConversations) {
+    async enrollE2EI(discoveryUrl, user, client, nbPrekeys, certificateTtl, getOAuthToken) {
         const isCertificateRenewal = await this.coreCryptoClient.e2eiIsEnabled(this.config.defaultCiphersuite);
         const e2eiServiceInternal = new E2EIServiceInternal_1.E2EIServiceInternal(this.coreDatabase, this.coreCryptoClient, this.apiClient, certificateTtl, nbPrekeys, { user, clientId: client.id, discoveryUrl });
-        const { keyPackages, newCrlDistributionPoints } = await e2eiServiceInternal.generateCertificate(getOAuthToken, isCertificateRenewal, getAllConversations, this.config.defaultCiphersuite);
-        this.dispatchNewCrlDistributionPoints(newCrlDistributionPoints);
+        const rotateBundle = await e2eiServiceInternal.generateCertificate(getOAuthToken, isCertificateRenewal, this.config.defaultCiphersuite);
+        this.dispatchNewCrlDistributionPoints(rotateBundle);
         // upload the clients public keys
         if (!this.isInitializedMLSClient(client)) {
             // we only upload public keys for the initial certification process if the device is not already a registered MLS device.
             await this.uploadMLSPublicKeys(client);
         }
         // replace old key packages with new key packages with x509 certificate
-        await this.replaceKeyPackages(client.id, keyPackages);
+        await this.replaceKeyPackages(client.id, rotateBundle.newKeyPackages);
         // Verify that we have enough key packages
         await this.verifyRemoteMLSKeyPackagesAmount(client.id);
+        // Update keying material
+        for (const [groupId, commitBundle] of rotateBundle.commits) {
+            const groupIdAsBytes = bazinga64_1.Converter.hexStringToArrayBufferView(groupId);
+            // manual copy of the commit bundle data because of a problem while cloning it
+            const newCommitBundle = {
+                commit: commitBundle.commit,
+                // @ts-ignore
+                groupInfo: commitBundle?.group_info || commitBundle.groupInfo,
+                welcome: commitBundle?.welcome,
+            };
+            await this.uploadCommitBundle(groupIdAsBytes, newCommitBundle);
+        }
     }
 }
 exports.MLSService = MLSService;