@mtcute/convert 0.17.0 → 0.18.0

package/convert/src/tdesktop/tdata.cjs

@@ -0,0 +1,359 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const posix = require("node:path/posix");
+const io = require("@fuman/io");
+const utils = require("@fuman/utils");
+const core = require("@mtcute/core");
+const utils_js = require("@mtcute/core/utils.js");
+const crypto = require("../utils/crypto.cjs");
+const qtReader = require("./qt-reader.cjs");
+const qtWriter = require("./qt-writer.cjs");
+const TDF_MAGIC = /* @__PURE__ */ utils.utf8.encoder.encode("TDF$");
+const TDF_VERSION = 5008003;
+const MTP_AUTHORIZATION_BLOCK = 75;
+const HEX_ALPHABET = "0123456789ABCDEF";
+function toFilePart(key) {
+  let str = "";
+  for (let i = 0; i < 8; i++) {
+    const b = key[i];
+    const low = b & 15;
+    const high = b >> 4;
+    str += HEX_ALPHABET[low] + HEX_ALPHABET[high];
+  }
+  return str;
+}
+class Tdata {
+  constructor(options, fs, crypto2) {
+    this.options = options;
+    this.fs = fs;
+    this.crypto = crypto2;
+  }
+  keyData;
+  static async open(options) {
+    const fs = options.fs ?? await import("node:fs/promises");
+    const crypto$1 = options.crypto ?? await crypto.getDefaultCryptoProvider();
+    await crypto$1.initialize?.();
+    const tdata = new Tdata(options, fs, crypto$1);
+    tdata.keyData = await tdata.readKeyData();
+    return tdata;
+  }
+  static async create(options) {
+    const fs = options.fs ?? await import("node:fs/promises");
+    const crypto$1 = options.crypto ?? await crypto.getDefaultCryptoProvider();
+    await crypto$1.initialize?.();
+    const tdata = new Tdata(options, fs, crypto$1);
+    const keyData = {
+      ...options.keyData,
+      localKey: options.keyData.localKey ?? crypto$1.randomBytes(256),
+      version: options.keyData.version ?? TDF_VERSION
+    };
+    tdata.keyData = keyData;
+    await tdata.writeKeyData(keyData);
+    return tdata;
+  }
+  #readInt32(buf) {
+    return this.options.le ?? true ? io.read.int32le(buf) : io.read.int32be(buf);
+  }
+  #writeInt32(buf, val) {
+    if (this.options.le ?? true) {
+      io.write.int32le(buf, val);
+    } else {
+      io.write.int32be(buf, val);
+    }
+    return buf;
+  }
+  getDataName(idx) {
+    let res = this.options.dataKey ?? "data";
+    if (idx > 0) {
+      res += `#${idx + 1}`;
+    }
+    return res;
+  }
+  async readFile(filename) {
+    const order = [];
+    const modern = `${filename}s`;
+    if (await this.fs.stat(posix.join(this.options.path, modern))) {
+      order.push(modern);
+    } else {
+      const try0 = `${filename}0`;
+      const try1 = `${filename}1`;
+      const try0s = await this.fs.stat(posix.join(this.options.path, try0));
+      const try1s = await this.fs.stat(posix.join(this.options.path, try1));
+      if (try0s) {
+        order.push(try0);
+        if (try1s) {
+          order.push(try1);
+          if (try0s.lastModified < try1s.lastModified) {
+            order.reverse();
+          }
+        }
+      } else if (try1s) {
+        order.push(try1);
+      }
+    }
+    let lastError = "file not found";
+    for (const file of order) {
+      const data = await this.fs.readFile(posix.join(this.options.path, file));
+      const magic = data.subarray(0, 4);
+      if (!utils.typed.equal(magic, TDF_MAGIC)) {
+        lastError = "invalid magic";
+        continue;
+      }
+      const versionBytes = data.subarray(4, 8);
+      const version = this.#readInt32(versionBytes);
+      if (version > TDF_VERSION && !this.options.ignoreVersion) {
+        lastError = `Unsupported version: ${version}`;
+        continue;
+      }
+      const dataSize = data.length - 24;
+      const bytes = data.subarray(8, dataSize + 8);
+      const md5 = await this.crypto.createHash("md5");
+      await md5.update(bytes);
+      await md5.update(this.#writeInt32(utils.u8.alloc(4), dataSize));
+      await md5.update(versionBytes);
+      await md5.update(magic);
+      const hash = await md5.digest();
+      if (!utils.typed.equal(hash, data.subarray(dataSize + 8))) {
+        lastError = "md5 mismatch";
+        continue;
+      }
+      return [version, bytes];
+    }
+    throw new Error(`failed to read ${filename}, last error: ${lastError}`);
+  }
+  async writeFile(filename, data, mkdir = false) {
+    filename = posix.join(this.options.path, `${filename}s`);
+    const version = this.#writeInt32(utils.u8.alloc(4), TDF_VERSION);
+    const dataSize = this.#writeInt32(utils.u8.alloc(4), data.length);
+    const md5 = await this.crypto.createHash("md5");
+    await md5.update(data);
+    await md5.update(dataSize);
+    await md5.update(version);
+    await md5.update(TDF_MAGIC);
+    if (mkdir) {
+      await this.fs.mkdir(posix.dirname(filename), { recursive: true });
+    }
+    await this.fs.writeFile(
+      filename,
+      utils.u8.concat([TDF_MAGIC, version, data, await md5.digest()])
+    );
+  }
+  async createLocalKey(salt, passcode = this.options.passcode ?? "") {
+    const hasher = await this.crypto.createHash("sha512");
+    await hasher.update(salt);
+    await hasher.update(utils.utf8.encoder.encode(passcode));
+    await hasher.update(salt);
+    const hash = await hasher.digest();
+    return this.crypto.pbkdf2(
+      hash,
+      salt,
+      passcode === "" ? 1 : 1e5,
+      256,
+      "sha512"
+    );
+  }
+  async decryptLocal(encrypted, key) {
+    const encryptedKey = encrypted.subarray(0, 16);
+    const encryptedData = encrypted.subarray(16);
+    const ige = utils_js.createAesIgeForMessageOld(
+      this.crypto,
+      key,
+      encryptedKey,
+      false
+    );
+    const decrypted = ige.decrypt(encryptedData);
+    if (!utils.typed.equal(
+      this.crypto.sha1(decrypted).subarray(0, 16),
+      encryptedKey
+    )) {
+      throw new Error("Failed to decrypt, invalid password?");
+    }
+    const fullLen = encryptedData.length;
+    const dataLen = this.#readInt32(decrypted);
+    if (dataLen > decrypted.length || dataLen <= fullLen - 16 || dataLen < 4) {
+      throw new Error("Failed to decrypt, invalid data length");
+    }
+    return decrypted.subarray(4, dataLen);
+  }
+  async encryptLocal(data, key) {
+    const dataSize = data.length + 4;
+    const padding = dataSize & 15 ? this.crypto.randomBytes(16 - (dataSize & 15)) : utils.u8.empty;
+    const toEncrypt = utils.u8.alloc(dataSize + padding.length);
+    this.#writeInt32(toEncrypt, dataSize);
+    toEncrypt.set(data, 4);
+    toEncrypt.set(padding, dataSize);
+    const encryptedKey = this.crypto.sha1(toEncrypt).subarray(0, 16);
+    const ige = utils_js.createAesIgeForMessageOld(
+      this.crypto,
+      key,
+      encryptedKey,
+      false
+    );
+    const encryptedData = ige.encrypt(toEncrypt);
+    return utils.u8.concat2(encryptedKey, encryptedData);
+  }
+  async readKeyData() {
+    const [version, data] = await this.readFile(`key_${this.options.dataKey ?? "data"}`);
+    const bytes = io.Bytes.from(data);
+    const salt = qtReader.readQByteArray(bytes);
+    const keyEncrypted = qtReader.readQByteArray(bytes);
+    const infoEncrypted = qtReader.readQByteArray(bytes);
+    const passcodeKey = await this.createLocalKey(salt);
+    const keyInnerData = await this.decryptLocal(keyEncrypted, passcodeKey);
+    const infoDecrypted = await this.decryptLocal(
+      infoEncrypted,
+      keyInnerData
+    );
+    const info = io.Bytes.from(infoDecrypted);
+    const localKey = keyInnerData;
+    const count = io.read.int32be(info);
+    const order = [...new Array(count)].map(() => io.read.int32be(info));
+    const active = io.read.int32be(info);
+    return {
+      version,
+      localKey,
+      count,
+      order,
+      active
+    };
+  }
+  async writeKeyData(keyData) {
+    const info = io.Bytes.alloc();
+    io.write.int32be(info, keyData.count);
+    keyData.order.forEach((i) => io.write.int32be(info, i));
+    io.write.int32be(info, keyData.active);
+    const infoDecrypted = info.result();
+    const infoEncrypted = await this.encryptLocal(infoDecrypted, keyData.localKey);
+    const salt = this.crypto.randomBytes(32);
+    const passcodeKey = await this.createLocalKey(salt);
+    const keyEncrypted = await this.encryptLocal(keyData.localKey, passcodeKey);
+    const data = io.Bytes.alloc();
+    qtWriter.writeQByteArray(data, salt);
+    qtWriter.writeQByteArray(data, keyEncrypted);
+    qtWriter.writeQByteArray(data, infoEncrypted);
+    await this.writeFile(`key_${this.options.dataKey ?? "data"}`, data.result(), true);
+  }
+  async computeDataNameKey(accountIdx) {
+    const md5 = await this.crypto.createHash("md5");
+    await md5.update(utils.utf8.encoder.encode(this.getDataName(accountIdx)));
+    const r = await md5.digest();
+    return r.subarray(0, 8);
+  }
+  async computeDataNameKeyHex(accountIdx) {
+    return toFilePart(await this.computeDataNameKey(accountIdx));
+  }
+  async readEncryptedFile(filename) {
+    const [version, data] = await this.readFile(filename);
+    const encrypted = qtReader.readQByteArray(io.Bytes.from(data));
+    const decrypted = await this.decryptLocal(encrypted, this.keyData.localKey);
+    return [version, decrypted];
+  }
+  async writeEncryptedFile(filename, data, mkdir = false) {
+    const encryptedInner = await this.encryptLocal(data, this.keyData.localKey);
+    const writer = io.Bytes.alloc(data.length + 4);
+    qtWriter.writeQByteArray(writer, encryptedInner);
+    await this.writeFile(filename, writer.result(), mkdir);
+  }
+  async readMtpAuthorization(accountIdx = 0) {
+    const [, mtpData] = await this.readEncryptedFile(
+      await this.computeDataNameKeyHex(accountIdx)
+    );
+    let bytes = io.Bytes.from(mtpData);
+    const header = io.read.int32be(bytes);
+    if (header !== MTP_AUTHORIZATION_BLOCK) {
+      throw new core.MtUnsupportedError(`expected first setting to be mtp auth data, got 0x${header.toString(16)}`);
+    }
+    const mtpAuthBlock = qtReader.readQByteArray(bytes);
+    bytes = io.Bytes.from(mtpAuthBlock);
+    const legacyUserId = io.read.int32be(bytes);
+    const legacyMainDcId = io.read.int32be(bytes);
+    let userId, mainDcId;
+    if (legacyMainDcId === -1 && legacyMainDcId === -1) {
+      userId = qtReader.readLong(bytes);
+      mainDcId = io.read.int32be(bytes);
+    } else {
+      userId = core.Long.fromInt(legacyUserId);
+      mainDcId = legacyMainDcId;
+    }
+    function readKeys(target) {
+      const count = io.read.uint32be(bytes);
+      for (let i = 0; i < count; i++) {
+        const dcId = io.read.int32be(bytes);
+        const key = io.read.exactly(bytes, 256);
+        target.push({ dcId, key });
+      }
+    }
+    const authKeys = [];
+    const authKeysToDestroy = [];
+    readKeys(authKeys);
+    readKeys(authKeysToDestroy);
+    return {
+      userId,
+      mainDcId,
+      authKeys,
+      authKeysToDestroy
+    };
+  }
+  async writeMtpAuthorization(auth, accountIdx = 0) {
+    const bytes = io.Bytes.alloc();
+    io.write.int32be(bytes, -1);
+    io.write.int32be(bytes, -1);
+    qtWriter.writeLong(bytes, auth.userId);
+    io.write.int32be(bytes, auth.mainDcId);
+    function writeKeys(keys) {
+      io.write.uint32be(bytes, keys.length);
+      keys.forEach((k) => {
+        io.write.int32be(bytes, k.dcId);
+        io.write.bytes(bytes, k.key);
+      });
+    }
+    writeKeys(auth.authKeys);
+    writeKeys(auth.authKeysToDestroy);
+    const file = io.Bytes.alloc();
+    io.write.int32be(file, MTP_AUTHORIZATION_BLOCK);
+    qtWriter.writeQByteArray(file, bytes.result());
+    await this.writeEncryptedFile(
+      await this.computeDataNameKeyHex(accountIdx),
+      file.result()
+    );
+  }
+  async writeEmptyMapFile(accountIdx) {
+    const writer = io.Bytes.alloc();
+    qtWriter.writeQByteArray(writer, utils.u8.empty);
+    qtWriter.writeQByteArray(writer, utils.u8.empty);
+    qtWriter.writeQByteArray(writer, await this.encryptLocal(utils.u8.empty, this.keyData.localKey));
+    await this.writeFile(
+      posix.join(await this.computeDataNameKeyHex(accountIdx), "map"),
+      writer.result(),
+      true
+    );
+  }
+}
+exports.Tdata = Tdata;

package/convert/src/tdesktop/tdata.js

@@ -0,0 +1,332 @@
+import { join, dirname } from "node:path/posix";
+import { read, write, Bytes } from "@fuman/io";
+import { typed, utf8, u8 } from "@fuman/utils";
+import { MtUnsupportedError, Long } from "@mtcute/core";
+import { createAesIgeForMessageOld } from "@mtcute/core/utils.js";
+import { getDefaultCryptoProvider } from "../utils/crypto.js";
+import { readQByteArray, readLong } from "./qt-reader.js";
+import { writeQByteArray, writeLong } from "./qt-writer.js";
+const TDF_MAGIC = /* @__PURE__ */ utf8.encoder.encode("TDF$");
+const TDF_VERSION = 5008003;
+const MTP_AUTHORIZATION_BLOCK = 75;
+const HEX_ALPHABET = "0123456789ABCDEF";
+function toFilePart(key) {
+  let str = "";
+  for (let i = 0; i < 8; i++) {
+    const b = key[i];
+    const low = b & 15;
+    const high = b >> 4;
+    str += HEX_ALPHABET[low] + HEX_ALPHABET[high];
+  }
+  return str;
+}
+class Tdata {
+  constructor(options, fs, crypto) {
+    this.options = options;
+    this.fs = fs;
+    this.crypto = crypto;
+  }
+  keyData;
+  static async open(options) {
+    const fs = options.fs ?? await import("node:fs/promises");
+    const crypto = options.crypto ?? await getDefaultCryptoProvider();
+    await crypto.initialize?.();
+    const tdata = new Tdata(options, fs, crypto);
+    tdata.keyData = await tdata.readKeyData();
+    return tdata;
+  }
+  static async create(options) {
+    const fs = options.fs ?? await import("node:fs/promises");
+    const crypto = options.crypto ?? await getDefaultCryptoProvider();
+    await crypto.initialize?.();
+    const tdata = new Tdata(options, fs, crypto);
+    const keyData = {
+      ...options.keyData,
+      localKey: options.keyData.localKey ?? crypto.randomBytes(256),
+      version: options.keyData.version ?? TDF_VERSION
+    };
+    tdata.keyData = keyData;
+    await tdata.writeKeyData(keyData);
+    return tdata;
+  }
+  #readInt32(buf) {
+    return this.options.le ?? true ? read.int32le(buf) : read.int32be(buf);
+  }
+  #writeInt32(buf, val) {
+    if (this.options.le ?? true) {
+      write.int32le(buf, val);
+    } else {
+      write.int32be(buf, val);
+    }
+    return buf;
+  }
+  getDataName(idx) {
+    let res = this.options.dataKey ?? "data";
+    if (idx > 0) {
+      res += `#${idx + 1}`;
+    }
+    return res;
+  }
+  async readFile(filename) {
+    const order = [];
+    const modern = `${filename}s`;
+    if (await this.fs.stat(join(this.options.path, modern))) {
+      order.push(modern);
+    } else {
+      const try0 = `${filename}0`;
+      const try1 = `${filename}1`;
+      const try0s = await this.fs.stat(join(this.options.path, try0));
+      const try1s = await this.fs.stat(join(this.options.path, try1));
+      if (try0s) {
+        order.push(try0);
+        if (try1s) {
+          order.push(try1);
+          if (try0s.lastModified < try1s.lastModified) {
+            order.reverse();
+          }
+        }
+      } else if (try1s) {
+        order.push(try1);
+      }
+    }
+    let lastError = "file not found";
+    for (const file of order) {
+      const data = await this.fs.readFile(join(this.options.path, file));
+      const magic = data.subarray(0, 4);
+      if (!typed.equal(magic, TDF_MAGIC)) {
+        lastError = "invalid magic";
+        continue;
+      }
+      const versionBytes = data.subarray(4, 8);
+      const version = this.#readInt32(versionBytes);
+      if (version > TDF_VERSION && !this.options.ignoreVersion) {
+        lastError = `Unsupported version: ${version}`;
+        continue;
+      }
+      const dataSize = data.length - 24;
+      const bytes = data.subarray(8, dataSize + 8);
+      const md5 = await this.crypto.createHash("md5");
+      await md5.update(bytes);
+      await md5.update(this.#writeInt32(u8.alloc(4), dataSize));
+      await md5.update(versionBytes);
+      await md5.update(magic);
+      const hash = await md5.digest();
+      if (!typed.equal(hash, data.subarray(dataSize + 8))) {
+        lastError = "md5 mismatch";
+        continue;
+      }
+      return [version, bytes];
+    }
+    throw new Error(`failed to read ${filename}, last error: ${lastError}`);
+  }
+  async writeFile(filename, data, mkdir = false) {
+    filename = join(this.options.path, `${filename}s`);
+    const version = this.#writeInt32(u8.alloc(4), TDF_VERSION);
+    const dataSize = this.#writeInt32(u8.alloc(4), data.length);
+    const md5 = await this.crypto.createHash("md5");
+    await md5.update(data);
+    await md5.update(dataSize);
+    await md5.update(version);
+    await md5.update(TDF_MAGIC);
+    if (mkdir) {
+      await this.fs.mkdir(dirname(filename), { recursive: true });
+    }
+    await this.fs.writeFile(
+      filename,
+      u8.concat([TDF_MAGIC, version, data, await md5.digest()])
+    );
+  }
+  async createLocalKey(salt, passcode = this.options.passcode ?? "") {
+    const hasher = await this.crypto.createHash("sha512");
+    await hasher.update(salt);
+    await hasher.update(utf8.encoder.encode(passcode));
+    await hasher.update(salt);
+    const hash = await hasher.digest();
+    return this.crypto.pbkdf2(
+      hash,
+      salt,
+      passcode === "" ? 1 : 1e5,
+      256,
+      "sha512"
+    );
+  }
+  async decryptLocal(encrypted, key) {
+    const encryptedKey = encrypted.subarray(0, 16);
+    const encryptedData = encrypted.subarray(16);
+    const ige = createAesIgeForMessageOld(
+      this.crypto,
+      key,
+      encryptedKey,
+      false
+    );
+    const decrypted = ige.decrypt(encryptedData);
+    if (!typed.equal(
+      this.crypto.sha1(decrypted).subarray(0, 16),
+      encryptedKey
+    )) {
+      throw new Error("Failed to decrypt, invalid password?");
+    }
+    const fullLen = encryptedData.length;
+    const dataLen = this.#readInt32(decrypted);
+    if (dataLen > decrypted.length || dataLen <= fullLen - 16 || dataLen < 4) {
+      throw new Error("Failed to decrypt, invalid data length");
+    }
+    return decrypted.subarray(4, dataLen);
+  }
+  async encryptLocal(data, key) {
+    const dataSize = data.length + 4;
+    const padding = dataSize & 15 ? this.crypto.randomBytes(16 - (dataSize & 15)) : u8.empty;
+    const toEncrypt = u8.alloc(dataSize + padding.length);
+    this.#writeInt32(toEncrypt, dataSize);
+    toEncrypt.set(data, 4);
+    toEncrypt.set(padding, dataSize);
+    const encryptedKey = this.crypto.sha1(toEncrypt).subarray(0, 16);
+    const ige = createAesIgeForMessageOld(
+      this.crypto,
+      key,
+      encryptedKey,
+      false
+    );
+    const encryptedData = ige.encrypt(toEncrypt);
+    return u8.concat2(encryptedKey, encryptedData);
+  }
+  async readKeyData() {
+    const [version, data] = await this.readFile(`key_${this.options.dataKey ?? "data"}`);
+    const bytes = Bytes.from(data);
+    const salt = readQByteArray(bytes);
+    const keyEncrypted = readQByteArray(bytes);
+    const infoEncrypted = readQByteArray(bytes);
+    const passcodeKey = await this.createLocalKey(salt);
+    const keyInnerData = await this.decryptLocal(keyEncrypted, passcodeKey);
+    const infoDecrypted = await this.decryptLocal(
+      infoEncrypted,
+      keyInnerData
+    );
+    const info = Bytes.from(infoDecrypted);
+    const localKey = keyInnerData;
+    const count = read.int32be(info);
+    const order = [...new Array(count)].map(() => read.int32be(info));
+    const active = read.int32be(info);
+    return {
+      version,
+      localKey,
+      count,
+      order,
+      active
+    };
+  }
+  async writeKeyData(keyData) {
+    const info = Bytes.alloc();
+    write.int32be(info, keyData.count);
+    keyData.order.forEach((i) => write.int32be(info, i));
+    write.int32be(info, keyData.active);
+    const infoDecrypted = info.result();
+    const infoEncrypted = await this.encryptLocal(infoDecrypted, keyData.localKey);
+    const salt = this.crypto.randomBytes(32);
+    const passcodeKey = await this.createLocalKey(salt);
+    const keyEncrypted = await this.encryptLocal(keyData.localKey, passcodeKey);
+    const data = Bytes.alloc();
+    writeQByteArray(data, salt);
+    writeQByteArray(data, keyEncrypted);
+    writeQByteArray(data, infoEncrypted);
+    await this.writeFile(`key_${this.options.dataKey ?? "data"}`, data.result(), true);
+  }
+  async computeDataNameKey(accountIdx) {
+    const md5 = await this.crypto.createHash("md5");
+    await md5.update(utf8.encoder.encode(this.getDataName(accountIdx)));
+    const r = await md5.digest();
+    return r.subarray(0, 8);
+  }
+  async computeDataNameKeyHex(accountIdx) {
+    return toFilePart(await this.computeDataNameKey(accountIdx));
+  }
+  async readEncryptedFile(filename) {
+    const [version, data] = await this.readFile(filename);
+    const encrypted = readQByteArray(Bytes.from(data));
+    const decrypted = await this.decryptLocal(encrypted, this.keyData.localKey);
+    return [version, decrypted];
+  }
+  async writeEncryptedFile(filename, data, mkdir = false) {
+    const encryptedInner = await this.encryptLocal(data, this.keyData.localKey);
+    const writer = Bytes.alloc(data.length + 4);
+    writeQByteArray(writer, encryptedInner);
+    await this.writeFile(filename, writer.result(), mkdir);
+  }
+  async readMtpAuthorization(accountIdx = 0) {
+    const [, mtpData] = await this.readEncryptedFile(
+      await this.computeDataNameKeyHex(accountIdx)
+    );
+    let bytes = Bytes.from(mtpData);
+    const header = read.int32be(bytes);
+    if (header !== MTP_AUTHORIZATION_BLOCK) {
+      throw new MtUnsupportedError(`expected first setting to be mtp auth data, got 0x${header.toString(16)}`);
+    }
+    const mtpAuthBlock = readQByteArray(bytes);
+    bytes = Bytes.from(mtpAuthBlock);
+    const legacyUserId = read.int32be(bytes);
+    const legacyMainDcId = read.int32be(bytes);
+    let userId, mainDcId;
+    if (legacyMainDcId === -1 && legacyMainDcId === -1) {
+      userId = readLong(bytes);
+      mainDcId = read.int32be(bytes);
+    } else {
+      userId = Long.fromInt(legacyUserId);
+      mainDcId = legacyMainDcId;
+    }
+    function readKeys(target) {
+      const count = read.uint32be(bytes);
+      for (let i = 0; i < count; i++) {
+        const dcId = read.int32be(bytes);
+        const key = read.exactly(bytes, 256);
+        target.push({ dcId, key });
+      }
+    }
+    const authKeys = [];
+    const authKeysToDestroy = [];
+    readKeys(authKeys);
+    readKeys(authKeysToDestroy);
+    return {
+      userId,
+      mainDcId,
+      authKeys,
+      authKeysToDestroy
+    };
+  }
+  async writeMtpAuthorization(auth, accountIdx = 0) {
+    const bytes = Bytes.alloc();
+    write.int32be(bytes, -1);
+    write.int32be(bytes, -1);
+    writeLong(bytes, auth.userId);
+    write.int32be(bytes, auth.mainDcId);
+    function writeKeys(keys) {
+      write.uint32be(bytes, keys.length);
+      keys.forEach((k) => {
+        write.int32be(bytes, k.dcId);
+        write.bytes(bytes, k.key);
+      });
+    }
+    writeKeys(auth.authKeys);
+    writeKeys(auth.authKeysToDestroy);
+    const file = Bytes.alloc();
+    write.int32be(file, MTP_AUTHORIZATION_BLOCK);
+    writeQByteArray(file, bytes.result());
+    await this.writeEncryptedFile(
+      await this.computeDataNameKeyHex(accountIdx),
+      file.result()
+    );
+  }
+  async writeEmptyMapFile(accountIdx) {
+    const writer = Bytes.alloc();
+    writeQByteArray(writer, u8.empty);
+    writeQByteArray(writer, u8.empty);
+    writeQByteArray(writer, await this.encryptLocal(u8.empty, this.keyData.localKey));
+    await this.writeFile(
+      join(await this.computeDataNameKeyHex(accountIdx), "map"),
+      writer.result(),
+      true
+    );
+  }
+}
+export {
+  Tdata
+};