CSAPP Lab2 Note

Tip

CASPP 的 LAB 放在 Lab Assignments 上，在“Self-Study Handout”出下载对应 LAB 的资源。

课程 Lab 说明：“二进制炸弹”是一个提供给学生的可执行文件。运行时，它会提示用户输入 6 个不同的字符串。如果这些字符串中有任何一个不正确，炸弹就会“爆炸”并打印错误信息。学生必须通过反汇编和逆向自己的炸弹来确定这 6 个字符串应该是什么。这个实验让学生理解汇编语言，并强迫他们学习如何使用调试器（GDB）。这是一个你可以自己尝试的 Linux/x86-64 二进制炸弹。

我们选择的是“自学”模块，没有远程服务端检查和扣分机制，可以随意调试。但是，CMU 的同学就会有这些机制，输错了就扣分，所以需要小心调试。

解压 tar 包，得到三个文件 bomb、bomb.c 和一个 README，README 只说了这是一个 x86-64 程序。

`bomb.c` 解读#

bomb.c 应该就是 bomb 的主代码了。

代码引入了两个自定义库 support.h 和 phases.h，也就是说我们想要的字符串必须从程序中得到。

然后是命令行参数要求，总结如下：

bomb：标准的按行输入
bomb <file>：先从 <file> 中读取输入，结束后再转到标准输入
不可提供更多命令行参数，否则打印用法

然后就是打印提示信息并要求输入了。整个代码解读完毕，现在转向程序。

`bomb` 逆向 - GDB#

在 Linux 上使用包管理器安装 GDB，使用 gdb bomb 开始调试

基本操作：

`bomb` 逆向 - IDA#

这个 Lab 是需要在 Linux 环境下运行的，不过我们在 Windows 上，所以先用 IDA 分析一下。这里可以用 bomb.c 修复一下函数参数表，有些参数是没有用的：

1
int __fastcall main(int argc, const char **argv)
2
{
3
  const char *line; // rax
4
  const char *v3; // rax
5
  const char *v4; // rax
6
  const char *v5; // rax
7
  const char *v6; // rax
8
  const char *v7; // rax
9

10
  if ( argc == 1 )
11
  {
12
    infile = (FILE *)stdin;
13
  }
14
  else
15
  {
16
    if ( argc != 2 )
17
    {
18
      __printf_chk(1, "Usage: %s [<input_file>]\n", *argv);
19
      exit(8);
20
    }
21
    infile = fopen(argv[1], "r");
22
    if ( !infile )
23
    {
24
      __printf_chk(1, "%s: Error: Couldn't open %s\n", *argv, argv[1]);
25
      exit(8);
26
    }
27
  }
28
  initialize_bomb();
29
  puts("Welcome to my fiendish little bomb. You have 6 phases with");
30
  puts("which to blow yourself up. Have a nice day!");
31
  line = read_line();
32
  phase_1(line);
33
  phase_defused();
34
  puts("Phase 1 defused. How about the next one?");
35
  v3 = read_line();
36
  phase_2(v3);
37
  phase_defused();
38
  puts("That's number 2.  Keep going!");
39
  v4 = read_line();
40
  phase_3(v4);
41
  phase_defused();
42
  puts("Halfway there!");
43
  v5 = read_line();
44
  phase_4(v5);
45
  phase_defused();
46
  puts("So you got that one.  Try this one.");
47
  v6 = read_line();
48
  phase_5((__int64)v6);
49
  phase_defused();
50
  puts("Good work!  On to the next...");
51
  v7 = read_line();
52
  phase_6(v7);
53
  phase_defused();
54
  return 0;
55
}

Phase1#

先来看 Phase1，点进 phase_1(line)，即可得到内容：

1
result = strings_not_equal(line, "Border relations with Canada have never been better.");

Phase1 就是 Border relations with Canada have never been better.。

Phase2#

接下来是 Phase2。有了 Phase1 的经验，我们点开 phase_2(v5)：

1
__int64 __fastcall phase_2(__int64 a1)
2
{
3
  __int64 result; // rax
4
  char *v2; // rbx
5
  int v3; // [rsp+0h] [rbp-38h] BYREF
6
  char v4; // [rsp+4h] [rbp-34h] BYREF
7
  char v5; // [rsp+18h] [rbp-20h] BYREF
8

9
  read_six_numbers(a1, &v3);
10
  if ( v3 != 1 )
11
    explode_bomb();
12
  v2 = &v4;
13
  do
14
  {
15
    result = (unsigned int)(2 * *((_DWORD *)v2 - 1));
16
    if ( *(_DWORD *)v2 != (_DWORD)result )
17
      explode_bomb();
18
    v2 += 4;
19
  }
20
  while ( v2 != &v5 );
21
  return result;
22
}

先看第一个读取函数 read_six_numbers(a1, &v3)：

1
__int64 __fastcall read_six_numbers(__int64 a1, __int64 a2)
2
{
3
  __int64 n5; // rax
4

5
  n5 = __isoc99_sscanf(a1, "%d %d %d %d %d %d", a2, a2 + 4, a2 + 1, a2 + 12, a2 + 2, a2 + 20);
6
  if ( (int)n5 <= 5 )
7
    explode_bomb();
8
  return n5;
9
}

