[🥈 Silver 4] ctype 비트 하나를 잘못 짚으면 퍼뮤테이션 전체가 어긋난다 — DreamHack Permpkin 풀이

2026-07-21·1분 읽기·

[🥈 Silver 4] ctype 비트 하나를 잘못 짚으면 퍼뮤테이션 전체가 어긋난다 — DreamHack Permpkin 풀이

chall 바이너리는 입력을 받지 않는다. 대신 미리 정해둔 sample 문자열을 스스로 뒤섞어 rev1.txt/rev2.txt로 보여줄 뿐이다. 진짜 풀어야 할 대상은 같은 방식으로 미리 변환돼 주어진 flag1.txt/flag2.txt. 바이너리 안의 23자리 hex 문자열을 ctype 기반으로 숫자 배열(퍼뮤테이션+XOR 키)로 바꾸는데, 그 변환 도중 하필 값이 0이 되는 지점이 있어서 이후 strlen()이 배열 길이를 23에서 13으로 끊어버린다. 이 함정을 처음엔 못 보고 엉뚱한 ctype 비트를 가정해 틀렸다가, gdb로 실제 프로세스의 중간 메모리 상태를 직접 찍어보고 나서야 알고리즘을 100% 검증하고 뒤집을 수 있었다.

문제: DreamHack — Permpkin 분류: Reversing 난이도: 🥈 Silver 4 FLAG: flag{ch4ng3_fla9_wi7h_3a5y_5impl3_p3rmutati0n}

파일 세 개가 주어진다. 바이너리 chall, 그리고 숫자들이 공백으로 나열된 flag1.txt, flag2.txt. 문제 설명을 보면 구조가 처음부터 친절하게 설명돼 있다 — chall을 실행하면 "sample flag"를 변환해 rev1.txt/rev2.txt를 만들어주고, 우리가 진짜 풀어야 할 flag1.txt/flag2.txt는 같은 변환을 실제 flag에 적용해서 미리 저장해둔 결과라는 것이다. 즉 이 문제는 "바이너리를 실행해서 정답을 구하는" 문제가 아니라, 바이너리가 하는 일을 완전히 이해해서 거꾸로 되돌리는 문제다.


문제 개요

chall부터 살펴봤다.

작업 디렉터리 파일 목록, file 결과, pwntools로 확인한 임포트 목록(fopen/fprintf/fclose/strlen/__ctype_b_loc, read류 없음), flag1.txt/flag2.txt 내용

임포트 목록에 fopen/fprintf/fclose/strlen/__ctype_b_loc은 있지만 scanf/read/fgets 같은 입력 함수가 하나도 없다. 이 바이너리는 사용자 입력과 무관하게 항상 똑같이 동작한다는 뜻이다. flag1.txt는 21개, flag2.txt는 19개의 정수가 공백으로 나열돼 있다 — ASCII 코드 값처럼 보이지만 대부분 인쇄 가능 범위를 벗어난 값들(80~127대)도 섞여 있어서, 뭔가 변환(암호화/치환)을 거친 결과라는 걸 짐작할 수 있다.

일단 설명대로 chall을 직접 실행해봤다.

./chall 실행 결과 — 정상 종료(exit=0) 후 rev1.txt와 rev2.txt가 생성되고, 각각 21개·19개의 숫자가 저장됨

rev1.txt(21개 숫자), rev2.txt(19개 숫자)가 생성됐다. 개수가 flag1.txt/flag2.txt와 정확히 일치한다 — 문제 설명 그대로, 이 프로그램은 알려진 sample 문자열을 변환해서 이 파일들을 만든 것이다. 이제 chall이 정확히 어떤 변환을 하는지 완전히 파악하면, flag1.txt/flag2.txt에 그 변환의 역과정을 적용해 진짜 flag를 얻을 수 있다.


🔬 정찰 — 23자리 hex 문자열 하나가 두 가지 역할을 한다

