gmh5225/asm-obfuscatorOfusca assembly x86-64 com injeção de instruções, código lixo, ofuscação de constantes e descriptografia em tempo de execução para dificultar a engenharia reversa e a anti-análise.
Obfuscador avançado de assembly x86-64.
O Obfuscador de Código Assembly é uma ferramenta poderosa e versátil projetada para aumentar a segurança do seu código assembly x86-64. Ele protege seus projetos contra engenharia reversa e análise, empregando uma ampla gama de técnicas de ofuscação e medidas anti-análise.
Injeção de Instruções: Injeta sequências de bytes personalizadas antes de cada instrução assembly para confundir desmontadores.
Aleatoriedade: Introduz aleatoriedade na estrutura do código, tornando-o menos previsível.
Detecção de Debuggers: Detecta a presença de debuggers durante a execução do código e emprega medidas anti-debug.
Técnicas Anti-Análise: Confunde ferramentas de análise dinâmica com ramificações condicionais e verificações de tempo.
Descriptografia Dinâmica: Criptografa e descriptografa dinamicamente seções de código em tempo de execução, aumentando a complexidade.
Descompressão Dinâmica: Comprime e descomprime dinamicamente seções de código, ocultando a verdadeira natureza do código.
Ofuscação de Constantes: Ofusca constantes e valores de dados usando técnicas como XOR e manipulação de bits.
Renomeação de Variáveis: Renomeia variáveis e registradores, tornando o código menos legível para humanos.
Inserção de Código Lixo: Insere partições de código lixo para obscurecer ainda mais a base de código.
O núcleo do processo de ofuscação envolve a injeção de sequências de bytes personalizadas antes de cada instrução assembly no arquivo de código. Essas sequências de bytes, projetadas estrategicamente, têm a intenção de confundir desmontadores e analistas. Vamos examinar esse processo em detalhes:
4005d2: 55 push rbp
Em memória (hex):
0x55
400665: eb 01 jmp 400668 <main+0x3>
400667: b0 55 mov al,0x55
400669: eb 01 jmp 40066c <main+0x7>
Em memória (hex):
0xEB, 0x01, 0xB0, 0x55
Aqui está uma análise da transformação:
A instrução original PUSH RBP é montada como 0x55. O ofuscador insere os bytes 0xEB, 0x01, 0xB0 antes dela.
O resultado é uma sequência de instruções que, quando desmontada, pode parecer completamente diferente do código original. Isso torna desafiador para a engenharia reversa entender o verdadeiro propósito do código.
Introduz elementos de aleatoriedade no código. Envolve técnicas como permutação de instruções, troca de operandos e substituição de opcodes.
Incorpora mecanismos para detectar a presença de debuggers durante a execução do código. Possui verificações em tempo de execução para identificar artefatos relacionados a debuggers e acionar medidas anti-análise.
Integra várias medidas anti-análise, como ramificações condicionais e verificações de tempo. Por exemplo, pode inserir saltos condicionais e loops de atraso para retardar o processo de análise.
Emprega técnicas de descriptografia dinâmica. Criptografa certas seções de código e as descriptografa em tempo de execução usando uma chave secreta. Esse processo de descriptografia ocorre dinamicamente durante a execução do código.
Comprime seções específicas de código e as descomprime em tempo real quando executadas.
Usa técnicas como XOR, manipulação de bits e operações aritméticas para ofuscar constantes. Isso garante que os valores constantes não sejam facilmente reconhecíveis.
A ferramenta renomeia variáveis e registradores, tornando o código menos legível. O processo envolve substituir nomes de variáveis por strings geradas aleatoriamente ou identificadores numéricos.
Para obscurecer ainda mais o código, o ofuscador insere partições de código lixo em locais estratégicos. Esse código lixo consiste em instruções irrelevantes que não afetam a lógica do programa, mas servem para poluir a base de código.
; Original Code
mov eax, 1
; After Junk Code Insertion
mov ebx, 2
sub ecx, ecx
add edx, edx
Em memória (hex):
0x89, 0xD8, 0x31, 0xC9, 0x01, 0xD2
O código lixo inserido é projetado para desviar a atenção e fazer o código parecer mais complicado.
Também incorpora um recurso para detectar cabeçalhos UPX falsos. Ele examina o código em busca de sinais de adulteração nos cabeçalhos UPX, garantindo a integridade do executável.
Antes da Transformação (Código Original):
section .text
global _start
_start:
; Calculate the sum of the first 10 natural numbers
mov ecx, 10 ; Initialize loop counter
mov eax, 0 ; Initialize sum to 0
loop_start:
add eax, ecx ; Add current value of ECX to EAX (sum)
loop loop_start ; Decrement ECX and loop if not zero
; Exit program
mov eax, 1 ; SYS_exit
int 0x80 ; Invoke syscall
Representação Hexadecimal (Código Original):
31 C9 xor ecx,ecx
B8 00 00 00 00 mov eax,0x0
EB 0E jmp 0x1c
01 C8 add eax,ecx
E2 FB loop 0x11
B8 01 00 00 00 mov eax,0x1
CD 80 int 0x80
Após a Transformação (Código Ofuscado):
section .text
global _start
_start:
; Calculate the sum of the first 10 natural numbers
mov eax, 0x1
add eax, 0x2
add eax, 0x3
add eax, 0x4
add eax, 0x5
add eax, 0x6
add eax, 0x7
add eax, 0x8
add eax, 0x9
add eax, 0xa
; Exit program
mov eax, 0x1
int 0x80
Representação Hexadecimal (Código Ofuscado):
B8 01 00 00 00 mov eax,0x1
83 C0 02 add eax,0x2
83 C0 03 add eax,0x3
83 C0 04 add eax,0x4
83 C0 05 add eax,0x5
83 C0 06 add eax,0x6
83 C0 07 add eax,0x7
83 C0 08 add eax,0x8
83 C0 09 add eax,0x9
83 C0 0A add eax,0xa
B8 01 00 00 00 mov eax,0x1
CD 80 int 0x80
No código ofuscado, tornamos a lógica original do programa menos aparente adicionando instruções ADD redundantes e usando valores hexadecimais como operandos imediatos.
Este projeto está licenciado sob a Licença MIT. Consulte o arquivo LICENSE para obter detalhes.
Contribuições são bem-vindas!
Para problemas, solicitações de recursos ou consultas gerais, por favor crie uma issue.
Esta ferramenta destina-se a fins educacionais e éticos.