🛡️ VMPacker

Sistema di Protezione per Macchine Virtuali ARM64 ELF

Traduce le istruzioni native ARM64 in bytecode VM personalizzato per la protezione del codice a livello di funzione

🇨🇳 中文文档 • Caratteristiche • Architettura • Avvio Rapido • Utilizzo • Licenza

Panoramica

VMPacker è un sistema di Protezione tramite Macchina Virtuale (VM) per eseguibili ARM64 (AArch64) Linux ELF. Decodifica le istruzioni native ARM64 della funzione target in una rappresentazione intermedia, le traduce in bytecode VM personalizzato e inietta un interprete VM incorporato nel file ELF. In esecuzione, le funzioni protette vengono eseguite dall'interprete VM invece che nativamente.

Concetto principale

ARM64 Native Code  →  Decode  →  Translate  →  Custom VM Bytecode
                                                      ↓
                    Original ELF  ←  Inject  ←  VM Interpreter Stub

Caratteristiche

🔄 Motore di Traduzione Istruzioni

63 istruzioni VM — che coprono ALU, memoria, salti, syscall e altro
Decodificatore basato su tabelle — corrispondenza di pattern basata sul Manuale di Riferimento dell'Architettura ARM
121 istruzioni ARM64 supportate (copertura base A64 100%), incluse:
- Aritmetica/Logica (ADD, SUB, MUL, AND, ORR, EOR, LSL, LSR, ASR, MVN, BIC, ORN, EON...)
- Moltiplicazione-Estensione (MADD, MSUB, SMADDL, SMSUBL, UMADDL, UMSUBL, SMULH, UMULH, UDIV, SDIV)
- Movimento Dati (MOV, MOVZ, MOVK, MOVN)
- Accesso alla Memoria (LDR, STR, LDP, STP, LDPSW, LDADD, CAS, LDAR, STLR, LDAXR, STLXR — varie larghezze e modalità di indirizzamento)
- Controllo di Salto (B, BL, BR, BLR, RET, B.cond, CBZ/CBNZ, TBZ/TBNZ)
- Selezione Condizionale (CSEL, CSINC, CSINV, CSNEG, CCMP, CCMN)
- Campi di Bit (UBFM, SBFM, BFM, EXTR)
- Manipolazione di Bit (CLZ, CLS, RBIT, REV, REV16, REV32)
- Aritmetica con Riporto (ADC, ADCS, SBC, SBCS)
- Caricamento/Archiviazione SIMD (LD1, ST1)
- Sistema/Barriere (SVC, MRS, MSR, ADRP/ADR, DMB, DSB, ISB, HLT, BRK, PRFM)

🔐 Protezione a Più Strati

🖥️ Interfaccia Grafica

App desktop multipiattaforma realizzata con Wails v2 (Go + Vue 3)
Componenti UI Element Plus
Selezione di funzioni simboliche + input manuale di funzioni (protezione per intervallo di indirizzi)
Protezione con un clic con output di log in tempo reale

Architettura

vmp/
├── cmd/vmpacker/          # CLI entry point
│   ├── main.go            # CLI argument parsing + orchestration
│   └── vm_interp.bin      # Compiled VM interpreter (GCC, go:embed)
│
├── pkg/                   # Go core library
│   ├── arch/arm64/        # ARM64 architecture support
│   │   ├── decoder.go     # Table-driven instruction decoder (implements vm.Decoder)
│   │   ├── decode_*.go    # Decode pattern tables (DP-IMM/DP-REG/Branch/LdSt)
│   │   ├── translator.go  # ARM64 → VM bytecode translator
│   │   ├── tr_alu.go      # ALU instruction translation
│   │   ├── tr_branch.go   # Branch instruction translation
│   │   ├── tr_loadstore.go # Memory instruction translation
│   │   ├── tr_bitfield.go # Bitfield instruction translation
│   │   └── tr_special.go  # Special instructions (ADRP/ADR)
│   ├── vm/                # VM ISA definitions
│   │   ├── types.go       # Shared types + interfaces (Decoder/Translator/Packer)
│   │   ├── opcodes.go     # 58+ VM opcode definitions (randomly mapped values)
│   │   └── disasm.go      # VM bytecode disassembler
│   └── binary/elf/        # ELF binary manipulation
│       ├── packer.go      # ELF VMP injection (PT_NOTE hijack, trampoline generation)
│       └── trampoline.go  # Trampoline code generation
│
├── stub/                  # C VM interpreter (compiled to PIC flat binary)
│   ├── vm_interp_clean.c  # Interpreter main loop + entry points
│   ├── vm_types.h         # VM CPU context (vm_ctx_t)
│   ├── vm_opcodes.h       # C-side opcode definitions (synced with opcodes.go)
│   ├── vm_decode.h        # Bytecode read utilities
│   ├── vm_token.h         # Token encode/decode + descriptor table
│   ├── vm_dispatch.h      # Indirect dispatch jump table
│   ├── vm_crc.h           # CRC32 integrity check
│   ├── vm_sections.h      # Handler section scattering macros
│   ├── vm_interp.lds      # Linker script
│   └── vm_handlers/       # Modular instruction handlers
│       ├── h_alu.h        # Arithmetic/logic operations
│       ├── h_mem.h        # Memory access
│       ├── h_branch.h     # Branch/jump
│       ├── h_cmp.h        # Compare/conditional
│       ├── h_mov.h        # Data movement
│       ├── 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 bindings
│
└── build/                 # Pre-compiled tools + test artifacts

