@armatofik/tgsnake-core 1.0.0

package/lib/src/crypto/SecretChat.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kdf = kdf;
+exports.pack = pack;
+exports.unpack = unpack;
+const platform_node_js_1 = require("../platform.node.js");
+const index_js_1 = require("../errors/index.js");
+const index_js_2 = require("../raw/index.js");
+const helpers_js_1 = require("../helpers.js");
+const Aes_js_1 = require("./Aes.js");
+const index_js_3 = require("../raw/index.js");
+function sha256(data) {
+    const hash = platform_node_js_1.crypto.createHash('sha256');
+    hash.update(data);
+    return hash.digest();
+}
+function sha1(data) {
+    const hash = platform_node_js_1.crypto.createHash('sha1');
+    hash.update(data);
+    return hash.digest();
+}
+function kdf(sharedKey, msgKey, isAdmin, v1 = false) {
+    const x = isAdmin ? 0 : 8;
+    if (v1) {
+        const sha1A = sha1(platform_node_js_1.Buffer.concat([
+            msgKey,
+            sharedKey.subarray(x, x + 32),
+        ]));
+        const sha1B = sha1(platform_node_js_1.Buffer.concat([
+            sharedKey.subarray(x + 32, x + 48),
+            msgKey,
+            sharedKey.subarray(x + 48, x + 64),
+        ]));
+        const sha1C = sha1(platform_node_js_1.Buffer.concat([
+            sharedKey.subarray(x + 64, x + 96),
+            msgKey,
+        ]));
+        const sha1D = sha1(platform_node_js_1.Buffer.concat([
+            msgKey,
+            sharedKey.subarray(x + 96, x + 128),
+        ]));
+        const aesKey = platform_node_js_1.Buffer.concat([
+            sha1A.subarray(0, 8),
+            sha1B.subarray(8, 20),
+            sha1C.subarray(4, 16),
+        ]);
+        const aesIv = platform_node_js_1.Buffer.concat([
+            sha1A.subarray(8, 20),
+            sha1B.subarray(0, 8),
+            sha1C.subarray(16, 20),
+            sha1D.subarray(0, 8),
+        ]);
+        return [aesKey, aesIv];
+    }
+    else {
+        const sha256A = sha256(platform_node_js_1.Buffer.concat([
+            msgKey,
+            sharedKey.subarray(x, x + 36),
+        ]));
+        const sha256B = sha256(platform_node_js_1.Buffer.concat([
+            sharedKey.subarray(x + 40, x + 76),
+            msgKey,
+        ]));
+        const aesKey = platform_node_js_1.Buffer.concat([
+            sha256A.subarray(0, 8),
+            sha256B.subarray(8, 24),
+            sha256A.subarray(24, 32),
+        ]);
+        const aesIv = platform_node_js_1.Buffer.concat([
+            sha256B.subarray(0, 8),
+            sha256A.subarray(8, 24),
+            sha256B.subarray(24, 32),
+        ]);
+        return [aesKey, aesIv];
+    }
+}
+function pack(message, sharedKey, inSeqNo, outSeqNo, isAdmin, layer, mtproto = 2) {
+    let msg = message;
+    if (layer > 8) {
+        msg = new index_js_3.Raw.DecryptedMessageLayer17({
+            randomBytes: platform_node_js_1.crypto.randomBytes(15 + 4 * Math.floor(Math.random() * 3)),
+            layer: layer,
+            inSeqNo: inSeqNo,
+            outSeqNo: outSeqNo,
+            message: message,
+        });
+    }
+    const bytesmsg = msg.write();
+    const length = platform_node_js_1.Buffer.alloc(4);
+    length.writeUInt32LE(platform_node_js_1.Buffer.byteLength(bytesmsg), 0);
+    const data = platform_node_js_1.Buffer.concat([length, bytesmsg]);
+    const padding = platform_node_js_1.Buffer.from(platform_node_js_1.crypto.randomBytes((0, helpers_js_1.mod)(-(platform_node_js_1.Buffer.byteLength(data) + 16), 16) + 16));
+    const paddedMsg = platform_node_js_1.Buffer.concat([
+        data,
+        padding,
+    ]);
+    const msgKeyLarge = sha256(platform_node_js_1.Buffer.concat([
+        sharedKey.subarray(88 + (isAdmin ? 0 : 8), 88 + (isAdmin ? 0 : 8) + 32),
+        paddedMsg,
+    ]));
+    const msgKey = mtproto === 1 ? sha1(data).subarray(-16) : msgKeyLarge.subarray(8, 8 + 16);
+    const [aesKey, aesIv] = mtproto === 1 ? kdf(sharedKey, msgKey, isAdmin, true) : kdf(sharedKey, msgKey, isAdmin, false);
+    const fingerprintKey = sha1(sharedKey).subarray(-8);
+    return platform_node_js_1.Buffer.concat([
+        fingerprintKey,
+        msgKey,
+        (0, Aes_js_1.ige256Encrypt)(paddedMsg, aesKey, aesIv),
+    ]);
+}
+async function unpack(message, sharedKey, isAdmin, mtproto = 2) {
+    const data = new index_js_2.BytesIO(message.bytes);
+    const serverFingerprintKey = data.readBigInt64LE();
+    const clientFingerprintKey = sha1(sharedKey).subarray(-8).readBigInt64LE();
+    if (serverFingerprintKey !== clientFingerprintKey) {
+        throw new index_js_1.SecretChatError.FingerprintMismatch();
+    }
+    const msgKey = data.read(16);
+    const encryptedMsg = data.read();
+    const [aesKey, aesIv] = mtproto === 1 ? kdf(sharedKey, msgKey, isAdmin, true) : kdf(sharedKey, msgKey, !isAdmin, false);
+    const decryptedMsg = new index_js_2.BytesIO((0, Aes_js_1.ige256Decrypt)(encryptedMsg, aesKey, aesIv));
+    const msgLength = decryptedMsg.readUInt32LE();
+    const payload = decryptedMsg.read();
+    const padding = payload.subarray(msgLength);
+    const msgKeyLarge = sha256(platform_node_js_1.Buffer.concat([
+        sharedKey.subarray(88 + (isAdmin ? 8 : 0), 88 + (isAdmin ? 8 : 0) + 32),
+        decryptedMsg.buffer,
+    ]));
+    const clientMsgKey = mtproto === 1
+        ? sha1(decryptedMsg.buffer.subarray(0, 4 + msgLength)).subarray(-16)
+        : msgKeyLarge.subarray(8, 8 + 16);
+    index_js_1.SecurityCheckMismatch.check(msgKey.equals(clientMsgKey), 'Given message key is not equal with client side');
+    index_js_1.SecurityCheckMismatch.check(platform_node_js_1.Buffer.byteLength(padding) >= 12 && platform_node_js_1.Buffer.byteLength(padding) <= 1024, 'Payload padding is lower than 12 or bigger than 1024');
+    index_js_1.SecurityCheckMismatch.check((0, helpers_js_1.mod)(platform_node_js_1.Buffer.byteLength(padding), 4) === 0, 'Mod of padding length with 4 is equal with zero');
+    const msg = await index_js_2.TLObject.read(new index_js_2.BytesIO(payload));
+    return msg;
+}

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

