Corso UIC Newbies 13

From UIC

SEH (Strucured Exception handle) Reversing

Infos
Author:	Pnluck
Email:	pnluck@virgilio.it
Website:	http://pnluck.netsons.org
Date:	28/08/2006 (dd/mm/yyyy)
Level:
Language:	Italian
Comments:

Introduzione

Cos'è un' eccezione? Spero che vi siate posti questa domanda ogni volta, che in ollydbg dovete premere alt+F(X), per passarne una. Qui alla UIC c'è già un documento sull'argomento ,scritto da Quequero, dove non c'è un analisi reversing-side, ma asm programming-side, da cui copierò tutta la parte teorica e c'è anche un doc di Ntoskrnl per il c++).

Tools

• OllyDbg
• Masm

Essay

Avete mai visto sul vostro bel pc, un messaggio di errore di windows, che ci avverte che il programma è terminato a causa di un errore? Questo succede perche' nel programma o non vi è un gestore di eccezione, o questo non ha svolto il suo compito.

Teoria

Le eccezioni sono usate parecchio dal sistema, un esempio è questo: supponiamo che un thread abbia bisogno di più stack, l'idea principale sarebbe quella di monitorare lo spazio che sta usando e dargli più stack quando non c'è più memoria disponibile, ma ciò porterebbe via molte risorse oltre che spazio nel programma finale, allora si installa un Exception Handler (ovvero un Gestore di Eccezioni) che con pochissime risorse e poco spazio controlla una sola cosa: appena il thread ha raggiunto il limite massimo di stack il sistema segnala un'errore che verrà controllato dal NOSTRO handler e non da quello di win, il nostro handler provvederà quindi ad allargare lo stack, il tutto succede in modo enormemente veloce e senza spreco inutile di risorse, ma entriamo nel dettaglio. Windows si preoccupa di monitorare con un Exception Handler ogni thread avviato, la posizione di questo Exception Handler si trova in fs:[0], ogni errore nel codice fa si che il controllo passi a questo Handler che controllerà in sequenza queste cose (grazie a J. Gordon per l'elenco):

Prima di iniziare con qualche esempio di codice dobbiamo fare una distinzione, di Handler infatti ne esistono due tipi, il primo si chiama Final Handler e si installa nel Thread principale del programma ed il secondo si chiama per-Thread Handler che come dice la parola stessa si installa all'inizio di ogni thread, facciamo un esempio di Final Handler:

Cosa succede? All'inizio del programma viene installato un Final Handler che resterà sul Thread principale, mi sembra palese ricordare che prima lo installate meglio è, se durante il programma dovesse incorrere un errore che noi non ci aspettiamo allora il sistema seguirà gli step di sopra, se supponiamo di aver settato SoftIce a "faults off" allora il processo di gestione dell'Exception si fermerà al 5° Step e poi il programma verrà chiuso. Come vedete il Final Handler è l'ultima spiaggia nel quale il sistema cerca riparo, ma fa sempre uso di API e cmq il livello di libertà che noi abbiamo resta molto basso. Ora prima di utilizzare un per-Thread Handler, vediamo cosa succederebbe se esso non ci fosse :

Eseguendo questo semplice programma, viene generata un'eccezione, che windows prontamente vi segnala (se usate win xp). Ora vediamo l'installazione di un per-Thread Handler:

Questo codice è solo un esempio, infatti qui non avviene alcuna eccezione. Ora che sappiamo come si installano questi due tipi di Handler, iniziamo a studiare la Struttura di Errore.
Questa è una parte importantissima, perchè con essa, possiamo sapere dove è accaduta e di che tipo è un'eccezione.

ottenere questi dati è semplicissimo, all'interno del codice del nostro Exception Handler, basta fare:

e concepire che:

così un semplicissimo:

può servire nel conoscere il tipo d'eccezione, ed un altrettanto semplice:

serve a farci conoscere dove è avvenuta l'eccezione, bello non credete?

Ora che conosciamo anche la struttura di errore, vi mostro quali sono i più comuni codici di errore e quindi faremo qualche esperimento:

Solo due dword necessitano di una spiegazione, la prima è C00000095h, ovvero Integer Overflow, questa eccezione accade quando, durante una operazione un registro si trova a dover contenere una cifra troppo grande; il secondo codice è 80000004h, ovvero Single Step, l'eccezione di Single Step accade quando, viene settato il TrapFlag; infatti se il processore vede che questo flag è settato, genera questo tipo d'eccezione, per ogni istruzione eseguita. Per una lista completa del tipo d'eccezioni, basta cercare su google (ma dai???). Bene, ora che sappiamo come installare un gestore d' eccezione, e come è formata la struttura d'errore, sperimentiamo l'uso concreto di un Exception Handler per-Thread:

Come notate il programma ora non crasha, anzi vi appare anche una bella MessageBox. Dopo aver sperimentato e capito cosa sono gli Handler, approfondiamo la struttura d' errore, per ora conosciamo solo due parametri: ExceptionCode, e ExceptionAddress.... Sono i più intuitivi, ma gli altri?

Ecco la parte più interessante delle SEH, infatti al momento della chiamata al per-Thread Handler, ESP+C punta al Context che contiene tutte le specifiche dei registri al momento dell'eccezione (il context si ottiene anche chiamando GetThreadContext) ed è:

Questa in pratica è la "sala dei bottoni" del vostro processore, da qua dentro fate proprio tutto :) anche quello che non potreste fare altrimenti :). Esp+8 punta invece ad una NOSTRA struttura di errore, mentre Esp+4 punta all'EXCEPTION_RECORD. Finito qui? Niente affatto, se succede un qualche tipo di errore cosa facciamo? Beh, prima di chiudere il programma dobbiamo constatare se l'eccezione è riparabile, se si allora possiamo fare qualcosa di davvero carino, appena viene invocato l'Handler ESP+8 punta alla nostra struttura di errore che è così formata:

vi garantisco che non è poco, infatti i valori contenuti da STRUTTURA+8 e STRUTTURA+14h sono importantissimi, ci consentono infatti di far continuare l'esecuzione del programma in un "luogo-sicuro" (se l'eccezione non è recuperabile allora si chiama RtlUnwind e pazienza :) quindi la prima cosa da fare è vedere se l'eccezione è continuabile, se si allora si estrae dalla nostra struttura di errore l'indirizzo del luogo-sicuro (STRUTTURA+8) e quello del nostro nuovo EBP (STRUTTURA+14h), quindi si estrae il CONTEXT e da li' dentro si manipola CONTEXT+B4 (registro ebp) ponendolo uguale al valore suggerito da STRUTTURA+8 e poi si manipola CONTEXT+B8 (registro eip) ponendolo uguale a STRUTTURA+14h, in questo modo l'EIP verrà cambiato ed il codice continuerà allegramente dove è in grado di prolificare :), vi riporto del codice di J. Gordon:

Reversing

Ora finalmente si inizia a reversare:

Eseguendo il programma vi accorgerete che apparire la seconda MessageBox, invece della prima, questo succede perchè int 3,genera un' eccezione. Se provate a steppare, vi accorgerete che stepperete attraverso l'int3, facendo apparire la prima MessageBox, ora provate a mettere invece di int3 "xor eax, eax" "div eax"; come notate olly non vi farà più steppare e vi dirà che per passare l'eccezione, dovrete premete alt+f7/f8/f9: f9 fa proseguire l'esecuzione del processo, premendolo ci appare la messagebox giusta, ma non ci permette di analizzare il codice. f7/f8, vi fanno apparire ciò:

Ora se steppate, vedrete che arrivando a ZwContinue, e vi appare la nostra bella MessageBox. Ora approfondiamo di più:

Cosa avviene in caso di eccezione? Semplice, come precedentemente spiegato, il controllo passa in mano all'offset di gestore, che in questo caso è 00401055 (vedi exe disassemblato), quindi mettiamo un bel bp a quest'indirizzo, e lanciamo il programma. Appena si verifica l'eccezione di tipo "integer division by zero", premiamo alt+F9 (per far proseguire il programma), e come per magia non apparirà più la MessageBox (come in precedenza), ma ci fermiamo al bp settato da noi, ora analizziamo il codice del gestore:

Per prima cosa il gestore preleva il context del processo, poi setta context+B8h(EIP) a 401031, e fa continuare l'esecuzione. In poche parole dopo il ret, il processo riprenderà dall'indirizzo 401031, quindi ora settiamo un bel breakpoint lì, e lanciamo il programma.
Come supposto, il processo riprende proprio a 401031, ora possiamo steppare fino alla MessageBox giusta :D.

Ora analizziamo un semplce crackme pieno di SEH Guardiamo il disassemblato in olly:

Nulla di interessante per i nostri scopi, continuiamo:

Vi spiego questa parte di disassemblato, lasciamo stare l'inizio e partiamo dalle istruzioni da 401032 a 40103D, non fanno altro che installare un gestore di eccezioni:

• Le istruzioni 401032 & 401037, non fanno altro che salvare nello stack l'indirizzo di handler (40104F), quindi mettiamoci un bp sopra.
• Le istruzioni da 401038 & 40103A: sarebbe "push fs:[0]", questo è un piccolo trick, xkè dopo lo "xor ecx, ecx" ,ecx diventa 0, quindi viene richiamato proprio fs:[0].
• L'istruzione 40103A, installa il per-thread handle.

Cmq dopo l'installazione dell'handle, possiamo trovare nello stack le informazioni riguardati l'installazioned di un SE handler:


o grazie ad ollydbg (Nel menu view->SEH chain)


Io vi consiglio di usare SEH chain, perchè potete mettere direttamenti li' un bel bp, ed attenzione perchè,il primo Seh handler del prg listato, corrisponde all'ultimo gestore installato.

Capito come viene installato un gestore d'eccezione (quindi mettiamo un bel bp a 40104F e lanciamo il prg); continuiamo l'analisi del nostro crackme:
l'istruzione 401040, trasforma il byte di 401047 da BB a CC(int3), ma se steppiamo, noi lo superiamo e stepperemo sempre tra il push e il ret.

Vediamo l'indirizzo del seh handler (come spiegato precedentemente): 40107B, come è possibile?? Allora l'indirizzo del seh handler è salvato nello stack, e dato che lo stack, dall'eccezione in poi non è stato modificato, esp+4 corrisponde all'indirizzo del seh handler nello stack :D, quindi il vecchio indirizzo del seh handler, viene sostituito con il nuovo.

Settiamo un bp a 4010a6, e continuiamo:

Mettiamo un bp ad handler3

Per controllare le modifiche al context eseguite in un seh handler, potete anche usare il mio plugin per olly, senza dover controllare il codice, in modo ossessivo. Continuiamo l'analisi:

Per risolvere questo crakme basta creare un file congratulations.txt ed il gioco è fatto :D RAGAAAAAAA ALLA PROSSIMA (speriamo)

Note Finali

Ringrazio quequero ke mi ha dato la possibilità di scrivere questa lezione, a nt, quake, evilcry, ermes, 0x87k e tutti quelli di #crack-it #pmode e #cryptorev, anche se più o meno so sempre le stesse persone :D

Disclaimer