ida-pro-mcp

Assistente de engenharia reversa alimentado por IA que conecta o IDA Pro a modelos de linguagem por meio do MCP.

Nota: Isso requer ter o idalib ativado globalmente e o uv instalado:

Instalação (Claude Code)

Para instalar a versão mais recente do IDA Pro MCP no Claude Code:

Instalação (Codex)

Para instalar a versão mais recente do IDA Pro MCP no Codex:

Instalação (Kimi Code)

Para instalar a versão mais recente do IDA Pro MCP no Kimi Code, execute este comando de barra no chat:

Isso instala o servidor MCP idalib e a skill idapython. Os plugins são copiados para $KIMI_CODE_HOME/plugins/managed/, portanto o uv deve estar no seu PATH. A primeira sessão após a instalação é mais lenta, porque o uv resolve as dependências antes de o servidor responder.

Instalação (GUI)

Nota: o plugin MCP não é mais recomendado e eventualmente será descontinuado. Use idalib-mcp em seu lugar.

Se você quiser configurar o servidor MCP manualmente pela GUI do IDA:

Configure os servidores MCP e instale o plugin do IDA:

Importante: Certifique-se de reiniciar completamente o IDA e o seu cliente MCP para que a instalação tenha efeito. Alguns clientes (como o Claude) são executados em segundo plano e precisam ser encerrados pelo ícone da bandeja do sistema.

Engenharia de Prompt

LLMs são propensos a alucinações e você precisa ser específico ao criar seus prompts. Para engenharia reversa, a conversão entre inteiros e bytes é especialmente problemática. Abaixo está um exemplo mínimo de prompt; sinta-se à vontade para iniciar uma discussão ou abrir uma issue se tiver bons resultados com um prompt diferente:

Este prompt foi apenas o primeiro experimento. Compartilhe se você encontrou maneiras de melhorar o resultado!

Outro prompt de @can1357:

Transmissão ao vivo discutindo prompts e mostrando análise de malware do mundo real:

Dicas para Melhorar a Precisão dos LLMs

Os Modelos de Linguagem de Grande Porte (LLMs) são ferramentas poderosas, mas às vezes podem ter dificuldades com cálculos matemáticos complexos ou apresentar "alucinações" (inventar fatos). Certifique-se de dizer ao LLM para usar a ferramenta MCP int_convert; talvez você também precise do math-mcp para determinadas operações.

Outra coisa a ter em mente é que os LLMs não terão um bom desempenho em código ofuscado. Antes de tentar usar um LLM para resolver o problema, explore o binário e gaste algum tempo removendo (automaticamente) os seguintes itens:

• Criptografia de strings
• Hash de imports
• Achatamento de fluxo de controle (control flow flattening)
• Criptografia de código
• Truques de anti-descompilação

Você também deve usar uma ferramenta como Lumina ou FLIRT para tentar resolver todo o código de bibliotecas de código aberto e a STL do C++; isso melhorará ainda mais a precisão.

Transportes e MCP Headless

Você pode executar um servidor SSE para conectar-se à interface do usuário assim:

Após instalar o idalib, você também pode executar um servidor MCP headless. Você pode iniciar com um binário inicial:

Ou inicie sem um binário e abra arquivos arbitrários mais tarde com idb_open(...):

Para clientes baseados em stdio, use:

Os workers de banco de dados são persistentes: cada um é executado como um processo destacado que sobrevive ao supervisor que o iniciou. Quando um novo supervisor (via stdio ou HTTP) chama idb_open para um binário que já está aberto em um worker neste host, o supervisor adota esse worker de forma transparente — não há nenhum modo "compartilhado" separado para ativar. Os workers são encerrados sozinhos quando nenhuma requisição os acessa durante um intervalo ocioso.

Nota: O recurso idalib foi contribuído por Willi Ballenthin.

Modelo de Sessão Headless do idalib

idalib-mcp é um supervisor que mantém cada banco de dados aberto em seu próprio processo worker do idalib. Os workers se registram em um diretório de descoberta local do host e sobrevivem ao supervisor que os iniciou; qualquer supervisor subsequente que quiser o mesmo caminho adota o worker em execução. Um worker é encerrado sozinho quando nenhuma requisição o acessa durante seu TTL ocioso (padrão de 1 hora). Chame idb_close para liberar um worker antecipadamente (liberando uma vaga em relação a --max-workers); instâncias adotadas de GUI/worker são destacadas em vez de encerradas.

idb_open escolhe o backend por meio do parâmetro mode:

• prefer_headless (padrão): iniciar um worker do idalib (ou adotar um que já tenha o arquivo aberto).
• force_headless: o mesmo, mas nunca adota uma GUI em execução, mesmo que uma tenha o arquivo.
• prefer_gui: adota uma GUI em execução para o arquivo; caso contrário, inicia um worker do idalib.
• force_gui: adota uma GUI em execução para o arquivo; caso contrário, inicia um novo processo de GUI do IDA.

Toda chamada de ferramenta deve incluir um argumento database explícito. Não há um "banco de dados atual" implícito — os chamadores nomeiam a sessão na qual desejam operar.

