CSAPP-Lab2-BombLab

bomblab的背景很有趣。Dr. Evil把“二进制炸弹”装在了教室的机子里。想要拆掉炸弹，你必须反编译“炸弹”，通过其中的汇编指令推测出可以拆掉炸弹的phrase。

phase1

1
2
3
4
5
6
7
8
9
0000000000400ee0 <phase_1>:
  400ee0:	48 83 ec 08          	sub    $0x8,%rsp
  400ee4:	be 00 24 40 00       	mov    $0x402400,%esi
  400ee9:	e8 4a 04 00 00       	callq  401338 <strings_not_equal>
  400eee:	85 c0                	test   %eax,%eax
  400ef0:	74 05                	je     400ef7 <phase_1+0x17>
  400ef2:	e8 43 05 00 00       	callq  40143a <explode_bomb>
  400ef7:	48 83 c4 08          	add    $0x8,%rsp
  400efb:	c3                   	retq

  • sub $0x8,%rsp

    rsp 存栈指针

    作用在于在堆栈上保留一些空间。 这可以用来给子例程的局部变量留一些空间。

​ 其实从第二行才正式开始：

  • mov $0x402400,%esi

    先把一个值，即字符串的地址放到esi寄存器中

    esi 普通的寄存器

  • 401338 <strings_not_equal>

    调用一个函数，判断这个函数的返回值

  • test %eax,%eax

    test做按位与操作，为零时不设置值，但是设置SF、ZF、和PF标志位，并将CF和OF的标志位清零。

    所以这里如果eax为0，则je跳转否则不跳，引爆炸弹

    1
    2
    3
    4
    5
    401338:	41 54                	push   %r12
    40133a:	55                   	push   %rbp
    40133b:	53                   	push   %rbx
    40133c:	48 89 fb             	mov    %rdi,%rbx
    40133f:	48 89 f5             	mov    %rsi,%rbp

    我们发现rsi存的就是上面的0x402400的字符串

    gdb调试 x/s 0x402400

    果然出现第一字符串：

    Border relations with Canada have never been better.

phase2

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
0000000000400efc <phase_2>:
  400efc:	55                   	push   %rbp
  400efd:	53                   	push   %rbx
  400efe:	48 83 ec 28          	sub    $0x28,%rsp
  400f02:	48 89 e6             	mov    %rsp,%rsi
  400f05:	e8 52 05 00 00       	callq  40145c <read_six_numbers>
  400f0a:	83 3c 24 01          	cmpl   $0x1,(%rsp)
  400f0e:	74 20                	je     400f30 <phase_2+0x34>
  400f10:	e8 25 05 00 00       	callq  40143a <explode_bomb>
  400f15:	eb 19                	jmp    400f30 <phase_2+0x34>
  400f17:	8b 43 fc             	mov    -0x4(%rbx),%eax
  400f1a:	01 c0                	add    %eax,%eax
  400f1c:	39 03                	cmp    %eax,(%rbx)
  400f1e:	74 05                	je     400f25 <phase_2+0x29>
  400f20:	e8 15 05 00 00       	callq  40143a <explode_bomb>
  400f25:	48 83 c3 04          	add    $0x4,%rbx
  400f29:	48 39 eb             	cmp    %rbp,%rbx
  400f2c:	75 e9                	jne    400f17 <phase_2+0x1b>
  400f2e:	eb 0c                	jmp    400f3c <phase_2+0x40>
  400f30:	48 8d 5c 24 04       	lea    0x4(%rsp),%rbx
  400f35:	48 8d 6c 24 18       	lea    0x18(%rsp),%rbp
  400f3a:	eb db                	jmp    400f17 <phase_2+0x1b>
  400f3c:	48 83 c4 28          	add    $0x28,%rsp
  400f40:	5b                   	pop    %rbx
  400f41:	5d                   	pop    %rbp
  400f42:	c3                   	retq

  • callq 40145c <read_six_numbers>

    这段汇编先读入六个数字（字面意思的函数名）

  • 观察这个函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    000000000040145c <read_six_numbers>:
      40145c:	48 83 ec 18          	sub    $0x18,%rsp
      401460:	48 89 f2             	mov    %rsi,%rdx
      401463:	48 8d 4e 04          	lea    0x4(%rsi),%rcx
      401467:	48 8d 46 14          	lea    0x14(%rsi),%rax
      40146b:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
      401470:	48 8d 46 10          	lea    0x10(%rsi),%rax
      401474:	48 89 04 24          	mov    %rax,(%rsp)
      401478:	4c 8d 4e 0c          	lea    0xc(%rsi),%r9
      40147c:	4c 8d 46 08          	lea    0x8(%rsi),%r8
      401480:	be c3 25 40 00       	mov    $0x4025c3,%esi
      401485:	b8 00 00 00 00       	mov    $0x0,%eax
      40148a:	e8 61 f7 ff ff       	callq  400bf0 <__isoc99_sscanf@plt>
      40148f:	83 f8 05             	cmp    $0x5,%eax
      401492:	7f 05                	jg     401499 <read_six_numbers+0x3d>
      401494:	e8 a1 ff ff ff       	callq  40143a <explode_bomb>
      401499:	48 83 c4 18          	add    $0x18,%rsp
      40149d:	c3                   	retq

    观察401480：将一个地址传给了esi

    返回值与5比较，如果返回值小于等于5就爆炸

  • cmpl $0x1,(%rsp)

    第一个元素的地址和1比较，所以第一个数是1

    跳转到17 循环处理输进去的数

    每次都是把前一个数存到eax中，然后翻倍，再跟当前数比较，如果相同跳转到25 后移四字节，如果没有到数组末尾就回去，即发现是一个等差数列1 2 4 8 16 32

    1 2 4 8 16 32

