@wireapp/core 46.24.4 → 46.25.0

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

@@ -19,16 +19,12 @@
  */
 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");
@@ -52,6 +48,7 @@ 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;
@@ -62,18 +59,27 @@ 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
@@ -103,13 +109,7 @@ class MLSService extends commons_1.TypedEventEmitter {
             ...defaultConfig,
             ...filteredMLSConfig,
         };
-        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,
-        });
+        await this.coreCryptoClient.transaction(cx => cx.mlsInit((0, MLSId_1.generateMLSDeviceId)(userId, client.id), this.config.ciphersuites, this.config.nbKeyPackages));
         try {
             const ccClientSignature = await this.getCCClientSignatureString();
             const mlsDeviceStatus = (0, Helper_1.getMLSDeviceStatus)(client, this.config.defaultCiphersuite, ccClientSignature);
@@ -151,47 +151,25 @@ class MLSService extends commons_1.TypedEventEmitter {
             ? core_crypto_1.CredentialType.X509
             : core_crypto_1.CredentialType.Basic;
     }
-    uploadCommitBundle = async (groupId, commitBundle, { isExternalCommit = false, regenerateCommitBundle } = {}) => {
+    _uploadCommitBundle = async ({ commit, groupInfo, welcome, }) => {
+        const bundlePayload = new Uint8Array([...commit, ...groupInfo.payload, ...(welcome || [])]);
         try {
-            return await this._uploadCommitBundle(groupId, async () => commitBundle, isExternalCommit);
+            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';
         }
         catch (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;
+            this.logger.error(`Failed to upload commit bundle`, error);
+            return {
+                abort: { reason: error instanceof Error ? error.message : 'unknown 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.
@@ -204,23 +182,8 @@ class MLSService extends commons_1.TypedEventEmitter {
         if (keyPackages.length < 1) {
             throw new Error('Empty list of keys provided to addUsersToExistingConversation');
         }
-        // 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 };
+        const crlNewDistributionPoints = await this.coreCryptoClient.transaction(cx => cx.addClientsToConversation(groupIdBytes, keyPackages));
+        this.dispatchNewCrlDistributionPoints(crlNewDistributionPoints);
     }
     /**
      * Will return a list of client ids which are already in the group at core crypto level
@@ -302,90 +265,55 @@ 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 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) {
+        const groupInfo = await getGroupInfo();
+        const welcomeBundle = await this.coreCryptoClient.transaction(cx => cx.joinByExternalCommit(groupInfo, credentialType));
+        await this.dispatchNewCrlDistributionPoints(welcomeBundle.crlNewDistributionPoints);
+        if (welcomeBundle.id) {
             //after we've successfully joined via external commit, we schedule periodic key material renewal
-            const groupIdStr = bazinga64_1.Encoder.toBase64(groupId).asString;
+            const groupIdStr = bazinga64_1.Encoder.toBase64(welcomeBundle.id).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(payload) {
-        const { crlNewDistributionPoints } = payload;
+    dispatchNewCrlDistributionPoints(crlNewDistributionPoints) {
         if (crlNewDistributionPoints && crlNewDistributionPoints.length > 0) {
             this.emit(MLSServiceEvents.NEW_CRL_DISTRIBUTION_POINTS, crlNewDistributionPoints);
         }
     }
     async processWelcomeMessage(welcomeMessage) {
-        const welcomeBundle = await this.coreCryptoClient.processWelcomeMessage(welcomeMessage);
-        this.dispatchNewCrlDistributionPoints(welcomeBundle);
+        const welcomeBundle = await this.coreCryptoClient.transaction(cx => cx.processWelcomeMessage(welcomeMessage));
+        this.dispatchNewCrlDistributionPoints(welcomeBundle.crlNewDistributionPoints);
         return welcomeBundle.id;
     }
     async decryptMessage(conversationId, payload) {
-        return await this.coreCryptoClient.transaction(async (cx) => {
-            try {
-                const decryptedMessage = await cx.decryptMessage(conversationId, payload);
-                this.dispatchNewCrlDistributionPoints(decryptedMessage);
-                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,
-                        proposals: [],
-                    };
-                }
-                throw error;
+        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 undefined;
+        }
     }
     async encryptMessage(conversationId, message) {
-        return this.coreCryptoClient.encryptMessage(conversationId, message);
+        return this.coreCryptoClient.transaction(cx => cx.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 });
-        });
-    }
-    updateKeyingMaterial(groupId) {
+    async updateKeyingMaterial(groupId) {
         const groupIdBytes = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
-        return this.processCommitAction(groupIdBytes, () => this.coreCryptoClient.updateKeyingMaterial(groupIdBytes));
+        await this.coreCryptoClient.transaction(cx => cx.updateKeyingMaterial(groupIdBytes));
     }
     /**
      * Will create an empty conversation inside of coreCrypto.
@@ -413,7 +341,7 @@ class MLSService extends commons_1.TypedEventEmitter {
             ciphersuite: this.config.defaultCiphersuite,
         };
         const credentialType = await this.getCredentialType();
-        return this.coreCryptoClient.createConversation(groupIdBytes, credentialType, configuration);
+        return this.coreCryptoClient.transaction(cx => cx.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.
@@ -437,19 +365,18 @@ class MLSService extends commons_1.TypedEventEmitter {
         }));
         if (keyPackages.length <= 0) {
             // If there are no clients to add, just update the keying material
-            const response = await this.updateKeyingMaterial(groupId);
+            await this.updateKeyingMaterial(groupId);
             await this.scheduleKeyMaterialRenewal(groupId);
-            return { ...response, failures: keysClaimingFailures };
+            return keysClaimingFailures;
         }
-        const response = await this.addUsersToExistingConversation(groupId, keyPackages);
+        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.
          */
-        response.failures = [...keysClaimingFailures, ...response.failures];
-        return response;
+        return keysClaimingFailures;
     }
     /**
      * Will create a 1:1 conversation inside of coreCrypto, try claiming key packages for user and (if succesfull) add them to the MLS group.
@@ -472,14 +399,10 @@ class MLSService extends commons_1.TypedEventEmitter {
             const { keyPackages: selfKeyPackages, failures: selfKeysClaimingFailures } = await this.getKeyPackagesPayload([
                 { ...selfUser.user, skipOwnClientId: selfUser.client },
             ]);
-            const response = await this.addUsersToExistingConversation(groupId, [
-                ...otherUserKeyPackages,
-                ...selfKeyPackages,
-            ]);
+            await this.addUsersToExistingConversation(groupId, [...otherUserKeyPackages, ...selfKeyPackages]);
             // We schedule a periodic key material renewal
             await this.scheduleKeyMaterialRenewal(groupId);
-            response.failures = [...otherUserKeysClaimingFailures, ...selfKeysClaimingFailures, ...response.failures];
-            return response;
+            return [...otherUserKeysClaimingFailures, ...selfKeysClaimingFailures];
         }
         catch (error) {
             await this.wipeConversation(groupId);
@@ -525,7 +448,7 @@ class MLSService extends commons_1.TypedEventEmitter {
      */
     removeClientsFromConversation(groupId, clientIds) {
         const groupIdBytes = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
-        return this.processCommitAction(groupIdBytes, () => this.coreCryptoClient.removeClientsFromConversation(groupIdBytes, clientIds.map(id => this.textEncoder.encode(id))));
+        return this.coreCryptoClient.transaction(cx => cx.removeClientsFromConversation(groupIdBytes, clientIds.map(id => this.textEncoder.encode(id))));
     }
     /**
      * Will check if mls group exists in corecrypto.
@@ -546,11 +469,11 @@ class MLSService extends commons_1.TypedEventEmitter {
     }
     async clientValidKeypackagesCount() {
         const credentialType = await this.getCredentialType();
-        return this.coreCryptoClient.clientValidKeypackagesCount(this.config.defaultCiphersuite, credentialType);
+        return this.coreCryptoClient.transaction(cx => cx.clientValidKeypackagesCount(this.config.defaultCiphersuite, credentialType));
     }
     async clientKeypackages(amountRequested) {
         const credentialType = await this.getCredentialType();
-        return this.coreCryptoClient.clientKeypackages(this.config.defaultCiphersuite, credentialType, amountRequested);
+        return this.coreCryptoClient.transaction(cx => cx.clientKeypackages(this.config.defaultCiphersuite, credentialType, amountRequested));
     }
     /**
      * Will send an empty commit into a group (renew key material)
@@ -697,7 +620,7 @@ class MLSService extends commons_1.TypedEventEmitter {
             return;
         }
         const groupIdBytes = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
-        return this.coreCryptoClient.wipeConversation(groupIdBytes);
+        return this.coreCryptoClient.transaction(cx => cx.wipeConversation(groupIdBytes));
     }
     /**
      * If there are pending proposals, we need to either process them,
@@ -740,10 +663,7 @@ class MLSService extends commons_1.TypedEventEmitter {
     async commitPendingProposals(groupId, shouldRetry = true) {
         const groupIdBytes = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
         try {
-            const commitBundle = await this.coreCryptoClient.commitPendingProposals(groupIdBytes);
-            if (commitBundle) {
-                await this.uploadCommitBundle(groupIdBytes, commitBundle);
-            }
+            await this.coreCryptoClient.transaction(cx => cx.commitPendingProposals(groupIdBytes));
             await this.cancelPendingProposalsTask(groupId);
         }
         catch (error) {
@@ -751,11 +671,6 @@ 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);
         }
     }
@@ -824,32 +739,20 @@ 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) {
+    async enrollE2EI(discoveryUrl, user, client, nbPrekeys, certificateTtl, getOAuthToken, getAllConversations) {
         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 rotateBundle = await e2eiServiceInternal.generateCertificate(getOAuthToken, isCertificateRenewal, this.config.defaultCiphersuite);
-        this.dispatchNewCrlDistributionPoints(rotateBundle);
+        const { keyPackages, newCrlDistributionPoints } = await e2eiServiceInternal.generateCertificate(getOAuthToken, isCertificateRenewal, getAllConversations, this.config.defaultCiphersuite);
+        this.dispatchNewCrlDistributionPoints(newCrlDistributionPoints);
         // 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, rotateBundle.newKeyPackages);
+        await this.replaceKeyPackages(client.id, keyPackages);
         // 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;