GhostMCP

Servidor MCP injetável para engenharia reversa orientada por IA dentro de processos

GitHub
32
Experimente este MCPPatrocinado

Documentação

Ghost-MCP 👻

Fale com seus binários. Aponte a IA para um processo e deixe ele trabalhar.

Ghost-MCP é um servidor MCP (Model Context Protocol) injetável para assistente de engenharia reversa por vibe no Windows. Ele combina inspeção de memória, desmontagem, depuração e injeção de código em uma única ferramenta que qualquer cliente de IA compatível com MCP pode usar. Injete-o em um processo alvo e interaja por conversa natural.

⚠️ EXPERIMENTAL: Este projeto é altamente experimental e está em desenvolvimento. As APIs podem mudar sem aviso prévio, os recursos podem estar incompletos ou instáveis, e a documentação pode não refletir o estado atual. Use por sua conta e risco.

O Que Você Pode Fazer Com Ele?

Pergunte ao seu assistente de IA coisas como:

  • "Encontre o valor de vida neste jogo e congele em 100"
  • "Mostre-me todas as funções que referenciam esta string"
  • "Defina um breakpoint em MessageBoxA e me avise quando for chamado"
  • "Desmonte a função neste endereço e explique o que ela faz"
  • "Encontre todos os ponteiros que levam a este endereço"

A IA cuida dos detalhes técnicos. Você apenas descreve o que quer.

Arquitetura Multi-Servidor

Ghost-MCP usa uma arquitetura modular multi-servidor para fornecer mais de 250 ferramentas enquanto permanece dentro dos limites do cliente MCP:

ServidorPortaFerramentasFinalidade
ghost-core-mcp1334085Memória, depuração, execução, segurança
ghost-analysis-mcp1334182Varredura, ponteiros, dumps, estruturas
ghost-static-mcp1334284Radare2, IDA, Ghidra, IA, YARA
ghost-extended-mcp1334385Injeção, anti-debug, entrada, speedhack

Configuração Rápida:

  • O agente escuta em 13338; o servidor principal usa stdio, análise/estático via TCP
  • scripts/launch-mcp.ps1 inicia um ou todos os servidores
  • Operações destrutivas exigem tokens de segurança: chame safety_request_token, depois inclua token_id

Recursos

Operações de Memória (estilo Cheat Engine)

Tudo o que você precisa para caçar valores e manipular memória:

  • Leitura/escrita de memória com conversão automática de tipos (inteiros, floats, strings, bytes)
  • Enumeração de regiões com flags de proteção (legível, gravável, executável)
  • Varredura de padrões com curingas AOB (48 8B ?? ?? 90)
  • Resolução de cadeias de ponteiros para estruturas de dados complexas

Varredura de Padrões e YARA

Correspondência avançada de padrões para análise de malware e varredura de assinaturas:

  • Varredura AOB para Array of Bytes com suporte a curingas
  • Varredura de strings para padrões ASCII, Unicode (UTF-16) e UTF-8
  • Padrões Regex com correspondência em nível de byte (requer o recurso yara)
  • Integração YARA para carregar e executar regras contra a memória
  • Bancos de assinaturas para armazenar, importar e exportar padrões nomeados
  • Assinaturas nomeadas para organizar padrões com tags e descrições

Despejo e Análise de Memória

Despejo completo da memória do processo com reconstrução de PE:

  • Despejos completos do processo para capturar todas as regiões de memória confirmadas
  • Despejos seletivos de regiões para faixas de endereços específicas
  • Despejos de módulos para extrair DLLs/EXEs com reconstrução de PE
  • Criação de minidumps em formato compatível com WinDbg
  • Despejos incrementais para rastrear alterações entre snapshots
  • Diff binário para comparar despejos e encontrar modificações
  • Busca de padrões dentro de despejos usando padrões AOB
  • Anotações para marcar e rotular locais interessantes
  • Reconstrução de PE com reconstrução de tabela de importação estilo Scylla
  • Catálogo de despejos para organizar e gerenciar múltiplos despejos

