++++++++++++++++++++
++++++++++++++++++++
++ =-=-=-=-=-=-=- ++
++ = KMICIC^lFE = ++    
++ =-=-=-=-=-=-=- ++
++++++++++++++++++++
++++++++++++++++++++
				


                                PRESENT :



          **************************************************** 
          ****************************************************
          **                                                **
          **   Tutorial do KoRnMe by payteR^HTB             **
          **                                                **
          ****************************************************
          ****************************************************



yo!


W tutku tym wezmiemy sie za crackme [a raczej KoRnMe ;] payteRa^HTB.

Najpierw odpalmy sobie info. Coz tam takiego ciekawego jest napisane :) Oooo! Mozemy patchowac ;) Ale i tak liczy sie tylko wyciagniecie poprawnego haselka. Panadto KoRnMe musi czyms poinformowac o zlamaniu :)

No, tyle od autora :)

Jedziemy!

Stadnardowo pulapka na GetDlgItemTexta i lookamy :

 CALL      USER32!GetDlgItemTextA
 CMP       AX,08        		1.
 JNZ       0040112F			
 XOR       EAX,EAX
 XOR       EBX,EBX
 MOV       EAX,[004030A4]		2.
 MOV       EBX,[004030A8]		3.


1. Haslo ma miec 8 znakow.
2. Do eax piewrsze 4 znaki
3. Do ebx 4 ostatnie

I mieeelooonkaaaaa :)

 ROL       EAX,1                              
 BSWAP     EAX                                
 XCHG      EAX,EBX                            
 XOR       EAX,0000F1FA                       
 SHL       EAX,1                              
 XOR       EAX,00BADB01                       
 XCHG      AH,AL                              
 ADD       EAX,04276221                       
 SUB       AX,0AFF                            
 NEG       EAX                                
 BSWAP     EAX                                
 XOR       EBX,00001410                       
 ROR       EBX,1                              
 XOR       EBX,00231765                       
 XCHG      BL,BH                              
 BSWAP     EBX                                
 XOR       EBX,00000666                       
 XOR       EBX,0000DEAD                       
 XOR       EBX,0000BABE                       
 XOR       EBX,00000EC0                       
 SHL       EBX,1                              
 NOT       EBX


I po niej male porownania :

 CMP       EBX,61F9BE03                       
 JNZ       0040112F                           
 CMP       EAX,02F3724B                 
 JNZ       0040112F

I na koncu :

 XOR       EAX,EAX                            
 XOR       EBX,EBX                            
 MOV       EAX,00403039        <<-- to               
 MOV       ECX,0040301B        <<--    i to :)            
 POP       EBX                                
 POP       ESI                                
 POP       EDI                                
 LEAVE                                        
 RET      


Heh, jesli chcesz teraz to jakos odwracac albo cus to daj se na razie siana :) 

Powiem Ci tylko, ze po tej calej mielonce prawidlowe haslo [spelniajace tego algosa] to : KoRn roX

Aleeee.... :)

Popatrz u gory na te movy :) Jesli eax i ebx sa czemus rowne to do eax i ecx ida teskty w stylu, ze crackme polamane. No ale jak wyjdziemy z softica to zadnej wiadomosci o polamaniu ani widu ani slychu ;) 

Czyli procka ma na celu nas oszukac :) Niejeden pewnie by teraz podeslal do payteRa haselko KoRn roX co? ;) I to bylby blad :)

Musimy sie dobrac do prawidlowej procedurki... Hmmmm... Ale jak? ;)

Coz... standardowo zawsze haselko jest pobierane przez rozne gety i takie tam :) np. GetWindowTextA albo GetDlgItemTexta.
Ale jak jest cos takiego jak get to i jest cos takiego jak send :) 
Hehe... Czyli sprobojmy na taka mala pulapeczke : 

bpx sendmessagea 

Yeah!!! :) Zlapalo sie :)

Teraz sie dobierzemy do prawidlowego haselka :)

Widzimy taki oto kodzik :


 CALL      USER32!SendMessageA        
 CMP       AL,27   			1.
 JNZ       004012B5                           
 XOR       EAX,EAX			2.     
 XOR       ECX,ECX                            
 XOR       EBX,EBX                            
 XOR       EDX,EDX                            
 MOV       EAX,004030AC			3.     
 MOV       ECX,00000027			4.     
 PUSH      ECX				5.