Fluxo típico:

database deve ser o ID da sessão retornado por idb_open (ou exibido em idb_list); nomes de arquivo e caminhos não são aceitos.

Ferramentas de gerenciamento

• idb_open(input_path, mode="prefer_headless", run_auto_analysis=True, build_caches=True, init_hexrays=True, preferred_session_id=""): abre um binário, aquece os subsistemas (cache de strings, Hex-Rays) e retorna o ID da sessão. Se um worker ou uma GUI para este caminho já estiver em execução no host, essa instância será adotada e preferred_session_id será ignorado.
• idb_list(): lista as sessões abertas e as instâncias de GUI do IDA em execução. Cada entrada tem adopted (True se este supervisor a gerencia; False para GUIs/workers descobertos, mas ainda não abertos via idb_open), backend (worker ou gui), is_active e IDs de processo.
• idb_close(database, save=True): salva (opcionalmente), cancela o registro da sessão e encerra o worker de sua propriedade, liberando uma vaga em relação a --max-workers. Instâncias adotadas de GUI/worker são destacadas, não encerradas.
• idb_save(session_id, path=""): salva o IDB de uma sessão em disco. Encaminhado como uma ferramenta comum de worker (database=<id> injetado) — mesma assinatura em ambos os backends.
• Saúde por banco de dados: chame server_health(database=<id>) (encaminhado). idb_list() informa is_active a partir da sondagem TCP/RPC do supervisor.

Controles do worker:

• --max-workers N: número máximo de workers de banco de dados simultâneos (0 = ilimitado, padrão 4).
• IDA_MCP_MAX_WORKERS: valor padrão de ambiente para --max-workers.

Recursos do MCP

Recursos representam estado navegável (dados somente leitura) seguindo a filosofia do MCP.

Estado principal do IDB:

• ida://idb/metadata - Informações do arquivo IDB (caminho, arquitetura, base, tamanho, hashes)
• ida://idb/segments - Segmentos de memória com permissões
• ida://idb/entrypoints - Pontos de entrada (main, callbacks de TLS, etc.)

Estado da interface:

• ida://cursor - Posição atual do cursor e função
• ida://selection - Intervalo de seleção atual

Informações de tipo:

• ida://types - Todos os tipos locais
• ida://structs - Todas as estruturas/uniões
• ida://struct/{name} - Definição da estrutura com campos

Consultas:

• ida://import/{name} - Detalhes do import por nome
• ida://export/{name} - Detalhes do export por nome
• ida://xrefs/from/{addr} - Referências cruzadas a partir do endereço

Funções principais

• lookup_funcs(queries): obtém função(ões) por endereço ou nome (detecção automática; aceita lista ou string separada por vírgulas).
• int_convert(inputs): converte números para diferentes formatos (decimal, hexadecimal, bytes, ASCII, binário).
• list_funcs(queries): lista funções (paginado, filtrado).
• list_globals(queries): lista variáveis globais (paginado, filtrado).
• imports(offset, count): lista todos os símbolos importados com nomes de módulos (paginado).
• decompile(addr): descompila a função no endereço fornecido.
• disasm(addr): desmonta a função com detalhes completos (argumentos, quadro de pilha, etc.).
• xrefs_to(addrs): obtém todas as referências cruzadas para o(s) endereço(s).
• xrefs_to_field(queries): obtém referências cruzadas para campo(s) específico(s) de estrutura.
• callees(addrs): obtém funções chamadas pela(s) função(ões) no(s) endereço(s).

Operações de modificação

• add_bookmark(addr, name, prefix): adiciona ou substitui o marcador (bookmark) do IDA em um endereço; defina prefix="" para não ter prefixo.
• set_comments(items): define comentários em endereço(s) nas visões de desmontagem e descompilador.
• patch_asm(items): aplica patch em instruções de assembly em endereço(s).
• declare_type(decls): declara tipo(s) C na biblioteca de tipos local.
• define_func(items): define função(ões) em endereço(s). Opcionalmente, especifique end para limites explícitos.
• define_code(items): converte bytes em instrução(ões) de código em endereço(s).
• undefine(items): remove a definição de item(ns) em endereço(s), convertendo de volta para bytes brutos. Opcionalmente, especifique end ou size.

Operações de leitura de memória

• get_bytes(addrs): lê bytes brutos em endereço(s).
• get_int(queries): lê valores inteiros usando ty (i8/u64/i16le/i16be/etc).
• get_string(addrs): lê string(s) terminada(s) em nulo.
• get_global_value(queries): lê valor(es) de variável(is) global(is) por endereço ou nome (detecção automática; valores em tempo de compilação).

Operações de quadro de pilha

• stack_frame(addrs): obtém variáveis do quadro de pilha para função(ões).
• declare_stack(items): cria variável(is) de pilha em offset(s) especificado(s).
• delete_stack(items): exclui variável(is) de pilha por nome.

Operações de estrutura

• read_struct(queries): lê valores de campos de estrutura em endereço(s) específico(s).
• search_structs(filter): busca estruturas por padrão de nome.

