gmh5225/asm-obfuscatorVerschleiert x86-64-Assembly mit Befehlsinjektion, Junk-Code, Konstanten-Verschleierung und Laufzeit-Entschlüsselung, um Reverse Engineering und Anti-Analyse zu erschweren.
Fortgeschrittener x86-64-Assembly-Obfuskator.
Der Assembly-Code-Obfuskator ist ein leistungsstarkes und vielseitiges Werkzeug, das entwickelt wurde, um die Sicherheit Ihres x86-64-Assembly-Codes zu erhöhen. Es schützt Ihre Projekte vor Reverse Engineering und Analyse, indem es eine breite Palette von Obfuskationstechniken und Anti-Analyse-Maßnahmen einsetzt.
Befehlsinjektion: Injiziert vor jedem Assembly-Befehl benutzerdefinierte Byte-Sequenzen, um Disassembler zu verwirren.
Randomisierung: Führt Zufälligkeit in die Codestruktur ein, wodurch sie weniger vorhersehbar wird.
Debugger-Erkennung: Erkennt das Vorhandensein von Debuggern während der Codeausführung und setzt Anti-Debugging-Maßnahmen ein.
Anti-Analyse-Techniken: Verwirrt dynamische Analysetools mit bedingten Verzweigungen und Timing-Prüfungen.
Dynamische Entschlüsselung: Verschlüsselt Codeabschnitte und entschlüsselt sie zur Laufzeit dynamisch, was die Komplexität erhöht.
Dynamische Dekomprimierung: Komprimiert Codeabschnitte und dekomprimiert sie bei der Ausführung dynamisch, wodurch die wahre Natur des Codes verborgen wird.
Konstanten-Obfuskation: Obfuskatiert Konstanten und Datenwerte mithilfe von Techniken wie XOR-Verknüpfung und Bitmanipulation.
Variablenumbenennung: Benennt Variablen und Register um, wodurch der Code weniger lesbar für Menschen wird.
Junk-Code-Einfügung: Fügt Junk-Code-Anteile ein, um die Codebasis weiter zu verschleiern.
Der Kern des Obfuskationsprozesses besteht darin, vor jedem Assembly-Befehl in der Codedatei benutzerdefinierte Byte-Sequenzen zu injizieren. Diese strategisch entworfenen Byte-Sequenzen sollen Disassembler und Analysten gleichermaßen verwirren. Betrachten wir diesen Prozess im Detail:
4005d2: 55 push rbp
Im Speicher (hex):
0x55
400665: eb 01 jmp 400668 <main+0x3>
400667: b0 55 mov al,0x55
400669: eb 01 jmp 40066c <main+0x7>
Im Speicher (hex):
0xEB, 0x01, 0xB0, 0x55
Hier ist eine Aufschlüsselung der Transformation:
Der ursprüngliche Befehl PUSH RBP wird zu 0x55 assembliert. Der Obfuskator fügt davor die Bytes 0xEB, 0x01, 0xB0 ein.
Das Ergebnis ist eine Sequenz von Befehlen, die beim Disassemblieren völlig anders erscheinen kann als der ursprüngliche Code. Dies macht es für RE schwierig, den wahren Zweck des Codes zu verstehen.
Es führt Randomisierungselemente in den Code ein. Dazu gehören Techniken wie Befehlspermutation, Operandentausch und Opcode-Substitution.
Integriert Mechanismen zur Erkennung des Vorhandenseins von Debuggern während der Codeausführung. Es enthält Laufzeitprüfungen, um debuggerbezogene Artefakte zu identifizieren und Anti-Analyse-Maßnahmen auszulösen.
Integriert mehrere Anti-Analyse-Maßnahmen wie bedingte Verzweigungen und Timing-Prüfungen. Beispielsweise kann es bedingte Sprünge und Verzögerungsschleifen einfügen, um den Analyseprozess zu verlangsamen.
Es verwendet dynamische Entschlüsselungstechniken. Es verschlüsselt bestimmte Codeabschnitte und entschlüsselt sie zur Laufzeit mit einem geheimen Schlüssel. Dieser Entschlüsselungsprozess erfolgt dynamisch während der Codeausführung.
Es komprimiert bestimmte Codeabschnitte und dekomprimiert sie bei der Ausführung im laufenden Betrieb.
Verwendet Techniken wie XOR-Verknüpfung, Bitmanipulation und arithmetische Operationen, um Konstanten zu obfuskieren. Dies stellt sicher, dass konstante Werte nicht ohne Weiteres erkennbar sind.
Das Werkzeug benennt Variablen und Register um, wodurch der Code weniger lesbar wird. Der Prozess beinhaltet das Ersetzen von Variablennamen durch zufällig generierte Zeichenfolgen oder numerische Bezeichner.
Um den Code weiter zu verschleiern, fügt der Obfuskator Junk-Code-Anteile an strategischen Stellen ein. Dieser Junk-Code besteht aus irrelevanten Befehlen, die die Programmlogik nicht beeinflussen, aber dazu dienen, die Codebasis zu überladen.
; Original Code
mov eax, 1
; After Junk Code Insertion
mov ebx, 2
sub ecx, ecx
add edx, edx
Im Speicher (hex):
0x89, 0xD8, 0x31, 0xC9, 0x01, 0xD2
Der eingefügte Junk-Code soll die Aufmerksamkeit ablenken und den Code verworrener erscheinen lassen.
Enthält außerdem eine Funktion zur Erkennung gefälschter UPX-Header. Es scannt den Code auf Anzeichen von Manipulationen an UPX-Headern und gewährleistet so die Integrität der ausführbaren Datei.
Vor der Transformation (ursprünglicher Code):
section .text
global _start
_start:
; Calculate the sum of the first 10 natural numbers
mov ecx, 10 ; Initialize loop counter
mov eax, 0 ; Initialize sum to 0
loop_start:
add eax, ecx ; Add current value of ECX to EAX (sum)
loop loop_start ; Decrement ECX and loop if not zero
; Exit program
mov eax, 1 ; SYS_exit
int 0x80 ; Invoke syscall
Hexadezimale Darstellung (ursprünglicher Code):
31 C9 xor ecx,ecx
B8 00 00 00 00 mov eax,0x0
EB 0E jmp 0x1c
01 C8 add eax,ecx
E2 FB loop 0x11
B8 01 00 00 00 mov eax,0x1
CD 80 int 0x80
Nach der Transformation (obfuskierter Code):
section .text
global _start
_start:
; Calculate the sum of the first 10 natural numbers
mov eax, 0x1
add eax, 0x2
add eax, 0x3
add eax, 0x4
add eax, 0x5
add eax, 0x6
add eax, 0x7
add eax, 0x8
add eax, 0x9
add eax, 0xa
; Exit program
mov eax, 0x1
int 0x80
Hexadezimale Darstellung (obfuskierter Code):
B8 01 00 00 00 mov eax,0x1
83 C0 02 add eax,0x2
83 C0 03 add eax,0x3
83 C0 04 add eax,0x4
83 C0 05 add eax,0x5
83 C0 06 add eax,0x6
83 C0 07 add eax,0x7
83 C0 08 add eax,0x8
83 C0 09 add eax,0x9
83 C0 0A add eax,0xa
B8 01 00 00 00 mov eax,0x1
CD 80 int 0x80
Im obfuskatierten Code haben wir die ursprüngliche Programmlogik weniger offensichtlich gemacht, indem wir redundante ADD-Befehle hinzugefügt und hexadezimale Werte als unmittelbare Operanden verwendet haben.
Dieses Projekt ist unter der MIT-Lizenz lizenziert. Weitere Details finden Sie in der Datei LICENSE.
Beiträge sind willkommen!.
Bei Problemen, Feature-Anfragen oder allgemeinen Fragen erstellen Sie bitte ein Issue.
Dieses Werkzeug ist für Bildungs- und ethische Zwecke bestimmt.