WinRar 2.5
Written by Spin0ne

Francamente non mi è chiaro lo scopo di questo corso, probabilmente perché non ho capito fino in fondo la protezione e comunque qual’è la connection con l’ellisse qualcuno dovrà poi spiegarmela.

SoftIce

www.uic-spippolatori.com sezione "Lezioni"

Bèh…chi non conosce winrar??…. un noto programma simile al Winzip ma non di certo alla sua protezione.

Bene, bene. Innanzitutto vi informo che non solo sono un newbies, ma questo è anche il mio primo tutorial quindi, non vi incazzate per le eventuali puttanate. Dopo un po' di tempo passato ad esercitarmi con i vari crackme ho pensato che poteva essere arrivato il momento di cimentarmi con un corso della UIC. Chissà perché, molto ingenuamente, ho creduto che date le affinità con winzip, winrar fosse ugualmente facile da reversare. Invece appena aperto……. porca pupazza….che casino! Ormai però c’ero dentro…. è visto che quando punto qualcosa non la mollo +……….. eccomi qua. Ma vediamo cosa siamo riusciti a capire…..

Dunque, nel tentativo di reversare il programma, l’ho attaccato dall’inizio. Dopo aver inserito "Spin0ne" come nick , "5555555" come seriale e, piazzato bpx hmemcpy nel sice, facciamolo poppare cliccando ok sulla finestra di registrazione……ecco siamo nell’Api di windows….pigiamo F5 cosi saltiamo la lettura del nome…di nuovo nell’Api di windows…. per la lettura del seriale….ora andiamo di F12 fino a quando siamo in winrar e…..approdiamo a:

 

:00409D4F cmp byte ptr [ebp+FFFFFE50], 00…………Si assicura che il seriale sia stato inserito

:00409D56 jne 00409D73……………………………………………………………Se non eseguite questo salto, vi spara dritto fuori dal proggy

Ora a questo punto se in Sice digitate "s 30:0 L FFFFFFF "vostronick" fate uno scan della memoria e potete leggere la locazione di memoria dove il proggy ha messo il vostro nome. Stessa cosa fate per il "vostroseriale". Annotate gli indirizzi, poi steppate con F8 addentrandovi in tutte le call (che sono una vagonata ed è meglio se vi tracciate un albero) fino ad arrivare a:

:00409D73 xor eax, eax

:00409D75 lea edi, dword ptr [ebp+FFFFFE98]………Carica in edi la locazione del nick

:00409D7B or ecx, FFFFFFFF

:00409D7E mov esi,0045BE70

:00409D83 repnz…………………………………………………………………………………Conta i bytes del nick

:00409D84 scasb

:00409D85 not ecx……………………………………………………………………………In ecx la lunghezza in byte del nick +1

:00409D87 sub edi, ecx

:00409D89 mov edx, ecx

:00409D8B xchg edi, esi………………………………………………………Inverte i registri….. in esi locazione del nick

:00409D8D shr ecx, 02……………………………………………………………Shifta ecx di 2 (divide il valore per 4)

:00409D90 mov eax, edi…………………………………………………………Carica in eax la locazione di memoria del nick

:00409D92 repz………………………………………………………………………………Prende il nick e lo copia in 4 bytes per volta (dword) nella locazione puntata da edi

Continuiamo con F8

:0042CF59 mov eax, ecx

:0042CF5B xor edx, edx

:0042CF5D test al, 01

:0042CF5F je 0042CF6D

:0042CF61 mov esi, eax…………………………………………………………In questa routine viene caricata la dword

:0042CF63 shr esi, 1………………………………………………………………EDB88320 quando il valore di al è 01. Ad

:0042CF65 xor esi,……………………………………………………………………ogni iterazione la dword viene shiftata ed il

:0042CF6B jmp 0042CF71…………………………………………………………risultato messo in eax. Alla fine delle 8

:0042CF6D mov esi, eax…………………………………………………………iterazioni il risultato finale che si trova in eax e

:0042CF6F shr esi,……………………………………………………………………viene posto nella locazione puntata da [ebx].

:0042CF71 mov eax, esi EDB88320………………………………La routine viene eseguita 100h volte e le

:0042CF73 inc edx………………………………………………………………………dword risultanti compongono una tavola scritta in

:0042CF74 cmp edx, 00000008……………………………………………memoria dalla locazione 465870 a 465CEC.

:0042CF77 jl 0042CF5D

:0042CF79 mov dword ptr [ebx], eax

:0042CF7B inc ecx

:0042CF7C add ebx, 00000004

:0042CF7F cmp ecx, 00000100

:0042CF85 jl 0042CF59

Dopo aver passato altre routine che puliscono la memoria (riempiono di 0 le locazioni) arriviamo a questa porzione del progg. dove troviamo un altro spostamento del nick:

:004272F8 xor eax, eax

:004272FA mov edi, edx…………………………………………………………Mette in edi la locazione del nick

:004272FC or ecx, FFFFFFFF

:004272FF lea esi, dword ptr [ebp+FFFFFF74]

:00427305 repnz……………………………………………………………………………Verifica la lunghezza del nome

:00427306 scasb

:00427307 not ecx………………………………………………………………………In ecx il n° dei char +1 del nome

:00427309 sub edi, ecx

:0042730B mov edx, ecx

:0042730D xchg edi,esi………………………………………………………Inverte i registri….. in esi locazione del nick

:0042730F shr ecx, 02…………………………………………………………Shifta ecx di 2 (divide il valore per 4)

:00427312 mov eax, edi

:00427314 repz

:00427315 movsd…………………………………………………………………………Copia il nome nella locazione puntata da edi

:00427316 mov ecx, edx

:00427318 and ecx, 00000003

:0042731B repz

:0042731C movsb

:0042731D mov eax, dword ptr [ebp+08]………………Mette in eax la locazione che punta al 1°byte del nome e……

:00427320 push eax…………………………………………………………………la salva nello stack

Continuiamo a steppare e arriveremo al trattamento del seriale:

 

:0042736E xor eax, eax

:00427370 mov dword ptr [ebp-0C], edx

:00427373 mov dword ptr [0045CC94], 00000001

:0042737D mov ecx, dword ptr [ebp+0C]…………………………Mette in ecx la locazione del seriale

:00427380 lea esi, dword ptr [ebp+FFFFFF2C]

:00427386 mov edi, ecx…………………………………………………………………Locazione seriale spostata in edi

:00427388 or ecx, FFFFFFFF

:0042738B repnz……………………………………………………………………………………Conta i byte del seriale

:0042738C scasb

:0042738D not ecx

:0042738F sub edi, ecx…………………………………………………………………In ecx lunghezza del seriale

:00427391 mov edx, ecx

:00427393 xchg edi, esi………………………………………………………………Inverte i registri…. in esi locazione del seriale

:00427395 shr ecx, 02……………………………………………………………………Shifta ecx di 2 (divide il valore per 4)

:00427398 mov eax, edi

:0042739A repz

:0042739B movsd……………………………………………………………………………………Copia la dword del seriale nella locazione puntata da edi

:0042739C mov ecx, edx

:0042739E and ecx, 00000003

:004273A1 repz

:004273A2 movsb……………………………………………………………………………………Copia i rimanenti byte del seriale

:004273A3 xor eax, eax

:004273A5 mov byte ptr [0045C69A], 00

:004273AC mov dword ptr [ebp-08], eax

:004273AF xor ebx, ebx

:004273B1 mov byte ptr [0045CCC8], 02

:004273B8 mov byte ptr [0045CCC9], 01

:004273BF cmp ebx, dword ptr [ebp-04]

:004273C2 mov byte ptr [0045CCCA], 00

:004273C9 lea eax, dword ptr [ebp+FFFFFF7]………In eax la locazione che punta al 1°byte del nome

:004273CF jge 004273DF

Dopo aver visto i vari spostamenti del nick e del seriale, continuando, arriviamo finalmente alla 1a manipolazione: 

 

:004273D1 xor edx, edx

:004273D3 inc ebx

