sroosh 1.0.0

package/network/connection/ConnectionWebSocket.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionWebSocket = exports.ObfuscatedIO = void 0;
+// src/gramjs/network/ConnectionWebSocket.ts
+const Helpers_1 = require("../../Helpers");
+const Connection_1 = require("./Connection");
+const TCPAbridged_1 = require("./TCPAbridged");
+const CTR_1 = require("../../crypto/CTR");
+const extensions_1 = require("../../extensions");
+class ObfuscatedIO {
+    constructor(connection) {
+        this.header = undefined;
+        this.connection = connection.socket;
+        this._packetClass = new TCPAbridged_1.AbridgedPacketCodec(connection);
+    }
+    async initHeader() {
+        const keywords = [
+            Buffer.from("50567247", "hex"),
+            Buffer.from("474554", "hex"),
+            Buffer.from("504f5354", "hex"),
+            Buffer.from("eeeeeeee", "hex"),
+        ];
+        let random;
+        while (true) {
+            random = (0, Helpers_1.generateRandomBytes)(64);
+            if (random[0] !== 0xef &&
+                !random.slice(4, 8).equals(Buffer.alloc(4))) {
+                let ok = true;
+                for (const key of keywords) {
+                    if (key.equals(random.slice(0, 4))) {
+                        ok = false;
+                        break;
+                    }
+                }
+                if (ok)
+                    break;
+            }
+        }
+        random = random.toJSON().data;
+        const randomReversed = Buffer.from(random.slice(8, 56)).reverse();
+        const encryptKey = Buffer.from(random.slice(8, 40));
+        const encryptIv = Buffer.from(random.slice(40, 56));
+        const decryptKey = Buffer.from(randomReversed.slice(0, 32));
+        const decryptIv = Buffer.from(randomReversed.slice(32, 48));
+        const encryptor = new CTR_1.CTR(encryptKey, encryptIv);
+        const decryptor = new CTR_1.CTR(decryptKey, decryptIv);
+        random = Buffer.concat([
+            Buffer.from(random.slice(0, 56)),
+            this._packetClass.obfuscateTag,
+            Buffer.from(random.slice(60)),
+        ]);
+        random = Buffer.concat([
+            Buffer.from(random.slice(0, 56)),
+            Buffer.from(encryptor.encrypt(random).slice(56, 64)),
+            Buffer.from(random.slice(64)),
+        ]);
+        this.header = random;
+        this._encrypt = encryptor;
+        this._decrypt = decryptor;
+    }
+    async read(n) {
+        const data = await this.connection.readExactly(n);
+        return this._decrypt.encrypt(data);
+    }
+    write(data) {
+        this.connection.write(this._encrypt.encrypt(data));
+    }
+}
+exports.ObfuscatedIO = ObfuscatedIO;
+class ConnectionWebSocket extends Connection_1.ObfuscatedConnection {
+    constructor(props) {
+        super(Object.assign(Object.assign({}, props), { socket: extensions_1.PromisedWebSockets }));
+        this.ObfuscatedIO = ObfuscatedIO;
+        this.PacketCodecClass = TCPAbridged_1.AbridgedPacketCodec;
+    }
+}
+exports.ConnectionWebSocket = ConnectionWebSocket;

package/network/connection/CustomIntermediatePacketCodec.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { PacketCodec } from "./Connection";
+export declare class CustomIntermediatePacketCodec extends PacketCodec {
+    tag: Buffer;
+    constructor(connection: any);
+    encodePacket(data: Buffer): Buffer;
+    readPacket(reader: any): Promise<Buffer>;
+}

package/network/connection/CustomIntermediatePacketCodec.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomIntermediatePacketCodec = void 0;
+const Connection_1 = require("./Connection");
+class CustomIntermediatePacketCodec extends Connection_1.PacketCodec {
+    constructor(connection) {
+        super(connection);
+        // تگ Intermediate: 4 بایت 0xee
+        this.tag = Buffer.from([0xee, 0xee, 0xee, 0xee]);
+    }
+    encodePacket(data) {
+        const length = Buffer.alloc(4);
+        length.writeUInt32LE(data.length, 0);
+        return Buffer.concat([length, data]);
+    }
+    async readPacket(reader) {
+        const lengthBuffer = await reader.readExactly(4);
+        const length = lengthBuffer.readUInt32LE(0);
+        if (length > 1024 * 1024) {
+            throw new Error(`Invalid packet length: ${length}`);
+        }
+        return await reader.readExactly(length);
+    }
+}
+exports.CustomIntermediatePacketCodec = CustomIntermediatePacketCodec;

