Tools utilizzati:
Winice 3.2x
W32dasm 8.9
HexWorkshop
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... a buon intenditore...
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 84C0 test al,al
:004152BB 751B 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 6A10 push 00000010
* Possible StringData Ref from Data Obj ->"DEMO NON ATTIVABILE"
|
:004152BF 68B0C34C00 push 004CC3B0
* Possible StringData Ref from Data Obj ->"Attenzione: Questo programma non "
[...]
- |
* Reference To: Lotto._ChiaveFrm
|
:004152D8 8B1570CE4D00 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 51 push ecx
:004386A8 8D8578FDFFFF 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 50 push eax
:004386AF E810230900 Call 004CA9C4
:004386B4 83C408 add esp, 00000008
:004386B7 FF4DB8 dec [ebp-48]
:004386BA 8D45E8 lea eax, dword ptr [ebp-18]
:004386BD BA02000000 mov edx, 00000002
:004386C2 E85D150900 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 68328D4D00 push 004D8D32
:004386CC 8D8D78FDFFFF lea ecx, dword ptr [ebp-288]
:004386D2 51 push ecx
:004386D3 E8EC220900 Call 004CA9C4 <---- e qui viene sommata al nostro nome in ebp-288
se stavate sempre puntando su questo indirizzo
ve ne sarete accorti
:004386D8 83C408 add esp, 00000008
:004386DB 33DB xor ebx, ebx
:004386DD 8D856CFFFFFF 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 C60000 mov byte ptr [eax], 00 <--- mette uno zero all'indirizzo 0075F7EC
Quindi al posto di A8 ci ritroviamo "00"
:004386E6 43 inc ebx
:004386E7 40 inc eax
:004386E8 83FB0B cmp ebx, 0000000B <--- e così via fino a che ebx è uguale a 0B (cioè 11)
:004386EB 7CF6 jl 004386E3
quindi all'indirizzo 0075F7EC abbiamo:
:0075F7EC | 00 00 00 00 00 00 00 00-00 00 etc...
:004386ED 33DB xor ebx, ebx
:004386EF 8DB578FDFFFF lea esi, dword ptr [ebp-288] <--- nostro_nome+I12N13TE43R235NET LI25B12E23RA viene
caricato in esi... sicuramente ora ci
farà qualcosa...
:004386F5 EB31 jmp 00438728
:00438728 8A0E mov cl, byte ptr [esi] <--- carica il primo carattere, nel mio caso "["
:0043872A 84C9 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 75C9 jne 004386F7
Qua inizia la PRIMA ROUTINE per la seriale, per cui maggiore attenzione:
:004386F7 8BC3 mov eax, ebx <--- ebx era 0 e porta a 0 anche eax
:004386F9 BF0A000000 mov edi, 0000000A
:004386FE 99 cdq <--- converte una doubleword in quadword per preparare
una divisione con segno (Signed)
:004386FF F7FF idiv edi <--- divide eax per edi e mette il resto in edx
:00438701 8BFA mov edi, edx <--- il resto della divisione viene spostato in edi
:00438703 0FBED1 movsx edx, cl <--- il primo carattere del
nostro_nome+I12N13TE43R235NET LI25B12E23RA viene
spostato in edx
:00438706 0FBE843D6CFFFFFF movsx eax, byte ptr [ebp+edi-94] <-- prende un byte dall'area di memoria ebp-94
ci somma il resto della divisione precedente (se c'era) e mette il risultato in eax
:0043870E 03C2 add eax, edx <--- il nostro carattere viene aggiunto al valore di eax
:00438710 B91A000000 mov ecx, 0000001A
:00438715 03C3 add eax, ebx <--- aggiunge ad eax il valore di ebx che parte da 0
:00438717 43 inc ebx <--- e poi viene incrementato di uno ad ogni ciclo
:00438718 83C00F add eax, 0000000F
:0043871B 99 cdq <--- covert double to quad
:0043871C F7F9 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 52 push edx
:0043871F 46 inc esi
:00438720 58 pop eax
:00438721 88843D6CFFFFFF mov byte ptr [ebp+edi-00000094], al
:00438728 8A0E mov cl, byte ptr [esi]
:0043872A 84C9 test cl, cl
:0043872C 75C9 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 33DB xor ebx, ebx
:00438730 8D8D6CFFFFFF lea ecx, dword ptr [ebp-0094] <--- ecx ora ha l'indirizzo di ebp-94, 0075F7EC
:00438736 800141 add byte ptr [ecx], 41 <--- aggiunge 41 a quel primo byte all'indirizzo
0075F7EC
:00438739 43 inc ebx
:0043873A 41 inc ecx
:0043873B 83FB0A cmp ebx, 0000000A <--- e fa così per tutti e dieci i byte
:0043873E 7CF6 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 33DB xor ebx, ebx
:00438742 8D8D6CFFFFFF lea ecx, dword ptr [ebp-0094]
:00438748 33F6 xor esi, esi
:0043874A 8D856CFFFFFF lea eax, dword ptr [ebp-0094]
:00438750 894588 mov dword ptr [ebp-78], eax
:00438753 8BF9 mov edi, ecx
TERZA ROUTINE:
Molto simile a quella vista prima... vi mette qualche commento a lato:
:00438755 8B5588 mov edx, dword ptr [ebp-78]
:00438758 46 inc esi
:00438759 0FBE07 movsx eax, byte ptr [edi] <---- mette il primo byte della prima pass ottenuta riferisco a "OLRPOHROSU") in eax
:0043875C 0FBE12 movsx edx, byte ptr [edx] <---- mette lo stesso byte in edx
:0043875F 03C2 add eax, edx <---- li somma ed il risultato in eax
:00438761 51 push ecx
:00438762 99 cdq
:00438763 B91A000000 mov ecx, 0000001A <---- aggiunge 1A ad ecx
:00438768 F7F9 idiv ecx <---- e divide eax per 1A mettendo il risultato in eax ed il
resto in edx
:0043876A 59 pop ecx
:0043876B 8817 mov byte ptr [edi], dl
:0043876D FF4588 inc [ebp-78]
:00438770 83FE0A cmp esi, 0000000A <---- fai questo loop per tutti e 10 i byte
:00438773 7CE0 jl 00438755
:00438775 800141 add byte ptr [ecx], 41 <---- aggiunge 41 quello che abbiamo all'indirizzo di ecx
:00438778 43 inc ebx
:00438779 41 inc ecx
:0043877A 83FB0A cmp ebx, 0000000A <---- fino a che non si è esaminata tutta la pass...
:0043877D 7CC9 jl 00438748
Praticamente abbiamo finito. Se stavate guardando come vi avevo sempre detto da diverse righe a questa parte avete 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 :)))
- Cavolo non mi ero mai accorto di essere così
buono, hei alt255 sicuro che non mi
- confondi con qualcun'altro????? ;))))))
-
- 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 ;)))
- ka10, PE_WoW e tutti gli altri che ora non
sto citando perchè son suonato della crew di Ringzer0 e del canale Crack-it.
Byez
[aLT255]