@chainlesschain/personal-data-hub 0.1.0 → 0.2.1

package/lib/adapters/wechat/db-reader.js

@@ -0,0 +1,209 @@
+/**
+ * Phase 12 v0.5 — WeChat SQLCipher DB reader (frida-INDEPENDENT).
+ *
+ * Opens the decrypted-via-MD5-key EnMicroMsg.db using
+ * better-sqlite3-multiple-ciphers (the same package LocalVault uses).
+ *
+ * Note about the key flow:
+ *   - For WeChat < 8.0: key comes from KeyExtractor (MD5(IMEI+UIN)[:7]).
+ *   - For WeChat 8.0+ : key comes from Frida hook (Phase 12.6). DI seam
+ *     `keyProvider.getKey()` lets both paths plug in cleanly.
+ *
+ * SQLCipher PRAGMA settings per design doc + sjqz reference:
+ *   PRAGMA cipher_default_kdf_iter = 4000;
+ *   PRAGMA cipher_default_use_hmac = OFF;
+ *   PRAGMA cipher_compatibility = 1;  // WCDB legacy SQLCipher v1 layout
+ *
+ * Different WeChat builds use different SQLCipher params — we try a few
+ * standard ones in order via tryOpen().
+ */
+
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const KNOWN_PRAGMA_PROFILES = [
+  // WCDB legacy (most common, WeChat < 8.0)
+  {
+    name: "wcdb-legacy",
+    pragmas: [
+      "PRAGMA cipher_compatibility = 1",
+      "PRAGMA cipher_default_kdf_iter = 4000",
+      "PRAGMA cipher_default_use_hmac = OFF",
+      "PRAGMA cipher_default_page_size = 1024",
+    ],
+  },
+  // SQLCipher v3 default — fallback for some PC WeChat builds
+  {
+    name: "sqlcipher-v3",
+    pragmas: [
+      "PRAGMA cipher_compatibility = 3",
+      "PRAGMA cipher_default_kdf_iter = 64000",
+    ],
+  },
+  // SQLCipher v4 default
+  {
+    name: "sqlcipher-v4",
+    pragmas: [
+      "PRAGMA cipher_compatibility = 4",
+    ],
+  },
+];
+
+class WeChatDBReader {
+  constructor(opts = {}) {
+    if (!opts || typeof opts !== "object") {
+      throw new Error("WeChatDBReader: opts required");
+    }
+    if (!opts.dbPath || typeof opts.dbPath !== "string") {
+      throw new Error("WeChatDBReader: opts.dbPath required");
+    }
+    if (!opts.keyProvider || typeof opts.keyProvider.getKey !== "function") {
+      throw new Error("WeChatDBReader: opts.keyProvider with getKey() required");
+    }
+    this._dbPath = opts.dbPath;
+    this._keyProvider = opts.keyProvider;
+    this._driver = opts.driver || null; // DI seam for tests
+    this._db = null;
+    this._profile = null;
+  }
+
+  async open() {
+    if (!fs.existsSync(this._dbPath)) {
+      throw new Error(`WeChatDBReader: DB not found: ${this._dbPath}`);
+    }
+    const key = await this._keyProvider.getKey();
+    if (!key) {
+      throw new Error("WeChatDBReader: keyProvider returned empty key");
+    }
+    const Database = this._driver || loadDriver();
+    let lastError = null;
+    for (const profile of KNOWN_PRAGMA_PROFILES) {
+      try {
+        const db = new Database(this._dbPath, { readonly: true });
+        db.pragma(`key = '${key}'`);
+        for (const p of profile.pragmas) db.exec(p);
+        // Probe — does sqlite_master open?
+        const row = db.prepare("SELECT count(*) AS n FROM sqlite_master").get();
+        if (row && Number.isFinite(row.n)) {
+          this._db = db;
+          this._profile = profile.name;
+          return { profile: profile.name, tables: row.n };
+        }
+        db.close();
+      } catch (err) {
+        lastError = err;
+      }
+    }
+    throw new Error(
+      `WeChatDBReader: failed to open with any pragma profile. Last error: ${lastError && lastError.message}`,
+    );
+  }
+
+  /**
+   * Quick check: does this look like an EnMicroMsg.db (the main WeChat
+   * message DB)? Verifies the `message` + `rcontact` tables exist.
+   */
+  isEnMicroMsg() {
+    if (!this._db) return false;
+    try {
+      const tables = this._db
+        .prepare("SELECT name FROM sqlite_master WHERE type='table'")
+        .all()
+        .map((r) => r.name);
+      return tables.includes("message") && tables.includes("rcontact");
+    } catch (_e) {
+      return false;
+    }
+  }
+
+  /**
+   * List tables present.
+   */
+  listTables() {
+    if (!this._db) return [];
+    return this._db
+      .prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
+      .all()
+      .map((r) => r.name);
+  }
+
+  /**
+   * Fetch up to `limit` messages since `sinceMsgSvrId` (per design doc
+   * §6 OQ-6 watermark = per-talker last msgSvrId). For initial v0 we
+   * accept a global watermark and let the adapter post-filter per
+   * talker.
+   */
+  fetchMessages({ sinceMsgSvrId = 0, limit = 1000, talker = null } = {}) {
+    if (!this._db) throw new Error("WeChatDBReader: call open() first");
+    let sql = "SELECT msgId, msgSvrId, talker, content, type, createTime, isSend, status FROM message";
+    const params = [];
+    const where = [];
+    if (sinceMsgSvrId) {
+      where.push("msgSvrId > ?");
+      params.push(sinceMsgSvrId);
+    }
+    if (talker) {
+      where.push("talker = ?");
+      params.push(talker);
+    }
+    if (where.length > 0) sql += " WHERE " + where.join(" AND ");
+    sql += " ORDER BY msgSvrId ASC LIMIT ?";
+    params.push(limit);
+    return this._db.prepare(sql).all(...params);
+  }
+
+  /**
+   * Fetch contacts. WeChat rcontact has many columns; we pull the ones
+   * relevant for normalization.
+   */
+  fetchContacts({ limit = 5000 } = {}) {
+    if (!this._db) throw new Error("WeChatDBReader: call open() first");
+    return this._db
+      .prepare(
+        "SELECT username, alias, nickname, conRemark, type FROM rcontact LIMIT ?",
+      )
+      .all(limit);
+  }
+
+  /**
+   * Fetch chatroom info.
+   */
+  fetchChatrooms({ limit = 1000 } = {}) {
+    if (!this._db) throw new Error("WeChatDBReader: call open() first");
+    return this._db
+      .prepare(
+        "SELECT chatroomname, memberlist, displayname, roomowner FROM chatroom LIMIT ?",
+      )
+      .all(limit);
+  }
+
+  close() {
+    if (this._db) {
+      try { this._db.close(); } catch (_e) {}
+      this._db = null;
+    }
+  }
+
+  /** Active pragma profile name (set after successful open). */
+  profile() { return this._profile; }
+}
+
+let _driverCache = null;
+function loadDriver() {
+  if (_driverCache) return _driverCache;
+  try {
+    _driverCache = require("better-sqlite3-multiple-ciphers");
+  } catch (err) {
+    throw new Error(
+      `WeChatDBReader: better-sqlite3-multiple-ciphers required: ${err && err.message ? err.message : err}`,
+    );
+  }
+  return _driverCache;
+}
+
+module.exports = {
+  WeChatDBReader,
+  KNOWN_PRAGMA_PROFILES,
+};