Scanner de Valores Avançado

Um scanner completo estilo Cheat Engine com gerenciamento de sessão:

  • 12 modos de varredura incluindo exato, alterado, inalterado, aumentado, diminuído, maior, menor, entre, valor inicial desconhecido, difuso e mais
  • Varredura iterativa para refinar resultados em múltiplas varreduras
  • Filtragem inteligente para somente leitura, somente executável, somente módulo, faixas de endereço personalizadas
  • Modo de varredura rápida com pulo baseado em alinhamento para aceleração de 4x+
  • Progresso ao vivo com rastreamento em tempo real e cancelamento
  • Exportar/Importar para salvar resultados como JSON, CSV ou XML do Cheat Engine

Scanner de Ponteiros (estilo Cheat Engine)

Encontre caminhos de ponteiros estáveis para endereços dinâmicos:

  • Varredura multinível com profundidade configurável (1-10 níveis) para encontrar cadeias de ponteiros
  • Filtragem de base estática para incluir apenas ponteiros relativos a módulos que sobrevivem a reinicializações
  • Restrições de deslocamento com deslocamento máximo configurável e opções de alinhamento
  • Revarredura de ponteiros para validar caminhos após reinicialização do processo com pontuação de estabilidade
  • Pontuação de estabilidade que rastreia a validade dos ponteiros entre revarreduras (pontuação 0.0-1.0)
  • Comparação de sessões para encontrar ponteiros válidos comuns entre conjuntos de varredura
  • Resolução de ponteiros para seguir cadeias e ler valores em endereços resolvidos
  • Exportar/Importar em JSON, CSV ou formato de ponteiro do Cheat Engine (.ptr)
  • Paginação para grandes conjuntos de resultados com limites configuráveis
  • Rastreamento de progresso com atualizações em tempo real e suporte a cancelamento

Análise Estática (estilo IDA Pro)

Navegue pelo código como um profissional:

  • Desmontagem via mecanismo Capstone (disasm_at, disasm_function)
  • Descompilação com geração de pseudo-C estilo Hex-Rays
  • Inspeção de módulos para listar todas as DLLs, suas exportações e importações
  • Resolução de símbolos via carregamento de PDB com DbgHelp e suporte completo a caminhada de pilha
  • Referências cruzadas para encontrar todas as referências CALL/JMP/LEA para qualquer endereço
  • Extração de strings para extrair strings ASCII/Unicode de qualquer módulo

Depuração Dinâmica (estilo x64dbg)

Depuração completa no processo sem depurador externo:

  • Breakpoints de software usando injeção INT3 com restauração automática de bytes
  • Breakpoints de hardware via registradores de depuração DR0-DR3 (4 slots)
  • Execução passo a passo com execução instrução por instrução baseada em flag de trap
  • Controle de threads para listar, suspender, retomar qualquer thread
  • Acesso a registradores para ler/escrever todos os registradores x64 (RAX-R15, RIP, RFLAGS)
  • Caminhada de pilha para pilha de chamadas completa com resolução de símbolos

Execução Direta e Injeção de Código

Execute código arbitrário dentro do processo alvo:

  • Montador para montagem x86/x64 de texto para bytes usando iced-x86 (Rust puro, mantido ativamente)
    • Suporta instruções comuns: MOV, ADD, SUB, XOR, PUSH, POP, CALL, JMP, saltos condicionais, etc.
    • Múltiplas opções de sintaxe: instruções separadas por nova linha ou ponto e vírgula
    • Imediatos hexadecimais: formato 0x1234 ou 1234h
    • Auxiliares de geração de shellcode para chamadas de função (ABI x64 do Windows)
  • Chamada de funções com suporte completo a convenções de chamada (cdecl, stdcall, fastcall, win64, thiscall)
  • Resolução dinâmica com buscas estilo GetProcAddress e cache
  • Execução de shellcode com múltiplos métodos:
    • Chamada direta na thread atual
    • Nova thread (CreateThread, NtCreateThreadEx)
    • Injeção APC
    • Sequestro de thread
  • Gerenciamento de memória para alocar, escrever e liberar memória executável
  • Code caves para encontrar e usar espaço executável não utilizado
  • Extração de syscalls para obter números de syscall diretamente de stubs do ntdll
  • Execução remota para injetar código em outros processos

