Warning
This article was last updated on 2021-05-14, the content may be out of date.
读完CS: APP第三章后，终于来到了期待已久的Bomb Lab环节，可能由于我拿到的是B&O提供的Self-Handout Version，加上之前有一点Re经验，所以难度没有现象中那么大，花了半个晚上就做完了。但是第一遍做的时候并没有仔细的一点一点读汇编，基本上是看个大概然后依靠直觉就得到答案了，这里再重新认真做一遍做个记录
Ubuntu 20.04.2 LTS on Windows 10 x86_64(WSL1)
GDB, objdump
Lab给出了一个二进制程序bomb和一个包含main函数的参考代码
这里放一段跟解题有关的部分
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
|
/* Do all sorts of secret stuff that makes the bomb harder to defuse. */
initialize_bomb();
printf("Welcome to my fiendish little bomb. You have 6 phases with\n");
printf("which to blow yourself up. Have a nice day!\n");
/* Hmm... Six phases must be more secure than one phase! */
input = read_line(); /* Get input */
phase_1(input); /* Run the phase */
phase_defused(); /* Drat! They figured it out!
* Let me know how they did it. */
printf("Phase 1 defused. How about the next one?\n");
/* The second phase is harder. No one will ever figure out
* how to defuse this... */
input = read_line();
phase_2(input);
phase_defused();
printf("That's number 2. Keep going!\n");
/* I guess this is too easy so far. Some more complex code will
* confuse people. */
input = read_line();
phase_3(input);
phase_defused();
printf("Halfway there!\n");
/* Oh yeah? Well, how good is your math? Try on this saucy problem! */
input = read_line();
phase_4(input);
phase_defused();
printf("So you got that one. Try this one.\n");
/* Round and 'round in memory we go, where we stop, the bomb blows! */
input = read_line();
phase_5(input);
phase_defused();
printf("Good work! On to the next...\n");
/* This phase will never be used, since no one will get past the
* earlier ones. But just in case, make this one extra hard. */
input = read_line();
phase_6(input);
phase_defused();
|
可以看到每个phase都是先读入一行字符串，然后传入对应的函数，如果解密成功则返回，进入下一个phase
在输入字符串之前，先看一下phase_1函数的汇编代码找找有没有格式要求，这里用了objdump静态反汇编生成代码
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
|
从汇编代码可以看出，phase_1主要是调用了strings_not_equal这个函数，然后判断返回值是否为0，若为0则跳转到retq，否则触发explode_bomb。这里第一次做的时候我没有深入研究，只是根据函数名来判断函数的功能，因为%rdi存的是输入字符串的指针，那么%rsi应该存的就是目标字符串，且其地址为0x402400，在反汇编文件中查找对应地址
1
2
3
4
|
402400 426f7264 65722072 656c6174 696f6e73 Border relations
402410 20776974 68204361 6e616461 20686176 with Canada hav
402420 65206e65 76657220 6265656e 20626574 e never been bet
402430 7465722e 00000000 576f7721 20596f75 ter.....Wow! You
|
可以看到0x402400对应的是字符串“Border relations with Canada have never been better.”，在GDB中也可以看到
GDB>x/s 0x402400
0x402400: “Border relations with Canada have never been better.”
当然不可能每次都能遇到加载了符号的汇编代码，所以还是要深入查看一下strings_not_equal这个函数
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
|
0000000000401338 <strings_not_equal>:
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
401342: e8 d4 ff ff ff callq 40131b <string_length>
401347: 41 89 c4 mov %eax,%r12d
40134a: 48 89 ef mov %rbp,%rdi
40134d: e8 c9 ff ff ff callq 40131b <string_length>
401352: ba 01 00 00 00 mov $0x1,%edx
401357: 41 39 c4 cmp %eax,%r12d
40135a: 75 3f jne 40139b <strings_not_equal+0x63>
40135c: 0f b6 03 movzbl (%rbx),%eax
40135f: 84 c0 test %al,%al
401361: 74 25 je 401388 <strings_not_equal+0x50>
401363: 3a 45 00 cmp 0x0(%rbp),%al
401366: 74 0a je 401372 <strings_not_equal+0x3a>
401368: eb 25 jmp 40138f <strings_not_equal+0x57>
40136a: 3a 45 00 cmp 0x0(%rbp),%al
40136d: 0f 1f 00 nopl (%rax)
401370: 75 24 jne 401396 <strings_not_equal+0x5e>
401372: 48 83 c3 01 add $0x1,%rbx
401376: 48 83 c5 01 add $0x1,%rbp
40137a: 0f b6 03 movzbl (%rbx),%eax
40137d: 84 c0 test %al,%al
40137f: 75 e9 jne 40136a <strings_not_equal+0x32>
401381: ba 00 00 00 00 mov $0x0,%edx
401386: eb 13 jmp 40139b <strings_not_equal+0x63>
401388: ba 00 00 00 00 mov $0x0,%edx
40138d: eb 0c jmp 40139b <strings_not_equal+0x63>
40138f: ba 01 00 00 00 mov $0x1,%edx
401394: eb 05 jmp 40139b <strings_not_equal+0x63>
401396: ba 01 00 00 00 mov $0x1,%edx
40139b: 89 d0 mov %edx,%eax
40139d: 5b pop %rbx
40139e: 5d pop %rbp
40139f: 41 5c pop %r12
4013a1: c3 retq
|
这段汇编还是很清晰的，可以看出，该函数先比较两个字符串的长度，若不相等则返回1，若相等则继续逐字符比较，均相等则返回0，否则返回1
所以phase_1就是Border relations with Canada have never been better.
第一个phase可以说是热身题，还是蛮简单的，重点就是不要陷入细节，要从宏观上把握程序逻辑
同样，在输入字符串之前先看一下有没有格式要求，对phase_2反汇编得到如下代码
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
|
可以看到该函数调用了read_six_numbers，且传入的两个参数分别为输入字符串和当前的栈顶指针，对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
|
这里可以看到该函数调用了标准库函数sscanf，且格式化字符串保存在0x4025c3中，使用GDB查看
GDB>x/s 0x4025c3
0x4025c3: “%d %d %d %d %d %d”
可以看到该函数很简单，就是简单的包装了一下sscanf函数，基本逻辑就是读入6个数字并依次保存在传入的栈指针指向的连续内存中，因为参数寄存器一共有6个，一共传入8个参数到sscanf中(前两个是输入字符串和格式字符串，剩余6个是指针)，前6个参数均保存在参数寄存器中，剩余两个参数则保存在栈上(%rsp和0x8(%rsp))，是典型的调用栈帧
接下来的代码主要包括两部分，第一部分如下
1
2
3
4
5
6
7
|
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>
...
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>
|
这里首先将1与输入的6个数字中的第一个比较，若相等则将第2个数字的地址保存在%rbx中，将第6个数字的地址保存在%rbp中，(注意这里由于使用的是16进制，所以18(16)实际上是24(10)，刚开始的时候我虽然看到了前导0x，但还是搞混了。)然后跳转到0x400f17处，即第二部分
1
2
3
4
5
6
7
8
9
|
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> # 函数结尾
|
可以看出这是一个循环，首先将%rbx指向的前一个数*2，然后与%rbx指向的数相比，若相等则将%rbx指向下一个数字；若%rbx与%rbp相等，即当%rbx指向第6个数字时跳转到函数结尾，否则继续下一轮循环，用C描述为
1
2
3
4
5
6
7
|
do
{
if(*(rbx-1)*2 == *rbx)
++rbx;
else
explode_bomb();
}while(rbx != rbp);
|
即从1开始，往后每个数都是前一个数的2倍，即$a_0=1,p=2,N=6$的等比数列{1, 2, 4, 8, 16, 32}
即phase_2即为1 2 4 8 16 32
在未知格式要求的情况下先看一下phase_3的汇编代码
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
|
可以看到首先调用了sscanf函数且格式字符串在0x4025cf，用GDB看一下可以得到
GDB>x/s 0x4025cf
0x4025cf: “%d %d”
即读入两个数字并分别储存在栈地址0x8(%rsp)和0xc(%rsp)中，随后对第一个数与7进行比较，若大于7则引爆
然后以第一个数为索引进行分支跳转，即switch(num1)，由于第一个数的范围是0-7，故一共有8条分支，查看位于0x402470的跳转表可得
GDB>x/8xg 0x402470
0x402470: 0x0000000000400f7c 0x0000000000400fb9
0x402480: 0x0000000000400f83 0x0000000000400f8a
0x402490: 0x0000000000400f91 0x0000000000400f98
0x4024a0: 0x0000000000400f9f 0x0000000000400fa6
其中每条分支都是先给%eax一个数，然后将其与第二个数相比较，若相等则返回，因此可以得到8对数
(0, 207(0xcf))，(1, 311(0x137))，(2, 707(0x2c3))，(3, 256(0x100))
(4, 389(0x185))，(5, 206(0xce))，(6, 682(0x2aa))，(7, 327(0x147))
故phase_3共有8组解，即{0 207，1 311，2 707，3 256，4 389，5 206，6 682，7 327}
先看下phase_4的汇编代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
000000000040100c <phase_4>:
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
|
可以看到前6行与phase_3相同，都是读入2个数字，且第一个数字要小于等于14(0xe)，然后调用了函数func4，且参数列表为(num1, 0, 14)，若func4返回0则继续，然后当第二个数字等于0时函数返回。所以重点就在func4中，看一下汇编
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
|
该段代码有两个比较跳转指令，分别在0x400fe2和0x400ff7处，且%ecx在这两条指令处均为7，则不考虑其他情况，当$num1 \ge 7$和$num1 \le 7$均满足时，有一条通路可以返回0，故首先可以得到一个解(7, 0)，这也是我第一次做得到的答案。但是这段代码在不满足上述条件时会触发递归，所以还可能存在其他的解。因为递归代码往往体积小却逻辑复杂，所以这里先对汇编代码手工进行反编译，以便进一步的分析
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
int func(int a, int b, int c)
{
int var1 = (c - b)/2;
int var2 = (c + b)/2;
if(var2 <= a)
var1 = 0;
else
return func(a, 0, var2-1)*2;
if(var2 >= a)
return var1;
else
return func(a, var2+1, c)*2 + 1;
}
|
只考虑第1条递归，可以得到当a={0, 1, 3, 7}时func返回0；考虑两个递归时无解
同样也可以用反编译代码写一段C程序得到答案
func(0, 0, 14) = 0,
func(1, 0, 14) = 0,
func(2, 0, 14) = 4,
func(3, 0, 14) = 0,
func(4, 0, 14) = 26,
func(5, 0, 14) = 2,
func(6, 0, 14) = 6,
func(7, 0, 14) = 0,
func(8, 0, 14) = 5,
func(9, 0, 14) = 13,
func(10, 0, 14) = 29,
func(11, 0, 14) = 1,
func(12, 0, 14) = 59,
func(13, 0, 14) = 3,
func(14, 0, 14) = 7,
故phase_4一共存在4组解{0 0，1 0，3 0，7 0}
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
|
观察汇编可以看出，这段代码使用了金丝雀值确保返回值不会被覆盖，同时需满足输入字符串的长度为6
代码前半部分是如下所示的一个循环结构(对顺序做了一些调整方便分析)
1
2
3
4
5
6
7
8
9
10
11
12
13
|
4010d2: b8 00 00 00 00 mov $0x0,%eax
4010d7: eb b2 jmp 40108b <phase_5+0x29>
...
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)
|
以0x4024b0为基址，取输入字符串中的每个字符的低4位作为偏移量访问内存，并将访问结果序列保存在栈地址0x10(%rsp)中，作为一个新的字符串。用GDB可以看到该地址对应的内容为
GDB>x/s 0x4024b0
0x4024b0 <array.3449>: “maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?”
由于使用4位二进制数作为偏移量，所以最多可以访问到该字符串的前16个字符，即"maduiersnfotvbyl"
1
2
3
4
5
6
7
8
|
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
|
然后将新字符串与地址0x40245e处的字符串进行比较，若相等则返回
用GDB查看该处的字符串内容
GDB>x/s 0x40245e
0x40245e: “flyers”
所以只需要在字符串0x4024b0中按顺序获取对应的字符即可。写行Python算一下偏移量
1
|
print(["maduiersnfotvbyl".find(i) for i in "flyers"])
|
[9, 15, 14, 5, 6, 7]
其中需保证输入字符的高4位在可打印字符的范围内，所以高4位可以取0x2到0x6，当不需要访问第16个字符时也可以取0x7，但由于偏移量包含15，所以0x7舍去，故一共有5组解，用如下Python代码可以得到
1
|
print([''.join([chr(h+i) for i in [9,15,14,5,6,7]]) for h in [0x20,0x30,0x40,0x50,0x60]])
|
[")/.%&’", ‘9?>567’, ‘IONEFG’, ‘Y_^UVW’, ‘ionefg’]
所以phase_5的解为{)/.%&'，9?>567，IONEFG，Y_^UVW，ionefg}
由于phase_6的汇编代码比较长，这里就不全部放出了，只分段进行分析，并且省略了无关的代码
开头和phase_2类似，读入6个数字并存在栈中，然后是一段循环
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
401114: 4c 89 ed mov %r13,%rbp
401117: 41 8b 45 00 mov 0x0(%r13),%eax
40111b: 83 e8 01 sub $0x1,%eax
40111e: 83 f8 05 cmp $0x5,%eax
401121: 76 05 jbe 401128 <phase_6+0x34>
401123: e8 12 03 00 00 callq 40143a <explode_bomb>
401128: 41 83 c4 01 add $0x1,%r12d
40112c: 41 83 fc 06 cmp $0x6,%r12d
401130: 74 21 je 401153 <phase_6+0x5f> #结束循环
401132: 44 89 e3 mov %r12d,%ebx
401135: 48 63 c3 movslq %ebx,%rax
401138: 8b 04 84 mov (%rsp,%rax,4),%eax
40113b: 39 45 00 cmp %eax,0x0(%rbp)
40113e: 75 05 jne 401145 <phase_6+0x51>
401140: e8 f5 02 00 00 callq 40143a <explode_bomb>
401145: 83 c3 01 add $0x1,%ebx
401148: 83 fb 05 cmp $0x5,%ebx
40114b: 7e e8 jle 401135 <phase_6+0x41>
40114d: 49 83 c5 04 add $0x4,%r13
401151: eb c1 jmp 401114 <phase_6+0x20>
|
其中%r13指向读入的6个数字的首地址。可以看到，这段代码对每个数字首先减1然后与5进行比较，当大于5时则引爆。然后从当前数字开始，逐个与后面的数字进行比较，若相等则引爆
所以可以得到两个条件
- 输入的6个数字均需小于7
- 输入的6个数字必须互不相同
接着又是一段循环
1
2
3
4
5
6
7
8
9
|
401153: 48 8d 74 24 18 lea 0x18(%rsp),%rsi
401158: 4c 89 f0 mov %r14,%rax
40115b: b9 07 00 00 00 mov $0x7,%ecx
401160: 89 ca mov %ecx,%edx
401162: 2b 10 sub (%rax),%edx
401164: 89 10 mov %edx,(%rax)
401166: 48 83 c0 04 add $0x4,%rax
40116a: 48 39 f0 cmp %rsi,%rax
40116d: 75 f1 jne 401160 <phase_6+0x6c>
|
其中%r14与%rsp相等，均指向读入的6个数字的首地址。这里对6个数字进行遍历，对每个数字都用7减去这个数并将结果原地更新，用Python表达为
1
|
for num in nums: num = 7 - num
|
接下来是phase_6中最复杂的一段代码，这里分成三部分，先看第一部分
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
40116f: be 00 00 00 00 mov $0x0,%esi
401174: eb 21 jmp 401197 <phase_6+0xa3>
401176: 48 8b 52 08 mov 0x8(%rdx),%rdx
40117a: 83 c0 01 add $0x1,%eax
40117d: 39 c8 cmp %ecx,%eax
40117f: 75 f5 jne 401176 <phase_6+0x82>
401181: eb 05 jmp 401188 <phase_6+0x94>
401183: ba d0 32 60 00 mov $0x6032d0,%edx
401188: 48 89 54 74 20 mov %rdx,0x20(%rsp,%rsi,2)
40118d: 48 83 c6 04 add $0x4,%rsi
401191: 48 83 fe 18 cmp $0x18,%rsi
401195: 74 14 je 4011ab <phase_6+0xb7> # 结束循环
401197: 8b 0c 34 mov (%rsp,%rsi,1),%ecx
40119a: 83 f9 01 cmp $0x1,%ecx
40119d: 7e e4 jle 401183 <phase_6+0x8f>
40119f: b8 01 00 00 00 mov $0x1,%eax
4011a4: ba d0 32 60 00 mov $0x6032d0,%edx
4011a9: eb cb jmp 401176 <phase_6+0x82>
|
这里依然是遍历输入的6个数，当遍历到小于等于1的数时，将0x6032d0保存在栈上0x20(%rsp,%rsi,2)处，然后%rsi增加4；当遍历到大于1的数时，可以看到401176处的代码多次将内存中的值作为地址进行访问，因此可以看出这里是访问一段链表，且访问到第num个节点，然后将该节点保存在栈上0x20(%rsp,%rsi,2)处，并将%rsi增加4。通过GDB访问地址0x6032d0也可以证明这是一个链表
GDB>x/24dw 0x6032d0
0x6032d0 <node1>: 332 1 6304480 0
0x6032e0 <node2>: 168 2 6304496 0
0x6032f0 <node3>: 924 3 6304512 0
0x603300 <node4>: 691 4 6304528 0
0x603310 <node5>: 477 5 6304544 0
0x603320 <node6>: 443 6 0 0
总的来看，这段代码的作用就是遍历输入的6个数，对于每个数num，将0x6032d0处的链表的第num个节点的地址保存在以0x20(%rsp)为首的第num个位置中，即按照输入的数字的顺序重新排列。注意，这里的输入数字是被7减去后的结果，因此并不等于实际输入的字符串中的6个数字
然后是第二部分
1
2
3
4
5
6
7
8
9
10
11
12
|
4011ab: 48 8b 5c 24 20 mov 0x20(%rsp),%rbx
4011b0: 48 8d 44 24 28 lea 0x28(%rsp),%rax
4011b5: 48 8d 74 24 50 lea 0x50(%rsp),%rsi
4011ba: 48 89 d9 mov %rbx,%rcx
4011bd: 48 8b 10 mov (%rax),%rdx
4011c0: 48 89 51 08 mov %rdx,0x8(%rcx)
4011c4: 48 83 c0 08 add $0x8,%rax
4011c8: 48 39 f0 cmp %rsi,%rax
4011cb: 74 05 je 4011d2 <phase_6+0xde> # 结束循环
4011cd: 48 89 d1 mov %rdx,%rcx
4011d0: eb eb jmp 4011bd <phase_6+0xc9>
4011d2: 48 c7 42 08 00 00 00 movq $0x0,0x8(%rdx)
|
这段代码的指针引用关系有点绕，但由于比较短，还是很好分析的。首先要明确的是%rbx和%rcx是节点指针，而%rax和%rdx都是指向节点指针的指针，即栈指针的偏移。先从重新排列后的第一个节点指针开始获取两个在栈上连续的节点指针，然后将第一个节点指针+8后指向的地址的值(即节点的指针域)改成第二个指针的值，最后直到第二个指针指向栈末尾的非节点地址时，将第一个指针指向的节点的指针域指向0(NULL)
因此，这段代码的作用就是用排列后的节点顺序更新链表的连接顺序
最后来看第三部分
1
2
3
4
5
6
7
8
9
|
4011da: bd 05 00 00 00 mov $0x5,%ebp
4011df: 48 8b 43 08 mov 0x8(%rbx),%rax
4011e3: 8b 00 mov (%rax),%eax
4011e5: 39 03 cmp %eax,(%rbx)
4011e7: 7d 05 jge 4011ee <phase_6+0xfa>
4011e9: e8 4c 02 00 00 callq 40143a <explode_bomb>
4011ee: 48 8b 5b 08 mov 0x8(%rbx),%rbx
4011f2: 83 ed 01 sub $0x1,%ebp
4011f5: 75 e8 jne 4011df <phase_6+0xeb>
|
最后一部分就比较简单了，由于%rbx是指向链表头节点的指针，所以这段循环的作用就是遍历链表并且当下一个链表的元素大于当前链表的元素时引爆炸弹。因此得到了第3个条件：输入的6个数字需使链表重新排列为降序
由链表的原始顺序可得
GDB>x/24dw 0x6032d0
0x6032d0 <node1>: 332 1 6304480 0
0x6032e0 <node2>: 168 2 6304496 0
0x6032f0 <node3>: 924 3 6304512 0
0x603300 <node4>: 691 4 6304528 0
0x603310 <node5>: 477 5 6304544 0
0x603320 <node6>: 443 6 0 0
排列链表的6个数字应该是{3, 4, 5, 6, 1, 2}，但由于这是被7减去后的结果，所以要得到原始输入，应该再次用7减去这6个数字，即输入的6个数字为{4, 3, 2, 1, 6, 5}，同时这6个数字也满足条件1和条件2
所以phase_6即为4 3 2 1 6 5
第一遍做的时候我是直接用GDB调试汇编得到的答案，因此并没有完整的查看程序的汇编代码，在写这篇文章的时候发现还有一个程序段叫secret_phase，但是在main函数里并没有找到入口，所以看了下其他的函数，发现其入口是在每次解开一个phase都要调用的一个叫phase_defused的函数中，所以又仔细研究了一下怎么才能触发这个调用。
首先看一下phase-defused的汇编，为节省空间这里省略了无关的部分
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
00000000004015c4 <phase_defused>:
4015d8: 83 3d 81 21 20 00 06 cmpl $0x6,0x202181(%rip) # 603760
4015df: 75 5e jne 40163f <phase_defused+0x7b> # 函数返回
4015e1: 4c 8d 44 24 10 lea 0x10(%rsp),%r8
4015e6: 48 8d 4c 24 0c lea 0xc(%rsp),%rcx
4015eb: 48 8d 54 24 08 lea 0x8(%rsp),%rdx
4015f0: be 19 26 40 00 mov $0x402619,%esi
4015f5: bf 70 38 60 00 mov $0x603870,%edi
4015fa: e8 f1 f5 ff ff callq 400bf0 <__isoc99_sscanf@plt>
4015ff: 83 f8 03 cmp $0x3,%eax
401602: 75 31 jne 401635 <phase_defused+0x71>
401604: be 22 26 40 00 mov $0x402622,%esi
401609: 48 8d 7c 24 10 lea 0x10(%rsp),%rdi
40160e: e8 25 fd ff ff callq 401338 <strings_not_equal>
401613: 85 c0 test %eax,%eax
401615: 75 1e jne 401635 <phase_defused+0x71>
401617: bf f8 24 40 00 mov $0x4024f8,%edi
40161c: e8 ef f4 ff ff callq 400b10 <puts@plt>
401621: bf 20 25 40 00 mov $0x402520,%edi
401626: e8 e5 f4 ff ff callq 400b10 <puts@plt>
40162b: b8 00 00 00 00 mov $0x0,%eax
401630: e8 0d fc ff ff callq 401242 <secret_phase>
401635: bf 58 25 40 00 mov $0x402558,%edi
40163a: e8 d1 f4 ff ff callq 400b10 <puts@plt>
|
这段代码首先将位于地址0x603760的值与0x6进行比较，若不相同则返回。通过搜索603760相关代码，发现这个地址的值初始化为0，每次读入一个字符串后都会自增1，这个操作在read_line函数中进行。所以只有当读入6个字符串，即读入phase_6之后才会运行后面的内容。但由于没有给额外的输入机会，因此唯一的方法是在前面6个phase后附加一个字符串作为secret_phase。
在读完6个字符串后，用GDB查看位于0x603870的源字符串和位于0x402619的格式化字符串
GDB>x/s 0x603870
0x603870 <input_strings+240>: “0 0”
GDB>x/s 0x402619
0x402619: “%d %d %s”
可以看到源字符串是前面读入的6个字符串中的第四个，即phase_4，格式化字符串为读入两个数和一个字符串。
因此只需要在phase_4后附加一个字符串即可触发secret_phase。可以看到后面调用了strings_not_equal，即之前分析的比较字符串的函数，并且传入的参数是附加字符串和位于0x402622的字符串，使用GDB查看
GDB>x/s 0x402622
0x402622: “DrEvil”
因此，只需要在phase_4后附加一个字符串DrEvil即可触发secret_phase
Halfway there!
0 0 DrEvil
So you got that one. Try this one.
9?>567
Good work! On to the next…
4 3 2 1 6 5
Curses, you’ve found the secret phase!
But finding it and solving it are quite different…
可以看到成功触发，接下来继续对secret_phase进行分析。这里把代码分成两部分，先看第一部分
1
2
3
4
5
6
7
8
9
10
11
12
|
0000000000401242 <secret_phase>:
401242: 53 push %rbx
401243: e8 56 02 00 00 callq 40149e <read_line>
401248: ba 0a 00 00 00 mov $0xa,%edx
40124d: be 00 00 00 00 mov $0x0,%esi
401252: 48 89 c7 mov %rax,%rdi
401255: e8 76 f9 ff ff callq 400bd0 <strtol@plt>
40125a: 48 89 c3 mov %rax,%rbx
40125d: 8d 40 ff lea -0x1(%rax),%eax
401260: 3d e8 03 00 00 cmp $0x3e8,%eax
401265: 76 05 jbe 40126c <secret_phase+0x2a>
401267: e8 ce 01 00 00 callq 40143a <explode_bomb>
|
这段代码先读入一个字符串，然后调用了strtol函数，查阅文档可得该函数原型为
1
|
long strtol( const char *restrict str, char **restrict str_end, int base );
|
因此根据传入的参数可知，该函数从输入字符串中读取一个long型10进制数，然后将其减1并与0x3e8(1000)进行比较，若大于则引爆炸弹
然后看第二部分
1
2
3
4
5
6
7
8
9
10
11
|
40126c: 89 de mov %ebx,%esi
40126e: bf f0 30 60 00 mov $0x6030f0,%edi
401273: e8 8c ff ff ff callq 401204 <fun7>
401278: 83 f8 02 cmp $0x2,%eax
40127b: 74 05 je 401282 <secret_phase+0x40>
40127d: e8 b8 01 00 00 callq 40143a <explode_bomb>
401282: bf 38 24 40 00 mov $0x402438,%edi
401287: e8 84 f8 ff ff callq 400b10 <puts@plt>
40128c: e8 33 03 00 00 callq 4015c4 <phase_defused>
401291: 5b pop %rbx
401292: c3 retq
|
可以看到这段代码将0x6030f0和输入的数字作为参数传入fun7中，当返回值为2时函数结束，否则引爆炸弹，因此重点就在这个fun7中。
按照惯例先看一下fun7的汇编
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
0000000000401204 <fun7>:
401204: 48 83 ec 08 sub $0x8,%rsp
401208: 48 85 ff test %rdi,%rdi
40120b: 74 2b je 401238 <fun7+0x34>
40120d: 8b 17 mov (%rdi),%edx
40120f: 39 f2 cmp %esi,%edx
401211: 7e 0d jle 401220 <fun7+0x1c>
401213: 48 8b 7f 08 mov 0x8(%rdi),%rdi
401217: e8 e8 ff ff ff callq 401204 <fun7>
40121c: 01 c0 add %eax,%eax
40121e: eb 1d jmp 40123d <fun7+0x39>
401220: b8 00 00 00 00 mov $0x0,%eax
401225: 39 f2 cmp %esi,%edx
401227: 74 14 je 40123d <fun7+0x39>
401229: 48 8b 7f 10 mov 0x10(%rdi),%rdi
40122d: e8 d2 ff ff ff callq 401204 <fun7>
401232: 8d 44 00 01 lea 0x1(%rax,%rax,1),%eax
401236: eb 05 jmp 40123d <fun7+0x39>
401238: b8 ff ff ff ff mov $0xffffffff,%eax
40123d: 48 83 c4 08 add $0x8,%rsp
401241: c3 retq
|
简单分析一下代码和内存可以看出，这段代码主要是递归访问二叉树，因此为了分析具体逻辑对该段代码进行反编译
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
int fun7(struct BinTree * root, int num, int ret)
{
if(root = NULL)
ret = 0xffffffff;
else if(root->value > num)
ret = 2*fun7(root->left, num, ret);
else
{
ret = 0;
if(root->value != num)
ret = 2*fun7(root->right, num, ret) + 1;
}
return ret;
}
|
根据代码逻辑分析，为了能够最终返回2，应该在第6行处调用fun7且返回1；若要fun7返回1，则应该在第11行处调用fun7且返回0；若要fun7返回0，则应该使num等于root->value。
因此最终二叉树的遍历路径为先访问左分支，再访问右分支，然后使num与当前分支的数据域相等即可。
使用GDB查看对应的数值
GDB>x/dw *(0x10+*(0x6030f0+0x8))
0x603150 <n32>: 22
因此得到secret_phase为22
做完这个Lab之后现在看汇编都如同看C代码了，而且在这些机器码中穿梭本身也是一种乐趣。加上objdump和GDB这些强大的工具，降低了许多调试的难度。在看多了汇编以后，愈发体验到高级语言的强大和简洁，不得不佩服搞出各种编译器的那帮人
AryanSjet