@mtcute/core 0.1.0

package/esm/utils/bigint-utils.js

@@ -0,0 +1,92 @@
+import bigInt from 'big-integer';
+import { randomBytes } from './buffer-utils.js';
+/**
+ * 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 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) {
+        throw new Error('Value out of bounds');
+    }
+    if (length !== 0) {
+        // padding
+        while (array.length !== length)
+            array.unshift(0);
+    }
+    if (le)
+        array.reverse();
+    const buffer = new Uint8Array(length || array.length);
+    buffer.set(array, 0);
+    return buffer;
+}
+/**
+ * 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)];
+    if (le)
+        arr.reverse();
+    return bigInt.fromArray(arr, 256);
+}
+/**
+ * Generate a random big integer of the given size (in bytes)
+ * @param size  Size in bytes
+ */
+export function randomBigInt(size) {
+    return bufferToBigInt(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);
+    }
+    return num;
+}
+/**
+ * Generate a random big integer in the range [min, max)
+ *
+ * @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())
+        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);
+}
+/**
+ * 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;
+    while (true) {
+        if (!n.and(pow).isZero())
+            return m;
+        m = m.plus(bigInt.one);
+        pow = pow.shiftLeft(1);
+    }
+}
+//# sourceMappingURL=bigint-utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bigint-utils.js","sourceRoot":"","sources":["../../../src/utils/bigint-utils.ts"],"names":[],"mappings":"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","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"]}

package/esm/utils/binary/asn1-parser.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Parses a single PEM block to buffer.
+ * In fact just strips begin/end tags and parses the rest as Base64
+ */
+export declare function parsePemContents(pem: string): Uint8Array;
+interface Asn1Object {
+    type: number;
+    lengthSize: number;
+    length: number;
+    children?: Asn1Object[];
+    value?: Uint8Array;
+}
+/**
+ * Parses ASN.1 data to an object
+ */
+export declare function parseAsn1(data: Uint8Array): Asn1Object;
+export {};

package/esm/utils/binary/asn1-parser.js

