@mtkruto/node 0.0.6

package/script/utilities/1_message.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decryptMessage = exports.encryptMessage = exports.unpackUnencryptedMessage = exports.packUnencryptedMessage = exports.getMessageId = void 0;
+const deps_js_1 = require("../deps.js");
+const _0_tl_raw_reader_js_1 = require("../tl/0_tl_raw_reader.js");
+const _0_tl_raw_writer_js_1 = require("../tl/0_tl_raw_writer.js");
+const _1_tl_object_js_1 = require("../tl/1_tl_object.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 _0_buffer_js_1 = require("./0_buffer.js");
+const _0_hash_js_1 = require("./0_hash.js");
+let lastMsgId = 0n;
+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;
+}
+exports.getMessageId = getMessageId;
+function packUnencryptedMessage(data) {
+    const message = (0, _0_buffer_js_1.concat)((0, _0_buffer_js_1.bufferFromBigInt)(0x00, 8), (0, _0_buffer_js_1.bufferFromBigInt)(getMessageId(), 8), (0, _0_buffer_js_1.bufferFromBigInt)(data.length, 4), data);
+    return message;
+}
+exports.packUnencryptedMessage = packUnencryptedMessage;
+function unpackUnencryptedMessage(buffer) {
+    const reader = new _0_tl_raw_reader_js_1.TLRawReader(buffer);
+    const _authKeyId = reader.readInt64();
+    const messageId = reader.readInt64();
+    const messageLength = reader.readInt32();
+    const message = reader.read(messageLength);
+    return { messageId, message };
+}
+exports.unpackUnencryptedMessage = unpackUnencryptedMessage;
+async function encryptMessage(message, authKey, authKeyId, salt, sessionId) {
+    const encoded = message.body.serialize();
+    const payloadWriter = new _0_tl_raw_writer_js_1.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 = (0, _0_buffer_js_1.concat)(payload, new Uint8Array(1));
+    }
+    const messageKey = (await (0, _0_hash_js_1.sha256)((0, _0_buffer_js_1.concat)(authKey.slice(88, 120), payload))).slice(8, 24);
+    const a = await (0, _0_hash_js_1.sha256)((0, _0_buffer_js_1.concat)(messageKey, authKey.slice(0, 36)));
+    const b = await (0, _0_hash_js_1.sha256)((0, _0_buffer_js_1.concat)(authKey.slice(40, 76), messageKey));
+    const aesKey = (0, _0_buffer_js_1.concat)(a.slice(0, 8), b.slice(8, 24), a.slice(24, 32));
+    const aesIV = (0, _0_buffer_js_1.concat)(b.slice(0, 8), a.slice(8, 24), b.slice(24, 32));
+    const messageWriter = new _0_tl_raw_writer_js_1.TLRawWriter();
+    messageWriter.writeInt64(authKeyId);
+    messageWriter.write(messageKey);
+    messageWriter.write((0, deps_js_1.ige256Encrypt)(payload, aesKey, aesIV));
+    return messageWriter.buffer;
+}
+exports.encryptMessage = encryptMessage;
+async function decryptMessage(buffer, authKey, authKeyId, _sessionId) {
+    const reader = new _3_tl_reader_js_1.TLReader(buffer);
+    (0, deps_js_1.assertEquals)(reader.readInt64(false), authKeyId);
+    const messageKey_ = reader.readInt128();
+    const messageKey = (0, _0_buffer_js_1.bufferFromBigInt)(messageKey_, 16, true, true);
+    const a = await (0, _0_hash_js_1.sha256)((0, _0_buffer_js_1.concat)(messageKey, authKey.slice(8, 44)));
+    const b = await (0, _0_hash_js_1.sha256)((0, _0_buffer_js_1.concat)(authKey.slice(48, 84), messageKey));
+    const aesKey = (0, _0_buffer_js_1.concat)(a.slice(0, 8), b.slice(8, 24), a.slice(24, 32));
+    const aesIv = (0, _0_buffer_js_1.concat)(b.slice(0, 8), a.slice(8, 24), b.slice(24, 32));
+    const plaintext = (0, deps_js_1.ige256Decrypt)(reader.buffer, aesKey, aesIv);
+    (0, deps_js_1.assertEquals)(plaintext.buffer.byteLength % 4, 0);
+    let plainReader = new _3_tl_reader_js_1.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 _3_tl_reader_js_1.TLReader(plainReader.read(length));
+    const cid = plainReader.readInt32(false);
+    if (cid == _6_message_container_js_1.MessageContainer[_1_tl_object_js_1.id]) {
+        return _6_message_container_js_1.MessageContainer.deserialize(plainReader.buffer);
+    }
+    else if (cid == _4_rpc_result_js_1.RPCResult[_1_tl_object_js_1.id]) {
+        const body = _4_rpc_result_js_1.RPCResult.deserialize(plainReader.buffer);
+        return new _5_message_js_1.Message(mid, seqno, body);
+    }
+    else {
+        const body = plainReader.readObject(cid);
+        return new _5_message_js_1.Message(mid, seqno, body);
+    }
+}
+exports.decryptMessage = decryptMessage;

