[🥇 Gold 1] 세그폴트가 곧 정답이다 — DreamHack Nonsense 풀이

void handler(int signo, siginfo_t *info, void *ucontext);

file extracted/nonsense; readelf -hW extracted/nonsense | grep -E "Type:|Entry"; nm -D extracted/nonsense

./extracted/nonsense; echo "rc=$?"; ./extracted/nonsense AAAA; echo "rc=$?"; ./extracted/nonsense AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA; echo "rc=$?"

objdump -d -M intel --start-address=0xb0a --stop-address=0xb97 extracted/nonsense | sed -f annot_main.sed | tail -n +6

/^ *b21:/s|$|        <-- argc == 2 (인자 하나)|
/^ *b3f:/s|$|     <-- strlen(argv[1])|
/^ *b44:/s|$|                  <-- 길이는 정확히 48|
/^ *b72:/s|$|        <-- argv[1] 을 2바이트(uint16) 단위로|
/^ *b7a:/s|$|  <-- 스펀지 해시. uint32 를 돌려준다|
/^ *b7f:/s|$|        <-- ★ 그 32비트를 포인터로 역참조 = SIGSEGV|
/^ *b82:/s|$|  <-- 누적합|
/^ *b8a:/s|$|     <-- 청크 24개 반복|
/^ *b90:/s|$|    <-- 합이 0 이어야 'wrong...' 을 건너뛴다|

int main(int argc, char **argv) {
    long sum = 0;
    if (argc != 2) _exit(1);
    if (strlen(argv[1]) != 0x30) _exit(1);
 
    for (int i = 0; i <= 0x17; i++) {
        unsigned short v = *(unsigned short *)(argv[1] + 2 * i);
        long *p = (long *)(unsigned long)sub_AB7(v);   /* 32비트 반환 */
        sum += *p;                                     /* 0xb7f */
    }
    if (sum != 0) printf("wrong...");
    return 0;
}

readelf -dW extracted/nonsense | grep -E "INIT_ARRAY|FINI_ARRAY"; readelf -rW extracted/nonsense | grep RELATIVE; objdump -d -M intel --start-address=0x9f9 --stop-address=0xa5a extracted/nonsense | sed -f annot_ctor.sed | tail -n +6

/^ *a2c:/s|$|  <-- 핸들러 = 0x92a|
/^ *a3a:/s|$|   <-- sa_flags = 4 = SA_SIGINFO (si_addr·ucontext 를 받는다)|
/^ *a50:/s|$|   <-- signum 11 = SIGSEGV|
/^ *a55:/s|$|   <-- sigaction 등록|

void fini(void) {                       /* .fini_array[1] */
    if (*(long *)0x206100 == 0x18) printf("correct!!");
    else                           printf("wrong...");
}

objdump -d -M intel --start-address=0x92a --stop-address=0x9f9 extracted/nonsense | sed -f annot_handler.sed | tail -n +6

/^ *939:/s|$|   <-- ucontext + 0x28 = uc_mcontext|
/^ *949:/s|$|  <-- gregs[REG_RIP] (0x80 = 16*8)|
/^ *958:/s|$|   <-- siginfo->si_addr (오프셋 0x10)|
/^ *960:/s|$|   <-- 11 = SIGSEGV 만 처리|
/^ *96a:/s|$|  <-- main 주소|
/^ *971:/s|$|   <-- +0x75 = 0xb7f, 그 역참조에서 난 폴트만|
/^ *97f:/s|$| <-- gregs[REG_RAX] = 0 (0x68 = 13*8)|
/^ *992:/s|$|   <-- RIP += 3, 폴트 명령을 건너뛴다|
/^ *9b0:/s|$|  <-- .bss 0x206100 = 지금까지 맞춘 개수|
/^ *9c9:/s|$|  <-- 정답표 .data 0x206020|
/^ *9d4:/s|$|   <-- si_addr == 표[counter] 인가|
/^ *9e5:/s|$|  <-- 맞으면 counter++|
/^ *9f0:/s|$|   <-- 표는 최대 48개까지 훑는다|