@@ -0,0 +1,116 @@
+// all available libraries either suck or are extremely large for the use case, so i made my own~
+import { base64DecodeToBuffer, hexEncode } from '@mtcute/tl-runtime';
+/**
+ * Parses a single PEM block to buffer.
+ * In fact just strips begin/end tags and parses the rest as Base64
+ */
+export function parsePemContents(pem) {
+    return base64DecodeToBuffer(pem.replace(/^-----(BEGIN|END)( RSA)? PUBLIC KEY-----$|\n/gm, ''));
+}
+const ELOOPN = 102;
+const ELOOP = `iterated over ${ELOOPN} elements (probably a malformed file)`;
+const EDEEPN = 60;
+const EDEEP = `element nested over ${EDEEPN} layers deep (probably a malformed file)`;
+// Container Types are Sequence 0x30, Container Array? (0xA0, 0xA1)
+// Value Types are Boolean 0x01, Integer 0x02, Null 0x05, Object ID 0x06, String 0x0C, 0x16, 0x13, 0x1e
+// Value Array? (0x82)
+// Bit String (0x03) and Octet String (0x04) may be values or containers
+// Sometimes Bit String is used as a container (RSA Pub Spki)
+const CTYPES = {
+    '48': true,
+    '49': true,
+    '160': true,
+    '161': true,
+};
+const VTYPES = {
+    '1': true,
+    '2': true,
+    '5': true,
+    '6': true,
+    '12': true,
+    '130': true,
+};
+/**
+ * Parses ASN.1 data to an object
+ */
+export function parseAsn1(data) {
+    function parseAsn1Inner(buf, depth, eager = false) {
+        if (depth.length >= EDEEPN) {
+            throw new Error(EDEEP);
+        }
+        let index = 2; // we know, at minimum, data starts after type (0) and lengthSize (1)
+        const asn1 = { type: buf[0], lengthSize: 0, length: buf[1] };
+        let child;
+        let iters = 0;
+        let adjust = 0;
+        let adjustedLen = 0;
+        // Determine how many bytes the length uses, and what it is
+        if (0x80 & asn1.length) {
+            asn1.lengthSize = 0x7f & asn1.length;
+            // I think that buf->hex->int solves the problem of Endianness... not sure
+            asn1.length = parseInt(hexEncode(buf.subarray(index, index + asn1.lengthSize)), 16);
+            index += asn1.lengthSize;
+        }
+        // High-order bit Integers have a leading 0x00 to signify that they are positive.
+        // Bit Streams use the first byte to signify padding, which x.509 doesn't use.
+        if (buf[index] === 0x00 && (asn1.type === 0x02 || asn1.type === 0x03)) {
+            // However, 0x00 on its own is a valid number
+            if (asn1.length > 1) {
+                index += 1;
+                adjust = -1;
+            }
+        }
+        adjustedLen = asn1.length + adjust;
+        function parseChildren(eager = false) {
+            asn1.children = [];
+            while (iters < ELOOPN && index < 2 + asn1.length + asn1.lengthSize) {
+                iters += 1;
+                depth.length += 1;
+                child = parseAsn1Inner(buf.subarray(index, index + adjustedLen), depth, eager);
+                depth.length -= 1;
+                // The numbers don't match up exactly and I don't remember why...
+                // probably something with adjustedLen or some such, but the tests pass
+                index += 2 + child.lengthSize + child.length;
+                if (index > 2 + asn1.lengthSize + asn1.length) {
+                    throw new Error(`Parse error: child value length (${child.length}) is ` +
+                        `greater than remaining parent length (${asn1.length - index} = ${asn1.length} - ${index})`);
+                }
+                asn1.children.push(child);
+            }
+            if (index !== 2 + asn1.lengthSize + asn1.length) {
+                throw new Error('Unexpected EOF');
+            }
+            if (iters >= ELOOPN) {
+                throw new Error(ELOOP);
+            }
+            delete asn1.value;
+            return asn1;
+        }
+        // Recurse into types that are _always_ containers
+        if (CTYPES[asn1.type]) {
+            return parseChildren(eager);
+        }
+        // Return types that are _always_ values
+        asn1.value = buf.subarray(index, index + adjustedLen);
+        if (VTYPES[asn1.type]) {
+            return asn1;
+        }
+        // For ambiguous / unknown types, recurse and return on failure
+        // (and return child array size to zero)
+        try {
+            return parseChildren(true);
+        }
+        catch (e) {
+            if (asn1.children)
+                asn1.children.length = 0;
+            return asn1;
+        }
+    }
+    const asn1 = parseAsn1Inner(data, []);
+    const len = data.length;
+    if (len !== 2 + asn1.lengthSize + asn1.length) {
+        throw new Error('Length of buffer does not match length of ASN.1 sequence.');
+    }
+    return asn1;
+}
+//# sourceMappingURL=asn1-parser.js.map

