Il cracking � troppo facile? Allora troviamoci il seriale.... ma � facile anche quello :-)

Internet Cost Pro  1.4
Troviamo un seriale valido
Written by AndreaGeddon

Avevo crackato in memoria il prog per accettare qualsiasi serial, ma poi non riuscivo a tornare unregistered! Grazie ad XBug che mi ha detto che bastava cancellare il file in c:\windows\systwm\icpn.log.  Comunque, visto che il cracking si riduce alla modifica di un solo byte, troviamoci pure il serial, tanto per reversare un p�.

-  SoftIce

http://members.xoom.com/TheCyberTeam/

Nome+Cognome+Serial number di otto cifre, divise in xxxx-xxxx

Quando avviate il programma vi appare il solito nag che vi dice di registrarvi. Andate su register e vi troverete il dialog con i tre edit box. L'edit box corrispondente al seriale � gi� diviso per accettare un seriale di 4+4 cifre. Grazie ai programmatori per averci risparmiato un p� di tempo. Iniziamo. Settiamo un bpx getwindowtexta, inseriamo i dati (nel mio caso:  AndreaGeddon      superman     11665577). Premete register e vi ritroverete in getwindowtexta. Uhhmmmm..... c'� qualcosa che puzza e non sono io... diamo un'occhiata ai registri. In EAX abbiamo il valore 11, che dovrebbe corrispondere ai caratteri letti. 11hex = 17dec. Non c'� niente da 17 caratteri. Inoltre se cerchiamo in memoria il nome, cognome o serial messo, li troviamo tutti e tre, nonstante sia stata eseguita una sola getwindowtexta. Allora siamo in un punto del codice che non ci interessa. Leviamo getwindowtexta e settiamo unn bpx su hmemcpy, cos� andiamo sul sicuro. Tanto per cominciare, adesso ci troveremo 3 brak, uno per ogni edit box. Okay. Quindi breakiamo, disabilitiamo il break, ed iniziamo. Appena breakato ci troviamo in KERNEL. Dobbiamo tornare al processo di ICPro. Premete F12 sette volte e arriverete nel processo del programma. Steppate eseguendo tutti i RET, fino ad arrivare alla linea 00486333. Da qui iniziate a steppare, passerete alcune call, fino ad arrivare alla linea 00486393. Qui c'� un jump appena dopo un test eax, eax ed una call. Questo jump salta e ci porta alla linea 0048641C, subito dopo viene eseguita la call che fi spara il messaggio di errore (00486421). Bene. Se provate a modificare il jump alla linea 00486393 noppandolo, il programma si registrer� anche col serial sbagliato. Ma questo non ci iteressa. Vogliamo trovarci un serial valido. Allora che fare? Semplice, il jump che abbiamo menzionato faceva parte del codice:

:0048638C  call 0048607C     chiama una routine

:00486391  test al, al       controlla al

:00486393  je 0048641C       salta se � zero

La call restituisce in al un valore booleano per determinare il salto che ci proter� all'errore. Alora vediamo che succede nella call.

:0048607C   push ebx          salva ebx

:0048607D   mov ebx, eax      \__ molto utile!

:0048607F   mov eax, ebx      /

:00486081   call 00485FAC     chiama un'altra routine

:00486086   cmp eax, dword ptr [ebx+00000204]   compare del serial inserito e di quello giusto

:0048608C   sete al           se sono uguali i serial, setta al a 01

:0048608F   pop ebx           richiama ebx

:00486090   ret               torna a casa

all'inizio della routine, date un occhiata ai registri. Cosa troviamo in edx? il valore 15C9. Cos'�? E' il corrispondente esadecimale delle seconde 4 cifre del mio serial (5577). Poi viene eseguita una call. Dopo la call c'� un compare: in eax c'� un numeretto, 1536, ed in [ebx+204| c'� 15C9. Ma guarda, stai a vedere che 1536 � il numero giusto! E' il corrispondente hex di 5430 dec. Uscite, inserite nome e cognome uguali, mettete nel serial xxxx-5430 e sarete registrati. Che cagata! Contano solo le seconde 4 cifre del seriale. Vabb�, adesso unregistratevi e tornate al punto dove eravamo col sice, perch� andremo a vedere come viene generato il seriale (cio�, il mezzo seriale). E' evidente che il seriale viene generato nella   CALL 00485FAC. Entriamo:

:00485FAC   push esi           vari push

:00485FB2   mov al, byte ptr [esi+04]    mette in al la lunghezza del nome

