Che ppalle tutte le routine e le linee di codice inutile che trovate in questo prog. Ci troveremo il seriale e pure un ovetto di pasqua! Come al solito cercheò di essere il più chiaro possibile bla bla bla

WinRar 2.50 beta 3
Che ellisse sia! (con uovo!)
Written by AndreaGeddon

E chi non conosce il winrar?

-  SoftIce

www.uic-spippolatori.com

Solito nome/serial.

Okiz, se siete riusciti a scaricare e pure ad usare quel cavolo di rk, allora vuol dire che avete già fatto metà del tute :-P. A parte gli scherzi, carino l'RK manager. Comunque, bando alle ciance e cominciamo. Lanciamo il winrar e già ci appare la scritta "Evaluation copy" sulla title bar. Andiamo subito su Options->Registration e ci verrà chiesto il nome e il seriale. Notiamo suito che non ci sono restrizioni sul tipo o numero di caratteri da  inserire. Quindi partiremo da zero. Settiamo un bpx su GetDlgItemTextA, inseriamo nome e serial (io inserisco AndreaGeddon e 112233445566), e il softice popperà. Premete F5 e il sice popperà di nuovo, in corrispondenza del secondo edit box, quindi disabilitate il bpx, premete F12 e vi ritrovate pronti allo stepping alla linea 00409D4A. Da qui partite, e finite dopo poco sulla call alla linea 00409DA9. Le due righe prima contengono un PUSH EAX e PUSH EDX, che guarda caso sono i puntatori a nome e seriale immesso! Dopo questa call c'è un JNZ, che se non salta ci manda alla messagebox di errore. E' quindi ovvio che la call sulla riga 00409DA9 è quella che decide se il seriale immesso è buono oppure no. Finora è facile. Okiz, ora entriamo nella call, e qui la cosa si fa un pò più complicata. Infatti il codice è pieno di sub-call, e voi dovrete capire quali sono le parti che vi servono e quali no. Per Comodità vi consiglio di farvi un piccolo schemino su carta della struttura delle varie call, poi steppate e man mano cancellate quelle che vedete che non servono. Alla fine, vedete che i punti importanti di codice sono i seguenti:

004273D1   XOR        edx, edx              azzera edx

004273D3   INC       ebx                    incrementa il contatore

004273D4   MOV       dl, byte ptr [eax]     mette in dl il char n-esimo del nome

004273D6   INC       eax                    punta al carattere successivo

004273D7   XOR       dword ptr [ebp-08], edx xor il char preso con il byte alla locazione ebp-08

004273DA  CMP        ebx,  dword ptr [ebp-04] ebp-04 = numero di volte da eseguire il ciclo

004273DD   JL        004273D1                ripeti se il contatore in ebx era minore di ebp-04

questo ciclo crea un valore (nel mio caso 1E) tramite il nome, valore che viene salvato alla locazione ebp-08. Segnatevi questo valore perchè ci servirà come valore di xoring più avanti nei calcoli.

004273EA   mov        eax, ebx                 rimetti il contatore ebx in eax

004273EC   mov        edx, dword ptr [ebp-10]  metti il puntatore al nome in edx

004273EF   mov        esi, edx                 mettilo pure in esi

004273F1   cmp        eax, dword ptr [ebp-04]  controlla se il contatore eax è arrivato al numero di char del nome

004273F4   lea          edx, dword ptr [ebp+eax-0000008C]    carica in edx il puntatore al char corrente

004273EB   jge          0042740C                              salta se il contatore in eax ha superato i char del nome

004273FD   mov       cl, byte ptr [edx]                       metti il char n-esimo in cl

004273FF   add       edx, 00000005                       edx punta al 5° char successivo

00427402   add        byte ptr [esi], cl               aggiungi il char in cl al char puntato da esi

00427404   add        eax, 00000005                        anche eax punta al 5° char successivo

00427407   cmp       eax, dword ptr [ebp-04]  controlla se il contatore ha raggiunto il num di char del nome

0042740A   jl           004273FD                              se non lo ha raggiunto, ripeti

