x86byte/obfusk8Obfusk8: bibliothèque d'obfuscation légère basée sur C++17 / Header Only pour binaires windows
Obfusk8 est une bibliothèque légère, uniquement en-tête, conçue pour le C++17, destinée à renforcer considérablement l'obfuscation de vos applications, rendant la rétro-ingénierie nettement plus ardue. Elle y parvient grâce à un ensemble varié de techniques à la compilation et à l'exécution visant à protéger la logique et les données de votre code.
main_mainLe point d'entrée de votre application (main) est transformé en un moteur d'obfuscation complexe et multicouche :
main_body ne soit exécuté, une mini-MV (CPU simulé) exécute une séquence d'instructions « chiffrées ». Cela dissimule le véritable point d'entrée et les opérations initiales. L'état de la MV (registres, compteur de programme, clé de dispatch) est initialisé avec des valeurs aléatoires à l'exécution._main (à la fois dans le prologue et l'épilogue) sont transformées en machines à états complexes. Le flux de contrôle n'est pas direct mais déterminé par des variables d'état fortement « chiffrées ». Les clés de codage/décodage de ces variables d'état sont dynamiques, dérivées de l'état de la MV, des compteurs de boucle, de l'aléatoire à la compilation (comme __COUNTER__, __LINE__, __TIME__) et d'une graine opaque globale. Cela rend l'analyse statique du flux de contrôle exceptionnellement difficile.
obf_icff_ns_dcff et obf_icff_ns_epd) sont utilisés avec des logiques de transition d'état et de génération de clés différentes, compliquant encore l'analyse.OBF_BOGUS_FLOW_* macros) : De nombreux motifs de saut trompeurs et structures conditionnelles alambiquées sont injectés tout au long de _main. Ceux-ci utilisent des instructions goto combinées à des prédicats opaques (conditions qui s'évaluent toujours à vrai ou faux mais qui sont coûteuses en calcul ou difficiles à déterminer statiquement). Cela crée un labyrinthe de fausses pistes pour les désassembleurs et décompilateurs.
OBF_BOGUS_FLOW_LABYRINTH, OBF_BOGUS_FLOW_GRID, OBF_BOGUS_FLOW_SCRAMBLE, OBF_BOGUS_FLOW_WEAVER, OBF_BOGUS_FLOW_CASCADE et OBF_BOGUS_FLOW_CYCLONE pour générer des flux factices variés et complexes.Runtime, SEH) :
__except peuvent modifier l'état du programme, rendant difficile le suivi si le débogueur ignore les exceptions.Runtime contient des conditions qui, si elles sont remplies (en raison d'états MV spécifiques ou de temporisation), pourraient déclencher __debugbreak() ou lever des exceptions, conçues pour perturber les sessions de débogage.obf_vm_engine)Un composant central de la macro _main pour l'obfuscation :
r0, r1, r2), un compteur de programme (pc) et une dispatch_key. Il exécute des « instructions » personnalisées (gestionnaires).reg_dispatch_idx).get_mem_dispatch_table).mixed_dispatch_idx).
La dispatch_key est constamment mutée, rendant la séquence des gestionnaires exécutés hautement imprévisible.vm_handler_table) est elle-même mutée à l'exécution dans le prologue et l'épilogue de _main, obscurcissant davantage le comportement de la MV.OBFUSCATE_STRING de AES8.hpp)__FILE__, __LINE__) et de l'heure de compilation (__DATE__, __TIME__).AES8.hpp).STEALTH_API_OBFSTR / STEALTH_API_OBF de Resolve8.hpp)GetModuleHandle et GetProcAddress pour la résolution initiale si ceux-ci ne sont pas encore résolus par ce mécanisme.CT_HASH) des noms de DLL et d'API pour les recherches. Cela empêche l'apparition des noms en clair de DLL et d'API dans les données relatives aux importations ou dans les tables de chaînes du binaire lors de l'utilisation de ces macros.K8_SYSCALL)Obfusk8 intègre désormais un mécanisme d'appels système indirects de pointe pour contourner les hooks en mode utilisateur (EDR/AV) et les vérifications d'analyse statique.
K8_SYSCALL("ZwOpenProcess", ...) au lieu de NtOpenProcess.OBF_METHOD)Obfusk8 offre désormais un contrôle granulaire sur la sécurité de votre binaire grâce à l'Obfuscation par Méthode. Au lieu d'obfusquer l'intégralité de votre projet (ce qui peut impacter les performances), vous pouvez désormais protéger sélectivement des fonctions spécifiques de grande valeur ou des méthodes de classe.
OBF_METHOD : ```cpp
OBF_METHOD(ret_type, func_name, params, method_body)
ret_type : Le type de retour de votre fonction (par ex., bool, int, void*).func_name : Le nom de la méthode.params : Les paramètres de la fonction (doivent être entre parenthèses).method_body : La logique réelle de votre fonction entre { }.Dans cet exemple, PrintStatus est une fonction normale et lisible. Obfusk8_PrintStatus est protégée par 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; })
*Vous pouvez voir l'exemple complet ici : [obfusk8_methods.cpp](https://github.com/x86byte/Obfusk8/blob/main/Obfusk8/EXAMPLES/obfusk8_methods.cpp)*
---
### 6. Classes d’abstraction API avec furtivité intégrée
Obfusk8 fournit des classes auxiliaires qui encapsulent des ensembles courants d’API Windows. Ces classes utilisent automatiquement le mécanisme de résolution furtive d’API (`STEALTH_API_OBFSTR`) lors de leur construction, garantissant que les fonctions Windows sous-jacentes sont résolues sans laisser de traces d’importation statiques évidentes.
- **`K8_ProcessManipulationAPIs::ProcessAPI` (`k8_ProcessManipulationAPIs.hpp`)** :
* Fournit un accès pratique aux API Windows pour la manipulation de processus, telles que `OpenProcess`, `TerminateProcess`, `CreateRemoteThread`, `VirtualAllocEx`, `WriteProcessMemory`, `ReadProcessMemory`, `GetProcAddress`, `GetModuleHandleA`, `NtQueryInformationProcess`, `SuspendThread` et `GetCurrentProcessId`.
* **Résolution furtive automatique** : Résout les fonctions nécessaires depuis `kernel32.dll` et `ntdll.dll` de manière furtive.
* Simplifie l’exécution d’opérations liées aux processus avec une empreinte d’analyse statique réduite. Inclut l’énumération `PROCESSINFOCLASS` pour une utilisation avec `NtQueryInformationProcess`.
- **`k8_CryptographyAPIs::CryptographyAPI` (`k8_CryptographyAPIs.hpp`)** :
* Propose des wrappers pour les fonctions courantes de l’API de cryptographie Windows (CAPI/CNG). (Les fonctionnalités dépendent de l’implémentation réelle de ce fichier – l’extrait fourni était un doublon. En supposant des fonctions CAPI typiques comme `CryptAcquireContextA`, `CryptCreateHash`, etc.)
* **Résolution furtive automatique** : Résout les fonctions nécessaires principalement depuis `advapi32.dll` (et `kernel32.dll` pour les fonctions de base) de manière furtive.
* Facilite les opérations cryptographiques tout en minimisant l’exposition de l’utilisation de l’API crypto.
- **`k8_NetworkingAPIs::NetworkingAPI` (`k8_NetworkingAPIs.hpp`)** :
* Fournit un accès facile à un large éventail de fonctions réseau depuis `wininet.dll` (par ex., `InternetOpenA`, `HttpOpenRequestA`, `FtpPutFileA`), `urlmon.dll` (par ex., `URLDownloadToFileA`), `ws2_32.dll` (par ex., `socket`, `connect`, `WSAStartup`), `shell32.dll` (par ex., `ShellExecuteA`), `dnsapi.dll` (par ex., `DnsQuery_A`) et `mpr.dll` (par ex., `WNetOpenEnumA`).
* **Résolution furtive automatique** : Dans son constructeur, il utilise `STEALTH_API_OBFSTR` et `OBFUSCATE_STRING` pour résoudre toutes les fonctions requises depuis leurs DLL respectives (et `kernel32.dll` pour `LoadLibraryA`/`GetLastError`) sans laisser de traces d’importation évidentes.
* Simplifie l’exécution de requêtes réseau obscurcies et d’autres tâches liées au réseau.
- **`RegistryAPIs::RegistryAPI` (`k8_RegistryAPIs.hpp`)** :
* Encapsule les fonctions de registre Windows couramment utilisées telles que `RegSetValueExA`, `RegCreateKeyExA`, `RegOpenKeyExA`, `RegQueryValueExA`, `RegCloseKey`, etc.
* **Résolution furtive automatique** : Résout les fonctions depuis `advapi32.dll` (et `kernel32.dll`) de manière furtive lors de la construction.
* Aide à effectuer des opérations sur le registre avec des appels API moins traçables.
### 7. Primitives d’obscurcissement de base (Macros dans `Obfusk8Core.hpp`)
Ce sont les éléments de base utilisés de manière intensive dans toute la bibliothèque, en particulier dans la macro `_main` et le moteur de VM :
* **Arithmétique booléenne mixte (MBA)** : Transforme des opérations mathématiques et logiques simples (ADD, SUB, XOR, NOT, MUL) en séquences complexes mais équivalentes de formules bit à bit et arithmétiques (par ex., `OBF_MBA_ADD`, `OBF_MBA_XOR`). Elles sont conçues pour être très difficiles à simplifier par les décompilateurs pour retrouver leur forme originale.
* **Prédicats opaques** : Insère des branches conditionnelles dont la condition s’évalue toujours à vrai (par ex., `OBF_OPAQUE_PREDICATE_TRUE_1`) ou toujours à faux (par ex., `OBF_OPAQUE_PREDICATE_FALSE_1`). Ces conditions sont construites à partir d’expressions complexes et difficiles à évaluer statiquement impliquant `__COUNTER__`, `__LINE__`, `__TIME__` et la `_obf_global_opaque_seed`. Elles créent des chemins de code trompeurs et peuvent être utilisées pour protéger du code mort ou forcer des flux d’exécution spécifiques.
* **Injection de code indésirable** :
* `OBF_CALL_ANY_LOCAL_JUNK` : Appelle l’une des nombreuses petites fonctions indésirables aléatoires définies dans `obf_junk_ns`. Ces fonctions effectuent des opérations triviales et volatiles et sont sélectionnées aléatoirement à la compilation. Leur but est d’augmenter l’entropie du code, de briser les motifs de code simples et potentiellement d’induire en erreur la détection par signature ou les outils d’analyse.
* `NOP()` : Une macro qui insère des opérations volatiles conçues pour empêcher une suppression facile par les optimiseurs et pour modifier subtilement une graine globale.
* **Astuces anti-désassemblage et anti-analyse** :
* **Sauts obscurcis (macros `OBF_JUMP_*`)** : Crée des instructions `goto` dont les conditions ou les cibles sont obscurcies, reposant souvent sur des prédicats opaques ou MBA.
* **Transitions d’état obscurcies (macros `OBF_SET_NEXT_STATE_*`)** : Utilisées dans ICFF, ces macros définissent la variable d’état suivante pour le répartiteur de flux de contrôle aplati en utilisant des techniques d’obscurcissement similaires aux sauts obscurcis.
* **Manipulation de la pile (`OBF_STACK_ALLOC_MANIP`, `OBF_FAKE_PROLOGUE_MANIP`)** : Alloue des morceaux de taille variable sur la pile et effectue des manipulations factices sur ceux-ci. Les prologues factices tentent de confondre l’analyse de la pile.
* **Appels de fonction obscurcis (`OBF_CALL_VIA_OBF_PTR`)** : Les pointeurs de fonction sont XORés avec une clé dynamique avant et après utilisation, obscurcissant la véritable cible de l’appel.
* `K8_ASSUME(0)` : Utilisé dans les chemins de code mort pour indiquer au compilateur MSVC que ces chemins sont inaccessibles, permettant potentiellement des optimisations ou une génération de code différentes qui pourraient encore plus confondre l’analyse si l’hypothèse est violée par un patch.
### Dépendances
La bibliothèque Obfusk8 est modulaire. Les fonctionnalités de base reposent sur :
- `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` : (Ce fichier) L’en-tête central qui orchestre et fournit les principales macros et primitives d’obscurcissement.
- `Obfusk8/Instrumentation/materialization/transform/AES8.hpp` : Fournit le chiffrement de chaîne basé sur AES à la compilation et des fonctionnalités optionnelles de manipulation de section PE.
- `Obfusk8/Instrumentation/materialization/transform/Resolve8.hpp` : Implémente la résolution furtive d’API Windows basée sur le PEB.
* `Obfusk8/Instrumentation/materialization/transform/k8_indsys.hpp` : Orchestre le **moteur d’appel système indirect**. Il gère le cycle de vie des stubs de transition et fournit l’interface pour exécuter des appels système via des gadgets mémoire latéraux.
* `Obfusk8/Instrumentation/materialization/transform/getpeb8.hpp` : Facilite l’amorçage initial et la **découverte du PEB**. Il contient la logique de hachage personnalisée, les définitions de structure natives et l’algorithme du « Tri par chapeau » pour la déduction des SSN. Il sert de fondation de bas niveau pour toutes les tâches d’énumération de modules.
Les classes d’API auxiliaires optionnelles sont fournies dans des en-têtes séparés, généralement situés dans des sous-répertoires :
- `k8_ProcessManipulationAPIs/k8_ProcessManipulationAPIs.hpp` : Pour les API de manipulation de processus furtives.
- `k8_CryptographyAPIs/k8_CryptographyAPIs.hpp` : Pour les API de cryptographie furtives.
- `k8_NetworkingAPIs/k8_NetworkingAPIs.hpp` : Pour les API réseau furtives.
- `k8_RegistryAPIs/k8_RegistryAPIs.hpp` : Pour les API de registre furtives.
### Visualisation
* **graphe IDA** :
* **quelques fragments d’IDA Pro** :
* **résultats des signatures Detect It Easy** :
* **Règles YARA issues du crowdsourcing de VirusTotal** :
* **carte mémoire (depuis DIE)** :
* **sections** :
* **fichiers liés** :
### Analyse du moteur et profil de détection
Obfusk8 est conçu pour prioriser le contournement des moteurs de détection basés sur des signatures statiques. Les tests effectués auprès de fournisseurs standards du secteur montrent que la logique d’obscurcissement de base reste non détectée par les principaux produits de sécurité, notamment :
* **Microsoft Defender** : Non détecté
* **Kaspersky** : Non détecté
* **ESET-NOD32** : Non détecté
* **BitDefender** : Non détecté
Bien que les signatures statiques soient contournées, certains AV de nouvelle génération et EDR (comme CrowdStrike ou Symantec) peuvent générer des indicateurs heuristiques étiquetés comme « suspects » ou « malveillants à haute confiance ». Ces détections sont généralement déclenchées par la complexité architecturale élevée et la présence de sections PE personnalisées plutôt que par un code malveillant identifiable.
### Caractéristiques structurelles et médico-légales
* **Gestion de l’entropie** : L’implémentation actuelle produit une entropie globale d’environ 6,2. Cela est intentionnellement équilibré pour être suffisamment élevé afin d’obscurcir la logique, mais suffisamment bas pour éviter les alertes courantes de « fichier compressé » déclenchées par une entropie supérieure à 7,0.
* **Personnalisation des sections** : La configuration par défaut comprend 23 sections PE, dont certaines utilisent des noms leurres (par ex., `.themida`, `.vmp0`, `.enigma2`) pour imiter des protecteurs commerciaux connus.
* **Optimisation heuristique** : Pour réduire davantage le score de suspicion, les utilisateurs peuvent renommer ces sections en chaînes génériques (par ex., `.data_01`, `.rdata_aux`). La normalisation des noms de sections abaisse souvent le score d’« unicité » heuristique, rendant le binaire plus semblable à une application compilée conventionnelle.
* **Obscurcissement des importations** : La bibliothèque parvient à éliminer l’empreinte de la table des adresses d’importation (IAT) pour les API Windows critiques. En utilisant le bloc d’environnement de processus (PEB) pour la résolution et le moteur d’appel système indirect, le binaire maintient une pile d’appels propre, empêchant les moniteurs comportementaux de tracer les appels système vers des régions de code protégées.
- **Explication rapide** :
* **Déduction des SSN** : Pour contourner les hooks en mode utilisateur souvent placés sur le flux d’instructions de ntdll.dll, le moteur utilise un algorithme de tri relatif. En analysant le répertoire d’exportation et en triant toutes les fonctions préfixées par Zw par leurs adresses mémoire, le moteur déduit les numéros de service système (SSN) en fonction de leur index relatif. Cela permet au framework d’identifier le bon index d’appel système sans jamais lire les octets hookés du prologue de fonction.
* **Stubs d’appel système dynamiques** : Au lieu d’utiliser des instructions d’appel système statiques dans le binaire en espace utilisateur, la bibliothèque alloue dynamiquement de la mémoire exécutable pour héberger des stubs de transition transitoires. Le moteur peuple ces stubs avec une séquence de shellcode personnalisée (`mov r10, rcx; mov eax, ssnnumber; syscall; ret`) pour exécuter les appels système indirectement.
* **Amorçage en chaîne** : Le processus de résolution est auto-amorcé ; le moteur utilise un appel résolu initial pour établir l’environnement pour les appels système indirects ultérieurs. Cela garantit que l’ensemble du cycle de vie du processus — de l’énumération des modules à l’exécution des fonctions — reste opaque pour les moniteurs comportementaux et maintient une pile d’appels propre.
* **Anti-forensique** : L’utilisation de l’arithmétique booléenne mixte (MBA) et de l’architecture de jeu d’instructions virtuelles (V-ISA) multicouche garantit que même si un dump mémoire est obtenu, la logique sous-jacente est non triviale à reconstruire par des outils de dés-obscurcissement automatisés.
### Utilisation
1. Inclure `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` dans votre fichier de projet principal (par ex., `main.cpp`).
```cpp
#include "Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp" // Ajustez le chemin si nécessaire
```
2. Encapsuler le corps de votre fonction `main` avec la macro `_main` :
```cpp
_main({
// Le code original de votre application main ici
// Exemple :
// OBFUSCATE_STRING("Hello, Obfuscated World!").c_str();
// Utilisation d’une classe wrapper d’API
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) {
// ... utiliser hInternet ...
netAPI->pInternetCloseHandle(hInternet);
}
}
delete netAPI;
})
```
3. Utiliser `OBFUSCATE_STRING("votre chaîne")` pour tous les littéraux de chaîne importants. Accédez à la chaîne déchiffrée via sa méthode `.c_str()` si nécessaire pour les appels API, ou utilisez ses autres méthodes comme `.print_to_console()` si fournies par `Obfusk8/Instrumentation/materialization/transform/AES8.hpp`.
4. Utiliser `STEALTH_API_OBFSTR("dll_name.dll", "FunctionNameA")` pour les appels API furtifs directs, ou de préférence utilisez les classes wrapper d’API (par ex., `K8_ProcessManipulationAPIs::ProcessAPI`, `k8_NetworkingAPIs::NetworkingAPI`) pour plus de commodité et une furtivité intégrée.
5. Parsemez `OBF_BOGUS_FLOW_*`, `OBF_CALL_ANY_LOCAL_JUNK`, `NOP()` et d’autres primitives dans les sections critiques non sensibles aux performances de votre code pour des couches d’obscurcissement supplémentaires.
* Voir le fichier main.cpp.
### Compilation
* **Configuration requise du compilateur** : Cette bibliothèque est conçue pour C++17. Le compilateur Microsoft C++ (`cl.exe`) est principalement ciblé, en particulier pour les fonctionnalités de section PE et l’utilisation de SEH.
* **Obtenir `cl.exe` (compilateur MSVC) sur Windows** :
1. **Installer Visual Studio** : Le moyen le plus simple d’obtenir `cl.exe` est d’installer Visual Studio. Vous pouvez télécharger l’édition Community de Visual Studio gratuitement depuis le [site Web de Visual Studio](https://visualstudio.microsoft.com/downloads/).
2. **Sélectionner la charge de travail** : Pendant l’installation, assurez-vous de sélectionner la charge de travail « Développement Desktop en C++ ». Cela installera le compilateur C++, le SDK Windows et d’autres outils nécessaires.
3. **Utiliser l’invite de commandes développeur** : Après l’installation, recherchez « Invite de commandes développeur pour VS » (par ex., « x64 Native Tools Command Prompt for VS 2022 ») dans votre menu Démarrer et exécutez-la. Cette invite de commandes configure automatiquement les variables d’environnement (PATH, INCLUDE, LIB) nécessaires pour utiliser `cl.exe`.
* **Chemins d’inclusion** :
* Assurez-vous que le répertoire contenant `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` est dans le chemin d’inclusion de votre compilateur.
* Si `Obfusk8/Instrumentation/materialization/transform/AES8.hpp`, `Obfusk8/Instrumentation/materialization/transform/Resolve8.hpp` et les répertoires des wrappers d’API (par ex., `k8_NetworkingAPIs/`) ne sont pas dans le même répertoire que `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp`, assurez-vous que leurs chemins sont également configurés correctement. `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` utilise des chemins relatifs comme `../Obfusk8Core.hpp` pour certaines de ses inclusions internes des wrappers d’API, donc la structure des répertoires est importante. Si `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` est à la racine de votre répertoire d’inclusion pour cette bibliothèque, alors les wrappers d’API doivent se trouver dans des sous-répertoires comme `k8_NetworkingAPIs/` par rapport à l’endroit où `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` les attend, ou ajustez les chemins d’inclusion dans `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` lui-même.
* **Exemple de compilation (avec l’invite de commandes développeur)** :
En supposant que votre `main.cpp` et les en-têtes Obfusk8 sont correctement structurés, vous pouvez compiler en utilisant une commande similaire à :
```bash
cl /std:c++17 /EHsc main.cpp
```
* après avoir ouvert `x64 Native Tools Command Prompt for VS 2022` :
* `/std:c++17` : Spécifie la norme C++17.
* `/EHsc` : Spécifie le modèle de gestion des exceptions C++.
* `main.cpp` : Votre fichier source principal.
* `/I"chemin/vers/vos/includes_obfusk8"` : (Facultatif, si les en-têtes ne sont pas dans les chemins par défaut) Ajoutez le répertoire où se trouvent `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` et ses dépendances. S’ils sont dans des sous-répertoires, assurez-vous que les chemins relatifs dans `Obfusk8Core.hpp` correspondent à votre structure.
* **Note sur les bibliothèques** : Bien que la résolution furtive d’API vise à éviter la liaison statique pour les fonctions obscurcies, les en-têtes du SDK Windows eux-mêmes peuvent nécessiter la disponibilité de certains fichiers `.lib` pour l’éditeur de liens afin de résoudre toute utilisation non obscurcie du SDK ou les types internes (par ex., `Ws2_32.lib`, `Wininet.lib`, `Advapi32.lib`, etc.). Pour un projet simple comme `cl /std:c++17 /EHsc main.cpp`, l’éditeur de liens les résout souvent automatiquement s’il s’agit de bibliothèques Windows standard.
* **CMAKE** : Vous pouvez également compiler Obfusk8 en utilisant CMake.
1. Clonez et accédez au dépôt : `git clone https://github.com/x86byte/Obfusk8.git` puis `cd Obfusk8`
2. Configurez et générez les fichiers : `cmake CMakeLists.txt`
3. Sélection automatique des outils de compilation et compilation : `cmake --build .`
* après avoir ouvert `x64 Native Tools Command Prompt for VS 2022` :
* **CMAKE && Microsoft Visual Studio** :
* après avoir ouvert Microsoft Visual Studio, cliquez sur `Ctrl + B` pour compiler le projet :
* **Considérations sur la taille du binaire et améliorations futures** :
* **Impact sur la taille** : Soyez conscient que l’utilisation intensive de l’obscurcissement dans les en-têtes, en particulier avec des techniques comme l’inlining de code indésirable, les expansions MBA et le flux de contrôle aplati, peut entraîner une augmentation significative de la taille finale du binaire. Un petit programme peut passer de quelques kilo-octets à potentiellement 2 Mo ou plus, selon l’intensité de l’obscurcissement appliqué.
* **Personnalisation et compression (direction future)** :
* Actuellement, Obfusk8 se concentre sur l’obscurcissement dans le code. Les utilisateurs pourraient avoir besoin d’affiner l’utilisation des diverses macros (par exemple, réduire la densité de `OBF_CALL_ANY_LOCAL_JUNK` ou la complexité des boucles de `_main`) si la taille du binaire est une contrainte critique.
* Pour une réduction substantielle de la taille après obscurcissement, l’intégration ou l’utilisation d’un compresseur PE externe (comme UPX, MPRESS ou des solutions personnalisées) serait une étape séparée.
* Le développement futur d’Obfusk8 pourrait explorer des options pour un contrôle plus granulaire de l’intensité de l’obscurcissement ou même intégrer des stubs de compression/empaquetage légers directement dans la bibliothèque, bien que cela augmente considérablement sa complexité.
### Obscurcissement PE post-compilation
Obfusk8 inclut un script post-compilation pour durcir davantage le binaire compilé en supprimant les artefacts médico-légaux.
* **Emplacement du script** : `Obfusk8/SCRIPTS/obfuscate_pe.ps1`
* **Ce qu’il fait** :
1. **Supprime l’en-tête Rich** — supprime l’empreinte de l’environnement de construction MSVC qui révèle la version du compilateur et les détails de la chaîne d’outils.
2. **Masque le TimeDateStamp** — remplace l’horodatage de l’en-tête PE par une valeur fixe pour obscurcir l’heure de construction.
3. **Efface le répertoire de débogage** — supprime les entrées du répertoire de débogage qui pourraient divulguer les chemins PDB ou les métadonnées de construction.
* **Utilisation** :
Exécutez-le comme étape post-compilation après la compilation :
```powershell
PowerShell -NoProfile -ExecutionPolicy Bypass -File Obfusk8/SCRIPTS/obfuscate_pe.ps1 -Path "chemin\vers\Obfusk8.exe"
```
Le script modifie le binaire sur place. Aucune sauvegarde n’est créée.
### Démo
[[Obfusk8: C++17-Based Obfuscation Library - IDA pro Graph View] ~Video Demo](https://youtu.be/B9g4KSg3tHQ)
### Contribution et retourCe projet, Obfusk8, est une exploration continue des techniques avancées d'obfuscation en C++. La version actuelle pose une base solide avec une multitude de stratégies entrelacées.
* **Votre retour est précieux** : En tant que développeur d'Obfusk8, je suis très intéressé par votre point de vue, vos idées et tout retour que vous pourriez avoir. Que ce soit des suggestions de nouvelles fonctionnalités, des améliorations des techniques existantes, des rapports de tentatives de rétro-ingénierie réussies (ou non) contre du code protégé par Obfusk8, ou des réflexions générales sur l'utilisabilité et l'efficacité de la bibliothèque.
* **Contribution** : toutes les contributions sont les bienvenues et grandement appréciées. Ce projet prospère grâce aux apports de la communauté et aux tests en conditions réelles pour repousser ses limites et devenir un outil de protection de code encore plus redoutable. N'hésitez pas à partager vos réflexions, à signaler des problèmes ou à contribuer à son évolution !.
* **[Comment contribuer à Obfusk8 ?](https://opensource.guide/how-to-contribute/)**
### Remerciements spéciaux
* [sadMosquito](https://github.com/sadMosquito) — pour avoir signalé des problèmes et testé le projet
**Avertissement**
L'obfuscation est une couche de défense, pas une solution infaillible. Des attaquants déterminés avec des compétences et du temps suffisants peuvent souvent rétro-ingénier un code obfusqué. Obfusk8 vise à relever considérablement le niveau de difficulté pour de tels efforts. À utiliser en conjonction avec d'autres mesures de sécurité.
**Contact**
Si vous souhaitez partager vos retours, discuter de techniques d'obfuscation, signaler des tentatives de rétro-ingénierie, ou simplement avoir une discussion technique, n'hésitez pas à me contacter directement. Je suis toujours ouvert aux conversations constructives et à la collaboration (je serais ravi de collaborer sur des projets liés à l'obfuscation ou tout autre chose).
- x : https://x.com/x86byte
- telegram: https://t.me/x86byte
- discord: @x86byte