House Of Banana

House Of Banana 利用背景：

在glibc2.28之后更新了关于unsorted bin的bk指针的检查，导致我们不能在用unsortedbin attack来实现任意地址写一个较大值了

1
2
3
/* remove from unsorted list */
**if** (__glibc_unlikely (bck->fd != victim))  
malloc_printerr ("malloc(): corrupted unsorted chunks 3");

此时我们能够利用的还有large bin attack，例如house of storm，但是随着glibc版本的提高，更新了许多对于largebin的检查，导致了之前的一些largebin attack的手法失效了

1
2
3
4
5
6
7
8
9
10
11
12
13
if (__glibc_unlikely (size <= 2 * SIZE_SZ)
    || __glibc_unlikely (size > av->system_mem))
    malloc_printerr ("malloc(): invalid size (unsorted)");
if (__glibc_unlikely (chunksize_nomask (next) < 2 * SIZE_SZ)
              || __glibc_unlikely (chunksize_nomask (next) > av->system_mem))
    malloc_printerr ("malloc(): invalid next 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)");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if ((unsigned long) size
              == (unsigned long) chunksize_nomask (fwd))
    /* Always insert in the second position.  */
    fwd = fwd->fd;
else
{
    victim->fd_nextsize = fwd;
    victim->bk_nextsize = fwd->bk_nextsize;
    if (__glibc_unlikely (fwd->bk_nextsize->fd_nextsize != fwd))
        malloc_printerr ("malloc(): largebin double linked list corrupted (nextsize)");
    fwd->bk_nextsize = victim;
    victim->bk_nextsize->fd_nextsize = victim;
}
bck = fwd->bk;
if (bck->fd != fwd)
    malloc_printerr ("malloc(): largebin double linked list corrupted (bk)");

高版本largebin attack 在高版本只能从下面这个分支利用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/* maintain large bins in sorted order */
if (fwd != bck)                
{                  
    /* Or with inuse bit to speed comparisons */
    size |= PREV_INUSE;                  
    /* if smaller than smallest, bypass loop below */
    assert (chunk_main_arena (bck->bk));                  
    if ((unsigned long) (size)
        < (unsigned long) chunksize_nomask (bck->bk))
    {                      
        fwd = bck;                      
        bck = bck->bk;
        victim->fd_nextsize = fwd->fd;                      
        victim->bk_nextsize = fwd->fd->bk_nextsize;                      
        fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;                    
    }                  
    else                    
    {                      
        //......                  
    }                  
    //......             
}
‘

这种利用方法要求双链表中至少存在一个 largebin chunk 并且新链入的 largebin chunk 必须比目前在largebin 中最小的 chunk 还小，此时将新链入的 largebin chunk 的 bk_nextsize 指针修改为目标地址就可已实现一次任意地址写堆地址。

在该分支利用largebin attack，只是完成往任意地址写一个堆地址的作用，因为在这里bck->bk才是我们的 large bin，因此我们能够控制的也就是这个分支中的fwd->fd->bk_nextsize，而完成写的操作是在另一个分支的fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim; 这句中，即可以往任意地址写上这个unsorted bin chunk堆的地址。而以前旧版large bin attack是可以往任意的两个地址写两个堆地址。

Largebin 堆复习：

有一段时间没有学习堆知识了，这里简单复习一下：

  • fd** (Forward Pointer):** 指向链表中下一个（比当前 chunk 更靠近头部/Head） 的 chunk。
  • bk** (Backward Pointer):** 指向链表中上一个（比当前 chunk 更靠近尾部/Tail） 的 chunk。
  • fd_nextsize: 指向比当前 size 更小 的下一个 size 组的第一个块。
  • bk_nextsize: 指向比当前 size 更大 的上一个 size 组的第一个块。

这两个指针的指向逻辑与 fd/bk 是相反的（fd 指向大，而 fd_nextsize 指向小）。这是为了形成一个闭环，方便从大向小扫描，也方便从小向大扫描。

Largebin 内部是按 Size 从大到小 降序排列的。

  • Head -> Largest Chunk -> ... -> Smallest Chunk -> Head
  • fd 指向更大的 chunk，bk 指向更小的 chunk。

之前提到 Unsorted Bin Attack 在 2.28 后失效了，而 Largebin Attack 成了替代方案：

其原理就在于插入 Largebin 时，如果进入了 bk_nextsize 的处理逻辑，源码中会有这样的操作：

1
2
3
4
victim->bk_nextsize = fwd->bk_nextsize;
victim->fd_nextsize = fwd;
fwd->bk_nextsize->fd_nextsize = victim; // 关键写：*(addr + 0x20) = victim
fwd->bk_nextsize = victim;

通过伪造 fwd->bk_nextsize，我们依然可以实现类似 Unsorted Bin Attack 的 “往任意地址写一个堆地址” 的效果。

House Of Banana：

