E riekkoci a provare a risolvere un nuovo corso NewBies del vecchio AndreaGeddon ke ora mai sembra averci preso gusto a farci lambiccare il cervello ;-), tale corso consiste nell'abilitare cinque funzioni, ke sono tre pulsanti e due item di menù.

8° Corso NewBies
(Attivazione Funzioni Disattivate)

Written by Pincopall

Ordunque questa è la mia soluzione all'ottavo corso per niubbies ke , FIGAAAATA, può pure essere patchato, anzi  mi sa ke o lo si patcha o nisba ;-))

SoftIce --- vabbè c'è bisogno di scriverlo?....mmmm....  "il debugger" <== non si sa mai :-))

Hex WorkShop --- l'editor esadecimale, e potete sempre usare quello ke più  vi  piace, io uso  questo solo perkè mi pagano se ci faccio pubblicità ....skerzo :-))
WDasm32 --- il decompiler

Una guida alle API di WIndows ,ke fà sempre comodo --- io uso quella della Borland, poi fate voi...

Un cervello --- anke se io non l'ho usato, visto ke non lo uso mai....me l'ha detto il prof. di kimika....hihihihi

Lo trovate nel sito della UIC: quequero.cjb.net 

Allora per l'ottavo corso AndreaGeddon ci ha riservato le funzioni disabilitate, scopo del crackme è abilitare i pulsanti e gli item di menù, in modo tale ke di fianco ad essi ( per quanto riguarda i pulsanti ) salti fuori la stringa "registered" anzikè "unregistered"

Primo Pulsante, ma anke "mezzo" secondo e pure "mezzo" terzo .

Allora...pronti...partenza...Via!...bene, di gran carriera, visto ke tale programma può pure essere patchato, apro il WDasm per trovare le stringhe ke mi dicano kessò "Bravo ce l'hai fatta , etc..." ma quando faccio String Data Reference...nada, solo stringhe ke non mi possono essere d'aiuto.
Dunque vediamo un po', visto ke non ho altro a cui appoggiarmi, dato che il crackme, non cerca un keyfile, ne và a spulciare nel registro, l'unica cosa rimasta da fare mi sembra sia il brekkare alle API di Wincows ke fanno si ke una funzione venga abilitata o no e tra tali API provo ( Non è ke la provo perkè mi ispira, in realtà le ho provate tutte :-)) EnableWindow, la cui sintassi è :

BOOL EnableWindow(

    HWND hWnd,   // handle to window
    BOOL bEnable  // flag for enabling or disabling input
   );

Dunque decido di mettere nel SoftIce un bpx enablewindow, faccio poi partire il programma da "Menù di Avvio - Esegui " perkè sennò, se lo faccio partire kessò da "Esplora risorse" o da "Risorse del sistema" il Sice irrompe tremila volte, dunque
una volta lanciato il programma mia appare SoftIce , pigio una volta F12 e mi ritrovo in MFC42, sopra un RET, e facendogli eseguire tale RET steppando con F10, mi ritrovo in OTTAVO alla call all'indirizzo 00401560 ke è una call 00401C7C, digito in SIce "ec" per andare nella code window e comincio ad andare sopra tale call e vedo :

:004014B8   call edi
:004014BA   mov cl, 64
:004014BC   mov dl, 74
:004014BE   mov al, 72
:004014C0   mov byte ptr [00404211], cl
:004014C6   mov byte ptr [00404203], cl
:004014CC   push 00000000 --- Pusha nello stack il valore zero per il flag
:004014CE   lea ecx, dword ptr [esi+000000E0]--- Carica l'handle del primo pulsante
:004014D4   mov byte ptr [00404208], 52  --- muove la R
:004014DB   mov byte ptr [00404209], bl        "    " e
:004014E1   mov byte ptr [0040420A], 67        "    " g
:004014E8   mov byte ptr [0040420B], 69        "    " i
:004014EF   mov byte ptr [0040420C], 73        "    " s
:004014F6   mov byte ptr [0040420D], dl        "    " t
:004014FC   mov byte ptr [0040420E], bl        "    " e
:00401502   mov byte ptr [0040420F], al        "    " r
:00401507   mov byte ptr [00404210], bl        "    " e
:0040150D   mov byte ptr [00404212], 00  --- null
:00401514   mov byte ptr [004041F8], 55  --- muove la U
:0040151B   mov byte ptr [004041F9], 6E        "    " n
:00401522   mov byte ptr [004041FA], al        "    " r
:00401527   mov byte ptr [004041FB], bl        "    " e
:0040152D   mov byte ptr [004041FC], 67        "    " g
:00401534   mov byte ptr [004041FD], 69        "    " i
:0040153B   mov byte ptr [004041FE], 73        "   " s
:00401542   mov byte ptr [004041FF], dl        "    " t
:00401548   mov byte ptr [00404200], bl        "    " e
:0040154E   mov byte ptr [00404201], al        "    " r
:00401553   mov byte ptr [00404202], bl        "    " e
:00401559   mov byte ptr [00404204], 00 --- null

* Reference To: MFC42.Ordinal:0A52, Ord:0A52h
                                  |
:00401560   Call 00401C7C ---  Dopo il primo RET arriviamo qui
:00401565   push 004041F8 ---  Pusha la stringa "Unregistered"
:0040156A   push 000003EE
:0040156F   mov ecx, esi

* Reference To: MFC42.Ordinal:1741, Ord:1741h
                                  |
:00401571   Call 00401C76 ---  Chiamata a SetDlgItemTexta
:00401576   push 00000000 ---  Pusha nello stack il valore zero per il flag
:00401578   lea ecx, dword ptr [esi+000000A0]--- Carica l'handle del 2° pulsante

* Reference To: MFC42.Ordinal:0A52, Ord:0A52h
                                  |
:0040157E   Call 00401C7C --- Seconda chiamata a EnableWindow
:00401583   push 004041F8 --- Pusha la stringa "Unregistered"
:00401588   push 000003EF
:0040158D   mov ecx, esi

* Reference To: MFC42.Ordinal:1741, Ord:1741h
                                  |
:0040158F   Call 00401C76            --- Seconda chiamata a SetDlgItemTexta
:00401594   push 00000000            --- Ripusha il valore zero per il flag
:00401596   lea ecx, dword ptr [esi+60] --- Carica l'handle del terzo pulsante

* Reference To: MFC42.Ordinal:0A52, Ord:0A52h
                                  |
:00401599   Call 00401C7C --- E vabbè che sarà?
:0040159E   push 004041F8 --- E questo?
:004015A3   push 000003F0
:004015A8   mov ecx, esi

* Reference To: MFC42.Ordinal:1741, Ord:1741h
                                  |
:004015AA   Call 00401C76 --- Ovviamente terza ed ultima call a SetDlgItemTexta

Dunque rimuovo con bc* tutti i bpx e ne setto uno a 004014B8, o comunque ad un qualsivoglia indirizzo prima della prima della prima Call 00401C7C, dunque digito bpx 004014B8 e premo F5 per uscire dal Sice, chiudo Ottavo, lo riavvio e il Sice poppa, a questo punto, step by step arrivo sopra la call ke mi interessa e premo F8 per entrarci dentro, scopro così ke tale call è una call a EnableWindow, ma questo lo potevo già sapere solo vedendo che il ret di prima era dopo l'API EnableWindow, e scopro ancora, una volta tornato dalla call di prima, che quella a 00401C76 è una chiamata a SetDlgItemTexta che mi scrive ciò che viene pushato in quel push 004041F8, ovvero la stringa "Unregistered".  Come potete vedere, ci sono tre call a EnableWindow, e tre call a SetDlgItemTexta, e, dato ke ci sono tre pulsanti, un sospetto ci nasce, bene, ora però dobbiamo trovare il modo di far sì ke al posto della stringa "Unregistered " ci appaia quella "Registered", ma come fare?  Bene...vedete ke prima di ogni call 00401C7C il prog mette nello stack dei parametri ke sono quelli sopra descritti nella sintassi dell'API, ebbene come vedete c sono tre "push 00" ke sono quelli ke dicono ke valore dare al "flag for enabling or disabling input ", ora, poikè se viene pushato 0 la scritta è "unregistered" , per far apparire "registered " basterà far pushare il valore 1, nel sice dunque scriviamo " a 004014CC " e poi " push 01 " ,quindi battiamo ESC, e rifacciamo la stessa procedura per gli altri push, ovviamente queste modifiche sono solo temporanee, e per farle diventare permanenti i bytes andranno cambiati nell'editor esadecimale cambiando dunque quei 6A00 con dei 6A01.
Questi cambiamenti c faranno diventare attivi i primi tre pulsanti, quindi clikkiamo sul primo e...voilà "registered"; sul secondo e....dho! "unregistered"? e mi si ridisattiva??; sul terzo e...'Azz! Come il secondo :-((...Allora sotto c'è sotto qualke altro trick!!
Debelliamolo!

Altra metà del secondo

Allora..abbiamo visto ke fare il giokino dell' EnableWindow è servito solo per il primo pulsante, ora dunque si tratta di eliminare una protezione supplementare ke mi fa ridisabilitare il 2° pulsante,  ma come fare a trovarla? bhè, mi sono detto, ripercorriamo tutto ciò che il programma fà dopo la pressione di un tasto..eccioè...dopo la pressione di un tasto viene inviato un messaggio kiamato WM_COMMAND  che viene mandato ogniqualvolta l'utente seleziona un comando da un menù, quando un controllo manda un messaggio di notifica alla finestra a lui collegata, oppure quando si ha la pressione di un tasto ( appunto!). Mettiamo quindi un breakpoint su WM_COMMAND, ma questa non è un'"execution" (quindi non posso mettere un bpx ) bensì è un messaggio, per cui dovrò utilizzare il "breakpoint on message" (bmsg ), ma per utilizzare un bmsg ho bisogno dell'handle del messaggio, quindi aperto SIce (^D) scriverò " hwnd ottavo " e cerkerò tutti gli handle (prima colonna a sinistra ) ke nella colonna Class-Name hanno la scritta Button :

               Window Handle              Hqueue             SZ                Class Name

                   0A04                            3247               32                #32770 ( Dialog )
                   012C                            3247               32                Button
                   0644                             3247               32                Button
                   091C                            3247               32                Button
                   0A74                            3247               32                Button
                   .........
                   0888                             3247               32                Button
                   092C                            3247               32                Static
                   0A14                            3247               32                Button
                   ........

Si vabbè ma qual'è l'handle ke serve a me per il secondo pulsante...ehm bho!...cioè vanno provati tutti finkè pigiando poi il secondo pulsante il SoftIce non poppi, e quindi metterò 6 breakpoint con la sintassi: bmsg handle WM_COMMAND, uscirò dal SIce, premerò il secondo pulsante  e vedrò il SIce poppare dicendomi tra l'altro qual'è l'handle giusto, o meglio facendomi vedere qual'è il break ke ha avuto successo. Ah una cosa...gli handle cambiano ogni volta, quindi ogni volta ke riavviate il prog ricordatevi di riguardarvi gli handle !.
Dunque dicevamo...il nostro debugger ha poppato ( a me il secondo tasto risultava avere il 3° handle ) e siamo nel Kernel, premiamo dunque F12 finkè nella barra verde in basso non c compare la scritta MFC42 ( dovrebbero essere 7 volte ), a questo punto vediamo ke siamo sopra un RET, premiamo F10 e rifiniamo in "ottavo" e precisamente dopo una kiamata ke ormai c dovrebbe sembrare familiare, ovvero sotto una call 00401C7C all'adress 00401841, guardiamo un po' sopra e cosa vediamo :

:00401810   mov byte ptr [esp+10], al
:00401814   mov eax, dword ptr [00404020]
:00401819   mov dword ptr [esp+08], ecx
:0040181D   cmp eax, 0001E240 --- se eax è uguale a 0001E240 ...
:00401822   mov dword ptr [esp+0C], edx
:00401826   je 00401839 --- ... salta alla parte di codice che pone il flag = 0 altrimenti...
:00401828   mov al, 20
:0040182A   mov [esp+06], 52
:0040182F   mov byte ptr [esp+04], al
:00401833   mov byte ptr [esp+05], al
:00401837   jmp 00401846 --- ...si arriva qui dove questo saltino ci porta oltre tale codice

* Referenced by Jump at Address:
|:00401826(C)
|
:00401839   push 00000000 --- Qui dà di nuovo il valore del flag mettendolo uguale a Zero
:0040183B   lea ecx, dword ptr [esi+000000A0]--- Eggià qui ricarica l'handle del 2° pulsante

* Reference To: MFC42.Ordinal:0A52, Ord:0A52h
                                  |
:00401841   Call 00401C7C --- Non vi risulta familiare? Eggià è proprio una call a EnableWindow

* Referenced by a Jump at Address:
|:00401837(U)
|
:00401846   lea ecx, dword ptr [esp+04]
:0040184A   push ecx
:0040184B   push 000003EF

Come potete vedere si tratta di modificare quel je all'indirizzo 00401826, o noppandolo, o facendolo diventare un jne quindi sostituendo quel 7411 con un bel 9090 o con un 7511, in modo da far sempre arrivare il programma a quel jmp 00401846 ke , come potete vedere c porta aldilà di ogni preoccupazione :-)). Bene ora riavviamo il crackme, premiamo il primo pulsante e....alè "Registered "..vabbè questa la sapevamo già,..il secondo e...alèè "Registered ",... il terzo e...dho! "Unregistered " vabbè anke questa la sapevamo, non abbiamo fatto niente per lui...ankora >:-))

Seconda metà del terzo

Eccoci dunque al terzo pulsante, il procedimento da seguire qui è lo stesso ke per il secondo, riguardiamo infatti gli handle di "ottavo" con il SIce digitandovi " hwnd ottavo " e settiamo un bmsg handle WM_COMMAND per ogni handle con, ovviamente, scritto "Button " nella colonna "Class Name", usciamo da SIce (F5) e premiamo il terzo pulsante, scopriremo così qual'è l'handle del terzo bottone (  ke, vedrete, sarà il 4° handle ) e , dopo aver di nuovo premuto F12 tante volte quante ce ne serve per ritornare di nuovo in MFC42, premete F10 per eseguire il RET ke ci porterà...indovinate?...eggià proprio ad una nuova call 00401C7C (call EnableWindow ) ke stavolta si trova all'adress 004018DD, e come al solito, diamo uno sguardo a cosa la precede :

:00401884    mov eax, dword ptr [00404024]
:00401889    mov dword ptr [esp+08], ecx
:0040188D    cmp eax, 000003DB --- confronta eax con 3DB e se è uguale fa ....
:00401892    mov dword ptr [esp+0C], edx
:00401896    je 004018D8 ---...saltare questo jump ke ci porta alla parte ke pone il flag=0 ...
:00401898    mov al, byte ptr [00404214]
:0040189D    test al, al ---...sennò arriva qui dove confronta al con al e se non sono uguali..
:0040189F    jne 004018AD ---...questo salta e mi fà andare ad un jmp ke salta il "push 00" ...
:004018A1    cmp dword ptr [00404028], 0000029A ---...sennò fà ancora un confronto e se...
:004018AB    je 004018D8 --- ...il contenuto di 00404028 = 29A mi fà saltare al "push 00"

* Referenced by a Jump at Address:
|:0040189F(C)
|
:004018AD    mov ecx, dword ptr [00404208]
:004018B3    mov edx, dword ptr [0040420C]
:004018B9    mov ax, word ptr [00404210]
:004018BF    mov dword ptr [esp+04], ecx
:004018C3    mov cl, byte ptr [00404212]
:004018C9    mov dword ptr [esp+08], edx
:004018CD    mov word ptr [esp+0C], ax
:004018D2    mov byte ptr [esp+0E], cl
:004018D6    jmp 004018E2 --- pure questo salto mi fà saltare tutte le preoccupazioni ;-)

* Referenced by a Jump at Addresses:
|:00401896(C), :004018AB(C)
|
:004018D8    push 00000000 --- pusha il valore da dare al flag ovvero Zero
:004018DA    lea ecx, dword ptr [esi+60]--- Carica l'handle del 3° pulsante

* Reference To: MFC42.Ordinal:0A52, Ord:0A52h
                                  |
:004018DD    Call 00401C7C --- Guarda te ki si rivede ?! La riconoscete?

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004018D6(U)
|
:004018E2    lea edx, dword ptr [esp+04]
:004018E6    mov ecx, esi
:004018E8    push edx
:004018E9    push 000003F0

Dunque..bhè è facile... o si noppano tutti e tre i salti condizionali lasciando ke il prog arrivi tranquillamente all'esecuzione di quel jmp all'indirizzo 004018D6, oppure si invertono, oppure si può noppare/invertire il primo e rendere incondizionato il secondo sostituendo a quel 750C con un bel EB0C. Bene, cambiati i bytes?, okkei allora ora riavviamo il prog, l'avrete kiuso immagino per sostituire i bytes ;-) , e clikkiamo sul primo pulsante e...alèè "registered" ...vabbè ormai 'sta quì è vekkia; clikkiamo sul secondo e...alèèè "registered"...vabbè anke stà quì si sapeva; cliakkiamo sul terzo e.... alèèèè "registered", non
ci restano ora ke gli item di menù....andiamoli a vedè:

Item di menù, livello 4 e 5 ( prima metà di entrambi )

Okkei, eccoci alfine giunti agli Item di Menù, come vediamo il prog ha due voci di Menù disabilitate, andiamo dunque a vedere kon la guida delle API, su quale dobbiamo brekkare per far poppare SIce nel momento in cui viene toccato il menù...dunque c sono varie API, quale sarà quella giusta?..ehm.... proviamole tutte :-)), oki allora mettiamo un bpx su ognuna di queste API, e facciamo partire il crackme, il SIce poppa, facciamo "bl" per vedere quale dei bpx ha funzionato e trovo ke quello ke ha raggiunto lo scopo è il bpx su  EnableMenuItem di cui questa è la sintassi :

BOOL EnableMenuItem(

    HMENU hMenu,        // handle to menu
    UINT uIDEnableItem, // menu item to enable, disable, or gray
    UINT uEnable             // menu item flags
   );

Dunque, il SIce ha poppato e, se avete fatto partire il crackme da "Menù Avvio - Esegui ", premete una volta F12 e siete in "ottavo" subito sotto la kiamata, ma guardiamo un po' + sopra ke c stà :

:004015DD   mov ebx, dword ptr [00405498]
:004015E3   mov edi, eax
:004015E5   push 00000001 --- Il fatto ke il flag abbia valore 01 mi fà capire quale sarà

* Possible Ref to: MenuID_0083, Item: "Abilitami!" --- da qui si capisce ke si tratta del 5°
                                  |
:004015E7   push 00008003 --- Menù item da attivare, disattivare, o ingrigire
:004015EC   push edi      --- handle del menù
:004015ED   call ebx      --- call EnableWindowItem per il 5° livello
:004015EF   push 004041F8 --- dopo aver premuto una volta F12 arriviamo qui dove pusha la
:004015F4   push 000003F2     stringa "Unregistered"
:004015F9   mov ecx, esi

* Reference To: MFC42.Ordinal:1741, Ord:1741h
                                  |
:004015FB   Call 00401C76 --- call a SetDlgItemTexta ( l'avevamo già incontrata prima )
:00401600   push 00000001 --- valore del flag

* Possible Ref to Menu: MenuID_0083, Item: "Livello 4" --- ci fà capire ke si tratta del 4°
                                  |                        livello (ma và?)
:00401602   push 00008004 --- Menù Item da attivare, disattivare, o ingrigire
:00401607   push edi      --- handle del menù (come da sintassi )
:00401608   call ebx      --- di nuovo una call EnableMenuItem ma stavolta per il 4° livello
:0040160A   push 004041F8
:0040160F   push 000003F1
:00401614   mov ecx, esi

Ok dunque vediamo come c siano due kiamate a EnableMenuItem rispettivamente a 004015ED ed a 00401608, e vediamo come prima di queste vengano messi nello stack i valori sopra indicati nella sintassi, vediamo inoltre dalla guida delle API, ke il fatto ke il "menu item flag" valga 01, fà si ke tale Item venga ingrigito, ci sono infatti vari valori ke tale flag può prendere :
 

Value                                           Meaning

MF_BYCOMMAND  Indicates that uIDEnableItem gives the identifier of the menu item. If neither the                                   MF_BYCOMMAND nor MF_BYPOSITION flag is specified, the MF_BYCOMMAND flag is the default flag. = 0

MF_BYPOSITION    Indicates that uIDEnableItem gives the zero-based relative position of the menu item. = 400

MF_DISABLED        Indicates that the menu item is disabled, but not grayed, so it cannot be selected. = 2

MF_ENABLED         Indicates that the menu item is enabled and restored from a grayed state so that it can be selected.= 0

MF_GRAYED           Indicates that the menu item is disabled and grayed so that it cannot be selected. = 1

Il valore ke viene pushato è 01 e dunque, come potete vedere il valore del flag è GRAYED, per far abilitare le funzioni disabilitate, occorre dunque sostituire quei due "push 01" con due" push 00" , in modo tale da far avere al flag il valore di ENABLED, zero appunto.  Sostituiamo dunque i due 6A01 con due 6A00.
A questo punto abbiamo dunque abilitato i due Item di Menù, ma ankora non abbiamo finito...abbiamo infatti solo abilitato i due item, ma clikkandoli non salta fuori la scritta "registered", bensì rimane "Unregistered" pork...

Seconda metà dell' Item di Menù Livello 4

Allora, ora come sopraddetto abbiamo il pulsante abilitato, ma non c appare la stringa "registered", come fare? bhè, visto ke è bello riciclare ;-), riutilizziamo il comando WM_COMMAND, andiamo dunque a cercarci con il SIce gli handle (ke saranno diversi...come lo saranno ad ogni riavvio del proggy) e stavolta ci segnamo l'handle con scritto "Dialog " nella colonna "Class Name ", stavolta infatti c interessa qualsiasi WM_COMMAND mandato, cioè anke quelli dei menù. Poniamo dunque il nostro breakpoint on message : bmsg handle WM_COMMAND. Usciamo da SoftIce, e clikkiamo su Livello 4 ed ecco ke Sice poppa, premiamo 12 volte F12, ovvero lo premiamo finkè non c ritroviamo in MFC42, e poi da qui premiamo F10 eseguendo così quel ret ke c porta alla fine di una call ,all'indirizzo 004019FD dove c'è un cmp, e anke stavolta, alziamo lo sguardo e guardiamo ke ce stà più in alto :

:004019C3    mov eax, dword ptr [00404054] --- mette in eax la stringa "Unre"
:004019C8    push esi
:004019C9    mov edx, dword ptr [0040405C] --- mette in edx la stringa "ered"
:004019CF    mov esi, ecx
:004019D1    mov ecx, dword ptr [00404058] --- mette in ecx la stringa "gist"
:004019D7    mov dword ptr [esp+04], eax   --- mette la stringa "Unre" in esp+04
:004019DB    mov al, byte ptr [00404060]   --- mette anke il terminatore ("00") in al
:004019E0    mov dword ptr [esp+08], ecx   --- mette in esp+08 la stringa "gist", ora in esp+4
                                               c'è la stringa "Unregist"
:004019E4    lea ecx, dword ptr [esp+04]   --- mette la stringa "Unregist" in ecx
:004019E8    mov dword ptr [esp+0C], edx   --- mette in esp+0C la stringa "ered", ora in esp+4
                                               c'è la stringa "Unregistered"
:004019EC    push ecx                      --- Viene pushato ecx ke contiene "Unregistered"
:004019ED    push 000003F0
:004019F2    mov ecx, esi
:004019F4    mov byte ptr [esp+18], al     --- mette il terminatore alla stringa ("00")

* Reference To: MFC42.Ordinal:1741, Ord:1741h
                                  |
:004019F8    Call 00401C76 --- call a SetDlgItemTexta , non potete non averla riconosciuta ;-)
:004019FD    cmp dword ptr [004041F0], 0000000A --- confronta il contenuto di 4041F0 con Ah
:00401A04    jge 00401A17  --- salta se è maggiore o uguale
:00401A06    push 00404208 --- pusha la stringa "registered"
:00401A0B    push 000003F1
:00401A10    mov ecx, esi

* Reference To: MFC42.Ordinal:1741, Ord:1741h
                                  |
:00401A12    Call 00401C76 --- chiamata a SetDlgItemTexta ( ma và? )

* Referenced by a Jump at Address:
|:00401A04(C)
|
:00401A17    pop esi
:00401A18    add esp, 00000010
:00401A1B    ret

Come vedete dunque si hanno due chiamate a SetDlgItemTexta , una delle quali (la prima, all'indirizzo 004019F8 ) pusha la stringa "Unregistered" ed una , quella a 00401A12 che pusha la stringa "registered". Come potete vedere però, perkè la seconda avvenga, si rende necessario ke il jge all'indirizzo 00401A04, non salti, dunque, tale salto, o lo noppiamo, o lo invertiamo, sostituiamo quindi quel  7D11 con un bel 9090. Alèèèè, se ora clikkiamo sull'Item di Menù "Livello 4 " ci appare la stringa " registered " semo troppo forti !!

Ultima metà del 5° Livello

Ordunque c'è da fare un kiarimento, il Livello 5 infatti non tratta di Item di Menù, ma bensì di Voce di Menù, non è kambi molto ai fini della risoluzione del crackme, ma dopo si và in giro a dire ke Pincuzzo non distingue i fischi dai fiaschi ;-) ed allora è meglio precisare. Cmq, anke qui, come per il quarto livello, si parte settando un bel bmsg hadle_dialog WM_COMMAND, ovviamente ricordandosi di andare a rivedere quanto vale l'handle se il programma è stato riavviato.
Stavolta ovviamente, invece ke klikkare su "Livello 4 " faremo un click su "Abilitami !", il Sice popperà e c ritroveremo nel kernel, e qui cominciano i cavoli amari, infatti, dopo aver pigiato 3 volte F12 ci ritroviamo in MFC42, ma non riusciamo a tornare ad "Ottavo", se infatti ripremiamo F12 usciamo dal SIce, mentre se steppiamo con F10, o abbiamo un'eternità a disposizione, oppure a "Ottavo " un ci s'arriva, e non penso nemmeno ke un'eternità basti...l'ho provato ;-)) e quindi ..come fare? Bhè, a un certo punto mi viene in aiuto la mitica guida all'uso del SoftIce di GEnius nella quale è insita la guida ai breakpoint, e TADAA! penso di aver trovato il break che mi serve, ovvero un bpr, ovvero un "BreakPoint on Memory Range", ke mi scatterà ad ogni lettura/scrittura di bytes che mi avverrà in un determinato spazio di codice, già ma... in quale spazio?...eddai non fate gli avari....in tutto  il codice ke va dà 00401000 a 00403000, come? come faccio a saperlo? bhè,  disassemblate il programma con  WDasm e guardate alle prime righe, dove vengono segnate le sezioni :

Number of Objects = 0005 (dec), Imagebase = 00400000h

   Object01: .text    RVA: 00001000 Offset: 00000400 Size: 00001200 Flags: 60000020
   Object02: .rdata   RVA: 00003000 Offset: 00001600 Size: 00000800 Flags: 40000040
   Object03: .data    RVA: 00004000 Offset: 00001E00 Size: 00000200 Flags: C0000040
   Object04: .idata   RVA: 00005000 Offset: 00002000 Size: 00000800 Flags: C0000040
   Object05: .rsrc    RVA: 00006000 Offset: 00002800 Size: 00001200 Flags: 40000040

Quella che interessa a noi è la sezione .text, a volte sostituita da .CODE, ke contiene tutto il codice ke inizia all'RVA 1000 e finisce al 3000  . "Si vabbè, ma noi lì leggiamo da 1000 a 3000, non dà 00401000 a 00403000", ah giusto, dimenticavo,  bisogna usalre la formula : Imagebase + RVA , ovvero 00400000 + 1000 = 401000. Okkei, ora sappiamo da ke offset a ke offset deve operare il nostro bpr, non ci resta ke settarlo, dovremo dunque scrivere:  bpr offset_di_partenza offset_di_arrivo RW quindi : bpr 00401000 00403000 RW. Settiamo dunque il nostro bmsg handle_dialog WM_COMMAND, ed una volta ke il SIce ha poppato (Dopo aver quindi premuto "Abilitami !" ) mettiamo il nostro bpr 00401000 00403000 RW.  Ora premiamo F5 per uscire da SIce ed eccolo ke lui subito ripoppa, e ci troviamo in una schermata piena di jmp incondizionati, ma di kuesti nun ce ne può fregà de meno, quindi ripremiamo F5, e bom, rifiniamo in una skermata di jmp, continuando con F5 si avranno 5 skermate di jmp, poi quelle dei jmp si andranno ad alternare con una serie di skermate in cui saremo su dei ret ke se eseguiti ci portano in MFC42 facendoci così uscire da "Ottavo", finkè finalmente, con il dito stremato, dopo aver premuto ben 18 volte F5 arriviamo in quella ke sembra essere la nostra isola di salvezza, ovvero approdiamo qui :

:00401980   sub esp, 00000014 --- Approdiamo, è il caso di dirlo ;-), qui
:00401983   mov eax, ecx
:00401985   mov edx, dword ptr [004041F0] --- viene messo in edx il contenuto di 004041F0 che
                                              è un numero ke kambia ad ogni riavvio del proggy
:0040198B   mov ecx, 00000005 --- ecx fà da contatore ed in esso viene messo 05
:00401990   push esi
:00401991   push edi
:00401992   mov esi, 0040410C --- Viene messa in esi la stringa ".InArrivoLoStrainer"
:00401997   lea edi, dword ptr [esp+08]
:0040199B   repz
:0040199C   movsd
:0040199D   movsx ecx, byte ptr [esp+0B] --- viene messo in ecx la lettera "A"
:004019A2   cmp ecx, edx --- viene confrontato il valore ex di A ovvero 41 con il numero in edx
:004019A4   jle 004019B7  --- salta se è minore
:004019A6   push 00404208 --- pusha la stringa "registered"
:004019AB   push 000003F2
:004019B0   mov ecx, eax

* Reference To: MFC42.Ordinal:1741, Ord:1741h
                                  |
:004019B2   Call 00401C76 --- chiamata a SetDlgItemTexta

* Referenced by a Jump at Address:
|:004019A4(C)
|
:004019B7   pop edi --- qui arriviamo se il jle salta.
:004019B8   pop esi
:004019B9   add esp, 00000014
:004019BC   ret

Dunque mi sembra kiaro, viene messo in ecx un carattere, in questo caso il 4° della stringa ".InArrivoLoStrainer" , il cui valore esadecimale, 41 , viene confrontato con un numero, sempre diverso e cmq con l'ultimo byte sempre maggiore di 41, contenuto
in edx, quindi, se il valore 41 è minore di tale numero, e lo sarà sempre, il salto all'adress 004019A4 salta e passa oltre la call SetDlgItemTexta ke mi avrebbe fatto apparire la stringa "registered" pushata all'indirizzo 004019A6. La soluzione stà quindi nel noppare o invertire  quel jle sostituendo a quel 7E11 un bel 9090 per nopparlo od un 7D11 per farlo diventare un jge 4019B7.

Bene, una volta effettuate le modifiche rendendole permanenti coll'editor exadecimale e tolti tutti i bp dal SIce, riavviamo il proggy e..Livello 5...Abilitami!..."registered"....alèèè FINE!! l'avevo detto io ke eravamo troppo forti!!

CiauZZ Ragaaaa---BUON NATALEEEEE

            PincoPall

Okkey, tutto torna, tranne una cosa, non so perkè, quando pigio Livello 3 , lì accanto mi appare la scritta "registered", poi premo Livello 4 e accanto alla scritta " livello 4" mi appare la scritta "registered", ma accanto alla 3 mi riappare "Unregistered", e mi basta ripremere Livello 3 perkè tutto venga "registered" , ovvero, lo torni il 3 e lo rimanga il 4. Andrew..ke l'hai fatto apposta?...Ke è un buggino?...ke sono io ke ho fatto qualke kosa "ad cazzum"? bho!

Un saluto a TUUUTTA la ML, a TUUUTTI quelli del canale #crack-it ed in particolare ad AndreaGeddon ke mi fà questi bei corsi ke almeno mi fanno stare un po' di tempo senza studiare hihihihi...... Ah Andrew, io i soldi per la registrazione del crackme li ho mandati al Que attaccati con lo scotch a 'sto tutorial, per cui, se non t sono arrivati, o si sono persi (cosa mooolto improbabile ), o se li è intaascati lui ;-))))
Un saluto inoltre a B3bos, Ni0, C1CC10 e GiPOCO ke mi scarrozzano in giro per l'Italia ai vari hackmeeting e ke se non li saluto poi non mi portano +....skerzo skerzo hihihihi

Fuck To: Quegli s*ron*i di www.grandefratello.it ke mi hanno segato il sito (pincopallrulez.grandefratello.it)...

A chi lo dici, chi se lo ricorda il mio: www.marina-fa-le-pompe-al.grandefratello.it? NdQue

               Pincopall> Oh no Mi hanno ammazzato il sito
               Cail> Brutti bastardi!!  :-)

Vi ricordo 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: all'interno del tutorial non ho mai menzionato nulla che possa istigarvi ad utilizzare impropriamente quanto imparato. 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.