Assembler Code analysieren

[Belur]

Okay, so langsam werd ich verwirrt. Kann mich abends auch immer schlechter konzentrieren
Also mein Code aus Post 10 findet auch negative Schlüssel:
Beispiele.
-1171446559
-780994987
-390543415
-390543414
-91842
Die sind alle gültig.

Der Code für das Testen von deiner korrigierten Version:

#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv) {

	int var0;
	int i;
	for (i = 0; i <= 9223372036854775807; i++) {
		var0 = i;
		var0 = (((var0 << 2) + var0) * 2) + var0; // @ +45 to +62
		var0 = (var0 + (var0 >> 31)) / 2; // @ +62 to +77
		var0 /= 8; // @ +77
		var0 += 0xf7f9; // @ +81
		var0 -= 0x13c; // @ +88
		if (var0 == 0x17) {
			printf("%d \n", i);
			fflush(stdout);
		}
	}
}

Dann kriege ich als Ergebnis nach ein paar Sekunden diese Schlüssel:

 Spoiler

390359729
780811301
1171262873
1171262874
1561714446
1952166018
1952166019
-1952349706
-1952349705
-1561898133
-1171446561
-1171446560
-780994988
-390543416
-91844
-91843

Von den Schlüsseln stimmen aber nur 2 Stück. Einmal der, den du schon gefunden hattest und einmal
1952166018.
Der Rest ist ungültig.

[Jeoni]

Nun, dann muss beim Rückübersetzen oder Compilerspezifischen "neukompilieren" irgendein "Fehler" unterlaufen sein.
Für deine Zwecke ist das Rückübersetzen aber eigentlich auch gar nicht nötig. Wenn du die check_key Funktion auf asm Ebene leicht abänderst, so dass sie direkt einen Integer nimmt, statt einen String, der dann mit atoi geparst wird, kannst du sie gut in deine for-schleife einbinden. Dann hättest du die Originalfunktion zum bruteforcen der Keys, ohne potentielle Fehler oder Ungenauigkeiten beim Rückübersetzen oder Kompilieren des rückübersetzten Codes. Theoretisch kannste auch ohne Änderung die Funktion gebrauchen, aber dann musste jeden Integer erst via sprintf o.Ä. zum String machen bzw. einen intelligenten, aber komplexen Weg finden, immer einen String mit der Zahl parat zu haben.
Ich werde mich morgen Nachmittag / Abend da mal ransetzen, wenn du's bis dahin noch nicht selbst genau gelöst hast.
Ist das eigentlich so ein CrackMe / KeygenMe? Und darf ich fragen, wofür genau du das machst? Also ist ja nichts verwerflich dran, aber wundert mich da so scheinbar ohne bzw. nur mit wenigen Vorkenntnissen dort einzusteigen.
Mit freundlichen Grüßen
Jeoni

[Belur]

Danke ich werde morgen mal versuchen davon was umzusetzen.

Das ist eine Übungsaufgabe aus einem Kurs an der Uni. Eventuell fehlt mir auch noch eine Vorlesung, aber ich habs mir heute schonmal angeguckt.

Vllt. fällt es mir nach der nächsten Vorlesung auch etwas leichter, weil der Prof. nochmal einiges erläutert.
Im ersten Semester hatten wir ein bisschen Assembler, aber das ist auch schon etwas länger her.

[meak1]

ida + hexrays, benutze ich für functionen nachbauen ;D (musste mal ziemlich viele Hackshield functionen kopieren^^)

[Jeoni]

Originally Posted by meak1

ida + hexrays, benutze ich für functionen nachbauen ;D (musste mal ziemlich viele Hackshield functionen kopieren^^)

Da kann man dann nur hoffen, dass keine eigenen Aufrufkonventionen verwendet werden oder sonst irgendwelche Obfuscations den Decompiler verwirren. Ist zwar ganz nett, um sich einen Überblick zu verschaffen, aber 100%ig verlassen würde ich mich darauf nicht.

Habe nun mal eben das Bruteforce-Programm geschrieben (source im Anhang). Ist mit Visual Studio spezifischem inline asm (geht nicht als x64, aber der Key ist ja eh nur ein 32 bit Integer, daher ist die Funktion nicht auf 64 bit Register angewiesen), aber was es macht, sollte ja ersichtlich sein. Ich weiß selber, dass das Auslagern des asm Codes in eine eigene Datei, oder (in dem Fall) einfach alles direkt in asm schreiben idR die sauberere Methode ist, aber hierfür reicht's auch so. Die check_key-Funktion habe ich vom Originalcode genommen und dann leicht abgeändert: auf 32 bit geändert; unnötige lokale Variablen entfernt (der Key, der vorher an rbp-4 stand ist nun in ecx); Funktion nimmt direkt den Key als int; Aufrufkonvention ist MS fastcall, also erstes Argument in ecx.
Als Output bekomme ich folgendes:

 Spoiler

