@mtkruto/node 0.0.6

package/esm/tl/3_tl_object_deserializer.js

@@ -0,0 +1,72 @@
+import { assertEquals } from "../deps.js";
+import { analyzeOptionalParam, flags, isOptionalParam, isTLObjectConstructor, paramDesc } from "./1_tl_object.js";
+import { map } from "./2_types.js";
+function deserializeSingleParam(reader, type, ntype) {
+    if (isTLObjectConstructor(type)) {
+        const cid = reader.readInt32(false);
+        const constructor = map.get(cid);
+        if (!constructor) {
+            throw new Error(`Constructor with ID ${cid} not found`);
+        }
+        return deserialize(reader, constructor[paramDesc], constructor);
+    }
+    if (type == Uint8Array) {
+        return reader.readBytes();
+    }
+    else {
+        switch (type) {
+            case "bigint":
+                if (ntype == "int128") {
+                    return reader.readInt128();
+                }
+                else if (ntype === "int256") {
+                    return reader.readInt256();
+                }
+                else {
+                    return reader.readInt64();
+                }
+            case "boolean":
+                return reader.readInt32(false) == 0x997275B5;
+            case "number":
+                return reader.readInt32();
+            case "string":
+                return reader.readString();
+            case "true":
+                return true;
+            default:
+                throw new Error(`Unexpected type ${type}`);
+        }
+    }
+}
+export function deserialize(reader, paramDesc, constructor) {
+    const params = {};
+    const flagFields = {};
+    for (const [name, type, ntype] of paramDesc) {
+        if (isOptionalParam(ntype)) {
+            const { flagField, bitIndex } = analyzeOptionalParam(ntype);
+            const bits = flagFields[flagField];
+            if ((bits & (1 << bitIndex)) == 0) {
+                continue;
+            }
+        }
+        if (type == flags && ntype == "#") {
+            flagFields[name] = reader.readInt32();
+            continue;
+        }
+        if (type instanceof Array) {
+            assertEquals(reader.readInt32(false), 0x1CB5C415);
+            const count = reader.readInt32();
+            const items = new Array();
+            for (let i = 0; i < count; i++) {
+                items.push(deserializeSingleParam(reader, type[0], ntype));
+            }
+            params[name] = items;
+            continue;
+        }
+        const value = deserializeSingleParam(reader, type, ntype);
+        if (value) {
+            params[name] = value;
+        }
+    }
+    return new constructor(params);
+}

package/esm/tl/3_tl_reader.js

@@ -0,0 +1,16 @@
+import { TLRawReader } from "./0_tl_raw_reader.js";
+import { paramDesc } from "./1_tl_object.js";
+import { map } from "./2_types.js";
+import { deserialize } from "./3_tl_object_deserializer.js";
+export class TLReader extends TLRawReader {
+    readObject(id) {
+        if (!id) {
+            id = this.readInt32(false);
+        }
+        const constructor = map.get(id);
+        if (constructor) {
+            return deserialize(this, constructor[paramDesc], constructor);
+        }
+        throw new Error(`Unknown constructor ${id.toString(16)}`);
+    }
+}

package/esm/tl/3_tl_writer.js

@@ -0,0 +1,7 @@
+import { TLRawWriter } from "./0_tl_raw_writer.js";
+export class TLWriter extends TLRawWriter {
+    writeObject(object) {
+        this.write(object.serialize());
+        return this;
+    }
+}

package/esm/tl/4_rpc_result.js

@@ -0,0 +1,27 @@
+import { id } from "./1_tl_object.js";
+import { TLReader } from "./3_tl_reader.js";
+export class RPCResult {
+    static get [id]() {
+        return 0xF35C6D01;
+    }
+    constructor(messageId, result) {
+        Object.defineProperty(this, "messageId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: messageId
+        });
+        Object.defineProperty(this, "result", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: result
+        });
+    }
+    static deserialize(buffer) {
+        const reader = new TLReader(buffer);
+        const messageId = reader.readInt64();
+        const result = reader.readObject();
+        return new RPCResult(messageId, result);
+    }
+}

package/esm/tl/5_message.js