package/lib/adapters/wechat/env-probe.js

@@ -0,0 +1,218 @@
+/**
+ * Phase 12.6.4 — WeChat env-probe.
+ *
+ * Inspects the connected Android device (via `adb`) and decides which
+ * KeyProvider strategy is viable:
+ *
+ *   - suggestedKeyProvider: "md5" | "frida" | "unsupported"
+ *
+ * Decision tree:
+ *   - WeChat < 8.0  → "md5"   (legacy MD5(IMEI+UIN)[:7] path works)
+ *   - WeChat 8.0+   → "frida" (need live hook; requires root + frida-server)
+ *   - WeChat absent / device unreachable → "unsupported"
+ *
+ * Each capability is probed independently so UI can show a checklist.
+ * All shell commands are routed through an injected `exec()` so unit
+ * tests don't spawn real processes.
+ *
+ * Wire shape:
+ *   {
+ *     ok: boolean,                  // overall — true iff suggestedKeyProvider !== "unsupported"
+ *     suggestedKeyProvider: "md5" | "frida" | "unsupported",
+ *     reasons: string[],            // human strings for why suggestion chosen
+ *     device: {
+ *       reachable: boolean,
+ *       serial: string | null,
+ *       abi: string | null,         // arm64-v8a / armeabi-v7a / x86_64
+ *     },
+ *     root: {
+ *       detected: boolean,
+ *       magiskInstalled: boolean,
+ *     },
+ *     frida: {
+ *       serverRunning: boolean,
+ *       port: number | null,
+ *     },
+ *     wechat: {
+ *       installed: boolean,
+ *       versionName: string | null,
+ *       majorVersion: number | null,
+ *     },
+ *     warnings: string[],
+ *   }
+ */
+"use strict";
+
+// Lazy require of child_process so test injection beats the import
+function defaultExec() {
+  // eslint-disable-next-line global-require
+  const cp = require("node:child_process");
+  return (cmd, opts = {}) => new Promise((resolve) => {
+    cp.exec(cmd, { encoding: "utf-8", timeout: 5000, ...opts }, (err, stdout, stderr) => {
+      resolve({
+        code: err ? (err.code || 1) : 0,
+        stdout: String(stdout || ""),
+        stderr: String(stderr || ""),
+      });
+    });
+  });
+}
+
+async function probeDevice(exec) {
+  const out = { reachable: false, serial: null, abi: null };
+  const r = await exec("adb devices");
+  if (r.code !== 0) return out;
+  const lines = r.stdout.split(/\r?\n/);
+  // Header: "List of devices attached" then "<serial>\tdevice"
+  for (const line of lines) {
+    const m = /^(\S+)\s+device\s*$/.exec(line);
+    if (m) {
+      out.reachable = true;
+      out.serial = m[1];
+      break;
+    }
+  }
+  if (!out.reachable) return out;
+  const abiR = await exec("adb shell getprop ro.product.cpu.abi");
+  out.abi = abiR.code === 0 ? abiR.stdout.trim() || null : null;
+  return out;
+}
+
+async function probeRoot(exec) {
+  const out = { detected: false, magiskInstalled: false };
+  // `su -c id` succeeds (uid=0) only on rooted devices
+  const su = await exec('adb shell "su -c id" 2>&1');
+  if (su.code === 0 && /uid=0/.test(su.stdout)) out.detected = true;
+  // which magisk (Magisk command-line)
+  const ma = await exec('adb shell "command -v magisk"');
+  if (ma.code === 0 && ma.stdout.trim()) out.magiskInstalled = true;
+  return out;
+}
+
+async function probeFridaServer(exec) {
+  const out = { serverRunning: false, port: null };
+  // Look for frida-server in process list (matches frida-server-* prebuilds)
+  const ps = await exec('adb shell "pgrep -f frida-server" 2>&1');
+  if (ps.code === 0 && /^\d+/m.test(ps.stdout.trim())) out.serverRunning = true;
+  // Default port 27042; check if it's listening
+  const ns = await exec('adb shell "netstat -tln 2>/dev/null | grep -E \':27042\\b\'"');
+  if (ns.code === 0 && ns.stdout.includes("27042")) {
+    out.serverRunning = true;
+    out.port = 27042;
+  } else if (out.serverRunning) {
+    out.port = 27042;
+  }
+  return out;
+}
+
+async function probeWeChat(exec) {
+  const out = { installed: false, versionName: null, majorVersion: null };
+  const r = await exec('adb shell "dumpsys package com.tencent.mm | grep versionName"');
+  if (r.code !== 0) return out;
+  const m = /versionName=([\d.]+)/i.exec(r.stdout);
+  if (!m) return out;
+  out.installed = true;
+  out.versionName = m[1];
+  const major = parseInt(m[1].split(".")[0], 10);
+  out.majorVersion = Number.isFinite(major) ? major : null;
+  return out;
+}
+
+/**
+ * Decide suggested KeyProvider given probed capabilities.
+ * Exported separately so callers can also pass synthetic facts.
+ */
+function decide({ device, root, frida, wechat }) {
+  const reasons = [];
+  if (!device.reachable) {
+    return { suggestedKeyProvider: "unsupported", reasons: ["No adb device reachable"] };
+  }
+  if (!wechat.installed) {
+    return { suggestedKeyProvider: "unsupported", reasons: ["WeChat (com.tencent.mm) not installed"] };
+  }
+  const major = wechat.majorVersion;
+  if (major != null && major < 8) {
+    reasons.push(`WeChat ${wechat.versionName} (< 8.0) — legacy MD5(IMEI+UIN) path supported`);
+    return { suggestedKeyProvider: "md5", reasons };
+  }
+  // 8.0+ requires frida
+  if (!root.detected) {
+    return {
+      suggestedKeyProvider: "unsupported",
+      reasons: [`WeChat ${wechat.versionName || "8.x"} requires root for SQLCipher key extraction, root not detected`],
+    };
+  }
+  if (!frida.serverRunning) {
+    return {
+      suggestedKeyProvider: "unsupported",
+      reasons: [
+        `WeChat ${wechat.versionName || "8.x"} requires Frida hook`,
+        "frida-server not running on device — see Frida Setup runbook",
+      ],
+    };
+  }
+  reasons.push(`WeChat ${wechat.versionName} (≥ 8.0) — Frida hook on libwcdb.so sqlite3_key`);
+  if (!root.magiskInstalled) {
+    reasons.push("Magisk not detected — DenyList configuration unavailable; reverse-detection may be weaker");
+  }
+  return { suggestedKeyProvider: "frida", reasons };
+}
+
+/**
+ * Top-level probe.
+ *
+ * @param {object} [opts]
+ * @param {Function} [opts.exec]  injected exec(cmd, opts) → {code, stdout, stderr}
+ * @returns {Promise<object>}     full probe shape (see file header)
+ */
+async function probe(opts = {}) {
+  const exec = typeof opts.exec === "function" ? opts.exec : defaultExec();
+  const warnings = [];
+
+  const device = await probeDevice(exec);
+  if (!device.reachable) {
+    return {
+      ok: false,
+      suggestedKeyProvider: "unsupported",
+      reasons: ["No adb device reachable — enable USB debugging and reconnect"],
+      device,
+      root: { detected: false, magiskInstalled: false },
+      frida: { serverRunning: false, port: null },
+      wechat: { installed: false, versionName: null, majorVersion: null },
+      warnings,
+    };
+  }
+
+  const [root, frida, wechat] = await Promise.all([
+    probeRoot(exec),
+    probeFridaServer(exec),
+    probeWeChat(exec),
+  ]);
+
+  if (device.abi && !/^arm/.test(device.abi)) {
+    warnings.push(`ABI ${device.abi} — Frida prebuilt may need manual build for non-ARM target`);
+  }
+
+  const { suggestedKeyProvider, reasons } = decide({ device, root, frida, wechat });
+
+  return {
+    ok: suggestedKeyProvider !== "unsupported",
+    suggestedKeyProvider,
+    reasons,
+    device,
+    root,
+    frida,
+    wechat,
+    warnings,
+  };
+}
+
+module.exports = {
+  probe,
+  decide,
+  // exposed for fine-grained testing
+  probeDevice,
+  probeRoot,
+  probeFridaServer,
+  probeWeChat,
+};

