@wireapp/core 38.3.2 → 38.4.0

package/lib/messagingProtocols/proteus/ProteusService/CryptoClient/CryptoboxWrapper.js

@@ -0,0 +1,108 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2023 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.CryptoboxWrapper = void 0;
+const cryptobox_1 = require("@wireapp/cryptobox");
+const CryptoClient_types_1 = require("./CryptoClient.types");
+class CryptoboxWrapper {
+    constructor(cryptobox, config) {
+        this.cryptobox = cryptobox;
+        this.cryptobox.on(cryptobox_1.Cryptobox.TOPIC.NEW_PREKEYS, prekeys => {
+            const serializedPreKeys = prekeys.map(prekey => this.cryptobox.serialize_prekey(prekey));
+            config.onNewPrekeys(serializedPreKeys);
+        });
+    }
+    async encrypt(sessions, plainText) {
+        const encryptedPayloads = [];
+        for (const sessionId of sessions) {
+            const encrypted = await this.cryptobox.encrypt(sessionId, plainText);
+            encryptedPayloads.push([sessionId, new Uint8Array(encrypted)]);
+        }
+        return new Map(encryptedPayloads);
+    }
+    decrypt(sessionId, message) {
+        return this.cryptobox.decrypt(sessionId, message.buffer);
+    }
+    async init() {
+        await this.cryptobox.load();
+    }
+    async create(_nbPrekeys, entropy) {
+        const initialPrekeys = await this.cryptobox.create(entropy);
+        const prekeys = initialPrekeys
+            .map(preKey => {
+            const preKeyJson = this.cryptobox.serialize_prekey(preKey);
+            if (preKeyJson.id !== CryptoClient_types_1.LAST_PREKEY_ID) {
+                return preKeyJson;
+            }
+            return { id: -1, key: '' };
+        })
+            .filter(serializedPreKey => serializedPreKey.key);
+        return {
+            prekeys,
+            lastPrekey: this.cryptobox.serialize_prekey(this.cryptobox.lastResortPreKey),
+        };
+    }
+    async getFingerprint() {
+        return this.cryptobox.getIdentity().public_key.fingerprint();
+    }
+    async getRemoteFingerprint(sessionId) {
+        const session = await this.cryptobox.session_load(sessionId);
+        return session.fingerprint_remote();
+    }
+    sessionFromMessage(sessionId, message) {
+        return this.decrypt(sessionId, message);
+    }
+    async consumePrekey() {
+        // Cryptobox is keeping track of consumed prekeys internally
+    }
+    async sessionFromPrekey(sessionId, prekey) {
+        return void (await this.cryptobox.session_from_prekey(sessionId, prekey.buffer));
+    }
+    async sessionExists(sessionId) {
+        try {
+            return !!(await this.cryptobox.session_load(sessionId));
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    async saveSession() {
+        // Cryptobox saves sessions automatically
+    }
+    async deleteSession(sessionId) {
+        await this.cryptobox.session_delete(sessionId);
+    }
+    async newPrekey(id) {
+        // CryptoBox is generating prekeys internally
+        return { id, key: '' };
+    }
+    async debugBreakSession(sessionId) {
+        const session = await this.cryptobox.session_load(sessionId);
+        session.session.session_states = {};
+        this.cryptobox['cachedSessions'].set(sessionId, session);
+    }
+    async migrateToCoreCrypto() {
+        // No migration needed for cryptobox
+    }
+    get isCoreCrypto() {
+        return false;
+    }
+}
+exports.CryptoboxWrapper = CryptoboxWrapper;

package/lib/messagingProtocols/proteus/ProteusService/{PrekeysGenerator/PrekeysGenerator.d.ts → CryptoClient/PrekeysTracker/PrekeysTracker.d.ts}

@@ -1,8 +1,7 @@
 import { PreKey } from '@wireapp/api-client/lib/auth';
-import { CoreCrypto } from '@wireapp/core-crypto/platforms/web/corecrypto';
-import type { CoreDatabase } from '../../../../storage/CoreDB';
-import { NewDevicePrekeys } from '../ProteusService.types';
-type CoreCryptoPrekeyGenerator = Pick<CoreCrypto, 'proteusNewPrekey'>;
+import { CryptoClient } from '..';
+import type { CoreDatabase } from '../../../../../storage/CoreDB';
+type CoreCryptoPrekeyGenerator = Pick<CryptoClient, 'newPrekey'>;
 interface PrekeysGeneratorConfig {
     /**
      * The number of prekeys that will be generated for a new device and refilled when the low threshold is hit
@@ -14,22 +13,15 @@ interface PrekeysGeneratorConfig {
      */
     onNewPrekeys: (prekeys: PreKey[]) => void;
 }
-export declare const LAST_PREKEY_ID = 65535;
-export declare class PrekeyGenerator {
+export declare class PrekeyTracker {
     private readonly generator;
     private config;
     private prekeyState;
     constructor(generator: CoreCryptoPrekeyGenerator, db: CoreDatabase, config: PrekeysGeneratorConfig);
-    private generatePrekey;
     private generatePrekeys;
     consumePrekey(): Promise<void>;
+    setInitialState(nbInitialPrekeys: number): Promise<void>;
     private numberOfMissingPrekeys;
-    /**
-     * Will generate the initial set of prekeys for a new device
-     * @param nbPrekeys the number of prekeys to generate
-     * @param generator the class that will be used to generate a single prekey
-     */
-    generateInitialPrekeys(): Promise<NewDevicePrekeys>;
 }
 export {};
-//# sourceMappingURL=PrekeysGenerator.d.ts.map
+//# sourceMappingURL=PrekeysTracker.d.ts.map

package/lib/messagingProtocols/proteus/ProteusService/CryptoClient/PrekeysTracker/PrekeysTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrekeysTracker.d.ts","sourceRoot":"","sources":["../../../../../../src/messagingProtocols/proteus/ProteusService/CryptoClient/PrekeysTracker/PrekeysTracker.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,MAAM,EAAC,MAAM,8BAA8B,CAAC;AAIpD,OAAO,EAAC,YAAY,EAAC,MAAM,IAAI,CAAC;AAChC,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,+BAA+B,CAAC;AAEhE,KAAK,yBAAyB,GAAG,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;AAEjE,UAAU,sBAAsB;IAC9B;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;OAEG;IACH,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CAC3C;AAED,qBAAa,aAAa;IAItB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAE1B,OAAO,CAAC,MAAM;IALhB,OAAO,CAAC,WAAW,CAAsB;gBAGtB,SAAS,EAAE,yBAAyB,EACrD,EAAE,EAAE,YAAY,EACR,MAAM,EAAE,sBAAsB;YAK1B,eAAe;IASvB,aAAa;IAUb,eAAe,CAAC,gBAAgB,EAAE,MAAM;IAI9C,OAAO,CAAC,sBAAsB;CAK/B"}

package/lib/messagingProtocols/proteus/ProteusService/{PrekeysGenerator/PrekeysGenerator.js → CryptoClient/PrekeysTracker/PrekeysTracker.js}

@@ -18,25 +18,19 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrekeyGenerator = exports.LAST_PREKEY_ID = void 0;
-const bazinga64_1 = require("bazinga64");
-const PrekeysGenerator_store_1 = require("./PrekeysGenerator.store");
-exports.LAST_PREKEY_ID = 65535;
-class PrekeyGenerator {
+exports.PrekeyTracker = void 0;
+const PrekeysTracker_store_1 = require("./PrekeysTracker.store");
+class PrekeyTracker {
     constructor(generator, db, config) {
         this.generator = generator;
         this.config = config;
-        this.prekeyState = new PrekeysGenerator_store_1.PrekeysGeneratorStore(db);
-    }
-    async generatePrekey(id) {
-        const key = await this.generator.proteusNewPrekey(id);
-        return { id, key: bazinga64_1.Encoder.toBase64(key).asString };
+        this.prekeyState = new PrekeysTracker_store_1.PrekeysTrackerStore(db);
     }
     async generatePrekeys(nb) {
         const prekeys = [];
         const ids = await this.prekeyState.createIds(nb);
         for (const id of ids) {
-            prekeys.push(await this.generatePrekey(id));
+            prekeys.push(await this.generator.newPrekey(id));
         }
         return prekeys;
     }
@@ -49,21 +43,13 @@ class PrekeyGenerator {
             this.config.onNewPrekeys(newPrekeys);
         }
     }
+    async setInitialState(nbInitialPrekeys) {
+        await this.prekeyState.createIds(nbInitialPrekeys);
+    }
     numberOfMissingPrekeys(currentNumberOfPrekeys) {
         const threshold = Math.ceil(this.config.nbPrekeys / 2);
         const hasHitThreshold = currentNumberOfPrekeys <= threshold;
         return hasHitThreshold ? this.config.nbPrekeys - currentNumberOfPrekeys : 0;
     }
-    /**
-     * Will generate the initial set of prekeys for a new device
-     * @param nbPrekeys the number of prekeys to generate
-     * @param generator the class that will be used to generate a single prekey
-     */
-    async generateInitialPrekeys() {
-        return {
-            prekeys: await this.generatePrekeys(this.config.nbPrekeys),
-            lastPrekey: await this.generatePrekey(exports.LAST_PREKEY_ID),
-        };
-    }
 }
-exports.PrekeyGenerator = PrekeyGenerator;
+exports.PrekeyTracker = PrekeyTracker;

package/lib/messagingProtocols/proteus/ProteusService/{PrekeysGenerator/PrekeysGenerator.store.d.ts → CryptoClient/PrekeysTracker/PrekeysTracker.store.d.ts}

@@ -1,5 +1,5 @@
-import { CoreDatabase } from '../../../../storage/CoreDB';
-export declare class PrekeysGeneratorStore {
+import { CoreDatabase } from '../../../../../storage/CoreDB';
+export declare class PrekeysTrackerStore {
     private readonly db;
     constructor(db: CoreDatabase);
     private getState;
@@ -16,4 +16,4 @@ export declare class PrekeysGeneratorStore {
      */
     createIds(nbIds: number): Promise<number[]>;
 }
-//# sourceMappingURL=PrekeysGenerator.store.d.ts.map
+//# sourceMappingURL=PrekeysTracker.store.d.ts.map

package/lib/messagingProtocols/proteus/ProteusService/CryptoClient/PrekeysTracker/PrekeysTracker.store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrekeysTracker.store.d.ts","sourceRoot":"","sources":["../../../../../../src/messagingProtocols/proteus/ProteusService/CryptoClient/PrekeysTracker/PrekeysTracker.store.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,YAAY,EAAC,MAAM,+BAA+B,CAAC;AAQ3D,qBAAa,mBAAmB;IAClB,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,YAAY;YAE/B,QAAQ;YAIR,SAAS;IAIvB;;;OAGG;IACG,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC;IAOhC,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC;IAK3C;;;OAGG;IACG,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CAMlD"}

package/lib/messagingProtocols/proteus/ProteusService/{PrekeysGenerator/PrekeysGenerator.store.js → CryptoClient/PrekeysTracker/PrekeysTracker.store.js}

@@ -18,9 +18,9 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrekeysGeneratorStore = void 0;
+exports.PrekeysTrackerStore = void 0;
 const STATE_PRIMARY_KEY = 'prekeys_state';
-class PrekeysGeneratorStore {
+class PrekeysTrackerStore {
     constructor(db) {
         this.db = db;
     }
@@ -55,4 +55,4 @@ class PrekeysGeneratorStore {
         return Array.from(new Array(nbIds)).map((_, i) => currentState.highestId + 1 + i);
     }
 }
-exports.PrekeysGeneratorStore = PrekeysGeneratorStore;
+exports.PrekeysTrackerStore = PrekeysTrackerStore;

package/lib/messagingProtocols/proteus/ProteusService/CryptoClient/PrekeysTracker/PrekeysTracker.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=PrekeysTracker.test.d.ts.map

package/lib/messagingProtocols/proteus/ProteusService/CryptoClient/PrekeysTracker/PrekeysTracker.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrekeysTracker.test.d.ts","sourceRoot":"","sources":["../../../../../../src/messagingProtocols/proteus/ProteusService/CryptoClient/PrekeysTracker/PrekeysTracker.test.ts"],"names":[],"mappings":""}

package/lib/messagingProtocols/proteus/ProteusService/{PrekeysGenerator/PrekeysGenerator.test.js → CryptoClient/PrekeysTracker/PrekeysTracker.test.js}

@@ -18,16 +18,16 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-const PrekeysGenerator_1 = require("./PrekeysGenerator");
-const CoreDB_1 = require("../../../../storage/CoreDB");
+const PrekeysTracker_1 = require("./PrekeysTracker");
+const CoreDB_1 = require("../../../../../storage/CoreDB");
 describe('PrekeysGenerator', () => {
     let db;
     const baseConfig = {
         nbPrekeys: 10,
         onNewPrekeys: jest.fn(),
     };
-    const mockPrekeyGenerator = {
-        proteusNewPrekey: jest.fn().mockResolvedValue(Uint8Array.from([])),
+    const mockPrekeyTracker = {
+        newPrekey: jest.fn().mockResolvedValue(Uint8Array.from([])),
     };
     beforeEach(async () => {
         db = await (0, CoreDB_1.openDB)('test');
@@ -35,22 +35,16 @@ describe('PrekeysGenerator', () => {
     afterEach(async () => {
         await db.clear('prekeys');
     });
-    it('generates initial device prekeys', async () => {
-        const prekeyGenerator = new PrekeysGenerator_1.PrekeyGenerator(mockPrekeyGenerator, db, baseConfig);
-        const { prekeys, lastPrekey } = await prekeyGenerator.generateInitialPrekeys();
-        expect(prekeys).toHaveLength(baseConfig.nbPrekeys);
-        expect(lastPrekey.id).toBe(PrekeysGenerator_1.LAST_PREKEY_ID);
-    });
     it('triggers the threshold callback when number of prekeys hits the limit', async () => {
-        const prekeyGenerator = new PrekeysGenerator_1.PrekeyGenerator(mockPrekeyGenerator, db, baseConfig);
-        await prekeyGenerator.generateInitialPrekeys();
+        const prekeyTracker = new PrekeysTracker_1.PrekeyTracker(mockPrekeyTracker, db, baseConfig);
+        await prekeyTracker.setInitialState(baseConfig.nbPrekeys);
         expect(baseConfig.onNewPrekeys).not.toHaveBeenCalled();
-        await prekeyGenerator.consumePrekey();
-        await prekeyGenerator.consumePrekey();
-        await prekeyGenerator.consumePrekey();
-        await prekeyGenerator.consumePrekey();
+        await prekeyTracker.consumePrekey();
+        await prekeyTracker.consumePrekey();
+        await prekeyTracker.consumePrekey();
+        await prekeyTracker.consumePrekey();
         expect(baseConfig.onNewPrekeys).not.toHaveBeenCalled();
-        await prekeyGenerator.consumePrekey();
+        await prekeyTracker.consumePrekey();
         expect(baseConfig.onNewPrekeys).toHaveBeenCalledTimes(1);
     });
 });

package/lib/messagingProtocols/proteus/ProteusService/CryptoClient/PrekeysTracker/index.d.ts

@@ -0,0 +1,2 @@
+export * from './PrekeysTracker';
+//# sourceMappingURL=index.d.ts.map

package/lib/messagingProtocols/proteus/ProteusService/CryptoClient/PrekeysTracker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/messagingProtocols/proteus/ProteusService/CryptoClient/PrekeysTracker/index.ts"],"names":[],"mappings":"AAmBA,cAAc,kBAAkB,CAAC"}

package/lib/messagingProtocols/proteus/ProteusService/{PrekeysGenerator → CryptoClient/PrekeysTracker}/index.js

@@ -32,4 +32,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./PrekeysGenerator"), exports);
+__exportStar(require("./PrekeysTracker"), exports);

package/lib/messagingProtocols/proteus/ProteusService/CryptoClient/index.d.ts

@@ -0,0 +1,3 @@
+export * from './CryptoClient';
+export * from './CryptoClient.types';
+//# sourceMappingURL=index.d.ts.map

package/lib/messagingProtocols/proteus/ProteusService/CryptoClient/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/messagingProtocols/proteus/ProteusService/CryptoClient/index.ts"],"names":[],"mappings":"AAmBA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC"}

package/lib/messagingProtocols/proteus/ProteusService/CryptoClient/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2023 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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./CryptoClient"), exports);
+__exportStar(require("./CryptoClient.types"), exports);

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

@@ -57,7 +57,7 @@ const getErrorMessage = (code, userId, clientId, error) => {
 };
 const generateDecryptionError = (senderInfo, error) => {
     const { clientId: remoteClientId, userId } = senderInfo;
-    const code = mapCoreCryptoError(error);
+    const code = error.code || mapCoreCryptoError(error);
     const message = getErrorMessage(code, userId, remoteClientId, error);
     return new DecryptionError_1.DecryptionError(message, code);
 };

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

@@ -2,7 +2,8 @@ import type { APIClient } from '@wireapp/api-client/lib/APIClient';
 import type { PreKey, Context } from '@wireapp/api-client/lib/auth';
 import type { Conversation, OTRRecipients, QualifiedOTRRecipients, QualifiedUserClients, UserClients } from '@wireapp/api-client/lib/conversation';
 import type { QualifiedId, QualifiedUserPreKeyBundleMap, UserPreKeyBundleMap } from '@wireapp/api-client/lib/user';
-import type { CoreCrypto } from '@wireapp/core-crypto';
+import { CoreCrypto } from '@wireapp/core-crypto';
+import { Cryptobox } from '@wireapp/cryptobox';
 import { CRUDEngine } from '@wireapp/store-engine';
 import type { AddUsersToProteusConversationParams, CreateProteusConversationParams, ProteusServiceConfig, SendProteusMessageParams } from './ProteusService.types';
 import { SendResult } from '../../../conversation';
@@ -11,15 +12,14 @@ import type { EventHandlerResult } from '../../common.types';
 import { EventHandlerParams } from '../EventHandler';
 export declare class ProteusService {
     private readonly apiClient;
-    private readonly coreCryptoClient;
     private readonly config;
     private readonly messageService;
     private readonly logger;
-    private readonly prekeyGenerator;
-    constructor(apiClient: APIClient, coreCryptoClient: CoreCrypto, db: CoreDatabase, config: ProteusServiceConfig);
+    private readonly cryptoClient;
+    constructor(apiClient: APIClient, cryptoClient: CoreCrypto | Cryptobox, db: CoreDatabase, config: ProteusServiceConfig);
     handleEvent(params: Pick<EventHandlerParams, 'event' | 'source' | 'dryRun'>): EventHandlerResult;
     initClient(storeEngine: CRUDEngine, context: Context): Promise<void>;
-    createClient(): Promise<import("./ProteusService.types").NewDevicePrekeys>;
+    createClient(entropy?: Uint8Array): Promise<import("./CryptoClient").InitialPrekeys>;
     /**
      * Get the fingerprint of the local client.
      */
@@ -40,6 +40,5 @@ export declare class ProteusService {
     encrypt(plainText: Uint8Array, recipients: UserPreKeyBundleMap | UserClients, domain?: string): Promise<OTRRecipients<Uint8Array>>;
     deleteSession(userId: QualifiedId, clientId: string): Promise<void>;
     encryptQualified(plainText: Uint8Array, preKeyBundles: QualifiedUserPreKeyBundleMap | QualifiedUserClients): Promise<QualifiedOTRRecipients>;
-    private migrateToCoreCrypto;
 }
 //# sourceMappingURL=ProteusService.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ProteusService.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/ProteusService/ProteusService.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,mCAAmC,CAAC;AACjE,OAAO,KAAK,EAAC,MAAM,EAAE,OAAO,EAAC,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EACV,YAAY,EAEZ,aAAa,EACb,sBAAsB,EACtB,oBAAoB,EACpB,WAAW,EACZ,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAC,WAAW,EAAE,4BAA4B,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AAGjH,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,sBAAsB,CAAC;AAErD,OAAO,EAAC,UAAU,EAAC,MAAM,uBAAuB,CAAC;AAIjD,OAAO,KAAK,EACV,mCAAmC,EACnC,+BAA+B,EAC/B,oBAAoB,EACpB,wBAAwB,EACzB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAA0C,UAAU,EAAC,MAAM,uBAAuB,CAAC;AAE1F,OAAO,EAAC,YAAY,EAAC,MAAM,yBAAyB,CAAC;AACrD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAC,kBAAkB,EAAqB,MAAM,iBAAiB,CAAC;AAmBvE,qBAAa,cAAc;IAMvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IAEjC,OAAO,CAAC,QAAQ,CAAC,MAAM;IARzB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2C;IAClE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;gBAG/B,SAAS,EAAE,SAAS,EACpB,gBAAgB,EAAE,UAAU,EAC7C,EAAE,EAAE,YAAY,EACC,MAAM,EAAE,oBAAoB;IASlC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC,GAAG,kBAAkB;IAiBhG,UAAU,CAAC,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO;IAK1D,YAAY;IAInB;;OAEG;IACI,mBAAmB;IAInB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM;IAIlG;;;;;;OAMG;IACU,oBAAoB,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IAQ3E,kBAAkB,CAAC,EAC9B,gBAAgB,EAChB,YAAY,GACb,EAAE,+BAA+B,GAAG,OAAO,CAAC,YAAY,CAAC;IAiB7C,sBAAsB,CAAC,EAAC,cAAc,EAAE,gBAAgB,EAAC,EAAE,mCAAmC;IAI9F,WAAW,CAAC,EACvB,OAAO,EACP,cAAc,EACd,cAAc,EACd,UAAU,EACV,UAAU,EACV,OAAO,EACP,gBAAgB,GACjB,EAAE,wBAAwB,GAAG,OAAO,CAAC,UAAU,CAAC;YA2CnC,OAAO;IAwBR,OAAO,CAClB,SAAS,EAAE,UAAU,EACrB,UAAU,EAAE,mBAAmB,GAAG,WAAW,EAC7C,MAAM,GAAE,MAAW,GAClB,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IAc9B,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM;IAS7C,gBAAgB,CAC3B,SAAS,EAAE,UAAU,EACrB,aAAa,EAAE,4BAA4B,GAAG,oBAAoB,GACjE,OAAO,CAAC,sBAAsB,CAAC;YAWpB,mBAAmB;CA8BlC"}
+{"version":3,"file":"ProteusService.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/ProteusService/ProteusService.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,mCAAmC,CAAC;AACjE,OAAO,KAAK,EAAC,MAAM,EAAE,OAAO,EAAC,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EACV,YAAY,EAEZ,aAAa,EACb,sBAAsB,EACtB,oBAAoB,EACpB,WAAW,EACZ,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAC,WAAW,EAAE,4BAA4B,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AAGjH,OAAO,EAAC,UAAU,EAAC,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAC,SAAS,EAAC,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAC,UAAU,EAAC,MAAM,uBAAuB,CAAC;AAKjD,OAAO,KAAK,EACV,mCAAmC,EACnC,+BAA+B,EAC/B,oBAAoB,EACpB,wBAAwB,EACzB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAA0C,UAAU,EAAC,MAAM,uBAAuB,CAAC;AAE1F,OAAO,EAAC,YAAY,EAAC,MAAM,yBAAyB,CAAC;AACrD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAC,kBAAkB,EAAqB,MAAM,iBAAiB,CAAC;AAWvE,qBAAa,cAAc;IAMvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAG1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IARzB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2C;IAClE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;gBAGzB,SAAS,EAAE,SAAS,EACrC,YAAY,EAAE,UAAU,GAAG,SAAS,EACpC,EAAE,EAAE,YAAY,EACC,MAAM,EAAE,oBAAoB;IAMlC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC,GAAG,kBAAkB;IAiBhG,UAAU,CAAC,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO;IA0B1D,YAAY,CAAC,OAAO,CAAC,EAAE,UAAU;IAIxC;;OAEG;IACI,mBAAmB;IAInB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM;IAIlG;;;;;;OAMG;IACU,oBAAoB,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IAQ3E,kBAAkB,CAAC,EAC9B,gBAAgB,EAChB,YAAY,GACb,EAAE,+BAA+B,GAAG,OAAO,CAAC,YAAY,CAAC;IAiB7C,sBAAsB,CAAC,EAAC,cAAc,EAAE,gBAAgB,EAAC,EAAE,mCAAmC;IAI9F,WAAW,CAAC,EACvB,OAAO,EACP,cAAc,EACd,cAAc,EACd,UAAU,EACV,UAAU,EACV,OAAO,EACP,gBAAgB,GACjB,EAAE,wBAAwB,GAAG,OAAO,CAAC,UAAU,CAAC;YA2CnC,OAAO;IAuBR,OAAO,CAClB,SAAS,EAAE,UAAU,EACrB,UAAU,EAAE,mBAAmB,GAAG,WAAW,EAC7C,MAAM,GAAE,MAAW,GAClB,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IAc9B,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM;IAS7C,gBAAgB,CAC3B,SAAS,EAAE,UAAU,EACrB,aAAa,EAAE,4BAA4B,GAAG,oBAAoB,GACjE,OAAO,CAAC,sBAAsB,CAAC;CAUnC"}

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

@@ -24,8 +24,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProteusService = void 0;
 const logdown_1 = __importDefault(require("logdown"));
 const protocol_messaging_1 = require("@wireapp/protocol-messaging");
+const CryptoClient_1 = require("./CryptoClient");
+const cryptoMigrationStateStore_1 = require("./cryptoMigrationStateStore");
 const DecryptionErrorGenerator_1 = require("./DecryptionErrorGenerator");
-const PrekeysGenerator_1 = require("./PrekeysGenerator");
 const sessionIdMigrator_1 = require("./sessionIdMigrator");
 const conversation_1 = require("../../../conversation");
 const MessageService_1 = require("../../../conversation/message/MessageService");
@@ -33,25 +34,13 @@ const EventHandler_1 = require("../EventHandler");
 const getGenericMessageParams_1 = require("../Utility/getGenericMessageParams");
 const isClearFromMismatch_1 = require("../Utility/isClearFromMismatch");
 const SessionHandler_1 = require("../Utility/SessionHandler");
-function getLocalStorage() {
-    try {
-        return window.localStorage;
-    }
-    catch (_a) {
-        return { setItem: () => { }, getItem: () => { }, removeItem: () => { } };
-    }
-}
 class ProteusService {
-    constructor(apiClient, coreCryptoClient, db, config) {
+    constructor(apiClient, cryptoClient, db, config) {
         this.apiClient = apiClient;
-        this.coreCryptoClient = coreCryptoClient;
         this.config = config;
         this.logger = (0, logdown_1.default)('@wireapp/core/ProteusService');
         this.messageService = new MessageService_1.MessageService(this.apiClient, this);
-        this.prekeyGenerator = new PrekeysGenerator_1.PrekeyGenerator(coreCryptoClient, db, {
-            nbPrekeys: config.nbPrekeys,
-            onNewPrekeys: config.onNewPrekeys,
-        });
+        this.cryptoClient = (0, CryptoClient_1.wrapCryptoClient)(cryptoClient, db, config);
     }
     async handleEvent(params) {
         const handledEvent = await (0, EventHandler_1.handleBackendEvent)(Object.assign(Object.assign({}, params), { decryptMessage: (payload, userId, clientId) => this.decrypt(payload, userId, clientId) }));
@@ -60,23 +49,43 @@ class ProteusService {
             if (isSessionReset) {
                 this.logger.debug('A session was reset from a remote device');
                 // If a session reset message was received, we need to count a consumed prekey (because the sender has created a new session from a new prekey)
-                await this.prekeyGenerator.consumePrekey();
+                await this.cryptoClient.consumePrekey();
             }
         }
         return handledEvent;
     }
     async initClient(storeEngine, context) {
-        await this.migrateToCoreCrypto(storeEngine, context);
-        return this.coreCryptoClient.proteusInit();
+        const dbName = storeEngine.storeName;
+        if (context.domain && this.config.useQualifiedIds) {
+            // We want sessions to be fully qualified from now on
+            if (!cryptoMigrationStateStore_1.cryptoMigrationStore.qualifiedSessions.isReady(dbName)) {
+                this.logger.info(`Migrating existing session ids to qualified ids.`);
+                await (0, sessionIdMigrator_1.migrateToQualifiedSessionIds)(storeEngine, context.domain);
+                cryptoMigrationStateStore_1.cryptoMigrationStore.qualifiedSessions.markAsReady(dbName);
+                this.logger.info(`Successfully migrated session ids to qualified ids.`);
+            }
+        }
+        if (!cryptoMigrationStateStore_1.cryptoMigrationStore.coreCrypto.isReady(dbName) && this.cryptoClient.isCoreCrypto) {
+            this.logger.info(`Migrating data from cryptobox store (${dbName}) to corecrypto.`);
+            try {
+                await this.cryptoClient.migrateToCoreCrypto(dbName);
+                cryptoMigrationStateStore_1.cryptoMigrationStore.coreCrypto.markAsReady(dbName);
+                this.logger.info(`Successfully migrated from cryptobox store (${dbName}) to corecrypto.`);
+            }
+            catch (error) {
+                this.logger.error('Client was not able to perform DB migration: ', error);
+            }
+        }
+        return this.cryptoClient.init();
     }
-    createClient() {
-        return this.prekeyGenerator.generateInitialPrekeys();
+    createClient(entropy) {
+        return this.cryptoClient.create(this.config.nbPrekeys, entropy);
     }
     /**
      * Get the fingerprint of the local client.
      */
     getLocalFingerprint() {
-        return this.coreCryptoClient.proteusFingerprint();
+        return this.cryptoClient.getFingerprint();
     }
     constructSessionId(userId, clientId, domain) {
         return (0, SessionHandler_1.constructSessionId)({ clientId, userId, domain, useQualifiedIds: this.config.useQualifiedIds });
@@ -89,8 +98,8 @@ class ProteusService {
      *   If not provided and the session doesn't exists it will fetch a new prekey from the backend
      */
     async getRemoteFingerprint(userId, clientId, prekey) {
-        const sessionId = await (0, SessionHandler_1.initSession)({ userId, clientId, initialPrekey: prekey }, { coreCrypto: this.coreCryptoClient, apiClient: this.apiClient });
-        return this.coreCryptoClient.proteusFingerprintRemote(sessionId);
+        const sessionId = await (0, SessionHandler_1.initSession)({ userId, clientId, initialPrekey: prekey }, { cryptoClient: this.cryptoClient, apiClient: this.apiClient });
+        return this.cryptoClient.getRemoteFingerprint(sessionId);
     }
     async createConversation({ conversationData, otherUserIds, }) {
         let payload;
@@ -145,14 +154,13 @@ class ProteusService {
     async decrypt(encryptedText, userId, clientId) {
         var _a, _b;
         const sessionId = this.constructSessionId(userId, clientId);
-        const sessionExists = await this.coreCryptoClient.proteusSessionExists(sessionId);
+        const sessionExists = await this.cryptoClient.sessionExists(sessionId);
         try {
             const decryptedMessage = !sessionExists
-                ? await this.coreCryptoClient.proteusSessionFromMessage(sessionId, encryptedText)
-                : await this.coreCryptoClient.proteusDecrypt(sessionId, encryptedText);
+                ? await this.cryptoClient.sessionFromMessage(sessionId, encryptedText)
+                : await this.cryptoClient.decrypt(sessionId, encryptedText);
             if (!sessionExists) {
-                await this.coreCryptoClient.proteusSessionSave(sessionId);
-                await this.prekeyGenerator.consumePrekey();
+                await this.cryptoClient.saveSession(sessionId);
                 (_b = (_a = this.config).onNewClient) === null || _b === void 0 ? void 0 : _b.call(_a, { userId, clientId });
                 this.logger.info(`Created a new session from message for session ID "${sessionId}" and decrypted the message`);
             }
@@ -170,10 +178,10 @@ class ProteusService {
             recipients,
             domain,
             apiClient: this.apiClient,
-            coreCrypto: this.coreCryptoClient,
+            cryptoClient: this.cryptoClient,
             logger: this.logger,
         });
-        const payload = await this.coreCryptoClient.proteusEncryptBatched(sessions, plainText);
+        const payload = await this.cryptoClient.encrypt(sessions, plainText);
         return (0, SessionHandler_1.buildEncryptedPayloads)(payload);
     }
     deleteSession(userId, clientId) {
@@ -181,7 +189,7 @@ class ProteusService {
             userId,
             clientId,
             useQualifiedIds: this.config.useQualifiedIds,
-            coreCrypto: this.coreCryptoClient,
+            cryptoClient: this.cryptoClient,
         });
     }
     async encryptQualified(plainText, preKeyBundles) {
@@ -192,34 +200,5 @@ class ProteusService {
         }
         return qualifiedOTRRecipients;
     }
-    async migrateToCoreCrypto(storeEngine, context) {
-        var _a;
-        const dbName = storeEngine.storeName;
-        const migrationFlag = `${dbName}-corecrypto-ready`;
-        const localStorage = getLocalStorage();
-        if (localStorage.getItem(migrationFlag)) {
-            return;
-        }
-        // We want sessions to be fully qualified from now on
-        await (0, sessionIdMigrator_1.migrateToQualifiedSessionIds)(storeEngine, (_a = context.domain) !== null && _a !== void 0 ? _a : '');
-        this.logger.log(`Migrating data from cryptobox store (${dbName}) to corecrypto.`);
-        try {
-            await this.coreCryptoClient.proteusCryptoboxMigrate(dbName);
-            // We can clear 3 stores (keys - local identity, prekeys and sessions) from wire db.
-            // They will be stored in corecrypto database now.
-            /* TODO uncomment this code when we are sure migration for wire.com has happened successfully for enough users
-            const storesToClear = ['keys', 'prekeys', 'sessions'] as const;
-      
-            for (const storeName of storesToClear) {
-              await this.storeEngine?.deleteAll(storeName);
-            }
-            */
-            this.logger.log(`Successfully migrated from cryptobox store (${dbName}) to corecrypto.`);
-            localStorage.setItem(migrationFlag, '1');
-        }
-        catch (error) {
-            this.logger.error('Client was not able to perform DB migration: ', error);
-        }
-    }
 }
 exports.ProteusService = ProteusService;

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

@@ -51,9 +51,9 @@ const SessionHandler_1 = require("../Utility/SessionHandler");
 const notification_1 = require("../../../notification");
 const event_1 = require("@wireapp/api-client/lib/event");
 const protocol_messaging_1 = require("@wireapp/protocol-messaging");
-jest.mock('./PrekeysGenerator', () => {
+jest.mock('./CryptoClient/PrekeysTracker', () => {
     return {
-        PrekeyGenerator: jest.fn().mockImplementation(() => {
+        PrekeyTracker: jest.fn().mockImplementation(() => {
             return {
                 consumePrekey: jest.fn(),
                 getNumberOfPrekeys: jest.fn().mockResolvedValue(0),
@@ -148,7 +148,7 @@ describe('ProteusService', () => {
             expect(result).toBe(expectedFingerprint);
         });
         it('create a session from given prekey if session does not exists', async () => {
-            const [proteusService, { apiClient, coreCrypto }] = await await (0, ProteusService_mocks_1.buildProteusService)();
+            const [proteusService, { apiClient, coreCrypto }] = await (0, ProteusService_mocks_1.buildProteusService)();
             const expectedFingerprint = 'fingerprint-client1';
             const getPrekeyMock = jest.spyOn(apiClient.api.user, 'getClientPreKey');
             jest.spyOn(coreCrypto, 'proteusFingerprintRemote').mockResolvedValue(expectedFingerprint);

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

@@ -12,10 +12,6 @@ export type ProteusServiceConfig = {
     nbPrekeys: number;
     onNewPrekeys: (prekeys: PreKey[]) => void;
 };
-export type NewDevicePrekeys = {
-    prekeys: PreKey[];
-    lastPrekey: PreKey;
-};
 export type SendProteusMessageParams = SendCommonParams & MessageSendingOptions & {
     conversationId: QualifiedId;
     /**