package/esm/utils/binary/asn1-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"asn1-parser.js","sourceRoot":"","sources":["../../../../src/utils/binary/asn1-parser.ts"],"names":[],"mappings":"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","sourcesContent":["// all available libraries either suck or are extremely large for the use case, so i made my own~\n\nimport { base64DecodeToBuffer, hexEncode } from '@mtcute/tl-runtime'\n\n/**\n * Parses a single PEM block to buffer.\n * In fact just strips begin/end tags and parses the rest as Base64\n */\nexport function parsePemContents(pem: string): Uint8Array {\n    return base64DecodeToBuffer(pem.replace(/^-----(BEGIN|END)( RSA)? PUBLIC KEY-----$|\\n/gm, ''))\n}\n\n// based on https://git.coolaj86.com/coolaj86/asn1-parser.js/src/branch/master/asn1-parser.js\n// but modified for typescript and node buffers\n\ninterface Asn1Object {\n    type: number\n    lengthSize: number\n    length: number\n    children?: Asn1Object[]\n    value?: Uint8Array\n}\n\nconst ELOOPN = 102\nconst ELOOP = `iterated over ${ELOOPN} elements (probably a malformed file)`\nconst EDEEPN = 60\nconst EDEEP = `element nested over ${EDEEPN} layers deep (probably a malformed file)`\n\n// Container Types are Sequence 0x30, Container Array? (0xA0, 0xA1)\n// Value Types are Boolean 0x01, Integer 0x02, Null 0x05, Object ID 0x06, String 0x0C, 0x16, 0x13, 0x1e\n// Value Array? (0x82)\n// Bit String (0x03) and Octet String (0x04) may be values or containers\n// Sometimes Bit String is used as a container (RSA Pub Spki)\nconst CTYPES: Record<number, true> = {\n    '48': true,\n    '49': true,\n    '160': true,\n    '161': true,\n}\nconst VTYPES: Record<number, true> = {\n    '1': true,\n    '2': true,\n    '5': true,\n    '6': true,\n    '12': true,\n    '130': true,\n}\n\n/**\n * Parses ASN.1 data to an object\n */\nexport function parseAsn1(data: Uint8Array): Asn1Object {\n    function parseAsn1Inner(buf: Uint8Array, depth: number[], eager = false) {\n        if (depth.length >= EDEEPN) {\n            throw new Error(EDEEP)\n        }\n\n        let index = 2 // we know, at minimum, data starts after type (0) and lengthSize (1)\n        const asn1: Asn1Object = { type: buf[0], lengthSize: 0, length: buf[1] }\n        let child\n        let iters = 0\n        let adjust = 0\n        let adjustedLen = 0\n\n        // Determine how many bytes the length uses, and what it is\n        if (0x80 & asn1.length) {\n            asn1.lengthSize = 0x7f & asn1.length\n            // I think that buf->hex->int solves the problem of Endianness... not sure\n            asn1.length = parseInt(hexEncode(buf.subarray(index, index + asn1.lengthSize)), 16)\n            index += asn1.lengthSize\n        }\n\n        // High-order bit Integers have a leading 0x00 to signify that they are positive.\n        // Bit Streams use the first byte to signify padding, which x.509 doesn't use.\n        if (buf[index] === 0x00 && (asn1.type === 0x02 || asn1.type === 0x03)) {\n            // However, 0x00 on its own is a valid number\n            if (asn1.length > 1) {\n                index += 1\n                adjust = -1\n            }\n        }\n        adjustedLen = asn1.length + adjust\n\n        function parseChildren(eager = false) {\n            asn1.children = []\n\n            while (iters < ELOOPN && index < 2 + asn1.length + asn1.lengthSize) {\n                iters += 1\n                depth.length += 1\n                child = parseAsn1Inner(buf.subarray(index, index + adjustedLen), depth, eager)\n                depth.length -= 1\n                // The numbers don't match up exactly and I don't remember why...\n                // probably something with adjustedLen or some such, but the tests pass\n                index += 2 + child.lengthSize + child.length\n\n                if (index > 2 + asn1.lengthSize + asn1.length) {\n                    throw new Error(\n                        `Parse error: child value length (${child.length}) is ` +\n                            `greater than remaining parent length (${asn1.length - index} = ${asn1.length} - ${index})`,\n                    )\n                }\n                asn1.children.push(child)\n            }\n            if (index !== 2 + asn1.lengthSize + asn1.length) {\n                throw new Error('Unexpected EOF')\n            }\n            if (iters >= ELOOPN) {\n                throw new Error(ELOOP)\n            }\n\n            delete asn1.value\n\n            return asn1\n        }\n\n        // Recurse into types that are _always_ containers\n        if (CTYPES[asn1.type]) {\n            return parseChildren(eager)\n        }\n\n        // Return types that are _always_ values\n        asn1.value = buf.subarray(index, index + adjustedLen)\n\n        if (VTYPES[asn1.type]) {\n            return asn1\n        }\n\n        // For ambiguous / unknown types, recurse and return on failure\n        // (and return child array size to zero)\n        try {\n            return parseChildren(true)\n        } catch (e) {\n            if (asn1.children) asn1.children.length = 0\n\n            return asn1\n        }\n    }\n\n    const asn1 = parseAsn1Inner(data, [])\n    const len = data.length\n\n    if (len !== 2 + asn1.lengthSize + asn1.length) {\n        throw new Error('Length of buffer does not match length of ASN.1 sequence.')\n    }\n\n    return asn1\n}\n"]}

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