objdump로 main()을 열어보면 스택에 movabs 즉시값으로 문자열을 조립하는 코드가 여럿 나온다. 그중 하나가 눈에 띄었다.

objdump 디스어셈블 — movabs로 CC2A750B63821F45AC20839 라는 23자리 hex 문자열을 스택에 조립하는 부분

"CC2A750B63821F45AC20839" — 23자리, 전부 16진수로 유효한 문자(0-9, A-F)들이다. 이 문자열은 그대로 쓰이는 게 아니라, 한 글자씩 커스텀 변환 함수를 거쳐 숫자 배열로 바뀐다. 이 배열이 나중에 두 번 재사용된다 — 한 번은 문자를 뒤섞는 "퍼뮤테이션 키"로, 한 번은 XOR 암호화의 "반복 키"로.

hex 문자를 숫자로 바꾸는 변환 함수의 로직 정리 — ctype의 isdigit 비트가 참이면 c-0x28, 아니면 알파벳 구간별로 c-0x3c/0x46/0x50. F가 0으로 변환되는 지점을 강조

이 함수는 __ctype_b_loc()으로 얻은 glibc의 문자 분류 테이블에서 0x800 비트를 확인한 뒤, 그 비트가 서 있으면 문자코드 - 0x28을, 아니면 알파벳 구간(AE, FO, PY)별로 다른 상수를 빼는 방식으로 값을 만든다. 언뜻 평범한 "hex 문자 → 숫자" 변환처럼 보이지만, 자세히 보면 함정이 하나 숨어 있다 — 'F'(0x46)가 FO 구간 분기에 걸려서 0x46 - 0x46 = 0이 나온다. 이 "0"이라는 값이 나중에 이 배열을 strlen()으로 다루는 코드와 만나면서 문제가 생긴다.


▶🕳️ 삽질 — ctype 비트 하나를 잘못 짚어서 인덱스가 범위를 넘어가 버렸다

처음엔 0x800 비트를 isxdigit(16진수 문자 판별, 0-9와 A-F 모두 참)이라고 가정했다. hex 문자열이니 당연히 모든 문자가 이 분기를 타겠거니 생각한 것이다. 이 가정대로 23자리 전체를 문자코드 - 0x28 공식으로 변환하면, 결과값이 최대 30까지 나온다 — 그런데 이 값이 나중에 21자리 sample 문자열("_this_is_sample_flag_")의 인덱스로 쓰이니, 21을 넘는 인덱스는 명백히 범위를 벗어난다.

isxdigit 가정으로 계산한 값과 실제 gdb로 확인한 중간 상태가 일치하지 않음을 보여주는 캡쳐 — libc.isdigit/isxdigit를 직접 호출해 0x800 비트가 실제로는 isdigit(2048)에 대응함을 확인

이상하게도 바이너리 자체는 크래시 없이 잘 돌아갔다(스택의 다른 지역변수를 침범해도 딱히 문제가 안 될 위치였던 모양이다). 그래서 "일단 실행은 되니 내 가정이 맞겠지"라고 넘어갈 뻔했는데, 확실히 하기 위해 gdb로 실제 프로세스의 중간 상태(퍼뮤테이션 직후, XOR 적용 전)를 직접 찍어 내 파이썬 시뮬레이션 결과와 비교해봤다. 일치하지 않았다. 그제서야 libc.isxdigit()과 libc.isdigit()을 파이썬 ctypes로 직접 호출해서 실제 glibc가 리턴하는 비트 값을 대조해봤고, 0x800이라는 값이 isdigit()의 반환값(2048)과 정확히 일치한다는 걸 확인했다 — 즉 이 분기는 "16진수 문자인가"가 아니라 "순수 숫자(0-9)인가" 를 묻는 것이었다. 알파벳(A~F)은 전부 else 분기로 빠진다.

