Abilitiamo quello che Andreuzzo ha disabilitato!

Ottavo

(le funzioni disabilitate non sono un granché come restrizione :)

Written by The Hellfish

Bè c'è poco da introdurre su questo progetto. Vediamo come raggirare un programma con funzioni disabilitate.

SoftIce

Win32Dasm

Hiew

The Customizer

www.uic-spippolatori.com

Anche qui poco da dire, questo è programma che permette di realizzare disegni 3D, con funzioni avanzatissime e costa 1000000 di lire da versare sul conto corrente di Andreageddon. Se non lo registrate le funzioni "Livello" sono disabilitate. Personalmente io lo comprerei solo per la funzione "3° livello" perché è la funzione + interessante! Ovviamente sto scherzando, andiamo avanti...

Come diavolo si farà ad abilitare sti bottoni? Beh innanzi tutto è buona cosa sapere da che punto attaccare il programma. Se disassembliamo il prog troveremo all'inizio queste cosucce:

Import Module 004: USER32.dll

Addr:00005604 hint(00B0) Name: EnableMenuItem

Addr:0000569A hint(00B2) Name: EnableWindow

Allora, la prima delle 2 api ci servirà in seguito per adesso guardiamo la seconda. Questa ci servirà per fare poppare il sice quando all'apertura del programma si disabiliteranno i pulsanti. Allora iniziamo, BPX ENABLEWINDOW, eseguiamo il prog e quando sice poppa guardiamo il codice sopra

:004014C0 mov byte ptr [00404211], cl

:004014C6 mov byte ptr [00404203], cl

:004014CC push 00000000 ---> IMPORTANTE!

:004014CE lea ecx, dword ptr [esi+000000E0]

:004014D4 mov byte ptr [00404208], 52

:004014DB mov byte ptr [00404209], bl

:004014E1 mov byte ptr [0040420A], 67

:004014E8 mov byte ptr [0040420B], 69

:004014EF mov byte ptr [0040420C], 73

:004014F6 mov byte ptr [0040420D], dl

:004014FC mov byte ptr [0040420E], bl

:00401502 mov byte ptr [0040420F], al

:00401507 mov byte ptr [00404210], bl

:0040150D mov byte ptr [00404212], 00

:00401514 mov byte ptr [004041F8], 55

:0040151B mov byte ptr [004041F9], 6E

:00401522 mov byte ptr [004041FA], al

:00401527 mov byte ptr [004041FB], bl

:0040152D mov byte ptr [004041FC], 67

:00401534 mov byte ptr [004041FD], 69

:0040153B mov byte ptr [004041FE], 73

:00401542 mov byte ptr [004041FF], dl

:00401548 mov byte ptr [00404200], bl

:0040154E mov byte ptr [00404201], al

:00401553 mov byte ptr [00404202], bl

:00401559 mov byte ptr [00404204], 00

:00401560 Call 00401C7C

:00401565  push 004041F8

:0040156Apush 000003EE

:0040156F mov ecx, esi

:00401571 Call 00401C76

:00401576 push 00000000 ---> IMPORTANTE!

:00401578 lea ecx, dword ptr [esi+000000A0]

:0040157E Call 00401C7C

:00401583 push 004041F8

:00401588 push 000003EF

:0040158D mov ecx, esi

:0040158F Call 00401C76

:00401594 push 00000000 --->IMPORTANTE!

:00401596 lea ecx, dword ptr [esi+60]

Dunque dunque, indovinate cosa sono quei push 0... Se non ci siete arrivati ve lo dico io, sono i flag che dicono all'api ENBLEWINDOW cosa fare (0=disabilitato, 1=abilitato), quindi mi sembra una buona cosa cambiare quei push 0 in push 1. In questo modo abbiamo abilitato i 3 button. Apriamo di nuovo il prog e clicchiamo sul 1° livello, REGISTERED! Ora clicchiamo sul secondo e... UNREGISTERED! Porc! Bè niente paura sarà un controllino stupido evitabile invertendo qualche jump, il problema è: dov'è sto controllo?? Facciamo una cosa noi, apriamo il customizer, selezioniamo il tasto prendiamo nota del suo handle. In sice poi scriveremo bmsg handle wm_enable, clicchiamo sul secondo e steppa che ti steppa arriviamo qui

:0040180A mov ecx, dword ptr [00404058]

:00401810 mov byte ptr [esp+10], al

:00401814 mov eax, dword ptr [00404020]

:00401819 mov dword ptr [esp+08], ecx

:0040181D cmp eax, 0001E240

:00401822 mov dword ptr [esp+0C], edx

:00401826 je 00401839  ---> IMPORTANTE!

: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

