Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
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. | Kitploit
Ferramentas/GitHubGitHub/recurse-labs/recurse
Análise EstáticaAnálise Dinâmica (Sandboxing)Engenharia ReversaDepuradoresAnálise de MalwareCTFAnálise de BináriosAprendizado e EducaçãoEngenharia Reversa Assistida por IASegurança de IA
GitHub
31129437há 19 diasRevisado pelo Kitploit
recurse-labs/recurse

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.

Ver RepositórioSite
Compartilhar

Recurse

Ambiente de engenharia reversa agêntica — um aplicativo desktop da classe Ghidra no espírito de "Cursor para engenharia reversa". Construído com Tauri 2 (frontend React + TypeScript) sobre um backend de análise plugável. O padrão é um motor nativo em Rust puro — sem processo externo, sem dependência copyleft, multi-arquitetura via Capstone. Você também pode executar a análise através do r2 (radare2) ou do IDA Pro: selecione qualquer um dos motores, e todo o aplicativo — ferramentas do agente e UI — passa a utilizá-lo. A ferramenta do agente e a UI são agnósticas ao backend — consulte docs/backends.md.

Recurse demo

Estrutura do repositório

Workspace Cargo na raiz; o aplicativo desktop é um pacote dentro dele.

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 é apenas o agente; a análise estática vive em recurse-static e o depurador em recurse-debug, portanto o agente não inclui código de sistema que não utiliza. Nenhum crate depende do Tauri, e cada um compila/testa de forma autónoma; recurse-eval controla o agente sem interface. Todos são membros do workspace, portanto um único Cargo.lock e um único target/ cobrem todo o repositório.

Funcionalidades

  • Workspace ao estilo Cursor: lista de funções, separadores de desassemblagem/strings/imports, grafo CFG, e uma barra lateral de agente de chat (alternar com o botão Chat ou Ctrl+L)
  • Página de Recon: informação do binário, hashes MD5/SHA1/SHA256/CRC32, entropia, bibliotecas ligadas, um relatório de hardening autónomo (RELRO / PIE / NX / canary / FORTIFY / RPATH — sem checksec externo), e contagens de análise
  • Renomear funções a partir da lista (duplo clique ou o botão ✎); os nomes persistem em SQLite e aparecem na lista de funções, nas anotações da desassemblagem e para o agente
  • Anotar a partir do cabeçalho da função na listagem: clicar no nome de uma variável para a nomear, ou numa célula undefinedN para lhe atribuir um tipo. Um tipo de retorno definido é mostrado na linha de assinatura do cabeçalho. Ambos persistem em SQLite, indexados por função, e limpar uma célula reverte-a para o que as instruções indicam
  • Agente fundamentado: cada endereço é um objeto clicável (lista de funções, nós do grafo, xrefs, anotações do descompilador) — não texto colado que o modelo possa alucinar
  • Sessão de análise em direto sobre qualquer binário — incluindo ficheiros sem extensão
  • Memória de projeto persistente em SQLite com recuperação FTS5/BM25 — renomeações, descobertas e notas sobrevivem a /clear e à reabertura, e alimentam a sessão seguinte
  • Núcleo sem interface (recurse-agent) com rastreio de depuração por turno; o mesmo ciclo do agente corre na UI e no harness de avaliação
  • Agente LLM suportado por um endpoint compatível com OpenAI (OpenRouter por omissão) com um seletor de modelo; controla a sessão diretamente (disasm, xrefs, strings, imports, decompile)
  • UI com tema escuro por omissão, construída com Tailwind CSS v4 + shadcn/ui
  • Operação lift: eleva uma função para uma IL de desofuscação ao estilo VTIL e executa passagens de propagação/dobragem/eliminação de código morto/resolução de ramos sobre toda a rotina — útil quando a desassemblagem se assemelha a um dispatcher de VM ou a uma cadeia de predicados opacos (ver docs/vtil-lift.md)
  • Descompilador nativo: decompile gera pseudocódigo semelhante a C (if/while estruturado, cobertura total das instruções) a partir do mesmo pipeline recurse-vtil — sem ferramenta externa, sem necessidade de r2
  • 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 (ver docs/recurse-mcp.md)

Backends de análise

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

  • native (por omissão) — parsing ELF/PE/Mach-O em Rust puro e desassemblagem 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 compilação. Inclui um descompilador (o pipeline lift → otimização → estrutura do recurse-vtil — ver docs/vtil-lift.md) e uma operação lift para desofuscação ao estilo VTIL.
  • r2 (radare2) — suportado como alternativa opt-in para instalações que pretendam o seu próprio descompilador mais completo ou uma consola em bruto. Instale o r2 e selecione-o como motor; corre como um processo separado e nunca é ligado ou incluído no Recurse.
  • IDA Pro (ida) — análise headless opt-in e descompilação Hex-Rays via idat.

Escolha no 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, de modo que 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. Consulte docs/backends.md para a trait, as escolhas de crate e a justificativa de licenciamento. Abrir um binário grande é rápido porque a análise é lazy — a descoberta indexa funções de forma barata e os blocos básicos só são decodificados quando uma função é visualizada; consulte docs/lazy-analysis.md.

Por que não apenas MCP-to-IDA / fazer tudo no Claude Code?

Acoplar um servidor MCP ao IDA/Ghidra, ou colar desassembly em um agente de 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:

Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Sem dados de popularidade ainda.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →