[🥈 Silver 2] 리버싱 대신 메모리를 읽는다 — DreamHack just read memory 풀이

문제: DreamHack — just read memory 분류: Reversing 난이도: 🥈 Silver 2 FLAG: DH{7078981632989894389654921898749418541874549056189474343058581690}

받는 건 main 하나. 실행하면 Input: 을 띄우고 한 줄을 받는다. 아무거나 넣으면 Wrong, 정답을 넣으면 Correct 뒤에 플래그가 붙는다.

문제 이름이 이미 답을 반쯤 알려준다. "just read memory" — 정답을 힘들게 역산하지 말고, 프로그램이 메모리에 만들어 둔 걸 그냥 읽으라는 얘기다. 실제로 정답 검증에 쓰이는 값은 비교 직전에 힙 위에 통째로 올라와 있다.

그래도 왜 그게 되는지는 봐야 재밌다. 정답을 만드는 코드가 루프 인덱스를 쓰는 척하면서 실은 초기화도 안 한 스택 슬롯을 함수 세 개가 돌려쓰는 방식으로 숨은 점화식을 굴린다. 그 구조를 먼저 풀고, 마지막에 gdb 한 방으로 마무리한다.

문제 개요

풀이 흐름은 짧다. main이 64개짜리 연결리스트를 만들어 입력과 한 바이트씩 비교한다는 걸 확인하고, 노드 값이 어디서 오는지 헬퍼 세 개를 읽어 점화식으로 정리한 다음, gdb로 리스트를 힙에서 그대로 떠서 정답 입력을 복원한다.

🔎 정찰 — 심볼부터 본다

not stripped 바이너리라 심볼이 그대로 남아 있다. 이름만 봐도 그림이 그려진다.

file main
nm main | grep -E "generate_flag|append_list|unknown_func|cnt|head_node|tail_node"
strings main | grep -E "Input|Wrong|Correct|flag is DH"

• append_list, head_node, tail_node — 연결리스트를 직접 굴린다.
• generate_flag — 노드에 채울 값을 만드는 함수로 보인다.
• unknown_func1, unknown_func2 — 이름을 안 지어준 걸 보면 여기에 뭔가 숨겼다.
• 전역 cnt — 카운터. 뒤에서 이게 열쇠다.

