Tutorial #3: Usare OllyDBG, Parte 1Visulizza la lista completa dei tutorial

Prima di continuare a leggere. La traduzione e la revisione di questi tutorial mi hanno portato via molto tempo. Mi farebbe dunque molto piaceresapere cosa voi lettori pensiate del risultato finale. Siete liberi di esprimere giudizi, opinioni, pareri, critiche e consiglial seguente link https://it.surveymonkey.com/r/FS5YHC2. Si tratta di un piccolo sondaggio che mi sarà utile per capirese valga davvero la pena di continuare questa serie. Detto questo non mi rimane che augurarvi una buona lettura!

In questo tutorial, cercherò di introdurvi all'uso di OllyDbg. Olly ha molte funzioni e l'unico modo per impararleveramente tutte è quello di sperimentare e fare pratica. Detto questo, il seguente tutorial vi darà una breve panoramica.Ulteriori argomenti non trattati in questo tutorial saranno discussi in esercitazioni successive, in modo che entro la fine,dovreste avere una conoscenza abbastanza buona di Olly. In questa guida sono compresi alcuni file. È possibilescaricare la versione PDF di questo tutorial e i file allegati nella sezione apposita. Troverete un semplice binario cheuseremo in Olly, insieme a un file in cui ho incluso alcune scorciatoie da tastiera(OllyDebug Cheatsheet.xls), la miaversione di Olly con alcune modifiche estetiche, e un file ini che potete sostituire all'originale e che vi aiuterà se sietealle prime armi (ringrazio Lena151 per questo). Possono essere scaricati direttamente quihttp://octopuslabs.io/legend/files/tuts/R4ndom_tutorial_3.zip. Se invece preferite utilizzare la versione originale diOlly, potete scaricarla da qui http://www.ollydbg.de/.

