Scribd
Upload
198 views

Structured Exception Handler Exploitation

The SEH exploitation technique was publicly documented by David Litchfield September, 2003. At a high-level, the SEH overwrite technique uses a software vulnerability to execute arbitrary code by abusing the 32-bit exception dispatching facilities provided by Windows. At a functional level, an SEH overwrite is generally accomplished by using a stack-based buffer. This document explains SEH details while exploiting a real case. URL: https://www.htbridge.ch/publications/structured_exception_handler_exploitation.html Other information security publications: https://www.htbridge.ch/publications/

Uploaded by

High-Tech Bridge
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PDF or read online on Scribd
198 views

Structured Exception Handler Exploitation

The SEH exploitation technique was publicly documented by David Litchfield September, 2003. At a high-level, the SEH overwrite technique uses a software vulnerability to execute arbitrary code by abusing the 32-bit exception dispatching facilities provided by Windows. At a functional level, an SEH overwrite is generally accomplished by using a stack-based buffer. This document explains SEH details while exploiting a real case. URL: https://www.htbridge.ch/publications/structured_exception_handler_exploitation.html Other information security publications: https://www.htbridge.ch/publications/

Uploaded by

High-Tech Bridge
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PDF or read online on Scribd
You are on page 1/ 27

Structured Exception Handler EXPLOITATION

http://www.htbridge.ch/

Brian Mariani

What is an exception
An exception is an event that occurs during the execution of a program Requires the execution of code outside the normal flow of control

Structured Exception Handling


Blocks of code are encapsulated, with each block having one or more associated handlers. Each handler specifies some form of filter condition on the type of exception it handles When an exception is raised by code in a protected block, the set of corresponding handlers is searched in order, and the first one with a matchingfilter condition is executed A single method can have multiple structured exception handling blocks, and the blocks can also be nested within each other

Exception pointers structure (1)


Contains an exception record with a machine-independent description of an exception A context record with a machine-dependent description of the processor context at the time of the exception

Exception pointers structure (2)


A pointer to the next exception registration structure A pointer to the address of the actual code of the exception handler

Thread information block


The Thread Information Block (TIB) is a data structure in Win32 that stores information about the currently running thread At the position FS:[0x00] we found the current exception handler

Dumping SEH chain in Inmunity debugger

How SEH works?

The exception handlers are linked to each other They form a linked list chain on the stack, and sit relatively close to the bottom of the stack When an exception occurs, Windows retrieves the head of the SEH chain walks through the list and tries to find the suitable handler to close the application properly

Abusing the SEH


When exploiting an SEH overwrite and attacker clobbers the handler attribute of the EXCEPTION_REGISTRATION_RECORD with the address of an instruction sequence similar to POP POP RET When the exception occurs, this causes Windows to pass execution to this address, which subsequently returns to the location on the stack of the Next attribute of the EXCEPTION_REGISTRATION_RECORD The Next attribute is also controlled by the attacker, but if we recall the stack layout from earlier, the Next attribute is below the Handler attribute This limits the attacker to 4 bytes before running into the Handler address he previously supplied to originally obtain code execution However, by overwriting the Next attribute with the instructions that jump the Handler attribute, the attacker typically has enough room for arbitrary shellcode, and this is exactly what happens

Overwriting the Next SEH record and SE handler


To check a chain of exception handlers before and after an overflow we can use WinDbg !exchain command At the left we can see the SEH chain and the stack before the overflow occurs At the right we can see the pointers were successfully overwritten

What are we overwriting?

When we performs a regular stack based buffer overflow, we overwrite the return address of the Extended Instruction Pointer (EIP) When doing a SEH overflow, we will continue overwriting the stack after overwriting overflow EIP, so we can overwrite the default exception handler as well EIP

Viewing the SEH before the overflow


Before the overflow occurs we can see the stack and the SEH chain. The SEH chain starts from 0x015fd044 down to 0x015fffdc which indicates the end of the SEH chain Directly below 0x015fffe0, we see 0x7c839ad8, which is the address of the default SE 0x015fffe0 0x7c839ad8 handler for this application. This address sits in the address space of kernel32.dll

Viewing the SEH after the overflow


Dumping the TIB confirms that the SEH was overwritten Code execution is successfully passed to the injected address 0x61616161 Addresses 0x015fd044 and 0x015fd048 which were the Next SEH record and SE handler are now controlled.

EIP point to 0x61616161, so we can control the flow of the program

Pointer to the Next record and SEH handler was overwritten

TIB dumping let us know the SEH chain was sucessfully overwritten

See an exception analysis


The command !analyze v in Windbg give us more details about the triggering of the exception

How SEH base exploit works


When the exception is triggered the program flow go to the SE Handler All we need is just put some code to jump to our payload Faking a second exception makes the application goes to the next SEH pointer As the Next SEH pointer is before the SE handler we can overwrite the Next SEH Since the shellcode sits after the Handler, we can trick the SE Handler to execute POP POP RET instructions so the address to the Next SEH will be placed in EIP, therefore executing the code in Next SEH The code will basically jump over some bytes and execute the shellcode

Exploiting the application


We will exploit a vulnerability in Gogago Youtube Downloader Video ActiveX www.gogago.net/download/youtube_video_downloader_setup.exe A buffer overflow is triggered after injecting more that 2230 bytes in the Download() function This vulnerability could be exploited using a basic RET CALL technique We will use SEH based exploitation which is also functioning in this particular case

Creating the POC


We craft an html page calling the method Download using the CLASSID When we overflow the method with 2250 bytes with junk data we trigger an exception

Overwriting Next pointer and SE handler


To successfully overwrite the Next Pointer and SE Handler we must calculate the exact number of bytes to inject You can use tools as pattern_create and pattern_search from Metasploit, or you can do it manually injecting buffers with different patterns

Finding POP POP RET instructions


Finding opcodes its not a difficult task you can use findjump or IDA In this tutorial we will use WinDBG We launch our prove of concept and we attach to Internet Explorer. After the overflow Explorer occurs we search the base memory address of the Gogago module MDIEex.dll Finally we can search for the opcodes using the s command

Building the exploit


After calculating the number of bytes to overwrite the Next pointer and SE handler we inject 4 bytes of code to jump to our shellcode this will replace the old SE handler Following the SE handler we inject the POP POP RET opcodes from the same module of the exploited application Finally we inject our payload

Executing the exploit (1)


We place a breakpoint before entering in the vulnerable method. The SE handler that will be overwritten sits at 0x15fa79c, and corresponds to the jscript.dll module 0x15fa79c

Executing the exploit (2)


After the overflow occurs we successfully overwrites the old jscript SE handler later code execution will be redirected to our POP POP RET instructions

Redirect code execution


The code is redirected to our fake SE Handler address

Jumping to our payload


Jumping over 6 bytes to reach ou shellcode starting at address 0x015fa7a4

Shellcode execution
Time to dance

Questions

[email protected]

References
http://msdn.microsoft.com/en-us/library/ms680663%28v=VS.85%29.aspx http://msdn.microsoft.com/en-us/library/c68xfk56%28v=vs.71%29.aspx http://en.wikipedia.org/wiki/Win32_Thread_Information_Block http://corelan.be

You might also like