x86byte/obfusk8Obfusk8: biblioteca de ofuscación ligera basada en C++17 / Header Only para binarios de Windows
Obfusk8 es una biblioteca ligera de solo cabecera (header-only) para C++17, diseñada para mejorar significativamente la ofuscación de tus aplicaciones, haciendo que la ingeniería inversa sea una tarea sustancialmente más difícil. Lo consigue mediante un conjunto diverso de técnicas de tiempo de compilación y de ejecución orientadas a proteger la lógica y los datos de tu código.
main_mainEl punto de entrada de tu aplicación (main) se transforma en un motor de ofuscación complejo y multicapa:
main_body, una mini-VM (CPU simulada) ejecuta una secuencia de instrucciones "cifradas". Esto oculta el verdadero punto de entrada y las operaciones iniciales. El estado de la VM (registros, contador de programa, clave de despacho) se inicializa con valores aleatorizados en tiempo de ejecución._main (tanto en el prólogo como en el epílogo) se transforman en intrincadas máquinas de estado. El flujo de control no es directo, sino que está determinado por variables de estado fuertemente "cifradas". Las claves de codificación/decodificación de estas variables de estado son dinámicas y se derivan del estado de la VM, contadores de bucle, aleatoriedad de tiempo de compilación (como __COUNTER__, __LINE__, __TIME__) y una semilla opaca global. Esto dificulta enormemente el análisis estático del flujo de control.
obf_icff_ns_dcff y obf_icff_ns_epd) con diferente lógica de transición de estados y generación de claves, lo que complica aún más el análisis.OBF_BOGUS_FLOW_*): Se inyectan numerosos patrones de salto engañosos y estructuras condicionales enrevesadas a lo largo de _main. Utilizan sentencias goto combinadas con predicados opacos (condiciones que siempre se evalúan como verdaderas o falsas, pero que son computacionalmente costosas o difíciles de determinar estáticamente). Esto crea un laberinto de rutas falsas para desensambladores y descompiladores.
OBF_BOGUS_FLOW_LABYRINTH, OBF_BOGUS_FLOW_GRID, OBF_BOGUS_FLOW_SCRAMBLE, OBF_BOGUS_FLOW_WEAVER, OBF_BOGUS_FLOW_CASCADE y OBF_BOGUS_FLOW_CYCLONE para generar flujos falsos diversos y complejos.Runtime, SEH):
__except pueden alterar el estado del programa, lo que dificulta el seguimiento si el depurador omite las excepciones.Runtime contiene condiciones que, si se cumplen (debido a estados o temporización específicos de la VM), podrían activar __debugbreak() o lanzar excepciones, diseñadas para interrumpir las sesiones de depuración.obf_vm_engine)Un componente central de la ofuscación de la macro _main:
r0, r1, r2), un contador de programa (pc) y una dispatch_key. Ejecuta "instrucciones" (handlers) personalizadas.reg_dispatch_idx).get_mem_dispatch_table).mixed_dispatch_idx).
La dispatch_key se muta constantemente, haciendo que la secuencia de handlers ejecutados sea altamente impredecible.vm_handler_table) se muta en tiempo de ejecución dentro del prólogo y el epílogo de _main, oscureciendo aún más el comportamiento de la VM.OBFUSCATE_STRING de AES8.hpp)__FILE__, __LINE__) y el momento de compilación (__DATE__, __TIME__).AES8.hpp).STEALTH_API_OBFSTR / STEALTH_API_OBF de Resolve8.hpp)GetModuleHandle y GetProcAddress estándar para la resolución inicial si estas aún no han sido resueltas por este mecanismo.CT_HASH) de nombres de DLL y API para las búsquedas. Esto evita que los nombres en texto plano de DLL y API aparezcan en los datos relacionados con importaciones o en las tablas de cadenas del binario cuando se utilizan estas macros.K8_SYSCALL)Obfusk8 ahora integra un mecanismo de Syscall Indirecto de última generación para evadir los ganchos de modo usuario (EDR/AV) y las comprobaciones de análisis estático.
syscall; ret dentro de la memoria de ntdll.dll en tiempo de ejecución.
Pilas de Llamadas Limpias: Se asigna un thunk personalizado que salta al gadget de ntdll. Para el kernel del SO y los sensores de seguridad, la llamada al sistema parece originarse legítimamente desde ntdll.dll, manteniendo una pila de llamadas limpia.K8_SYSCALL("ZwOpenProcess", ...) en lugar de NtOpenProcess.OBF_METHOD)Obfusk8 ahora proporciona un control granular sobre la seguridad de tu binario mediante la Ofuscación Basada en Métodos. En lugar de ofuscar todo tu proyecto (lo que puede afectar al rendimiento), ahora puedes proteger selectivamente funciones o métodos de clase específicos y de alto valor.
OBF_METHOD: ```cpp
OBF_METHOD(ret_type, func_name, params, method_body)
ret_type: El tipo de retorno de tu función (p. ej., bool, int, void*).func_name: El nombre del método.params: Los parámetros de la función (deben estar encerrados entre paréntesis).method_body: La lógica real de tu función encerrada entre { }.En este ejemplo, PrintStatus es una función normal y legible. Obfusk8_PrintStatus está protegida por Obfusk8.```cpp
#include "../Instrumentation/materialization/state/Obfusk8Core.hpp"
#include "../Instrumentation/materialization/transform/K8_UTILS/k8_utils.hpp" // for the printf_, u can change the printf_ with anything else...
class Obfusk8_C { public: // standard method which is visible to reverse engineers void PrintStatus(void) { printf_("method\n"); }
// Obfuscated method protected by Obfusk8
OBF_METHOD_(void, Obfusk8_PrintStatus, (void),
{
printf_("same method but Obfuscated\n");
})
};
_main({ Obfusk8_C *pp = new Obfusk8_C; pp->PrintStatus(); pp->Obfusk8_PrintStatus(); delete pp; })
*Puedes ver el ejemplo completo aquí: [obfusk8_methods.cpp](https://github.com/x86byte/Obfusk8/blob/main/Obfusk8/EXAMPLES/obfusk8_methods.cpp)*
---
### 6. Clases de Abstracción de API con Sigilo Integrado
Obfusk8 proporciona clases auxiliares que encapsulan conjuntos comunes de APIs de Windows. Estas clases utilizan automáticamente el mecanismo sigiloso de resolución de API (`STEALTH_API_OBFSTR`) durante su construcción, garantizando que las funciones subyacentes de Windows se resuelvan sin dejar rastros evidentes de importación estática.
- **`K8_ProcessManipulationAPIs::ProcessAPI` (`k8_ProcessManipulationAPIs.hpp`)**:
* Proporciona acceso conveniente a las APIs de Windows para la manipulación de procesos, como `OpenProcess`, `TerminateProcess`, `CreateRemoteThread`, `VirtualAllocEx`, `WriteProcessMemory`, `ReadProcessMemory`, `GetProcAddress`, `GetModuleHandleA`, `NtQueryInformationProcess`, `SuspendThread` y `GetCurrentProcessId`.
* **Resolución Sigilosa Automática**: Resuelve sigilosamente las funciones necesarias de `kernel32.dll` y `ntdll.dll`.
* Simplifica la realización de operaciones relacionadas con procesos con una huella de análisis estático reducida. Incluye la enumeración `PROCESSINFOCLASS` para su uso con `NtQueryInformationProcess`.
- **`k8_CryptographyAPIs::CryptographyAPI` (`k8_CryptographyAPIs.hpp`)**:
* Ofrece envoltorios para funciones comunes de la API de Criptografía de Windows (CAPI/CNG). (La funcionalidad depende de la implementación real de este archivo: el fragmento proporcionado era un duplicado. Se asumen funciones CAPI típicas como `CryptAcquireContextA`, `CryptCreateHash`, etc.)
* **Resolución Sigilosa Automática**: Resuelve sigilosamente las funciones necesarias, principalmente de `advapi32.dll` (y `kernel32.dll` para funciones principales).
* Facilita las operaciones criptográficas mientras minimiza la exposición del uso de la API de criptografía.
- **`k8_NetworkingAPIs::NetworkingAPI` (`k8_NetworkingAPIs.hpp`)**:
* Proporciona fácil acceso a una amplia gama de funciones de red de `wininet.dll` (p. ej., `InternetOpenA`, `HttpOpenRequestA`, `FtpPutFileA`), `urlmon.dll` (p. ej., `URLDownloadToFileA`), `ws2_32.dll` (p. ej., `socket`, `connect`, `WSAStartup`), `shell32.dll` (p. ej., `ShellExecuteA`), `dnsapi.dll` (p. ej., `DnsQuery_A`) y `mpr.dll` (p. ej., `WNetOpenEnumA`).
* **Resolución Sigilosa Automática**: En su constructor, usa `STEALTH_API_OBFSTR` y `OBFUSCATE_STRING` para resolver todas las funciones requeridas desde sus respectivas DLL (y `kernel32.dll` para `LoadLibraryA`/`GetLastError`) sin dejar rastros evidentes de importación.
* Simplifica la realización de solicitudes de red ofuscadas y otras tareas relacionadas con la red.
- **`RegistryAPIs::RegistryAPI` (`k8_RegistryAPIs.hpp`)**:
* Envuelve funciones de registro de Windows de uso común, como `RegSetValueExA`, `RegCreateKeyExA`, `RegOpenKeyExA`, `RegQueryValueExA`, `RegCloseKey`, etc.
* **Resolución Sigilosa Automática**: Resuelve sigilosamente funciones de `advapi32.dll` (y `kernel32.dll`) durante la construcción.
* Ayuda a realizar operaciones de registro con llamadas a API menos rastreables.
### 7. Primitivas de Ofuscación Principal (Macros en `Obfusk8Core.hpp`)
Estos son los bloques de construcción utilizados extensivamente en toda la biblioteca, especialmente en la macro `_main` y en el motor de VM:
* **Aritmética Booleana Mixta (MBA)**: Transforma operaciones matemáticas y lógicas simples (ADD, SUB, XOR, NOT, MUL) en secuencias complejas, pero equivalentes, de fórmulas bit a bit y aritméticas (p. ej., `OBF_MBA_ADD`, `OBF_MBA_XOR`). Están diseñadas para que a los descompiladores les resulte muy difícil simplificarlas de vuelta a sus formas originales.
* **Predicados Opacos**: Inserta ramas condicionales donde la condición siempre se evalúa como verdadera (p. ej., `OBF_OPAQUE_PREDICATE_TRUE_1`) o siempre falsa (p. ej., `OBF_OPAQUE_PREDICATE_FALSE_1`). Estas condiciones se construyen a partir de expresiones complejas y difíciles de evaluar estáticamente que involucran `__COUNTER__`, `__LINE__`, `__TIME__` y `_obf_global_opaque_seed`. Crean rutas de código engañosas y pueden usarse para proteger código muerto o forzar flujos de ejecución específicos.
* **Inyección de Código Basura**:
* `OBF_CALL_ANY_LOCAL_JUNK`: Llama a una de las muchas funciones basura aleatorias y pequeñas definidas en `obf_junk_ns`. Estas funciones realizan operaciones triviales y volátiles y se seleccionan aleatoriamente en tiempo de compilación. Su propósito es aumentar la entropía del código, romper patrones de código simples y potencialmente engañar a las herramientas de detección o análisis basadas en firmas.
* `NOP()`: Una macro que inserta operaciones volátiles diseñadas para evitar su fácil eliminación por parte de los optimizadores y para modificar sutilmente una semilla global.
* **Trucos Anti-Desensamblado y Anti-Análisis**:
* **Saltos Ofuscados (macros `OBF_JUMP_*`)**: Crea sentencias `goto` cuyas condiciones o destinos están ofuscados, a menudo apoyándose en predicados opacos o MBA.
* **Transiciones de Estado Ofuscadas (macros `OBF_SET_NEXT_STATE_*`)**: Utilizadas en ICFF, estas macros establecen la variable de siguiente estado para el despachador de flujo de control aplanado usando técnicas de ofuscación similares a las de los saltos ofuscados.
* **Manipulación de Pila (`OBF_STACK_ALLOC_MANIP`, `OBF_FAKE_PROLOGUE_MANIP`)**: Asigna bloques de tamaño variable en la pila y realiza manipulaciones falsas sobre ellos. Los prólogos falsos intentan confundir el análisis de pila.
* **Llamadas a Funciones Ofuscadas (`OBF_CALL_VIA_OBF_PTR`)**: Los punteros a función se someten a XOR con una clave dinámica antes y después de usarse, oscureciendo el verdadero destino de la llamada.
* `K8_ASSUME(0)`: Se usa en rutas de código muerto para indicar al compilador MSVC que dichas rutas son inalcanzables, lo que potencialmente permite diferentes optimizaciones o generación de código que podrían confundir aún más el análisis si la suposición es violada por un parche.
### Dependencias
La biblioteca Obfusk8 es modular. La funcionalidad principal se basa en:
- `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp`: (Este archivo) El encabezado central que orquesta y proporciona las principales macros y primitivas de ofuscación.
- `Obfusk8/Instrumentation/materialization/transform/AES8.hpp`: Proporciona cifrado de cadenas en tiempo de compilación basado en AES y características opcionales de manipulación de secciones PE.
- `Obfusk8/Instrumentation/materialization/transform/Resolve8.hpp`: Implementa la resolución sigilosa de APIs de Windows basada en PEB.
* `Obfusk8/Instrumentation/materialization/transform/k8_indsys.hpp`: Orquesta el **Motor de Syscall Indirectas**. Gestiona el ciclo de vida de los stubs de transición y proporciona la interfaz para ejecutar llamadas al sistema a través de gadgets de memoria laterales.
* `Obfusk8/Instrumentation/materialization/transform/getpeb8.hpp`: Facilita el bootstrap inicial y el **Descubrimiento del PEB**. Contiene la lógica de hash personalizada, las definiciones de estructuras nativas y el algoritmo "Sorting Hat" para la deducción de SSN. Sirve como base de bajo nivel para todas las tareas de enumeración de módulos.
Las clases auxiliares opcionales de API se proporcionan en encabezados separados, normalmente ubicados en subdirectorios:
- `k8_ProcessManipulationAPIs/k8_ProcessManipulationAPIs.hpp`: Para APIs sigilosas de manipulación de procesos.
- `k8_CryptographyAPIs/k8_CryptographyAPIs.hpp`: Para APIs sigilosas de criptografía.
- `k8_NetworkingAPIs/k8_NetworkingAPIs.hpp`: Para APIs sigilosas de red.
- `k8_RegistryAPIs/k8_RegistryAPIs.hpp`: Para APIs sigilosas de registro.
### Visualización
* **gráfico de IDA**:
* **algunos fragmentos de IDA Pro**:
* **resultados de firmas de Detect It Easy**:
* **reglas YARA colaborativas de VirusTotal**:
* **mapa de memoria (de DIE)**:
* **secciones**:
* **archivos enlazados**:
### Análisis del Motor y Perfil de Detección
Obfusk8 está diseñado para priorizar la evasión de motores de detección basados en firmas estáticas. Las pruebas contra proveedores estándar de la industria muestran que la lógica central de ofuscación permanece sin ser detectada por los principales productos de seguridad, incluyendo:
* **Microsoft Defender**: No detectado
* **Kaspersky**: No detectado
* **ESET-NOD32**: No detectado
* **BitDefender**: No detectado
Aunque las firmas estáticas se eluden, algunos AV de próxima generación y EDR (como CrowdStrike o Symantec) pueden generar alertas heurísticas etiquetadas como "sospechoso" o "malicioso de alta confianza". Estas detecciones suelen estar provocadas por la alta complejidad arquitectónica y la presencia de secciones PE personalizadas, más que por código malicioso identificable.
### Características Estructurales y Forenses
* **gestión de entropía**: La implementación actual produce una entropía global de aproximadamente 6.2. Está equilibrada intencionalmente para ser lo suficientemente alta como para oscurecer la lógica, pero lo bastante baja para evitar las alertas comunes de "archivo empaquetado" provocadas por niveles de entropía superiores a 7.0.
* **Personalización de Secciones**: la configuración predeterminada incluye 23 secciones PE, algunas de las cuales utilizan nombres señuelo (p. ej., `.themida`, `.vmp0`, `.enigma2`) para imitar protectores comerciales conocidos.
* **Optimización Heurística**: para reducir aún más la puntuación de sospecha, los usuarios pueden renombrar estas secciones a cadenas genéricas (p. ej., `.data_01`, `.rdata_aux`). Estandarizar los nombres de las secciones a menudo reduce la puntuación heurística de "singularidad", haciendo que el binario parezca una aplicación compilada convencional.
* **Ofuscación de Importaciones**: La biblioteca elimina con éxito la huella de la Tabla de Direcciones de Importación (IAT) para APIs críticas de Windows. Al utilizar el Bloque de Entorno de Proceso (PEB) para la resolución y el motor de Syscall Indirectas, el binario mantiene una pila de llamadas limpia, impidiendo que los monitores de comportamiento rastreen las llamadas al sistema hasta las regiones de código protegido.
- **explicación rápida**:
* **deducción de SSN**: para evadir los hooks en modo usuario a menudo colocados en el flujo de instrucciones de ntdll.dll, el motor utiliza un algoritmo de ordenamiento relativo. Al analizar el Directorio de Exportaciones y ordenar todas las funciones con prefijo Zw por sus direcciones de memoria, el motor deduce los Números de Servicio del Sistema (SSN) basándose en su índice relativo. Esto permite al framework identificar el índice de syscall correcto sin leer nunca los bytes hookeados del prólogo de la función.
* Stubs de Syscall Dinámicos: En lugar de utilizar instrucciones syscall estáticas dentro del binario en modo usuario, la biblioteca asigna dinámicamente memoria ejecutable para alojar stubs de transición transitorios. El motor puebla estos stubs con una secuencia personalizada de shellcode (`mov r10, rcx; mov eax, ssnnumber; syscall; ret`) para ejecutar llamadas al sistema indirectamente.
* **arranque en cadena**: el proceso de resolución se autoinicia; el motor utiliza una llamada resuelta inicial para establecer el entorno de las syscalls indirectas posteriores. Esto asegura que todo el ciclo de vida del proceso—desde la enumeración de módulos hasta la ejecución de funciones—permanezca opaco para los monitores de comportamiento y mantenga una pila de llamadas limpia.
* **anti-Forense**: El uso de Aritmética Booleana Mixta (MBA) y una Arquitectura de Conjunto de Instrucciones Virtual (V-ISA) multicapa garantiza que, incluso si se obtiene un volcado de memoria, la lógica subyacente no sea trivial de reconstruir mediante herramientas automatizadas de desofuscación.
### Uso
1. Incluye `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` en tu archivo de proyecto principal (p. ej., `main.cpp`).
```cpp
#include "Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp" // Adjust path as needed
```
2. Envuelve el cuerpo de tu función `main` con `_main`:
```cpp
_main({
// Your application's original main code here
// Example:
// OBFUSCATE_STRING("Hello, Obfuscated World!").c_str();
// Using an API wrapper class
k8_NetworkingAPIs::NetworkingAPI* netAPI = new k8_NetworkingAPIs::NetworkingAPI;
if (netAPI->IsInitialized() && netAPI->pInternetOpenA) {
HINTERNET hInternet = netAPI->pInternetOpenA(OBFUSCATE_STRING("MyAgent").c_str(), INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
if (hInternet) {
// ... use hInternet ...
netAPI->pInternetCloseHandle(hInternet);
}
}
delete netAPI;
})
```
3. Usa `OBFUSCATE_STRING("your string")` para todos los literales de cadena importantes. Accede a la cadena descifrada mediante su método `.c_str()` si lo necesitas para llamadas a API, o usa sus otros métodos como `.print_to_console()` si los proporciona `Obfusk8/Instrumentation/materialization/transform/AES8.hpp`.
4. Usa `STEALTH_API_OBFSTR("dll_name.dll", "FunctionNameA")` para llamadas directas sigilosas a API, o preferiblemente usa las clases envoltorio de API (p. ej., `K8_ProcessManipulationAPIs::ProcessAPI`, `k8_NetworkingAPIs::NetworkingAPI`) por conveniencia y sigilo integrado.
5. Esparce `OBF_BOGUS_FLOW_*`, `OBF_CALL_ANY_LOCAL_JUNK`, `NOP()` y otras primitivas en secciones críticas de tu código que no sean sensibles al rendimiento para añadir capas de ofuscación.
* consulta el archivo main.cpp.
### Compilación
* **Requisito del Compilador**: Esta biblioteca está diseñada para C++17. El Compilador de Microsoft C++ (`cl.exe`) es el objetivo principal, especialmente para las características de secciones PE y el uso de SEH.
* **Obtener `cl.exe` (Compilador MSVC) en Windows**:
1. **Instala Visual Studio**: La forma más fácil de obtener `cl.exe` es instalando Visual Studio. Puedes descargar la edición Community de Visual Studio gratis desde el [sitio web de Visual Studio](https://visualstudio.microsoft.com/downloads/).
2. **Selecciona la carga de trabajo**: Durante la instalación, asegúrate de seleccionar la carga de trabajo "Desarrollo de escritorio con C++". Esto instalará el compilador de C++, el SDK de Windows y otras herramientas necesarias.
3. **Usa el Símbolo del sistema para desarrolladores**: Después de la instalación, busca "Developer Command Prompt for VS" (p. ej., "x64 Native Tools Command Prompt for VS 2022") en el menú Inicio y ejecútalo. Este símbolo del sistema configura automáticamente las variables de entorno (PATH, INCLUDE, LIB) necesarias para usar `cl.exe`.
* **Rutas de Inclusión**:
* Asegúrate de que el directorio que contiene `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` esté en la ruta de inclusión de tu compilador.
* Si `Obfusk8/Instrumentation/materialization/transform/AES8.hpp`, `Obfusk8/Instrumentation/materialization/transform/Resolve8.hpp` y los directorios de las clases envoltorio de API (p. ej., `k8_NetworkingAPIs/`) no están en el mismo directorio que `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp`, asegúrate de que sus rutas también estén configuradas correctamente. `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` usa rutas relativas como `../Obfusk8Core.hpp` para algunas de sus inclusiones internas de las clases envoltorio de API, por lo que la estructura de directorios importa. Si `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` está en la raíz de tu directorio de inclusión para esta biblioteca, entonces las clases envoltorio de API deberían estar en subdirectorios como `k8_NetworkingAPIs/` en relación con donde `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` las espera, o ajusta las rutas de inclusión dentro del propio `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp`.
* **Ejemplo de Compilación (usando Developer Command Prompt)**:
Suponiendo que tu `main.cpp` y los encabezados de Obfusk8 estén estructurados correctamente, puedes compilar usando un comando similar a:
```bash
cl /std:c++17 /EHsc main.cpp
```
* después de abrir `x64 Native Tools Command Prompt for VS 2022`:
* `/std:c++17`: Especifica el estándar C++17.
* `/EHsc`: Especifica el modelo de manejo de excepciones de C++.
* `main.cpp`: Tu archivo fuente principal.
* `/I"path/to/your/obfusk8_includes"`: (Opcional, si los encabezados no están en las rutas predeterminadas) Agrega el directorio donde se encuentran `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` y sus dependencias. Si están en subdirectorios, asegúrate de que las rutas relativas dentro de `Obfusk8Core.hpp` coincidan con tu estructura.
* **Nota sobre Bibliotecas**: Si bien la resolución sigilosa de API busca evitar la vinculación estática de las funciones ofuscadas, los encabezados del SDK de Windows pueden requerir que ciertos archivos `.lib` estén disponibles para el enlazador a fin de resolver cualquier uso no ofuscado del SDK o tipos internos (p. ej., `Ws2_32.lib`, `Wininet.lib`, `Advapi32.lib`, etc.). Para un proyecto simple como `cl /std:c++17 /EHsc main.cpp`, el enlazador a menudo los resuelve automáticamente si son bibliotecas estándar de Windows.
* **CMAKE**: también puedes compilar Obfusk8 usando cmake.
1. clona y entra al repositorio: `git clone https://github.com/x86byte/Obfusk8.git` y entra al directorio `cd Obfusk8`
2. configura y genera los archivos: `cmake CMakeLists.txt`
3. selección automática de herramientas de compilación y compilación: `cmake --build .`
* después de abrir `x64 Native Tools Command Prompt for VS 2022`:
* **CMAKE y Microsoft Visual Studio**:
* después de abrir `microsoft visual studio`, haz clic en `Ctrl + B` para compilar el proyecto:
* **Consideraciones sobre el Tamaño del Binario y Mejoras Futuras**:
* **Impacto en el Tamaño**: Ten en cuenta que el uso extensivo de ofuscación solo con encabezados, especialmente con técnicas como la inserción de código basura, expansiones MBA y flujo de control aplanado, puede llevar a un aumento significativo del tamaño final del binario. Un programa pequeño podría crecer de kilobytes a potencialmente 2 MB o más, dependiendo de la intensidad de ofuscación aplicada.
* **Personalización y Empaquetado (Dirección Futura)**:
* Actualmente, Obfusk8 se centra en la ofuscación dentro del código. Los usuarios podrían necesitar ajustar el uso de varias macros (p. ej., reducir la densidad de `OBF_CALL_ANY_LOCAL_JUNK` o la complejidad de los bucles de `_main`) si el tamaño del binario es una restricción crítica.
* Para una reducción sustancial del tamaño posterior a la ofuscación, integrar o usar un empaquetador PE externo (como UPX, MPRESS o soluciones personalizadas) sería un paso separado.
* El desarrollo futuro de Obfusk8 podría explorar opciones para un control más granular sobre la intensidad de la ofuscación o incluso integrar stubs ligeros de empaquetado/compresión directamente en la biblioteca, aunque esto aumentaría significativamente su complejidad.
### Ofuscación PE Posterior a la Compilación
Obfusk8 incluye un script posterior a la compilación para endurecer aún más el binario compilado eliminando artefactos forenses.
* **Ubicación del Script**: `Obfusk8/SCRIPTS/obfuscate_pe.ps1`
* **Qué hace**:
1. **Elimina el Rich Header** — elimina la huella del entorno de compilación de MSVC que revela la versión del compilador y detalles de la cadena de herramientas.
2. **Suplanta el TimeDateStamp** — reemplaza la marca de tiempo del encabezado PE con un valor fijo para oscurecer el momento de compilación.
3. **Limpia el Directorio de Depuración** — borra las entradas del directorio de depuración que podrían filtrar rutas PDB o metadatos de compilación.
* **Uso**: Ejecútalo como un paso posterior a la compilación después de compilar:
```powershell
PowerShell -NoProfile -ExecutionPolicy Bypass -File Obfusk8/SCRIPTS/obfuscate_pe.ps1 -Path "path\to\Obfusk8.exe"
```
El script modifica el binario en su lugar. No se crea ninguna copia de seguridad.
### Demo
[[Obfusk8: Biblioteca de Ofuscación Basada en C++17 - Vista de Grafo de IDA Pro] ~Demo en Video](https://youtu.be/B9g4KSg3tHQ)
### Contribución y ComentariosEste proyecto, Obfusk8, es una exploración en curso de técnicas avanzadas de ofuscación en C++. La versión actual sienta una base sólida con multitud de estrategias entrelazadas.
* **Tu opinión es invaluable**: Como desarrollador de Obfusk8, estoy muy interesado en tu perspectiva, conocimientos y cualquier comentario que puedas tener. Ya sea sugerencias para nuevas funciones, mejoras a las técnicas existentes, informes de intentos exitosos (o no) de ingeniería inversa contra código protegido por Obfusk8, o pensamientos generales sobre la usabilidad y eficacia de la biblioteca.
* **Contribución**: todas las contribuciones son bienvenidas y muy apreciadas. Este proyecto prospera gracias a la aportación de la comunidad y a las pruebas en el mundo real para ampliar sus límites y convertirse en una herramienta aún más formidable para la protección de código. No dudes en compartir tus ideas, reportar problemas o contribuir a su evolución!.
* **[¿Cómo contribuir a Obfusk8?](https://opensource.guide/how-to-contribute/)**
### Agradecimientos Especiales
* [sadMosquito](https://github.com/sadMosquito) — por reportar problemas y probar el proyecto
**Descargo de responsabilidad**
La ofuscación es una capa de defensa, no una solución infalible. Atacantes decididos con la habilidad y el tiempo suficientes a menudo pueden aplicar ingeniería inversa al código ofuscado. Obfusk8 pretende elevar significativamente el listón para tales esfuerzos. Úsalo junto con otras medidas de seguridad.
**Ponte en contacto**
Si deseas compartir comentarios, discutir técnicas de ofuscación, reportar intentos de ingeniería inversa o simplemente tener una discusión técnica, no dudes en contactarme directamente. Siempre estoy abierto a conversaciones constructivas y a la colaboración (estaré encantado de colaborar en proyectos relacionados con la ofuscación o cualquier otra cosa).
- x : https://x.com/x86byte
- telegram: https://t.me/x86byte
- discord: @x86byte