@melandlabs/integrations-telegram 0.1.0

package/dist/tdata-converter.js

@@ -0,0 +1,640 @@
+import { Buffer } from 'buffer';
+import * as crypto from 'crypto';
+import * as fs2 from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { AuthKey } from 'telegram/crypto/AuthKey';
+import { StringSession } from 'telegram/sessions';
+
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+function xorBuffer(a, b) {
+  for (let i = 0; i < a.length; i++) {
+    a.writeUInt8(a.readUInt8(i) ^ b.readUInt8(i), i);
+  }
+}
+function igeCrypt(buffer, aesKey, aesIv, isEncrypt) {
+  const cipher = crypto.createDecipheriv("aes-256-ecb", aesKey, null);
+  cipher.setAutoPadding(false);
+  const result = Buffer.allocUnsafe(buffer.length);
+  let prevCipherblock;
+  let prevPlainblock;
+  {
+    prevCipherblock = aesIv.subarray(16, 32);
+    prevPlainblock = aesIv.subarray(0, 16);
+  }
+  const current = Buffer.allocUnsafe(16);
+  for (let offset = 0; offset < buffer.length; offset += 16) {
+    const chunk = buffer.subarray(offset, offset + 16);
+    chunk.copy(current);
+    xorBuffer(current, prevCipherblock);
+    const crypted = Buffer.from(cipher.update(current));
+    xorBuffer(crypted, prevPlainblock);
+    crypted.copy(result, offset);
+    prevCipherblock = crypted;
+    prevPlainblock = chunk;
+  }
+  cipher.final();
+  return result;
+}
+function createLocalKey(passcode, salt) {
+  const iterations = passcode.length > 0 ? kStrongIterationsCount : 1;
+  const password = crypto.createHash("sha512");
+  password.update(salt);
+  password.update(passcode);
+  password.update(salt);
+  return crypto.pbkdf2Sync(password.digest(), salt, iterations, 256, "sha512");
+}
+function decryptLocal(encryptedMsg, localKey) {
+  const msgKey = encryptedMsg.subarray(0, 16);
+  const encryptedData = encryptedMsg.subarray(16);
+  const decrypted = aesDecryptLocal(encryptedData, msgKey, localKey);
+  const sha1 = crypto.createHash("sha1");
+  sha1.update(decrypted);
+  const calculatedMsgKey = sha1.digest().subarray(0, 16);
+  if (calculatedMsgKey.compare(msgKey) !== 0) {
+    throw new CryptoException("bad decrypt key, data not decrypted - incorrect password");
+  }
+  const length = decrypted.readUInt32LE(0);
+  if (length > decrypted.length) {
+    throw new CryptoException(`corrupted data. wrong length: ${length}`);
+  }
+  return decrypted.subarray(4, 4 + length);
+}
+function aesDecryptLocal(encryptedData, msgKey, localKey) {
+  const { aesKey, aesIv } = prepareAesOldMtp(localKey, msgKey, false);
+  return igeCrypt(encryptedData, aesKey, aesIv);
+}
+function prepareAesOldMtp(localKey, msgKey, send = false) {
+  const x = send ? 0 : 8;
+  const keyPos = (pos, size) => {
+    return localKey.subarray(pos, pos + size);
+  };
+  const dataA = Buffer.concat([msgKey, keyPos(x, 32)]);
+  const dataB = Buffer.concat([keyPos(x + 32, 16), msgKey, keyPos(x + 48, 16)]);
+  const dataC = Buffer.concat([keyPos(x + 64, 32), msgKey]);
+  const dataD = Buffer.concat([msgKey, keyPos(x + 96, 32)]);
+  const sha1A = crypto.createHash("sha1").update(dataA).digest();
+  const sha1B = crypto.createHash("sha1").update(dataB).digest();
+  const sha1C = crypto.createHash("sha1").update(dataC).digest();
+  const sha1D = crypto.createHash("sha1").update(dataD).digest();
+  const aesKey = Buffer.concat([sha1A.subarray(0, 8), sha1B.subarray(8, 20), sha1C.subarray(4, 16)]);
+  const aesIv = Buffer.concat([
+    sha1A.subarray(8, 20),
+    sha1B.subarray(0, 8),
+    sha1C.subarray(16, 20),
+    sha1D.subarray(0, 8)
+  ]);
+  return { aesKey, aesIv };
+}
+var kStrongIterationsCount, CryptoException;
+var init_crypto = __esm({
+  "src/tdata-decrypter/crypto.ts"() {
+    kStrongIterationsCount = 1e5;
+    CryptoException = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "CryptoException";
+      }
+    };
+  }
+});
+function readBytes(buffer, offset, size) {
+  if (offset + size > buffer.length) {
+    throw new Error(`Cannot read ${size} bytes at offset ${offset}, buffer length is ${buffer.length}`);
+  }
+  return buffer.subarray(offset, offset + size);
+}
+function readQtInteger(buffer, offset, size, signed) {
+  const value = readBytes(buffer, offset, size);
+  const hex = value.toString("hex");
+  let num = BigInt(`0x${hex}`);
+  if (signed && num >= BigInt(2) ** BigInt(size * 8 - 1)) {
+    num -= BigInt(2) ** BigInt(size * 8);
+  }
+  return Number(num);
+}
+function readQtInt32(buffer, offset) {
+  return readQtInteger(buffer, offset, 4, true);
+}
+function readQtUint64(buffer, offset) {
+  return readQtInteger(buffer, offset, 8, false);
+}
+function readQtByteArray(buffer, offset) {
+  const length = readQtInt32(buffer, offset);
+  let newOffset = offset + 4;
+  if (length <= 0) {
+    return { value: Buffer.alloc(0), newOffset };
+  }
+  const value = readBytes(buffer, newOffset, length);
+  newOffset += length;
+  return { value, newOffset };
+}
+function readQtUtf8(buffer, offset) {
+  const { value, newOffset } = readQtByteArray(buffer, offset);
+  const str = value.toString("utf16le");
+  return { value: str, newOffset };
+}
+var init_qt = __esm({
+  "src/tdata-decrypter/qt.ts"() {
+  }
+});
+
+// src/tdata-decrypter/settings.ts
+function readSettingsBlock(version, buffer, offset, blockId) {
+  switch (blockId) {
+    case 6 /* dbiAutoStart */:
+    case 7 /* dbiStartMinimized */:
+    case 29 /* dbiSendToMenu */:
+    case 10 /* dbiSeenTrayTooltip */:
+    case 12 /* dbiAutoUpdate */: {
+      const value = readQtInt32(buffer, offset) === 1;
+      return { value, newOffset: offset + 4 };
+    }
+    case 41 /* dbiSongVolumeOld */: {
+      const value = readQtInt32(buffer, offset) / 1e6;
+      return { value, newOffset: offset + 4 };
+    }
+    case 13 /* dbiLastUpdateCheck */:
+    case 88 /* dbiScalePercent */:
+    case 87 /* dbiPowerSaving */: {
+      const value = readQtInt32(buffer, offset);
+      return { value, newOffset: offset + 4 };
+    }
+    case 96 /* dbiFallbackProductionConfig */:
+    case 94 /* dbiApplicationSettings */: {
+      const { value, newOffset } = readQtByteArray(buffer, offset);
+      return { value, newOffset };
+    }
+    case 35 /* dbiDialogLastPath */: {
+      const { value, newOffset } = readQtUtf8(buffer, offset);
+      return { value, newOffset };
+    }
+    case 84 /* dbiThemeKey */: {
+      const day = readQtUint64(buffer, offset);
+      const night = readQtUint64(buffer, offset + 8);
+      const nightMode = readQtInt32(buffer, offset + 16) === 1;
+      return {
+        value: { day, night, nightMode },
+        newOffset: offset + 20
+      };
+    }
+    case 97 /* dbiBackgroundKey */: {
+      const day = readQtUint64(buffer, offset);
+      const night = readQtUint64(buffer, offset + 8);
+      return {
+        value: { day, night },
+        newOffset: offset + 16
+      };
+    }
+    case 85 /* dbiTileBackground */: {
+      const day = readQtInt32(buffer, offset);
+      const night = readQtInt32(buffer, offset + 4);
+      return {
+        value: { day, night },
+        newOffset: offset + 8
+      };
+    }
+    case 78 /* dbiLangPackKey */: {
+      const value = readQtUint64(buffer, offset);
+      return { value, newOffset: offset + 8 };
+    }
+    case 75 /* dbiMtpAuthorization */: {
+      const { value, newOffset } = readQtByteArray(buffer, offset);
+      return { value, newOffset };
+    }
+    default:
+      throw new Error(`Unknown block ID while reading settings: ${blockId}`);
+  }
+}
+function readSettingsBlocks(version, buffer) {
+  const blocks = /* @__PURE__ */ new Map();
+  let offset = 0;
+  try {
+    while (offset < buffer.length) {
+      const blockId = readQtInt32(buffer, offset);
+      offset += 4;
+      const { value, newOffset } = readSettingsBlock(version, buffer, offset, blockId);
+      offset = newOffset;
+      blocks.set(blockId, value);
+    }
+  } catch {
+  }
+  return blocks;
+}
+var init_settings = __esm({
+  "src/tdata-decrypter/settings.ts"() {
+    init_qt();
+  }
+});
+function decryptKeyDataTdf(passcode, keyDataTdf) {
+  const stream = keyDataTdf.encryptedData;
+  let offset = 0;
+  const { value: salt, newOffset: offset1 } = readQtByteArray(stream, offset);
+  offset = offset1;
+  const { value: keyEncrypted, newOffset: offset2 } = readQtByteArray(stream, offset);
+  offset = offset2;
+  const { value: infoEncrypted, newOffset: _ } = readQtByteArray(stream, offset);
+  const passcodeKey = createLocalKey(passcode, salt);
+  const localKey = decryptLocal(keyEncrypted, passcodeKey);
+  const infoDecrypted = decryptLocal(infoEncrypted, localKey);
+  return [localKey, infoDecrypted];
+}
+function readKeyDataAccounts(data) {
+  let offset = 0;
+  const count = data.readInt32BE(offset);
+  offset += 4;
+  const indexes = [];
+  for (let i = 0; i < count; i++) {
+    const index = data.readInt32BE(offset);
+    offset += 4;
+    indexes.push(index);
+  }
+  const mainAccount = data.readInt32BE(offset);
+  return [indexes, mainAccount];
+}
+var init_storage = __esm({
+  "src/tdata-decrypter/storage.ts"() {
+    init_crypto();
+    init_qt();
+  }
+});
+function parseRawTdf(data) {
+  if (data.subarray(0, 4).compare(TDF_MAGIC) !== 0) {
+    throw new WrongMagicTdfParserError();
+  }
+  const version = data.readUInt32LE(4);
+  const encryptedData = data.subarray(8, data.length - 16);
+  const hashsum = data.subarray(data.length - 16);
+  const actualMd5 = crypto.createHash("md5");
+  actualMd5.update(encryptedData);
+  const lengthBuffer = Buffer.allocUnsafe(4);
+  lengthBuffer.writeUInt32LE(encryptedData.length, 0);
+  actualMd5.update(lengthBuffer);
+  const versionBuffer = Buffer.allocUnsafe(4);
+  versionBuffer.writeUInt32LE(version, 0);
+  actualMd5.update(versionBuffer);
+  actualMd5.update(TDF_MAGIC);
+  const actualMd5Digest = actualMd5.digest();
+  if (actualMd5Digest.compare(hashsum) !== 0) {
+    throw new WrongHashsumTdfParserError();
+  }
+  return {
+    version,
+    encryptedData,
+    hashsum
+  };
+}
+function readTdfFile(filepath) {
+  const candidates = [`${filepath}s`, filepath];
+  for (const candidate of candidates) {
+    try {
+      const data = fs2.readFileSync(candidate);
+      return parseRawTdf(data);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  throw new Error(`TDF file not found: ${filepath}`);
+}
+var TDF_MAGIC, TdfParserError, WrongMagicTdfParserError, WrongHashsumTdfParserError;
+var init_tdf = __esm({
+  "src/tdata-decrypter/tdf.ts"() {
+    TDF_MAGIC = Buffer.from("TDF$", "ascii");
+    TdfParserError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "TdfParserError";
+      }
+    };
+    WrongMagicTdfParserError = class extends TdfParserError {
+      constructor(message = "Wrong magic. Not a TDF file?") {
+        super(message);
+        this.name = "WrongMagicTdfParserError";
+      }
+    };
+    WrongHashsumTdfParserError = class extends TdfParserError {
+      constructor(message = "Wrong hashsum. Corrupted file?") {
+        super(message);
+        this.name = "WrongHashsumTdfParserError";
+      }
+    };
+  }
+});
+function fileKeyToStr(fileKey) {
+  let result = "";
+  for (const b of fileKey) {
+    const hex = b.toString(16).toUpperCase();
+    const padded = hex.length === 1 ? `0${hex}` : hex;
+    result += padded[1] + padded[0];
+  }
+  return result;
+}
+function computeDataNameKey(dataName) {
+  const fileKey = crypto.createHash("md5").update(dataName, "utf8").digest().subarray(0, 8);
+  return fileKeyToStr(fileKey);
+}
+function composeAccountName(dataName, index) {
+  if (index > 0) {
+    return `${dataName}#${index + 1}`;
+  }
+  return dataName;
+}
+function readMtpAuthorization(buffer) {
+  let offset = 0;
+  const legacyUserId = readQtInt32(buffer, offset);
+  const legacyMainDcId = readQtInt32(buffer, offset + 4);
+  offset += 8;
+  let userId;
+  let mainDcId;
+  if (legacyUserId === -1 && legacyMainDcId === -1) {
+    userId = Number(readQtUint64(buffer, offset));
+    offset += 8;
+    mainDcId = readQtInt32(buffer, offset);
+    offset += 4;
+  } else {
+    userId = legacyUserId;
+    mainDcId = legacyMainDcId;
+  }
+  const count = readQtInt32(buffer, offset);
+  offset += 4;
+  const keys = /* @__PURE__ */ new Map();
+  for (let i = 0; i < count; i++) {
+    const dcId = readQtInt32(buffer, offset);
+    offset += 4;
+    const key = Buffer.from(buffer.subarray(offset, offset + 256));
+    offset += 256;
+    keys.set(dcId, key);
+  }
+  const destroyCount = readQtInt32(buffer, offset);
+  offset += 4;
+  const keysToDestroy = /* @__PURE__ */ new Map();
+  for (let i = 0; i < destroyCount; i++) {
+    const dcId = readQtInt32(buffer, offset);
+    offset += 4;
+    const key = Buffer.from(buffer.subarray(offset, offset + 256));
+    offset += 256;
+    keysToDestroy.set(dcId, key);
+  }
+  return {
+    userId,
+    currentDcId: mainDcId,
+    keys,
+    keysToDestroy
+  };
+}
+var AccountReader, TdataReader;
+var init_decrypter = __esm({
+  "src/tdata-decrypter/decrypter.ts"() {
+    init_crypto();
+    init_qt();
+    init_settings();
+    init_storage();
+    init_tdf();
+    AccountReader = class {
+      basePath;
+      index;
+      accountName;
+      dataNameKey;
+      constructor(basePath, index, dataName) {
+        this.basePath = basePath;
+        this.index = index;
+        this.accountName = composeAccountName(dataName, index);
+        this.dataNameKey = computeDataNameKey(this.accountName);
+      }
+      /**
+       * Read account data using local key
+       */
+      read(localKey) {
+        const mtpData = this.readMtpData(localKey);
+        return {
+          index: this.index,
+          mtpData
+        };
+      }
+      /**
+       * Read MTP data
+       */
+      readMtpData(localKey) {
+        const mtpDataFilePath = path.join(this.basePath, this.dataNameKey);
+        const tdfFile = readTdfFile(mtpDataFilePath);
+        const offset = 0;
+        const { value: encryptedData, newOffset: _ } = readQtByteArray(
+          Buffer.from(tdfFile.encryptedData),
+          offset
+        );
+        const decrypted = decryptLocal(encryptedData, localKey);
+        const blocks = readSettingsBlocks(tdfFile.version, decrypted);
+        const mtpAuth = blocks.get(75);
+        if (!mtpAuth || !(mtpAuth instanceof Buffer)) {
+          throw new Error("MTP authorization not found");
+        }
+        return readMtpAuthorization(mtpAuth);
+      }
+    };
+    TdataReader = class _TdataReader {
+      basePath;
+      dataName;
+      static DEFAULT_DATANAME = "data";
+      constructor(basePath, dataName) {
+        this.basePath = basePath;
+        this.dataName = dataName ?? _TdataReader.DEFAULT_DATANAME;
+      }
+      /**
+       * Read tdata directory
+       */
+      read(passcode) {
+        const settings = this.readSettings();
+        const [localKey, accountIndexes] = this.readKeyData(passcode ?? "");
+        const accounts = /* @__PURE__ */ new Map();
+        for (const accountIndex of accountIndexes) {
+          const reader = new AccountReader(this.basePath, accountIndex, this.dataName);
+          const account = reader.read(localKey);
+          accounts.set(accountIndex, account);
+        }
+        return { settings, accounts };
+      }
+      /**
+       * Read key data
+       */
+      readKeyData(passcode) {
+        const keyDataName = `key_${this.dataName}`;
+        const keyDataPath = path.join(this.basePath, keyDataName);
+        const keyDataTdf = readTdfFile(keyDataPath);
+        const [localKey, infoDecrypted] = decryptKeyDataTdf(Buffer.from(passcode), keyDataTdf);
+        const [accountIndexes] = readKeyDataAccounts(infoDecrypted);
+        return [localKey, accountIndexes];
+      }
+      /**
+       * Read settings
+       */
+      readSettings() {
+        const settingsPath = path.join(this.basePath, "settings");
+        const settingsTdf = readTdfFile(settingsPath);
+        const decrypted = settingsTdf.encryptedData;
+        return readSettingsBlocks(settingsTdf.version, decrypted);
+      }
+    };
+  }
+});
+
+// src/tdata-decrypter/index.ts
+init_decrypter();
+init_tdf();
+init_crypto();
+init_qt();
+init_storage();
+init_settings();
+init_tdf();
+init_crypto();
+
+// src/tdata-converter.ts
+var __filename$1 = fileURLToPath(import.meta.url);
+path.dirname(__filename$1);
+function getServerAddress(dcId) {
+  const addresses = {
+    1: "149.154.175.53",
+    2: "149.154.167.51",
+    3: "149.154.175.100",
+    4: "149.154.167.92",
+    5: "149.154.171.5"
+  };
+  return addresses[dcId] || "149.154.175.53";
+}
+function extractAuthKey(tdataPath) {
+  console.log("[TdataConverter] Using pure JS implementation to extract auth key...");
+  try {
+    const reader = new TdataReader(tdataPath);
+    const result = reader.read();
+    if (!result.accounts || result.accounts.size === 0) {
+      throw new Error("No accounts found in tdata. Please make sure you're logged into Telegram Desktop.");
+    }
+    const firstAccount = result.accounts.values().next().value;
+    if (!firstAccount) {
+      throw new Error("No accounts found in tdata.");
+    }
+    const { mtpData } = firstAccount;
+    const authKeyBytes = mtpData.keys.get(mtpData.currentDcId);
+    if (!authKeyBytes) {
+      throw new Error(`No auth key found for DC ${mtpData.currentDcId}`);
+    }
+    console.log("[TdataConverter] Pure JS implementation extracted:", {
+      userId: mtpData.userId,
+      dcId: mtpData.currentDcId,
+      authKeyLength: authKeyBytes.length
+    });
+    return {
+      userId: mtpData.userId,
+      dcId: mtpData.currentDcId,
+      authKey: authKeyBytes
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new Error("Failed to extract auth key from tdata");
+  }
+}
+function normalizeTdataPath(inputPath) {
+  if (inputPath.endsWith("tdata")) {
+    return inputPath;
+  }
+  const tdataSubdir = path.join(inputPath, "tdata");
+  if (fs2.existsSync(tdataSubdir) && fs2.statSync(tdataSubdir).isDirectory()) {
+    return tdataSubdir;
+  }
+  return inputPath;
+}
+async function convertTdataToStringSession(tdataPath) {
+  const normalizedPath = normalizeTdataPath(tdataPath);
+  console.log("[TdataConverter] Starting conversion from:", tdataPath);
+  console.log("[TdataConverter] Normalized path:", normalizedPath);
+  if (!fs2.existsSync(normalizedPath)) {
+    throw new Error(`tdata directory not found: ${normalizedPath}`);
+  }
+  try {
+    const { userId, dcId, authKey } = extractAuthKey(normalizedPath);
+    console.log("[TdataConverter] Creating GramJS StringSession...");
+    const mainAuthKey = new AuthKey();
+    await mainAuthKey.setKey(authKey);
+    const session = new StringSession("");
+    session.setDC(dcId, getServerAddress(dcId), 443);
+    session.setAuthKey(mainAuthKey);
+    const sessionString = session.save();
+    console.log("[TdataConverter] Conversion successful!");
+    return sessionString;
+  } catch (error) {
+    console.error("[TdataConverter] Conversion error:", error);
+    if (error instanceof Error) {
+      const errorMessage = error.message;
+      if (errorMessage.includes("No accounts found") || errorMessage.includes("logged into Telegram Desktop")) {
+        throw new Error(
+          "No active session found in Telegram Desktop.\n\nPlease make sure:\n\u2022 You're logged into Telegram Desktop\n\u2022 You've logged in at least once before\n\u2022 You're using the official Telegram Desktop from desktop.telegram.org"
+        );
+      }
+      throw new Error(
+        `Failed to read Telegram Desktop session: ${errorMessage}
+
+Suggestions:
+1. Make sure Telegram Desktop is closed
+2. Verify you're using the official Telegram Desktop from desktop.telegram.org
+3. Try using the QR code or phone number login method instead`
+      );
+    }
+    throw new Error(
+      "Failed to read Telegram Desktop session: Unknown error\n\nPlease try:\n1. Closing Telegram Desktop completely\n2. Using the QR code or phone number login method instead"
+    );
+  }
+}
+function validateTdataDirectory(tdataPath) {
+  try {
+    if (!fs2.existsSync(tdataPath)) {
+      return { valid: false, error: "Directory does not exist" };
+    }
+    if (!fs2.statSync(tdataPath).isDirectory()) {
+      return { valid: false, error: "Path is not a directory" };
+    }
+    const normalizedPath = normalizeTdataPath(tdataPath);
+    const keyDataPath = path.join(normalizedPath, "key_datas");
+    if (!fs2.existsSync(keyDataPath)) {
+      return {
+        valid: false,
+        error: `key_datas file missing.
+
+Checked path: ${normalizedPath}
+
+This usually means:
+1. Telegram Desktop has never been logged in on this machine
+2. You're using the macOS App Store version (not supported)
+3. The tdata path is incorrect`
+      };
+    }
+    return { valid: true };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+function extractAccountInfo(tdataPath) {
+  try {
+    const normalizedPath = normalizeTdataPath(tdataPath);
+    const { userId, dcId } = extractAuthKey(normalizedPath);
+    return {
+      userId,
+      dcId
+    };
+  } catch (error) {
+    console.error("[TdataConverter] Failed to extract account info:", error);
+    return null;
+  }
+}
+
+export { convertTdataToStringSession, extractAccountInfo, validateTdataDirectory };
+//# sourceMappingURL=tdata-converter.js.map
+//# sourceMappingURL=tdata-converter.js.map