@armatofik/tgsnake-core 1.0.0

package/lib/src/crypto/Aes.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ige256Encrypt = ige256Encrypt;
+exports.ige256Decrypt = ige256Decrypt;
+exports.ctr256Cipher = ctr256Cipher;
+exports.xor = xor;
+exports.AES = AES;
+const platform_node_js_1 = require("../platform.node.js");
+const Logger_js_1 = require("../Logger.js");
+const helpers_js_1 = require("../helpers.js");
+function ige256Encrypt(data, key, iv) {
+    Logger_js_1.Logger.debug(`[4] Encrypting ${platform_node_js_1.Buffer.byteLength(data)} bytes data with AES-256-IGE`);
+    const pad = (0, helpers_js_1.mod)(platform_node_js_1.Buffer.byteLength(data), 16);
+    if (pad) {
+        data = platform_node_js_1.Buffer.concat([
+            data,
+            platform_node_js_1.crypto.randomBytes(16 - pad),
+        ]);
+    }
+    return ige(data, key, iv, true);
+}
+function ige256Decrypt(data, key, iv) {
+    Logger_js_1.Logger.debug(`[5] Decrypting ${platform_node_js_1.Buffer.byteLength(data)} bytes data with AES-256-IGE`);
+    return ige(data, key, iv, false);
+}
+function ctr256Cipher(key, iv) {
+    if (platform_node_js_1.where === 'Browser') {
+        const cipher = new platform_node_js_1.aesjs.ModeOfOperation.ctr(key, new platform_node_js_1.aesjs.Counter(Uint8Array.from(iv)));
+        return (data) => {
+            Logger_js_1.Logger.debug(`[140] Cryptograph ${platform_node_js_1.Buffer.byteLength(data)} bytes data with AES-256-CTR`);
+            return platform_node_js_1.Buffer.from(cipher.encrypt(data));
+        };
+    }
+    try {
+        const cipher = platform_node_js_1.crypto.createCipheriv('AES-256-CTR', key, iv);
+        return (data) => {
+            Logger_js_1.Logger.debug(`[140] Cryptograph ${platform_node_js_1.Buffer.byteLength(data)} bytes data with AES-256-CTR`);
+            return platform_node_js_1.Buffer.from(cipher.update(data));
+        };
+    }
+    catch (_error) {
+        const cipher = ctr(key, iv);
+        return (data) => {
+            Logger_js_1.Logger.debug(`[140] Cryptograph ${platform_node_js_1.Buffer.byteLength(data)} bytes data with AES-256-CTR`);
+            return platform_node_js_1.Buffer.from(cipher.update(data));
+        };
+    }
+}
+function xor(a, b) {
+    return (0, helpers_js_1.bigintToBuffer)(BigInt((0, helpers_js_1.bufferToBigint)(a, false) ^ (0, helpers_js_1.bufferToBigint)(b, false)), platform_node_js_1.Buffer.byteLength(a), false);
+}
+function AES(key) {
+    const iv = platform_node_js_1.Buffer.alloc(0);
+    if (platform_node_js_1.where === 'Browser' || platform_node_js_1.where === 'Deno') {
+        const cipher = new platform_node_js_1.aesjs.ModeOfOperation.ecb(key);
+        return {
+            encrypt(data) {
+                return platform_node_js_1.Buffer.from(cipher.encrypt(data));
+            },
+            decrypt(data) {
+                return platform_node_js_1.Buffer.from(cipher.decrypt(data));
+            },
+        };
+    }
+    else {
+        const cipher = platform_node_js_1.crypto.createCipheriv('aes-256-ecb', key, iv);
+        const decipher = platform_node_js_1.crypto.createDecipheriv('aes-256-ecb', key, iv);
+        cipher.setAutoPadding(false);
+        decipher.setAutoPadding(false);
+        return {
+            encrypt(data) {
+                return platform_node_js_1.Buffer.from(cipher.update(data));
+            },
+            decrypt(data) {
+                return platform_node_js_1.Buffer.from(decipher.update(data));
+            },
+        };
+    }
+}
+function ige(data, key, iv, encrypt) {
+    const cipher = AES(key);
+    let iv1 = iv.subarray(0, 16);
+    let iv2 = iv.subarray(16, 32);
+    const temp = [];
+    for (const i of (0, helpers_js_1.range)(0, platform_node_js_1.Buffer.byteLength(data), 16)) {
+        temp.push(data.subarray(i, i + 16));
+    }
+    if (encrypt) {
+        for (let i = 0; i < temp.length; i++) {
+            const chunk = temp[i];
+            iv1 = temp[i] = xor(cipher.encrypt(xor(chunk, iv1)), iv2);
+            iv2 = chunk;
+        }
+    }
+    else {
+        for (let i = 0; i < temp.length; i++) {
+            const chunk = temp[i];
+            iv2 = temp[i] = xor(cipher.decrypt(xor(chunk, iv2)), iv1);
+            iv1 = chunk;
+        }
+    }
+    return platform_node_js_1.Buffer.concat(temp);
+}
+function ctr(key, iv, state = platform_node_js_1.Buffer.alloc(1)) {
+    const cipher = AES(platform_node_js_1.Buffer.from(key));
+    const _iv = platform_node_js_1.Buffer.from(iv);
+    let chunk = platform_node_js_1.Buffer.from(cipher.encrypt(iv));
+    return {
+        update: (data) => {
+            const out = platform_node_js_1.Buffer.from(data);
+            for (const i of (0, helpers_js_1.range)(0, platform_node_js_1.Buffer.byteLength(data), 16)) {
+                for (const j of (0, helpers_js_1.range)(0, Math.min(platform_node_js_1.Buffer.byteLength(data) - i, 16))) {
+                    out[i + j] ^= chunk[state[0]];
+                    state[0] += 1;
+                    if (state[0] >= 16) {
+                        state[0] = 0;
+                    }
+                    if (state[0] === 0) {
+                        for (const k of (0, helpers_js_1.range)(15, -1, -1)) {
+                            if (_iv[k] === 255) {
+                                _iv[k] = 0;
+                            }
+                            else {
+                                _iv[k] += 1;
+                                break;
+                            }
+                        }
+                        chunk = cipher.encrypt(_iv);
+                    }
+                }
+            }
+            return out;
+        },
+    };
+}