@@ -0,0 +1,6 @@
+export * as Mtproto from './Mtproto.js';
+export * as Prime from './Prime.js';
+export * as RSA from './RSA.js';
+export * as Password from './Password.js';
+export * as AES from './Aes.js';
+export * as SecretChats from './SecretChat.js';

package/lib/src/crypto/index.js

@@ -0,0 +1,42 @@
+"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.SecretChats = exports.AES = exports.Password = exports.RSA = exports.Prime = exports.Mtproto = void 0;
+exports.Mtproto = __importStar(require("./Mtproto.js"));
+exports.Prime = __importStar(require("./Prime.js"));
+exports.RSA = __importStar(require("./RSA.js"));
+exports.Password = __importStar(require("./Password.js"));
+exports.AES = __importStar(require("./Aes.js"));
+exports.SecretChats = __importStar(require("./SecretChat.js"));

package/lib/src/errors/Base.d.ts

@@ -0,0 +1,9 @@
+export declare class BaseError extends Error {
+    message: string;
+    description?: string;
+    constructor(message?: string);
+    toJSON(): {
+        [key: string]: unknown;
+    };
+    toString(): string;
+}

package/lib/src/errors/Base.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseError = void 0;
+const platform_node_js_1 = require("../platform.node.js");
+class BaseError extends Error {
+    message;
+    description;
+    constructor(message) {
+        super(message);
+    }
+    [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('_')) {
+                    toPrint[key] = value;
+                }
+            }
+        }
+        Object.setPrototypeOf(toPrint, {
+            stack: this.stack,
+        });
+        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,
+            stack: this.stack,
+        };
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                const value = this[key];
+                if (!key.startsWith('_')) {
+                    toPrint[key] = typeof value === 'bigint' ? String(value) : value;
+                }
+            }
+        }
+        return toPrint;
+    }
+    toString() {
+        return `[constructor of ${this.constructor.name}] ${JSON.stringify(this, null, 2)}`;
+    }
+}
+exports.BaseError = BaseError;

