VMDragonSlayer

Das Projekt wird Mitte Oktober veröffentlicht. Refactoring läuft.

Fortschrittliches Framework zur Erkennung und Analyse von Virtuellen Maschinen

VMDragonSlayer ist ein umfassendes Framework zur Analyse von Binärdateien, die durch VM-basierte Schutzhüllen wie VMProtect 2.x/3.x, Themida und benutzerdefinierte Malware-VMs geschützt sind. Das Framework kombiniert mehrere Analyse-Engines, darunter Dynamic Taint Tracking (DTT), Symbolic Execution (SE), Pattern Classification und Machine Learning, um den Reverse-Engineering-Prozess zu automatisieren.

Ziel: Die Analyse komplexer geschützter Binärdateien von Wochen/Monaten manueller Arbeit in eine strukturierte, automatisierte Analyse mit erklärbaren Ergebnissen umwandeln.

Hauptfunktionen

• Multi-Engine-Analyse: Kombiniert statische, dynamische und hybride Analysetechniken
• VM-Erkennung: Automatisierte Erkennung von kommerziellen und benutzerdefinierten VM-Schutzmechanismen
• Plugin-Ökosystem: Integrationen mit Ghidra, IDA Pro und Binary Ninja
• Machine Learning: Proof-of-Concept-ML-Modelle zur Musterklassifikation
• Erweiterbare Architektur: Modulares Design für benutzerdefinierte Analyse-Workflows
• Forschungs-Framework: Entwickelt für Malware-Forschung und Reverse-Engineering-Ausbildung

Kernfähigkeiten

Architekturübersicht

VMDragonSlayer verwendet eine modulare Architektur, in der mehrere Analyse-Engines zusammenarbeiten:

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]

Kernanalyse-Engines

1. VM-Erkennungs-Engine (dragonslayer.analysis.vm_discovery)

• Zweck: Erkennung und Klassifizierung von VM-basierten Schutzschemen
• Techniken: Dispatcher-Loop-Erkennung, Handler-Tabellen-Analyse, Kontrollfluss-Heuristiken
• Ziele: VMProtect, Themida, benutzerdefinierte Malware-VMs, verschachtelter Schutz

2. Dynamisches Taint-Tracking (dragonslayer.analysis.taint_tracking)

• Zweck: Verfolgung des Datenflusses durch die VM-Ausführung, um kritische Pfade zu identifizieren
• Implementierung: Intel Pin-basierte Instrumentierung mit Byte-Level-Präzision
• Funktionen: Shadow Memory, Anti-Analyse-Umgehung, automatisierte Handler-Erkennung

3. Musteranalyse (dragonslayer.analysis.pattern_analysis)

• Zweck: Klassifizierung und Kategorisierung von VM-Mustern und -Verhalten
• Methoden: Regelbasiertes Matching, Ähnlichkeitsanalyse, ML-Klassifikation
• Datenbank: Erweiterbare Musterdatenbank mit JSON-Schemata

4. Symbolische Ausführung (dragonslayer.analysis.symbolic_execution)

• Zweck: Symbolische Exploration von VM-Ausführungspfaden
• Funktionen: Constraint-Lösung, Pfadpriorisierung, Zustandsverschmelzung
• Integration: Nutzt Taint-Analyse-Ergebnisse zur Initialisierung der Exploration

5. Machine-Learning-Pipeline (dragonslayer.ml)

• Zweck: Automatisierte Klassifikation und Analyseunterstützung
• Modelle: Grundlegende Proof-of-Concept-Modelle für Forschung und Bildung
• Komponenten: Merkmalsextraktion, Modelltraining, Ensemble-Vorhersage

Repository-Struktur

VMDragonSlayer/
├── dragonslayer/                    # Haupt-Python-Paket
│   ├── analysis/                   # Analyse-Engines
│   │   ├── vm_discovery/          # VM-Erkennung und -Klassifikation
│   │   ├── pattern_analysis/      # Musterabgleich und ML-Klassifikation
│   │   ├── symbolic_execution/    # Symbolische Ausführungs-Engine
│   │   ├── taint_tracking/        # Dynamische Taint-Analyse
│   │   └── anti_evasion/          # Anti-Analyse-Gegenmaßnahmen
│   ├── api/                       # REST-API-Server und -Client
│   ├── core/                      # Kernkomponenten des Frameworks
│   ├── ml/                        # Machine-Learning-Pipeline
│   ├── analytics/                 # Analyseberichte und Metriken
│   ├── gpu/                       # GPU-Beschleunigungsunterstützung
│   ├── utils/                     # Hilfsfunktionen
├── data/                          # Konfigurations- und Datendateien
│   ├── patterns/                  # Musterdatenbank
│   ├── models/                    # ML-Modelle und Metadaten
│   │   ├── pretrained/           # Vorgewichtete Modelle (PoC)
│   │   └── metadata/             # Modell-Metadaten und Schemata
│   ├── samples/                   # Beispieldateien und Register
│   ├── schemas/                   # JSON-Schemata zur Validierung
│   └── training/                  # Trainingskonfigurationen
├── plugins/                       # Reverse-Engineering-Tool-Plugins
│   ├── ghidra/                   # Ghidra-Plugin (Java/Gradle)
│   ├── idapro/                   # IDA-Pro-Plugin (Python)
│   └── binaryninja/              # Binary-Ninja-Plugin (Python)
├── tests/                         # Testsuite
├── documentation/                 # Dokumentation
└── LICENSE                        # GPL v3 Lizenz

