@mtcute/core 0.1.0 → 0.1.1

package/esm/utils/bigint-utils.js

@@ -1,59 +1,87 @@
-import bigInt from 'big-integer';
-import { randomBytes } from './buffer-utils.js';
+import { bufferToReversed } from './buffer-utils.js';
+/**
+ * Get the minimum number of bits required to represent a number
+ */
+export function bigIntBitLength(n) {
+    // not the fastest way, but at least not .toString(2) and not too complex
+    // taken from: https://stackoverflow.com/a/76616288/22656950
+    const i = (n.toString(16).length - 1) * 4;
+    return i + 32 - Math.clz32(Number(n >> BigInt(i)));
+}
 /**
  * Convert a big integer to a buffer
  *
  * @param value  Value to convert
- * @param length  Length of the resulting buffer (by default it's computed automatically)
+ * @param length  Length of the resulting buffer (by default it's the minimum required)
  * @param le  Whether to use little-endian encoding
  */
 export function bigIntToBuffer(value, length = 0, le = false) {
-    const array = value.toArray(256).value;
-    if (length !== 0 && array.length > length) {
+    const bits = bigIntBitLength(value);
+    const bytes = Math.ceil(bits / 8);
+    if (length !== 0 && bytes > length) {
         throw new Error('Value out of bounds');
     }
-    if (length !== 0) {
-        // padding
-        while (array.length !== length)
-            array.unshift(0);
+    if (length === 0)
+        length = bytes;
+    const buf = new ArrayBuffer(length);
+    const u8 = new Uint8Array(buf);
+    const unaligned = length % 8;
+    const dv = new DataView(buf, 0, length - unaligned);
+    // it is faster to work with 64-bit words than with bytes directly
+    for (let i = 0; i < dv.byteLength; i += 8) {
+        dv.setBigUint64(i, value & 0xffffffffffffffffn, true);
+        value >>= 64n;
     }
-    if (le)
-        array.reverse();
-    const buffer = new Uint8Array(length || array.length);
-    buffer.set(array, 0);
-    return buffer;
+    if (unaligned > 0) {
+        for (let i = length - unaligned; i < length; i++) {
+            u8[i] = Number(value & 0xffn);
+            value >>= 8n;
+        }
+    }
+    if (!le)
+        u8.reverse();
+    return u8;
 }
 /**
  * Convert a buffer to a big integer
  *
  * @param buffer  Buffer to convert
- * @param offset  Offset to start reading from
- * @param length  Length to read
  * @param le  Whether to use little-endian encoding
  */
-export function bufferToBigInt(buffer, offset = 0, length = buffer.length, le = false) {
-    const arr = [...buffer.subarray(offset, offset + length)];
+export function bufferToBigInt(buffer, le = false) {
     if (le)
-        arr.reverse();
-    return bigInt.fromArray(arr, 256);
+        buffer = bufferToReversed(buffer);
+    const unaligned = buffer.length % 8;
+    const dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength - unaligned);
+    let res = 0n;
+    // it is faster to work with 64-bit words than with bytes directly
+    for (let i = 0; i < dv.byteLength; i += 8) {
+        res = (res << 64n) | BigInt(dv.getBigUint64(i, false));
+    }
+    if (unaligned > 0) {
+        for (let i = buffer.length - unaligned; i < buffer.length; i++) {
+            res = (res << 8n) | BigInt(buffer[i]);
+        }
+    }
+    return res;
 }
 /**
- * Generate a random big integer of the given size (in bytes)
+ * Generate a cryptographically safe random big integer of the given size (in bytes)
  * @param size  Size in bytes
  */
-export function randomBigInt(size) {
-    return bufferToBigInt(randomBytes(size));
+export function randomBigInt(crypto, size) {
+    return bufferToBigInt(crypto.randomBytes(size));
 }
 /**
  * Generate a random big integer of the given size (in bits)
  * @param bits
  */
-export function randomBigIntBits(bits) {
-    let num = randomBigInt(Math.ceil(bits / 8));
-    const bitLength = num.bitLength();
-    if (bitLength.gt(bits)) {
-        const toTrim = bigInt.randBetween(bitLength.minus(bits), 8);
-        num = num.shiftRight(toTrim);
+export function randomBigIntBits(crypto, bits) {
+    let num = randomBigInt(crypto, Math.ceil(bits / 8));
+    const bitLength = bigIntBitLength(num);
+    if (bitLength > bits) {
+        const toTrim = bitLength - bits;
+        num >>= BigInt(toTrim);
     }
     return num;
 }
@@ -63,30 +91,100 @@ export function randomBigIntBits(bits) {
  * @param max  Maximum value (exclusive)
  * @param min  Minimum value (inclusive)
  */
-export function randomBigIntInRange(max, min = bigInt.one) {
-    const interval = max.minus(min);
-    if (interval.isNegative())
+export function randomBigIntInRange(crypto, max, min = 1n) {
+    const interval = max - min;
+    if (interval < 0n)
         throw new Error('expected min < max');
-    const byteSize = interval.bitLength().divide(8).toJSNumber();
-    let result = randomBigInt(byteSize);
-    while (result.gt(interval))
-        result = result.minus(interval);
-    return min.plus(result);
+    const byteSize = bigIntBitLength(interval) / 8;
+    let result = randomBigInt(crypto, byteSize);
+    while (result > interval)
+        result -= interval;
+    return min + result;
 }
 /**
  * Compute the multiplicity of 2 in the prime factorization of n
  * @param n
  */
 export function twoMultiplicity(n) {
-    if (n === bigInt.zero)
-        return bigInt.zero;
-    let m = bigInt.zero;
-    let pow = bigInt.one;
+    if (n === 0n)
+        return 0n;
+    let m = 0n;
+    let pow = 1n;
     while (true) {
-        if (!n.and(pow).isZero())
+        if ((n & pow) !== 0n)
             return m;
-        m = m.plus(bigInt.one);
-        pow = pow.shiftLeft(1);
+        m += 1n;
+        pow <<= 1n;
+    }
+}
+export function bigIntMin(a, b) {
+    return a < b ? a : b;
+}
+export function bigIntAbs(a) {
+    return a < 0n ? -a : a;
+}
+export function bigIntGcd(a, b) {
+    // using euclidean algorithm is fast enough on smaller numbers
+    // https://en.wikipedia.org/wiki/Euclidean_algorithm#Implementations
+    while (b !== 0n) {
+        const t = b;
+        b = a % b;
+        a = t;
+    }
+    return a;
+}
+export function bigIntModPow(base, exp, mod) {
+    // using the binary method is good enough for our use case
+    // https://en.wikipedia.org/wiki/Modular_exponentiation#Right-to-left_binary_method
+    base %= mod;
+    let result = 1n;
+    while (exp > 0n) {
+        if (exp % 2n === 1n) {
+            result = (result * base) % mod;
+        }
+        exp >>= 1n;
+        base = base ** 2n % mod;
+    }
+    return result;
+}
+// below code is based on https://github.com/juanelas/bigint-mod-arith, MIT license
+function eGcd(a, b) {
+    let x = 0n;
+    let y = 1n;
+    let u = 1n;
+    let v = 0n;
+    while (a !== 0n) {
+        const q = b / a;
+        const r = b % a;
+        const m = x - u * q;
+        const n = y - v * q;
+        b = a;
+        a = r;
+        x = u;
+        y = v;
+        u = m;
+        v = n;
+    }
+    return [b, x, y];
+}
+function toZn(a, n) {
+    if (typeof a === 'number')
+        a = BigInt(a);
+    if (typeof n === 'number')
+        n = BigInt(n);
+    if (n <= 0n) {
+        throw new RangeError('n must be > 0');
+    }
+    const aZn = a % n;
+    return aZn < 0n ? aZn + n : aZn;
+}
+export function bigIntModInv(a, n) {
+    const [g, x] = eGcd(toZn(a, n), n);
+    if (g !== 1n) {
+        throw new RangeError(`${a.toString()} does not have inverse modulo ${n.toString()}`); // modular inverse does not exist
+    }
+    else {
+        return toZn(x, n);
     }
 }
 //# sourceMappingURL=bigint-utils.js.map

package/esm/utils/bigint-utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"bigint-utils.js","sourceRoot":"","sources":["../../../src/utils/bigint-utils.ts"],"names":[],"mappings":"AAAA,OAAO,MAAsB,MAAM,aAAa,CAAA;AAEhD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAE/C;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,KAAiB,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK;IACpE,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,CAAA;IAEtC,IAAI,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,MAAM,EAAE;QACvC,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAA;KACzC;IAED,IAAI,MAAM,KAAK,CAAC,EAAE;QACd,UAAU;QACV,OAAO,KAAK,CAAC,MAAM,KAAK,MAAM;YAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;KACnD;IAED,IAAI,EAAE;QAAE,KAAK,CAAC,OAAO,EAAE,CAAA;IAEvB,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,CAAA;IACrD,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;IAEpB,OAAO,MAAM,CAAA;AACjB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAAC,MAAkB,EAAE,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,GAAG,KAAK;IAC7F,MAAM,GAAG,GAAG,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,CAAA;IAEzD,IAAI,EAAE;QAAE,GAAG,CAAC,OAAO,EAAE,CAAA;IAErB,OAAO,MAAM,CAAC,SAAS,CAAC,GAA0B,EAAE,GAAG,CAAC,CAAA;AAC5D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY;IACrC,OAAO,cAAc,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAA;AAC5C,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY;IACzC,IAAI,GAAG,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAA;IAE3C,MAAM,SAAS,GAAG,GAAG,CAAC,SAAS,EAAE,CAAA;IAEjC,IAAI,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE;QACpB,MAAM,MAAM,GAAG,MAAM,CAAC,WAAW,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAA;QAC3D,GAAG,GAAG,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;KAC/B;IAED,OAAO,GAAG,CAAA;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAe,EAAE,GAAG,GAAG,MAAM,CAAC,GAAG;IACjE,MAAM,QAAQ,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IAC/B,IAAI,QAAQ,CAAC,UAAU,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAA;IAEhE,MAAM,QAAQ,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,UAAU,EAAE,CAAA;IAE5D,IAAI,MAAM,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;IACnC,OAAO,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC;QAAE,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;IAE3D,OAAO,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;AAC3B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,CAAa;IACzC,IAAI,CAAC,KAAK,MAAM,CAAC,IAAI;QAAE,OAAO,MAAM,CAAC,IAAI,CAAA;IAEzC,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAA;IACnB,IAAI,GAAG,GAAG,MAAM,CAAC,GAAG,CAAA;IAEpB,OAAO,IAAI,EAAE;QACT,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE;YAAE,OAAO,CAAC,CAAA;QAClC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QACtB,GAAG,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;KACzB;AACL,CAAC","sourcesContent":["import bigInt, { BigInteger } from 'big-integer'\n\nimport { randomBytes } from './buffer-utils.js'\n\n/**\n * Convert a big integer to a buffer\n *\n * @param value  Value to convert\n * @param length  Length of the resulting buffer (by default it's computed automatically)\n * @param le  Whether to use little-endian encoding\n */\nexport function bigIntToBuffer(value: BigInteger, length = 0, le = false): Uint8Array {\n    const array = value.toArray(256).value\n\n    if (length !== 0 && array.length > length) {\n        throw new Error('Value out of bounds')\n    }\n\n    if (length !== 0) {\n        // padding\n        while (array.length !== length) array.unshift(0)\n    }\n\n    if (le) array.reverse()\n\n    const buffer = new Uint8Array(length || array.length)\n    buffer.set(array, 0)\n\n    return buffer\n}\n\n/**\n * Convert a buffer to a big integer\n *\n * @param buffer  Buffer to convert\n * @param offset  Offset to start reading from\n * @param length  Length to read\n * @param le  Whether to use little-endian encoding\n */\nexport function bufferToBigInt(buffer: Uint8Array, offset = 0, length = buffer.length, le = false): BigInteger {\n    const arr = [...buffer.subarray(offset, offset + length)]\n\n    if (le) arr.reverse()\n\n    return bigInt.fromArray(arr as unknown as number[], 256)\n}\n\n/**\n * Generate a random big integer of the given size (in bytes)\n * @param size  Size in bytes\n */\nexport function randomBigInt(size: number): BigInteger {\n    return bufferToBigInt(randomBytes(size))\n}\n\n/**\n * Generate a random big integer of the given size (in bits)\n * @param bits\n */\nexport function randomBigIntBits(bits: number): BigInteger {\n    let num = randomBigInt(Math.ceil(bits / 8))\n\n    const bitLength = num.bitLength()\n\n    if (bitLength.gt(bits)) {\n        const toTrim = bigInt.randBetween(bitLength.minus(bits), 8)\n        num = num.shiftRight(toTrim)\n    }\n\n    return num\n}\n\n/**\n * Generate a random big integer in the range [min, max)\n *\n * @param max  Maximum value (exclusive)\n * @param min  Minimum value (inclusive)\n */\nexport function randomBigIntInRange(max: BigInteger, min = bigInt.one): BigInteger {\n    const interval = max.minus(min)\n    if (interval.isNegative()) throw new Error('expected min < max')\n\n    const byteSize = interval.bitLength().divide(8).toJSNumber()\n\n    let result = randomBigInt(byteSize)\n    while (result.gt(interval)) result = result.minus(interval)\n\n    return min.plus(result)\n}\n\n/**\n * Compute the multiplicity of 2 in the prime factorization of n\n * @param n\n */\nexport function twoMultiplicity(n: BigInteger): BigInteger {\n    if (n === bigInt.zero) return bigInt.zero\n\n    let m = bigInt.zero\n    let pow = bigInt.one\n\n    while (true) {\n        if (!n.and(pow).isZero()) return m\n        m = m.plus(bigInt.one)\n        pow = pow.shiftLeft(1)\n    }\n}\n"]}
+{"version":3,"file":"bigint-utils.js","sourceRoot":"","sources":["../../../src/utils/bigint-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { bufferToReversed } from './buffer-utils.js'\nimport { ICryptoProvider } from './crypto/abstract.js'\n\n/**\n * Get the minimum number of bits required to represent a number\n */\nexport function bigIntBitLength(n: bigint) {\n    // not the fastest way, but at least not .toString(2) and not too complex\n    // taken from: https://stackoverflow.com/a/76616288/22656950\n\n    const i = (n.toString(16).length - 1) * 4\n\n    return i + 32 - Math.clz32(Number(n >> BigInt(i)))\n}\n\n/**\n * Convert a big integer to a buffer\n *\n * @param value  Value to convert\n * @param length  Length of the resulting buffer (by default it's the minimum required)\n * @param le  Whether to use little-endian encoding\n */\nexport function bigIntToBuffer(value: bigint, length = 0, le = false): Uint8Array {\n    const bits = bigIntBitLength(value)\n    const bytes = Math.ceil(bits / 8)\n\n    if (length !== 0 && bytes > length) {\n        throw new Error('Value out of bounds')\n    }\n\n    if (length === 0) length = bytes\n\n    const buf = new ArrayBuffer(length)\n    const u8 = new Uint8Array(buf)\n\n    const unaligned = length % 8\n    const dv = new DataView(buf, 0, length - unaligned)\n\n    // it is faster to work with 64-bit words than with bytes directly\n    for (let i = 0; i < dv.byteLength; i += 8) {\n        dv.setBigUint64(i, value & 0xffffffffffffffffn, true)\n        value >>= 64n\n    }\n\n    if (unaligned > 0) {\n        for (let i = length - unaligned; i < length; i++) {\n            u8[i] = Number(value & 0xffn)\n            value >>= 8n\n        }\n    }\n\n    if (!le) u8.reverse()\n\n    return u8\n}\n\n/**\n * Convert a buffer to a big integer\n *\n * @param buffer  Buffer to convert\n * @param le  Whether to use little-endian encoding\n */\nexport function bufferToBigInt(buffer: Uint8Array, le = false): bigint {\n    if (le) buffer = bufferToReversed(buffer)\n\n    const unaligned = buffer.length % 8\n    const dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength - unaligned)\n\n    let res = 0n\n\n    // it is faster to work with 64-bit words than with bytes directly\n    for (let i = 0; i < dv.byteLength; i += 8) {\n        res = (res << 64n) | BigInt(dv.getBigUint64(i, false))\n    }\n\n    if (unaligned > 0) {\n        for (let i = buffer.length - unaligned; i < buffer.length; i++) {\n            res = (res << 8n) | BigInt(buffer[i])\n        }\n    }\n\n    return res\n}\n\n/**\n * Generate a cryptographically safe random big integer of the given size (in bytes)\n * @param size  Size in bytes\n */\nexport function randomBigInt(crypto: ICryptoProvider, size: number): bigint {\n    return bufferToBigInt(crypto.randomBytes(size))\n}\n\n/**\n * Generate a random big integer of the given size (in bits)\n * @param bits\n */\nexport function randomBigIntBits(crypto: ICryptoProvider, bits: number): bigint {\n    let num = randomBigInt(crypto, Math.ceil(bits / 8))\n\n    const bitLength = bigIntBitLength(num)\n\n    if (bitLength > bits) {\n        const toTrim = bitLength - bits\n        num >>= BigInt(toTrim)\n    }\n\n    return num\n}\n\n/**\n * Generate a random big integer in the range [min, max)\n *\n * @param max  Maximum value (exclusive)\n * @param min  Minimum value (inclusive)\n */\nexport function randomBigIntInRange(crypto: ICryptoProvider, max: bigint, min = 1n): bigint {\n    const interval = max - min\n    if (interval < 0n) throw new Error('expected min < max')\n\n    const byteSize = bigIntBitLength(interval) / 8\n\n    let result = randomBigInt(crypto, byteSize)\n    while (result > interval) result -= interval\n\n    return min + result\n}\n\n/**\n * Compute the multiplicity of 2 in the prime factorization of n\n * @param n\n */\nexport function twoMultiplicity(n: bigint): bigint {\n    if (n === 0n) return 0n\n\n    let m = 0n\n    let pow = 1n\n\n    while (true) {\n        if ((n & pow) !== 0n) return m\n        m += 1n\n        pow <<= 1n\n    }\n}\n\nexport function bigIntMin(a: bigint, b: bigint): bigint {\n    return a < b ? a : b\n}\n\nexport function bigIntAbs(a: bigint): bigint {\n    return a < 0n ? -a : a\n}\n\nexport function bigIntGcd(a: bigint, b: bigint): bigint {\n    // using euclidean algorithm is fast enough on smaller numbers\n    // https://en.wikipedia.org/wiki/Euclidean_algorithm#Implementations\n\n    while (b !== 0n) {\n        const t = b\n        b = a % b\n        a = t\n    }\n\n    return a\n}\n\nexport function bigIntModPow(base: bigint, exp: bigint, mod: bigint): bigint {\n    // using the binary method is good enough for our use case\n    // https://en.wikipedia.org/wiki/Modular_exponentiation#Right-to-left_binary_method\n\n    base %= mod\n\n    let result = 1n\n\n    while (exp > 0n) {\n        if (exp % 2n === 1n) {\n            result = (result * base) % mod\n        }\n\n        exp >>= 1n\n        base = base ** 2n % mod\n    }\n\n    return result\n}\n\n// below code is based on https://github.com/juanelas/bigint-mod-arith, MIT license\n\nfunction eGcd(a: bigint, b: bigint): [bigint, bigint, bigint] {\n    let x = 0n\n    let y = 1n\n    let u = 1n\n    let v = 0n\n\n    while (a !== 0n) {\n        const q = b / a\n        const r: bigint = b % a\n        const m = x - u * q\n        const n = y - v * q\n        b = a\n        a = r\n        x = u\n        y = v\n        u = m\n        v = n\n    }\n\n    return [b, x, y]\n}\n\nfunction toZn(a: number | bigint, n: number | bigint): bigint {\n    if (typeof a === 'number') a = BigInt(a)\n    if (typeof n === 'number') n = BigInt(n)\n\n    if (n <= 0n) {\n        throw new RangeError('n must be > 0')\n    }\n\n    const aZn = a % n\n\n    return aZn < 0n ? aZn + n : aZn\n}\n\nexport function bigIntModInv(a: bigint, n: bigint): bigint {\n    const [g, x] = eGcd(toZn(a, n), n)\n\n    if (g !== 1n) {\n        throw new RangeError(`${a.toString()} does not have inverse modulo ${n.toString()}`) // modular inverse does not exist\n    } else {\n        return toZn(x, n)\n    }\n}\n"]}

package/esm/utils/buffer-utils.d.ts

@@ -1,4 +1,3 @@
-export { _randomBytes as randomBytes } from './platform/random.js';
 /**
  * Check if two buffers are equal
  *
@@ -18,4 +17,11 @@ export declare function cloneBuffer(buf: Uint8Array, start?: number, end?: numbe
  * Concatenate multiple buffers into one
  */
 export declare function concatBuffers(buffers: Uint8Array[]): Uint8Array;
+/**
+ * Shortcut for creating a DataView from a Uint8Array
+ */
 export declare function dataViewFromBuffer(buf: Uint8Array): DataView;
+/**
+ * Reverse a buffer (or a part of it) into a new buffer
+ */
+export declare function bufferToReversed(buf: Uint8Array, start?: number, end?: number): Uint8Array;

package/esm/utils/buffer-utils.js

@@ -1,4 +1,3 @@
-export { _randomBytes as randomBytes } from './platform/random.js';
 /**
  * Check if two buffers are equal
  *
@@ -49,7 +48,21 @@ export function concatBuffers(buffers) {
     }
     return ret;
 }
+/**
+ * Shortcut for creating a DataView from a Uint8Array
+ */
 export function dataViewFromBuffer(buf) {
     return new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
 }
+/**
+ * Reverse a buffer (or a part of it) into a new buffer
+ */
+export function bufferToReversed(buf, start = 0, end = buf.length) {
+    const len = end - start;
+    const ret = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+        ret[i] = buf[end - i - 1];
+    }
+    return ret;
+}
 //# sourceMappingURL=buffer-utils.js.map

package/esm/utils/buffer-utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"buffer-utils.js","sourceRoot":"","sources":["../../../src/utils/buffer-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,IAAI,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAElE;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,CAAa,EAAE,CAAa;IACrD,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM;QAAE,OAAO,KAAK,CAAA;IAEvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QAC/B,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAAE,OAAO,KAAK,CAAA;KAClC;IAED,OAAO,IAAI,CAAA;AACf,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,GAAe,EAAE,KAAK,GAAG,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC,MAAM;IACpE,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,GAAG,GAAG,KAAK,CAAC,CAAA;IACvC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAA;IAEjC,OAAO,GAAG,CAAA;AACd,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,OAAqB;IAC/C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,OAAO,CAAC,CAAC,CAAC,CAAA;IAE3C,0CAA0C;IAC1C,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;QAC/B,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;KAChC;IACD,yCAAyC;IAEzC,IAAI,MAAM,GAAG,CAAC,CAAA;IAEd,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE;QACvB,MAAM,IAAI,GAAG,CAAC,MAAM,CAAA;KACvB;IAED,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAA;IAClC,IAAI,MAAM,GAAG,CAAC,CAAA;IAEd,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE;QACvB,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;QACpB,MAAM,IAAI,GAAG,CAAC,MAAM,CAAA;KACvB;IAED,OAAO,GAAG,CAAA;AACd,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,GAAe;IAC9C,OAAO,IAAI,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,CAAA;AACnE,CAAC","sourcesContent":["export { _randomBytes as randomBytes } from './platform/random.js'\n\n/**\n * Check if two buffers are equal\n *\n * @param a  First buffer\n * @param b  Second buffer\n */\nexport function buffersEqual(a: Uint8Array, b: Uint8Array): boolean {\n    if (a.length !== b.length) return false\n\n    for (let i = 0; i < a.length; i++) {\n        if (a[i] !== b[i]) return false\n    }\n\n    return true\n}\n\n/**\n * Copy a buffer\n *\n * @param buf  Buffer to copy\n * @param start  Start offset\n * @param end  End offset\n */\nexport function cloneBuffer(buf: Uint8Array, start = 0, end = buf.length): Uint8Array {\n    const ret = new Uint8Array(end - start)\n    ret.set(buf.subarray(start, end))\n\n    return ret\n}\n\n/**\n * Concatenate multiple buffers into one\n */\nexport function concatBuffers(buffers: Uint8Array[]): Uint8Array {\n    if (buffers.length === 1) return buffers[0]\n\n    /* eslint-disable no-restricted-globals */\n    if (typeof Buffer !== 'undefined') {\n        return Buffer.concat(buffers)\n    }\n    /* eslint-enable no-restricted-globals */\n\n    let length = 0\n\n    for (const buf of buffers) {\n        length += buf.length\n    }\n\n    const ret = new Uint8Array(length)\n    let offset = 0\n\n    for (const buf of buffers) {\n        ret.set(buf, offset)\n        offset += buf.length\n    }\n\n    return ret\n}\n\nexport function dataViewFromBuffer(buf: Uint8Array): DataView {\n    return new DataView(buf.buffer, buf.byteOffset, buf.byteLength)\n}\n"]}
+{"version":3,"file":"buffer-utils.js","sourceRoot":"","sources":["../../../src/utils/buffer-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,CAAa,EAAE,CAAa;IACrD,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM;QAAE,OAAO,KAAK,CAAA;IAEvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QAC/B,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAAE,OAAO,KAAK,CAAA;KAClC;IAED,OAAO,IAAI,CAAA;AACf,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,GAAe,EAAE,KAAK,GAAG,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC,MAAM;IACpE,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,GAAG,GAAG,KAAK,CAAC,CAAA;IACvC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAA;IAEjC,OAAO,GAAG,CAAA;AACd,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,OAAqB;IAC/C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,OAAO,CAAC,CAAC,CAAC,CAAA;IAE3C,0CAA0C;IAC1C,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;QAC/B,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;KAChC;IACD,yCAAyC;IAEzC,IAAI,MAAM,GAAG,CAAC,CAAA;IAEd,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE;QACvB,MAAM,IAAI,GAAG,CAAC,MAAM,CAAA;KACvB;IAED,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAA;IAClC,IAAI,MAAM,GAAG,CAAC,CAAA;IAEd,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE;QACvB,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;QACpB,MAAM,IAAI,GAAG,CAAC,MAAM,CAAA;KACvB;IAED,OAAO,GAAG,CAAA;AACd,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAAC,GAAe;IAC9C,OAAO,IAAI,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,CAAA;AACnE,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAe,EAAE,KAAK,GAAG,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC,MAAM;IACzE,MAAM,GAAG,GAAG,GAAG,GAAG,KAAK,CAAA;IACvB,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,GAAG,CAAC,CAAA;IAE/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;QAC1B,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAA;KAC5B;IAED,OAAO,GAAG,CAAA;AACd,CAAC","sourcesContent":["/**\n * Check if two buffers are equal\n *\n * @param a  First buffer\n * @param b  Second buffer\n */\nexport function buffersEqual(a: Uint8Array, b: Uint8Array): boolean {\n    if (a.length !== b.length) return false\n\n    for (let i = 0; i < a.length; i++) {\n        if (a[i] !== b[i]) return false\n    }\n\n    return true\n}\n\n/**\n * Copy a buffer\n *\n * @param buf  Buffer to copy\n * @param start  Start offset\n * @param end  End offset\n */\nexport function cloneBuffer(buf: Uint8Array, start = 0, end = buf.length): Uint8Array {\n    const ret = new Uint8Array(end - start)\n    ret.set(buf.subarray(start, end))\n\n    return ret\n}\n\n/**\n * Concatenate multiple buffers into one\n */\nexport function concatBuffers(buffers: Uint8Array[]): Uint8Array {\n    if (buffers.length === 1) return buffers[0]\n\n    /* eslint-disable no-restricted-globals */\n    if (typeof Buffer !== 'undefined') {\n        return Buffer.concat(buffers)\n    }\n    /* eslint-enable no-restricted-globals */\n\n    let length = 0\n\n    for (const buf of buffers) {\n        length += buf.length\n    }\n\n    const ret = new Uint8Array(length)\n    let offset = 0\n\n    for (const buf of buffers) {\n        ret.set(buf, offset)\n        offset += buf.length\n    }\n\n    return ret\n}\n\n/**\n * Shortcut for creating a DataView from a Uint8Array\n */\nexport function dataViewFromBuffer(buf: Uint8Array): DataView {\n    return new DataView(buf.buffer, buf.byteOffset, buf.byteLength)\n}\n\n/**\n * Reverse a buffer (or a part of it) into a new buffer\n */\nexport function bufferToReversed(buf: Uint8Array, start = 0, end = buf.length): Uint8Array {\n    const len = end - start\n    const ret = new Uint8Array(len)\n\n    for (let i = 0; i < len; i++) {\n        ret[i] = buf[end - i - 1]\n    }\n\n    return ret\n}\n"]}

package/esm/utils/crypto/abstract.d.ts

@@ -1,23 +1,30 @@
 import { MaybeAsync } from '../../types/index.js';
 export interface IEncryptionScheme {
-    encrypt(data: Uint8Array): MaybeAsync<Uint8Array>;
-    decrypt(data: Uint8Array): MaybeAsync<Uint8Array>;
+    encrypt(data: Uint8Array): Uint8Array;
+    decrypt(data: Uint8Array): Uint8Array;
+}
+export interface IAesCtr {
+    process(data: Uint8Array): Uint8Array;
+    close?(): void;
 }
 export interface ICryptoProvider {
     initialize?(): MaybeAsync<void>;
-    sha1(data: Uint8Array): MaybeAsync<Uint8Array>;
-    sha256(data: Uint8Array): MaybeAsync<Uint8Array>;
+    sha1(data: Uint8Array): Uint8Array;
+    sha256(data: Uint8Array): Uint8Array;
     pbkdf2(password: Uint8Array, salt: Uint8Array, iterations: number, keylen?: number, // = 64
     algo?: string): MaybeAsync<Uint8Array>;
     hmacSha256(data: Uint8Array, key: Uint8Array): MaybeAsync<Uint8Array>;
-    createAesCtr(key: Uint8Array, iv: Uint8Array, encrypt: boolean): MaybeAsync<IEncryptionScheme>;
-    createAesIge(key: Uint8Array, iv: Uint8Array): MaybeAsync<IEncryptionScheme>;
-    createAesEcb(key: Uint8Array): MaybeAsync<IEncryptionScheme>;
+    createAesCtr(key: Uint8Array, iv: Uint8Array, encrypt: boolean): IAesCtr;
+    createAesIge(key: Uint8Array, iv: Uint8Array): IEncryptionScheme;
     factorizePQ(pq: Uint8Array): MaybeAsync<[Uint8Array, Uint8Array]>;
+    gzip(data: Uint8Array, maxSize: number): Uint8Array | null;
+    gunzip(data: Uint8Array): Uint8Array;
+    randomFill(buf: Uint8Array): void;
+    randomBytes(size: number): Uint8Array;
 }
 export declare abstract class BaseCryptoProvider {
-    createAesIge(key: Uint8Array, iv: Uint8Array): MaybeAsync<IEncryptionScheme>;
+    abstract randomFill(buf: Uint8Array): void;
     factorizePQ(pq: Uint8Array): [Uint8Array, Uint8Array];
-    abstract createAesEcb(key: Uint8Array): MaybeAsync<IEncryptionScheme>;
+    randomBytes(size: number): Uint8Array;
 }
 export type CryptoProviderFactory = () => ICryptoProvider;

package/esm/utils/crypto/abstract.js

@@ -1,15 +1,12 @@
-import { AesModeOfOperationIge } from './common.js';
 import { factorizePQSync } from './factorization.js';
 export class BaseCryptoProvider {
-    createAesIge(key, iv) {
-        const ecb = this.createAesEcb(key);
-        if ('then' in ecb) {
-            return ecb.then((ecb) => new AesModeOfOperationIge(key, iv, ecb));
-        }
-        return new AesModeOfOperationIge(key, iv, ecb);
-    }
     factorizePQ(pq) {
-        return factorizePQSync(pq);
+        return factorizePQSync(this, pq);
+    }
+    randomBytes(size) {
+        const buf = new Uint8Array(size);
+        this.randomFill(buf);
+        return buf;
     }
 }
 //# sourceMappingURL=abstract.js.map

package/esm/utils/crypto/abstract.js.map

@@ -1 +1 @@
-{"version":3,"file":"abstract.js","sourceRoot":"","sources":["../../../../src/utils/crypto/abstract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAmCpD,MAAM,OAAgB,kBAAkB;IACpC,YAAY,CAAC,GAAe,EAAE,EAAc;QACxC,MAAM,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAA;QAElC,IAAI,MAAM,IAAI,GAAG,EAAE;YACf,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,qBAAqB,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;SACpE;QAED,OAAO,IAAI,qBAAqB,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,CAAC,CAAA;IAClD,CAAC;IAED,WAAW,CAAC,EAAc;QACtB,OAAO,eAAe,CAAC,EAAE,CAAC,CAAA;IAC9B,CAAC;CAGJ","sourcesContent":["import { MaybeAsync } from '../../types/index.js'\nimport { AesModeOfOperationIge } from './common.js'\nimport { factorizePQSync } from './factorization.js'\n\nexport interface IEncryptionScheme {\n    encrypt(data: Uint8Array): MaybeAsync<Uint8Array>\n\n    decrypt(data: Uint8Array): MaybeAsync<Uint8Array>\n}\n\nexport interface ICryptoProvider {\n    initialize?(): MaybeAsync<void>\n\n    sha1(data: Uint8Array): MaybeAsync<Uint8Array>\n\n    sha256(data: Uint8Array): MaybeAsync<Uint8Array>\n\n    pbkdf2(\n        password: Uint8Array,\n        salt: Uint8Array,\n        iterations: number,\n        keylen?: number, // = 64\n        algo?: string, // sha1 or sha512 (default sha512)\n    ): MaybeAsync<Uint8Array>\n\n    hmacSha256(data: Uint8Array, key: Uint8Array): MaybeAsync<Uint8Array>\n\n    // in telegram, iv is always either used only once, or is the same for all calls for the key\n    createAesCtr(key: Uint8Array, iv: Uint8Array, encrypt: boolean): MaybeAsync<IEncryptionScheme>\n\n    createAesIge(key: Uint8Array, iv: Uint8Array): MaybeAsync<IEncryptionScheme>\n\n    createAesEcb(key: Uint8Array): MaybeAsync<IEncryptionScheme>\n\n    factorizePQ(pq: Uint8Array): MaybeAsync<[Uint8Array, Uint8Array]>\n}\n\nexport abstract class BaseCryptoProvider {\n    createAesIge(key: Uint8Array, iv: Uint8Array): MaybeAsync<IEncryptionScheme> {\n        const ecb = this.createAesEcb(key)\n\n        if ('then' in ecb) {\n            return ecb.then((ecb) => new AesModeOfOperationIge(key, iv, ecb))\n        }\n\n        return new AesModeOfOperationIge(key, iv, ecb)\n    }\n\n    factorizePQ(pq: Uint8Array) {\n        return factorizePQSync(pq)\n    }\n\n    abstract createAesEcb(key: Uint8Array): MaybeAsync<IEncryptionScheme>\n}\n\nexport type CryptoProviderFactory = () => ICryptoProvider\n"]}
+{"version":3,"file":"abstract.js","sourceRoot":"","sources":["../../../../src/utils/crypto/abstract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AA0CpD,MAAM,OAAgB,kBAAkB;IAGpC,WAAW,CAAC,EAAc;QACtB,OAAO,eAAe,CAAC,IAAkC,EAAE,EAAE,CAAC,CAAA;IAClE,CAAC;IAED,WAAW,CAAC,IAAY;QACpB,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,CAAA;QAChC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAA;QAEpB,OAAO,GAAG,CAAA;IACd,CAAC;CACJ","sourcesContent":["import { MaybeAsync } from '../../types/index.js'\nimport { factorizePQSync } from './factorization.js'\n\nexport interface IEncryptionScheme {\n    encrypt(data: Uint8Array): Uint8Array\n    decrypt(data: Uint8Array): Uint8Array\n}\n\nexport interface IAesCtr {\n    process(data: Uint8Array): Uint8Array\n    close?(): void\n}\n\nexport interface ICryptoProvider {\n    initialize?(): MaybeAsync<void>\n\n    sha1(data: Uint8Array): Uint8Array\n\n    sha256(data: Uint8Array): Uint8Array\n\n    pbkdf2(\n        password: Uint8Array,\n        salt: Uint8Array,\n        iterations: number,\n        keylen?: number, // = 64\n        algo?: string, // sha1 or sha512 (default sha512)\n    ): MaybeAsync<Uint8Array>\n\n    hmacSha256(data: Uint8Array, key: Uint8Array): MaybeAsync<Uint8Array>\n\n    createAesCtr(key: Uint8Array, iv: Uint8Array, encrypt: boolean): IAesCtr\n\n    createAesIge(key: Uint8Array, iv: Uint8Array): IEncryptionScheme\n\n    factorizePQ(pq: Uint8Array): MaybeAsync<[Uint8Array, Uint8Array]>\n\n    gzip(data: Uint8Array, maxSize: number): Uint8Array | null\n    gunzip(data: Uint8Array): Uint8Array\n\n    randomFill(buf: Uint8Array): void\n    randomBytes(size: number): Uint8Array\n}\n\nexport abstract class BaseCryptoProvider {\n    abstract randomFill(buf: Uint8Array): void\n\n    factorizePQ(pq: Uint8Array) {\n        return factorizePQSync(this as unknown as ICryptoProvider, pq)\n    }\n\n    randomBytes(size: number) {\n        const buf = new Uint8Array(size)\n        this.randomFill(buf)\n\n        return buf\n    }\n}\n\nexport type CryptoProviderFactory = () => ICryptoProvider\n"]}

package/esm/utils/crypto/factorization.d.ts

@@ -1,5 +1,6 @@
+import { ICryptoProvider } from './abstract.js';
 /**
  * Factorize `p*q` to `p` and `q` synchronously using Brent-Pollard rho algorithm
  * @param pq
  */
-export declare function factorizePQSync(pq: Uint8Array): [Uint8Array, Uint8Array];
+export declare function factorizePQSync(crypto: ICryptoProvider, pq: Uint8Array): [Uint8Array, Uint8Array];

package/esm/utils/crypto/factorization.js

@@ -1,16 +1,15 @@
-import bigInt from 'big-integer';
-import { bigIntToBuffer, bufferToBigInt, randomBigIntInRange } from '../bigint-utils.js';
+import { bigIntAbs, bigIntGcd, bigIntMin, bigIntToBuffer, bufferToBigInt, randomBigIntInRange, } from '../bigint-utils.js';
 /**
  * Factorize `p*q` to `p` and `q` synchronously using Brent-Pollard rho algorithm
  * @param pq
  */
-export function factorizePQSync(pq) {
+export function factorizePQSync(crypto, pq) {
     const pq_ = bufferToBigInt(pq);
-    const n = PollardRhoBrent(pq_);
-    const m = pq_.divide(n);
+    const n = PollardRhoBrent(crypto, pq_);
+    const m = pq_ / n;
     let p;
     let q;
-    if (n.lt(m)) {
+    if (n < m) {
         p = n;
         q = m;
     }
@@ -20,42 +19,38 @@ export function factorizePQSync(pq) {
     }
     return [bigIntToBuffer(p), bigIntToBuffer(q)];
 }
-function PollardRhoBrent(n) {
-    if (n.isEven())
-        return bigInt[2];
-    let y = randomBigIntInRange(n.minus(1));
-    const c = randomBigIntInRange(n.minus(1));
-    const m = randomBigIntInRange(n.minus(1));
-    let g = bigInt.one;
-    let r = bigInt.one;
-    let q = bigInt.one;
+function PollardRhoBrent(crypto, n) {
+    if (n % 2n === 0n)
+        return 2n;
+    let y = randomBigIntInRange(crypto, n - 1n);
+    const c = randomBigIntInRange(crypto, n - 1n);
+    const m = randomBigIntInRange(crypto, n - 1n);
+    let g = 1n;
+    let r = 1n;
+    let q = 1n;
     let ys;
     let x;
-    while (g.eq(bigInt.one)) {
+    while (g === 1n) {
         x = y;
-        for (let i = 0; r.geq(i); i++)
-            y = y.multiply(y).mod(n).plus(c).mod(n);
-        // y = ((y * y) % n + c) % n
-        let k = bigInt.zero;
-        while (k.lt(r) && g.eq(1)) {
+        for (let i = 0; r >= i; i++)
+            y = (((y * y) % n) + c) % n;
+        let k = 0n;
+        while (k < r && g === 1n) {
             ys = y;
-            for (let i = bigInt.zero; i.lt(bigInt.min(m, r.minus(k))); i = i.plus(bigInt.one)) {
-                y = y.multiply(y).mod(n).plus(c).mod(n);
-                q = q.multiply(x.minus(y).abs()).mod(n);
-                // y = (y * y % n + c) % n
-                // q = q * abs(x - y) % n
+            for (let i = 0n; i < bigIntMin(m, r - k); i++) {
+                y = (((y * y) % n) + c) % n;
+                q = (q * bigIntAbs(x - y)) % n;
             }
-            g = bigInt.gcd(q, n);
-            k = k.plus(m);
+            g = bigIntGcd(q, n);
+            k = k + m;
         }
-        r = r.multiply(bigInt[2]);
+        r <<= 1n;
     }
-    if (g.eq(n)) {
+    if (g === n) {
         do {
-            ys = ys.multiply(ys).mod(n).plus(c).mod(n);
-            // ys = ((ys * ys) % n + c) % n
-            g = bigInt.gcd(x.minus(ys), n);
-        } while (g.leq(bigInt.one));
+            ys = (((ys * ys) % n) + c) % n;
+            g = bigIntGcd(x - ys, n);
+        } while (g <= 1n);
     }
     return g;
 }

package/esm/utils/crypto/factorization.js.map

@@ -1 +1 @@
-{"version":3,"file":"factorization.js","sourceRoot":"","sources":["../../../../src/utils/crypto/factorization.ts"],"names":[],"mappings":"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","sourcesContent":["import bigInt, { BigInteger } from 'big-integer'\n\nimport { bigIntToBuffer, bufferToBigInt, randomBigIntInRange } from '../bigint-utils.js'\n\n/**\n * Factorize `p*q` to `p` and `q` synchronously using Brent-Pollard rho algorithm\n * @param pq\n */\nexport function factorizePQSync(pq: Uint8Array): [Uint8Array, Uint8Array] {\n    const pq_ = bufferToBigInt(pq)\n\n    const n = PollardRhoBrent(pq_)\n    const m = pq_.divide(n)\n\n    let p\n    let q\n\n    if (n.lt(m)) {\n        p = n\n        q = m\n    } else {\n        p = m\n        q = n\n    }\n\n    return [bigIntToBuffer(p), bigIntToBuffer(q)]\n}\n\nfunction PollardRhoBrent(n: BigInteger): BigInteger {\n    if (n.isEven()) return bigInt[2]\n\n    let y = randomBigIntInRange(n.minus(1))\n    const c = randomBigIntInRange(n.minus(1))\n    const m = randomBigIntInRange(n.minus(1))\n    let g = bigInt.one\n    let r = bigInt.one\n    let q = bigInt.one\n\n    let ys: BigInteger\n    let x: BigInteger\n\n    while (g.eq(bigInt.one)) {\n        x = y\n        for (let i = 0; r.geq(i); i++) y = y.multiply(y).mod(n).plus(c).mod(n)\n        // y = ((y * y) % n + c) % n\n\n        let k = bigInt.zero\n\n        while (k.lt(r) && g.eq(1)) {\n            ys = y\n\n            for (let i = bigInt.zero; i.lt(bigInt.min(m, r.minus(k))); i = i.plus(bigInt.one)) {\n                y = y.multiply(y).mod(n).plus(c).mod(n)\n                q = q.multiply(x.minus(y).abs()).mod(n)\n                // y = (y * y % n + c) % n\n                // q = q * abs(x - y) % n\n            }\n\n            g = bigInt.gcd(q, n)\n            k = k.plus(m)\n        }\n\n        r = r.multiply(bigInt[2])\n    }\n\n    if (g.eq(n)) {\n        do {\n            ys = ys!.multiply(ys!).mod(n).plus(c).mod(n)\n            // ys = ((ys * ys) % n + c) % n\n\n            g = bigInt.gcd(x!.minus(ys), n)\n        } while (g.leq(bigInt.one))\n    }\n\n    return g\n}\n"]}
+{"version":3,"file":"factorization.js","sourceRoot":"","sources":["../../../../src/utils/crypto/factorization.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,SAAS,EACT,SAAS,EACT,SAAS,EACT,cAAc,EACd,cAAc,EACd,mBAAmB,GACtB,MAAM,oBAAoB,CAAA;AAG3B;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,MAAuB,EAAE,EAAc;IACnE,MAAM,GAAG,GAAG,cAAc,CAAC,EAAE,CAAC,CAAA;IAE9B,MAAM,CAAC,GAAG,eAAe,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACtC,MAAM,CAAC,GAAG,GAAG,GAAG,CAAC,CAAA;IAEjB,IAAI,CAAC,CAAA;IACL,IAAI,CAAC,CAAA;IAEL,IAAI,CAAC,GAAG,CAAC,EAAE;QACP,CAAC,GAAG,CAAC,CAAA;QACL,CAAC,GAAG,CAAC,CAAA;KACR;SAAM;QACH,CAAC,GAAG,CAAC,CAAA;QACL,CAAC,GAAG,CAAC,CAAA;KACR;IAED,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,CAAA;AACjD,CAAC;AAED,SAAS,eAAe,CAAC,MAAuB,EAAE,CAAS;IACvD,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE;QAAE,OAAO,EAAE,CAAA;IAE5B,IAAI,CAAC,GAAG,mBAAmB,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;IAC3C,MAAM,CAAC,GAAG,mBAAmB,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;IAC7C,MAAM,CAAC,GAAG,mBAAmB,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;IAC7C,IAAI,CAAC,GAAG,EAAE,CAAA;IACV,IAAI,CAAC,GAAG,EAAE,CAAA;IACV,IAAI,CAAC,GAAG,EAAE,CAAA;IAEV,IAAI,EAAU,CAAA;IACd,IAAI,CAAS,CAAA;IAEb,OAAO,CAAC,KAAK,EAAE,EAAE;QACb,CAAC,GAAG,CAAC,CAAA;QACL,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE;YAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAA;QAExD,IAAI,CAAC,GAAG,EAAE,CAAA;QAEV,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE;YACtB,EAAE,GAAG,CAAC,CAAA;YAEN,KAAK,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;gBAC3C,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAA;gBAC3B,CAAC,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;aACjC;YAED,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;YACnB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;SACZ;QAED,CAAC,KAAK,EAAE,CAAA;KACX;IAED,IAAI,CAAC,KAAK,CAAC,EAAE;QACT,GAAG;YACC,EAAE,GAAG,CAAC,CAAC,CAAC,EAAG,GAAG,EAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAA;YAEhC,CAAC,GAAG,SAAS,CAAC,CAAE,GAAG,EAAG,EAAE,CAAC,CAAC,CAAA;SAC7B,QAAQ,CAAC,IAAI,EAAE,EAAC;KACpB;IAED,OAAO,CAAC,CAAA;AACZ,CAAC","sourcesContent":["import {\n    bigIntAbs,\n    bigIntGcd,\n    bigIntMin,\n    bigIntToBuffer,\n    bufferToBigInt,\n    randomBigIntInRange,\n} from '../bigint-utils.js'\nimport { ICryptoProvider } from './abstract.js'\n\n/**\n * Factorize `p*q` to `p` and `q` synchronously using Brent-Pollard rho algorithm\n * @param pq\n */\nexport function factorizePQSync(crypto: ICryptoProvider, pq: Uint8Array): [Uint8Array, Uint8Array] {\n    const pq_ = bufferToBigInt(pq)\n\n    const n = PollardRhoBrent(crypto, pq_)\n    const m = pq_ / n\n\n    let p\n    let q\n\n    if (n < m) {\n        p = n\n        q = m\n    } else {\n        p = m\n        q = n\n    }\n\n    return [bigIntToBuffer(p), bigIntToBuffer(q)]\n}\n\nfunction PollardRhoBrent(crypto: ICryptoProvider, n: bigint): bigint {\n    if (n % 2n === 0n) return 2n\n\n    let y = randomBigIntInRange(crypto, n - 1n)\n    const c = randomBigIntInRange(crypto, n - 1n)\n    const m = randomBigIntInRange(crypto, n - 1n)\n    let g = 1n\n    let r = 1n\n    let q = 1n\n\n    let ys: bigint\n    let x: bigint\n\n    while (g === 1n) {\n        x = y\n        for (let i = 0; r >= i; i++) y = (((y * y) % n) + c) % n\n\n        let k = 0n\n\n        while (k < r && g === 1n) {\n            ys = y\n\n            for (let i = 0n; i < bigIntMin(m, r - k); i++) {\n                y = (((y * y) % n) + c) % n\n                q = (q * bigIntAbs(x - y)) % n\n            }\n\n            g = bigIntGcd(q, n)\n            k = k + m\n        }\n\n        r <<= 1n\n    }\n\n    if (g === n) {\n        do {\n            ys = (((ys! * ys!) % n) + c) % n\n\n            g = bigIntGcd(x! - ys!, n)\n        } while (g <= 1n)\n    }\n\n    return g\n}\n"]}

package/esm/utils/crypto/index.d.ts

@@ -1,5 +1,9 @@
 export * from './abstract.js';
+export * from './factorization.js';
 export * from './keys.js';
+export * from './miller-rabin.js';
+export * from './mtproto.js';
 export * from './password.js';
+export * from './utils.js';
 import { CryptoProviderFactory } from './abstract.js';
 export declare const defaultCryptoProviderFactory: CryptoProviderFactory;

package/esm/utils/crypto/index.js

@@ -1,6 +1,10 @@
 export * from './abstract.js';
+export * from './factorization.js';
 export * from './keys.js';
+export * from './miller-rabin.js';
+export * from './mtproto.js';
 export * from './password.js';
+export * from './utils.js';
 import { _defaultCryptoProviderFactory } from '../platform/crypto.js';
 export const defaultCryptoProviderFactory = _defaultCryptoProviderFactory;
 //# sourceMappingURL=index.js.map

package/esm/utils/crypto/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/utils/crypto/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA;AACzB,cAAc,eAAe,CAAA;AAE7B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAA;AAGrE,MAAM,CAAC,MAAM,4BAA4B,GAA0B,6BAA6B,CAAA","sourcesContent":["export * from './abstract.js'\nexport * from './keys.js'\nexport * from './password.js'\n\nimport { _defaultCryptoProviderFactory } from '../platform/crypto.js'\nimport { CryptoProviderFactory } from './abstract.js'\n\nexport const defaultCryptoProviderFactory: CryptoProviderFactory = _defaultCryptoProviderFactory\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/utils/crypto/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,oBAAoB,CAAA;AAClC,cAAc,WAAW,CAAA;AACzB,cAAc,mBAAmB,CAAA;AACjC,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAE1B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAA;AAGrE,MAAM,CAAC,MAAM,4BAA4B,GAA0B,6BAA6B,CAAA","sourcesContent":["export * from './abstract.js'\nexport * from './factorization.js'\nexport * from './keys.js'\nexport * from './miller-rabin.js'\nexport * from './mtproto.js'\nexport * from './password.js'\nexport * from './utils.js'\n\nimport { _defaultCryptoProviderFactory } from '../platform/crypto.js'\nimport { CryptoProviderFactory } from './abstract.js'\n\nexport const defaultCryptoProviderFactory: CryptoProviderFactory = _defaultCryptoProviderFactory\n"]}

package/esm/utils/crypto/keys.d.ts

@@ -9,7 +9,7 @@ import { ICryptoProvider } from './abstract.js';
  * @param key  PEM-encoded RSA public key
  * @param old  Whether this is an "old" key
  */
-export declare function parsePublicKey(crypto: ICryptoProvider, key: string, old?: boolean): Promise<TlPublicKey>;
+export declare function parsePublicKey(crypto: ICryptoProvider, key: string, old?: boolean): TlPublicKey;
 /**
  * Add public key to the global index.
  *
@@ -17,7 +17,7 @@ export declare function parsePublicKey(crypto: ICryptoProvider, key: string, old
  * @param key  PEM-encoded RSA public key
  * @param old  Whether this is an "old" key
  */
-export declare function addPublicKey(crypto: ICryptoProvider, key: string, old?: boolean): Promise<void>;
+export declare function addPublicKey(crypto: ICryptoProvider, key: string, old?: boolean): void;
 /**
  * Get public key by its fingerprint.
  *

package/esm/utils/crypto/keys.js

@@ -9,7 +9,7 @@ import { parseAsn1, parsePemContents } from '../binary/asn1-parser.js';
  * @param key  PEM-encoded RSA public key
  * @param old  Whether this is an "old" key
  */
-export async function parsePublicKey(crypto, key, old = false) {
+export function parsePublicKey(crypto, key, old = false) {
     const asn1 = parseAsn1(parsePemContents(key));
     const modulus = asn1.children?.[0].value;
     const exponent = asn1.children?.[1].value;
@@ -20,7 +20,7 @@ export async function parsePublicKey(crypto, key, old = false) {
     writer.bytes(modulus);
     writer.bytes(exponent);
     const data = writer.result();
-    const sha = await crypto.sha1(data);
+    const sha = crypto.sha1(data);
     const fp = hexEncode(sha.slice(-8).reverse());
     return {
         modulus: hexEncode(modulus),
@@ -36,8 +36,8 @@ export async function parsePublicKey(crypto, key, old = false) {
  * @param key  PEM-encoded RSA public key
  * @param old  Whether this is an "old" key
  */
-export async function addPublicKey(crypto, key, old = false) {
-    const parsed = await parsePublicKey(crypto, key, old);
+export function addPublicKey(crypto, key, old = false) {
+    const parsed = parsePublicKey(crypto, key, old);
     keysIndex[parsed.fingerprint] = parsed;
 }
 /**