@wireapp/core 27.6.0 → 28.2.0

package/CHANGELOG.md

@@ -3,6 +3,49 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [28.2.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@28.1.0...@wireapp/core@28.2.0) (2022-07-04)
+
+
+### Features
+
+* **core, api-client:** Add MLS group creation ([#4295](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4295)) ([9755e03](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/9755e03bee6a01860b932c4da5f713809551241f))
+
+
+
+
+
+# [28.1.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@28.0.0...@wireapp/core@28.1.0) (2022-07-04)
+
+
+### Bug Fixes
+
+* **core:** More suited types for Account ([051b4f3](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/051b4f35be7164624f3ed7913366010bdf8b17c4))
+
+
+### Features
+
+* **api-client:** Adapt to api version 2 ([#4308](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4308)) ([2ac928d](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/2ac928d0b812080faa81e2cd9de12c959eb59276))
+
+
+
+
+
+# [28.0.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@27.6.0...@wireapp/core@28.0.0) (2022-07-01)
+
+
+### Features
+
+* Use mls config object ([#4307](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4307)) ([3d510d0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/3d510d0e041a3d049282e6a312ffa880d9bafd89))
+
+
+### BREAKING CHANGES
+
+* the enableMLS flag has been removed in favor of a config object. If the config object is set, then MLS will be activated
+
+
+
+
+
 # [27.6.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@27.5.0...@wireapp/core@27.6.0) (2022-06-30)
 
 

package/package.json

@@ -4,10 +4,10 @@
   },
   "dependencies": {
     "@open-wc/webpack-import-meta-loader": "0.4.7",
-    "@otak/core-crypto": "0.2.0-beta-3",
+    "@otak/core-crypto": "0.3.0-beta-1",
     "@types/long": "4.0.1",
     "@types/node": "~14",
-    "@wireapp/api-client": "19.7.2",
+    "@wireapp/api-client": "19.9.0",
     "@wireapp/cryptobox": "12.8.0",
     "bazinga64": "5.10.0",
     "hash.js": "1.1.7",
@@ -73,6 +73,6 @@
     "test:project": "yarn dist && yarn test",
     "test:node": "nyc jasmine --config=jasmine.json"
   },
-  "version": "27.6.0",
-  "gitHead": "8bc302af20f400f4c0cb3e15edfcaebb4494f1d0"
+  "version": "28.2.0",
+  "gitHead": "5fb6aacf6f616c92d73593ec24cefb50a5a0f7f0"
 }

package/src/main/Account.d.ts

@@ -59,13 +59,22 @@ declare type SecretCrypto<T> = {
     encrypt: (value: Uint8Array) => Promise<T>;
     decrypt: (payload: T) => Promise<Uint8Array>;
 };
-interface AccountOptions<T> {
-    /** Used to store info in the database (will create a inMemory engine if returns undefined) */
-    createStore?: CreateStoreFn;
-    /** encrypt/decrypt function pair that will be called before storing/fetching secrets in the secrets database.
+interface MLSConfig<T = any> {
+    /**
+     * encrypt/decrypt function pair that will be called before storing/fetching secrets in the secrets database.
      * If not provided will use the built in encryption mechanism
      */
     secretsCrypto?: SecretCrypto<T>;
+    /**
+     * path on the public server to the core crypto wasm file.
+     * This file will be downloaded lazily when corecrypto is needed.
+     * It, thus, needs to know where, on the server, the file can be found
+     */
+    coreCrypoWasmFilePath: string;
+}
+interface AccountOptions<T> {
+    /** Used to store info in the database (will create a inMemory engine if returns undefined) */
+    createStore?: CreateStoreFn;
     /** Number of prekeys to generate when creating a new device (defaults to 2)
      * Prekeys are Diffie-Hellmann public keys which allow offline initiation of a secure Proteus session between two devices.
      * Having a high value will:
@@ -76,16 +85,18 @@ interface AccountOptions<T> {
      *    - make it likely that all prekeys get consumed while the device is offline and the last resort prekey will be used to create new session
      */
     nbPrekeys?: number;
-    enableMLS?: boolean;
+    /**
+     * Config for MLS devices. Will not load corecrypt or create MLS devices if undefined
+     */
+    mlsConfig?: MLSConfig<T>;
 }
-export declare class Account<T = unknown> extends EventEmitter {
+export declare class Account<T = any> extends EventEmitter {
     private readonly apiClient;
     private readonly logger;
     private readonly createStore;
     private storeEngine?;
-    private readonly secretsCrypto?;
     private readonly nbPrekeys;
-    private readonly enableMLS;
+    private readonly mlsConfig?;
     private coreCryptoClient?;
     static readonly TOPIC: typeof TOPIC;
     service?: {
@@ -108,7 +119,7 @@ export declare class Account<T = unknown> extends EventEmitter {
      * @param apiClient The apiClient instance to use in the core (will create a new new one if undefined)
      * @param accountOptions
      */
-    constructor(apiClient?: APIClient, { createStore, nbPrekeys, secretsCrypto, enableMLS }?: AccountOptions<T>);
+    constructor(apiClient?: APIClient, { createStore, nbPrekeys, mlsConfig }?: AccountOptions<T>);
     private persistCookie;
     get clientId(): string;
     get userId(): string;

package/src/main/Account.js

@@ -86,14 +86,13 @@ class Account extends events_1.EventEmitter {
      * @param apiClient The apiClient instance to use in the core (will create a new new one if undefined)
      * @param accountOptions
      */
-    constructor(apiClient = new api_client_1.APIClient(), { createStore = () => undefined, nbPrekeys = 2, secretsCrypto, enableMLS = false } = {}) {
+    constructor(apiClient = new api_client_1.APIClient(), { createStore = () => undefined, nbPrekeys = 2, mlsConfig } = {}) {
         super();
         this.apiClient = apiClient;
         this.backendFeatures = this.apiClient.backendFeatures;
-        this.secretsCrypto = secretsCrypto;
+        this.mlsConfig = mlsConfig;
         this.nbPrekeys = nbPrekeys;
         this.createStore = createStore;
-        this.enableMLS = enableMLS;
         apiClient.on(api_client_1.APIClient.TOPIC.COOKIE_REFRESH, async (cookie) => {
             if (cookie && this.storeEngine) {
                 try {
@@ -233,7 +232,7 @@ class Account extends events_1.EventEmitter {
         const conversationService = new conversation_1.ConversationService(this.apiClient, cryptographyService, {
             // We can use qualified ids to send messages as long as the backend supports federated endpoints
             useQualifiedIds: this.backendFeatures.federationEndpoints,
-        });
+        }, () => this.coreCryptoClient);
         const notificationService = new notification_1.NotificationService(this.apiClient, cryptographyService, this.storeEngine);
         const selfService = new self_1.SelfService(this.apiClient);
         const teamService = new team_1.TeamService(this.apiClient);
@@ -260,17 +259,17 @@ class Account extends events_1.EventEmitter {
         const loadedClient = await this.service.client.getLocalClient();
         await this.apiClient.api.client.getClient(loadedClient.id);
         this.apiClient.context.clientId = loadedClient.id;
-        if (this.enableMLS) {
-            this.coreCryptoClient = await this.createMLSClient(loadedClient, this.apiClient.context);
+        if (this.mlsConfig) {
+            this.coreCryptoClient = await this.createMLSClient(loadedClient, this.apiClient.context, this.mlsConfig);
         }
         return loadedClient;
     }
-    async createMLSClient(client, context) {
+    async createMLSClient(client, context, mlsConfig) {
         const coreCryptoKeyId = 'corecrypto-key';
         const { CoreCrypto } = await Promise.resolve().then(() => __importStar(require('@otak/core-crypto')));
         const dbName = `secrets-${this.generateDbName(context)}`;
-        const secretStore = this.secretsCrypto
-            ? await (0, encryptedStore_1.createCustomEncryptedStore)(dbName, this.secretsCrypto)
+        const secretStore = mlsConfig.secretsCrypto
+            ? await (0, encryptedStore_1.createCustomEncryptedStore)(dbName, mlsConfig.secretsCrypto)
             : await (0, encryptedStore_1.createEncryptedStore)(dbName);
         let key = await secretStore.getsecretValue(coreCryptoKeyId);
         if (!key) {
@@ -279,21 +278,22 @@ class Account extends events_1.EventEmitter {
         }
         const { userId, domain } = this.apiClient.context;
         return CoreCrypto.init({
-            path: `corecrypto-${this.generateDbName(context)}`,
+            databaseName: `corecrypto-${this.generateDbName(context)}`,
             key: bazinga64_1.Encoder.toBase64(key).asString,
             clientId: `${userId}:${client.id}@${domain}`,
+            wasmFilePath: mlsConfig.coreCrypoWasmFilePath,
         });
     }
     async registerClient(loginData, clientInfo = coreDefaultClient, entropyData) {
         if (!this.service) {
             throw new Error('Services are not set.');
         }
-        this.logger.info(`Creating new client {mls: ${!!this.enableMLS}}`);
+        this.logger.info(`Creating new client {mls: ${!!this.mlsConfig}}`);
         const registeredClient = await this.service.client.register(loginData, clientInfo, entropyData);
-        if (this.enableMLS) {
-            this.coreCryptoClient = await this.createMLSClient(registeredClient, this.apiClient.context);
+        if (this.mlsConfig) {
+            this.coreCryptoClient = await this.createMLSClient(registeredClient, this.apiClient.context, this.mlsConfig);
             await this.service.client.uploadMLSPublicKeys(this.coreCryptoClient.clientPublicKey(), registeredClient.id);
-            await this.service.client.uploadMLSKeyPackages(this.coreCryptoClient.clientKeypackages(this.nbPrekeys), registeredClient.id);
+            await this.service.client.uploadMLSKeyPackages(await this.coreCryptoClient.clientKeypackages(this.nbPrekeys), registeredClient.id);
         }
         this.apiClient.context.clientId = registeredClient.id;
         this.logger.info('Client is created');

package/src/main/conversation/ConversationService.d.ts

@@ -1,3 +1,4 @@
+import type { CoreCrypto } from '@otak/core-crypto';
 import type { APIClient } from '@wireapp/api-client';
 import { MessageSendingStatus, Conversation, DefaultConversationRoleName, MutedStatus, NewConversation, QualifiedUserClients, UserClients, ClientMismatch } from '@wireapp/api-client/src/conversation';
 import type { ConversationMemberLeaveEvent } from '@wireapp/api-client/src/event';
@@ -61,12 +62,13 @@ export interface MessageSendingCallbacks {
 export declare class ConversationService {
     private readonly apiClient;
     private readonly config;
+    private readonly coreCryptoClientProvider;
     readonly messageTimer: MessageTimer;
     private readonly messageService;
     private selfConversationId?;
     constructor(apiClient: APIClient, cryptographyService: CryptographyService, config: {
         useQualifiedIds?: boolean;
-    });
+    }, coreCryptoClientProvider: () => CoreCrypto);
     private createEphemeral;
     private getConversationQualifiedMembers;
     /**
@@ -167,6 +169,7 @@ export declare class ConversationService {
      * @returns Resolves when the conversation was created
      */
     createConversation(conversationData: NewConversation): Promise<Conversation>;
+    private createMLSConversation;
     getConversations(conversationId: string): Promise<Conversation>;
     getConversations(conversationIds?: string[]): Promise<Conversation[]>;
     getAsset({ assetId, assetToken, otrKey, sha256 }: RemoteData): Promise<Uint8Array>;

package/src/main/conversation/ConversationService.js

@@ -19,6 +19,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConversationService = exports.MessageTargetMode = void 0;
+const bazinga64_1 = require("bazinga64");
 const conversation_1 = require("@wireapp/api-client/src/conversation");
 const data_1 = require("@wireapp/api-client/src/conversation/data");
 const protocol_messaging_1 = require("@wireapp/protocol-messaging");
@@ -35,9 +36,10 @@ var MessageTargetMode;
     MessageTargetMode[MessageTargetMode["USERS_CLIENTS"] = 2] = "USERS_CLIENTS";
 })(MessageTargetMode = exports.MessageTargetMode || (exports.MessageTargetMode = {}));
 class ConversationService {
-    constructor(apiClient, cryptographyService, config) {
+    constructor(apiClient, cryptographyService, config, coreCryptoClientProvider) {
         this.apiClient = apiClient;
         this.config = config;
+        this.coreCryptoClientProvider = coreCryptoClientProvider;
         this.messageTimer = new conversation_2.MessageTimer();
         this.messageService = new MessageService_1.MessageService(this.apiClient, cryptographyService);
     }
@@ -620,8 +622,64 @@ class ConversationService {
         else {
             payload = conversationData;
         }
+        if (typeof conversationData !== 'string' && conversationData.protocol === conversation_1.ConversationProtocol.MLS) {
+            return this.createMLSConversation(conversationData);
+        }
         return this.apiClient.api.conversation.postConversation(payload);
     }
+    async createMLSConversation(conversationData) {
+        /**
+         * @note For creating MLS conversations the users & qualified_users
+         * field must be empty as backend is not aware which users
+         * are in a MLS conversation because of the MLS architecture.
+         */
+        const newConversation = await this.apiClient.api.conversation.postConversation(Object.assign(Object.assign({}, conversationData), { users: undefined, qualified_users: undefined }));
+        const { group_id: groupId } = newConversation;
+        const groupIdDecodedFromBase64 = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
+        const { qualified_users: qualifiedUsers = [], selfUserId } = conversationData;
+        if (!selfUserId) {
+            throw new Error('You need to pass self user qualified id in order to create an MLS conversation');
+        }
+        /**
+         * @note We need to fetch key packages for all the users
+         * we want to add to the new MLS conversations,
+         * includes self user too.
+         */
+        const keyPackages = await Promise.all([
+            this.apiClient.api.client.claimMLSKeyPackages(selfUserId.id, selfUserId.domain, 
+            /**
+             * we should skip fetching key packages for current self client,
+             * it's already added by the backend on the group creation time
+             */
+            conversationData.creator_client),
+            ...qualifiedUsers.map(qualifiedId => this.apiClient.api.client.claimMLSKeyPackages(qualifiedId.id, qualifiedId.domain)),
+        ]);
+        const coreCryptoClient = this.coreCryptoClientProvider();
+        const coreCryptoKeyPackagesPayload = keyPackages.reduce((previousValue, currentValue) => {
+            // skip users that have not uploaded their MLS key packages
+            if (currentValue.key_packages.length > 0) {
+                return [
+                    ...previousValue,
+                    ...currentValue.key_packages.map(keyPackage => ({
+                        id: new TextEncoder().encode(keyPackage.client),
+                        kp: bazinga64_1.Decoder.fromBase64(keyPackage.key_package).asBytes,
+                    })),
+                ];
+            }
+            return previousValue;
+        }, []);
+        await coreCryptoClient.createConversation(groupIdDecodedFromBase64);
+        const memberAddedMessages = await coreCryptoClient.addClientsToConversation(groupIdDecodedFromBase64, coreCryptoKeyPackagesPayload);
+        const sendingPromises = [];
+        if (memberAddedMessages === null || memberAddedMessages === void 0 ? void 0 : memberAddedMessages.welcome) {
+            sendingPromises.push(this.apiClient.api.conversation.postMlsWelcomeMessage(Uint8Array.from(memberAddedMessages.welcome)));
+        }
+        if (memberAddedMessages === null || memberAddedMessages === void 0 ? void 0 : memberAddedMessages.message) {
+            sendingPromises.push(this.apiClient.api.conversation.postMlsMessage(Uint8Array.from(memberAddedMessages.message)));
+        }
+        await Promise.all(sendingPromises);
+        return newConversation;
+    }
     async getConversations(conversationIds) {
         if (!conversationIds || !conversationIds.length) {
             return this.apiClient.api.conversation.getAllConversations();