@mtkruto/node 0.0.6 → 0.0.7

package/esm/transport/transport_abridged.js

@@ -0,0 +1,69 @@
+import { bufferFromBigInt, concat } from "../utilities/0_buffer.js";
+import { getObfuscationParameters } from "../utilities/1_obfuscation.js";
+import { Transport } from "./transport.js";
+export class TransportAbridged extends Transport {
+    constructor(connection, obfuscated = false) {
+        super();
+        Object.defineProperty(this, "connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: connection
+        });
+        Object.defineProperty(this, "obfuscated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: obfuscated
+        });
+    }
+    async initialize() {
+        if (!this.initialized) {
+            if (this.obfuscated) {
+                this.obfuscationParameters = await getObfuscationParameters(0xEFEFEFEF, this.connection);
+            }
+            else {
+                await this.connection.write(new Uint8Array([0xEF]));
+            }
+            this.initialized = true;
+        }
+        else {
+            throw new Error("Transport already initialized");
+        }
+    }
+    async receive() {
+        let length;
+        {
+            let buffer = new Uint8Array(1);
+            await this.connection.read(buffer);
+            buffer = this.decrypt(buffer);
+            if (buffer[0] < 0x7F) {
+                length = buffer[0];
+            }
+            else {
+                let buffer = new Uint8Array(3);
+                await this.connection.read(buffer);
+                buffer = this.decrypt(buffer);
+                const dataView = new DataView(buffer.buffer);
+                length = dataView.getUint16(0, true);
+            }
+        }
+        length *= 4;
+        let buffer = new Uint8Array(length);
+        await this.connection.read(buffer);
+        buffer = this.decrypt(buffer);
+        return buffer;
+    }
+    async send(buffer) {
+        if (!this.initialized) {
+            throw new Error("Transport not initialized");
+        }
+        const bufferLength = buffer.length / 4;
+        const header = new Uint8Array([bufferLength >= 0x7F ? 0x7F : bufferLength]);
+        const length = bufferLength >= 0x7F ? bufferFromBigInt(bufferLength, 3) : new Uint8Array();
+        await this.connection.write(this.encrypt(concat(header, length, buffer)));
+    }
+    deinitialize() {
+        this.initialized = false;
+    }
+}

package/esm/transport/transport_provider.js

@@ -11,13 +11,13 @@ const dcToNameMap = {
     "4": "vesta",
     "5": "flora",
 };
