最近做了一些堆的題，發(fā)現(xiàn)對unlink還是不太熟悉，所以回來做下筆記

unlink的目的：把一個雙向鏈表中的空閑塊拿出來，然后和目前物理相鄰的 free chunk 進行合并。這實際上是對chunk的fd和bk指針的操作，fd_nextsize和bk_nextsize只有在chunk是large bins chunk時才會用到，而一般情況下很少用到。

unlink攻擊的前提條件： 程序必須有個地方存儲著malloc返回的地址，例如bss段中存放chunk地址的全局變量數(shù)組

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攻擊可以實現(xiàn)向任意地址寫

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狀態(tài)，修改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就可以觸發(fā)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;                  
              }                                                                  
          }                                                                    
      }                                                                        
}