package/script/utilities/1_obfuscation.js

@@ -0,0 +1,60 @@
+"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.getObfuscationParameters = void 0;
+const dntShim = __importStar(require("../_dnt.shims.js"));
+const _0_buffer_js_1 = require("./0_buffer.js");
+const _0_crypto_js_1 = require("./0_crypto.js");
+async function getObfuscationParameters(protocol, connection) {
+    const dc = 0xFCFF;
+    let init;
+    while (true) {
+        init = (0, _0_buffer_js_1.concat)(dntShim.crypto.getRandomValues(new Uint8Array(56)), (0, _0_buffer_js_1.bufferFromBigInt)(protocol, 4, false), (0, _0_buffer_js_1.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 _0_crypto_js_1.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 _0_crypto_js_1.CTR(decryptKey, decryptIv);
+    await connection.write((0, _0_buffer_js_1.concat)(init.slice(0, 56), encryptedInit.slice(56, 56 + 8)));
+    return { encryptionCTR, decryptionCTR };
+}
+exports.getObfuscationParameters = getObfuscationParameters;

package/types/_dnt.shims.d.ts

@@ -0,0 +1,10 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export { crypto, type Crypto, type SubtleCrypto, type AlgorithmIdentifier, type Algorithm, type RsaOaepParams, type BufferSource, type AesCtrParams, type AesCbcParams, type AesGcmParams, type CryptoKey, type KeyAlgorithm, type KeyType, type KeyUsage, type EcdhKeyDeriveParams, type HkdfParams, type HashAlgorithmIdentifier, type Pbkdf2Params, type AesDerivedKeyParams, type HmacImportParams, type JsonWebKey, type RsaOtherPrimesInfo, type KeyFormat, type RsaHashedKeyGenParams, type RsaKeyGenParams, type BigInteger, type EcKeyGenParams, type NamedCurve, type CryptoKeyPair, type AesKeyGenParams, type HmacKeyGenParams, type RsaHashedImportParams, type EcKeyImportParams, type AesKeyAlgorithm, type RsaPssParams, type EcdsaParams } from "@deno/shim-crypto";
+import { default as WebSocket } from "ws";
+export { default as WebSocket } from "ws";
+export declare const dntGlobalThis: Omit<typeof globalThis, "WebSocket" | "crypto" | "Deno"> & {
+    Deno: typeof Deno;
+    crypto: import("@deno/shim-crypto").Crypto;
+    WebSocket: typeof WebSocket;
+};

package/types/client/client.d.ts

@@ -0,0 +1,19 @@
+import { MaybePromise } from "../types.js";
+import { Type, Updates } from "../tl/2_types.js";
+import { Function } from "../tl/3_functions.js";
+import { ClientAbstract } from "./client_abstract.js";
+export type UpdatesHandler = null | ((client: Client, update: Updates) => MaybePromise<void>);
+export declare class Client extends ClientAbstract {
+    private sessionId;
+    private auth?;
+    private state;
+    private promises;
+    private toAcknowledge;
+    updatesHandler: UpdatesHandler;
+    connect(): Promise<void>;
+    private receiveLoop;
+    private pingLoop;
+    invoke<T extends (Function<unknown> | Type) = Function<unknown>>(function_: T): Promise<T extends Function<unknown> ? T["__R"] : void>;
+    invoke<T extends (Function<unknown> | Type) = Function<unknown>>(function_: T, noWait: true): Promise<void>;
+    send<T extends (Function<unknown> | Type) = Function<unknown>>(function_: T): Promise<void>;
+}

package/types/client/client_abstract.d.ts

@@ -0,0 +1,20 @@
+import { Connection } from "../connection/connection.js";
+import { Transport } from "../transport/transport.js";
+export declare abstract class ClientAbstract {
+    protected transportProvider: (cdn: boolean) => {
+        connection: Connection;
+        transport: Transport;
+        dcId: number;
+    };
+    connection: Connection;
+    transport: Transport;
+    dcId: number;
+    protected connected: boolean;
+    constructor(transportProvider?: (cdn: boolean) => {
+        connection: Connection;
+        transport: Transport;
+        dcId: number;
+    });
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/types/client/client_plain.d.ts

@@ -0,0 +1,10 @@
+import { Function } from "../tl/3_functions.js";
+import { ClientAbstract } from "./client_abstract.js";
+export declare class ClientPlain extends ClientAbstract {
+    invoke<T extends Function<unknown>>(function_: T): Promise<T["__R"]>;
+    createAuthKey(): Promise<{
+        authKey: Uint8Array;
+        authKeyId: bigint;
+        salt: bigint;
+    }>;
+}

package/types/connection/connection.d.ts

@@ -0,0 +1,7 @@
+import { MaybePromise } from "../types.js";
+export declare abstract class Connection {
+    abstract open(): MaybePromise<void>;
+    abstract read(p: Uint8Array): MaybePromise<void>;
+    abstract write(p: Uint8Array): MaybePromise<void>;
+    abstract close(): MaybePromise<void>;
+}

package/types/connection/connection_web_socket.d.ts

@@ -0,0 +1,13 @@
+import { Connection } from "./connection.js";
+export declare class ConnectionWebSocket implements Connection {
+    private webSocket;
+    private rMutex;
+    private wMutex;
+    private buffer;
+    private nextResolve;
+    constructor(url: string | URL);
+    open(): Promise<void>;
+    read(p: Uint8Array): Promise<void>;
+    write(p: Uint8Array): Promise<void>;
+    close(): void;
+}

package/types/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const ackThreshold = 10;
+export declare const publicKeys: Map<bigint, [bigint, bigint]>;

package/types/deps/deno.land/std@0.186.0/fmt/colors.d.ts

@@ -0,0 +1,270 @@
+/** RGB 8-bits per channel. Each in range `0->255` or `0x00->0xff` */
+interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+}
+/**
+ * Set changing text color to enabled or disabled
+ * @param value
+ */
+export declare function setColorEnabled(value: boolean): void;
+/** Get whether text color change is enabled or disabled. */
+export declare function getColorEnabled(): boolean;
+/**
+ * Reset the text modified
+ * @param str text to reset
+ */
+export declare function reset(str: string): string;
+/**
+ * Make the text bold.
+ * @param str text to make bold
+ */
+export declare function bold(str: string): string;
+/**
+ * The text emits only a small amount of light.
+ * @param str text to dim
+ */
+export declare function dim(str: string): string;
+/**
+ * Make the text italic.
+ * @param str text to make italic
+ */
+export declare function italic(str: string): string;
+/**
+ * Make the text underline.
+ * @param str text to underline
+ */
+export declare function underline(str: string): string;
+/**
+ * Invert background color and text color.
+ * @param str text to invert its color
+ */
+export declare function inverse(str: string): string;
+/**
+ * Make the text hidden.
+ * @param str text to hide
+ */
+export declare function hidden(str: string): string;
+/**
+ * Put horizontal line through the center of the text.
+ * @param str text to strike through
+ */
+export declare function strikethrough(str: string): string;
+/**
+ * Set text color to black.
+ * @param str text to make black
+ */
+export declare function black(str: string): string;
+/**
+ * Set text color to red.
+ * @param str text to make red
+ */
+export declare function red(str: string): string;
+/**
+ * Set text color to green.
+ * @param str text to make green
+ */
+export declare function green(str: string): string;
+/**
+ * Set text color to yellow.
+ * @param str text to make yellow
+ */
+export declare function yellow(str: string): string;
+/**
+ * Set text color to blue.
+ * @param str text to make blue
+ */
+export declare function blue(str: string): string;
+/**
+ * Set text color to magenta.
+ * @param str text to make magenta
+ */
+export declare function magenta(str: string): string;
+/**
+ * Set text color to cyan.
+ * @param str text to make cyan
+ */
+export declare function cyan(str: string): string;
+/**
+ * Set text color to white.
+ * @param str text to make white
+ */
+export declare function white(str: string): string;
+/**
+ * Set text color to gray.
+ * @param str text to make gray
+ */
+export declare function gray(str: string): string;
+/**
+ * Set text color to bright black.
+ * @param str text to make bright-black
+ */
+export declare function brightBlack(str: string): string;
+/**
+ * Set text color to bright red.
+ * @param str text to make bright-red
+ */
+export declare function brightRed(str: string): string;
+/**
+ * Set text color to bright green.
+ * @param str text to make bright-green
+ */
+export declare function brightGreen(str: string): string;
+/**
+ * Set text color to bright yellow.
+ * @param str text to make bright-yellow
+ */
+export declare function brightYellow(str: string): string;
+/**
+ * Set text color to bright blue.
+ * @param str text to make bright-blue
+ */
+export declare function brightBlue(str: string): string;
+/**
+ * Set text color to bright magenta.
+ * @param str text to make bright-magenta
+ */
+export declare function brightMagenta(str: string): string;
+/**
+ * Set text color to bright cyan.
+ * @param str text to make bright-cyan
+ */
+export declare function brightCyan(str: string): string;
+/**
+ * Set text color to bright white.
+ * @param str text to make bright-white
+ */
+export declare function brightWhite(str: string): string;
+/**
+ * Set background color to black.
+ * @param str text to make its background black
+ */
+export declare function bgBlack(str: string): string;
+/**
+ * Set background color to red.
+ * @param str text to make its background red
+ */
+export declare function bgRed(str: string): string;
+/**
+ * Set background color to green.
+ * @param str text to make its background green
+ */
+export declare function bgGreen(str: string): string;
+/**
+ * Set background color to yellow.
+ * @param str text to make its background yellow
+ */
+export declare function bgYellow(str: string): string;
+/**
+ * Set background color to blue.
+ * @param str text to make its background blue
+ */
+export declare function bgBlue(str: string): string;
+/**
+ *  Set background color to magenta.
+ * @param str text to make its background magenta
+ */
+export declare function bgMagenta(str: string): string;
+/**
+ * Set background color to cyan.
+ * @param str text to make its background cyan
+ */
+export declare function bgCyan(str: string): string;
+/**
+ * Set background color to white.
+ * @param str text to make its background white
+ */
+export declare function bgWhite(str: string): string;
+/**
+ * Set background color to bright black.
+ * @param str text to make its background bright-black
+ */
+export declare function bgBrightBlack(str: string): string;
+/**
+ * Set background color to bright red.
+ * @param str text to make its background bright-red
+ */
+export declare function bgBrightRed(str: string): string;
+/**
+ * Set background color to bright green.
+ * @param str text to make its background bright-green
+ */
+export declare function bgBrightGreen(str: string): string;
+/**
+ * Set background color to bright yellow.
+ * @param str text to make its background bright-yellow
+ */
+export declare function bgBrightYellow(str: string): string;
+/**
+ * Set background color to bright blue.
+ * @param str text to make its background bright-blue
+ */
+export declare function bgBrightBlue(str: string): string;
+/**
+ * Set background color to bright magenta.
+ * @param str text to make its background bright-magenta
+ */
+export declare function bgBrightMagenta(str: string): string;
+/**
+ * Set background color to bright cyan.
+ * @param str text to make its background bright-cyan
+ */
+export declare function bgBrightCyan(str: string): string;
+/**
+ * Set background color to bright white.
+ * @param str text to make its background bright-white
+ */
+export declare function bgBrightWhite(str: string): string;
+/**
+ * Set text color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
+ * @param str text color to apply paletted 8bit colors to
+ * @param color code
+ */
+export declare function rgb8(str: string, color: number): string;
+/**
+ * Set background color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
+ * @param str text color to apply paletted 8bit background colors to
+ * @param color code
+ */
+export declare function bgRgb8(str: string, color: number): string;
+/**
+ * Set text color using 24bit rgb.
+ * `color` can be a number in range `0x000000` to `0xffffff` or
+ * an `Rgb`.
+ *
+ * To produce the color magenta:
+ *
+ * ```ts
+ *      import { rgb24 } from "https://deno.land/std@$STD_VERSION/fmt/colors.ts";
+ *      rgb24("foo", 0xff00ff);
+ *      rgb24("foo", {r: 255, g: 0, b: 255});
+ * ```
+ * @param str text color to apply 24bit rgb to
+ * @param color code
+ */
+export declare function rgb24(str: string, color: number | Rgb): string;
+/**
+ * Set background color using 24bit rgb.
+ * `color` can be a number in range `0x000000` to `0xffffff` or
+ * an `Rgb`.
+ *
+ * To produce the color magenta:
+ *
+ * ```ts
+ *      import { bgRgb24 } from "https://deno.land/std@$STD_VERSION/fmt/colors.ts";
+ *      bgRgb24("foo", 0xff00ff);
+ *      bgRgb24("foo", {r: 255, g: 0, b: 255});
+ * ```
+ * @param str text color to apply 24bit rgb to
+ * @param color code
+ */
+export declare function bgRgb24(str: string, color: number | Rgb): string;
+/**
+ * Remove ANSI escape codes from the string.
+ * @param string to remove ANSI escape codes from
+ */
+export declare function stripColor(string: string): string;
+export {};

package/types/deps/deno.land/std@0.186.0/testing/_diff.d.ts

@@ -0,0 +1,26 @@
+export declare enum DiffType {
+    removed = "removed",
+    common = "common",
+    added = "added"
+}
+export interface DiffResult<T> {
+    type: DiffType;
+    value: T;
+    details?: Array<DiffResult<T>>;
+}
+/**
+ * Renders the differences between the actual and expected values
+ * @param A Actual value
+ * @param B Expected value
+ */
+export declare function diff<T>(A: T[], B: T[]): Array<DiffResult<T>>;
+/**
+ * Renders the differences between the actual and expected strings
+ * Partially inspired from https://github.com/kpdecker/jsdiff
+ * @param A Actual string
+ * @param B Expected string
+ */
+export declare function diffstr(A: string, B: string): DiffResult<string>[];
+export declare function buildMessage(diffResult: ReadonlyArray<DiffResult<string>>, { stringDiff }?: {
+    stringDiff?: boolean | undefined;
+}): string[];

package/types/deps/deno.land/std@0.186.0/testing/_format.d.ts

@@ -0,0 +1 @@
+export declare function format(v: unknown): string;