Gerenciamento de Processos e Sessões

Controle total sobre processos alvo:

  • Listagem de processos para enumerar processos em execução com filtragem
  • Criação de processos para iniciar processos (normal ou suspenso)
  • Anexar/desanexar para conectar a processos por nome ou PID
  • Múltiplos modos de inicialização incluindo Normal, Suspenso, Depuração, Atrasado, WaitForModule

Introspecção de Processos e Sistema

Visibilidade profunda nos detalhes internos do processo:

  • Detalhes do processo incluindo PID, caminho, arquitetura, contagens de threads/handles, endereço do PEB
  • Acesso ao PEB para flag BeingDebugged, base da imagem, dados do loader, informações de versão do SO
  • Mapas de memória mostrando o layout completo da memória virtual com proteção e tipos de região
  • Introspecção de threads com enumeração, acesso ao TEB, slots TLS, informações de prioridade
  • Detalhes de módulos com endereço base, tamanho, ponto de entrada, informações de versão
  • Enumeração de janelas com título, classe, estilos, hierarquia e filtragem
  • Análise de tokens para SID de usuário, privilégios, status de elevação, nível de integridade
  • Manipulação de privilégios para habilitar/desabilitar privilégios como SeDebugPrivilege
  • Acesso ao ambiente para ler variáveis de ambiente e diretório de trabalho

Comandos Meta do MCP

Autodescoberta e introspecção:

  • Descoberta de capacidades para listar todas as ferramentas disponíveis com categorias
  • Documentação para obter ajuda detalhada e exemplos para qualquer ferramenta
  • Verificações de saúde para verificar a conexão do agente e o status do mecanismo de script
  • Informações de versão para versão do servidor e informações de build

Suporte a Comandos Bidirecionais IA/LLM

Integração perfeita para análise assistida por IA:

  • Agrupamento de comandos para executar sequências de comandos de múltiplas etapas com condições
  • Histórico de comandos para consultar e reproduzir comandos anteriores
  • Assinaturas de eventos para acionamentos de breakpoints, exceções, alterações de memória, gatilhos de hooks
  • Resumos amigáveis para IA com sumarização sensível ao contexto dos resultados de operações
  • Relatórios de diff para comparar estados (memória, registradores, módulos) com diffs estruturados
  • Explicações de erros com mensagens em linguagem natural e correções sugeridas
  • Sessões de depuração para depuração conversacional com descobertas, hipóteses e próximos passos
  • Recomendações de breakpoints com sugestões orientadas por IA para locais de breakpoints
  • Análise de vulnerabilidades para detecção automatizada de padrões de segurança
  • Aprendizado de padrões para salvar e relembrar padrões de código, comportamentos e estruturas de dados

Métodos de Hook Estendidos

Kit abrangente de hooks para interceptação de funções:

  • Hooks inline com detours baseados em trampolim (saltos de 5/14 bytes), hooks de meio de função, hot-patching, hooks de breakpoint INT3
  • Hooks IAT/EAT para hooking de tabela de endereços de importação e exportação com enumeração
  • Hooks VEH/PAGE_GUARD para breakpoints de memória sem hardware via tratamento de exceção vetorizada
  • Hooks de syscall via patch de stub do ntdll para interceptação de syscalls
  • Geração de shellcode para modelos de código independente de posição (chamar função, carregar biblioteca, etc.)
  • Codificação de shellcode com codificador XOR e geração de stub de decodificador
  • Localizador de gadgets ROP para buscar gadgets de programação orientada a retorno em módulos carregados
  • Gerenciamento de hooks com ativar/desativar, encadeamento e transações para operações atômicas de múltiplos hooks

