Troviamo l'algoritmo e generiamoci un serial valido. Volevo crakkarlo per evitarmi la fatica di dover stepparmi tutto l'algoritmo del serial, ma visto che il programma contiene vari file eseguibili e una dll da patchare, avrei fatto prima a riscriverlo daccapo piuttosto che stare ad eliminare tutti i controlli del serial. Ho optato cos� per la ricerca del serial. Eccheccacchio... Anyway, it's reversing!

Rubiamo il seriale di MicroAngelo 2.1
Serial fishing
Written by AndreaGeddon

-  SoftIce 4.00

-  WinDasm

E' uscito sul CD di una rivista, ma non mi ricordo quale.

Un programmillo per fare icone animate e puntatori animati. Carino. Protezione classica Serial/Nome.

L'algo che ci accingiamo a sfrakkiare non � complesso. Mi ricorda molto MovGear. Per iniziare partiamo col breaking su GetDlgItemTextA. Anche questo serial � composto da una parte fissa e da una vincolata da algoritmo. Vediamo come: dopo il break arriviamo a questo codice:

:100028F4    call edi       call a getdlgitemtexta   prende il nome

:10002903    call edi       call a getdlgitemtexta   prende il serial

:10002905    cmp byte ptr [10008180], 50  confronta il primo char del serial con 50  "P"

:1000290C    jne 10002915                  se � diverso salta a errore

:10002915    cmp byte ptr [10008180], 54  confronta il primo char del serial con 54  "T"

:1000291C    jne 10002925                  se � diverso salta a errore

:10002925    cmp byte ptr [10008180], 53  confronta il primo char del serial con 53  "S"

:1000292C    jne 10002A11                  se � diverso salta a errore

Da qui si vede che il primo carattere del serial deve rientrare tra P, T ed S, altrimenti salta direttamente alla routine di errore. Quindi se non l'avevate gi� fatto, andate ad inserire il serial number con una bella P davanti per procedere avanti nello stepping. Io ho scelto la P perch� � la prima che mi sono trovato davanti, non so se le altre due vanno bene ugualmente, ma credo di si. Ora possiamo superare questo primo intoppo. Procediamo ed arriviamo a:

1000384E     call       100037E0

Entriamo nella call e steppiamo fino ad arrivare a:

......     questa parte viene saltata sempre

                          ebx contiene il primo char del serial

:1000384E    mov ecx, dword ptr [100077A8]  mette in ecx una tabella di valori

:10003854    xor eax, eax     azzera eax

:10003856    mov ax, word ptr [ecx+2*ebx]  metti in eax il valore corrispondente al char del serial (sempre 84)

:1000385A    and eax, 00000004     84   and  04

:1000385D    test eax, eax    controlla eax

:1000385F    je 10003871      se � 0 abbiamo finito

:10003861    lea eax, dword ptr [ebp+4*ebp]  all'inizio ebp = 0

:10003865    inc esi    incrementa il puntatore al serial

:10003866    lea ebp, dword ptr [ebx+2*eax-30]  mette in ebp i risultati parziali del calcolo

:1000386A    xor ebx, ebx  azzera ebx

:1000386C    mov bl, byte ptr [esi-01] mette in bl il char seguente

:1000386F    jmp 10003838    ripeti il ciclo per ogni char

:10003871    mov eax, ebp    alla fine muovi il valore finale da ebp a eax

:1000387E    ret

Con questa routine ci ritroveremo in eax il valore finale per il serial. Lo chiamer� Valore_Serial. Continuando dopo il ret abbiamo:

:10002946    mov dword ptr [1000836C], eax  salva il Valore_Serial nella locazione 1000836C

:10002950    cdq               converte la dword in eax in una quadword usando come estensione edx

:10002951    mov ecx, 0000000A   mette A in ecx

:10002956    idiv ecx       divide eax per ecx

:10002958    mov dword ptr [1000836C], eax il risultato della divisione, contenuto in eax, viene messo alla locazione 1000836C

Quindi il Valore_Serial adesso � stato modificato. Praticamente � stato diviso per 10 decimale. E' stato nuovamente salvato nella locazione 1000836C. Ce lo dobbiamo ricordare. Dopo il codice appena descritto arriviamo a:

:1000295D    push 10008180   salva il serial

:10002968    call edi  call a lstrlenA, in eax avremo la lunghezza del serial

:1000296A    movsx eax, byte ptr [eax+1000817F] IMPORTANTE muove in eax l'ultimo char del serial

:10002971    sub eax, 00000030    gli sottrae 30 ed ottiene il valore decimale dell'ultimo numero del serial (in eax)

:10002974    push 10008310    salva il puntatore al Nome

:10002979    mov dword ptr [10008174], eax  MUOVE EAX nella locazione 10008174

:1000297E    call edi  call a lstrlenA, in eax avremo la lunghezza del nome

:10002980    cmp eax, 00000006    se la lunghezza del nome � < 6

:10002983    jle 10002A0D   salta a errore

:1000298E    call 10002070   call da spulciare