1. Haselko ma miec 27h czyli 39 znakow :)
2. Zerowanie rejestrow
3. Do eax nasze haselko
4. Ecx jest teraz rowne 27h
5. Odkladanie ecx na stos

Oke... dalej mamy :

 MOV       BL,[EAX]		1.
 XOR       BL,63   		2.
 ADD       BL,17
 XOR       BL,10
 SUB       BL,02


1. Do bl laduje pierwszy znak naszego haslo [potem nastepne znaki]
2. Mielonka 

Dalej :

 IMUL      ECX,ECX,02    		1.                     
 XOR       ECX,00003256                       
 XOR       ECX,00326532                       
 ROL       ECX,04                             
 BSWAP     ECX                                
 XCHG      CL,CH                              
 ADD       ECX,000BA560                       
 SUB       CX,0326                            
 XOR       ECX,66667777


1. Ecx jest poddane ostrej mielonce :) Ecx czyli 27h

Wlasciwie ten kawalek kodu to mozna se olac :) Wystarczy zapamietac, ze po mielonce w cl jest 28h :) Reszta sie nam nie przyda :)

Dalej mamy takie cus :

 ADD       BL,CL		1.
 XOR       BL,CL                              
 SUB       CL,04                              
 ADD       BL,CL                              
 XOR       BL,CL                              
 XOR       BL,01                              
 XOR       BL,09                              
 XOR       BL,08                              
 XOR       BL,06                              
 MOV       [EAX],BL		2.
 XOR       EBX,EBX		3.
 INC       EAX			4.
 POP       ECX			5.
 LOOP      0040122C		6.


1. Spora mielonka :) Bl z poprzedniej mielonki jest mieszane z cl, ktore jak wiemy 28h :)

2. To co wyszlo laduje do eax
3. Zerowanie ebx
4. Zwiekszenie eax
5. Pobranie ecx ze stosu (27h)
6. Loop do pierwszego pusha ecx :) Czyli zajebista petla mielaca nasze znaki po koleii.

I momemt kulminacyjny :


 XOR       EBX,EBX                            1.
 CMP       DWORD PTR [ECX+00403057],00        2.
 JZ        004012A1                           
 MOV       EBX,[ECX+00403057]                 3.
 BSWAP     EBX                                4.
 CMP       [ECX+004030AC],EBX                 5.
 JNZ       004012B5                           
 ADD       ECX,04                             6.
 JMP       00401283                           7.
 PUSH      01                                 
 PUSH      DWORD PTR [00403094]               
 CALL      USER32!ShowWindow                  8.
       

1. Zerowanie ebx
2. Sprawdzenie czy koniec pewnego ciagu :]
3. Do ebx 4 pierwsze hexy tego ciagu :]
4. Bswapowanie ich [zamiana kolejnosci]
5. Porownianie naszego mielenia z ebx
6. Zwiekszenie ecx [czyli kolejne 4 znki z tajemniczego ciagu]
7. Skok do punktu 2
8. Nasze gratulacje za zlamanie ! :}

No oki :) Wiemy juz, ze przemielony serial musi byc rowny pewnemu ciagowi. Spojrzmy na ten ciag :

63h, 0bh, 81h, 54h, 0bh, 09h, 0b4h, 5eh, 09h, 4eh, 5eh, 63h, 5eh, 0b1h, 62h, 62h, 63h, 0bh, 09h, 4fh, 81h, 1fh, 5eh, 0fah, 09h, 5eh, 1dh, 4ch, 1fh, 0b7h, 62h, 5eh, 08h, 5eh, 09h, 5eh, 00h, 1dh, 0b4h, 0b7h

Spory ten ciag :) Ale zauwazmy jeszcze ze kolejne jego literki sa bswapowane :) Czyli prawidlowy ciag ma taka postac :

54h, 81h, 0bh, 63h, 5eh, 0b4h, 09h, 0bh, 63h, 5eh, 4eh, 09h, 62h, 62h, 0b1h, 5eh, 4fh, 09h, 0bh, 63h, 0fah, 5eh, 1fh, 81h, 4ch, 1dh, 5eh, 09h, 5eh, 62h, 0b7h, 1fh, 5eh, 09h, 5eh, 08h, 0b7h, 0b4h, 1dh, 00h