Rastreamento e Monitoramento de Chamadas de API (estilo Rohitab API Monitor)

Rastreamento completo de chamadas de API Win32 com decodificação de argumentos:

  • Sessões de rastreamento para criar, iniciar, parar, pausar, retomar rastreamento
  • Pipeline de eventos com buffer circular configurável e estratégias de contrapressão (descartar mais antigo, bloquear, amostrar)
  • Pacotes de API com definições baseadas em JSON para kernel32, user32, ntdll, ws2_32, advapi32
  • Filtragem no lado do servidor para incluir/excluir por nome de API, módulo, thread, valor de retorno
  • Correspondência de padrões com suporte a prefixo, sufixo, contém, curinga e regex
  • Predefinições de filtro incluindo predefinições integradas (Operações de Arquivo, Rede, Registro, Somente Erros) além de personalizadas
  • Estatísticas para contagens de chamadas por API, durações, taxas de sucesso/fracasso
  • Monitoramento de fila para profundidade, descartes, eventos por segundo

Monitoramento Avançado de Processos

Capacidades estendidas de monitoramento para análise profunda:

  • Monitoramento dinâmico de API para rastrear resoluções de GetProcAddress/LdrGetProcedureAddress
  • Congelamento de processo para congelar/retomar threads para análise estática (todas, específicas ou filtradas)
  • Varredura de objetos COM para detectar e enumerar interfaces COM com análise de vtable
  • Monitoramento de DLL para capturar eventos de LoadLibrary/FreeLibrary com pilhas de chamadas
  • Importações atrasadas para varrer e monitorar cargas de DLL atrasadas (__delayLoadHelper2)

API Override e Breakpoints Condicionais

Manipulação completa de parâmetros e valores de retorno com controle condicional:

  • Breakpoints condicionais com temporização antes/depois da chamada, condições de argumento/retorno, filtros por ID de thread
  • Condições compostas usando lógica AND/OR/NOT, gatilhos por contagem de chamadas (N-ésima chamada, a cada N-ésima chamada)
  • Substituição de parâmetros para modificar inteiros, booleanos, ponteiros, strings (ANSI/Unicode), buffers, injeção de NULL
  • Substituição de valor de retorno para modificação de código de retorno, auxiliares HRESULT/NTSTATUS, controle de SetLastError
  • Mecanismo de pausa para coordenação de threads, timeouts configuráveis com continuação automática
  • Trilha de auditoria com registro completo de todas as modificações, valores antes/depois, exportação para JSON/CSV

Correspondência Avançada de Padrões

Poderosas capacidades de busca em nível de instrução:

  • Sequências de instruções para encontrar padrões de código com mnemônicos curinga e correspondência de operandos
  • Busca por operandos para encontrar instruções por tipo de registro, valores imediatos, operandos de memória
  • Busca por imediatos para localizar valores em código/dados com correspondência de faixa e opções de alinhamento
  • Busca por strings para correspondência de padrões ASCII/UTF-16 com controle de sensibilidade a maiúsculas/minúsculas
  • Busca por referências cruzadas para encontrar todas as referências de código/dados a endereços
  • Busca unificada com paginação por cursor para grandes conjuntos de resultados

Segurança e Salvaguardas

Sistema abrangente de segurança para prevenir acidentes:

  • Modos de segurança com Educacional (bloqueia operações perigosas), Padrão (exige aprovação), Especialista (restrições mínimas)
  • Processos protegidos com detecção automática e bloqueio para processos do sistema (csrss, lsass, svchost, etc.)
  • Limitação de taxa usando algoritmo de token bucket para operações globais e limitação específica de escrita
  • Limites de tamanho com limites configuráveis para operações de leitura/escrita/varredura e avisos no limite de 80%
  • Fluxo de aprovação exigindo aprovação explícita baseada em token para operações perigosas
  • Histórico de patches com capacidade total de desfazer via ferramenta patch_undo
  • Pré-visualização de simulação para visualizar patches antes de aplicar com patch_preview
  • Backup automático para backup automático de estado e recuperação de falhas