核心就是 __isoc99_sscanf。查询函数定义¹可知，这里是从我们输入的 Phase2 中读取格式化的“%d %d %d %d %d %d”并写入 v3[i]。

我们可以在这里修复一下函数定义，修复后的 phase_2(v5)：

1
int __fastcall phase_2(const char *a1)
2
{
3
  int result; // eax
4
  int *v2; // rbx
5
  int v3[6]; // [rsp+0h] [rbp-38h] BYREF
6
  int v4; // [rsp+18h] [rbp-20h] BYREF
7

8
  read_six_numbers(a1, v3);
9
  if ( v3[0] != 1 )
10
    explode_bomb();
11
  v2 = &v3[1];
12
  do
13
  {
14
    result = 2 * *(v2 - 1);
15
    if ( *v2 != result )
16
      explode_bomb();
17
    ++v2;
18
  }
19
  while ( v2 != &v4 );
20
  return result;
21
}

可以知道，v3[0] ，即第一个输入值必然是 1。v2 对应第二个输入值的地址。

然后进入一个 do-while 循环，循环条件是 v2 不等于 v4 的地址。

循环体的逻辑是计算 2 * v2[i-1] 的值，然后和 v2[i] 进行比较。如果不相等，就引爆炸弹。然后移动到下一个元素。

v4 和我们的输入无关且分配内存时接在 v3 之后，基于内存连续性，我们认为数组 v3 结束于地址 v4。

v3 应当是一个初始值为 1，公比为 2 的等比数列，即 1, 2, 4, 8, 16, 32

Phase2 就是 1 2 4 8 16 32

Phase3#

1
  if ( (int)__isoc99_sscanf(a1, "%d %d", &v2, &n207_1) <= 1 )
2
    explode_bomb();
3
  switch ( v2 )
4
  {
5
    case 0:
6
      n207 = 207;
7
      break;
8
    case 1:
9
      n207 = 311;
10
      break;
11
    case 2:
12
      n207 = 707;
13
      break;
14
    case 3:
15
      n207 = 256;
16
      break;
17
    case 4:
18
      n207 = 389;
19
      break;
20
    case 5:
21
      n207 = 206;
22
      break;
23
    case 6:
24
      n207 = 682;
25
      break;
26
    case 7:
27
      n207 = 327;
28
      break;
29
    default:
30
      explode_bomb();
31
  }
32
  if ( (_DWORD)n207 != n207_1 )
33
    explode_bomb();
34
  return n207;
35
}

要求输入的数值对符合 switch-case 定义的 8 种情况，否则炸弹爆炸。

一个合法的 Phase3 示例为 0 207

Phase4#

1
  if ( (unsigned int)__isoc99_sscanf(a1, "%d %d", &n0xE, &v3) != 2 || n0xE > 14 )
2
    explode_bomb();
3
  result = func4(n0xE, 0, 14);
4
  if ( (_DWORD)result || v3 )                   // v3 = 0
5
    explode_bomb();
6
  return result;

输入的数值对中，第一个输入的值不能大于 14，第二个值必须为 0。

result，即 func 的返回值必须为 0。

1
__int64 __fastcall func4(signed int n0xE, __int64 a2, int n14)
2
{
3
  signed int _0xE_1___7; // ecx
4
  __int64 result; // rax
5

6
  _0xE_1___7 = (n14 - (int)a2) / 2 + a2;        // 0xE_1 = 7
7
  if ( _0xE_1___7 > n0xE )
8
    return 2 * (unsigned int)func4(n0xE, a2, _0xE_1___7 - 1);
9
  result = 0;
10
  if ( _0xE_1___7 < n0xE )
11
    return 2 * (unsigned int)func4(n0xE, (unsigned int)(_0xE_1___7 + 1), n14) + 1;
12
  return result;
13
}

函数的核心逻辑：

计算中点：_0xE_1___7 = (n14 - a2) / 2 + a2，即区间 [a2, n14] 的中间值
如果中点 > 目标值：递归搜索左半区间 [a2, mid-1]，返回值乘以 2
如果中点 < 目标值：递归搜索右半区间 [mid+1, n14]，返回值乘以 2 再加 1
如果中点 == 目标值：返回 0

由于返回值要求 0，因此我们的目标值就需要一次等于计算出来的中点，即 7。

Phase4 为 7 0

Phase5#

1
unsigned __int64 __fastcall phase_5(const char *line)
2
{
3
  __int64 i; // rax
4
  char line_; // [rsp+10h] [rbp-18h] BYREF
5
  char v4; // [rsp+16h] [rbp-12h]
6
  unsigned __int64 v5; // [rsp+18h] [rbp-10h]
7

8
  v5 = __readfsqword(0x28u);
9
  if ( (unsigned int)string_length(line) != 6 )
10
    explode_bomb();
11
  for ( i = 0; i != 6; ++i )
12
    *(&line_ + i) = array_3449[line[i] & 0xF];
13
  v4 = 0;
14
  if ( (unsigned int)strings_not_equal(&line_, "flyers") )
15
    explode_bomb();
16
  return __readfsqword(0x28u) ^ v5;
17
}