No dobra :) czyli wiemy juz, ze po pewnym mieleniu ma wyjsc taki ciag. Jak wyjdzie to haslo jest git :) Ok... polaczmy teraz to cale mielenie :) A bedzie ono takie :

	mov	cl, 28h

	xor	bl, 63h
	add	bl, 17h
	xor	bl, 10h
	sub	bl, 02h

	add	bl, cl
	xor	bl, cl
	sub	cl, 04h
	add	bl, cl
	xor	bl, cl
	xor	bl, 01h
	xor	bl, 09h
	xor	bl, 08h
	xor	bl, 06h

Jak juz mowilem mieleniem na ecx sie nie przejmujemy takze wystarczy nam wiedza, ze w cl ma byc 28h :) Stad ten mov cl, 28h :) Dalej jest procka po ktorej bl ma odpowiednio przyjmowac wartosci z tablicy. 

Czyli dla pierwszego znaku po mieleniu ma wyjsc 54h, dla drugiego 81h i tak dalej...

Coz juz pewnie odwracasz ta procke wzrokiem... :) Ale proponuje Ci cos lepszego :) Napiszemy sobie programik, ktory w mgnieniu oka odnajdzie nam cale haslo :) I to bez odwracania :) Cos a'la tyci brute-force ;D

Skopiujemy sobie ta procke mielaca oraz nasza tablice i po dodaniu paru instrukcji w oka mgnieniu zobaczymy nasze poprawne haselko :)

Programik bedzie wygladal tak :

------------------CUT--------------------------------------------------

.686
.model flat,stdcall
option casemap:none

include \masm32\include\windows.inc
          
include \masm32\include\advapi32.inc
include \masm32\include\gdi32.inc
include \masm32\include\user32.inc
include \masm32\include\kernel32.inc
include \masm32\include\comctl32.inc
include \masm32\include\comdlg32.inc
include \masm32\include\shell32.inc
include \masm32\include\imagehlp.inc
	
					;lubie luxus ;D
includelib \masm32\lib\imagehlp.lib
includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\gdi32.lib
includelib \masm32\lib\user32.lib
includelib \masm32\lib\comctl32.lib
includelib \masm32\lib\comdlg32.lib
includelib \masm32\lib\shell32.lib
includelib \masm32\lib\advapi32.lib


; nasza tablica jako magic


.data
	
magic	db 54h, 81h, 0bh, 63h, 5eh, 0b4h, 09h, 0bh, 63h, 5eh, 4eh, 09h, 62h, 62h, 0b1h, 5eh, 4fh, 09h, 0bh, 63h, 0fah, 5eh, 1fh, 81h, 4ch, 1dh, 5eh, 09h, 5eh, 62h, 0b7h, 1fh, 5eh, 09h, 5eh, 08h, 0b7h, 0b4h, 1dh

.data?

serial      db  40 dup (?)  ; nasz wygenerowany serialik ;)
 
.code

_start:

	int 3

	xor	edx, edx
	xor	edi, edi
	mov	esi, offset magic		;offsety do rejestrow
	mov	edi, offset serial	

jazda:
	push	1
	pop	eax
	
	
kolejne:

	dec	al		; kolejne wartosci
	mov	bl, al

dalej:
	
	mov	cl, 28h

	xor	bl, 63h
	add	bl, 17h
	xor	bl, 10h
	sub	bl, 02h
					; nasz procka mielaca
	add	bl, cl
	xor	bl, cl
	sub	cl, 04h
	add	bl, cl
	xor	bl, cl
	xor	bl, 01h
	xor	bl, 09h
	xor	bl, 08h
	xor	bl, 06h
	
	cmp	bl, byte ptr [esi]	; rowne wartosci z tablicy?
	jnz	kolejne			; jak nie to szukamy dalej

	mov	[edi], al		; jak dobre to do edi :)
	inc 	esi
	inc	edi
	cmp	byte ptr [esi], 0	; koniec?
	jnz	jazda
	xor	esi, esi
	mov	[edi], esi		; do edi haselko :)

	mov	cx, 27h

rownaj:					; ladnie nam wyrownuje haslo :)

	dec	edi
	dec	cx
	jnz	rownaj


	int	3			; wklepnji d edi :)
					; i masz haslo ! :)

end _start

------------------CUT--------------------------------------------------



Wszystko ladnie, pieknie i szybciutko :)
Wystarczy zastawic pulapke na int 3 przy uruchamianiu proga.

Po wklepaniu d edi widzimy haselko :


Nick nack paddy wack, give a dog a bone


I mamy wiadomosc, ze crackme potrzaskane!!! :)

Koniec tuta ;)

Pozdro dla wszystkich grupek na scenie :)

Kmicic (kmicic85@o2.pl)
