In der Weite des Netzwerks wurde unser Pod gefunden. Das ist Crackme . Natürlich ist es notwendig, es zu studieren. Für die Autopsie benötigen wir:
- Ein bisschen Assembler
- Logik mit Debugger (IDA PRO)
Lassen Sie uns mit Python ein Medikament
Diese Crackme ist nicht sehr kompliziert. Betrachten Sie den Algorithmus zum Generieren eines Schlüssels für den richtigen Schlüssel 8365-5794-2566-0817 . In IDA Pro habe ich Kommentare zum Code hinzugefügt.
Patientenuntersuchung
Auf den ersten Blick ist das Verhalten normal. .Exe-Erweiterung. Nicht verpackt. Lasst uns beginnen.
Was ist das? Benötigt einen Schlüssel. Müssen heilen :)
Autopsie des Patienten
Im Fehlerfall gab es die Aufschrift "Fail, Serial is ungültig!". Nehmen wir einen Platz ein, an dem es im Programm verwendet wird.
Wir sehen 1 Funktion key_check_func vor dem bedingten Zweig. Untersuchen wir sie.
Es stellt sich ein interessanter Baum heraus.
Wir setzen einen Haltepunkt und beginnen mit dem Debuggen.
Der Schlüssel muss 19 Zeichen lang sein.
Anschließend prüft das Programm alle 5 Zeichen, ob ein Strich in der Taste vorhanden ist, und tritt dreimal in die Schleife ein.
Nachdem überprüft wurde, ob ein Bindestrich vorhanden ist, prüft das Programm, ob der Schlüsselblock (1/4 Schlüssel) aus Zahlen besteht. Es wird davon ausgegangen, zu verstehen, welche Ziffer an den Compiler übergeben wurde, der den Befehl ausführt.
add eax, 0FFFFFFD0h
Fügen Sie beispielsweise 8 (38h) mit der angegebenen Nummer hinzu. Die resultierende Anzahl ist zu groß ( 10000008h) und am Ende ist 8, daher wird es abgeschnitten. Bleibt 8. Dies ist die Zahl, die wir gegeben haben. Dies geschieht viermal in einem Zyklus.
Was jetzt? Heutzutage werden die Codes jeder Ziffer des geprüften Blocks zueinander addiert, aber die letzten 4 Ziffern werden dreimal hintereinander hinzugefügt. Der resultierende Betrag wird erneut addiert. Der Code der letzten Ziffer des Blocks + der resultierende Betrag ist 150h. Das Ergebnis wird zu r10d hinzugefügt. Dieser gesamte Zyklus wird für jeden Schlüsselblock viermal wiederholt.
Betrachten Sie in unserem Fall das Beispiel des ersten Blocks des Schlüssels 8365: 38h (8) + 33h (3) + 36h (6) + 35h (5) + 35h (5) + 35h (5) = 140h + 35h - 150h = 25h. 25 wird zu r10d hinzugefügt und in den Speicher geschrieben. Markieren wir diesen Ort als A. Die Summe der anderen Blöcke des Schlüssels beträgt ebenfalls 25 Stunden. Daher multiplizieren wir 25h * 4 = 94.
Als nächstes erfolgt eine bitweise Verschiebung nach rechts um 2 Bytes. Wir werden diesen Ort für uns als B markieren.
Wir haben einen Wert, der als A (25h) und B (25h) bezeichnet wird. Anschließend werden diese Zahlen verglichen. Sie müssen gleich sein. Diese Operation erfolgt für jeden Schlüsselblock.
Das letzte, was das Programm tut, ist zu überprüfen, ob die Zahlen in den Blöcken ähnlich sind. Zunächst werden die Ziffern des 1. Blocks mit den Ziffern des 2. Blocks verglichen. Dann überprüfen Sie 2 Blöcke mit 3 Blöcken. Endkontrolle 3 Blöcke mit 4 Blöcken. All diese Überprüfungen erfolgen nicht sofort, sondern schrittweise in einem Zyklus.
Die Analyse ist beendet. Der Patient wurde untersucht.
Zeit für eine Heilung
Wir werden etwas Ungewöhnliches verwenden, um den Schlüssel zu generieren. Python + Library zufällig.
Der Code selbst ist unten. Kommentare im Code:
import random
def gen_key_part():
#
num1 = str(random.randint(0, 9))
num2 = str(random.randint(0, 9))
num3 = str(random.randint(0, 9))
num4 = str(random.randint(0, 9))
# (1 )
final = num1 + num2 + num3 + num4
return final
def sum_ord(key_part):
#
num1 = key_part[0]
num2 = key_part[1]
num3 = key_part[2]
num4 = key_part[3]
# crackme
sum = ord(num1) + ord(num2) + ord(num3) + ord(num4) + ord(num4) + ord(num4)
sum_final = ord(num4) + sum - 336
return sum_final
def shr(key):
#
a = key[0:4]
b = key[5:9]
c = key[10:14]
d = key[15:19]
# crackme
x = sum_ord(a) + sum_ord(b) + sum_ord(c) + sum_ord(d)
x = x >> 2
return x
def check_key(key):
i = 0 #
while i != 4:
# i 1 4.
first = 0 + i
second = 5 + i
third = 10 + i
four = 15 + i
# ( , A B)
if sum_ord(key[0:4]) != shr(key) or sum_ord(key[5:9]) != shr(key) or sum_ord(key[10:14]) != shr(key) or sum_ord(key[15:19]) != shr(key):
return False
#
if int(key[first]) == int(key[second]):
return False
if int(key[second]) == int(key[third]):
return False
if int(key[third]) == int(key[four]):
return False
i += 1 # #
def generate_key():
#
key = gen_key_part() + '-' + gen_key_part() + '-' + gen_key_part() + '-' + gen_key_part()
# true false
while True: #
if check_key(key) == False:
#
key = gen_key_part() + '-' + gen_key_part() + '-' + gen_key_part() + '-' + gen_key_part()
print('Checking this key -> ' + key)
else:
#
print('This is the correct key -> ' + key)
break
# ,
if __name__ == "__main__":
generate_key()
Wir starten.
Geben Sie den Schlüssel ein und sehen Sie.
Der Patient ist geheilt.
Vielen Dank für Ihre Aufmerksamkeit. Ich freue mich auf Ihre Kommentare und Kritik. Sei nicht krank