wechat-cli 0.1.0__py3-none-any.whl

wechat_cli/setup.py

@@ -0,0 +1,342 @@
+"""Download, validate, copy and instrument WeChat without modifying the installed app."""
+
+import hashlib
+import json
+import lzma
+import os
+import platform
+import secrets
+import shutil
+import socket
+import struct
+import subprocess
+import tempfile
+import urllib.error
+import urllib.request
+from contextlib import contextmanager
+from pathlib import Path
+
+from .config import ASSETS, load_runtime, private_directory, save_json
+from .errors import AppError
+from .network import ssl_context
+
+WECHAT_URL = "https://dldir1v6.qq.com/weixin/Universal/Mac/WeChatMac_4.1.15.dmg"
+GADGET_URL = (
+    "https://github.com/frida/frida/releases/download/17.8.0/frida-gadget-17.8.0-macos-universal.dylib.xz"
+)
+GADGET_SHA256 = "4cf5433452e745e8b283c7a2e79518c2cd6295e85869589dc3c171d5689e6b8c"
+GADGET_LOAD = b"@executable_path/../Frameworks/FridaGadget.dylib"
+PROFILE = json.loads((ASSETS / "profile.json").read_text())
+
+
+def require_macos():
+    if platform.system() != "Darwin" or platform.machine() != "arm64":
+        raise AppError("unsupported_platform", "Native setup requires Apple Silicon macOS", 424)
+
+
+def execute(args, **kwargs):
+    try:
+        return subprocess.run(
+            [str(x) for x in args],
+            check=True,
+            capture_output=True,
+            timeout=kwargs.pop("timeout", 120),
+            **kwargs,
+        ).stdout
+    except (OSError, subprocess.SubprocessError) as error:
+        # Do not include command outputs; they may contain private paths or tokens.
+        raise AppError(
+            "setup_command_failed",
+            f"{Path(str(args[0])).name} failed; check Xcode command-line tools and app write permissions",
+            424,
+        ) from error
+
+
+def fingerprint(path):
+    with path.open("rb") as source:
+        return hashlib.file_digest(source, "sha256").hexdigest()
+
+
+def check_payload(app):
+    try:
+        actual = fingerprint(app / "Contents/Resources/wechat.dylib")
+    except OSError:
+        raise AppError("invalid_wechat_app", "Missing Contents/Resources/wechat.dylib", 424) from None
+    for path in sorted((ASSETS / "profiles").glob("*.json")):
+        profile = json.loads(path.read_text())
+        if actual == profile["payloadSha256"]:
+            return profile
+    raise AppError(
+        "unsupported_wechat_version",
+        "This WeChat payload has no validated native profile. Update wechat-cli, "
+        "or select a supported installer with --wechat-url. Stock WeChat was not modified.",
+        424,
+    )
+
+
+def check_app(app):
+    app = Path(app).expanduser().resolve()
+    if app == Path("/Applications/WeChat.app").resolve():
+        raise AppError(
+            "stock_app_protected", "Use --source to copy stock WeChat, or --app with a separate patched copy"
+        )
+    check_payload(app)
+    try:
+        config = json.loads((app / "Contents/Frameworks/FridaGadget.config").read_text())["interaction"]
+        if (
+            config["type"] != "listen"
+            or config.get("address", "127.0.0.1") != "127.0.0.1"
+            or type(config["port"]) is not int
+            or not 1 <= config["port"] <= 65535
+            or not isinstance(config["token"], str)
+            or len(config["token"]) < 16
+        ):
+            raise ValueError()
+        if not (app / "Contents/Frameworks/FridaGadget.dylib").is_file():
+            raise ValueError()
+    except (OSError, KeyError, TypeError, ValueError):
+        raise AppError(
+            "invalid_gadget_config", "A loopback-only authenticated Frida Gadget is required", 424
+        ) from None
+    return app
+
+
+def download(url, target, maximum, expected=None):
+    """Bounded, atomic HTTPS download; a failed download never replaces a cached file."""
+    if not url.startswith("https://"):
+        raise AppError("invalid_download_url", "Installer downloads require HTTPS")
+    if target.is_file() and expected and fingerprint(target) == expected:
+        return target
+    temporary = target.with_suffix(target.suffix + ".part")
+    try:
+        request = urllib.request.Request(url, headers={"User-Agent": "wechat-cli/0.1.0"})
+        with (
+            urllib.request.urlopen(request, timeout=60, context=ssl_context()) as response,
+            temporary.open("wb") as output,
+        ):
+            if not response.url.startswith("https://"):
+                raise AppError("invalid_download_url", "Download redirected away from HTTPS")
+            size = 0
+            while chunk := response.read(1024 * 1024):
+                size += len(chunk)
+                if size > maximum:
+                    raise AppError("download_too_large", "Download exceeds the configured size limit", 413)
+                output.write(chunk)
+        if expected and fingerprint(temporary) != expected:
+            raise AppError(
+                "download_checksum_mismatch", "Downloaded Frida Gadget failed SHA-256 verification", 424
+            )
+        os.replace(temporary, target)
+        return target
+    except (OSError, urllib.error.URLError) as error:
+        raise AppError(
+            "download_failed",
+            "Cannot download the installer; check connectivity or supply --source /path/to/WeChat.app",
+            424,
+        ) from error
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+@contextmanager
+def mounted_app(dmg, directory):
+    mount = Path(tempfile.mkdtemp(prefix="mount-", dir=directory))
+    attached = False
+    try:
+        execute(
+            ["/usr/bin/hdiutil", "attach", "-readonly", "-nobrowse", "-mountpoint", mount, dmg], timeout=180
+        )
+        attached = True
+        apps = [p for p in mount.glob("*.app") if p.name in {"WeChat.app", "微信.app"}]
+        if len(apps) != 1:
+            raise AppError("invalid_installer", "Installer must contain one WeChat.app", 424)
+        yield apps[0]
+    finally:
+        if attached:
+            execute(["/usr/bin/hdiutil", "detach", mount], timeout=30)
+        mount.rmdir()
+
+
+def inject_gadget(binary):
+    """Add LC_LOAD_DYLIB only in verified empty Mach-O header padding.
+
+    No relocation or vendor payload modification. Support thin 64-bit and
+    universal 32-bit fat headers; fail closed for other layouts.
+    """
+    data = bytearray(binary.read_bytes())
+    if data[:4] == b"\xca\xfe\xba\xbe":
+        count = struct.unpack_from(">I", data, 4)[0]
+        if not 1 <= count <= 8 or len(data) < 8 + count * 20:
+            raise AppError("invalid_macho", "Invalid universal Mach-O header", 424)
+        slices = [struct.unpack_from(">IIIII", data, 8 + i * 20)[2:4] for i in range(count)]
+    else:
+        slices = [(0, len(data))]
+    for base, size in slices:
+        if base + size > len(data) or size < 32 or data[base : base + 4] != b"\xcf\xfa\xed\xfe":
+            raise AppError("invalid_macho", "Expected a 64-bit Mach-O executable", 424)
+        ncmds, cmdsize = struct.unpack_from("<II", data, base + 16)
+        end = base + 32 + cmdsize
+        if end > base + size:
+            raise AppError("invalid_macho", "Load commands exceed the Mach-O slice", 424)
+        cursor, found = base + 32, False
+        first_section = base + size
+        for _ in range(ncmds):
+            if cursor + 8 > end:
+                raise AppError("invalid_macho", "Truncated load command", 424)
+            cmd, length = struct.unpack_from("<II", data, cursor)
+            if length < 8 or cursor + length > end:
+                raise AppError("invalid_macho", "Invalid load command length", 424)
+            if cmd == 0x19:
+                if length < 72:
+                    raise AppError("invalid_macho", "Truncated segment command", 424)
+                section_count = struct.unpack_from("<I", data, cursor + 64)[0]
+                if length < 72 + section_count * 80:
+                    raise AppError("invalid_macho", "Truncated section table", 424)
+                for section in range(section_count):
+                    section_offset = struct.unpack_from("<I", data, cursor + 72 + section * 80 + 48)[0]
+                    if section_offset:
+                        first_section = min(first_section, base + section_offset)
+            if cmd in {0xC, 0x80000018} and GADGET_LOAD in data[cursor : cursor + length]:
+                found = True
+            cursor += length
+        if cursor != end:
+            raise AppError("invalid_macho", "Inconsistent load command size", 424)
+        if found:
+            continue
+        length = (24 + len(GADGET_LOAD) + 1 + 7) & ~7
+        if end + length > first_section or any(data[end : end + length]):
+            raise AppError("macho_padding_unavailable", "No empty header padding for Frida Gadget", 424)
+        command = struct.pack("<IIIIII", 0xC, length, 24, 0, 0, 0) + GADGET_LOAD + b"\0"
+        data[end : end + length] = command.ljust(length, b"\0")
+        struct.pack_into("<II", data, base + 16, ncmds + 1, cmdsize + length)
+    binary.write_bytes(data)
+
+
+def build_helper(app):
+    # Gadget configuration lives in Frameworks, so codesign treats it as nested code.
+    # A generic file signature is stored in extended attributes by macOS.
+    execute(["/usr/bin/codesign", "--force", "--sign", "-", app / "Contents/Frameworks/FridaGadget.config"])
+    compiler = execute(["/usr/bin/clang++", "--version"])
+    flags = ["-arch", "arm64", "-std=c++17", "-dynamiclib", "-O2", "-Wall", "-Wextra", "-Werror"]
+    source = ASSETS / "bridge.cpp"
+    digest = hashlib.sha256(source.read_bytes() + compiler + json.dumps(flags).encode()).hexdigest()[:16]
+    library = f"native-reader-{digest}.dylib"
+    output = app / "Contents/Frameworks" / library
+    if not output.exists():
+        temporary = output.with_suffix(f".{os.getpid()}.tmp")
+        try:
+            execute(["/usr/bin/clang++", *flags, source, "-o", temporary])
+            os.replace(temporary, output)
+        finally:
+            temporary.unlink(missing_ok=True)
+    execute(
+        ["/usr/bin/codesign", "--force", "--sign", "-", "--entitlements", ASSETS / "entitlements.plist", app]
+    )
+    return library
+
+
+def register(app, directory):
+    app = check_app(app)
+    library = build_helper(app)
+    save_json(directory / "native-runtime.json", {"app": str(app), "supportLibrary": library})
+    return {
+        "configured": True,
+        "app": str(app),
+        "version": check_payload(app)["version"],
+        "build": check_payload(app)["build"],
+    }
+
+
+def prepare(source, destination, gadget, directory):
+    source, destination = Path(source).resolve(), Path(destination).resolve()
+    if destination == Path("/Applications/WeChat.app").resolve() or destination == source:
+        raise AppError("stock_app_protected", "Destination must be a separate app copy")
+    if source in destination.parents:
+        raise AppError("invalid_destination", "Destination cannot be inside the source app")
+    if destination.exists():
+        raise AppError("destination_exists", "Destination already exists; use setup --app to register it")
+    check_payload(source)  # Reject before copying hundreds of megabytes.
+    destination.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    with tempfile.TemporaryDirectory(prefix="prepare-", dir=destination.parent) as staging:
+        app = Path(staging) / "WeChatBridge.app"
+        execute(["/usr/bin/ditto", source, app], timeout=180)
+        frameworks = app / "Contents/Frameworks"
+        shutil.copyfile(gadget, frameworks / "FridaGadget.dylib")
+        with socket.socket() as sock:
+            sock.bind(("127.0.0.1", 0))
+            port = sock.getsockname()[1]
+        save_json(
+            frameworks / "FridaGadget.config",
+            {
+                "interaction": {
+                    "type": "listen",
+                    "address": "127.0.0.1",
+                    "port": port,
+                    "token": secrets.token_hex(32),
+                    "on_load": "wait",
+                }
+            },
+        )
+        inject_gadget(app / "Contents/MacOS/WeChat")
+        execute(["/usr/bin/codesign", "--force", "--sign", "-", frameworks / "FridaGadget.dylib"])
+        library = build_helper(app)
+        # Ensure no partially prepared app is exposed as the configured runtime.
+        os.rename(app, destination)
+    save_json(directory / "native-runtime.json", {"app": str(destination), "supportLibrary": library})
+    return {
+        "configured": True,
+        "app": str(destination),
+        "version": check_payload(destination)["version"],
+        "build": check_payload(destination)["build"],
+    }
+
+
+def setup(directory, *, app=None, source=None, destination=None, gadget=None, wechat_url=WECHAT_URL):
+    require_macos()
+    private_directory(directory)
+    if app:
+        return register(app, directory)
+    destination = Path(destination or directory / "apps/WeChatBridge.app").expanduser().resolve()
+    if not source and destination.exists():
+        return register(destination, directory)
+    downloads = private_directory(directory / "downloads")
+    if gadget:
+        gadget_path = Path(gadget).expanduser().resolve()
+    else:
+        compressed = download(GADGET_URL, downloads / "gadget-17.8.0.dylib.xz", 64 * 1024**2, GADGET_SHA256)
+        gadget_path = downloads / "FridaGadget.dylib"
+        with lzma.open(compressed) as input_file, gadget_path.open("wb") as output:
+            # The compressed archive is pinned to a verified hash.
+            shutil.copyfileobj(input_file, output)
+    if source:
+        return prepare(source, destination, gadget_path, directory)
+    dmg = download(wechat_url, downloads / "WeChat.dmg", 1024**3)
+    with mounted_app(dmg, downloads) as stock:
+        # Verify Tencent's signature before trusting any downloaded executable.
+        execute(["/usr/bin/codesign", "--verify", "--deep", "--strict", stock])
+        details = subprocess.run(
+            ["/usr/bin/codesign", "-dv", "--verbose=4", str(stock)], capture_output=True, timeout=30
+        )
+        if b"TeamIdentifier=5A4RE8SF68" not in details.stderr:
+            raise AppError(
+                "invalid_vendor_signature",
+                "Downloaded app is not signed by the expected WeChat developer",
+                424,
+            )
+        return prepare(stock, destination, gadget_path, directory)
+
+
+def doctor(directory):
+    require_macos()
+    runtime = load_runtime(directory)
+    check_app(runtime["app"])
+    import frida
+
+    return {
+        "ready": True,
+        "app": runtime["app"],
+        "version": check_payload(Path(runtime["app"]))["version"],
+        "build": check_payload(Path(runtime["app"]))["build"],
+        "fridaVersion": frida.__version__,
+        "dataDir": str(directory),
+    }