package/lib/src/crypto/Mtproto.d.ts

@@ -0,0 +1,5 @@
+import { Buffer } from '../platform.node.js';
+import { Message, BytesIO } from '../raw/index.js';
+export declare function kdf(authKey: Buffer, msgKey: Buffer, outgoing: boolean): Array<Buffer>;
+export declare function pack(message: Message, salt: bigint, sessionId: Buffer, authKey: Buffer, authKeyId: Buffer): Buffer;
+export declare function unpack(b: BytesIO, sessionId: Buffer, authKey: Buffer, authKeyId: Buffer, storedMsgId: Array<bigint>): Promise<Message>;

package/lib/src/crypto/Mtproto.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kdf = kdf;
+exports.pack = pack;
+exports.unpack = unpack;
+const platform_node_js_1 = require("../platform.node.js");
+const index_js_1 = require("../errors/index.js");
+const index_js_2 = require("../raw/index.js");
+const MsgId_js_1 = require("../session/internals/MsgId.js");
+const helpers_js_1 = require("../helpers.js");
+const Aes_js_1 = require("./Aes.js");
+const Logger_js_1 = require("../Logger.js");
+const STORED_MSG_IDS_MAX_SIZE = 1000 * 2;
+function sha256(data) {
+    const hash = platform_node_js_1.crypto.createHash('sha256');
+    hash.update(data);
+    return hash.digest();
+}
+function toBytes(value) {
+    const bytesArray = [];
+    for (let i = 0; i < 8; i++) {
+        let shift = value >> BigInt(8 * i);
+        shift &= BigInt(255);
+        bytesArray[i] = Number(String(shift));
+    }
+    return platform_node_js_1.Buffer.from(bytesArray);
+}
+function kdf(authKey, msgKey, outgoing) {
+    const x = outgoing ? 0 : 8;
+    const sha256A = sha256(platform_node_js_1.Buffer.concat([
+        msgKey,
+        authKey.subarray(x, x + 36),
+    ]));
+    const sha256B = sha256(platform_node_js_1.Buffer.concat([
+        authKey.subarray(x + 40, x + 76),
+        msgKey,
+    ]));
+    const aesKey = platform_node_js_1.Buffer.concat([
+        sha256A.subarray(0, 8),
+        sha256B.subarray(8, 24),
+        sha256A.subarray(24, 32),
+    ]);
+    const aesIv = platform_node_js_1.Buffer.concat([
+        sha256B.subarray(0, 8),
+        sha256A.subarray(8, 24),
+        sha256B.subarray(24, 32),
+    ]);
+    return [aesKey, aesIv];
+}
+function pack(message, salt, sessionId, authKey, authKeyId) {
+    const data = platform_node_js_1.Buffer.concat([
+        platform_node_js_1.Buffer.concat([
+            toBytes(salt),
+            sessionId,
+        ]),
+        message.write(),
+    ]);
+    const padding = platform_node_js_1.Buffer.from(platform_node_js_1.crypto.randomBytes((0, helpers_js_1.mod)(-(platform_node_js_1.Buffer.byteLength(data) + 12), 16) + 12));
+    const msgKeyLarge = sha256(platform_node_js_1.Buffer.concat([
+        authKey.subarray(88, 88 + 32),
+        data,
+        padding,
+    ]));
+    const msgKey = msgKeyLarge.subarray(8, 24);
+    const [aesKey, aesIv] = kdf(authKey, msgKey, true);
+    return platform_node_js_1.Buffer.concat([
+        authKeyId,
+        msgKey,
+        (0, Aes_js_1.ige256Encrypt)(platform_node_js_1.Buffer.concat([data, padding]), aesKey, aesIv),
+    ]);
+}
+async function unpack(b, sessionId, authKey, authKeyId, storedMsgId) {
+    index_js_1.SecurityCheckMismatch.check(b.read(8).equals(authKeyId), 'Provided auth key id is not equal with expected one.');
+    const msgKey = b.read(16);
+    const [aesKey, aesIv] = kdf(authKey, msgKey, false);
+    const encrypted = b.read();
+    const decrypted = (0, Aes_js_1.ige256Decrypt)(encrypted, aesKey, aesIv);
+    const hash = sha256(platform_node_js_1.Buffer.concat([
+        authKey.subarray(96, 96 + 32),
+        decrypted,
+    ]));
+    index_js_1.SecurityCheckMismatch.check(msgKey.equals(hash.subarray(8, 24)), 'Provided msg key is not equal with expected one');
+    const data = new index_js_2.BytesIO(decrypted);
+    data.read(8);
+    index_js_1.SecurityCheckMismatch.check(platform_node_js_1.Buffer.from(data.read(8)).equals(sessionId), 'Provided session id is not equal with expected one.');
+    const message = await index_js_2.Message.read(new index_js_2.BytesIO(data.buffer.slice(16))).catch((error) => {
+        Logger_js_1.Logger.error(error);
+    });
+    data.seek(32);
+    const payload = data.read();
+    const padding = payload.subarray(message.length);
+    index_js_1.SecurityCheckMismatch.check(platform_node_js_1.Buffer.byteLength(padding) >= 12 && platform_node_js_1.Buffer.byteLength(padding) <= 1024, 'Payload padding is lower than 12 or bigger than 1024');
+    index_js_1.SecurityCheckMismatch.check((0, helpers_js_1.mod)(platform_node_js_1.Buffer.byteLength(padding), 4) === 0, 'Mod of padding length with 4 is equal with zero');
+    index_js_1.SecurityCheckMismatch.check((0, helpers_js_1.bigIntMod)(message.msgId, BigInt(2)) !== BigInt(0), 'Mod of msgId with 2 is not equal with zero');
+    if (storedMsgId.length > STORED_MSG_IDS_MAX_SIZE) {
+        storedMsgId.splice(0, Math.floor(STORED_MSG_IDS_MAX_SIZE / 2));
+    }
+    if (storedMsgId.length) {
+        if (message.msgId < storedMsgId[0]) {
+            throw new index_js_1.SecurityCheckMismatch('Msg id is lower than all of the stored values');
+        }
+        if (storedMsgId.includes(message.msgId)) {
+            throw new index_js_1.SecurityCheckMismatch('Msg id is equal to any of the stored values');
+        }
+        const msgId = new MsgId_js_1.MsgId();
+        const timeDiff = BigInt(message.msgId - msgId.getMsgId()) / BigInt(2 ** 32);
+        if (timeDiff > BigInt(30)) {
+            throw new index_js_1.SecurityCheckMismatch('Msg id belongs over 30 seconds in the future');
+        }
+        if (timeDiff < BigInt(-300)) {
+            throw new index_js_1.SecurityCheckMismatch('Msg id belongs over 300 seconds in the past');
+        }
+    }
+    storedMsgId.push(message.msgId);
+    storedMsgId.sort((a, b) => {
+        if (a > b)
+            return 1;
+        if (a < b)
+            return -1;
+        return 0;
+    });
+    return message;
+}

