.

09d: Tutorial
Contents

1 OllyDbg 1.09d: Tutorial o 1.1 Introduction o 1.2 Tools o 1.3 Notizie sul Programma o 1.4 Essay 1.4.1 OllyDbg - I Menu 1.4.1.1 Prima di File 1.4.1.2 File 1.4.1.3 View 1.4.1.4 Debug 1.4.1.5 Plugins 1.4.1.6 Options 1.4.1.7 Window 1.4.1.8 Help 1.4.2 OllyDbg - Le Finestre 1.4.2.1 Log 1.4.2.2 Executable Modules

o o

1.4.2.3 Memory 1.4.2.4 Heap 1.4.2.5 Threads 1.4.2.6 Windows 1.4.2.7 Handles 1.4.2.8 CPU 1.4.2.9 CPU: Disassembler Window 1.4.2.10 CPU: Registers Window 1.4.2.11 CPU: Dump Window 1.4.2.12 CPU: Stack Window 1.4.2.13 Patches 1.4.2.14 Call stack 1.4.2.15 Breakpoints 1.4.2.16 Watches 1.4.2.17 References 1.4.2.18 Run Trace 1.4.2.19 Source 1.4.2.20 Source files 1.4.3 OllyDbg - Hands On: CM68 by Eimiar 1.4.3.1 Analisi Iniziale 1.4.3.2 Reversing della Routine 1.4.3.3 Creazione di un Keygen 1.5 Note Finali 1.6 Disclaimer

Author: Email: Website: Date: Level: Language: Comments:

OllyDbg 1.09d tutorial Bender0 http://www.bender0.altervista.org/ 18/02/2004 (dd/mm/yyyy) Italian Ho vinto il premio per la TOC pi lunga della storia!

Introduction
Tutti dicono che non si trovano tutorial sull'olly, ergo.. eccovene uno! Uff... 60k di tute! Scritto per i newbies che hanno poca esperienza (poca significa che un minimo di assembly lo dovete sapere) o per chi vive a pane e softice e vuole conoscere questo prog.

OllyDbg (anche grazie ai numerosi problemi di installazione di softice nei nuovi os) sta spopolando. un debugger che lavora in user mode, ovvero non pu fare pi degli altri programmi di win avendo gli stessi privilegi, il che un difetto rispetto a s-ice. Ma per il reversing di tutti i giorni comunque un ottima scelta, anche perch pi potente di quanto sembri... Alla fine del tute c' anche una sezione hands-on: il nostro bersaglio sar il Crackme n68 di Eimiar, molto semplice per cominciare. Lo trovi a questa pagina: Crackme 51 - 75.

Tools
Beh, se non lo volete solo contemplare questo tute penso che vi servir OllyDbg! Io ho la versione 1.09d (step 4).

Notizie sul Programma

La protezione (nome\serial) del crackme davvero basilare, ma lo scopo di questo tute di isegnarvi a steppare con ollydbg... inoltre l'ho scelto perch c' una vulnerabilit interessante ;-) nel controllo del serial.

Essay
Eccoci qua. Direi di cominciare descrivendo la funzione di tutti i menu del prog. NOTA: per chi non lo sapesse, un context menu un men popup il cui contenuto varia a seconda di dove si clickato per farlo comparire, e che di solito associato al tasto destro del mouse...

OllyDbg - I Menu
Prima di File C' un icona che indica con una lettera la finestra attualmente maximizzata all'interno dell'olly. Per navigare tra le finestre aperte o cliccate su questa icona e scegliete "successivo" o usate lo shortcut CTRL+F6. Lo shortcut permette di attivare la finestra successiva in ogni momento (non necessario che le finestre siano maximizzate). Vedi la sezione OllyDbg - Le Finestre. File

Open (F3):

Carica un eseguibile (*.exe) in ollydbg. Anche tutte le librerie linkate staticamente all'eseguibile sono caricate ora, mentre quelle linkate dinamicamente sono caricate solo quando il programma lo richiede.

Attach:

Apre una finestra con una tabella che permette di selezionare il processo IN ESECUZIONE a cui ollydbg si deve "attaccare"; praticamente puoi caricare in olly un programma "on the fly". La tabella in ordine specifica: ID del processo - nome del processo - nome della finestra principale del processo - percorso del modulo associato al processo. Seleziona il processo che ti interessa e premi "attach" oppure esci con "cancel". Cliccando col destro sulla tabella si apre un context menu che contiene utili opzioni per copiare tutta la tabella o parte di essa, oltre a delle opzioni per personalizzare la visualizzazione della tabella.

Exit (Alt+X):

Esce da OLLYDBG, non dal processo che si sta debuggando. Chiude (o almeno ci prova) anche il processo che si sta debuggando.

Recent files list:

Sotto a Exit c' una lista degli ultimi file caricati in ollydbg. Per caricare l'ultimo aperto basta premere Ctrl+F2. View

Finestre:

Vari comandi e relativi shortcut relativi all'apertura delle finestre di ollydbg. Vedi la sezione OllyDbg - Le Finestre.

File:

Praticamente un mini hex-editor all'interno di ollydbg. Col context menu (click dx) permette di fare modifiche e salvarle nel file, creare backup, etc. Se si carica un file PE e si sceglie specialPE header ollydbg isola il l'header PE e ne riconosce le varie parti "traducendole" nella colonna a destra. Molto utile per avere informazioni sulle sezioni, etc.

Text file:

Apre la finestra source caricando il file sorgente scelto. Visualizza il numero della linea sulla sinistra. Debug Premessa: cercate di ficcarvi in testa gli shortcut di questi comandi se volete usare ollydbg!

Run (F9): esecuzione libera

