@armatofik/tgsnake-core 1.0.0

package/lib/src/connection/WebSocket.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Socket = void 0;
+const platform_node_js_1 = require("../platform.node.js");
+const Logger_js_1 = require("../Logger.js");
+const index_js_1 = require("../errors/index.js");
+const mutex = new platform_node_js_1.Mutex();
+class Socket {
+    _client;
+    _data;
+    _read;
+    _promisedReading;
+    timeout;
+    _connectionClosed;
+    constructor(timeout) {
+        this._data = platform_node_js_1.Buffer.alloc(0);
+        this._connectionClosed = true;
+        this.timeout = timeout;
+    }
+    async connect(ip, port, proxy) {
+        if (platform_node_js_1.isBrowser) {
+            if (proxy && !('server' in proxy && 'port' in proxy && 'secret' in proxy)) {
+                throw new index_js_1.WSError.ProxyUnsupported();
+            }
+            if (port === 443) {
+                this._client = new WebSocket(`wss://${ip.replace('$PORT', String(port))}`, 'binary');
+            }
+            else {
+                this._client = new WebSocket(`ws://${ip.replace('$PORT', String(port))}`, 'binary');
+            }
+            this._connectionClosed = false;
+            this._read = new Promise((resolve) => {
+                this._promisedReading = resolve;
+            });
+            return new Promise((resolve, reject) => {
+                this._client.onopen = () => {
+                    this.recv();
+                    resolve(this);
+                };
+                this._client.onerror = (error) => {
+                    return 'message' in error
+                        ? reject(new index_js_1.WSError.WebSocketError(error.message))
+                        : reject(error);
+                };
+                this._client.onclose = () => {
+                    if (this._client.readyState >= 2) {
+                        if (this._promisedReading)
+                            this._promisedReading(false);
+                        this._connectionClosed = true;
+                    }
+                };
+                globalThis.addEventListener('offline', this.destroy);
+            });
+        }
+        else {
+            if (proxy &&
+                !('server' in proxy && 'port' in proxy && 'secret' in proxy) &&
+                'hostname' in proxy &&
+                'port' in proxy &&
+                'socks' in proxy) {
+                const ws = await platform_node_js_1.SocksClient.createConnection({
+                    proxy: {
+                        host: proxy.hostname,
+                        port: proxy.port,
+                        type: proxy.socks < 4 || proxy.socks > 5 ? 5 : proxy.socks,
+                        userId: proxy.username,
+                        password: proxy.password,
+                    },
+                    command: 'connect',
+                    timeout: this.timeout,
+                    destination: {
+                        host: ip,
+                        port: port,
+                    },
+                });
+                this._client = ws.socket;
+                this._client.setTimeout(this.timeout);
+                this._connectionClosed = false;
+                this._read = new Promise((resolve) => {
+                    this._promisedReading = resolve;
+                });
+                return new Promise((resolve, reject) => {
+                    this._client.on('error', (error) => {
+                        return error.message
+                            ? reject(new index_js_1.WSError.WebSocketError(error.message))
+                            : reject(error);
+                    });
+                    this._client.on('close', () => {
+                        if (this._client.destroyed) {
+                            if (this._promisedReading)
+                                this._promisedReading(false);
+                            this._connectionClosed = true;
+                        }
+                    });
+                    this.recv();
+                    resolve(this);
+                });
+            }
+            else {
+                this._client = new platform_node_js_1.net.Socket();
+                this._client.setTimeout(this.timeout);
+                this._connectionClosed = false;
+                this._read = new Promise((resolve) => {
+                    this._promisedReading = resolve;
+                });
+                return new Promise((resolve, reject) => {
+                    this._client.connect(port, ip, () => {
+                        this.recv();
+                        resolve(this);
+                    });
+                    this._client.on('error', (error) => {
+                        return error.message
+                            ? reject(new index_js_1.WSError.WebSocketError(error.message))
+                            : reject(error);
+                    });
+                    this._client.on('close', () => {
+                        if (this._client.destroyed) {
+                            if (this._promisedReading)
+                                this._promisedReading(false);
+                            this._connectionClosed = true;
+                        }
+                    });
+                });
+            }
+        }
+    }
+    async destroy() {
+        if (this._client && !this._connectionClosed) {
+            this._connectionClosed = true;
+            this._read = new Promise((resolve) => {
+                this._promisedReading = resolve;
+            });
+            if (platform_node_js_1.isBrowser) {
+                await this._client.close();
+            }
+            else {
+                await this._client.destroy();
+                await this._client.unref();
+            }
+        }
+        return this._connectionClosed;
+    }
+    recv() {
+        if (this._client && !this._connectionClosed) {
+            if (platform_node_js_1.isBrowser) {
+                this._client.onmessage = async (data) => {
+                    const _data = platform_node_js_1.Buffer.from(await new Response(data.data).arrayBuffer());
+                    const release = await mutex.acquire();
+                    try {
+                        Logger_js_1.Logger.debug(`[3] Receive ${platform_node_js_1.Buffer.byteLength(_data)} bytes data`);
+                        this._data = platform_node_js_1.Buffer.concat([
+                            this._data,
+                            _data,
+                        ]);
+                        if (this._promisedReading)
+                            this._promisedReading(true);
+                    }
+                    finally {
+                        release();
+                    }
+                };
+            }
+            else {
+                this._client.on('data', async (data) => {
+                    const release = await mutex.acquire();
+                    try {
+                        Logger_js_1.Logger.debug(`[3] Receive ${platform_node_js_1.Buffer.byteLength(data)} bytes data`);
+                        this._data = platform_node_js_1.Buffer.concat([
+                            this._data,
+                            data,
+                        ]);
+                        if (this._promisedReading)
+                            this._promisedReading(true);
+                    }
+                    finally {
+                        release();
+                    }
+                });
+            }
+        }
+        else {
+            throw new index_js_1.WSError.Disconnected();
+        }
+    }
+    async send(data) {
+        if (this._client && !this._connectionClosed) {
+            const release = await mutex.acquire();
+            try {
+                if (platform_node_js_1.isBrowser) {
+                    this._client.send(data);
+                }
+                else {
+                    this._client.write(data);
+                }
+            }
+            finally {
+                release();
+            }
+        }
+        else {
+            throw new index_js_1.WSError.Disconnected();
+        }
+    }
+    async read(length) {
+        if (this._connectionClosed) {
+            throw new index_js_1.WSError.ReadClosed();
+        }
+        await this._read;
+        if (this._connectionClosed) {
+            throw new index_js_1.WSError.ReadClosed();
+        }
+        const toRead = this._data.subarray(0, length);
+        this._data = this._data.subarray(length);
+        if (platform_node_js_1.Buffer.byteLength(this._data) <= 0) {
+            this._read = new Promise((resolve) => {
+                this._promisedReading = resolve;
+            });
+        }
+        return toRead;
+    }
+    async reading(length) {
+        if (this._client && !this._connectionClosed) {
+            let data = platform_node_js_1.Buffer.alloc(0);
+            while (!this._connectionClosed) {
+                const readed = await this.read(length);
+                data = platform_node_js_1.Buffer.concat([data, readed]);
+                length = length - platform_node_js_1.Buffer.byteLength(readed);
+                if (!length)
+                    return data;
+            }
+        }
+        else {
+            throw new index_js_1.WSError.ReadClosed();
+        }
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        const toPrint = {
+            _: this.constructor.name,
+        };
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                const value = this[key];
+                if (!key.startsWith('_') && value !== undefined && value !== null) {
+                    toPrint[key] = value;
+                }
+            }
+        }
+        return toPrint;
+    }
+    [Symbol.for('Deno.customInspect')]() {
+        return String((0, platform_node_js_1.inspect)(this[Symbol.for('nodejs.util.inspect.custom')](), { colors: true }));
+    }
+    toJSON() {
+        const toPrint = {
+            _: this.constructor.name,
+        };
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                const value = this[key];
+                if (!key.startsWith('_') && value !== undefined && value !== null) {
+                    if (typeof value === 'bigint') {
+                        toPrint[key] = String(value);
+                    }
+                    else if (Array.isArray(value)) {
+                        toPrint[key] = value.map((v) => (typeof v === 'bigint' ? String(v) : v));
+                    }
+                    else {
+                        toPrint[key] = value;
+                    }
+                }
+            }
+        }
+        return toPrint;
+    }
+    toString() {
+        return `[constructor of ${this.constructor.name}] ${JSON.stringify(this, null, 2)}`;
+    }
+}
+exports.Socket = Socket;