package/network/connection/CustomPromisedWebSockets.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+export declare class CustomPromisedWebSockets {
+    private closed;
+    private timeout;
+    private stream;
+    private canRead;
+    private resolveRead;
+    private client?;
+    private website?;
+    disconnectCallback?: () => void;
+    private firstWrite;
+    private pendingTag;
+    constructor(proxy?: any);
+    private getWebSocketLink;
+    connect(port: number, ip: string, isTest?: boolean, isPremium?: boolean): Promise<unknown>;
+    write(data: Buffer): void;
+    close(): void;
+    readExactly(length: number): Promise<Buffer>;
+    read(length: number): Promise<Buffer>;
+    readAll(): Promise<Buffer>;
+    private receive;
+}

package/network/connection/CustomPromisedWebSockets.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomPromisedWebSockets = void 0;
+const websocket_1 = require("websocket");
+const buffer_1 = require("buffer");
+class CustomPromisedWebSockets {
+    constructor(proxy) {
+        this.closed = true;
+        this.timeout = 5000;
+        this.stream = buffer_1.Buffer.alloc(0);
+        this.firstWrite = true;
+        this.pendingTag = null;
+    }
+    getWebSocketLink(ip, port, isTest, isPremium) {
+        const protocol = port === 443 ? "wss" : "ws";
+        const testSuffix = isTest ? "_test" : "";
+        return `${protocol}://${ip}:${port}/apiws${testSuffix}`;
+    }
+    async connect(port, ip, isTest = false, isPremium = false) {
+        this.stream = buffer_1.Buffer.alloc(0);
+        this.canRead = new Promise((resolve) => {
+            this.resolveRead = resolve;
+        });
+        this.closed = false;
+        this.website = this.getWebSocketLink(ip, port, isTest, isPremium);
+        console.log(`[WS] Connecting to: ${this.website}`);
+        this.client = new websocket_1.w3cwebsocket(this.website, "binary", "https://web.splus.ir");
+        if (this.client) {
+            this.client.binaryType = "arraybuffer";
+        }
+        return new Promise((resolve, reject) => {
+            if (!this.client)
+                return;
+            let timeoutHandle;
+            let settled = false;
+            this.client.onopen = () => {
+                console.log("[WS] Connection opened!");
+                this.receive();
+                resolve(this);
+                settled = true;
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+            };
+            this.client.onerror = (error) => {
+                console.error("[WS] Error:", (error === null || error === void 0 ? void 0 : error.message) || error);
+                if (!settled) {
+                    reject(error);
+                    settled = true;
+                    if (timeoutHandle)
+                        clearTimeout(timeoutHandle);
+                }
+            };
+            this.client.onclose = (event) => {
+                var _a;
+                const code = event === null || event === void 0 ? void 0 : event.code;
+                const reason = event === null || event === void 0 ? void 0 : event.reason;
+                console.log(`[WS] Closed. Code: ${code}, Reason: ${reason}`);
+                (_a = this.resolveRead) === null || _a === void 0 ? void 0 : _a.call(this, false);
+                this.closed = true;
+                if (this.disconnectCallback)
+                    this.disconnectCallback();
+                if (!settled) {
+                    reject(new Error(`WebSocket closed with code ${code}`));
+                    settled = true;
+                    if (timeoutHandle)
+                        clearTimeout(timeoutHandle);
+                }
+            };
+            timeoutHandle = setTimeout(() => {
+                var _a, _b;
+                if (!settled) {
+                    console.error("[WS] Connection timeout!");
+                    reject(new Error("WebSocket connection timeout"));
+                    (_a = this.resolveRead) === null || _a === void 0 ? void 0 : _a.call(this, false);
+                    this.closed = true;
+                    if (this.disconnectCallback)
+                        this.disconnectCallback();
+                    (_b = this.client) === null || _b === void 0 ? void 0 : _b.close();
+                }
+            }, this.timeout);
+        });
+    }
+    write(data) {
+        var _a, _b;
+        if (this.closed)
+            throw new Error("Not connected");
+        // اگه اولین نوشته، تگ رو قبلش اضافه کن
+        if (this.firstWrite && data.length === 4 && data[0] === 0xee) {
+            console.log(`[WS] First write - waiting for next packet to combine with tag`);
+            this.pendingTag = data;
+            this.firstWrite = false;
+            return; // هنوز چیزی نفرست
+        }
+        if (this.pendingTag) {
+            const combined = buffer_1.Buffer.concat([this.pendingTag, data]);
+            console.log(`[WS RAW SEND COMBINED] ${combined.length} bytes | hex: ${combined.slice(0, 32).toString("hex")}`);
+            (_a = this.client) === null || _a === void 0 ? void 0 : _a.send(combined);
+            this.pendingTag = null;
+        }
+        else {
+            console.log(`[WS RAW SEND] ${data.length} bytes | hex: ${data
+                .slice(0, 32)
+                .toString("hex")}`);
+            (_b = this.client) === null || _b === void 0 ? void 0 : _b.send(data);
+        }
+    }
+    close() {
+        var _a;
+        (_a = this.client) === null || _a === void 0 ? void 0 : _a.close();
+        this.closed = true;
+    }
+    async readExactly(length) {
+        let result = buffer_1.Buffer.alloc(0);
+        while (true) {
+            const chunk = await this.read(length);
+            result = buffer_1.Buffer.concat([result, chunk]);
+            length -= chunk.length;
+            if (length === 0)
+                return result;
+        }
+    }
+    async read(length) {
+        if (this.closed)
+            throw new Error("Connection closed");
+        await this.canRead;
+        if (this.closed)
+            throw new Error("Connection closed");
+        const chunk = this.stream.slice(0, length);
+        this.stream = this.stream.slice(length);
+        if (this.stream.length === 0) {
+            this.canRead = new Promise((resolve) => {
+                this.resolveRead = resolve;
+            });
+        }
+        return chunk;
+    }
+    async readAll() {
+        if (this.closed || !(await this.canRead))
+            throw new Error("Connection closed");
+        const result = this.stream;
+        this.stream = buffer_1.Buffer.alloc(0);
+        this.canRead = new Promise((resolve) => {
+            this.resolveRead = resolve;
+        });
+        return result;
+    }
+    receive() {
+        if (this.client) {
+            this.client.onmessage = async (message) => {
+                var _a;
+                let data;
+                if (message.data instanceof ArrayBuffer) {
+                    data = buffer_1.Buffer.from(message.data);
+                }
+                else if (buffer_1.Buffer.isBuffer(message.data)) {
+                    data = message.data;
+                }
+                else {
+                    data = buffer_1.Buffer.from(message.data);
+                }
+                console.log(`[WS RAW RECV] ${data.length} bytes | hex: ${data
+                    .slice(0, Math.min(32, data.length))
+                    .toString("hex")}`);
+                this.stream = buffer_1.Buffer.concat([this.stream, data]);
+                (_a = this.resolveRead) === null || _a === void 0 ? void 0 : _a.call(this, true);
+            };
+        }
+    }
+}
+exports.CustomPromisedWebSockets = CustomPromisedWebSockets;