:004273D4 mov dl, byte ptr [eax]……………………………………Mette in dl il byte puntato del nick

:004273D6 inc eax……………………………………………………………………………Sposta il puntatore al prossimo byte

:004273D7 xor dword ptr [ebp-08], edx………………………Xora il byte messo in dl con il 1° del nick e ci scrive sopra il risultato

:004273DA cmp ebx, dword ptr [ebp-04]………………………Compara se ebx è uguale al dword puntata…in [ebp-04] lunghezza del nick, quindi controlla se tutti i byte sono stati trattati

:004273DD jl 004273D1…………………………………………………………………Se no salta e riprende il ciclo

Nella routine di sopra i bytes del nick vengono presi e xorati con il byte che si trova nella locazione [ebp-08]. Dal momento che il risultato è messo sempre nella locazione [ebp-08] sovrascrivendo ogni volta quello precedente esso costituisce anche il valore per gli xor succesivi. Alla fine il risultato, in caso del nick Spin0ne, è: 1F…. ma continuiamo a steppare fino a:

:004273EA mov eax, ebx

:004273EC mov edx, dword ptr [ebp-10]

:004273EF mov esi, edx………………………………………………Mette in edx locazione del byte del nick

:004273F1 cmp eax, dword ptr [ebp-04]………Verifica se tutti i byte sono stati trattati…in eax-il contatore cicli passato da ebx

:004273F4 lea edx, dword ptr [ebp+eax-0000008C]……Carica in edx locazione del nick

:004273FB jge 0042740C………………………………………………Salta se ha finito i cicli

:004273FD mov cl, byte ptr [edx]……………………Mette il byte puntato del nick in cl

:004273FF add edx, 00000005…………………………………Sposta il puntatore de nome di 5 byte

:00427402 add byte ptr [esi], cl……………………Addiziona cl al byte puntato da esi (che è se stesso)

:00427404 add eax, 00000005…………………………………Aggiunge 5 a eax……

:00427407 cmp eax, dword ptr [ebp-04]………e lo confronta con la lunghezza del nome

:0042740A jl 004273FD…………………………………………………Riprendi l'iterazione se inferiore ……altrimenti………

:0042740C inc ebx……………………………………………………………Aumenta il contatore dei cicli

:0042740D inc [ebp-10]………………………………………………Sposta il puntatore al prossimo byte da trattare

:00427410 cmp ebx, 00000005…………………………………Controlla se sono stati fatti i 5 cicli….

:00427413 jl 004273EA…………………………………………………se no riprendi il ciclo

 

In pratica nella routine precedente, ad ognuno dei primi 5 byte del nome viene addizionato se stesso e poi ancora aggiunto il valore del successivo 6° byte. I risultati vengono sovrascritti nella stessa locazione di ogni byte.

Continuiamo a steppare……

:00427430 cmp byte ptr [esi], 39…………………Legge il byte del seriale puntato in esi se è un numero o una lettera

:00427433 jbe 00427446 s……………………………………… Salta se numero…se lettera incece verrà trattato nella call sottostante

:00427435 xor eax, eax

:00427437 mov al, byte ptr [esi]

:00427439 push eax

:0042743A call 0044981C

:0042743F pop ecx

:00427440 add al, C9

:00427442 mov byte ptr [esi], al

:00427444 jmp 00427449

:00427446 add byte ptr [esi], D0………………Aggiunge il valore D0 al byte puntatto del seriale

:0427449 inc ebx…………………………………………………………Incrementa ebx (contatore)

:0042744A inc esi………………………………………………………Sposta il puntatore

:0042744B cmp edi, ebx…………………………………………Confronta il n° delle iterazioni

:0042744D jg 00427430……………………………………………Riprendi se non ha finito (in edi…n° di caratteri del seriale)

 

Nella routine di sopra, i valori esadecimali del seriale vengono convertiti in decimali.

Continuiamo fino all'offset:

:0042745B mov dl, byte ptr [eax]………………Mette in dl il byte del seriale puntato da eax

:0042745D shl edx, 04……………………………………………Shift di 4 su edx (valore modifcato in dl)

:00427460 add dl, byte ptr [eax+01]………Al valore in dl viene aggiunto quello del byte successivo

:00427463 xor dl, byte ptr [ebp-08]………Il risultato in dl viene xorato per il valore puntato da ebp-08 che è il risultato della manipolazione del nome eseguita nella routine 4273D1-4273DD (Ricordate?? quel valore che nel caso del mio nick è 1F!)

:00427466 mov ecx, ebx

:00427468 sar ecx, 1

:0042746A jns 0042746F

:0042746C adc ecx, 00000000

:0042746F mov byte ptr [ebp+ecx-44],dl………Il risultato in dl viene scritto all'indirizzo puntato

:00427473 add ebx, 00000002……………………………………Incrementa di 2 il contatore

:00427476 add eax, 00000002……………………………………Sposta di 2 byte il puntatore al seriale (ne salta uno)

:00427479 cmp edi, ebx…………………………………………………In edi il n° di char del seriale

:0042747B jg 0042745B……………………………………………………Riprende il ciclo se non ha finito

 

Nella routine sovrastante viene ancora manipolato il seriale. Viene effettuata a byte alterni (infatti eax viene spostato di 2 ogni volta) ed ad ogni byte viene addizionato il successivo. Il risultato in dl viene xorato per quell'unico valore risultante dalla manipolazione del nome. Incrementando di 2 il contatore, il n° delle iterazioni saranno uguali alla lunghezza del seriale/2. Nel mio caso con seriale di 7 char avremo 4 iterazioni, quindi solo quattro 4 bytes manipolati

Bene…. giunti a questo punto (dopo aver annotato la locazione inizialmente puntata da [ebp+ecx-44] ) per evitare di perderci nelle molteplici call, possiamo vedere subito come il programma utilizza il seriale manipolato….dunque in Sice scriviamo "bpmd <locazionedimemoria> r" dove la locazionememoria è quella che avete annotato prima, il parametro "r" servirà a far poppare sice in sola lettura quando il programma andrà ad accedere a quella locazione. Effecinquizzate e Sice vi popperà all’offset 4434F2….. ma vediamo dalle istruzioni antecedenti cosa fà il programma:

 

:004434D4 push ebp

:004434D5 mov ebp, esp

:004434D7 push esi

:004434D8 push edi

:004434D9 mov edi, dword ptr [ebp+08]

:004434DC mov eax, edi

:004434DE mov esi, dword ptr [ebp+0C]

:004434E1 mov ecx, dword ptr [ebp+10]……………………Mette in esi la locazione del dword manipolata

:004434E4 mov edx, ecx

:004434E6 shr ecx, 1

:004434E8 shr ecx, 1

:004434EA cld

:004434EB repz

:004434EC movsd………………………………………………………………………………Nessun spostamento…ecx=0

:004434ED mov ecx, edx

:004434EF and ecx, 00000003

:004434F2 repz

:004434F3 movsb………………………………………………………………………………Prende i bytes del seriale che erano situati nella locazione annotata e sulla quale abbiamo settato il bpmd e li muove all'indirizzo 4602BC

:004434F4 pop edi

:004434F5 pop esi

:004434F6 pop ebp

:004434F7 ret

 

Qui è necessario notare che nel mio caso (serial di 7 caratteri) essendoci stati degli shr che azzerano il contatore relativo all’istruzione repz movsd non viene mossa nessuna dword e solo successivamente vengono mossi solo 3 bytes

Continuiamo a steppare fino a giungere:

 

:0042CEA3 mov bl, byte ptr [0045CCCA]………………………Muove il byte puntato in bl

:0042CEA9 add byte ptr [ecx], bl……………………………………bl viene aggiunto al byte puntato da ecx

:0042CEAB mov bl, byte ptr [ecx]……………………………………Il risultato in ecx è rimesso in bl…..

:0042CEAD add byte ptr [esi], bl……………………………………e quindi addizionato al byte in esi

:0042CEAF mov bl, byte ptr [esi]……………………………………Il risultato in esi è rimesso in bl

:0042CEB1 sub byte ptr [eax], bl……………………………………Il valore finale in bl viene sottratto dal byte del seriale-nella locazione 4602bc puntato in eax

:0042CEB3 inc eax………………………………………………………………………………Sposta il puntatore al prossimo byte del seriale

:0042CEB4 mov ebx, edx………………………………………………………………In edx il n° delle iterazioni

:0042CEB6 add edx, FFFFFFFF

:0042CEB9 test ebx, ebx

:0042CEBB jne 0042CEA3…………………………………………………………………Salta se non ha finito

 

In pratica la routine di sopra ha come effetto di ridurre il 1° byte, del seriale in posto in 4602BC, del valore 3, il 2° di 4, il 3° di 5, e così via.

A questo punto il programma esegue delle lunghissime routine di preparazione e scrittura di una tavola di valori che vanno dalla locazione 466C41 a 467c38 e da46743C a 467AB9

Ma continuando pazientemente a steppare arriveremo a:

 

:0042F44B mov ecx, 00000008

:0042F450 mov edi, 004602B4

:0042F455 mov bl, byte ptr [edx+004602BC]…………Mette il 1° byte del seriale in bl

:0042F45B xor edx, edx

:0042F45D mov dl, byte ptr [eax+004602BD]…………Mette il 2° byte in dl

:0042F463 mov ebp, 00468C3C

:0042F468 movzx edx, dx

:0042F46B movzx eax, byte ptr [eax+004602BE]…Mette il 3° byte in eax

:0042F472 shl edx, 08………………………………………………………………Il 2° viene shiftato a sinistra di 8

:0042F475 sub ecx, dword ptr [004626C4]

:0042F47B shl ebx, 10……………………………………………………………Il 1° viene shiftato a sinistra di 10

:0042F47E or ebx, edx……………………………………………………………Esegue uno or dei due registri con risultato in ebx

:0042F480 or ebx, eax……………………………………………………………Ancora uno or con eax (i 3 bytes ora sono in ebx)

:0042F482 shr ebx, cl……………………………………………………………Il risultato è shiftato a destra con il valore di cl

:0042F484 and ebx, 0000FFFF

:0042F48A mov dword ptr [edi], ebx………………………Il risultato viene messo in edi all'indirizzo 4602B4

:0042F48C cmp dword ptr [ebp+00], 000075FF…Confronta con……

:0042F493 jbe 0042F4B1………………………………………………………Salta se inferiore o uguale a……

:0042F495 push 00451CF4

:0042F49A push 00451CDC

:0042F49F push 00000008

:0042F4A1 push ebx

:0042F4A2 call 0042FA4C

:0042F4A7 add esp, 00000010

:0042F4AA mov ebx, eax

:0042F4AC jmp 0042F536

:0042F4B1 cmp dword ptr [ebp+00], 00005DFF

:0042F4B8 jbe 0042F4D5…………………………………………………………Salta se inferiore o uguale a……

:0042F4BA push 00451CA8

:0042F4BF push 00451C8C

:0042F4C4 push 00000006

:0042F4C6 mov ecx, dword ptr [edi]

:0042F4C8 push ecx

:0042F4C9 call 0042FA4C

:0042F4CE add esp, 00000010

:0042F4D1 mov ebx, eax

:0042F4D3 jmp 0042F536

:0042F4D5 cmp dword ptr [ebp+00], 000035FF

:0042F4DC jbe 0042F4F9…………………………………………………………Salta se inferiore o uguale a……

:0042F4DE push 00451C58

:0042F4E3 push 00451C38

:0042F4E8 push 00000005

:0042F4EA mov eax, dword ptr [edi]

:0042F4EC push eax

:0042F4ED call 0042FA4C

Qui è accaduto qualcosa di molto interessante. In pratica in questa routine, i bytes del seriale vengono prelevati dalla locazione 4602BC-460CC2, successivamente manipolati ed il risultato messo in edi alla locazione 4602B4, sarà una word che costituirà un parametro da passare in seguito al registro eax per la prossima routine.

