core-3nweb-client-lib 0.19.5 → 0.20.3

package/build/lib-client/cryptor/cryptor-in-worker.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2020 3NSoft Inc.
+ Copyright (C) 2020 - 2021 3NSoft Inc.
 
  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
@@ -16,16 +16,41 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeInWorkerCryptor = void 0;
+exports.makeInWorkerWasmCryptor = exports.makeInWorkerCryptor = void 0;
 const worker_threads_1 = require("worker_threads");
-const ecma_nacl_1 = require("ecma-nacl");
 const os_1 = require("os");
 const processes_1 = require("../../lib-common/processes");
 const error_1 = require("../../lib-common/exceptions/error");
-const WORKER_MARKER = 'crypto worker';
+const path_1 = require("path");
+const protobuf_loader_1 = require("../protobuf-loader");
+const assert_1 = require("../../lib-common/assert");
 const MAX_IDLE_MILLIS = 60 * 1000;
+const jsWorkerFName = 'worker-js.js';
+const wasmWorkerFName = 'worker-wasm.js';
+function workerScriptFor(impl) {
+    // There is a bug with electrons 12, 13, that doesn't let
+    // worker_thread read files from asar pack, even though main thread
+    // makes call from here.
+    // Therefore, in case this runs from asar pack, we should switch to
+    // unpacked in path that is given to worker thread.
+    // Of course, asarUnpack should be used in electron-builder.
+    const asarInd = __dirname.indexOf('app.asar');
+    const dirWithThis = ((asarInd < 0) ?
+        __dirname : `${__dirname.substring(0, asarInd + 8)}.unpacked${__dirname.substring(asarInd + 8)}`);
+    if (impl === 'js') {
+        return path_1.join(dirWithThis, jsWorkerFName);
+    }
+    else if (impl === 'wasm') {
+        return path_1.join(dirWithThis, wasmWorkerFName);
+    }
+    else {
+        throw new Error(`Unknown worker implementation ${impl}`);
+    }
+}
 class Workers {
-    constructor(logWarning, maxThreads) {
+    constructor(workerScript, logErr, logWarning, maxThreads) {
+        this.workerScript = workerScript;
+        this.logErr = logErr;
         this.logWarning = logWarning;
         this.idleWorkers = [];
         this.allWorkers = new Set();
@@ -62,19 +87,25 @@ class Workers {
             return worker;
         }
     }
+    async doRequest(request, trans, d) {
+        if (this.isClosed) {
+            new Error(`Async cryptor is already closed`);
+        }
+        const worker = await this.getIdleWorker();
+        this.replySinks.set(worker, d);
+        if (trans) {
+            worker.postMessage(request, trans);
+        }
+        else {
+            worker.postMessage(request);
+        }
+        return d.res.promise;
+    }
     async makeWorker() {
-        // There is a bug with electrons 12, 13, that doesn't let
-        // worker_thread read this file from asar pack, even though main thread
-        // makes call from here.
-        // Therefore, in case this runs from asar pack, we should switch to
-        // unpacked in path that is given to worker thread.
-        // Of course, asarUnpack should be used in electron-builder.
-        const asarInd = __filename.indexOf('app.asar');
-        const pathOfThis = ((asarInd < 0) ?
-            __filename : `${__filename.substring(0, asarInd + 8)}.unpacked${__filename.substring(asarInd + 8)}`);
-        const worker = new worker_threads_1.Worker(pathOfThis, {
-            workerData: WORKER_MARKER
-        });
+        const workerData = {
+            loadDir: path_1.dirname(this.workerScript)
+        };
+        const worker = new worker_threads_1.Worker(this.workerScript, { workerData });
         this.allWorkers.add(worker);
         worker.on('message', (reply) => {
             const sink = this.replySinks.get(worker);
@@ -87,7 +118,7 @@ class Workers {
                 }
                 return;
             }
-            const { res, interim, err } = reply;
+            const { res, interim, err } = this.processReply(reply);
             if (res !== undefined) {
                 this.replySinks.delete(worker);
                 this.declareIdle(worker);
@@ -114,13 +145,19 @@ class Workers {
             const sink = this.replySinks.get(worker);
             if (sink) {
                 this.replySinks.delete(worker);
-                sink.res.reject(error_1.errWithCause(err, `Error in cryptor worker thread`));
+                const errWrapped = error_1.errWithCause(err, `Error in cryptor worker thread`);
+                this.logErr(errWrapped);
+                sink.res.reject(errWrapped);
             }
             this.detachWorker(worker);
             worker.terminate();
             this.makeWorker();
         });
-        worker.on('exit', err => { });
+        worker.on('exit', err => {
+            if (err && !this.isClosed) {
+                this.logErr(error_1.errWithCause(err, `Worker exited with error ${err}`));
+            }
+        });
         const workerReady = new Promise((resolve, reject) => {
             const errOnStart = (err) => reject(error_1.errWithCause(err, `Failed to start cryptor worker in thread`));
             const earlyExit = (exitCode) => reject(new Error(`Thread with worker cryptor exited early with code ${exitCode}`));
@@ -154,22 +191,6 @@ class Workers {
             this.idleWorkers.push({ worker, since });
         }
     }
-    async call(func, args, trans, interim) {
-        if (this.isClosed) {
-            new Error(`Async cryptor is already closed`);
-        }
-        const worker = await this.getIdleWorker();
-        const request = { func, args };
-        const res = processes_1.defer();
-        this.replySinks.set(worker, { res, interim });
-        if (trans) {
-            worker.postMessage(request, trans);
-        }
-        else {
-            worker.postMessage(request);
-        }
-        return res.promise;
-    }
     async close() {
         if (this.isClosed) {
             return;
@@ -189,21 +210,34 @@ class Workers {
 }
 Object.freeze(Workers.prototype);
 Object.freeze(Workers);
-function transfer(...arrs) {
-    const transferLst = [];
-    for (const arr of arrs) {
-        const buffer = arr.buffer;
-        if (!transferLst.includes(buffer)) {
-            transferLst.push(buffer);
-        }
+class JsWorkers extends Workers {
+    constructor(logErr, logWarning, maxThreads) {
+        super(workerScriptFor('js'), logErr, logWarning, maxThreads);
     }
-    return transferLst;
-}
-function makeInWorkerCryptor(logWarning, maxThreads) {
-    if (worker_threads_1.workerData === WORKER_MARKER) {
-        throw new Error(`This method can't be called in crypto worker thread`);
+    call(func, args, trans, interim) {
+        return this.doRequest({ func, args }, trans, { res: processes_1.defer(), interim });
+    }
+    processReply(reply) {
+        return reply;
     }
-    const workers = new Workers(logWarning, maxThreads);
+}
+Object.freeze(JsWorkers.prototype);
+Object.freeze(JsWorkers);
+// XXX can we have no-copy transfer to worker?
+// function transfer(...arrs: Uint8Array[]): ArrayBuffer[]|undefined {
+// 	const transferLst: ArrayBuffer[] = [];
+// 	for (const arr of arrs) {
+// 		const buffer = arr.buffer;
+// 		if (!transferLst.includes(buffer)) {
+// 			transferLst.push(buffer);
+// 		}
+// 	}
+// 	return transferLst;
+// }
+exports.makeInWorkerCryptor = (logErr, logWarning, maxThreads) => {
+    assert_1.assert(typeof logErr === 'function');
+    assert_1.assert(typeof logWarning === 'function');
+    const workers = new JsWorkers(logErr, logWarning, maxThreads);
     const close = workers.close.bind(workers);
     const cryptor = {
         scrypt: (passwd, salt, logN, r, p, dkLen, progressCB) => workers.call('scrypt', [passwd, salt, logN, r, p, dkLen], undefined, progressCB),
@@ -226,119 +260,119 @@ function makeInWorkerCryptor(logWarning, maxThreads) {
         }
     };
     return { cryptor, close };
+};
+class WasmWorkers extends Workers {
+    constructor(logErr, logWarning, maxThreads) {
+        super(workerScriptFor('wasm'), logErr, logWarning, maxThreads);
+        this.reqType = makeProtobufType('Request');
+        this.replyType = makeProtobufType('Reply');
+    }
+    call(req, interim) {
+        const msg = this.reqType.pack(req);
+        return this.doRequest(msg, undefined, { res: processes_1.defer(), interim });
+    }
+    processReply(replyBytes) {
+        const { res, interim, err } = this.replyType.unpack(replyBytes);
+        return {
+            res: res ? res.val : undefined,
+            interim: interim ? interim.val : undefined,
+            err: err ? toLocalErr(err) : undefined,
+        };
+    }
 }
-exports.makeInWorkerCryptor = makeInWorkerCryptor;
-if (worker_threads_1.workerData === WORKER_MARKER) {
-    if (!worker_threads_1.parentPort) {
-        throw new Error(`Missing expected parentPort from module`);
+Object.freeze(WasmWorkers.prototype);
+Object.freeze(WasmWorkers);
+function toArgs(...args) {
+    return args.map(val => ({ val }));
+}
+function toLocalErr(replyErr) {
+    if (replyErr.condition === 'cipher-verification') {
+        return { failedCipherVerification: true };
+    }
+    else if (replyErr.condition === 'signature-verification') {
+        return { failedSignatureVerification: true };
+    }
+    else {
+        return new Error(`WASM cryptor ${replyErr.condition}: ${replyErr.message}`);
     }
-    workerMain(worker_threads_1.parentPort);
 }
-function workerMain(port) {
-    const arrFactory = ecma_nacl_1.arrays.makeFactory();
-    const wipe = ecma_nacl_1.arrays.wipe;
-    const funcs = {
-        'scrypt': args => {
-            const progressCB = (n) => {
-                const reply = { interim: n };
-                port.postMessage(reply);
-            };
-            const res = ecma_nacl_1.scrypt(args[0], args[1], args[2], args[3], args[4], args[5], progressCB, arrFactory);
-            wipe(args[0]);
-            return { res };
-            // electron v.11.0.3 worker thread fails on memory move
-            // return { res, trans: transfer(res) };
-        },
-        'box.calc_dhshared_key': args => {
-            const res = ecma_nacl_1.box.calc_dhshared_key(args[0], args[1], arrFactory);
-            wipe(args[0], args[1]);
-            return { res };
-            // electron v.11.0.3 worker thread fails on memory move
-            // return { res, trans: transfer(res) };
-        },
-        'box.generate_pubkey': args => {
-            const res = ecma_nacl_1.box.generate_pubkey(args[0], arrFactory);
-            wipe(args[0]);
-            return { res };
-            // electron v.11.0.3 worker thread fails on memory move
-            // return { res, trans: transfer(res) };
-        },
-        'sbox.open': args => {
-            const res = ecma_nacl_1.secret_box.open(args[0], args[1], args[2], arrFactory);
-            wipe(args[2]);
-            return { res };
-            // electron v.11.0.3 worker thread fails on memory move
-            // return { res, trans: transfer(res) };
-        },
-        'sbox.pack': args => {
-            const res = ecma_nacl_1.secret_box.pack(args[0], args[1], args[2], arrFactory);
-            wipe(args[2]);
-            return { res };
-            // electron v.11.0.3 worker thread fails on memory move
-            // return { res, trans: transfer(res) };
-        },
-        'sbox.formatWN.open': args => {
-            const res = ecma_nacl_1.secret_box.formatWN.open(args[0], args[1], arrFactory);
-            wipe(args[1]);
-            return { res };
-            // electron v.11.0.3 worker thread fails on memory move
-            // return { res, trans: transfer(res) };
-        },
-        'sbox.formatWN.pack': args => {
-            const res = ecma_nacl_1.secret_box.formatWN.pack(args[0], args[1], args[2], arrFactory);
-            wipe(args[2]);
-            return { res };
-            // electron v.11.0.3 worker thread fails on memory move
-            // return { res, trans: transfer(res) };
-        },
-        'sign.generate_keypair': args => {
-            const pair = ecma_nacl_1.signing.generate_keypair(args[0], arrFactory);
-            wipe(args[0]);
-            return { res: pair };
-            // electron v.11.0.3 worker thread fails on memory move
-            // return { res: pair, trans: transfer(pair.pkey, pair.skey) };
+function makeProtobufType(type) {
+    const protoFile = 'cryptor.proto';
+    const typeName = `cryptor.${type}`;
+    try {
+        // make sure to copy protos with compile step (use npm script)
+        return protobuf_loader_1.ProtoType.makeFrom(__dirname, protoFile, typeName);
+    }
+    catch (err) {
+        // we won't get here if referenced  module exists, but metro packager
+        // in LiqudCore needs static path require
+        const fallback = require('./proto-defs');
+        return protobuf_loader_1.ProtoType.makeFrom(__dirname, protoFile, typeName, fallback);
+    }
+}
+exports.makeInWorkerWasmCryptor = (logErr, logWarning, maxThreads) => {
+    assert_1.assert(typeof logErr === 'function');
+    assert_1.assert(typeof logWarning === 'function');
+    const workers = new WasmWorkers(logErr, logWarning, maxThreads);
+    const close = workers.close.bind(workers);
+    const boolValType = makeProtobufType('BoolVal');
+    const kpairType = makeProtobufType('Keypair');
+    const cryptor = {
+        scrypt: (passwd, salt, logN, r, p, dkLen, progressCB) => workers.call({
+            func: 1,
+            scryptArgs: { passwd, salt, logN, r, p, dkLen }
+        }, (bytes) => progressCB(bytes[0])),
+        box: {
+            calc_dhshared_key: (pk, sk) => workers.call({
+                func: 2,
+                byteArgs: toArgs(pk, sk)
+            }),
+            generate_pubkey: (sk) => workers.call({
+                func: 3,
+                byteArgs: toArgs(sk)
+            })
         },
-        'sign.signature': args => {
-            const res = ecma_nacl_1.signing.signature(args[0], args[1], arrFactory);
-            wipe(args[1]);
-            return { res };
-            // electron v.11.0.3 worker thread fails on memory move
-            // return { res, trans: transfer(res) };
+        sbox: {
+            open: (c, n, k) => workers.call({
+                func: 4,
+                byteArgs: toArgs(c, n, k)
+            }),
+            pack: (m, n, k) => workers.call({
+                func: 5,
+                byteArgs: toArgs(m, n, k)
+            }),
+            formatWN: {
+                open: (cn, k) => workers.call({
+                    func: 6,
+                    byteArgs: toArgs(cn, k)
+                }),
+                pack: (m, n, k) => workers.call({
+                    func: 7,
+                    byteArgs: toArgs(m, n, k)
+                })
+            }
         },
-        'sign.verify': args => {
-            const ok = ecma_nacl_1.signing.verify(args[0], args[1], args[2], arrFactory);
-            return { res: ok };
+        signing: {
+            generate_keypair: async (seed) => {
+                const rep = await workers.call({
+                    func: 8,
+                    byteArgs: toArgs(seed)
+                });
+                return kpairType.unpack(rep);
+            },
+            signature: (m, sk) => workers.call({
+                func: 9,
+                byteArgs: toArgs(m, sk)
+            }),
+            verify: async (sig, m, pk) => {
+                const rep = await workers.call({
+                    func: 10,
+                    byteArgs: toArgs(sig, m, pk)
+                });
+                return boolValType.unpack(rep).val;
+            }
         }
     };
-    function wrapError(err) {
-        const exc = {
-            runtimeException: true,
-            type: 'cryptor'
-        };
-        if (err.failedCipherVerification) {
-            exc.failedCipherVerification = true;
-        }
-        else {
-            exc.message = `Error occured in cryptor worker thread`;
-            exc.cause = error_1.stringifyErr(err);
-        }
-        return exc;
-    }
-    port.on('message', (msg) => {
-        const { args, func } = msg;
-        const code = funcs[func];
-        if (!code) {
-            throw new Error(`Function ${func} is unknown`);
-        }
-        try {
-            const { res, trans } = code(args);
-            const reply = { res };
-            port.postMessage(reply, trans);
-        }
-        catch (err) {
-            const reply = { err: wrapError(err) };
-            port.postMessage(reply);
-        }
-    });
-}
+    return { cryptor, close };
+};
 Object.freeze(exports);