@@ -0,0 +1,21 @@
+export { _randomBytes as randomBytes } from './platform/random.js';
+/**
+ * Check if two buffers are equal
+ *
+ * @param a  First buffer
+ * @param b  Second buffer
+ */
+export declare function buffersEqual(a: Uint8Array, b: Uint8Array): boolean;
+/**
+ * Copy a buffer
+ *
+ * @param buf  Buffer to copy
+ * @param start  Start offset
+ * @param end  End offset
+ */
+export declare function cloneBuffer(buf: Uint8Array, start?: number, end?: number): Uint8Array;
+/**
+ * Concatenate multiple buffers into one
+ */
+export declare function concatBuffers(buffers: Uint8Array[]): Uint8Array;
+export declare function dataViewFromBuffer(buf: Uint8Array): DataView;

package/esm/utils/buffer-utils.js

@@ -0,0 +1,55 @@
+export { _randomBytes as randomBytes } from './platform/random.js';
+/**
+ * Check if two buffers are equal
+ *
+ * @param a  First buffer
+ * @param b  Second buffer
+ */
+export function buffersEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+/**
+ * Copy a buffer
+ *
+ * @param buf  Buffer to copy
+ * @param start  Start offset
+ * @param end  End offset
+ */
+export function cloneBuffer(buf, start = 0, end = buf.length) {
+    const ret = new Uint8Array(end - start);
+    ret.set(buf.subarray(start, end));
+    return ret;
+}
+/**
+ * Concatenate multiple buffers into one
+ */
+export function concatBuffers(buffers) {
+    if (buffers.length === 1)
+        return buffers[0];
+    /* eslint-disable no-restricted-globals */
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.concat(buffers);
+    }
+    /* eslint-enable no-restricted-globals */
+    let length = 0;
+    for (const buf of buffers) {
+        length += buf.length;
+    }
+    const ret = new Uint8Array(length);
+    let offset = 0;
+    for (const buf of buffers) {
+        ret.set(buf, offset);
+        offset += buf.length;
+    }
+    return ret;
+}
+export function dataViewFromBuffer(buf) {
+    return new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+//# sourceMappingURL=buffer-utils.js.map

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

@@ -0,0 +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"]}

package/esm/utils/condition-variable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Class implementing a condition variable like behaviour.
+ */
+export declare class ConditionVariable {
+    private _notify?;
+    private _timeout?;
+    wait(timeout?: number): Promise<void>;
+    notify(): void;
+}

package/esm/utils/condition-variable.js

@@ -0,0 +1,24 @@
+/**
+ * Class implementing a condition variable like behaviour.
+ */
+export class ConditionVariable {
+    wait(timeout) {
+        const prom = new Promise((resolve) => {
+            this._notify = resolve;
+        });
+        if (timeout) {
+            this._timeout = setTimeout(() => {
+                this._notify?.();
+                this._timeout = undefined;
+            }, timeout);
+        }
+        return prom;
+    }
+    notify() {
+        this._notify?.();
+        if (this._timeout)
+            clearTimeout(this._timeout);
+        this._notify = undefined;
+    }
+}
+//# sourceMappingURL=condition-variable.js.map

package/esm/utils/condition-variable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"condition-variable.js","sourceRoot":"","sources":["../../../src/utils/condition-variable.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,OAAO,iBAAiB;IAI1B,IAAI,CAAC,OAAgB;QACjB,MAAM,IAAI,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YACvC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QAC1B,CAAC,CAAC,CAAA;QAEF,IAAI,OAAO,EAAE;YACT,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC5B,IAAI,CAAC,OAAO,EAAE,EAAE,CAAA;gBAChB,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAA;YAC7B,CAAC,EAAE,OAAO,CAAC,CAAA;SACd;QAED,OAAO,IAAI,CAAA;IACf,CAAC;IAED,MAAM;QACF,IAAI,CAAC,OAAO,EAAE,EAAE,CAAA;QAChB,IAAI,IAAI,CAAC,QAAQ;YAAE,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QAC9C,IAAI,CAAC,OAAO,GAAG,SAAS,CAAA;IAC5B,CAAC;CACJ","sourcesContent":["/**\n * Class implementing a condition variable like behaviour.\n */\nexport class ConditionVariable {\n    private _notify?: () => void\n    private _timeout?: NodeJS.Timeout\n\n    wait(timeout?: number): Promise<void> {\n        const prom = new Promise<void>((resolve) => {\n            this._notify = resolve\n        })\n\n        if (timeout) {\n            this._timeout = setTimeout(() => {\n                this._notify?.()\n                this._timeout = undefined\n            }, timeout)\n        }\n\n        return prom\n    }\n\n    notify(): void {\n        this._notify?.()\n        if (this._timeout) clearTimeout(this._timeout)\n        this._notify = undefined\n    }\n}\n"]}

package/esm/utils/controllable-promise.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A promise that can be resolved or rejected from outside.
+ */
+export type ControllablePromise<T = unknown> = Promise<T> & {
+    resolve(val: T): void;
+    reject(err?: unknown): void;
+};
+/**
+ * The promise was cancelled
+ */
+export declare class PromiseCancelledError extends Error {
+}
+/**
+ * Creates a promise that can be resolved or rejected from outside.
+ */
+export declare function createControllablePromise<T = unknown>(): ControllablePromise<T>;

package/esm/utils/controllable-promise.js

@@ -0,0 +1,20 @@
+/**
+ * The promise was cancelled
+ */
+export class PromiseCancelledError extends Error {
+}
+/**
+ * Creates a promise that can be resolved or rejected from outside.
+ */
+export function createControllablePromise() {
+    let _resolve;
+    let _reject;
+    const promise = new Promise((resolve, reject) => {
+        _resolve = resolve;
+        _reject = reject;
+    });
+    promise.resolve = _resolve;
+    promise.reject = _reject;
+    return promise;
+}
+//# sourceMappingURL=controllable-promise.js.map

package/esm/utils/controllable-promise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"controllable-promise.js","sourceRoot":"","sources":["../../../src/utils/controllable-promise.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,MAAM,OAAO,qBAAsB,SAAQ,KAAK;CAAG;AAEnD;;GAEG;AACH,MAAM,UAAU,yBAAyB;IACrC,IAAI,QAA2C,CAAA;IAC/C,IAAI,OAAyC,CAAA;IAC7C,MAAM,OAAO,GAAG,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAC/C,QAAQ,GAAG,OAAO,CAAA;QAClB,OAAO,GAAG,MAAM,CAAA;IACpB,CAAC,CAAC,CAGD;IAAC,OAAkC,CAAC,OAAO,GAAG,QAAS,CACvD;IAAC,OAAkC,CAAC,MAAM,GAAG,OAAQ,CAAA;IAEtD,OAAO,OAAiC,CAAA;AAC5C,CAAC","sourcesContent":["/**\n * A promise that can be resolved or rejected from outside.\n */\nexport type ControllablePromise<T = unknown> = Promise<T> & {\n    resolve(val: T): void\n    reject(err?: unknown): void\n}\n\n/**\n * The promise was cancelled\n */\nexport class PromiseCancelledError extends Error {}\n\n/**\n * Creates a promise that can be resolved or rejected from outside.\n */\nexport function createControllablePromise<T = unknown>(): ControllablePromise<T> {\n    let _resolve: ControllablePromise<T>['resolve']\n    let _reject: ControllablePromise<T>['reject']\n    const promise = new Promise<T>((resolve, reject) => {\n        _resolve = resolve\n        _reject = reject\n    })\n    // ts doesn't like this, but it's fine\n\n    ;(promise as ControllablePromise<T>).resolve = _resolve!\n    ;(promise as ControllablePromise<T>).reject = _reject!\n\n    return promise as ControllablePromise<T>\n}\n"]}

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

@@ -0,0 +1,23 @@
+import { MaybeAsync } from '../../types/index.js';
+export interface IEncryptionScheme {
+    encrypt(data: Uint8Array): MaybeAsync<Uint8Array>;
+    decrypt(data: Uint8Array): MaybeAsync<Uint8Array>;
+}
+export interface ICryptoProvider {
+    initialize?(): MaybeAsync<void>;
+    sha1(data: Uint8Array): MaybeAsync<Uint8Array>;
+    sha256(data: Uint8Array): MaybeAsync<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>;
+    factorizePQ(pq: Uint8Array): MaybeAsync<[Uint8Array, Uint8Array]>;
+}
+export declare abstract class BaseCryptoProvider {
+    createAesIge(key: Uint8Array, iv: Uint8Array): MaybeAsync<IEncryptionScheme>;
+    factorizePQ(pq: Uint8Array): [Uint8Array, Uint8Array];
+    abstract createAesEcb(key: Uint8Array): MaybeAsync<IEncryptionScheme>;
+}
+export type CryptoProviderFactory = () => ICryptoProvider;

package/esm/utils/crypto/abstract.js

@@ -0,0 +1,15 @@
+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);
+    }
+}
+//# sourceMappingURL=abstract.js.map

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

