[🥉 Bronze 2] AES S-box 블록 변환을 역산해 입력 복원 — DreamHack rev-basic-9 풀이

문제: DreamHack — rev-basic-9

분류: Reversing (입력 검증 역산)

난이도: 🥉 Bronze 2

FLAG: DH{Reverse__your__brain_;)}

문제 개요

rev-basic 시리즈는 "입력을 넣으면 검증해서 Correct/Wrong 을 출력하는" 바이너리다. 목표는 Correct 를 만드는 입력을 찾는 것이고, 그 입력이 곧 플래그 내용이 된다. 9번은 앞 번호들의 단순 XOR·치환과 달리, 입력을 블록 암호처럼 여러 라운드로 뒤섞은 뒤 비교한다. 그래도 각 연산이 가역이라 차분히 뒤집으면 풀린다.

1. 정찰 — main 의 큰 그림

file 로 보면 PE32+ x86-64 콘솔 실행파일이고, strings 에 Input :, Correct, Wrong, __stdio_common_vfscanf 가 보인다. 전형적인 rev-basic 이다. main 을 디스어셈블하면 흐름이 셋으로 나뉜다.

• 길이 검증: (strlen(input) + 1) % 8 == 0 이 아니면 즉시 실패. → 입력 길이는 7, 15, 23, … 중 하나(8의 배수 - 1).
• 블록 루프: k = 0, 8, 16, … 로 8바이트씩 잘라 검증 함수 sub_1400010a0(input + k) 를 호출. 이 함수가 입력 버퍼를 제자리에서(in-place) 변환한다.
• 비교: 변환이 끝난 입력을 memcmp(input, target, 0x19) 로 하드코딩된 25바이트(=24바이트 + 널)와 비교. 같으면 Correct.

즉 "입력 → 변환 → target 과 일치?" 구조다. 우리가 원하는 건 변환 결과가 target 이 되는 원래 입력이다.

2. 변환 로직 리버싱 — 라운드 함수

핵심 검증 함수 sub_1400010a0 을 디스어셈블한 것이다. 이중 루프(바깥 16회, 안쪽 8회)가 눈에 들어온다.

#!/usr/bin/env bash
# chall9.exe 입력검증 루프 디스어셈블 (8바이트 블록 16라운드 변환)
cd extracted
objdump -d -M intel chall9.exe 2>/dev/null | sed -n '/1400010fc:/,/14000116f:/p' \
 | grep -E '10(fc|f2|f6):|11(01|03|17|1c|1e|22|27|2c|30|37|3b|3f|41|4c|50|52|55|68|6c):' \
 | sed -E 's#<.*>##' \
 | sed -E 's/(83 7c 24 08 10).*/\1  ; i < 16 (outer, 16라운드)/' \
 | sed -E 's/(83 7c 24 04 08).*/\1  ; j < 8 (inner, 블록 8바이트)/' \
 | sed -E 's/(33 c1).*/\1              ; eax = s ^ K[j]/' \
 | sed -E 's/(0f b6 04 01).*4020.*/movzx eax,[rcx+rax]        ; eax = SBOX[s ^ K[j]]  (rcx=AES sbox)/' \
 | sed -E 's/(03 c1).*/\1              ; += b[(j+1)\&7]/' \
 | sed -E 's/(c0 c8 05).*/\1        ; ror al, 5/' \
 | sed -E 's/(88 14 01).*/\1        ; b[(j+1)\&7] = s   (피드백 저장)/'
echo
echo "→ s = ror5( AES_Sbox[s ^ K[j]] + b[(j+1)&7] );  b[(j+1)&7] = s   (16라운드 x 8바이트)"

bash cap_disasm.sh

정리하면 8바이트 블록 b[0..7] 에 대해 이렇게 돈다.

s = b[0];
for (i = 0; i < 16; i++)              // 16 라운드
    for (j = 0; j < 8; j++) {         // 블록 8바이트
        p = (j + 1) & 7;
        s = SBOX[s ^ K[j]];           // 치환
        s = (s + b[p]) & 0xff;        // 덧셈
        s = ror8(s, 5);               // 5비트 회전
        b[p] = s;                     // 피드백: 결과를 버퍼에 다시 씀
    }

s(러닝 상태)는 블록 시작 시 b[0] 으로 초기화되고, 매 스텝 b[(j+1)&7] 에 결과를 되먹임(feedback)하며 흘러간다. 스트림 암호의 상태 갱신과 비슷하다.

3. 상수 3종 추출 — K, S-box, target

변환에 쓰이는 상수를 바이너리에서 그대로 뽑았다.

