O primeiro engenheiro reverso agêntico do mundo.
Orquestração de LLM para engenharia reversa de binários
A maioria das tarefas segue uma relação linear: quanto mais difícil uma tarefa, mais tempo ela geralmente leva. A engenharia reversa (e a análise de binários) é uma tarefa em que a dificuldade real é um tanto trivial, mas o tempo de execução pode ser da ordem de horas (e dias!), mesmo para um binário com algumas centenas de funções.
Kong automatiza a camada mecânica, usando um framework de engenharia reversa de nível NSA. Kong pode pegar um binário totalmente ofuscado e sem símbolos e executar um pipeline completo de análise: triagem de funções, construção de contexto de grafo de chamadas, recuperação de tipos e símbolos através de descompilação guiada por LLM, e escrevendo os resultados de volta no banco de dados de programas do Ghidra. A saída é um binário onde alguma FUN_00401a30 agora é parse_http_header, com structs, nomes de parâmetros e convenções de chamada recuperados.
Por que isso existe
Binários sem símbolos perdem todo o contexto que torna o código legível: nomes de funções, informações de tipo, nomes de variáveis, layouts de struct. Recuperar esse contexto é a maior parte do trabalho na maioria das tarefas de RE, e é em grande parte correspondência de padrões: reconhecer funções de biblioteca padrão, inferir tipos a partir do uso, propagar nomes através de grafos de chamadas.
LLMs são bons exatamente nesse tipo de correspondência de padrões. Mas apontar um LLM para a saída bruta do descompilador e perguntar "o que isso faz?" dá resultados medíocres. O modelo carece de contexto de chamada, informações de referência cruzada e a visão mais ampla de como o binário está estruturado. Além disso, a maioria dos binários ofuscados introduz técnicas extremas para impedir a engenharia reversa.
Kong resolve isso construindo janelas de contexto ricas a partir da análise de programas do Ghidra (grafos de chamadas, referências cruzadas, referências de string, fluxo de dados) antes de tocar no LLM, então orquestrando a análise em ordem de dependência para que cada função se beneficie de suas chamadoras já nomeadas. Além disso, Kong introduz seu próprio pipeline de desofuscação agêntico, o primeiro do tipo.
Kong works with most Ghidra-decompilable binaries (for now, more to come).
| C | C++ | Go | Rust | |
|---|---|---|---|---|
| x86 | Alta | Alta | Média | Média |
| x86-64 | Alta | Alta | Média | Média |
| ARM (32-bit) | Alta | Alta | Média | Baixa |
| AArch64 | Alta | Alta | Média | Baixa |
| MIPS | Média | Média | Baixa | Baixa |
| PowerPC | Média | Média | Baixa | Baixa |
Alta: Kong descompila, desofusca e recupera nomes, tipos e estruturas de forma confiável.
Média: A descompilação é utilizável, mas mais ruidosa. Espere recuperação parcial e pontuações de confiança mais baixas.
Baixa: A descompilação tem lacunas significativas e os resultados permanecerão incompletos, ruidosos ou ilegíveis.
Nota: O tamanho do binário escala positivamente com a contagem de funções, custo do LLM e tempo para conclusão. No entanto, o tamanho do binário também escala negativamente com a confiança, portanto, tenha isso em mente ao analisar binários maiores.
Kong usa um pipeline de cinco fases orquestrado por um supervisor que coordena triagem, análise paralela e pós-processamento:
┌──────────────────────┐
│ Triage │
│ enumerate, classify,│
│ build call graph, │
│ match signatures │
└──────────┬───────────┘
│
▼
┌────────────────┼────────────────┐
│ │ │
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Analyze │ │ Analyze │ │ ... │
│ (leaf fns) │ │ (next tier) │ │ │
└──────┬───────┘ └──────┬───────┘ └──────┬───────┘
│ │ │
└────────┬───────┴────────────────┘
│
▼
┌──────────────────────┐
│ Cleanup │
│ normalize, dedupe │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ Synthesis │
│ unify names, build │
│ structs, deobfuscate│
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ Export │
│ analysis.json + │
│ Ghidra writeback │
└──────────────────────┘
Triagem enumera todas as funções no binário, classifica-as por tamanho (trivial / pequena / média / grande), constrói o grafo de chamadas, detecta a linguagem fonte e executa a correspondência de assinaturas contra funções conhecidas da biblioteca padrão e criptográficas. Funções correspondidas por assinatura são marcadas como resolvidas e pulam completamente a análise LLM.
Análise processa funções em ordem ascendente a partir do grafo de chamadas usando uma fila de trabalho. Para cada função, Kong constrói uma janela de contexto a partir do banco de dados de programas do Ghidra — descompilação, referências cruzadas, referências de string e as assinaturas de funções chamadas já analisadas — normaliza a saída do descompilador e a envia ao LLM para recuperação de nomes, tipos e parâmetros. Se ofuscação for detectada na descompilação de uma função, Kong executa uma passagem de desofuscação agêntica com acesso a ferramentas simbólicas antes de produzir a análise. Os resultados são escritos de volta no Ghidra imediatamente para que as funções chamadoras posteriores vejam nomes atualizados.
Limpeza unifica tipos de struct a partir de propostas acumuladas durante a análise e tenta novamente quaisquer assinaturas de função que falharam ao ser aplicadas durante a passagem de análise.
Síntese adota uma visão global em todas as funções analisadas. Uma única chamada LLM revisa as funções mais conectadas, unifica convenções de nomenclatura, sintetiza definições de struct a partir de padrões de acesso a campos e refina nomes que parecem inconsistentes no contexto mais amplo.
Exportação escreve o analysis.json final e aplica todos os nomes, tipos e assinaturas recuperados de volta ao banco de dados de programas do Ghidra.
# 1. Install Kong
uv pip install kong-re
# 2. Set your API key(s)
export ANTHROPIC_API_KEY="sk-ant-..."
# and/or
export OPENAI_API_KEY="sk-..."
# 3. Run the setup wizard (first time only)
kong setup
# 4. Analyze a binary
kong analyze ./path/to/stripped_binary
The setup wizard lets you pick which LLM providers to use and sets a default. Kong auto-detects your Ghidra and JDK installations, loads the binary into an in-process Ghidra instance, and runs the full pipeline.
git clone https://github.com/amruth-sn/kong.git
cd kong
uv sync
uv run kong setup
uv run kong analyze ./path/to/stripped_binary
| Variável | Obrigatório | Descrição |
|---|---|---|
ANTHROPIC_API_KEY | Pelo menos uma | Chave de API Anthropic (Claude) |
OPENAI_API_KEY | Pelo menos uma | Chave de API OpenAI (GPT-4o) |
GHIDRA_INSTALL_DIR | Não | Caminho para a instalação do Ghidra (auto-detectado se não definido) |
JAVA_HOME | Não | Caminho para o JDK (auto-detectado se não definido) |
KONG_CONFIG_DIR | Não | Substituir diretório de configuração (padrão: ~/.config/kong) |
# Run the setup wizard
kong setup
# Analyze a stripped binary (uses your configured default provider)
kong analyze ./binary
# Analyze with a specific provider
kong analyze ./binary --provider openai
# Override the model
kong analyze ./binary --provider openai --model gpt-4o-mini
# Show binary metadata without running analysis
kong info ./binary
# Evaluate analysis output against ground-truth source
kong eval ./analysis.json ./source.c
Results are written to the output directory (default: ./kong_output_{binary_name}/):
kong_output_{binary_name}/
├── analysis.json # All recovered function names, types, parameters
└── events.log # Pipeline execution trace
Kong reconstruiu autonomamente toda a cadeia de kill do backdoor XZ (CVE-2024-3094) a partir de um binário sem símbolos liblzma.so.5.4.1 — identificando todas as cinco funções principais do implante com 90-95% de confiança em 15 minutos por $6.63.
Veja BENCHMARKS.md para o estudo de caso completo e instruções de reprodução.
kong/
├── __main__.py # CLI entry point (click)
├── config.py # KongConfig, LLMProvider, LLMConfig
├── db.py # SQLite config store (~/.config/kong/)
├── banner.py # ASCII banner, API key helpers
├── agent/
│ ├── supervisor.py # Pipeline orchestrator
│ ├── triage.py # Function enumeration + classification
│ ├── analyzer.py # LLM-guided function analysis
│ ├── queue.py # BFS work queue from call graph
│ ├── signatures.py # Known function signature matching
│ ├── prompts.py # System prompt + output schema
│ ├── events.py # Phase/event types for pipeline tracing
│ └── models.py # FunctionResult dataclass
├── ghidra/
│ ├── client.py # In-process GhidraClient (PyGhidra/JPype)
│ ├── types.py # FunctionInfo, BinaryInfo, XRef, etc.
│ └── environment.py # Ghidra/JDK auto-detection
├── llm/
│ ├── client.py # AnthropicClient
│ ├── openai_client.py # OpenAIClient
│ ├── usage.py # TokenUsage, cost tracking, pricing registry
│ └── limits.py # Model-specific limits + rate limiter
├── normalizer/
│ └── syntactic.py # Decompiler output normalization
├── synthesis/
│ └── semantic.py # Global name unification + struct synthesis
├── evals/
│ ├── harness.py # Ground-truth extraction + scoring
│ └── metrics.py # symbol_accuracy, type_accuracy
├── export/
│ └── source.py # analysis.json + Ghidra writeback
├── signatures/
│ ├── stdlib.json # C standard library signatures
│ └── crypto.json # Cryptographic function signatures
└── tui/
└── app.py # Textual TUI
Kong está licenciado sob a Apache License 2.0. Kong é um projeto gratuito e de código aberto.
Esta licença é compatível com a licença do Ghidra e permite uso comercial.
Issues e pedidos de funcionalidades são bem-vindos via GitHub Issues.
Um grande agradecimento ao projeto Shannon da KeygraphHQ, que forneceu a inspiração para este projeto. Minha motivação foi impulsionada por replicar o mesmo tipo de pipeline que Shannon usa para sua ferramenta de pentest baseada na web, e adaptá-lo para análise de binários e descompilação.
Tema o macaco.
Kong: O primeiro engenheiro reverso de IA do mundo