@wireapp/core 31.1.3 → 31.2.0

package/src/main/cryptography/AssetCryptography/index.d.ts

@@ -0,0 +1,8 @@
+import { CipherOptions } from '@wireapp/api-client/src/asset';
+import { EncryptedAsset } from './EncryptedAsset';
+interface EncryptOptions extends CipherOptions {
+    plainText: Uint8Array;
+}
+export declare const decryptAsset: ({ cipherText, keyBytes, sha256, }: EncryptedAsset) => Promise<Uint8Array>;
+export declare const encryptAsset: ({ plainText, algorithm }: EncryptOptions) => Promise<EncryptedAsset>;
+export {};

package/src/main/cryptography/AssetCryptography/index.js

@@ -0,0 +1,53 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2021 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encryptAsset = exports.decryptAsset = void 0;
+const crypto_node_1 = require("./crypto.node");
+const isEqual = (a, b) => {
+    const arrayA = new Uint32Array(a);
+    const arrayB = new Uint32Array(b);
+    const hasSameLength = arrayA.length === arrayB.length;
+    const hasSameValues = arrayA.every((value, index) => value === arrayB[index]);
+    return hasSameLength && hasSameValues;
+};
+const decryptAsset = async ({ cipherText, keyBytes, sha256: referenceSha256, }) => {
+    const computedSha256 = await crypto_node_1.crypto.digest(cipherText);
+    if (!isEqual(computedSha256, referenceSha256)) {
+        throw new Error('Encrypted asset does not match its SHA-256 hash');
+    }
+    return crypto_node_1.crypto.decrypt(cipherText, keyBytes);
+};
+exports.decryptAsset = decryptAsset;
+const encryptAsset = async ({ plainText, algorithm = 'AES-256-CBC' }) => {
+    const initializationVector = crypto_node_1.crypto.getRandomValues(16);
+    const rawKeyBytes = crypto_node_1.crypto.getRandomValues(32);
+    const { key, cipher } = await crypto_node_1.crypto.encrypt(plainText, rawKeyBytes, initializationVector, algorithm);
+    const ivCipherText = new Uint8Array(cipher.byteLength + initializationVector.byteLength);
+    ivCipherText.set(initializationVector, 0);
+    ivCipherText.set(new Uint8Array(cipher), initializationVector.byteLength);
+    const sha256 = await crypto_node_1.crypto.digest(ivCipherText);
+    return {
+        cipherText: ivCipherText,
+        keyBytes: key,
+        sha256,
+    };
+};
+exports.encryptAsset = encryptAsset;
+//# sourceMappingURL=index.js.map

package/src/main/cryptography/AssetCryptography/interfaces.d.ts

@@ -0,0 +1,9 @@
+export interface Crypto {
+    digest(cipherText: Uint8Array): Promise<Uint8Array>;
+    decrypt(cipherText: Uint8Array, keyBytes: Uint8Array): Promise<Uint8Array>;
+    getRandomValues(size: number): Uint8Array;
+    encrypt(plainText: Uint8Array, keyBytes: Uint8Array, initializationVector: Uint8Array, algorithm: string): Promise<{
+        key: Uint8Array;
+        cipher: Uint8Array | ArrayBuffer;
+    }>;
+}

package/src/main/cryptography/AssetCryptography/interfaces.js

@@ -0,0 +1,21 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2021 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interfaces.js.map

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

@@ -0,0 +1,16 @@
+import { CRUDEngine } from '@wireapp/store-engine';
+export declare enum DatabaseStores {
+    AMPLIFY = "amplify",
+    CLIENTS = "clients",
+    KEYS = "keys",
+    PRE_KEYS = "prekeys",
+    SESSIONS = "sessions",
+    GROUP_IDS = "group_ids",
+    PENDING_PROPOSALS = "pending_proposals"
+}
+export declare class CryptographyDatabaseRepository {
+    private readonly storeEngine;
+    static readonly STORES: typeof DatabaseStores;
+    constructor(storeEngine: CRUDEngine);
+    deleteStores(): Promise<boolean[]>;
+}

package/src/main/cryptography/CryptographyDatabaseRepository.js

