zydak/leetobfuscatorOfusca C/C++ mediante pases de LLVM: cifrado de cadenas, aplanamiento del flujo de control, reescritura MBA y anti-análisis para derrotar la ingeniería inversa.
██╗ ███████╗███████╗████████╗
██║ ██╔════╝██╔════╝╚══██╔══╝
██║ █████╗ █████╗ ██║
██║ ██╔══╝ ██╔══╝ ██║
███████╗███████╗███████╗ ██║
╚══════╝╚══════╝╚══════╝ ╚═╝
██████╗ ██████╗ ███████╗██╗ ██╗███████╗ ██████╗ █████╗ ████████╗ ██████╗ ██████╗
██╔═══██╗██╔══██╗██╔════╝██║ ██║██╔════╝██╔════╝██╔══██╗╚══██╔══╝██╔═══██╗██╔══██╗
██║ ██║██████╔╝█████╗ ██║ ██║███████╗██║ ███████║ ██║ ██║ ██║██████╔╝
██║ ██║██╔══██╗██╔══╝ ██║ ██║╚════██║██║ ██╔══██║ ██║ ██║ ██║██╔══██╗
╚██████╔╝██████╔╝██║ ╚██████╔╝███████║╚██████╗██║ ██║ ██║ ╚██████╔╝██║ ██║
╚═════╝ ╚═════╝ ╚═╝ ╚═════╝ ╚══════╝ ╚═════╝╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝
A simple obfuscator for C/C++ x64 and x86 code
Esto está hecho como un fork de LLVM, por lo que necesitas el código fuente real para ofuscar. No es un ofuscador de ejecutables arbitrarios. Es una versión modificada del compilador.
Si quieres ver los resultados, he creado y ofuscado 2 crackmes con esto. Puedes obtenerlos en releases junto con el binario de clang precompilado.
Todo esto fue compilado con el flag -O3 y todas las capturas de pantalla provienen de IDA Pro 9.4. También lo probé con Binary Ninja y Ghidra, los resultados fueron iguales o peores.
Cifra las cadenas en tiempo de compilación e inserta una función de descifrado en cada uso de la cadena cifrada. Esto desactiva por completo la capacidad de buscar cualquier cadena en el binario. Y cada cadena tiene su propia clave única hardcodeada en la función de descifrado, lo que hace mucho más difícil volcarlas y descifrarlas. Estas funciones de descifrado también se inlinean. (no inlineadas abajo solo para mostrarlo)
 Antes del pase |
 Después |
Reemplaza las operaciones aritméticas con sus equivalentes MBA. Es básicamente imposible ver qué hacía la operación original a menos que primero la pases por un desofuscador de MBA. Por supuesto, esta ofuscación es algo débil porque MBA es el truco más viejo del libro, así que hay muchas herramientas para lidiar con eso, por ejemplo CoBRA, que desofuscará esto con éxito a la expresión 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 eso he creado el pase AAMBA.
 Antes del pase |
 Después |
Reemplaza los operandos de las operaciones binarias con ADC(X, 255) - 255 - CF y SBB(X, 255) + 255 + CF. Por supuesto, siempre se evalúa como X, pero hace que la expresión dependa del flag de acarreo. A menos que el descompilador rastree el estado de CF (lo cual a veces es imposible), se confundirá mucho y no podrá plegar estas expresiones. Se combina muy bien con el pase MBA anterior, ofuscando aún más la aritmética. Como se puede ver a continuación, el descompilador creó algunas variables adicionales y usa muchas llamadas a __PAIR64__ y __CFADD__, por lo que se vuelve mucho más difícil (aunque no imposible) pegarlo en herramientas como CoBRA; el plugin gooMBA de IDA tampoco ayuda a simplificar esto. Además, el descompilador de IDA rastrea el flag de acarreo hasta cierto punto, pero combinarlo con la ofuscación del flujo de control hace que el rastreo sea prácticamente imposible sin ejecución, ya que no se sabe cuál fue la operación anterior: quizás puso CF a 1, quizás no, por lo que los pases posteriores se sumarán aún más a este.
|
Antes del pase |
 Después |
Recopila todos los bloques dentro de una función y forma con ellos una única máquina de estados gigante; crea una tabla de saltos al principio de la función y coloca todos los punteros de bloque dentro de ella. Luego, en lugar de un salto normal al final de cada bloque, todo se enruta a través del despachador, que usa saltos indirectos; estos son casi imposibles de resolver estáticamente sin ninguna ejecución. También degrada los registros a la pila, por lo que si divides un bloque por la mitad, todas las variables del bloque anterior estarán en la pila, lo que significa que habrá MUCHÍSIMAS variables en cada expresión. Si pasas las operaciones de un solo bloque por CoBRA, no podrá desofuscarlo mucho, ya que habrá demasiadas variables desconocidas.
Crea un montón de bloques falsos que contienen ensamblador inválido. Esto descoloca enormemente a los desensambladores, porque si el desensamblador encuentra un byte técnicamente inválido que nunca se ejecuta, aun así intentará darle sentido. Así que si el byte está incompleto, creará una instrucción a partir de los bytes que haya después, consumiéndolos esencialmente. Eso crea una desincronización que destruye todas las instrucciones posteriores. En binarios de Windows, IDA podrá recuperarse hasta cierto punto; en casos raros podrá generar un grafo y descompilar lo que pueda (aunque estará roto e incompleto), mientras que en binarios de Linux rompe por completo la vista de grafo y deshabilita la descompilación. Además, insertará un temporizador RDTSC y algunas otras comprobaciones anti depuración; si detecta un depurador, se produce un fallo.
 Windows |
 Linux |