package/lib/adapters/wechat/frida-agent/loader.js

@@ -0,0 +1,67 @@
+/**
+ * Phase 12.6.2 — Frida agent loader (host side).
+ *
+ * Reads the raw agent JS so FridaKeyProvider can pass it to
+ * `session.createScript(text)`. Also exposes `runUnderMock()` so the
+ * host can unit-test the agent's behavior by injecting fake Frida
+ * globals (Module / Interceptor / Process / send / setTimeout).
+ *
+ * The agent itself (wechat-key-hook.js) is plain JS — no `require` or
+ * `module.exports` — because Frida loads it as a text blob inside the
+ * target process. The loader hides that detail from callers.
+ */
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const vm = require("node:vm");
+
+const AGENT_PATH = path.join(__dirname, "wechat-key-hook.js");
+
+function loadAgentScript() {
+  return fs.readFileSync(AGENT_PATH, "utf-8");
+}
+
+/**
+ * Execute the agent script in a sandboxed context where the caller
+ * supplies the Frida globals. Used for unit tests.
+ *
+ * @param {object} mocks
+ * @param {object} mocks.Module     mock with findExportByName(modName, sym)
+ * @param {object} mocks.Process    mock with findModuleByName(modName)
+ * @param {object} mocks.Interceptor mock with attach(addr, handlers)
+ * @param {Function} mocks.send     captures send() calls
+ * @param {Function} [mocks.setTimeout]  defaults to global setTimeout
+ * @returns {object}  the sandbox context after execution
+ */
+function runAgentUnderMock(mocks = {}) {
+  if (!mocks.Module || typeof mocks.Module.findExportByName !== "function") {
+    throw new Error("runAgentUnderMock: mocks.Module.findExportByName required");
+  }
+  if (!mocks.Process || typeof mocks.Process.findModuleByName !== "function") {
+    throw new Error("runAgentUnderMock: mocks.Process.findModuleByName required");
+  }
+  if (!mocks.Interceptor || typeof mocks.Interceptor.attach !== "function") {
+    throw new Error("runAgentUnderMock: mocks.Interceptor.attach required");
+  }
+  if (typeof mocks.send !== "function") {
+    throw new Error("runAgentUnderMock: mocks.send required");
+  }
+  const sandbox = {
+    Module: mocks.Module,
+    Process: mocks.Process,
+    Interceptor: mocks.Interceptor,
+    send: mocks.send,
+    setTimeout: mocks.setTimeout || setTimeout,
+  };
+  const ctx = vm.createContext(sandbox);
+  const src = loadAgentScript();
+  vm.runInContext(src, ctx, { filename: "wechat-key-hook.js" });
+  return sandbox;
+}
+
+module.exports = {
+  AGENT_PATH,
+  loadAgentScript,
+  runAgentUnderMock,
+};