:00401839 push 00000000 ---> FLAG BALORDO!

:0040183B lea ecx, dword ptr [esi+000000A0]

:00401841 Call 00401C7C

:00401846 lea ecx, dword ptr [esp+04]

:0040184A push ecx

:0040184B push 000003EF

:00401850 mov ecx, esi

:00401852 Call 00401C76

:00401857 pop esi

:00401858 add esp, 00000010

:0040185B ret

Osserviamo il jump condizionato a 401826: se esegue il salto finisce su un push 0 se invece non lo esegue, il jmp che c'è dopo gli fa saltare questo push 0. Vi ricordo che push 0 è il flag negativo, cosa ci rimane da fare quindi? Invertiamo o noppiamo questo je!! Bene bene, ora clicchiamo sul terzo e naturalmente anche lui farà la sua balordata: diventa grigio. Uffa! Ripetiamo il procedimento di prima per questo pulsante (devo dirvelo che l'handle sarà diverso?) e dopo aver messo il breakpoint, dopo aver cliccato sul bottone e dopo aver steppato arriviamo qui!

:00401889 mov dword ptr [esp+08], ecx

:0040188D cmp eax, 000003DB

:00401892 mov dword ptr [esp+0C], edx

:00401896 je 004018D8 ---> IMPORTANTE!

:00401898 mov al, byte ptr [00404214]

:0040189D test al, al

:0040189F jne 004018AD ---> questo non ci darà fastidio

:004018A1 cmp dword ptr [00404028], 0000029A

:004018AB je 004018D8 ---> IMPORTANTE!

: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

:004018D8 push 00000000 ---> FLAG BALORDO!

:004018DAlea ecx, dword ptr [esi+60]

:004018DD Call 00401C7C

:004018E2 lea edx, dword ptr [esp+04]

:004018E6 mov ecx, esi

:004018E8 push edx

:004018E9 push 000003F0

:004018EE Call 00401C76

:004018F3 pop esi

:004018F4 add esp, 00000010

:004018F7 ret

Lo schema è simile a quello precedente questa volta al posto di avere un controllo ne abbiamo 2 se seguite il codice vi accorgerete che per il resto è uguale a prima perciò noppiamo a 401896 e a 4018ab! E anche questo livello è finito! Ora passiamo ai menu, e vediamo come abilitarli. Avete presente quell'api che vi o detto che ci servirà in seguito? Vabè era EnableMenuItem. Quest'api funziona allo stesso modo di EnableWindow quindi anche qui dovremo andare a cercare il flag che fa diventare disabilitato il pulsante. BPX ENABLEMENUITEM, avviate il prog, premete F5 fino a quando in basso a destra non c'è scritto OTTAVO e poi steppate fino a fuori la call. Guardate il codice sopra:

:004015B8 Call 00401C70

:004015BD mov eax, dword ptr [esp+10]

:004015C1 mov [esp+1C], 00000001

:004015C9 push eax

:004015CA push 00000000 ---> FLAG BALORDO

:004015CC push 00000000

:004015CE push 00000000

:004015D0 Call dword ptr [00405480]

:004015D6 push eax

:004015D7 Call dword ptr [00405490]

:004015DD mov ebx, dword ptr [00405498]

:004015E3 mov edi, eax

:004015E5 push 00000001

 Come potete vedere anche qui ci sono i famosi push 0. Mettendo push 1 al primo abiliteremo sia il 5° livello che il 4°. Ora dobbiamo fare in modo che ci registri. Se adesso andiamo a cliccare sul 4° livello e noteremo con dispiacere che sul 3° viene scritto UNREGISTERED. Eh già un'altra piccola trappola di Andrea, vediamo come procedere. Abbiamo 2 problemi ora: registrare il 4° ed evitare che venga annullato il terzo. Dato che il 4° livello influisce sul 3° mettiamo un BMSG HANDLE_TERZO_LIVELLO WM_COMMAND. Clicchiamo sul quarto, steppiamo ed arriviamo qui:

:004019C0 sub esp, 00000010

:004019C3 mov eax, dword ptr [00404054]

:004019C8 push esi

:004019C9 mov edx, dword ptr [0040405C]

:004019CF mov esi, ecx

:004019D1 mov ecx, dword ptr [00404058]

:004019D7 mov dword ptr [esp+04], eax

:004019DB mov al, byte ptr [00404060]

:004019E0  mov dword ptr [esp+08], ecx

:004019E4 lea ecx, dword ptr [esp+04]

:004019E8 mov dword ptr [esp+0C], edx

:004019EC push ecx

:004019ED push 000003F0 ---> QUI C'è UN BUG

:004019F2 mov ecx, esi

