@wireapp/core 38.8.2 → 38.8.3

package/lib/messagingProtocols/proteus/ProteusService/ProteusService.mocks.d.ts

@@ -1,8 +1,8 @@
 import { APIClient } from '@wireapp/api-client';
-import { CoreCrypto } from '@wireapp/core-crypto';
+import { CryptoClient } from './CryptoClient';
 import { ProteusService } from './ProteusService';
 export declare const buildProteusService: (federated?: boolean) => Promise<[ProteusService, {
     apiClient: APIClient;
-    coreCrypto: CoreCrypto;
+    cryptoClient: CryptoClient;
 }]>;
 //# sourceMappingURL=ProteusService.mocks.d.ts.map

package/lib/messagingProtocols/proteus/ProteusService/ProteusService.mocks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProteusService.mocks.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/ProteusService/ProteusService.mocks.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAC,UAAU,EAAC,MAAM,sBAAsB,CAAC;AAGhD,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAC;AAIhD,eAAO,MAAM,mBAAmB;eAEQ,SAAS;gBAAc,UAAU;GAgBxE,CAAC"}
+{"version":3,"file":"ProteusService.mocks.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/ProteusService/ProteusService.mocks.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAE9C,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAE5C,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAC;AAIhD,eAAO,MAAM,mBAAmB;eAEQ,SAAS;kBAAgB,YAAY;GAgB5E,CAAC"}

package/lib/messagingProtocols/proteus/ProteusService/ProteusService.mocks.js

@@ -21,7 +21,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildProteusService = void 0;
 const client_1 = require("@wireapp/api-client/lib/client");
 const api_client_1 = require("@wireapp/api-client");
-const core_crypto_1 = require("@wireapp/core-crypto");
 const CoreCryptoWrapper_1 = require("./CryptoClient/CoreCryptoWrapper");
 const ProteusService_1 = require("./ProteusService");
 const PayloadHelper_1 = require("../../../test/PayloadHelper");
@@ -32,11 +31,11 @@ const buildProteusService = async (federated = false) => {
         userId: (0, PayloadHelper_1.getUUID)(),
         clientId: (0, PayloadHelper_1.getUUID)(),
     };