0042740C   inc          ebx                     se lo ha raggiunto, incrementa il contatore ebx

0042740D    inc          [ebp-10]                                 incrementa il puntatore al nome

00427410    cmp         ebx, 0000005                         il contatore ebx è arrivato a 5?

00427413    jl            004273EA                             se no, ripeti

questo ciclo serve a modificare i primi 5 char del nome. Nel mio caso, i char "Andre" si trasformano nei byte 52, 91, 2D, 48, 2E. Questi valori saranno usati nel confronto finale, cioè verranno effettuati dei calcoli sul serial, e il risultato dovrà essere pari a quei 4 byte. Quindi anche questi teneteli a mente.

00427430    cmp       byte ptr [esi],  39             il char n-esimo del serial è un numero?

00427433     jbe         00427446                      se si, salta

00427435     xor         eax, eax                         altrimenti azzera eax

00427437    mov        al, byte ptr [esi]               metti il char in al

00427439    push         eax                               

0042743A    call          0044981C             questa non la prendo manco in considerazione

0042743F    pop         ecx

00427440    add         al, C9                              aggiunngi C9 al char

00427442    mov         byte ptr [esi], al         metti il nuovo char al suo posto nel serial

00427444    jmp          00427449                        e questa cha farà mai???

00427446    add           byte ptr [esi], D0            aggiungi D0 al char del serial

00427449     inc            ebx                                 incrementa il contatore

0042744A    inc            esi                                   punta al carattere successivo

0042744B    cmp          edi, ebx                           il calcolo è stato fatto per tutti i char?

0042744D     jg            00427430                       se no, ripeti

questa routine in realtà non fa altro che trasformare i numeri da ascci a hex. Infatti all'inizio viene valutato se l'ascii è minore di 39. Se lo è, allora è un numero. Gli aggiunge D0 ed ottiene il corrispondente hex (es: 36 + D0 = 106 = 06). Se il numero era maggiore di 39, allora è una lettera, e gli aggiunge C9 (es: 42 + C9 = 10B = 0B). Ovviamente la routine è stata volutamente complicata, visto che questa conversione di solito si può fare in poche righe. Comunque, questa conversione ci dovrebbe far rizzare le orecchie: infatti se dal valore ascii ottiene il relativo valore hex, vuol dire che probabilmente il serial deve essere inserito con l'alfabeto del sistema esadecimale, cioè 0, 1, ..., 9, A, B, ..., F. Quindi adesso almeno abbiamo un piccolo indizio.

0042745B    mov       dl, byte ptr [eax]                metti in dl il char n-esimo

0042745D    shl          edx, 04                             spostalo a sinistra di una posizione

00427460     add        dl, byte ptr [eax+01]   aggiungigli il char successivo, così ottiene la coppia hex delle due cifre

00427463     xor         dl, byte ptr [ebp-08]   la coppia viene xorata con 1E, il valore che vi avevo detto di ricordare all'inizio

00427466    mov         ecx, ebx                           copia il contatore in ecx

00427468     sar          ecx, 1                              dividi il contatore per 2

0042746A    jns           0042746F                       se la divisione è intera, salta

0042746C    adc         ecx, 00000000                altrimenti aggiungi il carry ad ecx

0042746F    mov         byte ptr [ebp+ecx-44], dl    metti dl nella locaione 0071E850, che conterrà il serial lavorato

00427473     add          ebx, 00000002                aggiungi 2 al contatore ebx

00427476     add          eax, 00000002                 idem per eax

00427479     cmp         edi, ebx         controlla se abbiamo iterato per ogni coppia del serial

0042747B      jg            0042745B                       se no, ripeti

okiz, qui vengono presi i char due alla volta per formare una coppia (es: i byte 01 e 02 vengono uniti in 12), ed ogni coppia viene poi xorata con 1E il valore che abbiamo visto nel primo frammento di codice. Quindi otteniamo un numero di byte pari alla metà dei caratteri del serial. Questi byte vengono salvati nella locazione 0071E850. Questo calcolo ci fà pensare che il numero di caratteri del serial debba essere pari.