Operações do depurador (extensão)

As ferramentas do depurador ficam ocultas por padrão. Ative-as com o parâmetro de consulta ?ext=dbg:

Controle:

• dbg_start(): inicia o processo do depurador.
• dbg_exit(): encerra o processo do depurador.
• dbg_continue(): continua a execução.
• dbg_run_to(addr): executa até o endereço.
• dbg_step_into(): executa passo a passo entrando na instrução.
• dbg_step_over(): executa passo a passo sobre a instrução.

Pontos de interrupção:

• dbg_bps(): lista todos os pontos de interrupção.
• dbg_add_bp(addrs): adiciona ponto(s) de interrupção.
• dbg_delete_bp(addrs): exclui ponto(s) de interrupção.
• dbg_toggle_bp(items): ativa/desativa ponto(s) de interrupção.

Registradores:

• dbg_regs(): todos os registradores, thread atual.
• dbg_regs_all(): todos os registradores, todas as threads.
• dbg_regs_remote(tids): todos os registradores, thread(s) específica(s).
• dbg_gpregs(): registradores de propósito geral (GP), thread atual.
• dbg_gpregs_remote(tids): registradores de propósito geral (GP), thread(s) específica(s).
• dbg_regs_named(names): registradores nomeados, thread atual.
• dbg_regs_named_remote(tid, names): registradores nomeados, thread específica.

Pilha e memória:

• dbg_stacktrace(): pilha de chamadas com informações de módulo/símbolo.
• dbg_read(regions): lê memória do processo depurado.
• dbg_write(regions): escreve memória no processo depurado.

Operações avançadas de análise

• py_eval(code): executa código Python arbitrário no contexto do IDA (retorna dict com result/stdout/stderr; suporta avaliação no estilo Jupyter).
• analyze_funcs(addrs): análise abrangente de função (descompilação, assembly, xrefs, callees, callers, strings, constantes, blocos básicos).

Correspondência de padrões e busca

• find_regex(queries): busca strings com regex sem diferenciar maiúsculas/minúsculas (paginado).
• find_bytes(patterns, limit=1000, offset=0): encontra padrão(ões) de bytes no binário (ex.: "48 8B ?? ??"). Limite máximo: 10000.
• find_insns(sequences, limit=1000, offset=0): encontra sequência(s) de instruções no código. Limite máximo: 10000.
• find(type, targets, limit=1000, offset=0): busca avançada (valores imediatos, strings, referências a dados/código). Limite máximo: 10000.

Análise de fluxo de controle

• basic_blocks(addrs): obtém blocos básicos com sucessores e predecessores.

Operações de tipo

• set_type(edits): aplica tipo(s) a funções, globais, locais ou variáveis de pilha.
• infer_types(addrs): infere tipos em endereço(s) usando Hex-Rays ou heurísticas.

Operações de exportação

• export_funcs(addrs, format): exporta função(ões) no formato especificado (json, c_header ou prototypes).

Operações de grafo

• callgraph(roots, max_depth): constrói grafo de chamadas a partir da(s) função(ões) raiz com profundidade configurável.

Operações em lote

• rename(batch): operação unificada de renomeação em lote para funções, globais, locais e variáveis de pilha (aceita dict com chaves opcionais func, data, local, stack).
• patch(patches): aplica patch em várias sequências de bytes de uma só vez.
• put_int(items): escreve valores inteiros usando ty (i8/u64/i16le/i16be/etc).

Principais recursos:

• API type-safe: todas as funções usam parâmetros fortemente tipados com esquemas TypedDict para melhor suporte de IDE e saídas estruturadas para LLMs
• Design em lote primeiro: a maioria das operações aceita tanto itens únicos quanto listas
• Tratamento de erros consistente: todas as operações em lote retornam [{..., error: null|string}, ...]
• Paginação baseada em cursor: funções de busca retornam cursor: {next: offset} ou {done: true} (limite padrão: 1000, máximo imposto: 10000 para evitar estouro de tokens)
• Desempenho: strings são armazenadas em cache com invalidação baseada em MD5 para evitar chamadas repetidas a build_strlist em projetos grandes

Desenvolvimento

Adicionar novos recursos é um processo super fácil e simplificado. Tudo o que você precisa fazer é adicionar uma nova função @tool aos arquivos de API modulares em src/ida_pro_mcp/ida_mcp/api_*.py e sua função estará disponível no servidor MCP sem nenhum boilerplate adicional! Abaixo está um vídeo em que adiciono a função get_metadata em menos de 2 minutos (incluindo testes):

https://github.com/user-attachments/assets/951de823-88ea-4235-adcb-9257e316ae64

Para testar o próprio servidor MCP:

Isso abrirá uma interface web em http://localhost:5173 e permitirá que você interaja com as ferramentas MCP para testes.

Para testes, crio um link simbólico para o plugin do IDA e depois envio uma requisição JSON-RPC diretamente para http://localhost:13337/mcp. Após habilitar links simbólicos, você pode executar o seguinte comando:

Gere o changelog dos commits diretos para main: