In questo semplice tut vedremo come talvolta anche un programma che si presenta come demo non registrabile nasconde all'interno il form per la registrazione. Una volta reso registrabile, il tut si concentrerà sullo studio della routine per la seriale (non preoccupatevi, è molto semplice), si tratterà di fare qualche addizione, divisione, riporti e cose di questo tipo che tutti abbiamo imparato alle scuole elementari :)

Spero che a qualcuno possa risultare utile, non tanto per vincere al lotto ma per familiarizzare con le seriali!

Banco 2.5

(Da Demo non registrabile a Registrato con seriale)
Written by [aLT255]

Ok, ancora un altro programma sul lotto... eh eh, prometto che d'ora in poi li lascerò stare, se no Quequero mi picchia :))) (Hai colto nel segno :)))) NdQuequero) E' un crack per Newbies, quindi non mi tirate le arance per questo tut, se la protezione è troppo semplice, è solo per dare una mano a coloro che stanno iniziando e si avventurano da poco con Winice. Premetto che il programmatore di Banco ha utilizzato + - la stessa protezione su tutti gli altri programmi di sistemistica da lui realizzati, per cui... fate voi ;)
 

Winice 3.2x

W32dasm 8.9

HexWorkshop

Http://www.LaSchedina.com (lo trovate anche all'interno di alcune riviste di pc in edicola dentro il pacchetto Il Sistemista, non vi dico quale per non fare pubblicità :)))

Si tratta di un programma per l'elaborazione di sistemi per lotto, con funzioni di Archivio, Riduzione, Condizionamenti etc etc...

Va beh, passiamo al nostro programmetto.
Per crakkarlo possiamo seguire due strade:
a) patcharlo;
b) trovare la seriale.
Per questo tut seguirò la seconda strada...

Si parte, lanciamo il programma e vediamo che tipo di protezione ci riserva e che aspetto
ha :)
Osserviamo la barra degli strumenti... notate la voce "Codice"?
Ok, clickiamo e vediamo che ne vien fuori...

DEMO NON ATTIVABILE!!!   <---- uh???

Ma mi prendi in giro?? 
Scusate, ma... se non è attivabile, perchè ci metti il popup "Codice" nel programma? 
hmm... non so voi ma io non mi fido. 
Proviamo un attimo a disassemblarlo (io ho usato w32dasm, non è il caso di scomodare
IDA Pro per questa crack...) per vedere se sta mentendo...
Cercate la stringa DEMO NON ATTIVABILE con String Data Reference, scorrete scorrete e
voilà... che fortuna eccola lì... vediamo dove sta nel codice, clikkate e date un'occhiata
ora...

:004152B9                  test al,al
:004152BB                  jne 004152D8   <------ Questo ci permette di passare  
                                                  all'indirizzo 004152D8 dove ci sta
                                                  il form per inserire i dati di 
                                                  registrazione (se il prog fosse 
                                                  registrabile, nel nostro caso non salta)
:004152BD                  push 00000010

 

* Possible StringData Ref from Data Obj ->"DEMO NON ATTIVABILE"
                                             |
:004152BF                      push 004CC3B0

* Possible StringData Ref from Data Obj ->"Attenzione: Questo programma non "

[...]   

                                            |

* Reference To: Lotto._ChiaveFrm
                               |
:004152D8                     mov edx, dword ptr [004DCE70]  <--- l'indrizzo 004DCE70 punta al form
 

Per cui tutto quello che dobbiamo fare è prendere un editor esadecimale e cambiare il jne in je

Fatto questo facciamo ripartire il prog e vediamo che ora se premiamo su Codice ci appare il nostro bel Form di registrazione... per cui, avevo ragione, stava mentendo :)))
Ora passiamo alla parte + carina, quella della seriale, armatevi di Winice se non lo avete ancora fatto ed iniziamo...
Ci sono 4 righe... azz e quanta roba vuole??

"Inserite le 4 righe che avete ricevuto nell'esatto modo con cui le avete ricevute etc
etc "

Se se ...   ;))) NdQue

L'ultima riga è quasi sicuramente il codice seriale... ed i primi tre...?