Progettazione Modulare

Il progetto utilizza un'architettura modulare guidata da interfacce, che facilita l'estensione a nuove ISA e formati binari:

// 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
}

Pipeline di Protezione

graph LR
    A[Input ELF] --> B[Locate Target Function]
    B --> C[Extract ARM64 Instructions]
    C --> D[Decode ARM64]
    D --> E[Translate to VM Bytecode]
    E --> F[XOR Encrypt Bytecode]
    F --> G[Inject VM Interpreter]
    G --> H[Generate Trampoline]
    H --> I[Replace Function Entry]
    I --> J[Output Protected ELF]

Avvio Rapido

Prerequisiti

Go 1.21+
GCC (aarch64-linux-gnu-gcc) — per compilare lo stub
Linux ARM64 o ambiente di cross-compilazione

Installazione

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

Utilizzo

Protezione per Nome Funzione

# Protegge una singola funzione
./vmpacker -func check_license -v -o protected.elf original.elf

# Protegge più funzioni
./vmpacker -func "check_license,verify_token" -v -o protected.elf original.elf

Protezione per Intervallo di Indirizzi

# Specifica l'intervallo di indirizzi
./vmpacker -addr "0x4006AC-0x400790:main" -v -o protected.elf original.elf

# Modalità mista
./vmpacker -addr "0x4006AC-0x400790:main" -func verify -o protected.elf original.elf

Ispeziona Info ELF

./vmpacker -info input.elf

Opzioni CLI

Compilazione

Compila Stub Interprete VM

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

Compila Tool CLI

go build -o vmpacker ./cmd/vmpacker/

Compila GUI

cd vmpacker
make gui

Riferimento ISA VM

VMPacker definisce un'architettura del set di istruzioni (ISA) personalizzata con valori di opcode mappati casualmente per aumentare la difficoltà di reverse engineering.

📖 Per la tabella opcode completa con dettagli di codifica, consulta la documentazione cinese.

Categorie di Istruzioni

Roadmap

Integrazione GUI completa — Integrazione completa tra GUI e motore di protezione backend
Modalità ibrida — Esecuzione nativa parziale + protezione VM parziale
Mappatura opcode dinamica — Genera mappatura ISA unica per ogni esecuzione di protezione

Contributi

I contributi sono benvenuti! Segui queste linee guida:

Fai il fork del repository
Crea un branch di funzionalità: git checkout -b feature/new-arch
Fai il commit delle modifiche: git commit -m 'feat: add x86_64 decoder'
Carica il branch: git push origin feature/new-arch
Crea una Pull Request

Convenzione per i Commit

Seguiamo i Conventional Commits:

feat: Nuova funzionalità
fix: Correzione di bug
refactor: Refactoring del codice
docs: Documentazione
test: Test

Licenza

Questo progetto è concesso in licenza sotto la AGPL-3.0 License.

Perché AGPL-3.0:

✅ Copyleft forte — Qualsiasi modifica o opera derivata deve essere rilasciata open-source con la stessa licenza
✅ Clausola di uso in rete — Fornire la funzionalità di questo software come servizio di rete richiede anche la divulgazione del codice sorgente
✅ Protegge la tecnologia principale — Impedisce l'uso commerciale closed-source del motore di protezione
✅ Amico della comunità — Libero di studiare, ricercare e migliorare — i miglioramenti devono essere condivisi
✅ Licenze commerciali — Per uso commerciale closed-source, contatta l'autore per una licenza commerciale