wechat_cli/worker.py

@@ -0,0 +1,227 @@
+"""Authenticated local Gadget RPC transport. No UI automation; native chat reads and text sending."""
+
+import hashlib
+import json
+import os
+import pathlib
+import subprocess
+import sys
+import time
+
+import frida
+
+from .setup import check_payload
+
+package = pathlib.Path(__file__).resolve().parent / "assets"
+app = pathlib.Path(os.environ["WECHAT_NATIVE_APP"]).resolve()
+data_dir = pathlib.Path(os.environ["WECHAT_DATA_DIR"])
+config = json.loads((app / "Contents/Frameworks/FridaGadget.config").read_text())
+
+profile = check_payload(app)
+source = (package / "startup-notice.js").read_text() + "\n"
+source += "globalThis.WECHAT_NATIVE_PROFILE=" + json.dumps(profile) + ";\n"
+support = os.environ["WECHAT_NATIVE_SUPPORT"]
+if (
+    not support.startswith("native-reader-")
+    or not support.endswith(".dylib")
+    or pathlib.Path(support).name != support
+):
+    raise RuntimeError("invalid_native_runtime")
+source += "globalThis.WECHAT_NATIVE_SUPPORT=" + json.dumps(str(app / "Contents/Frameworks" / support)) + ";\n"
+source += (package / "native-agent.js").read_text()
+endpoint = "127.0.0.1:" + str(config["interaction"]["port"])
+session = device = script = child = None
+
+
+def emit(value):
+    print(json.dumps(value), flush=True)
+
+
+try:
+    digest = hashlib.sha256()
+    with (app / "Contents/Resources/wechat.dylib").open("rb") as binary:
+        for block in iter(lambda: binary.read(1048576), b""):
+            digest.update(block)
+    if digest.hexdigest() != profile["payloadSha256"]:
+        raise RuntimeError("native_payload_mismatch")
+    device = frida.get_device_manager().add_remote_device(endpoint, token=config["interaction"]["token"])
+    try:
+        session = device.attach("Gadget")
+    except frida.ServerNotRunningError:
+        snapshot = subprocess.run(
+            ["/bin/ps", "-axo", "pid=,comm="], check=True, capture_output=True, text=True, timeout=5
+        )
+        if any(
+            line.strip().split(None, 1)[-1] == "/Applications/WeChat.app/Contents/MacOS/WeChat"
+            for line in snapshot.stdout.splitlines()
+        ):
+            raise RuntimeError("stock_app_running")
+        child = subprocess.Popen(
+            [str(app / "Contents/MacOS/WeChat")],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+        for attempt in range(250):
+            if child.poll() is not None:
+                raise RuntimeError("native_copy_exited")
+            try:
+                session = device.attach("Gadget")
+                break
+            except (frida.TransportError, frida.ServerNotRunningError, frida.TimedOutError):
+                time.sleep(0.2)
+        else:
+            raise RuntimeError("native_bridge_timeout")
+    script = session.create_script(source)
+    script.load()
+    identity = script.exports_sync.startup_status()
+    if pathlib.Path(identity["executable"]).resolve() != (app / "Contents/MacOS/WeChat").resolve():
+        raise RuntimeError("native_process_identity_mismatch")
+    # Resume a Gadget-waiting app even after an earlier gateway startup timed out.
+    if child is not None or not identity.get("applicationRunning"):
+        try:
+            device.resume(identity["pid"])
+        except frida.InvalidOperationError:
+            pass
+    emit({"event": "ready"})
+    for line in sys.stdin:
+        request = json.loads(line)
+        try:
+            if request["method"] == "status":
+                result = script.exports_sync.status()
+            elif request["method"] == "probeTextProcessor":
+                result = script.exports_sync.probe_text_processor()
+            elif request["method"] == "prepareText":
+                result = script.exports_sync.prepare_text(
+                    request["params"]["chatId"], request["params"]["text"]
+                )
+            elif request["method"] == "sendText":
+                result = script.exports_sync.send_text(request["params"]["chatId"], request["params"]["text"])
+            elif request["method"] == "selfId":
+                result = script.exports_sync.self_id()
+            elif request["method"] == "importControl":
+                result = script.exports_sync.import_control(request["params"]["action"])
+            elif request["method"] == "migrationStatus":
+                result = script.exports_sync.migration_status()
+            elif request["method"] == "microphoneStatus":
+                result = script.exports_sync.microphone_status()
+            elif request["method"] == "armRecording":
+                result = script.exports_sync.arm_recording(request["params"]["chatId"])
+            elif request["method"] == "recordingResult":
+                result = script.exports_sync.recording_result()
+            elif request["method"] == "discardRecording":
+                result = script.exports_sync.discard_recording()
+            elif request["method"] in ["sendVoice", "prepareVoice"]:
+                result = script.exports_sync.send_voice(
+                    request["params"]["chatId"],
+                    request["params"]["dataBase64"],
+                    request["params"]["durationMs"],
+                    request["method"] == "prepareVoice",
+                )
+            elif request["method"] == "attachmentData":
+                result = script.exports_sync.attachment_data(
+                    request["params"]["chatId"], request["params"]["id"]
+                )
+            elif request["method"] == "voiceData":
+                result = script.exports_sync.voice_data(request["params"]["chatId"], request["params"]["id"])
+            elif request["method"] == "transcribeVoice":
+                result = script.exports_sync.transcribe_voice(
+                    request["params"]["chatId"], request["params"]["id"]
+                )
+            elif request["method"] == "extractImageText":
+                result = script.exports_sync.extract_image_text(request["params"]["dataBase64"])
+            elif request["method"] == "voiceTranscriptionResult":
+                result = script.exports_sync.voice_transcription_result(
+                    request["params"]["chatId"], request["params"]["id"]
+                )
+            elif request["method"] == "cachedMedia":
+                result = script.exports_sync.cached_media(request["params"]["hash"])
+            elif request["method"] == "listChats":
+                result = script.exports_sync.list_chats()
+            elif request["method"] in ["listMessages", "rawMessages"]:
+                result = script.exports_sync.list_messages(
+                    request["params"]["chatId"], request["params"]["limit"]
+                )
+            else:
+                raise RuntimeError("native_method_unimplemented")
+            emit({"id": request["id"], "result": result})
+        except Exception as error:
+            # Private diagnostic for native call failures. Never sent to callers
+            # and never logged with chat/secret values.
+            if isinstance(error, frida.core.RPCException):
+                description = str(error).split("\n")[0]
+                if request["method"] == "prepareVoice" or description.startswith(
+                    (
+                        "Error: access violation",
+                        "Error: invalid address",
+                        "TypeError:",
+                        "Error: native_",
+                        "Error: recursive_mutex",
+                    )
+                ):
+                    diagnostic = data_dir / "native-rpc-error.json"
+                    diagnostic.write_text(
+                        json.dumps({"method": request["method"], "description": description}) + "\n"
+                    )
+                    diagnostic.chmod(0o600)
+            code = "native_read_failed"
+            if isinstance(error, frida.core.RPCException):
+                for known in [
+                    "native_feature_unavailable",
+                    "native_invalid_media_id",
+                    "native_migration_busy",
+                    "native_migration_failed",
+                    "native_recording_unavailable",
+                    "native_recording_invalid",
+                    "native_recording_recipient_changed",
+                    "native_send_outcome_unknown",
+                    "native_voice_layout_unverified",
+                    "invalid_voice",
+                    "native_voice_prepare_failed",
+                    "native_ocr_not_ready",
+                    "native_ocr_failed",
+                    "native_invalid_ocr_image",
+                    "native_ocr_layout_unverified",
+                    "native_message_not_found",
+                    "invalid_media_type",
+                    "native_transcription_failed",
+                    "native_conversations_not_observed",
+                    "native_account_not_ready",
+                    "native_signature_mismatch",
+                    "native_module_missing",
+                    "native_chat_not_found",
+                    "native_message_layout_unverified",
+                    "native_services_not_ready",
+                    "native_message_service_not_ready",
+                    "native_task_context_unavailable",
+                    "native_send_failed",
+                    "native_invalid_recipient",
+                    "invalid_chat_id",
+                    "invalid_text",
+                    "native_bridge_busy",
+                    "native_session_service_not_ready",
+                    "native_session_layout_unverified",
+                ]:
+                    if known in str(error):
+                        code = known
+                        break
+            emit({"id": request["id"], "error": code})
+except Exception as error:
+    code = str(error) if isinstance(error, RuntimeError) else "native_bridge_unavailable"
+    emit({"event": "failure", "error": code})
+finally:
+    if script is not None:
+        try:
+            script.unload()
+        except Exception:
+            pass
+    if session is not None:
+        try:
+            session.detach()
+        except Exception:
+            pass
+    if device is not None:
+        frida.get_device_manager().remove_remote_device(endpoint)
+    # Keep the native app running for its normal login/session lifecycle.
+    # This transport never logs out or terminates the user's app on API close.