Cerchiamo di capire come viene generato il codice di sblocco. Questo � il mio primo tut per cui in bocca al lupo!!! (per me che scrivo e per voi che leggete).

ADVANCED ENAMAGIC 2.0
Troviamo il seriale
Written by Tomlawer

Sono un appassionato di sistemistica ragion per cui sono sempre alla ricerca di programmi di tal genere (shareware ovviamente) cos� unisco l'utile al dilettevole. Quale poi sia l'utile o il dilettevole non lo so neanche io :)))

SoftIce

http://magisoft.hypermart.net

Il programma in questione � uno di quelli per il condizionamento e/o la riduzione di sistemi superenalotto. La versione shareware ha alcune limitazioni tra cui quella di non poter aggiornare l'archivio e stampare pi� di un certo numero di colonne. Ma noi vogliamo stamparle tutte le colonne, verooooo? E allora let's go!!!!

Lanciamo il programma, premiamo help e poi sblocco. A questo punto compare il form per la registrazione.
Ci viene chiesto di inserire il nostro nome e cognome e poi il codice di sblocco. Piccolo preambolo: per quanto riguarda il nome occore che questo contenga almeno uno spazio (il motivo ve lo spieger� dopo). Quindi se volete usare il vostro nome e cognome (Mario Rossi), no problem perch� siete obbligati a mettere uno spazio, se invece volete usare il vostro nick (il mio � Tomlawer) allora potrete scriverlo anche cos�: T o m l a w e r. (fine preambolo). Adesso, dopo aver inserito T o m l a w e r, passiamo al serial number (da ora in poi sn). Per prima cosa vediamo se il programma prevede un limite per il sn. No, pu� essere lungo quanto vogliamo. Allora inseriamo 123456. Adesso scomodiamo pure il nostro Softice e settiamp un bpx hmemcpy e premiamo "sblocco". Softice � entrato in azione!!! Steppiamo con F12 fino a quando non saremo arrivati nel codice del programma e precisamente qui:

 

:0048AEAF               mov eax, dword ptr [ebp+FFFFB844]     

Qualche istruzione pi� sotto troviamo gi� qualcosa di interessante:

:0048AEE6               cmp bl, 0E      confronta la lunghezza del sn con 0E cio� 14

:0048AEE9               je 0048AEF7      se non � 14 cifre

:0048AEF0               call 00406FC4      "codice errato"

Allora inseriamo un sn di 14 cifre 12345678901234, ripetiamo la procedura di cui sopra e come possiamo vedere il je 0048AEF7 avviene con successo. Proseguiamo quindi con l'analaisi del codice per arrivare, alcune righe pi� gi�, ad un loop il quale non fa altro che prendere uno alla volta i caratteri (compresi gli spazi) del nostro nome e sommarli tra di loro. Il totale verr� poi usato successivamente per calcolare alcune cifre del sn.

:0048AF09               xor ecx, ecx      (INIZIO LOOP)

:0048AF0B               mov cl, al     

:0048AF0D               mov esi, dword ptr [ebp-0C]     

:0048AF10               movzx ecx, byte ptr [esi+ecx-01]      muove uno alla volta in ecx i caratteri del nome compresi gli spazi

:0048AF15               add di, cx      e li somma ad edi

:0048AF18               inc eax     

:0048AF19               dec dl     

:0048AF1B               jne 0048AF09      e salta fino a quando non ha preso tutti i caratteri (FINE LOOP)

Alla fine in edi avremo la somma totale di tutti i caratteri del nome che nel mio caso � 42B cio� 1067. Questo valore, come gi� detto, verr� usato per il calcolo del sn. A questo punto ha inizio il calcolo del sn:

:0048AF33               mov dl, byte ptr [edx+0C]      mette in dl la penultima cifra del sn ("3")

:0048AF36               mov byte ptr [eax+01], dl     

:0048AF39               mov byte ptr [eax], 01     

:0048AF3C               lea edx, dword ptr [ebp+FFFFB840]     

:0048AF42               lea eax, dword ptr [ebp+FFFFB83C]     

:0048AF48               call 00402940     

:0048AF4D               lea eax, dword ptr [ebp+FFFFB838]     

:0048AF53               mov edx, dword ptr [ebp-08]     

:0048AF56               mov dl, byte ptr [edx+0D]      mette in dl l'ultima cifra del sn ("4")

.........               .............     

:0048AF8D               mov al, byte ptr [ebp-01]      mette in eax le ultime due cifre del sn cio� "34"