void handler(int sig, siginfo_t *info, void *uctx) {
    mcontext_t *mc  = (mcontext_t *)((char *)uctx + 0x28);
    void *fault_rip = (void *)mc->gregs[REG_RIP];      /* +0x80 */
    void *si_addr   = info->si_addr;                   /* +0x10 */
 
    if (sig != SIGSEGV)              return;
    if (fault_rip != (char*)main + 0x75) return;       /* 0xb7f 에서 난 폴트만 */
 
    mc->gregs[REG_RAX]  = 0;                           /* +0x68 */
    mc->gregs[REG_RIP] += 3;                           /* mov rax,[rax] 는 3바이트 */
 
    for (int i = 0; i <= 0x2f; i++)
        if (i == counter && si_addr == table[i])       /* table = .data 0x206020 */
            counter++;
}

#!/usr/bin/env python3
"""ELF 의 .data 를 직접 열어 SIGSEGV 핸들러가 참조하는 정답표를 뽑는다.
 
핸들러(0x92a)는 si_addr 을 `0x206020 + i*8` 과 비교한다. 8바이트로 저장돼 있지만
상위 4바이트는 전부 0 — sub_AB7 의 반환이 32비트라 그렇다.
바로 뒤 0x2060e0 의 17바이트는 스펀지 해시의 IV 다.
"""
import struct
 
BIN = "extracted/nonsense"
DATA_VADDR, DATA_OFF = 0x206000, 0x6000     # readelf -S 의 .data Address / Off
 
raw = open(BIN, "rb").read()
off = lambda va: DATA_OFF + (va - DATA_VADDR)
 
print("[표] .data 0x206020 — 청크별 si_addr 정답 24개")
tbl = [struct.unpack_from("<Q", raw, off(0x206020) + 8 * i)[0] for i in range(24)]
for i in range(0, 24, 4):
    print("  " + "  ".join(f"[{i+j:2}] {tbl[i+j]:#018x}" for j in range(4)))
 
dup = {v: [i for i, t in enumerate(tbl) if t == v] for v in set(tbl)}
print("\n[중복] 같은 값이 두 번 나온 인덱스 =",
      sorted(v for v in dup.values() if len(v) > 1))
 
iv = raw[off(0x2060e0):off(0x2060e0) + 17]
print(f"\n[IV] .data 0x2060e0 — 17바이트({len(iv) * 8}비트) 스펀지 초기상태")
print("  " + iv.hex(" "))

python3 dump_targets.py

# gdb_fault.gdb — 첫 번째 SIGSEGV 를 잡아 "어디서 · 무엇을" 역참조하다 죽었는지 본다.
set pagination off
set confirm off
run
set $base = $rip - 0xb7f
printf "\n[RIP]      %p   (PIE base %p + 0xb7f = main+0x75)\n", $rip, $base
printf "[RAX]      0x%x   <- sub_AB7 이 돌려준 32비트 값\n", $rax
printf "[si_addr]  0x%x   <- .data 0x206020 표의 0번 항목과 같아야 한다\n", $_siginfo._sifields._sigfault.si_addr
printf "[표 [0]]   0x%x\n", *(unsigned long*)($base + 0x206020)
set disassembly-flavor intel
x/1i $rip
quit

gdb -q -batch -x gdb_fault.gdb --args extracted/nonsense AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

objdump -d -M intel --start-address=0x57e3 --stop-address=0x5877 extracted/nonsense | sed -f annot_sponge.sed | tail -n +6

/^ *57e7:/s|$|   <-- 스펀지 상태 0x230 바이트를 스택에|
/^ *581c:/s|$|  <-- init : IV 17바이트를 비트 136개로 펼친다|
/^ *583e:/s|$|  <-- absorb: 입력 2바이트를 한 바이트씩 흡수|
/^ *5857:/s|$|  <-- squeeze: 17바이트를 짜낸다|

