VMDragonSlayer

Il progetto sarà reso pubblico a metà ottobre - Refactoring in corso

Framework avanzato di rilevamento e analisi di macchine virtuali

VMDragonSlayer è un framework completo per l'analisi di binari protetti da protettori basati su macchine virtuali (VM) come VMProtect 2.x/3.x, Themida e VM malware personalizzate. Il framework combina molteplici motori di analisi tra cui Dynamic Taint Tracking (DTT), Symbolic Execution (SE), Classificazione di Pattern e Machine Learning per automatizzare il processo di reverse engineering.

Obiettivo: Trasformare l'analisi complessa di binari protetti da settimane/mesi di lavoro manuale in analisi strutturata e automatizzata con risultati spiegabili.

Caratteristiche principali

• Analisi multi-motore: Combina tecniche di analisi statiche, dinamiche e ibride
• Rilevamento VM: Rilevamento automatico di protettori VM commerciali e personalizzati
• Ecosistema di plugin: Integrazioni con Ghidra, IDA Pro e Binary Ninja
• Machine Learning: Modelli ML proof-of-concept per la classificazione di pattern
• Architettura estensibile: Design modulare per flussi di lavoro di analisi personalizzati
• Framework di ricerca: Progettato per la ricerca su malware e la didattica del reverse engineering

Capacità principali

Panoramica dell'architettura

VMDragonSlayer utilizza un'architettura modulare in cui molteplici motori di analisi lavorano insieme:

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]

Motori di analisi principali

1. Motore di scoperta VM (dragonslayer.analysis.vm_discovery)

• Scopo: Rilevare e classificare schemi di protezione basati su VM
• Tecniche: Rilevamento del ciclo del dispatcher, analisi della tabella degli handler, euristiche del flusso di controllo
• Target: VMProtect, Themida, VM malware personalizzate, protezione annidata

2. Dynamic Taint Tracking (dragonslayer.analysis.taint_tracking)

• Scopo: Tracciare il flusso dei dati attraverso l'esecuzione della VM per identificare percorsi critici
• Implementazione: Strumentazione basata su Intel Pin con precisione a livello di byte
• Caratteristiche: Memoria shadow, elusione dell'analisi, scoperta automatica degli handler

3. Analisi dei pattern (dragonslayer.analysis.pattern_analysis)

• Scopo: Classificare e categorizzare pattern e comportamenti VM
• Metodi: Matching basato su regole, analisi di similarità, classificazione ML
• Database: Database di pattern estensibile con schemi JSON

4. Esecuzione simbolica (dragonslayer.analysis.symbolic_execution)

• Scopo: Esplorare simbolicamente i percorsi di esecuzione della VM
• Caratteristiche: Risoluzione di vincoli, prioritizzazione dei percorsi, merging degli stati
• Integrazione: Utilizza i risultati dell'analisi taint per avviare l'esplorazione

5. Pipeline Machine Learning (dragonslayer.ml)

• Scopo: Classificazione automatica e assistenza all'analisi
• Modelli: Modelli proof-of-concept di base per ricerca e didattica
• Componenti: Estrazione delle feature, addestramento del modello, predizione ensemble

Struttura del repository

VMDragonSlayer/
├── dragonslayer/                    # Pacchetto Python principale
│   ├── analysis/                   # Motori di analisi
│   │   ├── vm_discovery/          # Rilevamento e classificazione VM
│   │   ├── pattern_analysis/      # Matching pattern e classificazione ML
│   │   ├── symbolic_execution/    # Motore di esecuzione simbolica
│   │   ├── taint_tracking/        # Analisi taint dinamica
│   │   └── anti_evasion/          # Contromisure anti-analisi
│   ├── api/                       # Server e client API REST
│   ├── core/                      # Componenti principali del framework
│   ├── ml/                        # Pipeline di machine learning
│   ├── analytics/                 # Report e metriche di analisi
│   ├── gpu/                       # Supporto all'accelerazione GPU
│   ├── utils/                     # Funzioni di utilità
├── data/                          # File di configurazione e dati
│   ├── patterns/                  # Database dei pattern
│   ├── models/                    # Modelli ML e metadati
│   │   ├── pretrained/           # Modelli pre-addestrati (PoC)
│   │   └── metadata/             # Metadati e schemi dei modelli
│   ├── samples/                   # File di esempio e registri
│   ├── schemas/                   # Schemi JSON per validazione
│   └── training/                  # Configurazioni di addestramento
├── plugins/                       # Plugin per strumenti di reverse engineering
│   ├── ghidra/                   # Plugin Ghidra (Java/Gradle)
│   ├── idapro/                   # Plugin IDA Pro (Python)
│   └── binaryninja/              # Plugin Binary Ninja (Python)
├── tests/                         # Suite di test
├── documentation/                 # Documentazione
└── LICENSE                        # Licenza GPL v3