390359730
780811302
780811303
1171262875
1561714447
1952166019
1952166020
-1952349704
-1561898132
-1171446560
-1171446559
-780994987
-390543415
-390543414
-91843
-91842

Abweichung um 1 von den Schlüsseln, die du mit meiner zweiten Rückübersetzung generiert hast. Könnte also sein, dass ich etwas übersehen habe oder so.

Mit dem Ansatz muss man kein Stück der Originalfunktion wirklich zurückübersetzen und der genaue Algorithmus zur Schlüsselverifikation ist ebenso unerheblich
Mit freundlichen Grüßen
Jeoni

[Belur]

Werde mir später nochmal die Zeit nehmen das zu verstehen, danke schonmal.

Ich habe jetzt zum Üben eine andere ähnliche Aufgabe genommen und mich daran versucht. Assembler-Code sieht so aus:

 Spoiler

Dump of assembler code for function check_key:
   0x00000000004005bd <+0>:	push   rbp
   0x00000000004005be <+1>:	mov    rbp,rsp
   0x00000000004005c1 <+4>:	sub    rsp,0x20
   0x00000000004005c5 <+8>:	mov    QWORD PTR [rbp-0x18],rdi
   0x00000000004005c9 <+12>:	mov    rax,QWORD PTR [rbp-0x18]
   0x00000000004005cd <+16>:	mov    rdi,rax
   0x00000000004005d0 <+19>:	mov    eax,0x0
   0x00000000004005d5 <+24>:	call   0x4004c0 <atoi@plt>
   0x00000000004005da <+29>:	mov    DWORD PTR [rbp-0x4],eax
   0x00000000004005dd <+32>:	cmp    DWORD PTR [rbp-0x4],0x0
   0x00000000004005e1 <+36>:	jne    0x4005ea <check_key+45>
   0x00000000004005e3 <+38>:	mov    eax,0xffffffff
   0x00000000004005e8 <+43>:	jmp    0x400621 <check_key+100>
   0x00000000004005ea <+45>:	shl    DWORD PTR [rbp-0x4],0x4
   0x00000000004005ee <+49>:	mov    eax,DWORD PTR [rbp-0x4]
   0x00000000004005f1 <+52>:	mov    edx,eax
   0x00000000004005f3 <+54>:	shr    edx,0x1f
   0x00000000004005f6 <+57>:	add    eax,edx
   0x00000000004005f8 <+59>:	sar    eax,1
   0x00000000004005fa <+61>:	mov    DWORD PTR [rbp-0x4],eax
   0x00000000004005fd <+64>:	sar    DWORD PTR [rbp-0x4],0x2
   0x0000000000400601 <+68>:	add    DWORD PTR [rbp-0x4],0xf93a
   0x0000000000400608 <+75>:	sub    DWORD PTR [rbp-0x4],0x316
   0x000000000040060f <+82>:	cmp    DWORD PTR [rbp-0x4],0x17
   0x0000000000400613 <+86>:	jne    0x40061c <check_key+95>
   0x0000000000400615 <+88>:	mov    eax,0x0
   0x000000000040061a <+93>:	jmp    0x400621 <check_key+100>
   0x000000000040061c <+95>:	mov    eax,0x1
   0x0000000000400621 <+100>:	leave  
   0x0000000000400622 <+101>:	ret

Jetzt hab ich praktisch 2 Versionen, die allerdings beide nicht funktionieren.
Einmal das "sar" also normales "shr" interpretiert:

 Spoiler

#include <stdio.h>
#include <stdlib.h>
int main(void) {
	int var0;
	int i;

	for (i = 0; i<=9223372036854775807; i++) {
		var0 = i;
		var0 = var0 << 4;
		var0 = ((var0 >> 0x1f) + var0) >> 1;
		var0 = var0 >> 2;
		var0 += 0xf93a;
		var0 -= 0x316;

		if (var0 == 0x17) {
			printf("Key: %d \n", i);
			fflush(stdout);
		}

	}
}

Und einmal das "sar" als n-Fache Division durch 2:

 Spoiler

#include <stdio.h>
#include <stdlib.h>
int main(void) {
	int var0;
	int i;

	for (i = 0; 9223372036854775807; i++) {
		var0 = i;
		var0 = var0 << 4;
		var0 = ((var0 >> 0x1f) + var0) / 2;
		var0 = var0 / 4;
		var0 += 0xf93a;
		var0 -= 0x316;

		if (var0 == 0x17) {
			printf("Key: %d \n", i);
			fflush(stdout);
		}

	}
}