package/lib/adapters/wechat/frida-agent/wechat-key-hook.js

@@ -0,0 +1,126 @@
+/**
+ * Phase 12.6.2 — Frida agent: WeChat SQLCipher key hook.
+ *
+ * This script runs INSIDE the WeChat process (com.tencent.mm) after
+ * being injected by the FridaKeyProvider on the host. It hooks the
+ * sqlite3_key family of symbols in libwcdb.so (WeChat's SQLCipher fork)
+ * and sends the captured 32-byte key hex back to the host via Frida's
+ * `send()` channel.
+ *
+ * Wire contract (host expects):
+ *   { kind: "key", hex: "<lowercase hex>", source: "<symbol-name>" }
+ *   { kind: "hooked", symbol: "<symbol>", module: "libwcdb.so" }
+ *   { kind: "error", message: "<reason>" }
+ *   { kind: "module-waiting", module: "libwcdb.so" }
+ *
+ * Design references:
+ *   - Adapter_WeChat_SQLCipher.md §18.3 (agent script structure)
+ *   - §18.6 (anti-detection — hook at module-load time)
+ *
+ * Notes on portability:
+ *   - This file is loaded by the host as raw text and passed verbatim
+ *     to `session.createScript(...)`. It MUST NOT use any node `require()`
+ *     or host-only APIs. Frida injects its own runtime (Module,
+ *     Interceptor, Process, send, etc.) at runtime.
+ *   - Keep dependencies on host helpers (e.g. esbuild) zero. The whole
+ *     agent is ≤ 120 LOC of plain JS — no compilation step needed.
+ */
+
+/* eslint-disable */
+/* global Module, Interceptor, Process, send, setTimeout */
+
+"use strict";
+
+(function () {
+  var TARGET_MODULE = "libwcdb.so";
+  // Primary symbol per §18.3. Add fallbacks below — version drift will
+  // shift the export name; host treats first hit as authoritative.
+  var SYMBOLS = [
+    "sqlite3_key",
+    "sqlite3_key_v2",
+    "wcdb_setkey",
+    "WCDBKeyDerive",
+    // C++-mangled symbols (Itanium ABI) — rare but seen in WCDB 1.x
+    "_ZN4WCDB8Database13setCipherKeyERKNSt6__ndk112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE",
+  ];
+
+  function bytesToHex(buf) {
+    if (!buf || buf.byteLength === 0) return "";
+    var bytes = new Uint8Array(buf);
+    var out = "";
+    for (var i = 0; i < bytes.length; i++) {
+      var b = bytes[i].toString(16);
+      if (b.length < 2) b = "0" + b;
+      out += b;
+    }
+    return out;
+  }
+
+  // Track which symbol fired first; only emit the first key event so
+  // the host detaches quickly (anti-detection §18.6 #4).
+  var fired = false;
+
+  function makeHook(symbolName) {
+    return {
+      onEnter: function (args) {
+        if (fired) return;
+        try {
+          // sqlite3_key signature: int sqlite3_key(sqlite3 *db, const void *pKey, int nKey)
+          // args[1] = key bytes, args[2] = key length
+          var len = args[2].toInt32();
+          if (len <= 0 || len > 256) {
+            send({ kind: "error", message: "implausible key length " + len + " at " + symbolName });
+            return;
+          }
+          var buf = args[1].readByteArray(len);
+          var hex = bytesToHex(buf);
+          if (!hex) {
+            send({ kind: "error", message: "empty key buffer at " + symbolName });
+            return;
+          }
+          fired = true;
+          send({ kind: "key", hex: hex, source: symbolName });
+        } catch (e) {
+          send({ kind: "error", message: "hook exception at " + symbolName + ": " + (e && e.message ? e.message : String(e)) });
+        }
+      },
+    };
+  }
+
+  function tryAttach() {
+    var mod = Process.findModuleByName(TARGET_MODULE);
+    if (!mod) return false;
+    var attached = 0;
+    for (var i = 0; i < SYMBOLS.length; i++) {
+      var addr = Module.findExportByName(TARGET_MODULE, SYMBOLS[i]);
+      if (!addr) continue;
+      try {
+        Interceptor.attach(addr, makeHook(SYMBOLS[i]));
+        send({ kind: "hooked", symbol: SYMBOLS[i], module: TARGET_MODULE });
+        attached++;
+      } catch (e) {
+        send({ kind: "error", message: "Interceptor.attach failed for " + SYMBOLS[i] + ": " + (e && e.message ? e.message : String(e)) });
+      }
+    }
+    return attached > 0;
+  }
+
+  // Module-load polling — §18.6 #1 "hook at module-load time before
+  // anti-detection thread runs". WeChat lazy-loads libwcdb when the
+  // first DB opens, so we can't always find it at script start.
+  if (!tryAttach()) {
+    send({ kind: "module-waiting", module: TARGET_MODULE });
+    var attempts = 0;
+    var poll = function () {
+      attempts++;
+      if (tryAttach()) return;
+      if (attempts >= 60) {
+        // 60 attempts × 500ms = 30s ceiling, matches host timeoutMs
+        send({ kind: "error", message: TARGET_MODULE + " did not load within 30s" });
+        return;
+      }
+      setTimeout(poll, 500);
+    };
+    setTimeout(poll, 500);
+  }
+})();