Il comando cede in controllo al programma debuggato che pu eseguirsi liberamente. Quando si carica un modulo in ollydbg di default lui si ferma sull'entry point in modalit PAUSED. Con questo comando si "fa partire" il programma. Se durante l'esecuzione dei breakpoints vengono attivati il controllo ritorna all'olly che si mette in modalit PAUSED. Per ripristinare l'esecuzione del programma usare questo comando.

Pause (F12): pausa (ma va?)

OllyDbg ferma l'esecuzione del programma debuggato e si prende il controllo. Quando il programma in modalit PAUSED si pu steppare, modificare i registri, e fare molte cose che ci piacciono tanto!

Restart (Ctrl+F2): ricomincia da capo

Ricarica il programma dall'entry point in modalit PAUSED proprio come se l'aveste appena aperto. Utile quando si fatto qualche casino irreversibile o se si deve semplicemente ricominciare tutto da capo!

Close (Alt+F2): chiudi

Chiude il programma debuggato.

Step into (F7): passo e entra

Questo comando, che pu essere utilizzato solo in modalit PAUSED, fa avanzare l'esecuzione del prog di UNA istruzione. Se l'istruzione da eseguire una chiamata a funzione (call) vi ritroverete dentro la funzione.

Step over (F8): passa sopra

Questo comando, che pu essere utilizzato solo in modalit PAUSED, fa avanzare l'esecuzione del prog di UNA istruzione. Se l'istruzione da eseguire una chiamata a funzione (call) tale funzione viene eseguita e vi ritroverete all'istruzione che seguiva la chiamata.

Animate into (Ctrl+F7):

Simula una serie di "step into", come se si tenesse premuto il tasto F7. Il programma viene eseguito passo-passo finch non si preme esc o un comando di controllo (F7,F8,F9,F12...). L'animate pu fermarsi anche se si incontrano breakpoint o se si verifica un eccezione.

Animate over (Ctrl+F8):

Simula una serie di "step over", come se si tenesse premuto il tasto F8. Il programma viene eseguito passo-passo finch non si preme esc o un comando di controllo (F7,F8,F9,F12...). L'animate pu fermarsi anche se si incontrano breakpoint o se si verifica un eccezione.

Execute till return (Ctrl+F9): esegui fino al return

Il programma viene eseguito finch non si incontra un'istruzione di ritorno da chiamata (come ret). Se entrate per errore in una funzione sulla quale invece volevate "passare sopra" il modo pi rapido per uscirne.

Execute till user code (Alt+F9):

Comando molto utile. Se (ad esempio per un breakpoint) l'esecuzione si ferma in una dll di sistema, questo comando esegue il programma finch non incontra un istruzione non di sistema.
Esempio: Avete messo un breakpoint on execution su una API X che risiede in una dll. Dopo averne ripristinato l'esecuzione con F9, il programma che state

debuggando chiama una API Y, la quale chiama un'altra funzione in un'altra dll, la quale chiama la API X sulla quale avete messo il breakpoint. L'esecuzione si ferma e vi trovate persi e non riuscite a steppare fuori da queste dll. Premendo Alt+F9 vi ritrovate all'interno del codice del programma subito dopo la chiamata alla API Y.

Open or clear run trace:

Serve per iniziare una sessione di run trace (vedi sotto) oppure a svuotare il buffer di run trace per ricominciare.

Trace into (Ctrl+F11):

L'esecuzione in run trace per certi versi simile all'animate, olly esegue il programma step by step (entrando nelle funzioni con trace into e saltandole con trace over). Ci sono per due differenze fondamentali: 1. Il run trace si ferma anche se si incontrano certe condizioni settate dall'utente (vedi set condition). 2. Durante il run trace olly salva in un buffer i contenuti dei registri e tutto quello che serve per consentire lo "step all'indietro". Si, avete sentito bene, all'indietro... ovviamente non si riavvolge l'esecuzione del programma ma si pu vedere cosa ha fatto durante il run trace. Una volta fatto partire il run trace, fermatelo (con F12 ad esempio) e premete il tasto - (meno): olly ci mostra cosa succedeva al comando precedente, e cos via. Ovviamente tasto + per tornare avanti. Notate che la sezione registri e la zona sotto il disassemblato si scuriscono? Serve ad indicare che il cursore non all'attuale punto di esecuzione del programma, ma pi indietro (mi viene da dire "nel passato"!). Per capire le potenzialit aggiunte del run trace, vedi set condition.

Trace over (Ctrl+F12):

Vedi trace into.

Set Condition (Ctrl+T):

Bene, Ctrl+T e si apre una finestrella. Vi sono vari tipi di "condizioni" che si possono settare per stoppare il run trace. Vediamole: EIP is in range stop se l'istruzione da eseguire si trova nel range specificato. EIP is outside the range stop se l'istruzione da eseguire si trova fuori dal range specificato. Condition is TRUE stop se si verifica la condizione specificata. Per la sintassi delle condizione vedere "Evaluation of expressions" nell'help di ollydbg. Un esempio? 'eax = 1' oppure 'al = cl' o ancora 'eax == "Seriale esatto!"' (in quest'ultimo caso eax considerato un pointer a stringa). Command is suspicious or possibly invalid stop se l'istruzione da eseguire da considerarsi non valida. Per settare che istruzioni devono essere considerate non valide nelle debugging options (Alt+O) scegliere il tab analysis 3. Command is one of stop se l'istruzione da eseguire del tipo specificato. La sintassi semplice, far alcuni esempi: xor r8,r8 uno xor tra due registri a 8 bit qualsiasi (al,bl,cl...) add r32,r32 un add tra due registri a 32 bit (per es. add ecx,edx) cmp r32,CONST confronto tra un registro a 32 bit e una costante numerica (per es. cmp eax,1) jcc OFFSET salto condizionale a un offset qualsiasi

Ce ne sono altri, li potete trovare nella guida dell'olly sotto "assembler" dove dice "imprecise commands".

