VMDragonSlayer

Le projet sera rendu public d'ici la mi-octobre — Refactorisation en cours

Framework avancé de détection et d'analyse de machines virtuelles

VMDragonSlayer est un framework complet pour l'analyse de binaires protégés par des protecteurs basés sur des machines virtuelles (VM) tels que VMProtect 2.x/3.x, Themida et des VM malveillantes personnalisées. Le framework combine plusieurs moteurs d'analyse incluant le suivi de taint dynamique (DTT), l'exécution symbolique (SE), la classification de motifs et l'apprentissage automatique pour automatiser le processus de rétro-ingénierie.

Objectif : Transformer l'analyse complexe de binaires protégés, qui prend des semaines ou des mois de travail manuel, en une analyse structurée et automatisée avec des résultats explicables.

Fonctionnalités principales

• Analyse multi-moteur : Combine des techniques d'analyse statique, dynamique et hybride
• Détection de VM : Détection automatisée des protecteurs de VM commerciaux et personnalisés
• Écosystème de plugins : Intégrations avec Ghidra, IDA Pro et Binary Ninja
• Apprentissage automatique : Modèles ML de preuve de concept pour la classification de motifs
• Architecture extensible : Conception modulaire pour des workflows d'analyse personnalisés
• Cadre de recherche : Conçu pour la recherche de malwares et l'éducation à la rétro-ingénierie

Capacités principales

Aperçu de l'architecture

VMDragonSlayer utilise une architecture modulaire où plusieurs moteurs d'analyse travaillent ensemble :

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]

Moteurs d'analyse principaux

1. Moteur de découverte de VM (dragonslayer.analysis.vm_discovery)

• Objectif : Détecter et classifier les schémas de protection basés sur les VM
• Techniques : Détection de boucle de répartiteur (dispatcher), analyse de table de handlers, heuristiques de flux de contrôle
• Cibles : VMProtect, Themida, VM malveillantes personnalisées, protection imbriquée

2. Suivi de taint dynamique (dragonslayer.analysis.taint_tracking)

• Objectif : Suivre le flux de données à travers l'exécution de la VM pour identifier les chemins critiques
• Implémentation : Instrumentation basée sur Intel Pin avec une précision au niveau octet
• Fonctionnalités : Mémoire fantôme (shadow memory), contournement d'anti-analyse, découverte automatisée de handlers

3. Analyse de motifs (dragonslayer.analysis.pattern_analysis)

• Objectif : Classifier et catégoriser les motifs et comportements des VM
• Méthodes : Correspondance par règles, analyse de similarité, classification ML
• Base de données : Base de motifs extensible avec schémas JSON

4. Exécution symbolique (dragonslayer.analysis.symbolic_execution)

• Objectif : Explorer symboliquement les chemins d'exécution des VM
• Fonctionnalités : Résolution de contraintes, priorisation de chemins, fusion d'états
• Intégration : Utilise les résultats de l'analyse de taint pour amorcer l'exploration

5. Pipeline d'apprentissage automatique (dragonslayer.ml)

• Objectif : Classification automatisée et assistance à l'analyse
• Modèles : Modèles basiques de preuve de concept pour la recherche et l'éducation
• Composants : Extraction de caractéristiques, entraînement de modèles, prédiction d'ensemble

Structure du dépôt

VMDragonSlayer/
├── dragonslayer/                    # Package Python principal
│   ├── analysis/                   # Moteurs d'analyse
│   │   ├── vm_discovery/          # Détection et classification de VM
│   │   ├── pattern_analysis/      # Correspondance de motifs et classification ML
│   │   ├── symbolic_execution/    # Moteur d'exécution symbolique
│   │   ├── taint_tracking/        # Analyse de taint dynamique
│   │   └── anti_evasion/          # Contre-mesures anti-analyse
│   ├── api/                       # Serveur et client REST API
│   ├── core/                      # Composants principaux du framework
│   ├── ml/                        # Pipeline d'apprentissage automatique
│   ├── analytics/                 # Rapports d'analyse et métriques
│   ├── gpu/                       # Support d'accélération GPU
│   ├── utils/                     # Fonctions utilitaires
├── data/                          # Fichiers de configuration et de données
│   ├── patterns/                  # Base de motifs
│   ├── models/                    # Modèles ML et métadonnées
│   │   ├── pretrained/           # Modèles pré-entraînés (PoC)
│   │   └── metadata/             # Métadonnées et schémas des modèles
│   ├── samples/                   # Fichiers d'exemples et registres
│   ├── schemas/                   # Schémas JSON pour validation
│   └── training/                  # Configurations d'entraînement
├── plugins/                       # Plugins pour outils de rétro-ingénierie
│   ├── ghidra/                   # Plugin Ghidra (Java/Gradle)
│   ├── idapro/                   # Plugin IDA Pro (Python)
│   └── binaryninja/              # Plugin Binary Ninja (Python)
├── tests/                         # Suite de tests
├── documentation/                 # Documentation
└── LICENSE                        # Licence GPL v3

Écosystème de plugins

VMDragonSlayer s'intègre avec les principaux outils de rétro-ingénierie :

Plugin Ghidra

• Langage : Java avec système de build Gradle
• Fonctionnalités : Interface utilisateur d'analyse de VM, visualisation de motifs, workflows d'analyse automatisés
• Statut : Framework implémenté, composants UI en développement

