@chainlesschain/personal-data-hub 0.1.0 → 0.2.1

package/__tests__/adapters/wechat-bootstrap.test.js

@@ -0,0 +1,240 @@
+/**
+ * Phase 12.6.7 — bootstrapWechatAdapter unit tests.
+ *
+ * Validates the decision matrix that ties env-probe → KeyProvider →
+ * WechatAdapter. All exec calls are stubbed via `_probe` injection so
+ * tests stay fully hermetic (no adb, no Frida binding, no real device).
+ */
+"use strict";
+
+import { describe, it, expect } from "vitest";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import wechatModule from "../../lib/adapters/wechat/bootstrap.js";
+const { bootstrapWechatAdapter } = wechatModule;
+
+function mkProbe(overrides = {}) {
+  const base = {
+    ok: true,
+    suggestedKeyProvider: "md5",
+    reasons: ["WeChat 7.0.22 (< 8.0) — legacy MD5(IMEI+UIN) path supported"],
+    device: { reachable: true, serial: "SERIAL123", abi: "arm64-v8a" },
+    root: { detected: false, magiskInstalled: false },
+    frida: { serverRunning: false, port: null },
+    wechat: { installed: true, versionName: "7.0.22", majorVersion: 7 },
+    warnings: [],
+  };
+  return { ...base, ...overrides };
+}
+
+function mkWechatDataPath() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pdh-wechat-bootstrap-"));
+  return dir;
+}
+
+describe("bootstrapWechatAdapter — input validation", () => {
+  it("throws when account.uin missing (including bare opts)", async () => {
+    await expect(bootstrapWechatAdapter()).rejects.toThrow(/account\.uin/);
+    await expect(bootstrapWechatAdapter({})).rejects.toThrow(/account\.uin/);
+    await expect(
+      bootstrapWechatAdapter({ account: {} }),
+    ).rejects.toThrow(/account\.uin/);
+  });
+});
+
+describe("bootstrapWechatAdapter — md5 path", () => {
+  it("returns ok with MD5KeyProvider when probe suggests md5 + wechatDataPath provided", async () => {
+    const wechatDataPath = mkWechatDataPath();
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "1234567890" },
+      wechatDataPath,
+      _probe: mkProbe(),
+    });
+    expect(r.ok).toBe(true);
+    expect(r.adapter).toBeDefined();
+    expect(r.adapter.account.uin).toBe("1234567890");
+    expect(r.keyProvider).toBeDefined();
+    expect(r.keyProvider.name).toBe("md5");
+    expect(r.probe.suggestedKeyProvider).toBe("md5");
+  });
+
+  it("returns MD5_NEEDS_WECHAT_DATA_PATH when md5 chosen but wechatDataPath missing", async () => {
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "1234567890" },
+      _probe: mkProbe(),
+    });
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("MD5_NEEDS_WECHAT_DATA_PATH");
+    expect(r.probe).toBeDefined();
+    expect(r.message).toMatch(/wechatDataPath/);
+  });
+
+  it("propagates dbPath to the adapter constructor", async () => {
+    const wechatDataPath = mkWechatDataPath();
+    const dbPath = path.join(wechatDataPath, "MicroMsg.db");
+    fs.writeFileSync(dbPath, "stub", "utf-8");
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "1234567890" },
+      dbPath,
+      wechatDataPath,
+      _probe: mkProbe(),
+    });
+    expect(r.ok).toBe(true);
+    expect(r.adapter._dbPath).toBe(dbPath);
+  });
+});
+
+describe("bootstrapWechatAdapter — frida path", () => {
+  it("returns ok with FridaKeyProvider when probe suggests frida", async () => {
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "wxid_abcdef" },
+      _probe: mkProbe({
+        suggestedKeyProvider: "frida",
+        wechat: { installed: true, versionName: "8.0.50", majorVersion: 8 },
+        root: { detected: true, magiskInstalled: true },
+        frida: { serverRunning: true, port: 27042 },
+      }),
+    });
+    expect(r.ok).toBe(true);
+    expect(r.keyProvider).toBeDefined();
+    expect(r.keyProvider.name).toBe("frida");
+    expect(r.adapter).toBeDefined();
+  });
+
+  it("forwards fridaOpts.deviceId / packageName / timeoutMs", async () => {
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "wxid_abcdef" },
+      fridaOpts: {
+        deviceId: "EMULATOR_ID",
+        packageName: "com.tencent.mm.beta",
+        timeoutMs: 12_345,
+      },
+      _probe: mkProbe({
+        suggestedKeyProvider: "frida",
+        wechat: { installed: true, versionName: "8.0.50", majorVersion: 8 },
+        root: { detected: true, magiskInstalled: true },
+        frida: { serverRunning: true, port: 27042 },
+      }),
+    });
+    expect(r.ok).toBe(true);
+    expect(r.keyProvider._deviceId).toBe("EMULATOR_ID");
+    expect(r.keyProvider._packageName).toBe("com.tencent.mm.beta");
+    expect(r.keyProvider._timeoutMs).toBe(12_345);
+  });
+
+  it("falls back to probe.device.serial when fridaOpts.deviceId not provided", async () => {
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "wxid_abcdef" },
+      _probe: mkProbe({
+        suggestedKeyProvider: "frida",
+        device: { reachable: true, serial: "FROM_PROBE", abi: "arm64-v8a" },
+        wechat: { installed: true, versionName: "8.0.50", majorVersion: 8 },
+        root: { detected: true, magiskInstalled: true },
+        frida: { serverRunning: true, port: 27042 },
+      }),
+    });
+    expect(r.ok).toBe(true);
+    expect(r.keyProvider._deviceId).toBe("FROM_PROBE");
+  });
+});
+
+describe("bootstrapWechatAdapter — unsupported / unknown", () => {
+  it("returns ENV_UNSUPPORTED with probe reasons when nothing viable", async () => {
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "1234567890" },
+      _probe: mkProbe({
+        ok: false,
+        suggestedKeyProvider: "unsupported",
+        reasons: ["WeChat 8.0.50 requires root for SQLCipher key extraction"],
+      }),
+    });
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("ENV_UNSUPPORTED");
+    expect(r.message).toMatch(/root/);
+    expect(r.probe).toBeDefined();
+  });
+
+  it("returns UNKNOWN_KEY_PROVIDER when override is not md5/frida", async () => {
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "1234567890" },
+      keyProviderOverride: "magic-pony",
+      _probe: mkProbe(),
+    });
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("UNKNOWN_KEY_PROVIDER");
+  });
+});
+
+describe("bootstrapWechatAdapter — override", () => {
+  it("keyProviderOverride='frida' picks frida even when probe suggests md5", async () => {
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "wxid_force" },
+      keyProviderOverride: "frida",
+      _probe: mkProbe(), // suggests "md5"
+    });
+    expect(r.ok).toBe(true);
+    expect(r.keyProvider.name).toBe("frida");
+    expect(r.probe.suggestedKeyProvider).toBe("md5"); // probe transparent
+  });
+
+  it("keyProviderOverride='md5' picks md5 even when probe suggests frida", async () => {
+    const wechatDataPath = mkWechatDataPath();
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "1234567890" },
+      wechatDataPath,
+      keyProviderOverride: "md5",
+      _probe: mkProbe({
+        suggestedKeyProvider: "frida",
+        wechat: { installed: true, versionName: "8.0.50", majorVersion: 8 },
+        root: { detected: true, magiskInstalled: true },
+        frida: { serverRunning: true, port: 27042 },
+      }),
+    });
+    expect(r.ok).toBe(true);
+    expect(r.keyProvider.name).toBe("md5");
+  });
+});
+
+describe("bootstrapWechatAdapter — adapter ctor errors", () => {
+  it("returns ADAPTER_CTOR_FAILED when WechatAdapter throws", async () => {
+    const wechatDataPath = mkWechatDataPath();
+    function Boom() {
+      throw new Error("ctor boom");
+    }
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "1234567890" },
+      wechatDataPath,
+      _probe: mkProbe(),
+      _WechatAdapter: Boom,
+    });
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("ADAPTER_CTOR_FAILED");
+    expect(r.message).toBe("ctor boom");
+  });
+});
+
+describe("bootstrapWechatAdapter — test seams", () => {
+  it("uses injected _md5Provider verbatim", async () => {
+    const stubProvider = { name: "md5", getKey: async () => "deadbeef" };
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "1234567890" },
+      _probe: mkProbe(),
+      _md5Provider: stubProvider,
+    });
+    expect(r.ok).toBe(true);
+    expect(r.keyProvider).toBe(stubProvider);
+  });
+
+  it("uses injected _fridaProvider verbatim", async () => {
+    const stubProvider = { name: "frida", getKey: async () => "feedface".repeat(8) };
+    const r = await bootstrapWechatAdapter({
+      account: { uin: "wxid_abc" },
+      keyProviderOverride: "frida",
+      _probe: mkProbe(),
+      _fridaProvider: stubProvider,
+    });
+    expect(r.ok).toBe(true);
+    expect(r.keyProvider).toBe(stubProvider);
+  });
+});

