recurse

IDE de engenharia reversa agêntica com um desassemblador multi-arquitetura em Rust puro, descompilador nativo, depurador e agente LLM para análise de binários e trabalho em CTF.

recurse-agent é apenas o agente; a análise estática vive em recurse-static e o depurador em recurse-debug, então o agente não puxa nenhum código de sistema que não utiliza. Nenhum crate depende do Tauri, e cada um compila/testa de forma independente; recurse-eval executa o agente de forma headless. Todos são membros do workspace, então um Cargo.lock e um target/ cobrem todo o repositório.

Funcionalidades

• Workspace estilo Cursor: lista de funções, abas de disassembly/strings/imports, grafo CFG, e uma barra lateral de chat com agente (alterne com o botão Chat ou Ctrl+L)
• Página de Recon: informações do binário, hashes MD5/SHA1/SHA256/CRC32, entropia, bibliotecas vinculadas, um relatório de hardening autocontido (RELRO / PIE / NX / canary / FORTIFY / RPATH — sem checksec externo), e contagens de análise
• Renomeie funções a partir da lista (duplo clique ou o botão ✎); os nomes persistem no SQLite e aparecem na lista de funções, anotações de disassembly e para o agente
• Agente fundamentado: cada endereço é um objeto clicável (lista de funções, nós do grafo, xrefs, anotações do decompilador) — não texto colado que o modelo pode alucinar
• Sessão de análise ao vivo em qualquer binário — incluindo arquivos sem extensão
• Memória de projeto persistente em SQLite com recuperação FTS5/BM25 — renomeações, descobertas e notas sobrevivem ao /clear e à reabertura, e alimentam a próxima sessão
• Núcleo headless (recurse-agent) com rastreamento de depuração por turno; o mesmo loop do agente roda na UI e no harness de avaliação
• Agente LLM apoiado por um endpoint compatível com OpenAI (OpenRouter por padrão) com um seletor de modelo; conduz a sessão diretamente (disasm, xrefs, strings, imports, decompile)
• UI com tema escuro por padrão construída com Tailwind CSS v4 + shadcn/ui
• Operação lift: eleva uma função a uma IL de desobfuscação estilo VTIL e executa passes de propagação/dobramento/eliminação de código morto/resolução de branches em toda a rotina — útil quando o disassembly se parece com um dispatcher de VM ou cadeia de predicados opacos (veja docs/vtil-lift.md)
• Decompilador nativo: decompile renderiza pseudocódigo similar a C (if/while estrutural, cobertura total de instruções) do mesmo pipeline recurse-vtil — sem ferramenta externa, sem r2 necessário
• Servidor recurse-mcp autônomo: o mesmo Engine sobre MCP stdio para qualquer agente compatível com MCP (Claude Code, Cursor, Claude Desktop, …) — sem Tauri, sem licença IDA, sem ponte Python (veja docs/recurse-mcp.md)

Backends de análise

A análise passa por um único trait Engine (crates/recurse-static/src/engine.rs), então o motor é uma escolha, não uma dependência rígida:

• native (padrão) — parsing ELF/PE/Mach-O em Rust puro e disassembly multi-arquitetura (object + capstone): x86/x86-64, ARM, AArch64, MIPS, PowerPC, RISC-V, SPARC, SystemZ, M68K, BPF. Sem processo filho, sem ferramenta externa, sem LGPL na build. Inclui um decompilador (pipeline lift → optimize → structure do recurse-vtil — veja docs/vtil-lift.md) e uma operação lift para desobfuscação estilo VTIL.
• r2 (radare2) — suportado como alternativa opt-in para instalações que desejam seu próprio decompilador mais completo ou um console bruto. Instale o r2 e selecione-o como motor; ele roda como um processo separado e nunca é vinculado ou empacotado com o Recurse.

Escolha pelo menu de configurações, pela variável de ambiente RECURSE_BACKEND, ou pela configuração armazenada. O agente recebe uma ferramenta analyze neutra em relação ao backend (functions, disasm, graph, lift, decompile, xrefs, strings, imports, info, além de raw para o console do motor) — filtrada para as operações que o motor ativo realmente suporta, então raw (o nativo não tem console) só é anunciado quando disponível. A UI consome tipos de resultado canônicos, não o JSON de nenhum motor. Veja docs/backends.md para o trait, as escolhas de crate e a justificativa de licenciamento. Abrir um binário grande é rápido porque a análise é preguiçosa — a descoberta indexa funções de forma barata e os blocos básicos só são decodificados quando uma função é visualizada; veja docs/lazy-analysis.md.

Por que não apenas MCP-para-IDA / fazer na louca no Claude Code?

Acoplar um servidor MCP ao IDA/Ghidra, ou colar disassembly em um agente CLI, funciona para CTFs de 5 funções e desmorona em binários reais. O Recurse é um ambiente feito sob medida, não um wrapper de chatbot:

• Modelo de mundo do binário, não raspagem de texto. Funções, xrefs, strings e o CFG são estado de primeira classe compartilhado pelo agente e pela UI. Sem reparsear dumps de pdF para o contexto a cada turno, sem 0x401023s inventados.
• Verificação > geração. Em RE não existe npm test — a verificação é visual. Renomeações do agente se propagam para a lista de funções, grafo e decompilação instantaneamente, então um humano confirma ou rejeita com um clique.
• Feito para escala. Malware real tem 10k funções. Ferramentas sob demanda + memória persistente superam despejar decompilações completas até o contexto estourar.
• Motor agenciável. Um motor scriptável e canalizável significa que agentes podem rodar 100 turnos, bifurcar, resetar e comparar — e você pode realmente entregá-lo. O motor nativo padrão não precisa de nenhuma ferramenta externa.
• Seguro para malware por padrão. Local-first, roteamento BYO-key/OpenRouter, e um caminho para modelos offline — sem exfiltração forçada de amostras para um chatbot na nuvem.

Pré-requisitos

1. Toolchains principais

Verifique:

2. Motor de análise

O motor native padrão é Rust puro — nada para instalar. Para usar o r2 (radare2) como motor de análise, instale-o e selecione-o (o menu de configurações, ou RECURSE_BACKEND=r2); o Recurse conduz o binário r2 no seu PATH. O r2 é opcional, nunca é exigido pela build, e nunca é distribuído com o Recurse — traga sua própria instalação.

3. Dependências de sistema do Tauri no Linux

Debian/Ubuntu/Pop!_OS:

Outras distros: siga os pré-requisitos oficiais do Tauri.

4. Decompilador

Ambos os motores fornecem um: o native renderiza pseudocódigo via recurse-vtil (lift → optimize → structure — veja docs/vtil-lift.md), nada para instalar; o r2 pode fornecer seu próprio decompilador mais completo quando seu plugin está instalado.

Build

As dependências do aplicativo ficam em tauri/; o Rust vem da raiz do workspace. O just envolve ambos (veja just --list), ou conduza-os diretamente.

Desenvolvimento

Isso inicia o servidor de desenvolvimento Vite e abre a janela do Tauri. A primeira compilação leva um tempo (build Rust); as seguintes são rápidas.

Binário de produção

O pacote fica em target/release/bundle/ (target do workspace):

• .deb / .rpm / .AppImage para Linux
• binário autônomo em target/release/recurse

No Arch e outras distros rolling, a etapa do AppImage precisa de uma correção local única (o linuxdeploy upstream está atrasado em relação ao toolchain da distro) — veja docs/linux-appimage-build.md.

Apenas o frontend (sem shell desktop)

Verificações de qualidade

Comandos diretos equivalentes: cargo clippy --workspace --all-targets, cargo test --workspace na raiz; npm run lint / npm run format / npm run build dentro de tauri/.

Avaliações

O agente é avaliado de forma headless contra tiers de crackme (veja crates/recurse-eval/README.md). Os tiers são YAML: filtros de seleção sobre o dataset, ou uma lista congelada de hexids, mais parâmetros de execução.

eval-run é um binário, não um teste, então cargo test nunca gasta dinheiro ou tempo com o agente. Endpoint + chave vão em crates/recurse-eval/.env (copie .env.example). Cada execução escreve target/eval-traces/<tier>/<backend>/run.log (a narrativa completa) mais um <hexid>.json por tarefa com a conversa completa por turno. O backend (native ou r2) é selecionável por execução — veja o README de avaliação.

LLM do agente

O painel de chat do agente roda em qualquer endpoint compatível com OpenAI. Configure a chave de API, URL base e modelo no diálogo Model & Provider do aplicativo (persistido em ~/.recurse/recurse.db), ou via env:

Modelos locais / URL base personalizada

Aponte o agente para qualquer servidor compatível com OpenAI local ou auto-hospedado — Ollama, LM Studio, llama-server do llama.cpp, vLLM, text-generation-webui, ou um gateway remoto. Defina a Base URL no diálogo (uma URL base simples ou uma rota completa /chat/completions funcionam) e escolha um modelo do catálogo desse servidor, ou digite um id de modelo (llama3.1:8b, qwen2.5-coder, …) diretamente:

Endpoints locais não precisam de chave de API: quando a chave está em branco, a requisição é enviada sem cabeçalho Authorization, e a lista de modelos é lida do próprio {base}/models do endpoint. Um endpoint personalizado é tratado como configurado sem chave, então o chat funciona imediatamente contra um servidor local.

Sem credenciais, ele recorre a um cliente echo para que a integração permaneça exercitável.

O agente vê o contexto ao vivo do binário (arch, bits, tipo) e pode conduzir toda a superfície de análise (disassembly, xrefs, strings, imports, decompilação) através da sessão.

Licença

Apache-2.0 — © 2026 Aayush Khanna