Cominciamo col vedere di che tipo di protezione si tratta, immediatamente dopo l'apertura si presenta davanti a noi il classico schema Username/SerialNumber. Inserisco come username 'evilcry' e come serial 'triton', e poi setto un breakpoint su GetDlgItemTexA. Ecco cos'abbiamo di fronte:

004010D3 call GetDlgItemTextA

004010F2 call sub_4012DC ;Altra call che analizzeremo in seguito

Passiamo ora ad analizzare cosa fanno le call 00401272 e 004012dc...

004012DB retn

Come potete vedere il codice di questa call è semplicissimo, in poche parole controlla che i primi 6 caratteri del serial seguono determinate "condizioni". Penso sia inutile riscrivere quali sono le condizioni, quindi procediamo direttamente con il reverse (per altro sono operazioni semplicissime da reversare):

1°Char = Essendo (x Xor 65 - 1 = 0), basta prendere il valore prima di 65 cioè 64h (d)

2°Char = Shl x,3 = 328h quindi invertiamo l'operazione come Shr 328,3 cioè 65h (e)

3-4°Char = x + y = 0DFh in 2 secondi con la calcolatrice otteniamo 76h = (v) e 69h= (i)

5°Char = Shl x,1 = 0D2h invertiamo anche qui come Shr 0D2,1 = 7Ah = (l)

6°Char= Senza perdere tempo, i primi 5 bytes sono il nome dell'autore del crackme è devilz quindi devil(z) :)

Questa prima call è fatta, se i caratteri sono quelli giusti, setz dovrebbe settare AL=1. Procediamo ora con la prossima call 004012dc:

 

Il primo pezzo di routine controlla che i caratteri del serial che stanno immediatamente dopo 'devilz' rispettano alcune condizioni. Considerando che dobbiamo uscire da questo ciclo di check (004012E1-00401309) senza far saltare l'esecuzione fuori dal ciclo stesso, la cosa migliore è far sì che i caratteri diano 82h. Come prima facciamo:

Shl x,1= 82h, che revesato da Shr 82h,1= 41h (A)

Quindi comiciamo a mettere dopo devilz, una serie di A. Passiamo ora all'altra porzione di codice (da 0040130E per intenderci), attraverso la quale saremo in grado di determinare quale dev'essere la lunghezza del nostro serial. Per sapere quindi la lunghezza corretta vediam che

((Shl x,1) xor 45) - 1 = 0 che è molto semplice da reversare, considerando che il risultato dello xor dev'essere 1 (che poi sottratto da 0) prendiamo come secondo operando (dello xor sempre) 44h. Perciò

Shr 44,1 = 22h (34d)

capiamo facilmente che il serial dev'essere lungo 34. Con il prossimo pezzo di codice invece capiremo qual'è lo "scheletro" del nostro serial:

 

2Dh corrisponde al trattino, perciò seguendo le direttive di questo pezzo di codice saremo in grado di costruire lo "scheletro" del nostro seriale valido. Ecco come dovrebbe risultarvi la forma di un serial corretto:

devilz-AAAA-AAAA-AAAAAAAA-AAAAAAAA

Per facilitare il discorso, chiameremo ogni sigolo pezzo (compreso tra due trattini) in modo diverso. I nomi che gli daremo saranno, PrimaWord, SecondaWord, PrimaDword e SecondaDword.

Se appunto mettiamo questo serial, dovremmo ottenere questo messaggio: "You are Halfway.... You Need To Progress :p"

Passiamo ora a vedere cosa succede dopo questa call. Innanzitutto possiamo notare la presenza di 4 call tutte le stesse, chiamate in successione:

...

 

Se notate le call sono quattro, proprio come i "pezzi" di serial. Infatti andando ad analizzare l'nterno di questa funzione:

 

che, senza stare a perder tempo, altro non è che una funzione di conversione, che trasforma il nostro serial da hex a stringa semplice. Ogni call elabora un pezzo di serial. Adesso che sappiamo cosa fanno queste call, possiamo procedere oltre con l'analisi.

00401171 call sub_401499 ;call che analizzeremo in seguito

Passiamo ad analizzare la call 00401378

004013DC setz al ;Sennò setta al FALSE