Ecosistema di plugin

VMDragonSlayer si integra con i principali strumenti di reverse engineering:

Plugin Ghidra

• Linguaggio: Java con sistema di build Gradle
• Funzionalità: UI per analisi VM, visualizzazione pattern, flussi di lavoro automatizzati
• Stato: Framework implementato, componenti UI in fase di sviluppo

Plugin IDA Pro

• Linguaggio: Python
• Funzionalità: Integrazione fluida con il motore di analisi di IDA
• Stato: Funzionalità di base disponibili

Plugin Binary Ninja

• Linguaggio: Python
• Funzionalità: Integrazione nativa con API Binary Ninja
• Stato: Integrazione di base implementata

Componenti di Machine Learning

Nota: I modelli ML inclusi sono implementazioni proof-of-concept di base progettate per scopi di ricerca e didattici.

Installazione

Prerequisiti

• Python 3.8 o superiore
• Uno o più strumenti di reverse engineering:
  • Ghidra 10.0+ (per il plugin Ghidra)
  • IDA Pro 7.0+ (per il plugin IDA)
  • Binary Ninja (per il plugin Binary Ninja)

Requisiti hardware

Requisiti minimi

• CPU: Processore x64 moderno
• RAM: 8 GB minimo, 16 GB consigliati
• Storage: 5 GB di spazio libero
• SO: Windows 10/11, Linux (Ubuntu 20.04+), macOS 11+

Requisiti GPU (Opzionali ma consigliati)

• GPU NVIDIA: GTX 1060 o successiva per prestazioni ottimali
• CUDA: Versione 11.8 o 12.1+ (installata automaticamente con PyTorch)
• VRAM: 4 GB minimo per i modelli ML

Limitazioni importanti

• Macchine virtuali: Le funzionalità accelerate da GPU richiedono accesso hardware diretto e potrebbero non funzionare in VM
• WSL: Alcune funzionalità GPU potrebbero avere funzionalità limitate in ambienti WSL
• Server remoti: Assicurarsi che i driver CUDA siano installati correttamente per l'accesso GPU headless

Stato attuale (Problemi risolti)

Esempi verificati funzionanti

# Ora funziona perfettamente:
from dragonslayer.core.orchestrator import Orchestrator, AnalysisType

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

# I risultati sono strutturati correttamente:
vmd = result.get("vm_discovery", {})
print(f"VM detected: {vmd.get('vm_detected', False)}")
print(f"Handlers found: {len(vmd.get('handlers_found', []))}")

Avvio rapido

# 1. Installa con tutte le dipendenze
pip install -r requirements.txt
pip install -e .

Framework principale

# Clona il repository
git clone https://github.com/poppopjmp/VMDragonSlayer.git
cd VMDragonSlayer

# INSTALLAZIONE AGGIORNATA
# Installa tutte le dipendenze richieste incluso z3-solver
pip install -r requirements.txt

# Installa il framework in modalità di sviluppo
pip install -e .

Installazione per diversi hardware

# Installazione solo CPU (funzionalità di base)
pip install -r requirements.txt
pip install -e .

# GPU NVIDIA con CUDA 12.x (serie 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 con CUDA 11.8 (GPU più vecchie)
pip install -r requirements.txt
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
pip install -e .

Crea un ambiente virtuale

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

oppure

venv\Scripts\activate # Windows

Installa le dipendenze

pip install -r requirements.txt

Installa il framework

cd dragonslayer pip install -e .

Installazione dei plugin

Scegli il tuo disassemblatore preferito:

Plugin Ghidra

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

# Installa in Ghidra
cp dist/VMDragonSlayer.zip $GHIDRA_INSTALL_DIR/Extensions/

Avvio rapido

1. Utilizzo base del framework

from dragonslayer.core.orchestrator import Orchestrator, AnalysisType

# Inizializza l'orchestrator (carica automaticamente la configurazione predefinita)
orchestrator = Orchestrator()

# Analizza un binario
result = orchestrator.analyze_binary("path/to/protected_binary.exe", analysis_type=AnalysisType.VM_DISCOVERY)