:00485FB5   mov byte ptr [esp], al       lo salva in [esp|

:00485FB8   cmp byte ptr [esp], 2D       controlla che sia minore di 2D

:00485FBC   jbe 00485FC2                  se lo �, salta

:00485FBE   mov byte ptr [esp], 2D       se non lo �, salva la lunghezza come 2D

:00485FC2   mov al, byte ptr [esi+00000104]  mette in al la lunghezza del cognome

:00485FC8   mov byte ptr [esp+01], al        lo salva in [esp+1|

:00485FCC   cmp byte ptr [esp+01], 2D        controlla che sia minore di 2D

:00485FD1   jbe 00485FD8                      se lo �, salta

:00485FD3   mov [esp+01], 2D                  se nonn lo �, considera la lunghezza come 2D

:00485FD8   xor edi, edi                  azzeriamo edi

:00485FDA   mov al, byte ptr [esp]       mette in al la lunghezza del nome

:00485FDD   test al, al                    controlla al

:00485FDF   jbe 00485FF3                  se � zero salta.

:00485FE1   mov dl, 01                    metti 01 in dl

primo ciclo----------------------------------------------------------------

:00485FE3   xor ecx, ecx                  azzera pure ecx

:00485FE5   mov cl, dl                    muovi il contatore in ecx

:00485FE7   movzx ecx, byte ptr [esi+ecx+04]  metti in ecx l'n-esimo carattere del nome

:00485FEC   add edi, ecx                  aggiungilo a edi (conterr� la somma totale)

:00485FEE   inc edx                       incrementa il contatore

:00485FEF   dec al                        decrementa l'altro contatore

:00485FF1   jne 00485FE3                  ripeti per tutte le lettere del nome

:00485FF3   mov eax, edi                  metti la somma totale in eax

:00485FF5   mov ecx, 00000063             usiamo 63 come divisore

:00485FFA   cdq                           azzera edx

:00485FFB   idiv ecx                      somma totale / 63

:00485FFD   mov edi, edx                  metti il resto della divisione in edi

:00485FFF   xor ebp, ebp                  azzera ebp

:00486001   mov al, byte ptr [esp+01]    metti in al la lunnghezza del cognome

:00486005   test al, al                   controllala...

:00486007   jbe 0048601E                  ...e salta se � zero

:00486009   mov dl, 01                    metti 01 nel contatore

secondo ciclo-------------------------------------------------------------------

:0048600B   xor ecx, ecx                  azzera ecx

:0048600D   mov cl, dl                    metti il contatore in ecx

:0048600F   movzx ecx, byte ptr [esi+ecx+00000104] metti in ecx l'n-esimo carattere del cognome

:00486017   add ebp, ecx                  sommalo a ebp (conterr� la somma totale)

:00486019   inc edx                       icrementa il contatore

:0048601A   dec al                        decrementa la lunghezza del cognome

:0048601C   jne 0048600B                  ripeti per ogni lettera del cognome

:0048601E   mov eax, ebp                  metti la somma totale in eax

:00486020   mov ecx, 00000063             muovi il divisore 63 in ecx

:00486025   cdq                           azzera edx

:00486026   idiv ecx                      somma totale / 63

:00486028   mov ebp, edx                  metti il resto in ebp

                               adesso abbiamo in edi e ebp i resti delle due divisioni

:0048602A   xor eax, eax                  azzera eax

:0048602C   mov al, byte ptr [esp]       metti in al la lunghezza del nome

:0048602F   imul eax, 00000064            moltiplicala per 64

:00486032   add eax, edi                  eax = primo resto + eax

:00486034   xor edx, edx                  azzera edx

:00486036   mov dl, byte ptr [esp+01]    metti in dl la lunghezza del cognome

:0048603A   imul edx, 00000064            moltiplicala per 64

:0048603D   add ebp, edx                  ebp = secondo resto + ebp

:0048603F   add eax, ebp                  eax = (primo resto + eax) + (secondo resto + ebp)

:00486041   cmp eax, 00000CB8             controlla se questa somma � minore si CB8

:00486046   jle 0048604F                  se lo � salta....

:00486048   sub eax, 00000CB8             se non lo �, sottraigli CB8

:0048604F   add eax, 00000CB8             .... e aggiungili CB8

:00486054   cmp eax, 0000000A             controlla che eax sia maggiore di 0A

:00486057   jge 00486061                  se lo � salta

:00486059   imul eax, 000003E8            se non lo �, moltiplicalo per 3E8

:00486061   cmp eax, 00000064             controlla che sia maggiore di 64

:00486064   jge 0048606B                  se lo �, salta

:00486066   imul eax, 00000064            se non lo �, moltiplicalo per 64

:0048606B   cmp eax, 000003E8             controlla se � maggiore di 3E8

:00486070   jge 00486077                  salta se lo �

:00486072   add eax, eax                  raddoppialo

:00486074   lea eax, dword ptr [eax+4*eax] carica in eax il puntatore a eax+4*eax

fine dei calcoli

:00486077 pop edx          arrivati qui, in eax c'� il valore hex del serial giusto

:0048607B   ret

Tutto chiaro, no? Ricapitoliamo.

Prende tutti i caratteri del nome, e li somma. Ottiene una Somma_Nome.

Prende il resto della divisione Somma_Nome/63, lo chiamiamo Resto1

Prende tutti i caratteri del cognome e li somma. Ottiene Somma_Cognome

Prende il resto della divisione Somma_Cognome/63, lo chiamiamo Resto2

Moltiplica la Lunghezza_Nome per 64.

Somma il Resto1 a 64*Lunghezza_Nome   (ottiene Val1)

Moltiplica la Lunghezza_Cognome per 64

Somma il Resto2 a 64*LunghezzaCognome (ottiene Val2)

Somma Val1 e Val2

Dopo controlla solo alcune condizioni, cio�:

se (Val1+Val2) > CB8 allora sottraigli CB8, se � minore o uguale aggiungigli CB8

se (Val1+Val2) <= 0A allora moltiplicalo per 3E8

se (Val1+Val2) < 64 allora moltiplicalo per 64

se (Val1+Val2) < 3E8 allora raddoppialo

E qui finiscono tutti i calcoli. Adesso sappiamo come viee generato un seriale valido per questo stupido programma e le sue odiose dissolvenze (che tral'altro manco funzionano).

AndreaGeddon

Saluto tutti gli amici della mailing list. Saluto Fruity404 che mi aveva segnalato il prog. Ciauz  a  tutti.

Queste informazioni sono solo a scopo puramente didattico.

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

Home   Anonimato   Assembly    CrackMe   ContactMe   Forum   Iscrizione

Lezioni    Links   Linux   NewBies   News   Playstation

Tools   Tutorial   Search   UIC Faq

UIC