objdump -d -M intel --start-address=0xc51 --stop-address=0xc8e extracted/nonsense | sed -f annot_perm.sed | tail -n +6; objdump -d -M intel --start-address=0x1d4a --stop-address=0x1d5b extracted/nonsense | sed -f annot_perm.sed | tail -n +6

/^ *c5d:/s|$|   <-- 612개짜리 int 버퍼 A|
/^ *c6b:/s|$|   <-- 612개짜리 int 버퍼 B|
/^ *c79:/s|$|   <-- 554개짜리 int 버퍼 C|
/^ *d1f:/s|$|   <-- C\[0..9\] = -1 로 초기화|
/^ *1d4a:/s|$|   <-- 라운드 카운터 ++|
/^ *1d4e:/s|$|   <-- 0x21f = 543, 즉 544 라운드|

#!/usr/bin/env python3
"""nonsense 바이너리를 dlopen 가능한 .so 로 만든다.
 
PIE 실행파일은 ET_DYN 이라 구조상 공유 라이브러리와 같지만,
.dynamic 의 DT_FLAGS_1(0x6ffffffb) 에 DF_1_PIE(0x08000000) 가 켜져 있으면
glibc 의 dlopen 이 "cannot dynamically load position-independent executable"
로 거부한다. 그 비트 하나만 끄면 그대로 로드된다.
"""
import struct, shutil, sys
 
SRC = "extracted/nonsense"
DST = "nonsense_lib.so"
DYN_OFF, DYN_SIZE = 0x5d80, 0x1f0        # readelf -S 로 확인한 .dynamic
 
shutil.copy(SRC, DST)
buf = bytearray(open(DST, "rb").read())
 
patched = False
for off in range(DYN_OFF, DYN_OFF + DYN_SIZE, 16):
    tag, val = struct.unpack_from("<QQ", buf, off)
    if tag == 0x6ffffffb:                # DT_FLAGS_1
        print(f"DT_FLAGS_1 @ file+0x{off:x} = 0x{val:08x}")
        val &= ~0x08000000               # DF_1_PIE 제거
        struct.pack_into("<QQ", buf, off, tag, val)
        print(f"  -> 0x{val:08x}")
        patched = True
 
if not patched:
    sys.exit("DT_FLAGS_1 을 못 찾았다")
open(DST, "wb").write(buf)
print("WROTE", DST)

#!/usr/bin/env python3
"""문제 바이너리의 해시 함수(0xab7)를 파이썬에서 직접 호출해 본다.
 
배포본 그대로는 dlopen 이 거부한다 — PIE 실행파일이라 DT_FLAGS_1 에 DF_1_PIE 가 켜져 있고
glibc 가 그걸 보고 막는다. mk_lib.py 가 그 비트만 끈 사본을 만들어 준다.
"""
import ctypes, os, subprocess, sys, time
 
HERE = os.path.dirname(os.path.abspath(__file__))
BIN = os.path.join(HERE, "extracted", "nonsense")
LIB = os.path.join(HERE, "nonsense_lib.so")
 
print("[1] 배포본을 그대로 dlopen 해 본다")
try:
    ctypes.CDLL(BIN)
    print("    -> 로드됨")
except OSError as e:
    print(f"    -> OSError: {e}")
 
print("\n[2] DF_1_PIE 비트를 끈 사본을 만든다")
subprocess.run([sys.executable, "mk_lib.py"], check=True, cwd=HERE)
 
print("\n[3] 사본을 dlopen 하고 base+0xab7 을 직접 부른다")
lib = ctypes.CDLL(LIB)
base = next(int(l.split("-")[0], 16) for l in open("/proc/self/maps")
            if l.rstrip().endswith(os.path.basename(LIB)))
hash16 = ctypes.CFUNCTYPE(ctypes.c_uint32, ctypes.c_uint16)(base + 0xab7)
print(f"    base = {base:#x}")
 