Fin qui tutto liscio, niente di difficile. In effetti il programma si è solo preparato per il calcolo del seriale. Finita questa routine, riprendiamo a steppare. Arriviamo alla linea:

004274FE   call     004222D0

e qui ci fermiamo un attimo. Non entriamo. Più in giù nel codice ci sono altre due call, oltre le quali c'è un SETZ AL. Se ci arriviamo steppando, vediamo che la prima di queste altre due call non ci è utile (steppare per credere). Se steppiamo la seconda ci troviamo il compare tra i primi 5 char del nome modificati (vedi sopra) e altri 5 byte. Questo è il compare che decide se il serial è giusto o no. Però qui non vengono calcolati i 5 byte, quindi anche questa call non ci è utile per trovare il seriale. Allora tornando alla call su cui ci eravamo fermati senza entrare, stavolta decidiamo di entrarci, perchè è chiaro che è lì che vengono costruiti i 5 byte per il confronto finale. Entrando ci imbatteremo ancora in un'altra call sola soletta

call   0042EB0C

ed entriamo pure qui. Ora arriviamo ad una routine piena zeppa di call e di jump. Allora, qui ci sarà un gruppetto di call iniziali, che se steppate di accorgerete essere dalla dubbia utilità, tranne una. Dalle precedenti routine, infatti, venivano lavorati i numeri del seriale per ottenere dei valori. Questi valori venivano storati nelle locazioni

0071E850  e  004602BC

se tenete d'occhio questi numeri, arrivati alla fine li troverete leggermente cambiati. Allora segnatevi i valori che vengono salvati in 0071E850 dopo lo xoring con 1E, piazzate la data window sulla locazione 004602BC e steppate sulle call con F10. Quando una di queste call vi modifica i valori, ci entrate e ripetete il procedimento. Non mi ricordo tutta la strada perchè è parecchio lunga, ma alla fine arriverete alla routine:

:0042CE8C   push ebp               |

:0042CE8D   mov ebp, esp           | nuovo stack

:0042CE91   mov edx, dword ptr [ebp+0C]  metti in edx il numero di valori ottenuti dal serial (nel mio caso 6)

:0042CE94   mov eax, dword ptr [ebp+08]  mette in eax il puntatore a tali valori

:0042CE97   mov ecx, 0045CCC9             ecx punta a 01

:0042CE9C   mov esi, 0045CCC8             esi punta a 02

:0042CEA3   mov bl, byte ptr [0045CCCA]  0045CCCA è sempre zero

:0042CEA9   add byte ptr [ecx], bl       quindi aggiunge zero a 01

:0042CEAB   mov bl, byte ptr [ecx]       prende 01 in bl

:0042CEAD   add byte ptr [esi], bl       lo aggiunge ad esi (contatore che parte da 3)

:0042CEAF   mov bl, byte ptr [esi]       metti il contatore esi in bl

:0042CEB1   sub byte ptr [eax], bl       sottrailo al valore n-esimo

:0042CEB3   inc eax                       eax punta al prossimo valore

:0042CEB4   mov ebx, edx                  metti il numero di valori in ebx

:0042CEB6   add edx, FFFFFFFF             decrementa edx

:0042CEB9   test ebx, ebx                 controlla che ebx non sia zero

:0042CEBB   jne 0042CEA3                  salta se non lo è

:0042CEC0   ret

Beh, praticamente questa routine non fa altro che prendere il primo valore e sottrargli 03, prendere il secondo e sottrargli 04, prendere il terzo e sottrargli 05, e così via. Adesso dopo questa routine abbiamo nella locazione 004602BC i valori che saranno usati in seguito.

Allora proseguiamo, ritornando alla routine che parte da  0042EB0C, jumpiamo a destra e sinistra, fino ad arrivare alla linea

0042EC0D   call     0042F43C