package/lib/src/connection/connection.d.ts

@@ -0,0 +1,53 @@
+import * as TCPs from './TCP/index.js';
+import { Buffer } from '../platform.node.js';
+export declare const TCPModes: {
+    0: typeof TCPs.TCPFull;
+    1: typeof TCPs.TCPAbridged;
+    2: typeof TCPs.TCPIntermediate;
+    3: typeof TCPs.TCPPaddedIntermediate;
+    4: typeof TCPs.TCPAbridgedO;
+    5: typeof TCPs.TCPIntermediateO;
+};
+export type TypeTCP = TCPs.TCPFull | TCPs.TCPAbridged | TCPs.TCPIntermediate | TCPs.TCPAbridgedO | TCPs.TCPIntermediateO | TCPs.TCPPaddedIntermediate;
+export declare enum TCP {
+    TCPFull = 0,
+    TCPAbridged = 1,
+    TCPIntermediate = 2,
+    TCPPaddedIntermediate = 3,
+    TCPAbridgedO = 4,
+    TCPIntermediateO = 5
+}
+export interface SocksProxyInterface {
+    hostname: string;
+    port: number;
+    socks: 4 | 5;
+    username?: string;
+    password?: string;
+}
+export interface MtprotoProxyInterface {
+    server: string;
+    port: number;
+    secret: string | Buffer;
+}
+export type ProxyInterface = SocksProxyInterface | MtprotoProxyInterface;
+export declare class Connection {
+    maxRetries: number;
+    private _dcId;
+    private _test;
+    private _proxy?;
+    private _media;
+    private _mode;
+    private _address;
+    private _protocol;
+    private _connected;
+    private _local;
+    constructor(dcId: number, test: boolean, ipv6: boolean, proxy?: ProxyInterface, media?: boolean, mode?: TCP, local?: boolean);
+    connect(): Promise<true>;
+    close(): Promise<void>;
+    send(data: Buffer): Promise<void>;
+    recv(): Promise<Buffer<ArrayBufferLike> | undefined>;
+    toJSON(): {
+        [key: string]: any;
+    };
+    toString(): string;
+}