Questo pezzettino di codice ci permette di trovare il valore di PrimaWord, possiamo facilmente intuire che questo valore dipende solamente dall'hardisk in cui si trova il crackme.

Da questo pezzo di codice possiamo vedere, che adesso si comincia a lavorare con l'username. C'è anche da dire che il risulto dell'AND tra la LowerWord del SerialNumber del HDD ed il valore 5Fh andrà in una variabile che ho chiamato V1, la quale sarà usata in una routine che vedremo presto. Andiamo ora ad analizzare la call 00401421:

00401462 loopne loc_401435

Abbiamo davanti a noi la più classica delle routine di Crc32, riconoscibilissima anche a 100 km di distanza :). Per chi non lo sapesse CRC significa Cyclic Redundancy Check o a seconda dei casi anche Cyclic Redundancy Code, spesso (quasi sempre) i CRC vengono utilizzati come controlli d'integrità di codice o di dati. Adiamo avanti:

00401495 setz al ;Se eax è 0 setta AL a TRUE

Da questo pezzetto di codice possiamo ricavare il giusto valore di PrimaDword e successivamente di SecondaWord, infatti se prendiamo il codice da 00401470 in poi e ne aumentiamo il livello di astrazione (The+Q di +Fravia docet) saremo in grado con due semplici passaggi di reversare il codice:

Se abbiamo infatti: (PrimaDword >> 10h) && Delta

allora avremo: SecondaWord == ((PrimaDword >> 10h) && Delta)

che ritradotto in asm:

mov SecondaWord, ax

Questa è solo la prima parte della routine per ottenere SecondWord, infatti come potete vedere dalla relazione, alcune cose ancora non le abbiamo considerate (leggete più sotto, la parte che tratta del logaritmo).

Usciti da questa call, continuiamo la nostra analisi:

0040117B bswap eax

Vediamo cosa c'è dentro la call 00401499:

004014DF call sub_40158A ;Stessa call di sopra

 

Questa routine merita qualche spiegazione. Non è necessario studiare approfonditamente la call 40158A, perchè contiene al suo interno un piccolo algoritmo composto da shift, rotate ecc. di cui non c'interessa granchè dato che non dobbiamo reversarlo. Chiamerò questa call 'Algo()' per motivi di semplicità, c'è da notare che prima della chiamata ad Algo() viene messa in eax ed edx la variabile Delta. Analizzando i valori di ritorno eax ed edx di Algo(), possiamo notare che alla prima chiamata (004014A7h):

1°Algo(): eax = Delta, edx =! Delta

Alla seconda chiamata di Algo() possiamo intendere eax e edx come:

2°Algo(): eax=Delta+bswap(Delta), edx=bswap(Delta)

Procediamo con lo studio della routine:

00401523 fild dword_403A75 ;fild V5, cioè mette V5 in St0 (dovete conoscere un minimo di architettura del FPU - FloatingPointUnit)

Vediamo ora cosa succede all'uscita di questa call:

 

L'istruzione fyl2x come già detto esegue Z= Y log2 (X), voglio solo specificare che 0 < X < Infinito (cioè X dev'essere positivo), mentre per Y Infinito < Y < Infinito. Come prima aumentando il livello di astrazione:

(LowerWord)SecondaDword = V2^bl-(HighWord)SerialDword

dove se V2=1 per la proprietà dei logaritmi avremo log2(V2)=0

Per semplicità chiameremo la locazione 403A69 'V4'.

Passiamo ora ad analizzare la call 40152B:

 

Dentro questa call, come potete ben vedere, troviamo una serie di Floating Point Operations, si tratta di un puro calcolo matematico. Cerchiamo come prima cosa di elevare il livello di astrazione di questa routine per rendere le cose più chiare, e facilmente reversibili, ecco cosa fa "matematicamente" questa call:

Var2 = -.1529248683*((V4^2)*V1+V3*V4-74565.)/ V4^4

Risistemando un pò le cose, ecco che ricaviamo l'equazione finale da risolvere:

(V4^2)*V1+V4*V3-74565=0

Infine vi riporto la routine che ho usato nel keygen per risolvere questa equazione:

mov SecondaDword, eax

Bene, ecco tutto!! ;) spero di essere stato chiaro, se non avete capito qualcosa non esitate a contattarmi. Se invece mi venite a fare richieste di crack..non vi rispondo :->