phase3

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
0000000000400f43 <phase_3>:
  400f43:	48 83 ec 18          	sub    $0x18,%rsp
  400f47:	48 8d 4c 24 0c       	lea    0xc(%rsp),%rcx
  400f4c:	48 8d 54 24 08       	lea    0x8(%rsp),%rdx
  400f51:	be cf 25 40 00       	mov    $0x4025cf,%esi
  400f56:	b8 00 00 00 00       	mov    $0x0,%eax
  400f5b:	e8 90 fc ff ff       	callq  400bf0 <__isoc99_sscanf@plt>
  400f60:	83 f8 01             	cmp    $0x1,%eax
  400f63:	7f 05                	jg     400f6a <phase_3+0x27>
  400f65:	e8 d0 04 00 00       	callq  40143a <explode_bomb>
  400f6a:	83 7c 24 08 07       	cmpl   $0x7,0x8(%rsp)
  400f6f:	77 3c                	ja     400fad <phase_3+0x6a>
  400f71:	8b 44 24 08          	mov    0x8(%rsp),%eax
  400f75:	ff 24 c5 70 24 40 00 	jmpq   *0x402470(,%rax,8)
  400f7c:	b8 cf 00 00 00       	mov    $0xcf,%eax
  400f81:	eb 3b                	jmp    400fbe <phase_3+0x7b>
  400f83:	b8 c3 02 00 00       	mov    $0x2c3,%eax
  400f88:	eb 34                	jmp    400fbe <phase_3+0x7b>
  400f8a:	b8 00 01 00 00       	mov    $0x100,%eax
  400f8f:	eb 2d                	jmp    400fbe <phase_3+0x7b>
  400f91:	b8 85 01 00 00       	mov    $0x185,%eax
  400f96:	eb 26                	jmp    400fbe <phase_3+0x7b>
  400f98:	b8 ce 00 00 00       	mov    $0xce,%eax
  400f9d:	eb 1f                	jmp    400fbe <phase_3+0x7b>
  400f9f:	b8 aa 02 00 00       	mov    $0x2aa,%eax
  400fa4:	eb 18                	jmp    400fbe <phase_3+0x7b>
  400fa6:	b8 47 01 00 00       	mov    $0x147,%eax
  400fab:	eb 11                	jmp    400fbe <phase_3+0x7b>
  400fad:	e8 88 04 00 00       	callq  40143a <explode_bomb>
  400fb2:	b8 00 00 00 00       	mov    $0x0,%eax
  400fb7:	eb 05                	jmp    400fbe <phase_3+0x7b>
  400fb9:	b8 37 01 00 00       	mov    $0x137,%eax
  400fbe:	3b 44 24 0c          	cmp    0xc(%rsp),%eax
  400fc2:	74 05                	je     400fc9 <phase_3+0x86>
  400fc4:	e8 71 04 00 00       	callq  40143a <explode_bomb>
  400fc9:	48 83 c4 18          	add    $0x18,%rsp
  400fcd:	c3                   	retq

  • 0x400f51 出现的 $0x4025cf 这个地址被保存到了%esi里，把它输出一下看看是什么

    (gdb) x/s 0x4025cf
    0x4025cf: “%d %d”

    我们要过关，就要输入两个整数

  • mov $0x0,%eax

    接下来回调 sscanf 之后函数返回值存在这个%eax里，然后又和 1 去比较,即输入大于一个参数炸弹才不会爆炸

  • ```text
    400f6a: 83 7c 24 08 07 cmpl $0x7,0x8(%rsp)
    400f6f: 77 3c ja 400fad
    400f71: 8b 44 24 08 mov 0x8(%rsp),%eax
    400f75: ff 24 c5 70 24 40 00 jmpq *0x402470(,%rax,8)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

    x86-64中，栈顶 %rsp 的前 8 位存的是函数的返回地址所在栈地址，从 8(%rsp)开始存第一个参数。为验证正确，试验一下，第一个参数输入1，寄存器该位确实是1，所以第一个数字为0-7

    第二个数观察后面的代码，发现间接跳转到0x402470存储的地址

    ```asmt
    (gdb) x /16 0x402470
    0x402470:       0x00400f7c      0x00000000      0x00400fb9      0x00000000
    0x402480:       0x00400f83      0x00000000      0x00400f8a      0x00000000
    0x402490:       0x00400f91      0x00000000      0x00400f98      0x00000000
    0x4024a0:       0x00400f9f      0x00000000      0x00400fa6      0x00000000

    可见当第一个参数为1时，第二个参数为0xcf即207

