From d8080ace913889e8fbd36eb60176936f406fd44f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Hern=C3=A1ndez=20Serrano?= Date: Wed, 4 Aug 2021 12:50:36 +0200 Subject: [PATCH] fixed issue with workers in node 10 --- README.md | 6 + build/rollup.config.js | 18 +- dist/cjs/index.node.js | 712 +++++++++++++++++++++++++++++++++++++++++ docs/API.md | 16 +- package.json | 1 + src/docs/index.md | 6 + 6 files changed, 745 insertions(+), 14 deletions(-) create mode 100644 dist/cjs/index.node.js diff --git a/README.md b/README.md index 6ed17bd..0fb01cc 100644 --- a/README.md +++ b/README.md @@ -27,6 +27,12 @@ Then either require (Node.js CJS): const bigintCryptoUtils = require('bigint-crypto-utils') ``` +> **Node >=10.4 <11**. `bigint-crypto-utils` uses workers to speed up some operations. Workers are enabled by default with Node.js from version 11. In order to use them with Node >=10.4 and <11, you need to execute node with the flag `--experimental-worker`, and require the .js file manually (otherwise .cjs is required by default and would not be supported by the workers) +> +> ```javascript +> const bigintCryptoUtils = require('bigint-crypto-utils/dist/cjs/index.node') // ONLY FOR node >=10.4 <11 ! +> ``` + or import (JavaScript ES module): ```javascript diff --git a/build/rollup.config.js b/build/rollup.config.js index 5a573f6..0b6d645 100644 --- a/build/rollup.config.js +++ b/build/rollup.config.js @@ -115,12 +115,18 @@ module.exports = [ }, { // Node CJS input: input, - output: { - dir: path.join(rootDir, path.dirname(pkgJson.exports['.'].node.require)), - entryFileNames: path.basename(pkgJson.exports['.'].node.require), - ...sourcemapOutputOptions, - format: 'cjs' - }, + output: [ + { + file: path.join(rootDir, pkgJson.exports['.'].node.require), + ...sourcemapOutputOptions, + format: 'cjs' + }, + { + file: path.join(rootDir, pkgJson.exports['./node-js']), + ...sourcemapOutputOptions, + format: 'cjs' + } + ], plugins: [ replace({ IS_BROWSER: false, diff --git a/dist/cjs/index.node.js b/dist/cjs/index.node.js new file mode 100644 index 0000000..3f4a302 --- /dev/null +++ b/dist/cjs/index.node.js @@ -0,0 +1,712 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { value: true }); + +var bigintModArith = require('bigint-mod-arith'); + +function fromBuffer(buf) { + let ret = 0n; + for (const i of buf.values()) { + const bi = BigInt(i); + ret = (ret << 8n) + bi; + } + return ret; +} + +/** + * Secure random bytes for both node and browsers. Node version uses crypto.randomBytes() and browser one self.crypto.getRandomValues() + * + * @param byteLength - The desired number of random bytes + * @param forceLength - If we want to force the output to have a bit length of 8*byteLength. It basically forces the msb to be 1 + * + * @throws {RangeError} + * byteLength MUST be > 0 + * + * @returns A promise that resolves to a UInt8Array/Buffer (Browser/Node.js) filled with cryptographically secure random bytes + */ +function randBytes(byteLength, forceLength = false) { + if (byteLength < 1) + throw new RangeError('byteLength MUST be > 0'); + return new Promise(function (resolve, reject) { + { + const crypto = require('crypto'); // eslint-disable-line + crypto.randomBytes(byteLength, function (err, buf) { + /* istanbul ignore if */ + if (err !== null) + reject(err); + // If fixed length is required we put the first bit to 1 -> to get the necessary bitLength + if (forceLength) + buf[0] = buf[0] | 128; + resolve(buf); + }); + } + }); +} +/** + * Secure random bytes for both node and browsers. Node version uses crypto.randomFill() and browser one self.crypto.getRandomValues() + * + * @param byteLength - The desired number of random bytes + * @param forceLength - If we want to force the output to have a bit length of 8*byteLength. It basically forces the msb to be 1 + * + * @throws {RangeError} + * byteLength MUST be > 0 + * + * @returns A UInt8Array/Buffer (Browser/Node.js) filled with cryptographically secure random bytes + */ +function randBytesSync(byteLength, forceLength = false) { + if (byteLength < 1) + throw new RangeError('byteLength MUST be > 0'); + /* eslint-disable no-lone-blocks */ + { // node + const crypto = require('crypto'); // eslint-disable-line + const buf = crypto.randomBytes(byteLength); + // If fixed length is required we put the first bit to 1 -> to get the necessary bitLength + if (forceLength) + buf[0] = buf[0] | 128; + return buf; + } + /* eslint-enable no-lone-blocks */ +} + +/** + * Secure random bits for both node and browsers. Node version uses crypto.randomFill() and browser one self.crypto.getRandomValues() + * + * @param bitLength - The desired number of random bits + * @param forceLength - If we want to force the output to have a specific bit length. It basically forces the msb to be 1 + * + * @throws {RangeError} + * bitLength MUST be > 0 + * + * @returns A Promise that resolves to a UInt8Array/Buffer (Browser/Node.js) filled with cryptographically secure random bits + */ +function randBits(bitLength, forceLength = false) { + if (bitLength < 1) + throw new RangeError('bitLength MUST be > 0'); + const byteLength = Math.ceil(bitLength / 8); + const bitLengthMod8 = bitLength % 8; + return new Promise((resolve, reject) => { + randBytes(byteLength, false).then(function (rndBytes) { + if (bitLengthMod8 !== 0) { + // Fill with 0's the extra bits + rndBytes[0] = rndBytes[0] & (2 ** bitLengthMod8 - 1); + } + if (forceLength) { + const mask = (bitLengthMod8 !== 0) ? 2 ** (bitLengthMod8 - 1) : 128; + rndBytes[0] = rndBytes[0] | mask; + } + resolve(rndBytes); + }); + }); +} +/** + * Secure random bits for both node and browsers. Node version uses crypto.randomFill() and browser one self.crypto.getRandomValues() + * @param bitLength - The desired number of random bits + * @param forceLength - If we want to force the output to have a specific bit length. It basically forces the msb to be 1 + * + * @throws {RangeError} + * bitLength MUST be > 0 + * + * @returns A Uint8Array/Buffer (Browser/Node.js) filled with cryptographically secure random bits + */ +function randBitsSync(bitLength, forceLength = false) { + if (bitLength < 1) + throw new RangeError('bitLength MUST be > 0'); + const byteLength = Math.ceil(bitLength / 8); + const rndBytes = randBytesSync(byteLength, false); + const bitLengthMod8 = bitLength % 8; + if (bitLengthMod8 !== 0) { + // Fill with 0's the extra bits + rndBytes[0] = rndBytes[0] & (2 ** bitLengthMod8 - 1); + } + if (forceLength) { + const mask = (bitLengthMod8 !== 0) ? 2 ** (bitLengthMod8 - 1) : 128; + rndBytes[0] = rndBytes[0] | mask; + } + return rndBytes; +} + +/** + * Returns a cryptographically secure random integer between [min,max]. Both numbers must be >=0 + * @param max Returned value will be <= max + * @param min Returned value will be >= min + * + * @throws {RangeError} + * Arguments MUST be: max > 0 && min >=0 && max > min + * + * @returns A cryptographically secure random bigint between [min,max] + */ +function randBetween(max, min = 1n) { + if (max <= 0n || min < 0n || max <= min) + throw new RangeError('Arguments MUST be: max > 0 && min >=0 && max > min'); + const interval = max - min; + const bitLen = bigintModArith.bitLength(interval); + let rnd; + do { + const buf = randBitsSync(bitLen); + rnd = fromBuffer(buf); + } while (rnd > interval); + return rnd + min; +} + +let _useWorkers = false; // The following is just to check whether we can use workers +/* eslint-disable no-lone-blocks */ +{ // Node.js + try { + require.resolve('worker_threads'); + _useWorkers = true; + } + catch (e) { + /* istanbul ignore next */ + console.log(`[bigint-crypto-utils] WARNING: +This node version doesn't support worker_threads. You should enable them in order to greatly speedup the generation of big prime numbers. + · With Node >=11 it is enabled by default (consider upgrading). + · With Node 10, starting with 10.5.0, you can enable worker_threads at runtime executing node --experimental-worker `); + } +} + +/** + * The test first tries if any of the first 250 small primes are a factor of the input number and then passes several + * iterations of Miller-Rabin Probabilistic Primality Test (FIPS 186-4 C.3.1) + * + * @param w - A positive integer to be tested for primality + * @param iterations - The number of iterations for the primality test. The value shall be consistent with Table C.1, C.2 or C.3 + * @param disableWorkers - Disable the use of workers for the primality test + * + * @throws {RangeError} + * w MUST be >= 0 + * + * @returns A promise that resolves to a boolean that is either true (a probably prime number) or false (definitely composite) + */ +function isProbablyPrime(w, iterations = 16, disableWorkers = false) { + if (typeof w === 'number') { + w = BigInt(w); + } + if (w < 0n) + throw RangeError('w MUST be >= 0'); + { // Node.js + /* istanbul ignore else */ + if (!disableWorkers && _useWorkers) { + const { Worker } = require('worker_threads'); // eslint-disable-line + return new Promise((resolve, reject) => { + const worker = new Worker(__filename); + worker.on('message', (data) => { + worker.terminate(); + resolve(data.isPrime); + }); + worker.on('error', reject); + const msg = { + rnd: w, + iterations: iterations, + id: 0 + }; + worker.postMessage(msg); + }); + } + else { + return new Promise((resolve) => { + resolve(_isProbablyPrime(w, iterations)); + }); + } + } +} +function _isProbablyPrime(w, iterations) { + /* + PREFILTERING. Even values but 2 are not primes, so don't test. + 1 is not a prime and the M-R algorithm needs w>1. + */ + if (w === 2n) + return true; + else if ((w & 1n) === 0n || w === 1n) + return false; + /* + Test if any of the first 250 small primes are a factor of w. 2 is not tested because it was already tested above. + */ + const firstPrimes = [ + 3n, + 5n, + 7n, + 11n, + 13n, + 17n, + 19n, + 23n, + 29n, + 31n, + 37n, + 41n, + 43n, + 47n, + 53n, + 59n, + 61n, + 67n, + 71n, + 73n, + 79n, + 83n, + 89n, + 97n, + 101n, + 103n, + 107n, + 109n, + 113n, + 127n, + 131n, + 137n, + 139n, + 149n, + 151n, + 157n, + 163n, + 167n, + 173n, + 179n, + 181n, + 191n, + 193n, + 197n, + 199n, + 211n, + 223n, + 227n, + 229n, + 233n, + 239n, + 241n, + 251n, + 257n, + 263n, + 269n, + 271n, + 277n, + 281n, + 283n, + 293n, + 307n, + 311n, + 313n, + 317n, + 331n, + 337n, + 347n, + 349n, + 353n, + 359n, + 367n, + 373n, + 379n, + 383n, + 389n, + 397n, + 401n, + 409n, + 419n, + 421n, + 431n, + 433n, + 439n, + 443n, + 449n, + 457n, + 461n, + 463n, + 467n, + 479n, + 487n, + 491n, + 499n, + 503n, + 509n, + 521n, + 523n, + 541n, + 547n, + 557n, + 563n, + 569n, + 571n, + 577n, + 587n, + 593n, + 599n, + 601n, + 607n, + 613n, + 617n, + 619n, + 631n, + 641n, + 643n, + 647n, + 653n, + 659n, + 661n, + 673n, + 677n, + 683n, + 691n, + 701n, + 709n, + 719n, + 727n, + 733n, + 739n, + 743n, + 751n, + 757n, + 761n, + 769n, + 773n, + 787n, + 797n, + 809n, + 811n, + 821n, + 823n, + 827n, + 829n, + 839n, + 853n, + 857n, + 859n, + 863n, + 877n, + 881n, + 883n, + 887n, + 907n, + 911n, + 919n, + 929n, + 937n, + 941n, + 947n, + 953n, + 967n, + 971n, + 977n, + 983n, + 991n, + 997n, + 1009n, + 1013n, + 1019n, + 1021n, + 1031n, + 1033n, + 1039n, + 1049n, + 1051n, + 1061n, + 1063n, + 1069n, + 1087n, + 1091n, + 1093n, + 1097n, + 1103n, + 1109n, + 1117n, + 1123n, + 1129n, + 1151n, + 1153n, + 1163n, + 1171n, + 1181n, + 1187n, + 1193n, + 1201n, + 1213n, + 1217n, + 1223n, + 1229n, + 1231n, + 1237n, + 1249n, + 1259n, + 1277n, + 1279n, + 1283n, + 1289n, + 1291n, + 1297n, + 1301n, + 1303n, + 1307n, + 1319n, + 1321n, + 1327n, + 1361n, + 1367n, + 1373n, + 1381n, + 1399n, + 1409n, + 1423n, + 1427n, + 1429n, + 1433n, + 1439n, + 1447n, + 1451n, + 1453n, + 1459n, + 1471n, + 1481n, + 1483n, + 1487n, + 1489n, + 1493n, + 1499n, + 1511n, + 1523n, + 1531n, + 1543n, + 1549n, + 1553n, + 1559n, + 1567n, + 1571n, + 1579n, + 1583n, + 1597n + ]; + for (let i = 0; i < firstPrimes.length && (firstPrimes[i] <= w); i++) { + const p = firstPrimes[i]; + if (w === p) + return true; + else if (w % p === 0n) + return false; + } + /* + 1. Let a be the largest integer such that 2**a divides w−1. + 2. m = (w−1) / 2**a. + 3. wlen = len (w). + 4. For i = 1 to iterations do + 4.1 Obtain a string b of wlen bits from an RBG. + Comment: Ensure that 1 < b < w−1. + 4.2 If ((b ≤ 1) or (b ≥ w−1)), then go to step 4.1. + 4.3 z = b**m mod w. + 4.4 If ((z = 1) or (z = w − 1)), then go to step 4.7. + 4.5 For j = 1 to a − 1 do. + 4.5.1 z = z**2 mod w. + 4.5.2 If (z = w−1), then go to step 4.7. + 4.5.3 If (z = 1), then go to step 4.6. + 4.6 Return COMPOSITE. + 4.7 Continue. + Comment: Increment i for the do-loop in step 4. + 5. Return PROBABLY PRIME. + */ + let a = 0n; + const d = w - 1n; + let aux = d; + while (aux % 2n === 0n) { + aux /= 2n; + ++a; + } + const m = d / (2n ** a); + do { + const b = randBetween(d, 2n); + let z = bigintModArith.modPow(b, m, w); + if (z === 1n || z === d) + continue; + let j = 1; + while (j < a) { + z = bigintModArith.modPow(z, 2n, w); + if (z === d) + break; + if (z === 1n) + return false; + j++; + } + if (z !== d) + return false; + } while (--iterations !== 0); + return true; +} +if (_useWorkers) { // node.js with support for workers + const { parentPort, isMainThread } = require('worker_threads'); // eslint-disable-line + const isWorker = !isMainThread; + /* istanbul ignore if */ + if (isWorker) { // worker + parentPort.on('message', function (data) { + const isPrime = _isProbablyPrime(data.rnd, data.iterations); + const msg = { + isPrime: isPrime, + value: data.rnd, + id: data.id + }; + parentPort.postMessage(msg); + }); + } +} + +/** + * A probably-prime (Miller-Rabin), cryptographically-secure, random-number generator. + * The browser version uses web workers to parallelise prime look up. Therefore, it does not lock the UI + * main process, and it can be much faster (if several cores or cpu are available). + * The node version can also use worker_threads if they are available (enabled by default with Node 11 and + * and can be enabled at runtime executing node --experimental-worker with node >=10.5.0). + * + * @param bitLength - The required bit length for the generated prime + * @param iterations - The number of iterations for the Miller-Rabin Probabilistic Primality Test + * + * @throws {RangeError} + * bitLength MUST be > 0 + * + * @returns A promise that resolves to a bigint probable prime of bitLength bits. + */ +function prime(bitLength, iterations = 16) { + if (bitLength < 1) + throw new RangeError('bitLength MUST be > 0'); + /* istanbul ignore if */ + if (!_useWorkers) { // If there is no support for workers + let rnd = 0n; + do { + rnd = fromBuffer(randBitsSync(bitLength, true)); + } while (!_isProbablyPrime(rnd, iterations)); + return new Promise((resolve) => { resolve(rnd); }); + } + return new Promise((resolve, reject) => { + const workerList = []; + const _onmessage = (msg, newWorker) => { + if (msg.isPrime) { + // if a prime number has been found, stop all the workers, and return it + for (let j = 0; j < workerList.length; j++) { + workerList[j].terminate(); + } + while (workerList.length > 0) { + workerList.pop(); + } + resolve(msg.value); + } + else { // if a composite is found, make the worker test another random number + const buf = randBitsSync(bitLength, true); + const rnd = fromBuffer(buf); + try { + const msgToWorker = { + rnd: rnd, + iterations: iterations, + id: msg.id + }; + newWorker.postMessage(msgToWorker); + } + catch (error) { + // The worker has already terminated. There is nothing to handle here + } + } + }; + { // Node.js + const { cpus } = require('os'); // eslint-disable-line + const { Worker } = require('worker_threads'); // eslint-disable-line + for (let i = 0; i < cpus().length - 1; i++) { + const newWorker = new Worker(__filename); + newWorker.on('message', (msg) => _onmessage(msg, newWorker)); + workerList.push(newWorker); + } + } + for (let i = 0; i < workerList.length; i++) { + randBits(bitLength, true).then(function (buf) { + const rnd = fromBuffer(buf); + workerList[i].postMessage({ + rnd: rnd, + iterations: iterations, + id: i + }); + }).catch(reject); + } + }); +} +/** + * A probably-prime (Miller-Rabin), cryptographically-secure, random-number generator. + * The sync version is NOT RECOMMENDED since it won't use workers and thus it'll be slower and may freeze thw window in browser's javascript. Please consider using prime() instead. + * + * @param bitLength - The required bit length for the generated prime + * @param iterations - The number of iterations for the Miller-Rabin Probabilistic Primality Test + * + * @throws {RangeError} + * bitLength MUST be > 0 + * + * @returns A bigint probable prime of bitLength bits. + */ +function primeSync(bitLength, iterations = 16) { + if (bitLength < 1) + throw new RangeError('bitLength MUST be > 0'); + let rnd = 0n; + do { + rnd = fromBuffer(randBitsSync(bitLength, true)); + } while (!_isProbablyPrime(rnd, iterations)); + return rnd; +} + +Object.defineProperty(exports, 'abs', { + enumerable: true, + get: function () { + return bigintModArith.abs; + } +}); +Object.defineProperty(exports, 'bitLength', { + enumerable: true, + get: function () { + return bigintModArith.bitLength; + } +}); +Object.defineProperty(exports, 'eGcd', { + enumerable: true, + get: function () { + return bigintModArith.eGcd; + } +}); +Object.defineProperty(exports, 'gcd', { + enumerable: true, + get: function () { + return bigintModArith.gcd; + } +}); +Object.defineProperty(exports, 'lcm', { + enumerable: true, + get: function () { + return bigintModArith.lcm; + } +}); +Object.defineProperty(exports, 'max', { + enumerable: true, + get: function () { + return bigintModArith.max; + } +}); +Object.defineProperty(exports, 'min', { + enumerable: true, + get: function () { + return bigintModArith.min; + } +}); +Object.defineProperty(exports, 'modInv', { + enumerable: true, + get: function () { + return bigintModArith.modInv; + } +}); +Object.defineProperty(exports, 'modPow', { + enumerable: true, + get: function () { + return bigintModArith.modPow; + } +}); +Object.defineProperty(exports, 'toZn', { + enumerable: true, + get: function () { + return bigintModArith.toZn; + } +}); +exports.isProbablyPrime = isProbablyPrime; +exports.prime = prime; +exports.primeSync = primeSync; +exports.randBetween = randBetween; +exports.randBits = randBits; +exports.randBitsSync = randBitsSync; +exports.randBytes = randBytes; +exports.randBytesSync = randBytesSync; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.node.js","sources":["../../src/ts/fromBuffer.ts","../../src/ts/randBytes.ts","../../src/ts/randBits.ts","../../src/ts/randBetween.ts","../../src/ts/workerUtils.ts","../../src/ts/isProbablyPrime.ts","../../src/ts/prime.ts"],"sourcesContent":null,"names":["bitLength","modPow"],"mappings":"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J,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QAC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"} diff --git a/docs/API.md b/docs/API.md index 1c77a06..0b8f3aa 100644 --- a/docs/API.md +++ b/docs/API.md @@ -133,7 +133,7 @@ w MUST be >= 0 A promise that resolves to a boolean that is either true (a probably prime number) or false (definitely composite) -Defined in: [src/ts/isProbablyPrime.ts:21](https://github.com/juanelas/bigint-crypto-utils/blob/365e92e/src/ts/isProbablyPrime.ts#L21) +Defined in: [src/ts/isProbablyPrime.ts:21](https://github.com/juanelas/bigint-crypto-utils/blob/9543211/src/ts/isProbablyPrime.ts#L21) ___ @@ -273,7 +273,7 @@ bitLength MUST be > 0 A promise that resolves to a bigint probable prime of bitLength bits. -Defined in: [src/ts/prime.ts:21](https://github.com/juanelas/bigint-crypto-utils/blob/365e92e/src/ts/prime.ts#L21) +Defined in: [src/ts/prime.ts:21](https://github.com/juanelas/bigint-crypto-utils/blob/9543211/src/ts/prime.ts#L21) ___ @@ -298,7 +298,7 @@ bitLength MUST be > 0 A bigint probable prime of bitLength bits. -Defined in: [src/ts/prime.ts:100](https://github.com/juanelas/bigint-crypto-utils/blob/365e92e/src/ts/prime.ts#L100) +Defined in: [src/ts/prime.ts:100](https://github.com/juanelas/bigint-crypto-utils/blob/9543211/src/ts/prime.ts#L100) ___ @@ -322,7 +322,7 @@ Arguments MUST be: max > 0 && min >=0 && max > min A cryptographically secure random bigint between [min,max] -Defined in: [src/ts/randBetween.ts:15](https://github.com/juanelas/bigint-crypto-utils/blob/365e92e/src/ts/randBetween.ts#L15) +Defined in: [src/ts/randBetween.ts:15](https://github.com/juanelas/bigint-crypto-utils/blob/9543211/src/ts/randBetween.ts#L15) ___ @@ -346,7 +346,7 @@ bitLength MUST be > 0 A Promise that resolves to a UInt8Array/Buffer (Browser/Node.js) filled with cryptographically secure random bits -Defined in: [src/ts/randBits.ts:14](https://github.com/juanelas/bigint-crypto-utils/blob/365e92e/src/ts/randBits.ts#L14) +Defined in: [src/ts/randBits.ts:14](https://github.com/juanelas/bigint-crypto-utils/blob/9543211/src/ts/randBits.ts#L14) ___ @@ -370,7 +370,7 @@ bitLength MUST be > 0 A Uint8Array/Buffer (Browser/Node.js) filled with cryptographically secure random bits -Defined in: [src/ts/randBits.ts:45](https://github.com/juanelas/bigint-crypto-utils/blob/365e92e/src/ts/randBits.ts#L45) +Defined in: [src/ts/randBits.ts:45](https://github.com/juanelas/bigint-crypto-utils/blob/9543211/src/ts/randBits.ts#L45) ___ @@ -394,7 +394,7 @@ byteLength MUST be > 0 A promise that resolves to a UInt8Array/Buffer (Browser/Node.js) filled with cryptographically secure random bytes -Defined in: [src/ts/randBytes.ts:12](https://github.com/juanelas/bigint-crypto-utils/blob/365e92e/src/ts/randBytes.ts#L12) +Defined in: [src/ts/randBytes.ts:12](https://github.com/juanelas/bigint-crypto-utils/blob/9543211/src/ts/randBytes.ts#L12) ___ @@ -418,7 +418,7 @@ byteLength MUST be > 0 A UInt8Array/Buffer (Browser/Node.js) filled with cryptographically secure random bytes -Defined in: [src/ts/randBytes.ts:46](https://github.com/juanelas/bigint-crypto-utils/blob/365e92e/src/ts/randBytes.ts#L46) +Defined in: [src/ts/randBytes.ts:46](https://github.com/juanelas/bigint-crypto-utils/blob/9543211/src/ts/randBytes.ts#L46) ___ diff --git a/package.json b/package.json index 194cb9f..8333704 100644 --- a/package.json +++ b/package.json @@ -36,6 +36,7 @@ }, "default": "./dist/esm/index.browser.js" }, + "./node-js": "./dist/cjs/index.node.js", "./esm-browser-bundle": "./dist/bundles/bigint-crypto-utils.esm.js", "./iife-browser-bundle": "./dist/bundles/bigint-crypto-utils.iife.js", "./umd-browser-bundle": "./dist/bundles/bigint-crypto-utils.umd.js", diff --git a/src/docs/index.md b/src/docs/index.md index 954c087..ae987a7 100644 --- a/src/docs/index.md +++ b/src/docs/index.md @@ -26,6 +26,12 @@ Then either require (Node.js CJS): const {{PKG_CAMELCASE}} = require('{{PKG_NAME}}') ``` +> **Node >=10.4 <11**. `bigint-crypto-utils` uses workers to speed up some operations. Workers are enabled by default with Node.js from version 11. In order to use them with Node >=10.4 and <11, you need to execute node with the flag `--experimental-worker`, and require the .js file manually (otherwise .cjs is required by default and would not be supported by the workers) +> +> ```javascript +> const bigintCryptoUtils = require('bigint-crypto-utils/dist/cjs/index.node') // ONLY FOR node >=10.4 <11 ! +> ``` + or import (JavaScript ES module): ```javascript