[System Hacking] 2주차 dreamhack stage 12 - (1)

free로 해제한 청크를 free로 다시 해제했을 때 발생하는 현상에 주목 

- free : 청크를 추가하는 함수, malloc : 청크를 꺼내는 함수 

- 임의의 청크에 대해 free를 두 번이상 적용할 수 있다 ▷ 청크를 free list에 여러 번 추가할 수 있음 

- 청크가 free list에 중복해서 존재하면 청크가 duplicated 되었다고 한다.

 

-> duplocated free list를 이용하면 임의 주소에 청크를 할당할 수 있다.

▶ 같은 청크를 중복해서 해제할 수 있는 코드는 보안상의 약점으로 분류, Double Free Bug라고 부름 

 

 

 

1. Double Free Bug (DFB)

- 같은 청크를 두 번 해제할 수 있는 버그 

 

- ptmalloc2에서 free list의 각 청크들은 fd와 bk로 연결된다. 

→ fd : 자신보다 이후에 해제된 청크 

→ bk : 자신보다 이전에 해제된 청크 

* 해제된 링크에서 fd와 bk값을 저장하는 공간은 할당된 청크에서 데이터를 저장하는 데 사용됨 

>> 어떤 링크가 free list에 중복해서 포함된다면, 첫 번째 재할당에서 fd와 bk의 값을 조작해서 free list에 임의 주소를 포함시킬 수

있다.

 

최근에는 보호 기법이 glibc에 구현되면서, 이를 우회하지 않으면 같은 청크를 두 번 해제하는 즉시 프로세스가 종료됨.

 

 

Tcache Double Free

다음은 같은 청크를 두 번 해제하는 예제 코드이다.

// Name: dfb.c
// Compile: gcc -o dfb dfb.c
#include <stdio.h>
#include <stdlib.h>
int main() {
  char *chunk;
  chunk = malloc(0x50);
  printf("Address of chunk: %p\n", chunk);
  free(chunk);
  free(chunk); // Free again
}

컴파일 실행하면 tcache에 대한 Double Free가 감지되어 프로그램이 비정상 종료되는 걸 확인할 수 있다.

 

 

 

2. Mitigation for Tcache DFB

정적 패치 분석

tcache_entry 

tcache에 도입된 보호 기법을 분석하기 위해, 패치된 코드의 diff를 살펴보고자 한다.

#tcahe_entry 구조체의 Diff
typedef struct tcache_entry {
  struct tcache_entry *next;
+ /* This field exists to detect double frees.  */
+ struct tcache_perthread_struct *key;
} tcache_entry;

위 코드를 보면 double free를 탐지하기 위해 key 포인터가 tcahe_entry에 추가되었음을 알 수 있다.

(tcache_entry는 해제된 tcache 청크들이 갖는 구조)

일반 청크의 fd가 next로 대체되고, LIFO로 사용되므로 bk에 대응되는 값은 없다.

 

* tcache_perthread_struct : tcache를 처음 사용하면 할당되는 구조체

 

 

 

 

tcache_put

tcache_put은 해제한 청크를 tcache에 추가하는 함수이다.

tcache_put(mchunkptr chunk, size_t tc_idx) {
  tcache_entry *e = (tcache_entry *)chunk2mem(chunk);
  assert(tc_idx < TCACHE_MAX_BINS);
  
+ /* Mark this chunk as "in the tcache" so the test in _int_free will detect a
       double free.  */
+ e->key = tcache;
  e->next = tcache->entries[tc_idx];
  tcache->entries[tc_idx] = e;
  ++(tcache->counts[tc_idx]);
}

위 코드를 보면 tcache_put함수는 해제되는 청크의 key에 tcache라는 값을 대입하도록 변경되었다.

tcache는 tcache_perthread라는 구조체 변수를 가리킨다.

                                                                                             

 

 

tcache_get

- tcache에 연결된 청크를 재사용할 때 사용하는 함수          

tcache_get (size_t tc_idx)
   assert (tcache->entries[tc_idx] > 0);
   tcache->entries[tc_idx] = e->next;
   --(tcache->counts[tc_idx]);
+  e->key = NULL;
   return (void *) e;
 }