entriamo e ci troveremo nella routine che cercavamo. Come ho fatto a trovarla? Se vi ricordate la routine col confronto finale, lì c'erano da una parte il puntatore al nome modificato, dall'altra il puntatore ai valori calcolati tramite il serial. Questi valori si trovano alla locazione 00775948. Basta che teniate la data window su questa riga di memoria, e che vediate quando il programma ci va a mettere i valori che ritrovate anche nel confronto finale. Se steppate da fuori la call 0042F43C, vi appariranno i byte che verranno usati poi, quindi entrate nella routine. Poi è facile: all'interno della routine, steppate, e arriverete ad un altra sub-call. Se steppate la call con F10 di nuovo vi appariranno i byte finali ma incrementati di 1: infatti in quella sub-call vengono calcolati i byte, e poi dopo vengono decrementati di 1. Quindi ora abbiamo una overview generale, procediamo con l'analisi.

:0042F450   mov edi, 004602B4                 edi = puntatore "vicino" ai byte ottenuti dal serial

:0042F455   mov bl, byte ptr [edx+004602BC]  prendi in bl il byte puntato

:0042F45B   xor edx, edx                      azzera edx

:0042F45D   mov dl, byte ptr [eax+004602BD]  prendo in dl il byte successivo

:0042F468   movzx edx, dx                     estendi dx a tutto edx

:0042F46B   movzx eax, byte ptr [eax+004602BE] estendi a tutto eax il byte ancora successivo

:0042F472   shl edx, 08                       sposta il byte in edx di 1 posizione a sinistra

:0042F47B   shl ebx, 10                       sposta il byte in ebx di 2 posizioni a sinistra

:0042F47E   or ebx, edx                       |

:0042F480   or ebx, eax                        |somma il tutto ed ottiene un valore di 3 byte

:0042F482   shr ebx, cl                       spostalo a destra di cl volte (questo sarà lo SHIFTER)

:0042F484   and ebx, 0000FFFF                 tieni solo la parte bassa

:0042F48A   mov dword ptr [edi], ebx         muovi la WORD ottenuta nello spazio puntato da edi

:0042F48C   cmp dword ptr [ebp+00], 000075FF il valore in ebp+00 é minore di 000075FF?

:0042F493   jbe 0042F4B1                      se si salta

:0042F4B1   cmp dword ptr [ebp+00], 00005DFF il valore in ebp+00 é minore di 00005DFF?

:0042F4B8   jbe 0042F4D5                      se si salta

:0042F4D5   cmp dword ptr [ebp+00], 000035FF il valore in ebp+00 é minore di 000035FF?

:0042F4DC   jbe 0042F4F9                      se si salta

:0042F4F9   cmp dword ptr [ebp+00], 00000DFF il valore in ebp+00 é minore di 00000DFF?

:0042F500   jbe 0042F51D                      se si salta (praticamente finite sempre qui)

:0042F502   push 00451C04                     pusha il puntatore a una tabella BYTE (importante)

:0042F507   push 00451BE4                     pusha un altro puntatore a una tabella WORD (importante)

:0042F50C   push 00000005                     pusha il valore 5

:0042F50E   mov eax, dword ptr [edi]         metti in eax la WORD ottenuta prima

:0042F510   push eax                          pushala

:0042F511   call 0042FA4C                     chiama la prossima routine

:0042FA51   mov edx, dword ptr [ebp+0C]      metti in edx 05 (penultimo valore pushato prima della call)

:0042FA54   mov esi, dword ptr [ebp+08]      metti in esi la DWORD

:0042FA57   and esi, 0000FFF0                 azzerane l'ultima cifra

:0042FA5D   xor ebx, ebx                      azzera ebx

:0042FA5F   mov eax, dword ptr [ebp+10]      metti in eax il puntatore alla tabella di words

:0042FA64   inc edx                           incrementa il contatore (che partiva da 5)

:0042FA65   inc ebx                           incrementa il contatore ebx (partiva da zero)

:0042FA66   add eax, 00000004                 eax punta alla prossima word della tabella

:0042FA69   mov ecx, dword ptr [eax]         metti in ecx la word puntata

:0042FA6B   cmp ecx, esi                      controlla questa word della tabella con la WORD

:0042FA6D   jbe 0042FA64                      loop se è minore

