Crackme by lock3r by ged_//tkm!

Crackme korzysta z KeyExpand - podprocki AES'a. rozkminienie samego algo nie jest trudne, ale wymaga wyobrani =).

Crackme ma 4 editboxy, z kadego pobierane s 4 znaki (mona wpisa wicej, ale tylko 4 pierwsze s brane pod uwag). Pierwsza myl: bruteforce, (4*2^32 kombinacji do sprawdzenia), ale po disasmie exeka okazuje si, e nasze 4 dwordy s szyfrowane jako cig 128-bitowy (kady bajt zaley od pozostaych), wic ilo kombinacji do sprawdzenia bruteforcem wzrasta do 2^(32*4), czyli 2^128. W takim wypadku brute odpada :). Look na disasm:

_text:00401024                 push    ebx
_text:00401025                 mov     eax, dword_0_40324C
_text:0040102A                 mov     buf1, eax
_text:0040102F                 mov     eax, dword_0_403250
_text:00401034                 mov     buf2, eax
_text:00401039                 mov     eax, dword_0_403254
_text:0040103E                 mov     buf3, eax
_text:00401043                 mov     eax, dword_0_403258
_text:00401048                 mov     buf4, eax
_text:0040104D                 mov     ecx, 0Ah
_text:00401052                 mov     eax, 4
_text:00401057                 mov     count, eax

Kopiowanie dwordw seriala do bufora tymczasowego. buf1..4 trzymaj kolejne czci sn. "count" to mao wany licznik ;)

_text:0040105C 
_text:0040105C loc_0_40105C:       ; CODE XREF: sub_0_401024+46 j
_text:0040105C                 mov     ebx, count
_text:00401062                 push    ebx
_text:00401063                 push    4
_text:00401065                 call    crypt
_text:0040106A                 loop    loc_0_40105C

Procka szyfrujca zaptlona 10 razy

_text:0040106C                 mov     eax, buf1[ebx*4]
_text:00401073                 cmp     eax, 8B8F49EDh
_text:00401078                 jnz     short loc_0_4010BB
_text:0040107A                 inc     ebx
_text:0040107B                 mov     eax, buf1[ebx*4]
_text:00401082                 cmp     eax, 0E4274E99h
_text:00401087                 jnz     short loc_0_4010BB
_text:00401089                 inc     ebx
_text:0040108A                 mov     eax, buf1[ebx*4]
_text:00401091                 cmp     eax, 28BCA17Ch
_text:00401096                 jnz     short loc_0_4010BB
_text:00401098                 inc     ebx
_text:00401099                 mov     eax, buf1[ebx*4]
_text:004010A0                 cmp     eax, 0EDE87268h
_text:004010A5                 jnz     short loc_0_4010BB

8B8F49EDh 0E4274E99h 28BCA17Ch 0EDE87268h
^^^^^ to co ma wyj po szyfrowaniu

Ok, teraz naszym gwnym zadaniem jest zrozumienie dziaania procki szyfrujcej.

_text:004010CF crypt           proc near    ; CODE XREF: sub_0_401024+41 p
_text:004010CF 
_text:004010CF arg_0           = dword ptr  8
_text:004010CF arg_4           = dword ptr  0Ch
_text:004010CF 
_text:004010CF                 push    ebp
_text:004010D0                 mov     ebp, esp
_text:004010D2                 push    ebx
_text:004010D3                 mov     eax, [ebp+arg_4]
_text:004010D6                 dec     eax
_text:004010D7                 mov     edx, buf1[eax*4]

W edx lduje ostatni dword naszego sn

_text:004010DE                 inc     eax
_text:004010DF                 rol     edx, 8

Po rol edx, 8, dl trzyma najbardziej znaczcy bajt edx

_text:004010E2                 movzx   ebx, dl
_text:004010E5                 mov     dl, byte ptr sbox[ebx]

Najbardziej znaczcy bajt 4 dworda sn to pozycja w tablicy nowego bajtu wartoci SEED, ktra posuy do szyfrowania ...

_text:004010EB                 movzx   ebx, dh
_text:004010EE                 mov     dh, byte ptr sbox[ebx]

Kolejny bajt

_text:004010F4                 rol     edx, 10h
_text:004010F7                 movzx   ebx, dl
_text:004010FA                 mov     dl, byte ptr sbox[ebx]
_text:00401100                 movzx   ebx, dh
_text:00401103                 mov     dh, byte ptr sbox[ebx]

itd...

_text:00401109                 ror     edx, 10h
_text:0040110C                 mov     ebx, [ebp+arg_4]
_text:0040110F                 sub     ebx, 4
_text:00401112                 xor     edx, dword ptr tab[ebx]

Teraz nasza warto SEED wygenerowana na podstawie 4 dworda sn, jest xorowana z pewn sta wartoci z tablicy (dodatkowe zamieszanie + dyfuzja bitw)

_text:00401118                 mov     ebx, [ebp+arg_4]
_text:0040111B                 sub     ebx, [ebp+arg_0]
_text:0040111E                 mov     eax, buf1[ebx*4]
_text:00401125                 xor     eax, edx

