Zoom Icon

Corso UIC Avanzato 05 GR!SU

From UIC Archive

CrackME 5 (Risolviamo il 5° Corso della UIC)

Contents


Corso UIC Avanzato 05 GR!SU
Author: GR!SU
Email: [email protected]
Website: Home page
Date: 05/01/2000 (dd/mm/yyyy)
Level: Working brain required
Language: Italian Flag Italian.gif
Comments:

Commenti, se volete



Introduzione

il CrackME in questione è costituito da tre livelli crescenti di difficoltà .


Tools

SoftIce 3.2x
W32dasm 8.9x
Ida
Hex Workshop
[Monitor]
Ice Dump


Link e Riferimenti

http://linox.tecnoprogress.it/progetti.html
Scaricate qui l'allegato


Notizie sul Programma

Un CrackME molto Tosto.


Essay

Benissimo....Iniziamo il lavoro che ci porterà alla soluzione di questo CrackMe facente parte del 5° corso della U.I.C.Cercheremo insieme di risolvere e spiegare tutti i punti prefissati come obbiettivi da raggiungere per una corretta e completa soluzione del corso.Avviamo il CrackMe..... e se ovviamente (penso che lo avete) abbiamo installato sul nostro PC SoftIce comparirà una MsgBox che ci obbligherà ad alzare una mano in quanto noi siamo tra quelli che usano Sice. Che cosa è questa finestra?? è ovvio che è un controllo antidebug è cioe un controllo che Checka la presenza di Sice, prima di iniziare quindi il nostro vero e proprio lavoro dobbiamo eliminare questo controllo senza usare però nessun Tool. Ovviamente ci potrebbero essere più modi per risolvere questo problema , io ho usato questo:

A) Eliminazione del controllo sulla presenza di Sice.

Settiamo un Bpx su Hmemcpy, in Sice BPX Hmemcpy poi F5 ed avviamo il Prg., iniziamo a steppare fino a che entriamo nel codice del CrackME, continuiamo ancora fino a che ci butta fuori facendo attenzione appunto al codice e particolarmente alla presenza in esso di Interrupt (Int) , non è però questa la sede in cui andrò a spiegarvi il loro funzionamento, uno lo troviamo a 00401064 Int 68 subito dopo troviamo un Cmp e di seguito a 0040106A un Jz che salterà alla MsgBox se Sice è presente dobbiamo quindi solamente invertire il Jz, anche qui non vi sto a spiegare come dovete fare perchè altrimenti in ogni tut rischiamo di dire sempre la stessa cosa. Ok il primo passo e fatto rilanciamo il Prg. dopo averlo Patchato...... heeeee noooooo......un altro controllo ripetiamo le operazioni precedenti e troviamo un altro controllo e quindi a 004010E3 un altro Jz da noppare. Bene ora sembra che siamo a posto...per il momento.Andando avanti con i livelli noteremo che verrà effettuato ancora un altro controllo sulla presenza di Sice ed esattamente a 00401542 dove troveremo un Jnz che ovviamente dovremo invertire.Andiamo quindi avanti, sappiamo da quello che ci ha detto Que che è una protezione multipla composta da tre livelli di difficoltà, il primo consiste nel trovare un codice o Seriale.

B)1° Check

Identificazione del Codice (1° Seriale) e spiegazione della Routine che effettua il Check.