위의 코드를 보면 tcache_get 함수는 재사용하는 청크의 key 값에 NULL을 대입하도록 변경되었다.

 

 

 

_int_free

- 청크를 해제할 때 호출되는 함수                                                                                                                                                            

_int_free (mstate av, mchunkptr p, int have_lock)
 #if USE_TCACHE
   {
     size_t tc_idx = csize2tidx (size);
-
-    if (tcache
-       && tc_idx < mp_.tcache_bins
-       && tcache->counts[tc_idx] < mp_.tcache_count)
+    if (tcache != NULL && tc_idx < mp_.tcache_bins)
       {
-       tcache_put (p, tc_idx);
-       return;
+       /* Check to see if it's already in the tcache.  */
+       tcache_entry *e = (tcache_entry *) chunk2mem (p);
+
+       /* This test succeeds on double free.  However, we don't 100%
+          trust it (it also matches random payload data at a 1 in
+          2^<size_t> chance), so verify it's not an unlikely
+          coincidence before aborting.  */
+       if (__glibc_unlikely (e->key == tcache))
+         {
+           tcache_entry *tmp;
+           LIBC_PROBE (memory_tcache_double_free, 2, e, tc_idx);
+           for (tmp = tcache->entries[tc_idx];
+                tmp;
+                tmp = tmp->next)
+             if (tmp == e)
+               malloc_printerr ("free(): double free detected in tcache 2");
+           /* If we get here, it was a coincidence.  We've wasted a
+              few cycles, but don't abort.  */
+         }
+
+       if (tcache->counts[tc_idx] < mp_.tcache_count)
+         {
+           tcache_put (p, tc_idx);
+           return;
+         }
       }
   }
 #endif

20번째 줄 이하를 보면, 

재할당하려는 청크의 key값이 tcache이면 Double Free가 발생했다고 보고 프로그램을 중단시킨다.

20번째 줄의 조건문을 통과하면 Double Free를 일으킬 수 있다.

 

 

 

 

동적 분석

gdb를 이용하여 보호 기법의 적용 과정을 동적 분석 해볼 것이다.

dreamhack 페이지에 나와있는 double_free가 dfb 코드인 것 같아서 이걸로 진행했다.

쟇

disassemble main

청크 할당 지점에 해당하는 main+13의 직후인 main+18 부분에 중단점을 설정하고 실행한다.

 

 

 

heap 명령어로 청크들의 정보를 조회하면 다음과 같다.

heap

이 중에서 malloc(0x50)으로 설정한 chunk의 주소는 0x555555756250 (크기가 가장 비슷한 부분)

해당 메모리 값을 덤프해볼 것이다.

 

아직 아무런 데이터가 입력되지 않았음을 확인할 수 있다.

이후의 참조를 위해 gdb 변수로 정의했다.

 

 

 

 

3. Tcache Duplication

// Name: tcache_dup.c
// Compile: gcc -o tcache_dup tcache_dup.c
#include <stdio.h>
#include <stdlib.h>
int main() {
  void *chunk = malloc(0x20);
  printf("Chunk to be double-freed: %p\n", chunk);
  free(chunk);
  *(char *)(chunk + 8) = 0xff;  // manipulate chunk->key
  free(chunk);                  // free chunk in twice
  printf("First allocation: %p\n", malloc(0x20));
  printf("Second allocation: %p\n", malloc(0x20));
  return 0;
}

위의 코드는 tcache에 적용된 double free 보호 기법을 우회하여 Double Free Bug을 트리거하는 코드이다.

컴파일하고 실행해보았다.

실행해보니 chunk가 tcache에 중복 연결되어 연속으로 재할당되는 걸 확인할 수 있다.

-> double free bug로 발생시킬 수 있으며, tcache poisoning으로 응용될 수 있다.

 

*tcache poisoning 

: tcache chunk의 next를 원하는 주소로 바꿔 공격하는 기법

 

 

 

 

Quiz: Double Free Bug

 

답) C

어떤 링크가 free list에 중복돼서 포함되는 경우 double free를 위심해볼 수 있을 것이다. 

따라서 C가 가장 의심된다.