• K = "I_am_KEY" (8바이트). 라운드마다 K[j] 로 XOR.
• SBOX 는 63 7c 77 7b f2 6b 6f c5 … 로 시작 — 그 유명한 AES S-box 다. 256개 값이 전부 유일(전단사)하므로 역치환이 존재한다. 이게 역산의 열쇠다.
• target = 7e7d9a8b252dd53d 032b3898279f4fbc 2a79007dc42a4f58 = 24바이트 = 8바이트 블록 3개. 길이 검증(23자)과도 맞는다.

4. 역산 — 라운드를 거꾸로 되감기

블록끼리는 서로 영향을 주지 않으므로(각각 독립 변환) 블록 하나씩 뒤집으면 된다. 한 라운드 스텝의 역함수를 구하는 게 핵심이다.

정방향 스텝은 b[p] (단, p=(j+1)&7) 하나만 갱신한다. 그리고 여기서 결정적인 관찰이 나온다 — 이 스텝은 b[j] 를 건드리지 않는다. 정방향에서 s 는 바로 직전 스텝이 쓴 값(b[j])이므로, s_before == b[j](현재 버퍼값) 이다. 덕분에 역산에 필요한 s 를 따로 추적할 필요 없이 버퍼에서 바로 읽을 수 있다.

역스텝은 세 연산을 순서대로 되돌린다.

• ror8(·,5) 의 역은 rol8(·,5)
• + b[p] 의 역은 - SBOX[s ^ K[j]] (모듈러 256 뺄셈)
• 치환은 값 자체를 되돌릴 필요 없이, 원래 b[p] 만 복원하면 됨

for i in range(16):
    for j in reversed(range(8)):     # 라운드도, j 순서도 거꾸로
        p = (j + 1) & 7
        s_before = b[j]              # 이 스텝은 b[j]를 안 건드림 → s_before == b[j]
        t = rol8(b[p], 5)            # ror5 되돌리기
        b[p] = (t - SBOX[s_before ^ K[j]]) & 0xff

5. 자체 완결 solve.py

정방향/역방향을 모두 구현하고, 역산 결과를 다시 정방향으로 돌려 target 과 일치하는지 블록마다 검증했다.

def forward(block):                  # 바이너리와 동일
    b = list(block); s = b[0]
    for _ in range(16):
        for j in range(8):
            p = (j + 1) & 7
            s = ror(( (SBOX[s ^ K[j]] + b[p]) & 0xff ), 5)
            b[p] = s
    return bytes(b)
 
def invert(block):                   # 역함수
    b = list(block)
    for _ in range(16):
        for j in reversed(range(8)):
            p = (j + 1) & 7
            s_before = b[j]
            b[p] = (rol(b[p], 5) - SBOX[s_before ^ K[j]]) & 0xff
    return bytes(b)

세 블록을 역산해 이어붙이면 Reverse_ + _your__b + rain_;) = Reverse__your__brain_;) 이고, 각 블록은 정방향 재변환으로 target 과 일치함을 확인했다.

6. 런타임 확인 — wine 으로 진짜 "Correct"

역산이 맞는지 실제 바이너리에 넣어 봤다. 리눅스라 wine 으로 돌렸다.

복원한 입력에서만 Correct, 아무 문자열(대조군)은 Wrong. 역산이 정확했다.

플래그: DH{Reverse__your__brain_;)}

7. 삽질 기록

8. 마무리 — 리버싱에서 배우는 것

rev-basic-9 는 "블록 암호 흉내를 낸 입력 검증"을 역산하는 연습이다. 몇 가지 일반화할 교훈이 있다.

• 가역 연산의 조합은 통째로 가역이다. XOR·모듈러 덧셈·비트 회전·전단사 치환(S-box) 은 각각 역이 있으니, 순서만 거꾸로 밟으면 전체가 뒤집힌다. 검증 로직이 아무리 복잡해 보여도 "출력 → 입력"이 유일하게 정해지면 keygen 은 성립한다.
• 상수의 정체를 알아채면 절반은 끝. S-box 앞 몇 바이트(63 7c 77 7b …)만 봐도 AES 임을 알 수 있고, 전단사라는 사실이 곧 "역산 가능"을 보장한다.
• 피드백/상태를 정확히 읽어라. 이 문제의 s_before == b[j] 처럼, 상태가 실은 버퍼에 남아 있는 경우가 많다. 자료 흐름을 정확히 따라가면 역산이 단순해진다.
• 정적 역산 + 동적 확인을 병행하라. 역산 결과를 실제 바이너리(wine)로 재현해 Correct 를 받으면 실수를 즉시 잡을 수 있다.

방어 관점에서, 이런 "로컬에서 정답을 검증하는" 방식(클라이언트 사이드 검증)은 바이너리만 있으면 반드시 뚫린다. 진짜 비밀은 서버에 두고 검증도 서버에서 해야 한다.

FLAG: DH{Reverse__your__brain_;)}