first-fit

如果一个chunk可用且足够大，那么就会使用这个chunk。

calc_tcache_idx

tcache(thread local caching)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

/* We want 64 entries.  This is an arbitrary limit, which tunables can reduce.  */
# define TCACHE_MAX_BINS		64
# define MAX_TCACHE_SIZE	tidx2usize (TCACHE_MAX_BINS-1)

/* Only used to pre-fill the tunables.  */
# define tidx2usize(idx)	(((size_t) idx) * MALLOC_ALIGNMENT + MINSIZE - SIZE_SZ)

/* When "x" is from chunksize().  */
# define csize2tidx(x) (((x) - MINSIZE + MALLOC_ALIGNMENT - 1) / MALLOC_ALIGNMENT)
/* When "x" is a user-provided size.  */
# define usize2tidx(x) csize2tidx (request2size (x))

/* With rounding and alignment, the bins are...
   idx 0   bytes 0..24 (64-bit) or 0..12 (32-bit)
   idx 1   bytes 25..40 or 13..20
   idx 2   bytes 41..56 or 21..28
   etc.  */

tcache拥有和fastbin差不多的结构。默认情况下，64个bin，每个bin最多7个chunk

64bit: IDX = (CHUNKSIZE - 0x11) / 0x10

fastbin_dup

free(fastbin)过程中，只检查了链表头部是否和将要free的指针一样。

1
2
3
4
5
6
7

int *a = malloc(8);
int *b = malloc(8);
int *c = malloc(8);

free(a);
free(b);
free(a);

此时fastbin 0x20: a->b->a

附注：

tcache可以检测到double free。在本机glibc2.31中发现，tcache_entry中使用key指向了tcache_perthread_struct。malloc.c:4186

1
2
3
4
5
6

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

tcache检测double free代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

/* 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.  */
}

fastbin_dup_into_stack.c

假设fastbin中通过double free得到以下序列。

fastbin: a->b->a

第一次malloc得到a后，修改数据，使得第二个a->fd指向栈地址。

0ctf2017-babyheap

fill函数中存在对chunk的任意长度溢出。

1
2
3
4
5

allocate(0x20)
allocate(0x20)
allocate(0x20)
allocate(0x20)
allocate(0x80)		# smallbin

mmap分配空间那块没看懂，怎么就获得了随机空间。。如果有人看懂，麻烦告诉我一下

泄露：通过partial overwrite修改fd，指向smallbin。溢出修改smallbin->size为0x31，两次分配后得到另一指针指向该smallbin。而后重新修改smallbin->size为0x91，free该smallbin，smallbin->fd和smallbin->bk就会指向main_arena中的区域。使用另一指针打印内容就可以得到libc_base。

攻击：0x70 fastbin attack，复写__malloc_hook为one_gadget地址。

ref

https://uaf.io/exploitation/2017/03/19/0ctf-Quals-2017-BabyHeap2017.html

fastbin_dup_consolidate

double free fastbin到unsorted bin和fastbin。通过分配large bin触发malloc_consolidate，清空fastbin到unsorted bin。图源

Hitcon 2016 SleepyHolder

fastbin dup consolidate double free

unsafe unlink

ref

https://github.com/mehQQ/public_writeup/tree/master/hitcon2016/SleepyHolder

在前块中构造fake_chunk，用一些方法将后块的pre_in_use位清掉，释放后块向前合并。

伪造fake_chunk需要绕过检查，一般用某个指针变量前后的地址当做fd、bk。之后就会将该指针变量就会被覆盖。

1
2
3
4
5

#define unlink(AV, P, BK, FD) {                                            \
    FD = P->fd;								      \
    BK = P->bk;								      \
    if (__builtin_expect (FD->bk != P || BK->fd != P, 0))		      \
      malloc_printerr (check_action, "corrupted double-linked list", P, AV);  \

how2heap对glibc的版本要求<2.26似乎有误？据我测试，glibc2.31 without tcache也可以运行成功，只要添加chunk0_ptr[1] = (uint64_t)malloc_size;，glibc2.31中看起来只是增加了size的验证。

1
2
3
4
5
6
7
8
9

/* consolidate backward */
if (!prev_inuse(p)) {
    prevsize = prev_size (p);
    size += prevsize;
    p = chunk_at_offset(p, -((long) prevsize));
    if (__glibc_unlikely (chunksize(p) != prevsize))
        malloc_printerr ("corrupted size vs. prev_size while consolidating");
    unlink_chunk (av, p);
}

非fastbin size才会进行前后consolidate。

Hitcon2014 stkof

p1分配0x80，p2分配0x80。

p1内伪造fake_chunk，溢出修改p2的pre_size,pre_in_use。free(p2)

覆盖free_got泄露地址，再任意写到atoi_got

House of spirit

在不可控区域周围构造fakechunk，覆盖某指针，释放再分配，以控制不可控区域。

hack.lu2014 oreo

在message_ptr周围构造。

poison null byte

溢出，覆盖已经释放的chunk的size，使其大小变小。free后块使其合并。

Plaidctf2015 plaiddb

null byte溢出，堆块重叠，libc泄露和fastbin attack

ref

  1. https://4ngelboy.blogspot.com/2016/10/span-display-block-overflow-hidden_10.html
  2. https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/off_by_one-zh/#2-plaidctf-2015-plaiddb

house of lore

glibc2.31 without tcache可以运行成功。

smallbin链表的特点是头插尾取的FIFO。

关键的漏洞点在，攻击者可以控制已经释放的smallbin的bk指针。取出smallbin过程中，双向链表尾部被修改为fake_chunk。

程序中的描述对于64位有些问题，但没有影响效果。64位过程如下：