Injeção de DLL (via ghost-loader)

Opções flexíveis de injeção:

  • LoadLibraryExW para injeção padrão do Windows
  • Anexação de processo por PID, nome ou aguardar-processo
  • Modos de inicialização incluindo Normal, Suspenso, Depuração, Atrasado, WaitForModule
  • Suporte x86/x64 para processos de 32 e 64 bits

Integração com Ferramentas Externas de RE

Conecte-se às suas ferramentas favoritas de engenharia reversa:

  • Radare2 com integração completa r2pipe (multiplataforma)
  • Ghidra via modo headless ou JSON-RPC através de ghidra-pipe
  • IDA Pro via idalib (requer IDA v9.x)
  • API unificada fornecendo uma interface consistente em todos os backends

Arquitetura

Ghost-MCP usa uma arquitetura modular de múltiplos servidores para permanecer abaixo do limite de ~100 ferramentas do MCP, enquanto fornece mais de 250 ferramentas:

┌─────────────────────────────────────────────────────────────────────────────┐
│                              AI CLIENTS                                      │
│              Claude Desktop │ Cursor │ Windsurf │ Custom                     │
└───────┬─────────────┬─────────────┬─────────────┬───────────────────────────┘
        │             │             │             │
        ▼             ▼             ▼             ▼
┌───────────────┐ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│ghost-core-mcp │ │ghost-analysis │ │ghost-static   │ │ghost-extended │
│  Port 13340   │ │  Port 13341   │ │  Port 13342   │ │  Port 13343   │
│   85 tools    │ │   82 tools    │ │   84 tools    │ │   85 tools    │
│ Memory, Debug │ │ Scanner, Dump │ │ R2, IDA, AI   │ │ Inject, Input │
└───────┬───────┘ └───────┬───────┘ └───────┬───────┘ └───────┬───────┘
        │                 │                 │                 │
        └─────────────────┴─────────────────┴─────────────────┘
                                  │ IPC (TCP localhost:13338)
                                  ▼
┌─────────────────────────────────────────────────────────────────┐
│                LAYER 2: INJECTED AGENT                          │
│                     ghost-agent.dll                             │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │               ghost-core (static library)                 │  │
│  │    Memory │ Disasm │ Debug │ Hooks │ Scanner │ Exec      │  │
│  └──────────────────────────────────────────────────────────┘  │
└───────────────────────────────┬─────────────────────────────────┘
                                │ Direct Access
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│                      TARGET PROCESS                             │
│                   (game.exe, app.exe, etc.)                     │
└─────────────────────────────────────────────────────────────────┘

Servidores Modulares

ServidorPortaFerramentasPropósito
ghost-core-mcp1334085Processo ao vivo: memória, depuração, execução, segurança
ghost-analysis-mcp1334182Análise: varredura, ponteiros, dumps, estruturas
ghost-static-mcp1334284RE estática: Radare2, IDA, Ghidra, IA, YARA
ghost-extended-mcp1334385Estendido: injeção, anti-depuração, entrada, speedhack

Cada servidor inclui 4 ferramentas de meta compartilhadas (mcp_capabilities, mcp_documentation, mcp_version, mcp_health) e permanece abaixo do limite de 90 ferramentas do MCP.

Por que este design?

  • Segurança porque o agente é pequeno e resistente a falhas; o trabalho pesado acontece no host
  • Flexibilidade já que o mesmo núcleo funciona como DLL injetada ou EXE autônomo
  • Amigável para IA com respostas JSON estruturadas, paginação, mensagens de erro claras