@@ -0,0 +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"]}

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

@@ -0,0 +1,12 @@
+import type { IEncryptionScheme } from './abstract.js';
+/**
+ * AES mode of operation IGE implementation in JS
+ */
+export declare class AesModeOfOperationIge implements IEncryptionScheme {
+    private _key;
+    private _iv;
+    private _aes;
+    constructor(key: Uint8Array, iv: Uint8Array, ecb: IEncryptionScheme);
+    encrypt(data: Uint8Array): Promise<Uint8Array>;
+    decrypt(data: Uint8Array): Promise<Uint8Array>;
+}

package/esm/utils/crypto/common.js

@@ -0,0 +1,50 @@
+import { xorBufferInPlace } from './utils.js';
+/**
+ * AES mode of operation IGE implementation in JS
+ */
+export class AesModeOfOperationIge {
+    constructor(key, iv, ecb) {
+        this._key = key;
+        this._iv = iv;
+        this._aes = ecb;
+    }
+    async encrypt(data) {
+        if (data.length % 16 !== 0) {
+            throw new Error('invalid plaintext size (must be multiple of 16 bytes)');
+        }
+        const ciphertext = new Uint8Array(data.length);
+        let block = new Uint8Array(16);
+        let iv1 = this._iv.subarray(0, 16);
+        let iv2 = this._iv.subarray(16, 32);
+        for (let i = 0; i < data.length; i += 16) {
+            block.set(data.subarray(i, i + 16));
+            xorBufferInPlace(block, iv1);
+            block = await this._aes.encrypt(block);
+            xorBufferInPlace(block, iv2);
+            ciphertext.set(block, i);
+            iv1 = ciphertext.subarray(i, i + 16);
+            iv2 = data.subarray(i, i + 16);
+        }
+        return ciphertext;
+    }
+    async decrypt(data) {
+        if (data.length % 16 !== 0) {
+            throw new Error('invalid ciphertext size (must be multiple of 16 bytes)');
+        }
+        const plaintext = new Uint8Array(data.length);
+        let block = new Uint8Array(16);
+        let iv1 = this._iv.subarray(16, 32);
+        let iv2 = this._iv.subarray(0, 16);
+        for (let i = 0; i < data.length; i += 16) {
+            block.set(data.subarray(i, i + 16));
+            xorBufferInPlace(block, iv1);
+            block = await this._aes.decrypt(block);
+            xorBufferInPlace(block, iv2);
+            plaintext.set(block, i);
+            iv1 = plaintext.subarray(i, i + 16);
+            iv2 = data.subarray(i, i + 16);
+        }
+        return plaintext;
+    }
+}
+//# sourceMappingURL=common.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../../src/utils/crypto/common.ts"],"names":[],"mappings":"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","sourcesContent":["import type { IEncryptionScheme } from './abstract.js'\nimport { xorBufferInPlace } from './utils.js'\n\n/**\n * AES mode of operation IGE implementation in JS\n */\nexport class AesModeOfOperationIge implements IEncryptionScheme {\n    private _key: Uint8Array\n    private _iv: Uint8Array\n    private _aes: IEncryptionScheme\n\n    constructor(key: Uint8Array, iv: Uint8Array, ecb: IEncryptionScheme) {\n        this._key = key\n        this._iv = iv\n        this._aes = ecb\n    }\n\n    async encrypt(data: Uint8Array): Promise<Uint8Array> {\n        if (data.length % 16 !== 0) {\n            throw new Error('invalid plaintext size (must be multiple of 16 bytes)')\n        }\n\n        const ciphertext = new Uint8Array(data.length)\n        let block = new Uint8Array(16)\n\n        let iv1 = this._iv.subarray(0, 16)\n        let iv2 = this._iv.subarray(16, 32)\n\n        for (let i = 0; i < data.length; i += 16) {\n            block.set(data.subarray(i, i + 16))\n            xorBufferInPlace(block, iv1)\n            block = await this._aes.encrypt(block)\n            xorBufferInPlace(block, iv2)\n            ciphertext.set(block, i)\n\n            iv1 = ciphertext.subarray(i, i + 16)\n            iv2 = data.subarray(i, i + 16)\n        }\n\n        return ciphertext\n    }\n\n    async decrypt(data: Uint8Array): Promise<Uint8Array> {\n        if (data.length % 16 !== 0) {\n            throw new Error('invalid ciphertext size (must be multiple of 16 bytes)')\n        }\n\n        const plaintext = new Uint8Array(data.length)\n        let block = new Uint8Array(16)\n\n        let iv1 = this._iv.subarray(16, 32)\n        let iv2 = this._iv.subarray(0, 16)\n\n        for (let i = 0; i < data.length; i += 16) {\n            block.set(data.subarray(i, i + 16))\n            xorBufferInPlace(block, iv1)\n            block = await this._aes.decrypt(block)\n            xorBufferInPlace(block, iv2)\n            plaintext.set(block, i)\n\n            iv1 = plaintext.subarray(i, i + 16)\n            iv2 = data.subarray(i, i + 16)\n        }\n\n        return plaintext\n    }\n}\n"]}

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