-    const coreCrypto = await core_crypto_1.CoreCrypto.deferredInit('store-name', 'key');
-    const proteusService = new ProteusService_1.ProteusService(apiClient, new CoreCryptoWrapper_1.CoreCryptoWrapper(coreCrypto, {}, {}), {
+    const cryptoClient = new CoreCryptoWrapper_1.CoreCryptoWrapper({}, {}, {});
+    const proteusService = new ProteusService_1.ProteusService(apiClient, cryptoClient, {
         nbPrekeys: 0,
         useQualifiedIds: federated,
     });
-    return [proteusService, { apiClient, coreCrypto }];
+    return [proteusService, { apiClient, cryptoClient }];
 };
 exports.buildProteusService = buildProteusService;

package/lib/messagingProtocols/proteus/ProteusService/ProteusService.test.js

@@ -65,7 +65,7 @@ jest.mock('./CryptoClient/PrekeysTracker', () => {
 jest.mock('../Utility/Recipients', () => (Object.assign(Object.assign({}, jest.requireActual('../Utility/Recipients')), { getRecipientsForConversation: jest.fn(), getQualifiedRecipientsForConversation: jest.fn() })));
 const MockedRecipients = Recipients;
 const prepareDataForEncryption = async (useQualifiedIds = true) => {
-    const [proteusService, { coreCrypto, apiClient }] = await (0, ProteusService_mocks_1.buildProteusService)(useQualifiedIds);
+    const [proteusService, { cryptoClient, apiClient }] = await (0, ProteusService_mocks_1.buildProteusService)(useQualifiedIds);
     const domain = 'staging.zinfra.io';
     //user 1
     const firstUserId = 'bc0c99f1-49a5-4ad2-889a-62885af37088';
@@ -88,7 +88,7 @@ const prepareDataForEncryption = async (useQualifiedIds = true) => {
     //user 2
     const secondUserId = 'cd0c88f1-49a5-4ar2-889a-62885af37069';
     //user 2 client
-    const thirdClientId = 'be67218b77d02d69';
+    const thirdClientId = 'ce67218b77d02d69';
     //user 2 sessions
     const secondClientSessionId = (0, SessionHandler_1.constructSessionId)({
         userId: secondUserId,
@@ -107,7 +107,7 @@ const prepareDataForEncryption = async (useQualifiedIds = true) => {
         key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
     };
     return {
-        services: { proteusService, apiClient, coreCryptoClient: coreCrypto },
+        services: { proteusService, apiClient, cryptoClient },
         data: {
             firstUser: {
                 id: firstUserId,
@@ -130,29 +130,35 @@ const prepareDataForEncryption = async (useQualifiedIds = true) => {
 describe('ProteusService', () => {
     describe('getRemoteFingerprint', () => {
         it('create a session if session does not exists', async () => {
-            const [proteusService, { apiClient, coreCrypto }] = await (0, ProteusService_mocks_1.buildProteusService)();
+            const [proteusService, { apiClient, cryptoClient }] = await (0, ProteusService_mocks_1.buildProteusService)();
             const expectedFingerprint = 'fingerprint-client1';
-            const getPrekeyMock = jest.spyOn(apiClient.api.user, 'getClientPreKey').mockResolvedValue({
-                client: 'client1',
-                prekey: {
-                    id: 123,
-                    key: 'pQABARhIAqEAWCCaJpFa9c626ORmjj1aV6OnOYgmTjfoiE3ynOfNfGAOmgOhAKEAWCD60VMzRrLfO+1GSjgyhnVp2N7L58DM+eeJhZJi1tBLfQT2',
-                },
-            });
-            jest.spyOn(coreCrypto, 'proteusFingerprintRemote').mockResolvedValue(expectedFingerprint);
-            jest.spyOn(coreCrypto, 'proteusSessionExists').mockResolvedValue(false);
             const userId = { id: 'user1', domain: 'domain.com' };
             const clientId = 'client1';
+            jest.spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles').mockResolvedValue({
+                [userId.domain]: {
+                    [userId.id]: {
+                        [clientId]: {
+                            id: 123,
+                            key: 'pQABARhIAqEAWCCaJpFa9c626ORmjj1aV6OnOYgmTjfoiE3ynOfNfGAOmgOhAKEAWCD60VMzRrLfO+1GSjgyhnVp2N7L58DM+eeJhZJi1tBLfQT2',
+                        },
+                    },
+                },
+            });
+            jest.spyOn(cryptoClient, 'getRemoteFingerprint').mockResolvedValue(expectedFingerprint);
+            jest.spyOn(cryptoClient, 'sessionFromPrekey').mockResolvedValue(undefined);
+            jest.spyOn(cryptoClient, 'saveSession').mockResolvedValue(undefined);
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(false);
             const result = await proteusService.getRemoteFingerprint(userId, clientId);
-            expect(getPrekeyMock).toHaveBeenCalledWith(userId, clientId);
             expect(result).toBe(expectedFingerprint);
         });
         it('create a session from given prekey if session does not exists', async () => {
-            const [proteusService, { apiClient, coreCrypto }] = await (0, ProteusService_mocks_1.buildProteusService)();
+            const [proteusService, { apiClient, cryptoClient }] = await (0, ProteusService_mocks_1.buildProteusService)();
             const expectedFingerprint = 'fingerprint-client1';
             const getPrekeyMock = jest.spyOn(apiClient.api.user, 'getClientPreKey');
-            jest.spyOn(coreCrypto, 'proteusFingerprintRemote').mockResolvedValue(expectedFingerprint);
-            jest.spyOn(coreCrypto, 'proteusSessionExists').mockResolvedValue(false);
+            jest.spyOn(cryptoClient, 'getRemoteFingerprint').mockResolvedValue(expectedFingerprint);
+            jest.spyOn(cryptoClient, 'sessionFromPrekey').mockResolvedValue(undefined);
+            jest.spyOn(cryptoClient, 'saveSession').mockResolvedValue(undefined);
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(false);
             const userId = { id: 'user1', domain: 'domain.com' };
             const clientId = 'client1';
             const result = await proteusService.getRemoteFingerprint(userId, clientId, {
@@ -163,12 +169,12 @@ describe('ProteusService', () => {
             expect(result).toBe(expectedFingerprint);
         });
         it('returns the fingerprint from existing session', async () => {
-            const [proteusService, { apiClient, coreCrypto }] = await (0, ProteusService_mocks_1.buildProteusService)();
+            const [proteusService, { apiClient, cryptoClient }] = await (0, ProteusService_mocks_1.buildProteusService)();
             const expectedFingerprint = 'fingerprint-client1';
             const getPrekeyMock = jest.spyOn(apiClient.api.user, 'getClientPreKey');
-            const sessionFromPrekeyMock = jest.spyOn(coreCrypto, 'proteusSessionFromPrekey');
-            jest.spyOn(coreCrypto, 'proteusFingerprintRemote').mockResolvedValue(expectedFingerprint);
-            jest.spyOn(coreCrypto, 'proteusSessionExists').mockResolvedValue(true);
+            const sessionFromPrekeyMock = jest.spyOn(cryptoClient, 'sessionFromPrekey');
+            jest.spyOn(cryptoClient, 'getRemoteFingerprint').mockResolvedValue(expectedFingerprint);
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(true);
             const userId = { id: 'user1', domain: 'domain.com' };
             const clientId = 'client1';
             const result = await proteusService.getRemoteFingerprint(userId, clientId);
@@ -188,9 +194,10 @@ describe('ProteusService', () => {
         };
         const decryptedMessage = {};
         it('decrypts incoming proteus encrypted events when session already exists', async () => {
-            const [proteusService, { coreCrypto }] = await (0, ProteusService_mocks_1.buildProteusService)();
-            jest.spyOn(coreCrypto, 'proteusSessionExists').mockResolvedValue(true);
-            const createSessionSpy = jest.spyOn(coreCrypto, 'proteusSessionFromMessage');
+            const [proteusService, { cryptoClient }] = await (0, ProteusService_mocks_1.buildProteusService)();
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(true);
+            const createSessionSpy = jest.spyOn(cryptoClient, 'sessionFromMessage');
+            jest.spyOn(cryptoClient, 'decrypt').mockResolvedValue(new Uint8Array());
             jest.spyOn(protocol_messaging_1.GenericMessage, 'decode').mockReturnValue(decryptedMessage);
             const result = await proteusService.handleEvent(eventPayload);
             expect(result).toBeDefined();
@@ -198,10 +205,11 @@ describe('ProteusService', () => {
             expect(result === null || result === void 0 ? void 0 : result.decryptedData).toBe(decryptedMessage);
         });
         it('decrypts incoming proteus encrypted and creates session if not already existing', async () => {
-            const [proteusService, { coreCrypto }] = await (0, ProteusService_mocks_1.buildProteusService)();
-            jest.spyOn(coreCrypto, 'proteusSessionExists').mockResolvedValue(false);
-            const createSessionSpy = jest.spyOn(coreCrypto, 'proteusSessionFromMessage');
-            const decryptSpy = jest.spyOn(coreCrypto, 'proteusDecrypt');
+            const [proteusService, { cryptoClient }] = await (0, ProteusService_mocks_1.buildProteusService)();
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(false);
+            jest.spyOn(cryptoClient, 'saveSession').mockResolvedValue(undefined);
+            const createSessionSpy = jest.spyOn(cryptoClient, 'sessionFromMessage').mockResolvedValue(new Uint8Array());
+            const decryptSpy = jest.spyOn(cryptoClient, 'decrypt');
             jest.spyOn(protocol_messaging_1.GenericMessage, 'decode').mockReturnValue(decryptedMessage);
             const result = await proteusService.handleEvent(eventPayload);
             expect(result).toBeDefined();
@@ -212,28 +220,18 @@ describe('ProteusService', () => {
     });
     describe('"encrypt"', () => {
         it('returns encrypted payload', async () => {
-            const { services, data: { firstUser, validPreKey, encryptedMessageBuffer, messageBuffer }, } = await prepareDataForEncryption(false);
+            const { services, data: { firstUser, encryptedMessageBuffer, messageBuffer }, } = await prepareDataForEncryption(false);
             const userClients = {
                 [firstUser.id]: [firstUser.clients.first, firstUser.clients.second],
             };
-            const preKeyBundleMap = {
-                [firstUser.id]: {
-                    [firstUser.clients.first]: validPreKey,
-                    [firstUser.clients.second]: validPreKey,
-                },
-            };
             const encryptedPayload = new Map([
                 [firstUser.sessions.first, encryptedMessageBuffer],
                 [firstUser.sessions.second, encryptedMessageBuffer],
             ]);
-            jest
-                .spyOn(services.apiClient.api.user, 'postMultiPreKeyBundles')
-                .mockImplementationOnce(() => Promise.resolve(preKeyBundleMap));
-            jest
-                .spyOn(services.coreCryptoClient, 'proteusEncryptBatched')
-                .mockImplementationOnce(() => Promise.resolve(encryptedPayload));
+            jest.spyOn(services.cryptoClient, 'sessionExists').mockResolvedValue(true);
+            jest.spyOn(services.cryptoClient, 'encrypt').mockImplementationOnce(() => Promise.resolve(encryptedPayload));
             const encrypted = await services.proteusService.encrypt(messageBuffer, userClients);
-            expect(services.coreCryptoClient.proteusEncryptBatched).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second], messageBuffer);
+            expect(services.cryptoClient.encrypt).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second], messageBuffer);
             expect(encrypted).toEqual({
                 [firstUser.id]: {
                     [firstUser.clients.first]: encryptedMessageBuffer,
@@ -242,33 +240,20 @@ describe('ProteusService', () => {
             });
         });
         it('returns encrypted payload for multiple users', async () => {
-            const { services, data: { firstUser, secondUser, validPreKey, encryptedMessageBuffer, messageBuffer }, } = await prepareDataForEncryption(false);
+            const { services, data: { firstUser, secondUser, encryptedMessageBuffer, messageBuffer }, } = await prepareDataForEncryption(false);
             const userClients = {
                 [firstUser.id]: [firstUser.clients.first, firstUser.clients.second],
                 [secondUser.id]: [secondUser.clients.first],
             };
-            const preKeyBundleMap = {
-                [firstUser.id]: {
-                    [firstUser.clients.first]: validPreKey,
-                    [firstUser.clients.second]: null,
-                },
-                [secondUser.id]: {
-                    [secondUser.clients.first]: validPreKey,
-                },
-            };
             const encryptedPayload = new Map([
                 [firstUser.sessions.first, encryptedMessageBuffer],
                 [firstUser.sessions.second, encryptedMessageBuffer],
                 [secondUser.sessions.first, encryptedMessageBuffer],
             ]);
-            jest
-                .spyOn(services.apiClient.api.user, 'postMultiPreKeyBundles')
-                .mockImplementationOnce(() => Promise.resolve(preKeyBundleMap));
-            jest
-                .spyOn(services.coreCryptoClient, 'proteusEncryptBatched')
-                .mockImplementationOnce(() => Promise.resolve(encryptedPayload));
+            jest.spyOn(services.cryptoClient, 'sessionExists').mockResolvedValue(true);
+            jest.spyOn(services.cryptoClient, 'encrypt').mockResolvedValueOnce(encryptedPayload);
             const encrypted = await services.proteusService.encrypt(messageBuffer, userClients);
-            expect(services.coreCryptoClient.proteusEncryptBatched).toHaveBeenCalledWith([firstUser.sessions.first, secondUser.sessions.first], messageBuffer);
+            expect(services.cryptoClient.encrypt).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second, secondUser.sessions.first], messageBuffer);
             expect(encrypted).toEqual({
                 [firstUser.id]: {
                     [firstUser.clients.first]: encryptedMessageBuffer,
@@ -282,33 +267,21 @@ describe('ProteusService', () => {
     });
     describe('"encryptQualified"', () => {
         it('returns encrypted payload', async () => {
-            const { services, data: { firstUser, validPreKey, encryptedMessageBuffer, messageBuffer, domain }, } = await prepareDataForEncryption();
+            const { services, data: { firstUser, encryptedMessageBuffer, messageBuffer, domain }, } = await prepareDataForEncryption();
             const userClients = {
                 [domain]: {
                     [firstUser.id]: [firstUser.clients.first, firstUser.clients.second],
                 },
             };
-            const preKeyBundleMap = {
-                [domain]: {
-                    [firstUser.id]: {
-                        [firstUser.clients.first]: validPreKey,
-                        [firstUser.clients.second]: validPreKey,
-                    },
-                },
-            };
             const encryptedPayload = new Map([
                 [firstUser.sessions.first, encryptedMessageBuffer],
                 [firstUser.sessions.second, encryptedMessageBuffer],
             ]);
-            jest
-                .spyOn(services.apiClient.api.user, 'postQualifiedMultiPreKeyBundles')
-                .mockImplementationOnce(() => Promise.resolve(preKeyBundleMap));
-            jest
-                .spyOn(services.coreCryptoClient, 'proteusEncryptBatched')
-                .mockImplementationOnce(() => Promise.resolve(encryptedPayload));
+            jest.spyOn(services.cryptoClient, 'sessionExists').mockResolvedValue(true);
+            jest.spyOn(services.cryptoClient, 'encrypt').mockResolvedValueOnce(encryptedPayload);
             const encrypted = await services.proteusService.encryptQualified(messageBuffer, userClients);
             // console.log({encrypted, missing});
-            expect(services.coreCryptoClient.proteusEncryptBatched).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second], messageBuffer);
+            expect(services.cryptoClient.encrypt).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second], messageBuffer);
             expect(encrypted).toEqual({
                 [domain]: {
                     [firstUser.id]: {
@@ -319,40 +292,27 @@ describe('ProteusService', () => {
             });
         });
         it('returns missing clients and encrypted payload for multiple users', async () => {
-            const { services, data: { firstUser, secondUser, validPreKey, encryptedMessageBuffer, messageBuffer, domain }, } = await prepareDataForEncryption();
+            const { services, data: { firstUser, secondUser, encryptedMessageBuffer, messageBuffer, domain }, } = await prepareDataForEncryption();
             const userClients = {
                 [domain]: {
                     [firstUser.id]: [firstUser.clients.first, firstUser.clients.second],
                     [secondUser.id]: [secondUser.clients.first],
                 },
             };
-            const preKeyBundleMap = {
-                [domain]: {
-                    [firstUser.id]: {
-                        [firstUser.clients.first]: validPreKey,
-                        [firstUser.clients.second]: null,
-                    },
-                    [secondUser.id]: {
-                        [secondUser.clients.first]: validPreKey,
-                    },
-                },
-            };
             const encryptedPayload = new Map([
                 [firstUser.sessions.first, encryptedMessageBuffer],
+                [firstUser.sessions.second, encryptedMessageBuffer],
                 [secondUser.sessions.first, encryptedMessageBuffer],
             ]);
-            jest
-                .spyOn(services.apiClient.api.user, 'postQualifiedMultiPreKeyBundles')
-                .mockImplementationOnce(() => Promise.resolve(preKeyBundleMap));
-            jest
-                .spyOn(services.coreCryptoClient, 'proteusEncryptBatched')
-                .mockImplementationOnce(() => Promise.resolve(encryptedPayload));
+            jest.spyOn(services.cryptoClient, 'sessionExists').mockResolvedValue(true);
+            jest.spyOn(services.cryptoClient, 'encrypt').mockResolvedValueOnce(encryptedPayload);
             const encrypted = await services.proteusService.encryptQualified(messageBuffer, userClients);
-            expect(services.coreCryptoClient.proteusEncryptBatched).toHaveBeenCalledWith([firstUser.sessions.first, secondUser.sessions.first], messageBuffer);
+            expect(services.cryptoClient.encrypt).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second, secondUser.sessions.first], messageBuffer);
             expect(encrypted).toEqual({
                 [domain]: {
                     [firstUser.id]: {
                         [firstUser.clients.first]: encryptedMessageBuffer,
+                        [firstUser.clients.second]: encryptedMessageBuffer,
                     },
                     [secondUser.id]: {
                         [secondUser.clients.first]: encryptedMessageBuffer,

package/lib/messagingProtocols/proteus/Utility/SessionHandler/SessionHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SessionHandler.d.ts","sourceRoot":"","sources":["../../../../../src/messagingProtocols/proteus/Utility/SessionHandler/SessionHandler.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,MAAM,EAAC,MAAM,8BAA8B,CAAC;AACpD,OAAO,EAAC,WAAW,EAAC,MAAM,sCAAsC,CAAC;AACjE,OAAO,EAAC,WAAW,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AAE9E,OAAO,EAAC,MAAM,EAAC,MAAM,SAAS,CAAC;AAE/B,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAK9C,OAAO,EAAC,YAAY,EAAC,MAAM,mCAAmC,CAAC;AAE/D,UAAU,wBAAwB;IAChC,MAAM,EAAE,MAAM,GAAG,WAAW,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,QAAA,MAAM,kBAAkB,kDAAiD,wBAAwB,KAAG,MAKnG,CAAC;AA2GF;;;GAGG;AACH,QAAA,MAAM,WAAW;YAC6B,WAAW;cAAY,MAAM;;;eAClC,SAAS;kBAAgB,YAAY;MAC3E,QAAQ,MAAM,CAYhB,CAAC;AAyBF,UAAU,wCAAwC;IAChD,UAAU,EAAE,WAAW,GAAG,mBAAmB,CAAC;IAC9C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,QAAA,MAAM,YAAY,6DAMf,wCAAwC,KAAG,QAAQ,MAAM,EAAE,CAgC7D,CAAC;AAEF,UAAU,mBAAmB;IAC3B,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,YAAY,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;CAC1B;AACD,iBAAe,aAAa,CAAC,MAAM,EAAE,mBAAmB,iBAGvD;AA+CD,KAAK,iBAAiB,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;AAC9D;;GAEG;AACH,QAAA,MAAM,sBAAsB,uDAO3B,CAAC;AAEF,OAAO,EAAC,kBAAkB,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAC,CAAC"}
+{"version":3,"file":"SessionHandler.d.ts","sourceRoot":"","sources":["../../../../../src/messagingProtocols/proteus/Utility/SessionHandler/SessionHandler.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,MAAM,EAAC,MAAM,8BAA8B,CAAC;AACpD,OAAO,EAAC,WAAW,EAAC,MAAM,sCAAsC,CAAC;AACjE,OAAO,EAAC,WAAW,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AAE9E,OAAO,EAAC,MAAM,EAAC,MAAM,SAAS,CAAC;AAE/B,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAK9C,OAAO,EAAC,YAAY,EAAC,MAAM,mCAAmC,CAAC;AAE/D,UAAU,wBAAwB;IAChC,MAAM,EAAE,MAAM,GAAG,WAAW,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,QAAA,MAAM,kBAAkB,kDAAiD,wBAAwB,KAAG,MAKnG,CAAC;AAuFF;;;GAGG;AACH,QAAA,MAAM,WAAW;YAC6B,WAAW;cAAY,MAAM;;;eAClC,SAAS;kBAAgB,YAAY;MAC3E,QAAQ,MAAM,CAmBhB,CAAC;AAyBF,UAAU,wCAAwC;IAChD,UAAU,EAAE,WAAW,GAAG,mBAAmB,CAAC;IAC9C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,QAAA,MAAM,YAAY,6DAMf,wCAAwC,KAAG,QAAQ,MAAM,EAAE,CAgC7D,CAAC;AAEF,UAAU,mBAAmB;IAC3B,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,YAAY,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;CAC1B;AACD,iBAAe,aAAa,CAAC,MAAM,EAAE,mBAAmB,iBAGvD;AA+CD,KAAK,iBAAiB,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;AAC9D;;GAEG;AACH,QAAA,MAAM,sBAAsB,uDAO3B,CAAC;AAEF,OAAO,EAAC,kBAAkB,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAC,CAAC"}

package/lib/messagingProtocols/proteus/Utility/SessionHandler/SessionHandler.js

@@ -43,13 +43,6 @@ const parseSessionId = (sessionId) => {
     }
     return match.groups;
 };
-const createSession = async ({ sessionId, initialPrekey, cryptoClient, apiClient, }) => {
-    const { userId, clientId, domain } = parseSessionId(sessionId);
-    const prekey = initialPrekey !== null && initialPrekey !== void 0 ? initialPrekey : (await apiClient.api.user.getClientPreKey({ id: userId, domain: domain !== null && domain !== void 0 ? domain : '' }, clientId)).prekey;
-    const prekeyBuffer = bazinga64_1.Decoder.fromBase64(prekey.key).asBytes;
-    await cryptoClient.sessionFromPrekey(sessionId, prekeyBuffer);
-    await cryptoClient.saveSession(sessionId);
-};
 const createLegacySessions = async ({ userClients, apiClient, cryptoClient, logger, }) => {
     const preKeyBundleMap = await apiClient.api.user.postMultiPreKeyBundles(userClients);
     const sessions = await createSessionsFromPreKeys({
@@ -87,15 +80,22 @@ const createQualifiedSessions = async ({ userClientMap, domain, apiClient, crypt
 const initSession = async ({ userId, clientId, initialPrekey }, { cryptoClient, apiClient }) => {
     const sessionId = constructSessionId({ userId, clientId, useQualifiedIds: !!userId.domain });
     const sessionExists = await cryptoClient.sessionExists(sessionId);
-    if (!sessionExists) {
-        await createSession({
-            sessionId,
-            initialPrekey,
-            apiClient: apiClient,
-            cryptoClient,
-        });
+    if (sessionExists) {
+        return sessionId;
+    }
+    if (initialPrekey) {
+        const prekeyBuffer = bazinga64_1.Decoder.fromBase64(initialPrekey.key).asBytes;
+        await cryptoClient.sessionFromPrekey(sessionId, prekeyBuffer);
+        await cryptoClient.saveSession(sessionId);
+        return sessionId;
     }
-    return sessionId;
+    const sessions = await initSessions({
+        recipients: { [userId.id]: [clientId] },
+        domain: userId.domain,
+        apiClient,
+        cryptoClient,
+    });
+    return sessions[0];
 };
 exports.initSession = initSession;
 /**

package/lib/messagingProtocols/proteus/Utility/SessionHandler/SessionHandler.test.js

@@ -18,10 +18,28 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+const api_client_1 = require("@wireapp/api-client");
 const SessionHandler_1 = require("./SessionHandler");
-const CoreCryptoWrapper_1 = require("../../ProteusService/CryptoClient/CoreCryptoWrapper");
-const ProteusService_mocks_1 = require("../../ProteusService/ProteusService.mocks");
+function generatePrekeys(userId, clientIds) {
+    const clients = clientIds.reduce((prekeys, clientId, index) => {
+        return Object.assign(Object.assign({}, prekeys), { [clientId]: {
+                id: index,
+                key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
+            } });
+    }, {});
+    return {
+        [userId.id]: Object.assign({}, clients),
+    };
+}
 describe('SessionHandler', () => {
+    const cryptoClient = {
+        sessionFromMessage: jest.fn(),
+        sessionFromPrekey: jest.fn(),
+        sessionExists: jest.fn(),
+        saveSession: jest.fn(),
+        deleteSession: jest.fn(),
+    };
+    const apiClient = new api_client_1.APIClient({ urls: api_client_1.APIClient.BACKEND.STAGING });
     describe('constructSessionId', () => {
         describe('constructs a session ID', () => {
             it('without a domain', () => {
@@ -66,35 +84,42 @@ describe('SessionHandler', () => {
     });
     describe('initSession', () => {
         it('only returns sessions that already exists', async () => {
-            const { apiClient, coreCrypto } = (await (0, ProteusService_mocks_1.buildProteusService)())[1];
-            jest.spyOn(coreCrypto, 'proteusSessionExists').mockResolvedValue(true);
-            const sessionFromPrekeySpy = jest.spyOn(coreCrypto, 'proteusSessionFromPrekey');
-            await (0, SessionHandler_1.initSession)({ userId: { id: 'user1', domain: 'domain' }, clientId: 'client1' }, { apiClient, cryptoClient: new CoreCryptoWrapper_1.CoreCryptoWrapper(coreCrypto, {}, {}) });
-            expect(sessionFromPrekeySpy).not.toHaveBeenCalled();
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(true);
+            await (0, SessionHandler_1.initSession)({ userId: { id: 'user1', domain: 'domain' }, clientId: 'client1' }, { apiClient, cryptoClient });
+            expect(cryptoClient.sessionFromPrekey).not.toHaveBeenCalled();
         });
         it('creates the session if it does not already exist', async () => {
-            const { apiClient, coreCrypto } = (await (0, ProteusService_mocks_1.buildProteusService)())[1];
-            jest.spyOn(coreCrypto, 'proteusSessionExists').mockResolvedValue(false);
-            jest.spyOn(apiClient.api.user, 'getClientPreKey').mockResolvedValue({
-                prekey: {
-                    id: 1,
-                    key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
-                },
-                client: 'client1',
+            const userId = { id: 'user1', domain: 'domain' };
+            const clientId = 'client1';
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(false);
+            jest
+                .spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles')
+                .mockResolvedValue({ domain: generatePrekeys(userId, [clientId]) });
+            const sessionId = (0, SessionHandler_1.constructSessionId)({
+                userId,
+                clientId,
+                useQualifiedIds: true,
             });
+            await (0, SessionHandler_1.initSession)({ userId, clientId }, { apiClient, cryptoClient });
+            expect(cryptoClient.sessionFromPrekey).toHaveBeenCalledWith(sessionId, expect.any(Object));
+        });
+        it('indicates the consumer if a session could not be created', async () => {
+            const userId = { id: 'user1', domain: 'domain' };
+            const clientId = 'client1';
+            jest
+                .spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles')
+                .mockResolvedValue({ domain: generatePrekeys(userId, [clientId]) });
             const sessionId = (0, SessionHandler_1.constructSessionId)({
-                userId: { id: 'user1', domain: 'domain' },
-                clientId: 'client1',
+                userId,
+                clientId,
                 useQualifiedIds: true,
             });
-            const sessionFromPrekeySpy = jest.spyOn(coreCrypto, 'proteusSessionFromPrekey');
-            await (0, SessionHandler_1.initSession)({ userId: { id: 'user1', domain: 'domain' }, clientId: 'client1' }, { apiClient, cryptoClient: new CoreCryptoWrapper_1.CoreCryptoWrapper(coreCrypto, {}, {}) });
-            expect(sessionFromPrekeySpy).toHaveBeenCalledWith(sessionId, expect.any(Object));
+            await (0, SessionHandler_1.initSession)({ userId, clientId }, { apiClient, cryptoClient });
+            expect(cryptoClient.sessionFromPrekey).toHaveBeenCalledWith(sessionId, expect.any(Object));
         });
     });
     describe('initSessions', () => {
         it('creates new sessions only for sessions that are missing', async () => {
-            const { apiClient, coreCrypto } = (await (0, ProteusService_mocks_1.buildProteusService)())[1];
             const existingUserClients = {
                 'existing-user1': ['client1'],
                 'existing-user2': ['client1', 'client2'],
@@ -104,32 +129,15 @@ describe('SessionHandler', () => {
                 'missing-user2': ['client1', 'client2'],
             };
             jest.spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles').mockResolvedValue({});
-            jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockResolvedValue({
-                'missing-user1': {
-                    client1: {
-                        id: 1,
-                        key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
-                    },
-                },
-                'missing-user2': {
-                    client1: {
-                        id: 1,
-                        key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
-                    },
-                    client2: {
-                        id: 1,
-                        key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
-                    },
-                },
-            });
+            jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockResolvedValue(Object.assign(Object.assign({}, generatePrekeys({ id: 'missing-user1', domain: '' }, ['client1'])), generatePrekeys({ id: 'missing-user2', domain: '' }, ['client1', 'client2'])));
             jest
-                .spyOn(coreCrypto, 'proteusSessionExists')
+                .spyOn(cryptoClient, 'sessionExists')
                 .mockImplementation(sessionId => Promise.resolve(sessionId.includes('missing')));
-            const sessionFromPrekeySpy = jest.spyOn(coreCrypto, 'proteusSessionFromPrekey');
+            const sessionFromPrekeySpy = jest.spyOn(cryptoClient, 'sessionFromPrekey');
             const sessions = await (0, SessionHandler_1.initSessions)({
                 recipients: Object.assign(Object.assign({}, existingUserClients), missingUserClients),
                 apiClient,
-                cryptoClient: new CoreCryptoWrapper_1.CoreCryptoWrapper(coreCrypto, {}, {}),
+                cryptoClient,
             });
             expect(sessionFromPrekeySpy).toHaveBeenCalledTimes(3);
             expect(sessions).toHaveLength(6);

package/package.json

@@ -11,7 +11,7 @@
     "./lib/cryptography/AssetCryptography/crypto.node": "./lib/cryptography/AssetCryptography/crypto.browser.js"
   },
   "dependencies": {
-    "@wireapp/api-client": "^22.15.0",
+    "@wireapp/api-client": "^22.15.1",
     "@wireapp/commons": "^5.0.4",
     "@wireapp/core-crypto": "0.6.0-rc.3",
     "@wireapp/cryptobox": "12.8.0",
@@ -19,7 +19,7 @@
     "@wireapp/protocol-messaging": "1.44.0",
     "@wireapp/store-engine": "5.0.3",
     "@wireapp/store-engine-dexie": "^2.0.5",
-    "axios": "1.2.6",
+    "axios": "1.3.0",
     "bazinga64": "6.0.3",
     "hash.js": "1.1.7",
     "http-status-codes": "2.2.0",
@@ -60,6 +60,6 @@
     "test:coverage": "jest --coverage",
     "watch": "tsc --watch"
   },
-  "version": "38.8.2",
-  "gitHead": "a3496f10bd03a239ba33affb747c3c9edf087599"
+  "version": "38.8.3",
+  "gitHead": "b37fb8e63a6d258cf0aed3be478fc5411f9bd6fe"
 }