phase4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
40100c:	48 83 ec 18          	sub    $0x18,%rsp
401010:	48 8d 4c 24 0c       	lea    0xc(%rsp),%rcx
401015:	48 8d 54 24 08       	lea    0x8(%rsp),%rdx
40101a:	be cf 25 40 00       	mov    $0x4025cf,%esi
40101f:	b8 00 00 00 00       	mov    $0x0,%eax
401024:	e8 c7 fb ff ff       	callq  400bf0 <__isoc99_sscanf@plt>
401029:	83 f8 02             	cmp    $0x2,%eax
40102c:	75 07                	jne    401035 <phase_4+0x29>
40102e:	83 7c 24 08 0e       	cmpl   $0xe,0x8(%rsp)
401033:	76 05                	jbe    40103a <phase_4+0x2e>
401035:	e8 00 04 00 00       	callq  40143a <explode_bomb>
40103a:	ba 0e 00 00 00       	mov    $0xe,%edx
40103f:	be 00 00 00 00       	mov    $0x0,%esi
401044:	8b 7c 24 08          	mov    0x8(%rsp),%edi
401048:	e8 81 ff ff ff       	callq  400fce <func4>
40104d:	85 c0                	test   %eax,%eax
40104f:	75 07                	jne    401058 <phase_4+0x4c>
401051:	83 7c 24 0c 00       	cmpl   $0x0,0xc(%rsp)
401056:	74 05                	je     40105d <phase_4+0x51>
401058:	e8 dd 03 00 00       	callq  40143a <explode_bomb>
40105d:	48 83 c4 18          	add    $0x18,%rsp
401061:	c3                   	retq

跟上面一样，可以先分析出来，输入两个整数

%rsp + 8 是我们输入的第一个参数的地址，把第一个参数与 0xe 也就是 14 比较，要求我们的这个参数必须小于等于 14 否则就炸了。

在 func4 函数之前存了三个寄存器，先列在下面。

1
2
3
40103a:	ba 0e 00 00 00       	mov    $0xe,%edx
40103f:	be 00 00 00 00       	mov    $0x0,%esi
401044:	8b 7c 24 08          	mov    0x8(%rsp),%edi

这三个应该便是传进 func4 的参数，根据x86-64 传参规则，func4 的参数应该是

