ctfwiki--堆的基础操作

向右看齐 2022-01-11 17:29 350阅读 0赞

参考链接：[https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/implementation/basic-zh/\#\_\_comments][https_ctf-wiki.github.io_ctf-wiki_pwn_linux_glibc-heap_implementation_basic-zh_comments]

# 堆的基础操作 #

## unlink ##

unlink 用来将一个双向链表（只存储空闲的 chunk）中的一个元素取出来，可能在其他地方使用。

（1）malloc

1.  从恰好合适的 large bin 中获取 chunk  
    需注意：fastbin 和 small bin 没有使用 unlink，这就是为什么漏洞会经常出现在它们这里的原因。  
    依次遍历处理 unsorted bin 时也没有使用 unlink 的。
2.  从比请求 chunk 所在的 bin 大的 bin 中取 chunk

（2）free

1.  后向合并，合并物理相邻低地址空闲 chunk
2.  前向合并，合并物理相邻高地址空闲 chunk（除了 top chunk）

（3）malloc\_consolidate

1.  后向合并，合并物理相邻低地址空闲 chunk
2.  前向合并，合并物理相邻高地址空闲 chunk（除了 top chunk）

（4）realloc

前向扩展，合并物理相邻高地址空闲 chunk（除了 top chunk）

由于 unlink 使用非常频繁，因此 unlink 被实现了一个宏：

/* Take a chunk off a bin list */
    // unlink p
    #define unlink(AV, P, BK, FD) { \ // 由于 P 已经在双向链表中，所以有两个地方记录其大小，所以检查一下其大小是否一致。
        if (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0))      \
          malloc_printerr ("corrupted size vs. prev_size");               \
        FD = P->fd;                                                                      \
        BK = P->bk;                                                                      \
        // 防止攻击者简单篡改空闲的 chunk 的 fd 与 bk 来实现任意写的效果。
        if (__builtin_expect (FD->bk != P || BK->fd != P, 0))                      \
          malloc_printerr (check_action, "corrupted double-linked list", P, AV);  \
        else {                                                                       \
            FD->bk = BK;                                                              \
            BK->fd = FD;                                                              \
            // 下面主要考虑 P 对应的 nextsize 双向链表的修改
            if (!in_smallbin_range (chunksize_nomask (P))                              \
                // 如果P->fd_nextsize为 NULL，表明 P 未插入到 nextsize 链表中。
                // 那么其实也就没有必要对 nextsize 字段进行修改了。
                // 这里没有去判断 bk_nextsize 字段，可能会出问题。
                && __builtin_expect (P->fd_nextsize != NULL, 0)) {                       \
                // 类似于小的 chunk 的检查思路
                if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0)              \
                    || __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0))    \
                  malloc_printerr (check_action,                                      \
                                   "corrupted double-linked list (not small)",    \
                                   P, AV);                                              \
                // 这里说明 P 已经在 nextsize 链表中了。
                // 如果 FD 没有在 nextsize 链表中
                if (FD->fd_nextsize == NULL) {                                       \
                    // 如果 nextsize 串起来的双链表只有 P 本身，那就直接拿走 P
                    // 令 FD 为 nextsize 串起来的
                    if (P->fd_nextsize == P)                                      \
                      FD->fd_nextsize = FD->bk_nextsize = FD;                      \
                    else {                                                               \
                    // 否则我们需要将 FD 插入到 nextsize 形成的双链表中
                        FD->fd_nextsize = P->fd_nextsize;                              \
                        FD->bk_nextsize = P->bk_nextsize;                              \
                        P->fd_nextsize->bk_nextsize = FD;                              \
                        P->bk_nextsize->fd_nextsize = FD;                              \
                      }                                                              \
                  } else {                                                               \
                    // 如果在的话，直接拿走即可
                    P->fd_nextsize->bk_nextsize = P->bk_nextsize;                      \
                    P->bk_nextsize->fd_nextsize = P->fd_nextsize;                      \
                  }                                                                      \
              }                                                                      \
          }                                                                              \
    }

这里以 small bin 的 unlink 为例子介绍一下，对于 large bin 的 unlink, 与其类似，只是多个 nextsize的处理。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1NzI3ODA5_size_16_color_FFFFFF_t_70]  
可以看出：P最后的fd 和 bk 指针并没有发生变化。但是当我们去遍历整个双向链表时，已经遍历不到对应的链表了。  
这一点没有变化还是有用处的，因为我们有时候可以使用这个方法来泄露地址：

1.  libc 地址  
    P 位于双向链表头部，bk 泄露  
    P 位于双向链表尾部，fd 泄露  
    双向链表只包含一个空闲 chunk 时，P 位于双向链表中，fd 和 bk 均可泄露
2.  堆地址，双向链表包含多个空闲 chunk  
    P 位于双向链表头部，fd 泄露  
    P 位于双向链表中，fd 和 bk 均可泄露  
    P 位于双向链表尾部，bk 泄露

注意：  
这里的头部指的是 bin 的 fd 指向的 chunk, 即双向链表中最新加入的 chunk  
这里的尾部指的是 bin 的 bk 指向的 chunk, 即双向链表中最先加入的 chunk

同时，无论是 fd bk 还是 fd\_nextsize, bk\_nextsize，程序都会检测 fd 和 bk 是否满足对应的要求

// fd bk
    if (__builtin_expect (FD->bk != P || BK->fd != P, 0))                      \
      malloc_printerr (check_action, "corrupted double-linked list", P, AV);  \
    
      // next_size related
                  if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0)              \
                    || __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0))    \
                  malloc_printerr (check_action,                                      \
                                   "corrupted double-linked list (not small)",    \
                                   P, AV);

注意：  
堆的第一个 chunk 所记录的 prev\_inuse 位默认为1.

## malloc\_printerr ##

当 glibc malloc 检测到错误时，会调用 malloc\_printerr 函数

static void malloc_printerr(const char *str) { 
      __libc_message(do_abort, "%s\n", str);
      __builtin_unreachable();
    }

主要会调用 \_\_libc\_message 来执行 abort 函数，如下：

if ((action & do_abort)) { 
        if ((action & do_backtrace))
          BEFORE_ABORT(do_abort, written, fd);
    
        /* Kill the application. */
        abort();
      }

在 abort 函数中，在 glic 还是 2.23 版本时，会 fflush stream.

/* Flush all streams. We cannot close them now because the user might have registered a handler for SIGABRT. */
      if (stage == 1)
        { 
          ++stage;
          fflush (NULL);
        }

[https_ctf-wiki.github.io_ctf-wiki_pwn_linux_glibc-heap_implementation_basic-zh_comments]: https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/implementation/basic-zh/#__comments
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1NzI3ODA5_size_16_color_FFFFFF_t_70]: /images/20220110/1517723820e94672887434676a7f6817.png