[🥇 Gold 4] 파일 커서를 656번 흩뿌린 검증기 되감기 — DreamHack fverify 풀이

file extracted/main; readelf -SW extracted/main | grep -E " \.(text|rodata|data|bss) "

fseek(fp, off, SEEK_SET);   // 파일 시작 기준 — off 가 곧 절대 위치
fseek(fp, off, SEEK_CUR);   // 현재 위치 기준 — 지금 어디인지 모르면 결과도 모른다
fseek(fp, off, SEEK_END);   // 파일 끝 기준
long ftell(FILE *fp);       // 현재 위치를 돌려준다

objdump -T extracted/main | grep UND; objdump -s -j .rodata extracted/main | tail -3

objdump -d -M intel --start-address=0x1233 --stop-address=0x12bc extracted/main | sed -f annot_main.sed

FILE *fp = fopen(argv[1], "rb");
fseek(fp, 0, SEEK_END);
long size = ftell(fp);
fseek(fp, 0, SEEK_SET);          // 커서를 0 으로 되돌려 놓고
if (size != 0x290) { puts("size mismatch"); puts("Wrong!"); return 0; }
char ok = fverify(fp);           // 0x12e3
puts(ok ? "Correct!" : "Wrong!");

objdump -d -M intel --start-address=0x1308 --stop-address=0x13c9 extracted/main | sed -f annot_fverify.sed

objdump -d -M intel --start-address=0x2aa89 --stop-address=0x2aadd extracted/main | sed -f annot_tail.sed

movzx  edx, BYTE PTR [rbp-0x9]   ; 지금까지의 ok
movzx  eax, BYTE PTR [rbp-0xa]   ; 방금 읽은 바이트
cmp    al, 0x20                  ; 기대값과 비교
sete   al
and    eax, edx                  ; ok &= (byte == 0x20)
mov    BYTE PTR [rbp-0x9], al

#!/usr/bin/env python3
# fverify 본문이 정말 "fseek/fread/cmp 세 종류뿐"인지 세어 본다.
# 니모닉에서 즉치값만 K 로 뭉개고 빈도를 뽑는다.
import re
import subprocess
from collections import Counter
from pathlib import Path
 
BIN = Path(__file__).resolve().parent / "extracted" / "main"
out = subprocess.run(["objdump", "-d", "-M", "intel", str(BIN)],
                     capture_output=True, text=True, check=True).stdout
 
body = []
for line in out.split("\n"):
    m = re.match(r"\s*([0-9a-f]+):\t([0-9a-f ]+)\t(.*)", line)
    if m and 0x12E3 <= int(m.group(1), 16) <= 0x2AADC:
        body.append(m.group(3).strip())
 
print(f"fverify 본문 명령 수: {len(body)}")
c = Counter(re.sub(r"#.*", "", re.sub(r"0x[0-9a-f]+", "K", t)).strip() for t in body)
print("--- 상위 20개 (즉치값은 K 로 뭉갬) ---")
for text, n in c.most_common(20):
    print(f"{n:6d}  {text}")
print("--- 조건분기(jcc)·산술 명령이 어디에 있나 ---")
for line in body:
    if re.match(r"j(?!mp)[a-z]+\s", line) or re.match(r"(add|sub|xor|imul|shl|shr|rol|ror)\s", line):
        print(f"        {line}")
print("        ^ 전부 프롤로그(스택 확보)·에필로그(스택 카나리)뿐이다.")
print("          본문에는 분기도 연산도 없다 — 읽고 비교하기만 한다.")

python3 stats.py

mov  esi, 0x3e            ; fseek 의 2번째 인자 — 양수는 esi
mov  rsi, 0xff...ffcc     ; 음수는 rsi 로 부호확장돼 들어온다
lea  rax, [rbp-0x299]     ; fread 의 목적지 슬롯
movzx eax, BYTE PTR [rbp-0x299] / cmp al, 0x68   ; 그 슬롯의 기대값