Batman e Robin
Supereroi
Via della Giustizia,1
CODICE

Vi tornano i conti? Non ci giurerei ma potrebbe essere una cosa del genere...
Proviamo ad utilizzare solo la prima e l'ultima riga e vediamo se ci avverte che mancano 
campi da inserire...

CODICE ERRATO!

Ora provate a riempirli tutti e da lo stesso messaggio.
Per cui, riinseriamo nella prima riga il nostro nome e nell'ultima un codice fittizzio:

1^ RIGA: [aLT255]
U^ RIGA: 111333111

Prima di premere il pulsante di conferma settiamo Winice con questi BPX:

BPX GetWindowTextA
BPX GetDlgItemTextA

Proviamo...

Hmm non funzia... fa niente, non disperate a cercate quale api abbia utilizzato, provate con

BPX HmemCpy che c'è sempre nelle manipolazioni delle stringhe (ricordatevi di disattivare
gli altri)

Una volta poppato Winice, premete F12 fino a che non vi ritrovate nel codice a 32 bit (basta guardare in sice in alto a destra e se c'è scritto PROT32 allora state nel codice a 32bit ndQue),

per cui un'occhiata agli indirizzi, dovete passare dalla forma XXXX:XXXX a XXXX:XXXXXXXX ok?
Steppate con F10 e dopo un pò dovreste trovarvi ancora nei meandri di qualche api... (Kernel32)
Ancora F12 fino a tornare nel nostro codice a 32 bit e poi ancora F10, fino a trovarvi nel codice qua sotto:

Qua le cose iniziano a farsi interessanti...

:004386A7                     push ecx

:004386A8                     lea eax, dword ptr [ebp-288]     <--- ebp-288 punta al nome che abbiamo
                                                                    inserito, e viene caricato in eax

fate:
>d ebp-288 per verificare e tenete puntato sempre questo indirizzo per ora...

Continuate a steppare con F10

:004386AE                     push eax

:004386AF                     Call 004CA9C4

:004386B4                     add esp, 00000008

:004386B7                     dec [ebp-48]             

:004386BA                     lea eax, dword ptr [ebp-18]

:004386BD                     mov edx, 00000002

:004386C2                     call 004C9C24  <---------------------- da questo indirizzo viene richiamata una 
                                                                     sequenza di byte che in ASCII è:
                                                                     I12N13TE43R235NET LI25B12E23RA  
                                                                     ...cos'ho sentito?? la pass?? Naaaa ho detto
                                                                     che era semplice ma non fino a questo
                                                                     punto... (Non dire che non l'hai provata ndQue :)

:004386C7                     push 004D8D32                          

:004386CC                     lea ecx, dword ptr [ebp-288]   

:004386D2                     push ecx

:004386D3                     Call 004CA9C4 <----------------------- e qui viene sommata al nostro nome in ebp-288
                                                                     se stavate sempre puntando su questo indirizzo ve ne sarete accorti

:004386D8                     add esp, 00000008

:004386DB                     xor ebx, ebx

:004386DD                     lea eax, dword ptr [ebp-0094]   <---- prende 4 byte dall'indirizzo 0075F7EC 
                                                                                                 e li mette in eax

Per vedere cosa sta succedendo a quell'indirizzo:

>d ebp-94

dovreste avere questi bytes:

:0075F7EC | A8 00 02 88 41 0D A7 17-01 00 etc....

teneteli d'occhio mentre continuate a steppare con F10

:004386E3                      mov byte ptr [eax], 00 <---------------- mette uno zero all'indirizzo 0075F7EC
                                                                        Quindi al posto di A8 ci ritroviamo "00"

:004386E6                      inc ebx                          

:004386E7                      inc eax

:004386E8                      cmp ebx, 0000000B  <------------ e così via fino a che ebx è uguale a 0B (cioè 11)

:004386EB                      jl 004386E3

 

quindi all'indirizzo 0075F7EC abbiamo:

:0075F7EC | 00 00 00 00 00 00 00 00-00 00 etc...

 

:004386ED                     xor ebx, ebx

:004386EF                     lea esi, dword ptr [ebp-288]     <------- nostro_nome+I12N13TE43R235NET                                                                                             LI25B12E23RA viene caricato in esi... sicuramente ora ci 
                                                                                          farà qualcosa...

:004386F5                     jmp 00438728

:00438728                     mov cl, byte ptr [esi]    <-------------- carica il primo carattere, nel mio caso "["

:0043872A                     test cl, cl                      <------- e va all'indirizzo 004386F7 per seguire la
                                                                        prima routine e così via per tutti quanti fino all'ultimo. Una volta                                                                           esaminati tutti passa  alla seconda routine.
:0043872C                     jne 004386F7

Qua inizia la PRIMA ROUTINE per la seriale, per cui maggiore attenzione:

 

:004386F7                     mov eax, ebx     <--------------- ebx era 0 e porta a 0 anche eax

:004386F9                     mov edi, 0000000A                

:004386FE                     cdq      <----------------------- converte una doubleword in quadword per preparare 
                                                                una divisione con segno (Signed)

:004386FF                     idiv edi   <--------------------- divide eax per edi e mette il resto in edx

:00438701                     mov edi, edx   <----------------- il resto della divisione viene spostato in edi  

:00438703                     movsx edx, cl  <----------------- il primo carattere del 
                                                                nostro_nome+I12N13TE43R235NET LI25B12E23RA viene 
                                                                spostato in edx

:00438706                     movsx eax, byte ptr [ebp+edi-94] <-- prende un byte dall'area di memoria ebp-94  
                                                      ci somma il resto della divisione recedente (se c'era) e mette il risultato in eax
:0043870E                     add eax, edx     <----------- il nostro carattere viene aggiunto al valore di eax

:00438710                     mov ecx, 0000001A     

:00438715                     add eax, ebx <--------------- aggiunge ad eax il valore di ebx che parte da 0

:00438717                     inc ebx     <---------------- e poi viene incrementato di uno ad ogni ciclo

:00438718                     add eax, 0000000F  

:0043871B                     cdq         <---------------- coverte una double in quad

:0043871C                     idiv ecx   <----------------- divide eax per 1A (valore di ecx) e mette il resto
                                                            in edx

I resti vengono calcolati in questa maniera:

Il primo byte è per me 5B che in ASCII è "[".
A questo dovremmo aggiungere il resto della divisione di edi di prima, ma è 0 per i primi 10 cicli, aggiungere il valore di ebx, che però parte da 0, e quindi per il primo byte somma 0, poi sommare 0F, ed il valore ottenuto diviso per 1A-.
Quindi 5B+0F=6A    6A/1A=4  Ora per sapere il resto moltiplichiamo 4*1A=68  e sottraiamo 6A-68=02 <-- questo è il primo resto. Capito?

Comunque tenete sempre puntato l'indirizzo di memoria di ebp-94, 0075F7EC e capirete tutto e vedrete come vengono trattati i nostri caratteri...

 

:0043871E                       push edx                         

:0043871F                       inc esi

:00438720                       pop eax

:00438721                       mov byte ptr [ebp+edi-00000094], al   

:00438728                       mov cl, byte ptr [esi]

:0043872A                       test cl, cl

:0043872C                       jne 004386F7

 

alla fine della prima routine in ebp-94 ho:

:0075F7EC 0E 0B 11 0F 0E 07 11 0E 12 14

 

SECONDA ROUTINE:

:0043872E                       xor ebx, ebx

:00438730                       lea ecx, dword ptr [ebp-0094]  <--- ecx ora ha l'indirizzo di ebp-94, 0075F7EC

:00438736                       add byte ptr [ecx], 41         <--- aggiunge 41 a quel primo byte all'indirizzo
                                                                                                0075F7EC
:00438739                       inc ebx

:0043873A                       inc ecx

:0043873B                       cmp ebx, 0000000A    <-------------- e fa così per tutti e dieci i byte

:0043873E                       jl 00438736

 

Svolgiamo la somma:

 

0E 0B 11 0F 0E 07 11 0E 12 14 +
41 41 41 41 41 41 41 41 41 41  =
---------------------------------------
4F 4C 52 50 4F 48 52 4F 53 55    che in ASCII è:  O L R P O H R O S U

:00438740                     xor ebx, ebx

:00438742                     lea ecx, dword ptr [ebp-0094]

:00438748                     xor esi, esi

:0043874A                     lea eax, dword ptr [ebp-0094]

:00438750                     mov dword ptr [ebp-78], eax

:00438753                     mov edi, ecx

TERZA ROUTINE:

Molto simile a quella vista prima... vi metto qualche commento a lato:

 

:00438755                     mov edx, dword ptr [ebp-78] 

:00438758                     inc esi

:00438759                     movsx eax, byte ptr [edi]     <-------- mette il primo byte della prima pass ottenuta

                                                                                                        (mi riferisco a  "OLRPOHROSU") in eax

:0043875C                     movsx edx, byte ptr [edx]     <-------- mette lo stesso byte in edx

:0043875F                     add eax, edx                  <-------- li somma ed il risultato in eax

:00438761                     push ecx       

:00438762                     cdq       

:00438763                     mov ecx, 0000001A      <--------------- aggiunge 1A ad ecx

:0043876                        idiv ecx   <-------- e divide eax per 1A mettendo il risultato in eax ed il resto in edx

:0043876A                     pop ecx

:0043876B                     mov byte ptr [edi], dl        

:0043876D                     inc [ebp-78]

:00438770                     cmp esi, 0000000A             <--------- fai questo loop per tutti e 10 i byte

:00438773                     jl 00438755

:00438775                     add byte ptr [ecx], 41     <--------- aggiunge 41 a quello che abbiamo all'indirizzo di ecx

:00438778                     inc ebx

:00438779                     inc ecx

:0043877A                     cmp ebx, 0000000A             <--------- fino a che non si è esaminata tutta la pass...

:0043877D                     jl 00438748

 

A questo punto abbiamo finito. Se stavate guardando come vi avevo sempre detto da diverse righe a questa parte, all'indirizzo di memoria ebp-98, avrete visto
costruire nella finestra del codice ASCII di Winice la vostra password. 
Per me, la password finale è:

1^RIGA: [aLT255]
U^RIGA: SYCAXJRSFM

Se provate ad inserire anche gli altri campi, prima di giungere alle routine che abbiamo visto sopra dovrete steppare con F12 ed F10 più volte, perchè la routine inizierà un pò prima, non l'ho messa qua nel tut se no diventava una cosa 
lunghissima e pallosa. Ve lo lascio a voi come esercizio.
Spero che ciò che ho scritto in queste righe possa servire a qualcuno che sta ancora all'inizio per impratichirsi un pò 
più con le routine delle seriali. Scusate per gli errori tecnici, anche io sono un newbie :)

Vorei ringraziare e salutare: Quequero, sempre gentilissimo e disponibile in tutto, per aver corretto i grossi errori tecnici presenti in questo tut, per non essersi mai stancato per tutte le domande che fin'ora gli ho fatto su hackz, crackz e chi + ne ha ne metta :))) ; Neural_Noise, per avermi fatto conoscere il chan crack-it quando ancora vagavo in efnet, per tutti i favori che mi ha fatto, (Fguard ti dice qualcosa?) gli aiuti, i consigli, e per il tempo che spesso gli faccio perdere ;P ; Guybrush, praticamente il BOT di crack-it ;))) ; T3X, ka10, PE_WoW e tutti gli altri che ora non sto citando perchè son suonato della crew di Ringzer0 e del canale Crack-it e non ricordo.

Byez

[aLT255]
 

Vorrei ricordare che il software va comprato e  non rubato. Se il programma in questione dovesse essere di vostro gradimento ed intendete utilizzarlo allora compratelo, non usate quello rippato. Non mi ritengo responsabile per eventuali danni causati al vostro computer determinati dall'uso improprio di questo tutorial. Questo documento è stato scritto a puro scopo didattico e non vuole assolutamente essere un incitamento alla pirateria.

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

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

 

Home  Assembly  CrackMe  IRC  Links  NewBies
News  Forum Hacking  Tools
Tutorial

UIC