package/lib/src/crypto/Password.d.ts

@@ -0,0 +1,5 @@
+import { Raw } from '../raw/index.js';
+import { Buffer } from '../platform.node.js';
+export declare function xor(a: Buffer, b: Buffer): Buffer<ArrayBufferLike>;
+export declare function computePasswordHash(algo: Raw.PasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow, password: string): Buffer;
+export declare function computePasswordCheck(r: Raw.account.Password, password: string): Raw.InputCheckPasswordSRP;

package/lib/src/crypto/Password.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xor = xor;
+exports.computePasswordHash = computePasswordHash;
+exports.computePasswordCheck = computePasswordCheck;
+const index_js_1 = require("../raw/index.js");
+const platform_node_js_1 = require("../platform.node.js");
+const helpers_js_1 = require("../helpers.js");
+function sha256(data) {
+    return platform_node_js_1.crypto.createHash('sha256').update(data).digest();
+}
+function xor(a, b) {
+    const length = Math.min(platform_node_js_1.Buffer.byteLength(a), platform_node_js_1.Buffer.byteLength(b));
+    for (let i = 0; i < length; i++) {
+        a[i] =
+            a[i] ^ b[i];
+    }
+    return a;
+}
+function computePasswordHash(algo, password) {
+    const hash1 = sha256(platform_node_js_1.Buffer.concat([
+        algo.salt1,
+        platform_node_js_1.Buffer.from(password, 'utf8'),
+        algo.salt1,
+    ]));
+    const hash2 = sha256(platform_node_js_1.Buffer.concat([
+        algo.salt2,
+        hash1,
+        algo.salt2,
+    ]));
+    const hash3 = platform_node_js_1.crypto.pbkdf2Sync(hash2, algo.salt1, 100000, 64, 'sha512');
+    return sha256(platform_node_js_1.Buffer.concat([
+        algo.salt2,
+        hash3,
+        algo.salt2,
+    ]));
+}
+function computePasswordCheck(r, password) {
+    const algo = r.currentAlgo;
+    const pBytes = algo.p;
+    const p = btoi(pBytes);
+    const g = algo.g;
+    const gBytes = itob(BigInt(g));
+    const BBytes = r.srpB;
+    const B = btoi(BBytes);
+    const srpId = r.srpId;
+    const xBytes = computePasswordHash(algo, password);
+    const x = btoi(xBytes);
+    const gX = (0, helpers_js_1.bigIntPow)(BigInt(g), x, p);
+    const kBytes = sha256(platform_node_js_1.Buffer.concat([pBytes, gBytes]));
+    const k = btoi(kBytes);
+    const kGX = (0, helpers_js_1.bigIntMod)(k * gX, p);
+    let aBytes;
+    let a;
+    let A;
+    let ABytes;
+    let u;
+    while (true) {
+        aBytes = platform_node_js_1.crypto.randomBytes(256);
+        a = btoi(aBytes);
+        A = (0, helpers_js_1.bigIntPow)(BigInt(g), a, p);
+        ABytes = itob(A);
+        u = btoi(sha256(platform_node_js_1.Buffer.concat([ABytes, BBytes])));
+        if (u > BigInt(0))
+            break;
+    }
+    const gB = (0, helpers_js_1.bigIntMod)(B - kGX, p);
+    const uX = u * x;
+    const aUX = a + uX;
+    const S = (0, helpers_js_1.bigIntPow)(gB, aUX, p);
+    const SBytes = itob(S);
+    const KBytes = sha256(SBytes);
+    const M1Bytes = sha256(platform_node_js_1.Buffer.concat([
+        xor(sha256(pBytes), sha256(gBytes)),
+        sha256(algo.salt1),
+        sha256(algo.salt2),
+        ABytes,
+        BBytes,
+        KBytes,
+    ]));
+    return new index_js_1.Raw.InputCheckPasswordSRP({
+        srpId: srpId,
+        a: ABytes,
+        m1: M1Bytes,
+    });
+}
+function btoi(b) {
+    return (0, helpers_js_1.bufferToBigint)(b, false);
+}
+function itob(i) {
+    return (0, helpers_js_1.bigintToBuffer)(i, 256, false);
+}