set pagination off
set confirm off
set $n = 0
break fread
commands
silent
set $n = $n + 1
printf "fread #%-2d  ftell=%4ld  -> buf[rbp-0x%lx]\n", $n, (long)ftell($rcx), $rbp - $rdi
if $n >= 10
  printf "... (총 656회 중 앞 10회만 표시)\n"
  kill
  quit
end
continue
end
run answer.bin

gdb -q -batch -x trace_reads.gdb ./extracted/main

#!/usr/bin/env python3
# fverify (DreamHack, Gold 4 / reversing) — 검증 파일 656바이트 복원
#
# main 은 파일 크기가 0x290(656)인지 보고 fverify() 로 넘긴다.
# fverify 는 분기 하나 없는 직선 코드로
#   fseek(f, imm, SEEK_CUR) 4949회 · fread(&slot, 1, 1, f) 656회 · cmp al, imm 656회
# 만 반복한다. 즉 파일 커서를 상대이동으로 흩뿌려 가며 656바이트를 순서만 뒤섞어 읽고,
# 각 바이트를 상수와 비교해 ok 를 누산한다.
#
# 따라서 objdump 출력을 그대로 재생(커서 시뮬레이션)하면
#   "몇 번째 fread 가 파일의 몇 번 오프셋을 읽는가" 가 복원되고,
# 그 오프셋에 대응하는 cmp 상수를 꽂으면 파일 전체가 나온다.
import re
import subprocess
import sys
from pathlib import Path
 
HERE = Path(__file__).resolve().parent
BIN = HERE / "extracted" / "main"
OUT = HERE / "answer.bin"
 
FVERIFY_START = 0x12E3   # main 이 call 하는 함수
FVERIFY_END = 0x2AADC    # ret
SIZE = 0x290             # main 의 cmp QWORD PTR [rbp-0x8],0x290
 
 
def disassemble(path):
    """objdump 로 .text 를 통째로 뜬다 (주소, 니모닉) 목록."""
    out = subprocess.run(
        ["objdump", "-d", "-M", "intel", str(path)],
        capture_output=True, text=True, check=True,
    ).stdout
    insns = []
    for line in out.split("\n"):
        m = re.match(r"\s*([0-9a-f]+):\t([0-9a-f ]+)\t(.*)", line)
        if not m:
            continue
        addr = int(m.group(1), 16)
        if FVERIFY_START <= addr <= FVERIFY_END:
            insns.append((addr, m.group(3).strip()))
    return insns
 
 
def sx(text):
    """objdump 가 찍은 64비트 즉치값을 부호 있는 정수로."""
    v = int(text, 16)
    return v - (1 << 64) if v >= (1 << 63) else v
 
 
def extract_ops(insns):
    """(seek, 오프셋) / (read, 스택슬롯) / (cmp, (스택슬롯, 기대값)) 시퀀스로 압축."""
    ops = []
    pend_off = pend_slot = pend_cmp_slot = None
    for _, text in insns:
        m = re.match(r"mov\s+r?e?si,(0x[0-9a-f]+)$", text)          # fseek 2번째 인자
        if m:
            pend_off = sx(m.group(1))
            continue
        m = re.match(r"lea\s+rax,\[rbp-(0x[0-9a-f]+)\]$", text)      # fread 목적지
        if m:
            pend_slot = int(m.group(1), 16)
            continue
        if text.startswith("call") and "fseek@plt" in text:
            ops.append(("seek", pend_off))
            continue
        if text.startswith("call") and "fread@plt" in text:
            ops.append(("read", pend_slot))
            continue
        m = re.match(r"movzx\s+eax,BYTE PTR \[rbp-(0x[0-9a-f]+)\]$", text)
        if m:
            pend_cmp_slot = int(m.group(1), 16)
            continue
        m = re.match(r"cmp\s+al,(0x[0-9a-f]+)$", text)               # ok &= (byte == imm)
        if m:
            ops.append(("cmp", (pend_cmp_slot, int(m.group(1), 16))))
            continue
    return ops
 
 