# Estrai i risultati della scoperta VM
vmd = result.get("vm_discovery", {})
print(f"Protezione VM rilevata: {vmd.get('vm_detected', False)}")
print(f"Conteggio handler: {len(vmd.get('handlers_found', []))}")
print(f"Analisi riuscita: {result.get('success', False)}")

Stato dei plugin

Integrazioni con strumenti di reverse engineering

Architettura

VMDragonSlayer utilizza un'architettura modulare con molteplici motori di analisi:

Motori di analisi

Motore di scoperta VM

• Rilevamento del dispatcher: Identifica i cicli del dispatcher VM tramite analisi del flusso di controllo
• Mappatura degli handler: Mappa gli handler VM e le loro relazioni
• Riconoscimento dell'architettura: Rileva architetture VMProtect, Themida e VM personalizzate

Motore di Taint Tracking

• Analisi dinamica: Traccia il flusso dei dati attraverso gli handler VM
• Controllo di precisione: Granularità a livello di byte o di istruzione
• Anti-elusione: Bypassa le comuni tecniche di rilevamento dell'analisi

Motore di analisi dei pattern

• Matching per firme: Riconoscimento di pattern basato su regole
• Classificazione ML: Classificazione degli handler basata su machine learning
• Analisi di similarità: Matching fuzzy per il rilevamento di varianti

Motore di esecuzione simbolica

• Esplorazione dei percorsi: Esplorazione sistematica dei percorsi di esecuzione
• Risoluzione di vincoli: Risoluzione dei vincoli basata su Z3
• Analisi consapevole della VM: Gestione specializzata per codice virtualizzato

Modelli di Machine Learning

Il framework include diversi modelli proof-of-concept:

Modelli disponibili

• Classificatore di bytecode: Riconoscimento di pattern in sequenze di bytecode VM
• Rilevatore VM: Classificazione binaria per la presenza di protezione VM
• Classificatore di handler: Classificazione dei tipi di handler VM
• Rilevatore VMProtect: Rilevatore specializzato per pattern VMProtect
• Modello Ensemble: Combina più classificatori per una precisione migliorata

Caratteristiche dei modelli

• Formato: Compatibile con Scikit-learn (serializzazione joblib)
• Dimensione: Modelli piccoli adatti per prototipazione rapida
• Scopo: Esempi didattici e baseline di ricerca
• Dati di addestramento: Campioni sintetici e reali limitati

Configurazione

Variabili d'ambiente

# Configurazione principale
export VMDS_CONFIG_PATH="/path/to/config"
export VMDS_MODEL_PATH="/path/to/models"
export VMDS_LOG_LEVEL="INFO"

# Configurazione database
export VMDS_DB_URL="sqlite:///vmds.db"

# Configurazione API
export VMDS_API_HOST="localhost"
export VMDS_API_PORT="8000"

File di configurazione

• data/database_config.json: Impostazioni del database
• data/taint_config.properties: Parametri dell'analisi taint
• data/models/model_registry_config.toml: Configurazione dei modelli ML

Esempi

Configurazione avanzata

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

# Configurazione personalizzata
config = Config({
    'vm_discovery': {
        'min_handler_count': 10,
        'dispatcher_threshold': 0.8
    },
    'taint_tracking': {
        'precision': 'byte_level',
        'max_depth': 1000
    }
})

# Inizializza motori specifici
vm_engine = VMDiscoveryEngine(config)
taint_tracker = TaintTracker(config)

# Esegui analisi mirata
vm_result = vm_engine.analyze("binary.exe")
if vm_result.vm_detected:
    taint_result = taint_tracker.analyze(vm_result.handlers)

Analisi batch

from dragonslayer.workflows.manager import WorkflowManager

# Processa più binari
manager = WorkflowManager()
results = manager.process_batch([
    "sample1.exe",
    "sample2.exe",
    "sample3.exe"
])

# Genera report di riepilogo
manager.generate_report(results, "analysis_report.json")

Contribuire

Accogliamo con favore i contributi! Consultare:

• CONTRIBUTING.md - Linee guida per lo sviluppo
• CODE_OF_CONDUCT.md - Standard della community
• SECURITY.md - Politica di sicurezza

Licenza

Questo progetto è concesso in licenza secondo i termini della GNU General Public License v3.0. Consultare LICENSE per i dettagli.

Citazione

Se utilizzi VMDragonSlayer nella tua ricerca, cita:

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

Contatti

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

Ringraziamenti

Un ringraziamento speciale alla community del reverse engineering e agli sviluppatori degli strumenti e delle librerie di analisi sottostanti che rendono possibile questo framework.