package/lib/src/crypto/Prime.d.ts

@@ -0,0 +1,4 @@
+declare const CURRENT_DH_PRIME: bigint;
+export declare function gcd(a: bigint, b: bigint): bigint;
+export declare function decompose(pq: bigint): bigint;
+export { CURRENT_DH_PRIME };

package/lib/src/crypto/Prime.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CURRENT_DH_PRIME = void 0;
+exports.gcd = gcd;
+exports.decompose = decompose;
+const helpers_js_1 = require("../helpers.js");
+const CURRENT_DH_PRIME = BigInt('0x' +
+    'C71CAEB9C6B1C9048E6C522F70F13F73980D40238E3E21C14934D037563D930F' +
+    '48198A0AA7C14058229493D22530F4DBFA336F6E0AC925139543AED44CCE7C37' +
+    '20FD51F69458705AC68CD4FE6B6B13ABDC9746512969328454F18FAF8C595F64' +
+    '2477FE96BB2A941D5BCD1D4AC8CC49880708FA9B378E3C4F3A9060BEE67CF9A4' +
+    'A4A695811051907E162753B56B0F6B410DBA74D8A84B2A14B3144E0EF1284754' +
+    'FD17ED950D5965B4B9DD46582DB1178D169C6BC465B0D6FF9CA3928FEF5B9AE4' +
+    'E418FC15E83EBEA0F87FA9FF5EED70050DED2849F47BF959D956850CE929851F' +
+    '0D8115F635B105EE2E4E15D04B2454BF6F4FADF034B10403119CD8E3B92FCC5B');
+exports.CURRENT_DH_PRIME = CURRENT_DH_PRIME;
+function gcd(a, b) {
+    while (b) {
+        const c = (0, helpers_js_1.bigIntMod)(a, b);
+        a = b;
+        b = c;
+    }
+    return a;
+}
+function decompose(pq) {
+    if (pq == BigInt(1))
+        return pq;
+    if ((0, helpers_js_1.bigIntMod)(pq, BigInt(2)) === BigInt(0))
+        return BigInt(2);
+    let y = (0, helpers_js_1.randBigint)(BigInt(1), pq - BigInt(1));
+    const c = (0, helpers_js_1.randBigint)(BigInt(1), pq - BigInt(1));
+    const m = (0, helpers_js_1.randBigint)(BigInt(1), pq - BigInt(1));
+    let g = BigInt(1);
+    let r = BigInt(1);
+    let q = BigInt(1);
+    let x = BigInt(0);
+    let ys = BigInt(0);
+    while (g === BigInt(1)) {
+        x = y;
+        for (let i = 0; BigInt(i) < r; i++) {
+            y = (0, helpers_js_1.bigIntMod)((0, helpers_js_1.bigIntPow)(y, BigInt(2), pq) + c, pq);
+        }
+        let k = BigInt(0);
+        while (k < r && g === BigInt(1)) {
+            ys = y;
+            for (let i = 0; BigInt(i) < helpers_js_1.bigMath.min(m, r - k); i++) {
+                y = (0, helpers_js_1.bigIntMod)((0, helpers_js_1.bigIntPow)(y, BigInt(2), pq) + c, pq);
+                q = q * (0, helpers_js_1.bigIntMod)(helpers_js_1.bigMath.abs(BigInt(x - y)), pq);
+            }
+            g = gcd(q, pq);
+            k += m;
+        }
+        r *= BigInt(2);
+        if (g === pq) {
+            while (true) {
+                ys = (0, helpers_js_1.bigIntMod)((0, helpers_js_1.bigIntPow)(ys, BigInt(2), pq) + c, pq);
+                g = gcd(helpers_js_1.bigMath.abs(BigInt(x - ys)), pq);
+                if (g > BigInt(1))
+                    break;
+            }
+        }
+    }
+    return g;
+}

