obfus.h

obfus.h es una biblioteca de solo macros para ofuscar aplicaciones C en tiempo de compilación, diseñada específicamente para Tiny C (tcc) (puedes descargarlo aquí -> Tiny-C-Compiler/releases). Está adaptada para plataformas Windows x86 y x64 y soporta casi todas las versiones del compilador. ¡Una armadura muy fiable para tus programas en C!

¿Qué características tiene?...

• 🔍 Ofuscación de llamadas a funciones: Confunde las llamadas a funciones para hacer tu código menos legible ante miradas no autorizadas.
• 🛡️ Técnicas anti-depuración: Mecanismos integrados para prevenir el análisis del código durante la ejecución.
• 🔄 Mutación del flujo de control: Convierte el código en espagueti, dificultando el análisis de condiciones y bucles.
• 🧶 Ocultación de cadenas: Oculta cadenas específicas en un archivo y las recopila dinámicamente al ejecutarse.
• 🚫 Técnicas anti-descompilación: Hace que muchos descompiladores populares sean inútiles rompiendo visualmente su salida.
• 😈 Adición de firmas falsas: Puede añadir firmas falsas de varios empaquetadores y protectores para confundir a los ingenieros inversos.
• 🧠 Virtualización: Hace que las operaciones matemáticas sean muy difíciles de entender mediante comandos de máquina virtual.

👾 Uso

Integrar obfus.h en tu proyecto es un proceso sencillo. Solo incluye la siguiente línea en tu código:

#include "obfus.h"

Esto ofuscará automáticamente tu código durante la compilación, garantizando la protección y confidencialidad de tu propiedad intelectual.

Opciones disponibles para configurar la protección:

root@kitploit:~

// Advanced code protection (see the "Virtualization" part of the documentation!)
#define VIRT           1  // Allows you to use the functions of a math VM

// Additional options
#define CFLOW_V2       1  // More powerful Control Flow obfuscation (slowly!)
#define ANTIDEBUG_V2   1  // Use better dynamic anti-debugging protection
#define FAKE_SIGNS     1  // Adds fake signatures of various protectors or packers

// Disabling default features
#define NO_OBF         1  // Don't obfuscate (for debugging)
#define NO_CFLOW       1  // Don't use Control-Flow obfuscation
#define NO_ANTIDEBUG   1  // Don't build in debugging protection

o úsalo con argumentos del compilador:

root@kitploit:~

tcc "app.c" -w  -D NO_CFLOW  -D ANTIDEBUG_V2  -D FAKE_SIGNS  -D VIRT

[!WARNING] Al compilar una aplicación con ofuscación, usa el argumento -w para suprimir las advertencias. De lo contrario, la consola mostrará numerosos logs intimidantes que no tienen impacto en el resultado final. No hay necesidad de alarmarse por ellos.

🔐 La protección contra depuración se activa mediante llamadas a muchas funciones básicas de MSVCRT. En lugares críticos del código puedes usar la construcción ANTI_DEBUG;. Por ejemplo:

ANTI_DEBUG;
if (!licenseExpired()) {
	// ...
}

🧶 Ocultación de cadenas

HIDE_STRING(str) ofusca y oculta visualmente las cadenas mutándolas, complicando significativamente su descubrimiento y parcheo en el código fuente. Cuando se declaran de esta manera, las cadenas se ensamblan en la pila mediante instrucciones mov en lugar de cargarse de una sola vez. Este método garantiza que las cadenas no se declaren estáticamente y, en su lugar, se construyan en tiempo de ejecución, haciéndolas menos susceptibles al análisis estático. Sin embargo, es importante tener en cuenta que esta característica no se puede usar para ocultar campos estáticos durante su declaración, ya que implica una llamada a función.

[!IMPORTANT] Algunos descompiladores aún pueden revelarlas debido a optimizaciones estáticas. En la salida del desensamblador, el código aparecerá complejo y engorroso, lo que puede disuadir un análisis sencillo, pero puede no prevenir por completo los esfuerzos decididos de ingeniería inversa.

Un ejemplo de llamada a la función printf de la biblioteca estándar con ocultación estática del mensaje y su descifrado en la pila:

char *hidden_message = HIDE_STRING("Hello, world!");
// ...
printf(hidden_message);

👺 Virtualización

Esta es una técnica de protección en la que ciertos cálculos se realizan a través de una máquina virtual integrada mediante comandos. ¡Hace que el análisis de operaciones matemáticas sea muy difícil! Funcionará con la opción VIRT habilitada (¡y solo con ella!). De lo contrario, todos los comandos de la máquina virtual serán reemplazados por operadores matemáticos ordinarios.

[!WARNING] La virtualización en ubicaciones críticas puede afectar la optimización. Úsala con precaución solo en áreas donde sea realmente necesaria