Allerdings scheint das beides nicht richtig zu sein. Die 1. Variante gibt falsche Keys aus und die 2. Variante gibt (zumindest nach ein paar Minuten) garkeine Keys aus.

Ich hätte vermutet dass die erste Variante wieder passt, da für das Beispiel von gestern (also "sar" als normalen Shift übersetzen) alles perfekt passte.
Evtl. hab ich also so etwas falsch gemacht.

Vllt sieht jemand den Fehler.

Ich hänge nochmal das Programm an, dann kann man auf Wunsch selbst testen.




Eine Sache noch: Ich hab jetzt schon einige Aufgaben gerechnet und hier ein anderes Beispiel:

 Spoiler

Dump of assembler code for function check_key:
   0x00000000004005bd <+0>:	push   rbp
   0x00000000004005be <+1>:	mov    rbp,rsp
   0x00000000004005c1 <+4>:	sub    rsp,0x20
   0x00000000004005c5 <+8>:	mov    QWORD PTR [rbp-0x18],rdi
   0x00000000004005c9 <+12>:	mov    rax,QWORD PTR [rbp-0x18]
   0x00000000004005cd <+16>:	mov    rdi,rax
   0x00000000004005d0 <+19>:	mov    eax,0x0
   0x00000000004005d5 <+24>:	call   0x4004c0 <atoi@plt>
   0x00000000004005da <+29>:	mov    DWORD PTR [rbp-0x4],eax
   0x00000000004005dd <+32>:	cmp    DWORD PTR [rbp-0x4],0x0
   0x00000000004005e1 <+36>:	jne    0x4005ea <check_key+45>
   0x00000000004005e3 <+38>:	mov    eax,0xffffffff
   0x00000000004005e8 <+43>:	jmp    0x40062c <check_key+111>
   0x00000000004005ea <+45>:	mov    edx,DWORD PTR [rbp-0x4]
   0x00000000004005ed <+48>:	mov    eax,edx
   0x00000000004005ef <+50>:	shl    eax,0x2
   0x00000000004005f2 <+53>:	add    eax,edx
   0x00000000004005f4 <+55>:	add    eax,eax
   0x00000000004005f6 <+57>:	mov    DWORD PTR [rbp-0x4],eax
   0x00000000004005f9 <+60>:	mov    eax,DWORD PTR [rbp-0x4]
   0x00000000004005fc <+63>:	mov    edx,eax
   0x00000000004005fe <+65>:	shr    edx,0x1f
   0x0000000000400601 <+68>:	add    eax,edx
   0x0000000000400603 <+70>:	sar    eax,1
   0x0000000000400605 <+72>:	mov    DWORD PTR [rbp-0x4],eax
   0x0000000000400608 <+75>:	sar    DWORD PTR [rbp-0x4],0x3
   0x000000000040060c <+79>:	add    DWORD PTR [rbp-0x4],0x7494
   0x0000000000400613 <+86>:	sub    DWORD PTR [rbp-0x4],0x1f3
   0x000000000040061a <+93>:	cmp    DWORD PTR [rbp-0x4],0x17
   0x000000000040061e <+97>:	jne    0x400627 <check_key+106>
   0x0000000000400620 <+99>:	mov    eax,0x0
   0x0000000000400625 <+104>:	jmp    0x40062c <check_key+111>
   0x0000000000400627 <+106>:	mov    eax,0x1
   0x000000000040062c <+111>:	leave  
   0x000000000040062d <+112>:	ret    
End of assembler dump.

Den Keygen-Code dazu habe ich so übersetzt:

 Spoiler

#include <stdio.h>
#include <stdlib.h>
int main(void) {
	int var0;
	int i;

	for (i = 0; i<9223372036854775807; i++) {
		var0 = i;

		var0 = ((var0 << 2) + var0) * 2;
		var0 = ((var0 >> 0x1f) + var0) >> 1;
		var0 >>= 3;
		var0 += 0x7494;
		var0 -= 0x1f3;

		if (var0 == 0x17) {
			printf("Key: %d \n", i);
			fflush(stdout);
		}
	}
}

Also das "sar" wieder ganz normal als Shift rückübersetzt. Bei der Lösung kriege ich auch nur richtige Schlüssel ausgegeben.

Ich sehe eigentlich keinen Unterschied zu der 1. Version von oben. Es sind halt andere Operationen aber ich habe praktisch nach dem gleichen "Verfahren" rückübersetzt. Einmal klappt es perfekt und einmal garnicht.