1
func_4 (x,0,14)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
0000000000400fce <func4>:
  400fce:	48 83 ec 08          	sub    $0x8,%rsp
  400fd2:	89 d0                	mov    %edx,%eax
  400fd4:	29 f0                	sub    %esi,%eax
  400fd6:	89 c1                	mov    %eax,%ecx
  400fd8:	c1 e9 1f             	shr    $0x1f,%ecx
  400fdb:	01 c8                	add    %ecx,%eax
  400fdd:	d1 f8                	sar    %eax
  400fdf:	8d 0c 30             	lea    (%rax,%rsi,1),%ecx
  400fe2:	39 f9                	cmp    %edi,%ecx
  400fe4:	7e 0c                	jle    400ff2 <func4+0x24>
  400fe6:	8d 51 ff             	lea    -0x1(%rcx),%edx
  400fe9:	e8 e0 ff ff ff       	callq  400fce <func4>
  400fee:	01 c0                	add    %eax,%eax
  400ff0:	eb 15                	jmp    401007 <func4+0x39>
  400ff2:	b8 00 00 00 00       	mov    $0x0,%eax
  400ff7:	39 f9                	cmp    %edi,%ecx
  400ff9:	7d 0c                	jge    401007 <func4+0x39>
  400ffb:	8d 71 01             	lea    0x1(%rcx),%esi
  400ffe:	e8 cb ff ff ff       	callq  400fce <func4>
  401003:	8d 44 00 01          	lea    0x1(%rax,%rax,1),%eax
  401007:	48 83 c4 08          	add    $0x8,%rsp
  40100b:	c3                   	retq  
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
int func4(int edi, int esi, int edx)
{
    int eax = edx;
    eax -= esi;
    int ecx = eax;
    ecx >>= 31;
    eax += ecx;
    eax >>= 1;
    ecx = eax + esi;
    if (ecx > edi)
    {
        edx = ecx - 1;
        eax = func4(edi, esi, edx);
        eax *= 2;
        return eax;
    }
    else
    {
        eax = 0;
        if(ecx < edi)
        {
            esi = ecx + 1;
            eax = func4(edi, esi, edx);
            eax = eax * 2 + 1;
            return eax;
        }
        else
            return eax;
    }
}

由此可见，输入为7即可，第二个直接填0就可以了

phase5

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
0000000000401062 <phase_5>:
  401062:	53                   	push   %rbx
  401063:	48 83 ec 20          	sub    $0x20,%rsp
  401067:	48 89 fb             	mov    %rdi,%rbx
  40106a:	64 48 8b 04 25 28 00 	mov    %fs:0x28,%rax
  401071:	00 00 
  401073:	48 89 44 24 18       	mov    %rax,0x18(%rsp)
  401078:	31 c0                	xor    %eax,%eax
  40107a:	e8 9c 02 00 00       	callq  40131b <string_length>
  40107f:	83 f8 06             	cmp    $0x6,%eax
  401082:	74 4e                	je     4010d2 <phase_5+0x70>
  401084:	e8 b1 03 00 00       	callq  40143a <explode_bomb>
  401089:	eb 47                	jmp    4010d2 <phase_5+0x70>
  40108b:	0f b6 0c 03          	movzbl (%rbx,%rax,1),%ecx
  40108f:	88 0c 24             	mov    %cl,(%rsp)
  401092:	48 8b 14 24          	mov    (%rsp),%rdx
  401096:	83 e2 0f             	and    $0xf,%edx
  401099:	0f b6 92 b0 24 40 00 	movzbl 0x4024b0(%rdx),%edx
  4010a0:	88 54 04 10          	mov    %dl,0x10(%rsp,%rax,1)
  4010a4:	48 83 c0 01          	add    $0x1,%rax
  4010a8:	48 83 f8 06          	cmp    $0x6,%rax
  4010ac:	75 dd                	jne    40108b <phase_5+0x29>
  4010ae:	c6 44 24 16 00       	movb   $0x0,0x16(%rsp)
  4010b3:	be 5e 24 40 00       	mov    $0x40245e,%esi
  4010b8:	48 8d 7c 24 10       	lea    0x10(%rsp),%rdi
  4010bd:	e8 76 02 00 00       	callq  401338 <strings_not_equal>
  4010c2:	85 c0                	test   %eax,%eax
  4010c4:	74 13                	je     4010d9 <phase_5+0x77>
  4010c6:	e8 6f 03 00 00       	callq  40143a <explode_bomb>
  4010cb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
  4010d0:	eb 07                	jmp    4010d9 <phase_5+0x77>
  4010d2:	b8 00 00 00 00       	mov    $0x0,%eax
  4010d7:	eb b2                	jmp    40108b <phase_5+0x29>
  4010d9:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
  4010de:	64 48 33 04 25 28 00 	xor    %fs:0x28,%rax
  4010e5:	00 00 
  4010e7:	74 05                	je     4010ee <phase_5+0x8c>
  4010e9:	e8 42 fa ff ff       	callq  400b30 <__stack_chk_fail@plt>
  4010ee:	48 83 c4 20          	add    $0x20,%rsp
  4010f2:	5b                   	pop    %rbx
  4010f3:	c3                   	retq