package/lib/src/connection/connection.js

@@ -0,0 +1,189 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Connection = exports.TCP = exports.TCPModes = void 0;
+const TCPs = __importStar(require("./TCP/index.js"));
+const index_js_1 = require("../session/index.js");
+const helpers_js_1 = require("../helpers.js");
+const Logger_js_1 = require("../Logger.js");
+const platform_node_js_1 = require("../platform.node.js");
+const index_js_2 = require("../errors/index.js");
+exports.TCPModes = {
+    0: TCPs.TCPFull,
+    1: TCPs.TCPAbridged,
+    2: TCPs.TCPIntermediate,
+    3: TCPs.TCPPaddedIntermediate,
+    4: TCPs.TCPAbridgedO,
+    5: TCPs.TCPIntermediateO,
+};
+var TCP;
+(function (TCP) {
+    TCP[TCP["TCPFull"] = 0] = "TCPFull";
+    TCP[TCP["TCPAbridged"] = 1] = "TCPAbridged";
+    TCP[TCP["TCPIntermediate"] = 2] = "TCPIntermediate";
+    TCP[TCP["TCPPaddedIntermediate"] = 3] = "TCPPaddedIntermediate";
+    TCP[TCP["TCPAbridgedO"] = 4] = "TCPAbridgedO";
+    TCP[TCP["TCPIntermediateO"] = 5] = "TCPIntermediateO";
+})(TCP || (exports.TCP = TCP = {}));
+class Connection {
+    maxRetries;
+    _dcId;
+    _test;
+    _proxy;
+    _media;
+    _mode;
+    _address;
+    _protocol;
+    _connected;
+    _local;
+    constructor(dcId, test, ipv6, proxy, media = false, mode = TCP.TCPFull, local = (platform_node_js_1.isBrowser && globalThis && globalThis.location.protocol !== 'https:') || true) {
+        this.maxRetries = 3;
+        this._dcId = dcId;
+        this._test = test;
+        this._proxy = proxy;
+        this._media = media;
+        this._mode = mode;
+        this._address = index_js_1.DataCenter.DataCenter(dcId, test, ipv6, media);
+        this._local = local;
+        this._connected = false;
+    }
+    async connect() {
+        if (this._protocol && this._connected) {
+            throw new index_js_2.ClientError.ClientReady();
+        }
+        for (let i = 0; i < this.maxRetries; i++) {
+            if (((this._proxy &&
+                'server' in this._proxy &&
+                'port' in this._proxy &&
+                'secret' in this._proxy) ||
+                platform_node_js_1.isBrowser) &&
+                this._mode !== TCP.TCPAbridgedO &&
+                this._mode !== TCP.TCPIntermediateO) {
+                if (this._proxy &&
+                    'server' in this._proxy &&
+                    'port' in this._proxy &&
+                    'secret' in this._proxy) {
+                    const secret = (0, helpers_js_1.normalizeSecretString)(this._proxy.secret);
+                    if (secret[0] === 0xdd) {
+                        this._mode = TCP.TCPIntermediateO;
+                    }
+                    else {
+                        this._mode = TCP.TCPAbridgedO;
+                    }
+                }
+                else {
+                    this._mode = TCP.TCPAbridgedO;
+                }
+            }
+            this._protocol = new exports.TCPModes[this._mode]();
+            try {
+                Logger_js_1.Logger.debug(`[1] Connecting to DC${this._dcId} with ${this._protocol.constructor.name}`);
+                await this._protocol.connect(this._address[0], platform_node_js_1.isBrowser ? (this._local ? 80 : this._address[1]) : this._address[1], this._proxy, this._dcId + (this._test ? 10000 : 0) * (this._media ? -1 : 1));
+                this._connected = true;
+                break;
+            }
+            catch (error) {
+                Logger_js_1.Logger.error(`[106] Got error when trying connecting to telegram :`, error);
+                this._protocol.close();
+                await (0, helpers_js_1.sleep)(2000);
+            }
+        }
+        if (!this._connected) {
+            throw new index_js_2.ClientError.ClientFailed();
+        }
+        return this._connected;
+    }
+    async close() {
+        if (!this._protocol || !this._connected) {
+            throw new index_js_2.ClientError.ClientNotReady();
+        }
+        this._connected = false;
+        await (0, helpers_js_1.sleep)(10);
+        await this._protocol.close();
+    }
+    async send(data) {
+        Logger_js_1.Logger.debug(`[2] Sending ${platform_node_js_1.Buffer.byteLength(data)} bytes data.`);
+        await this._protocol.send(data);
+    }
+    async recv() {
+        if (!this._connected) {
+            throw new index_js_2.ClientError.ClientDisconnected();
+        }
+        return await this._protocol.recv();
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        const toPrint = {
+            _: this.constructor.name,
+        };
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                const value = this[key];
+                if (!key.startsWith('_') && value !== undefined && value !== null) {
+                    toPrint[key] = value;
+                }
+            }
+        }
+        return toPrint;
+    }
+    [Symbol.for('Deno.customInspect')]() {
+        return String((0, platform_node_js_1.inspect)(this[Symbol.for('nodejs.util.inspect.custom')](), { colors: true }));
+    }
+    toJSON() {
+        const toPrint = {
+            _: this.constructor.name,
+        };
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                const value = this[key];
+                if (!key.startsWith('_') && value !== undefined && value !== null) {
+                    if (typeof value === 'bigint') {
+                        toPrint[key] = String(value);
+                    }
+                    else if (Array.isArray(value)) {
+                        toPrint[key] = value.map((v) => (typeof v === 'bigint' ? String(v) : v));
+                    }
+                    else {
+                        toPrint[key] = value;
+                    }
+                }
+            }
+        }
+        return toPrint;
+    }
+    toString() {
+        return `[constructor of ${this.constructor.name}] ${JSON.stringify(this, null, 2)}`;
+    }
+}
+exports.Connection = Connection;

