From 066352b391140ce31c41d888d1c197d28f99b454 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Hern=C3=A1ndez=20Serrano?= Date: Fri, 19 Apr 2019 12:05:37 +0200 Subject: [PATCH] Working! --- ... => bigint-crypto-utils-latest.browser.js} | 344 +++++++++--------- .../bigint-crypto-utils-latest.browser.min.js | 1 + ...bigint-crypto-utils-latest.browser.mod.js} | 342 +++++++++-------- ...int-crypto-utils-latest.browser.mod.min.js | 1 + ....js => bigint-crypto-utils-latest.node.js} | 254 ++++++------- dist/bigint-utils-latest.browser.min.js | 15 - dist/bigint-utils-latest.browser.mod.min.js | 15 - 7 files changed, 462 insertions(+), 510 deletions(-) rename dist/{bigint-utils-latest.browser.js => bigint-crypto-utils-latest.browser.js} (94%) create mode 100644 dist/bigint-crypto-utils-latest.browser.min.js rename dist/{bigint-utils-latest.browser.mod.js => bigint-crypto-utils-latest.browser.mod.js} (94%) create mode 100644 dist/bigint-crypto-utils-latest.browser.mod.min.js rename dist/{bigint-utils-latest.node.js => bigint-crypto-utils-latest.node.js} (97%) delete mode 100644 dist/bigint-utils-latest.browser.min.js delete mode 100644 dist/bigint-utils-latest.browser.mod.min.js diff --git a/dist/bigint-utils-latest.browser.js b/dist/bigint-crypto-utils-latest.browser.js similarity index 94% rename from dist/bigint-utils-latest.browser.js rename to dist/bigint-crypto-utils-latest.browser.js index eb16d95..fcbb545 100644 --- a/dist/bigint-utils-latest.browser.js +++ b/dist/bigint-crypto-utils-latest.browser.js @@ -1,4 +1,4 @@ -var bigintUtils = (function (exports) { +var bigintCryptoUtils = (function (exports) { 'use strict'; /** @@ -13,64 +13,6 @@ var bigintUtils = (function (exports) { return (a >= BigInt(0)) ? a : -a; }; - /** - * Greatest-common divisor of two integers based on the iterative binary algorithm. - * - * @param {number|bigint} a - * @param {number|bigint} b - * - * @returns {bigint} The greatest common divisor of a and b - */ - const gcd = function (a, b) { - a = abs(a); - b = abs(b); - let shift = BigInt(0); - while (!((a | b) & BigInt(1))) { - a >>= BigInt(1); - b >>= BigInt(1); - shift++; - } - while (!(a & BigInt(1))) a >>= BigInt(1); - do { - while (!(b & BigInt(1))) b >>= BigInt(1); - if (a > b) { - let x = a; - a = b; - b = x; - } - b -= a; - } while (b); - - // rescale - return a << shift; - }; - - /** - * The least common multiple computed as abs(a*b)/gcd(a,b) - * @param {number|bigint} a - * @param {number|bigint} b - * - * @returns {bigint} The least common multiple of a and b - */ - const lcm = function (a, b) { - a = BigInt(a); - b = BigInt(b); - return abs(a * b) / gcd(a, b); - }; - - /** - * Finds the smallest positive element that is congruent to a in modulo n - * @param {number|bigint} a An integer - * @param {number|bigint} n The modulo - * - * @returns {bigint} The smallest positive representation of a in modulo n - */ - const toZn = function (a, n) { - n = BigInt(n); - a = BigInt(a) % n; - return (a < 0) ? a + n : a; - }; - /** * @typedef {Object} egcdReturn A triple (g, x, y), such that ax + by = g = gcd(a, b). * @property {bigint} g @@ -113,6 +55,77 @@ var bigintUtils = (function (exports) { }; }; + /** + * Greatest-common divisor of two integers based on the iterative binary algorithm. + * + * @param {number|bigint} a + * @param {number|bigint} b + * + * @returns {bigint} The greatest common divisor of a and b + */ + const gcd = function (a, b) { + a = abs(a); + b = abs(b); + let shift = BigInt(0); + while (!((a | b) & BigInt(1))) { + a >>= BigInt(1); + b >>= BigInt(1); + shift++; + } + while (!(a & BigInt(1))) a >>= BigInt(1); + do { + while (!(b & BigInt(1))) b >>= BigInt(1); + if (a > b) { + let x = a; + a = b; + b = x; + } + b -= a; + } while (b); + + // rescale + return a << shift; + }; + + /** + * 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 {bigint} w An integer to be tested for primality + * @param {number} iterations The number of iterations for the primality test. The value shall be consistent with Table C.1, C.2 or C.3 + * + * @return {Promise} A promise that resolve to a boolean that is either true (a probably prime number) or false (definitely composite) + */ + const isProbablyPrime = async function (w, iterations = 16) { + { + return new Promise(resolve => { + let worker = _isProbablyPrimeWorker(); + + worker.onmessage = (event) => { + worker.terminate(); + resolve(event.data.isPrime); + }; + + worker.postMessage({ + 'rnd': w, + 'iterations': iterations + }); + }); + } + }; + + /** + * The least common multiple computed as abs(a*b)/gcd(a,b) + * @param {number|bigint} a + * @param {number|bigint} b + * + * @returns {bigint} The least common multiple of a and b + */ + const lcm = function (a, b) { + a = BigInt(a); + b = BigInt(b); + return abs(a * b) / gcd(a, b); + }; + /** * Modular inverse. * @@ -162,29 +175,56 @@ var bigintUtils = (function (exports) { }; /** - * Secure random bytes for both node and browsers. Browser implementation uses WebWorkers in order to not lock the main process + * 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). * - * @param {number} byteLength The desired number of random bytes - * @param {boolean} forceLength If we want to force the output to have a bit length of 8*byteLength. It basically forces the msb to be 1 + * @param {number} bitLength The required bit length for the generated prime + * @param {number} iterations The number of iterations for the Miller-Rabin Probabilistic Primality Test * - * @returns {Promise} A promise that resolves to a Buffer/UInt8Array filled with cryptographically secure random bytes + * @returns {Promise} A promise that resolves to a bigint probable prime of bitLength bits */ - const randBytes = async function (byteLength, forceLength = false) { - return new Promise((resolve) => { - let buf; + const prime = async function (bitLength, iterations = 16) { + return new Promise(async (resolve) => { + { + let workerList = []; + for (let i = 0; i < self.navigator.hardwareConcurrency; i++) { + let newWorker = _isProbablyPrimeWorker(); + newWorker.onmessage = async (event) => { + if (event.data.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) { + workerList.pop(); + } + resolve(event.data.value); + } else { // if a composite is found, make the worker test another random number + let rnd = BigInt(0); + rnd = fromBuffer(await randBytes(bitLength / 8, true)); + newWorker.postMessage({ + 'rnd': rnd, + 'iterations': iterations + }); + } + }; + workerList.push(newWorker); + } + + for (const worker of workerList) { + let rnd = BigInt(0); + rnd = fromBuffer(await randBytes(bitLength / 8, true)); + worker.postMessage({ + 'rnd': rnd, + 'iterations': iterations + }); + } - { // browser - buf = new Uint8Array(byteLength); - self.crypto.getRandomValues(buf); - // 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); } }); }; - /** * Returns a cryptographically secure random integer between [min,max] * @param {bigint} max Returned value will be <= max @@ -214,53 +254,74 @@ var bigintUtils = (function (exports) { }; /** - * 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) + * Secure random bytes for both node and browsers. Node version uses crypto.randomFill() and browser one self.crypto.getRandomValues() * - * @param {bigint} w An integer to be tested for primality - * @param {number} iterations The number of iterations for the primality test. The value shall be consistent with Table C.1, C.2 or C.3 + * @param {number} byteLength The desired number of random bytes + * @param {boolean} forceLength If we want to force the output to have a bit length of 8*byteLength. It basically forces the msb to be 1 * - * @return {Promise} A promise that resolve to a boolean that is either true (a probably prime number) or false (definitely composite) + * @returns {Promise} A promise that resolves to a Buffer/UInt8Array filled with cryptographically secure random bytes */ - const isProbablyPrime = async function (w, iterations = 16) { - { - return new Promise(resolve => { - let worker = _isProbablyPrimeWorker(); + const randBytes = async function (byteLength, forceLength = false) { + return new Promise((resolve) => { + let buf; - worker.onmessage = (event) => { - resolve(event.data.isPrime); - }; - worker.postMessage({ - 'rnd': w, - 'iterations': iterations - }); - }); - } + { // browser + buf = new Uint8Array(byteLength); + self.crypto.getRandomValues(buf); + // 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); + } + }); }; + + /** + * Finds the smallest positive element that is congruent to a in modulo n + * @param {number|bigint} a An integer + * @param {number|bigint} n The modulo + * + * @returns {bigint} The smallest positive representation of a in modulo n + */ + const toZn = function (a, n) { + n = BigInt(n); + a = BigInt(a) % n; + return (a < 0) ? a + n : a; + }; + + + + /* HELPER FUNCTIONS */ + + function fromBuffer(buf) { + let ret = BigInt(0); + for (let i of buf.values()) { + let bi = BigInt(i); + ret = (ret << BigInt(8)) + bi; + } + return ret; + } + + function bitLength(a) { + let bits = 1; + do { + bits++; + } while ((a >>= BigInt(1)) > BigInt(1)); + return bits; + } + function _isProbablyPrimeWorker() { async function _onmessage(event) { // Let's start once we are called // event.data = {rnd: , iterations: } - const isPrime = await isProbablyPrime(event.data.rnd, event.data.iterations, false); + const isPrime = await isProbablyPrime(event.data.rnd, event.data.iterations); postMessage({ 'isPrime': isPrime, 'value': event.data.rnd }); } - let workerCode = `(() => { - 'use strict'; + let workerCode = `(() => {'use strict';const eGcd = ${eGcd.toString()};const modInv = ${modInv.toString()};const modPow = ${modPow.toString()};const toZn = ${toZn.toString()};const randBytes = ${randBytes.toString()};const randBetween = ${randBetween.toString()};const isProbablyPrime = ${_isProbablyPrime.toString()};${bitLength.toString()}${fromBuffer.toString()}onmessage = ${_onmessage.toString()};})()`; - const eGcd = ${eGcd.toString()}; - const modInv = ${modInv.toString()}; - const modPow = ${modPow.toString()}; - const toZn = ${toZn.toString()}; - const randBytes = ${randBytes.toString()}; - const randBetween = ${randBetween.toString()}; - const isProbablyPrime = ${_isProbablyPrime.toString()}; - ${bitLength.toString()} - ${fromBuffer.toString()} - - onmessage = ${_onmessage.toString()}; - })()`; var _blob = new Blob([workerCode], { type: 'text/javascript' }); return new Worker(window.URL.createObjectURL(_blob)); @@ -585,77 +646,6 @@ var bigintUtils = (function (exports) { return true; } - /** - * A probably-prime (Miller-Rabin), cryptographically-secure, random-number generator - * - * @param {number} bitLength The required bit length for the generated prime - * @param {number} iterations The number of iterations for the Miller-Rabin Probabilistic Primality Test - * - * @returns {Promise} A promise that resolves to a bigint probable prime of bitLength bits - */ - const prime = async function (bitLength, iterations = 16) { - return new Promise(async (resolve) => { - { - let workerList = []; - for (let i = 0; i < self.navigator.hardwareConcurrency; i++) { - let newWorker = _isProbablyPrimeWorker(); - newWorker.onmessage = async (event) => { - if (event.data.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) { - workerList.pop(); - } - resolve(event.data.value); - } else { // if a composite is found, make the worker test another random number - let rnd = BigInt(0); - rnd = fromBuffer(await randBytes(bitLength / 8, true)); - newWorker.postMessage({ - 'rnd': rnd, - 'iterations': iterations - }); - } - }; - workerList.push(newWorker); - } - - for (const worker of workerList) { - let rnd = BigInt(0); - rnd = fromBuffer(await randBytes(bitLength / 8, true)); - worker.postMessage({ - 'rnd': rnd, - 'iterations': iterations - }); - } - - } - }); - }; - - - - - /* HELPER FUNCTIONS */ - - function fromBuffer(buf) { - let ret = BigInt(0); - for (let i of buf.values()) { - let bi = BigInt(i); - ret = (ret << BigInt(8)) + bi; - } - return ret; - } - - function bitLength(a) { - let bits = 1; - do { - bits++; - } while ((a >>= BigInt(1)) > BigInt(1)); - return bits; - } - exports.abs = abs; exports.eGcd = eGcd; exports.gcd = gcd; diff --git a/dist/bigint-crypto-utils-latest.browser.min.js b/dist/bigint-crypto-utils-latest.browser.min.js new file mode 100644 index 0000000..20875ac --- /dev/null +++ b/dist/bigint-crypto-utils-latest.browser.min.js @@ -0,0 +1 @@ +var bigintCryptoUtils=function(a){'use strict';function b(a){let b=BigInt(0);for(let c of a.values()){let a=BigInt(c);b=(b<>=BigInt(1))>BigInt(1));return c}function d(){let a=`(() => {'use strict';const eGcd = ${g.toString()};const modInv = ${j.toString()};const modPow = ${k.toString()};const toZn = ${o.toString()};const randBytes = ${m.toString()};const randBetween = ${l.toString()};const isProbablyPrime = ${e.toString()};${c.toString()}${b.toString()}onmessage = ${async function(a){const b=await i(a.data.rnd,a.data.iterations);postMessage({isPrime:b,value:a.data.rnd})}.toString()};})()`;var d=new Blob([a],{type:"text/javascript"});return new Worker(window.URL.createObjectURL(d))}async function e(c,b=16){if(c===BigInt(2))return!0;if((c&BigInt(1))===BigInt(0)||c===BigInt(1))return!1;const e=[3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997,1009,1013,1019,1021,1031,1033,1039,1049,1051,1061,1063,1069,1087,1091,1093,1097,1103,1109,1117,1123,1129,1151,1153,1163,1171,1181,1187,1193,1201,1213,1217,1223,1229,1231,1237,1249,1259,1277,1279,1283,1289,1291,1297,1301,1303,1307,1319,1321,1327,1361,1367,1373,1381,1399,1409,1423,1427,1429,1433,1439,1447,1451,1453,1459,1471,1481,1483,1487,1489,1493,1499,1511,1523,1531,1543,1549,1553,1559,1567,1571,1579,1583,1597];for(let a=0;a=BigInt(0)?b:-b},g=function(c,d){c=BigInt(c),d=BigInt(d);let e=BigInt(0),f=BigInt(1),g=BigInt(1),h=BigInt(0);for(;c!==BigInt(0);){let a=d/c,b=d%c,i=e-g*a,j=f-h*a;d=c,c=b,e=g,f=h,g=i,h=j}return{b:d,x:e,y:f}},h=function(c,d){c=f(c),d=f(d);let e=BigInt(0);for(;!((c|d)&BigInt(1));)c>>=BigInt(1),d>>=BigInt(1),e++;for(;!(c&BigInt(1));)c>>=BigInt(1);do{for(;!(d&BigInt(1));)d>>=BigInt(1);if(c>d){let a=c;c=d,d=a}d-=c}while(d);return c<{let e=d();e.onmessage=a=>{e.terminate(),c(a.data.isPrime)},e.postMessage({rnd:a,iterations:b})})},j=function(b,a){let c=g(b,a);return c.b===BigInt(1)?o(c.x,a):null},k=function(c,d,e){if(e=BigInt(e),c=o(c,e),d=BigInt(d),d>3,h=f-8*g;0a||i{let d;d=new Uint8Array(a),self.crypto.getRandomValues(d),b&&(d[0]|=128),c(d)})},o=function(b,c){return c=BigInt(c),b=BigInt(b)%c,0>b?b+c:b};return a.abs=f,a.eGcd=g,a.gcd=h,a.isProbablyPrime=i,a.lcm=function(c,d){return c=BigInt(c),d=BigInt(d),f(c*d)/h(c,d)},a.modInv=j,a.modPow=k,a.prime=async function(a,c=16){return new Promise(async e=>{{let f=[];for(let g,h=0;h{if(d.data.isPrime){for(let a=0;a= BigInt(0)) ? a : -a; }; -/** - * Greatest-common divisor of two integers based on the iterative binary algorithm. - * - * @param {number|bigint} a - * @param {number|bigint} b - * - * @returns {bigint} The greatest common divisor of a and b - */ -const gcd = function (a, b) { - a = abs(a); - b = abs(b); - let shift = BigInt(0); - while (!((a | b) & BigInt(1))) { - a >>= BigInt(1); - b >>= BigInt(1); - shift++; - } - while (!(a & BigInt(1))) a >>= BigInt(1); - do { - while (!(b & BigInt(1))) b >>= BigInt(1); - if (a > b) { - let x = a; - a = b; - b = x; - } - b -= a; - } while (b); - - // rescale - return a << shift; -}; - -/** - * The least common multiple computed as abs(a*b)/gcd(a,b) - * @param {number|bigint} a - * @param {number|bigint} b - * - * @returns {bigint} The least common multiple of a and b - */ -const lcm = function (a, b) { - a = BigInt(a); - b = BigInt(b); - return abs(a * b) / gcd(a, b); -}; - -/** - * Finds the smallest positive element that is congruent to a in modulo n - * @param {number|bigint} a An integer - * @param {number|bigint} n The modulo - * - * @returns {bigint} The smallest positive representation of a in modulo n - */ -const toZn = function (a, n) { - n = BigInt(n); - a = BigInt(a) % n; - return (a < 0) ? a + n : a; -}; - /** * @typedef {Object} egcdReturn A triple (g, x, y), such that ax + by = g = gcd(a, b). * @property {bigint} g @@ -110,6 +52,77 @@ const eGcd = function (a, b) { }; }; +/** + * Greatest-common divisor of two integers based on the iterative binary algorithm. + * + * @param {number|bigint} a + * @param {number|bigint} b + * + * @returns {bigint} The greatest common divisor of a and b + */ +const gcd = function (a, b) { + a = abs(a); + b = abs(b); + let shift = BigInt(0); + while (!((a | b) & BigInt(1))) { + a >>= BigInt(1); + b >>= BigInt(1); + shift++; + } + while (!(a & BigInt(1))) a >>= BigInt(1); + do { + while (!(b & BigInt(1))) b >>= BigInt(1); + if (a > b) { + let x = a; + a = b; + b = x; + } + b -= a; + } while (b); + + // rescale + return a << shift; +}; + +/** + * 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 {bigint} w An integer to be tested for primality + * @param {number} iterations The number of iterations for the primality test. The value shall be consistent with Table C.1, C.2 or C.3 + * + * @return {Promise} A promise that resolve to a boolean that is either true (a probably prime number) or false (definitely composite) + */ +const isProbablyPrime = async function (w, iterations = 16) { + { + return new Promise(resolve => { + let worker = _isProbablyPrimeWorker(); + + worker.onmessage = (event) => { + worker.terminate(); + resolve(event.data.isPrime); + }; + + worker.postMessage({ + 'rnd': w, + 'iterations': iterations + }); + }); + } +}; + +/** + * The least common multiple computed as abs(a*b)/gcd(a,b) + * @param {number|bigint} a + * @param {number|bigint} b + * + * @returns {bigint} The least common multiple of a and b + */ +const lcm = function (a, b) { + a = BigInt(a); + b = BigInt(b); + return abs(a * b) / gcd(a, b); +}; + /** * Modular inverse. * @@ -159,29 +172,56 @@ const modPow = function (a, b, n) { }; /** - * Secure random bytes for both node and browsers. Browser implementation uses WebWorkers in order to not lock the main process + * 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). * - * @param {number} byteLength The desired number of random bytes - * @param {boolean} forceLength If we want to force the output to have a bit length of 8*byteLength. It basically forces the msb to be 1 + * @param {number} bitLength The required bit length for the generated prime + * @param {number} iterations The number of iterations for the Miller-Rabin Probabilistic Primality Test * - * @returns {Promise} A promise that resolves to a Buffer/UInt8Array filled with cryptographically secure random bytes + * @returns {Promise} A promise that resolves to a bigint probable prime of bitLength bits */ -const randBytes = async function (byteLength, forceLength = false) { - return new Promise((resolve) => { - let buf; +const prime = async function (bitLength, iterations = 16) { + return new Promise(async (resolve) => { + { + let workerList = []; + for (let i = 0; i < self.navigator.hardwareConcurrency; i++) { + let newWorker = _isProbablyPrimeWorker(); + newWorker.onmessage = async (event) => { + if (event.data.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) { + workerList.pop(); + } + resolve(event.data.value); + } else { // if a composite is found, make the worker test another random number + let rnd = BigInt(0); + rnd = fromBuffer(await randBytes(bitLength / 8, true)); + newWorker.postMessage({ + 'rnd': rnd, + 'iterations': iterations + }); + } + }; + workerList.push(newWorker); + } + + for (const worker of workerList) { + let rnd = BigInt(0); + rnd = fromBuffer(await randBytes(bitLength / 8, true)); + worker.postMessage({ + 'rnd': rnd, + 'iterations': iterations + }); + } - { // browser - buf = new Uint8Array(byteLength); - self.crypto.getRandomValues(buf); - // 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); } }); }; - /** * Returns a cryptographically secure random integer between [min,max] * @param {bigint} max Returned value will be <= max @@ -211,53 +251,74 @@ const randBetween = async function (max, min = 1) { }; /** - * 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) + * Secure random bytes for both node and browsers. Node version uses crypto.randomFill() and browser one self.crypto.getRandomValues() * - * @param {bigint} w An integer to be tested for primality - * @param {number} iterations The number of iterations for the primality test. The value shall be consistent with Table C.1, C.2 or C.3 + * @param {number} byteLength The desired number of random bytes + * @param {boolean} forceLength If we want to force the output to have a bit length of 8*byteLength. It basically forces the msb to be 1 * - * @return {Promise} A promise that resolve to a boolean that is either true (a probably prime number) or false (definitely composite) + * @returns {Promise} A promise that resolves to a Buffer/UInt8Array filled with cryptographically secure random bytes */ -const isProbablyPrime = async function (w, iterations = 16) { - { - return new Promise(resolve => { - let worker = _isProbablyPrimeWorker(); +const randBytes = async function (byteLength, forceLength = false) { + return new Promise((resolve) => { + let buf; - worker.onmessage = (event) => { - resolve(event.data.isPrime); - }; - worker.postMessage({ - 'rnd': w, - 'iterations': iterations - }); - }); - } + { // browser + buf = new Uint8Array(byteLength); + self.crypto.getRandomValues(buf); + // 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); + } + }); }; + +/** + * Finds the smallest positive element that is congruent to a in modulo n + * @param {number|bigint} a An integer + * @param {number|bigint} n The modulo + * + * @returns {bigint} The smallest positive representation of a in modulo n + */ +const toZn = function (a, n) { + n = BigInt(n); + a = BigInt(a) % n; + return (a < 0) ? a + n : a; +}; + + + +/* HELPER FUNCTIONS */ + +function fromBuffer(buf) { + let ret = BigInt(0); + for (let i of buf.values()) { + let bi = BigInt(i); + ret = (ret << BigInt(8)) + bi; + } + return ret; +} + +function bitLength(a) { + let bits = 1; + do { + bits++; + } while ((a >>= BigInt(1)) > BigInt(1)); + return bits; +} + function _isProbablyPrimeWorker() { async function _onmessage(event) { // Let's start once we are called // event.data = {rnd: , iterations: } - const isPrime = await isProbablyPrime(event.data.rnd, event.data.iterations, false); + const isPrime = await isProbablyPrime(event.data.rnd, event.data.iterations); postMessage({ 'isPrime': isPrime, 'value': event.data.rnd }); } - let workerCode = `(() => { - 'use strict'; + let workerCode = `(() => {'use strict';const eGcd = ${eGcd.toString()};const modInv = ${modInv.toString()};const modPow = ${modPow.toString()};const toZn = ${toZn.toString()};const randBytes = ${randBytes.toString()};const randBetween = ${randBetween.toString()};const isProbablyPrime = ${_isProbablyPrime.toString()};${bitLength.toString()}${fromBuffer.toString()}onmessage = ${_onmessage.toString()};})()`; - const eGcd = ${eGcd.toString()}; - const modInv = ${modInv.toString()}; - const modPow = ${modPow.toString()}; - const toZn = ${toZn.toString()}; - const randBytes = ${randBytes.toString()}; - const randBetween = ${randBetween.toString()}; - const isProbablyPrime = ${_isProbablyPrime.toString()}; - ${bitLength.toString()} - ${fromBuffer.toString()} - - onmessage = ${_onmessage.toString()}; - })()`; var _blob = new Blob([workerCode], { type: 'text/javascript' }); return new Worker(window.URL.createObjectURL(_blob)); @@ -582,75 +643,4 @@ async function _isProbablyPrime(w, iterations = 16) { return true; } -/** - * A probably-prime (Miller-Rabin), cryptographically-secure, random-number generator - * - * @param {number} bitLength The required bit length for the generated prime - * @param {number} iterations The number of iterations for the Miller-Rabin Probabilistic Primality Test - * - * @returns {Promise} A promise that resolves to a bigint probable prime of bitLength bits - */ -const prime = async function (bitLength, iterations = 16) { - return new Promise(async (resolve) => { - { - let workerList = []; - for (let i = 0; i < self.navigator.hardwareConcurrency; i++) { - let newWorker = _isProbablyPrimeWorker(); - newWorker.onmessage = async (event) => { - if (event.data.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) { - workerList.pop(); - } - resolve(event.data.value); - } else { // if a composite is found, make the worker test another random number - let rnd = BigInt(0); - rnd = fromBuffer(await randBytes(bitLength / 8, true)); - newWorker.postMessage({ - 'rnd': rnd, - 'iterations': iterations - }); - } - }; - workerList.push(newWorker); - } - - for (const worker of workerList) { - let rnd = BigInt(0); - rnd = fromBuffer(await randBytes(bitLength / 8, true)); - worker.postMessage({ - 'rnd': rnd, - 'iterations': iterations - }); - } - - } - }); -}; - - - - -/* HELPER FUNCTIONS */ - -function fromBuffer(buf) { - let ret = BigInt(0); - for (let i of buf.values()) { - let bi = BigInt(i); - ret = (ret << BigInt(8)) + bi; - } - return ret; -} - -function bitLength(a) { - let bits = 1; - do { - bits++; - } while ((a >>= BigInt(1)) > BigInt(1)); - return bits; -} - export { abs, eGcd, gcd, isProbablyPrime, lcm, modInv, modPow, prime, randBetween, randBytes, toZn }; diff --git a/dist/bigint-crypto-utils-latest.browser.mod.min.js b/dist/bigint-crypto-utils-latest.browser.mod.min.js new file mode 100644 index 0000000..c50f7c0 --- /dev/null +++ b/dist/bigint-crypto-utils-latest.browser.mod.min.js @@ -0,0 +1 @@ +const abs=function(b){return b=BigInt(b),b>=BigInt(0)?b:-b},eGcd=function(c,d){c=BigInt(c),d=BigInt(d);let e=BigInt(0),f=BigInt(1),g=BigInt(1),h=BigInt(0);for(;c!==BigInt(0);){let a=d/c,b=d%c,i=e-g*a,j=f-h*a;d=c,c=b,e=g,f=h,g=i,h=j}return{b:d,x:e,y:f}},gcd=function(c,d){c=abs(c),d=abs(d);let e=BigInt(0);for(;!((c|d)&BigInt(1));)c>>=BigInt(1),d>>=BigInt(1),e++;for(;!(c&BigInt(1));)c>>=BigInt(1);do{for(;!(d&BigInt(1));)d>>=BigInt(1);if(c>d){let a=c;c=d,d=a}d-=c}while(d);return c<{let d=_isProbablyPrimeWorker();d.onmessage=a=>{d.terminate(),c(a.data.isPrime)},d.postMessage({rnd:a,iterations:b})})},lcm=function(c,d){return c=BigInt(c),d=BigInt(d),abs(c*d)/gcd(c,d)},modInv=function(b,a){let c=eGcd(b,a);return c.b===BigInt(1)?toZn(c.x,a):null},modPow=function(c,d,e){if(e=BigInt(e),c=toZn(c,e),d=BigInt(d),d{{let d=[];for(let e,f=0;f{if(f.data.isPrime){for(let a=0;a>3,f=d-8*e;0a||g{let d;d=new Uint8Array(a),self.crypto.getRandomValues(d),b&&(d[0]|=128),c(d)})},toZn=function(b,c){return c=BigInt(c),b=BigInt(b)%c,0>b?b+c:b};function fromBuffer(a){let b=BigInt(0);for(let c of a.values()){let a=BigInt(c);b=(b<>=BigInt(1))>BigInt(1));return c}function _isProbablyPrimeWorker(){let a=`(() => {'use strict';const eGcd = ${eGcd.toString()};const modInv = ${modInv.toString()};const modPow = ${modPow.toString()};const toZn = ${toZn.toString()};const randBytes = ${randBytes.toString()};const randBetween = ${randBetween.toString()};const isProbablyPrime = ${_isProbablyPrime.toString()};${bitLength.toString()}${fromBuffer.toString()}onmessage = ${async function(a){const b=await isProbablyPrime(a.data.rnd,a.data.iterations);postMessage({isPrime:b,value:a.data.rnd})}.toString()};})()`;var b=new Blob([a],{type:"text/javascript"});return new Worker(window.URL.createObjectURL(b))}async function _isProbablyPrime(c,b=16){if(c===BigInt(2))return!0;if((c&BigInt(1))===BigInt(0)||c===BigInt(1))return!1;const e=[3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997,1009,1013,1019,1021,1031,1033,1039,1049,1051,1061,1063,1069,1087,1091,1093,1097,1103,1109,1117,1123,1129,1151,1153,1163,1171,1181,1187,1193,1201,1213,1217,1223,1229,1231,1237,1249,1259,1277,1279,1283,1289,1291,1297,1301,1303,1307,1319,1321,1327,1361,1367,1373,1381,1399,1409,1423,1427,1429,1433,1439,1447,1451,1453,1459,1471,1481,1483,1487,1489,1493,1499,1511,1523,1531,1543,1549,1553,1559,1567,1571,1579,1583,1597];for(let a=0;a= BigInt(0)) ? a : -a; }; -/** - * Greatest-common divisor of two integers based on the iterative binary algorithm. - * - * @param {number|bigint} a - * @param {number|bigint} b - * - * @returns {bigint} The greatest common divisor of a and b - */ -const gcd = function (a, b) { - a = abs(a); - b = abs(b); - let shift = BigInt(0); - while (!((a | b) & BigInt(1))) { - a >>= BigInt(1); - b >>= BigInt(1); - shift++; - } - while (!(a & BigInt(1))) a >>= BigInt(1); - do { - while (!(b & BigInt(1))) b >>= BigInt(1); - if (a > b) { - let x = a; - a = b; - b = x; - } - b -= a; - } while (b); - - // rescale - return a << shift; -}; - -/** - * The least common multiple computed as abs(a*b)/gcd(a,b) - * @param {number|bigint} a - * @param {number|bigint} b - * - * @returns {bigint} The least common multiple of a and b - */ -const lcm = function (a, b) { - a = BigInt(a); - b = BigInt(b); - return abs(a * b) / gcd(a, b); -}; - -/** - * Finds the smallest positive element that is congruent to a in modulo n - * @param {number|bigint} a An integer - * @param {number|bigint} n The modulo - * - * @returns {bigint} The smallest positive representation of a in modulo n - */ -const toZn = function (a, n) { - n = BigInt(n); - a = BigInt(a) % n; - return (a < 0) ? a + n : a; -}; - /** * @typedef {Object} egcdReturn A triple (g, x, y), such that ax + by = g = gcd(a, b). * @property {bigint} g @@ -114,6 +56,65 @@ const eGcd = function (a, b) { }; }; +/** + * Greatest-common divisor of two integers based on the iterative binary algorithm. + * + * @param {number|bigint} a + * @param {number|bigint} b + * + * @returns {bigint} The greatest common divisor of a and b + */ +const gcd = function (a, b) { + a = abs(a); + b = abs(b); + let shift = BigInt(0); + while (!((a | b) & BigInt(1))) { + a >>= BigInt(1); + b >>= BigInt(1); + shift++; + } + while (!(a & BigInt(1))) a >>= BigInt(1); + do { + while (!(b & BigInt(1))) b >>= BigInt(1); + if (a > b) { + let x = a; + a = b; + b = x; + } + b -= a; + } while (b); + + // rescale + return a << shift; +}; + +/** + * 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 {bigint} w An integer to be tested for primality + * @param {number} iterations The number of iterations for the primality test. The value shall be consistent with Table C.1, C.2 or C.3 + * + * @return {Promise} A promise that resolve to a boolean that is either true (a probably prime number) or false (definitely composite) + */ +const isProbablyPrime = async function (w, iterations = 16) { + { + return _isProbablyPrime(w, iterations); + } +}; + +/** + * The least common multiple computed as abs(a*b)/gcd(a,b) + * @param {number|bigint} a + * @param {number|bigint} b + * + * @returns {bigint} The least common multiple of a and b + */ +const lcm = function (a, b) { + a = BigInt(a); + b = BigInt(b); + return abs(a * b) / gcd(a, b); +}; + /** * Modular inverse. * @@ -163,32 +164,27 @@ const modPow = function (a, b, n) { }; /** - * Secure random bytes for both node and browsers. Browser implementation uses WebWorkers in order to not lock the main process + * 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). * - * @param {number} byteLength The desired number of random bytes - * @param {boolean} forceLength If we want to force the output to have a bit length of 8*byteLength. It basically forces the msb to be 1 + * @param {number} bitLength The required bit length for the generated prime + * @param {number} iterations The number of iterations for the Miller-Rabin Probabilistic Primality Test * - * @returns {Promise} A promise that resolves to a Buffer/UInt8Array filled with cryptographically secure random bytes + * @returns {Promise} A promise that resolves to a bigint probable prime of bitLength bits */ -const randBytes = async function (byteLength, forceLength = false) { - return new Promise((resolve) => { - let buf; - - { // node - const crypto = require('crypto'); - buf = Buffer.alloc(byteLength); - crypto.randomFill(buf, (err, buf) => { - // 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); - }); +const prime = async function (bitLength, iterations = 16) { + return new Promise(async (resolve) => { + { + let rnd = BigInt(0); + do { + rnd = fromBuffer(await randBytes(bitLength / 8, true)); + } while (! await isProbablyPrime(rnd, iterations)); + resolve(rnd); } }); }; - /** * Returns a cryptographically secure random integer between [min,max] * @param {bigint} max Returned value will be <= max @@ -218,19 +214,65 @@ const randBetween = async function (max, min = 1) { }; /** - * 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) + * Secure random bytes for both node and browsers. Node version uses crypto.randomFill() and browser one self.crypto.getRandomValues() * - * @param {bigint} w An integer to be tested for primality - * @param {number} iterations The number of iterations for the primality test. The value shall be consistent with Table C.1, C.2 or C.3 + * @param {number} byteLength The desired number of random bytes + * @param {boolean} forceLength If we want to force the output to have a bit length of 8*byteLength. It basically forces the msb to be 1 * - * @return {Promise} A promise that resolve to a boolean that is either true (a probably prime number) or false (definitely composite) + * @returns {Promise} A promise that resolves to a Buffer/UInt8Array filled with cryptographically secure random bytes */ -const isProbablyPrime = async function (w, iterations = 16) { - { - return _isProbablyPrime(w, iterations); - } +const randBytes = async function (byteLength, forceLength = false) { + return new Promise((resolve) => { + let buf; + + { // node + const crypto = require('crypto'); + buf = Buffer.alloc(byteLength); + crypto.randomFill(buf, (err, buf) => { + // 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); + }); + } + }); }; +/** + * Finds the smallest positive element that is congruent to a in modulo n + * @param {number|bigint} a An integer + * @param {number|bigint} n The modulo + * + * @returns {bigint} The smallest positive representation of a in modulo n + */ +const toZn = function (a, n) { + n = BigInt(n); + a = BigInt(a) % n; + return (a < 0) ? a + n : a; +}; + + + +/* HELPER FUNCTIONS */ + +function fromBuffer(buf) { + let ret = BigInt(0); + for (let i of buf.values()) { + let bi = BigInt(i); + ret = (ret << BigInt(8)) + bi; + } + return ret; +} + +function bitLength(a) { + let bits = 1; + do { + bits++; + } while ((a >>= BigInt(1)) > BigInt(1)); + return bits; +} + async function _isProbablyPrime(w, iterations = 16) { /* PREFILTERING. Even values but 2 are not primes, so don't test. @@ -550,48 +592,6 @@ async function _isProbablyPrime(w, iterations = 16) { return true; } -/** - * A probably-prime (Miller-Rabin), cryptographically-secure, random-number generator - * - * @param {number} bitLength The required bit length for the generated prime - * @param {number} iterations The number of iterations for the Miller-Rabin Probabilistic Primality Test - * - * @returns {Promise} A promise that resolves to a bigint probable prime of bitLength bits - */ -const prime = async function (bitLength, iterations = 16) { - return new Promise(async (resolve) => { - { - let rnd = BigInt(0); - do { - rnd = fromBuffer(await randBytes(bitLength / 8, true)); - } while (! await isProbablyPrime(rnd, iterations)); - resolve(rnd); - } - }); -}; - - - - -/* HELPER FUNCTIONS */ - -function fromBuffer(buf) { - let ret = BigInt(0); - for (let i of buf.values()) { - let bi = BigInt(i); - ret = (ret << BigInt(8)) + bi; - } - return ret; -} - -function bitLength(a) { - let bits = 1; - do { - bits++; - } while ((a >>= BigInt(1)) > BigInt(1)); - return bits; -} - exports.abs = abs; exports.eGcd = eGcd; exports.gcd = gcd; diff --git a/dist/bigint-utils-latest.browser.min.js b/dist/bigint-utils-latest.browser.min.js deleted file mode 100644 index 2e89ca3..0000000 --- a/dist/bigint-utils-latest.browser.min.js +++ /dev/null @@ -1,15 +0,0 @@ -var bigintUtils=function(a){'use strict';function b(){let a=`(() => { - 'use strict'; - - const eGcd = ${i.toString()}; - const modInv = ${j.toString()}; - const modPow = ${k.toString()}; - const toZn = ${h.toString()}; - const randBytes = ${l.toString()}; - const randBetween = ${n.toString()}; - const isProbablyPrime = ${c.toString()}; - ${e.toString()} - ${d.toString()} - - onmessage = ${async function(a){const b=await o(a.data.rnd,a.data.iterations,!1);postMessage({isPrime:b,value:a.data.rnd})}.toString()}; - })()`;var b=new Blob([a],{type:"text/javascript"});return new Worker(window.URL.createObjectURL(b))}async function c(c,b=16){if(c===BigInt(2))return!0;if((c&BigInt(1))===BigInt(0)||c===BigInt(1))return!1;const e=[3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997,1009,1013,1019,1021,1031,1033,1039,1049,1051,1061,1063,1069,1087,1091,1093,1097,1103,1109,1117,1123,1129,1151,1153,1163,1171,1181,1187,1193,1201,1213,1217,1223,1229,1231,1237,1249,1259,1277,1279,1283,1289,1291,1297,1301,1303,1307,1319,1321,1327,1361,1367,1373,1381,1399,1409,1423,1427,1429,1433,1439,1447,1451,1453,1459,1471,1481,1483,1487,1489,1493,1499,1511,1523,1531,1543,1549,1553,1559,1567,1571,1579,1583,1597];for(let a=0;a>=BigInt(1))>BigInt(1));return c}const f=function(b){return b=BigInt(b),b>=BigInt(0)?b:-b},g=function(c,d){c=f(c),d=f(d);let e=BigInt(0);for(;!((c|d)&BigInt(1));)c>>=BigInt(1),d>>=BigInt(1),e++;for(;!(c&BigInt(1));)c>>=BigInt(1);do{for(;!(d&BigInt(1));)d>>=BigInt(1);if(c>d){let a=c;c=d,d=a}d-=c}while(d);return c<b?b+c:b},i=function(c,d){c=BigInt(c),d=BigInt(d);let e=BigInt(0),f=BigInt(1),g=BigInt(1),h=BigInt(0);for(;c!==BigInt(0);){let a=d/c,b=d%c,i=e-g*a,j=f-h*a;d=c,c=b,e=g,f=h,g=i,h=j}return{b:d,x:e,y:f}},j=function(b,a){let c=i(b,a);return c.b===BigInt(1)?h(c.x,a):null},k=function(c,d,e){if(e=BigInt(e),c=h(c,e),d=BigInt(d),d{let d;d=new Uint8Array(a),self.crypto.getRandomValues(d),b&&(d[0]|=128),c(d)})},n=async function(a,b=1){let c,f=e(a),g=f>>3,h=f-8*g;0a||i{let e=b();e.onmessage=a=>{d(a.data.isPrime)},e.postMessage({rnd:a,iterations:c})})};return a.abs=f,a.eGcd=i,a.gcd=g,a.isProbablyPrime=o,a.lcm=function(c,d){return c=BigInt(c),d=BigInt(d),f(c*d)/g(c,d)},a.modInv=j,a.modPow=k,a.prime=async function(a,c=16){return new Promise(async e=>{{let f=[];for(let g,h=0;h{if(b.data.isPrime){for(let a=0;a=BigInt(0)?b:-b},gcd=function(c,d){c=abs(c),d=abs(d);let e=BigInt(0);for(;!((c|d)&BigInt(1));)c>>=BigInt(1),d>>=BigInt(1),e++;for(;!(c&BigInt(1));)c>>=BigInt(1);do{for(;!(d&BigInt(1));)d>>=BigInt(1);if(c>d){let a=c;c=d,d=a}d-=c}while(d);return c<b?b+c:b},eGcd=function(c,d){c=BigInt(c),d=BigInt(d);let e=BigInt(0),f=BigInt(1),g=BigInt(1),h=BigInt(0);for(;c!==BigInt(0);){let a=d/c,b=d%c,i=e-g*a,j=f-h*a;d=c,c=b,e=g,f=h,g=i,h=j}return{b:d,x:e,y:f}},modInv=function(b,a){let c=eGcd(b,a);return c.b===BigInt(1)?toZn(c.x,a):null},modPow=function(c,d,e){if(e=BigInt(e),c=toZn(c,e),d=BigInt(d),d{let d;d=new Uint8Array(a),self.crypto.getRandomValues(d),b&&(d[0]|=128),c(d)})},randBetween=async function(a,b=1){let c,d=bitLength(a),e=d>>3,f=d-8*e;0a||g{let d=_isProbablyPrimeWorker();d.onmessage=a=>{c(a.data.isPrime)},d.postMessage({rnd:a,iterations:b})})};function _isProbablyPrimeWorker(){let a=`(() => { - 'use strict'; - - const eGcd = ${eGcd.toString()}; - const modInv = ${modInv.toString()}; - const modPow = ${modPow.toString()}; - const toZn = ${toZn.toString()}; - const randBytes = ${randBytes.toString()}; - const randBetween = ${randBetween.toString()}; - const isProbablyPrime = ${_isProbablyPrime.toString()}; - ${bitLength.toString()} - ${fromBuffer.toString()} - - onmessage = ${async function(a){const b=await isProbablyPrime(a.data.rnd,a.data.iterations,!1);postMessage({isPrime:b,value:a.data.rnd})}.toString()}; - })()`;var b=new Blob([a],{type:"text/javascript"});return new Worker(window.URL.createObjectURL(b))}async function _isProbablyPrime(c,b=16){if(c===BigInt(2))return!0;if((c&BigInt(1))===BigInt(0)||c===BigInt(1))return!1;const e=[3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997,1009,1013,1019,1021,1031,1033,1039,1049,1051,1061,1063,1069,1087,1091,1093,1097,1103,1109,1117,1123,1129,1151,1153,1163,1171,1181,1187,1193,1201,1213,1217,1223,1229,1231,1237,1249,1259,1277,1279,1283,1289,1291,1297,1301,1303,1307,1319,1321,1327,1361,1367,1373,1381,1399,1409,1423,1427,1429,1433,1439,1447,1451,1453,1459,1471,1481,1483,1487,1489,1493,1499,1511,1523,1531,1543,1549,1553,1559,1567,1571,1579,1583,1597];for(let a=0;a{{let d=[];for(let e,f=0;f{if(f.data.isPrime){for(let a=0;a>=BigInt(1))>BigInt(1));return c}export{abs,eGcd,gcd,isProbablyPrime,lcm,modInv,modPow,prime,randBetween,randBytes,toZn};