Início Rápido

1. Compilar

cargo build --release

2. Injetar no alvo

ghost-loader.exe --target game.exe

3. Conectar seu cliente de IA

Adicione à sua configuração do Claude Desktop (%APPDATA%\Claude\claude_desktop_config.json):

{
  "mcpServers": {
    "ghost-core": {
      "command": "path/to/ghost-core-mcp.exe",
      "args": ["--transport", "stdio"]
    },
    "ghost-analysis": {
      "command": "path/to/ghost-analysis-mcp.exe",
      "args": ["--port", "13341"]
    },
    "ghost-static": {
      "command": "path/to/ghost-static-mcp.exe",
      "args": ["--port", "13342"]
    },
    "ghost-extended": {
      "command": "path/to/ghost-extended-mcp.exe",
      "args": ["--port", "13343"]
    }
  }
}

Comece a conversar com sua IA favorita sobre o processo alvo.

4. Verificar Configuração

# Validate all server registries
.\scripts\launch-mcp.ps1 -ValidateOnly

# Or launch everything with one command
.\scripts\launch-mcp.ps1 -Target game.exe

Componentes

ComponenteDescrição
ghost-hostServidor MCP que conversa com clientes de IA e roteia comandos
ghost-coreBiblioteca estática com todos os primitivos de RE
ghost-agentDLL injetada que executa dentro do processo alvo
ghost-loaderInjetor de DLL multi-método
ghost-commonTipos compartilhados, protocolo IPC, sistema de capacidades
ghost-mcp-commonInfraestrutura compartilhada de servidor MCP (registro, configuração, saúde)
ghost-core-mcpServidor MCP modular para ferramentas de processo ao vivo (85 ferramentas, porta 13340)
ghost-analysis-mcpServidor MCP modular para ferramentas de análise (82 ferramentas, porta 13341)
ghost-static-mcpServidor MCP modular para ferramentas de RE estática (84 ferramentas, porta 13342)
ghost-extended-mcpServidor MCP modular para capacidades estendidas (85 ferramentas, porta 13343)
ghost-re-backendsIntegrações com Radare2, Ghidra, IDA
ghost-test-targetAplicativo de teste com layout de memória conhecido
ghost-mcp-clientCliente MCP CLI para teste e automação

Desenvolvimento e Testes

# Run all tests (370+ unit tests)
cargo test --workspace

# Build release binaries
cargo build --release

# Format and lint
cargo fmt --all --check
cargo clippy --workspace -- -D warnings

Pilha de Testes

Usamos uma abordagem de testes em múltiplas camadas:

  • Testes unitários Módulos principais têm testes abrangentes para operações de memória, correspondência de padrões, desmontagem, hooks, IPC e conversões de tipo
  • Testes de integração tests/integration/ valida fluxos de ponta a ponta: injeção, leitura/escrita de memória, varreduras de padrões, breakpoints, hooks
  • Fuzzing de IPC tests/integration/ipc_fuzzing.rs testa o protocolo sob estresse com mensagens malformadas/aleatórias
  • Pipeline de CI GitHub Actions executa a suíte completa de testes a cada push

Alvos de Teste

ComponenteO que é Testado
ghost-test-targetAplicativo dummy com layout de memória conhecido, funções exportadas, símbolos de depuração
ghost-mcp-clientCLI para testes manuais, automação por script e verificações de regressão
# CLI testing examples
ghost-client --stdio --host-binary ./target/release/ghost-host tools
ghost-client --stdio --host-binary ./target/release/ghost-host call mcp_version
ghost-client --stdio --host-binary ./target/release/ghost-host repl

Princípios de Design

  1. Segurança em Primeiro Lugar para nunca travar o processo alvo
  2. IA em Primeiro Lugar com saídas estruturadas, erros claros, paginação
  3. Modular com separação limpa entre host, núcleo e agente
  4. Extensível via design baseado em traits para fácil troca de backends

Modelo de Segurança