@@ -0,0 +1,44 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2018 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptographyDatabaseRepository = exports.DatabaseStores = void 0;
+var DatabaseStores;
+(function (DatabaseStores) {
+    DatabaseStores["AMPLIFY"] = "amplify";
+    DatabaseStores["CLIENTS"] = "clients";
+    DatabaseStores["KEYS"] = "keys";
+    DatabaseStores["PRE_KEYS"] = "prekeys";
+    DatabaseStores["SESSIONS"] = "sessions";
+    DatabaseStores["GROUP_IDS"] = "group_ids";
+    DatabaseStores["PENDING_PROPOSALS"] = "pending_proposals";
+})(DatabaseStores = exports.DatabaseStores || (exports.DatabaseStores = {}));
+class CryptographyDatabaseRepository {
+    constructor(storeEngine) {
+        this.storeEngine = storeEngine;
+    }
+    deleteStores() {
+        return Promise.all(
+        //make sure we use enum's lowercase values, not uppercase keys
+        Object.values(CryptographyDatabaseRepository.STORES).map(store => this.storeEngine.deleteAll(store)));
+    }
+}
+exports.CryptographyDatabaseRepository = CryptographyDatabaseRepository;
+CryptographyDatabaseRepository.STORES = DatabaseStores;
+//# sourceMappingURL=CryptographyDatabaseRepository.js.map

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

@@ -0,0 +1,52 @@
+import { APIClient } from '@wireapp/api-client';
+import { PreKey as SerializedPreKey } from '@wireapp/api-client/src/auth/';
+import { RegisteredClient } from '@wireapp/api-client/src/client/';
+import { OTRRecipients, QualifiedOTRRecipients, QualifiedUserClients, UserClients } from '@wireapp/api-client/src/conversation/';
+import { ConversationOtrMessageAddEvent } from '@wireapp/api-client/src/event';
+import { QualifiedId, QualifiedUserPreKeyBundleMap, UserPreKeyBundleMap } from '@wireapp/api-client/src/user/';
+import { Cryptobox } from '@wireapp/cryptobox';
+import { GenericMessage } from '@wireapp/protocol-messaging';
+import { CRUDEngine } from '@wireapp/store-engine';
+import { PayloadBundle, PayloadBundleSource } from '../conversation';
+export declare type DecryptionError = {
+    code: number;
+    message: string;
+};
+export interface MetaClient extends RegisteredClient {
+    meta: {
+        is_verified?: boolean;
+        primary_key: string;
+    };
+}
+export declare class CryptographyService {
+    readonly apiClient: APIClient;
+    private readonly storeEngine;
+    private readonly config;
+    private readonly logger;
+    cryptobox: Cryptobox;
+    private readonly database;
+    constructor(apiClient: APIClient, storeEngine: CRUDEngine, config: {
+        useQualifiedIds: boolean;
+        nbPrekeys: number;
+    });
+    constructSessionId(userId: string | QualifiedId, clientId: string, domain?: string): string;
+    static convertArrayRecipientsToBase64(recipients: OTRRecipients<Uint8Array>): OTRRecipients<string>;
+    static convertBase64RecipientsToArray(recipients: OTRRecipients<string>): OTRRecipients<Uint8Array>;
+    createCryptobox(entropyData?: Uint8Array): Promise<SerializedPreKey[]>;
+    decrypt(sessionId: string, encodedCiphertext: string): Promise<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[]>;
+    resetSession(sessionId: string): Promise<void>;
+    decryptMessage(otrMessage: ConversationOtrMessageAddEvent): Promise<GenericMessage>;
+    mapGenericMessage(otrMessage: ConversationOtrMessageAddEvent, genericMessage: GenericMessage, source: PayloadBundleSource): PayloadBundle;
+    private generateDecryptionError;
+}

package/src/main/cryptography/CryptographyService.js