@@ -0,0 +1,54 @@
+import { id, length } from "./1_tl_object.js";
+import { TLReader } from "./3_tl_reader.js";
+import { TLWriter } from "./3_tl_writer.js";
+import { RPCResult } from "./4_rpc_result.js";
+export class Message {
+    constructor(id, seqNo, body) {
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: id
+        });
+        Object.defineProperty(this, "seqNo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: seqNo
+        });
+        Object.defineProperty(this, "body", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: body
+        });
+    }
+    serialize() {
+        if (this.body instanceof RPCResult) {
+            throw new Error("Not applicable");
+        }
+        return new TLWriter()
+            .writeInt64(this.id)
+            .writeInt32(this.seqNo)
+            .writeInt32(this.body[length])
+            .writeObject(this.body)
+            .buffer;
+    }
+    static deserialize(reader) {
+        const id_ = reader.readInt64();
+        const seqNo = reader.readInt32();
+        const length = reader.readInt32();
+        reader = new TLReader(reader.read(length));
+        const cid = reader.readInt32(false);
+        let body;
+        {
+            if (cid == RPCResult[id]) {
+                body = RPCResult.deserialize(reader.buffer);
+            }
+            else {
+                body = reader.readObject(cid);
+            }
+        }
+        return new Message(id_, seqNo, body);
+    }
+}

package/esm/tl/6_message_container.js

@@ -0,0 +1,35 @@
+import { id } from "./1_tl_object.js";
+import { TLReader } from "./3_tl_reader.js";
+import { TLWriter } from "./3_tl_writer.js";
+import { Message } from "./5_message.js";
+export class MessageContainer {
+    static get [id]() {
+        return 0x73F1F8DC;
+    }
+    constructor(messages) {
+        Object.defineProperty(this, "messages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: messages
+        });
+    }
+    serialize() {
+        const writer = new TLWriter();
+        writer.writeInt32(MessageContainer[id]);
+        writer.writeInt32(this.messages.length);
+        for (const message of this.messages) {
+            writer.write(message.serialize());
+        }
+        return writer.buffer;
+    }
+    static deserialize(buffer) {
+        const reader = new TLReader(buffer);
+        const length = reader.readInt32();
+        const messages = new Array();
+        for (let i = 0; i < length; i++) {
+            messages.push(Message.deserialize(reader));
+        }
+        return new MessageContainer(messages);
+    }
+}

package/esm/transport/transport.js

@@ -0,0 +1,32 @@
+export class Transport {
+    constructor() {
+        Object.defineProperty(this, "initialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "obfuscationParameters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    encrypt(buffer) {
+        if (this.obfuscationParameters) {
+            return this.obfuscationParameters.encryptionCTR.encrypt(buffer);
+        }
+        else {
+            return buffer;
+        }
+    }
+    decrypt(buffer) {
+        if (this.obfuscationParameters) {
+            return this.obfuscationParameters.decryptionCTR.decrypt(buffer);
+        }
+        else {
+            return buffer;
+        }
+    }
+}

package/esm/transport/transport_intermediate.js

@@ -0,0 +1,56 @@
+import { bufferFromBigInt, concat } from "../utilities/0_buffer.js";
+import { getObfuscationParameters } from "../utilities/1_obfuscation.js";
+import { Transport } from "./transport.js";
+export class TransportIntermediate 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(0xEEEEEEEE, this.connection);
+            }
+            else {
+                await this.connection.write(new Uint8Array([0xEE, 0xEE, 0xEE, 0xEE]));
+            }
+            this.initialized = true;
+        }
+        else {
+            throw new Error("Transport already initialized");
+        }
+    }
+    async receive() {
+        let length;
+        {
+            const buffer = new Uint8Array(4);
+            await this.connection.read(buffer);
+            const dataView = new DataView(this.decrypt(buffer).buffer);
+            length = dataView.getUint32(0, true);
+        }
+        const buffer = new Uint8Array(length);
+        await this.connection.read(buffer);
+        return this.decrypt(buffer);
+    }
+    async send(buffer) {
+        if (!this.initialized) {
+            throw new Error("Transport not initialized");
+        }
+        const length = bufferFromBigInt(buffer.length, 4);
+        await this.connection.write(this.encrypt(concat(length, buffer)));
+    }
+    deinitialize() {
+        this.initialized = false;
+    }
+}

package/esm/transport/transport_provider.js