Ghost-MCP usa um modelo de segurança baseado em capacidades com salvaguardas abrangentes de segurança:

Escopos de Capacidade

CapacidadeRiscoOperações
leituraBaixoLeituras de memória, listagens de módulos, introspecção (padrão)
escritaMédioEscritas de memória, operações de patch
execuçãoAltoChamadas de função, shellcode, threads remotas
depuraçãoMédioBreakpoints, suspensão/retomada de threads, execução passo a passo
adminAltoMudanças de modo de segurança, reconexão de agente

Tokens de Segurança

Operações destrutivas exigem tokens de segurança para autorização:

  1. Cliente solicita token: safety_request_token(scope: "write", ttl_secs: 300)
  2. Agente valida que o cliente tem a capacidade necessária e emite o token
  3. Cliente inclui token_id em operações de escrita subsequentes
  4. Token expira automaticamente ou o cliente o libera explicitamente

Tokens têm TTL configurável (máximo 24 horas) e são de uso único para máxima segurança.

Modos de Segurança

ModoDescriçãoOperações Perigosas
EducacionalRestrições máximas para aprendizadoBloqueadas
PadrãoModo padrão com fluxo de aprovaçãoExige aprovação
EspecialistaRestrições mínimas para usuários experientesPermitidas

Ferramentas de Segurança

FerramentaDescrição
safety_statusVisualizar modo atual, estatísticas e aprovações pendentes
safety_set_modeAlternar entre educacional/padrão/especialista
safety_approveAprovar uma operação perigosa pendente
patch_historyVisualizar todos os patches aplicados nesta sessão
patch_undoRestaurar bytes originais para qualquer patch
patch_previewPré-visualização de simulação antes de aplicar patches

Operações perigosas exigem confirmação explícita no modo Padrão. Use safety_set_mode expert para desabilitar requisitos de aprovação.

Casos de Uso

  • Pesquisa de Segurança para análise de vulnerabilidades, desenvolvimento de exploits, fuzzing
  • Análise de Malware para análise dinâmica, desempacotamento, bypass de anti-depuração
  • Hacking de Jogos para varredura de valores, resolução de ponteiros, treinadores
  • Testes de Software para injeção de falhas, modificação de comportamento, análise de cobertura
  • Aprendizado para entender como programas funcionam no nível binário

Uso Responsável

Ghost-MCP é uma ferramenta poderosa que fornece acesso profundo aos internals de processos. Com esse poder vem a responsabilidade.

Uso Pretendido

  • Fins educacionais para aprender engenharia reversa e entender como o software funciona no nível binário
  • Pesquisa de segurança para analisar vulnerabilidades em software que você possui ou tem autorização explícita para testar
  • Modding de jogos para modificar jogos single-player e offline para diversão pessoal
  • Desenvolvimento de software para depurar seus próprios aplicativos, testar casos extremos, analisar desempenho

Uso Proibido

  • Trapaça em multiplayer online - não use esta ferramenta para obter vantagens injustas em jogos online
  • Contornar proteções ilegalmente - não burle DRM, licenciamento ou medidas de segurança em software que você não possui
  • Atividades maliciosas - não use para desenvolvimento de malware, acesso não autorizado ou qualquer propósito ilegal
  • Violar termos de serviço - respeite o EULA e os ToS do software com o qual você interage

Você é o único responsável por garantir que seu uso esteja em conformidade com as leis e regulamentos aplicáveis em sua jurisdição.

Contribuindo

Contribuições são bem-vindas! Por favor:

  1. Faça um fork do repositório
  2. Crie um branch de funcionalidade (git checkout -b feature/your-feature)
  3. Faça commit das suas alterações (git commit -m 'Add your feature')
  4. Envie para o branch (git push origin feature/your-feature)
  5. Abra um Pull Request

Execute cargo fmt --all e cargo clippy --workspace -- -D warnings antes de enviar.

Licença

MIT