🛡️ VMPacker

ARM64 ELF Virtuelles-Maschinen-Schutzsystem

Übersetzt native ARM64-Anweisungen in benutzerdefinierten VM-Bytecode für funktionsweisen Code-Schutz

🇨🇳 中文文档 • Funktionen • Architektur • Schnellstart • Verwendung • Lizenz

Übersicht

VMPacker ist ein Virtual Machine Protection (VMP)-System für ARM64 (AArch64) Linux ELF-Binärdateien. Es dekodiert die nativen ARM64-Anweisungen der Zielfunktion in eine Zwischendarstellung, übersetzt sie in benutzerdefinierten VM-Bytecode und injiziert einen eingebetteten VM-Interpreter in die ELF-Datei. Zur Laufzeit werden geschützte Funktionen vom VM-Interpreter anstatt nativ ausgeführt.

Kernkonzept

ARM64 nativer Code → Dekodieren → Übersetzen → Benutzerdefinierter VM-Bytecode
                                                      ↓
                    Original-ELF ← Injizieren ← VM-Interpreter-Stub

Funktionen

🔄 Befehlsübersetzungsengine

63 VM-Anweisungen — ALU, Speicher, Verzweigung, Syscall und mehr
Tabellengesteuerter Dekoder — Mustererkennung basierend auf dem ARM Architecture Reference Manual
121 ARM64-Anweisungen unterstützt (Basis A64 100% Abdeckung), einschließlich:
- Arithmetik/Logik (ADD, SUB, MUL, AND, ORR, EOR, LSL, LSR, ASR, MVN, BIC, ORN, EON...)
- Multiply-Extend (MADD, MSUB, SMADDL, SMSUBL, UMADDL, UMSUBL, SMULH, UMULH, UDIV, SDIV)
- Datenbewegung (MOV, MOVZ, MOVK, MOVN)
- Speicherzugriff (LDR, STR, LDP, STP, LDPSW, LDADD, CAS, LDAR, STLR, LDAXR, STLXR — verschiedene Breiten und Adressierungsmodi)
- Verzweigungssteuerung (B, BL, BR, BLR, RET, B.cond, CBZ/CBNZ, TBZ/TBNZ)
- Bedingte Auswahl (CSEL, CSINC, CSINV, CSNEG, CCMP, CCMN)
- Bitfeld (UBFM, SBFM, BFM, EXTR)
- Bitmanipulation (CLZ, CLS, RBIT, REV, REV16, REV32)
- Carry-Arithmetik (ADC, ADCS, SBC, SBCS)
- SIMD-Laden/Speichern (LD1, ST1)
- System/Barrieren (SVC, MRS, MSR, ADRP/ADR, DMB, DSB, ISB, HLT, BRK, PRFM)

🔐 Mehrschichtiger Schutz

🖥️ GUI

Plattformunabhängige Desktop-App mit Wails v2 (Go + Vue 3)
Element Plus UI-Komponenten
Symbolfunktionsauswahl + manuelle Funktionseingabe (Schutz nach Adressbereich)
Ein-Klick-Schutz mit Echtzeit-Logausgabe

Architektur

vmp/
├── cmd/vmpacker/          # CLI-Einstiegspunkt
│   ├── main.go            # CLI-Argument-Parsing + Orchestrierung
│   └── vm_interp.bin      # Kompilierter VM-Interpreter (GCC, go:embed)
│
├── pkg/                   # Go-Kernbibliothek
│   ├── arch/arm64/        # ARM64-Architekturunterstützung
│   │   ├── decoder.go     # Tabellengesteuerter Befehlsdekoder (implementiert vm.Decoder)
│   │   ├── decode_*.go    # Dekodierungsmustertabellen (DP-IMM/DP-REG/Branch/LdSt)
│   │   ├── translator.go  # ARM64 → VM-Bytecode-Übersetzer
│   │   ├── tr_alu.go      # ALU-Befehlsübersetzung
│   │   ├── tr_branch.go   # Verzweigungsbefehlsübersetzung
│   │   ├── tr_loadstore.go # Speicherbefehlsübersetzung
│   │   ├── tr_bitfield.go # Bitfeld-Befehlsübersetzung
│   │   └── tr_special.go  # Spezielle Befehle (ADRP/ADR)
│   ├── vm/                # VM-ISA-Definitionen
│   │   ├── types.go       # Gemeinsame Typen + Schnittstellen (Decoder/Translator/Packer)
│   │   ├── opcodes.go     # 58+ VM-Opcode-Definitionen (zufällig zugeordnete Werte)
│   │   └── disasm.go      # VM-Bytecode-Disassembler
│   └── binary/elf/        # ELF-Binärdatei-Manipulation
│       ├── packer.go      # ELF-VMP-Injektion (PT_NOTE-Hijack, Trampolin-Generierung)
│       └── trampoline.go  # Trampolin-Code-Generierung
│
├── stub/                  # C-VM-Interpreter (kompiliert als PIC Flat Binary)
│   ├── vm_interp_clean.c  # Interpreter-Hauptschleife + Einstiegspunkte
│   ├── vm_types.h         # VM-CPU-Kontext (vm_ctx_t)
│   ├── vm_opcodes.h       # C-seitige Opcode-Definitionen (synchron mit opcodes.go)
│   ├── vm_decode.h        # Bytecode-Lese-Dienstprogramme
│   ├── vm_token.h         # Token-Codieren/Decodieren + Deskriptortabelle
│   ├── vm_dispatch.h      # Indirekte Dispatch-Sprungtabelle
│   ├── vm_crc.h           # CRC32-Integritätsprüfung
│   ├── vm_sections.h      # Handler-Abschnitts-Streuungs-Makros
│   ├── vm_interp.lds      # Linker-Skript
│   └── vm_handlers/       # Modulare Anweisungs-Handler
│       ├── h_alu.h        # Arithmetik/Logik-Operationen
│       ├── h_mem.h        # Speicherzugriff
│       ├── h_branch.h     # Verzweigung/Sprung
│       ├── h_cmp.h        # Vergleich/Bedingung
│       ├── h_mov.h        # Datenbewegung
│       ├── h_stack.h      # Stack (PUSH/POP)
│       └── h_system.h     # System (SVC/MRS/BLR/BR/RET)
│
├── vmp-gui/               # Wails-GUI-Frontend
│   ├── frontend/          # Vue 3 + Element Plus
│   └── backend/           # Go-Backend-Bindungen
│
└── build/                 # Vorkompilierte Tools + Test-Artefakte

