出题人的 “恶意”

在做 BUUCTF 上的 [2019 红帽杯] easyRE 时，出题人将我引导进了一篇看雪的文章：[原创] 看雪 CTF 从入门到存活（六）主动防御。由于时过境迁，评论区已经给出了正确的 flag，但在 2019 年的评论中，我们依然能体会到当时参赛者们满头问号的感受。这样一篇高视角的理论文章，到底对解题有多大作用呢？

实际上，出题人就是以该文章的理念设计了这么一道题目。

什么是 “主动防御”

在初期我们做的 CTF 题目中，出题人都是将 flag 获取逻辑放在一个函数中，然后设置障碍，我们称为 “被动防御”。虽然这些障碍可能难以跨越，但参赛者心中都有一条明确的思路：只要越过这些障碍，就能得到 flag。

与之相对的 “主动防御”，是指将参赛者引导到一条无法获取正确 flag 的路径。这条路径同样有一些障碍，参赛者往往会错判预期，认为只需要跨过这些障碍，就可以得到 flag，结果却折服于出题人的小巧思。

主动防御基于过程激励理论，该理论又有三大理论：期望理论、公平理论和强化理论。总结起来就是让参赛者认为 “此路可通” 并不断强化这种信念。

这本身需要出题人有一定水平，可以合理安排真假线索。

示例

我们先从头分析开头的题目。下面的伪代码已经经过我的修改：

__int64 sub_4009C6()
{
  __int64 result; // rax
  int i; // [rsp+Ch] [rbp-114h]
  __int64 v2; // [rsp+10h] [rbp-110h]
  __int64 v3; // [rsp+18h] [rbp-108h]
  __int64 v4; // [rsp+20h] [rbp-100h]
  __int64 v5; // [rsp+28h] [rbp-F8h]
  __int64 v6; // [rsp+30h] [rbp-F0h]
  __int64 v7; // [rsp+38h] [rbp-E8h]
  __int64 v8; // [rsp+40h] [rbp-E0h]
  __int64 v9; // [rsp+48h] [rbp-D8h]
  __int64 v10; // [rsp+50h] [rbp-D0h]
  __int64 v11; // [rsp+58h] [rbp-C8h]
  _BYTE key[13]; // [rsp+60h] [rbp-C0h] BYREF
  _BYTE key1[4]; // [rsp+6Dh] [rbp-B3h] BYREF
  _BYTE key2[19]; // [rsp+71h] [rbp-AFh] BYREF
  _QWORD buf[5]; // [rsp+90h] [rbp-90h] BYREF
  _QWORD buf_1[8]; // [rsp+C0h] [rbp-60h] BYREF
  char v17; // [rsp+100h] [rbp-20h]
  unsigned __int64 v18; // [rsp+108h] [rbp-18h]

  v18 = __readfsqword(0x28u);
  qmemcpy(key, "Iodl>Qnb(ocy", 12);
  key[12] = 127;
  qmemcpy(key1, "y.i", 3);
  key1[3] = 127;
  qmemcpy(key2, "d`3w}wek9{iy=~yL@EC", sizeof(key2));
  memset(buf, 0, 37);
  bufRead(0, buf, 37);
  BYTE4(buf[4]) = 0;
  if ( bufLength(buf) == 36 )
  {
    for ( i = 0; i < bufLength(buf); ++i )
    {
      if ( (*(buf + i) ^ i) != key[i] )         // key = key + key1 + key2
      {
        result = 4294967294LL;
        goto LABEL_13;
      }
    }
    puts("continue!");
    memset(buf_1, 0, sizeof(buf_1));
    v17 = 0;
    bufRead(0, buf_1, 64);
    HIBYTE(buf_1[4]) = 0;
    if ( bufLength(buf_1) == 39 )
    {
      v2 = base64Encode(buf_1);
      v3 = base64Encode(v2);
      v4 = base64Encode(v3);
      v5 = base64Encode(v4);
      v6 = base64Encode(v5);
      v7 = base64Encode(v6);
      v8 = base64Encode(v7);
      v9 = base64Encode(v8);
      v10 = base64Encode(v9);
      v11 = base64Encode(v10);
      if ( !flagCmp(v11, fakeFlag) )
      /*
      fakeFlag = "Vm0wd2VHUXhTWGhpUm1SWVYwZDRWVll3Wkc5WFJsbDNXa1pPVlUxV2NIcFhhMk0xVmpKS1NHVkdXbFpOYmtKVVZtcEtTMUl5VGtsaVJtUk9ZV3hhZVZadGVHdFRNVTVYVW01T2FGSnRVbGhhVjNoaFZWWmtWMXBFVWxSTmJFcElWbTAxVDJGV1NuTlhia0pXWWxob1dGUnJXbXRXTVZaeVdrWm9hVlpyV1hwV1IzaGhXVmRHVjFOdVVsWmlhMHBZV1ZSR1lWZEdVbFZTYlhSWFRWWndNRlZ0TVc5VWJGcFZWbXR3VjJKSFVYZFdha1pXWlZaT2NtRkhhRk5pVjJoWVYxZDBhMVV3TlhOalJscFlZbGhTY1ZsclduZGxiR1J5VmxSR1ZXSlZjRWhaTUZKaFZqSktWVkZZYUZkV1JWcFlWV3BHYTFkWFRrZFRiV3hvVFVoQ1dsWXhaRFJpTWtsM1RVaG9hbEpYYUhOVmJUVkRZekZhY1ZKcmRGTk5Wa3A2VjJ0U1ExWlhTbFpqUldoYVRVWndkbFpxUmtwbGJVWklZVVprYUdFeGNHOVhXSEJIWkRGS2RGSnJhR2hTYXpWdlZGVm9RMlJzV25STldHUlZUVlpXTlZadE5VOVdiVXBJVld4c1dtSllUWGhXTUZwell6RmFkRkpzVWxOaVNFSktWa1phVTFFeFduUlRhMlJxVWxad1YxWnRlRXRXTVZaSFVsUnNVVlZVTURrPQ=="
      */
      {
        puts("You found me!!!");
        puts("bye bye~");
      }
      result = 0;
    }
    else
    {
      result = 4294967293LL;
    }
  }
  else
  {
    result = 0xFFFFFFFFLL;
  }
LABEL_13:
  if ( __readfsqword(0x28u) != v18 )
    StackErrorexit();
  return result;
}