문자열은 Input: / Wrong / Correct / flag is DH{. 딱 예상한 대로다.

🔬 main 읽기 — 리스트를 만들고 입력과 비교한다

main에서 두 부분만 보면 된다. 리스트를 채우는 루프와, 그 리스트를 입력과 대조하는 루프다.

objdump -d -M intel --start-address=0x1280 --stop-address=0x12f5 main | sed -E -f ann_main.sed

앞쪽 루프는 i를 0부터 0x3f까지 돌리며 append_list(i)를 부른다. i <= 63이니 노드가 정확히 64개 생긴다.

1289: mov  eax, [rbp-0x4]        ; i
128e: call append_list          ; append_list(i)  — 인자로 i를 넘기지만…
1293: add  DWORD PTR [rbp-0x4],1 ; i++
1297: cmp  DWORD PTR [rbp-0x4],0x3f
129b: jle  1289                  ; i <= 63  → 64개

뒤쪽 루프는 head_node->next부터 리스트를 따라가며, 각 노드의 첫 바이트(node->value)를 입력 버퍼 input[j]와 비교한다. 하나라도 다르면 [rbp-0x8](정답 플래그)을 0으로 내린다. 중간에 빠져나가지 않고 끝까지 다 돈다.

12c1: movzx eax, BYTE PTR [rbp+rax*1-0x70] ; input[j]
12cd: movzx eax, BYTE PTR [rax]            ; node->value
12d3: cmp   edx, eax                       ; 두 바이트 비교
12d5: je    12de
12d7: mov   DWORD PTR [rbp-0x8], 0         ; 다르면 실패 표시

정리하면 정답 입력은 64개 노드의 값을 순서대로 이어붙인 바이트열이다. 그러니 노드 값이 어떻게 정해지는지만 알면 끝난다. 노드는 append_list 안에서 만들어지니 거기로 내려간다.

🐛 삽질 — "노드 값 = f(i)" 라는 착각

💣 핵심 — 함수 셋이 돌려쓰는 스택 슬롯

append_list는 노드를 만들기 전에 unknown_func1 → unknown_func2 → generate_flag를 차례로 부른다. 셋 다 push rbp; mov rbp, rsp만 하고 스택을 더 안 잡는다. 그래서 세 함수의 [rbp-0x4]는 같은 스택 주소를 가리킨다. 한 함수가 거기 써 놓은 값을 다음 함수가 그대로 이어받는다. 지역 변수인 척하지만 실은 셋이 공유하는 슬롯이다.

objdump -d -M intel --start-address=0x13f8 --stop-address=0x1472 main | sed -E -f ann_helpers.sed

셋을 이어 읽으면 슬롯 값(slot)의 변화는 이렇다.

• unknown_func1: slot = cnt — 전역 cnt를 공유 슬롯으로 로드.
• unknown_func2: slot = (slot+5)*3, 다시 (slot-7)*9, 마지막에 +0x1f. 전개하면 slot = 27*cnt + 103.
• generate_flag: 먼저 cnt = slot으로 전역을 갱신하고, return (slot % 74) + 0x30.

여기서 generate_flag 끝의 imul ... 0xdd67c8a7 → shr → imul ..., 0x4a(=74) → sub 흐름은 컴파일러가 나눗셈을 곱셈으로 바꾼 관용구다. 손으로 풀기 귀찮으니 매직 상수가 정말 74로 나눈 나머지인지 파이썬으로 전 구간 확인했다.

# check_magic.py — generate_flag 끝의 매직 넘버 나눗셈이 (v % 74) 인지 검증
MASK = 0xFFFFFFFF
 
def asm_mod74(v):
    v &= MASK
    q = ((v >> 1) * 0xdd67c8a7) >> 32   # 64비트 곱의 상위 32비트
    q >>= 5                             # q == v // 74
    return (v - 74 * q) & MASK          # == v % 74
 
bad = sum(asm_mod74(v) != v % 74 for v in range(0, 2_000_000))
print(f"checked 0..2_000_000 : mismatches = {bad}")

불일치 0. 그러니 노드 값은 (slot % 74) + '0'이고, slot은 매 노드마다 cnt에 다시 저장된다. cnt는 .bss라 처음엔 0. 결국 인덱스는 어디에도 안 쓰이고, 전역 하나만 도는 선형 합동 점화식(LCG)이 남는다.

cnt_0    = 0
cnt_{i+1} = (27 * cnt_i + 103) mod 2**32
node[i]   = (cnt_{i+1} % 74) + ord('0')

27*cnt+103이 32비트 안에서 도니 노드 값은 (x % 74) + '0' 범위, 즉 '0'(0x30)부터 'y'(0x79)까지의 출력 가능한 문자다. 공백이 없어 scanf("%64s")로 64바이트가 통째로 들어간다.

🎯 just read memory — 힙에서 정답을 줍는다

점화식을 알았으니 파이썬으로 정답을 뽑아도 되지만, 문제가 시키는 대로 하는 게 더 빠르고 확실하다. main은 입력을 먼저 받은 뒤 리스트를 만든다. 그리고 리스트 값은 입력과 무관하게 항상 같다. 그러니 입력을 안 줘도(빈 stdin) 리스트는 정상적으로 생성된다.

리스트 생성이 끝나는 지점(main+0xd4, 비교 루프 직전)에 브레이크를 걸고, head_node->next부터 체인을 따라가며 각 노드의 첫 바이트만 이어 출력하면 그게 정답 입력이다.

# read_memory.gdb
break *main+0xd4
run < /dev/null
set $node = *(unsigned long *)(*(unsigned long *)&head_node + 8)
while $node != 0
  printf "%c", *(char *)$node
  set $node = *(unsigned long *)($node + 8)
end

gdb -q -batch -x read_memory.gdb --args ./main

head_node는 값 0짜리 더미라 head->next부터 읽는다. 나오는 64바이트 MxaDc03Lq\clEbET5XEtshc4[Nw:C@;6o0AT=NCJKh;2iV[:E69rS^qPsb7vytO2가 그대로 정답 입력이다. 리버싱은 사실상 여기서 끝난다 — 점화식을 손으로 안 풀어도, 값은 이미 메모리에 다 있다.

🚀 Full solve

메모리에서 읽은 값과 점화식으로 계산한 값이 같은지 교차 검증하고, 그 입력을 바이너리에 도로 먹여 플래그까지 받는다. 성공 분기가 출력하는 플래그는 각 입력 바이트의 끝자리(input[i] % 10, "%d")를 이어붙인 것이다.

# solve.py — 숨은 점화식을 재현해 정답 입력을 복원하고, 바이너리로 검증
import subprocess
 
MASK = 0xFFFFFFFF
 
def node_bytes():
    cnt, out = 0, []
    for _ in range(64):
        slot = cnt
        slot = (slot + 5) & MASK          # unknown_func2
        slot = (slot * 3) & MASK
        slot = (slot - 7) & MASK
        slot = (slot * 9) & MASK
        slot = (slot + 0x1f) & MASK
        cnt = slot                        # generate_flag: cnt = slot
        out.append(((slot % 74) + 0x30) & 0xFF)
    return bytes(out)
 
correct = node_bytes()
print(f"[*] recovered correct input ({len(correct)} bytes):")
print(f"    {correct.decode('latin-1')!r}")
 
# 성공 분기는 DH{ + 각 input[i] % 10 + } 를 찍는다
predicted = "DH{" + "".join(str(b % 10) for b in correct) + "}"
print(f"[*] predicted flag: {predicted}")
 
res = subprocess.run(["./main"], input=correct + b"\n", capture_output=True)
print(f"[*] binary output : {res.stdout.decode('latin-1').strip()}")

점화식으로 만든 입력이 gdb로 힙에서 읽은 값과 정확히 같고, 그 입력을 넣으면 바이너리가 Correct와 함께 플래그를 뱉는다.

flag is DH{7078981632989894389654921898749418541874549056189474343058581690}

이 값을 드림핵에 제출하면 정답 처리된다.

📝 결론

정답을 메모리에 먼저 만들어 두면, 그건 이미 유출이다.

이 문제의 검증기는 정답 바이트열을 힙에 통째로 올려놓고 입력과 비교한다. 비교 대상이 프로세스 메모리에 평문으로 존재하는 순간, 아무리 생성 로직을 꼬아도 브레이크 한 번이면 끝난다. 클라이언트 측에서 정답/키를 들고 비교하는 구조 자체가 약점이다.

난독화는 "왜 그렇게 됐나"를 숨길 뿐, "지금 값이 뭔가"는 못 숨긴다.

unknown_func1/2가 공유하는 초기화 안 된 스택 슬롯 트릭은 정적 분석을 확실히 성가시게 만든다. 인자로 넘어오는 i에 시선을 뺏기면 한참 헤맨다. 하지만 그 모든 계산의 결과는 결국 리스트 노드라는 구체적인 메모리에 남는다. 정적으로 점화식을 복원하는 길과, 동적으로 결과만 줍는 길 — 리버싱에선 둘 다 손에 익혀 두는 게 좋다. 이 문제는 후자가 훨씬 짧다.

컴파일러 관용구는 표로 외워두면 빠르다.

imul 매직 상수 + shr + sub 조합은 십중팔구 상수 나눗셈의 나머지 계산이다. 매번 손으로 전개하지 말고, 의심되면 오늘처럼 전 구간을 한 번 돌려 확인하고 넘어가면 된다.