[🥉 Bronze 2] .rodata 247바이트가 스택 VM 바이트코드였다 — DreamHack SelfStatus 풀이

file extracted/prob && checksec --file=extracted/prob

readelf --dyn-syms -W extracted/prob | grep UND && strings -a -t x extracted/prob | grep -aE "proc/self|TracerPid|Enter flag|Correct|Wrong"

objdump -s -j .rodata extracted/prob

#!/usr/bin/env bash
# TracerPid 가 실제로 무엇을 담는지 두 경우로 비교한다.
#   ① 아무도 안 붙었을 때  ② gdb 가 붙어 있을 때
echo "[1] 아무도 안 붙은 상태 (이 셸 자신)"
grep TracerPid /proc/self/status
 
echo
echo "[2] gdb 로 prob 을 붙잡아 둔 상태 — 그 프로세스의 status 를 본다"
gdb -q -batch -ex starti \
    -ex 'shell grep TracerPid /proc/$(pgrep -n prob)/status' \
    -ex kill --args ./extracted/prob

./tracerpid_demo.sh

s|# 2117 .*|&   <-- "/proc/self/status"|
s|# 2129 .*|&   <-- "TracerPid:"|
s|call.*<open@plt>|&   <-- open(path, O_RDONLY)|
s|mov    edx,0x1ff|&   <-- 최대 511바이트만 읽는다|
s|call.*<read@plt>|&   <-- read(fd, buf, 511)|
s|call.*<strstr@plt>|&   <-- strstr(buf, "TracerPid:")|
s|add    QWORD PTR \[rbp-0x220\],0xa|&   <-- 포인터를 "TracerPid:" 10글자만큼 전진|
s|cmp    al,0x20|&   <-- 공백 건너뛰기|
s|cmp    al,0x9|&   <-- 탭 건너뛰기|
s|cmp    al,0x30|&   <-- 첫 글자가 '0' 인가|
s|mov    eax,0x1$|&   <-- '0' 이 아니면 1(=추적당하는 중) 반환|

objdump -d -M intel --start-address=0x11c3 --stop-address=0x1239 extracted/prob | sed -f annot_antidbg.sed

objdump -d -M intel --start-address=0x125c --stop-address=0x12cf extracted/prob | sed -f annot_antidbg.sed

int anti_debug(void)
{
    char buf[512];
    int fd = open("/proc/self/status", O_RDONLY);
    if (fd < 0) return 0;                       /* 못 열면 통과 */
 
    ssize_t n = read(fd, buf, 0x1ff);
    close(fd);
    if (n <= 0) return 0;                       /* 못 읽어도 통과 */
    buf[n] = 0;
 
    char *p = strstr(buf, "TracerPid:");
    if (!p) return 0;                           /* 그 줄이 없어도 통과 */
    p += 10;
    while (*p == ' ' || *p == '\t') p++;
 
    return (*p == '0') ? 0 : 1;
}

strace -f -e trace=openat,open,read,write,exit_group ./extracted/prob

15f9:  lea    rax,[rbp-0x90]        ; 3번째 인자: 출력 버퍼
1600:  mov    rdx,rax
1603:  mov    esi,0xf7              ; 2번째 인자: 247 (= 0x2116 - 0x2020 + 1)
1608:  lea    rax,[rip+0xa11]       ; 1번째 인자: 0x2020 — .rodata 의 그 바이트열
160f:  mov    rdi,rax
1612:  call   12e5                  ; vm(code, len, out)
1617:  lea    rdx,[rbp-0x110]       ; 사용자 입력
161e:  lea    rax,[rbp-0x90]        ; VM 출력
1625:  mov    rsi,rdx
1628:  mov    rdi,rax
162b:  call   1080 <strcmp@plt>

s|cmp    BYTE PTR \[rbp-0xa9\],0xa1|&   <-- PUSH imm|
s|cmp    BYTE PTR \[rbp-0xa9\],0xa2|&   <-- POP|
s|cmp    BYTE PTR \[rbp-0xa9\],0xa3|&   <-- XOR imm|
s|cmp    BYTE PTR \[rbp-0xa9\],0xa4|&   <-- ADD imm|
s|cmp    BYTE PTR \[rbp-0xa9\],0xa5|&   <-- SKIP (오퍼랜드 1바이트 버림)|
s|cmp    BYTE PTR \[rbp-0xa9\],0xee|&   <-- SKIP (0xa5 와 완전히 같은 동작)|
s|cmp    BYTE PTR \[rbp-0xa9\],0xf0|&   <-- OUT (pop 해서 출력 버퍼로)|
s|cmp    BYTE PTR \[rbp-0xa9\],0xff|&   <-- HALT|
s|mov    QWORD PTR \[rbp-0x98\],rdx|&   <-- pc 갱신|
s|mov    BYTE PTR \[rbp-0xa9\],al|&   <-- op = code\[pc++\]|
s|mov    BYTE PTR \[rbp+rax\*1-0x90\],dl|&   <-- stack\[sp++\] = code\[pc++\]|
s|add    QWORD PTR \[rbp-0x98\],0x1$|&   <-- pc += 1 (오퍼랜드를 삼키기만 한다)|
s|sub    QWORD PTR \[rbp-0xa8\],0x1$|&   <-- sp -= 1|
s|mov    BYTE PTR \[rax\],dl|&   <-- out\[oi++\] = stack\[sp\]|