:0048AF90               xor edx, edx     

:0048AF92               mov dl, bl      mette in edx la lunghezza del nome (8 caratteri + 7 spazi = 15)

:0048AF94               sub edx, 00000002      sottrae 2 a edx (15-2=13)

:0048AF97               cmp eax, edx      confronta eax ("34") con edx ("13")

:0048AF99               je 0048AFA5      se sono uguali salta, altrimenti

:0048AF9B               mov eax, 0048B6CC     

:0048AFA0               call 00406FC4      "codice errato"

Quindi affinch� il je 0048AFA5 venga eseguito occorre che le ultime due cifre del sn siano uguali al numero dei caratteri del nome meno 2 e cio�, nel nostro caso, a "13". Pertanto mettiamo un bpx su je 0048AFA5 usciamo e rinseriamo i dati e il sn "12345678901213" premiamo "sblocco" e come possiamo vedere il salto viene eseguito. Proseguendo lo step arriviamo alla routine che calcola la prima cifra del sn:

:0048AFA5               movzx eax, di      muove edi in eax (ricordate? In edi c'� 42B cio� 1067 ossia la somma dei valori esadecimali dei singoli caratteri del nome comprensiva degli spazi generata dal loop di cui sopra).

:0048AFA8               mov ecx, 00000009      mette 9 in ecx

:0048AFAD               cdq      si prepara alla divisione

:0048AFAE               idiv ecx      divide eax con ecx, il risultato esadecimale("76") lo mette in eax ed il resto esadecimale ("5") in edx.

A questo punto continuiamo a steppare e dopo 2-3 righe troviamo

:0048AFE0               pop eax     

:0048AFE1               call 00403BB4      all'uscita da questa call se il primo numero del sn � esatto

:0048AFE6               je 0048AFF2      avviene il salto e si prosegue nel check del sn, altrimenti...

:0048AFE8               mov eax, 0048B6CC     

:0048AFED               call 00406FC4      siamo dei cattivi ragazzi

Pertanto � necessario entrare nella call 00403BB4 per vedere cosa bisogna fare per far si che all'uscita avvenga il salto. Quindi in Sice premiamo F8 appena siamo sulla call e analizziamone il codice. Se ben notate quasi alla fine possiamo osservare un compare sospetto:

:00403C09               mov ecx, dword ptr [esi]     

:00403C0B               mov ebx, dword ptr [edi]     

:00403C0D               cmp cl, bl      dopo una serie di spostamenti in cl troviamo "5" e in bl "1". Qui viene fatto il compare tra "5" (il resto della divisione di cui sopra) e "1" cio� il primo numero del nostro sn.

:00403C0F               jne 00403C52      se � "5" allora all'uscita avverr� il salto altrimenti no.

Vi voglio anticipare che ogni successico check sul sn fa capo al cmp cl, bl di cui sopra ad eccezione del 12� numero. Inoltre, ad eccezione del 2�, 7� e 12� numero, il sn giusto viene dato dal resto di una divisione analoga a quella che abbiamo analizzato poc'anzi. Andiamo avanti e vediamo come viene calcolato il 2� valore del sn. Subito dopo il jne 00403C52 troviamo

:0048AFF2               mov eax, esi      mette in eax il gi� noto 42B

:0048AFF4               and eax, 80000007      42B and 800000007 = "3"

:0048AFF9               jns 0048B000     

Il "3" � il secondo valore che deve avere il sn. Infatti appena qualche istruzione pi� sotto cosa abbiamo?

:0048B031               pop eax     

:0048AFF9               call 00403BB4     

:0048AFF9               je 0048B053     

cio� la stessa routine di controllo che abbiamo visto per il check sul primo valore del sn. Al suo interno troveremo, ovviamente

:00403C09               mov ecx, dword ptr [esi]     

:00403C0B               mov ebx, dword ptr [edi]     

:00403C0D               cmp cl, bl      confronta cl (il risultato dell'operazione and) cio� "3" con "2" (il valore da noi inserito)

:00403C0F               jne 00403C52     

Come gi� detto i primi undici valori del sn vengono confrontati all'interno della call 00403BB4 dall'istruzione cmp cl, bl. Quindi basterebbe mettere un bpx su questa istruzione per trovarli tutti. Per� cos� facendo non riusciremmo a capire come vengono calcolati. Pertanto continuiamo ad analizzare il codice. Allora, sappiamo che i primi due valori del sn per il nome T o m l a w e r devono essere "5" e "3" mentre gli ultimi due "1" e "3". Quindi inseriamo il sn 53

345678901213 e continuiamo con l'analisi del codice. Il terzo valore del sn � dato da questa parte di codice che si trova dopo il salto all'uscita della call 00403BB4

:0048B053               mov eax, dword ptr [ebp-0C]      mette il nostro nome in eax

:0048B056               movzx eax, byte ptr [eax+02]      muove il 3�carattere del nome, "o", in eax

:0048B05A               mov ecx, 00000009      muove 9 in ecx

:0048B05F               cdq     

:0048B060               idiv ecx      divide il valore hex di "o"(cio� 6f) per 9, il risultato viene messo in eax, il resto "3" in edx

Abbiamo appena trovato il 3�valore del sn. Adesso calcoliamoci il 4�. La routine di calcolo di quest'ultimo � identica alla precedente ad eccezione del fatto che il valore esadecimale della lettera "o"anzich� venir diviso per "9" viene diviso per "7" per cui avremo come resto"6"

(4�valore del sn). Infatti "6f"(che in decimale � "111") : 7 =15 con resto "6". Quindi sappiamo che le prime quattro cifre devono essere "5336" mentre le ultime due "13". Di seguito troviamo la parte di codice adibita al calcolo del 5� valore del sn:

:0048B118               movzx eax, byte ptr [eax]      muove il primo carattere del nome ("T") in eax

:0048B11B               mov ecx, 00000006      mette 6 in ecx

:0048B120               cdq     

:0048B121               idiv ecx      divide eax (cio� "T" ossia 54 dec) con 6, il risultato lo mette in eax e il resto ("0") (5� valore del sn) in ecx

Il 6� valore del sn viene generato alcune righe pi� gi� in maniera analoga al precednte. L'unica differenza sta nel fatto che ad essere diviso per 6 � il valore esadecimale dell'ultima lettera del nome da noi inserito per cui avremo 114 (valore decimale di "r"):6=19 con resto "0"

(6� valore del sn). Il 7� valore viene invece calcolato nel seguente modo:

:0048B1E7               mov eax, dword ptr [ebp-0C]      mette il nome in eax

:0048B1EA               movzx eax, byte ptr [eax+01]      prende il secondo carattere del nome(cio� lo spazio che in hex � 20)

:0048B1EE               and eax, 80000007      20 and 80000007=0 (ecco il 7� valore del sn)

:0048B1F3               jns 0048B1FA     

Per calcolare l'8� valore, invece, lo spazio (32 in decimale) viene diviso per 7 per cui 32:7=4 con resto"4". Tutto questo viene effettuato dalla seguente parte di codice:

:0048B24D                mov eax, dword ptr [ebp-0C]     

:0048B250               movzx eax, byte ptr [eax+01]     

:0048B254               mov ecx, 00000007     

:0048B259               cdq     

:0048B25A               idiv ecx

Come vedete � identica alla precedente eccezion fatta per l'operazione. E' opportuno ribadire che ogni routine di calcolo del sn termina sempre con la famosa call 00403BB4 che controlla se il resto della divisione o il risultato dell'and corrisponde al valore da noi inserito o meno. A questo punto consciamo le prime otto cifre del sn e cio�"53360004" e le ultime due "13". Passiamo adesso a calcolarci il 9� valore del sn (ultimo sforzo � quasi finita!!!!):

:0048B2AF              mov eax, esi      muove il gi� noto 42B (1067) in eax

:0048B2B1              inc eax      incrementa eax (42B+1=42C cio� 1068)

:0048B2B2              mov ecx, 00000006      muove 6 in ecx

:0048B2B7              cdq     

:0048B2B8              idiv ecx      divide eax con 6 (1068:6=178 resto "0")

Una volta inserito"0"come 9� valore del sn all'uscita dalla famosa call 00403BB4 il jne viene eseguito. Subito dopo troviamo un jmp che ci porta nel punto dove verr� calcolato il 10� valore del nostro sn e precisamente qui:

:0048B316              mov ecx, dword ptr [ebp-0C]      mette il nome in ecx

:0048B319              mov dl, byte ptr [ecx+edx-01]      mette il primo char del nome("T") in dl

:0048B31D              cmp dl, 20      confronta "T" con 20 (cio� spazio)

:0048B320              jne 0048B301      se sono uguali non salta e continua nel calcolo del sn altrimenti ricomincia da capo con il 2� char e continua fino a che non trova uno sapzio

Questa parte di codice non fa altro che prendere uno alla volta i caratteri del nome e confrontarli con "spazio" e fino a quando non lo trova il programma non proceder� al calcolo del 10� valore del sn. Ecco perch� all'inizio di questo tutorial ho detto che era necessario che il nome contenesse almeno uno spazio altrimenti se avessimo inserito, ad es., "Tomlawer" ci saremmo dovuti fermare al check sul 10� valore del sn e non avremmo potuto proseguire nel reversaggio del programma se non invertendo o noppando il jne 0048B301. Ma noi vogliamo trovare il seriale del programma non crakkarlo!!!

:0048B322              movzx eax, di      mette in eax il carattere che precede il primo spazio(nel nostro caso "T") in parole povere se noi avessimo inserito come nome Mario Rossi quest'istruzione avrebbe messo in eax la "o" di Mario proprio perch� � questa la lettera presa per ultima dal loop che confronta i char del nome con lo spazio. Dato che noi abbiamo inserito T o m l a w e r il loop si � fermato alla "T" proprio perch� subito dopo gi� c'� lo spazio. :0048B325              mov ecx, 00000009      mette 9 in ecx

:0048B32A              cdq     

:0048B32B              idiv ecx      divide ecx ("T" che in dec � 84):9=9 resto "3" (10� valore del sn)

Se il 10� valore del sn � esatto il programma passer� a calcolare l'11� nel seguente modo:

:0048B377              mov dl, byte ptr [edx]      muove il primo numero del sn ("5") in dl

:........              ........     

:0048B384              call 00406FC4      poi viene messo in eax

:0048B389              mov edi, eax      e quindi in edi

:........              ........     

:0048B394              mov dl, byte ptr [edx+01]      muove il secondo numero del sn ("3") in dl

:0048B397              call 004039CC      e lo mette in eax

:........              ........     

:0048B3A7              add di, ax      somma edi con eax (5+3=8) e il risultato viene messo in edi

:........              ........     

:0048B3B3              mov dl, byte ptr [edx+02]      muove il terzo valore del sn ("3") in dl

:........              ........     

:0048B3C1              call 00406FC4      e viene messo in eax

:0048B3C6              add di, ax      somma edi con eax (8+3=11) e il risultato viene messo in edi

:........              ........     

:0048B3D2              mov dl, byte ptr [edx+03]      muove il quaro valore del sn ("6") in dl

:........              ........     

:0048B3E0              call 00406FC4      viene messo in eax

:0048B3E5              add di, ax      e sommato ad edi (11+6=17) e mette il risultato in edi

:........              ........     

:0048B3F1              mov dl, byte ptr [edx+04]      muove il quinto valore del sn ("0") in dl

:........              ........     

:0048B3FF              call 00406FC4      viene messo in eax

:0048B404              add di, ax      e sommato a edi (17+0=17) e il risultato messo in edi

:0048B407              movzx eax, di      e poi in eax

:0048B40A              mov ecx, 00000009      mette 9 in ecx

:0048B40F              cdq      si prepara alla divisione

:0048B410              idiv ecx      divisione: ecx ("17"):9=1 resto "8" (11� valore del sn)

.....e finalmente siamo arrivati al check sull'ultimo valore del sn e cio� il 12� (il 13� e 14� gi� sono stati calcolati per primi, se ben ricordate). Stranamente per questo calcolo i programmatori hanno preferito usare un semplice cmp. Forse si erano rotti a farsi altre seghe mentali su come inventare l'ultima operazione che generasse l'ultima cifra del sn!!!!! Ed infatti: :0048B468              cmp byte ptr [eax+0B], 34      Confronta il 12� numero da noi inserito ("2") con 34 ossia "4" Adesso abbiamo il nostro bel codice di sblocco che per il nome T o m l a w e r  ï¿½ 53360004038413 Un'ultima cosa: i dati della registrazione sono contenuti nel file user.ini che si trova in c:\windows. Basta cancellarlo per far ritornare il programma in versione shareware.                                                                                                                  Tomlawer

Spero di essere stato chiaro, comunque se ci sono dei problemi la mia e-mail la conoscete. Per concludere vorrei salutare il mio amico Monster, sicuramente il miglior tecnico hardware sulla piazza, Mr. Morris e Papillon17 che se potesse upgraderebbe anche la ragazza!!! Un saluto particolare va a +Mad il quale mi ha insegnato moltissimo e naturalmente a tutto lo staff della UIC.

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 ;))))