문제: DreamHack — Small Counter 분류: Reversing 난이도: 🥉 Bronze 1 FLAG:
DH{389998e56e90e8eb34238948469cecd6dd89c04dce359c345e0b2f3ef9edc66a}
실행 파일 하나가 주어진다. 돌려보면 ---Counter--- 아래로 10, 9, … 1을 세고 ---END---로 끝난다. flag는 어디에도 안 나온다. 정찰해 보면 flag_gen이라는 함수가 flag를 만들지만, 그 함수를 부르는 분기가 절대 실행되지 않는 죽은 코드다. 그래서 정상 실행으로는 flag를 볼 수 없고, flag_gen이 무슨 변환을 하는지 읽어서 손으로 복원해야 한다.

문제 개요
| 항목 | 내용 |
|---|---|
| 문제명 | Small Counter |
| 난이도 | 🥉 Bronze 1 |
| 분류 | Reversing (x86-64 ELF) |
| 제공 파일 | chall (PIE, dynamically linked, not stripped) |
| 핵심 취약점 / 기법 | 죽은 코드 안의 Caesar 복호 루틴을 정적으로 복원 |
flag는 서버가 아니라 바이너리 안에 암호문 형태로 박혀 있다. flag_gen이 그 암호문을 Caesar 복호하면 flag가 되는데, 정상 실행 경로에선 flag_gen이 호출되지 않는다.
🧩 배경 — Caesar cipher와 시프트 테이블
Caesar cipher는 알파벳을 일정 칸수(shift)만큼 밀어 바꾸는 가장 단순한 치환 암호다. A를 3칸 밀면 D, B는 E가 되는 식이다. 복호는 반대로 같은 칸수만큼 당기면 된다.
이 문제의 flag_gen은 시프트를 룩업 테이블로 구현한다. 먼저 abcdefg...z, ABC...Z 두 벌의 알파벳을 스택에 만들고, 인덱스를 shift만큼 어긋나게 배치한 테이블을 하나 더 만든다. 그러면 어떤 글자를 그 테이블에서 찾기만 해도 시프트된 결과가 나온다. 코드로 보면 복잡해 보이지만, 결국 하는 일은 "글자를 shift칸 당기는" 것뿐이다.
핵심은 shift 값을 알아내는 것이다. flag 형식이 DH{...}인데 암호문이 IM{...로 시작한다면, I → D, M → H가 성립하는 shift를 찾으면 된다. I(9번째)에서 D(4번째)는 5칸 차이, M에서 H도 5칸이다. 그래서 shift는 5다.
🔬 코드 정찰 — 실행해도 안 나오는 flag
먼저 파일 종류와 심볼을 본다. PIE에 stripping이 안 된 바이너리라, 함수 이름이 그대로 남아 있다.
이 글의 명령은 모두
extracted/에서 실행한다.
file chall; echo; nm chall | grep -E " T (flag_gen|main)| t "
flag_gen이라는 이름이 대놓고 보인다. 여기가 flag를 만드는 곳이다. 다음으로 문자열을 보면 흥미로운 게 두 덩어리 나온다.
strings -n 6 chall | sed -n "/^abcdefgh/,/^k5jk8jih/p"
위쪽 abcdefgh…, ABCDEFGH…는 flag_gen이 시프트 테이블을 만들 때 쓰는 알파벳이고, 아래쪽 IM{50888, 9j32j87j, … k5jk8jih는 암호문 조각이다. IM{로 시작하는 게 바로 눈에 띈다 — DH{를 5칸 민 것이다. flag가 이 안에 있다는 확신이 선다.
🧪 flag_gen 뜯어보기 — Caesar 복호기
flag_gen(입력, 출력, shift) 세 인자를 받는다. 먼저 스택에 두 벌의 알파벳 테이블을 세운다.
objdump -d -M intel --no-show-raw-insn chall | sed -n "/11ed:/,/1255:/p" | \
sed -e "s|movabs rax,0x6867666564636261|& ; \"abcdefgh\"|" \
-e "s|movabs rdx,0x706f6e6d6c6b6a69|& ; \"ijklmnop\"|" \
-e "s|movabs rax,0x7877767574737271|& ; \"qrstuvwx\" (+yz) → 소문자 26|" \
-e "s|movabs rax,0x4847464544434241|& ; \"ABCDEFGH\"|" \
-e "s|movabs rax,0x5857565554535251|& ; \"XYZ...\" → 대문자 26|" \
-e "s|mov DWORD PTR \[rbp-0x18\],0x0|& ; i=0|"
0x6867666564636261은 리틀엔디언으로 "abcdefgh", 다음이 "ijklmnop"… 이런 식으로 소문자 26자와 대문자 26자를 스택에 깔아둔다. 그 다음 루프에서 이 테이블을 shift만큼 어긋나게 재배치한다.
objdump -d -M intel --no-show-raw-insn chall | sed -n "/<flag_gen>:/,/12df:/p" | \
sed -e "s|movabs rax,0x6867666564636261|& ; \"abcdefgh...\" 소문자 테이블|" \
-e "s|movabs rax,0x4847464544434241|& ; \"ABCDEFGH...\" 대문자 테이블|" \
-e "s|imul rax,rax,0x4ec4ec4f|& ; (i+shift) %% 26 (26으로 나누기 매직)|" \
-e "s|movzx edx,BYTE PTR \[rbp+rdx\*1-0x40\]|& ; dl = 소문자[i]|" \
-e "s|mov BYTE PTR \[rbp+rax\*1-0x80\],dl|& ; shifted[(i+shift)%%26]=dl|" \
-e "s|cmp DWORD PTR \[rbp-0x18\],0x19|& ; i=0..25 루프|"
imul rax, rax, 0x4ec4ec4f 뒤 시프트 연산은 26으로 나눈 나머지를 구하는 컴파일러 관용구다. 결국 shifted[(i+shift) % 26] = 'a'+i를 26번 반복한다. 이렇게 만들어진 테이블에서 입력 글자를 찾으면, 그 글자가 shift칸 앞으로 당겨진 결과가 나온다. 소문자는 'a' + ((c-'a'-shift) % 26), 대문자는 'A' + ((C-'A'-shift) % 26)로 복호되는 것이다.
문자 종류는 __ctype_b_loc로 판별한다. 소문자면 소문자 테이블, 대문자면 대문자 테이블에서 찾고, 숫자면 별도 계산을 한다. 숫자 처리가 조금 독특하다.
objdump -d -M intel --no-show-raw-insn chall | sed -n "/13d3:/,/1437:/p" | \
sed -e "s|add edx,0x3|& ; shift + 3|" \
-e "s|imul eax,edx|& ; ascii(c) * (shift+3)|" \
-e "s|imul rdx,rdx,0x38e38e39|& ; \\/ 9 (매직)|" \
-e "s|sub eax,edx|& ; r = 값 %% 9|" \
-e "s|cmp DWORD PTR \[rbp-0x14\],0x7|& ; r <= 7 ?|" \
-e "s|add DWORD PTR \[rbp-0x14\],0x28|& ; r==8 → +40 =
숫자 문자는 ascii(c) × (shift+3)을 9로 나눈 나머지 r을 구한 뒤, r이 7 이하면 r+50('2'~'9'), r이 8이면 r+40('0')으로 매핑한다. 글자용 Caesar와는 규칙이 다르지만, shift만 정해지면 결과는 완전히 결정된다. '{', '}' 같은 비영숫자는 그대로 복사한다.
🧭 main 분석 — flag_gen은 죽은 코드였다
정작 main이 flag_gen을 어떻게 부르는지가 이 문제의 핵심이다. main은 카운터를 10부터 1까지 세는 루프를 돈다.
objdump -d -M intel --no-show-raw-insn chall | sed -n "/14aa:/,/14fc:/p" | \
sed -e "s|call 1090 <puts@plt>|& ; puts(\"---Counter---\")|" \
-e "s|mov DWORD PTR \[rbp-0x4\],0xa|& ; counter = 10|" \
-e "s|call 10b0 <printf@plt>|& ; printf(\"%d\",counter)|" \
-e "s|cmp DWORD PTR \[rbp-0x4\],0x3|& ; if(counter==3)|" \
-e "s|movabs rax,0x38383830357b4d49|& ; 암호문 \"IM{50888\"...|"
카운터가 3이 되는 순간, movabs로 조립한 암호문 "IM{50888…22f}"를 스택 버퍼([rbp-0x50])에 memcpy로 복사한다. 즉 암호문은 루프 도중 조용히 스택에 심긴다. 루프가 끝난 뒤가 문제다.
objdump -d -M intel --no-show-raw-insn chall | sed -n "/1581:/,/1613:/p" | \
sed -e "s|call 10c0 <memcpy@plt>|& ; 암호문 → \[rbp-0x50\]|" \
-e "s|sub DWORD PTR \[rbp-0x4\],0x1|& ; counter--|" \
-e "s|cmp DWORD PTR \[rbp-0x4\],0x0|& ; while(counter>0)|" \
-e "s|cmp DWORD PTR \[rbp-0x4\],0x5|& ; if(counter==5) ← 0에서 끝나 도달불가|" \
-e "s|call 11c9 <flag_gen>|& ; flag_gen(암호문, shift) 죽은코드|" \
-e "s|jne 15fe|& ; 항상 여기로 → ---END---|"
루프 조건은 counter > 0이라, 카운터가 0이 되면 빠져나온다. 그 직후 cmp counter, 5; jne로 분기하는데, 카운터는 이미 0이니 이 비교는 절대 참이 될 수 없다. 그래서 flag_gen을 호출하고 결과를 출력하는 코드 블록(call flag_gen → printf)은 실행되지 않고, 항상 jne가 걸려 ---END---만 찍고 끝난다. flag를 만드는 코드가 통째로 죽어 있는 것이다.
정상 실행으로는 flag를 못 보니, flag_gen의 로직을 그대로 재현해서 손으로 복호하는 수밖에 없다.
🐛 삽질 — shift는 몇이고 숫자는 어떻게 되나
▶🐛 삽질 — 죽은 분기를 억지로 실행시키려다 shift 함정에 빠질 뻔
처음엔 "그냥 flag_gen 분기로 점프하게 패치하면 되지"라고 생각했다. 그런데 main을 다시 보면 flag_gen에 넘기는 shift가 [rbp-0x8] = [rbp-0x4](카운터)인데, 루프가 끝난 시점의 카운터는 0이다. 그래서 분기만 억지로 살려도 flag_gen(cipher, 0)이 호출돼 아무것도 안 바뀐 IM{…}이 그대로 나온다. shift를 따로 5로 넣어줘야 한다는 뜻이다.
shift가 5라는 근거는 암호문의 시작이다. IM{에서 I → D, M → H가 되려면 정확히 5칸을 당겨야 한다. 다른 값도 대볼 수 있는데, shift 3이면 FJ{, shift 4면 EI{처럼 flag 형식이 깨진다. 5만 DH{로 떨어지고 뒤쪽 hex도 깔끔하게 나온다.
숫자 분기도 잠깐 헷갈렸다. r+50, r+40 매핑을 보고 "원래 숫자를 어떻게 복원하지?" 싶었는데, 이건 복원할 필요가 없다. flag_gen이 곧 복호기이므로, 암호문 숫자를 그 규칙에 그대로 통과시키면 flag의 숫자가 된다. 방향을 헷갈리지만 않으면 된다.
결론은 간단하다. 암호문에 flag_gen을 shift 5로 적용하면 flag가 된다.
💣 핵심 — shift=5로 죽은 복호기를 재현
암호문은 main의 movabs 값들을 리틀엔디언으로 이어 붙이면 나온다.
IM{508889j32j87j9jg54650840428hjhi2ii08h74ihj538h543j7g6k5jk8jih22f}
여기에 flag_gen의 규칙(소문자·대문자 Caesar 복호, 숫자 매핑, 나머지 그대로)을 shift 5로 적용하면 flag가 복원된다. 글자는 5칸 당겨지고(IM{ → DH{), 숫자는 숫자 규칙을 타고, 중괄호는 그대로 남는다.
🎯 익스플로잇 — 재현 + GDB로 교차검증
먼저 flag_gen을 Python으로 재현한다.
import struct
# main 의 movabs 8바이트(리틀엔디언) 조각 + 마지막 dword 로 조립되는 암호문
qwords = [0x38383830357b4d49, 0x6a37386a32336a39, 0x3035363435676a39,
0x6a68383234303438, 0x6838306969326968, 0x3833356a68693437,
0x3667376a33343568, 0x68696a386b6a356b]
cipher = (b"".join(struct.pack("<Q", q) for q in qwords)
+ struct.pack("<I", 0x7d663232)).decode()
def flag_gen(s, shift):
out = []
for ch in s:
o = ord(ch)
if ch.islower(): # 'a'+((c-'a'-shift)%26)
out.append(chr(ord('a') + (o - ord('a') - shift) % 26))
elif ch.isupper():
out.append(chr(ord('A') + (o - ord('A') - shift) % 26))
elif ch.isdigit(): # (ascii*(shift+3))%9
r = (o * (shift + 3)) % 9
out.append(chr(r + 50) if r <= 7 else chr(r + 40))
else:
out.append(ch) # '{', '}' 등은 그대로
return "".join(out)
print("[+] FLAG :", flag_gen(cipher, 5))재현이 맞는지 믿으려면, 실제 바이너리의 flag_gen을 직접 불러 비교하는 게 확실하다. not stripped라 GDB에서 심볼로 바로 호출할 수 있다. main에 멈춘 뒤, malloc으로 버퍼를 잡고 암호문을 넣어 flag_gen(cipher, 5)를 호출했다.

실제 flag_gen(cipher, 5)가 DH{389998e56e90e8eb…f9edc66a}를 그대로 뱉는다. 대조용으로 shift 3, 4를 넣으니 FJ{…, EI{…처럼 형식이 깨진다. shift 5가 유일하게 맞다는 게 실행으로 확인된다.
🚀 Full Exploit
재현 스크립트를 그대로 돌리면 flag가 나온다.
import struct
qwords = [0x38383830357b4d49, 0x6a37386a32336a39, 0x3035363435676a39,
0x6a68383234303438, 0x6838306969326968, 0x3833356a68693437,
0x3667376a33343568, 0x68696a386b6a356b]
cipher = (b"".join(struct.pack("<Q", q) for q in qwords)
+ struct.pack("<I", 0x7d663232)).decode()
def flag_gen(s, shift):
out = []
for ch in s:
o = ord(ch)
if ch.islower():
out.append(chr(ord('a') + (o - ord('a') - shift) % 26))
elif ch.isupper():
out.append(chr(ord('A') + (o - ord('A') - shift) % 26))
elif ch.isdigit():
r = (o * (shift + 3)) % 9
out.append(chr(r + 50) if r <= 7 else chr(r + 40))
else:
out.append(ch)
return "".join(out)
print("[*] cipher :", cipher)
print("[+] FLAG :", flag_gen(cipher, 5))
[*] cipher : IM{508889j32j87j9jg54650840428hjhi2ii08h74ihj538h543j7g6k5jk8jih22f}
[+] FLAG : DH{389998e56e90e8eb34238948469cecd6dd89c04dce359c345e0b2f3ef9edc66a}📝 결론
"실행하면 안 나온다"고 flag가 없는 게 아니다.
이 문제의 함정은 flag 생성 코드가 살아 있지만 호출되지 않는 죽은 코드라는 점이다. 카운터 루프는 0에서 끝나는데 flag_gen 분기는 카운터가 5여야 실행되니, 정상 흐름에선 영원히 닿지 않는다. 리버싱에서 실행 결과만 보고 판단하면 이런 코드를 통째로 놓친다. 심볼(flag_gen)과 문자열(IM{…), 그리고 어떤 조건에서 어떤 코드가 실행되는지를 정적으로 읽어야 전체 그림이 보인다.
Caesar cipher는 암호가 아니라 인코딩이다.
flag를 시프트 테이블로 "숨겼지만", 암호문의 첫 글자만 봐도 shift가 드러난다. DH{라는 알려진 접두사가 IM{로 나타나는 순간 shift=5는 확정된다. 이런 고정 접두사(known-plaintext)가 있으면 시프트·XOR 계열 인코딩은 즉시 뚫린다. 값을 정말 감추려면 키가 있는 진짜 암호를 써야 하고, 그 키를 바이너리 안에 같이 넣으면 결국 이렇게 정적 분석으로 복원된다. 클라이언트에 준 바이너리 안에 있는 비밀은 비밀이 아니다.
Comments
댓글
댓글을 남기려면 로그인이 필요해요. (네이버 · 구글 계정)
댓글 불러오는 중…