@wireapp/core 18.0.0 → 20.0.2

package/CHANGELOG.md

@@ -3,6 +3,63 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [20.0.2](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@20.0.1...@wireapp/core@20.0.2) (2021-12-09)
+
+**Note:** Version bump only for package @wireapp/core
+
+
+
+
+
+## [20.0.1](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@20.0.0...@wireapp/core@20.0.1) (2021-12-09)
+
+
+### Bug Fixes
+
+* **core:** Generate new session and reencrypt payload when sessionIds are missing ([#4200](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4200)) ([07eab82](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/07eab82ee7512bb4eba71adf20c13c5609dbc024))
+
+
+
+
+
+# [20.0.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@19.0.0...@wireapp/core@20.0.0) (2021-12-08)
+
+
+### Code Refactoring
+
+* **core:** Harmonize asset param name ([#4199](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4199)) ([f29c825](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/f29c825df427e9fccae164a728f0071fdf1bc3af))
+
+
+### BREAKING CHANGES
+
+* **core:** The `imageAsset` property given to the `MessageBuilder.createImage` function has been renamed `asset` to be coherent with sending files.
+Replace `MessageBuilder.createImage({..., imageAsset: asset})` with `MessageBuilder.createImage({..., asset})`
+
+
+
+
+
+# [19.0.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@18.0.0...@wireapp/core@19.0.0) (2021-12-08)
+
+
+### Features
+
+* **core:** Ability to cancel asset uploading ([#4198](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4198)) ([e111f46](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/e111f46d06bf2ec22f2002c9a2954cdf0c9e8d09))
+
+
+### BREAKING CHANGES
+
+* **core:** Uploading an asset now return a structure that allow cancelling the upload. Thus instances of `await account.service.asset.uploadAsset(...)` must be replaced by 
+```
+const {cancel, response} = await account.service.asset.uploadAsset(...);
+cancel() // This is how you cancel the upload
+await response// This will contain the uploaded asset once the upload is done
+```
+
+
+
+
+
 # [18.0.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@17.34.0...@wireapp/core@18.0.0) (2021-12-08)
 
 

package/package.json

@@ -5,7 +5,7 @@
   "dependencies": {
     "@types/long": "4.0.1",
     "@types/node": "~14",
-    "@wireapp/api-client": "15.11.1",
+    "@wireapp/api-client": "16.1.0",
     "@wireapp/cryptobox": "12.7.1",
     "bazinga64": "5.10.0",
     "hash.js": "1.1.7",
@@ -69,6 +69,6 @@
     "test:project": "yarn dist && yarn test",
     "test:node": "nyc jasmine --config=jasmine.json"
   },
-  "version": "18.0.0",
-  "gitHead": "2881ae7d03e14fda38627186f93079e028f4af17"
+  "version": "20.0.2",
+  "gitHead": "34e17094bdbf142c28dc09726427dd6ac197a48a"
 }

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

@@ -1,11 +1,10 @@
+/// <reference types="node" />
 import type { APIClient } from '@wireapp/api-client';
 import type { AssetOptions } from '@wireapp/api-client/src/asset';
-import type { FileContent, ImageContent } from '../conversation/content/';
+import type { ProgressCallback, RequestCancelable } from '@wireapp/api-client/src/http';
 import type { EncryptedAssetUploaded } from '../cryptography/';
 export declare class AssetService {
     private readonly apiClient;
     constructor(apiClient: APIClient);
-    private postAsset;
-    uploadImageAsset(image: ImageContent, options?: AssetOptions): Promise<EncryptedAssetUploaded>;
-    uploadFileAsset(file: FileContent, options?: AssetOptions): Promise<EncryptedAssetUploaded>;
+    uploadAsset(plainText: Buffer | Uint8Array, options?: AssetOptions, progressCallback?: ProgressCallback): Promise<RequestCancelable<EncryptedAssetUploaded>>;
 }

package/src/main/conversation/AssetService.js

@@ -24,27 +24,23 @@ class AssetService {
     constructor(apiClient) {
         this.apiClient = apiClient;
     }
-    async postAsset(plainText, options, progressCallback) {
+    async uploadAsset(plainText, options, progressCallback) {
         const { cipherText, keyBytes, sha256 } = await (0, AssetCryptography_1.encryptAsset)({
             plainText,
             algorithm: options === null || options === void 0 ? void 0 : options.algorithm,
             hash: options === null || options === void 0 ? void 0 : options.hash,
         });
-        const request = await this.apiClient.asset.api.postAsset(new Uint8Array(cipherText), options, progressCallback);
-        const { key, token } = await request.response;
-        return {
-            cipherText,
-            key,
-            keyBytes,
-            sha256,
-            token,
-        };
-    }
-    uploadImageAsset(image, options) {
-        return this.postAsset(image.data, options);
-    }
-    uploadFileAsset(file, options) {
-        return this.postAsset(file.data, options);
+        const request = this.apiClient.asset.api.postAsset(new Uint8Array(cipherText), options, progressCallback);
+        return Object.assign(Object.assign({}, request), { response: request.response.then(response => {
+                const { key, token } = response;
+                return {
+                    cipherText,
+                    key,
+                    keyBytes,
+                    sha256,
+                    token,
+                };
+            }) });
     }
 }
 exports.AssetService = AssetService;

package/src/main/conversation/message/MessageBuilder.d.ts

@@ -1,4 +1,3 @@
-import type { CipherOptions } from '@wireapp/api-client/src/asset';
 import { Confirmation } from '@wireapp/protocol-messaging';
 import { AbortReason } from '..';
 import { EncryptedAssetUploaded } from '../../cryptography';
@@ -12,19 +11,15 @@ interface BaseOptions {
     messageId?: string;
 }
 interface CreateImageOptions extends BaseOptions {
-    cipherOptions?: CipherOptions;
     expectsReadConfirmation?: boolean;
-    imageAsset: EncryptedAssetUploaded;
+    asset: EncryptedAssetUploaded;
     image: ImageContent;
     legalHoldStatus?: LegalHoldStatus;
 }
-interface CreateFileOptions {
-    cipherOptions?: CipherOptions;
-    conversationId: string;
+interface CreateFileOptions extends BaseOptions {
     expectsReadConfirmation?: boolean;
     asset: EncryptedAssetUploaded;
     file: FileContent;
-    from: string;
     legalHoldStatus?: LegalHoldStatus;
     originalMessageId: string;
 }

package/src/main/conversation/message/MessageBuilder.js

@@ -70,11 +70,11 @@ class MessageBuilder {
             }, id: payload.originalMessageId, type: __1.PayloadBundleType.ASSET_ABORT });
     }
     static createImage(payload) {
-        const { expectsReadConfirmation, image, imageAsset, legalHoldStatus } = payload;
+        const { expectsReadConfirmation, image, asset, legalHoldStatus } = payload;
         return Object.assign(Object.assign({}, createCommonProperties(payload)), { content: {
-                asset: imageAsset,
                 expectsReadConfirmation,
                 image,
+                asset,
                 legalHoldStatus,
             }, type: __1.PayloadBundleType.ASSET_IMAGE });
     }

package/src/main/conversation/message/MessageService.js

@@ -59,7 +59,10 @@ class MessageService {
             plainTextPayload = externalPayload.text;
             cipherText = externalPayload.cipherText;
         }
-        const encryptedPayload = await this.cryptographyService.encrypt(plainTextPayload, recipients);
+        const { encrypted, missing } = await this.cryptographyService.encrypt(plainTextPayload, recipients);
+        const encryptedPayload = Object.keys(missing).length
+            ? await this.reencryptAfterMismatch({ missing, deleted: {} }, encrypted, plainText)
+            : encrypted;
         const send = (payload) => {
             return options.sendAsProtobuf
                 ? this.sendOTRProtobufMessage(sendingClientId, payload, Object.assign(Object.assign({}, options), { assetData: cipherText }))
@@ -97,7 +100,10 @@ class MessageService {
         const send = (payload) => {
             return this.sendFederatedOtrMessage(sendingClientId, payload, options);
         };
-        const encryptedPayload = await this.cryptographyService.encryptQualified(plainText, recipients);
+        const { encrypted, missing } = await this.cryptographyService.encryptQualified(plainText, recipients);
+        const encryptedPayload = Object.keys(missing).length
+            ? await this.reencryptAfterFederatedMismatch({ missing, deleted: {} }, encrypted, plainText)
+            : encrypted;
         try {
             return await send(encryptedPayload);
         }
@@ -216,8 +222,8 @@ class MessageService {
         deleted.forEach(({ userId, data }) => data.forEach(clientId => delete recipients[userId.id][clientId]));
         if (missing.length) {
             const missingPreKeyBundles = await this.apiClient.user.api.postMultiPreKeyBundles(mismatch.missing);
-            const reEncrypted = await this.cryptographyService.encrypt(plainText, missingPreKeyBundles);
-            const reEncryptedPayloads = (0, UserClientsUtil_1.flattenUserClients)(reEncrypted);
+            const { encrypted } = await this.cryptographyService.encrypt(plainText, missingPreKeyBundles);
+            const reEncryptedPayloads = (0, UserClientsUtil_1.flattenUserClients)(encrypted);
             // add missing clients to the recipients
             reEncryptedPayloads.forEach(({ data, userId }) => (recipients[userId.id] = Object.assign(Object.assign({}, recipients[userId.id]), data)));
         }
@@ -238,8 +244,8 @@ class MessageService {
         deleted.forEach(({ userId, data }) => data.forEach(clientId => delete recipients[userId.domain][userId.id][clientId]));
         if (Object.keys(missing).length) {
             const missingPreKeyBundles = await this.apiClient.user.api.postQualifiedMultiPreKeyBundles(mismatch.missing);
-            const reEncrypted = await this.cryptographyService.encryptQualified(plainText, missingPreKeyBundles);
-            const reEncryptedPayloads = (0, UserClientsUtil_1.flattenQualifiedUserClients)(reEncrypted);
+            const { encrypted } = await this.cryptographyService.encryptQualified(plainText, missingPreKeyBundles);
+            const reEncryptedPayloads = (0, UserClientsUtil_1.flattenQualifiedUserClients)(encrypted);
             reEncryptedPayloads.forEach(({ data, userId }) => (recipients[userId.domain][userId.id] = Object.assign(Object.assign({}, recipients[userId.domain][userId.id]), data)));
         }
         return recipients;

package/src/main/cryptography/CryptographyService.d.ts

@@ -29,9 +29,14 @@ export declare class CryptographyService {
     static convertBase64RecipientsToArray(recipients: OTRRecipients<string>): OTRRecipients<Uint8Array>;
     createCryptobox(): Promise<SerializedPreKey[]>;
     decrypt(sessionId: string, encodedCiphertext: string): Promise<Uint8Array>;
-    private static dismantleSessionId;
-    encryptQualified(plainText: Uint8Array, preKeyBundles: QualifiedUserPreKeyBundleMap | QualifiedUserClients): Promise<QualifiedOTRRecipients>;
-    encrypt(plainText: Uint8Array, users: UserPreKeyBundleMap | UserClients, domain?: string): Promise<OTRRecipients<Uint8Array>>;
+    encryptQualified(plainText: Uint8Array, preKeyBundles: QualifiedUserPreKeyBundleMap | QualifiedUserClients): Promise<{
+        missing: QualifiedUserClients;
+        encrypted: QualifiedOTRRecipients;
+    }>;
+    encrypt(plainText: Uint8Array, users: UserPreKeyBundleMap | UserClients, domain?: string): Promise<{
+        missing: UserClients;
+        encrypted: OTRRecipients<Uint8Array>;
+    }>;
     private encryptPayloadForSession;
     initCryptobox(): Promise<void>;
     deleteCryptographyStores(): Promise<boolean[]>;

package/src/main/cryptography/CryptographyService.js

@@ -81,41 +81,39 @@ class CryptographyService {
         const messageBytes = bazinga64_1.Decoder.fromBase64(encodedCiphertext).asBytes;
         return this.cryptobox.decrypt(sessionId, messageBytes.buffer);
     }
-    static dismantleSessionId(sessionId) {
-        // see https://regex101.com/r/c8FtCw/1
-        const regex = /((?<domain>.+)@)?(?<userId>.+)@(?<clientId>.+)$/g;
-        const match = regex.exec(sessionId);
-        const { domain, userId, clientId } = (match === null || match === void 0 ? void 0 : match.groups) || {};
-        return { clientId, domain, userId };
-    }
     async encryptQualified(plainText, preKeyBundles) {
         const qualifiedOTRRecipients = {};
+        const missing = {};
         for (const [domain, preKeyBundleMap] of Object.entries(preKeyBundles)) {
-            qualifiedOTRRecipients[domain] = await this.encrypt(plainText, preKeyBundleMap, domain);
+            const result = await this.encrypt(plainText, preKeyBundleMap, domain);
+            qualifiedOTRRecipients[domain] = result.encrypted;
+            missing[domain] = result.missing;
         }
-        return qualifiedOTRRecipients;
+        return {
+            encrypted: qualifiedOTRRecipients,
+            missing,
+        };
     }
     async encrypt(plainText, users, domain) {
-        const bundles = [];
+        const encrypted = {};
+        const missing = {};
         for (const userId in users) {
             const clientIds = (0, util_1.isUserClients)(users) ? users[userId] : Object.keys(users[userId]);
             for (const clientId of clientIds) {
                 const base64PreKey = (0, util_1.isUserClients)(users) ? undefined : users[userId][clientId].key;
                 const sessionId = CryptographyService.constructSessionId(userId, clientId, domain || null);
-                bundles.push(this.encryptPayloadForSession(sessionId, plainText, base64PreKey));
+                const result = await this.encryptPayloadForSession(sessionId, plainText, base64PreKey);
+                if (result) {
+                    encrypted[userId] || (encrypted[userId] = {});
+                    encrypted[userId][clientId] = result.encryptedPayload;
+                }
+                else {
+                    missing[userId] || (missing[userId] = []);
+                    missing[userId].push(clientId);
+                }
             }
         }
-        const payloads = await Promise.all(bundles);
-        return payloads.reduce((recipients, payload) => {
-            if (!payload) {
-                return recipients;
-            }
-            const { encryptedPayload, sessionId } = payload;
-            const { userId, clientId } = CryptographyService.dismantleSessionId(sessionId);
-            recipients[userId] || (recipients[userId] = {});
-            recipients[userId][clientId] = encryptedPayload;
-            return recipients;
-        }, {});
+        return { encrypted, missing };
     }
     async encryptPayloadForSession(sessionId, plainText, base64EncodedPreKey) {
         this.logger.log(`Encrypting payload for session ID "${sessionId}"`);

package/src/main/linkPreview/LinkPreviewService.js

@@ -40,7 +40,7 @@ class LinkPreviewService {
             return preview;
         }
         const uploadedLinkPreview = preview;
-        const asset = await this.assetService.uploadImageAsset(linkPreview.image);
+        const asset = await (await this.assetService.uploadAsset(linkPreview.image.data)).response;
         uploadedLinkPreview.imageUploaded = {
             asset,
             image,