对 fakeFlag 进行十次 Base64 解码会得到我们所说的网址。但不是我们想要的 flag。

然而，在 fakeFlag 的下方，还有一串没有被使用的常量：

.data:00000000006CC0A0     ; char byte_6CC0A0[3]
.data:00000000006CC0A0     byte_6CC0A0     db 40h                  ; DATA XREF: sub_400D35+95↑r
.data:00000000006CC0A0                                             ; sub_400D35+C1↑r
.data:00000000006CC0A1                     db  35h ; 5
.data:00000000006CC0A2                     db  20h
.data:00000000006CC0A3     byte_6CC0A3     db 56h                  ; DATA XREF: sub_400D35+A6↑r
.data:00000000006CC0A4                     db  5Dh ; ]
.data:00000000006CC0A5                     db  18h
.data:00000000006CC0A6                     db  22h ; "
.data:00000000006CC0A7                     db  45h ; E
.data:00000000006CC0A8                     db  17h
.data:00000000006CC0A9                     db  2Fh ; /
.data:00000000006CC0AA                     db  24h ; $
.data:00000000006CC0AB                     db  6Eh ; n
.data:00000000006CC0AC                     db  62h ; b
.data:00000000006CC0AD                     db  3Ch ; <
.data:00000000006CC0AE                     db  27h ; '
.data:00000000006CC0AF                     db  54h ; T
.data:00000000006CC0B0                     db  48h ; H
.data:00000000006CC0B1                     db  6Ch ; l
.data:00000000006CC0B2                     db  24h ; $
.data:00000000006CC0B3                     db  6Eh ; n
.data:00000000006CC0B4                     db  72h ; r
.data:00000000006CC0B5                     db  3Ch ; <
.data:00000000006CC0B6                     db  32h ; 2
.data:00000000006CC0B7                     db  45h ; E
.data:00000000006CC0B8                     db  5Bh ; [
.data:00000000006CC0B9                     db    0

通过查询 byte_6CC0A0 的交叉引用，我们发现它被函数 sub_400D35() 使用了。分析该函数会发现 byte_6CC0A3 其实也属于 byte_6CC0A0，于是进行修复，得到最终的函数：

sub_400D35()

unsigned __int64 __fastcall sub_400D35(__int64 a1, __int64 a2)
{
  unsigned __int64 result; // rax
  unsigned int v3; // [rsp+Ch] [rbp-24h]
  int i; // [rsp+10h] [rbp-20h]
  int j; // [rsp+14h] [rbp-1Ch]
  unsigned int v6; // [rsp+24h] [rbp-Ch]
  unsigned __int64 v7; // [rsp+28h] [rbp-8h]

  v7 = __readfsqword(0x28u);
  v3 = sub_43FD20(0) - qword_6CEE38;
  for ( i = 0; i <= 1233; ++i )
  {
    sub_40F790(v3);
    sub_40FE60();
    sub_40FE60();
    v3 = sub_40FE60() ^ 0x98765432;
  }
  v6 = v3;
  if ( (v3 ^ realFlag[0]) == 'f' && (HIBYTE(v6) ^ realFlag[3]) == 'g' )
  {
    for ( j = 0; j <= 24; ++j )
      sub_410E90(realFlag[j] ^ *(&v6 + j % 4));
  }
  result = __readfsqword(0x28u) ^ v7;
  if ( result )
    StackErrorexit();
  return result;
}

循环 1 生成随机值 v3，然后赋值给 v6。接下来是一个判断，v3（取低位的 1 字节）和 realFlag 的第一个字符进行异或后等于 f 且 v6 取高位的 1 字节和 realFlag 的第四个字符进行异或后得到 g，则进入第 2 个循环，将 realFlag 和 v6 异或得到 flag。

因此我们需要得到符合条件的 v6。根据进入循环 2 的条件，我们可以将 flag 和 realFlag 的前四个元素进行异或，得到正确的 v6，然后用 v6 和 realFlag 异或得到 flag。

cipher = [0x40, 0x35, 0x20, 0x56, 0x5D, 0x18, 0x22, 0x45, 0x17, 0x2F, 0x24, 0x6E, 0x62, 0x3C, 0x27, 0x54, 0x48, 0x6C, 0x24, 0x6E, 0x72, 0x3C, 0x32, 0x45, 0x5B]
key = [0x40^ord('f'),0x35^ord('l'),0x20^ord('a'),0x56^ord('g')]
flag = ""
for i in range(len(cipher)):
    flag += chr(cipher[i]^(key[i%4]))
print(flag)
# flag{Act1ve_Defen5e_Test}

题做完了，不过我们还想看一下出题人是怎么把这个函数埋入程序执行流程中的。

查询 sub_400D35() 的交叉引用，会发现这个函数是存放于 .fini_array 中的。在程序启动流程中，main 函数返回之后便会执行 __libc_csu_fini() 函数，静态编译下该函数会按降序取出 .fini_array 中的函数指针并执行。

Note

_fini_array 是一个特殊的 ELF 符号数组，用于存储在程序或共享对象的终止（清理）阶段将要执行的终止函数的地址。运行时的链接器 / 加载器会在程序或共享对象终止时依次调用这些函数，以完成清理工作。_fini_array 是 ELF 文件中的一部分，属于特殊的节 (section) 之一。这些特殊节在程序执行过程中具有特定的目的和执行顺序。

在 C 程序中，可以通过 __attribute__((destructor)) 指定一个函数在程序退出时执行，这些函数的地址会被放入 .fini_array 中。例如：

#include <stdio.h>

void cleanup() __attribute__((destructor));

void cleanup() {
    printf("Program is exiting. Cleaning up resources...\n");
}

int main() {
    printf("Hello, World!\n");
    return 0;
}

这个题目属于 “可执行代码段中没有被显式 CALL 的函数”，是准确反汇编的主要障碍之一。^[1] 很显然，大量选手（包括我哈）都缺乏应对这类题的经验。在我~~耻辱下播~~查阅 WP 时，有相当数量的作者说自己没有想到这一点，只能参考别人的 WP。

Disassembly Challenges ↩︎