t0 = time.time()
for s in (b"Go", b"N{", b"AA"):
    v = s[0] | (s[1] << 8)                # main 이 읽는 그대로 리틀엔디언 uint16
    print(f"    hash({s.decode()!r} = {v:#06x}) = {hash16(v):#010x}")
print(f"    {(time.time() - t0) / 3 * 1000:.2f} ms/call")

python3 probe.py

#!/usr/bin/env python3
"""Nonsense (DreamHack 455 / Gold 1, reversing) — solver
 
동작 요약
  main 은 argv[1](48바이트)을 uint16 24개로 잘라 sub_AB7(chunk) 를 부른다.
  sub_AB7 은 스펀지 해시(레이트 8비트·용량 128비트, 상태 136비트)를 돌려 17바이트를
  뱉고 그 앞 4바이트를 uint32 로 돌려주는데, main 은 그 값을 '포인터'로 역참조한다.
  → 반드시 SIGSEGV. .init_array 가 걸어 둔 핸들러(0x92a)가 si_addr 을
    .data 0x206020 의 정답표 24개와 순서대로 대조하고, 맞으면 카운터를 올린 뒤
    RAX=0 / RIP+=3 으로 복구한다. .fini_array 의 0xa7f 가 카운터==24 면 correct!!.
 
  즉 "argv[1] 의 2바이트 청크 24개를 해시한 값이 정답표와 순서대로 일치" 가 전부다.
  해시는 2바이트 입력이라 경우의 수가 65,536 — 전수조사로 끝난다.
 
  해시 자체를 재구현하지 않고 문제 바이너리를 그대로 오라클로 쓴다.
  PIE 실행파일이라 dlopen 이 거부하므로 DT_FLAGS_1 의 DF_1_PIE 비트만 끈 사본을 만든다.
"""
import ctypes, os, struct, subprocess, sys, time
 
HERE = os.path.dirname(os.path.abspath(__file__))
BIN  = os.path.join(HERE, "extracted", "nonsense")
LIB  = os.path.join(HERE, "nonsense_lib.so")
 
# ── 1. .data 0x206020 의 정답표 24개를 ELF 에서 직접 읽는다 ─────────────
DATA_VADDR, DATA_OFF = 0x206000, 0x6000          # readelf -S
raw = open(BIN, "rb").read()
tbl_off = DATA_OFF + (0x206020 - DATA_VADDR)
TARGETS = [struct.unpack_from("<Q", raw, tbl_off + 8 * i)[0] for i in range(24)]
print("정답표(.data 0x206020):")
for i, t in enumerate(TARGETS):
    print(f"  [{i:2}] 0x{t:016x}")
 
# ── 2. dlopen 가능한 사본 준비 ──────────────────────────────────────────
if not os.path.exists(LIB):
    subprocess.run([sys.executable, os.path.join(HERE, "mk_lib.py")], check=True, cwd=HERE)
 
lib = ctypes.CDLL(LIB)
base = next(int(l.split("-")[0], 16) for l in open("/proc/self/maps")
            if l.rstrip().endswith(os.path.basename(LIB)))
hash16 = ctypes.CFUNCTYPE(ctypes.c_uint32, ctypes.c_uint16)(base + 0xab7)
print(f"\nlib base = 0x{base:x}  /  hash = base+0xab7")
 
# ── 3. 2바이트 전수조사 (출력 가능한 ASCII 조합만) ──────────────────────
want = {t: i for i, t in enumerate(TARGETS)}
found = {}
t0 = time.time()
for hi in range(0x20, 0x7f):
    for lo in range(0x20, 0x7f):
        v = hash16(lo | (hi << 8))            # 리틀엔디언: lo 가 앞 글자
        if v in want:
            found.setdefault(v, bytes((lo, hi)))
print(f"전수조사 {(0x7f-0x20)**2}개 / {time.time()-t0:.1f}s / 적중 {len(found)}/24")
 
