Recurse

Environnement d'ingénierie inverse agentique — une application de bureau de la classe Ghidra dans l'esprit de « Cursor pour l'ingénierie inverse ». Construite avec Tauri 2 (frontend React + TypeScript) au-dessus d'un backend d'analyse enfichable. Par défaut, il s'agit d'un moteur natif en Rust pur — aucun processus externe, aucune dépendance copyleft, multi-architecture via Capstone. Vous pouvez également exécuter l'analyse via r2 (radare2) ou IDA Pro : sélectionnez l'un ou l'autre moteur, et toute l'application — outils de l'agent et interface — le pilote à la place. L'outil de l'agent et l'interface sont agnostiques vis-à-vis du backend — voir docs/backends.md.

Organisation du dépôt

Espace de travail Cargo à la racine ; l'application de bureau est l'un de ses paquets.

tauri/                   desktop app (Tauri + React)
  src/                     React frontend
  src-tauri/               Tauri Rust backend (engine sessions, agent wiring)
  package.json             app scripts (Vite, Vitest, Tauri CLI)
crates/
  recurse-agent/              agent framework: LLM loop, tool runtime, SQLite memory
  recurse-static/          static analysis: ELF/PE/Mach-O parsing, multi-arch disassembly,
                           CFG and cross-reference recovery, the engine seam
  recurse-vtil/            VTIL-inspired de-obfuscation/de-virtualization IL, lifter, optimizer
  recurse-mcp/             standalone headless MCP server (stdio) over the engine — no Tauri, no IDA
  recurse-debug/           cross-platform debugger (ptrace/Mach/Win32, breakpoints, stepping)
  recurse-eval/            headless eval harness (YAML-configured tiers)
justfile                 single entry point for both halves

recurse-agent n'est que l'agent ; l'analyse statique réside dans recurse-static et le débogueur dans recurse-debug, ainsi l'agent n'intègre aucun code système qu'il n'utilise pas. Aucun crate ne dépend de Tauri, et chacun se compile/se teste de manière autonome ; recurse-eval pilote l'agent en mode headless. Tous sont membres du workspace, donc un seul Cargo.lock et un seul target/ couvrent l'ensemble du dépôt.

Fonctionnalités

• Espace de travail de style Cursor : liste des fonctions, onglets désassemblage/chaînes/imports, graphe CFG, et une barre latérale d'agent conversationnel (basculez avec le bouton Chat ou Ctrl+L)
• Page Recon : informations sur le binaire, hachages MD5/SHA1/SHA256/CRC32, entropie, bibliothèques liées, un rapport de durcissement autonome (RELRO / PIE / NX / canary / FORTIFY / RPATH — sans checksec externe), et les décomptes d'analyse
• Renommez les fonctions depuis la liste (double-clic ou le bouton ✎) ; les noms persistent dans SQLite et apparaissent dans la liste des fonctions, les annotations de désassemblage, et pour l'agent
• Annotez depuis l'en-tête de fonction du listing : cliquez sur le nom d'une variable pour la nommer, ou sur une cellule undefinedN pour lui donner un type. Un type de retour que vous définissez est affiché dans la ligne de signature de l'en-tête. Les deux persistent dans SQLite, indexés par fonction, et effacer une cellule la rétablit à ce que disent les instructions
• Agent ancré : chaque adresse est un objet cliquable (liste des fonctions, nœuds du graphe, xrefs, annotations du décompilateur) — pas du texte collé que le modèle peut halluciner
• Session d'analyse en direct sur n'importe quel binaire — y compris les fichiers sans extension
• Mémoire de projet persistante dans SQLite avec récupération FTS5/BM25 — renommages, découvertes et notes survivent à /clear et à la réouverture, et amorcent la session suivante
• Cœur headless (recurse-agent) avec traçage de débogage par tour ; la même boucle d'agent s'exécute dans l'UI et dans le harnais d'évaluation
• Agent LLM adossé à un point de terminaison compatible OpenAI (OpenRouter par défaut) avec un sélecteur de modèle ; pilote directement la session (disasm, xrefs, chaînes, imports, décompilation)
• UI à thème sombre par défaut construite avec Tailwind CSS v4 + shadcn/ui
• Opération lift : élève une fonction vers un IL de désobfuscation de style VTIL et exécute des passes de propagation/pliage/élimination de code mort/résolution de branches sur toute la routine — utile lorsque le désassemblage ressemble à un dispatcheur de VM ou à une chaîne de prédicats opaques (voir docs/vtil-lift.md)
• Décompilateur natif : decompile produit du pseudocode de type C (if/while structurés, couverture totale des instructions) à partir du même pipeline recurse-vtil — aucun outil externe, pas besoin de r2
• Serveur recurse-mcp autonome : le même Engine via MCP stdio pour tout agent compatible MCP (Claude Code, Cursor, Claude Desktop, …) — pas de Tauri, pas de licence IDA, pas de pont Python (voir docs/recurse-mcp.md)

Backends d'analyse

L'analyse passe par un unique trait Engine (crates/recurse-static/src/engine.rs), ainsi le moteur est un choix, pas une dépendance obligatoire :

• native (par défaut) — analyse ELF/PE/Mach-O en pur Rust et désassemblage multi-architecture (object + capstone) : x86/x86-64, ARM, AArch64, MIPS, PowerPC, RISC-V, SPARC, SystemZ, M68K, BPF. Aucun processus enfant, aucun outil externe, aucune LGPL dans la compilation. Inclut un décompilateur (pipeline lift → optimisation → structuration de recurse-vtil — voir docs/vtil-lift.md) et une opération lift pour la désobfuscation de style VTIL.
• r2 (radare2) — pris en charge comme alternative opt-in pour les installations qui veulent son propre décompilateur plus complet ou une console brute. Installez r2 et sélectionnez-le comme moteur ; il s'exécute comme un processus séparé et n'est jamais lié ni intégré à Recurse.
• IDA Pro (ida) — analyse headless opt-in et décompilation Hex-Rays via idat.

Sélectionnez-le via le menu des paramètres, la variable d'environnement RECURSE_BACKEND, ou la configuration enregistrée. L'agent dispose d'un outil analyze neutre vis-à-vis du backend (functions, disasm, graph, lift, decompile, xrefs, strings, imports, info, plus raw pour la console du moteur) — filtré selon les opérations réellement prises en charge par le moteur actif, de sorte que raw (le natif n'a pas de console) n'est proposé que lorsqu'il est disponible. L'interface consomme des types de résultats canoniques, et non le JSON d'un moteur quelconque. Voir docs/backends.md pour le trait, les choix de crates et la justification des licences. L'ouverture d'un binaire volumineux est rapide car l'analyse est paresseuse — la découverte indexe les fonctions à moindre coût et les blocs de base ne sont décodés que lorsqu'une fonction est consultée ; voir docs/lazy-analysis.md.

Pourquoi ne pas simplement brancher MCP sur IDA / tout balancer dans Claude Code ?

Greffer un serveur MCP sur IDA/Ghidra, ou coller du désassemblage dans un agent CLI, fonctionne pour des CTF à 5 fonctions et s'effondre sur de vrais binaires. Recurse est un environnement conçu sur mesure, pas un wrapper de chatbot :