适用版本及其原理：

  1. glibc2.23——至今
  2. 程序能实现若干次large bin attack
  3. 程序能够调用exit结束

源码分析：

程序通过exit退出时，会调用一个名叫 rtld_global 的结构体中的一系列函数来进行诸如恢复寄存器，清除缓冲区等操作：

1
rtld_global -> _ns_loaded -> link_map -> ((fini_t) array[i]) ()

rtld_global结构体里面的link_map结构体，其中rtld_global中的_ns_loaded指向link_map结构体的头节点。通过劫持link_map结构体就能实现函数调用。

下面来分析一下rtld_global结构体 , rtld_global结构体组成也是非常复杂的，我们直击重点

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
struct rtld_global
{
    #endif
    /* Don't change the order of the following elements.  'dl_loaded'
     must remain the first element.  Forever.  */

    /* Non-shared code has no support for multiple namespaces.  */
    #ifdef SHARED
    # define DL_NNS 16
    #else
    # define DL_NNS 1
    #endif
    EXTERN struct link_namespaces
    {
        /* A pointer to the map for the main map.  */
        struct link_map *_ns_loaded;
        /* Number of object in the _dl_loaded list.  */
        unsigned int _ns_nloaded;
        /* Direct pointer to the searchlist of the main object.  */
        struct r_scope_elem *_ns_main_searchlist;
        /* This is zero at program start to signal that the global scope map is
       allocated by rtld.  Later it keeps the size of the map.  It might be
       reset if in _dl_close if the last global object is removed.  */
        unsigned int _ns_global_scope_alloc;

        /* During dlopen, this is the number of objects that still need to
       be added to the global scope map.  It has to be taken into
       account when resizing the map, for future map additions after
       recursive dlopen calls from ELF constructors.  */
        unsigned int _ns_global_scope_pending_adds;

        /* Once libc.so has been loaded into the namespace, this points to
       its link map.  */
        struct link_map *libc_map; ##link_map结构体

            /* Search table for unique objects.  */
            struct unique_sym_table
            {
                __rtld_lock_define_recursive (, lock)
                    struct unique_sym
                    {
                        uint32_t hashval;
                        const char *name;
                        const ElfW(Sym) *sym;
                        const struct link_map *map;  
                    } *entries;
                size_t size;
                size_t n_elements;
                void (*free) (void *);
            } _ns_unique_sym_table;
        /* Keep track of changes to each namespace' list.  */
        struct r_debug _ns_debug;
    } _dl_ns[DL_NNS];
    /* One higher than index of last used namespace.  */
    EXTERN size_t _dl_nns;
    .................................................................................
    };
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
+-------+----------------------------------+----------------------------------+
| 偏移  | 前 8 字节 (0byte ~ 7byte)         | 后 8 字节 (8byte ~ 15byte)       |
+-------+----------------------------------+----------------------------------+
| +0x00 | l_addr                           | l_name                           |
|       | p64(0)                           | p64(l_next)                      |
+-------+----------------------------------+----------------------------------+
| +0x10 | l_ld                             | l_next                           |
+-------+----------------------------------+----------------------------------+
| +0x20 | l_prev                           | l_real                           |
|       | p64(0)                           | p64(base_addr)                   |
+-------+----------------------------------+----------------------------------+
| +0x30 | l_ns                             | l_libname                        |
|       | p64(0)                           | p64(base_addr + 0x8)             |
+-------+----------------------------------+----------------------------------+
| +0x40 | l_info[26] (DT_FINI_ARRAY)       | l_info[27]                       |
|       | p64(base_addr + 0x100)           | p64(base_addr + 0x108)           |
+-------+----------------------------------+----------------------------------+
| +0x50 | l_info[28] (DT_FINI_ARRAYSZ)     | padding                          |
|       | p64(base_addr + 0x110)           | p64(0)                           |
+-------+----------------------------------+----------------------------------+
| +0x60 | f_r8                             | f_r9 / rdi                       |
|       | p64(0)                           | p64(cmd_addr)                    |
+-------+----------------------------------+----------------------------------+
| +0x70 | f_r10 / rsi                      | f_r11 / rbp                      |
|       | p64(0)                           | p64(base_addr + 0x900)           |
+-------+----------------------------------+----------------------------------+

+-------+----------------------------------+----------------------------------+
| +0x80 | padding                          | padding                          |
|   ~   | p64(0)                           | p64(0)                           |
| +0xF0 |                                  |                                  |
+-------+----------------------------------+----------------------------------+
| +0x100| fake_dyn[FINI_ARRAY].d_tag       | fake_dyn[FINI_ARRAY].d_ptr       |
|       | p64(chunk_base + 0x110)          | p64(base_addr + 0x130)           |
+-------+----------------------------------+----------------------------------+
| +0x110| fake_dyn[FINI_ARRAYSZ].d_tag     | fake_dyn[FINI_ARRAYSZ].d_val     |
|       | p64(chunk_base + 0x110 + 0x10)   | p64(0x20) (所需数组大小)          |
+-------+----------------------------------+----------------------------------+
| +0x120| 字符串寄放区 / padding            | 函数基址辅助指针 / padding        |
|       | b"flag\x00\x00\x00\x00"          | p64(base_addr)                   |
+-------+----------------------------------+----------------------------------+
| +0x130| target_func_array[0]             | target_func_array[1]             |
|       | p64(setcontext_addr)             | p64(ret)                         |
+-------+----------------------------------+----------------------------------+