Allora...partiamo dal presupposto che noi non sappiamo niente, non sappiamo ne dove bobbiamo inserire il codice, ne di quanti caratteri deve essere composto sappiamo solo che se sarà checkato dal Prg significa che anche se è stato accuratamente occultato, criptato ho chi più ne ha più ne metta, siamo sicuri che nel codice sarà presente.Proviamo ad inserire nel Box superiore 12345 e premiamo Register notiamo subito che il codice da noi inserito scompare, lo reinseriamo 12345 premiamo Register e compare una MsgBox che ci dice di inserire un numero composto da almeno sei caratteri. Come mai alla prima pressione non esce niente mentre alla seconda esce la MsgBox? Evidentemente perche dopo la prima pressione ha già effettuato il primo Check, infatti il codice scompare liberando la riga di Edit quindi quando lo reinseriamo ci dà la MsgBox perchè evidentemente per il secondo punto da risolvere del CrackME è previsto un Serial di almeno sei caratteri, comunque questo lo vedremo dopo, ora andiamo per ordine. Quindi per essere nella prima routine dobbiamo ogni volta riavviare il Prg. Settiamo Bpx GetWindowTextA inseriamo 12345 e premiamo Register popperemo in Sice, facciamo F12 e ci ritroveremo Quì.

:0040124C call 0040159C.....................................................Questa routine per il momento non ci interessa, la analizzeremo solo nel caso decidiamo di realizzare un KeyFileGenerator
:00401251 xor ecx, ecx...........................................................azzera ecx
:00401253 xor dword ptr [ecx+00403273], 000000ED...........in 00403273 abbiamo il codice da noi inserito
:0040125D inc ecx...................................................................incrementa il contatore
:0040125E cmp ecx, 0000000C..............................................confronta Ecx con 0Ch (12 decimale)
:00401261 jne 00401253........................................................salta e ripete il ciclo fino a che Ecx= 0Ch
:00401263 xor ecx, ecx............................................................azzera il contatore
:00401265 xor dword ptr [ecx+00403273], 134F7432
:0040126F xor dword ptr [ecx+00403273], 4A710930
:00401279 xor dword ptr [ecx+00403273], 58D71DE6
:00401283 add ecx, 00000004
:00401286 cmp ecx, 0000000C
:00401289 jne 00401265
:0040128B Call GetTickCount...........................................riporta in Eax i millisecondi trascorsi dall' ultimo avvioWindows
:00401290 xor dword ptr [00403273], eax
:00401296 xor dword ptr [00403277], eax
:0040129C xor dword ptr [0040327B], eax
:004012A2 xor dword ptr [0040327F], eax
:004012A8 xor dword ptr [00403283], eax
:004012AE xor dword ptr [00403287], eax
:004012B4 and dword ptr [0040327F], 00627893
:004012BE and dword ptr [00403273], 00627893
:004012C8 mov esi, 00403273 .............................................muove in Esi il risultato dello Xoring con il nostro Codice
:004012CD mov edi, 0040327F.............................................muove in Edi il risultato dello Xoring con la stringa fissa
:004012D2 mov ecx, 0000000C
:004012D7 repz
:004012D8 cmpsb
:004012D9 je 00401300........................................................salta se sono uguali
:004012DF mov dword ptr [0040329B], 0000F892...............muove F892h in 0040329B se il Codice non è esatto
:004012E9 jmp 0040130A.....................................................salta ed inizia il secondo Check

|

:00401300 mov dword ptr [0040329B], 0000F896................muove F896h in 0040329B se il Codice è esatto