package/lib/src/connection/index.d.ts

@@ -0,0 +1,4 @@
+import * as TCP from './TCP/index.js';
+export * as Connections from './connection.js';
+export { Socket } from './WebSocket.js';
+export { TCP };

package/lib/src/connection/index.js

@@ -0,0 +1,41 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TCP = exports.Socket = exports.Connections = void 0;
+const TCP = __importStar(require("./TCP/index.js"));
+exports.TCP = TCP;
+exports.Connections = __importStar(require("./connection.js"));
+var WebSocket_js_1 = require("./WebSocket.js");
+Object.defineProperty(exports, "Socket", { enumerable: true, get: function () { return WebSocket_js_1.Socket; } });

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

@@ -0,0 +1,10 @@
+import { Buffer } from '../platform.node.js';
+export declare function ige256Encrypt(data: Buffer, key: Buffer, iv: Buffer): Buffer;
+export declare function ige256Decrypt(data: Buffer, key: Buffer, iv: Buffer): Buffer;
+export type CtrCipherFn = (data: Buffer) => Buffer;
+export declare function ctr256Cipher(key: Buffer, iv: Buffer): CtrCipherFn;
+export declare function xor(a: Buffer, b: Buffer): Buffer<ArrayBuffer>;
+export declare function AES(key: Buffer): {
+    encrypt(data: Buffer): Buffer;
+    decrypt(data: Buffer): Buffer;
+};