@@ -0,0 +1,5 @@
+/**
+ * Factorize `p*q` to `p` and `q` synchronously using Brent-Pollard rho algorithm
+ * @param pq
+ */
+export declare function factorizePQSync(pq: Uint8Array): [Uint8Array, Uint8Array];

package/esm/utils/crypto/factorization.js

@@ -0,0 +1,62 @@
+import bigInt from 'big-integer';
+import { 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) {
+    const pq_ = bufferToBigInt(pq);
+    const n = PollardRhoBrent(pq_);
+    const m = pq_.divide(n);
+    let p;
+    let q;
+    if (n.lt(m)) {
+        p = n;
+        q = m;
+    }
+    else {
+        p = m;
+        q = n;
+    }
+    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;
+    let ys;
+    let x;
+    while (g.eq(bigInt.one)) {
+        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)) {
+            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
+            }
+            g = bigInt.gcd(q, n);
+            k = k.plus(m);
+        }
+        r = r.multiply(bigInt[2]);
+    }
+    if (g.eq(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));
+    }
+    return g;
+}
+//# sourceMappingURL=factorization.js.map

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

@@ -0,0 +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"]}

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

@@ -0,0 +1,5 @@
+export * from './abstract.js';
+export * from './keys.js';
+export * from './password.js';
+import { CryptoProviderFactory } from './abstract.js';
+export declare const defaultCryptoProviderFactory: CryptoProviderFactory;