all indirizzo 00401253 Xora ogni carattere del nostro codice con EDh e lo sostituisce con il risultato, dall offset 0040125E possiamo capire che il nostro codice deve essere composto da 12 caratteri (l'ultimo non viene usato viene sempre riportato a zero quindi può essere omesso, andando avanti vengono effettuate altre operazioni di Xoring , in seguito viene chiamata l'Api GetTickCount che riporta in Eax i millisecondi trascorsi dall'ultimo avvio di Windows, penso sia stata usata per creare un valore Random diverso per ogni esecuzione del Prg.In seguito vengono effettuati degli Xor tra questo valore Random e i risultati avuti dai precedenti Xor con il nostro Codice (il risultato viene mosso in Esi) ed in seguito anche con una stringa fissa che troviamo consecutivamente a quella avutasi con lo Xoring del nostro Codice (il risultato và in Edi) viene quindi effettuato un Cmp Byte per Byte tra le due stringhe. Se sono uguali il Je successivo salta. Che cosa significa tutto questo? Significa che se ad ogni avvio abbiamo un valore Random diverso e lo mettiamo in Eax, questo valore lo Xoriamo con la stringa data dal nostro codice e poi con un altra fissa , e ovvio che se vogliamo che i due risultati siino uguali dobbiamo far si essendo che uno degli operandi (il valore Random) dello Xor è uguale per tutte e due le operazioni e che la stringa fissa e sempre la stessa, risulta evidente che il risultato dello Xoring del nosto Codice che viene effettuato tra la porzione di codice che va da 00401251 e la fine del ciclo a 00401289 e che viene messo in 00403273 deve essere uguale alla stringa fissa contenuta in 0040327F, in seguito venendo Xorate tutte e due con lo stesso valore se sono uguali daranno ovviamente lo stesso risultato. Per farla semplice, steppate fino a 0040128B qui fate in Sice D 00403273 vedrete il risultato dello Xoring con il vostro Codice che dovrà risultare uguale alla stringa contenuta a 0040327F (fate D 0040327F).Adesso stà a voi farvi tutte le operazioni inverse per arrivare da questa stringa a quella che dovrete inserire nell' EditBox, se volete capire come fà altrimenti prendete per buona questa : Cr4nB&Rr13$. Andando avanti ed esaminando il codice notiamo che in base al nostro risultato mette un valore in 0040329B e continua poi per il secondo Check, indipendentemente quindi dal fatto che il primo sia correttamente superato (Codice valido) oppure no (Codice errato) marca però questo risultato con un valore in modo differente per i due casi.

C) 2° Check

Troveremo il Serial corrispondente al nostro Nick e spiegheremo il funzionamento della routine che lo genera.

Inseriamo ora nella EditBox superiore il nostro Nick " GR!SU' " premiamo Register ed uscira la MsgBox che ci dice che deve essere composto almeno da sei caratteri digitiamo quindi "GR!SU'_crk" (PS. non usate più di 13 caratteri perchè il CrackMe si blocca) nel box inferiore invece inseriamo 12345 , in sice settiamo Bpx GetWindowTextA e poi premiamo Register poppiamo in Sice facciamo F12 e ci ritroviamo Qui:

:00401335 mov dword ptr [00403241], eax...................in Eax troviamo il numero di caratteri del nostro Nick
:0040133A cmp eax, 00000006.....................................controlla che siano almeno sei
:0040133D jl 0040141E
:00401343 Call GetTickCount.........................................riporta in Eax i millisecondi trascorsi dall' ultimo avvioWindows
:00401348 mov dword ptr [0040323D], eax
:0040134D xor ecx, ecx...................................................azzera Ecx
:0040134F xor ebx, ebx...................................................azzera Ebx
:00401351 mov edx, dword ptr [0040324A]....................muove in Edx i caratteri 2° 3° 4° 5° del Nick
:00401357 mov eax, dword ptr [00403249].....................muove in Eax i caratteri 1° 2° 3° 4° del Nick
:0040135C imul eax, edx..................................................effettua l'operazione e mette il risultato in Eax
:0040135F mov dword ptr [00403249], eax.....................muove Eax in 00403249 sovrapponendolo al nostro Nick
:00401364 xor ecx, ecx....................................................azzera il registro
:00401366 add ecx, 00000004.........................................addiziona ad Ecx il valore 4
:00401369 dec dword ptr [00403241]..............................in 00403241 c'è il numero di caratteri del nostro Nick
:0040136F inc ecx.............................................................incrementa Ecx
:00401370 mov al, byte ptr [ecx+00403249].....................muove in al il primo Byte contenuto in Ecx+00403249
:00401376 add al, byte ptr [ecx+0040324A].....................addiziona ad al il primo Byte contenuto in Ecx+0040324A
:0040137C mov byte ptr [ecx+00403249], al....................muove al al posto del primo Byte contenuto in Ecx+00403249
:00401382 cmp ecx, dword ptr [00403241]
:00401388 jl 0040136F..................................ripete il ciclo fino a che ecx resta minore del valore contenuto in 00403241
:0040138A mov eax, dword ptr [00403249]
:0040138F mov ebx, dword ptr [0040324D]
:00401395 imul eax, ebx
:00401398 mov dword ptr [00403249], eax
:0040139D inc dword ptr [00403241]
:004013A3 xor ecx, ecx
:004013A5 mov ecx, dword ptr [00403241]
:004013AB mov eax, dword ptr [ecx+00403249]
:004013B1 xor eax, 04CF580F...........................................Xora Eax con 04CF580F
:004013B6 mov dword ptr [ecx+00403249], eax
:004013BC dec ecx
:004013BD test ecx, ecx
:004013BF jne 004013AB...................................................salta fino a che in Ecx è presente un valore
:004013C1 call 00401438....................................................routine che genera il Seriale in base al Nick
:004013C6 xor eax, eax.......................................................qui facendo in Sice D 40324A vediamo il Serial generato
:004013C8 call 004013EF...................................................crea un valore Random e lo mette in 00403235
:004013CD call 004014AE..................................................esegue delle operazioni tra il seriale generato ed il Random e mette il risultato in 0040324A
:004013D2 push 00000014
:004013D4 push 0040325D
:004013D9 push dword ptr [00402034] |
:004013DF call GetWindowTextA..........................................legge il serial da noi inserito e riporta in Eax il numero delle cifre di cui è composto
:004013E4 call 0040157A......................................................effettua delle operazioni con il seriale da noi inserito ed il Random contenuto in 00403235 e mette il risultato in 0040325D
:004013E9 call 004015EF......................................................molto importante
:004013EE ret

Mi sembra inutile dare ulteriori delucidazioni al codice appena visto, in pratica con varie operazioni viene creata una stringa in base al Nick che si va a sovrapporre nella stessa posizione in cui era contenuto il nostro Nick a 00403249. La routine chiamata a 004013C1 è quella che genera il seriale in base al Nick, evito per questa routine, anche se può sembrare non corretto, di dare alcuna spiegazione perche per niente complicata, effettua solo alcune operazioni, che daranno di ritorno dalla Call sempre allo stesso indirizzo 00403249 il nostro Serial in chiaro. In pratica arrivati a 004013C6 se facciamo D 40324A vedremo in chiaro il serial per il nostro Nick ma non ancora nel modo corretto di come dovrebbe essere inserito nella EditBox. Andiamo quindi avanti e vediamo cosa succede. Entriamo ora nella Routine chiamata a 004013E9

:004015EF push dword ptr [00402034]
:004015F5 call GetWindowTextA......................................legge il serial da noi inserito e riporta in Eax il numero delle cifre di cui è composto
:004015FA cmp eax, 0000000F........................................confronta Eax con 0Fh (15 dec.)
:004015FD jne 00401108..................................................salta fuori della routine se Eax è diverso da 0F
:00401603 mov esi, 0040324A...........................................contiene il risultato delle operazioni effettuate con il serial generato in base al Nick
:00401608 mov edi, 0040325D...........................................contiene il risultato delle operazioni effettuate con il Serial da noi inserito
:0040160D mov ecx, dword ptr [00403241].......................muove in Ecx il numero di caratteri da cui è composto il Nick
:00401613 repz
:00401614 cmpsb
:00401615 je 004014F4......................................................salta se sono uguali
:0040161B mov dword ptr [0040329F], 000091C2.............muove in 0040329F il valore 91C2h se il Serial è errato

|

:004014F4 mov dword ptr [0040329F], 000091B2.............muove in 0040329F il valore 91B2h se il Serial è corretto

da 0015FA risulta evidente che il nostro serial deve essere composto da 15 cifre, quindi usciamo ed inseriamo 123456789012345 ritorniamo poi di nuovo allo stesso punto, la routine quindi continua....ed effettua un Cmp confrontando un byte per volta le due stringhe contenute in Esi ed in Edi che come per il primo Check dovrebbero risultare uguali essendo state esse realizzate tra: La stringa in esi dal Serial esatto ed il Random mentre la stringa in Edi dal Serial inserito ed il Random (il valore Random abbiamo visto che è uguale per tutte e due). In conclusione come abbiamo già detto basta che a 004013C1 fate D 0040324A e vedrete in chiaro il Seriale da inserire, dovrete solo aggiungere tante cifre quante ne servono per arrivare a 15 (io ho usato degli zeri ma potete inserire qualsiasi cosa tanto non è utilizzata).

GR!SU'_crk

332134496200000

Anche questo secondo Check è stato quindi superato andiamo avanti ora con il KeyFile, che in questo caso essendo un CrackME sappiamo già dalle istruzioni che è richiesto, comunque c'è ne saremmo accorti ugualmente usando per esempio FileMonitor, tramite il quale infatti abbiamo individuato il nome (Crykey.key) che deve avere questo file, nome che se abbiamo esaminato attentamente il codice visto fino a questo momento avremo sicuramente già notato avremmo quindi potuto fare a meno di usare anche questo Tools.

D) 3° Check

Identificazione delle routine che crittano e confrontano il KeyFile e generazione dello stesso.

Arrivati quindi a 00401615 con il Nick/Serial corretto il Je ci fa saltare e continuiamo a steppare fino a:

:00401522 Call GetWindowTextA
:00401527 call 0040167F...........................................routine che genera i dati che dovrà contenere il KeyFile
:0040152C call 00401B79..........................................apre il KeyFile e lo legge
:00401531 call 00401BCE..........................................critta il KeyFile ed i dati generati dalla prima routine

Iniziamo ad analizzare la prima delle tre Routine interessate dal KeyFile, quindi a 00401527 facciamo F8 se vogliamo seguire tutto l'algoritmo, ma in questa sede non lo faremo, in quanto essendo molto elaborato sarebbe molto complicato spiegarlo mentre è molto più semplice (se vi interessa) capirlo analizzandolo passo passo direttamente sul campo vi dirò solamente che questa routine in pratica nella sua prima parte di codice genera in base al nostro serial un insieme di dati crittati mentre nella seconda parte li elabora diciamo in un modo X .Io ora vi dirò solo come prelevare dalla prima parte di questa routine i dati da inserire nel KeyFile. Allora fate F8 e vi ritroverete qui:

:0040167F mov ecx, 00000023....................................siete qui
|
|
:0040190B mov eax, 00402BFC..................................arrivati qui fate quello che vi indico di seguito

allora ricapitolando questo tratto di codice che vi ho indicato e quello che genera e immette all' indirizzo 00402BFC tutto i dati che noi dovremmo andare ad immettere nel nostro KeyFile che come potrete vedere nella routine successiva dovrà essere di 700Byte. Bene voi adesso direte come facciamo a copiare tutta questa roba e a metterla nel File? I sistemi sono due ho create un generatore di KeyFile oppure prendete tutti questi dati e li salvate in un file, è proprio questo che noi faremo ora grazie all'ausilio di un Tools e precisamente IceDump che purtroppo non starò a spiegarvi come funziona, ma una volta installato basterà che in Sice arrivati a questo punto 0040190B digidate questa riga di comando :

PAGEIN <address> [<length> <file name>]

praticamente digitate questo PAGEIN 00402BFC 2BC Crykey.key dove per 2BC si intende la lunghezza del file 700Byte in questo modo creerete un file di nome appunto Crykey.key (naturalmente potete indicare il percorso completo di dove volete creare il file) contenente tutto quello che è compreso tra 00402BFC per 700Byte. Bene adesso avete anche il KeyFile. Andiamo ancora avanti e facciamo F8 a 0040152C questa routine la analizzeremo vedendo solo i punti più importanti per eliminare alcuni dubbi su delle affermazioni che precedentemente ho fatto prendere per buone ma che evidentemente avevo già evidenziato io in precedenza appunto analizzando questa routine come per esempio il fatto che il KeyFile debba essere di 700Byte. Facendo F8 ci ritroveremo qui:

:00401B79 push 00000002.........................................................apriamo il file in modalita Read/Write
:00401B7B push 00402050.........................................................puntatore al buffer che conterra le informazioni
:00401B80 push 0040322A........................................................puntatore al nome del File
:00401B85 Call OpenFile
:00401B8A mov dword ptr [00402048], eax...............................muove in 00402048 l'Handle del file
:00401B8F cmp eax, FFFFFFFF................................................controlla se il file è stato aperto correttamente
:00401B92 je 00401560.............................................................salta se il file contiene errori ho non è presente
:00401B98 push 00000000
:00401B9A push 00000000
:00401B9C push dword ptr [004032A7]
:00401BA2 push dword ptr [00402048].......................................handle del file
:00401BA8 Call SetFilePointer
:00401BAD push 00000000
:00401BAF push 00402320.........................................................conterrà i byte effettivamente letti
:00401BB4 push dword ptr [004031FC]......................................contiene i byte da leggere (2BCh 700dec.)
:00401BBA push 004025F0........................................................qui ritroveremo i dati una volta letto il file
:00401BBF push dword ptr [00402048].......................................handle del file
:00401BC5 Call ReadFile
:00401BCA ret

anche per questa parte di codice non penso ci sia bisogno di ulteriori delucidazioni, vi ricordo che a 00401BB4 se in Sice facciamo D 004031FC non ci rimarrà più alcun dubbio per quanto riguarda la dimensione del nostro Crykey.Key. se il file creato in precedenza è quindi effettivamente di 700 byte potremmo vederlo una volta letto in D 00402320.Usciamo quindi da questa routine per entrare nell'ultima della quale vi dirò solamente che : Elabora il KeyFile appena letto nello stesso modo X di come sono stati elaborati i dati generati nella prima parte della prima routine, successivamente saranno proprio i risultati di queste due differenti elaborazioni che il codice andrà a confrontare, una volta usciti da questa chiamata ci ritroveremo quì:

:00401536 mov ebp, 4243484B
:0040153B mov ax, 0004
:0040153F int 03
:00401540 cmp al, 04
:00401542 je 004011EE..............................................qui effettua l'ultimo controllo antiSice (già eliminato in precedenza)
:00401548 mov esi, 00402BFC...................................KeyFile elaborato
:0040154D mov edi, 004025F0...................................dati creati nella prima routine elaborati
:00401552 mov ecx, dword ptr [004031FC]................muove in ecx il valore 2BC (700dec.)
:00401558 repz
:00401559 cmpsb........................................................qui effettua l'ultimo check, quello sul KeyFile
:0040155A je 00401DE9............................................salta se il KeyFile è corretto
:00401560 mov dword ptr [004032A3], 000057A3.....muove 57A3h in 004032A3 se il Key file non è esatto
|
|
:00401DE9 mov dword ptr [004032A3], 000057B3.........muove 57B3 in 004032A3 se il KeyFile è esatto

Finalmente è finita.......eeeeeinvece noooo... la tanto agoniata MessageBox non esce ancora, ma anche questo lo sapevamo dalle istruzioni che Que ci ha dato all'inizio, il problema non è questo ma è quello che appena saprete come si fa a far apparire la MessageBox direte.....ma ha che è servito tutto questo lavoro? A niente....abbiamo solo imparato qualche altra nuova nozione.Vediamo quindi cosa succede

:00401DF3 xor eax, eax
:00401DF5 mov eax, dword ptr [0040329B]....................in 0040329B troviamo il valore inserito alla fine del 1° Check
:00401DFA mov ebx, dword ptr [0040329F]...................in 0040329F troviamo il valore inserito alla fine del 2° Check
:00401E00 add eax, ebx...................................................addiziona i due valori
:00401E02 mov ebx, dword ptr [004032A3]....................in 004032A3 troviamo il valòore inserito alla fine del 3° Check
:00401E08 add eax, ebx...................................................addiziona l'ultimo valore con la somma di quelli precedenti
:00401E0A mov ebx, dword ptr [00403431]...................quello che dovrebbe esserci qui ve lo spiego dopo
:00401E10 add eax, ebx
:00401E12 mov ecx, 5723814A
:00401E17 xor eax, ecx
:00401E19 rol eax, cl
:00401E1B cmp eax, 8982D55C......................................confronta il tutto con questo valore
:00401E20 jne 00401108................................salta se sono diversi altrimenti continua verso la MsgBox di congratulazioni

PS. Il KeyFile Generato dalla mia postazione non risulterà mai corretto se usato su di un altro computer pur usando gli stessi Nick/Serial, il perchè lo capirete esaminando la primissima routine incontrata durante l'esame del codice interessato al primo Check e precisamente a 0040124C.

E) Facciamo comparire la MessageBox di congratulazioni.

Qui vi spieghero semplicemente come si fà e come sono arrivato a questa soluzione. Allora fin dall' inizio ho pensato perchè Quequero ha predisposto per ogni check due valori differenti da salvare in una determinata posizione in base al risultato stesso del Check che può essere positivo cioè esatto o negativo?? Un motivo ci doveva essere.......è presto detto. Noi siamo arrivati quindi a questo punto con tutti i Check con risultato positivo cioè Codice Nick/Serial e KeyFile esatti ,quindi se nella parte di codice precedente ci mettiamo quei valori, cosa metteremo o cosa dovrebbe esserci nella posizione 00403431 indicata a 00401E0A ? Fate così provate a disassemblare il CrackME con Ida fate un jamp to andress a 00403431 arrivati qui fate doppio click su start+1CBW che si trova sulla stessa riga e vi ritroverete a 004011CB

:004011B8 push 00000020
:004011BA push 0040344E ...............................................qui troviamo CrackME 5 About Box
:004011BF push 00403462
:004011C4 push 00000000
:004011C6 Call MessageBoxA
:004011CB inc dword ptr [00403431]...................................vi trovate qui

che cosa significa incrementa 00403431, o meglio cosa dobbiamo fare per incrementare il valore in quella posizione, se guardiamo qualche riga in su vediamo che c'è una chiamata alla MessageBox e se andiamo a vedere nella posizione contenente la Captin Box troviamo CrackME 5 About Box.............Lampadina...mi si è accesa una lampadina.... ..ogni volta che premo il pulsante About ovviamente stando a quello che si vede dal codice mi incrementa il valore in 00403431.Ed infatti è proprio così.Adesso però non vi dico più niente fate voi tutte le operazioni inverse, con Check tutti positivi, per trovare il valore che ci dovrebbe essere in 00403431 in modo che una volta saputo a quanto equivale adrete a premere tante volte quanto è questo valore il pulsante About affinchè possa incrementare. Ma non finisce qui perche se avete fatto tutte le operazioni correttamente vi accorgerete che questo valore risulterà negativo, il che non può essere possibile....Ecco quindi perchè Quequero ha usato due valori differenti asseconda che i vari Check fossero positivi o negativi.....provate quindi ad inserire Codice errato, Nick/Serial errato e KeyFile anche errato, verranno quindi inseriti tutti i valori attribuiti ad ogni check con risultato errato rifate tutte le operazioni inverse è se avete fatto tutto bene vedrete che il valore che dovremmo mettere in 00403431 che a sua volta verra mosso in Ebx all indirizzo 00401E0A è: 08 (otto).

