Tranning-2

Introduction to Software
Exploitation
Faheem & Ali
Ebryx (pvt) Ltd
Reference:
http://opensecuritytraining.info/Expl
oits1.html

Purpose of the course
•Give you a deep understanding of the
mechanics of software exploitation
•Demonstration of buffer overflow attack
•Custom Shell-code writing and executing
•Exploit finding techniques
http://opensecuritytraining.info/Exploits1.html

Lets get down to business

What are we trying to achieve?
•Arbitrary code execution
•Examples
–Forcing ssh to give you root access to the power
grid (like Trinity in the previous slide!)
–Bypassing authentication checks.
–Forcing a privileged administrator process to
execute code your normally wouldn’t be able to.
–Etc….

You are presented with the following program….
This worked in the movies…
What arbitrary code execution do we want? Go_shell() would be nice!http://opensecuritytraining.info/Exploits1.html

Real life
Sayyyyy what?

x86 Review Lab
•The EBP register points to the base of the stack
frame. Local variables, which are stored on the
stack, are referenced via this base pointer.
•Every time a function is called, a new stack
frame is setup so that the function has its own
fresh context (its own clean set of local
variables).
•The call instruction also puts a return address
on the stack so that the function knows where
to return execution to.http://opensecuritytraining.info/Exploits1.html

Boring…. Let’s investigate
Stack (grows downwards)
Junk
Junk
Junk
Junk
Junk
Junk
Junk
Main() just called

Return address into main
Main’s saved frame pointer
(ebp)
Char password[64];
Junk
Junk
Junk
Junk
Authorize() just called
The top of authorize()’s stack frame
stores main()’s saved frame pointer
(0xbffff5f8) as well as the return address
to return execution too once authorize()
is finished (0x080483b)http://opensecuritytraining.info/Exploits1.html

Return address into main
Main’s saved frame pointer
(ebp)
“password”
Junk
Junk
Junk
Junk
Authorize() just called
Notice the 64 byte difference between
the top of the stack (esp) and the base
of the frame (ebp). These are the 64
bytes we created to store password.
Also worth noting is that where
password is stored on the stack is 68
bytes away from the saved return
address into main…

f password is more than the 64 bytes than we allocated for it on the stack?
The instruction pointer ends up pointing to 0x41414141, which is “AAAA.” This means
we can cause arbitrary code execution since we can set the instruction pointer.http://opensecuritytraining.info/Exploits1.html

Since 0x41414141 is arbitrary, we have achieved our goal of “Arbitrary code execution.”
However, 0x41414141 isn’t very useful since it just crashes the program
(because 0x41414141 points to nowhere). Remember what we want to achieve is
execution of go_shell() since that does something useful (gives us administrator access).
To achieve this, we first fill up the password[64] buffer with 64 bytes of junk, then 4 extra
bytes of junk to overwrite the saved frame pointer, and then also write 4 bytes
representing the address of go_shell().

Oh, Yeahh we corrupted that stack! We are now executing go_shell()’s code!

It’s more useful for us to put this all together outside of a debugger.
he unix pipe “|” is to redirect output of our command (cat payload;cat) and use it as
he input for simple_login. We have to put the extra “cat” in the command to echo
ommands to the shell we will spawn, otherwise an EOF is sent and the shell closes
mmediately before we can actually execute any programs.

Shellcode
•So that’s nice, but it isn’t quite “Arbitrary code
execution” since we are relying on simple_login
to contain this root shell spawning code
prepackaged (not realistic).
•How do we insert our own arbitrary code into
the program to execute?

Shellcode 2
•Among other places, we can actually just insert
this code into the program through a typical
input medium. In other words, when
simple_login attempts to read in our password
guess, we can feed it in an executable program.
•Thus the password[64] buffer will end up
containing a small standalone program that we
will later execute by redirecting the overwritten
stored return address to the address of buffer!

Properties of shellcode
•Aims to be small since it often has to fit in small
input buffers.
•Position independent (can’t make any
assumptions about program state when it
begins executing)
•Should contain no null characters (many
standard string copying library calls terminate
upon seeing a null character)
•Must be self contained in an executable section
(shouldn’t reference data in data sections, etc).