而这个结构体里面存放的是elf文件各段的符号结构体 _dl_ns，而这个符号结构体里面又套的有结构体，我们关注的是里面的 fini_array 段的动态链接结构体指针，而这个指针又会在 _dl_fini 中被使用。

当调用到 _dl_fini 函数时，会执行每个 so 中注册的 fini 函数：

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
void
_dl_fini (void) //house of banana
{
  
  for (Lmid_t ns = GL(dl_nns) - 1; ns >= 0; --ns)
    {
   
      ...
	  for (i = 0; i < nmaps; ++i) //l遍历link_map的链表
	    {
	   ...

	      if (l->l_init_called)  //重要的检查点
		{
		
		  l->l_init_called = 0;

		 
		  if (l->l_info[DT_FINI_ARRAY] != NULL //26 
		      || (ELF_INITFINI && l->l_info[DT_FINI] != NULL)) //13 这个基本都是满足条件的
		    {
		     
		      if (l->l_info[DT_FINI_ARRAY] != NULL) //26
			{
			  ElfW(Addr) *array =
			    (ElfW(Addr) *) (l->l_addr
					    + l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
			  unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val
					    / sizeof (ElfW(Addr)));
			  while (i-- > 0)
			    ((fini_t) array[i]) ();  //目标位置
			}
          }
}


代码中的l是link_map结构体

link_map结构体是一个在Linux下用于动态链接的数据结构，用于保存共享对象库之间的依赖关系和符号表信息。每个共享对象都有一个link_map结构体，通过这些结构体可以组成一个链表，这个链表描述了所有的共享对象库之间的依赖关系。

link_map结构体定义在/usr/include/link.h头文件中，其主要成员变量包括：

  • l_next：指向下一个共享对象库的link_map结构体的指针。
  • l_real：指向本身的地址
  • info[x]:它是一个指向ElfW(Dyn)类型的指针，用于保存共享对象库的动态信息

_rtld_global是一个在Linux下用于动态链接的全局变量，它是一个指向struct link_map结构体的指针，代表当前进程的所有共享对象库之间的依赖关系和符号表信息。

该全局变量在动态链接器ld.so中定义，其作用是记录动态链接器在进程启动时加载的所有共享对象库的link_map结构体链表的头指针。

在动态链接过程中，当需要查找符号表信息时，动态链接器可以通过访问_rtld_global指向的link_map链表，遍历所有已加载的共享对象库，以寻找所需的符号表信息，这是动态链接的核心功能之一。

_也就是说我们需要利用large bin attack需改 rtld_global为我们伪造的link_map结构体

构造函数指针入口 (l_info)：

link_map 结构体内部有一个 l_info 指针数组，保存着指向 Elf64_Dyn（动态节）的指针。我们需要精心伪造两个关键条目：

  • l_info[DT_FINI_ARRAY]：指向伪造的动态节条目，该条目进一步指向包含目标恶意函数地址的数组。
  • 这个恶意地址可以是 one_gadgets，高版本 libc 下也可以是 setcontext
  • l_info[DT_FINI_ARRAYSZ]：指向指明数组大小的伪造条目（确保循环能够执行）。

3. 触发漏洞执行流

完成堆上数据的布局后，通过输入程序菜单的退出选项 Quit 或触发异常终止程序，引导控制流进入 exit()。

4. 结合 setcontext 进行栈迁移 (SROP)

在高版本 libc 的利用场景中，我们直接跳转的目标通常不是 system("/bin/sh")（沙箱场景），而是 Glibc 中的汇编片段 setcontext+0x3d（或类似偏移）。

  • 当 _dl_fini 调用伪造的析构函数时，寄存器 RDX 恰好指向当前的 link_map 结构体（即我们的伪造堆块）。
  • 执行效果：setcontext 代码会从 [rdx + offset] 处恢复各个通用寄存器（包括 RSP 栈指针）。我们将 RSP 劫持到预先布置了 ROP 链的堆内存上，即可流畅执行任意系统调用。

在有些情况下，rtld_global_ptr与libc_base的偏移在本地与远程并不是固定的，可能会在地址的第2字节处发生变化，因此可以爆破256种可能得到远程环境的精确偏移。

更新: 2026-05-20 15:23:16
原文: https://www.yuque.com/idcm/wnemg9/ekzm2qwvp90s5lcr