
Ofusca C/C++ através de passes LLVM: criptografia de strings, achatamento de fluxo de controle, reescrita de MBA e anti-análise para impedir engenharia reversa.
██╗ ███████╗███████╗████████╗
██║ ██╔════╝██╔════╝╚══██╔══╝
██║ █████╗ █████╗ ██║
██║ ██╔══╝ ██╔══╝ ██║
███████╗███████╗███████╗ ██║
╚══════╝╚══════╝╚══════╝ ╚═╝
██████╗ ██████╗ ███████╗██╗ ██╗███████╗ ██████╗ █████╗ ████████╗ ██████╗ ██████╗
██╔═══██╗██╔══██╗██╔════╝██║ ██║██╔════╝██╔════╝██╔══██╗╚══██╔══╝██╔═══██╗██╔══██╗
██║ ██║██████╔╝█████╗ ██║ ██║███████╗██║ ███████║ ██║ ██║ ██║██████╔╝
██║ ██║██╔══██╗██╔══╝ ██║ ██║╚════██║██║ ██╔══██║ ██║ ██║ ██║██╔══██╗
╚██████╔╝██████╔╝██║ ╚██████╔╝███████║╚██████╗██║ ██║ ██║ ╚██████╔╝██║ ██║
╚═════╝ ╚═════╝ ╚═╝ ╚═════╝ ╚══════╝ ╚═════╝╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝
A simple obfuscator for C/C++ x64 and x86 code
Isto é feito como um fork do LLVM, então você precisa do código-fonte real para ofuscar. Não é um ofuscador de executáveis arbitrários. É uma versão modificada do compilador.
Se você quiser conferir os resultados, eu criei e ofusquei 2 crackmes com isto. Você pode obtê-los em releases junto com o binário clang pré-compilado.
Tudo isto foi compilado com a flag -O3 e todas as capturas de tela vêm do IDA Pro 9.4. Também testei com o Binary Ninja e o Ghidra, os resultados foram iguais ou piores.
Criptografa strings em tempo de compilação e insere uma função de descriptografia a cada uso da string criptografada. Isto desabilita completamente a capacidade de procurar por quaisquer strings no binário. E cada string tem sua própria chave única hardcoded na função de descriptografia, o que torna o dump e a descriptografia delas muito mais difíceis. Essas funções de descriptografia também serão inlined. (não inlined abaixo apenas para demonstração)
![]() Antes do passe |
![]() Depois |
Substitui operações aritméticas por seus equivalentes MBA. É basicamente impossível ver o que a operação original fazia a menos que você a passe primeiro por um desofuscador de MBA. É claro que esta ofuscação é meio fraca porque MBA é o truque mais antigo que existe, então há muitas ferramentas para lidar com isso, por exemplo o CoBRA, que irá desofuscar isto com sucesso para a expressão original:
./cobra-cli --mba "((x^y) - (((x^y)&0xFF)&0xA) + 10) * ((x^y) - ((x^y)|0xA) + 10) + ((x^y) - (((x^y)&0xFF)|0xFFFFFFF5) - 11) * (~(x^y) - (~(x^y)|0xA) + 10)" --bitwidth 32
10 * (x ^ y)
É por isso que criei o passe AAMBA.
![]() Antes do passe |
![]() Depois |
Substitui os operandos de operações binárias por ADC(X, 255) - 255 - CF e SBB(X, 255) + 255 + CF. É claro que sempre resulta em X, mas torna a expressão dependente da flag de carry. A menos que o descompilador rastreie o estado de CF (o que às vezes é impossível), ele ficará muito confuso e não conseguirá dobrar essas expressões. Combina muito bem com o passe MBA anterior, ofuscando ainda mais a aritmética. Como você pode ver abaixo, o descompilador criou algumas variáveis adicionais e usa muitas chamadas __PAIR64__ e __CFADD__, então fica muito mais difícil (ainda não impossível) colar isso em ferramentas como o CoBRA, e o plugin gooMBA do IDA também não ajuda a simplificar isso. Além disso, o descompilador do IDA rastreia a flag de carry até certo ponto, mas combinar isso com ofuscação de fluxo de controle torna o rastreamento basicamente impossível sem execução, já que você não sabe qual foi a operação anterior, talvez tenha definido CF como 1, talvez não, então os passes posteriores se somam ainda mais a este.
![]() Antes do passe |
![]() Depois |
Coleta todos os blocos dentro de uma função e transforma tudo em uma única máquina de estados gigante, cria uma jump table no início da função e coloca todos os ponteiros de bloco dentro dela. Então, em vez de um salto normal no final de cada bloco, tudo é roteado através do dispatcher que usa saltos indiretos, os quais são quase impossíveis de resolver estaticamente sem qualquer execução. Também rebaixa registradores para a pilha, então se você dividir um bloco ao meio, todas as variáveis do bloco anterior estarão na pilha, o que significa que haverá MUITAS variáveis em cada expressão. Se você passar as operações de um único bloco pelo CoBRA, ele não conseguirá desofuscá-lo muito, já que haverá variáveis desconhecidas demais.
Cria vários blocos falsos contendo assembly inválido. Isso confunde imensamente os desmontadores, porque se o desmontador encontrar um byte tecnicamente inválido que nunca é executado, ele ainda tentará dar sentido a ele. Então, se o byte estiver incompleto, ele criará uma instrução a partir dos bytes que estiverem logo depois, essencialmente consumindo-os. Isso cria uma dessincronização que destrói todas as instruções seguintes. Em binários Windows, o IDA conseguirá se recuperar um pouco disso, em casos raros conseguirá gerar um grafo e descompilar o que puder (embora fique quebrado e incompleto), enquanto em binários Linux isso quebra completamente a visualização do grafo e desabilita a descompilação. Além disso, ele inserirá um temporizador RDTSC e algumas outras verificações anti-debug, e se detectar um depurador, você trava.
![]() Windows |
![]() Linux |
Descubra as ferramentas mais usadas pela nossa comunidade.
Sem dados de popularidade ainda.