@@ -0,0 +1,205 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2018 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptographyService = void 0;
+const cryptobox_1 = require("@wireapp/cryptobox");
+const proteus_1 = require("@wireapp/proteus");
+const protocol_messaging_1 = require("@wireapp/protocol-messaging");
+const bazinga64_1 = require("bazinga64");
+const logdown_1 = __importDefault(require("logdown"));
+const conversation_1 = require("../conversation");
+const util_1 = require("../util");
+const CryptographyDatabaseRepository_1 = require("./CryptographyDatabaseRepository");
+const GenericMessageMapper_1 = require("./GenericMessageMapper");
+class CryptographyService {
+    constructor(apiClient, storeEngine, config) {
+        this.apiClient = apiClient;
+        this.storeEngine = storeEngine;
+        this.config = config;
+        this.cryptobox = new cryptobox_1.Cryptobox(this.storeEngine, config.nbPrekeys);
+        this.database = new CryptographyDatabaseRepository_1.CryptographyDatabaseRepository(this.storeEngine);
+        this.logger = (0, logdown_1.default)('@wireapp/core/cryptography/CryptographyService', {
+            logger: console,
+            markdown: false,
+        });
+    }
+    constructSessionId(userId, clientId, domain) {
+        const { id, domain: baseDomain } = typeof userId === 'string' ? { id: userId, domain } : userId;
+        const baseId = `${id}@${clientId}`;
+        return baseDomain && this.config.useQualifiedIds ? `${baseDomain}@${baseId}` : baseId;
+    }
+    static convertArrayRecipientsToBase64(recipients) {
+        return Object.fromEntries(Object.entries(recipients).map(([userId, otrClientMap]) => {
+            const otrClientMapWithBase64 = Object.fromEntries(Object.entries(otrClientMap).map(([clientId, payload]) => {
+                return [clientId, bazinga64_1.Encoder.toBase64(payload).asString];
+            }));
+            return [userId, otrClientMapWithBase64];
+        }));
+    }
+    static convertBase64RecipientsToArray(recipients) {
+        return Object.fromEntries(Object.entries(recipients).map(([userId, otrClientMap]) => {
+            const otrClientMapWithUint8Array = Object.fromEntries(Object.entries(otrClientMap).map(([clientId, payload]) => {
+                return [clientId, bazinga64_1.Decoder.fromBase64(payload).asBytes];
+            }));
+            return [userId, otrClientMapWithUint8Array];
+        }));
+    }
+    async createCryptobox(entropyData) {
+        const initialPreKeys = await this.cryptobox.create(entropyData);
+        return initialPreKeys
+            .map(preKey => {
+            const preKeyJson = this.cryptobox.serialize_prekey(preKey);
+            if (preKeyJson.id !== proteus_1.keys.PreKey.MAX_PREKEY_ID) {
+                return preKeyJson;
+            }
+            return { id: -1, key: '' };
+        })
+            .filter(serializedPreKey => serializedPreKey.key);
+    }
+    decrypt(sessionId, encodedCiphertext) {
+        this.logger.log(`Decrypting message for session ID "${sessionId}"`);
+        const messageBytes = bazinga64_1.Decoder.fromBase64(encodedCiphertext).asBytes;
+        return this.cryptobox.decrypt(sessionId, messageBytes.buffer);
+    }
+    async encryptQualified(plainText, preKeyBundles) {
+        const qualifiedOTRRecipients = {};
+        const missing = {};
+        for (const [domain, preKeyBundleMap] of Object.entries(preKeyBundles)) {
+            const result = await this.encrypt(plainText, preKeyBundleMap, domain);
+            qualifiedOTRRecipients[domain] = result.encrypted;
+            missing[domain] = result.missing;
+        }
+        return {
+            encrypted: qualifiedOTRRecipients,
+            missing,
+        };
+    }
+    async encrypt(plainText, users, domain) {
+        var _a;
+        const encrypted = {};
+        const missing = {};
+        for (const userId in users) {
+            const clientIds = (0, util_1.isUserClients)(users)
+                ? users[userId]
+                : Object.keys(users[userId])
+                    // We filter out clients that have `null` prekey
+                    .filter(clientId => !!users[userId][clientId]);
+            for (const clientId of clientIds) {
+                const base64PreKey = (0, util_1.isUserClients)(users) ? undefined : (_a = users[userId][clientId]) === null || _a === void 0 ? void 0 : _a.key;
+                const sessionId = this.constructSessionId(userId, clientId, domain);
+                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);
+                }
+            }
+        }
+        return { encrypted, missing };
+    }
+    async encryptPayloadForSession(sessionId, plainText, base64EncodedPreKey) {
+        this.logger.log(`Encrypting payload for session ID "${sessionId}"`);
+        let encryptedPayload;
+        try {
+            const decodedPreKeyBundle = base64EncodedPreKey
+                ? bazinga64_1.Decoder.fromBase64(base64EncodedPreKey).asBytes.buffer
+                : undefined;
+            const payloadAsArrayBuffer = await this.cryptobox.encrypt(sessionId, plainText, decodedPreKeyBundle);
+            encryptedPayload = new Uint8Array(payloadAsArrayBuffer);
+        }
+        catch (error) {
+            const notFoundErrorCode = 2;
+            if (error.code === notFoundErrorCode) {
+                // If the session is not in the database, we just return undefined. Later on there will be a mismatch and the session will be created
+                return undefined;
+            }
+            this.logger.error(`Could not encrypt payload: ${error.message}`);
+            encryptedPayload = new Uint8Array(Buffer.from('💣', 'utf-8'));
+        }
+        return { encryptedPayload, sessionId };
+    }
+    async initCryptobox() {
+        await this.cryptobox.load();
+    }
+    deleteCryptographyStores() {
+        return this.database.deleteStores();
+    }
+    async resetSession(sessionId) {
+        await this.cryptobox.session_delete(sessionId);
+        this.logger.log(`Deleted session ID "${sessionId}".`);
+    }
+    async decryptMessage(otrMessage) {
+        const { from, qualified_from, data: { sender, text: cipherText }, } = otrMessage;
+        const sessionId = this.constructSessionId(from, sender, qualified_from === null || qualified_from === void 0 ? void 0 : qualified_from.domain);
+        try {
+            const decryptedMessage = await this.decrypt(sessionId, cipherText);
+            return protocol_messaging_1.GenericMessage.decode(decryptedMessage);
+        }
+        catch (error) {
+            throw this.generateDecryptionError(otrMessage, error);
+        }
+    }
+    mapGenericMessage(otrMessage, genericMessage, source) {
+        if (genericMessage.content === conversation_1.GenericMessageType.EPHEMERAL) {
+            const unwrappedMessage = GenericMessageMapper_1.GenericMessageMapper.mapGenericMessage(genericMessage.ephemeral, otrMessage, source);
+            unwrappedMessage.id = genericMessage.messageId;
+            if (genericMessage.ephemeral) {
+                const expireAfterMillis = genericMessage.ephemeral.expireAfterMillis;
+                unwrappedMessage.messageTimer =
+                    typeof expireAfterMillis === 'number' ? expireAfterMillis : expireAfterMillis.toNumber();
+            }
+            return unwrappedMessage;
+        }
+        return GenericMessageMapper_1.GenericMessageMapper.mapGenericMessage(genericMessage, otrMessage, source);
+    }
+    generateDecryptionError(event, error) {
+        var _a;
+        const errorCode = (_a = error.code) !== null && _a !== void 0 ? _a : 999;
+        let message = 'Unknown decryption error';
+        const { data: eventData, from: remoteUserId, time: formattedTime } = event;
+        const remoteClientId = eventData.sender;
+        const isDuplicateMessage = error instanceof proteus_1.errors.DecryptError.DuplicateMessage;
+        const isOutdatedMessage = error instanceof proteus_1.errors.DecryptError.OutdatedMessage;
+        // We don't need to show these message errors to the user
+        if (isDuplicateMessage || isOutdatedMessage) {
+            message = `Message from user ID "${remoteUserId}" at "${formattedTime}" will not be handled because it is outdated or a duplicate.`;
+        }
+        const isInvalidMessage = error instanceof proteus_1.errors.DecryptError.InvalidMessage;
+        const isInvalidSignature = error instanceof proteus_1.errors.DecryptError.InvalidSignature;
+        const isRemoteIdentityChanged = error instanceof proteus_1.errors.DecryptError.RemoteIdentityChanged;
+        // Session is broken, let's see what's really causing it...
+        if (isInvalidMessage || isInvalidSignature) {
+            message = `Session with user '${remoteUserId}' (${remoteClientId}) is broken.\nReset the session for possible fix.`;
+        }
+        else if (isRemoteIdentityChanged) {
+            message = `Remote identity of client '${remoteClientId}' from user '${remoteUserId}' changed`;
+        }
+        this.logger.warn(`Failed to decrypt event from client '${remoteClientId}' of user '${remoteUserId}' (${formattedTime}).\nError Code: '${errorCode}'\nError Message: ${error.message}`, error);
+        return { code: errorCode, message };
+    }
+}
+exports.CryptographyService = CryptographyService;
+//# sourceMappingURL=CryptographyService.js.map

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