free((void*)victim)后，该chunk被放入fastbin，后void *p2 = malloc(1200);申请largebin触发malloc_consolidate，将fastbin放入unsortedbin，然后遍历unsortedbin查找chunk导致victim chunk被放入smallbin。

1
2
3
4

victim_chunk->bk   = stack_buffer_1;
stack_buffer_1->fd = vimtim_chunk;
stack_buffer_1->bk = stack_buffer_2;
stack_buffer_2->fd = stack_buffer_1;

overlapping chunks

溢出，对unsortedbin中的chunk的size进行更改，造成重叠。可以添加prev_size(nextchunk) == chunk->size检查修补。

hack.lu2015 bookstore

overlapping

format string vulnerability：泄露libc，修改fini_array和返回地址

overlapping chunks 2

1
2
3
4
5

  p1 = malloc(1000);
  p2 = malloc(1000);
  p3 = malloc(1000);
  p4 = malloc(1000);
  p5 = malloc(1000);

首先free(p4)，溢出，对使用中的chunk p2的size进行更改，free掉p2，与p4合并，造成重叠。

house of force

覆盖topchun-size为0xffffffff，分配一个能够溢出size_t的evil_size，到目的地址，再分配一次，对其进行修改。

bctf2016 bcloud

null byte overflow，strcpy溢出。修改free_got为put_plt，泄露libc base，后修改atoi_got。

unsorted bin into stack

和house of lore差不多，只不过这里是对于unsorted bin。

在栈上伪造chunk，修改unsorted bin尾部chunk的size和bk，使其size不符合下一次分配的要求，使其bk指向栈上伪造的chunk，造成下一次分配落到栈上。

unsorted bin attack

修改unsorted bin中某一chunk的bk指向某位置p，接下来该chunk分配后，p+2*SIZE_ZE处会被覆盖为unsorted bin头结点的地址，也就是unsortedbin地址。

该攻击通常为进一步攻击做准备，比如覆盖global_max_fast

0ctf2016 zerostorage

UAF，realloc with topchunk

large bin attack

对已存在于large bin中的chunk的bk、bk_nextsize字段进行更改，在unsorted bin中取出插入该large bin时，会将bk->fd、bk_nextsize->fd_nextsize的位置覆盖成堆的地址。和先前的unsorted bin attack类似，通常为进一步攻击做准备，如修改global_max_fast。

large bin

0ctf2018 heapstorm2

poison null byte, large bin attack，fake unsorted bin

house of einherjar

泄露堆地址，计算fake size。

off-by-one覆盖victim->pre_in_use，修改victim->prev_size。

释放victim，与fake chunk合并。

victim需要与top chunk临近。

Secon2016 tinypad

house of orange

将topchunk->size缩小并对齐页，malloc一个大于size，就会将old top chunk释放到unsorted bin中。

Hitcon2016 houseoforange

house of roman

最主要的思想就是partial overwrite，所以能够在不泄露地址的情况下getshell。

需要溢出或者UAF

fast bin attack，partial overwrite fd或者bk指向main_arena的块（从small large unsorted bin中malloc），使其指向malloc_hook-0x23

unsorted bin attack，将bk指向malloc_hook-0x10，使得malloc_hook被写入main_arena地址，从而partial overwrite成为system、onegadget等。

tcache dup

glibc 2.26~2.28

没有任何检查，简单的double free

tcache poisoning

修改tcache中已释放块的next(fd)到任意位置，然后进行分配得到

tcache house of spirit

伪造堆块释放到tcahe。和普通house of spirit不同的是，tcache并没有对后块检查

prev_inuse没有影响，IS_MMAPPED、NON_MAIN_ARENA有影响

house of botcake

double free

commit在struct tcache_entry结构中添加了key变量指向tcache_perthread_struct，所以简单的向tcache中double free两次会被检测到。

1
2
3
4
5
6

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

使用把某个大小tcache填满的方式，将victim同时double free到tcache和unsorted bin，并在victim前面准备了了prev块，以使得size不一样，便于分配。

在tcache中布置5个chunk，对应大小的small bin中布置2个chunk。修改倒数第二个small chunk的bk指向target，target->bk写入一个可写的位置。使用calloc触发，因为calloc调用_int_malloc不会使用tcache进行分配（除了遍历unsorted bin的尾部），只会往tcache中填充。

可以造成target->bk->fd位置写入大数字，并且target成为tcache中第一个，再次malloc就可以获得。

有点像fastbin reverse into tcache。

variation

在tcache中布置6个chunk，对应大小的small bin中布置2个chunk。（可以用unsorted bin切割的方式布置2个small bin）

修改倒数第二个small chunk的bk，calloc触发，只修改bk->fd。

tips

可以使用分割unsorted bin的方法，得到对应大小small bin，在不必填满tcache的情况下。

Hitcon2019 one punch

fastbin reverse into tcache

UAF or overflow

可以达成类似unsorted bin attack的效果，写入一个大的数字到指定地址。（但也可以获得指定地址的chunk。。

chunk size = 0x50

  1. 填满tcache。除了victim外，再往fastbin释放1或6个chunk。如果要写入位置存储的数值为0，则1个就可以。如果数值不为0，则需要6个。结构如下

    fast bin 0x50: p1->p2->p3->p4->p5->p6->victim

  2. 分配清空tcache

  3. 修改victim->fd为"指定地址-0x10"

    fast bin 0x50: p1->p2->p3->p4->p5->p6->victim->target

  4. malloc触发，target->fd被覆盖为堆地址。tcache中的结构如下

    tcache 0x50: target->victim->p6->p5->p4->p3->p2

  5. 再malloc一次，获得target