"실행이 크래시 없이 잘 됐다"는 사실이 "내 가정이 맞았다"는 증거는 아니었다. 겉으로 드러나는 이상 징후가 없어도, 계산 로직을 다루는 문제에서는 반드시 알려진 입력·출력 쌍으로 직접 대조 검증해야 한다는 걸 다시 확인했다.


💣 핵심 — 값이 0이 되는 지점에서 strlen()이 배열을 끊어버린다

isdigit 비트로 다시 계산하면 값 범위가 훨씬 안정적으로 좁아진다. "CC2A750B63821F45AC20839"의 23글자를 하나씩 변환하면:

  • 숫자(0-9)는 문자코드 - 0x28
  • 알파벳(A,B,C,F)은 구간별로 -0x3c/-0x46/-0x50

이렇게 계산한 23개의 값 중, 'F'가 있던 자리(14번째 문자)에서 정확히 0이 나온다. 이 배열은 이후 코드에서 strlen()으로 길이를 잰다 — 그런데 strlen()은 첫 번째 널바이트(0x00)를 만나면 그 자리에서 멈춘다. 숫자 배열을 C 문자열처럼 취급하는 순간, 값이 우연히 0이 된 지점이 곧 "문자열의 끝"이 되어버리는 것이다. 그 결과 원래 23개였어야 할 키가 실질적으로 13개로 잘린다.

이 13개짜리 키([7, 7, 10, 5, 15, 13, 8, 6, 14, 11, 16, 10, 9])가 두 가지 역할을 순서대로 한다.

  1. 퍼뮤테이션: 키의 각 값 idx에 대해 swap(문자열[0], 문자열[idx])를 반복 실행 — 매번 맨 앞 글자를 특정 위치의 글자와 맞바꾸는 셔플이다.
  2. 반복 키 XOR: 퍼뮤테이션이 끝난 문자열을, 같은 13개짜리 키를 반복해서 XOR한다(문자열이 키보다 길면 키를 순환).

이 두 단계가 정확히 이 순서로 적용된 결과가 rev1.txt/rev2.txt(그리고 우리가 풀어야 할 flag1.txt/flag2.txt)다. gdb로 실측한 중간 상태를 다시 확인해보면, 13개짜리 키로 계산한 값이 실제 프로세스 메모리와 정확히 일치한다.

gdb로 두 sample 블록 각각의 '퍼뮤테이션 직후, XOR 적용 전' 메모리 상태를 직접 덤프한 결과

🎯 자체 완결 solve

이 파이프라인을 파이썬으로 그대로 옮기고, 두 개의 sample 문자열("_this_is_sample_flag_", "this_is_sample_flag")에 적용해 rev1.txt/rev2.txt와 정확히 일치하는지부터 확인했다(완전히 일치했다). 그 다음 역변환을 적용했다 — XOR은 같은 키로 한 번 더 적용하면 원래대로 돌아오고(자기 자신이 역연산), 퍼뮤테이션은 같은 swap들을 역순으로 재생하면 원래 상태로 되돌릴 수 있다(각각의 swap 자체가 자기 자신의 역연산이기 때문에, 순서만 뒤집으면 된다).

import ctypes
 
libc = ctypes.CDLL("libc.so.6")
libc.isdigit.restype = ctypes.c_int
libc.isdigit.argtypes = [ctypes.c_int]
 
 
def transform_char(c):
    code = ord(c)
    if libc.isdigit(code):
        return code - 0x28
    if code <= 0x45:
        return code - 0x3C
    if code <= 0x4F:
        return code - 0x46
    if code <= 0x59:
        return code - 0x50
    return 0
 
 
HEXSTR = "CC2A750B63821F45AC20839"
raw = [transform_char(c) for c in HEXSTR]
 
KEY = []
for v in raw:
    if v == 0:          # 'F' -> 0 에서 strlen()처럼 끊기는 부분을 재현
        break
    KEY.append(v)
 
 
def xor_repeat(data, key):
    b = bytearray(data)
    n, k = len(b), len(key)
    for i in range(n):
        b[i] ^= key[i % k] if n > k else key[i]
    return bytes(b)
 
 