package/network/connection/ObfuscatedIO.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { Connection } from "./Connection";
+export declare class ObfuscatedIO {
+    header: Buffer;
+    private _encrypt;
+    private _decrypt;
+    private _connection;
+    constructor(connection: Connection);
+    private initHeader;
+    encrypt(data: Buffer): Buffer;
+    decrypt(data: Buffer): Buffer;
+}

package/network/connection/ObfuscatedIO.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObfuscatedIO = void 0;
+const AES_CTR_1 = require("../extensions/AES_CTR");
+class ObfuscatedIO {
+    constructor(connection) {
+        this._connection = connection;
+        const { random, encryptor, decryptor } = this.initHeader(connection.PacketCodecClass);
+        this.header = random;
+        this._encrypt = encryptor;
+        this._decrypt = decryptor;
+    }
+    initHeader(CodecClass) {
+        // تولید هدر ۶۴ بایتی
+        let random;
+        while (true) {
+            random = Buffer.alloc(64);
+            // پر کردن با اعداد رندوم
+            for (let i = 0; i < 64; i++) {
+                random[i] = Math.floor(Math.random() * 256);
+            }
+            // چک کردن اینکه شبیه پروتکل‌های وب نباشه
+            const first4 = random.slice(0, 4).toString("hex");
+            if (random[0] !== 0xef &&
+                first4 !== "50567247" && // PVrG
+                first4 !== "47455420" && // GET 
+                first4 !== "504f5354" && // POST
+                first4 !== "48454144" && // HEAD
+                first4 !== "eeeeeeee") {
+                break;
+            }
+        }
+        // استخراج کلید و IV
+        const reversed = Buffer.from(random.slice(8, 56)).reverse();
+        const keyEncrypt = reversed.slice(0, 32);
+        const ivEncrypt = reversed.slice(32, 48);
+        const keyDecrypt = random.slice(8, 40);
+        const ivDecrypt = random.slice(40, 56);
+        // ساخت AES-CTR
+        const encryptor = new AES_CTR_1.AES_CTR(keyEncrypt, ivEncrypt);
+        const decryptor = new AES_CTR_1.AES_CTR(keyDecrypt, ivDecrypt);
+        // تزریق تگ پروتکل
+        const obfuscateTag = CodecClass.obfuscateTag || Buffer.from("efefefef", "hex");
+        random = Buffer.concat([
+            random.slice(0, 56),
+            obfuscateTag,
+            random.slice(60)
+        ]);
+        // رمزنگاری بخش آخر هدر
+        const encrypted = encryptor.encrypt(random);
+        random = Buffer.concat([
+            random.slice(0, 56),
+            encrypted.slice(56, 64)
+        ]);
+        return { random, encryptor, decryptor };
+    }
+    encrypt(data) {
+        return this._encrypt.encrypt(data);
+    }
+    decrypt(data) {
+        return this._decrypt.decrypt(data);
+    }
+}
+exports.ObfuscatedIO = ObfuscatedIO;

