详情移步Github
Bomb Lab
介绍
“二进制炸弹”是作为目标代码文件提供给学生的程序。 运行时，它提示用户输入6个不同的字符串。 如果其中任何一个不正确，炸弹就会“爆炸”，学生必须通过拆卸和逆向工程程序来“消散”自己独特的炸弹，以确定6个字符串应该是什么。该实验室教会学生理解汇编语言，并强迫他们学习如何使用调试器。
实验步骤
使用GDB逆向工程推断6个字符串。设置断点，一步一步调试，找到explode_bomb的跳转命令，结合逻辑和寄存器的值进行判断字符串的值。
每一个炸弹都是从read_line()函数从输入流stdin中读取的，存放于input变量中，对应%rax寄存器中，将%rax的值赋给%rdi作为参数传递给phase_x函数，%rdi中存放的是字符串的首地址。
phase_1
在命令行中使用以下命令：
调试bomb可执行程序
unix> gdb bomb
反汇编phase_1函数
gdb> disas phase_1
得到：
gdb) disas phase_1
Dump of assembler code for function phase_1:
0x0000000000400ee0 <+0>: sub $0x8,%rsp
0x0000000000400ee4 <+4>: mov $0x402400,%esi
0x0000000000400ee9 <+9>: callq 0x401338 <strings_not_equal>
0x0000000000400eee <+14>: test %eax,%eax
0x0000000000400ef0 <+16>: je 0x400ef7 <phase_1+23>
0x0000000000400ef2 <+18>: callq 0x40143a <explode_bomb>
0x0000000000400ef7 <+23>: add $0x8,%rsp
0x0000000000400efb <+27>: retq
End of assembler dump.
- 字符串首地址在
%rdi寄存器中。 - 申请8个字节的栈空间。
- 将立即数
0x402400存放到%esi寄存器中（第二个参数寄存器）。 - 调用字符串比较函数，比较是否相同，结果返回于
%eax中。 - 检查
%eax中的值是否为0，为0跳转到<phase_1+23>，跳过引爆炸弹的函数。 - 否则执行explod_bomb函数，回收栈空间。
故%esi寄存器存放的指向字符串的地址便是第一个字符串。
在phase_1和explode_bomb处设置断点并运行，检查%rsi寄存器指向字符串的值。
第一个字符串便是Border relations with Canada have never been better.。
第一个💣解除。
phase_2
同样的步骤查看phase_2函数的反汇编代码：
(gdb) disas phase_2
Dump of assembler code for function phase_2:
0x0000000000400efc <+0>: push %rbp
0x0000000000400efd <+1>: push %rbx
0x0000000000400efe <+2>: sub $0x28,%rsp
0x0000000000400f02 <+6>: mov %rsp,%rsi
0x0000000000400f05 <+9>: callq 0x40145c <read_six_numbers>
0x0000000000400f0a <+14>: cmpl $0x1,(%rsp)
0x0000000000400f0e <+18>: je 0x400f30 <phase_2+52>
0x0000000000400f10 <+20>: callq 0x40143a <explode_bomb>
0x0000000000400f15 <+25>: jmp 0x400f30 <phase_2+52>
0x0000000000400f17 <+27>: mov -0x4(%rbx),%eax
0x0000000000400f1a <+30>: add %eax,%eax
0x0000000000400f1c <+32>: cmp %eax,(%rbx)
0x0000000000400f1e <+34>: je 0x400f25 <phase_2+41>
0x0000000000400f20 <+36>: callq 0x40143a <explode_bomb>
0x0000000000400f25 <+41>: add $0x4,%rbx
0x0000000000400f29 <+45>: cmp %rbp,%rbx
0x0000000000400f2c <+48>: jne 0x400f17 <phase_2+27>
0x0000000000400f2e <+50>: jmp 0x400f3c <phase_2+64>
0x0000000000400f30 <+52>: lea 0x4(%rsp),%rbx
0x0000000000400f35 <+57>: lea 0x18(%rsp),%rbp
0x0000000000400f3a <+62>: jmp 0x400f17 <phase_2+27>
0x0000000000400f3c <+64>: add $0x28,%rsp
0x0000000000400f40 <+68>: pop %rbx
0x0000000000400f41 <+69>: pop %rbp
0x0000000000400f42 <+70>: retq
End of assembler dump.
我们可以看到将%rbp和%rbx压入栈后，请求了0x28大小的栈空间，将%rsp赋给%rsi第二个寄存器，第一个参数寄存器是%rdi，然后进去了read_six_numbers函数，根据名字是估计读入6个数字的函数。
我们进入read_six_numbers函数一探究竟。
(gdb) disas read_six_numbers
Dump of assembler code for function read_six_numbers:
0x000000000040145c <+0>: sub $0x18,%rsp
0x0000000000401460 <+4>: mov %rsi,%rdx
0x0000000000401463 <+7>: lea 0x4(%rsi),%rcx
0x0000000000401467 <+11>: lea 0x14(%rsi),%rax
0x000000000040146b <+15>: mov %rax,0x8(%rsp)
0x0000000000401470 <+20>: lea 0x10(%rsi),%rax
0x0000000000401474 <+24>: mov %rax,(%rsp)
0x0000000000401478 <+28>: lea 0xc(%rsi),%r9
0x000000000040147c <+32>: lea 0x8(%rsi),%r8
0x0000000000401480 <+36>: mov $0x4025c3,%esi
0x0000000000401485 <+41>: mov $0x0,%eax
0x000000000040148a <+46>: callq 0x400bf0 <__isoc99_sscanf@plt>
0x000000000040148f <+51>: cmp $0x5,%eax
0x0000000000401492 <+54>: jg 0x401499 <read_six_numbers+61>
0x0000000000401494 <+56>: callq 0x40143a <explode_bomb>
0x0000000000401499 <+61>: add $0x18,%rsp
0x000000000040149d <+65>: retq
End of assembler dump.
逐指令分析：
- 申请0x18大小的栈空间，24个字节。
- 将
%rsi赋给%rdx寄存器，%rsi是phase_2传入进来的参数，内容是调用函数之前的%rsp。 - 将
%rsi加上0x4赋给rcx寄存器。 - 将
%rsi加上0x14赋给rax寄存器。 - 将
%rax赋给%rsp+0x8偏移量指向的内存中。 - 将
%rsi加上0x10赋给rax寄存器。 - 将
%rax赋给%rsp指向的内存中。 - 将
%rsi加上0xc赋给%r9寄存器。 - 将
%rsi加上0x8赋给%r8寄存器。 - 将立即数0x4025c3赋给
%esi寄存器。 - 将
eax置为0。 - 调用
sscanf函数。
sscanf函数的语法是：
int sscanf(const char *buffer, const char *format, [argument]...);
第一个参数是起始地址，第二个参数是格式字符串，第三个是参数变量。 我们观察一下此时各个寄存器的内容。
| %rax | %rdi | %rsi | %rdx | %rcx | %r8 | %r9 | |
|---|---|---|---|---|---|---|---|
| 0x0 | 第二个字符串地址 | 0x4025c3 | 调用函数之前的%rsp | 调用函数之前的%rsp + 0x4 | 调用函数之前的%rsp + 0x8 | 调用函数之前的%rsp + 0xc | 调用函数之前的%rsp + 0x1c |
| 返回值 | 第一个参数寄存器 | 第二个参数寄存器 | 第三个参数寄存器 | 第四个参数寄存器 | 第五个参数寄存器 | 第六个参数寄存器 |
可以想到%rdi对应第一个参数起始地址;
%rsi对应第二个参数对应格式字符串;
%rdx对应&buffer[0];
%rcx对应&buffer[1];
r8对应&buffer[2];
r9对应&buffer[3];
调用函数前的%rsp + 0x10，也就是函数内的%rsp对应&buffer[4];
调用函数前的%rsp + 0x14，也就是函数内的%rsp+0x8对应&buffer[5]。
我们将进入read_six_number函数内执行到调用sscanf函数之前，查看%rsi的内容
(gdb) x/s $esi
0x4025c3: "%d %d %d %d %d %d"
验证成功是，六个数字的输入格式控制符。
我们回到phase_2函数：
(gdb) disas phase_2
Dump of assembler code for function phase_2:
0x0000000000400efc <+0>: push %rbp
0x0000000000400efd <+1>: push %rbx
0x0000000000400efe <+2>: sub $0x28,%rsp
0x0000000000400f02 <+6>: mov %rsp,%rsi
0x0000000000400f05 <+9>: callq 0x40145c <read_six_numbers>
=> 0x0000000000400f0a <+14>: cmpl $0x1,(%rsp)
0x0000000000400f0e <+18>: je 0x400f30 <phase_2+52>
0x0000000000400f10 <+20>: callq 0x40143a <explode_bomb>
0x0000000000400f15 <+25>: jmp 0x400f30 <phase_2+52>
0x0000000000400f17 <+27>: mov -0x4(%rbx),%eax
0x0000000000400f1a <+30>: add %eax,%eax
0x0000000000400f1c <+32>: cmp %eax,(%rbx)
0x0000000000400f1e <+34>: je 0x400f25 <phase_2+41>
0x0000000000400f20 <+36>: callq 0x40143a <explode_bomb>
0x0000000000400f25 <+41>: add $0x4,%rbx
0x0000000000400f29 <+45>: cmp %rbp,%rbx
0x0000000000400f2c <+48>: jne 0x400f17 <phase_2+27>
0x0000000000400f2e <+50>: jmp 0x400f3c <phase_2+64>
0x0000000000400f30 <+52>: lea 0x4(%rsp),%rbx
0x0000000000400f35 <+57>: lea 0x18(%rsp),%rbp
0x0000000000400f3a <+62>: jmp 0x400f17 <phase_2+27>
0x0000000000400f3c <+64>: add $0x28,%rsp
0x0000000000400f40 <+68>: pop %rbx
0x0000000000400f41 <+69>: pop %rbp
0x0000000000400f42 <+70>: retq
End of assembler dump.
发现将%rsp起始地址指向的内容和0x1比较。也就是buffer[0]，如果相等就跳转到<phase_2+52>否则就引爆炸弹，所以可以判定buffer[0] = 1；
将%rsp加上0x4赋给%rbx，也就是将&buffer[1]的值赋给了rbx寄存器；
将%rsp加上0x18赋给%rbp，将&buffer[6]的值赋给了rbp寄存器也就是数组的临界地址；
接着跳转到<phase_2+27>，将%rbx减0x4后的地址指向的内容赋给%eax，也就是%eax = buffer[0]，将%eax扩大1倍，然后与%rbx地址指向的内容进行比较，如果不相等引爆炸弹，相等接着跳转。
...
可以发现就是在比较
buffer[5] = 2 * buffer[4];
buffer[4] = 2 * buffer[3];
...
buffer[1] = 2 * buffer[0];
buffer[0] = 1;
所以字符串的内容便是1 2 4 8 16 32。
第二个💣解除。
phase_3
(gdb) disas phase_3
Dump of assembler code for function phase_3:
0x0000000000400f43 <+0>: sub $0x18,%rsp
0x0000000000400f47 <+4>: lea 0xc(%rsp),%rcx
0x0000000000400f4c <+9>: lea 0x8(%rsp),%rdx
0x0000000000400f51 <+14>: mov $0x4025cf,%esi
0x0000000000400f56 <+19>: mov $0x0,%eax
0x0000000000400f5b <+24>: callq 0x400bf0 <__isoc99_sscanf@plt>
0x0000000000400f60 <+29>: cmp $0x1,%eax
0x0000000000400f63 <+32>: jg 0x400f6a <phase_3+39>
0x0000000000400f65 <+34>: callq 0x40143a <explode_bomb>
0x0000000000400f6a <+39>: cmpl $0x7,0x8(%rsp)
0x0000000000400f6f <+44>: ja 0x400fad <phase_3+106>
0x0000000000400f71 <+46>: mov 0x8(%rsp),%eax
0x0000000000400f75 <+50>: jmpq *0x402470(,%rax,8)
0x0000000000400f7c <+57>: mov $0xcf,%eax
0x0000000000400f81 <+62>: jmp 0x400fbe <phase_3+123>
0x0000000000400f83 <+64>: mov $0x2c3,%eax
0x0000000000400f88 <+69>: jmp 0x400fbe <phase_3+123>
0x0000000000400f8a <+71>: mov $0x100,%eax
0x0000000000400f8f <+76>: jmp 0x400fbe <phase_3+123>
0x0000000000400f91 <+78>: mov $0x185,%eax
0x0000000000400f96 <+83>: jmp 0x400fbe <phase_3+123>
0x0000000000400f98 <+85>: mov $0xce,%eax
0x0000000000400f9d <+90>: jmp 0x400fbe <phase_3+123>
0x0000000000400f9f <+92>: mov $0x2aa,%eax
0x0000000000400fa4 <+97>: jmp 0x400fbe <phase_3+123>
0x0000000000400fa6 <+99>: mov $0x147,%eax
0x0000000000400fab <+104>: jmp 0x400fbe <phase_3+123>
0x0000000000400fad <+106>: callq 0x40143a <explode_bomb>
0x0000000000400fb2 <+111>: mov $0x0,%eax
0x0000000000400fb7 <+116>: jmp 0x400fbe <phase_3+123>
0x0000000000400fb9 <+118>: mov $0x137,%eax
0x0000000000400fbe <+123>: cmp 0xc(%rsp),%eax
0x0000000000400fc2 <+127>: je 0x400fc9 <phase_3+134>
0x0000000000400fc4 <+129>: callq 0x40143a <explode_bomb>
0x0000000000400fc9 <+134>: add $0x18,%rsp
0x0000000000400fcd <+138>: retq
End of assembler dump.
有了上一个phase的经验，我们之间查看%esi的内容：
(gdb) x/s $esi
0x4025cf: "%d %d"
我们可以推断输入的字符串包含2个整数。一个存放在%rsp+0x8，一个存放在%rsp+0xc中。
cmpl $0x7,0x8(%rsp)，比较第一个数与0x7的大小关系，如果大于7跳到<+106>引爆炸弹。
由于是ja命令所以，第一个数的范围是0-6的整数。
将mov 0x8(%rsp),%eax将第一个数赋给%eax，jmpq *0x402470(,%rax,8)，根据第一个数的值进行一次间接跳转。我们分别测试第一个数0-6，可以得到不同的间接跳转，发现每个跳转都是第二个数与某个立即数进行比较。我们可以得到下表。
| 第一个参数 | 第二个参数 |
|---|---|
| 0 | 207 |
| 1 | 311 |
| 2 | 707 |
| 3 | 256 |
| 4 | 389 |
| 5 | 206 |
| 6 | 682 |
所以字符串的内容是上表中的任意一对数，例如0 207。
第三个💣解除。
phase_4
(gdb) disas phase_4
Dump of assembler code for function phase_4:
0x000000000040100c <+0>: sub $0x18,%rsp
0x0000000000401010 <+4>: lea 0xc(%rsp),%rcx
0x0000000000401015 <+9>: lea 0x8(%rsp),%rdx
0x000000000040101a <+14>: mov $0x4025cf,%esi
0x000000000040101f <+19>: mov $0x0,%eax
0x0000000000401024 <+24>: callq 0x400bf0 <__isoc99_sscanf@plt>
0x0000000000401029 <+29>: cmp $0x2,%eax
0x000000000040102c <+32>: jne 0x401035 <phase_4+41>
0x000000000040102e <+34>: cmpl $0xe,0x8(%rsp)
0x0000000000401033 <+39>: jbe 0x40103a <phase_4+46>
0x0000000000401035 <+41>: callq 0x40143a <explode_bomb>
0x000000000040103a <+46>: mov $0xe,%edx
0x000000000040103f <+51>: mov $0x0,%esi
0x0000000000401044 <+56>: mov 0x8(%rsp),%edi
0x0000000000401048 <+60>: callq 0x400fce <func4>
0x000000000040104d <+65>: test %eax,%eax
0x000000000040104f <+67>: jne 0x401058 <phase_4+76>
0x0000000000401051 <+69>: cmpl $0x0,0xc(%rsp)
0x0000000000401056 <+74>: je 0x40105d <phase_4+81>
0x0000000000401058 <+76>: callq 0x40143a <explode_bomb>
0x000000000040105d <+81>: add $0x18,%rsp
0x0000000000401061 <+85>: retq
End of assembler dump.
查看%esi寄存器指向的内容。
(gdb) x/s $esi
0x4025cf: "%d %d"
我们能够得知字符串包含两个整数。使用sscanf函数读入，这部分代码我们之前已经熟悉过不再讲解。
我们从<+46>行开始看，将%edx赋值为0xe，将%esi赋值为0x0，将%edi赋值为第一个输入整数，传入func4函数中。
我们反汇编查看func4函数的代码：
(gdb) disas func4
Dump of assembler code for function func4:
0x0000000000400fce <+0>: sub $0x8,%rsp
0x0000000000400fd2 <+4>: mov %edx,%eax
0x0000000000400fd4 <+6>: sub %esi,%eax
0x0000000000400fd6 <+8>: mov %eax,%ecx
0x0000000000400fd8 <+10>: shr $0x1f,%ecx
0x0000000000400fdb <+13>: add %ecx,%eax
0x0000000000400fdd <+15>: sar %eax
0x0000000000400fdf <+17>: lea (%rax,%rsi,1),%ecx
0x0000000000400fe2 <+20>: cmp %edi,%ecx
0x0000000000400fe4 <+22>: jle 0x400ff2 <func4+36>
0x0000000000400fe6 <+24>: lea -0x1(%rcx),%edx
0x0000000000400fe9 <+27>: callq 0x400fce <func4>
0x0000000000400fee <+32>: add %eax,%eax
0x0000000000400ff0 <+34>: jmp 0x401007 <func4+57>
0x0000000000400ff2 <+36>: mov $0x0,%eax
0x0000000000400ff7 <+41>: cmp %edi,%ecx
0x0000000000400ff9 <+43>: jge 0x401007 <func4+57>
0x0000000000400ffb <+45>: lea 0x1(%rcx),%esi
0x0000000000400ffe <+48>: callq 0x400fce <func4>
0x0000000000401003 <+53>: lea 0x1(%rax,%rax,1),%eax
0x0000000000401007 <+57>: add $0x8,%rsp
0x000000000040100b <+61>: retq
End of assembler dump.
由于%ecx的值被覆盖而未先使用，所以我们判定func4使用3个参数寄存器，分别是%edi，esi，edx寄存器。
void func4(int x, int y, int z)
x in %rdi, y in %rsi, z in %rdx, k in %rax, t in %rcx
第一次进入时 y = 0x0, z = 0xe;
mov %edx,%eax
sub %esi,%eax k = z - y; k = 0xe;
mov %eax,%ecx
shr $0x1f,%ecx t = k >> 31; t = 0x0;
add %ecx,%eax
sar %eax k = (k + t) >> 1; k = 0x7;
lea (%rax,%rsi,1),%ecx t = (k + y); t = 0x7;
cmp %edi, %ecx
jle <func4+36> x < 0x7时，会继续执行，否则跳转<func4+36>
lea -0x1(%rcx),%edx z = t - 1; z = 0x6;
callq <func4> x < 0x7时会递归调用<func4>
<func4+36>
mov $0x0,%eax k = 0x0;
cmp %edi,%ecx
jge <func4+57> x 0x7 >= x时，跳转<func4+57> 由于之前的判定x < 0x7 执行到这里是 x >=0x7 所以x == 0x7时跳转<func4+57>，发现跳转<57>后就就跳出函数了
后面的一段代码就不分析了。从前面的代码我们可以得出结论：要想函数执行完毕，%rdi寄存器的内容必须是0x7，也就是第一个参数的值。
执行完func4函数后返回phase_4，cmpl $0x0,0xc(%rsp)，检查第二个参数与0是否相等，如果不相等就会引爆炸弹，说明第二个参数是0x0。
所以字符串的内容是7 0。
第四个💣拆除。
phase_5
(gdb) disas phase_5
Dump of assembler code for function phase_5:
0x0000000000401062 <+0>: push %rbx
0x0000000000401063 <+1>: sub $0x20,%rsp
0x0000000000401067 <+5>: mov %rdi,%rbx
0x000000000040106a <+8>: mov %fs:0x28,%rax
0x0000000000401073 <+17>: mov %rax,0x18(%rsp)
0x0000000000401078 <+22>: xor %eax,%eax
0x000000000040107a <+24>: callq 0x40131b <string_length>
0x000000000040107f <+29>: cmp $0x6,%eax
0x0000000000401082 <+32>: je 0x4010d2 <phase_5+112>
0x0000000000401084 <+34>: callq 0x40143a <explode_bomb>
0x0000000000401089 <+39>: jmp 0x4010d2 <phase_5+112>
0x000000000040108b <+41>: movzbl (%rbx,%rax,1),%ecx
0x000000000040108f <+45>: mov %cl,(%rsp)
0x0000000000401092 <+48>: mov (%rsp),%rdx
0x0000000000401096 <+52>: and $0xf,%edx
0x0000000000401099 <+55>: movzbl 0x4024b0(%rdx),%edx
0x00000000004010a0 <+62>: mov %dl,0x10(%rsp,%rax,1)
0x00000000004010a4 <+66>: add $0x1,%rax
0x00000000004010a8 <+70>: cmp $0x6,%rax
0x00000000004010ac <+74>: jne 0x40108b <phase_5+41>
0x00000000004010ae <+76>: movb $0x0,0x16(%rsp)
0x00000000004010b3 <+81>: mov $0x40245e,%esi
0x00000000004010b8 <+86>: lea 0x10(%rsp),%rdi
0x00000000004010bd <+91>: callq 0x401338 <strings_not_equal>
0x00000000004010c2 <+96>: test %eax,%eax
0x00000000004010c4 <+98>: je 0x4010d9 <phase_5+119>
0x00000000004010c6 <+100>: callq 0x40143a <explode_bomb>
0x00000000004010cb <+105>: nopl 0x0(%rax,%rax,1)
0x00000000004010d0 <+110>: jmp 0x4010d9 <phase_5+119>
0x00000000004010d2 <+112>: mov $0x0,%eax
0x00000000004010d7 <+117>: jmp 0x40108b <phase_5+41>
0x00000000004010d9 <+119>: mov 0x18(%rsp),%rax
0x00000000004010de <+124>: xor %fs:0x28,%rax
0x00000000004010e7 <+133>: je 0x4010ee <phase_5+140>
0x00000000004010e9 <+135>: callq 0x400b30 <__stack_chk_fail@plt>
0x00000000004010ee <+140>: add $0x20,%rsp
0x00000000004010f2 <+144>: pop %rbx
0x00000000004010f3 <+145>: retq
End of assembler dump.
先检查字符串长度是否为6，如果长度不为6直接引爆炸弹。取出字符串的第一个字符与0xf相与，取出字符的第四位作为偏移量。取出0x4024b0+偏移量地址指向的字节内容赋给栈空间。循环从第一个字符到第6个字符，最后将字符串与0x40245e地址指向的字符串比较，如果相等成功解除炸弹否则引爆。
我们查看两个地址指向的内容。
(gdb) x/s 0x4024b0
0x4024b0 <array.3449>: "maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?"
(gdb) x/s 0x40245e
0x40245e: "flyers"
我们从长字符串选出组成"flyers"，可以使用程序代码帮助我们写出偏移值。
#include <iostream>
#include <string>
using namespace std;
int main() {
string a = "maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?";
string b = "flyers";
for (int i = 0; i < b.size(); ++i) {
for (int j = 0; j < a.size(); ++j) {
if (b[i] == a[j]) {
cout << j << endl;
break;
}
}
}
return 0;
}
9 15 14 5 6 7
我们再把偏移值作为ASCII字符的低四位，构造成可输入的字符。我这里是分别加上80(01010000)，构成第五个字符串Y_^UVW。
第五个💣拆除。