:0042FA89   sub ecx, edx                      sottrai edx a ecx=10 (edx contiene il contatore che partiva da 5)

:0042FA9F   push eax                          pusha eax (word tabella)

:0042FAA0   mov eax, esi                      metti in eax la nostra WORD

:0042FAA2   pop ebx                           richiama in ebx la word tabella

:0042FAA3   sub eax, ebx                      sottrai la word tabella alla nostra WORD

:0042FAA5   shr eax, cl                       shifta il risultato di CL (cl ottenuto dalla sottrazione del contatore poco fa)

:0042FAA7   mov ecx, dword ptr [ebp+14]      metti in ecx la tabella di BYTE

:0042FAAA   add eax, dword ptr [ecx+4*edx]   aggiungi ad eax il valore puntato nella tabella BYTE

:0042FAB0   ret

e qui dovremmo aver finito le routine. Ora non ci restano che i calcoli. Prima però facciamo un pò di luce sulla nomenclatura usata:

WORD = la nostra word ottenuta dal serial

word (o word tabella) = il valore word puntato nella tabella alla locazione 00451BE4 (in realtà sono dwords)

BYTE (o BYTE tabella) = il valore byte puntato nella tabella alla locazione 00451C04

SHIFTER = il valore usato per lo shift dei 3 byte costruiti dal serial (dai quali otterrò la WORD)

okei, tutto chiaro ora. Forse. Adesso vediamo in passi in alto livello cosa fa questa routine:

- prende 3 byte ottenuti dalla lavorazione per coppie, e ci forma un terzetto di byte (ad esempio 12, 34, 56 formano la dword 00123456)

- fa uno shift di questo terzetto per il valore SHIFTER (e ne tiene la parte bassa, quindi abbiamo la nostra WORD)

- azzera l'ultima cifra della WORD (es: 3456 -> 3450)

- adesso controlla la WORD con la word della tabella, e se la word è minore, cotrolla la WORD con la prossima word, e ad ogni iterazioni incrementa i due contatori, uno che parte da zero, l'altro da 5.

- Sottrae alla WORD l'ultima word che era minore della WORD (che casino...)

- Shifta il risultato di (10 - contatore che parte da 5) volte a destra

- Al risultato di tale shift aggiunge il BYTE puntato nella tabella da (contatore che parte da 5)*4

- Decrementa di uno il tutto

ecco, con questo procedimento il programma ottiene i numeri che saranno usati nel confronto finale. Non preoccupatevi se non avete capito l'algoritmo, basterà fare qualche esempio di calcolo e vedrete che sarà tutto più chiaro. Prima però dobbiamo avere una lista delle variabili usate, quindi dovremo conoscere la tabella word e la tabella BYTE. Ricopiamoci i valori dalla memoria ed ecco la nostra sacra tabella:

bene, ora ci restano solo i calcoli. Adesso riprendo i primi 5 char del nome che il programma aveva modificato (li avete scritti, vero?), nel mio caso sono:

52, 91, 2D, 48, 2E

e partiamo dal primo: 52. Riutilizziamo al contrario la scaletta dei calcoli:

-> incrementiamo il byte:   52 -> 53

-> il byte 53 è la somma di una quantità più un'altra della tabella BYTE. Non potendo sapere a priori come era composta la somma, procediamo per tentativi:

la somma può essere 53+0. Allora il byte 53 và shiftato a sinistra per (10 -(contatore che parte da 5) ) volte, e otteniamo: 29800, quindi questo valore è sbagliato perchè dovevamo ritrovarci una word, cioè un valore massimo di FFFF.

Nota: tutti i calcoli sono in hexa, e il valore (contatore che parte da 5) non è sempre 5, ma dipende se sia stato incrementato (vedi linea 0042FA64). Fortunatamente l'algoritmo è legato, cioè se abbiamo considerato il primo caso, allora il contatore che parte da 5 vale 5, e 10 - (contatore che parte da 5) vale 0B. Questi valori ottenuti dalla sottrazione sono quelli a destra nella tabella.

-> il byte 53 può essere la somma di 4F + F. Allora dovrei avere: 4F shl A = 13C00 e anche questo non va.

-> il byte 53 può essere la somma di 27 + 2C. Allora avrei: 27 shl 9 = 4E00, e questo è valido. Ora però dovrei aggiungergli la word precedente alla riga in cui mi trovo nella tabella: noi ci troviamo alla riga

7      2C       E000      9

quindi la word che dobbiamo aggiungere è C000. Il risultato sarebbe:  10E00, che supera il valore FFFF.

-> il byte 53 può essere la somma di 17 + 3C. Allora avrei: 17 shl 8 = 1700. 1700 + E000 = F700. E anche questo non lo possiamo accettare: infatti se lo mettiamo nell'algoritmo dall'inizio, vediamo che è maggiore di F200, quindi l'algoritmo sarebbe arrivato alla 7° linea della tabella, e gli avrebbe dovuto sottrarre F200 invece di E000.

-> il byte 53 può essere la somma di 07 + 4C. Avrei: 07 shl 6 = 1C0. 1C0 + F000 = F1C0. Questo lo possiamo accettare, ma siccome avevo sbagliato i conti, non lo avevo accettato, ed ero passato al successivo. Comunque il risultato è lo stesso.

-> il byte 53 può essere la somma di 03 + 50. Avrei: 03 shl 5 = 0060. 0060 + F200 = F260. Finalmente questo valore lo possiamo accettare! Infatti se inserito nell'algoritmo coincide pienamente con tutti i passaggi. Quindi abbiamo trovato la nostra WORD esatta, cioè. F260. Ora la dobbiamo usare per calcolarci all'inverso il serial, ma adesso è facile: ora ci sono due passi elementari, quelli all'inizio, cioè uno XOR e una addizione.

-> F2 60       F5 64  xor

  + 03 04     1E   1E  =

=  F5 64.    EB 7A.

Questi due valori dovrebbero essere i primi due valori del serial esatto. Come vedremo tra poco, c'è una piccola modifica da fare. Intanto li prendiamo per buoni: se alle prime 4 cifre del serial mettiamo EB7A, vediamo che il programma ci dà come riusltato il valore 52, che era quello da cui eravamo partiti.

Ora procediamo analogamente per la prossima cifra: dopo 52 c'è il 91. Quindi rifacciamo i calcoli. Adesso vi salterò i tentativi sbagliati, visto che avete capito il funzionamento.

-> 91 + 1 = 92

-> 92 = 13 + 7F

-> 7F shl 4 = 130

-> 130 + F7E0 = F910

e qui però non possiamo più procedere come prima. Vediamo che succede: noi abbiamo i 5 valori ottenuti dal serial, supponiamo che sono 01 02 03 04 05. Alla prima iterazione, viene costruito il terzetto 010203, viene shiftato a destra di 8 e otteniamo 0102 che poi usiamo direttamente per ricavarci i primi due char del seriale. Ora però, alla seconda iterazione viene costruito il terzetto 020304, ma poi non viene shiftato di 8, ma di 5. Il che vuol dire che il valore che otterremo non sarà una immagine diretta dei caratteri del serial, ma si è aggiunto un passaggio in più, e cioè questo shift. Quindi prima di ricalcolare dovremo shiftare a sinistra di 5 volte il valore F910. Però otteniamo: 1F2200. E qui si pone il problema: essendo questo terzetto immagine del terzetto dei valori 2°, 3° e 4°, ho una discordanza: il valore 1F ed il valore 60. Infatti prima la WORD di partenza era F260, quindi ora avremmo dovuto avere 602200. Se shiftiamo F910 otteniamo 1F2200, quindi se shiftiamo 1F910, 2F910 etc... otterremo i multipli: 3F2200, 5F2200 etc. Quindi basta trovare un multiplo le cui prime due cifre si avvicinino a 60. Tale multiplo si scoprirà essere 6F2200, che si poteva pure ottenere sommando 60 a 1F (i valori discordanti). Allora, torniamo al calcolo di prima, quello che ci ha dato EB 7A, che partiva da F260. Ora invece di 60 useremo 7F. 7F + 4 = 83. 83 xor 1E = 9D. Ora procediamo calcolando i valori per 2200. A proposito, probabilmente avete notate che 7F2200 shr 5 = 3F910 invece di F910. Fa niente! Tanto la parte alta viene tagliata, ricordate?

22 00 +    27 06 xor

05 06 =   1E 1E  =

27 06       39 18

ovviamente anche queste nuove cifre del serial avranno bisogno di un ritocco nella prossima iterazione.Però intanto abbiamo sicuri i valori EB 9D.

Procediamo con il prossimo numero: 2D!

-> 2D + 1 = 2E

-> 2E =  2 + 2c

->  2 shl 9 = 400

-> 400 + C000 = C400

-> C400 shl 1 = 018800

Se vi state chiedendo perchè ora ho shiftato di 1, è perchè il programma cambia questo valore! Questo corrisponde allo SHIFTER di cui avevo già parlato. Io ho semplicemente seguito il programma ad ogni iterazione e di volta in volta li ho segnati :-P

-> un multiplo di 018800 tale che le prime due cifre si avvicinino a 22 è: 238800.  (discordanza 22 + 01)

-> 23 88 00  +       28 8E 07   xor

     05 06 07  =      1E 1E 1E   =

     28 8E 07          36  90 19

Quindi siamo arrivati a 3 cifre buone: EB 9D 36!

Andiamo avanti. Ora c'è 48.

-> 48 + 1 = 49

-> 49 = D + 3C

-> D shl 8 = D00

-> D00 + E000 = ED00

-> ED00 shl 2 = 3B400

-> discordanza 88 + 3 = 8B    quindi ho  8BB400

-> 8B B4 00  +         91  BB  08  xor

     06  07 08   =        1E  1E  1E   =

     91  BB 08            8F  A5  16

ora il nostro serial sale a EB 9D 36 8F!

Infine abbiamo l'ultimo valore: 2E.

-> 2E + 1 = 2F

-> 2F = 3 + 2C

-> 3 shl 9 = 600

->  600 + C000 = C600

-> C600 shl 2 = 31800

-> discordanza 03 + B4 == B71800

->  B7 18   00  +         BE  20  09  xor

      07  08   09  =        1E  1E  1E    =

     BE  20   09            A0   3E  17

e siamo così giunti al termine! Ecco il nostro seriale: EB 9D 36 8F A0 3E 17! Ovviamente funziona anche senza 3E e 17, essendo l'algoritmo basato su 5 valori. Finalmente! Non ce la facevo più a scrivere!

ED ORA LA PARTE PIU' INTERESSANTE: L' UOVO DI PASQUA!!!!!

Ebbene si, questo prog nasconde un easter egg. Per scoprirlo dovrete sudare settanta camice, potrebbero volerci giorni e giorni di calcoli, dovrete leggere decine e decine di tutorials, dovrete chiedere aiuto a tutti i più grandi reverser del mondo! In pratica io l'ho trovato totalmente a culo! E' successo con la versione 2.70 che mi consigliò void (ciao void!): stavo vedendo come trovare un seriale valido, ma non trovavo il dialog per l'inserimente del serial (infatti non c'era), così mentre ero nella finestrella About, ho per puro caso cliccato 2 volte col sinistro sull'icona della finestrella e.... sutpore immenso!! Un easter egg! Poi ho visto che basta un solo click col sinistro. Effettivamente, era facile scoprirlo :-P. Guarda caso per la versione di questo tutorial il trick era lo stesso :-). Okiz, adesso ho davvero concluso.

Ciauuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuz

AndreaGeddon

Saluto tuuuuuutto l'hack meeting! Un particolare saluto a Zoa che mi ha dato la sua foto!! Ora sono l'eletto! Anzi no, il vero eletto è Que che è stato baciato in bocca da Zoa, io sono l'eletto di riserva ;-) Ciauuuuuuuz.....Si ma non diffondiamo troppo queste notizie sennò le mie pulzelle si arrabiano :)))))))

Queste informazioni sono solo a scopo puramente didattico (eh già..).