Example shellcode payloads
1)Execute a shell
2)Add an Administrator user
3)Download and install a rootkit
4)Connect back to attacker controlled server and
wait for commands
5)Etc…

Hello, World! - Linux

Can we use it as shellcode?
What are the problems here?

Can we use it as shellcode?
1)Null bytes are bad. Basically every standard library function is going
to treat those null characters as terminators and end up truncating
our program.
2)Not position independent. That 0x80490a4 address referenced is
going to be meaningless when we inject this into another program.

he extended (eax, ebx, ecx…) x86 registers are 32 bit. So when we attempt to
Move a less than 32 bit value to one of them (mov eax, 0x4), the compiler pads the
alue with 0. If we instead move the immediate value to the appropriately sized
ersion of the registers, the null padding will not be added.
ecall:
ax = 32 bits, ax = 16 bits, al = 8 bits
We still have 1 null byte left. What if we actually need to use a null byte in our code
Somewhere like when we are trying to exit with a status code of 0? What about
that pesky string address we are still referencing? Suggestions?

pting to achieve position independence and our reliance on that fixed string address.
-We can create a null byte to use by performing xor ebx, ebx
- Store the string we want to print/reference on the stack, and then just pass
esp
to the system call!
But wait, the code still won’t work as shellcode.
Challenge: What did Corey do wrong??

Corey burned a good hour trying to figure this mystery out…
Standard library functions also truncate on the new line byte (0x0a)! Hence 0x0a
Is bad like null bytes!

The easy way out….
cally I just changed the newline character to another exclamation point to get rid of
ibc copy problem, and to put emphasis on how hard we are owning these programs.
u are jaded you might just think I’m cheating here…http://opensecuritytraining.info/Exploits1.html

New goal!
•Previously we forced the simple login program
to execute go_shell(). By overwriting the saved
return address and thereby setting the eip to
go_shell()’s start.
•But we want to use our new toy, our snazzy
shellcode.
•How do we get our shellcode into the program
so we can overflow the return address again and
set eip to execute our shellcode?

Game Plan
•Instead of spraying a bunch of junk into the
password buffer to get to the saved return
address, we will first input our shellcode’s
opcodes. (This is perfectly acceptable program
input).
•Then, we will change the eip of the program to
point to the password buffer, where are
shellcode’s opcode is stored!

For ease I created a hello_shell.pl script which just prints out our shellcode’s
opcodes, making it easier to inject into the password[64] buffer in the simple
login program.

member, when overflowing the password[64] buffer of the simple_login program
overwrite the eip, we first filled password with 64 bytes of junk (0x41), 4 additional
tes of junk to overwrite the saved frame pointer, and then 4 bytes representing the
dress with which we were going to overwrite the saved return address with.
AAAAAA…. 64 times><AAAA><0x080482aa>
Old payload…

New Payload
Heres what we are going for…
<NOP.NOP.NOP><SHELLCODE OPS><AAAA><Address of password buffer>
• <NOP.NOP.NOP><SHELLCODE OPS> still needs to be
a total of 64 bytes combined.
• Recall, NOPS are just do nothing instructions, so
when eip points to the password buffer, it will just
‘do nothing’ until it starts hitting the shellcode op
codes.
•sizeof<NOPS> = 64 – sizeof<SHELLCODE OPS>

•First we build the <NOPS><SHELLCODE>
portion of the shellcode
•Still need the <AAAA><Address of Password
Buffer> part of the payload
•We need to determine the address of the
password bufferhttp://opensecuritytraining.info/Exploits1.html

•We set a break point after the gets() call that
reads in the buffer so we can try to find out
shellcode on the stack
•Looks like 0xbffff594 lies in the middle of our
NOPS, so the password buffer must be there.
We will make this our target eip.http://opensecuritytraining.info/Exploits1.html

Final Payload Construction
•We now have the
<NOPS><Shellcode><AAAA><address of
password buffer> payload complete
•Let’s use it!

•We just forced simple_login to execute
arbitrary code that we injected into it!!!
•In reality, an attacker would want to do
something more useful than just print a
message.
•What would you do if you wanted to execute
arbitrary code but the architecture forbid you
from executing the password buffer as if it were
code?

Something more useful!

Tranning-2

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Tranning-2 (20)

Tranning-2

Editor's Notes