Déchiffrement et consultation des conversations WeChat 4.x (macOS + Windows)
Auto-vérification initiale (l'agent doit impérativement l'exécuter)
python3 -c "import platform; print(platform.system())"
claude mcp list 2>&1 | grep -q "wechat.*Connected" && echo "MCP_OK" || echo "MCP_MISSING"
test -f ~/.claude/skills/wechat-decrypt/key.txt && echo "KEY_OK" || echo "KEY_MISSING"
| Statut | Action |
|---|---|
MCP_MISSING | macOS bash setup.sh / Windows powershell -File setup.ps1, puis informer l'utilisateur de « redémarrer Claude Code » |
KEY_MISSING | Exécuter la procédure d'extraction de la clé correspondant à la plateforme (après extraction de la clé sur Windows, exécuter python scripts\windows\decrypt_all.py pour déchiffrer toute la base de données en texte clair) |
| Tout OK | Utiliser directement les outils MCP |
Auto-vérification Windows (PowerShell, en correspondance avec les trois points macOS ci-dessus) :
python -c "import frida, Crypto; print('DEPS_OK')" # Manquant → pip install frida pycryptodome Test-Path "$env:USERPROFILE\.claude\skills\wechat-decrypt\key_windows.txt" # Manquant → extract_raw_key.py pour extraire la clé Test-Path "$env:USERPROFILE\.claude\skills\wechat-decrypt\decrypted" # Manquant → decrypt_all.py pour déchiffrer toute la baseExécuter l'étape correspondante à ce qui manque : deps →
setup.ps1, key →extract_raw_key.py, base en clair →decrypt_all.py.
Ne pas sauter l'auto-vérification.
Règles de déclenchement pour l'agent
| Intention de l'utilisateur | Action |
|---|---|
| « Voir mes WeChat », « conversations récentes », « qui m'a écrit », « y a-t-il des messages » | MCP : wechat_recent_messages / wechat_chat_summary |
| « Chercher la conversation de X », « mentionné avec X » | MCP : wechat_search_messages |
| « Lister les discussions », « quels groupes » | MCP : wechat_list_chats |
| « Lire la conversation avec X » | MCP : wechat_read_chat |
| « Exporter la conversation avec X », « exporter X sur le bureau » | D'abord effectuer ① la vérification du modèle (ci-dessous), puis python3 scripts/common/export_chat.py <contact> [--start/--end/--year] [-o path] (sans date = tout l'historique ; si le modèle est présent, transcription par défaut, --no-transcribe pour désactiver ; le résultat de la transcription vocale est mis en cache dans voice_cache.json, les exportations suivantes sont instantanées) |
| « Transcrire le message vocal de X », « voix en texte », « exporter la voix en texte » | python3 scripts/common/export_chat.py <contact> --transcribe, ou séparément python3 scripts/common/transcribe_db.py <contact> -o map.json |
| « WeChat a été mis à jour », « refaire le cracking », « la clé n'est plus valide » | Exécuter la procédure d'extraction de la clé correspondant à la plateforme ci-dessous |
① Prérequis à l'exportation – Vérification du modèle de transcription vocale (exécutée par défaut)
Avant d'exporter ou de transcrire toute conversation pouvant contenir des messages vocaux, vérifier si le modèle est présent :
test -d ~/.cache/huggingface/hub/models--mlx-community--whisper-large-v3-mlx && echo MODEL_OK || echo MODEL_MISSING
| Résultat | Action |
|---|---|
MODEL_OK | L'exportation active la transcription vocale par défaut (le script détecte le modèle et transcrit automatiquement, sans --transcribe ; ajouter --no-transcribe seulement si l'utilisateur le demande explicitement) |
MODEL_MISSING | Demander d'abord à l'utilisateur s'il souhaite l'installer (whisper-large-v3 ~3 Go, téléchargement unique hors ligne). S'il installe → ajouter --transcribe (téléchargement et transcription automatiques lors de la première exécution) ; sinon → exportation normale, les messages vocaux sont conservés sous forme de [Audio] |
Le script intègre déjà cette logique (modèle présent → transcription par défaut, absent → laisse [Audio] et affiche une suggestion). Mais quand MODEL_MISSING, l'agent doit demander activement à l'utilisateur, ne pas télécharger 3 Go sans autorisation.
Outils MCP (nom d'enregistrement wechat)
| Outil | Paramètres | Utilisation |
|---|---|---|
wechat_list_chats | Aucun | Toutes les discussions (nom du groupe et remarques déjà résolus) |
wechat_read_chat | contact, limit(50), days(7) | Conversation spécifique |
wechat_search_messages | keyword, days(30), limit(50) | Recherche plein texte |
wechat_recent_messages | days(3), limit(100) | Messages récents |
wechat_chat_summary | days(3) | Résumé structuré + tâches à faire |
[Moi] = messages envoyés par l'utilisateur, [Contact] = messages envoyés par le contact.
Transcription vocale (entièrement automatique)
Les messages vocaux (local_type=34) sont stockés au format SILK v3 dans media_0.db sous VoiceInfo.voice_data, alignés par svr_id == server_id. Pipeline : extraction directe depuis VoiceInfo → décodage SILK→wav via pilk → transcription via whisper large-v3 → réinjection par server_id. Entièrement automatique, par lots, hors ligne, sans nécessiter BlackHole, lecture audio ou redémarrage. Comportement par défaut : si le modèle est déjà en cache, transcription automatique ; --transcribe force la transcription (inclut le téléchargement initial du modèle ~3 Go, mis en cache dans ~/.cache/huggingface/) ; --no-transcribe désactive la transcription. Le backend est automatiquement sélectionné selon la plateforme : macOS = mlx-whisper (Apple Silicon), Windows = faster-whisper (CPU int8, téléchargement à la demande) ; l'ancienne solution BlackHole+Swift se trouve dans le dépôt de développement langlobal.
Entrée en ligne de commande (cœur logique ; MCP est une façade optionnelle)
Le cœur logique réside dans scripts/common/query.py (ligne de commande), les outils MCP dans server.py ne font que rediriger vers celui-ci. Pour un appel par l'agent, recommander l'utilisation de --json pour obtenir une sortie structurée (analyse fiable, insensible à la mise en forme du texte) ; pour le débogage humain, ne pas utiliser --json et lire le texte.
SKILL_DIR=~/.claude/skills/wechat-decrypt
python3 "$SKILL_DIR/scripts/common/query.py" list
python3 "$SKILL_DIR/scripts/common/query.py" recent -d 3 --json # agent : utiliser --json
python3 "$SKILL_DIR/scripts/common/query.py" search mot_clé --json
# Sous-commandes : list / read <contact> / search <kw> / recent / summary / stats / media / openfile
Système de clés (commun aux deux plateformes)
- Clé brute (Raw Key) : 64 caractères hexadécimaux, indépendante par appareil (WeChat 4.0 : pour un même compte, la raw key sur macOS et Windows est différente, non interchangeable) ; tant que WeChat n'est pas mis à jour, elle reste valide.
- Formule de dérivation :
PBKDF2-HMAC-SHA512(raw_key, db_file_salt, 256000) → 32 bytes - Paramètres SQLCipher :
PRAGMA key = "x'<derived>'"; PRAGMA kdf_iter = 1; PRAGMA cipher_compatibility = 4; PRAGMA cipher_page_size = 4096;
Chemins des bases de données
| Plateforme | Chemin |
|---|---|
| macOS | ~/Library/Containers/com.tencent.xinWeChat/.../xwechat_files/{wxid}/db_storage/ |
| Windows | ~/Documents/xwechat_files/{wxid}/db_storage/ |
Extraction de la clé
macOS
Procédure d'exécution par l'agent
- Vérifier la resignature :
codesign -dv /Applications/WeChat.app 2>&1 | grep -q "Signature=adhoc" || echo "NEED_RESIGN"NEED_RESIGN→ informer l'utilisateur d'exécutersudo codesign --force --deep --sign - /Applications/WeChat.app
- Exécuter
bash ~/.claude/skills/wechat-decrypt/scripts/macos/extract_key.sh - Le script lance WeChat → demander à l'utilisateur de se connecter par QR code → après connexion, la clé est écrite automatiquement dans
key.txt - Vérification :
test -f ~/.claude/skills/wechat-decrypt/key.txt && echo "OK" - Après extraction, informer obligatoirement l'utilisateur de restaurer la signature : la resignature adhoc est une opération destructive unidirectionnelle qui écrase la signature originale de Tencent, provoquant des demandes d'autorisation répétées pour les captures d'écran et l'accès aux données de WeChat. codesign ne peut pas restaurer la signature tierce ; seule une réinstallation de WeChat peut la rétablir. L'historique des conversations se trouve dans un répertoire de conteneur indépendant (
~/Library/Containers/com.tencent.xinWeChat/), la réinstallation de/Applications/WeChat.appn'a aucun impact. Une fois la clé extraite, la consultation quotidienne des messages est en lecture seule sur la base de données, la resignature n'est plus nécessaire.
Informations clés
- La resignature n'est nécessaire qu'au moment de l'extraction de la clé ; une fois l'extraction terminée, réinstaller WeChat pour restaurer la signature.
- Les demandes d'autorisation répétées sont un symptôme de l'état adhoc de la signature de WeChat, et ne sont pas causées par Claude Code/MCP.
- La clé est indépendante par appareil (chaque appareil a une clé différente, non interchangeable) ; tant que WeChat n'est pas mis à jour, elle reste valide et n'a pas besoin d'être extraite à nouveau.
Principe
La version macOS de WeChat 4.x n'utilise pas sqlite3_key (cette fonction de SQLite système sur macOS est vide), mais passe par la couche de chiffrement unifiée WCDB qui appelle CCKeyDerivationPBKDF (CommonCrypto). Frida utilise Module.findGlobalExportByName (API Frida 17.x+) pour hooker cette fonction et capturer le paramètre de mot de passe lorsque passwordLen=32, rounds>1000, dkLen=32 (la clé brute).
Windows (résolu : extraction de la clé → déchiffrement → lecture, capacités équivalentes à macOS)
État actuel (testé avec UTM le 06/06/2026) : extraction de la clé → déchiffrement complet de la base → MCP/exportation/transcription vocale, mêmes capacités que macOS. message_0 a décodé 99 discussions / 1384 messages. Procédure complète dans docs/2026-06-06-windows-raw-key-journey.md.
Procédure d'exécution par l'agent
- Connecter WeChat
- Extraire la clé :
python scripts\windows\extract_raw_key.py→ suivre les instructions et redémarrer WeChat manuellement sur le bureau (obligatoire ; un lancement via schtasks/SSH crée une coquille vide qui ne lit pas la base de données) → le script effectue automatiquement un race-attach + hook sha512 pour capturer la raw key + vérification, et l'écrit danskey_windows.txt - Déchiffrer toute la base :
python scripts\windows\decrypt_all.py→ utilise la raw key pour déchiffrer toutes les bases dedb_storagedansdecrypted\{wxid}_<device>\db_storage\(texte clair) - Redémarrer Claude Code → les outils MCP, l'exportation et la transcription vocale sont identiques à macOS (server/export/transcribe utilisent
DB_BACKEND="sqlite3"pour lire la base en clair ; la transcription vocale utilise faster-whisper)
Pour la vérification/débogage d'une seule base : scripts\windows\decrypt_read.py <raw_key> (déchiffre uniquement message_0 pour vérification).
Principe d'extraction de la clé (hook de l'entrée sha512 + ipad HMAC)
Essentiel : la raw key/K1 est protégée de manière multiple en mémoire (clés de tour AES-NI / effacement après utilisation / mémoire sécurisée, les attaques par force brute en mémoire échouent toutes), mais la clé dérivée SQLCipher passe par PBKDF2-HMAC-SHA512, et au moment de la construction du bloc ipad HMAC, la clé est en clair key XOR 0x36 (les 96 derniers octets sont 0x36) — ce qui contourne toutes les protections et permet de la capturer directement.
extract_raw_key.py est autonome : localisation automatique de l'entrée sha512 (recherche de la constante K 0x428a2f98d728ae22 → xref → désassemblage, sans adresse codée en dur, fonctionne même si la version de WeChat change) + race-attach (avant l'ouverture de la base) + hook de l'entrée (rdx = bloc d'entrée) + détection ipad + vérification automatique (PBKDF2→AES page1 = raw key universelle / AES direct = K1 pour une seule base). L'exécution de PBKDF2(raw,salt) expose la raw key ; le page-MAC en cours d'exécution n'expose que la mac_key (inutile) → il faut impérativement un race-attach pour capturer le démarrage.
Frida sous émulation ARM (xtajit traduit x64) peut hooker les fonctions x64 internes de WeChat (vérifié 11,27 millions de fois) ; en l'absence de compatibilité spawn, utiliser race-attach.
- Chemin des données :
C:\Users\<utilisateur>\Documents\xwechat_files\{wxid}_<device>\db_storage\.wechat-dump-rsa été bloqué par DMCA, cette méthode le remplace. - L'ensemble des scripts de développement (localisation/force brute/enregistrement des échecs) se trouve dans le dépôt de développement langlobal ; seuls
extract_raw_key.py+decrypt_all.pysont nécessaires pour l'exécution.
Distribution et installation
Copier tout le répertoire de la compétence. Le destinataire exécute :
macOS : bash setup.sh
Windows : powershell -File setup.ps1
key.txt, contacts.json, all_keys.json, voice_cache.json sont des données personnelles, à supprimer avant distribution (déjà dans .gitignore).
Liste des fichiers
~/.claude/skills/wechat-decrypt/ # Unité d'exécution ; l'ensemble du développement (tests/docs/scripts de résolution/legacy) se trouve dans le dépôt de développement langlobal
├── server.py config.py crypto.py db.py contacts.py message.py ← Cœur MCP (6 fichiers), db.py avec double backend
├── scripts/
│ ├── common/ ← Multi-plateforme : export_chat (exportation+transcription) transcribe_db voice_decode sqlcipher_decrypt read_doc export_media verify_key
│ ├── macos/ ← extract_key.sh + hook_pbkdf.js (CCKeyDerivationPBKDF)
│ └── windows/ ← extract_raw_key.py (extraction de clé autonome) decrypt_all.py (déchiffrement complet → texte clair) decrypt_read.py (vérification d'une seule base)
├── setup.sh / setup.ps1 ← Installation par plateforme
├── SKILL.md README.md LICENSE
├── key.txt key_windows.txt ← .gitignore
└── contacts.json ← .gitignore
Dépendances : macOS python global (mcp/frida/cryptography/pilk/mlx-whisper/zstd) ; Windows (mcp/frida/pycryptodome/pilk/faster-whisper/zstandard). Cache du modèle vocal ~/.cache/huggingface/.