objdump -d -M intel --start-address=0x133a --stop-address=0x13a6 extracted/prob | sed -f annot_vm.sed

objdump -d -M intel extracted/prob | grep -E "cmp +BYTE PTR \[rbp-0xa9\]" | sed -f annot_vm.sed

objdump -d -M intel --start-address=0x14a1 --stop-address=0x1505 extracted/prob | sed -f annot_vm.sed

#!/usr/bin/env python3
"""SelfStatus (DreamHack, Bronze 2, reversing) - solver
 
prob 의 .rodata 0x2020 에 박힌 247바이트 바이트코드를 그대로 꺼내
0x12e5 의 VM 을 파이썬으로 재현한다. VM 출력이 곧 정답 플래그다
(main 은 그 출력과 사용자 입력을 strcmp 로 비교할 뿐이다).
"""
import sys
from pathlib import Path
 
ELF = Path(__file__).with_name("extracted") / "prob"
 
CODE_VADDR = 0x2020   # main 이 vm 에 넘기는 첫 인자 (lea rax,[rip+0xa11])
CODE_LEN   = 0xF7     # 두 번째 인자 (mov esi,0xf7)
 
# --- .rodata 를 섹션 헤더로 찾아 파일 오프셋으로 환산 -------------------
def read_code(path: Path) -> bytes:
    b = path.read_bytes()
    e_shoff  = int.from_bytes(b[0x28:0x30], "little")
    e_shentsize = int.from_bytes(b[0x3A:0x3C], "little")
    e_shnum  = int.from_bytes(b[0x3C:0x3E], "little")
    for i in range(e_shnum):
        sh = b[e_shoff + i * e_shentsize : e_shoff + (i + 1) * e_shentsize]
        addr = int.from_bytes(sh[0x10:0x18], "little")
        off  = int.from_bytes(sh[0x18:0x20], "little")
        size = int.from_bytes(sh[0x20:0x28], "little")
        if addr <= CODE_VADDR < addr + size:          # .rodata 가 잡힌다
            start = off + (CODE_VADDR - addr)
            return b[start : start + CODE_LEN]
    raise SystemExit("바이트코드가 든 섹션을 못 찾았다")
 
# --- 0x12e5 의 VM 을 그대로 옮긴 것 ------------------------------------
PUSH, POP, XOR, ADD, NOP1, NOP2, OUT, HALT = 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xEE, 0xF0, 0xFF
 
def run(code: bytes):
    stack, out, pc = [], bytearray(), 0
    while pc < len(code):
        op = code[pc]; pc += 1
        if op == PUSH:                      # stack[sp++] = code[pc++]
            stack.append(code[pc]); pc += 1
        elif op == POP:                     # if sp: sp--
            if stack: stack.pop()
        elif op == XOR:                     # if sp: stack[-1] ^= code[pc++]
            if not stack: continue
            stack[-1] ^= code[pc]; pc += 1
        elif op == ADD:                     # if sp: stack[-1] += code[pc++]
            if not stack: continue
            stack[-1] = (stack[-1] + code[pc]) & 0xFF; pc += 1
        elif op in (NOP1, NOP2):            # 오퍼랜드 1바이트만 삼키고 아무것도 안 한다
            pc += 1
        elif op == OUT:                     # if sp: out[oi++] = stack[--sp]
            if stack: out.append(stack.pop())
        elif op == HALT:
            break
        # 그 밖의 바이트는 오퍼랜드를 소비하지 '않고' 그냥 무시된다
    return bytes(out)
 
# --- 바이트코드 디스어셈블러 (글/검증용) --------------------------------
def disasm(code: bytes):
    lines, pc = [], 0
    while pc < len(code):
        at, op = pc, code[pc]; pc += 1
        if op in (PUSH, XOR, ADD, NOP1, NOP2):
            arg = code[pc]; pc += 1
            name = {PUSH: "PUSH", XOR: "XOR ", ADD: "ADD ", NOP1: "SKIP", NOP2: "SKIP"}[op]
            lines.append(f"{at:04x}: {op:02x} {arg:02x}   {name} 0x{arg:02x}")
        else:
            name = {POP: "POP", OUT: "OUT", HALT: "HALT"}.get(op, "??? (무시)")
            lines.append(f"{at:04x}: {op:02x}      {name}")
            if op == HALT: break
    return lines
 
