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]

VMDragonSlayer/
├── dragonslayer/                    # 메인 Python 패키지
│   ├── analysis/                   # 분석 엔진
│   │   ├── vm_discovery/          # VM 탐지 및 분류
│   │   ├── pattern_analysis/      # 패턴 매칭 및 ML 분류
│   │   ├── symbolic_execution/    # 기호 실행 엔진
│   │   ├── taint_tracking/        # 동적 오염 분석
│   │   └── anti_evasion/          # 안티 분석 대응책
│   ├── api/                       # REST API 서버 및 클라이언트
│   ├── core/                      # 핵심 프레임워크 구성 요소
│   ├── ml/                        # 머신러닝 파이프라인
│   ├── analytics/                 # 분석 보고 및 메트릭
│   ├── gpu/                       # GPU 가속 지원
│   ├── utils/                     # 유틸리티 함수
├── data/                          # 설정 및 데이터 파일
│   ├── patterns/                  # 패턴 데이터베이스
│   ├── models/                    # ML 모델 및 메타데이터
│   │   ├── pretrained/           # 사전 학습 모델 (PoC)
│   │   └── metadata/             # 모델 메타데이터 및 스키마
│   ├── samples/                   # 샘플 파일 및 레지스트리
│   ├── schemas/                   # 검증용 JSON 스키마
│   └── training/                  # 학습 구성
├── plugins/                       # 리버스 엔지니어링 도구 플러그인
│   ├── ghidra/                   # Ghidra 플러그인 (Java/Gradle)
│   ├── idapro/                   # IDA Pro 플러그인 (Python)
│   └── binaryninja/              # Binary Ninja 플러그인 (Python)
├── tests/                         # 테스트 스위트
├── documentation/                 # 문서
└── LICENSE                        # GPL v3 라이선스

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

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

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

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

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

# Ghidra에 설치
cp dist/VMDragonSlayer.zip $GHIDRA_INSTALL_DIR/Extensions/

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

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

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)

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

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