Quindi per concludere per far uscire la MsgBox di Congratulazioni occorre inserire tutto errato (tenete presente però che il Serial del Nick deve essere sempre di 15 caratteri) e prima di premere Register aprite e chiudete per otto volte la MessageBox About premendo appunto sul pulsante About. Ermmm vorrei fare una piccola precisazione, per far apparire il messagebox invece devi inserire tutto esatto, poi prima dell'ultimo check devi premere 4 volte il pulsante di about, fai l'ultimo check e ti appare :)

CiAo da GR!SU'.....alla prossima.!!!


Note Finali

Voglio solo dire che se in questo Tut troverete delle lacune e degli errori non fateci caso perche l'ho scritto tutto d'un fiatoooo essendo in ritardo con la sua consegna....... :-(((

Ora non mi resta che, ovviamente, Ringraziare QUEQUERO per la sua grande disponibilità e la UIC tutta ed in rigoroso ordine casuale tutti quelli che mi hanno aiutato a progredire in questa nobile ARTE (anche se alcuni di loro forse non lo sanno).

Un dovuto e sentito ringraziamento va' all'amico Sator SSH per avermi iniziato a questa Nobile Arte. +ORC mitico Neural_Noise, Scacco, CoRN2, ED!SON, raZZia, FROSTMAN, CbD, Qapla , +MaLattiA, along3x, Marcus, AloR, Xoanon, Int19, syscalo, alt255 tutto il gruppo di RingZ3r0, tutti quelli che ho dimenticato ed anche quelli che non conosco. Ringrazio inoltre tutta la ML e tutti quelli che hanno partecipato ogniuno a proprio modo a questa battaglia.


Disclaimer

I documenti qui pubblicati sono da considerarsi pubblici e liberamente distribuibili, a patto che se ne citi la fonte di provenienza. Tutti i documenti presenti su queste pagine sono stati scritti esclusivamente a scopo di ricerca, nessuna di queste analisi è stata fatta per fini commerciali, o dietro alcun tipo di compenso. I documenti pubblicati presentano delle analisi puramente teoriche della struttura di un programma, in nessun caso il software è stato realmente disassemblato o modificato; ogni corrispondenza presente tra i documenti pubblicati e le istruzioni del software oggetto dell'analisi, è da ritenersi puramente casuale. Tutti i documenti vengono inviati in forma anonima ed automaticamente pubblicati, i diritti di tali opere appartengono esclusivamente al firmatario del documento (se presente), in nessun caso il gestore di questo sito, o del server su cui risiede, può essere ritenuto responsabile dei contenuti qui presenti, oltretutto il gestore del sito non è in grado di risalire all'identità del mittente dei documenti. Tutti i documenti ed i file di questo sito non presentano alcun tipo di garanzia, pertanto ne è sconsigliata a tutti la lettura o l'esecuzione, lo staff non si assume alcuna responsabilità per quanto riguarda l'uso improprio di tali documenti e/o file, è doveroso aggiungere che ogni riferimento a fatti cose o persone è da considerarsi PURAMENTE casuale. Tutti coloro che potrebbero ritenersi moralmente offesi dai contenuti di queste pagine, sono tenuti ad uscire immediatamente da questo sito.

Vogliamo inoltre ricordare che il Reverse Engineering è uno strumento tecnologico di grande potenza ed importanza, senza di esso non sarebbe possibile creare antivirus, scoprire funzioni malevole e non dichiarate all'interno di un programma di pubblico utilizzo. Non sarebbe possibile scoprire, in assenza di un sistema sicuro per il controllo dell'integrità, se il "tal" programma è realmente quello che l'utente ha scelto di installare ed eseguire, né sarebbe possibile continuare lo sviluppo di quei programmi (o l'utilizzo di quelle periferiche) ritenuti obsoleti e non più supportati dalle fonti ufficiali.