PWN unlink

最近做了一些堆的题，发现对unlink还是不太熟悉，所以回来做下笔记

unlink的目的：把一个双向链表中的空闲块拿出来，然后和目前物理相邻的 free chunk 进行合并。这实际上是对chunk的fd和bk指针的操作，fd_nextsize和bk_nextsize只有在chunk是large bins chunk时才会用到，而一般情况下很少用到。

unlink攻击的前提条件： 程序必须有个地方存储着malloc返回的地址，例如bss段中存放chunk地址的全局变量数组

unlink攻击的本质，是对fd和bk这两个指针的利用

FD = P->fd;                                                                     
BK = P->bk; 
FD->bk = BK;                                   
BK->fd = FD; 
因为unlink会有一个check,检查chunk的fd和bk是否被恶意修改了，所以要绕过这一check
FD和BK只能修改成特定的值，假设ptr上存储着P的地址
 (__builtin_expect (FD->bk != P || BK->fd != P, 0))
64位下
FD = ptr - 0x18
BK  = ptr- 0x10
unlink实际做了
*(ptr - 0x18 + 0x18) = ptr - 0x10
*(ptr - 0x10 - 0x10) = ptr - 0x18 #主要看这步
等价于
*ptr = ptr - 0x18

通过unlink攻击可以实现向任意地址写

PWN中的unlink 攻击主要分两种：

• 向前合并的unlink(这里的前是指高地址的chunk)
• 向后合并的unlink(这里的后是指低地址的chunk)
  这两者要构造的chunk有点不一样
  下面一律假设 free掉的chunk为P，存储着P地址的地址 为ptr

1. 向后合并
   源码：

  if (!prev_inuse(p)) {
      prevsize = prev_size (p);
      size += prevsize;
      p = chunk_at_offset(p, -((long) prevsize));
      unlink(av, p, bck, fwd);
    }

• 根据P的size字段的flag位，判断前一个chunk是否正在使用
• 如果前一个chunk是free状态，修改size大小
• 修改指向P的指针，改为指向前一个chunk
• 利用unlink将前一个chunk从bins链表中移除
  这里构造的话要在前一个chunk中伪造一个fake_chunk,fake_chunk的fd和bk指针要为特定值，同时通过存在的漏洞控制当前chunk的prev_size字段和size字段，使其prev_size的大小的fake_chunk的大小，size字段中的prev_inuse标志位为0
  构造的payload

#假设 前一个chunk的大小为0xa0, P的大小为0x90
64位的
fake_chunk = p64(0) + p64(0x90) + p64(ptr - 0x18) + p64(ptr - 0x10) 
fake_chunk = fake_chunk.ljust(0x90,'a')
32位的
fake_chunk = p32(0) + p32(0x90) + p32(ptr- 0x10) + p32(ptr - 0x8)
fake_chunk = fake_chunk.ljust(0x90,'a')

同时要修改P的prev_size为 0x90，size字段为0x90
最后free掉P就可以触发unlink了

---

2.向前合并
源码：

 if (nextchunk != av->top) {
      /* get and clear inuse bit */
      nextinuse = inuse_bit_at_offset(nextchunk, nextsize);/*这里检查下下个chunk的flag标志位*/
      /* consolidate forward */
      if (!nextinuse) {
        unlink(av, nextchunk, bck, fwd);
        size += nextsize;
      }
.......

#define inuse_bit_at_offset(p, s)\
  (((mchunkptr) (((char *) (p)) + (s)))->mchunk_size & PREV_INUSE)

• 检查下下个chunk的prev_inuse标志位
• 如果prev_inuse为0，就进行unlink，将P从链表中取出

• 然后修改P的size字段
  这里利用要构造的chunk和向后合并不一样，它要能控制P的下下个chunk的size字段

  
  image.png

上面的图是一个64位的简单的例子，chunk1已经设置好了fd和bk，此时只要free掉chunk0，就会检查是否可以向前合并，通过检查chunk0的下下个chunk的prev_inuse标志位，也就是chunk2的，这里chunk2的prev_ inuse已经被我设置为0了，这时就会进行向前合并，通过unlink宏将chunk1从链表中取出来。

大致的就是上面所说的，不过实际上会复杂很多。
下面贴上unlink源码
unlink源码：

#define unlink(AV, P, BK, FD) {                                            
    if (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0))    /*检查chunk的size字段*/
      malloc_printerr ("corrupted size vs. prev_size");                              
    FD = P->fd;                                                                     
    BK = P->bk;                                                                    
    if (__builtin_expect (FD->bk != P || BK->fd != P, 0))/*检查chunk的fd 和bk是否正确，这里也是unlink要绕过的地方*/                     
      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;                  
              }                                                                  
          }                                                                    
      }                                                                        
}