La máquina virtual no soporta algunas operaciones básicas de comparación de double.

Puedes usar operadores lógicos que utilizan llamadas a la máquina virtual para complicar aún más la comprensión de tu código:

Esto no es un reemplazo completo de if/else, sino solo una complicación de los operadores estándar.

Un ejemplo sencillo de uso de la virtualización:

// ...
#define VIRT 1
// ...

// if ((2 + 2) == 4) { ... }
VM_IF (VM_EQU(VM_ADD(2, 2), 4)) {
	printf("2 + 2 == 4!");
}

// if (condition1) { ... }
// else if (condition2) { ... }
// else { ... }
VM_IF (condition1) {
	// if
} VM_ELSE_IF (condition2) {
	// else if
} VM_ELSE {
	// else
}

Puedes encontrar ejemplos de uso de todas las funciones de la máquina virtual en el archivo tests/virtualmachine.c

❓ Ejemplo de uso

Si necesitas protección avanzada contra reversers expertos, usa las opciones CFLOW_V2 y ANTIDEBUG_V2.

// Let's obfuscate your code!

#include <stdio.h>

#define VIRT         1 // [+] Use math virtual machine

#define CFLOW_V2     1 // [+] ControlFlow v2
#define FAKE_SIGNS   1 // [+] Fake signatures
#define ANTIDEBUG_V2 1 // [+] AntiDebug v2

#define NO_OBF       0 // [-] Don't obfuscate (disable all)
#define NO_CFLOW     0 // [-] Disable ControlFlow
#define NO_ANTIDEBUG 0 // [-] Disable AntiDebug


#include "obfus.h"

void main() {
	char *out = malloc(256);

	strcpy(out, HIDE_STRING("Hello, world!\n"));

	if (out) {
		printf(out);
	} else {
		printf("Error!\n");
	}

	free(out);

	int result = VM_ADD(5, 7); // 5 + 7

	VM_IF (VM_EQU(result, 12)) { // (5 + 7) == 12
		printf("5 + 7 == 12");
	}
}

🤖 ¿Cómo funciona?

🛠 Compilador (importante)

Se recomienda usar la última versión de Tiny C (0.9.27). Desafortunadamente, algunas versiones del compilador no soportan la funcionalidad necesaria para una ofuscación completa. Visual C, GCC y Clang no son compatibles y es poco probable que lo sean.

🌐 Actualizador de obfus.h

Puedes usar el script especial para Windows para obtener las últimas versiones de obfus.h descargando el paquete del repositorio oficial. Esto es útil si necesitas automatizar las actualizaciones de seguridad sin usar git.

Por ejemplo, puedes usarlo antes de compilar tu proyecto:

root@kitploit:~

+ C:\...> call obfh-update
  C:\...> tcc app.c -w

El script actualizará el contenido del archivo obfus.h en el directorio actual (según la configuración especificada)

🦎 Auditorías de seguridad y la comunidad

• Derrotando un binario fuertemente ofuscado - Análisis de caja negra de los mecanismos de seguridad internos de obfus.h y su desofuscación. Todas las vulnerabilidades ya han sido parcheadas.
• ObfusHunter - Una utilidad para escanear archivos protegidos por obfus.h

📖 Resumen

El código de un programa (y su lógica original) protegido con obfus.h es casi imposible de recuperar (desofuscar). Sin embargo, usar este ofuscador no garantiza una protección completa contra todos los tipos de amenazas. Es importante desarrollar y mantener los sistemas de seguridad internos del programa.

Así es como se verá el código esquemático después de la ofuscación:

El reverser verá algo como esto si intenta usar un descompilador:

Así es como se ven todas las cadenas ocultas mediante la función HIDE_STRING en el desensamblador (arquitectura x86-64):

root@kitploit:~

  ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;
  ; PROTECTED STRING:                  ; ORIGINAL STRING:         ;
  mov eax, 48h                         lea rax, aHelloWorld       ;
  mov [rbp-0Fh], al                    mov r11, rax               ;
  mov eax, 65h                         ; . . .                    ;
  mov [rbp-0Eh], al                                               ;
  mov eax, 6Ch                                                    ;
  mov [rbp-0Dh], al                                               ;
  mov eax, 6Ch                                                    ;
  mov [rbp-0Ch], al                                               ;
  mov eax, 6Fh                                                    ;
  mov [rbp-0Bh], al                                               ;
  mov eax, 2Ch                                                    ;
  ; etc . . .                                                     ;
  ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;

🌈 Agradecimientos especiales

Gracias a todos los que ayudaron en el desarrollo de este proyecto. ¡Lo aprecio! ❤️

• 👨🏼‍💻 @horsicq (por la ayuda con el código y los consejos)
• 🐺 @ac3ss0r (por las geniales ideas y sus soluciones)

Y gracias a ti 🤝 por prestar atención a este proyecto.