const crypto = require('crypto'); const fs = require("fs").promises; class Helpers { /** * Generates a random long integer (8 bytes), which is optionally signed * @returns {BigInt} */ static generateRandomLong(signed) { let buf = Buffer.from(Helpers.generateRandomBytes(8)); // 0x12345678 = 305419896 if (signed) return buf.readBigInt64LE(0); else return buf.readBigUInt64LE(0); } /** * Generates a random bytes array * @param count * @returns {Buffer} */ static generateRandomBytes(count) { return crypto.randomBytes(count); } /** * Loads the user settings located under `api/` * @param path * @returns {Promise} */ static async loadSettings(path = "api/settings") { let settings = {}; let left, right, value_pair; let data = await fs.readFile(path, 'utf-8'); for (let line of data.toString().split('\n')) { value_pair = line.split("="); if (value_pair.length !== 2) { break; } left = value_pair[0].replace(/ \r?\n|\r/g, ''); right = value_pair[1].replace(/ \r?\n|\r/g, ''); if (!isNaN(right)) { settings[left] = Number.parseInt(right); } else { settings[left] = right; } } return settings; } /** * Calculate the key based on Telegram guidelines, specifying whether it's the client or not * @param shared_key * @param msg_key * @param client * @returns {{iv: Buffer, key: Buffer}} */ static calcKey(shared_key, msg_key, client) { let x = client === true ? 0 : 8; let iv, key, sha1a, sha1b, sha1c, sha1d; sha1a = Helpers.sha1(Buffer.concat([ msg_key, shared_key.slice(x, (x + 32)) ])); sha1b = Helpers.sha1(Buffer.concat([ shared_key.slice(x + 32, x + 48), msg_key, shared_key.slice(x + 48, x + 64) ])); sha1c = Helpers.sha1(Buffer.concat([ shared_key.slice(x + 64, x + 96), msg_key ])); sha1d = Helpers.sha1(Buffer.concat([ msg_key, shared_key.slice((x + 96), (x + 128)) ])); key = Buffer.concat([ sha1a.slice(0, 8), sha1b.slice(8, 20), sha1c.slice(4, 16)]); iv = Buffer.concat([ sha1a.slice(8, 20), sha1b.slice(0, 8), sha1c.slice(16, 20), sha1d.slice(0, 8)]); return {key, iv} } /** * Calculates the message key from the given data * @param data * @returns {Buffer} */ static calcMsgKey(data) { return Helpers.sha1(data).slice(4, 20); } /** * Generates the key data corresponding to the given nonces * @param serverNonce * @param newNonce * @returns {{ivBuffer: Buffer, keyBuffer: Buffer}} */ static generateKeyDataFromNonces(serverNonce, newNonce) { let hash1 = Helpers.sha1(Buffer.concat([newNonce, serverNonce])); let hash2 = Helpers.sha1(Buffer.concat([serverNonce, newNonce])); let hash3 = Helpers.sha1(Buffer.concat([newNonce, newNonce])); let keyBuffer = Buffer.concat([hash1, hash2.slice(0, 12)]); let ivBuffer = Buffer.concat([hash2.slice(12, 20), hash3, newNonce.slice(0, 4)]); return {keyBuffer: keyBuffer, ivBuffer: ivBuffer} } /** * Calculates the SHA1 digest for the given data * @param data * @returns {Buffer} */ static sha1(data) { let shaSum = crypto.createHash('sha1'); shaSum.update(data); return shaSum.digest(); } /** * Reads a Telegram-encoded string * @param buffer {Buffer} * @param offset {number} * @returns {{string: string, offset: number}} */ static tgReadString(buffer, offset) { let res = Helpers.tgReadByte(buffer, offset); offset = res.offset; let string = res.data.toString("utf8"); return {string, offset} } /** * * @param reader {Buffer} * @param offset {number} */ static tgReadObject(reader, offset) { let constructorId = reader.readUInt32LE(offset); offset += 4; let clazz = tlobjects[constructorId]; if (clazz === undefined) { /** * The class was None, but there's still a * chance of it being a manually parsed value like bool! */ if (constructorId === 0x997275b5) { return true } else if (constructorId === 0xbc799737) { return false } throw Error("type not found "+ constructorId); } return undefined; } /** * * @param buffer {Buffer} * @param offset {Number} * @returns {{data: Buffer, offset: Number}} */ static tgReadByte(buffer, offset) { let firstByte = buffer[offset]; offset += 1; let padding, length; if (firstByte === 254) { length = buffer.readInt8(offset) | (buffer.readInt8(offset + 1) << 8) | (buffer.readInt8(offset + 2) << 16); offset += 3; padding = length % 4; } else { length = firstByte; padding = (length + 1) % 4; } let data = buffer.slice(offset, offset + length); offset += length; if (padding > 0) { padding = 4 - padding; offset += padding; } return {data: data, offset: offset} } static tgWriteString(string) { return Helpers.tgWriteBytes(Buffer.from(string, "utf8")); } static tgWriteBytes(data) { let buffer; let padding; if (data.length < 254) { padding = (data.length + 1) % 4; if (padding !== 0) { padding = 4 - padding; } buffer = Buffer.concat([Buffer.from([data.length]), data]); } else { padding = data.length % 4; if (padding !== 0) { padding = 4 - padding; } buffer = Buffer.concat([ Buffer.from([254]), Buffer.from([data.length % 256]), Buffer.from([(data.length >> 8) % 256]), Buffer.from([(data.length >> 16) % 256]), data, ]); } return Buffer.concat([buffer, Buffer.alloc(padding).fill(0)]); } /** * Fast mod pow for RSA calculation. a^b % n * @param a * @param b * @param n * @returns {bigint} */ static modExp(a, b, n) { a = a % n; let result = 1n; let x = a; while (b > 0) { let leastSignificantBit = b % 2n; b = b / 2n; if (leastSignificantBit === 1n) { result = result * x; result = result % n; } x = x * x; x = x % n; } return result; }; /** * returns a random int from min (inclusive) and max (inclusive) * @param min * @param max * @returns {number} */ static getRandomInt(min, max) { min = Math.ceil(min); max = Math.floor(max); return Math.floor(Math.random() * (max - min + 1)) + min; } /** * Sleeps a specified amount of time * @param ms time in milliseconds * @returns {Promise} */ static sleep = ms => new Promise(resolve => setTimeout(resolve, ms)); } module.exports = Helpers;