⚠️ Disclaimer

QUESTO SOFTWARE VIENE FORNITO "COSÌ COM'È", SENZA GARANZIA DI ALCUN TIPO, ESPRESSA O IMPLICITA, INCLUSE MA NON LIMITATE ALLE GARANZIE DI COMMERCIABILITÀ, IDONEITÀ PER UN PARTICOLARE SCOPO E NON VIOLAZIONE. IN NESSUN CASO GLI AUTORI O I TITOLARI DEL COPYRIGHT SARANNO RESPONSABILI PER QUALSIASI RECLAMO, DANNO O ALTRA RESPONSABILITÀ, DERIVANTE DA O IN CONNESSIONE CON IL SOFTWARE O L'USO O ALTRE OPERAZIONI NEL SOFTWARE.

Questo progetto è progettato per fornire una protezione legittima della proprietà intellettuale per gli sviluppatori di software, aiutando a salvaguardare gli algoritmi principali e il codice critico nel software commerciale da reverse engineering o furto non autorizzato.

Avviso per l'utente:

È necessario rispettare tutte le leggi e i regolamenti applicabili nella propria giurisdizione quando si utilizza questo software

È severamente vietato utilizzare questo software per qualsiasi scopo illegale, inclusi ma non limitati a: sviluppo di malware, elusione di audit di sicurezza, violazione dei diritti di proprietà intellettuale altrui o compromissione della sicurezza dei sistemi informatici

Gli autori non potranno essere ritenuti responsabili per eventuali conseguenze dirette o indirette derivanti dall'uso di questo software da parte di qualsiasi persona

Scaricando, utilizzando o distribuendo questo software, riconosci di aver letto e accettato i termini sopra indicati

Autore

LeoChen — @LeoChen-CoreMind

Protezione VM	ISA Personalizzata	Opcode mappati casualmente — i reverse engineer non possono identificare direttamente la semantica delle istruzioni
OpcodeCryptor	Crittografia opcode per istruzione	`enc[pc] = op[pc] ^ (key ^ (pc * 0x9E3779B9))`
Inversione Bytecode	Inversione dell'ordine di esecuzione	Istruzioni memorizzate in ordine inverso; l'interprete scorre all'indietro
Ingresso Token	Trampolino a 3 istruzioni	Funzione originale sostituita con un ingresso tokenizzato, nascondendo la posizione effettiva del bytecode
Dispatch Indiretto	Tabella di salto tramite puntatore a funzione	Riempita a runtime sullo stack, rompendo i riferimenti incrociati di IDA


_{Elenco Funzioni}	_{Analisi e Selezione}	_{Opzioni Protezione}

_{Log in Tempo Reale}	_{Protezione Completata}

`-func`	—	Nome/i funzione da proteggere (separati da virgola)
`-addr`	—	Proteggi per indirizzo (`0xSTART-0xEND[:nome]`)
`-o`	`input.vmp`	Percorso file di output
`-v`	`false`	Output verboso (mostra disassemblato)
`-strip`	`true`	Rimuovi tabella dei simboli
`-debug`	`false`	Genera file di mapping di debug ARM64 → bytecode VM
`-token`	`true`	Modalità ingresso basata su token
`-info`	`false`	Stampa solo info ELF

Movimento Dati	3	MOV_IMM64, MOV_IMM32, MOV_REG
Aritmetica/Logica	21	ADD, SUB, MUL, XOR, AND, OR, SHL, SHR, ASR, NOT, ROR, UMULH + varianti _IMM
Accesso alla Memoria	8	LOAD/STORE 8/16/32/64
Salto/Salto condizionale	13	JMP, JE, JNE, JL, JGE, JGT, JLE, JB, JAE, JBE, JA, TBZ, TBNZ
Confronto	6	CMP, CMP_IMM, CCMP_REG, CCMP_IMM, CCMN_REG, CCMN_IMM
Stack	2	PUSH, POP
Sistema/Speciale	8	NOP, HALT, RET, CALL_NATIVE, CALL_REG, BR_REG, SVC, MRS
SIMD	2	VLD16, VST16
Totale	63

Più Popolari

VMPacker