def replay(ops):
    """파일 커서를 그대로 흉내내 슬롯→파일오프셋 매핑을 얻고 기대 바이트를 채운다."""
    pos = 0
    slot_off = {}
    data = {}
    stats = {"seek": 0, "read": 0, "cmp": 0, "neg_fail": 0, "past_eof": 0, "eof_read": 0}
    for kind, val in ops:
        if kind == "seek":
            stats["seek"] += 1
            nxt = pos + val
            if nxt < 0:
                stats["neg_fail"] += 1   # fseek 실패 → 커서 유지
            else:
                pos = nxt
                if pos >= SIZE:
                    stats["past_eof"] += 1
        elif kind == "read":
            stats["read"] += 1
            if pos >= SIZE:             # EOF 뒤라 아무것도 안 읽힘
                stats["eof_read"] += 1
                slot_off[val] = None
            else:
                slot_off[val] = pos
                pos += 1
        else:
            stats["cmp"] += 1
            slot, want = val
            off = slot_off.get(slot)
            if off is not None:
                data[off] = want
    return data, stats
 
 
def main():
    if not BIN.exists():
        sys.exit(f"바이너리가 없습니다: {BIN}")
 
    insns = disassemble(BIN)
    ops = extract_ops(insns)
    data, st = replay(ops)
 
    print(f"[*] fverify 명령 수      : {len(insns)}")
    print(f"[*] fseek / fread / cmp  : {st['seek']} / {st['read']} / {st['cmp']}")
    print(f"[*] 음수 seek 실패       : {st['neg_fail']}   EOF 뒤 read: {st['eof_read']}")
    print(f"[*] 커서가 EOF 를 넘어간 횟수: {st['past_eof']}")
 
    missing = [i for i in range(SIZE) if i not in data]
    if missing:
        sys.exit(f"[!] 복원 실패 — 빈 오프셋 {len(missing)}개: {missing[:10]}")
 
    blob = bytes(data[i] for i in range(SIZE))
    OUT.write_bytes(blob)
    print(f"[+] {SIZE}바이트 전부 복원 → {OUT.name}")
    print()
    print(blob.decode("utf-8", "replace"))
 
    m = re.search(rb"DH\{[^}]+\}", blob)
    print(f"[+] FLAG: {m.group().decode() if m else '(못 찾음)'}")
 
 
if __name__ == "__main__":
    main()

python3 solve.py

There are countless functions within <stdio.h> - from fopen all the way through to fread, fwrite, fseek, and ftell.
But I've always hated how C lets you use just any file without question.
I wanted only the files I approved of to ever be touched.
 
So I devised my own creation: the fverify function. With it, I can filter out every unwanted file and keep only the chosen ones.
HA! HAHAHA!
 
And within this wicked scheme lies the flag:
DH{ce60d40e6fd2cc3303465d66559d021a5391a8245b65f517fda3bf61646bfe9a}.
 
In this terrifying world, isn't it only natural that someone like me would craft a function to verify files?
After all, one must always be prepared...

#!/usr/bin/env python3
# 복원한 answer.bin 을 진짜 바이너리에 먹여 판정을 확인한다.
#   ① 원본 그대로            → Correct!
#   ② 한 바이트만 뒤집기     → Wrong!     (전 바이트가 검사된다는 증거)
#   ③ 길이를 줄이기          → size mismatch
import subprocess
from pathlib import Path
 
HERE = Path(__file__).resolve().parent
BIN = HERE / "extracted" / "main"
GOOD = HERE / "answer.bin"
 
 
def run(path):
    r = subprocess.run([str(BIN), str(path)], capture_output=True, text=True)
    return r.stdout.strip().replace("\n", " / ")
 
 
blob = GOOD.read_bytes()
print(f"answer.bin  {len(blob)}바이트  ->  {run(GOOD)}")
 
flipped = HERE / "bad.bin"
mut = bytearray(blob)
mut[300] ^= 0x01
flipped.write_bytes(bytes(mut))
print(f"bad.bin     300번 바이트 1비트 반전  ->  {run(flipped)}")
 
short = HERE / "short.bin"
short.write_bytes(blob[:100])
print(f"short.bin   100바이트로 자름         ->  {run(short)}")

python3 verify.py