package/network/connection/TCPAbridged.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { Connection, PacketCodec } from "./Connection";
+import type { PromisedNetSockets, PromisedWebSockets } from "../../extensions";
+export declare class AbridgedPacketCodec extends PacketCodec {
+    static tag: Buffer;
+    static obfuscateTag: Buffer;
+    private tag;
+    obfuscateTag: Buffer;
+    constructor(props: any);
+    encodePacket(data: Buffer): Buffer;
+    readPacket(reader: PromisedNetSockets | PromisedWebSockets): Promise<Buffer>;
+}
+/**
+ * This is the mode with the lowest overhead, as it will
+ * only require 1 byte if the packet length is less than
+ * 508 bytes (127 << 2, which is very common).
+ */
+export declare class ConnectionTCPAbridged extends Connection {
+    PacketCodecClass: typeof AbridgedPacketCodec;
+}

package/network/connection/TCPAbridged.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionTCPAbridged = exports.AbridgedPacketCodec = void 0;
+const Helpers_1 = require("../../Helpers");
+const Connection_1 = require("./Connection");
+const big_integer_1 = __importDefault(require("big-integer"));
+class AbridgedPacketCodec extends Connection_1.PacketCodec {
+    constructor(props) {
+        super(props);
+        this.tag = AbridgedPacketCodec.tag;
+        this.obfuscateTag = AbridgedPacketCodec.obfuscateTag;
+    }
+    encodePacket(data) {
+        let length = data.length >> 2;
+        let temp;
+        if (length < 127) {
+            const b = Buffer.alloc(1);
+            b.writeUInt8(length, 0);
+            temp = b;
+        }
+        else {
+            temp = Buffer.concat([
+                Buffer.from("7f", "hex"),
+                (0, Helpers_1.readBufferFromBigInt)((0, big_integer_1.default)(length), 3),
+            ]);
+        }
+        return Buffer.concat([temp, data]);
+    }
+    async readPacket(reader) {
+        const readData = await reader.read(1);
+        let length = readData[0];
+        if (length >= 127) {
+            length = Buffer.concat([
+                await reader.read(3),
+                Buffer.alloc(1),
+            ]).readInt32LE(0);
+        }
+        return reader.read(length << 2);
+    }
+}
+exports.AbridgedPacketCodec = AbridgedPacketCodec;
+AbridgedPacketCodec.tag = Buffer.from("ef", "hex");
+AbridgedPacketCodec.obfuscateTag = Buffer.from("efefefef", "hex");
+/**
+ * This is the mode with the lowest overhead, as it will
+ * only require 1 byte if the packet length is less than
+ * 508 bytes (127 << 2, which is very common).
+ */
+class ConnectionTCPAbridged extends Connection_1.Connection {
+    constructor() {
+        super(...arguments);
+        this.PacketCodecClass = AbridgedPacketCodec;
+    }
+}
+exports.ConnectionTCPAbridged = ConnectionTCPAbridged;

package/network/connection/TCPFull.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import { Connection, PacketCodec } from "./Connection";
+import type { PromisedNetSockets, PromisedWebSockets } from "../../extensions";
+export declare class FullPacketCodec extends PacketCodec {
+    private _sendCounter;
+    constructor(connection: any);
+    encodePacket(data: Buffer): Buffer;
+    /**
+     *
+     * @param reader {PromisedWebSockets}
+     * @returns {Promise<*>}
+     */
+    readPacket(reader: PromisedNetSockets | PromisedWebSockets): Promise<Buffer>;
+}
+export declare class ConnectionTCPFull extends Connection {
+    PacketCodecClass: typeof FullPacketCodec;
+}

