🛡️ VMPacker

Sistema de Proteção de Máquina Virtual ARM64 ELF

Traduza instruções nativas ARM64 para bytecode VM personalizado para proteção de código em nível de função

🇨🇳 中文文档 • Funcionalidades • Arquitetura • Início Rápido • Uso • Licença

Visão Geral

O VMPacker é um sistema de Proteção por Máquina Virtual (VMP) para binários ARM64 (AArch64) Linux ELF. Ele decodifica instruções ARM64 nativas da função alvo em uma representação intermediária, traduz-as em bytecode VM personalizado e injeta um interpretador VM embarcado no arquivo ELF. Em tempo de execução, as funções protegidas são executadas pelo interpretador VM em vez de nativamente.

Conceito Principal

Código Nativo ARM64  →  Decodificar  →  Traduzir  →  Bytecode VM Personalizado
                                                      ↓
                    ELF Original  ←  Injetar  ←  Stub do Interpretador VM

Funcionalidades

🔄 Motor de Tradução de Instruções

63 instruções VM — cobrindo ALU, memória, desvio, chamadas de sistema e mais
Decodificador orientado por tabela — correspondência de padrões baseada no Manual de Referência de Arquitetura ARM
121 instruções ARM64 suportadas (cobertura de 100% da base A64), incluindo:
- Aritmética/Lógica (ADD, SUB, MUL, AND, ORR, EOR, LSL, LSR, ASR, MVN, BIC, ORN, EON...)
- Multiplicação-Extensão (MADD, MSUB, SMADDL, SMSUBL, UMADDL, UMSUBL, SMULH, UMULH, UDIV, SDIV)
- Movimento de Dados (MOV, MOVZ, MOVK, MOVN)
- Acesso à Memória (LDR, STR, LDP, STP, LDPSW, LDADD, CAS, LDAR, STLR, LDAXR, STLXR — várias larguras e modos de endereçamento)
- Controle de Desvio (B, BL, BR, BLR, RET, B.cond, CBZ/CBNZ, TBZ/TBNZ)
- Seleção Condicional (CSEL, CSINC, CSINV, CSNEG, CCMP, CCMN)
- Campos de Bits (UBFM, SBFM, BFM, EXTR)
- Manipulação de Bits (CLZ, CLS, RBIT, REV, REV16, REV32)
- Aritmética com Carry (ADC, ADCS, SBC, SBCS)
- Carga/Descarga SIMD (LD1, ST1)
- Sistema/Barreiras (SVC, MRS, MSR, ADRP/ADR, DMB, DSB, ISB, HLT, BRK, PRFM)

🔐 Proteção em Multi-Camadas

🖥️ Interface Gráfica (GUI)

Aplicativo de desktop multiplataforma construído com Wails v2 (Go + Vue 3)
Componentes de interface Element Plus
Seleção de funções por símbolo + entrada manual de função (proteger por intervalo de endereços)
Proteção com um clique e saída de logs em tempo real

Arquitetura

vmp/
├── cmd/vmpacker/          # Ponto de entrada da CLI
│   ├── main.go            # Análise de argumentos da CLI + orquestração
│   └── vm_interp.bin      # Interpretador VM compilado (GCC, go:embed)
│
├── pkg/                   # Biblioteca central Go
│   ├── arch/arm64/        # Suporte à arquitetura ARM64
│   │   ├── decoder.go     # Decodificador orientado por tabela (implementa vm.Decoder)
│   │   ├── decode_*.go    # Tabelas de padrões de decodificação (DP-IMM/DP-REG/Branch/LdSt)
│   │   ├── translator.go  # Tradutor ARM64 → bytecode VM
│   │   ├── tr_alu.go      # Tradução de instruções ALU
│   │   ├── tr_branch.go   # Tradução de instruções de desvio
│   │   ├── tr_loadstore.go # Tradução de instruções de memória
│   │   ├── tr_bitfield.go # Tradução de instruções de campos de bits
│   │   └── tr_special.go  # Instruções especiais (ADRP/ADR)
│   ├── vm/                # Definições da ISA VM
│   │   ├── types.go       # Tipos compartilhados + interfaces (Decoder/Translator/Packer)
│   │   ├── opcodes.go     # Definições de 58+ opcodes VM (valores mapeados aleatoriamente)
│   │   └── disasm.go      # Desmontador de bytecode VM
│   └── binary/elf/        # Manipulação de binários ELF
│       ├── packer.go      # Injeção VMP em ELF (sequestro de PT_NOTE, geração de trampolim)
│       └── trampoline.go  # Geração de código de trampolim
│
├── stub/                  # Interpretador VM em C (compilado para binário PIC flat)
│   ├── vm_interp_clean.c  # Loop principal do interpretador + pontos de entrada
│   ├── vm_types.h         # Contexto de CPU VM (vm_ctx_t)
│   ├── vm_opcodes.h       # Definições de opcodes do lado C (sincronizadas com opcodes.go)
│   ├── vm_decode.h        # Utilitários de leitura de bytecode
│   ├── vm_token.h         # Codificação/decodificação de token + tabela descritora
│   ├── vm_dispatch.h      # Tabela de despacho indireto
│   ├── vm_crc.h           # Verificação de integridade CRC32
│   ├── vm_sections.h      # Macros de dispersão de seções de handlers
│   ├── vm_interp.lds      # Script do linker
│   └── vm_handlers/       # Handlers modulares de instruções
│       ├── h_alu.h        # Operações aritméticas/lógicas
│       ├── h_mem.h        # Acesso à memória
│       ├── h_branch.h     # Desvio/salto
│       ├── h_cmp.h        # Comparação/condicional
│       ├── h_mov.h        # Movimento de dados
│       ├── h_stack.h      # Pilha (PUSH/POP)
│       └── h_system.h     # Sistema (SVC/MRS/BLR/BR/RET)
│
├── vmp-gui/               # Frontend da GUI Wails
│   ├── frontend/          # Vue 3 + Element Plus
│   └── backend/           # Ligações do backend em Go
│
└── build/                 # Ferramentas pré-compiladas + artefatos de teste

