obfus.h Download - obfus.h Quellcode Download

obfus.h

C#-Quellcode

2024-11-24

Herunterladen

obfus.h

obfus.h ist eine makroäre Bibliothek zur Verschleierung von C-Anwendungen für Kompilierzeit, die speziell für das winzige C (TCC) entwickelt wurde. Es ist auf Windows X86- und X64 -Plattformen zugeschnitten und unterstützt fast alle Versionen des Compilers. Sehr zuverlässige Rüstung für Ihre C -Programme!

Welche Funktionen hat es? ...

? Funktionsaufruf Verschleierung : Verwechseln Sie Funktionsaufrufe, um Ihren Code für nicht autorisierte Augen weniger lesbar zu machen.
? ️ Anti-Debugging-Techniken : Eingebaute Mechanismen zur Verhinderung der Codeanalyse während der Laufzeit.
Kontrolldurchflusscode -Mutation : Verwandelt Code in Spaghetti, wodurch es schwierig ist, Bedingungen und Schleifen zu analysieren.
Anti-Dekompilierungstechniken : Es macht viele beliebte Dekompiler nutzlos, ihre Produktion visuell zu brechen.
? Gefälschte Unterschriften Hinzufügen : Kann gefälschte Unterschriften verschiedener Packer und Beschützer hinzufügen, um Reverse -Ingenieure zu verwirren.
? Virtualisierung : Mächelt Mathematikoperationen sehr schwer zu verstehen, indem es Befehle virtueller Maschinen verwendet.

? Verwendung

Die Integration von Obfus.h in Ihr Projekt ist ein einfacher Prozess. Fügen Sie einfach die folgende Zeile in Ihren Code ein:

 #include "obfus.h"

Dies verschleiert Ihren Code automatisch während der Kompilierung und gewährleistet den Schutz und die Vertraulichkeit Ihres geistigen Eigentums.

Verfügbare Optionen zum Schutzkonfiguration:

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

Oder verwenden Sie es mit Compiler -Argumenten:

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

Warnung

Verwenden Sie beim Kompilieren einer Anwendung mit Verschleierung das Argument -w , um Warnungen zu unterdrücken. Andernfalls zeigt die Konsole zahlreiche einschüchternde Protokolle an, die keinen Einfluss auf das Endergebnis haben. Es ist nicht erforderlich, von ihnen beunruhigt zu werden.

? Das Debugging -Schutz wird durch Aufrufe an viele grundlegende MSVCRT -Funktionen ausgelöst. An kritischen Stellen im Code können Sie den ANTI_DEBUG; Konstrukt. Zum Beispiel:

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

? Virtualisierung

Dies ist eine Schutztechnik, bei der bestimmte Berechnungen durch eine eingebettete virtuelle Maschine beim Befehl durchgeführt werden. Macht die Analyse mathematischer Operationen sehr schwierig ! Es funktioniert mit der aktivierten VIRT -Option (und nur!). Andernfalls werden alle Befehle für virtuelle Maschine durch gewöhnliche mathematische Operatoren ersetzt.

Warnung

Die Virtualisierung an kritischen Stellen kann die Optimierung beeinflussen. Verwendung mit Vorsicht nur in Bereichen, in denen es wirklich benötigt wird