Close run trace:

Svuota il buffer del run trace.

Hardware breakpoints:

Con ollydbg si possono settare 4 breakpoint "hardware". Con questi si pu breakkare nel prog senza sostituire un int3 all'istruzione. Non si possono settare da qui, ma con il context menu sulla cpu window (vedi OllyDbg - Le Finestre). Da qui puoi cercarli nel disassemblato o eliminarli.

Inspect:

Bene, l'inspector serve a visualizzare il contenuto di un array mono- o bi-dimensionale in una tabella di cui potete specificare le dimensioni. Non capisco come usarlo per un'array 2d, ma se ad esempio specificate "[eax+4*%A]" con un range per %A di ad es. 10 e 1 per %B vedrete la dword puntata da eax e i 9 valori successivi. Pratico per visualizzare strutture.

Arguments:

Permette di specificare gli argomenti passati al prog debuggato quando viene lanciato. Se l'avete gi lanciato dovete riavviarlo per vedere gli effetti (ovviamente!). Provate a specificare il percorso di un file *.txt e lanciare il buon vecchio notepad e... MAGIA!... notepad si apre proprio con quel file!

Select import libraries:

Serve a caricare dei file *.lib che olly user per sostituire i nomi delle funzioni esportate dalle dll caricate ai rispettivi ordinali.

Select path for symbols:

Specifica la cartella da dove olly andr a leggere i file con le informazioni simboliche di debug. Plugins Visualizza dei men relativi ai plugin caricati all'avvio da ollydbg. Quelli distribuiti assieme al prog sono 2:

Command line

Utilissimo plug-in che permette di inserire comandi in command-line come su s-ice. Si apre con Alt+F1. I comandi che ci interessano di pi (breakpoints!): bp [nome api\indirizzo] Per settare breakpoint on execution (come il bpx in softice). Attenzione: al contrario di softice olly molto fiscale riguardo ai nomi della API qui specificati, in termini di maiuscole\minuscole. bpx [...] Strano comando. Qualsiasi cosa si scriva dopo bpx si apre una finestra che contiene tutte le chiamate a API che partono dal modulo che si sta debuggando... o il mio pc andato a

puttane... bc [nome api\indirizzo] Per rimuovere il break sulla API o all'indirizzo specificato. mr [start addr] [end addr] Setta un memory breakpoint sull'accesso a un certo range in memoria, specificato da start e end. mw [start addr] [end addr] Setta un memory breakpoint sulla scrittura in un certo range in memoria, specificato da start e end. md Rimuove il memory breakpoint attivo (settato con mr o mw) hr [indirizzo] Setta un breakpoint hardware che scatta quando si accede alla memoria all'indirizzo specificato. hw [indirizzo] Setta un breakpoint hardware che scatta quando si scrive sulla memoria all'indirizzo specificato. he [indirizzo] Setta un breakpoint hardware che scatta quando si esegue l'istruzione all'indirizzo specificato. hd [indirizzo] Elimina il breakpoint hardware all'indirizzo specificato.

Bookmarks

Semplice sistema di bookmarks (segnalibri) ovvero parti del codice dove vogliamo tornare spesso senza ricordarci l'indirizzo a memoria... per aggiungere un bookmark cliccare col destro nella code window e scegliere bookmarkinsert bookmark X. Options

Appearance

Apre una finestra che contiene NUMEROSE opzioni di visualizzazione che per la maggior parte si spiegano da sole. La sezione code highlighting permette di personalizzare il modo in cui ollydbg visualizza i vari opcode nel disassemblato. un opzione molto utile!

Debugging options (Alt+O)

Apre una finestra che contiene tutte le opzioni di debug di ollydbg (sono TANTISSIME). Vediamo i men pi importanti: Exceptions: Consente di specificare quali eccezioni ignorare (ovvero passare al programma) tra quelle note, e anche di specificare un range di eccezioni da ignorare (io le ignoro TUTTE, cio 00000000 .. FFFFFFFF per non avere problemi). Events: Si pu scegliere dove si deve pausare il programma quando viene caricato, prima che il sistema chiami il nostro programma, all'entry point (lo consiglio) o alla winmain. Si pu anche dire all'olly di fermarsi se vengono caricate\rilasciate dll, se vengono avviati\terminati thread, o se il programma chiama OutputDebugString per farci sapere qualcosa. Da modificare a seconda della situazione, perch puo diventare molto fastidioso - provate a reversare winamp 5 con le opzioni delle dll e dei thread attivate e capirete cosa intendo. Disasm: Opzioni relative all'output disassemblato nella finestra CPU. Giocateci un p e vedete con quali vi trovate meglio. Cpu: Consiglio di mettere la v su "show direction of jumps" e su "show jump path", che rendono pi

facile seguire visualmente il flow del programma. Le altre opzioni sono buone di default (imho), ma ci non vi impedisce di smanettare...

Just-in-time debugging

Configura ollydbg per essere\non essere il debugger just-in-time, ovvero il debugger che windows lancia se un programma crasha. C' anche l'opzione per "attaccarsi" al programma crashato senza chiedere conferma.

Add to explorer

Aggiunge\toglie l'opzione "Open with ollydbg" al context men che si apre con un click destro su un file .exe in explorer. Window Contiene le solite opzioni per organizzare le finestre aperte (tile,cascade...) e la lista di quelle aperte per saltare da una all'altra. Help

About

Che dire della about box? Carina. Mi piace l'icona dell'olly...c' ADDIRITTURA un link al sito! ;-)

Contents

Apre l'help file di ollydbg.

Select API help file

Permette di selezionare la tua guida delle API preferita che in seguito pu essere aperta con il successivo men.

Open API help file

Apre la guida selezionata col men precedente.