package/lib/adapters/wechat/index.js

@@ -0,0 +1,37 @@
+"use strict";
+
+const { WechatAdapter, NAME, VERSION } = require("./wechat-adapter");
+const { parseContent, parseXmlAttrs, extractTag, isGroupTalker, TYPE_NAMES, APPMSG_SUBTYPES } = require("./content-parser");
+const { extractWeChatKey, deriveLegacyKey, extractUinFromPrefs, extractImeiFromCompatibleInfo } = require("./key-extractor");
+const { WeChatDBReader, KNOWN_PRAGMA_PROFILES } = require("./db-reader");
+const { normalizeMessage, normalizeContact, wxidToPersonId } = require("./normalize");
+const { KeyProvider, MD5KeyProvider, FridaKeyProvider } = require("./key-providers");
+const envProbe = require("./env-probe");
+const { bootstrapWechatAdapter } = require("./bootstrap");
+
+module.exports = {
+  WechatAdapter,
+  WECHAT_NAME: NAME,
+  WECHAT_VERSION: VERSION,
+  parseWeChatContent: parseContent,
+  parseWeChatXmlAttrs: parseXmlAttrs,
+  extractWeChatTag: extractTag,
+  isWeChatGroupTalker: isGroupTalker,
+  WECHAT_TYPE_NAMES: TYPE_NAMES,
+  WECHAT_APPMSG_SUBTYPES: APPMSG_SUBTYPES,
+  extractWeChatKey,
+  deriveWeChatLegacyKey: deriveLegacyKey,
+  extractWeChatUinFromPrefs: extractUinFromPrefs,
+  extractWeChatImeiFromCompatibleInfo: extractImeiFromCompatibleInfo,
+  WeChatDBReader,
+  WECHAT_PRAGMA_PROFILES: KNOWN_PRAGMA_PROFILES,
+  normalizeWeChatMessage: normalizeMessage,
+  normalizeWeChatContact: normalizeContact,
+  wxidToWeChatPersonId: wxidToPersonId,
+  WeChatKeyProvider: KeyProvider,
+  WeChatMD5KeyProvider: MD5KeyProvider,
+  WeChatFridaKeyProvider: FridaKeyProvider,
+  probeWeChatEnv: envProbe.probe,
+  decideWeChatKeyProvider: envProbe.decide,
+  bootstrapWechatAdapter,
+};