VMDragonSlayer

Projeto será público até meados de outubro - Refatoração em andamento

Framework Avançado de Detecção e Análise de Máquinas Virtuais

VMDragonSlayer é um framework abrangente para análise de binários protegidos por protetores baseados em Máquina Virtual (VM) como VMProtect 2.x/3.x, Themida e VMs personalizadas de malware. O framework combina múltiplos motores de análise, incluindo Rastreamento Dinâmico de Taint (DTT), Execução Simbólica (SE), Classificação de Padrões e Aprendizado de Máquina para automatizar o processo de engenharia reversa.

Objetivo: Transformar a análise complexa de binários protegidos de semanas/meses de trabalho manual em uma análise estruturada e automatizada com resultados explicáveis.

Principais Funcionalidades

• Análise Multi-Motor: Combina técnicas de análise estática, dinâmica e híbrida
• Detecção de VM: Detecção automatizada de protetores de VM comerciais e personalizados
• Ecossistema de Plugins: Integrações com Ghidra, IDA Pro e Binary Ninja
• Aprendizado de Máquina: Modelos de ML de prova de conceito para classificação de padrões
• Arquitetura Extensível: Design modular para fluxos de análise personalizados
• Framework de Pesquisa: Construído para pesquisa de malware e educação em engenharia reversa

Capacidades Principais

Visão Geral da Arquitetura

VMDragonSlayer usa uma arquitetura modular onde múltiplos motores de análise trabalham juntos:

graph TD
    A[VM Discovery Engine] --> B[Pattern/ML Classifier]
    B --> C[Symbolic Execution Engine]
    B --> D[Dynamic Taint Tracker]
    D --> C
    
    subgraph DataSources ["Data Sources"]
        E[Pattern Database]
        F[ML Models - PoC]
    end
    
    subgraph Coordination
        G[Orchestrator - Workflow Management & Coordination]
    end
    
    E --> B
    F --> B
    A --> G
    B --> G
    C --> G
    D --> G
    E --> G
    F --> G
    G --> H[REST API Server]
    G --> I[Plugins - RE Tools]

Motores de Análise Principais

1. Motor de Descoberta de VM (dragonslayer.analysis.vm_discovery)

• Propósito: Detectar e classificar esquemas de proteção baseados em VM
• Técnicas: Detecção de loop de despacho, análise de tabela de manipuladores, heurísticas de fluxo de controle
• Alvos: VMProtect, Themida, VMs de malware personalizadas, proteção aninhada

2. Rastreamento Dinâmico de Taint (dragonslayer.analysis.taint_tracking)

• Propósito: Rastrear fluxo de dados através da execução da VM para identificar caminhos críticos
• Implementação: Instrumentação baseada em Intel Pin com precisão em nível de byte
• Funcionalidades: Memória sombra, evasão de anti-análise, descoberta automatizada de manipuladores

3. Análise de Padrões (dragonslayer.analysis.pattern_analysis)

• Propósito: Classificar e categorizar padrões e comportamentos de VM
• Métodos: Correspondência baseada em regras, análise de similaridade, classificação por ML
• Banco de Dados: Banco de padrões extensível com esquemas JSON

4. Execução Simbólica (dragonslayer.analysis.symbolic_execution)

• Propósito: Explorar caminhos de execução da VM simbolicamente
• Funcionalidades: Resolução de restrições, priorização de caminhos, mesclagem de estados
• Integração: Usa resultados de análise de taint para semear a exploração

5. Pipeline de Aprendizado de Máquina (dragonslayer.ml)

• Propósito: Classificação automatizada e assistência à análise
• Modelos: Modelos básicos de prova de conceito para pesquisa e educação
• Componentes: Extração de características, treinamento de modelos, predição ensemble

Estrutura do Repositório

VMDragonSlayer/
├── dragonslayer/                    # Pacote Python principal
│   ├── analysis/                   # Motores de análise
│   │   ├── vm_discovery/          # Detecção e classificação de VM
│   │   ├── pattern_analysis/      # Correspondência de padrões e classificação ML
│   │   ├── symbolic_execution/    # Motor de execução simbólica
│   │   ├── taint_tracking/        # Análise dinâmica de taint
│   │   └── anti_evasion/          # Contramedidas de anti-análise
│   ├── api/                       # Servidor e cliente REST API
│   ├── core/                      # Componentes principais do framework
│   ├── ml/                        # Pipeline de aprendizado de máquina
│   ├── analytics/                 # Relatórios de análise e métricas
│   ├── gpu/                       # Suporte a aceleração GPU
│   ├── utils/                     # Funções utilitárias
├── data/                          # Arquivos de configuração e dados
│   ├── patterns/                  # Banco de padrões
│   ├── models/                    # Modelos ML e metadados
│   │   ├── pretrained/           # Modelos pré-treinados (PoC)
│   │   └── metadata/             # Metadados e esquemas de modelos
│   ├── samples/                   # Amostras e registros de amostras
│   ├── schemas/                   # Esquemas JSON para validação
│   └── training/                  # Configurações de treinamento
├── plugins/                       # Plugins de ferramentas de engenharia reversa
│   ├── ghidra/                   # Plugin Ghidra (Java/Gradle)
│   ├── idapro/                   # Plugin IDA Pro (Python)
│   └── binaryninja/              # Plugin Binary Ninja (Python)
├── tests/                         # Conjunto de testes
├── documentation/                 # Documentação
└── LICENSE                        # Licença GPL v3

Ecossistema de Plugins

VMDragonSlayer integra-se com as principais ferramentas de engenharia reversa:

Plugin Ghidra

• Linguagem: Java com sistema de build Gradle
• Funcionalidades: UI de análise de VM, visualização de padrões, fluxos de análise automatizados
• Status: Framework implementado, componentes de UI em desenvolvimento

Plugin IDA Pro

• Linguagem: Python
• Funcionalidades: Integração perfeita com o motor de análise do IDA
• Status: Funcionalidade central disponível

Plugin Binary Ninja

• Linguagem: Python
• Funcionalidades: Integração nativa com a API do Binary Ninja
• Status: Integração básica implementada

Componentes de Aprendizado de Máquina

Nota: Os modelos ML incluídos são implementações básicas de prova de conceito projetadas para fins de pesquisa e educacionais.

Instalação

Pré-requisitos

• Python 3.8 ou superior
• Uma ou mais ferramentas de engenharia reversa:
  • Ghidra 10.0+ (para o plugin Ghidra)
  • IDA Pro 7.0+ (para o plugin IDA)
  • Binary Ninja (para o plugin Binary Ninja)

Requisitos de Hardware

Requisitos Mínimos

• CPU: Processador x64 moderno
• RAM: 8GB mínimo, 16GB recomendado
• Armazenamento: 5GB de espaço livre
• SO: Windows 10/11, Linux (Ubuntu 20.04+), macOS 11+

Requisitos de GPU (Opcional, mas Recomendado)

• GPU NVIDIA: GTX 1060 ou superior para desempenho ideal
• CUDA: Versão 11.8 ou 12.1+ (instalada automaticamente com PyTorch)
• VRAM: 4GB mínimo para modelos ML

Limitações Importantes

• Máquinas Virtuais: Recursos acelerados por GPU requerem acesso direto ao hardware e podem não funcionar em VMs
• WSL: Alguns recursos de GPU podem ter funcionalidade limitada em ambientes WSL
• Servidores Remotos: Certifique-se de que os drivers CUDA estejam instalados corretamente para acesso GPU headless

Status Atual (Problemas Corrigidos)

Exemplos Verificados em Funcionamento

# Isso agora funciona perfeitamente:
from dragonslayer.core.orchestrator import Orchestrator, AnalysisType

orchestrator = Orchestrator()
result = orchestrator.analyze_binary("your_binary.exe", analysis_type=AnalysisType.VM_DISCOVERY)

# Os resultados estão devidamente estruturados:
vmd = result.get("vm_discovery", {})
print(f"VM detectada: {vmd.get('vm_detected', False)}")
print(f"Manipuladores encontrados: {len(vmd.get('handlers_found', []))}")

Início Rápido

# 1. Instalar com todas as dependências
pip install -r requirements.txt
pip install -e .

Framework Principal

# Clonar repositório
git clone https://github.com/poppopjmp/VMDragonSlayer.git
cd VMDragonSlayer

# INSTALAÇÃO ATUALIZADA
# Instalar todas as dependências necessárias, incluindo z3-solver
pip install -r requirements.txt

# Instalar framework em modo de desenvolvimento
pip install -e .

Instalação para Diferentes Hardwares

# Instalação apenas CPU (funcionalidade básica)
pip install -r requirements.txt
pip install -e .

# GPU NVIDIA com CUDA 12.x (séries RTX 30xx/40xx) 
pip install -r requirements.txt
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install -e .

# GPU NVIDIA com CUDA 11.8 (GPUs mais antigas)
pip install -r requirements.txt  
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
pip install -e .

Criar ambiente virtual

python -m venv venv source venv/bin/activate # Linux/macOS

ou

venv\Scripts\activate # Windows

Instalar dependências

pip install -r requirements.txt

Instalar framework

cd dragonslayer pip install -e .

Instalação de Plugin

Escolha seu descompilador preferido:

Plugin Ghidra

cd plugins/ghidra
./build.bat  # Windows
# ou
./build.sh   # Linux/macOS

# Instalar no Ghidra
cp dist/VMDragonSlayer.zip $GHIDRA_INSTALL_DIR/Extensions/

Início Rápido

1. Uso Básico do Framework

from dragonslayer.core.orchestrator import Orchestrator, AnalysisType

# Inicializar orchestrator (carrega configuração padrão automaticamente)
orchestrator = Orchestrator()

# Analisar um binário
result = orchestrator.analyze_binary("path/to/protected_binary.exe", analysis_type=AnalysisType.VM_DISCOVERY)