package/lib/src/errors/Client.d.ts

@@ -0,0 +1,21 @@
+import { BaseError } from './Base.js';
+export declare class ClientDisconnected extends BaseError {
+    message: string;
+    description: string;
+}
+export declare class ClientFailed extends BaseError {
+    message: string;
+    description: string;
+}
+export declare class ClientReady extends BaseError {
+    message: string;
+    description: string;
+}
+export declare class ClientNotReady extends BaseError {
+    message: string;
+    description: string;
+}
+export declare class AuthKeyMissing extends BaseError {
+    message: string;
+    description: string;
+}

package/lib/src/errors/Client.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthKeyMissing = exports.ClientNotReady = exports.ClientReady = exports.ClientFailed = exports.ClientDisconnected = void 0;
+const Base_js_1 = require("./Base.js");
+class ClientDisconnected extends Base_js_1.BaseError {
+    message = "Can't send request to telegram when client is unconnected.";
+    description = 'The provided telegram client is unconnected, make sure to start the telegram client first before sending request.';
+}
+exports.ClientDisconnected = ClientDisconnected;
+class ClientFailed extends Base_js_1.BaseError {
+    message = 'Client failed to connect to server.';
+    description = 'The provided telegram client failed to connect to the telegram data center server. Attempts to connect to the telegram server have exceeded the specified maximum limit.';
+}
+exports.ClientFailed = ClientFailed;
+class ClientReady extends Base_js_1.BaseError {
+    message = 'Client is already connected to server.';
+    description = 'The provided telegram client has been already connected to the telegram data center server.';
+}
+exports.ClientReady = ClientReady;
+class ClientNotReady extends Base_js_1.BaseError {
+    message = 'Client is already disconnected to server.';
+    description = 'The provided telegram client has been already disconnected to the telegram data center server.';
+}
+exports.ClientNotReady = ClientNotReady;
+class AuthKeyMissing extends Base_js_1.BaseError {
+    message = 'Auth key unavailable';
+    description = 'Auth key is unavailable, this can happen because at when the client is run, the user does not provide information to login.';
+}
+exports.AuthKeyMissing = AuthKeyMissing;

package/lib/src/errors/File.d.ts

@@ -0,0 +1,13 @@
+import { BaseError } from './Base.js';
+export declare class FileError extends BaseError {
+    constructor(message: string, description?: string);
+}
+export declare class FileUploadZero extends FileError {
+    constructor();
+}
+export declare class FileUploadBigger extends FileError {
+    constructor(limit: number, size: number);
+}
+export declare class FileIsNotReadable extends FileError {
+    constructor();
+}

package/lib/src/errors/File.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileIsNotReadable = exports.FileUploadBigger = exports.FileUploadZero = exports.FileError = void 0;
+const Base_js_1 = require("./Base.js");
+class FileError extends Base_js_1.BaseError {
+    constructor(message, description) {
+        super();
+        this.message = message;
+        this.description = description;
+    }
+}
+exports.FileError = FileError;
+class FileUploadZero extends FileError {
+    constructor() {
+        super("Can't upload file when it zero bytes.", 'Provided file has zero bytes (0 B) file size.');
+    }
+}
+exports.FileUploadZero = FileUploadZero;
+class FileUploadBigger extends FileError {
+    constructor(limit, size) {
+        super(`File greater than ${limit} B.`, `The provided file has ${size} B file size, it greater than ${limit} B`);
+    }
+}
+exports.FileUploadBigger = FileUploadBigger;
+class FileIsNotReadable extends FileError {
+    constructor() {
+        super('FILE_IS_NOT_READABLE', 'The argument provided is not a Readable stream.');
+    }
+}
+exports.FileIsNotReadable = FileIsNotReadable;

