obfus.h

OBFUS.H

OBFUS.H es una biblioteca de macro solo para compilar aplicaciones de C ofuscando, diseñada específicamente para la pequeña C (TCC) . Está diseñado para plataformas Windows X86 y X64 y admite casi todas las versiones del compilador. Armadura muy confiable para sus programas C!

¿Qué características tiene? ...

• ? Función de llamada de llamadas : confundir las llamadas de función para que su código sea menos legible para los ojos no autorizados.
• ? ️ Técnicas anti-fondos : mecanismos incorporados para evitar el análisis de código durante el tiempo de ejecución.
• Mutación del código de flujo de control : convierte el código en espagueti, lo que dificulta el análisis de las condiciones y los bucles.
• Técnicas antidecompilación : hace que muchos descompiladores populares no rompan visualmente su producción.
• ? Adición de firmas falsas : puede agregar firmas falsas de varios empacadores y protectores para confundir a los ingenieros inversos.
• ? Virtualización : hace que las operaciones matemáticas sean muy difíciles de entender con los comandos de máquina virtual.

? Uso

Integrar OBFUS.H en su proyecto es un proceso simple. Solo incluya la siguiente línea en su código:

 #include "obfus.h"

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

Opciones disponibles para configuración de protección:

 // 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_CFLOW       1  // Don't use Control-Flow obfuscation
#define NO_ANTIDEBUG   1  // Don't build in debugging protection

o úselo con Args del compilador:

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

Advertencia

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

? La protección de depuración se desencadena por las llamadas a muchas funciones básicas de MSVCRT. En lugares críticos en el código, puede usar el ANTI_DEBUG; construir. Por ejemplo:

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

? 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 sobre el comando. ¡Hace que el análisis de las operaciones matemáticas sea muy difícil ! Funcionará con la opción VIRT habilitada (¡y solo!). De lo contrario, todos los comandos de la máquina virtual serán reemplazados por operadores matemáticos ordinarios.

Advertencia

La virtualización en ubicaciones críticas puede afectar la optimización. Usar con precaución solo en áreas donde es realmente necesaria

Función	Tipo	Opción	Descripción	Ejemplo
VM_ADD	largo	+	Agrega dos números	VM_ADD(5, 3) = 8
VM_SUB	largo	-	Resta dos números	VM_SUB(5, 3) = 2
VM_MUL	largo	*	Multiplica dos números	VM_MUL(5, 3) = 15
VM_DIV	largo	/	Divide dos números	VM_DIV(6, 3) = 2
VM_MOD	largo	%	Calcula el módulo de dos números	VM_MOD(5, 3) = 2
VM_EQU	Bool	==	Comprobaciones si dos números son iguales	VM_EQU(5, 5) = true
VM_NEQ	Bool	!=	Verificaciones si dos números no son iguales	VM_NEQ(5, 3) = true
VM_LSS	Bool	<	Verifica si el primer número es menor que el segundo número	VM_LSS(3, 5) = true
VM_GTR	Bool	>	Verifica si el primer número es mayor que el segundo número	VM_GTR(5, 3) = true
VM_LEQ	Bool	<=	Verifica si el primer número es menor o igual al segundo número	VM_LEQ(3, 5) = true
VM_GEQ	Bool	>=	Verifica si el primer número es mayor o igual al segundo número	VM_GEQ(5, 3) = true
VM_ADD_DBL	doble	+	Agrega dos números dobles	VM_ADD_DBL(5.5, 3.2) = ≈8.7
VM_SUB_DBL	doble	-	Resta dos números dobles	VM_SUB_DBL(5.5, 3.2) = ≈2.3
VM_MUL_DBL	doble	*	Multiplica dos números dobles	VM_MUL_DBL(5.5, 3.2) = ≈17.6
VM_DIV_DBL	doble	/	Divide dos números dobles	VM_DIV_DBL(6.0, 3.0) = ≈2.0
VM_LSS_DBL	Bool	<	Verifica si el primer número doble es menor que el segundo número doble	VM_LSS_DBL(3.5, 5.2) = true
VM_GTR_DBL	Bool	>	Verifica si el primer número doble es mayor que el segundo número doble	VM_GTR_DBL(5.5, 3.2) = true

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

Puede usar operadores lógicos que usen llamadas de máquina virtual para complicar aún más la comprensión de su código.

Operador	Descripción
VM_IF	Usar en lugar de if
VM_ELSE_IF	Usar en lugar de else if
VM_ELSE	Usar en lugar de else

Un ejemplo simple 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
}

Puede encontrar ejemplos de uso de todas las funciones de una máquina virtual en las pruebas de archivo/virtualmachine.c

❓ Ejemplo de uso

Si necesita protección avanzada contra reversores calificados, use 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_CFLOW     0 // [-] Disable ControlFlow
#define NO_ANTIDEBUG 0 // [-] Disable AntiDebug


#include "obfus.h"

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

    strcpy ( out , "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 para su uso la última versión de Tiny C ( 0.9.27 ). Desafortunadamente, algunas versiones del compilador no admiten la funcionalidad necesaria para ofuscarse por completo. Visual C , GCC y Clang no es compatible y es poco probable que sea compatible.

obfus.h updater

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

Por ejemplo, puede usarlo antes de construir su proyecto:

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

El script actualizará el contenido del archivo OBFUS.H en el directorio actual (de acuerdo con la configuración especificada)

Resumir

El código de un programa (y su lógica original original) protegido usando OBFUS.H es casi imposible de recuperar (Deobfuscato) . Sin embargo, el uso de este ofuscador no garantiza una protección completa contra todo tipo de amenazas. Es importante desarrollar y mantener sistemas de seguridad de programas internos.

Cómo será el código diagramático después de la ofuscación:

El Reverser verá algo así si intenta usar un descompilador:

? Agradecimiento especial

Gracias a todos los que ayudaron en el desarrollo de este proyecto. ¡Te lo agradezco! ❤️

• ?? ‍ @horsicq (para obtener ayuda con el código y los consejos)
• ? @AC3SS0R (para ideas geniales y sus soluciones)

¿Y gracias a ti ? ¡Por prestar atención a este proyecto!