Modulares Design

Das Projekt verwendet eine schnittstellengesteuerte modulare Architektur, was eine einfache Erweiterung auf neue ISAs und Binärformate ermöglicht:

// Architecture decoder interface — extensible to x86, RISC-V
type Decoder interface {
    Decode(raw uint32, offset int) Instruction
    InstName(op int) string
}

// Bytecode translator interface
type Translator interface {
    Translate(instructions []Instruction) (*TranslateResult, error)
}

// Binary format injector interface — extensible to PE, Mach-O
type Packer interface {
    Process() error
}

Schutz-Pipeline

graph LR
    A[Eingabe ELF] --> B[Zielfunktion lokalisieren]
    B --> C[ARM64-Anweisungen extrahieren]
    C --> D[ARM64 dekodieren]
    D --> E[In VM-Bytecode übersetzen]
    E --> F[XOR-Verschlüsselung des Bytecodes]
    F --> G[VM-Interpreter injizieren]
    G --> H[Trampolin generieren]
    H --> I[Funktionseintritt ersetzen]
    I --> J[Geschützte ELF ausgeben]

Schnellstart

Voraussetzungen

Go 1.21+
GCC (aarch64-linux-gnu-gcc) — zum Kompilieren des Stubs
Linux ARM64 oder Cross-Kompilierungsumgebung

Installation

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

Verwendung

Schutz nach Funktionsname

# Einzelne Funktion schützen
./vmpacker -func check_license -v -o protected.elf original.elf

# Mehrere Funktionen schützen
./vmpacker -func "check_license,verify_token" -v -o protected.elf original.elf

Schutz nach Adressbereich

# Adressbereich angeben
./vmpacker -addr "0x4006AC-0x400790:main" -v -o protected.elf original.elf

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

ELF-Info anzeigen

./vmpacker -info input.elf

CLI-Optionen

Bauen

VM-Interpreter-Stub kompilieren

# Standard Build (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

CLI-Tool kompilieren

go build -o vmpacker ./cmd/vmpacker/

GUI erstellen

cd vmpacker
make gui

VM-ISA-Referenz

VMPacker definiert eine benutzerdefinierte Befehlssatzarchitektur (ISA) mit zufällig zugeordneten Opcode-Werten, um die Reverse-Engineering-Schwierigkeit zu erhöhen.

📖 Für die vollständige Opcode-Tabelle mit Kodierungsdetails siehe die chinesische Dokumentation.

Befehlskategorien

Fahrplan

Vollständige GUI-Integration — Vollständige Integration GUI ↔ Backend-Schutzengine
Hybridmodus — Teilweise native Ausführung + teilweiser VM-Schutz
Dynamische Opcode-Zuordnung — Einzigartige ISA-Zuordnung pro Schutzlauf generieren

Mitwirken

Beiträge sind willkommen! Bitte befolgen Sie diese Richtlinien:

Repository forken
Feature-Branch erstellen: git checkout -b feature/neue-architektur
Änderungen committen: git commit -m 'feat: x86_64-Dekoder hinzugefügt'
Branch pushen: git push origin feature/neue-architektur
Pull Request erstellen

Commit-Konvention

Wir folgen Conventional Commits:

feat: Neue Funktion
fix: Fehlerbehebung
refactor: Code-Umstrukturierung
docs: Dokumentation
test: Tests

Lizenz

Dieses Projekt ist unter der AGPL-3.0-Lizenz lizenziert.

Warum AGPL-3.0:

✅ Starkes Copyleft — Änderungen oder abgeleitete Werke müssen unter derselben Lizenz als Open Source veröffentlicht werden
✅ Netzwerkklausel — Die Bereitstellung der Funktionalität dieser Software als Netzwerkdienst erfordert ebenfalls die Offenlegung des Quellcodes
✅ Schützt Kerntechnologie — Verhindert die Closed-Source-kommerzielle Nutzung der Schutzengine
✅ Community-freundlich — Kostenloses Studium, Forschung und Verbesserung — Verbesserungen müssen zurückgegeben werden
✅ Kommerzielle Lizenzierung — Für Closed-Source-kommerzielle Nutzung kontaktieren Sie den Autor für eine kommerzielle Lizenz

⚠️ Haftungsausschluss

DIESE SOFTWARE WIRD "AS IS" BEREITGESTELLT, OHNE JEGLICHE AUSDRÜCKLICHE ODER STILLSCHWEIGENDE GEWÄHRLEISTUNG, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF DIE GEWÄHRLEISTUNG DER MARKTGÄNGIGKEIT, DER EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND DER NICHTVERLETZUNG VON RECHTEN. IN KEINEM FALL HAFTEN DIE AUTOREN ODER COPYRIGHT-INHABER FÜR JEGLICHE ANSPRÜCHE, SCHÄDEN ODER ANDERE HAFTUNG, OB AUS VERTRAG, UNERLAUBTER HANDLUNG ODER ANDERWEITIG, DIE SICH AUS DER SOFTWARE ODER DER NUTZUNG ODER ANDEREN GESCHÄFTEN MIT DER SOFTWARE ERGEBEN.

Dieses Projekt dient dem legitimen Schutz geistigen Eigentums für Softwareentwickler und hilft, Kernalgorithmen und kritischen Code in kommerzieller Software vor unbefugtem Reverse Engineering oder Diebstahl zu schützen.

Hinweis für Benutzer:

Sie müssen alle geltenden Gesetze und Vorschriften Ihres Rechtsgebiets bei der Nutzung dieser Software einhalten

Es ist strengstens verboten, diese Software für illegale Zwecke zu verwenden, einschließlich, aber nicht beschränkt auf: Entwicklung von Schadsoftware, Umgehung von Sicherheitsprüfungen, Verletzung der Rechte geistigen Eigentums anderer oder Beeinträchtigung der Sicherheit von Computersystemen

Der/die Autor(en) haftet / haften nicht für direkte oder indirekte Folgen, die sich aus der Nutzung dieser Software durch irgendeine Person ergeben

Durch Herunterladen, Nutzen oder Verteilen dieser Software erklären Sie, dass Sie die oben genannten Bedingungen gelesen haben und ihnen zustimmen

Autor

LeoChen — @LeoChen-CoreMind

VM-Schutz	Benutzerdefinierte ISA	Zufällig zugeordnete Opcodes – Reverse Engineers können die Anweisungssemantik nicht direkt identifizieren
OpcodeCryptor	Per-Anweisung Opcode-Verschlüsselung	`enc[pc] = op[pc] ^ (key ^ (pc * 0x9E3779B9))`
Bytecode-Umkehrung	Umkehrung der Ausführungsreihenfolge	Anweisungen in umgekehrter Reihenfolge gespeichert; Interpreter durchläuft rückwärts
Token-Eintritt	3-Anweisungs-Trampolin	Ursprüngliche Funktion durch tokenisierten Eintritt ersetzt, versteckt die tatsächliche Bytecode-Position
Indirekter Dispatch	Funktionszeiger-Sprungtabelle	Wird zur Laufzeit auf dem Stack gefüllt, unterbricht IDA-Kreuzverweise


_{Funktionsliste}	_{Analyse & Auswahl}	_{Schutzoptionen}

_{Echtzeitprotokolle}	_{Schutz abgeschlossen}

`-func`	—	Zu schützende Funktionsname(n) (kommagetrennt)
`-addr`	—	Schutz nach Adresse (`0xSTART-0xEND[:name]`)
`-o`	`input.vmp`	Ausgabedateipfad
`-v`	`false`	Ausführliche Ausgabe (Disassembly anzeigen)
`-strip`	`true`	Symboltabelle entfernen
`-debug`	`false`	ARM64 → VM-Bytecode-Debug-Zuordnungsdatei generieren
`-token`	`true`	Token-basierter Eintrittsmodus
`-info`	`false`	Nur ELF-Info ausgeben

Datenbewegung	3	MOV_IMM64, MOV_IMM32, MOV_REG
Arithmetik/Logik	21	ADD, SUB, MUL, XOR, AND, OR, SHL, SHR, ASR, NOT, ROR, UMULH + _IMM-Varianten
Speicherzugriff	8	LOAD/STORE 8/16/32/64
Verzweigung/Sprung	13	JMP, JE, JNE, JL, JGE, JGT, JLE, JB, JAE, JBE, JA, TBZ, TBNZ
Vergleich	6	CMP, CMP_IMM, CCMP_REG, CCMP_IMM, CCMN_REG, CCMN_IMM
Stack	2	PUSH, POP
System/Spezial	8	NOP, HALT, RET, CALL_NATIVE, CALL_REG, BR_REG, SVC, MRS
SIMD	2	VLD16, VST16
Gesamt	63

Beliebteste

VMPacker