I cicli saranno in totale 5 e per ognuno di essi i bytes saranno caricati nella maniera e succesione di ciclo seguente:

Primo ciclo:…………..1° byte 2° e 3°

Secondo ciclo:……….1° byte 2° e 3°

Terzo ciclo:…………..2° byte 3° e 4°

Quarto ciclo:………….3° byte 4° e 5°

Quinto ciclo:………….4° byte 5° e 6°

Attenzione!! essendoci solo nella locazione 4602BC solo 3 bytes l’ultimo byte (il 3°) potrà interessare solo fino al quarto ciclo. Il quinto ciclo preleverà 4°,5° e 6° byte che sono degli zeri. Questa condizione porterà fuori dal programma senza peraltro aver interessato la routine di confronto del seriale con il nick. Pertanto è necessario che il seriale immesso all’inizio, nella finestra di registrazione, sia almeno di 8 caratteri.

:0042FA4C push ebp

:0042FA4D mov ebp, esp

:0042FA4F push ebx

:0042FA50 push esi

:0042FA51 mov edx, dword ptr [ebp+0C]……………Mette il valore 5 in edx

:0042FA54 mov esi, dword ptr [ebp+08]……………I due bytes calcolati prima sono messi in esi

:0042FA57 and esi, 0000FFF0………………………………………Viene azzerato l’ultimo bit in esi

:0042FA5D xor ebx, ebx

:0042FA5F mov eax, dword ptr [ebp+10]……………Viene messa in eax la locazione di memoria 451BE4

:0042FA62 jmp 0042FA69……………………………………………………Salta a………

:0042FA64 inc edx………………………………………………………Incrementa edx

:0042FA65 inc ebx………………………………………………………Incrementa edx

:0042FA66 add eax, 00000004……………………………Sposta i puntatore in eax al prossimo valore della tavola

:0042FA69 mov ecx, dword ptr [eax]………………Carica un valore preso dalla tavola che inizia a 451BE4

:0042FA6B cmp ecx, esi………………………………………………Compara se i due bytes è un valore inferiore o uguale a quello preso dalla tavola

:0042FA6D jbe 0042FA64 Ritorna su se inferiore o uguale

Praticamente in questa routine si determina se il valore della dword con i due byte è in un determinato range. Infatti i valori possono essere 2000, C000, F000,…… Se il valore è inferiore si ritorna sù e si sposta il puntatore della tavola al valore successivo. Questi passaggi influenzano anche edx e ebx con i loro incrementi che a loro volta come vedremo sotto influenzeranno il risultato della manipolazione della dword.

:0042FA6F mov eax, dword ptr [004626C4]……Mette il valore 6 in eax

:0042FA74 add eax, edx…………………………………………………Ricordo che edx è influenzato dal n° di passaggi di prima, quindi dal valore tavola, ovvero dal range valore dei due bytes

:0042FA76 mov ecx, eax

:0042FA78 and eax, 00000007

:0042FA7B shr ecx, 03

:0042FA7E add dword ptr [004626C0], ecx

:0042FA84 mov ecx, 00000010

:0042FA89 sub ecx, edx

:0042FA8B test ebx, ebx

:0042FA8D mov dword ptr [004626C4], eax

:0042FA92 je 0042FA9D

:0042FA94 mov eax, dword ptr [ebp+10

:0042FA97 mov eax, dword ptr [ebx*4+eax-04]………………Mette in eax il valore puntato. Anche qui

ricordo che esiste l’influenza di una variazione di ebx

:0042FA9B jmp 0042FA9F

:0042FA9D xor eax, eax

:0042FA9F push eax

:0042FAA0 mov eax, esi……………………………………………Muove la word con i due byte in eax (ultimo bit azzerato)

:0042FAA2 pop ebx

:0042FAA3 sub eax, ebx……………………………………………Sottrae il valore della tavola da eax il valorerimanente è shiftato con cla word con i due

:0042FAA5 shr eax, cl

:0042FAA7 mov ecx, dword ptr [ebp+14]

:0042FAAA add eax, dword ptr [ecx+4*edx]……………………Aggiunge ad eax un valore puntato in una tavola

:0042FAAD pop esi

:0042FAAE pop ebx

:0042FAAF pop ebp

:0042FAB0 ret

Come possiamo vedere nella 2a parte della routine il valore dei due bytes sono pesantemente influenzati dai valori ecx e edx. Quindi il valore "pescato" dalla tavola in funzione del range dei byte manipolati del seriale, è fondamentale.

Al ritorno della call ci troveremo in:

:0042F516 add esp, 00000010:0042F519 mov ebx, eax…………………………………………Mette il valore del risultato della routine precedente in ebx

:0042F51B jmp 0042F536…………………………………………Salta a…

:0042F51D push 00451BB0

:0042F522 push 00451B8C

:0042F527 push 00000004

:0042F529 mov eax, dword ptr [edi]

:0042F52B push eax

:0042F52C call 0042FA4C

:0042F531 add esp, 00000010

:0042F534 mov ebx, eax

:0042F536 cmp dword ptr [00468C54], 00000000

:0042F53D je 0042F6A3

:0042F543 test ebx, ebx

:0042F545 jne 0042F554

:0042F547 cmp dword ptr [edi], 00000FFF

:0042F54D jbe 0042F554

:0042F54F mov ebx, 00000100

:0042F554 dec ebx……………………………………………………………Sottrae 1 a ebx (ebx= risultato scorsa routine)

:0042F555 cmp ebx, FFFFFFFF

:0042F558 jne 0042F6C6.

 

:0042F6C6 add dword ptr [ebp+00], ebx…………………Scrive all’indirizzo puntato da ebp il valore del risultato che è in ebx. La dword risultante…….

:0042F6C9 mov eax, dword ptr [ebp+00]……………………viene spostata in eax

:0042F6CC shr eax, 08………………………………………………………………Dopo lo shift a destra di eax, ah passa i al

:0042F6CF sub dword ptr [ebp+00], eax……………………che viene sottratto alla dword in ebp

:0042F6D2 add dword ptr [00468C58], 00000010

:0042F6D9 cmp dword ptr [00468C58], 000000FF

:0042F6E3 jbe 0042F6F5

:0042F6E5 mov dword ptr [00468C58], 00000090

:0042F6EF shr dword ptr [00468C5C], 1

:0042F6F5 mov eax, dword ptr [4*ebx+0046603C]…In eax viene caricato il valore puntato da .tavola

:0042F6FC mov edx, dword ptr [004602A8]……………Carica in edx la dword puntata ( è l’indirizzo .memoria dove verrano scritti i risultati finali di tutte le manipolazioni

:0042F702 mov ecx, dword ptr [004602AC]

:0042F708 lea esi, dword ptr [4*ebx+0046603C]

:0042F70F shr eax, 08………………………………………………………………Il valore della tavola messo in eax viene.shiftato. Il risultato è in al ed è quello.finale che verrà confrontato con il nick…

:0042F712 mov byte ptr [edx+ecx], al………………………Il risultato in al è messo nella locazione puntata

:0042F715 inc dword ptr [004602AC]

:0042F71B dec dword ptr [0045890C]

Nell’esecuzione di questa routine potrete accorgervi che il byte finale che trovate in al all’offset 42F712 è in pratica lo stesso che è in ebx all’offset 42F554.

Dopo aver eseguito alcune istruzioni il programma ritorna all’offset 42F44B per ripetere tutto il ciclo di calcolo (come gia detto sono 5 in tutto) per un ulteriore byte finale da confrontare.

Bene…… (siamo arrivati finalmente alla routine finale) dopo un po’ di step vi ritrovate in questa porzione di codice:

:004436B6 mov bl, byte ptr [eax]…………………………Mette il bl il 1° byte del nick

:004436B8 cmp bl, byte ptr [edx……………………………Lo confronta con quello puntato da edx

:004436BA jne 004436C0……………………………………………………Salta se sbagliato…… se giusto continua

:004436BC inc eax…………………………………………………………………Sposta il puntatore al prossimo byte

:004436BD inc edx…………………………………………………………………Sposta il puntatore al prossimo byte

:004436BE jmp 004436CB

:004436C0 movzx eax, byte ptr [eax]

:004436C3 movzx edx, byte ptr [edx]

:004436C6 sub eax, edx

:004436C8 pop ebx

:004436C9 pop ebp

:004436CA ret

:004436CB mov ebx, ecx………………………………………………………In ecx il contatore delle iterazioni

:004436CD add ecx, FFFFFFFF…………………………………………Sottrai 1 da ecx

:004436D0 test ebx, ebx……………………………………………………Verifica se ha finito le iterazioni:

:004436D2 jne :004436B6………………………………………………………Se no riprende…… se ha finito…

:004436D4 movzx eax, byte ptr [eax-01]……………Mette in eax l’ultimo byte verificato

:004436D8 movzx edx, byte ptr [edx-01]……………Mette in edx l’ultimo byte verificato

:004436DC sub eax, edx………………………………………………………Sottrai edx da eax… se sono uguali eax vale 0

:004436DE pop ebx

:004436DF pop ebp

:004436E0 ret

dopo il ret ci troviamo:

:00427551 add esp, 0000000C

:00427554 test eax, eax………………………………………………………Verifica se eax e uguale a 0

:00427556 sete al………………………………………………………………………Se al = 0 allora setta il flag zero a 1

Siamo all’epilogo…..quindi il programma si registra dopo che i confronti hanno permesso una sottrazione con un risultato in eax = 0 e quindi il parametro passato al ritorno della call è 0. Se non viene soddisfatta questa condizione l’istruzione "sete al" fallisce ed il proggy vi sbatte fuori.

Bèh visto che reversare il proggy è un’impresa ardua a causa delle numerose variabili che influenzano i valori "pescati dalle tavole" e ci potrebbe venire in aiuto uno stratagemma matematico fatto di formule relative all’ellisse che io non ricordo e non ho voglia di ristudiare, non ci resta che ingannare il programma facendogli credere che i codici inseriti inizialmente siano quelli corretti…procedete cosi:

cambiate l’istruzione :00427554 85C0 test eax,eax in :00427554 33C0 xor eax,eax……azzerando eax il flag alla prossima istruzione sarà settato a 1 ed il programma vi ringrazierà e si registrerà. Un’ultima cosa… verrà creato infine un file Winrar.ini dove verranno immagazzinati il vostro nick e seriale credendoli corretti. Ovviamente rendete la modifica permanente modificando il byte 85 in 33, intervenendo sul file exe con un editor esadecimale. 

                  Ciauzzzzzzzzzz                                                     

Ragazzi che roba……non credevo che scrivere un tutorial fosse cosi lungo e difficile, questo mi porta ad apprezzare ancor di + le fatiche altrui…..Mi spiace se a volte posso non esssere stato chiaro o magari non esauriente nelle spiegazioni, questo è il meglio delle mie conoscenze di "Absolutely Newbies"…. bene vorrei ringraziare innanzitutto il nostro Que e TinMan per l’impegno che dimostrano nel portare avanti la UIC, poi vorrei salutare i miei compagni di ventura: Il Bieco, Il Socio e Kriosman, tutti i ragazzi della UIC e del canale Crack-it. Infine uno Special Thanks và a Yado per la sua disponibilità ed i suoi crack-me molto istruttivi che x me sono stati "unamanosanta". Byez

Vorrei ricordare che il software va comprato e  non rubato, dovete registrare il vostro prodotto dopo il periodo di valutazione. Non mi ritengo responsabile per eventuali danni causati al vostro computer determinati dall'uso improprio di questo tutorial. Questo documento è stato scritto per invogliare il consumatore a registrare legalmente i propri programmi, e non a fargli fare uso dei tantissimi file crack presenti in rete, infatti tale documento aiuta a comprendere lo sforzo immane che ogni singolo programmatore ha dovuto portare avanti per fornire ai rispettivi consumatori i migliori prodotti possibili.

Noi reversiamo al solo scopo informativo e di miglioramento del linguaggio Assembly.

Capitoooooooo????? Bhè credo di si ;))))