通过 glibc2.25 学习 unsorted bin

前言：那再进步一点点。。。

0X00 通过 how2heap 学习原理

#include 
#include 

int main(){
    fprintf(stderr, "This file demonstrates unsorted bin attack by write a large unsigned long value into stack\n");
    fprintf(stderr, "In practice, unsorted bin attack is generally prepared for further attacks, such as rewriting the "
           "global variable global_max_fast in libc for further fastbin attack\n\n");

    unsigned long stack_var=0;
    fprintf(stderr, "Let's first look at the target we want to rewrite on stack:\n");
    fprintf(stderr, "%p: %ld\n\n", &stack_var, stack_var);

    unsigned long *p=malloc(400);
    fprintf(stderr, "Now, we allocate first normal chunk on the heap at: %p\n",p);
    fprintf(stderr, "And allocate another normal chunk in order to avoid consolidating the top chunk with"
           "the first one during the free()\n\n");
    malloc(500);

    free(p);
    fprintf(stderr, "We free the first chunk now and it will be inserted in the unsorted bin with its bk pointer "
           "point to %p\n",(void*)p[1]);

    //------------VULNERABILITY-----------

    p[1]=(unsigned long)(&stack_var-2);
    fprintf(stderr, "Now emulating a vulnerability that can overwrite the victim->bk pointer\n");
    fprintf(stderr, "And we write it with the target address-16 (in 32-bits machine, it should be target address-8):%p\n\n",(void*)p[1]);

    //------------------------------------

    malloc(400);
    fprintf(stderr, "Let's malloc again to get the chunk we just free. During this time, the target should have already been "
           "rewritten:\n");
    fprintf(stderr, "%p: %p\n", &stack_var, (void*)stack_var);
}

用一张图解释一下发生了什么，图片来自 CTF WIKI

简单来说通过伪造最后一个 chunk 的 bk，来达到改写的目的。

以下内容摘自 CTF WIKI：

unsorted bin 中的 chunk 有两种基本来源：

• 当分割一块比较大的 chunk 的时候，（特殊的 chunk 除外）如果剩下的 chunk 大于 MINISIZE（64 位是 32 Byte），就会放在 unsorted bin 中
• 释放一个不属于 fastbin 的 chunk，如果不和 top chunk 紧邻，就会放在 unsorted bin 中

unsorted bin 中的 chunk 有两种基本去处：

• 空闲的 chunk 从头部进，从链表尾部拿出 chunk
• 还可以把 unsorted bin 看成 small bin 和 large bin 的缓存，在寻找 chunk 的时候，如果 fastbin 里面没有合适的 chunk，就会去 unsorted bin 里面去寻找 chunk，如果 unsorted bin 里面没有，就会把 unsorted bin 里面的 chunk，放回到 small bin large bin 中

0X01 通过调试学习防护机制

通过 glibc 2.25 我们来学习一下 unsorted bin 的创建需要哪些检查，建议跟着一起调试：

pwngdb 走起：

// gcc unsorted.c -o unsorted -g
// patchelf --set-interpreter /home/tenshine/all_glibc/glibc-2.25/64/lib/ld-2.25.so unsorted
// gdb unsorted 
#include 
#include 

int main() {
    
    void* p = malloc(0x80);
    malloc(0x20);
    void* p1 = malloc(0x100);
    malloc(0x20);

    free(p);
    free(p1);

    malloc(0x100);
    return 0;
}

这里我们暂时只分析相同大小的 unsorted bin 分配，等我学完了大部分的攻击，我们再继续深入。

我们直接进入最后一个 malloc

来看看，现在 unsorted bin 的情况：

现在有两个 unsorted bin chunk，箭头的意思是 fd。unsorted bin 是一个循环双向链表。它的头地址在 main_arena+88 的位置，这个位置的 bk 指向最后一个 chunk。

我们继续进入 __libc_malloc 再进入 _int_malloc：

顺着走下来，我们走到一个循环：

在这个循环中，我们开始从最后一个 unsorted bin 开始选择合适的 chunk

while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))

这个循环中，victim 被赋值最后一个 chunk 的地址

我们迎来了第一个检查：

大致意思是，这最后一个 chunk 的 size 不能比 2 × SIZE_SZ 要小，也不能比该分配区分配的内存要大。

好我们继续

这个 if 在我们这个情况下可以不用看，跳过。上面的注释写得很清楚。

注意看这里，glibc 直接把 victim 从链表中拿出来了。但是！并不知道是不是满足分配的大小，而我们知道，这个 chunk 的 size 是不满足的。

我们看看现在的 unsorted chunk：

那么这个 chunk 放到哪里了呢？放到了 small bin 或者 large bin 中了。并把那个 bin 标记有空闲的 chunk

到第二次循环，我们直接进入：

然后就可以把它分配出来了。

0X02 总结

总结一下：

在 glibc2.25 中如果能够控制最后一个 chunk 的 bk，在 0X00 中我们正是修改了最后一个 chunk 的 bk，导致 bck 指向的不是 main_arena+88，而是其他位置（被计算好的），通过修改 bck->fd 来修改想改的值。

unsorted_chunks (av)->bk = bck;
bck->fd = unsorted_chunks (av);

完结撒花。。。