🛡️ VMPacker

Système de Protection par Machine Virtuelle pour ELF ARM64

Traduit les instructions natives ARM64 en bytecode VM personnalisé pour une protection au niveau des fonctions

🇨🇳 中文文档 • Fonctionnalités • Architecture • Démarrage rapide • Utilisation • Licence

Aperçu

VMPacker est un système de Protection par Machine Virtuelle (VMP) pour les binaires ELF Linux ARM64 (AArch64). Il décode les instructions natives ARM64 de la fonction cible en une représentation intermédiaire, les traduit en bytecode VM personnalisé et injecte un interpréteur VM embarqué dans le fichier ELF. À l'exécution, les fonctions protégées sont exécutées par l'interpréteur VM au lieu de nativement.

Concept central

Code natif ARM64  →  Décodage  →  Traduction  →  Bytecode VM personnalisé
                                                      ↓
                    ELF original  ←  Injection  ←  Stub de l'interpréteur VM

Fonctionnalités

🔄 Moteur de traduction d'instructions

• 63 instructions VM — couvrant ALU, mémoire, branchement, appel système, etc.
• Décodeur piloté par tables — correspondance de motifs basée sur le Manuel de Référence de l'Architecture ARM
• 121 instructions ARM64 prises en charge (couverture de base A64 à 100 %), incluant :
  • Arithmétique/Logique (ADD, SUB, MUL, AND, ORR, EOR, LSL, LSR, ASR, MVN, BIC, ORN, EON...)
  • Multiplication-extension (MADD, MSUB, SMADDL, SMSUBL, UMADDL, UMSUBL, SMULH, UMULH, UDIV, SDIV)
  • Mouvement de données (MOV, MOVZ, MOVK, MOVN)
  • Accès mémoire (LDR, STR, LDP, STP, LDPSW, LDADD, CAS, LDAR, STLR, LDAXR, STLXR — diverses largeurs et modes d'adressage)
  • Contrôle de branchement (B, BL, BR, BLR, RET, B.cond, CBZ/CBNZ, TBZ/TBNZ)
  • Sélection conditionnelle (CSEL, CSINC, CSINV, CSNEG, CCMP, CCMN)
  • Champs de bits (UBFM, SBFM, BFM, EXTR)
  • Manipulation de bits (CLZ, CLS, RBIT, REV, REV16, REV32)
  • Arithmétique avec retenue (ADC, ADCS, SBC, SBCS)
  • Chargement/Stockage SIMD (LD1, ST1)
  • Système/Barrières (SVC, MRS, MSR, ADRP/ADR, DMB, DSB, ISB, HLT, BRK, PRFM)

🔐 Protection multicouche

🖥️ Interface graphique

• Application de bureau multiplateforme construite avec Wails v2 (Go + Vue 3)
• Composants d'interface Element Plus
• Sélection de fonctions symboliques + saisie manuelle de fonctions (protection par plage d'adresses)
• Protection en un clic avec sortie de logs en temps réel

Architecture

vmp/
├── cmd/vmpacker/          # Point d'entrée CLI
│   ├── main.go            # Analyse des arguments CLI + orchestration
│   └── vm_interp.bin      # Interpréteur VM compilé (GCC, go:embed)
│
├── pkg/                   # Bibliothèque principale Go
│   ├── arch/arm64/        # Support de l'architecture ARM64
│   │   ├── decoder.go     # Décodeur d'instructions piloté par tables (implémente vm.Decoder)
│   │   ├── decode_*.go    # Tables de motifs de décodage (DP-IMM/DP-REG/Branch/LdSt)
│   │   ├── translator.go  # Traducteur ARM64 → bytecode VM
│   │   ├── tr_alu.go      # Traduction des instructions ALU
│   │   ├── tr_branch.go   # Traduction des instructions de branchement
│   │   ├── tr_loadstore.go # Traduction des instructions mémoire
│   │   ├── tr_bitfield.go # Traduction des instructions de champ de bits
│   │   └── tr_special.go  # Instructions spéciales (ADRP/ADR)
│   ├── vm/                # Définitions de l'ISA VM
│   │   ├── types.go       # Types partagés + interfaces (Decoder/Translator/Packer)
│   │   ├── opcodes.go     # 58+ définitions d'opcodes VM (valeurs mappées aléatoirement)
│   │   └── disasm.go      # Désassembleur de bytecode VM
│   └── binary/elf/        # Manipulation des binaires ELF
│       ├── packer.go      # Injection VMP ELF (détournement PT_NOTE, génération de trampoline)
│       └── trampoline.go  # Génération de code de trampoline
│
├── stub/                  # Interpréteur VM en C (compilé en binaire plat PIC)
│   ├── vm_interp_clean.c  # Boucle principale de l'interpréteur + points d'entrée
│   ├── vm_types.h         # Contexte CPU VM (vm_ctx_t)
│   ├── vm_opcodes.h       # Définitions d'opcodes côté C (synchronisées avec opcodes.go)
│   ├── vm_decode.h        # Utilitaires de lecture du bytecode
│   ├── vm_token.h         # Encodage/décodage des jetons + table de descripteurs
│   ├── vm_dispatch.h      # Table de distribution indirecte
│   ├── vm_crc.h           # Vérification d'intégrité CRC32
│   ├── vm_sections.h      # Macros de dispersion des sections de gestionnaires
│   ├── vm_interp.lds      # Script de l'éditeur de liens
│   └── vm_handlers/       # Gestionnaires d'instructions modulaires
│       ├── h_alu.h        # Opérations arithmétiques/logiques
│       ├── h_mem.h        # Accès mémoire
│       ├── h_branch.h     # Branchement/saut
│       ├── h_cmp.h        # Comparaison/conditionnel
│       ├── h_mov.h        # Mouvement de données
│       ├── h_stack.h      # Pile (PUSH/POP)
│       └── h_system.h     # Système (SVC/MRS/BLR/BR/RET)
│
├── vmp-gui/               # Interface graphique Wails
│   ├── frontend/          # Vue 3 + Element Plus
│   └── backend/           # Liaisons Go backend
│
└── build/                 # Outils pré-compilés + artefacts de test

Conception modulaire

Le projet utilise une architecture modulaire pilotée par interfaces, ce qui facilite l'extension à de nouveaux ISA et formats binaires :

// Interface du décodeur d'architecture — extensible à x86, RISC-V
type Decoder interface {
    Decode(raw uint32, offset int) Instruction
    InstName(op int) string
}

// Interface du traducteur de bytecode
type Translator interface {
    Translate(instructions []Instruction) (*TranslateResult, error)
}

// Interface de l'injecteur de format binaire — extensible à PE, Mach-O
type Packer interface {
    Process() error
}

Pipeline de protection

graph LR
    A[ELF d'entrée] --> B[Localiser la fonction cible]
    B --> C[Extraire les instructions ARM64]
    C --> D[Décoder ARM64]
    D --> E[Traduire en bytecode VM]
    E --> F[Chiffrer le bytecode par XOR]
    F --> G[Injecter l'interpréteur VM]
    G --> H[Générer le trampoline]
    H --> I[Remplacer l'entrée de la fonction]
    I --> J[ELF protégé en sortie]

Démarrage rapide

Prérequis

• Go 1.21+
• GCC (aarch64-linux-gnu-gcc) — pour compiler le stub
• Linux ARM64 ou environnement de compilation croisée

Installation

git clone https://github.com/LeoChen-CoreMind/VMPacker.git
cd VMPacker
make all

Utilisation

Protection par nom de fonction

# Protéger une seule fonction
./vmpacker -func check_license -v -o protected.elf original.elf

# Protéger plusieurs fonctions
./vmpacker -func "check_license,verify_token" -v -o protected.elf original.elf

Protection par plage d'adresses

# Spécifier une plage d'adresses
./vmpacker -addr "0x4006AC-0x400790:main" -v -o protected.elf original.elf

# Mode mixte
./vmpacker -addr "0x4006AC-0x400790:main" -func verify -o protected.elf original.elf

Inspecter les informations ELF

./vmpacker -info input.elf

Options CLI

Construction

Compiler le stub de l'interpréteur VM

# Construction standard (GCC)
aarch64-linux-gnu-gcc -Os -nostdlib -fPIC -ffreestanding \
  -o stub.elf stub/vm_interp_clean.c \
  -T stub/vm_interp.lds
aarch64-linux-gnu-objcopy -O binary stub.elf vm_interp.bin

Compiler l'outil CLI

go build -o vmpacker ./cmd/vmpacker/

Construire l'interface graphique

cd vmpacker
make gui

Référence de l'ISA VM

VMPacker définit une architecture de jeu d'instructions (ISA) personnalisée avec des valeurs d'opcodes mappées aléatoirement pour augmenter la difficulté de rétro-ingénierie.

📖 Pour la table complète des opcodes avec les détails d'encodage, voir la documentation chinoise.

Catégories d'instructions

Feuille de route

• Intégration complète de l'interface graphique — Intégration complète du moteur de protection GUI ↔ backend
• Mode hybride — Exécution native partielle + protection VM partielle
• Mappage dynamique des opcodes — Générer un mappage ISA unique par exécution de protection

Contribution

Les contributions sont les bienvenues ! Veuillez suivre ces directives :

1. Forker le dépôt
2. Créer une branche de fonctionnalité : git checkout -b feature/nouvelle-arch
3. Valider vos modifications : git commit -m 'feat: ajout du décodeur x86_64'
4. Pousser la branche : git push origin feature/nouvelle-arch
5. Créer une Pull Request

Convention de validation

Nous suivons les Commits Conventionnels :

• feat: Nouvelle fonctionnalité
• fix: Correction de bug
• refactor: Refactorisation du code
• docs: Documentation
• test: Tests

Licence

Ce projet est sous licence AGPL-3.0.

Pourquoi AGPL-3.0 :

• ✅ Copyleft fort — Toute modification ou œuvre dérivée doit être open-source sous la même licence
• ✅ Clause d'utilisation en réseau — Fournir les fonctionnalités de ce logiciel en tant que service réseau nécessite également la divulgation du code source
• ✅ Protège la technologie de base — Empêche l'utilisation commerciale en source fermée du moteur de protection
• ✅ Amical pour la communauté — Libre d'étude, de recherche et d'amélioration — les améliorations doivent être partagées en retour
• ✅ Licence commerciale — Pour une utilisation commerciale en source fermée, contactez l'auteur pour une licence commerciale

⚠️ Avertissement

CE LOGICIEL EST FOURNI "EN L'ÉTAT", SANS GARANTIE D'AUCUNE SORTE, EXPLICITE OU IMPLICITE, Y COMPRIS MAIS SANS S'Y LIMITER LES GARANTIES DE QUALITÉ MARCHANDE, D'ADÉQUATION À UN USAGE PARTICULIER ET D'ABSENCE DE CONTREFAÇON. EN AUCUN CAS LES AUTEURS OU TITULAIRES DU DROIT D'AUTEUR NE POURRONT ÊTRE TENUS RESPONSABLES DE TOUTE RÉCLAMATION, DOMMAGE OU AUTRE RESPONSABILITÉ, QUE CE SOIT DANS LE CADRE D'UNE ACTION CONTRACTUELLE, DÉLICTUELLE OU AUTRE, DÉCOULANT DE, OU EN RELATION AVEC LE LOGICIEL OU SON UTILISATION OU AUTRE INTERACTION AVEC LE LOGICIEL.

Ce projet est conçu pour fournir une protection légitime de la propriété intellectuelle aux développeurs de logiciels, aidant à protéger les algorithmes fondamentaux et le code critique dans les logiciels commerciaux contre la rétro-ingénierie ou le vol non autorisé.

Avis à l'utilisateur :

1. Vous devez respecter toutes les lois et réglementations applicables dans votre juridiction lors de l'utilisation de ce logiciel
2. Il est strictement interdit d'utiliser ce logiciel à des fins illégales, y compris mais sans s'y limiter : développement de logiciels malveillants, contournement d'audits de sécurité, violation des droits de propriété intellectuelle d'autrui, ou compromission de la sécurité des systèmes informatiques
3. Le(s) auteur(s) ne pourra(ont) être tenu(s) responsable(s) des conséquences directes ou indirectes résultant de l'utilisation de ce logiciel par quiconque
4. En téléchargeant, utilisant ou distribuant ce logiciel, vous reconnaissez avoir lu et accepté les termes ci-dessus

Auteur

LeoChen — @LeoChen-CoreMind

Copyright © 2026 LeoChen. Tous droits réservés.