Qui prende l'ultimo char del serial, prende il suo valore decimale e poi si arriva alla call. Entriamo nella call e vediamo chesuccede:

...  dopo qualche linea arriviamo qui. Ricordate la locazione 10008174?

            Ci veniva messo il valore decimale dell'ultimo char del serial.

:1000208D   cmp dword ptr [10008174], 00000001 confronta l'ultimo char del serial con 1

:10002098  je 100020B6                        salta se � uguale

:1000209A   cmp dword ptr [10008174], 00000002  confronta l'ultimo char con 2

:100020A1  je 100020B6                        salta se � uguale

:100020A3   cmp dword ptr [10008174], 00000004  confronta l'ultimo char con 4

:100020AA  je 100020B6                        salta se � uguale

:100020AC   xor eax, eax                se siamo qui, nessuno dei precedenti compare

:100020AE   pop ebp                     � andato bene, quindi andremo al messaggio

:100020AF   pop edi                     di errore.

:100020B5   ret

Questa routine controlla che l'ultimo byte del serial inserito sia il numero 1, 2 o 4. Per Andare avanti riscrivete il serial con alla fine il numero 4 e ricominciate a steppare. Vi d� un consiglio, mettei 4, vedremo fra poco il perch�!

Se uno dei tre precedenti jump � andato a segno, arriviamo al codice:

...............    Sniiiiip    8<  8<  8<

In questa parte tagliata vengono effettuati tanti calcoli (ma tanti) che ai nostri fini non sono essenziali.

Questi calcoli trasformano il nome in un valore numerico, che poi alla fine lo troviamo in EDX

:10002181    cdq

Vi ricordate? In EDX c'e il Valore_Nome, e in 1000836C c'� il Valore_Serial che gi� conosciamo.

:1000218A    cmp edx, FFFFDCD6  Confronta EDX.

:10002190    jne 100021B7  Salta se sono diversi.

:1000219C    mov ecx, dword ptr [100082AC]   | Vi ricordate il valore 4 alla fine del serial? Qui viene controllato

:100021A2    test dword ptr [10008174], ecx  | ulteriormente e deve essere 4, non vanno bene 1 e 2

:100021AA    mov eax, 00000001  In eax viene messo 1, quindi il programma deve passare di qui

:100021AF    pop esp           se vogliamo registrarci

:100021B6    ret

Ecco, abbiamo quasi finito. Ormai � chiaro tutto. Avevamo salvato nella locazione 1000836C il Valore_Serial. Eccolo che torna. La parte che ho tagliato qui sopra dal codice, prende il nome e ci fa una serie di calcoli molto luuunghi. A noi interessa il valore che alla fine ne esce fuori, cio� quello in EDX. Alla fine viene sottratto al Valore_Nome il Valore serial. Il risultato della sottrazione deve essere uguale a FFFFDCD6. Per un dato Nome il Valore_Nome � sempre uguale. Quindi io ho messo il nome AndreaGeddon, e alla fine il Valore_Nome � 00301B77. Basta adesso risolvere la sottrazione:

00301B77  -  Valore_Serial   =  FFFFDCD6

il numero di Valore_Serial per cui l'equazione � soddisfatta sar� il nostro Valore_Serial giusto. Basta quindi esplicitare:

Valore_Serial  =  00301B77 - FFFFDCD6

ed avremo come risultato 303EA1. Bene. Vi ricordate che all'inizio il Valore_Serial veniva diviso per 0A? Quindi il valore che abbiamo trovato adesso lo dobbiamo moltiplicare per 0A, ed otteniamo: 1E2724A. Quindi il Valore_Serial giusto da ottenere � questo. Come facciamo a convertirlo nel serial da inserire? Semplice, avete riconosciuto la routine di calcolo del serial? Serve a trasformare il valore ascii del serial in valore hex. Quindi convertiamo 1E2724A in decimale ed avremo: 31617610. Questo � quello che ci serve. Vi ricordate i vincoli? La prima lettera deve essere P e l'ultima deve essere 4. Ma se cambia il numero non va pi� bene... invece no. Va bene! Infatti subito dopo la routine di calcolo del serial c'� IDIV Valore_Seria per 0A. Cos� nel Valore_Serial ci ritroviamo la parte intera della divisione, ma il resto viene ignorato. Se quindi modifichiamo il serial in

P31617614, la P viene esclua, ed il 4 viene considerato, per� nell' IDIV Valore_Serial per 0A non cambia la parte intera, ma solo il risultato. Abbiamo quindi i nostri Nome e Serial perfettamente funzionanti.

AndreaGeddon

Saluto tutti gli amici della mailing list. Ciauuuz.

Queste informazioni sono solo a scopo puramente didattico. Non mi ritengo responsabile dell'uso che ne verr� fatto.

 

UIC's page of reverse engineering, scegli dove andare:

Home   Anonimato   Assembly    CrackMe   ContactMe   Forum       
    Iscrizione   Lezioni    Links   NewBies   News   Playstation        
  Tools   Tutorial   Search   UIC Faq

UIC