missing = [i for t, i in want.items() if t not in found]
if missing:
    sys.exit(f"인덱스 {missing} 미발견 — 출력 가능 범위 밖")
 
flag = b"".join(found[t] for t in TARGETS)
print("\nFLAG:", flag.decode())
print("len :", len(flag))
 
# ── 4. 문제 바이너리로 직접 확인 ────────────────────────────────────────
out = subprocess.run([BIN, flag], capture_output=True, text=True)
print("검증:", repr(out.stdout), "rc =", out.returncode)

python3 solve.py

FLAG: GoN{wait_i_can_handle_my_fault_plz_don_t_hit_me}

#!/usr/bin/env python3
"""찾은 flag 를 문제 바이너리에 그대로 먹여 최종 확인한다."""
import subprocess
 
flag = "GoN{wait_i_can_handle_my_fault_plz_don_t_hit_me}"
r = subprocess.run(["./extracted/nonsense", flag], capture_output=True, text=True)
print(f"argv[1] : {flag}")
print(f"len     : {len(flag)}")
print(f"stdout  : {r.stdout.strip()!r}")
print(f"exitcode: {r.returncode}")
 
bad = "A" * 48
r2 = subprocess.run(["./extracted/nonsense", bad], capture_output=True, text=True)
print(f"\n대조군 'A'*48 -> stdout: {r2.stdout.strip()!r}")

python3 verify.py

# gdb_counter.gdb — SIGSEGV 를 프로그램에 그대로 넘겨 핸들러가 24번 다 돌게 두고 세 지점을 읽는다.
#  ① 0xb82  핸들러가 복귀시킨 지점의 RAX
#  ② 0xb90  main 이 누적합을 검사하는 지점의 [rbp-8]
#  ③ 0xa7f  .fini_array 판정 함수 직전의 .bss 카운터
set pagination off
set confirm off
run
set $base = $rip - 0xb7f
handle SIGSEGV nostop noprint pass
break *($base + 0xb82)
continue
printf "\n[핸들러 복귀] RIP = %p  = base+0xb82 (0xb7f + 3, 폴트 명령을 건너뜀)\n", $rip
printf "[핸들러 복귀] RAX = %d  <- 0 으로 덮여서 main 의 누적합이 안 늘어난다\n", $rax
delete breakpoints
break *($base + 0xb90)
continue
printf "\n[main 누적합] rbp-8 = %ld  <- 0 이라 'wrong...' 을 건너뛴다\n", *(long*)($rbp - 0x8)
delete breakpoints
break *($base + 0xa7f)
continue
printf "\n[.bss 0x206100] counter = %d  <- 0x18(24) 이어야 correct!!\n", *(long*)($base + 0x206100)
continue
quit

gdb -q -batch -x gdb_counter.gdb --args extracted/nonsense 'GoN{wait_i_can_handle_my_fault_plz_don_t_hit_me}'

#!/usr/bin/env bash
# Nonsense (DreamHack 455 / Gold 1 reversing) — 한 방 재현.
#   solve.py 가 DF_1_PIE 를 끈 사본을 만들고, 문제 바이너리의 해시를 dlopen 으로
#   직접 불러 2바이트 전수조사 → flag 복원 → 문제 바이너리로 correct!! 까지 확인한다.
# 필요한 것: python3, gcc 없음, 인터넷 없음. 로컬 glibc 만 있으면 된다.
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/nonsense
OUT=$(timeout 600 python3 solve.py 2>&1) || true
 
echo "$OUT" | tail -8
FLAG=$(printf '%s' "$OUT" | grep -aoE 'GoN\{[^}]+\}' | head -1)
if [ -n "$FLAG" ] && { [ -z "$EXPECT" ] || [ "$FLAG" = "$EXPECT" ]; }; then
  echo; echo "✅ PASS  $FLAG"; exit 0
fi
echo; echo "❌ FAIL (얻은 값: '${FLAG:-없음}' / 기대: '$EXPECT')"; exit 1