需要输入长度为 6 的字符串。每个字符和 0xF 相与后在 array_3449 寻找对应下标字符，再回写。最终字符串要等于 flyers

array_3449: maduiersnfotvbyl

Phase5 为 9?>567

Phase6#

1
__int64 __fastcall phase_6(const char *a1)
2
{
3
  int *filted_input_1; // r13
4
  int n5_2; // r12d
5
  int n5; // ebx
6
  int *filted_input_2; // rax
7
  unsigned __int64 i; // rsi
8
  _QWORD *p_node1; // rdx
9
  int v7; // eax
10
  int v8; // ecx
11
  __int64 j_3; // rbx
12
  char *v10; // rax
13
  __int64 j; // rcx
14
  __int64 j_2; // rdx
15
  int n5_1; // ebp
16
  __int64 result; // rax
17
  int filted_input[6]; // [rsp+0h] [rbp-78h] BYREF
18
  char v16; // [rsp+18h] [rbp-60h] BYREF
19
  __int64 j_1; // [rsp+20h] [rbp-58h]
20
  char v18; // [rsp+28h] [rbp-50h] BYREF
21
  char v19; // [rsp+50h] [rbp-28h] BYREF
22

23
  filted_input_1 = filted_input;
24
  read_six_numbers(a1, filted_input);
25
  n5_2 = 0;
26
  while ( 1 )
27
  {
28
    if ( (unsigned int)(*filted_input_1 - 1) > 5 )// if(filted_input[i] > 6)
29
      explode_bomb();
30
    if ( ++n5_2 == 6 )
31
      break;
32
    n5 = n5_2;
33
    do
34
    {
35
      if ( *filted_input_1 == filted_input[n5] )// the input should be diff from each other
36
        explode_bomb();
37
      ++n5;
38
    }
39
    while ( n5 <= 5 );
40
    ++filted_input_1;
41
  }
42
  filted_input_2 = filted_input;
43
  do
44
  {
45
    *filted_input_2 = 7 - *filted_input_2;      // f_input[i] = 7 - f_input[i]
46
    ++filted_input_2;
47
  }
48
  while ( filted_input_2 != (int *)&v16 );
49
  for ( i = 0; i != 24; i += 4LL )
50
  {
51
    v8 = filted_input[i / 4];
52
    if ( v8 <= 1 )
53
    {
54
      p_node1 = &node1;
55
    }
56
    else
57
    {
58
      v7 = 1;
59
      p_node1 = &node1;
60
      do
61
      {
62
        p_node1 = (_QWORD *)p_node1[1];
63
        ++v7;
64
      }
65
      while ( v7 != v8 );
66
    }
67
    *(__int64 *)((char *)&j_1 + 2 * i) = (__int64)p_node1;
68
  }
69
  j_3 = j_1;
70
  v10 = &v18;
71
  for ( j = j_1; ; j = j_2 )
72
  {
73
    j_2 = *(_QWORD *)v10;
74
    *(_QWORD *)(j + 8) = *(_QWORD *)v10;
75
    v10 += 8;
76
    if ( v10 == &v19 )
77
      break;
78
  }
79
  *(_QWORD *)(j_2 + 8) = 0;
80
  n5_1 = 5;
81
  do
82
  {
83
    result = **(unsigned int **)(j_3 + 8);
84
    if ( *(_DWORD *)j_3 < (int)result )
85
      explode_bomb();
86
    j_3 = *(_QWORD *)(j_3 + 8);
87
    --n5_1;
88
  }
89
  while ( n5_1 );
90
  return result;
91
}

首先，需要输入 6 个数字，每个数字都不相同，且在 1~6 之间（无符号数，小于 1 就溢出了）。

然后对输入进行变换，将每个数字 x 替换为 7 - x，即原来的 1~~6 变成 6~~1。

根据变换后的输入选择 node<x>，再将 node<x> 链接成一个链表，检查此链表的节点值是否按降序排序。如果按降序排序，那么原始输入就是合法的。

node 结构大概是：

1
struct node {
2
    int value;
3
    int id;
4
    struct node *next;
5
};

我们可以通过查看内存布局得到各个 node 的具体数据。

排序后发现降序顺序为：node3 → node4 → node5 → node6 → node1 → node2

对应的 id 为：3 4 5 6 1 2

Phase6 为 4 3 2 1 6 5

Secret Phase#

C 库函数 int sscanf ↩

音乐

`bomb.c` 解读#

`bomb` 逆向 - GDB#

`bomb` 逆向 - IDA#

Phase1#

Phase2#

Phase3#

Phase4#

Phase5#

Phase6#

Secret Phase#

文章分享

评论区

bomb.c 解读#

bomb 逆向 - GDB#

bomb 逆向 - IDA#

Phase1#

Phase2#

Phase3#

Phase4#

Phase5#

Phase6#

Secret Phase#

Footnotes#

文章分享

评论区

`bomb.c` 解读#

`bomb` 逆向 - GDB#

`bomb` 逆向 - IDA#