 ==============================================================================
                            Tutorial by Tymon//tkm!
 ==============================================================================

 .: info :.

 what:          CrackMe 5.0 by WiteG
 tools:         soft-ice, ida
 protection:    SHA-160, RSA-1920
 description:   crackme jest napisane pod czystym win32asm i skompilowane
		najprawdopodobniej pod masm. Spakowane UPX'em. Nie zawiera
		zadnych utrudnien w sledzeniu kodu.

 ==============================================================================

 .: start :.

 Witam w kolejnym tutorku. Dzisiaj zajmiemy sie CrackMe 5.0 by WiteG i 
 postaramy sie dowiedziec, dlaczego na stronie autora, obok naszego celu 
 widnieje napis _nearly_ uncrackable. So, czas nacisnac ctrl-d i przeniesc sie
 w otchlan asemblerowskiego kodu... :)

 ==============================================================================

 .: Debug :.

 Otwieramy crackme i wpisujemy jakies fake dane. Standardowe bpx'y na nic sie 
 nie zdadza, wiec zakladamy bpx SendDlgItemMessageA. Teraz przenosimy sie juz 
 do sice...

          pusha
          mov   esi, offset _name
          push  esi
          push  65h
          push  0Dh
          push  3E8h
          push  [ebp+hDlg]
          call  SendDlgItemMessageA
          cmp   eax, 5
          jl    loc_40278F
          mov   edi, esi
          push  esi
          push  eax
          push  edi
          call  _SHA160

 Na poczatku sprawdzane jest czy name ma minimum 5 znakow, a nastepnie na jego 
 podstawie jest wyliczany hash SHA-160.

          xor   ebx, ebx
          mov   ecx, 0Ah

 _1: 
          add   ebx, 14h
          add   edi, 14h
          push  esi
          push  ebx
          push  edi
          call  _SHA160
          dec   ecx
          jnz   short _1

 Powyzszy kawalek oblicza kolejne hashe SHA-160, do momentu, az zapelnia 
 odpowiedni buffer.

          push  esi                     ; lParam
          push  1E1h                    ; wParam
          push  0Dh                     ; Msg
          push  6Ah                     ; nIDDlgItem
          push  [ebp+hDlg]              ; hDlg
          call  SendDlgItemMessageA
          cmp   eax, 480
          jnz   short loc_40278F

 Tutaj pobierany jest serial i sprawdzane jest czy ma on 480 znakow.

          mov   edi, esi
          mov   ecx, 3Ch

 loc_402728:
          push  esi
          call  sub_4024BF
          jb    short loc_40278F
          mov   [edi], eax
          add   esi, 8
          add   edi, 4
          dec   ecx
          jnz   short loc_402728
          mov   eax, 3Ch

 Procka zamieniajaca nasz serial na hex.

loc_402740:
          mov   [edi+eax*4-4], ecx
          dec   eax
          jnz   short loc_402740

 Czyszczenie niepotrzebnych smieci...

          push  offset _serial
          push  offset _n
          push  offset _serial
          call  sub_402428

 Tutaj jest wlasciwie cale serce crackmesa, wiec musimy obejrzec tego call'a. 
 Jak mozna sie domyslec, beda tu operacje na bigach. Jak je rozpoznac? Na 
 poczatku trzeba rozpoznac format bigow. W tym crackme liczby te zapisane sa 
 zwyczajnie, bajt po bajcie... Nastepnie najlepiej podstawiac do procek jakies male 
 liczby i domyslac sie, co one robia. Jezeli ten sposob nie zadziala trzeba 
 obejrzec dokladnie call'e. Na szczescie w tym crackme wystarczy pierwsza 
 metoda. Zobaczmy wiec jakie to operacje:

          push  ebp
          mov   ebp, esp
          push  [ebp+arg_8]             ; s
          push  [ebp+arg_8]             ; s
          push  offset _buf1
          call  _imul
          push  [ebp+arg_8]             ; s
          push  [ebp+arg_8]             ; s
          push  offset _buf1
          call  _imul
          push  offset _buf1            ; s*s
          push  [ebp+arg_4]             ; n
          push  offset _buf2
          call  _div
          push  offset _buf2            ; (s*s)/n
          push  [ebp+arg_4]             ; n
          push  offset _buf3
          call  _imul
          push  offset _buf1            ; s*s
          push  offset _buf3            ; s*s/n*n
          push  offset _buf2
          call  _sub

 Jak doskonale widac powyzszy kawalek kodu oblicza reszte z kwadratu seriala. 
 Przeksztalcmy podane dzialania:

  s^2 - (s^2/n)*n <=> s^2 mod n

 Wynik tych operacji oznacze jako w1.

          call  _imul
          push  offset _buf3            ; s*w1
          push  [ebp+arg_4]             ; n
          push  offset _buf1
          call  _div
          push  offset _buf1            ; s*w1/n
          push  [ebp+arg_4]             ; n
          push  offset _buf2
          call  _imul
          push  offset _buf3            ; s*w1
          push  offset _buf2            ; (s*w1/n)*n
          push  [ebp+arg_0]
          call  _sub

 Powyzsze instrukcje mozna przeksztalcic:

  (s*w1) - ((s*w1/n)*n) <=> s*w1 mod n <=> s*(s^2 mod n) mod n <=> s^3 mod n

 Jak widac nic innego jak RSA z e=3 :)

 Oki, zobaczmy co dalej:

          mov   ecx, 3Ch

 loc_402760:
          mov   eax, ds:hInstance[ecx*4]
          cmp   eax, ds:dword_404FEC[ecx*4]
          jnz   short loc_40278F
          dec   ecx
          jnz   short loc_402760
          mov   eax, offset aCongratulation ; "Congratulations. Good work !"

 Tutaj jest porownanie wyniku poprzednich obliczen z hash'em sha160. Jezeli te 
 dwie liczby sa rowne to mamy dobry serial. Zapiszmy wiec cale zabezpieczenie:

   serial^e mod n = hash, gdzie e=3

 Rozwiazaniem jest wiec:

   serial = hash^d mod n

 No i tutaj jest najwiekszy problem :( Zobaczmy ile bitowe jest n... tak, to AZ 
 1920 bitow!!! Jak wiadomo, zeby obliczyc d musimy rozlozyc podana liczbe na 
 czynniki pierwsze. Jednak przy wspolczesnych metodach faktoryzujacych moze to 
 zajac nawet kilka wiekow!!! Co z tego wynika? Czyzby crackme bylo nielamliwe? 
 W dzisiejszych czasach na pewno tak! Jednak pamietacie dopisek na stronie 
 Witka? O co wiec chodzi? To proste... Jak juz powiedzialem w dzisiejszych 
 czasach zlamanie tego crackme jest niemozliwe, jednak, jak wiadomo, 
 technologia rozwija sie w zaskakujacym tepie... Byc moze za kilka lat taka 
 ilosc bitow w n nie sprawi zadnych przeszkod kryptografom... Szybko 
 rozwijajace sie zegary procesorow i ciagle prace naukowe moze juz niedlugo 
 doprowadza do znalezienia jakis back door'ow w algorytmie lub po prostu 
 powstana nowe algorytmy faktoryzacji duzych liczb... No coz, nie pozostaje nam 
 nic innego jak czekac na te cuda techniki :) No, a jak na razie jedynym 
 sensownym rozwiazaniem jest... tutorial opisujacy zabezpieczenie lub crack 
 (jednak ten drugi jest niedozwolony).

 Musze tutaj przyznac, ze najwieksza zaleta tego crackmesa, jest to, ze 
 wszystkie operacje na big'ach sa napisane pod czystym asemblerem (respect
 WiteG!)

 ==============================================================================
 .: Greetz :.

 WiteG - za crackme....
 all people from AAoCG/HTBTeam/TKM! + veneta//MBE