Funktion	Typ	Op	Beschreibung	Beispiel
`VM_ADD`	lang	`+`	Fügt zwei Zahlen hinzu	`VM_ADD(5, 3)` = `8`
`VM_SUB`	lang	`-`	Subtrahiert zwei Zahlen	`VM_SUB(5, 3)` = `2`
`VM_MUL`	lang	`*`	Multipliziert zwei Zahlen	`VM_MUL(5, 3)` = `15`
`VM_DIV`	lang	`/`	Teilt zwei Zahlen	`VM_DIV(6, 3)` = `2`
`VM_MOD`	lang	`%`	Berechnet den Modul von zwei Zahlen	`VM_MOD(5, 3)` = `2`
`VM_EQU`	Bool	`==`	Überprüfungen, wenn zwei Zahlen gleich sind	`VM_EQU(5, 5)` = `true`
`VM_NEQ`	Bool	`!=`	Überprüft, ob zwei Zahlen nicht gleich sind	`VM_NEQ(5, 3)` = `true`
`VM_LSS`	Bool	`<`	Überprüft, ob die erste Nummer kleiner als die zweite Zahl ist	`VM_LSS(3, 5)` = `true`
`VM_GTR`	Bool	`>`	Überprüft, ob die erste Zahl größer ist als die zweite Zahl	`VM_GTR(5, 3)` = `true`
`VM_LEQ`	Bool	`<=`	Überprüft, ob die erste Zahl kleiner oder gleich der zweiten Zahl ist	`VM_LEQ(3, 5)` = `true`
`VM_GEQ`	Bool	`>=`	Überprüft, ob die erste Zahl größer oder gleich der zweiten Zahl ist	`VM_GEQ(5, 3)` = `true`
`VM_ADD_DBL`	langes Doppel	`+`	Fügt zwei Doppelzahlen hinzu	`VM_ADD_DBL(5.5, 3.2)` = `≈8.7`
`VM_SUB_DBL`	langes Doppel	`-`	Subtrahiert zwei Doppelzahlen	`VM_SUB_DBL(5.5, 3.2)` = `≈2.3`
`VM_MUL_DBL`	langes Doppel	`*`	Multipliziert zwei Doppelzahlen	`VM_MUL_DBL(5.5, 3.2)` = `≈17.6`
`VM_DIV_DBL`	langes Doppel	`/`	Zwei doppelte Zahlen teilt	`VM_DIV_DBL(6.0, 3.0)` = `≈2.0`
`VM_LSS_DBL`	Bool	`<`	Überprüft, ob die erste Doppelzahl unter der zweiten Doppelzahl ist	`VM_LSS_DBL(3.5, 5.2)` = `true`
`VM_GTR_DBL`	Bool	`>`	Überprüft, ob die erste Doppelzahl größer ist als die zweite Doppelzahl	`VM_GTR_DBL(5.5, 3.2)` = `true`

Die virtuelle Maschine unterstützt einige grundlegende double nicht.

Sie können logische Operatoren verwenden, die virtuelle Maschinenaufrufe verwenden, um das Verständnis Ihres Codes weiter zu komplizieren.

Operator	Beschreibung
`VM_IF`	Verwenden Sie anstelle von `if`
`VM_ELSE_IF`	Verwenden Sie anstelle von `else if`
`VM_ELSE`	Verwenden Sie statt `else`

Ein einfaches Beispiel für die Verwendung von Virtualisierung:

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

Sie finden Beispiele für die Verwendung aller Funktionen einer virtuellen Maschine in den Dateitests/virtualMachine.c

❓ Beispiel für die Verwendung

Wenn Sie einen fortgeschrittenen Schutz vor qualifizierten Umkehrern benötigen, verwenden Sie CFLOW_V2 und ANTIDEBUG_V2 -Optionen.

 // 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" );
    }
}

? Wie funktioniert es?

? Compiler (wichtig)

Die neueste Version von Tiny C ( 0.9.27 ) wird für die Verwendung empfohlen. Leider unterstützen einige Versionen des Compilers die Funktionalität, die für die vollständige Verschleierung erforderlich ist, nicht. Visual C , GCC und Clang werden nicht unterstützt und es ist unwahrscheinlich, dass sie unterstützt werden.

Obfus.h Updater

Sie können ein spezielles Skript für Windows verwenden, um die neuesten Versionen von obfus.h zu erhalten, indem Sie das Paket aus dem offiziellen Repository herunterladen. Dies ist nützlich, wenn Sie Sicherheitsaktualisierungen automatisieren müssen, ohne git zu verwenden.

Sie können es beispielsweise verwenden, bevor Sie Ihr Projekt erstellen:
 + C:...> call obfh-update
  C:...> tcc app.c -w
Das Skript aktualisiert den Inhalt der obfus.h -Datei im aktuellen Verzeichnis (gemäß der angegebenen Konfiguration).

Zusammenfassen

Der Code eines Programms (und seine ursprüngliche Logik), die mit OBFUS geschützt ist. Die Verwendung dieses Verschleifers garantiert jedoch keinen vollständigen Schutz gegen alle Arten von Bedrohungen. Es ist wichtig, interne Programmsicherheitssysteme zu entwickeln und zu pflegen.