OllyDbg - Le Finestre
Ecco le finestre nell'ordine in cui sono listate nel menu view: Log Un semplice log, con informazioni sui plug-in caricati, moduli caricati e scaricati ecc ecc. Executable Modules I moduli attualmente caricati nell'olly. Contiene anche path del modulo, versione, nome ms-dos... Interessante l'opzione del context menu "view all resources" che crea un'elenco delle risorse del modulo, che si possono dumpare su disco con il context menu di questa finestra.

Memory Mappatura di tutta la memoria assegnata all'eseguibile debuggato. Olly riconosce a che modulo appartiene ciascuna sezione di memoria. Per dumpare una sezione di memoria: con right clickdump si apre una dump window, da qui right clickbackupsave data to file e il gioco fatto! Se ad esempio dumpate tutte le sezioni di un modulo e le rimettete assieme con un hex editor, se il programma non fa scherzi a run-time otterrete un dump funzionante! Heap Non funziona su nt, e non l'ho mai provato. La guida di ollydbg dice che questo comando mostra una lista dei blocchi di memoria allocati dal programma in uno dei suoi heap. Threads Lista di tutti i threads relativi al processo attivo in ollydbg, e alcune informazioni extra come l'ultimo errore avvenuto nel thread, il suo stato e la sua priorit. Usando la stessa procedura che ho descritto a proposito della memory window, si pu dumpare un thread! Windows Lista delle finestre aperte dall'applicazione con id, stili, classe di appartenenza... per chi non lo sapesse, anche i control (bottoni, edit ecc...) sono finestre. Se ad esempio tra i parametri di una chiamata alla GetDlgItemTextA vedete che pusha come id del control "3E8" qui potete vedere che tipo di finestra , il testo associato (titolo) e quant'altro. La vera potenzialit di questa finestra sta nella possibilit di settare breakpoints (anche condizionali) sulla classproc della finestra, e gi cos potreste intercettare un messaggio di WM_GETTEXT con due click sul context men... per facilitarvi ulteriormente la vita, c' addirittura una funzione di break sui messaggi (sempre nel context men) che offre anche una lista dei messaggi di windows per fare prima. Quindi potete tranquillamente trovare il punto d'attacco di quei crackme che pensano di fotterci usando SendMessage con WM_GETTEXT invece che GetWindowText o simili. Handles Lista di tutte le handle aperte dal programma debuggato, che contiene files e directory aperte, chiavi del registro... CPU Uff eccoci qua, al CORE di olly. La CPU window la finestra pi complessa, pi potente e pi utile di ollydbg, e per ogni opera di reversing (che pomposo!) l'avrete SEMPRE aperta. quello che fa la differenza tra olly e softice: olly fonde un eccellente debugger con un buon disassembler. Anzi, il disassemblato di olly migliore di quello del wdasm della ursoft e viene prodotto in brevissimo tempo. Olly individua provenienza e destinazione di salti e call, routines, loops, switches e altre cose notevoli automaticamente e le evidenzia graficamente rendendoci pi facile lo stepping. Olly decodifica i parametri pushati alle funzioni del c e alle API, convertendo i numeri nelle costanti simboliche corrispondenti. Olly a runtime tiene d'occhio la memoria puntata dai registri e dagli offset e vi segnala se c' qualcosa di interessante (come una stringa). L'analisi del codice pu essere fatta in qualsiasi momento, quindi se vi trovate un prog che si decrypta a runtime, steppatevi il loader fino all'OEP (original entry point) e rianalizzate il codice, e in mezzo secondo vedrete il disassemblato delle istruzioni decryptate come su softice. Per questi motivi, e data la centralit

dell'argomento, vedr di dare adeguato spazio e di spiegare tutto il mecessario per permettervi di ammaestrare l'olly. Prima di cominciare, rapido riassunto degli shorcuts di debug essenziali (vedi "ollydbg - i menu" sotto "debug"):
F3 - open file F9 - run F12 - pause Ctrl+F2 - restart Alt+F2 - close F7 - step into F8 - step over F2 - set breakpoint at selected address

Vediamo le 4 parti della CPU window: In alto a sx: disassembler window Disassemblato del file e "centro di comando" In alto a dx: registers window -> visualizza il contenuto dei registri In basso a sx: dump window visualizza il contenuto della memoria In basso a dx: stack window visualizza lo stack CPU: Disassembler Window La finestra pi importante. Dopo qualche secondo dal caricamento (F3) di un prog, olly metter qui il disassemblato della sezione che contiene l'entry point, avvisandovi se si trova fuori dalla sezione code. Sull'entry point (se non avete specificato diversamente nelle opzioni) verr posizionato il cursore dell'istruzione corrente, cio vedrete a sx l'indirizzo dell'istruzione a colori invertiti (lo sfondo nel colore del testo e viceversa). Il vostro cursore invece quella fascia di disassemblato pi scura (a meno di color schemes psichedelici) con la quale potete selezionare una o pi linee di codice per i vostri scopi. Analizziamo la finestra: dovreste vedere quattro colonne pi uno spazio in basso. 1. La colonna pi a sx contiene gli indirizzi in memoria. Tutto il resto si basa su questi indirizzi. L'indirizzo dell'istruzione corrente evidenziato. 2. La seconda colonna contiene informazioni sul codice a livello grafico. Le grandi "parentesi" nere rappresentano le routine. Le freccine rappresentano la direzione su\giu del jump a quella riga o la destinazione di altri jump. Le "parentesi" in rosso pi sottili indicano il percorso di un jump, e si vedono se si seleziona un'istruzione jump o la destinazione di un jump. Se non vedete qualcuna di queste cose, qui spiego come attivarle. 3. Nella terza colonna c' il disassemblato. 4. La quarta colonna serve a olly per scriverci ogni cosa notevole. Se un registro mentre steppate contiene un puntatore a stringa, vedrete la stringa. Se il prog sta pushando i parametri per una call ad una funzione nota, vedrete una "parentesi" nera che contiene i parametri pushati (nome del parametro in grigio e valore in nero) e la call, ovvero il nome della funzione in rosso. Se l'istruzione sospetta (per impostare quali istruzioni sono da ritenersi sospette, nelle debugging options (Alt+O) scegliere il tab analysis 3), viene scritto. E altre cose che non mi vengono in mente... 5. Lo spazio in basso ha una funzione simile a quella della quarta colonna, ma lavora pi in dettaglio. Mostra informazioni relative all'istruzione corrente: contenuti dei registri coinvolti, se un salto condizionale verr eseguito o no, destinazione dei salti, indirizzi da cui si salta all'istruzione corrente, etc etc etc... Vediamo il context men:

| |---|-backup: | ^ salva tutta la sezione di memoria nella disassembler window in un backup | ^ che si pu ripristinare in seguito. inoltre pu salvare tutto in un file. |-copy: | ^ il solito: copia la selezione negli appunti (Ctrl+C) o in un file. | ^ ci sono anche opzioni per la selezione rapida. |-binary: | ^ edita la selezione in hex, riempie di 00 o di NOPs, copia\incolla gli opcode selezionati. |-assemble (space): | ^ apre una finestra dove inserire un'istruzione in asm che sovrascriver la corrente in memoria. | ^ utilissimo quando si cracka! | ^ conviene usare "fill with NOPs" per non generare istruzioni non valide con i byte | ^ rimanenti dopo le modifiche... cos saranno sostituiti con degli innocui nop. |-label (:): | ^ da un nome (etichetta) all'indirizzo specificato. olly sostituisce tutte le referenze a questo indirizzo con l'etichetta. |-comment (;): | ^ serve a commentare il codice. i commenti compariranno nella quarta colonna. |-breakpoint: | ^ comandi relativi ai breakpoint dei quali ho gi parlato, pi run to selection (F4), | ^ che esegue il programma fino all'istruzione selezionata. |-hit trace: | ^ permette di aggiungere alle zone di hit trace la selezione, la procedura selezionata, tutte le procedure... | ^ le zone di hit trace vengono segnate con un quadratino grigio a fianco che diventa rosso se vengono eseguite. |-run trace: | ^ ho parlato diffusamente del run trace nella sezione debug. |---|-new origin here: | ^ assegna a EIP l'indirizzo dell'istruzione selezionata. spesso il prog crasha dopo di questo... |-go to: | ^ permette di saltare a vari punti del disassemblato, tra cui l'origin (cio eip), | ^ il valore di un espressione che verr valutata, la prossima routine e la precedente (Ctrl++ e Ctrl+). | ^ con + e - si pu navigare tra le ultime istruzioni eseguite, ma consigliabile il run trace per questo scopo. |-follow in dump: | ^ a seconda di che tipo di istruzione state selezionando e della validit dei valori in gioco potrete visualizzare | ^ nella dump window l'istruzione corrente, o la memoria puntata da costanti o registri. |-view call tree (Ctrl+K): | ^ visualizza l'albero delle chiamate, ovvero l'elenco gerarchico delle routine che hanno chiamato la corrente. |---|-search for: | ^ permette di cercare nel disassemblato molte cose... ma facili da capire, basta leggere i comandi nel context men. |-find references to:

| ^ permette di cercare delle referenze all'istruzione selezionata (Ctrl+R), | ^ alle varie costanti o variabili usate dall'istruzione, | ^ alla destinazione del salto e cos via... |-view: | ^ per vedere il profilo (numero di esecuzioni per ogni istruzione) al posto dei commenti a destra, | ^ per vedere il file eseguibile originale e per cambiare (a sx) tra indirizzi assoluti e relativi a quello selezionato. |-copy to executable: | ^ copia la selezione o tutte le modifiche fatte al programma in memoria e le trasporta nel file originale. | ^ se fate una patch in memoria e vedete che funziona, cos potete "salvarla". |-analysis: | ^ ri-analizza o rimuove l'analisi dal codice (utili per crypters e smc), e passa al setaccio i file *.obj e *lib | ^ in cerca di nomi simbolici da usare nel disassemblato. "assume arguments" costringe l'olly a considerare | ^ l'indirizzo selezionato come entry point di una funzione con certi argomenti, selezionabili da una lista. |-help on symbolic name (F1): | ^ olly apre la guida API selezionata nel menu help e cerca il nome simbolico selezionato all'interno della guida. |-bookmark: | ^ vedi plugins. |---|-appearance: | ^ solite opzioni di visualizzazione. |---CPU: Registers Window In ogni momento qui vedrete il contenuto dei registri. Cliccando sulla barra in alto si cambia tra i registri FPU, MMX e 3dNow!, ma in ogni caso il set standard di registri e flag (che poi sono quelli che ci interessano) viene sempre visualizzato. Se un registro punta a una stringa tale stringa comparir vicino al registro. Lo stesso vale per le locazioni del codice: olly vi mostrer dove punta il registro (a che modulo e l'indirizzo) e se l'indirizzo di una funzione nota, lo sostituir con il nome di tale funzione. Ora vediamo come interagire con i registri. Clickate col tasto dx su un registro standard e comparir un context men che conterr (al massimo) queste opzioni: | |---|-increment (+): | ^ aumenta di 1 il valore del registro |-decrement (-): | ^ diminuisce di 1 il valore del registro |-set to 1: | ^ assegna il valore 1 al registro |-modify (enter): | ^ apre una finestra nella quale inserire il nuovo valore per il registro |-copy to clipboard: | ^ copia il contenuto del registro negli appunti

|---|-follow in disassembler: | ^ cerca nel disassemblato l'istruzione puntata dal registro e ci posiziona il cursore. | ^ disponibile solo se il puntatore punta a del codice. |-follow in dump: | ^ cerca nella memoria del prog debuggato l'area puntata dal registro e la carica nella dump window. | ^ disponibile solo se il puntatore punta a una valida zona di memoria nell'address space del programma. |-follow in stack: | ^ cerca nello stack l'indirizzo puntata dal registro e posiziona la stack window a quell'indirizzo. | ^ disponibile solo se il puntatore punta allo stack. |---|-view (FPU,MMX,3dNow!,debug) registers: | ^ specifica i registri non standard da visualizzare. |---|-appearance: | ^ solite opzioni di visualizzazione. |---Nota: per i registri non standard ci sono funzioni specifiche, e alcuni registri, come eip e i registri di debug, non si possono modificare. Almeno non cos... ad esempio eip si pu modificare dalla finestra del disassemblato. CPU: Dump Window Questa finestra serve a visualizzare aree di memoria in vari formati, che si possono scegliere nel context men. Potete vederla come hex bytes con l'ascii a fianco (cosa che farete molto spesso) oppure come solo testo o ancora come numeri in vari formati (short, long, float). Potete vederla anche come disassemblato, quindi olly pu disassemblare QUALSIASI area della memoria, che sia una sezione .text, .data, .rsrc o qualcos'altro. Inoltre c' l'opzione PE header - se c' un valido header da qualche parte nell'area di memoria visualizzata, olly lo decodificher nelle sue varie parti (dos signature, pe, con le descrizioni delle varie sezioni etc etc). Sempre con il context men, potete operare sulla memoria: backup per creare un backup dell'area di memoria selezionata, che si pu facilmete ripristinare. anche per dumparla in un file. copy copia l'area selezionata negli appunti o in un file, o seleziona tutto. binary per editare la memoria in hex, riempire di 00 o di FF, e copiare\incollare zone di memoria. search for consente la ricerca di stringhe o labels nella memoria caricata nella dump window. Le altre opzioni le abbiamo gi viste per la CPU window e comunque servono a poco qui. CPU: Stack Window La finestra stack visualizza... lo stack! O meglio, lo stack del thread corrente. Ovviamente olly vi segnala ogni pointer a stringa o a sezioni di codice nello stack, quindi se viene pushato l'indirizzo di una stringa vedrete alla prima riga l'indirizzo E la stringa. Vediamo il context: | |----

|-address: | ^ cambia il modo di visualizzazione degli indirizzi dello stack (la colonna pi a sx). | ^ absolute li mostra come indirizzi in memoria, relative to ESP\EBP come ad es. "ebp+4", | ^ relative to selection come per ESP\EBP ma usa l'indirizzo selezionato come riferimento. |-show ASCII dump: | ^ aggiunge una colonna con la "traduzione" in ascii dei valori dello stack. | ^ un comando potenzialmente inutile. |-show UNICODE dump: | ^ vedi sopra... |-lock\unlock stack: | ^ lo stack normalmente si auto-posiziona sempre allo stack top, cos si disabilita questa feature. |---|-copy to clipboard (Ctrl+C): | ^ copia indirizzi e valori selezionati negli appunti. |-modify: | ^ semplice finestrella per editare i dati all'indirizzo selezionato. |-edit: | ^ sempre per editare (anche pi righe), ma pi completa, con ascii\unicode\hex. |-search for address: | ^ trova nello stack il valore specificato. |-search for binary string (Ctrl+B): | ^ permette di specificare una search pattern e ne trova la prima ricorrenza. | ^ specificando "56 ?? FF ?A" si pu trovare ad es. "56 45 FF 4A". |---|-go to esp (*): | ^ porta all'indirizzo dello stack puntato da esp. |-go to ebp: | ^ porta all'indirizzo dello stack puntato da ebp. |-go to espression: | ^ calcola il valore dell'espressione specificata e si posiziona su quell'indirizzo. | ^ "ebp-eax" porter all'indirizzo puntato da ebp meno eax bytes. |---Patches Lista delle patch (attive e non), ovvero le modifiche apportate dall'utente nel codice del programma debuggato. Le istruzioni per patchare sono nella sezione CPU window. Con la space bar (oltre al classico context menu) attivate\disattivate una patch. Con del la potete rimuovere, ma vi consiglio di disattivarle e basta perch possono sempre tornare utili. Con enter il cursore della CPU window si posiziona sul primo byte della patch. Call stack Permette di visualizzare il call stack (ma daveeeeero?), ovvero l'indirizzo a cui deve ritornare la procedura corrente finita la sua esecuzione pi tutti gli altri delle routine che hanno chiamato la corrente. Ovviamente in puro stile stack gli indirizzi di ritorno pi "vicini" li vedrete apparire all'inizio della lista. Se steppate un p un prog (con step into (F7) mi raccomando altrimenti inutile) vedrete i nuovi return addresses che si aggiungono in cima alla lista e li vedrete sparire a fine call. Breakpoints

La lista dei breakpoint (attivi e non) che avete settato sul codice del programma. Da qui potete individuarli nella cpu window (enter), modificare la loro condizione di break, abilitarli\disabilitarli (space bar) e cancellarli (del) usando il context menu o con gli shortcuts. Watches Apre la finestra degli watch. Un watch semplicemente un espressione che viene valutata continuamente mentre il programma debuggato in esecuzione. Per esempio, se scriviamo "eax" olly ci dir il contenuto del registro eax; se scriviamo "[eax]" ci dir a che valore punta eax e cos via. References Finestra che si apre quando si cercano referenze a un comando o a un indirizzo e che le lista tutte. Vedi CPU window. Run Trace Dopo aver eseguito un run trace (vedi il menu "debug") in questa finestra si vedono tutte le istruzioni che il programma ha eseguito prima di essere fermato; ovviamente entro i limiti di buffer che si settano nelle debuggin options (Alt+O) nel tab "trace". Oltre alle istruzioni ci sono gli indrizzi a cui si trovano, i moduli a cui appartengono, i thread che le hanno eseguite e (importante) i registri che hanno modificato, con il valore modificato. C' un opzione carina nel context men che permette di evidenziare un registro per seguire meglio i suoi cambiamenti. Source Mmmh... non ho mai provato a debuggare con il sorgente (siamo reverser, in fondo). Ad ogni modo questa finestra dovrebbe solo far vedere il codice sorgente (quando disponibile). Inoltre - stando alla guida - se il programma debuggato ha le informazioni di debug in formato borland permette di trovare il punto esatto nei sorgenti che corrisponde all istruzione corrente nella cpu window. Source files Mostra i file contenenti i sorgenti e i moduli corrispondenti (sono un poeta!). Ripeto, non ho mai usato queste features quindi non vi posso assicurare niente...

OllyDbg - Hands On: CM68 by Eimiar

Dar una spiegazione ESAUSTIVA del processo di keygenning di questo crackme. Analisi Iniziale Prima di tutto lanciate l'eseguibile per studiarlo... prova2.exe? Che nome ? Ok a parte questo, nome\serial, la about box ci dice solo che dobbiamo fare un keygen, la finestra in tipico stile dialog il che ci orienta verso GetDlgItemText per breakkare. Se avete PEditor o qualsiasi altro programma veloce che visualizza gli imports e le sezioni, usatelo ora. Con un'occhiata alle sezioni o alle funzioni importate si pu individuare in un attimo se il prog packato\cryptato (non andrebbe molto lontano importando solo LoadLibrary e GetProcAddress, no?). In questo caso vediamo DialogBoxParamA e GetDlgItemTextA e molte altre, inoltre le sezioni sono perfettamente normali quindi... si procede con il debugger! Fine analisi...

Reversing della Routine Lanciate ollydbg e caricate il file (F3). Finita l'analisi del codice (olly molto veloce) il cursore si ferma all'entry point (anche il programma :-). Date le modeste dimensioni del crackme potreste trovare il punto d'attacco solo scorrendo il codice nella CPU window ma... facciamo le cose per bene. Ricordate gli imports? Alt+F1 e nella command-line scrivete "bp GetDlgItemTextA" (occhio alle maiuscole!) per settare un breakpoint on execution su tale API. Potete amministrare i breakpoint nella apposita finestra (Alt+B). Ora eseguite il programma (F9) e scrivete "bender0" - err - il vostro nick nel campo nome e il vostro codice fiscale o numero di telefono o quel c***o che volete nel campo serial. Premete Try it! e incrociate le dita... Boom! L'olly prende il controllo. Vi ritrovate in user32.dll. Ora dovete uscirne, quindi o usate execute till return (Ctrl+F9) e poi steppate sul return per ritrovarvi dopo la chiamata alla API, oppure pi semplicemente usate execute till user code (Alt+F9) che fa da solo. Vi trovate all'indirizzo 4010DE: nelle 5 righe precedenti vedete i parametri da passare a GetDlgItemTextA e la call. Vedete come olly vi risolve i parametri? E non tutto... vedete che pusha esi come "buffer"? Durante la chiamata esi non viene modificato, quindi guardate a destra i registri: esi contiene l'indirizzo in memoria del buffer che contiene il vostro nome, e l'olly cos carino da scrivercelo a fianco! Segue un'altra chiamata a GetDlgItemTextA per il serial, vedete che il "buffer" in ebp. Disabilitate il breakpoint su GetDlgItemTextA usando la breakpoint window (Alt+B) (non viene visualizzato il nome della API ma l'indirizzo, ad ogni modo sotto "module" c' scritto user32 quindi...). Abbiamo tolto il break perch adesso andiamo a steppare over (F8) l'altra chiamata a GetDlgItemTextA e al posto di passarci sopra come vogliamo olly avrebbe breakkato proprio sulla API. Steppata la call, vedete a destra su ebp l'indirizzo del buffer e il vostro serial. Ora vedrete questo (i commenti li ho aggiunti io, per commentare il codice premete ';' col cursore sulla linea desiderata): 004010E9 MOV EDI,ESI ; sposta in edi l'indirizzo del nome 004010EB OR ECX,FFFFFFFF ; ecx = -1 004010EE XOR EAX,EAX ; eax = 0 004010F0 MOV EBX,DWORD PTR DS:[<&USER32.MessageBoxA>] 004010F6 REPNE SCAS BYTE PTR ES:[EDI] ; scorre la stringa finch non incontra uno 0,<br />e ogni volta diminuisce di 1 ecx 004010F8 NOT ECX ; ecx viene negato (ribaltato nei positivi) 004010FA DEC ECX ; e diminuito di 1, ora contiene la lunghezza del nostro nome 004010FB CMP ECX,3 ; confronta la lunghezza con 3 004010FE JNB SHORT prova2.0040110F ; se la lunghezza del nome NON MINORE di 3,<br />salta la messagebox di errore e prosegue Capito? Controlla la lunghezza del nome che deve essere almeno 3 caratteri (ho riportato il codice perch ne vedrete parecchi di questi controlli). Steppate queste righe e (se non avete un nick da 2 caratteri :-) salterete la chiamata a MessageBoxA e potrete proseguire. Notare che, messagebox o meno, il controllo del codice continua, non vi butta fuori. Vi sarete accorti che segue un controllo uguale per la lunghezza del serial... steppatelo allegramente e salterete anche la parte che vi butta fuori! Cos se non si scrive niente o quasi in entrambi i campi, escono DUE messagebox scassac***o E POI vi butta fuori. Non carino. Ora vi trovate all'indirizzo 40113E. E indovinate? Ora il prog RICONTROLLA la lunghezza di nome e codice... che bello! Steppate pure. Dopo questi altri 2 check a 401162 c' una routine quasi

uguale (oh nooooooo)... La differenza e quel je alla fine, praticamente qui controlla che il nome non sia di zero caratteri (ma non ne sei ancora convinto?!?). Eccoci a 401170. Alla prima riga viene caricato in ebp l'indirizzo di una particolare stringa, "0123456789:;<=>?@ABCDEFGHIJKL", che chiameremo keystring. Notare che poche linee fa ebx stato azzerato, perch ora far da counter. 00401170 LEA EBP,DWORD PTR SS:[ESP+14] ; keystring caricata in ebp 00401174 MOV EDX,ESI ; indirizzo del nome in edx 00401176 SUB EBP,ESI ; ebp = indirizzo keystring MENO indirizzo nome ; INIZIO LOOP 00401178 MOV AL,BYTE PTR DS:[EDX+EBP] ; prende un char da keystring e lo mette in al 0040117B MOV CL,BYTE PTR DS:[EDX] ; prende un char dal nome e lo mette in cl 0040117D XOR CL,AL ; vengono xorati questi due valori 0040117F INC EBX ; ebx fa da counter, viene incrementato 00401180 MOV BYTE PTR DS:[EDX],CL ; il valore xorato sostituisce in memoria<br />le lettere del nome 00401182 MOV EDI,ESI ; # (le istruzioni con # servono a calcolare a ogni ciclo<br />la lunghezza del nome) 00401184 OR ECX,FFFFFFFF ; # 00401187 XOR EAX,EAX ; # 00401189 INC EDX ; passa al prossimo char 0040118A REPNE SCAS BYTE PTR ES:[EDI] ; # 0040118C NOT ECX ; # 0040118E DEC ECX ; # 0040118F CMP EBX,ECX ; l'ultimo carattere del nome? 00401191 JB SHORT prova2.00401178 ; se si prosegui se no passa al prossimo char ; FINE LOOP Bene, avrete capito che questo loop non fa altro che xorare ogni carattere del vostro nome con quello allo stesso posto nella keystring... Fate bene attenzione al prossimo pezzetto di codice... hee hee hee... 00401193 MOV EBP,DWORD PTR SS:[ESP+10] ; carica il serial in ebp 00401197 MOV EDI,ESI ; carica il nome xorato con keystring in edi 00401199 OR ECX,FFFFFFFF ; # (stessa storia di prima...) 0040119C XOR EAX,EAX ; # 0040119E XOR EBX,EBX ; ebx = 0 004011A0 REPNE SCAS BYTE PTR ES:[EDI] ; # 004011A2 NOT ECX ; # 004011A4 DEC ECX ; # 004011A5 JE SHORT prova2.004011C8 ; controlla che il nome xorato con keystring<br />non sia una stringa di zero caratteri All'apparenza questo sembra un normale controllo sulla stringa che il programma ha creato nel loop precedente per evitare che contenga solo uno zero... ma provate a immaginare che succede se il primo carattere zero... ecx conterr zero e quindi il jump si far, MA GUARDATE DOVE FINISCE IL JUMP! Alla messagebox di congratulazioni! Studiamo la vulnerabilit (parlo come un professore...sigh): il primo carattere di questa stringa, ovvero il nostro nome xorato con la keystring deve dare 0, la keystring comincia con '0' (30 in hex) quindi "x xor 30 = 0". Ovviamente x deve

valere 30: qualsiasi nome che cominci per '0' salter quindi il controllo e verr accettato, provare per credere! (peccato che nel mio nick lo zero sia alla fine!) Dopo questa (intenzionale?) vulnerabilit, abbiamo il check vero e proprio... non riporto neanche il codice perch si tratta di un loop del tutto simile ai precedenti che ad ogni giro confronta la nuova stringa (nome xorato con keystring) con il nostro serial, carattere per carattere. Ovviamente se ne trova 2 diversi ci butta fuori e tanti saluti... Creazione di un Keygen Bene, ora la protezione dovrebbe esservi chiara... ecco il sorgente in c di un keygen per questo crackme: #include <stdio.h> int main() { // la keystring e il buffer per il vostro nick char keystring[31] = "0123456789:;<=>?@ABCDEFGHIJKL"; char buffer[31]; // intro e raccolta dati printf("keygen per il crackme69 by eimiar\n"); printf("il tuo nick in uppercase (max 30 chars!): "); gets(buffer); // loop che calcola il serial for (int c=0;c<=30;c++) { if (buffer[c] == 0) break; buffer[c] = buffer[c]^keystring[c]; } // se poi non lo stampiamo non serve a niente, no? printf("il tuo serial : "); printf(buffer); getchar(); return 0; } Ora, anche se il nick lo dovete scrivere voi in uppercase, il serial generato valido, ma tante volte contiene dei caratteri strani ed quindi difficile da riportare nel programma. Abbiamo finito! Il crackme non era decisamente un osso duro ma almeno avete messo le mani sull'olly e avete intravisto cos pu fare... Droppatemi una mail al mio indirizzo (in cima alla pagina!) per qualsiasi cosa. Quo usque tandem abutere, bender0, patientia nostra? ok, ok, la smetto... al prossimo tute! Thx e ciao.

Note Finali
Thx2: Que & la UIC (esclusi i lameri che continuano a chiedere crack sul forum) la blacksun research facility che mi ha insegnato un sacco di cose phobos che ha mirrorato ringzer0! Oleh Yuschuk, il tizio che ha scritto ollydbg - senza di lui che tute avrei scritto? sourceforge che mi aiuta nel coding cure e smashing pumpkins che ho ascoltato scrivendo questo tute tool e meshuggah che ho ascoltato wikizzando questo tute ;) la gente di deviantART che mi vuole bene! softice che mi blocca l'orologio del win e mi fa arrivare sempre in ritardo!