Plugin IDA Pro

• Langage : Python
• Fonctionnalités : Intégration transparente avec le moteur d'analyse d'IDA
• Statut : Fonctionnalités de base disponibles

Plugin Binary Ninja

• Langage : Python
• Fonctionnalités : Intégration native avec l'API de Binary Ninja
• Statut : Intégration de base implémentée

Composants d'apprentissage automatique

Remarque : Les modèles ML inclus sont des implémentations basiques de preuve de concept conçues pour la recherche et l'éducation.

Installation

Prérequis

• Python 3.8 ou supérieur
• Un ou plusieurs outils de rétro-ingénierie :
  • Ghidra 10.0+ (pour le plugin Ghidra)
  • IDA Pro 7.0+ (pour le plugin IDA)
  • Binary Ninja (pour le plugin Binary Ninja)

Configuration matérielle requise

Configuration minimale

• CPU : Processeur x64 moderne
• RAM : 8 Go minimum, 16 Go recommandé
• Stockage : 5 Go d'espace libre
• OS : Windows 10/11, Linux (Ubuntu 20.04+), macOS 11+

Configuration GPU (optionnelle mais recommandée)

• GPU NVIDIA : GTX 1060 ou plus récent pour des performances optimales
• CUDA : Version 11.8 ou 12.1+ (installé automatiquement avec PyTorch)
• VRAM : 4 Go minimum pour les modèles ML

Limitations importantes

• Machines virtuelles : Les fonctionnalités accélérées par GPU nécessitent un accès direct au matériel et peuvent ne pas fonctionner dans les VM
• WSL : Certaines fonctionnalités GPU peuvent avoir des fonctionnalités limitées dans les environnements WSL
• Serveurs distants : Assurez-vous que les pilotes CUDA sont correctement installés pour un accès GPU sans tête (headless)

État actuel (problèmes corrigés)

Exemples fonctionnels vérifiés

# 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', []))}")

Démarrage rapide

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

Framework de base

# 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 pour différents matériels

# 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 .

Installation des plugins

Choisissez votre désassembleur préféré :

Plugin Ghidra

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

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

Démarrage rapide

1. Utilisation de base du framework

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)}")

Statut des plugins

Intégrations avec outils de rétro-ingénierie

Architecture

VMDragonSlayer utilise une architecture modulaire avec plusieurs moteurs d'analyse :

Moteurs d'analyse

Moteur de découverte de VM

• Détection de répartiteur : Identifie les boucles de répartiteur de VM à l'aide de l'analyse de flux de contrôle
• Correspondance de handlers : Cartographie les handlers de VM et leurs relations
• Reconnaissance d'architecture : Détecte les architectures VMProtect, Themida et les architectures VM personnalisées

Moteur de suivi de taint

• Analyse dynamique : Suit le flux de données à travers les handlers de VM
• Contrôle de précision : Granularité au niveau octet ou instruction
• Anti-contournement : Contourne les techniques de détection d'analyse courantes

Moteur d'analyse de motifs

• Correspondance de signatures : Reconnaissance de motifs basée sur des règles
• Classification ML : Classification des handlers basée sur l'apprentissage automatique
• Analyse de similarité : Correspondance floue pour la détection de variantes

Moteur d'exécution symbolique

• Exploration de chemins : Exploration systématique des chemins d'exécution
• Résolution de contraintes : Résolution de contraintes basée sur Z3
• Analyse adaptée aux VM : Traitement spécialisé pour le code virtualisé

Modèles d'apprentissage automatique

Le framework inclut plusieurs modèles de preuve de concept :

Modèles disponibles

• Classifieur de bytecode : Reconnaissance de motifs dans les séquences de bytecode VM
• Détecteur de VM : Classification binaire pour la présence de protection VM
• Classifieur de handlers : Classification des types de handlers VM
• Détecteur VMProtect : Détecteur spécialisé pour les motifs VMProtect
• Modèle d'ensemble : Combine plusieurs classifieurs pour une précision améliorée

Caractéristiques des modèles

• Format : Compatible Scikit-learn (sérialisation joblib)
• Taille : Petits modèles adaptés au prototypage rapide
• Objectif : Exemples éducatifs et bases de recherche
• Données d'entraînement : Échantillons synthétiques et réels limités

Configuration

Variables d'environnement

# 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"

Fichiers de configuration

• data/database_config.json : Paramètres de la base de données
• data/taint_config.properties : Paramètres d'analyse de taint
• data/models/model_registry_config.toml : Configuration des modèles ML

Exemples

Configuration avancée

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)

Analyse par lots

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")

Contribution

Nous accueillons les contributions ! Veuillez consulter :

• CONTRIBUTING.md - Directives de développement
• CODE_OF_CONDUCT.md - Normes communautaires
• SECURITY.md - Politique de sécurité

Licence

Ce projet est sous licence GNU General Public License v3.0. Voir LICENSE pour les détails.

Citation

Si vous utilisez VMDragonSlayer dans vos recherches, veuillez citer :

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

Contact

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

Remerciements

Un grand merci à la communauté de la rétro-ingénierie et aux développeurs des outils et bibliothèques d'analyse sous-jacents qui rendent ce framework possible.