:004019F4 mov byte ptr [esp+18], al

:004019F8 Call 00401C76

:004019FD cmp dword ptr [004041F0], 0000000A

:00401A04 jge 00401A17 ---> IMPORTANTE

:00401A06 push 00404208

:00401A0B push 000003F1

:00401A10  mov ecx, esi

:00401A12 Call 00401C76 ---> CALL CHE DICE REGISTERED

:00401A17 pop esi

:00401A18 add esp, 00000010

:00401A1B ret

Il salto condizionato a 401a04 determina se il 4° livello è registrato. Trascurando le condizioni di questo salto possiamo notare che se il salto avviene, la call a 401a12 non viene eseguita. Cosa faremo noi allora? Noppiamo a 401a04! La seconda bastardata viene attuata prima di questo salto. Guardate il push a 4019ed, qui c'è un errore (o bagolo come lo chiama Andre :) e se si cambia in push 3f1 abbiamo risolto i nostri problemi! Siamo finalmente arrivati al quinto e ultimo livello. Questo è più difficile degli altri perché bisogna attaccarlo con un metodo diverso da quelli di prima. All'inizio qui stavo diventando scemo con il solito breakpoint sull'handle ma poi fortunatamente Andreuzzo mi ha suggerito: "parti dal presupposto che il programma DEVE tornare al processo dell'ottavo, quindi devi trovare un modo per monitorare ogni esecuzione del codice dell'ottavo dal break su WM_COMMAND in poi". In seguito ho capito a cosa serviva il comando BPR in sice :). Partiamo mettendo un bmsg sull'handle della dialog (col customizer dovete selezionare la finestrella del prog Ottavo). BMSG HANDLE_DIALOG WM_COMMAND, clicchiamo sul quinto livello e su "Abilitami" e vediamo cosa succede. Il debugger a questo punto finisce in mare di loop infiniti che la MFC continua a fare, dobbiamo trovare un modo per risalire al codice. In sice esiste un comando che ci permette di vedere le sezioni del programma, cioè map32. Scrivete MAP32 OTTAVO in sice e prendete nota degli indirizzi di inizio e di fine della parte di .TEXT vi dico io che sarà da 401000 a 403000. Come vi dicevo prima il comando BPR (breakpoint on memory range) ci permette di brekkare nell'intervallo di indirizzi che gli diamo perciò noi faremo in questo modo: BPR 401000 403000 R In questo modo abbiamo un breakpoint su ogni parte di codice che sta in quel intervallo; la R sta per READ, se non la mettete sice prenderà il breakpoint di default in WRITE. Ricapitoliamo: settiamo il BMSG, clicchiamo ABILITAMI nel quinto livello, settiamo il BPR e schiacciamo F5 fino a quando non siamo qui:

:00401980 sub esp, 00000014

:00401983 mov eax, ecx

:00401985 mov edx, dword ptr [004041F0]

:0040198B mov ecx, 00000005

:00401990 push esi

:00401991 push edi

:00401992 mov esi, 0040410C

:00401997 lea edi, dword ptr [esp+08]

:0040199B repz

:0040199C movsd

:0040199D movsx ecx, byte ptr [esp+0B]

:004019A2 cmp ecx, edx

:004019A4 jle 004019B7 ---> UHM... UN SALTO CONDIZIONALE?

:004019A6 push 00404208

:004019AB push 000003F2

:004019B0 mov ecx, eax

:004019B2 Call 00401C76 ---> CALL CHE SCRIVE REGISTERED

:004019B7 pop edi

:004019B8 pop esi

:004019B9 add esp, 00000014

:004019BC ret

Ormai il grosso è fatto, se siamo arrivati fin qui abbiamo finito. Vedete quel jmp condizionale? Trascurando, come al solito, per quali condizioni salta o meno lavoriamo un attimo di logica: vediamo una call, vogliamo che venga eseguita, il salto andrebbe oltre la call, cosa ci rimane da fare? Ovviamente invertire o noppare il jmp, niente di più semplice!

                                               The Hellfish

Wow! Ed anche questa è fatta! Volevo iniziare complimentandomi con Andreone per l'ottimo crackme, che mi ha insegnato tante cose, e per le cose che si degna di insegnarmi quando lo becco su irc, grazie 1000! Un saluto al Que ed Olga, se lo strainer è davvero così cattivo chissà che programmazione ci sta dietro, grandi! Un saluto al Bieco, al quale tra l'altro devo la grafica del mio sito, un saluto a tutti i membri di #crack-it che non ho nominato e che spero non si sentano offesi ed infine un saluto a te che stai leggendo questo tutorial. Ciauzzzz.....

Vorrei ricordare 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. 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.