可以看到这个函数设置了一个“金丝雀值”，放在了 %rsp+24 这个地方，然后就相应的去找函数结尾的异或判断，发现下面从 4010d9 开始就都是判断的了，这些和题目关系不大，可以粗略的看一眼。

整体扫过来一眼，发现调用了两个函数，string_length 和 strings_not_equal 两个函数，都是在之前分析过的，这里就不重复了。发现 string_length 这个函数的返回值和 6 比较，相等才能继续，不相等就爆炸。那跳到相等的地方看， %eax 置 0 ，跳回 40108b 。

根据最前面几行我们可以判断一下，%rbx 里存的是我们输入的数据，这里我们输入的是abcdef，输出 %rbx 里的东西看看：

1
2
(gdb) x/s $rbx
0x6038c0 <input_strings+320>:   "abcdef"

没有问题。看一下这个语句：

1
2
3
4
40108b:	0f b6 0c 03          	movzbl (%rbx,%rax,1),%ecx
40108f:	88 0c 24             	mov    %cl,(%rsp)
401092:	48 8b 14 24          	mov    (%rsp),%rdx
401096:	83 e2 0f             	and    $0xf,%edx

将 %rbx + %rax 里的东西 0 扩展成 32 位以后存到 %ecx ，此时 %eax 里存的是 0 。然后一通寄存器转换，最后 0xf 和%rdx的低四字节进行与运算，只取低四位。输出一下 %rdx 里存的东西看看：

1
2
(gdb) print $rdx
$19 = 97

这里卡了挺久的，不过还好，后来突然想起来字符在计算机里以ASCII码的形式存储，刚刚取得是 %rdx 的最低四位，应该是输入的第一个字符的ASCII码，对照表看一下，a 的十进制ASCII码值确实是 97 。好了，继续向下。

看到一个地址 0x4024b0，输出看一下。

1
2
(gdb) x/s 0x4024b0
0x4024b0 <array.3449>:  "maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?"

这个字符串先放着，看看后面的：

1
2
3
4
5
401099:	0f b6 92 b0 24 40 00 	movzbl 0x4024b0(%rdx),%edx
4010a0:	88 54 04 10          	mov    %dl,0x10(%rsp,%rax,1)
4010a4:	48 83 c0 01          	add    $0x1,%rax
4010a8:	48 83 f8 06          	cmp    $0x6,%rax
4010ac:	75 dd                	jne    40108b <phase_5+0x29>

将 ( %rdx + 0x4024b0 )里面低位的一个字节拿出来进行 32 位 0 扩展之后放进 %edx 里。 %dl 是 %edx 的低 8 位，放到 %rsp + %rax +16 这个地址。然后递增 %rax ，直到 %rax 里面的数为 6 的时候 （%rax 初始为 0 ）结束循环。也就是说这个循环是把 6 个输入字符的ASCII码存到 %rsp+16 ，%rsp + 17 一直到 %rsp + 21。

1
4010ae:	c6 44 24 16 00       	movb   $0x0,0x16(%rsp)

这句话意思是在 %rsp+22 这个地方放 0 ，根据前面是字符串我们可以判断这个 0 其实就是 ‘ ‘ \0 ‘ 的意思。往下，看见一个地址放到了 %esi 里，输出看看。

1
2
(gdb) x/s 0x40245e
0x40245e:       "flyers"

这是个啥？不急，继续往下看。%rdi 指向我们刚刚输入的第一个字符，然后调用strings_not_equal函数测两个字符串是不是相等。相等则继续，不相等则爆炸。后面就是测“金丝雀值”的语句，没啥好说的。

所以综合下，整个phase是要求输入一个有且只能有 6 位的字符串，在机器里以ASCII码的方式存储。我们把每个字符ASCII码的低 4 位拿出来当作下标，下标范围从 0 - 15 ，放到那个很长的字符串里去一一匹配，也就是需要去那个很长的字符串里找“flyers”六个字母：

1
maduiersnfotvbyl

仔细查正好是 16 个，一一对应 0123456789ABCDEF 。flyers 对着 9FE567，所以我们去ASCII码表里找哪六个字符的ASCII码的低四位分别是 9FE567。

9 == 1001
F == 1111
E == 1110
5 == 0101
6 == 0110
7 == 0111

然后自己对着ASCII码找就好了。我自己懒得找了，试了一下输入 ionefg ，可以通过。

phase6

不想做了，回头有空再做

image-20231019164418077