# Extrair resultados da descoberta de VM
vmd = result.get("vm_discovery", {})
print(f"Proteção de VM Detectada: {vmd.get('vm_detected', False)}")
print(f"Contagem de Manipuladores: {len(vmd.get('handlers_found', []))}")
print(f"Sucesso da Análise: {result.get('success', False)}")

Status dos Plugins

Integrações com Ferramentas de Engenharia Reversa

Arquitetura

VMDragonSlayer usa uma arquitetura modular com múltiplos motores de análise:

Motores de Análise

Motor de Descoberta de VM

• Detecção de Despacho: Identifica loops de despacho de VM usando análise de fluxo de controle
• Mapeamento de Manipuladores: Mapeia manipuladores de VM e suas relações
• Reconhecimento de Arquitetura: Detecta VMProtect, Themida e arquiteturas de VM personalizadas

Motor de Rastreamento de Taint

• Análise Dinâmica: Rastreia fluxo de dados através de manipuladores de VM
• Controle de Precisão: Granularidade em nível de byte ou instrução
• Anti-Evasão: Ignora técnicas comuns de detecção de análise

Motor de Análise de Padrões

• Correspondência de Assinaturas: Reconhecimento de padrões baseado em regras
• Classificação ML: Classificação de manipuladores baseada em aprendizado de máquina
• Análise de Similaridade: Correspondência difusa para detecção de variantes

Motor de Execução Simbólica

• Exploração de Caminhos: Exploração sistemática de caminhos de execução
• Resolução de Restrições: Resolução de restrições baseada em Z3
• Análise Consciente de VM: Tratamento especializado para código virtualizado

Modelos de Aprendizado de Máquina

O framework inclui vários modelos de prova de conceito:

Modelos Disponíveis

• Classificador de Bytecode: Reconhecimento de padrões em sequências de bytecode de VM
• Detector de VM: Classificação binária para presença de proteção de VM
• Classificador de Manipuladores: Classificação de tipos de manipuladores de VM
• Detector de VMProtect: Detector especializado para padrões de VMProtect
• Modelo Ensemble: Combina múltiplos classificadores para precisão melhorada

Características dos Modelos

• Formato: Compatível com Scikit-learn (serialização joblib)
• Tamanho: Modelos pequenos adequados para prototipagem rápida
• Propósito: Exemplos educacionais e linhas de base de pesquisa
• Dados de Treinamento: Amostras sintéticas e limitadas do mundo real

Configuração

Variáveis de Ambiente

# Configuração principal
export VMDS_CONFIG_PATH="/path/to/config"
export VMDS_MODEL_PATH="/path/to/models"  
export VMDS_LOG_LEVEL="INFO"

# Configuração do banco de dados
export VMDS_DB_URL="sqlite:///vmds.db"

# Configuração da API
export VMDS_API_HOST="localhost"
export VMDS_API_PORT="8000"

Arquivos de Configuração

• data/database_config.json: Configurações do banco de dados
• data/taint_config.properties: Parâmetros de análise de taint
• data/models/model_registry_config.toml: Configuração do modelo ML

Exemplos

Configuração Avançada

from dragonslayer.core.config import Config
from dragonslayer.analysis.vm_discovery import VMDiscoveryEngine
from dragonslayer.analysis.taint_tracking import TaintTracker

# Configuração personalizada
config = Config({
    'vm_discovery': {
        'min_handler_count': 10,
        'dispatcher_threshold': 0.8
    },
    'taint_tracking': {
        'precision': 'byte_level',
        'max_depth': 1000
    }
})

# Inicializar motores específicos
vm_engine = VMDiscoveryEngine(config)
taint_tracker = TaintTracker(config)

# Executar análise direcionada
vm_result = vm_engine.analyze("binary.exe")
if vm_result.vm_detected:
    taint_result = taint_tracker.analyze(vm_result.handlers)

Análise em Lote

from dragonslayer.workflows.manager import WorkflowManager

# Processar múltiplos binários
manager = WorkflowManager()
results = manager.process_batch([
    "sample1.exe",
    "sample2.exe", 
    "sample3.exe"
])

# Gerar relatório resumido
manager.generate_report(results, "analysis_report.json")

Contribuindo

Recebemos contribuições! Por favor, veja:

• CONTRIBUTING.md - Diretrizes de desenvolvimento
• CODE_OF_CONDUCT.md - Padrões da comunidade
• SECURITY.md - Política de segurança

Licença

Este projeto está licenciado sob a Licença Pública Geral GNU v3.0. Veja LICENSE para detalhes.

Citação

Se você usar VMDragonSlayer em sua pesquisa, por favor, cite:

@software{vmdragonslayer_2025,
  title   = {VMDragonSlayer: Automated VM-based Binary Protection Analysis},
  author  = {Panico, Agostino},
  year    = {2025},
  url     = {https://github.com/poppopjmp/VMDragonSlayer}
}

Contato

• Autor: van1sh
• Email: [email protected]
• GitHub: @poppopjmp

Agradecimentos

Agradecimentos especiais à comunidade de engenharia reversa e aos desenvolvedores das ferramentas e bibliotecas de análise subjacentes que tornam este framework possível.