Plugin-Ökosystem

VMDragonSlayer integriert sich mit den wichtigsten Reverse-Engineering-Tools:

Ghidra-Plugin

• Sprache: Java mit Gradle-Build-System
• Funktionen: VM-Analyse-UI, Muster-Visualisierung, automatisierte Analyse-Workflows
• Status: Framework implementiert, UI-Komponenten in Entwicklung

IDA-Pro-Plugin

• Sprache: Python
• Funktionen: Nahtlose Integration mit IDAs Analyse-Engine
• Status: Kernfunktionalität verfügbar

Binary-Ninja-Plugin

• Sprache: Python
• Funktionen: Native Binary-Ninja-API-Integration
• Status: Grundlegende Integration implementiert

Machine-Learning-Komponenten

Hinweis: Die enthaltenen ML-Modelle sind grundlegende Proof-of-Concept-Implementierungen, die für Forschungs- und Bildungszwecke konzipiert sind.

Installation

Voraussetzungen

• Python 3.8 oder höher
• Ein oder mehrere Reverse-Engineering-Tools:
  • Ghidra 10.0+ (für Ghidra-Plugin)
  • IDA Pro 7.0+ (für IDA-Plugin)
  • Binary Ninja (für Binary-Ninja-Plugin)

Hardware-Anforderungen

Mindestanforderungen

• CPU: Moderner x64-Prozessor
• RAM: mindestens 8 GB, empfohlen 16 GB
• Speicher: 5 GB freier Speicherplatz
• Betriebssystem: Windows 10/11, Linux (Ubuntu 20.04+), macOS 11+

GPU-Anforderungen (Optional, aber empfohlen)

• NVIDIA GPU: GTX 1060 oder neuer für optimale Leistung
• CUDA: Version 11.8 oder 12.1+ (wird automatisch mit PyTorch installiert)
• VRAM: mindestens 4 GB für ML-Modelle

Wichtige Einschränkungen

• Virtuelle Maschinen: GPU-beschleunigte Funktionen benötigen direkten Hardwarezugriff und funktionieren möglicherweise nicht in VMs
• WSL: Einige GPU-Funktionen könnten in WSL-Umgebungen eingeschränkt sein
• Remote-Server: Stellen Sie sicher, dass CUDA-Treiber korrekt installiert sind, um GPU-Zugriff im Headless-Modus zu ermöglichen

Aktueller Status (Behobene Probleme)

Verifizierte funktionierende Beispiele

# This now works perfectly:
from dragonslayer.core.orchestrator import Orchestrator, AnalysisType

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

# Results are properly structured:
vmd = result.get("vm_discovery", {})
print(f"VM detected: {vmd.get('vm_detected', False)}")
print(f"Handlers found: {len(vmd.get('handlers_found', []))}")

Schnellstart

# 1. Install with all dependencies
pip install -r requirements.txt
pip install -e .

Kern-Framework

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

# UPDATED INSTALLATION
# Install all required dependencies including z3-solver
pip install -r requirements.txt

# Install framework in development mode
pip install -e .

Installation für verschiedene Hardware

# CPU-only installation (basic functionality)
pip install -r requirements.txt
pip install -e .

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

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

Create virtual environment

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

or

venv\Scripts\activate # Windows

Install dependencies

pip install -r requirements.txt

Install framework

cd dragonslayer pip install -e .

Plugin-Installation

Wählen Sie Ihren bevorzugten Disassembler:

Ghidra-Plugin

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

# Install to Ghidra
cp dist/VMDragonSlayer.zip $GHIDRA_INSTALL_DIR/Extensions/

Schnellstart

1. Grundlegende Framework-Nutzung

from dragonslayer.core.orchestrator import Orchestrator, AnalysisType

# Initialize orchestrator (loads default configuration automatically)
orchestrator = Orchestrator()

# Analyze a binary
result = orchestrator.analyze_binary("path/to/protected_binary.exe", analysis_type=AnalysisType.VM_DISCOVERY)