package/lib/src/crypto/RSA.d.ts

@@ -0,0 +1,7 @@
+import { Buffer } from '../platform.node.js';
+declare const PublicKey: Map<bigint, {
+    m: bigint;
+    e: bigint;
+}>;
+export declare function encrypt(data: Buffer, fingerprint: bigint): Buffer<ArrayBuffer>;
+export { PublicKey };

package/lib/src/crypto/RSA.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublicKey = void 0;
+exports.encrypt = encrypt;
+const helpers_js_1 = require("../helpers.js");
+const platform_node_js_1 = require("../platform.node.js");
+const PublicKey = new Map();
+exports.PublicKey = PublicKey;
+PublicKey.set(BigInt('-4344800451088585951'), {
+    m: BigInt('0x' +
+        'C150023E2F70DB7985DED064759CFECF0AF328E69A41DAF4D6F01B538135A6F9' +
+        '1F8F8B2A0EC9BA9720CE352EFCF6C5680FFC424BD634864902DE0B4BD6D49F4E' +
+        '580230E3AE97D95C8B19442B3C0A10D8F5633FECEDD6926A7F6DAB0DDB7D457F' +
+        '9EA81B8465FCD6FFFEED114011DF91C059CAEDAF97625F6C96ECC74725556934' +
+        'EF781D866B34F011FCE4D835A090196E9A5F0E4449AF7EB697DDB9076494CA5F' +
+        '81104A305B6DD27665722C46B60E5DF680FB16B210607EF217652E60236C255F' +
+        '6A28315F4083A96791D7214BF64C1DF4FD0DB1944FB26A2A57031B32EEE64AD1' +
+        '5A8BA68885CDE74A5BFC920F6ABF59BA5C75506373E7130F9042DA922179251F'),
+    e: BigInt('0x010001'),
+});
+PublicKey.set(BigInt('847625836280919973'), {
+    m: BigInt('0x' +
+        'AEEC36C8FFC109CB099624685B97815415657BD76D8C9C3E398103D7AD16C9BB' +
+        'A6F525ED0412D7AE2C2DE2B44E77D72CBF4B7438709A4E646A05C43427C7F184' +
+        'DEBF72947519680E651500890C6832796DD11F772C25FF8F576755AFE055B0A3' +
+        '752C696EB7D8DA0D8BE1FAF38C9BDD97CE0A77D3916230C4032167100EDD0F9E' +
+        '7A3A9B602D04367B689536AF0D64B613CCBA7962939D3B57682BEB6DAE5B6081' +
+        '30B2E52ACA78BA023CF6CE806B1DC49C72CF928A7199D22E3D7AC84E47BC9427' +
+        'D0236945D10DBD15177BAB413FBF0EDFDA09F014C7A7DA088DDE9759702CA760' +
+        'AF2B8E4E97CC055C617BD74C3D97008635B98DC4D621B4891DA9FB0473047927'),
+    e: BigInt('0x010001'),
+});
+PublicKey.set(BigInt('1562291298945373506'), {
+    m: BigInt('0x' +
+        'BDF2C77D81F6AFD47BD30F29AC76E55ADFE70E487E5E48297E5A9055C9C07D2B' +
+        '93B4ED3994D3ECA5098BF18D978D54F8B7C713EB10247607E69AF9EF44F38E28' +
+        'F8B439F257A11572945CC0406FE3F37BB92B79112DB69EEDF2DC71584A661638' +
+        'EA5BECB9E23585074B80D57D9F5710DD30D2DA940E0ADA2F1B878397DC1A72B5' +
+        'CE2531B6F7DD158E09C828D03450CA0FF8A174DEACEBCAA22DDE84EF66AD370F' +
+        '259D18AF806638012DA0CA4A70BAA83D9C158F3552BC9158E69BF332A45809E1' +
+        'C36905A5CAA12348DD57941A482131BE7B2355A5F4635374F3BD3DDF5FF925BF' +
+        '4809EE27C1E67D9120C5FE08A9DE458B1B4A3C5D0A428437F2BECA81F4E2D5FF'),
+    e: BigInt('0x010001'),
+});
+PublicKey.set(BigInt('-5859577972006586033'), {
+    m: BigInt('0x' +
+        'B3F762B739BE98F343EB1921CF0148CFA27FF7AF02B6471213FED9DAA0098976' +
+        'E667750324F1ABCEA4C31E43B7D11F1579133F2B3D9FE27474E462058884E5E1' +
+        'B123BE9CBBC6A443B2925C08520E7325E6F1A6D50E117EB61EA49D2534C8BB4D' +
+        '2AE4153FABE832B9EDF4C5755FDD8B19940B81D1D96CF433D19E6A22968A85DC' +
+        '80F0312F596BD2530C1CFB28B5FE019AC9BC25CD9C2A5D8A0F3A1C0C79BCCA52' +
+        '4D315B5E21B5C26B46BABE3D75D06D1CD33329EC782A0F22891ED1DB42A1D6C0' +
+        'DEA431428BC4D7AABDCF3E0EB6FDA4E23EB7733E7727E9A1915580796C55188D' +
+        '2596D2665AD1182BA7ABF15AAA5A8B779EA996317A20AE044B820BFF35B6E8A1'),
+    e: BigInt('0x010001'),
+});
+PublicKey.set(BigInt('6491968696586960280'), {
+    m: BigInt('0x' +
+        'BE6A71558EE577FF03023CFA17AAB4E6C86383CFF8A7AD38EDB9FAFE6F323F2D' +
+        '5106CBC8CAFB83B869CFFD1CCF121CD743D509E589E68765C96601E813DC5B9D' +
+        'FC4BE415C7A6526132D0035CA33D6D6075D4F535122A1CDFE017041F1088D141' +
+        '9F65C8E5490EE613E16DBF662698C0F54870F0475FA893FC41EB55B08FF1AC21' +
+        '1BC045DED31BE27D12C96D8D3CFC6A7AE8AA50BF2EE0F30ED507CC2581E3DEC5' +
+        '6DE94F5DC0A7ABEE0BE990B893F2887BD2C6310A1E0A9E3E38BD34FDED254150' +
+        '8DC102A9C9B4C95EFFD9DD2DFE96C29BE647D6C69D66CA500843CFAED6E44019' +
+        '6F1DBE0E2E22163C61CA48C79116FA77216726749A976A1C4B0944B5121E8C01'),
+    e: BigInt('0x010001'),
+});
+PublicKey.set(BigInt('6427105915145367799'), {
+    m: BigInt('0x' +
+        'F8B7F73EF804D72C5B25408C6840245744324935699DA0E389E76707945BB4D5' +
+        'A309EA9255A9181DBAAA18C208BF958219D15DAEA39F30D70D4ACB4FB5253A47' +
+        'D526470EADAAE388CA4A52B943A37BD1FEE175482AABA3C8BD8849D2BEE1938C' +
+        '978842324A9ABB0E1B3F549BAF4DEF65141B53AA84034E15E23F3BF410320558' +
+        '6BDD61BDF998BEB795DF1924E0484C4F60497CAD934760D579441F81BABA151F' +
+        '61CB4CEA53FE62557E2918A608DF585E6575ECD5E16A3D2D21F471919214869E' +
+        '265F1DD00F048B2E41F60B413BC98BF977D044A38E9ABEDAE01338468D9D7B9A' +
+        'EBDA2DA877B8585DDDC33BD1514A5E32D7303C026E3C45F77DE561C5DCDFCE99'),
+    e: BigInt('0x010001'),
+});
+PublicKey.set(BigInt('2685959930972952888'), {
+    m: BigInt('0x' +
+        'CEE1D50BBB04E742A1A3FC83559B569E5980E417FF68CF0A658DD6CD2D7AC3AC' +
+        '35B01AA2A63F2880C186ED42DB181B5898A11A23B20824EE963369B531A5D59E' +
+        'CA92F1DECF6860198B2F2B48DDD2ED2D9AF30A7845765E86CD09017BD9788CF8' +
+        'E6207208C05FC9C6C92A64B079891EB11508EE150EF1E4219A6FD4614129258E' +
+        'D53ADD087A68AE5114A9AA5450D8595CC876A161435CBDB2026F8FBF00FEDCA0' +
+        'A067E9C079172CCCECC09C2B16C428EC776373149DB66AAB9A4DEBF7916B391E' +
+        '832AE5A7892E27DE0AB1B4451C55F90F1F2ECE3ACEF708BC2C5EE022066EE434' +
+        '4C7268D724AABAAC667667D727AC3F2956ED4BDAF7089DDE0AEB18A6652DA16F'),
+    e: BigInt('0x010001'),
+});
+function encrypt(data, fingerprint) {
+    const key = PublicKey.get(fingerprint);
+    if (key == undefined) {
+        throw new Error(`unknown fingerprint ${fingerprint}n`);
+    }
+    return platform_node_js_1.Buffer.from((0, helpers_js_1.bigintToBuffer)((0, helpers_js_1.bigIntPow)((0, helpers_js_1.bufferToBigint)(data, false), key.e, key.m), 256, false));
+}

package/lib/src/crypto/SecretChat.d.ts

@@ -0,0 +1,5 @@
+import { Buffer } from '../platform.node.js';
+import { Raw } from '../raw/index.js';
+export declare function kdf(sharedKey: Buffer, msgKey: Buffer, isAdmin: boolean, v1?: boolean): Array<Buffer>;
+export declare function pack(message: Raw.TypeDecryptedMessage, sharedKey: Buffer, inSeqNo: number, outSeqNo: number, isAdmin: boolean, layer: number, mtproto?: number): Buffer;
+export declare function unpack(message: Raw.TypeEncryptedMessage, sharedKey: Buffer, isAdmin: boolean, mtproto?: number): Promise<Raw.TypeDecryptedMessage>;