@@ -0,0 +1,6 @@
+import { ConversationOtrMessageAddEvent } from '@wireapp/api-client/src/event/';
+import { PayloadBundle, PayloadBundleSource } from '../conversation';
+export declare class GenericMessageMapper {
+    private static readonly logger;
+    static mapGenericMessage(genericMessage: any, event: ConversationOtrMessageAddEvent, source: PayloadBundleSource): PayloadBundle;
+}

package/src/main/cryptography/GenericMessageMapper.js

@@ -0,0 +1,160 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2019 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericMessageMapper = void 0;
+const logdown_1 = __importDefault(require("logdown"));
+const conversation_1 = require("../conversation");
+class GenericMessageMapper {
+    // TODO: Turn "any" into a specific type (or collection of types) and make the return type more specific based on the
+    // "genericMessage" input parameter.
+    static mapGenericMessage(genericMessage, event, source) {
+        const baseMessage = {
+            conversation: event.conversation,
+            qualifiedConversation: event.qualified_conversation,
+            qualifiedFrom: event.qualified_from,
+            fromClientId: event.data.sender,
+            from: event.from,
+            state: conversation_1.PayloadBundleState.INCOMING,
+            timestamp: new Date(event.time).getTime(),
+            id: genericMessage.messageId,
+            messageTimer: 0,
+            source,
+        };
+        switch (genericMessage.content) {
+            case conversation_1.GenericMessageType.TEXT: {
+                const { content: text, expectsReadConfirmation, legalHoldStatus, linkPreview: linkPreviews, mentions, quote, } = genericMessage[conversation_1.GenericMessageType.TEXT];
+                const content = { expectsReadConfirmation, legalHoldStatus, text };
+                if (linkPreviews === null || linkPreviews === void 0 ? void 0 : linkPreviews.length) {
+                    content.linkPreviews = linkPreviews;
+                }
+                if (mentions === null || mentions === void 0 ? void 0 : mentions.length) {
+                    content.mentions = mentions;
+                }
+                if (quote) {
+                    content.quote = quote;
+                }
+                if (typeof legalHoldStatus !== 'undefined') {
+                    content.legalHoldStatus = legalHoldStatus;
+                }
+                return Object.assign(Object.assign({}, baseMessage), { content, type: conversation_1.PayloadBundleType.TEXT });
+            }
+            case conversation_1.GenericMessageType.BUTTON_ACTION: {
+                return Object.assign(Object.assign({}, baseMessage), { content: genericMessage.buttonAction, type: conversation_1.PayloadBundleType.BUTTON_ACTION });
+            }
+            case conversation_1.GenericMessageType.CALLING: {
+                return Object.assign(Object.assign({}, baseMessage), { content: genericMessage.calling.content, type: conversation_1.PayloadBundleType.CALL });
+            }
+            case conversation_1.GenericMessageType.CONFIRMATION: {
+                const { firstMessageId, moreMessageIds, type } = genericMessage[conversation_1.GenericMessageType.CONFIRMATION];
+                const content = { firstMessageId, moreMessageIds, type };
+                return Object.assign(Object.assign({}, baseMessage), { content, type: conversation_1.PayloadBundleType.CONFIRMATION });
+            }
+            case conversation_1.GenericMessageType.CLEARED: {
+                const content = genericMessage[conversation_1.GenericMessageType.CLEARED];
+                return Object.assign(Object.assign({}, baseMessage), { content, type: conversation_1.PayloadBundleType.CONVERSATION_CLEAR });
+            }
+            case conversation_1.GenericMessageType.DELETED: {
+                const originalMessageId = genericMessage[conversation_1.GenericMessageType.DELETED].messageId;
+                const content = { messageId: originalMessageId };
+                return Object.assign(Object.assign({}, baseMessage), { content, type: conversation_1.PayloadBundleType.MESSAGE_DELETE });
+            }
+            case conversation_1.GenericMessageType.EDITED: {
+                const { expectsReadConfirmation, text: { content: editedText, legalHoldStatus, linkPreview: editedLinkPreviews, mentions: editedMentions, quote: editedQuote, }, replacingMessageId, } = genericMessage[conversation_1.GenericMessageType.EDITED];
+                const content = {
+                    expectsReadConfirmation,
+                    legalHoldStatus,
+                    originalMessageId: replacingMessageId,
+                    text: editedText,
+                };
+                if (editedLinkPreviews === null || editedLinkPreviews === void 0 ? void 0 : editedLinkPreviews.length) {
+                    content.linkPreviews = editedLinkPreviews;
+                }
+                if (editedMentions === null || editedMentions === void 0 ? void 0 : editedMentions.length) {
+                    content.mentions = editedMentions;
+                }
+                if (editedQuote) {
+                    content.quote = editedQuote;
+                }
+                return Object.assign(Object.assign({}, baseMessage), { content, type: conversation_1.PayloadBundleType.MESSAGE_EDIT });
+            }
+            case conversation_1.GenericMessageType.HIDDEN: {
+                const { conversationId, messageId } = genericMessage[conversation_1.GenericMessageType.HIDDEN];
+                const content = {
+                    conversationId,
+                    messageId,
+                };
+                return Object.assign(Object.assign({}, baseMessage), { content, type: conversation_1.PayloadBundleType.MESSAGE_HIDE });
+            }
+            case conversation_1.GenericMessageType.KNOCK: {
+                const { expectsReadConfirmation, legalHoldStatus } = genericMessage[conversation_1.GenericMessageType.KNOCK];
+                const content = { expectsReadConfirmation, hotKnock: false, legalHoldStatus };
+                return Object.assign(Object.assign({}, baseMessage), { content, type: conversation_1.PayloadBundleType.PING });
+            }
+            case conversation_1.GenericMessageType.LOCATION: {
+                const { expectsReadConfirmation, latitude, legalHoldStatus, longitude, name, zoom } = genericMessage[conversation_1.GenericMessageType.LOCATION];
+                const content = {
+                    expectsReadConfirmation,
+                    latitude,
+                    legalHoldStatus,
+                    longitude,
+                    name,
+                    zoom,
+                };
+                return Object.assign(Object.assign({}, baseMessage), { content, type: conversation_1.PayloadBundleType.LOCATION });
+            }
+            case conversation_1.GenericMessageType.ASSET: {
+                const { expectsReadConfirmation, legalHoldStatus, notUploaded, original, preview, status, uploaded } = genericMessage[conversation_1.GenericMessageType.ASSET];
+                const isImage = !!(uploaded === null || uploaded === void 0 ? void 0 : uploaded.assetId) && !!(original === null || original === void 0 ? void 0 : original.image);
+                const content = {
+                    abortReason: notUploaded,
+                    expectsReadConfirmation,
+                    legalHoldStatus,
+                    original,
+                    preview,
+                    status,
+                    uploaded,
+                };
+                return Object.assign(Object.assign({}, baseMessage), { content, type: isImage ? conversation_1.PayloadBundleType.ASSET_IMAGE : conversation_1.PayloadBundleType.ASSET });
+            }
+            case conversation_1.GenericMessageType.REACTION: {
+                const { emoji, legalHoldStatus, messageId } = genericMessage[conversation_1.GenericMessageType.REACTION];
+                const content = {
+                    legalHoldStatus,
+                    originalMessageId: messageId,
+                    type: emoji,
+                };
+                return Object.assign(Object.assign({}, baseMessage), { content, type: conversation_1.PayloadBundleType.REACTION });
+            }
+            default: {
+                this.logger.warn(`Unhandled event type "${genericMessage.content}": ${JSON.stringify(genericMessage)}`);
+                return Object.assign(Object.assign({}, baseMessage), { content: genericMessage.content, type: conversation_1.PayloadBundleType.UNKNOWN });
+            }
+        }
+    }
+}
+exports.GenericMessageMapper = GenericMessageMapper;
+GenericMessageMapper.logger = (0, logdown_1.default)('@wireapp/core/cryptography/GenericMessageMapper', {
+    logger: console,
+    markdown: false,
+});
+//# sourceMappingURL=GenericMessageMapper.js.map

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

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { AssetContent, LocationContent, TextContent } from '../conversation/content';
+export declare type AvailableMessageContent = AssetContent | LocationContent | TextContent;
+export declare class MessageHashService {
+    private readonly messageContent;
+    private readonly timestamp;
+    constructor(messageContent: AvailableMessageContent, timestamp?: number);
+    private createSha256Hash;
+    private convertToUtf16BE;
+    private getAssetBytes;
+    private getTimestampBuffer;
+    private getLocationBytes;
+    private getTextBytes;
+    private getBytes;
+    getHash(): Buffer;
+}