def unpermute(data, key):
    b = bytearray(data)
    for idx in reversed(key):       # swap을 역순으로 재생
        b[0], b[idx] = b[idx], b[0]
    return bytes(b)
 
 
def decode(path):
    nums = [int(x) for x in open(path).read().split()]
    return unpermute(xor_repeat(bytes(nums), KEY), KEY)
 
 
part1 = decode("flag1.txt").decode()
part2 = decode("flag2.txt").decode()
print("[+] FLAG: flag{%s%s}" % (part1, part2))
solve.py 실행 결과 — flag{ch4ng3_fla9_wi7h_3a5y_5impl3_p3rmutati0n} 출력

flag1.txt를 복원하면 ch4ng3_fla9_wi7h_3a5y("change flag with easy"의 리트 표기), flag2.txt를 복원하면 _5impl3_p3rmutati0n("simple permutation")이 나온다. 두 조각을 이어붙이면 "change flag with easy simple permutation"이라는, 이 문제의 기법 자체를 설명하는 문장이 된다. 두 파일이 왜 굳이 21자와 19자로 나뉘어 있는지도 이제 설명이 된다 — sample 문자열이 "_this_is_sample_flag_"(21자)와 "this_is_sample_flag"(19자)로 길이가 다르게 설계돼 있었고, 실제 flag도 정확히 같은 두 길이로 쪼개서 각각 변환해뒀던 것이다. 파일이 두 개로 나뉜 이유 자체가 sample 데모의 구조를 그대로 반영한 셈이다.

전체 풀이 흐름 다이어그램 — 입력 없는 바이너리 확인, hex 문자열의 ctype 변환과 strlen 절단 발견, isdigit/isxdigit 혼동을 gdb로 바로잡은 과정, 역swap+역XOR로 flag 복원까지 4단계

이 flag를 처음엔 드림핵의 표준 형식인 DH{...}로 감싸서 제출했는데 "오답"이 떴다. 값은 확실했으니 형식을 의심해 문제 설명을 다시 읽어보니, 맨 아래에 "플래그 형식은 flag{} 입니다"라고 명시돼 있었다. flag{...}로 다시 감싸서 제출하니 바로 정답으로 확정됐다 — 이 문제는 드림핵의 관례적 형식을 그대로 가정하면 안 되는, 몇 안 되는 예외였다.


📝 결론

이 문제가 잘 짚어준 지점은 "프로그램이 정상적으로 실행됐다"는 사실이 "내가 로직을 정확히 이해했다"는 증거가 될 수 없다는 것이었다.

  • ctype 비트마스크처럼 "당연히 그럴 것 같은" 가정일수록 직접 검증해야 한다. isxdigit과 isdigit은 이름부터 헷갈리기 쉽고, hex 문자열을 다루는 코드라면 isxdigit을 쓰는 게 훨씬 자연스러워 보인다. 하지만 실제 비트값은 함수 이름의 "직관"이 아니라 어셈블리에 박힌 상수(0x800)로 정확히 확인해야 하는 사실이다. ctypes로 실제 libc 함수를 직접 호출해 비교하는 데는 몇 줄이면 충분했다.
  • 알려진 입력·출력 쌍(known plaintext)이 있으면 반드시 그걸로 자기 이해를 검증한다. 이 문제는 친절하게도 chall을 실행해 "sample 변환 결과"를 직접 만들어볼 수 있게 해줬다. 이 사실 자체가 "네 알고리즘 이해가 맞는지 이걸로 검증해봐"라는 신호였다 — gdb로 중간 상태까지 찍어 대조하고 나서야 확신을 가지고 실제 flag 파일에 역변환을 적용할 수 있었다.
  • strlen()으로 순수 데이터 배열의 길이를 재는 코드는 항상 의심할 만하다. 이 배열이 사람이 읽는 "문자열"이 아니라 임의의 숫자를 담는 용도로 재사용되고 있다면, 그 값들 중 하나가 우연히 0이 되는 순간 배열이 조기 절단된다. 이런 "우연한 널바이트" 패턴은 실제 C 프로그램에서도 종종 골칫거리가 되는 흔한 버그 유형이다.