Caricare l'applicazioneIl primo passo è quello di caricare il binario di nostro interesse in Olly. È anche possibile trascinare e rilasciare il filenella finestra di disassemblaggio di Olly, oppure fare clic sull'icona di caricamento file in alto a sinistra. In questo caso,caricate “FirstProgram.exe”, che potete scaricare da questo sito. Olly lo analizzerà (se siete abbastanza veloci dovresteessere in grado di vedere lo svolgimento dell'analisi nella barra inferiore del display di Olly) e si fermerà all'EntryPoint (EP) del programma:

La prima cosa da notare è che l'EP è all'indirizzo 401000, come possiamo vedere nella prima colonna. Questo è unpunto di partenza abbastanza comune per un eseguibile (almeno per un'eseguibile non "packed" o comunque nonoffuscato). Se Olly ha un'aspetto diverso e non si è fermato a 401000, provate ad andare in Appearance e selezionatedebugging options, poi fate clic sulla scheda “Events”, e assicuratevi che “WinMain (if location is known)" siaselezionato. Quindi riavviate l'applicazione.

Ecco uno screenshot dello spazio di memoria occupato da "First Program.exe". Fate clic sull'icona "Me" (o "M" seutilizzate una versione diversa di Olly):

Se guardate nella colonna dell'indirizzo, vedrete che in 401000, la riga contiene la dimensione 1000, il nome"FirstPro" (abbreviazione di FirstProgram), il nome della sezione “.text, e contiene “SFX, code”. Come impareremopiù avanti in questa serie, i file exe hanno diverse sezioni che a loro volta contengono diversi tipi di dati. In questasezione c'è il "codice" per il programma. È lungo 1000h byte e parte dall'indirizzo di memoria 401000. Sotto potetevedere le altre sezioni del nostro "FirstProgram"; C'è una sezione .rdata che contiene data e imports all'indirizzo402000, una sezione chiamata “.data” che non contiene nulla all'indirizzo 403000, e infine, una sezione chiamata“.rsrc” che contiene le risorse (come ad esempio le finestre di dialogo,le immagini,il testo etc..) Tenete a mente chequeste sezioni possono essere chiamate da qualsiasi cosa- è completamente a discrezione del programmatore. Vichiederete perché la sezione .data non contiene nulla. Beh, in realtà, non è cosi. Contiene cose come le variabili globalie i dati casuali. Olly sceglie di non elencare queste cose in quanto non è in grado di stabilire esattamente di che tipo didati si tratta. Nella parte superiore delle sezioni, ce n'è una chiamata “PE Header”. Questa è una sezione moltoimportante, una di quelle che incontreremo spesso nei tutorial futuri.Per adesso,è sufficiente sapere che è come unmanuale di istruzioni per Windows con passaggi per caricare il file nella memoria, la quantità di spazio di cui habisogno per funzionare,dove sono certe cose ecc È all'head di qualsiasi exe (e anche DLL del resto). Se ora guardate inbasso alla lista, vedrete altri file oltre First Program. Vedrete comctl32, imm32, gdi32, kernel32 etc. Questi sono i fileDLL di cui la nostra applicazione ha bisogno per essere eseguita. ADII file è una collezione di funzioni fornite daWindows (o da qualche altro programmatore) che il nostro programma può chiamare. Queste sono operazioni comeaprire finestre di dialogo, comparare stringe, creare finestre etc. Collettivamente, queste sono le API di Windows. Laragione per cui i programmi le usano, è perché se si dovesse programmare ogni funzione, anche solo la visualizzazionedi una message box impiegheremmo migliaia di linee di codice. Invece, Windows ha fornito una funzione comeCreateWindow che lo fa il lavoro al posto nostro. Questo rende la programmazione molto, molto più semplice per ilprogrammatore. Potreste chiedervi come queste DLL arrivano nello spazio degli indirizzi del nostro programma e ilmodo in cui windows sapeva quali fossero necessarie. Ebbene, queste informazioni vengono memorizzate nel PEHeader di cui abbiamo parlato prima. Quando Windows carica il nostro exe in memoria, controlla questo header etrova i nomi dei DLL, cosi come le funzioni in ogni DLL di cui necessita il nostro programma, e poi le carica nellospazio di memoria del programma in modo che possa chiamarli. Ogni programma caricato in memoria avrà anche leDLL necessarie di cui ha bisogno caricate nel suo spazio di memoria. Questo significa che, presumibilmente, alcuneDLL potrebbero essere caricate più volte in memoria se diversi programmi sono attualmente caricati e tutti utilizzanoquel particolare DLL. Se volete vedere con esattezza quali funzioni chiama il nostro programma,potete fare clic destro

nella finestra di disassembly di Olly e selezionare “Search For” -> “All Intermodular Calls”. Dovrebbe apparirviqualcosa di simile a questo:

Questo potrebbe sorprendervi, ma l'elenco apparso è molto piccolo, solitamente ci sono centinaia o migliaia di funzioninecessarie per un prodotto commerciale, ma dal momento che il programma di esempio è molto semplice, non nenecessita di molte. Sebbene, pensando a ciò che fa il nostro programma, vi sembreranno comunque un sacco difunzioni solo per svolgere un ruolo così basilare! Benvenuti in Windows. Questa finestra mostra per primo il nome delDLL, e in seguito il nome della funzione. For instance, User32.LoadIconA è nella DLL User32 e il nome dellafunzione è LoadIconA. Questa funzione di solito ha il compito di caricare l'icona nell'angolo in alto a sinistra dellafinestra. Quindi, facciamo una ricerca di tutte le stringhe dell'app. Fate clic sulla finestra di disassembly e scegliete“Search For” -> “All Referenced Text Strings":

Questa finestra mostra tutte le stringhe di testo che è stato possibile trovare all'interno della nostra app. Dal momentoche si tratta di un'applicazione molto semplice, ce ne sono solo un paio. La maggior parte delle applicazioni neavranno molte di più (a volte anche centinaia di migliaia) a meno che non siano state offuscate o packed. In questocaso, potreste non vederne nemmeno una! Il motivo per la quale i packers fanno questo è perche i reverse engineers(almeno quelli nuovi) fanno un pesantemente affidamento alle stringhe di testo per trovare funzioni importanti in unfile binario, e rimuovendo le stringhe di testo si rende molto più difficile la vita ai reverser. Immaginate se facendo unaricerca delle stringhe di testo trovate un messaggio del genere “Congratulazioni! Hai inserito il seriale corretto”? Beh,questo sarebbe un grande aiuto per un reverser (and we will see this time and again). A proposito, facendo doppio clicsu una delle stringhe verrete portati alle istruzioni che le utilizzano nella finestra di disassembly. Questa è una bellafeature, in questo modo potete saltare direttamente al codice che utilizza la stringa.

Esecuzione del programmaSe guardate in alto a sinistra su Olly, dovreste vedere una finestra gialla con scritto "Paused". Questo significa chel'applicazione è in pausa (all'inizio in questo caso) e pronta all'utilizzo. Quindi cerchiamo di darci da fare! Provate apremere F9 (oppure andate su "Run" dal menu "Debug"). Dopo qualche secondo, il nostro programma farà apparireuna finestra di dialogo (che potrebbe però aprirsi alle spalle Olly, quindi se necessario riducete a icona la finestra deldebugger per assicurarvi che la finestra di dialogo non sia finita in secondo piano.)

Quella stessa casella che precedentemente segnava Paused dovrebbe ora apparire come Running(In esecuzione). Ciòsignifica che l'applicazione è in esecuzione, ma in esecuzione all'interno di Olly. A questo punto potete interagire con ilprogramma, dunque fatelo*Guardate come funziona e cosa fa. Se accidentalmente doveste chiuderla, fate nuovamente click su di Olly e premeteCtrl-F2 (o selezionate Debug-> Restart) per ri-caricare il programma, a questo punto basta premere F9 per eseguirenuovamente l'applicazione. Ora provate questo: con il programma in esecuzione, fate clic sull'icona di pausa di Olly (inalternativa premete su F12, oppure andate in Debug-> Pause). Questo farà si che il programma andrà in pausa ovunquesi trovi in esecuzione in memoria. Ora se provate a visualizzare il programma, apparirà divertente (o potrebbe anchenon apparire). Questo perché Windows non aggiorna la visualizzazione quando è in pausa. Ora premete di nuovo F9 edovreste essere in grado di giocare ancora una volta con il programma. Se qualcosa va storto, basta cliccare sull'iconadella doppia freccia rivolta a sinistra( ) o scegliete Debug-restart (o ctrl-F2) e l'applicazione verrà ricaricata e messainpausa all'inizio. È ora possibile eseguirla nuovamente se lo si desidera.

Stepping del programmaEseguire un'applicazione è bello e interessante, ma non vi fornità molte informazioni su quello che sta succedendo.Proviamo quindi con uno step alla volta. Ricaricate l'applicazione (dall'apposita icona,oppure premendocontemporaneaamente Ctrl e F2, o andando in Debug-> restart) e vi troverete in pausa all'inizio dell'applicazione. Orapremete F8. Noterete che l'attuale selettore di linea è andato giù di una riga. Olly ha eseguito una singola riga diistruzione per poi tornare nuovamente in pausa. Se foste davvero attenti, vi sareste anche accorti della finestra di stackscorrere di uno verso il basso e dell'apparire di una nuova voce in alto:

Questo perché l'istruzione che abbiamo eseguito, PUSH 0″ ha ‘spinto’ uno zero nello stack. Questo apparirà nellostack come “pModule = NULL”. NULL è un altro nome per dire zero. È possibile inoltre notare che nella finestra deiregistri, i registri ESP e EIP si sono trasformati in rosso:

Quando un registro diventa rosso, vuol dire che l'ultima istruzione eseguita ha cambiato il valore di quest'ultimo. Inquesto caso, il registro ESP (che punta all'indirizzo in cima allo stack) è stato incrementato di uno poiché abbiamo

spinto un nuovo valore nello stack. Il registro EIP, che punta all'istruzione corrente che è in esecuzione è ancheaumentato di due. Questo perché non siamo più all'indirizzo 401000, ma 401002- eseguendo l'ultima istruzione cheera lunga due byte, ora siete in pausa sulla prossima istruzione. Questa istruzione è al 401002, che è il valore correntedell' EIP. L'istruzione sulla quale Olly è ora in pausa è una CALL. Un'instruzione call significa che noi vogliamomettere in pausa temporanemanete la funzione corrente e eseguirne un'altra. Questo scenario è analogo a quello dellachiamata di una funzione di un metodo in un linguaggio di alto livello, per esempio: int main(){ int x = 1; call doSomething(); x = x + 1;}

In questo codice, prima assegniamo a x il valore 1, poi mettiamo in pausa questa linea di logica e chiamiamodoSomething (). Quando doSomething finisce, riprenderemo con la nostra logica originale e x verrà incementato di 1.Ebbene, lo stesso vale nel linguaggio assembly. Per prima cosa abbiamo spinto uno zero nello stack e ora vogliamochiamare una funzione, in questo caso quella in Kernel32.dll chiamata GetModuleHandleA():

Ora premete F8 ancora un'altra volta. L'indicatore di riga corrente si sposterà in basso di uno, il registro EIP rimarràrosso e aumenterà di 5 (in quanto l'istruzione eseguita era lunga 5 byte) e lo stack è stato riportato a come eraoriginariamente mostrato. Quello che è successo è che da quando abbiamo premuto F8, che vuol dire “Step-Over”, ilcodice all'interno della call è stato eseguito e Olly si è fermato nella riga successiva alla call. Ora, all'interno di questacall il programma protrebbe aver fatto qualsiasi cosa, ma we ‘stepped over’ it. Ora, per vedere le altre opzioni,riavviate il programma (CTRL-F2), premete F8 per fare step over sulla prima istruzione, ma questa volta premete F7sull'istruzioni call. Noterete che l'intera finestra è ora diventata diversa:

Questo perché F7 corrisponde a “Step-In”, il che significa che Olly ha fatto la call e si è fermato alla prima linea diquesta nuova funzione. In questo caso, la chiamata è saltata in una nuova area di memoria (EIP = 4012d6).Teoricamente, se avete continuato a fare stepping attraverso queste nuove funzioni di linee di codice, vorrete poitornare allo statement dopo la chiamata che ci ha portato qui, di nuovo all'inizio. Ovviamente, ci sono scorciatoie perquesto, ma per ora limitiamoci a ri-avviare il programma e ricominciare da capo per evitare di confonderci troppo. Orache vi siete soffermati all'inizio del programma, premete F8 (Step-Over) 4 volte e atterrerete su questo statement:

Noterete che ci sono 4 PUSH statements consecutivamente. Questa volta, guardate la finestra dello stack quandopremete F8 4 volte e vedrete lo stack crescere (in realtà cresce verso il basso – ricordate l'esempio dei piatti?). Ora vi

chiederete perché abbiamo spinto questi numeri arbitrari nello stack. In questo caso è perché questi 4 numeri vengonotrasmessi come parametri alla funzione (la funzione che stiamo per chiamare all'indirizzo 401021). Se prendiamo ilnostro precedente programma di alto livello e lo modifichiamo un po' diventerà tutto più chiaro: int main(){ int x = 1; int y = 0; call doSomething( x, y ); x = x + 1;}

Qui, dichiariamo due variabili, x e y, e le passiamo dentro la funzione doSomething. La funzione doSomething(probabilmente) farà qualcosa con queste variabili e poi torna indietro il controllo al programma chiamante. Lo stack èuno dei principali metodi con cui le variabili possono essere passate a una funzione: ciascuna variabile è inserita nellostack, la funzione è chiamata, e nella funzione, queste variabili sono accessibili, generalmente utilizzando l'inversodell'istruzione PUSH che è POP. Lo stack non è l'unico modo per fare questo, è solo il metodo più spesso utilizzato.Queste variabili potrebbero anche essere state messe nei registri ed è possibile accedervi attraverso questi registriall'interno della funzione chiamata, ma in questo caso, il compilatore del nostro programma ha scelto di metterli nellostack. Tutto questo diventerà più chiaro dopo aver studiato il linguaggio assembly (perchè voi state studiando illinguaggio assembly, non è vero?). Ora, se premete F8 ancora una volta, noterete che apparirà “Running” nell'activebar di Olly e la finestra di dialogo del programma verrà mostrata. Questo è dovuto al fatto che abbiamo stepped-overthe call that actually has most of the program in it. all'interno di questa chiamata c'è il codice che entra in un loop diattesa di noi che facciamo qualcosa, quindi non ottenerremo mai nuovamente indietro il controllo alla linea dopo lachiamata. Bene, andiamo a risolvere il problema…Fate click sul programma e premete il pulsante 'close' per terminarel'applicazione. Olly andrà immediatamente in pausa nella riga successiva alla chiamata:

Noterete anche che il nostro programma è scomparso. Questo perché, da qualche parte nella call, la finestra di dialogoè stata chiusa. Inoltre, se guardate in basso di una riga vedrete che siamo sul punto di chiamare kernel32.dll ->ExitProcess. Questa è l'API di Windows che stoppa un'applicazione, quindi, in pratica Olly ha messo in pausa il nostroprogramma dopo aver chiuso la finestra, ma prima che sia stato effettivamente terminato! Se ora premete F9, ilprogramma verrà terminato, l'active bar in Olly dirà “Terminated” e non staremo più facendo il debugging di nulla.

Breakpoints

Proviamo qualcos'altro, ricaricate l'app (ctrl-F2) e fate doppio clic sulla linea all'indirizzo 401011 nella secondacolonna farete clic sugli opcodes “6A 0A”. L'indirizzo 401011 orà diventerà rosso:

Praticamente avete impostato un breakpoint all'indirizzo 401011. I Breakpoints costringono Olly a sospenderel'esecuzione quando vengono raggiunti. Ci sono diversi tipi di breakpoints, al fine di interrompere l'esecuzione sudiversi eventi:

Software Breakpoints

Un software breakpoint sostituisce il byte all'indirizzo di breakpoint con un 0xCC opcode, che è un int 3. Questo è unospecial interrupt che dice al sistema operativo che il debugger ha intenzione di mettere in pausa e prendere il controlloprima di eseguire l'istruzione. Non vedrete il cambiamento di istruzioni a 0xCC, Olly fa tutto questo dietro lequinte, ma quando Olly finisce su un BP un'eccezione si verifica e verrà intrappolata consentendo all'utente di fare ciòche desidera. Se scegliete di consentire al programma di continuare (eseguendolo o facendo stepping), l'opcode 0xCC

verrà sostituito di nuovo con quello originale.

Per impostare un breakpoint, è possibile fare doppio clic sulla colonna degli opcode, oppure si può evidenziare la rigasulla quale si desidera impostare il punto di interruzione, premere il tasto destro del mouse, e selezionare Breakpoints->Toggle (o premere F2). Per rimuovere il breakpoint, potete fare doppio clic sulla stessa riga o premere il tasto destrodel mouse e selezionare Breakpoint->Remove Software Breakpoint (o pigiate nuovamente F2).

Ora che abbiamo impostato un BP (breakpoint) all'indirizzo 401011 e il nostro programma è andato in pausa alla primaistruzione, premete F9 (run). Il nostro programma verrà eseguito, ma si metterà in pausa sulla linea in cui è presente ilnostro BP.

Desidero inoltre sottolineare una cosa molto utile. Facendo clic sull'icona della barra degli strumenti "Br" oselezionando View->Breakpoints. Vedrete una voce nella finestra dei breakpoint che mostra il breakpoint attualmenteimpostato:

Questo vi fornirà una rapida panoramica di tutti i breakpoints che sono stati settati. Facendo doppio clic su uno di essi,dalla finestra di disassembly passerete al breakpoint selezionato (anche se l'EIP rimarrà lo stesso in quanto in realtà nonsi sta cambiando il flusso di controllo del programma. Doppio clic sul registro EIP to go back to the current line set toexecute next).

Se evidenziate un breakpoint e premete la barra spaziatrice, il breakpoint si alternerà tra enabled e disabled. È anchepossibile evidenziare una riga in cui è presente un breakpoint e premere il tasto "DEL" che rimuoverà il punto diinterruzione.

Infine, riavviate il programma, andate nella finestra dei breakpoints, ed evidenziate il punto di interruzione che aveteimpostato all'indirizzo 401011, e premete la barra spaziatrice. La colonna "Active" cambierà in “Disabled”. Oraeseguite il programma (F9). Noterete che Olly non si è fermato al nostro BP perché è stato disattivato.

Hardware Breakpoints

Un hardware breakpoint utilizza i registri di debug della CPU. Ci sono 8 di questi registri integrati nella CPU, R0-R7.Anche se ci sono 8 built into the chip, possiamo utilizzarne solo quattro. Questi possono essere utilizzati per breakingon reading, scrivere o eseguire una sezione di memoria . La differenza tra hardware e software breakpoints è chel'hardware BP non modifica la memoria del processo, quindi possono essere più affidabili, specialmente in caso diprogrammi che sono packed o protetti. È possibile impostare un hardware breakpoint facendo clic destro sulla rigadesiderata, selezionando Breakpoint, e poi scegliendo Hardware, on execution:

L'unico modo per vedere i BP impostati in memoria è quello di selezionare "Debug" e poi "Hardware Breakpoints".Fortunatamente c'è un plugin che renderà questo processo molto più rapido, ma di questo parleremo in seguito

Memory Breakpoints

A volte potreste trovare una stringa o una costante nella memoria del programma, senza però sapere in quale partevenga utilizzata. Utilizzando un memory breakpoint, comunichiamo a Olly che il nostro desiderio è quello di metterein pausa ogni volta che QUALSIASI istruzione nel programma legge o scrive all'indirizzo di memoria (O gruppi diindirizzi.) Ci sono tre modi per selezionare un memory breakpoint:

Per un'istruzione, fate clic destro sulla riga desiderata e selezionate Breakpoint->Memory, On Access o Memory, OnWrite.Per impostare un BP su un indirizzo nel dump della memoria, evidenziate uno o più byte nella finestra dump , fate clicdestro su di essi e scegliete la stessa opzione di sopra. È anche possibile impostare un BP per un'intera sezione dimemoria. Aprite la finestra Memory (Icona “Me” o View->Memory), tasto destro del mouse sulla sezione dellamemoria che si desidera, tasto destro del mouse e selezionate “Set Break On Access for either Access or Write".

Uso del riquadro Dump

È possibile utilizzare il riquadro del dump per ispezionare il contenuto di qualsiasi locazione di memoria nello spaziodi memoria del processo di debug. Se un'istruzione nella finestra di disassembly, un registro, o un qualsiasi elementonello stack contiene una reference a una locazione di memoria, potete fare clic destro su questa reference e selezionare“Follow in Dump” e il pannello del dump vi mostrerà la sezione dell'indirizzo. È anche possibile fare clic destro inqualsiasi punto del riquadro dump e selezionare“Go To” per inserire un indirizzo da visualizzare. Proviamolo.

Assicuratevi che FirstProgram venga caricato e messo in pausa all'inizio. Ora, premete F8 otto volte e vi troveresull'istruzione all'indirizzo 401021 that says CALL FirstPro.40102c. Guardando questa linea, noterete che questa callsta per saltare giù all'indirizzo 40102c, which happens to be 3 lines down from where we currently are. Premete F7 perfare step in nel salto e ci ritroveremo a questo indirizzo: 40102c. Ricordate che questa è un'istruzione CALL, quindialla fine torneremo a 401021 (o almeno all'istruzione dopo questa).

Ora fate lo step del codice (F8) fino ad arrivare all'indirizzo 401062. Si può anche semplicemente impostare unbreakpoint su questa linea e premere F9 per eseguirla. Ricordate come si imposta un breakpoint? Doppio clic nellacolonna opcode nella linea sulla quale si desidera impostare il BP. (È anche possibile evidenziare la riga e premere F2per mettere il BP on e off ). Ora siamo in pausa all'indirizzo 401062:

Ora, diamo un'occhiata alla linea nella quale ci siamo soffermati. L'istruzione è MOV [LOCAL.3], FirstPro.00403009.Sono certo che voi sapete (perché avete studiato il linguaggio assembly :P ) che questa istruzione muove qualsiasicosa ci sia all 'indirizzo 00403009 nello stack (which Olly references as LOCAL.3). Potete vedere come nella colonnadei commenti that Olly has discovered that at this address is the ASCII string “MyMenu”. Bene, diamo uno sguardo.Fate clic destro sull'istruzione e selezionate "Follow in Dump". Noterete di avere a disposizione un paio di opzioni:

In questo caso, selezionate “Immediate Constant”. Questo carica qualsiasi indirizzo interessato nelle istruzioni. Seaveste scelto “Selection”, la finestra di dump avrebbe mostrato l'indirizzo della riga evidenziata, in questo caso 401062(la linea in cui ci siamo soffermati). We would basically just be looking at a dump of what we were looking at in thedisassembly window. Infine, se avessimo scelto “Memory address”, il dump screen avrebbe mostrato la memoria perLOCAL.3. Ciò in effetti mostra la memoria per le variabili locali con la quali stavamo lavorando (nello the stack).Ecco, questo è come il dump appare dopo aver selezionato "Immediate Constant":

Come potete vedere,il dump ora mostra la memoria a partire dall'indirizzo 403009, che è l'indirizzo dell'istruzione Ollywas loading the ASCII string from. Sulla destra, potete vedere la stringa, “MyMenu”. Sulla sinistra, potete vederel'hex attuale per ogni carattere. Potete notare come dopo "MyMenu" ci siano alcune stringhe aggiuntive. Questestringhe verranno utilizzate in altre parti del programma.

Finalmente qualcosa di divertente!

Per terminare questa parte del tutorial, facciamo qualcosa di divertente. Cerchiamo di modificare il file binario pervisualizzare un messaggio a nostra scelta! Cambieremo la stringa “Dialog As Main” con qualcosa di nostro e poivedremo cosa succede.

In primo luogo, fate clic sulla "D" di “Dialog As Main” nella sezione ASCII della finestra dump:

Noterete che la prima cifra esadecimale è anche evidenziata a sinistra. Questa cifra corrisponde alla lettera "D". Seguardate in alto sul grafico ASCII vedrete che l'hex per la lettera "D" è 0×44. Ora, fate clic e trascinate per selezionarel'intera stringa “Dialog As Main”:

Ora, fate clic sul tasto destro del mouse in qualsiasi punto della selezione e scegliete “Binary” -> “Edit”. Questo cipermette di cambiare il contenuto della memoria del nostro programma:

Dovremmo vedere una schermata simile a questa:

Il primo campo ci mostra la nostra stringa in ASCII. Il secondo l'Unicode (che questo programma non usa, perciò ilcampo è vuoto) e l'ultimo campo è per i raw data relativi a questa stringa. Ora, cambiamoli. Cliccate sulla prima lettera("D") e digitate qualsiasi cosa desideriate sopra la parte superiore della stringa “Dialog As Main”. Ma fate attenzione anon aggiungere più lettere rispetto alla stringa originale! Potreste sovrascrivere le altre stringhe di cui il programmanecessita, o peggio, parte di codice necessario al funzionamento del programma!! Nel mio caso, ho digitato “Program

R4ndom”:

Ora fate clic su OK ed eseguite l'applicazione (fate clic all'interno di Olly e premete F9). Spostatevi sul programma,digitate qualcosa e selezionate “Options” -> “Get Text”. Ora guardate la finestra di dialogo!!

Notate qualcosa di diverso nel titolo?

-Alla prossima

R4ndom

Link al tut originale : http://octopuslabs.io/legend/blog/archives/115.html

Traduzione a cura di Gmarksa.