package/__tests__/adapters/wechat-env-probe.test.js

@@ -0,0 +1,162 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const { probe, decide } = require("../../lib/adapters/wechat/env-probe");
+
+/**
+ * Build a scripted exec that returns a canned response per matching
+ * substring. Falls back to `{ code: 1, stdout: "", stderr: "" }`.
+ */
+function makeExec(table) {
+  return async (cmd) => {
+    for (const [needle, response] of table) {
+      if (cmd.includes(needle)) return { code: 0, stdout: response, stderr: "" };
+    }
+    return { code: 1, stdout: "", stderr: "" };
+  };
+}
+
+const ADB_DEVICES_OK = "List of devices attached\nABC123XYZ\tdevice\n\n";
+const WECHAT_7 = "    versionName=7.0.22\n";
+const WECHAT_8 = "    versionName=8.0.50\n";
+const NETSTAT_FRIDA = "tcp        0      0 0.0.0.0:27042           0.0.0.0:*               LISTEN\n";
+
+describe("decide() — pure decision logic", () => {
+  it("device unreachable → unsupported", () => {
+    const r = decide({
+      device: { reachable: false }, root: {}, frida: {}, wechat: {},
+    });
+    expect(r.suggestedKeyProvider).toBe("unsupported");
+  });
+
+  it("WeChat 7.x → md5 regardless of root/frida", () => {
+    const r = decide({
+      device: { reachable: true },
+      root: { detected: false },
+      frida: { serverRunning: false },
+      wechat: { installed: true, versionName: "7.0.22", majorVersion: 7 },
+    });
+    expect(r.suggestedKeyProvider).toBe("md5");
+  });
+
+  it("WeChat 8.x + root + frida → frida", () => {
+    const r = decide({
+      device: { reachable: true },
+      root: { detected: true, magiskInstalled: true },
+      frida: { serverRunning: true, port: 27042 },
+      wechat: { installed: true, versionName: "8.0.50", majorVersion: 8 },
+    });
+    expect(r.suggestedKeyProvider).toBe("frida");
+  });
+
+  it("WeChat 8.x + no root → unsupported", () => {
+    const r = decide({
+      device: { reachable: true },
+      root: { detected: false },
+      frida: { serverRunning: true },
+      wechat: { installed: true, versionName: "8.0.50", majorVersion: 8 },
+    });
+    expect(r.suggestedKeyProvider).toBe("unsupported");
+    expect(r.reasons.join(" ")).toMatch(/root/);
+  });
+
+  it("WeChat 8.x + root + no frida-server → unsupported", () => {
+    const r = decide({
+      device: { reachable: true },
+      root: { detected: true },
+      frida: { serverRunning: false },
+      wechat: { installed: true, versionName: "8.0.50", majorVersion: 8 },
+    });
+    expect(r.suggestedKeyProvider).toBe("unsupported");
+    expect(r.reasons.join(" ")).toMatch(/frida-server/i);
+  });
+
+  it("WeChat not installed → unsupported", () => {
+    const r = decide({
+      device: { reachable: true },
+      root: { detected: true },
+      frida: { serverRunning: true },
+      wechat: { installed: false },
+    });
+    expect(r.suggestedKeyProvider).toBe("unsupported");
+    expect(r.reasons.join(" ")).toMatch(/not installed/);
+  });
+
+  it("WeChat 8.x + root + frida + no Magisk → frida (warn reason)", () => {
+    const r = decide({
+      device: { reachable: true },
+      root: { detected: true, magiskInstalled: false },
+      frida: { serverRunning: true, port: 27042 },
+      wechat: { installed: true, versionName: "8.0.50", majorVersion: 8 },
+    });
+    expect(r.suggestedKeyProvider).toBe("frida");
+    expect(r.reasons.join(" ")).toMatch(/Magisk not detected/);
+  });
+});
+
+describe("probe() — end-to-end with mock exec", () => {
+  it("returns unsupported when no device", async () => {
+    const exec = makeExec([["adb devices", "List of devices attached\n\n"]]);
+    const r = await probe({ exec });
+    expect(r.ok).toBe(false);
+    expect(r.suggestedKeyProvider).toBe("unsupported");
+    expect(r.device.reachable).toBe(false);
+  });
+
+  it("WeChat 7.x device → md5 path", async () => {
+    const exec = makeExec([
+      ["adb devices", ADB_DEVICES_OK],
+      ["getprop ro.product.cpu.abi", "arm64-v8a\n"],
+      ["com.tencent.mm", WECHAT_7],
+    ]);
+    const r = await probe({ exec });
+    expect(r.ok).toBe(true);
+    expect(r.suggestedKeyProvider).toBe("md5");
+    expect(r.device.serial).toBe("ABC123XYZ");
+    expect(r.device.abi).toBe("arm64-v8a");
+    expect(r.wechat.majorVersion).toBe(7);
+  });
+
+  it("WeChat 8.x + rooted + frida → frida path", async () => {
+    const exec = makeExec([
+      ["adb devices", ADB_DEVICES_OK],
+      ["getprop ro.product.cpu.abi", "arm64-v8a\n"],
+      ['su -c id', "uid=0(root) gid=0(root) groups=0(root)\n"],
+      ["command -v magisk", "/system/bin/magisk\n"],
+      ["pgrep -f frida-server", "12345\n"],
+      ["netstat -tln", NETSTAT_FRIDA],
+      ["com.tencent.mm", WECHAT_8],
+    ]);
+    const r = await probe({ exec });
+    expect(r.ok).toBe(true);
+    expect(r.suggestedKeyProvider).toBe("frida");
+    expect(r.root.detected).toBe(true);
+    expect(r.root.magiskInstalled).toBe(true);
+    expect(r.frida.serverRunning).toBe(true);
+    expect(r.frida.port).toBe(27042);
+    expect(r.wechat.majorVersion).toBe(8);
+  });
+
+  it("WeChat 8.x but no root → unsupported with reason", async () => {
+    const exec = makeExec([
+      ["adb devices", ADB_DEVICES_OK],
+      ["getprop ro.product.cpu.abi", "arm64-v8a\n"],
+      ["com.tencent.mm", WECHAT_8],
+    ]);
+    const r = await probe({ exec });
+    expect(r.ok).toBe(false);
+    expect(r.suggestedKeyProvider).toBe("unsupported");
+    expect(r.reasons.join(" ")).toMatch(/root not detected/);
+  });
+
+  it("non-ARM ABI gets warning", async () => {
+    const exec = makeExec([
+      ["adb devices", ADB_DEVICES_OK],
+      ["getprop ro.product.cpu.abi", "x86_64\n"],
+      ["com.tencent.mm", WECHAT_7],
+    ]);
+    const r = await probe({ exec });
+    expect(r.warnings.join(" ")).toMatch(/x86_64/);
+  });
+});