Design Modular

O projeto usa uma arquitetura modular orientada por interfaces, facilitando a extensão para novas ISAs e formatos binários:

// Interface do decodificador de arquitetura — extensível para x86, RISC-V
type Decoder interface {
    Decode(raw uint32, offset int) Instruction
    InstName(op int) string
}

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

// Interface do injetor de formato binário — extensível para PE, Mach-O
type Packer interface {
    Process() error
}

Pipeline de Proteção

graph LR
    A[ELF de Entrada] --> B[Localizar Função Alvo]
    B --> C[Extrair Instruções ARM64]
    C --> D[Decodificar ARM64]
    D --> E[Traduzir para Bytecode VM]
    E --> F[Criptografar Bytecode com XOR]
    F --> G[Injetar Interpretador VM]
    G --> H[Gerar Trampolim]
    H --> I[Substituir Entrada da Função]
    I --> J[ELF Protegido de Saída]

Início Rápido

Pré-requisitos

Go 1.21+
GCC (aarch64-linux-gnu-gcc) — para compilar o stub
Linux ARM64 ou ambiente de compilação cruzada

Instalação

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

Uso

Proteger por Nome da Função

# Proteger uma única função
./vmpacker -func check_license -v -o protected.elf original.elf

# Proteger múltiplas funções
./vmpacker -func "check_license,verify_token" -v -o protected.elf original.elf

Proteger por Intervalo de Endereços

# Especificar intervalo de endereços
./vmpacker -addr "0x4006AC-0x400790:main" -v -o protected.elf original.elf

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

Inspecionar Informações ELF

./vmpacker -info input.elf

Opções da CLI

Compilação

Compilar o Stub do Interpretador VM

# Compilação padrão (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

Compilar a Ferramenta CLI

go build -o vmpacker ./cmd/vmpacker/

Compilar a GUI

cd vmpacker
make gui

Referência da ISA VM

O VMPacker define uma Arquitetura de Conjunto de Instruções (ISA) personalizada com valores de opcode mapeados aleatoriamente para aumentar a dificuldade de engenharia reversa.

📖 Para a tabela completa de opcodes com detalhes de codificação, veja a documentação em chinês.

Categorias de Instruções

Roteiro (Roadmap)

Integração Completa da GUI — Integração completa entre a GUI e o motor de proteção backend
Modo Híbrido — Execução nativa parcial + proteção VM parcial
Mapeamento Dinâmico de Opcodes — Gerar mapeamento ISA único por execução de proteção

Contribuição

Contribuições são bem-vindas! Por favor, siga estas diretrizes:

Faça um fork do repositório
Crie um branch de funcionalidade: git checkout -b feature/nova-arquitetura
Faça commit das suas alterações: git commit -m 'feat: adicionar decodificador x86_64'
Envie o branch: git push origin feature/nova-arquitetura
Crie um Pull Request

Convenção de Commits

Seguimos Conventional Commits:

feat: Nova funcionalidade
fix: Correção de bug
refactor: Refatoração de código
docs: Documentação
test: Testes

Licença

Este projeto está licenciado sob a Licença AGPL-3.0.

Por que AGPL-3.0:

✅ Copyleft Forte — Quaisquer modificações ou trabalhos derivados devem ser de código aberto sob a mesma licença
✅ Cláusula de Uso em Rede — Fornecer a funcionalidade deste software como um serviço de rede também exige a divulgação do código-fonte
✅ Protege a Tecnologia Central — Impede o uso comercial fechado do motor de proteção
✅ Amigável à Comunidade — Livre para estudar, pesquisar e melhorar — as melhorias devem ser compartilhadas de volta
✅ Licenciamento Comercial — Para uso comercial fechado, entre em contato com o autor para uma licença comercial

⚠️ Aviso Legal

ESTE SOFTWARE É FORNECIDO "NO ESTADO EM QUE SE ENCONTRA", SEM QUALQUER TIPO DE GARANTIA, EXPRESSA OU IMPLÍCITA, INCLUINDO, MAS NÃO SE LIMITANDO A, GARANTIAS DE COMERCIALIZAÇÃO, ADEQUAÇÃO A UM FIM ESPECÍFICO E NÃO VIOLAÇÃO. EM NENHUMA HIPÓTESE OS AUTORES OU DETENTORES DE DIREITOS AUTORAIS SERÃO RESPONSÁVEIS POR QUALQUER RECLAMAÇÃO, DANOS OU OUTRA RESPONSABILIDADE, SEJA EM AÇÃO CONTRATUAL, EXTRA CONTRATUAL OU DE OUTRA FORMA, DECORRENTE DE, OU EM CONEXÃO COM, O SOFTWARE OU O USO OU OUTRAS NEGOCIAÇÕES NO SOFTWARE.

Este projeto foi projetado para fornecer proteção legítima de propriedade intelectual para desenvolvedores de software, ajudando a proteger algoritmos centrais e código crítico em software comercial contra engenharia reversa ou roubo não autorizado.

Aviso ao Usuário:

Você deve cumprir todas as leis e regulamentos aplicáveis na sua jurisdição ao usar este software

É estritamente proibido usar este software para qualquer finalidade ilegal, incluindo, mas não se limitando a: desenvolvimento de malware, contorno de auditorias de segurança, violação dos direitos de propriedade intelectual de terceiros ou comprometimento da segurança de sistemas de computador

O(s) autor(es) não será(ão) responsabilizado(s) por quaisquer consequências diretas ou indiretas resultantes do uso deste software por qualquer pessoa

Ao baixar, usar ou distribuir este software, você reconhece que leu e concordou com os termos acima

Autor

LeoChen — @LeoChen-CoreMind

Proteção VM	ISA Personalizada	Opcodes mapeados aleatoriamente — engenheiros reversos não podem identificar diretamente a semântica das instruções
Criptografia de Opcode	Criptografia de opcode por instrução	`enc[pc] = op[pc] ^ (key ^ (pc * 0x9E3779B9))`
Reversão de Bytecode	Inversão da ordem de execução	Instruções armazenadas em ordem inversa; interpretador percorre para trás
Entrada Tokenizada	Trampolim de 3 instruções	Função original substituída por entrada tokenizada, ocultando a localização real do bytecode
Despacho Indireto	Tabela de ponteiros de função	Preenchida em tempo de execução na pilha, quebrando referências cruzadas do IDA


_{Lista de Funções}	_{Análise e Seleção}	_{Opções de Proteção}

_{Logs em Tempo Real}	_{Proteção Concluída}

`-func`	—	Nome(s) da(s) função(ões) a proteger (separados por vírgula)
`-addr`	—	Proteger por endereço (`0xINÍCIO-0xFIM[:nome]`)
`-o`	`input.vmp`	Caminho do arquivo de saída
`-v`	`false`	Saída detalhada (mostrar desmontagem)
`-strip`	`true`	Remover tabela de símbolos
`-debug`	`false`	Gerar arquivo de mapeamento de depuração ARM64 → bytecode VM
`-token`	`true`	Modo de entrada por token
`-info`	`false`	Apenas imprimir informações do ELF

Movimento de Dados	3	MOV_IMM64, MOV_IMM32, MOV_REG
Aritmética/Lógica	21	ADD, SUB, MUL, XOR, AND, OR, SHL, SHR, ASR, NOT, ROR, UMULH + variantes _IMM
Acesso à Memória	8	LOAD/STORE 8/16/32/64
Desvio/Salto	13	JMP, JE, JNE, JL, JGE, JGT, JLE, JB, JAE, JBE, JA, TBZ, TBNZ
Comparação	6	CMP, CMP_IMM, CCMP_REG, CCMP_IMM, CCMN_REG, CCMN_IMM
Pilha	2	PUSH, POP
Sistema/Especial	8	NOP, HALT, RET, CALL_NATIVE, CALL_REG, BR_REG, SVC, MRS
SIMD	2	VLD16, VST16
Total	63

Mais Populares

VMPacker