-export const defaultTransportProvider = (params) => {
-    return (cdn) => {
-        const { dc, wss = typeof location !== "undefined" && location.protocol == "http:" ? false : true } = params ?? { dc: defaultDc };
-        const url = `${wss ? "wss" : "ws"}://${dcToNameMap[dc]}${cdn ? "-1" : ""}.telegram.org/apiws${dc.endsWith("-test") ? "apiws_test" : "apiws"}`;
+export function defaultTransportProvider(wss) {
+    return ({ dc, cdn }) => {
+        wss ??= typeof location !== "undefined" && location.protocol == "http:" ? false : true;
+        const url = `${wss ? "wss" : "ws"}://${dcToNameMap[dc]}${cdn ? "-1" : ""}.web.telegram.org/${dc.endsWith("-test") ? "apiws_test" : "apiws"}`;
         const connection = new ConnectionWebSocket(url);
         const transport = new TransportIntermediate(connection, true);
         const dcId = Number(dc[0]) + (dc.endsWith("-test") ? 10000 : 0) * (cdn ? -1 : 1);
         return { connection, transport, dcId };
     };
-};
+}

package/esm/utilities/0_bigint.js

@@ -35,3 +35,6 @@ export function getRandomBigInt(byteLength, little, signed) {
     dntShim.crypto.getRandomValues(randomBytes);
     return bigIntFromBuffer(randomBytes, little, signed);
 }
+export function getRandomId() {
+    return getRandomBigInt(8, true, true);
+}

package/esm/utilities/1_password.js

@@ -0,0 +1,140 @@
+import * as dntShim from "../_dnt.shims.js";
+import * as types from "../tl/2_types.js";
+import { bufferFromBigInt, concat } from "./0_buffer.js";
+import { sha256 } from "./0_hash.js";
+import { bigIntFromBuffer, getRandomBigInt, mod, modExp } from "./0_bigint.js";
+export function isSafePrime(primeBytes, g) {
+    // deno-fmt-ignore
+    const goodPrime = new Uint8Array([
+        0xC7, 0x1C, 0xAE, 0xB9, 0xC6, 0xB1, 0xC9, 0x04, 0x8E, 0x6C, 0x52, 0x2F,
+        0x70, 0xF1, 0x3F, 0x73, 0x98, 0x0D, 0x40, 0x23, 0x8E, 0x3E, 0x21, 0xC1,
+        0x49, 0x34, 0xD0, 0x37, 0x56, 0x3D, 0x93, 0x0F, 0x48, 0x19, 0x8A, 0x0A,
+        0xA7, 0xC1, 0x40, 0x58, 0x22, 0x94, 0x93, 0xD2, 0x25, 0x30, 0xF4, 0xDB,
+        0xFA, 0x33, 0x6F, 0x6E, 0x0A, 0xC9, 0x25, 0x13, 0x95, 0x43, 0xAE, 0xD4,
+        0x4C, 0xCE, 0x7C, 0x37, 0x20, 0xFD, 0x51, 0xF6, 0x94, 0x58, 0x70, 0x5A,
+        0xC6, 0x8C, 0xD4, 0xFE, 0x6B, 0x6B, 0x13, 0xAB, 0xDC, 0x97, 0x46, 0x51,
+        0x29, 0x69, 0x32, 0x84, 0x54, 0xF1, 0x8F, 0xAF, 0x8C, 0x59, 0x5F, 0x64,
+        0x24, 0x77, 0xFE, 0x96, 0xBB, 0x2A, 0x94, 0x1D, 0x5B, 0xCD, 0x1D, 0x4A,
+        0xC8, 0xCC, 0x49, 0x88, 0x07, 0x08, 0xFA, 0x9B, 0x37, 0x8E, 0x3C, 0x4F,
+        0x3A, 0x90, 0x60, 0xBE, 0xE6, 0x7C, 0xF9, 0xA4, 0xA4, 0xA6, 0x95, 0x81,
+        0x10, 0x51, 0x90, 0x7E, 0x16, 0x27, 0x53, 0xB5, 0x6B, 0x0F, 0x6B, 0x41,
+        0x0D, 0xBA, 0x74, 0xD8, 0xA8, 0x4B, 0x2A, 0x14, 0xB3, 0x14, 0x4E, 0x0E,
+        0xF1, 0x28, 0x47, 0x54, 0xFD, 0x17, 0xED, 0x95, 0x0D, 0x59, 0x65, 0xB4,
+        0xB9, 0xDD, 0x46, 0x58, 0x2D, 0xB1, 0x17, 0x8D, 0x16, 0x9C, 0x6B, 0xC4,
+        0x65, 0xB0, 0xD6, 0xFF, 0x9C, 0xA3, 0x92, 0x8F, 0xEF, 0x5B, 0x9A, 0xE4,
+        0xE4, 0x18, 0xFC, 0x15, 0xE8, 0x3E, 0xBE, 0xA0, 0xF8, 0x7F, 0xA9, 0xFF,
+        0x5E, 0xED, 0x70, 0x05, 0x0D, 0xED, 0x28, 0x49, 0xF4, 0x7B, 0xF9, 0x59,
+        0xD9, 0x56, 0x85, 0x0C, 0xE9, 0x29, 0x85, 0x1F, 0x0D, 0x81, 0x15, 0xF6,
+        0x35, 0xB1, 0x05, 0xEE, 0x2E, 0x4E, 0x15, 0xD0, 0x4B, 0x24, 0x54, 0xBF,
+        0x6F, 0x4F, 0xAD, 0xF0, 0x34, 0xB1, 0x04, 0x03, 0x11, 0x9C, 0xD8, 0xE3,
+        0xB9, 0x2F, 0xCC, 0x5B,
+    ]);
+    if (goodPrime.every((v, i) => v == primeBytes[i])) {
+        if ([3, 4, 5, 7].includes(g)) { // It's good
+            return true;
+        }
+    }
+    return false;
+}
+// H(data) := sha256(data)
+export const h = sha256;
+// SH(data, salt) := H(salt | data | salt)
+export const sh = (data, salt) => h(concat(salt, data, salt));
+// PH1(password, salt1, salt2) := SH(SH(password, salt1), salt2)
+export const ph1 = async (password, salt1, salt2) => await sh(await sh(password, salt1), salt2);
+export async function pbkdf2(password, salt, iterations) {
+    const key = await dntShim.dntGlobalThis.crypto.subtle.importKey("raw", password, "PBKDF2", false, ["deriveBits"]);
+    const buffer = await dntShim.dntGlobalThis.crypto.subtle.deriveBits({ name: "PBKDF2", salt, iterations, hash: "SHA-512" }, key, 512);
+    return new Uint8Array(buffer);
+}
+// PH2(password, salt1, salt2) := SH(pbkdf2(sha512, PH1(password, salt1, salt2), salt1, 100000), salt2)
+export const ph2 = async (password, salt1, salt2) => await sh(await pbkdf2(await ph1(password, salt1, salt2), salt1, 100000), salt2);
+export function isGoodModExpFirst(modexp, prime) {
+    const diff = prime - modexp;
+    const minDiffBitsCount = 2048 - 64;
+    const maxModExpSize = 256;
+    return !(diff < 0n ||
+        diff.toString(2).length < minDiffBitsCount ||
+        modexp.toString(2).length < minDiffBitsCount ||
+        Math.floor((modexp.toString(2).length + 7) / 8) > maxModExpSize);
+}
+export function pad(bigint) {
+    if (typeof bigint === "number") {
+        bigint = BigInt(bigint);
+    }
+    if (typeof bigint === "bigint") {
+        return bufferFromBigInt(bigint, 256, false);
+    }
+    else {
+        return concat(new Uint8Array(256 - bigint.length), bigint);
+    }
+}
+export async function checkPassword(password, ap) {
+    const algo = ap.currentAlgo;
+    if (!(algo instanceof
+        types.PasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow)) {
+        throw new Error("Unexpected algorithm");
+    }
+    // g := algo.g
+    const g = algo.g;
+    // p := algo.p
+    const p = bigIntFromBuffer(algo.p, false);
+    if (!isSafePrime(algo.p, g)) {
+        throw new Error("Got unsafe prime");
+    }
+    const srpB = ap.srpB;
+    const srpId = ap.srpId;
+    {
+        if (!srpB) {
+            throw new Error("srbB is not set");
+        }
+        if (!srpId) {
+            throw new Error("srpId is not set");
+        }
+    }
+    // salt1 := algo.salt1
+    const salt1 = algo.salt1;
+    // salt2 := algo.salt2
+    const salt2 = algo.salt2;
+    // g_b := srp_B
+    const gB = bigIntFromBuffer(srpB, false);
+    // k := H(p | g)
+    const k = bigIntFromBuffer(await h(concat(pad(p), pad(g))), false);
+    let u = 0n;
+    let a = 0n;
+    let gA = 0n;
+    for (let i = 0; i < 1000; i++) {
+        a = getRandomBigInt(256, false);
+        // g_a := pow(g, a) mod p
+        gA = modExp(BigInt(g), a, p);
+        if (isGoodModExpFirst(gA, p)) {
+            u = bigIntFromBuffer(await sha256(concat(pad(gA), pad(gB))), false);
+            if (u > 0n) {
+                break;
+            }
+        }
+    }
+    if (!a || !u || !gA) {
+        throw new Error();
+    }
+    // x := PH2(password, salt1, salt2)
+    const x = bigIntFromBuffer(await ph2(password, salt1, salt2), false);
+    // v := pow(g, x) mod p
+    const v = modExp(BigInt(g), x, p);
+    // k_v := (k * v) mod p
+    const kV = mod(k * v, p);
+    // t := (g_b - k_v) mod p
+    const t = mod(gB - kV, p);
+    // s_a := pow(t, a + u * x) mod p
+    const sA = modExp(t, a + u * x, p);
+    // k_a := H(s_a)
+    const kA = await h(pad(sA));
+    // M1 := H(H(p) xor H(g) | H(salt1) | H(salt2) | g_a | g_b | k_a)
+    const hG = await h(pad(g));
+    const m1 = await h(concat((await h(pad(p))).map((v, i) => v ^ hG[i]), await h(salt1), await h(salt2), pad(gA), pad(gB), kA));
+    return new types.InputCheckPasswordSRP({
+        srpId: srpId,
+        A: pad(gA),
+        M1: m1,
+    });
+}

package/package.json

@@ -3,7 +3,7 @@
   "main": "./script/mod.js",
   "types": "./types/mod.d.ts",
   "name": "@mtkruto/node",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "MTKruto for Node.js",
   "author": "Roj <rojvv@icloud.com>",
   "license": "LGPL-3.0-or-later",

package/script/client/client.js

@@ -1,21 +1,52 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = void 0;
 const deps_js_1 = require("../deps.js");
 const constants_js_1 = require("../constants.js");
 const _0_bigint_js_1 = require("../utilities/0_bigint.js");
 const _1_message_js_1 = require("../utilities/1_message.js");
-const _2_types_js_1 = require("../tl/2_types.js");
-const _3_functions_js_1 = require("../tl/3_functions.js");
+const types = __importStar(require("../tl/2_types.js"));
+const functions = __importStar(require("../tl/3_functions.js"));
 const _3_tl_reader_js_1 = require("../tl/3_tl_reader.js");
 const _4_rpc_result_js_1 = require("../tl/4_rpc_result.js");
 const _5_message_js_1 = require("../tl/5_message.js");
 const _6_message_container_js_1 = require("../tl/6_message_container.js");
 const client_abstract_js_1 = require("./client_abstract.js");
 const client_plain_js_1 = require("./client_plain.js");
+const _1_password_js_1 = require("../utilities/1_password.js");
+const session_memory_js_1 = require("../session/session_memory.js");
 class Client extends client_abstract_js_1.ClientAbstract {
-    constructor() {
-        super(...arguments);
+    constructor(session = new session_memory_js_1.SessionMemory(), params) {
+        super(params?.transportProvider);
+        Object.defineProperty(this, "session", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: session
+        });
         Object.defineProperty(this, "sessionId", {
             enumerable: true,
             configurable: true,
@@ -60,18 +91,45 @@ class Client extends client_abstract_js_1.ClientAbstract {
         await plain.disconnect();
         this.auth = { key, id };
         this.state.salt = salt;
+        await this.session.load();
+        if (this.session.dc != null) {
+            const { connection, transport, dcId } = this.transportProvider({ dc: this.session.dc, cdn: false });
+            this.connection = connection;
+            this.transport = transport;
+            this.dcId = dcId;
+        }
         await super.connect();
         // logger().debug("Client connected");
         this.receiveLoop();
         this.pingLoop();
     }
+    async authorizeUser(apiId, apiHash, resolvers) {
+        const phoneNumber = typeof resolvers.phoneNumber === "string" ? resolvers.phoneNumber : await resolvers.phoneNumber();
+        const { phoneCodeHash } = await this.invoke(new functions.AuthSendCode({ phoneNumber, apiId, apiHash, settings: new types.CodeSettings({}) }));
+        const phoneCode = typeof resolvers.code === "string" ? resolvers.code : await resolvers.code();
+        try {
+            await this.invoke(new functions.AuthSignIn({ phoneNumber, phoneCodeHash, phoneCode }));
+        }
+        catch (err) {
+            if (err instanceof types.RPCError && err.errorMessage == "SESSION_PASSWORD_NEEDED") {
+                const password = await this.invoke(new functions.AccountGetPassword());
+                if (password.currentAlgo instanceof types.PasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) {
+                    const password_ = typeof resolvers.password === "string" ? resolvers.password : await resolvers.password(password.hint ?? null);
+                    await this.invoke(new functions.AuthCheckPassword({ password: await (0, _1_password_js_1.checkPassword)(new TextEncoder().encode(password_), password) }));
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+    }
     async receiveLoop() {
         if (!this.auth) {
             throw new Error("Not connected");
         }
         while (this.connected) {
             if (this.toAcknowledge.size >= constants_js_1.ackThreshold) {
-                await this.send(new _2_types_js_1.MsgsAck({ msgIds: [...this.toAcknowledge] }));
+                await this.send(new types.MsgsAck({ msgIds: [...this.toAcknowledge] }));
                 this.toAcknowledge.clear();
             }
             const buffer = await this.transport.receive();
@@ -86,21 +144,21 @@ class Client extends client_abstract_js_1.ClientAbstract {
             const messages = decrypted instanceof _6_message_container_js_1.MessageContainer ? decrypted.messages : [decrypted];
             for (const message of messages) {
                 let body = message.body;
-                if (body instanceof _2_types_js_1.GZIPPacked) {
+                if (body instanceof types.GZIPPacked) {
                     body = new _3_tl_reader_js_1.TLReader((0, deps_js_1.gunzip)(body.packedData)).readObject();
                 }
                 // logger().debug(`Received ${body.constructor.name}`);
-                if (body instanceof _2_types_js_1.Updates) {
+                if (body instanceof types.Updates) {
                     this.updatesHandler?.(this, body);
                 }
                 else if (message.body instanceof _4_rpc_result_js_1.RPCResult) {
                     let result = message.body.result;
-                    if (result instanceof _2_types_js_1.GZIPPacked) {
+                    if (result instanceof types.GZIPPacked) {
                         result = new _3_tl_reader_js_1.TLReader((0, deps_js_1.gunzip)(result.packedData)).readObject();
                     }
                     const promise = this.promises.get(message.body.messageId);
                     if (promise) {
-                        if (result instanceof _2_types_js_1.RPCError) {
+                        if (result instanceof types.RPCError) {
                             promise.reject(result);
                         }
                         else {
@@ -109,15 +167,15 @@ class Client extends client_abstract_js_1.ClientAbstract {
                         this.promises.delete(message.body.messageId);
                     }
                 }
-                else if (message.body instanceof _2_types_js_1.Pong) {
+                else if (message.body instanceof types.Pong) {
                     const promise = this.promises.get(message.body.msgId);
                     if (promise) {
                         promise.resolve(message.body);
                         this.promises.delete(message.body.msgId);
                     }
                 }
-                else if (message.body instanceof _2_types_js_1.BadMsgNotification || message.body instanceof _2_types_js_1.BadServerSalt) {
-                    if (message.body instanceof _2_types_js_1.BadServerSalt) {
+                else if (message.body instanceof types.BadMsgNotification || message.body instanceof types.BadServerSalt) {
+                    if (message.body instanceof types.BadServerSalt) {
                         this.state.salt = message.body.newServerSalt;
                     }
                     const promise = this.promises.get(message.body.badMsgId);
@@ -133,7 +191,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
     async pingLoop() {
         while (this.connected) {
             try {
-                await this.invoke(new _3_functions_js_1.Ping({ pingId: (0, _0_bigint_js_1.getRandomBigInt)(8, true, false) }));
+                await this.invoke(new functions.Ping({ pingId: (0, _0_bigint_js_1.getRandomBigInt)(8, true, false) }));
             }
             catch (_err) {
                 // logger().error(`Failed to invoke ping: ${err}`);
@@ -146,7 +204,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
             throw new Error("Not connected");
         }
         let seqNo = this.state.seqNo * 2;
-        if (!(function_ instanceof _3_functions_js_1.Ping) && !(function_ instanceof _2_types_js_1.MsgsAck)) {
+        if (!(function_ instanceof functions.Ping) && !(function_ instanceof types.MsgsAck)) {
             seqNo++;
             this.state.seqNo++;
         }
@@ -159,7 +217,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
         const result = await new Promise((resolve, reject) => {
             this.promises.set(message.id, { resolve, reject });
         });
-        if (result instanceof _2_types_js_1.BadServerSalt) {
+        if (result instanceof types.BadServerSalt) {
             return await this.invoke(function_);
         }
         else {

package/script/client/client_abstract.js

@@ -35,7 +35,7 @@ class ClientAbstract {
             writable: true,
             value: false
         });
-        const { connection, transport, dcId } = transportProvider(false);
+        const { connection, transport, dcId } = transportProvider({ dc: transport_provider_js_1.defaultDc, cdn: false });
         this.connection = connection;
         this.transport = transport;
         this.dcId = dcId;