package/lib/src/errors/RpcError.d.ts

@@ -0,0 +1,22 @@
+import { Raw, TLObject } from '../raw/index.js';
+export declare class RPCError extends Error {
+    id: string;
+    code: number;
+    message: string;
+    name: string;
+    value?: number | string | Raw.RpcError;
+    _isSigned?: boolean;
+    _isUnknown?: boolean;
+    _rpcName?: string;
+    constructor(value?: number | string | Raw.RpcError, rpcName?: string, isUnknown?: boolean, isSigned?: boolean);
+    protected _format(): void;
+    static raise(rpcError: Raw.RpcError, rpcType: TLObject): Promise<void>;
+    toJSON(): {
+        [key: string]: unknown;
+    };
+    toString(): string;
+}
+export declare class UnknownError extends RPCError {
+    code: number;
+    name: string;
+}

package/lib/src/errors/RpcError.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownError = exports.RPCError = void 0;
+const Logger_js_1 = require("../Logger.js");
+const All_js_1 = require("./exceptions/All.js");
+const platform_node_js_1 = require("../platform.node.js");
+const index_js_1 = require("./index.js");
+function getModule(name) {
+    const [namespace, mod] = name.split('.');
+    if (index_js_1.Exceptions[namespace] &&
+        index_js_1.Exceptions[namespace][mod]) {
+        return index_js_1.Exceptions[namespace][mod];
+    }
+    return UnknownError;
+}
+class RPCError extends Error {
+    id;
+    code;
+    message;
+    name;
+    value;
+    _isSigned;
+    _isUnknown;
+    _rpcName;
+    constructor(value, rpcName, isUnknown, isSigned) {
+        super();
+        Logger_js_1.Logger.debug(`[8] Creating new instance RPCError(${rpcName ?? this.name})`);
+        this._isSigned = isSigned;
+        this._isUnknown = isUnknown;
+        this._rpcName = rpcName;
+        if (!Number.isNaN(value)) {
+            this.value = Number(value);
+        }
+        else {
+            this.value = value;
+        }
+        if (isUnknown) {
+            Logger_js_1.Logger.debug(`[9] UnknownError : ${this.name}`);
+        }
+    }
+    _format() {
+        this.message = `Telegram Says: [${this._isSigned ? '-' : ''}${this.code} ${this.id || this.name}] - ${(this.message || '').replace(/\{value\}/g, String(this.value))} ${this._rpcName ? `(caused by ${this._rpcName})` : ''}`;
+    }
+    static async raise(rpcError, rpcType) {
+        let code = rpcError.errorCode;
+        const message = rpcError.errorMessage;
+        const isSigned = code < 0;
+        const name = rpcType.className;
+        if (isSigned)
+            code = -code;
+        if (!(code in All_js_1.Exceptions)) {
+            throw new UnknownError(`[${code} ${message}]`, name, true, isSigned);
+        }
+        let id = message.replace(/\_\d+/gm, '_X');
+        const regexMatch = message.match(/\_(\d+)/gm);
+        let value = '';
+        if (regexMatch) {
+            value = regexMatch[0].replace(/\_/g, '');
+        }
+        if (!(id in All_js_1.Exceptions[code])) {
+            id = id.split('_').splice(-1, 1, '*').join('_');
+            if (!(id in All_js_1.Exceptions[code])) {
+                const modules = getModule(All_js_1.Exceptions[code]['_']);
+                const _module = new modules(value, name, true, isSigned);
+                _module.message = `[${code} ${message}]`;
+                _module.id = message.replace(/\_\d+/gm, '_X');
+                _module._format();
+                throw _module;
+            }
+        }
+        const modules = await getModule(All_js_1.Exceptions[code][id]);
+        const _module = new modules(value, name, false, isSigned);
+        _module._format();
+        throw _module;
+    }
+    [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;
+                }
+            }
+        }
+        Object.setPrototypeOf(toPrint, {
+            stack: this.stack,
+        });
+        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,
+            stack: this.stack,
+        };
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                const value = this[key];
+                if (!key.startsWith('_')) {
+                    toPrint[key] = typeof value === 'bigint' ? String(value) : value;
+                }
+            }
+        }
+        return toPrint;
+    }
+    toString() {
+        return `[constructor of ${this.constructor.name}] ${JSON.stringify(this, null, 2)}`;
+    }
+}
+exports.RPCError = RPCError;
+class UnknownError extends RPCError {
+    code = 520;
+    name = 'Unknown Error';
+}
+exports.UnknownError = UnknownError;