# Extract VM discovery results
vmd = result.get("vm_discovery", {})
print(f"VM Protection Detected: {vmd.get('vm_detected', False)}")
print(f"Handler Count: {len(vmd.get('handlers_found', []))}")
print(f"Analysis Success: {result.get('success', False)}")

Plugin-Status

Reverse-Engineering-Tool-Integrationen

Architektur

VMDragonSlayer verwendet eine modulare Architektur mit mehreren Analyse-Engines:

Analyse-Engines

VM-Erkennungs-Engine

• Dispatcher-Erkennung: Identifiziert VM-Dispatcher-Schleifen mittels Kontrollflussanalyse
• Handler-Mapping: Kartiert VM-Handler und ihre Beziehungen
• Architektur-Erkennung: Erkennt VMProtect-, Themida- und benutzerdefinierte VM-Architekturen

Taint-Tracking-Engine

• Dynamische Analyse: Verfolgt Datenfluss durch VM-Handler
• Präzisionssteuerung: Byte-Level- oder Instruktions-Level-Granularität
• Anti-Evasion: Umgeht gängige Erkennungstechniken der Analyse

Musteranalyse-Engine

• Signatur-Matching: Regelbasierte Mustererkennung
• ML-Klassifikation: Maschinelles Lernen-basierte Handler-Klassifikation
• Ähnlichkeitsanalyse: Fuzzy-Matching zur Variantenerkennung

Symbolische Ausführungs-Engine

• Pfadexploration: Systematische Exploration von Ausführungspfaden
• Constraint-Lösung: Z3-basierte Constraint-Auflösung
• VM-bewusste Analyse: Spezielle Handhabung virtualisierten Codes

Machine-Learning-Modelle

Das Framework enthält mehrere Proof-of-Concept-Modelle:

Verfügbare Modelle

• Bytecode-Klassifikator: Mustererkennung in VM-Bytecode-Sequenzen
• VM-Detektor: Binäre Klassifikation für das Vorhandensein von VM-Schutz
• Handler-Klassifikator: Klassifikation von VM-Handler-Typen
• VMProtect-Detektor: Spezialisierter Detektor für VMProtect-Muster
• Ensemble-Modell: Kombiniert mehrere Klassifikatoren für verbesserte Genauigkeit

Modelleigenschaften

• Format: Scikit-learn-kompatibel (joblib-Serialisierung)
• Größe: Kleine Modelle, geeignet für schnelles Prototyping
• Zweck: Bildungsbeispiele und Forschungs-Baselines
• Trainingsdaten: Synthetische und begrenzte reale Beispiele

Konfiguration

Umgebungsvariablen

# Core configuration
export VMDS_CONFIG_PATH="/path/to/config"
export VMDS_MODEL_PATH="/path/to/models"  
export VMDS_LOG_LEVEL="INFO"

# Database configuration
export VMDS_DB_URL="sqlite:///vmds.db"

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

Konfigurationsdateien

• data/database_config.json: Datenbankeinstellungen
• data/taint_config.properties: Taint-Analyse-Parameter
• data/models/model_registry_config.toml: ML-Modellkonfiguration

Beispiele

Fortgeschrittene Konfiguration

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

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

# Initialize specific engines
vm_engine = VMDiscoveryEngine(config)
taint_tracker = TaintTracker(config)

# Run targeted analysis
vm_result = vm_engine.analyze("binary.exe")
if vm_result.vm_detected:
    taint_result = taint_tracker.analyze(vm_result.handlers)

Batch-Analyse

from dragonslayer.workflows.manager import WorkflowManager

# Process multiple binaries
manager = WorkflowManager()
results = manager.process_batch([
    "sample1.exe",
    "sample2.exe", 
    "sample3.exe"
])

# Generate summary report
manager.generate_report(results, "analysis_report.json")

Mitwirken

Wir begrüßen Beiträge! Bitte siehe:

• CONTRIBUTING.md – Entwicklungsrichtlinien
• CODE_OF_CONDUCT.md – Gemeinschaftsstandards
• SECURITY.md – Sicherheitsrichtlinie

Lizenz

Dieses Projekt ist unter der GNU General Public License v3.0 lizenziert. Siehe LICENSE für Details.

Zitierung

Wenn Sie VMDragonSlayer in Ihrer Forschung verwenden, zitieren Sie bitte:

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

Kontakt

• Autor: van1sh
• E-Mail: [email protected]
• GitHub: @poppopjmp

Danksagungen

Besonderer Dank gilt der Reverse-Engineering-Community und den Entwicklern der zugrunde liegenden Analyse-Tools und Bibliotheken, die dieses Framework ermöglichen.