x86byte/obfusk8Obfusk8: biblioteca leve de ofuscação baseada em C++17 / Header Only para binários do Windows
Obfusk8 é uma biblioteca leve, somente de cabeçalho, em C++17, projetada para aprimorar significativamente a ofuscação de suas aplicações, tornando a engenharia reversa um desafio substancialmente maior. Ela alcança isso por meio de um conjunto diversificado de técnicas em tempo de compilação e execução, com o objetivo de proteger a lógica e os dados do seu código.
main_mainO ponto de entrada da sua aplicação (main) é transformado em um mecanismo de ofuscação complexo e multicamadas:
main_body seja executado, uma mini-VM (CPU simulada) executa uma sequência de instruções "criptografadas". Isso oculta o verdadeiro ponto de entrada e as operações iniciais. O estado da VM (registradores, contador de programa, chave de despacho) é inicializado com valores aleatórios em tempo de execução._main (tanto no prólogo quanto no epílogo) são transformados em máquinas de estado intricadas. O fluxo de controle não é direto, mas determinado por variáveis de estado fortemente "criptografadas". As chaves de codificação/decodificação dessas variáveis de estado são dinâmicas, derivadas do estado da VM, contadores de loop, aleatoriedade em tempo de compilação (como __COUNTER__, __LINE__, __TIME__) e uma semente opaca global. Isso torna a análise estática do fluxo de controle excepcionalmente difícil.
obf_icff_ns_dcff e obf_icff_ns_epd) são usados com lógica de transição de estado e geração de chaves diferentes, complicando ainda mais a análise.OBF_BOGUS_FLOW_*): Numerosos padrões de salto enganosos e estruturas condicionais convolutas são injetados ao longo de _main. Eles usam declarações goto combinadas com predicados opacos (condições que sempre avaliam para verdadeiro ou falso, mas são computacionalmente caras ou difíceis de determinar estaticamente). Isso cria um labirinto de caminhos falsos para desmontadores e decompiladores.
OBF_BOGUS_FLOW_LABYRINTH, OBF_BOGUS_FLOW_GRID, OBF_BOGUS_FLOW_SCRAMBLE, OBF_BOGUS_FLOW_WEAVER, OBF_BOGUS_FLOW_CASCADE e OBF_BOGUS_FLOW_CYCLONE para gerar fluxos falsos diversos e complexos.Runtime, SEH):
__except podem alterar o estado do programa, dificultando o acompanhamento se o depurador ignorar exceções.Runtime contém condições que, se atendidas (devido a estados específicos da VM ou temporização), podem acionar __debugbreak() ou lançar exceções, projetadas para atrapalhar sessões de depuração.obf_vm_engine)Um componente central da ofuscação da macro _main:
r0, r1, r2), um contador de programa (pc) e uma dispatch_key. Ela executa "instruções" personalizadas (handlers).reg_dispatch_idx).get_mem_dispatch_table).mixed_dispatch_idx).
A dispatch_key é constantemente mutada, tornando a sequência de handlers executados altamente imprevisível.vm_handler_table) é ela própria mutada em tempo de execução dentro do prólogo e epílogo de _main, obscurecendo ainda mais o comportamento da VM.OBFUSCATE_STRING de AES8.hpp)__FILE__, __LINE__) e tempo de compilação (__DATE__, __TIME__).AES8.hpp).STEALTH_API_OBFSTR / STEALTH_API_OBF de Resolve8.hpp)GetModuleHandle e GetProcAddress para a resolução inicial se elas próprias ainda não tiverem sido resolvidas por esse mecanismo.CT_HASH) de nomes de DLLs e APIs para buscas. Isso impede que nomes de DLLs e APIs em texto puro apareçam nos dados relacionados a importações ou nas tabelas de strings do binário ao usar essas macros.K8_SYSCALL)Obfusk8 agora integra um mecanismo de Syscall Indireto de última geração para contornar Hooks em Modo de Usuário (EDRs/AVs) e verificações de análise estática.
K8_SYSCALL("ZwOpenProcess", ...) em vez de NtOpenProcess.OBF_METHOD)Obfusk8 agora oferece controle granular sobre a segurança do seu binário por meio da Ofuscação Baseada em Métodos. Em vez de ofuscar todo o seu projeto (o que pode impactar o desempenho), agora você pode proteger seletivamente funções específicas de alto valor ou métodos de classe.
OBF_METHOD: ```cpp
OBF_METHOD(ret_type, func_name, params, method_body)
ret_type: O tipo de retorno da sua função (ex.: bool, int, void*).func_name: O nome do método.params: Os parâmetros da função (devem estar entre parênteses).method_body: A lógica real da sua função entre { }.Neste exemplo, PrintStatus é uma função normal e legível. Obfusk8_PrintStatus é protegida pelo 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; })
*Você pode ver o exemplo completo aqui: [obfusk8_methods.cpp](https://github.com/x86byte/Obfusk8/blob/main/Obfusk8/EXAMPLES/obfusk8_methods.cpp)*
---
### 6. Classes de Abstração de API com Furtividade Integrada
O Obfusk8 fornece classes auxiliares que encapsulam conjuntos comuns de APIs do Windows. Essas classes usam automaticamente o mecanismo furtivo de resolução de API (`STEALTH_API_OBFSTR`) durante sua construção, garantindo que as funções subjacentes do Windows sejam resolvidas sem deixar rastros óbvios de importação estática.
- **`K8_ProcessManipulationAPIs::ProcessAPI` (`k8_ProcessManipulationAPIs.hpp`)**:
* Fornece acesso conveniente às APIs do Windows para manipulação de processos, como `OpenProcess`, `TerminateProcess`, `CreateRemoteThread`, `VirtualAllocEx`, `WriteProcessMemory`, `ReadProcessMemory`, `GetProcAddress`, `GetModuleHandleA`, `NtQueryInformationProcess`, `SuspendThread` e `GetCurrentProcessId`.
* **Resolução Furtiva Automática**: Resolve funções necessárias de `kernel32.dll` e `ntdll.dll` de forma furtiva.
* Simplifica a realização de operações relacionadas a processos com uma pegada reduzida de análise estática. Inclui o enum `PROCESSINFOCLASS` para uso com `NtQueryInformationProcess`.
- **`k8_CryptographyAPIs::CryptographyAPI` (`k8_CryptographyAPIs.hpp`)**:
* Oferece wrappers para funções comuns da API de Criptografia do Windows (CAPI/CNG). (A funcionalidade depende da implementação real deste arquivo - o trecho fornecido era uma duplicata. Assumindo funções CAPI típicas como `CryptAcquireContextA`, `CryptCreateHash`, etc.)
* **Resolução Furtiva Automática**: Resolve funções necessárias principalmente de `advapi32.dll` (e `kernel32.dll` para funções principais) de forma furtiva.
* Facilita operações criptográficas minimizando a exposição do uso de APIs criptográficas.
- **`k8_NetworkingAPIs::NetworkingAPI` (`k8_NetworkingAPIs.hpp`)**:
* Fornece acesso fácil a uma ampla gama de funções de rede de `wininet.dll` (ex.: `InternetOpenA`, `HttpOpenRequestA`, `FtpPutFileA`), `urlmon.dll` (ex.: `URLDownloadToFileA`), `ws2_32.dll` (ex.: `socket`, `connect`, `WSAStartup`), `shell32.dll` (ex.: `ShellExecuteA`), `dnsapi.dll` (ex.: `DnsQuery_A`) e `mpr.dll` (ex.: `WNetOpenEnumA`).
* **Resolução Furtiva Automática**: Em seu construtor, usa `STEALTH_API_OBFSTR` e `OBFUSCATE_STRING` para resolver todas as funções necessárias de suas respectivas DLLs (e `kernel32.dll` para `LoadLibraryA`/`GetLastError`) sem deixar rastros óbvios de importação.
* Simplifica fazer solicitações de rede ofuscadas e executar outras tarefas relacionadas a redes.
- **`RegistryAPIs::RegistryAPI` (`k8_RegistryAPIs.hpp`)**:
* Encapsula funções comumente usadas do Registro do Windows, como `RegSetValueExA`, `RegCreateKeyExA`, `RegOpenKeyExA`, `RegQueryValueExA`, `RegCloseKey`, etc.
* **Resolução Furtiva Automática**: Resolve funções de `advapi32.dll` (e `kernel32.dll`) de forma furtiva durante a construção.
* Auxilia na realização de operações de registro com chamadas de API menos rastreáveis.
### 7. Primitivas Principais de Ofuscação (Macros em `Obfusk8Core.hpp`)
Estes são os blocos de construção usados extensivamente em toda a biblioteca, especialmente no macro `_main` e no mecanismo VM:
* **Aritmética Booleana Mista (MBA)**: Transforma operações matemáticas e lógicas simples (ADD, SUB, XOR, NOT, MUL) em sequências complexas, porém equivalentes, de fórmulas bit a bit e aritméticas (ex.: `OBF_MBA_ADD`, `OBF_MBA_XOR`). Elas são projetadas para serem muito difíceis de serem simplificadas pelos descompiladores de volta às suas formas originais.
* **Predicados Opacos**: Insere ramificações condicionais onde a condição sempre avalia para verdadeiro (ex.: `OBF_OPAQUE_PREDICATE_TRUE_1`) ou sempre falso (ex.: `OBF_OPAQUE_PREDICATE_FALSE_1`). Essas condições são construídas a partir de expressões complexas e difíceis de avaliar estaticamente envolvendo `__COUNTER__`, `__LINE__`, `__TIME__` e `_obf_global_opaque_seed`. Elas criam caminhos de código enganosos e podem ser usadas para proteger código morto ou forçar fluxos de execução específicos.
* **Injeção de Código Lixo**:
* `OBF_CALL_ANY_LOCAL_JUNK`: Chama uma de muitas funções lixo pequenas e aleatórias definidas em `obf_junk_ns`. Essas funções realizam operações triviais e voláteis e são selecionadas aleatoriamente em tempo de compilação. Seu propósito é aumentar a entropia do código, quebrar padrões simples de código e potencialmente enganar ferramentas de detecção ou análise baseadas em assinaturas.
* `NOP()`: Um macro que insere operações voláteis projetadas para impedir a remoção fácil por otimizadores e para modificar sutilmente uma semente global.
* **Truques Anti-Desmontagem e Anti-Análise**:
* **Saltos Ofuscados (macros `OBF_JUMP_*`)**: Cria instruções `goto` cujas condições ou alvos são ofuscados, muitas vezes dependendo de predicados opacos ou MBA.
* **Transições de Estado Ofuscadas (macros `OBF_SET_NEXT_STATE_*`)**: Usados no ICFF, esses macros definem a variável de próximo estado para o despachante de fluxo de controle achatado usando técnicas de ofuscação semelhantes às dos saltos ofuscados.
* **Manipulação de Pilha (`OBF_STACK_ALLOC_MANIP`, `OBF_FAKE_PROLOGUE_MANIP`)**: Aloca blocos de tamanho variável na pilha e realiza manipulações falsas neles. Prólogos falsos tentam confundir a análise de pilha.
* **Chamadas de Função Ofuscadas (`OBF_CALL_VIA_OBF_PTR`)**: Ponteiros de função são submetidos a XOR com uma chave dinâmica antes e depois de serem usados, ocultando o verdadeiro alvo da chamada.
* `K8_ASSUME(0)`: Usado em caminhos de código morto para indicar ao compilador MSVC que esses caminhos são inalcançáveis, potencialmente permitindo otimizações ou geração de código diferentes que podem confundir ainda mais a análise se a suposição for violada por um patch.
### Dependências
A biblioteca Obfusk8 é modular. A funcionalidade principal depende de:
- `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp`: (Este arquivo) O cabeçalho central que orquestra e fornece os principais macros e primitivas de ofuscação.
- `Obfusk8/Instrumentation/materialization/transform/AES8.hpp`: Fornece criptografia de strings em tempo de compilação baseada em AES e recursos opcionais de manipulação de seções PE.
- `Obfusk8/Instrumentation/materialization/transform/Resolve8.hpp`: Implementa a resolução furtiva de APIs do Windows baseada no PEB.
* `Obfusk8/Instrumentation/materialization/transform/k8_indsys.hpp`: Orquestra o **Mecanismo de Syscall Indireto**. Ele gerencia o ciclo de vida dos stubs de transição e fornece a interface para executar chamadas de sistema por meio de gadgets de memória laterais.
* `Obfusk8/Instrumentation/materialization/transform/getpeb8.hpp`: Facilita o bootstrap inicial e a **Descoberta do PEB**. Contém a lógica de hash personalizada, definições de estruturas nativas e o algoritmo "Sorting Hat" para dedução de SSN. Ele serve como a base de baixo nível para todas as tarefas de enumeração de módulos.
Classes auxiliares de API opcionais são fornecidas em cabeçalhos separados, normalmente localizados em subdiretórios:
- `k8_ProcessManipulationAPIs/k8_ProcessManipulationAPIs.hpp`: Para APIs furtivas de manipulação de processos.
- `k8_CryptographyAPIs/k8_CryptographyAPIs.hpp`: Para APIs furtivas de criptografia.
- `k8_NetworkingAPIs/k8_NetworkingAPIs.hpp`: Para APIs furtivas de rede.
- `k8_RegistryAPIs/k8_RegistryAPIs.hpp`: Para APIs furtivas de registro.
### Visualização
* **grafo do ida**:
* **alguns trechos do ida pro**:
* **resultados de assinaturas do detect it easy**:
* **Regras YARA de crowdsourcing do virustotal**:
* **mapa de memória (do die)**:
* **seções**:
* **arquivos vinculados**:
### Perfil de Análise e Detecção do Mecanismo
O Obfusk8 é projetado para priorizar a evasão de mecanismos de detecção baseados em assinaturas estáticas. Testes contra fornecedores padrão do setor mostram que a lógica central de ofuscação permanece não detectada pelos principais produtos de segurança, incluindo:
* **Microsoft Defender**: Não detectado
* **Kaspersky**: Não detectado
* **ESET-NOD32**: Não detectado
* **BitDefender**: Não detectado
Embora assinaturas estáticas sejam contornadas, alguns AVs de próxima geração e EDRs (como CrowdStrike ou Symantec) podem gerar sinalizações heurísticas rotuladas como "suspicious" ou "high Confidence Malicious." Essas detecções são normalmente acionadas pela alta complexidade arquitetural e pela presença de seções PE personalizadas, e não por código malicioso identificável.
### Características Estruturais e Forenses
* **gerenciamento de entropia**: A implementação atual produz uma entropia global de aproximadamente 6.2. Isso é intencionalmente equilibrado para ser alto o suficiente para obscurecer a lógica, mas baixo o suficiente para evitar os alertas comuns de "arquivo empacotado" acionados por níveis de entropia acima de 7.0.
* **Personalização de Seções**: a configuração padrão inclui 23 seções PE, algumas das quais usam nomes de isca (ex.: `.themida`, `.vmp0`, `.enigma2`) para imitar protetores comerciais conhecidos.
* **Otimização Heurística**: para reduzir ainda mais a pontuação de suspeita, os usuários podem renomear essas seções para strings genéricas (ex.: `.data_01`, `.rdata_aux`). Padronizar os nomes das seções geralmente reduz a pontuação heurística de "exclusividade", fazendo o binário parecer mais um aplicativo compilado convencional.
* **Ofuscação de Importações**: A biblioteca elimina com sucesso a pegada da Tabela de Endereços de Importação (IAT) para APIs críticas do Windows. Ao utilizar o Bloco de Ambiente do Processo (PEB) para resolução e o mecanismo de Syscall Indireto, o binário mantém uma pilha de chamadas limpa, impedindo que monitores comportamentais rastreiem chamadas de sistema de volta às regiões de código protegidas.
- **explicação rápida**:
* **dedução de SSN**: para contornar os hooks em modo de usuário frequentemente colocados no fluxo de instruções do ntdll.dll, o mecanismo utiliza um algoritmo de ordenação relativa. Ao analisar o Diretório de Exportação e ordenar todas as funções com prefixo Zw por seus endereços de memória, o mecanismo deduz os Números de Serviço do Sistema (SSNs) com base em seu índice relativo. Isso permite que a estrutura identifique o índice correto de syscall sem nunca ler os bytes hookados do prólogo da função.
Stubs Dinâmicos de Syscall: Em vez de utilizar instruções de syscall estáticas dentro do binário em modo de usuário, a biblioteca aloca dinamicamente memória executável para hospedar stubs de transição transitórios. O mecanismo preenche esses stubs com uma sequência de shellcode personalizada (`mov r10, rcx; mov eax, ssnnumber; syscall; ret`) para executar chamadas de sistema indiretamente.
* **bootstrapping em cadeia**: o processo de resolução é auto-inicializado; o mecanismo usa uma chamada resolvida inicial para estabelecer o ambiente para syscalls indiretos subsequentes. Isso garante que todo o ciclo de vida do processo—da enumeração de módulos à execução de funções—permaneça opaco para monitores comportamentais e mantenha uma pilha de chamadas limpa.
* **anti-forense**: O uso de Aritmética Booleana Mista (MBA) e Arquitetura de Conjunto de Instruções Virtuais (V-ISA) em múltiplas camadas garante que, mesmo que um dump de memória seja obtido, a lógica subjacente não seja trivial de reconstruir por meio de ferramentas automatizadas de desofuscação.
### Uso
1. Inclua `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` no arquivo principal do seu projeto (ex.: `main.cpp`).
```cpp
#include "Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp" // Adjust path as needed
```
2. Envolva o corpo da sua função `main` com o `_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. Use `OBFUSCATE_STRING("your string")` para todos os literais de string importantes. Acesse a string descriptografada por meio do método `.c_str()` se necessário para chamadas de API, ou use seus outros métodos como `.print_to_console()` se fornecidos por `Obfusk8/Instrumentation/materialization/transform/AES8.hpp`.
4. Use `STEALTH_API_OBFSTR("dll_name.dll", "FunctionNameA")` para chamadas de API furtivas diretas ou, preferencialmente, use as classes wrapper de API (ex.: `K8_ProcessManipulationAPIs::ProcessAPI`, `k8_NetworkingAPIs::NetworkingAPI`) para conveniência e furtividade integrada.
5. Salpique `OBF_BOGUS_FLOW_*`, `OBF_CALL_ANY_LOCAL_JUNK`, `NOP()` e outros primitivos em seções críticas não sensíveis a desempenho do seu código para camadas adicionais de ofuscação.
* veja o arquivo main.cpp.
### Compilação
* **Requisito do Compilador**: Esta biblioteca é projetada para C++17. O Compilador C++ da Microsoft (`cl.exe`) é o alvo principal, especialmente para recursos de seções PE e uso de SEH.
* **Obtendo `cl.exe` (Compilador MSVC) no Windows**:
1. **Instale o Visual Studio**: A maneira mais fácil de obter o `cl.exe` é instalando o Visual Studio. Você pode baixar a edição Visual Studio Community gratuitamente no [site do Visual Studio](https://visualstudio.microsoft.com/downloads/).
2. **Selecione a carga de trabalho**: Durante a instalação, certifique-se de selecionar a carga de trabalho "Desenvolvimento para desktop com C++". Isso instalará o compilador C++, o SDK do Windows e outras ferramentas necessárias.
3. **Use o Prompt de Comando do Desenvolvedor**: Após a instalação, procure por "Prompt de Comando do Desenvolvedor para VS" (ex.: "Prompt de Comando de Ferramentas Nativas x64 para VS 2022") no Menu Iniciar e execute-o. Esse prompt de comando configura automaticamente as variáveis de ambiente (PATH, INCLUDE, LIB) necessárias para usar o `cl.exe`.
* **Caminhos de Inclusão**:
* Garanta que o diretório que contém `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` esteja no caminho de inclusão do seu compilador.
* Se `Obfusk8/Instrumentation/materialization/transform/AES8.hpp`, `Obfusk8/Instrumentation/materialization/transform/Resolve8.hpp` e os diretórios dos wrappers de API (ex.: `k8_NetworkingAPIs/`) não estiverem no mesmo diretório que `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp`, garanta que seus caminhos também estejam configurados corretamente. `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` usa caminhos relativos como `../Obfusk8Core.hpp` para alguns de seus includes internos dos wrappers de API, portanto a estrutura de diretórios importa. Se `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` estiver na raiz do seu diretório de inclusão para esta biblioteca, os wrappers de API devem estar em subdiretórios como `k8_NetworkingAPIs/` relativos ao local onde `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` os espera, ou ajuste os caminhos de inclusão dentro do próprio `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp`.
* **Exemplo de Compilação (usando o Prompt de Comando do Desenvolvedor)**:
Supondo que seu `main.cpp` e os cabeçalhos do Obfusk8 estejam estruturados corretamente, você pode compilar usando um comando semelhante a:
```bash
cl /std:c++17 /EHsc main.cpp
```
* após abrir o `Prompt de Comando de Ferramentas Nativas x64 para VS 2022`:
* `/std:c++17`: Especifica o padrão C++17.
* `/EHsc`: Especifica o modelo de tratamento de exceções C++.
* `main.cpp`: Seu arquivo de código-fonte principal.
* `/I"caminho/para/seus/obfusk8_includes"`: (Opcional, se os cabeçalhos não estiverem nos caminhos padrão) Adicione o diretório onde `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` e suas dependências estão localizados. Se eles estiverem em subdiretórios, garanta que os caminhos relativos dentro de `Obfusk8Core.hpp` correspondam ao seu layout.
* **Nota sobre Bibliotecas**: Embora a resolução furtiva de APIs tenha como objetivo evitar a vinculação estática das funções ofuscadas, os próprios cabeçalhos do SDK do Windows podem exigir que certos arquivos `.lib` estejam disponíveis para o vinculador, a fim de resolver qualquer uso não ofuscado do SDK ou tipos internos (ex.: `Ws2_32.lib`, `Wininet.lib`, `Advapi32.lib`, etc.). Para um projeto simples como `cl /std:c++17 /EHsc main.cpp`, o vinculador geralmente resolve isso automaticamente se forem bibliotecas padrão do Windows.
* **CMAKE**: você também pode compilar o Obfusk8 usando cmake.
1. clone e entre no repositório: `git clone https://github.com/x86byte/Obfusk8.git` e entre no diretório `cd Obfusk8`
2. configure e gere os arquivos: `cmake CMakeLists.txt`
3. seleção automática das ferramentas de compilação e compilação: `cmake --build .`
* após abrir o `Prompt de Comando de Ferramentas Nativas x64 para VS 2022`:
* **CMAKE && Microsoft Visual Studio**:
* após abrir o `microsoft visual studio`, clique em `Ctrl + B` para compilar o projeto:
* **Considerações sobre o Tamanho do Binário e Melhorias Futuras**:
* **Impacto no Tamanho**: Esteja ciente de que o uso extensivo de ofuscação somente em cabeçalhos, especialmente com técnicas como inlining de código lixo, expansões de MBA e fluxo de controle achatado, pode levar a um aumento significativo no tamanho final do binário. Um programa pequeno pode crescer de kilobytes para potencialmente 2MB ou mais, dependendo da intensidade da ofuscação aplicada.
* **Personalização e Empacotamento (Direção Futura)**:
* Atualmente, o Obfusk8 foca na ofuscação no código. Os usuários podem precisar ajustar o uso de vários macros (ex.: reduzir a densidade de `OBF_CALL_ANY_LOCAL_JUNK` ou a complexidade dos loops do `_main`) se o tamanho do binário for uma restrição crítica.
* Para uma redução substancial de tamanho após a ofuscação, integrar ou usar um empacotador de PE externo (como UPX, MPRESS ou soluções personalizadas) seria uma etapa separada.
* O desenvolvimento futuro do Obfusk8 poderia explorar opções para um controle mais granular sobre a intensidade da ofuscação ou até integrar stubs leves de empacotamento/compressão diretamente na biblioteca, embora isso aumentaria significativamente sua complexidade.
### Ofuscação de PE Pós-Compilação
O Obfusk8 inclui um script pós-compilação para endurecer ainda mais o binário compilado, removendo artefatos forenses.
* **Localização do Script**: `Obfusk8/SCRIPTS/obfuscate_pe.ps1`
* **O que ele faz**:
1. **Remove o Rich Header** — remove a impressão digital do ambiente de compilação do MSVC que revela a versão do compilador e detalhes da cadeia de ferramentas.
2. **Spoofa o TimeDateStamp** — substitui o carimbo de data/hora do cabeçalho PE por um valor fixo para obscurecer o horário de compilação.
3. **Limpa o Diretório de Depuração** — apaga entradas do diretório de depuração que poderiam vazar caminhos de PDB ou metadados de compilação.
* **Uso**:
Execute como uma etapa pós-compilação após compilar:
```powershell
PowerShell -NoProfile -ExecutionPolicy Bypass -File Obfusk8/SCRIPTS/obfuscate_pe.ps1 -Path "path\to\Obfusk8.exe"
```
O script modifica o binário no local. Nenhum backup é criado.
### Demonstração
[[Obfusk8: Biblioteca de Ofuscação Baseada em C++17 - Visualização em Grafo do IDA Pro] ~Vídeo de Demonstração](https://youtu.be/B9g4KSg3tHQ)
### contribuição e feedbackEste projeto, Obfusk8, é uma exploração contínua de técnicas avançadas de ofuscação em C++. A versão atual estabelece uma base sólida com uma infinidade de estratégias entrelaçadas.
* **Seu Feedback é Inestimável**: Como desenvolvedor do Obfusk8, estou profundamente interessado na sua perspectiva, percepções e em qualquer feedback que você possa ter. Seja sugestões de novos recursos, melhorias nas técnicas existentes, relatos de tentativas bem-sucedidas (ou malsucedidas) de engenharia reversa contra código protegido pelo Obfusk8, ou pensamentos gerais sobre a usabilidade e eficácia da biblioteca.
* **Contribuição**: todas as contribuições são bem-vindas e altamente apreciadas. Este projeto prospera com a contribuição da comunidade e testes no mundo real para ampliar seus limites e se tornar uma ferramenta ainda mais formidável para proteção de código. Sinta-se à vontade para compartilhar suas ideias, abrir issues ou contribuir para sua evolução!.
* **[Como contribuir com o Obfusk8?](https://opensource.guide/how-to-contribute/)**
### Agradecimentos Especiais
* [sadMosquito](https://github.com/sadMosquito) — por relatar problemas e testar o projeto
**Aviso Legal**
Ofuscação é uma camada de defesa, não uma solução infalível. Atacantes determinados, com habilidade e tempo suficientes, muitas vezes conseguem fazer engenharia reversa de código ofuscado. O Obfusk8 visa elevar significativamente o nível de dificuldade para tais esforços. Utilize em conjunto com outras medidas de segurança.
**Entre em Contato**
Se você quiser compartilhar feedback, discutir técnicas de ofuscação, relatar tentativas de engenharia reversa ou apenas ter uma discussão técnica, sinta-se à vontade para falar diretamente comigo. Estou sempre aberto a conversas construtivas e colaboração (ficaria feliz em colaborar em projetos relacionados a ofuscação ou qualquer outra coisa).
- x : https://x.com/x86byte
- telegram: https://t.me/x86byte
- discord: @x86byte