package/lib/src/errors/SecretChat.d.ts

@@ -0,0 +1,13 @@
+import { BaseError } from './Base.js';
+export declare class SecretChatError extends BaseError {
+    constructor(message: string, description?: string);
+}
+export declare class FingerprintMismatch extends SecretChatError {
+    constructor();
+}
+export declare class ChatNotFound extends SecretChatError {
+    constructor(chatId: number);
+}
+export declare class AlreadyAccepted extends SecretChatError {
+    constructor();
+}

package/lib/src/errors/SecretChat.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlreadyAccepted = exports.ChatNotFound = exports.FingerprintMismatch = exports.SecretChatError = void 0;
+const Base_js_1 = require("./Base.js");
+class SecretChatError extends Base_js_1.BaseError {
+    constructor(message, description) {
+        super();
+        this.message = message;
+        this.description = description;
+    }
+}
+exports.SecretChatError = SecretChatError;
+class FingerprintMismatch extends SecretChatError {
+    constructor() {
+        super('Fingerprint key mismatch', 'Given fingerprint key from message is mismatch. So the message is not secure and the secret chat should be closed.');
+    }
+}
+exports.FingerprintMismatch = FingerprintMismatch;
+class ChatNotFound extends SecretChatError {
+    constructor(chatId) {
+        super('Secret chat not found', `Provided chatId (${chatId}) is not found in session. Make sure the chatId is correct and already saved in session.`);
+    }
+}
+exports.ChatNotFound = ChatNotFound;
+class AlreadyAccepted extends SecretChatError {
+    constructor() {
+        super('Secret chat already accepted');
+    }
+}
+exports.AlreadyAccepted = AlreadyAccepted;

package/lib/src/errors/WebSocket.d.ts

@@ -0,0 +1,13 @@
+import { BaseError } from './Base.js';
+export declare class WebSocketError extends BaseError {
+    constructor(message: string, description?: string);
+}
+export declare class Disconnected extends WebSocketError {
+    constructor();
+}
+export declare class ReadClosed extends WebSocketError {
+    constructor();
+}
+export declare class ProxyUnsupported extends WebSocketError {
+    constructor();
+}

package/lib/src/errors/WebSocket.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyUnsupported = exports.ReadClosed = exports.Disconnected = exports.WebSocketError = void 0;
+const Base_js_1 = require("./Base.js");
+class WebSocketError extends Base_js_1.BaseError {
+    constructor(message, description) {
+        super();
+        this.message = message;
+        this.description = description;
+    }
+}
+exports.WebSocketError = WebSocketError;
+class Disconnected extends WebSocketError {
+    constructor() {
+        super('WebSocket Disconnected', "This happen when you trying to send request or receive update from websocket server hut the websocket client is doesn't ready. Make sure the websocket client is connected to server.");
+    }
+}
+exports.Disconnected = Disconnected;
+class ReadClosed extends WebSocketError {
+    constructor() {
+        super('WebSocket connection closed when reading data', 'This happen when suddenly the connection between the websocket client and the server is lost when fetching data updates from the server.');
+    }
+}
+exports.ReadClosed = ReadClosed;
+class ProxyUnsupported extends WebSocketError {
+    constructor() {
+        super('WebSocket proxy unsupported', 'This is because browser telegram or websocket proxy are not supported by the framework at this time.');
+    }
+}
+exports.ProxyUnsupported = ProxyUnsupported;