package/network/connection/TCPFull.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionTCPFull = exports.FullPacketCodec = void 0;
+const Connection_1 = require("./Connection");
+const Helpers_1 = require("../../Helpers");
+const errors_1 = require("../../errors");
+class FullPacketCodec extends Connection_1.PacketCodec {
+    constructor(connection) {
+        super(connection);
+        this._sendCounter = 0; // Telegram will ignore us otherwise
+    }
+    encodePacket(data) {
+        // https://core.telegram.org/mtproto#tcp-transport
+        // total length, sequence number, packet and checksum (CRC32)
+        const length = data.length + 12;
+        const e = Buffer.alloc(8);
+        e.writeInt32LE(length, 0);
+        e.writeInt32LE(this._sendCounter, 4);
+        data = Buffer.concat([e, data]);
+        const crc = Buffer.alloc(4);
+        crc.writeUInt32LE((0, Helpers_1.crc32)(data), 0);
+        this._sendCounter += 1;
+        return Buffer.concat([data, crc]);
+    }
+    /**
+     *
+     * @param reader {PromisedWebSockets}
+     * @returns {Promise<*>}
+     */
+    async readPacket(reader) {
+        const packetLenSeq = await reader.readExactly(8); // 4 and 4
+        if (packetLenSeq === undefined) {
+            // Return empty buffer in case of issue
+            return Buffer.alloc(0);
+        }
+        const packetLen = packetLenSeq.readInt32LE(0);
+        if (packetLen < 0) {
+            // # It has been observed that the length and seq can be -429,
+            // # followed by the body of 4 bytes also being -429.
+            // # See https://github.com/LonamiWebs/Telethon/issues/4042.
+            const body = await reader.readExactly(4);
+            throw new errors_1.InvalidBufferError(body);
+        }
+        let body = await reader.readExactly(packetLen - 8);
+        const checksum = body.slice(-4).readUInt32LE(0);
+        body = body.slice(0, -4);
+        const validChecksum = (0, Helpers_1.crc32)(Buffer.concat([packetLenSeq, body]));
+        if (!(validChecksum === checksum)) {
+            throw new errors_1.InvalidChecksumError(checksum, validChecksum);
+        }
+        return body;
+    }
+}
+exports.FullPacketCodec = FullPacketCodec;
+class ConnectionTCPFull extends Connection_1.Connection {
+    constructor() {
+        super(...arguments);
+        this.PacketCodecClass = FullPacketCodec;
+    }
+}
+exports.ConnectionTCPFull = ConnectionTCPFull;

package/network/connection/TCPMTProxy.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="node" />
+import { ObfuscatedConnection } from "./Connection";
+import { AbridgedPacketCodec } from "./TCPAbridged";
+import { Logger, PromisedNetSockets, PromisedWebSockets } from "../../extensions";
+interface BasicProxyInterface {
+    ip: string;
+    port: number;
+    timeout?: number;
+    username?: string;
+    password?: string;
+}
+export declare type MTProxyType = BasicProxyInterface & {
+    secret: string;
+    MTProxy: true;
+};
+export declare type SocksProxyType = BasicProxyInterface & {
+    socksType: 4 | 5;
+};
+export declare type ProxyInterface = MTProxyType | SocksProxyType;
+declare class MTProxyIO {
+    header?: Buffer;
+    private connection;
+    private _encrypt?;
+    private _decrypt?;
+    private _packetClass;
+    private _secret;
+    private _dcId;
+    constructor(connection: TCPMTProxy);
+    initHeader(): Promise<void>;
+    read(n: number): Promise<Buffer>;
+    write(data: Buffer): void;
+}
+interface TCPMTProxyInterfaceParams {
+    ip: string;
+    port: number;
+    dcId: number;
+    loggers: Logger;
+    proxy: ProxyInterface;
+    socket: typeof PromisedNetSockets | typeof PromisedWebSockets;
+    testServers: boolean;
+}
+export declare class TCPMTProxy extends ObfuscatedConnection {
+    ObfuscatedIO: typeof MTProxyIO;
+    _secret: Buffer;
+    constructor({ ip, port, dcId, loggers, proxy, socket, testServers, }: TCPMTProxyInterfaceParams);
+}
+export declare class ConnectionTCPMTProxyAbridged extends TCPMTProxy {
+    PacketCodecClass: typeof AbridgedPacketCodec;
+}
+export {};