if __name__ == "__main__":
    code = read_code(ELF)
    if "-d" in sys.argv:
        lines = disasm(code)
        if "--limit" in sys.argv:
            n = int(sys.argv[sys.argv.index("--limit") + 1])
            lines, rest = lines[:n], len(lines) - n
            if rest > 0:
                lines.append(f"... (같은 모양으로 {rest}줄 더)")
        print("\n".join(lines))
        sys.exit(0)
    flag = run(code)
    print(f"바이트코드 {len(code)}바이트 -> 출력 {len(flag)}바이트")
    print("FLAG:", flag.decode())

python3 solve.py -d --limit 24

(SKIP 여러 개)  PUSH v  XOR 0x42  OUT

python3 solve.py

/* nostatus.c — prob 의 anti-debug 를 무력화하는 LD_PRELOAD 심.
 *
 * prob 은 open("/proc/self/status") 로 자기 상태를 읽어 TracerPid 를 본다.
 * 그 open 호출만 가로채 우리가 만든 fake_status 로 돌린다.
 *   gcc -shared -fPIC -o nostatus.so nostatus.c -ldl
 */
#define _GNU_SOURCE
#include <dlfcn.h>
#include <fcntl.h>
#include <stdarg.h>
#include <string.h>
#include <sys/types.h>
 
int open(const char *path, int flags, ...)
{
    static int (*real_open)(const char *, int, ...);
    if (!real_open)
        real_open = dlsym(RTLD_NEXT, "open");
 
    mode_t mode = 0;
    if (flags & O_CREAT) {
        va_list ap;
        va_start(ap, flags);
        mode = va_arg(ap, int);
        va_end(ap);
    }
 
    if (strcmp(path, "/proc/self/status") == 0)
        path = "./fake_status";
 
    return real_open(path, flags, mode);
}

gcc -shared -fPIC -o nostatus.so nostatus.c -ldl
printf 'Name:\tprob\nState:\tR (running)\nTracerPid:\t0\nUid:\t1000\t1000\t1000\t1000\n' > fake_status
printf 'AAAA\n' > input.txt

# dump_expected.gdb — VM 이 만들어 낸 "정답 문자열"을 실행 중에 직접 꺼내 본다.
#   LD_PRELOAD 심으로 anti-debug 를 끈 뒤 strcmp 호출 직전(파일 오프셋 0x162b)에 멈추고
#   rdi(= VM 출력 버퍼) 와 rsi(= 사용자 입력) 를 그대로 읽는다.
set confirm off
set pagination off
set environment LD_PRELOAD ./nostatus.so
starti < input.txt
python
import gdb
base = None
for line in gdb.execute("info proc mappings", to_string=True).splitlines():
    parts = line.split()
    if parts and parts[-1].endswith("/prob"):
        base = int(parts[0], 16)
        break
print("PIE base = %#x  (info proc mappings 로 확인, 관례 가정 금지)" % base)
gdb.execute("break *%#x" % (base + 0x162b))
gdb.execute("continue")
gdb.execute('printf "rdi (VM 이 조립한 정답) = %s\\n", (char*)$rdi')
gdb.execute('printf "rsi (내가 넣은 입력)    = %s\\n", (char*)$rsi')
end
kill

gdb -q -batch -x dump_expected.gdb --args ./extracted/prob

#!/usr/bin/env python3
"""solve.py 가 뽑은 값을 문제 바이너리에 그대로 먹여 판정을 받아 온다."""
import subprocess
from solve import read_code, ELF, run
 
flag = run(read_code(ELF)).decode()
p = subprocess.run([str(ELF)], input=flag + "\n", capture_output=True, text=True)
print(f"입력 : {flag}")
print(f"출력 : {p.stdout.replace(chr(0), '').strip()}")
print(f"판정 : {'PASS' if 'Correct' in p.stdout else 'FAIL'}")

python3 verify.py

#!/usr/bin/env bash
# SelfStatus (DreamHack #1983, Bronze 2, reversing) — 한 방 재현.
#   .rodata 의 VM 바이트코드를 파이썬으로 돌려 flag 를 만들고,
#   그 값을 문제 바이너리에 넣어 Correct! 가 나오는지까지 확인한다.
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
EXPECT=$(python3 -c "import json;print(json.load(open('문제.json'))['flag'])" 2>/dev/null || echo '')
 
chmod +x extracted/prob
OUT=$(timeout 60 python3 verify.py 2>&1) || true
echo "$OUT"
 
FLAG=$(printf '%s' "$OUT" | grep -aoE 'DH\{[^}]+\}' | head -1)
if [ -n "$FLAG" ] && printf '%s' "$OUT" | grep -q 'PASS' \
   && { [ -z "$EXPECT" ] || [ "$FLAG" = "$EXPECT" ]; }; then
  echo; echo "✅ PASS  $FLAG"; exit 0
fi
echo; echo "❌ FAIL (얻은 값: '${FLAG:-없음}' / 기대: '$EXPECT')"; exit 1