방어자 관점에서 보면, 이 문제는 바이트 지향 데이터와 널종단(null-terminated) 문자열을 섞어 쓸 때 생기는 위험을 정확히 보여준다. 실제 소프트웨어에서도 암호화 키나 해시 값처럼 임의의 바이트를 담는 버퍼를 strlen/strcpy 같은 C 문자열 함수로 다루다가, 그 바이트들 중 하나가 우연히 0x00이 되는 순간 데이터가 조용히 잘려나가는 사고가 실제로 발생한다. 임의의 바이너리 데이터를 다룰 때는 반드시 길이를 명시적으로 관리하는 API(memcpy, 길이 인자를 받는 함수)를 쓰고, 문자열 전용 함수(strlen, strcpy)는 정말로 널종단 텍스트를 다룰 때만 써야 한다는 원칙을, 이 문제는 공격자 입장에서 거꾸로 체험하게 해준다.

이 글이 도움이 됐나요?

Comments

댓글

0개

댓글을 남기려면 로그인이 필요해요. (네이버 · 구글 계정)

댓글 불러오는 중…

Related

관련 글

3개
[🥈 Silver 2] Rust 크랙미의 비트 치환을 거꾸로 돌려 64글자 입력 복원 — DreamHack CrabME 풀이
blog

[🥈 Silver 2] Rust 크랙미의 비트 치환을 거꾸로 돌려 64글자 입력 복원 — DreamHack CrabME 풀이

Rust 로 빌드된 크랙미. 입력은 64글자 소문자 hex 로 고정돼 있고, 두 글자씩 묶은 32바이트를 flagchecker 가 "비트 치환 → XOR 0x63 → +0x22" 세 단계로 바꿔 .rodata 에 박힌 상수 32개와 비교한다. 세 단계가 전부 바이트 단위 전단사라 브루트포스 없이 그대로 역산되고, 나온 64글자가 곧 플래그 본문이다. objdump 로 치환표를 유도하고 gdb 로 런타임에서 같은 값이 나오는지 확인했다.
#dreamhack#ctf#reversing+6
2026-07-26#dreamhack +4
[🥈 Silver 3] 난수가 상쇄되는 플래그 체커 뜯기 — DreamHack CRC 풀이
blog

[🥈 Silver 3] 난수가 상쇄되는 플래그 체커 뜯기 — DreamHack CRC 풀이

"Crackable Random Checker"라는 이름처럼 rand()로 겁을 주지만, 두 검증 단계의 난수가 전부 상쇄되는 x86-64 리버싱 문제. 생성자가 기본시드로 깔아두는 상수 테이블, srand(0x1337)의 결정적 수열 역산, 그리고 "A와 0x7f의 AND"로 환원되는 stage2 변환식을 정적 분석과 gdb 런타임 검증으로 짚어 두 hex 입력을 역산하고 플래그를 복원한다.
#dreamhack#ctf#reversing+5
2026-10-12#dreamhack +4
[🥈 Silver 1] 교차하는 선으로 숨긴 이미지 — DreamHack Crossing 풀이
blog

[🥈 Silver 1] 교차하는 선으로 숨긴 이미지 — DreamHack Crossing 풀이

이미지 대신 "또 다른 2D 표현"으로 flag.jpg를 숨긴 인코더를 리버싱했다. 바이트를 니블로 쪼개 getrandom으로 뽑은 행·열·방향에 0xff 구분 토큰으로 그려 넣는 구조를 파악하고, 격자의 모든 행과 열을 전수 스캔해 니블을 재조립하는 역변환으로 원본 JPEG을 복원했다.
#dreamhack#ctf#reversing+5
2026-10-09#dreamhack +4