package/__tests__/adapters/wechat-frida-agent.test.js

@@ -0,0 +1,191 @@
+"use strict";
+
+import { describe, it, expect, vi } from "vitest";
+
+const { loadAgentScript, runAgentUnderMock } = require("../../lib/adapters/wechat/frida-agent/loader");
+
+function hexToBuffer(hex) {
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = parseInt(hex.substr(i * 2, 2), 16);
+  }
+  return out.buffer;
+}
+
+/** Fake NativePointer — supports toInt32() (length) and readByteArray(len) (key bytes). */
+function fakePtr(value) {
+  return {
+    _v: value,
+    toInt32() { return typeof value === "number" ? value : 0; },
+    readByteArray(len) {
+      // value is a hex string for key bytes; len ignored beyond bounds
+      if (typeof value !== "string") return new Uint8Array(0).buffer;
+      const buf = hexToBuffer(value);
+      // truncate to requested len if needed
+      return new Uint8Array(buf, 0, Math.min(len, buf.byteLength)).buffer;
+    },
+  };
+}
+
+describe("frida-agent loader — script loading", () => {
+  it("loadAgentScript returns non-empty JS text", () => {
+    const src = loadAgentScript();
+    expect(src.length).toBeGreaterThan(100);
+    expect(src).toContain("libwcdb.so");
+    expect(src).toContain("sqlite3_key");
+  });
+});
+
+describe("frida-agent — sqlite3_key hook on module already loaded", () => {
+  it("emits hooked + key on sqlite3_key onEnter", () => {
+    const send = vi.fn();
+    const attached = {};
+    const Interceptor = {
+      attach(addr, handlers) {
+        attached[addr.symbol] = handlers;
+      },
+    };
+    const Module = {
+      findExportByName(mod, sym) {
+        if (mod !== "libwcdb.so") return null;
+        if (sym === "sqlite3_key") return { symbol: sym };
+        return null; // only sqlite3_key resolves; others null
+      },
+    };
+    const Process = {
+      findModuleByName(mod) { return mod === "libwcdb.so" ? { name: mod } : null; },
+    };
+
+    runAgentUnderMock({ Module, Process, Interceptor, send });
+
+    // After load, "hooked" event already sent
+    const hooked = send.mock.calls.find((c) => c[0].kind === "hooked");
+    expect(hooked).toBeDefined();
+    expect(hooked[0].symbol).toBe("sqlite3_key");
+    expect(hooked[0].module).toBe("libwcdb.so");
+
+    // Fire the hook: args = [sqlite3*, keyBytes, len]
+    const keyHex = "11223344556677889900aabbccddeeff" +
+                   "00112233445566778899aabbccddeeff"; // 64 hex = 32 bytes (SQLCipher 256-bit)
+    const args = [fakePtr(0), fakePtr(keyHex), fakePtr(32)];
+    attached.sqlite3_key.onEnter(args);
+
+    const key = send.mock.calls.find((c) => c[0].kind === "key");
+    expect(key).toBeDefined();
+    expect(key[0].hex).toBe(keyHex);
+    expect(key[0].source).toBe("sqlite3_key");
+  });
+
+  it("only emits the first key event (anti-detection: hook fires once)", () => {
+    const send = vi.fn();
+    const attached = {};
+    const Interceptor = {
+      attach(addr, handlers) { attached[addr.symbol] = handlers; },
+    };
+    const Module = {
+      findExportByName(mod, sym) {
+        if (sym === "sqlite3_key") return { symbol: sym };
+        return null;
+      },
+    };
+    const Process = { findModuleByName() { return { name: "libwcdb.so" }; } };
+
+    runAgentUnderMock({ Module, Process, Interceptor, send });
+
+    const args = [fakePtr(0), fakePtr("aabb" + "00".repeat(30)), fakePtr(32)];
+    attached.sqlite3_key.onEnter(args);
+    attached.sqlite3_key.onEnter(args);
+    attached.sqlite3_key.onEnter(args);
+
+    const keyEvents = send.mock.calls.filter((c) => c[0].kind === "key");
+    expect(keyEvents).toHaveLength(1);
+  });
+
+  it("rejects implausible key length with error event", () => {
+    const send = vi.fn();
+    const attached = {};
+    const Interceptor = {
+      attach(addr, handlers) { attached[addr.symbol] = handlers; },
+    };
+    const Module = {
+      findExportByName(mod, sym) { return sym === "sqlite3_key" ? { symbol: sym } : null; },
+    };
+    const Process = { findModuleByName() { return { name: "libwcdb.so" }; } };
+
+    runAgentUnderMock({ Module, Process, Interceptor, send });
+
+    attached.sqlite3_key.onEnter([fakePtr(0), fakePtr("aa"), fakePtr(9999)]);
+
+    const errs = send.mock.calls.filter((c) => c[0].kind === "error");
+    expect(errs.length).toBeGreaterThan(0);
+    expect(errs[0][0].message).toMatch(/implausible key length 9999/);
+  });
+});
+
+describe("frida-agent — fallback symbol resolution", () => {
+  it("attaches to wcdb_setkey when sqlite3_key absent", () => {
+    const send = vi.fn();
+    const attached = {};
+    const Interceptor = {
+      attach(addr, handlers) { attached[addr.symbol] = handlers; },
+    };
+    const Module = {
+      findExportByName(mod, sym) {
+        // WeChat 8.x renamed primary symbol
+        if (sym === "wcdb_setkey") return { symbol: sym };
+        return null;
+      },
+    };
+    const Process = { findModuleByName() { return { name: "libwcdb.so" }; } };
+
+    runAgentUnderMock({ Module, Process, Interceptor, send });
+
+    const hooked = send.mock.calls.find((c) => c[0].kind === "hooked");
+    expect(hooked[0].symbol).toBe("wcdb_setkey");
+    expect(attached.wcdb_setkey).toBeDefined();
+  });
+
+  it("emits source = matched symbol when fallback fires", () => {
+    const send = vi.fn();
+    const attached = {};
+    const Interceptor = {
+      attach(addr, handlers) { attached[addr.symbol] = handlers; },
+    };
+    const Module = {
+      findExportByName(mod, sym) {
+        return sym === "WCDBKeyDerive" ? { symbol: sym } : null;
+      },
+    };
+    const Process = { findModuleByName() { return { name: "libwcdb.so" }; } };
+
+    runAgentUnderMock({ Module, Process, Interceptor, send });
+
+    attached.WCDBKeyDerive.onEnter([
+      fakePtr(0),
+      fakePtr("deadbeef" + "00".repeat(28)),
+      fakePtr(32),
+    ]);
+
+    const key = send.mock.calls.find((c) => c[0].kind === "key");
+    expect(key[0].source).toBe("WCDBKeyDerive");
+  });
+});
+
+describe("frida-agent — module not yet loaded path", () => {
+  it("emits module-waiting and schedules retry", () => {
+    const send = vi.fn();
+    const Interceptor = { attach: vi.fn() };
+    const Module = { findExportByName: vi.fn().mockReturnValue(null) };
+    const Process = { findModuleByName: vi.fn().mockReturnValue(null) };
+    const setTimeoutMock = vi.fn();
+
+    runAgentUnderMock({ Module, Process, Interceptor, send, setTimeout: setTimeoutMock });
+
+    const waiting = send.mock.calls.find((c) => c[0].kind === "module-waiting");
+    expect(waiting).toBeDefined();
+    expect(waiting[0].module).toBe("libwcdb.so");
+    expect(setTimeoutMock).toHaveBeenCalled();
+    // First retry delay 500ms
+    expect(setTimeoutMock.mock.calls[0][1]).toBe(500);
+  });
+});