obfus.h Téléchargement - obfus.h Téléchargement du code source

obfus.h

Code source C#

2024-11-24

Télécharger

obfus.h

OBFUS.H est une bibliothèque macro uniquement pour les applications de C de compilation à l'obscurcissement, conçu spécifiquement pour le minuscule C (TCC) . Il est adapté aux plates-formes Windows X86 et X64 et prend en charge presque toutes les versions du compilateur. Armure très fiable pour vos programmes C!

Quelles fonctionnalités ont-t-il? ...

? Obfuscation des appels de fonction : confondez les appels de fonction pour rendre votre code moins lisible aux yeux non autorisés.
? ️ Techniques anti-débugage : mécanismes intégrés pour empêcher l'analyse du code pendant l'exécution.
Mutation de code de flux de contrôle : transforme le code en spaghetti, ce qui rend difficile l'analyse des conditions et des boucles.
Techniques anti-décompilation : rend de nombreux décompilateurs populaires inutiles brisant visuellement leur production.
? Fausses signatures ajoutant : peut ajouter de fausses signatures de divers packers et protecteurs pour confondre les indexes inverses.
? Virtualisation : rend les opérations mathématiques très difficiles à comprendre à l'aide de commandes de machines virtuelles.

? Usage

L'intégration d'Obfus.h dans votre projet est un processus simple. Incluez simplement la ligne suivante dans votre code:

 #include "obfus.h"

Cela obscurcira automatiquement votre code pendant la compilation, assurant la protection et la confidentialité de votre propriété intellectuelle.

Options disponibles pour la protection Configuration:

 // 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

ou utilisez-le avec des args de compilateur:

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

Avertissement

Lors de la compilation d'une application avec obscurcissement, utilisez l'argument -w pour supprimer les avertissements. Sinon, la console affichera de nombreux journaux intimidants qui n'ont aucun impact sur le résultat final. Il n'est pas nécessaire d'être alarmé par eux.

? La protection du débogage est déclenchée par des appels vers de nombreuses fonctions de base MSVCRT. Dans les endroits critiques du code, vous pouvez utiliser l' ANTI_DEBUG; construction. Par exemple:

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

? Virtualisation

Il s'agit d'une technique de protection dans laquelle certains calculs sont effectués via une machine virtuelle intégrée sur commande. Rend une analyse des opérations mathématiques très difficile ! Il fonctionnera avec l'option VIRT activée (et seulement!). Sinon, toutes les commandes de machines virtuelles seront remplacées par des opérateurs mathématiques ordinaires.

Avertissement

La virtualisation dans des emplacements critiques peut avoir un impact sur l'optimisation. Utiliser avec prudence uniquement dans les zones où il est vraiment nécessaire

Fonction	Taper	Faire un coup de pouce	Description	Exemple
`VM_ADD`	long	`+`	Ajoute deux nombres	`VM_ADD(5, 3)` = `8`
`VM_SUB`	long	`-`	Soustrait deux nombres	`VM_SUB(5, 3)` = `2`
`VM_MUL`	long	`*`	Multiplie deux nombres	`VM_MUL(5, 3)` = `15`
`VM_DIV`	long	`/`	Divise deux nombres	`VM_DIV(6, 3)` = `2`
`VM_MOD`	long	`%`	Calcule le module de deux nombres	`VM_MOD(5, 3)` = `2`
`VM_EQU`	Bool	`==`	Vérifie si deux nombres sont égaux	`VM_EQU(5, 5)` = `true`
`VM_NEQ`	Bool	`!=`	Vérifie si deux nombres ne sont pas égaux	`VM_NEQ(5, 3)` = `true`
`VM_LSS`	Bool	`<`	Vérifie si le premier numéro est inférieur au deuxième numéro	`VM_LSS(3, 5)` = `true`
`VM_GTR`	Bool	`>`	Vérifie si le premier numéro est supérieur au deuxième numéro	`VM_GTR(5, 3)` = `true`
`VM_LEQ`	Bool	`<=`	Vérifie si le premier nombre est inférieur ou égal au deuxième nombre	`VM_LEQ(3, 5)` = `true`
`VM_GEQ`	Bool	`>=`	Vérifie si le premier nombre est supérieur ou égal au deuxième nombre	`VM_GEQ(5, 3)` = `true`
`VM_ADD_DBL`	long double	`+`	Ajoute deux nombres doubles	`VM_ADD_DBL(5.5, 3.2)` = `≈8.7`
`VM_SUB_DBL`	long double	`-`	Soustrait deux doubles nombres	`VM_SUB_DBL(5.5, 3.2)` = `≈2.3`
`VM_MUL_DBL`	long double	`*`	Multiplie deux doubles nombres	`VM_MUL_DBL(5.5, 3.2)` = `≈17.6`
`VM_DIV_DBL`	long double	`/`	Divise deux doubles nombres	`VM_DIV_DBL(6.0, 3.0)` = `≈2.0`
`VM_LSS_DBL`	Bool	`<`	Vérifie si le premier numéro double est inférieur au deuxième numéro double	`VM_LSS_DBL(3.5, 5.2)` = `true`
`VM_GTR_DBL`	Bool	`>`	Vérifie si le premier numéro double est supérieur au deuxième numéro double	`VM_GTR_DBL(5.5, 3.2)` = `true`

La machine virtuelle ne prend pas en charge certaines opérations de base double comparaison.

Vous pouvez utiliser des opérateurs logiques qui utilisent des appels de machines virtuelles pour compliquer davantage la compréhension de votre code.

Opérateur	Description
`VM_IF`	Utiliser au lieu de `if`
`VM_ELSE_IF`	Utiliser plutôt que `else if`
`VM_ELSE`	Utiliser au lieu d' `else`

Un exemple simple d'utilisation de la virtualisation:

 // ...
#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
}

Vous pouvez trouver des exemples d'utilisation de toutes les fonctions d'une machine virtuelle dans les tests de fichiers / virtualmachine.c

❓ Exemple d'utilisation

Si vous avez besoin d'une protection avancée contre les inverseurs qualifiés, utilisez les options CFLOW_V2 et 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" );
    }
}

? Comment ça marche?

? Compilateur (important)

La dernière version de Tiny C ( 0.9.27 ) est recommandée pour une utilisation. Malheureusement, certaines versions du compilateur ne prennent pas en charge les fonctionnalités nécessaires à l'obscurcissement complètement. Visual C , GCC et Clang ne sont pas pris en charge et il est peu probable qu'il soit pris en charge.

OBFUS.H UPDATER

Vous pouvez utiliser un script spécial pour Windows pour obtenir les dernières versions d' obfus.h en téléchargeant le package à partir du référentiel officiel. Ceci est utile si vous devez automatiser les mises à jour de sécurité sans utiliser git .

Par exemple, vous pouvez l'utiliser avant de construire votre projet:
 + C:...> call obfh-update
  C:...> tcc app.c -w
Le script mettra à jour le contenu du fichier obfus.h dans le répertoire actuel (selon la configuration spécifiée)

Résumer

Le code d'un programme (et sa logique d'origine) protégée à l'aide d'Obfus.h est presque impossible à récupérer (Deobfuscate) . Cependant, l'utilisation de cet obscurcisseur ne garantit pas une protection complète contre tous les types de menaces. Il est important de développer et de maintenir les systèmes de sécurité des programmes internes.