Pierwszy dword sn jest xorowany z wartoci SEED

_text:00401127                 mov     ebx, [ebp+arg_4]
_text:0040112A                 mov     buf1[ebx*4], eax

... i zapisywany do bufora (cale szyfrowanie :)

_text:00401131                 inc     [ebp+arg_4]
_text:00401134                 inc     ebx
_text:00401135                 sub     ebx, [ebp+arg_0]
_text:00401138                 mov     edx, buf1[ebx*4]
_text:0040113F                 xor     eax, edx

2 dword XOR warto SEED

_text:00401141                 mov     ebx, [ebp+arg_4]
_text:00401144                 mov     buf1[ebx*4], eax
_text:0040114B                 inc     [ebp+arg_4]
_text:0040114E                 inc     ebx
_text:0040114F                 sub     ebx, [ebp+arg_0]
_text:00401152                 mov     edx, buf1[ebx*4]
_text:00401159                 xor     eax, edx

Teraz 3..

_text:0040115B                 mov     ebx, [ebp+arg_4]
_text:0040115E                 mov     buf1[ebx*4], eax
_text:00401165                 inc     [ebp+arg_4]
_text:00401168                 inc     ebx
_text:00401169                 sub     ebx, [ebp+arg_0]
_text:0040116C                 mov     edx, buf1[ebx*4]
_text:00401173                 xor     eax, edx

W kocu 4

_text:00401175                 mov     ebx, [ebp+arg_4]
_text:00401178                 mov     buf1[ebx*4], eax
_text:0040117F                 inc     [ebp+arg_4]
_text:00401182                 mov     eax, [ebp+arg_4]
_text:00401185                 mov     count, eax
_text:0040118A                 pop     ebx
_text:0040118B                 leave
_text:0040118C                 retn    8
_text:0040118C crypt           endp

Algo jest cakiem fajne :). Na pierwszy rzut oka nie wida, co trzeba zrobi eby wynik odszyfrowa, ale...

c1,c2,c3,c4 - bajty zaszyfrowanego 4 dworda
a,b,c,d - bajty naszego SEED'a
sbox[i] - warto pola i tablicy sbox

Szyfrowanie ostatniego dworda przebiega nastpujco:

c1 = a XOR sbox[b]
c2 = b XOR sbox[c]
c3 = c XOR sbox[d]
c4 = d XOR sbox[a]

Dlaczego tak? sbox[a..d] to kolejne bajty naszego SEED'a wygenerowane na podstawie 4 dworda. Jak to rozwiza? Gdybymy mieli taki ukad rwna:

c1 = a XOR sbox[a]
c2 = b XOR sbox[b]
c3 = c XOR sbox[c]
c4 = d XOR sbox[d]

To nie byoby adnego problemu, bo mona by stablicowa warto x^sbox[x], dla kadego bajtu x, a potem tylko znale szukan liczb w tablicy. W tym ukadzie rwna ... :

c1 = a XOR sbox[b]
c2 = b XOR sbox[c]
c3 = c XOR sbox[d]
c4 = d XOR sbox[a]

nie moemy tak postpi, bo nie ma adnego liniowego zwizku midzy x^sbox[y] (2 niewiadome). Zamiast zabawy z tablicami, mona wykorzysta bruteforca :). Najpierw losujemy warto d (ostatni bajt 4 dworda), na tej podstawie obliczamy sbox[d]. Rozwizujemy rwnanie:

c3 = c XOR sbox[d]
c = c3 XOR sbox[d]

I mamy c, czyli 3 bajt :), analogicznie liczymy b i a, eby sprawdzi czy poprawie rozwizalimy rwnania, liczymy sbox[a] i xorujemy z d, jeli otrzymany wynik rwna si c4, to bingo, mamy 4 dword :). Ddla jasnoci:

c4 = d XOR sbox[a]

C4 jest dane, d wylosowalimy, sbox[a] udao nam si policzy, wic jeli dobrze wylosowalimy d, to rwnanie musi by spenione :). Kiedy bdziemy mie ju cay 4 dword, to bez problemu generujemy oryginalny SEED i deszyfrujemy reszt byfora.

*ZONK*

Za szybko wziem si za pisanie tutora - szyfrowanie przebiega zupenie inaczej :D.

A,B,C,D - dwordy seriala
C1,C2,C3,C4 - kryptogram 
SEED - wiadomo

C1 = SEED^A
C2 = SEED^A^B
C3 = SEED^A^B^C
C4 = SEED^A^B^C^D

Banal :P. xorujemy rwnania 3 i 4 i otrzymujemy..

C3^C4 = D

teraz 2 i 3..

C2^C3 = C

1 i 2..

C1^C2 = B

Teraz z D liczymy SEED'a, xorujemy z C1 i mamy A :) oczywicie poprzednia metoda jest bdna... :)). sorx za zamieszanie. rdo 'keygena' doczone do zina.

XJX8-SP4D-Y3NJ-PDH6

ged_//tkm!
ged@hoga.pl