@wireapp/core 17.24.0 → 17.26.0

package/src/main/conversation/ConversationService.test.node.ts

@@ -19,8 +19,7 @@
 
 import {APIClient} from '@wireapp/api-client';
 import {ClientType} from '@wireapp/api-client/src/client';
-import {UserPreKeyBundleMap} from '@wireapp/api-client/src/user';
-import {GenericMessage, LegalHoldStatus, Text} from '@wireapp/protocol-messaging';
+import {LegalHoldStatus} from '@wireapp/protocol-messaging';
 import {MemoryEngine} from '@wireapp/store-engine';
 import {PayloadBundleSource, PayloadBundleState, PayloadBundleType} from '.';
 
@@ -29,31 +28,6 @@ import * as PayloadHelper from '../test/PayloadHelper';
 import {MentionContent, QuoteContent} from './content';
 import {OtrMessage} from './message/OtrMessage';
 
-const createMessage = (content: string) => {
-  const customTextMessage = GenericMessage.create({
-    messageId: PayloadHelper.getUUID(),
-    text: Text.create({content}),
-  });
-
-  return GenericMessage.encode(customTextMessage).finish();
-};
-
-const generatePreKeyBundle = (userCount: number, clientsPerUser: number): UserPreKeyBundleMap => {
-  const prekeyBundle: UserPreKeyBundleMap = {};
-  for (let userIndex = 0; userIndex < userCount; userIndex++) {
-    const userId = PayloadHelper.getUUID();
-    prekeyBundle[userId] = {};
-    for (let clientIndex = 0; clientIndex < clientsPerUser; clientIndex++) {
-      const clientId = PayloadHelper.getUUID();
-      prekeyBundle[userId][clientId] = {
-        id: -1,
-        key: '',
-      };
-    }
-  }
-  return prekeyBundle;
-};
-
 describe('ConversationService', () => {
   let account: Account;
 
@@ -63,29 +37,6 @@ describe('ConversationService', () => {
     await account.initServices(new MemoryEngine());
   });
 
-  describe("'shouldSendAsExternal'", () => {
-    it('returns true for a big payload', () => {
-      const preKeyBundles = generatePreKeyBundle(128, 4);
-
-      const longMessage =
-        'Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Duis autem';
-      const plainText = createMessage(longMessage);
-
-      const shouldSendAsExternal = account.service!.conversation['shouldSendAsExternal'](plainText, preKeyBundles);
-      expect(shouldSendAsExternal).toBe(true);
-    });
-
-    it('returns false for a small payload', async () => {
-      const preKeyBundles = generatePreKeyBundle(2, 1);
-
-      const shortMessage = PayloadHelper.getUUID();
-      const plainText = createMessage(shortMessage);
-
-      const shouldSendAsExternal = account.service!.conversation['shouldSendAsExternal'](plainText, preKeyBundles);
-      expect(shouldSendAsExternal).toBe(false);
-    });
-  });
-
   describe('"send"', () => {
     const baseMessage = {
       conversation: PayloadHelper.getUUID(),
@@ -126,6 +77,25 @@ describe('ConversationService', () => {
         expect(callbacks.onSuccess).toHaveBeenCalledWith(jasmine.any(Object), sentTime);
       });
     });
+
+    it(`cancels message sending if onStart returns false`, async () => {
+      account['apiClient'].context = {
+        clientType: ClientType.NONE,
+        userId: PayloadHelper.getUUID(),
+        clientId: PayloadHelper.getUUID(),
+      };
+      const conversationService = account.service!.conversation;
+      spyOn<any>(conversationService, 'sendGenericMessage');
+      const message: OtrMessage = {...baseMessage, type: PayloadBundleType.TEXT, content: {text: 'test'}};
+      const callbacks = {onStart: () => Promise.resolve(false), onSuccess: jasmine.createSpy()};
+      await conversationService.send({
+        callbacks,
+        payloadBundle: message,
+      });
+
+      expect(callbacks.onSuccess).not.toHaveBeenCalled();
+      expect(conversationService['sendGenericMessage']).not.toHaveBeenCalled();
+    });
   });
 
   describe('"createText"', () => {

package/src/main/conversation/ConversationService.ts

@@ -50,7 +50,6 @@ import {
   MessageHide,
   Reaction,
 } from '@wireapp/protocol-messaging';
-import {Encoder} from 'bazinga64';
 
 import {
   AssetService,
@@ -62,7 +61,7 @@ import {
   PayloadBundleType,
 } from '../conversation/';
 import type {AssetContent, ClearedContent, DeletedContent, HiddenContent, RemoteData} from '../conversation/content/';
-import type {CryptographyService, EncryptedAsset} from '../cryptography/';
+import type {CryptographyService} from '../cryptography/';
 import * as AssetCryptography from '../cryptography/AssetCryptography.node';
 import {isStringArray, isQualifiedIdArray, isQualifiedUserClients, isUserClients} from '../util/TypePredicateUtil';
 import {MessageBuilder} from './message/MessageBuilder';
@@ -91,9 +90,19 @@ import type {
 } from './message/OtrMessage';
 
 export interface MessageSendingCallbacks {
-  onStart?: (message: GenericMessage) => void;
+  onStart?: (message: GenericMessage) => Promise<boolean | undefined>;
   onSuccess?: (message: GenericMessage, sentTime?: string) => void;
-  onClientMismatch?: (status: ClientMismatch | MessageSendingStatus) => Promise<boolean | undefined>;
+  /**
+   * Called whenever there is a clientmismatch returned from the server. Will also indicate the sending status of the message (if it was already sent or not)
+   *
+   * @param status The mismatch info
+   * @param wasSent Indicate whether the message was already sent or if it can still be canceled
+   * @return
+   */
+  onClientMismatch?: (
+    status: ClientMismatch | MessageSendingStatus,
+    wasSent: boolean,
+  ) => undefined | Promise<boolean | undefined>;
 }
 
 export class ConversationService {
@@ -103,12 +112,12 @@ export class ConversationService {
 
   constructor(
     private readonly apiClient: APIClient,
-    private readonly cryptographyService: CryptographyService,
+    cryptographyService: CryptographyService,
     private readonly assetService: AssetService,
   ) {
     this.messageTimer = new MessageTimer();
     this.messageBuilder = new MessageBuilder(this.apiClient, this.assetService);
-    this.messageService = new MessageService(this.apiClient, this.cryptographyService);
+    this.messageService = new MessageService(this.apiClient, cryptographyService);
   }
 
   private createEphemeral(originalGenericMessage: GenericMessage, expireAfterMillis: number): GenericMessage {
@@ -227,55 +236,6 @@ export class ConversationService {
     return this.apiClient.conversation.api.getConversation(userId);
   }
 
-  private async sendExternalGenericMessage(
-    sendingClientId: string,
-    conversationId: string,
-    asset: EncryptedAsset,
-    preKeyBundles: UserPreKeyBundleMap,
-    sendAsProtobuf?: boolean,
-  ): Promise<ClientMismatch | undefined> {
-    if (preKeyBundles.none) {
-      const {cipherText, keyBytes, sha256} = asset;
-      const messageId = MessageBuilder.createId();
-
-      const externalMessage = {
-        otrKey: new Uint8Array(keyBytes),
-        sha256: new Uint8Array(sha256),
-      };
-
-      const base64CipherText = Encoder.toBase64(cipherText).asString;
-
-      const genericMessage = GenericMessage.create({
-        [GenericMessageType.EXTERNAL]: externalMessage,
-        messageId,
-      });
-
-      const plainTextArray = GenericMessage.encode(genericMessage).finish();
-
-      const recipients = await this.cryptographyService.encrypt(plainTextArray, preKeyBundles);
-
-      if (sendAsProtobuf) {
-        return this.messageService.sendOTRProtobufMessage(
-          sendingClientId,
-          recipients,
-          conversationId,
-          plainTextArray,
-          cipherText,
-        );
-      }
-      return this.messageService.sendOTRMessage(
-        sendingClientId,
-        recipients,
-        conversationId,
-        plainTextArray,
-        base64CipherText,
-      );
-
-      // todo: add federated sending here
-    }
-    return undefined;
-  }
-
   private async getQualifiedRecipientsForConversation(
     conversationId: QualifiedId,
     userIds?: QualifiedId[] | QualifiedUserClients,
@@ -287,13 +247,24 @@ export class ConversationService {
     return this.getQualifiedPreKeyBundle(recipientIds);
   }
 
+  private async getRecipientsForConversation(
+    conversationId: string,
+    userIds?: string[] | UserClients,
+  ): Promise<UserClients | UserPreKeyBundleMap> {
+    if (isUserClients(userIds)) {
+      return userIds;
+    }
+    return this.getPreKeyBundleMap(conversationId, userIds);
+  }
+
   /**
-   * Sends a message to a federated environment.
+   * Sends a message to a conversation
    *
    * @param sendingClientId The clientId from which the message is sent
    * @param conversationId The conversation in which to send the message
-   * @param conversationDomain The domain where the conversation lives
    * @param genericMessage The payload of the message to send
+   * @param options.domain? The federated domain the server runs on. Should only be set for federation enabled envs
+   * @param options.sendAsProtobuf? Will send the message as a protobuf payload
    * @param options.userIds? can be either a QualifiedId[] or QualfiedUserClients or undefined. The type has some effect on the behavior of the method.
    *    When given undefined the method will fetch both the members of the conversations and their devices. No ClientMismatch can happen in that case
    *    When given a QualifiedId[] the method will fetch the freshest list of devices for those users (since they are not given by the consumer). As a consequence no ClientMismatch error will trigger and we will ignore missing clients when sending
@@ -301,24 +272,6 @@ export class ConversationService {
    * @param options.onClientMismatch? Will be called whenever there is a clientmismatch returned from the server. Needs to be combined with a userIds of type QualifiedUserClients
    * @return Resolves with the message sending status from backend
    */
-  private async sendFederatedGenericMessage(
-    sendingClientId: string,
-    conversationId: QualifiedId,
-    genericMessage: GenericMessage,
-    options: {
-      userIds?: QualifiedId[] | QualifiedUserClients;
-      onClientMismatch?: (mismatch: MessageSendingStatus) => Promise<boolean | undefined>;
-    } = {},
-  ): Promise<MessageSendingStatus> {
-    const plainTextArray = GenericMessage.encode(genericMessage).finish();
-    const recipients = await this.getQualifiedRecipientsForConversation(conversationId, options.userIds);
-
-    return this.messageService.sendFederatedOTRMessage(sendingClientId, conversationId, recipients, plainTextArray, {
-      reportMissing: isQualifiedUserClients(options.userIds), // we want to check mismatch in case the consumer gave an exact list of users/devices
-      onClientMismatch: options.onClientMismatch,
-    });
-  }
-
   private async sendGenericMessage(
     sendingClientId: string,
     conversationId: string,
@@ -327,46 +280,33 @@ export class ConversationService {
       domain?: string;
       userIds?: string[] | QualifiedId[] | UserClients | QualifiedUserClients;
       sendAsProtobuf?: boolean;
-      onClientMismatch?: (mistmatch: ClientMismatch | MessageSendingStatus) => Promise<boolean | undefined>;
+      onClientMismatch?: MessageSendingCallbacks['onClientMismatch'];
     } = {},
-  ): Promise<ClientMismatch | MessageSendingStatus | undefined> {
+  ): Promise<ClientMismatch | MessageSendingStatus> {
     const {domain, userIds} = options;
+    const plainText = GenericMessage.encode(genericMessage).finish();
     if (domain) {
       if (isStringArray(userIds) || isUserClients(userIds)) {
-        throw new Error('Invalid userIds option for sending');
+        throw new Error('Invalid userIds option for sending to federated backend');
       }
-
-      return this.sendFederatedGenericMessage(
-        this.apiClient.validatedClientId,
-        {id: conversationId, domain},
-        genericMessage,
-        {userIds, onClientMismatch: options.onClientMismatch},
-      );
+      const recipients = await this.getQualifiedRecipientsForConversation({id: conversationId, domain}, userIds);
+      return this.messageService.sendFederatedMessage(sendingClientId, recipients, plainText, {
+        conversationId: {id: conversationId, domain},
+        reportMissing: isQualifiedUserClients(options.userIds), // we want to check mismatch in case the consumer gave an exact list of users/devices
+        onClientMismatch: mismatch => options.onClientMismatch?.(mismatch, false),
+      });
     }
 
-    if (isQualifiedIdArray(userIds) || isQualifiedUserClients(userIds)) {
+    if (!isStringArray(userIds) && !isUserClients(userIds)) {
       throw new Error('Invalid userIds option for sending');
     }
-
-    const plainTextArray = GenericMessage.encode(genericMessage).finish();
-    const preKeyBundles = await this.getPreKeyBundleMap(conversationId, userIds);
-
-    if (this.shouldSendAsExternal(plainTextArray, preKeyBundles)) {
-      const encryptedAsset = await AssetCryptography.encryptAsset({plainText: plainTextArray});
-      return this.sendExternalGenericMessage(
-        this.apiClient.validatedClientId,
-        conversationId,
-        encryptedAsset,
-        preKeyBundles,
-        options.sendAsProtobuf,
-      );
-    }
-
-    const recipients = await this.cryptographyService.encrypt(plainTextArray, preKeyBundles);
-
-    return options.sendAsProtobuf
-      ? this.messageService.sendOTRProtobufMessage(sendingClientId, recipients, conversationId, plainTextArray)
-      : this.messageService.sendOTRMessage(sendingClientId, recipients, conversationId, plainTextArray);
+    const recipients = await this.getRecipientsForConversation(conversationId, userIds);
+    return this.messageService.sendMessage(sendingClientId, recipients, plainText, {
+      conversationId,
+      sendAsProtobuf: options.sendAsProtobuf,
+      reportMissing: isUserClients(options.userIds), // we want to check mismatch in case the consumer gave an exact list of users/devices
+      onClientMismatch: mistmatch => options.onClientMismatch?.(mistmatch, false),
+    });
   }
 
   private generateButtonActionGenericMessage(payloadBundle: ButtonActionMessage): GenericMessage {
@@ -746,20 +686,6 @@ export class ConversationService {
     };
   }
 
-  private shouldSendAsExternal(plainText: Uint8Array, preKeyBundles: UserPreKeyBundleMap): boolean {
-    const EXTERNAL_MESSAGE_THRESHOLD_BYTES = 200 * 1024;
-
-    let clientCount = 0;
-    for (const user in preKeyBundles) {
-      clientCount += Object.keys(preKeyBundles[user]).length;
-    }
-
-    const messageInBytes = new Uint8Array(plainText).length;
-    const estimatedPayloadInBytes = clientCount * messageInBytes;
-
-    return estimatedPayloadInBytes > EXTERNAL_MESSAGE_THRESHOLD_BYTES;
-  }
-
   public leaveConversation(conversationId: string): Promise<ConversationMemberLeaveEvent> {
     return this.apiClient.conversation.api.deleteMember(conversationId, this.apiClient.context!.userId);
   }
@@ -846,7 +772,8 @@ export class ConversationService {
    * @param params.sendAsProtobuf?
    * @param params.conversationDomain? The domain the conversation lives on (if given with QualifiedId[] or QualfiedUserClients in the userIds params, will send the message to the federated endpoint)
    * @param params.callbacks? Optional callbacks that will be called when the message starts being sent and when it has been succesfully sent.
-   * @param [callbacks.onClientMismatch] Will be called when a mismatch happens. Returning `false` from the callback will stop the sending attempt
+   * @param callbacks.onStart Will be called before a message is actually sent. Returning 'false' will prevent the message from being sent
+   * @param callbacks.onClientMismatch? Will be called when a mismatch happens. Returning `false` from the callback will stop the sending attempt
    * @return resolves with the sent message
    */
   public async send<T extends OtrMessage = OtrMessage>({
@@ -923,14 +850,27 @@ export class ConversationService {
         throw new Error(`No send method implemented for "${payloadBundle['type']}".`);
     }
 
-    callbacks?.onStart?.(genericMessage);
+    if ((await callbacks?.onStart?.(genericMessage)) === false) {
+      // If the onStart call returns false, it means the consumer wants to cancel the message sending
+      return payloadBundle;
+    }
+
     const response = await this.sendGenericMessage(
       this.apiClient.validatedClientId,
       payloadBundle.conversation,
       genericMessage,
-      {userIds, sendAsProtobuf, domain: conversationDomain, onClientMismatch: callbacks?.onClientMismatch},
+      {
+        userIds,
+        sendAsProtobuf,
+        domain: conversationDomain,
+        onClientMismatch: callbacks?.onClientMismatch,
+      },
     );
-    callbacks?.onSuccess?.(genericMessage, response?.time);
+    if (!this.isClearFromMismatch(response)) {
+      // We warn the consumer that there is a mismatch that did not prevent message sending
+      callbacks?.onClientMismatch?.(response, true);
+    }
+    callbacks?.onSuccess?.(genericMessage, response.time);
 
     return {
       ...payloadBundle,
@@ -991,4 +931,12 @@ export class ConversationService {
       conversation_role: conversationRole,
     });
   }
+
+  private isClearFromMismatch(mismatch: ClientMismatch | MessageSendingStatus): boolean {
+    const hasMissing = Object.keys(mismatch.missing || {}).length > 0;
+    const hasDeleted = Object.keys(mismatch.deleted || {}).length > 0;
+    const hasRedundant = Object.keys(mismatch.redundant || {}).length > 0;
+    const hasFailed = Object.keys((mismatch as MessageSendingStatus).failed_to_send || {}).length > 0;
+    return !hasMissing && !hasDeleted && !hasRedundant && !hasFailed;
+  }
 }

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

@@ -1,23 +1,53 @@
 import { APIClient } from '@wireapp/api-client';
-import { ClientMismatch, MessageSendingStatus, OTRRecipients, QualifiedUserClients } from '@wireapp/api-client/src/conversation';
+import { ClientMismatch, MessageSendingStatus, QualifiedUserClients, UserClients } from '@wireapp/api-client/src/conversation';
 import { CryptographyService } from '../../cryptography';
-import { QualifiedId, QualifiedUserPreKeyBundleMap } from '@wireapp/api-client/src/user';
+import { QualifiedId, QualifiedUserPreKeyBundleMap, UserPreKeyBundleMap } from '@wireapp/api-client/src/user';
 export declare class MessageService {
     private readonly apiClient;
     private readonly cryptographyService;
     constructor(apiClient: APIClient, cryptographyService: CryptographyService);
-    sendOTRMessage(sendingClientId: string, recipients: OTRRecipients<Uint8Array>, conversationId: string | null, plainTextArray: Uint8Array, base64CipherText?: string): Promise<ClientMismatch>;
-    private isClientMismatchError;
-    private checkFederatedClientsMismatch;
-    sendFederatedOTRMessage(sendingClientId: string, { id: conversationId, domain }: QualifiedId, recipients: QualifiedUserClients | QualifiedUserPreKeyBundleMap, plainTextArray: Uint8Array, options?: {
+    /**
+     * Sends a message to a non-federated backend.
+     *
+     * @param sendingClientId The clientId of the current user
+     * @param recipients The list of recipients to send the message to
+     * @param plainText The plainText data to send
+     * @param options.conversationId? the conversation to send the message to. Will broadcast if not set
+     * @param options.reportMissing? trigger a mismatch error when there are missing recipients in the payload
+     * @param options.sendAsProtobuf?
+     * @param options.onClientMismatch? Called when a mismatch happens on the server
+     * @return the ClientMismatch status returned by the backend
+     */
+    sendMessage(sendingClientId: string, recipients: UserClients | UserPreKeyBundleMap, plainText: Uint8Array, options?: {
+        conversationId?: string;
+        reportMissing?: boolean;
+        sendAsProtobuf?: boolean;
+        onClientMismatch?: (mismatch: ClientMismatch) => undefined | Promise<boolean | undefined>;
+    }): Promise<ClientMismatch>;
+    /**
+     * Sends a message to a federated backend.
+     *
+     * @param sendingClientId The clientId of the current user
+     * @param recipients The list of recipients to send the message to
+     * @param plainText The plainText data to send
+     * @param options.conversationId? the conversation to send the message to. Will broadcast if not set
+     * @param options.reportMissing? trigger a mismatch error when there are missing recipients in the payload
+     * @param options.sendAsProtobuf?
+     * @param options.onClientMismatch? Called when a mismatch happens on the server
+     * @return the MessageSendingStatus returned by the backend
+     */
+    sendFederatedMessage(sendingClientId: string, recipients: QualifiedUserClients | QualifiedUserPreKeyBundleMap, plainText: Uint8Array, options: {
         assetData?: Uint8Array;
+        conversationId?: QualifiedId;
         reportMissing?: boolean;
-        onClientMismatch?: (mismatch: MessageSendingStatus) => Promise<boolean | undefined>;
+        onClientMismatch?: (mismatch: MessageSendingStatus) => undefined | Promise<boolean | undefined>;
     }): Promise<MessageSendingStatus>;
-    sendOTRProtobufMessage(sendingClientId: string, recipients: OTRRecipients<Uint8Array>, conversationId: string | null, plainTextArray: Uint8Array, assetData?: Uint8Array): Promise<ClientMismatch>;
-    private onClientMismatch;
-    private onClientProtobufMismatch;
-    private deleteExtraQualifiedClients;
+    private sendFederatedOtrMessage;
+    private sendOTRMessage;
+    private generateExternalPayload;
+    private shouldSendAsExternal;
+    private isClientMismatchError;
+    private reencryptAfterMismatch;
     /**
      * Will re-encrypt a message when there were some missing clients in the initial send (typically when the server replies with a client mismatch error)
      *
@@ -26,6 +56,6 @@ export declare class MessageService {
      * @param {Uint8Array} plainText The text that should be encrypted for the missing clients
      * @return resolves with a new message payload that can be sent
      */
-    private onFederatedMismatch;
-    private addMissingQualifiedClients;
+    private reencryptAfterFederatedMismatch;
+    private sendOTRProtobufMessage;
 }