@@ -0,0 +1,23 @@
+import { ConnectionWebSocket } from "../connection/connection_web_socket.js";
+import { TransportIntermediate } from "./transport_intermediate.js";
+export const defaultDc = "2-test";
+const dcToNameMap = {
+    "1": "pluto",
+    "1-test": "pluto",
+    "2": "venus",
+    "2-test": "venus",
+    "3": "aurora",
+    "3-test": "aurora",
+    "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"}`;
+        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/types.js

@@ -0,0 +1 @@
+export {};

package/esm/utilities/0_bigint.js

@@ -0,0 +1,37 @@
+import * as dntShim from "../_dnt.shims.js";
+export function modExp(a, b, n) {
+    a %= n;
+    let result = 1n;
+    let x = a;
+    while (b > 0n) {
+        const leastSignificantBit = b % 2n;
+        b /= 2n;
+        if (leastSignificantBit == 1n) {
+            result *= x;
+            result %= n;
+        }
+        x *= x;
+        x %= n;
+    }
+    return result;
+}
+export function mod(n, m) {
+    return ((n % m) + m) % m;
+}
+export function bigIntFromBuffer(buffer, little = true, signed = false) {
+    let randomBuffer = buffer;
+    const bytesLength = randomBuffer.length;
+    if (little) {
+        randomBuffer = randomBuffer.reverse();
+    }
+    let bigIntVar = BigInt("0x" + [...randomBuffer].map((v) => v.toString(16).padStart(2, "0")).join(""));
+    if (signed && Math.floor(bigIntVar.toString(2).length / 8) >= bytesLength) {
+        bigIntVar = bigIntVar - (2n ** (BigInt(bytesLength * 8)));
+    }
+    return bigIntVar;
+}
+export function getRandomBigInt(byteLength, little, signed) {
+    const randomBytes = new Uint8Array(byteLength);
+    dntShim.crypto.getRandomValues(randomBytes);
+    return bigIntFromBuffer(randomBytes, little, signed);
+}

package/esm/utilities/0_buffer.js

@@ -0,0 +1,33 @@
+export function concat(...buffers) {
+    return new Uint8Array(buffers.map((v) => Array.from(v)).flat());
+}
+const bufferFromHexString = (hexString) => Uint8Array.from(hexString.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+export function bufferFromBigInt(bigIntVar, bytesNumber, little = true, signed = false) {
+    bigIntVar = BigInt(typeof bigIntVar === "number" ? Math.ceil(bigIntVar) : bigIntVar);
+    const bitLength = bigIntVar.toString(2).length;
+    const bytes = Math.ceil(bitLength / 8);
+    if (bytesNumber < bytes) {
+        throw new Error("OverflowError: int too big to convert");
+    }
+    if (!signed && bigIntVar < 0n) {
+        throw new Error("Cannot convert to unsigned");
+    }
+    let below = false;
+    if (bigIntVar < 0n) {
+        below = true;
+        bigIntVar = bigIntVar < 0 ? bigIntVar * -1n : bigIntVar;
+    }
+    const hex = bigIntVar.toString(16).padStart(bytesNumber * 2, "0");
+    const buffer = bufferFromHexString(hex);
+    if (signed && below) {
+        buffer[buffer.length - 1] = 256 -
+            buffer[buffer.length - 1];
+        for (let i = 0; i < buffer.length - 1; i++) {
+            buffer[i] = 255 - buffer[i];
+        }
+    }
+    if (little) {
+        buffer.reverse();
+    }
+    return buffer;
+}

package/esm/utilities/0_crypto.js

@@ -0,0 +1,35 @@
+import { ctr256Decrypt, ctr256Encrypt } from "../deps.js";
+export class CTR {
+    constructor(key, iv) {
+        Object.defineProperty(this, "key", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: key
+        });
+        Object.defineProperty(this, "iv", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: iv
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Uint8Array(1)
+        });
+    }
+    encrypt(data) {
+        const [encrypted, iv, state] = ctr256Encrypt(data, this.key, this.iv, this.state);
+        this.iv = iv;
+        this.state = state;
+        return new Uint8Array(encrypted);
+    }
+    decrypt(data) {
+        const [decrypted, iv, state] = ctr256Decrypt(data, this.key, this.iv, this.state);
+        this.iv = iv;
+        this.state = state;
+        return new Uint8Array(decrypted);
+    }
+}

package/esm/utilities/0_hash.js

@@ -0,0 +1,7 @@
+import * as dntShim from "../_dnt.shims.js";
+export async function sha256(payload) {
+    return new Uint8Array(await dntShim.crypto.subtle.digest("SHA-256", payload));
+}
+export async function sha1(payload) {
+    return new Uint8Array(await dntShim.crypto.subtle.digest("SHA-1", payload));
+}

package/esm/utilities/1_auth.js

@@ -0,0 +1,29 @@
+import * as dntShim from "../_dnt.shims.js";
+import { assert, assertEquals, ige256Encrypt } from "../deps.js";
+import { bigIntFromBuffer, modExp } from "./0_bigint.js";
+import { bufferFromBigInt, concat } from "./0_buffer.js";
+import { sha256 } from "./0_hash.js";
+export async function rsaPad(data, [serverKey, exponent]) {
+    assert(data.length <= 144);
+    let keyAesEncryptedInt;
+    let tries = 0;
+    do {
+        if (++tries == 10) {
+            throw new Error("Out of tries");
+        }
+        const dataWithPadding = concat(data, new Uint8Array(192 - data.length));
+        const dataPadReversed = new Uint8Array(dataWithPadding).reverse();
+        const tempKey = dntShim.crypto.getRandomValues(new Uint8Array(32));
+        const dataWithHash = concat(dataPadReversed, await sha256(concat(tempKey, dataWithPadding)));
+        const aesEncrypted = ige256Encrypt(dataWithHash, tempKey, new Uint8Array(32));
+        const aesEncryptedSha256 = await sha256(aesEncrypted);
+        const tempKeyXor = tempKey.map((v, i) => v ^ aesEncryptedSha256[i]);
+        const keyAesEncrypted = concat(tempKeyXor, aesEncrypted);
+        assertEquals(keyAesEncrypted.length, 256);
+        keyAesEncryptedInt = bigIntFromBuffer(keyAesEncrypted, false, false);
+    } while (keyAesEncryptedInt >= serverKey);
+    const encryptedDataInt = modExp(keyAesEncryptedInt, exponent, serverKey);
+    const encryptedData = bufferFromBigInt(encryptedDataInt, 256, false, false);
+    assertEquals(encryptedData.length, 256);
+    return encryptedData;
+}

package/esm/utilities/1_message.js

@@ -0,0 +1,94 @@
+import { assertEquals, ige256Decrypt, ige256Encrypt } from "../deps.js";
+import { TLRawReader } from "../tl/0_tl_raw_reader.js";
+import { TLRawWriter } from "../tl/0_tl_raw_writer.js";
+import { id } from "../tl/1_tl_object.js";
+import { TLReader } from "../tl/3_tl_reader.js";
+import { RPCResult } from "../tl/4_rpc_result.js";
+import { Message } from "../tl/5_message.js";
+import { MessageContainer } from "../tl/6_message_container.js";
+import { bufferFromBigInt, concat } from "./0_buffer.js";
+import { sha256 } from "./0_hash.js";
+let lastMsgId = 0n;
+export function getMessageId() {
+    const now = new Date().getTime() / 1000 + 0;
+    const nanoseconds = Math.floor((now - Math.floor(now)) * 1e9);
+    let newMsgId = (BigInt(Math.floor(now)) <<
+        32n) ||
+        (BigInt(nanoseconds) << 2n);
+    if (lastMsgId >= (newMsgId)) {
+        newMsgId = lastMsgId + 4n;
+    }
+    lastMsgId = newMsgId;
+    return newMsgId;
+}
+export function packUnencryptedMessage(data) {
+    const message = concat(bufferFromBigInt(0x00, 8), bufferFromBigInt(getMessageId(), 8), bufferFromBigInt(data.length, 4), data);
+    return message;
+}
+export function unpackUnencryptedMessage(buffer) {
+    const reader = new TLRawReader(buffer);
+    const _authKeyId = reader.readInt64();
+    const messageId = reader.readInt64();
+    const messageLength = reader.readInt32();
+    const message = reader.read(messageLength);
+    return { messageId, message };
+}
+export async function encryptMessage(message, authKey, authKeyId, salt, sessionId) {
+    const encoded = message.body.serialize();
+    const payloadWriter = new TLRawWriter();
+    payloadWriter.writeInt64(salt);
+    payloadWriter.writeInt64(sessionId);
+    payloadWriter.writeInt64(message.id);
+    payloadWriter.writeInt32(message.seqNo);
+    payloadWriter.writeInt32(encoded.length);
+    payloadWriter.write(encoded);
+    payloadWriter.write(new Uint8Array(payloadWriter.buffer.length + 12 % 16 + 12));
+    let payload = payloadWriter.buffer;
+    while (true) {
+        if (payload.length % 16 == 0 && (payload.length) % 4 == 0) {
+            break;
+        }
+        payload = concat(payload, new Uint8Array(1));
+    }
+    const messageKey = (await sha256(concat(authKey.slice(88, 120), payload))).slice(8, 24);
+    const a = await sha256(concat(messageKey, authKey.slice(0, 36)));
+    const b = await sha256(concat(authKey.slice(40, 76), messageKey));
+    const aesKey = concat(a.slice(0, 8), b.slice(8, 24), a.slice(24, 32));
+    const aesIV = concat(b.slice(0, 8), a.slice(8, 24), b.slice(24, 32));
+    const messageWriter = new TLRawWriter();
+    messageWriter.writeInt64(authKeyId);
+    messageWriter.write(messageKey);
+    messageWriter.write(ige256Encrypt(payload, aesKey, aesIV));
+    return messageWriter.buffer;
+}
+export async function decryptMessage(buffer, authKey, authKeyId, _sessionId) {
+    const reader = new TLReader(buffer);
+    assertEquals(reader.readInt64(false), authKeyId);
+    const messageKey_ = reader.readInt128();
+    const messageKey = bufferFromBigInt(messageKey_, 16, true, true);
+    const a = await sha256(concat(messageKey, authKey.slice(8, 44)));
+    const b = await sha256(concat(authKey.slice(48, 84), messageKey));
+    const aesKey = concat(a.slice(0, 8), b.slice(8, 24), a.slice(24, 32));
+    const aesIv = concat(b.slice(0, 8), a.slice(8, 24), b.slice(24, 32));
+    const plaintext = ige256Decrypt(reader.buffer, aesKey, aesIv);
+    assertEquals(plaintext.buffer.byteLength % 4, 0);
+    let plainReader = new TLReader(plaintext);
+    const _salt = plainReader.readInt64();
+    const _sessionId_ = plainReader.readInt64(false);
+    const mid = plainReader.readInt64();
+    const seqno = plainReader.readInt32();
+    const length = plainReader.readInt32();
+    plainReader = new TLReader(plainReader.read(length));
+    const cid = plainReader.readInt32(false);
+    if (cid == MessageContainer[id]) {
+        return MessageContainer.deserialize(plainReader.buffer);
+    }
+    else if (cid == RPCResult[id]) {
+        const body = RPCResult.deserialize(plainReader.buffer);
+        return new Message(mid, seqno, body);
+    }
+    else {
+        const body = plainReader.readObject(cid);
+        return new Message(mid, seqno, body);
+    }
+}

package/esm/utilities/1_obfuscation.js

@@ -0,0 +1,33 @@
+import * as dntShim from "../_dnt.shims.js";
+import { bufferFromBigInt, concat } from "./0_buffer.js";
+import { CTR } from "./0_crypto.js";
+export async function getObfuscationParameters(protocol, connection) {
+    const dc = 0xFCFF;
+    let init;
+    while (true) {
+        init = concat(dntShim.crypto.getRandomValues(new Uint8Array(56)), bufferFromBigInt(protocol, 4, false), bufferFromBigInt(dc, 2, false), dntShim.crypto.getRandomValues(new Uint8Array(2)));
+        if (init[0] == 0xEF) {
+            continue;
+        }
+        const dataView = new DataView(init.buffer);
+        const firstInt = dataView.getInt32(0);
+        if ([0x44414548, 0x54534F50, 0x20544547, 0x4954504F, 0x02010316, 0xDDDDDDDD, 0xEEEEEEEE].includes(firstInt)) {
+            continue;
+        }
+        const secondInt = dataView.getInt32(4);
+        if (secondInt == 0x00000000) {
+            continue;
+        }
+        break;
+    }
+    const encryptKey = init.slice(8, 8 + 32);
+    const encryptIv = init.slice(40, 40 + 16);
+    const encryptionCTR = new CTR(encryptKey, encryptIv);
+    const encryptedInit = encryptionCTR.encrypt(init);
+    const initRev = new Uint8Array(init).reverse();
+    const decryptKey = initRev.slice(8, 8 + 32);
+    const decryptIv = initRev.slice(40, 40 + 16);
+    const decryptionCTR = new CTR(decryptKey, decryptIv);
+    await connection.write(concat(init.slice(0, 56), encryptedInit.slice(56, 56 + 8)));
+    return { encryptionCTR, decryptionCTR };
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "module": "./esm/mod.js",
+  "main": "./script/mod.js",
+  "types": "./types/mod.d.ts",
+  "name": "@mtkruto/node",
+  "version": "0.0.6",
+  "description": "MTKruto for Node.js",
+  "author": "Roj <rojvv@icloud.com>",
+  "license": "LGPL-3.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MTKruto/MTKruto.git"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./types/mod.d.ts",
+        "default": "./esm/mod.js"
+      },
+      "require": {
+        "types": "./types/mod.d.ts",
+        "default": "./script/mod.js"
+      }
+    }
+  },
+  "scripts": {
+    "test": "node test_runner.js"
+  },
+  "dependencies": {
+    "async-mutex": "0.4.0",
+    "@deno/shim-deno": "~0.15.0",
+    "@deno/shim-crypto": "~0.3.1",
+    "ws": "^8.13.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.11.9",
+    "chalk": "^4.1.2",
+    "@types/ws": "^8.5.4"
+  }
+}