@melandlabs/integrations-telegram 0.1.0

package/dist/tdata-decrypter-index.js

@@ -0,0 +1,671 @@
+import { Buffer } from 'buffer';
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 createLegacyLocalKey(passcode, salt) {
+  const iterations = passcode.length > 0 ? LocalEncryptIterCount : LocalEncryptNoPwdIterCount;
+  return crypto.pbkdf2Sync(passcode, salt, iterations, 256, "sha1");
+}
+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 LocalEncryptNoPwdIterCount, LocalEncryptIterCount, kStrongIterationsCount, CryptoException;
+var init_crypto = __esm({
+  "src/tdata-decrypter/crypto.ts"() {
+    LocalEncryptNoPwdIterCount = 4;
+    LocalEncryptIterCount = 400;
+    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 readQtUint32(buffer, offset) {
+  return readQtInteger(buffer, offset, 4, false);
+}
+function readQtInt64(buffer, offset) {
+  return readQtInteger(buffer, offset, 8, 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 SettingsBlocks;
+var init_settings = __esm({
+  "src/tdata-decrypter/settings.ts"() {
+    init_qt();
+    SettingsBlocks = /* @__PURE__ */ ((SettingsBlocks2) => {
+      SettingsBlocks2[SettingsBlocks2["dbiKey"] = 0] = "dbiKey";
+      SettingsBlocks2[SettingsBlocks2["dbiUser"] = 1] = "dbiUser";
+      SettingsBlocks2[SettingsBlocks2["dbiDcOptionOldOld"] = 2] = "dbiDcOptionOldOld";
+      SettingsBlocks2[SettingsBlocks2["dbiChatSizeMaxOld"] = 3] = "dbiChatSizeMaxOld";
+      SettingsBlocks2[SettingsBlocks2["dbiMutePeerOld"] = 4] = "dbiMutePeerOld";
+      SettingsBlocks2[SettingsBlocks2["dbiSendKeyOld"] = 5] = "dbiSendKeyOld";
+      SettingsBlocks2[SettingsBlocks2["dbiAutoStart"] = 6] = "dbiAutoStart";
+      SettingsBlocks2[SettingsBlocks2["dbiStartMinimized"] = 7] = "dbiStartMinimized";
+      SettingsBlocks2[SettingsBlocks2["dbiSoundFlashBounceNotifyOld"] = 8] = "dbiSoundFlashBounceNotifyOld";
+      SettingsBlocks2[SettingsBlocks2["dbiWorkModeOld"] = 9] = "dbiWorkModeOld";
+      SettingsBlocks2[SettingsBlocks2["dbiSeenTrayTooltip"] = 10] = "dbiSeenTrayTooltip";
+      SettingsBlocks2[SettingsBlocks2["dbiDesktopNotifyOld"] = 11] = "dbiDesktopNotifyOld";
+      SettingsBlocks2[SettingsBlocks2["dbiAutoUpdate"] = 12] = "dbiAutoUpdate";
+      SettingsBlocks2[SettingsBlocks2["dbiLastUpdateCheck"] = 13] = "dbiLastUpdateCheck";
+      SettingsBlocks2[SettingsBlocks2["dbiWindowPositionOld"] = 14] = "dbiWindowPositionOld";
+      SettingsBlocks2[SettingsBlocks2["dbiConnectionTypeOldOld"] = 15] = "dbiConnectionTypeOldOld";
+      SettingsBlocks2[SettingsBlocks2["dbiDefaultAttach"] = 17] = "dbiDefaultAttach";
+      SettingsBlocks2[SettingsBlocks2["dbiCatsAndDogsOld"] = 18] = "dbiCatsAndDogsOld";
+      SettingsBlocks2[SettingsBlocks2["dbiReplaceEmojiOld"] = 19] = "dbiReplaceEmojiOld";
+      SettingsBlocks2[SettingsBlocks2["dbiAskDownloadPathOld"] = 20] = "dbiAskDownloadPathOld";
+      SettingsBlocks2[SettingsBlocks2["dbiDownloadPathOldOld"] = 21] = "dbiDownloadPathOldOld";
+      SettingsBlocks2[SettingsBlocks2["dbiScaleOld"] = 22] = "dbiScaleOld";
+      SettingsBlocks2[SettingsBlocks2["dbiEmojiTabOld"] = 23] = "dbiEmojiTabOld";
+      SettingsBlocks2[SettingsBlocks2["dbiRecentEmojiOldOldOld"] = 24] = "dbiRecentEmojiOldOldOld";
+      SettingsBlocks2[SettingsBlocks2["dbiLoggedPhoneNumberOld"] = 25] = "dbiLoggedPhoneNumberOld";
+      SettingsBlocks2[SettingsBlocks2["dbiMutedPeersOld"] = 26] = "dbiMutedPeersOld";
+      SettingsBlocks2[SettingsBlocks2["dbiNotifyViewOld"] = 28] = "dbiNotifyViewOld";
+      SettingsBlocks2[SettingsBlocks2["dbiSendToMenu"] = 29] = "dbiSendToMenu";
+      SettingsBlocks2[SettingsBlocks2["dbiCompressPastedImageOld"] = 30] = "dbiCompressPastedImageOld";
+      SettingsBlocks2[SettingsBlocks2["dbiLangOld"] = 31] = "dbiLangOld";
+      SettingsBlocks2[SettingsBlocks2["dbiLangFileOld"] = 32] = "dbiLangFileOld";
+      SettingsBlocks2[SettingsBlocks2["dbiTileBackgroundOld"] = 33] = "dbiTileBackgroundOld";
+      SettingsBlocks2[SettingsBlocks2["dbiAutoLockOld"] = 34] = "dbiAutoLockOld";
+      SettingsBlocks2[SettingsBlocks2["dbiDialogLastPath"] = 35] = "dbiDialogLastPath";
+      SettingsBlocks2[SettingsBlocks2["dbiRecentEmojiOldOld"] = 36] = "dbiRecentEmojiOldOld";
+      SettingsBlocks2[SettingsBlocks2["dbiEmojiVariantsOldOld"] = 37] = "dbiEmojiVariantsOldOld";
+      SettingsBlocks2[SettingsBlocks2["dbiRecentStickers"] = 38] = "dbiRecentStickers";
+      SettingsBlocks2[SettingsBlocks2["dbiDcOptionOld"] = 39] = "dbiDcOptionOld";
+      SettingsBlocks2[SettingsBlocks2["dbiTryIPv6Old"] = 40] = "dbiTryIPv6Old";
+      SettingsBlocks2[SettingsBlocks2["dbiSongVolumeOld"] = 41] = "dbiSongVolumeOld";
+      SettingsBlocks2[SettingsBlocks2["dbiWindowsNotificationsOld"] = 48] = "dbiWindowsNotificationsOld";
+      SettingsBlocks2[SettingsBlocks2["dbiIncludeMutedOld"] = 49] = "dbiIncludeMutedOld";
+      SettingsBlocks2[SettingsBlocks2["dbiMegagroupSizeMaxOld"] = 50] = "dbiMegagroupSizeMaxOld";
+      SettingsBlocks2[SettingsBlocks2["dbiDownloadPathOld"] = 51] = "dbiDownloadPathOld";
+      SettingsBlocks2[SettingsBlocks2["dbiAutoDownloadOld"] = 52] = "dbiAutoDownloadOld";
+      SettingsBlocks2[SettingsBlocks2["dbiSavedGifsLimitOld"] = 53] = "dbiSavedGifsLimitOld";
+      SettingsBlocks2[SettingsBlocks2["dbiShowingSavedGifsOld"] = 54] = "dbiShowingSavedGifsOld";
+      SettingsBlocks2[SettingsBlocks2["dbiAutoPlayOld"] = 55] = "dbiAutoPlayOld";
+      SettingsBlocks2[SettingsBlocks2["dbiAdaptiveForWideOld"] = 56] = "dbiAdaptiveForWideOld";
+      SettingsBlocks2[SettingsBlocks2["dbiHiddenPinnedMessagesOld"] = 57] = "dbiHiddenPinnedMessagesOld";
+      SettingsBlocks2[SettingsBlocks2["dbiRecentEmojiOld"] = 58] = "dbiRecentEmojiOld";
+      SettingsBlocks2[SettingsBlocks2["dbiEmojiVariantsOld"] = 59] = "dbiEmojiVariantsOld";
+      SettingsBlocks2[SettingsBlocks2["dbiDialogsModeOld"] = 64] = "dbiDialogsModeOld";
+      SettingsBlocks2[SettingsBlocks2["dbiModerateModeOld"] = 65] = "dbiModerateModeOld";
+      SettingsBlocks2[SettingsBlocks2["dbiVideoVolumeOld"] = 66] = "dbiVideoVolumeOld";
+      SettingsBlocks2[SettingsBlocks2["dbiStickersRecentLimitOld"] = 67] = "dbiStickersRecentLimitOld";
+      SettingsBlocks2[SettingsBlocks2["dbiNativeNotificationsOld"] = 68] = "dbiNativeNotificationsOld";
+      SettingsBlocks2[SettingsBlocks2["dbiNotificationsCountOld"] = 69] = "dbiNotificationsCountOld";
+      SettingsBlocks2[SettingsBlocks2["dbiNotificationsCornerOld"] = 70] = "dbiNotificationsCornerOld";
+      SettingsBlocks2[SettingsBlocks2["dbiThemeKeyOld"] = 71] = "dbiThemeKeyOld";
+      SettingsBlocks2[SettingsBlocks2["dbiDialogsWidthRatioOld"] = 72] = "dbiDialogsWidthRatioOld";
+      SettingsBlocks2[SettingsBlocks2["dbiUseExternalVideoPlayerOld"] = 73] = "dbiUseExternalVideoPlayerOld";
+      SettingsBlocks2[SettingsBlocks2["dbiDcOptionsOld"] = 74] = "dbiDcOptionsOld";
+      SettingsBlocks2[SettingsBlocks2["dbiMtpAuthorization"] = 75] = "dbiMtpAuthorization";
+      SettingsBlocks2[SettingsBlocks2["dbiLastSeenWarningSeenOld"] = 76] = "dbiLastSeenWarningSeenOld";
+      SettingsBlocks2[SettingsBlocks2["dbiSessionSettings"] = 77] = "dbiSessionSettings";
+      SettingsBlocks2[SettingsBlocks2["dbiLangPackKey"] = 78] = "dbiLangPackKey";
+      SettingsBlocks2[SettingsBlocks2["dbiConnectionTypeOld"] = 79] = "dbiConnectionTypeOld";
+      SettingsBlocks2[SettingsBlocks2["dbiStickersFavedLimitOld"] = 80] = "dbiStickersFavedLimitOld";
+      SettingsBlocks2[SettingsBlocks2["dbiSuggestStickersByEmojiOld"] = 81] = "dbiSuggestStickersByEmojiOld";
+      SettingsBlocks2[SettingsBlocks2["dbiSuggestEmojiOld"] = 82] = "dbiSuggestEmojiOld";
+      SettingsBlocks2[SettingsBlocks2["dbiTxtDomainStringOldOld"] = 83] = "dbiTxtDomainStringOldOld";
+      SettingsBlocks2[SettingsBlocks2["dbiThemeKey"] = 84] = "dbiThemeKey";
+      SettingsBlocks2[SettingsBlocks2["dbiTileBackground"] = 85] = "dbiTileBackground";
+      SettingsBlocks2[SettingsBlocks2["dbiCacheSettingsOld"] = 86] = "dbiCacheSettingsOld";
+      SettingsBlocks2[SettingsBlocks2["dbiPowerSaving"] = 87] = "dbiPowerSaving";
+      SettingsBlocks2[SettingsBlocks2["dbiScalePercent"] = 88] = "dbiScalePercent";
+      SettingsBlocks2[SettingsBlocks2["dbiPlaybackSpeedOld"] = 89] = "dbiPlaybackSpeedOld";
+      SettingsBlocks2[SettingsBlocks2["dbiLanguagesKey"] = 90] = "dbiLanguagesKey";
+      SettingsBlocks2[SettingsBlocks2["dbiCallSettingsOld"] = 91] = "dbiCallSettingsOld";
+      SettingsBlocks2[SettingsBlocks2["dbiCacheSettings"] = 92] = "dbiCacheSettings";
+      SettingsBlocks2[SettingsBlocks2["dbiTxtDomainStringOld"] = 93] = "dbiTxtDomainStringOld";
+      SettingsBlocks2[SettingsBlocks2["dbiApplicationSettings"] = 94] = "dbiApplicationSettings";
+      SettingsBlocks2[SettingsBlocks2["dbiDialogsFiltersOld"] = 95] = "dbiDialogsFiltersOld";
+      SettingsBlocks2[SettingsBlocks2["dbiFallbackProductionConfig"] = 96] = "dbiFallbackProductionConfig";
+      SettingsBlocks2[SettingsBlocks2["dbiBackgroundKey"] = 97] = "dbiBackgroundKey";
+      SettingsBlocks2[SettingsBlocks2["dbiEncryptedWithSalt"] = 333] = "dbiEncryptedWithSalt";
+      SettingsBlocks2[SettingsBlocks2["dbiEncrypted"] = 444] = "dbiEncrypted";
+      SettingsBlocks2[SettingsBlocks2["dbiVersion"] = 666] = "dbiVersion";
+      return SettingsBlocks2;
+    })(SettingsBlocks || {});
+  }
+});
+function decryptSettingsTdf(settingsTdf) {
+  const encryptedData = settingsTdf.encryptedData;
+  let offset = 0;
+  const { value: salt, newOffset: offset1 } = readQtByteArray(encryptedData, offset);
+  offset = offset1;
+  const { value: encryptedSettings, newOffset: _ } = readQtByteArray(encryptedData, offset);
+  const settingsKey = createLegacyLocalKey(Buffer.alloc(0), salt);
+  return decryptLocal(encryptedSettings, settingsKey);
+}
+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 = fs.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";
+      }
+    };
+  }
+});
+
+// src/tdata-decrypter/decrypter.ts
+var decrypter_exports = {};
+__export(decrypter_exports, {
+  TdataReader: () => TdataReader
+});
+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();
+async function extractAuthKey(tdataPath) {
+  try {
+    const { TdataReader: TdataReader2 } = await Promise.resolve().then(() => (init_decrypter(), decrypter_exports));
+    let path2 = tdataPath;
+    if (!path2.endsWith("tdata")) {
+      const tdataDir = __require("path").join(tdataPath, "tdata");
+      if (__require("fs").existsSync(tdataDir)) {
+        path2 = tdataDir;
+      }
+    }
+    const reader = new TdataReader2(path2);
+    const result = reader.read();
+    if (!result.accounts || result.accounts.size === 0) {
+      return {
+        success: false,
+        error: "No accounts found in tdata. Please make sure you're logged into Telegram Desktop."
+      };
+    }
+    const firstAccount = result.accounts.values().next().value;
+    if (!firstAccount) {
+      return {
+        success: false,
+        error: "No accounts found in tdata."
+      };
+    }
+    const { mtpData } = firstAccount;
+    const authKeyBytes = mtpData.keys.get(mtpData.currentDcId);
+    if (!authKeyBytes) {
+      return {
+        success: false,
+        error: `No auth key found for DC ${mtpData.currentDcId}`
+      };
+    }
+    return {
+      success: true,
+      userId: mtpData.userId,
+      dcId: mtpData.currentDcId,
+      authKey: authKeyBytes.toString("hex")
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+export { CryptoException, SettingsBlocks, TDF_MAGIC, TdataReader, TdfParserError, WrongHashsumTdfParserError, WrongMagicTdfParserError, aesDecryptLocal, createLegacyLocalKey, createLocalKey, decryptKeyDataTdf, decryptLocal, decryptSettingsTdf, extractAuthKey, parseRawTdf, prepareAesOldMtp, readBytes, readKeyDataAccounts, readQtByteArray, readQtInt32, readQtInt64, readQtInteger, readQtUint32, readQtUint64, readQtUtf8, readSettingsBlock, readSettingsBlocks, readTdfFile };
+//# sourceMappingURL=tdata-decrypter-index.js.map
+//# sourceMappingURL=tdata-decrypter-index.js.map