64-bit Stack-based Buffer Overflow
Last updated
Last updated
The purpose of this lab is to understand how to get control of the RIP register when dealing with classic stack-based buffer overflow vulnerabilities in 64-bit Linux programs.
This lab is based on a great post https://blog.techorganic.com/2015/04/10/64-bit-linux-stack-smashing-tutorial-part-1/.
Note that the vulnerable program used in this lab was compiled without memory protections deliberately and similarly, the ASLR was disabled.
For a more detailed overview of the stack based overflow exploitation:
For more information about the stack memory layout and calling convention for 64-bit Linux programs:
In this lab, we will be using the below vulnerable program, which declares a buffer buf of 80 bytes, but then allows writing 400 bytes to it, which when done, will overwrite stack's contents, specifically, the RBP and the return address, which can and will be exploited in this lab:
Remember about the stack
Stack grows downwards
Local variables are defined at lower stack addresses
Return address is located higher up in the stack, compared to local variables
We can compile the above code with:
Don't forget to disable the ASLR:
Let's try to overflow the program's buf buffer by sending some garbage data to it. First of, let's generate the said garbage data - 200 AAAAs:
Let's now run the vulnerable program, feed the garbage file to it and observe the program crash:
Note from the above screenshot the following key points:
The stack has been overflowed with As (lime);
RIP register (red) has not been overflowed although it would have been, had this been a 32-bit binary. On the same note, we can indeed see that the return address (RSP + 0 as ret instruction would pop this value and jump to it) has been filled with AAAA...s, so why are we not in control of the RIP register?
The reason the RIP was not overflowed (technically it was, as we saw in the above screenshot, but there's more to it), is because the AAAAAAAA (0x4141414141414141) is considered a non-canonical memory address, or, in other words, 0x4141414141414141 is a 64-bit wide address and current CPUs prevent applications and OSes to use 64-bit wide addresses.
Instead, the highest memory addresses programs can use are 48-bit wide addresses and they are capped to 0x00007FFFFFFFFFFF. This is done to prevent the unnecessary complexity in memory address translations that would not provide much benefit to the OSes or applications as it's very unlikely they would ever need to use all of that 64-bit address space.
Knowing about canonical addresses, we could take control of the RIP if the 64-bit wide return address 0x4141414141414141 (our garbage data) we tried to plant into the vulnerable program's stack, was translated to a 48-bit canonical address by masking off the 2 highest bytes:
Making our garbage return address a valid canonical address (note the 2 leading bytes are 00 00):
Let's see if we can make the program crash and point the RIP to the now canonical memory address 0x0000414141414141.
Before we can do this, we need to find out how much garbage AAA.. we need to send in to the vulnerable program before we can place 0x0000414141414141 onto the stack, so that we can take over the RIP.
In gdb-peda, let's create a pattern of 200 characters:
Feed that pattern to the vulnerable program, observe the crash, and find the offset where we should place our preferred RIP value (0x0000414141414141):
From the above screenshot, we can see that part of our pattern A7AAMAAiA... is visible at the top of the stack - this value would be popped from the stack and jumped to by the ret instruction. Now we need to know how many characters of the 200 bytes pattern that we generated earlier were put on the stack, before A7AAMAAiA got placed at the top of the stack.
Below screenshot illustrates the point outlined above:
200 characters pattern string
In red, 104 bytes of garbage characters
In cyan, the A7AAMAAiA - this is where we would place our arbitrary RIP value
To calculate the offset in gdb-peda, we can use pattern_offset like so:
The RIP offset as we've just identified is 104. Let's test it by generating a new garbage file that will now contain 104 A and a canonical return address 0x0000414141414141 (in reverse due to little-endianness):
Sending this data to the vulnerable program reveals that we have now taken control of the RIP register (lime):
We'd like the vulnerable program to spawn a shell for us when exploited, so we will place the shellcode in the environment variable PWN, so it ends up in the vulnerable program's stack when it's executed, like so:
Note that if you are trying to replicate this in your lab and you would like the vulnerable program to spawn a root shell, you need to use the shellcode that calls setuid(0) first. Thanks @reveng007.
We now need to find where on stack the PWN environment variable will be located in the vulnerable program. For this, we can use the following program:
Compile it with:
Then run it like so:
Note that the PWN environment variable will be on the vulnerable program's stack at 0x7fffffffefa8:
Convert 0x7fffffffefa8 to its canonical (2 highest bytes masked off) form, which equals to 0x0000ffffefa8. We can now try to exploit the vulnerable program by sending the garbage data that now includes the PWN environment variable address (that contains the shellcode that spawns a shell) as the return address at offset 104, like so:
To confirm the exploit worked as expected, we can unset the PWN environment variable and try to exploit the program again just to see the program crash, since it no longer knows what shellcode to execute:
