说明

6关卡，每个关卡需要输入一个字符串，通过逆向工程来获取对应关卡的字符串

准备工作

环境

需要用到gdb调试器

apt-get install gdb

系统: Ubuntu 22.04

本实验会用到的gdb调试器的指令如下

r或者 run或者run filename 运行程序,run filename就是用filename中的内容作为输入
b *address 在某个地址设置断点
d或delete 删除所有断点
d 断点号删除指定断点
info b 查看所有断点信息
x/参数地址查看指针解引用后的值，参数可以是s(字符串),d(十进制),x(十六进制),地址若是寄存器需要加上$
info register 或info r 查看所有寄存器的值
disas functionName 生成functionName的汇编代码
stepi 执行一个汇编指令
layout asm 窗口分为两部分，上面是将要执行的汇编代码，下面输入gdb调试命令

前置知识

寄存器的东西

这里面有一些寄存器的知识，了解即可
%rsp (register stack pointer) 栈指针
%esi:通用寄存器，长应用于指针或索引
%rax:存储函数的返回值,存储临时数据,系统调用号
%r12,%rbx:通用寄存器,参数传递的
%rbp(register base pointer):通常是当作基址指针来用

指令相关

test destination,source

destination和source可以是寄存器,内存地址,立即数.对两个操作数进行按位逻辑与操作,会更新下面寄存器的状态

Zero flag(ZF):若结果为0，则设置为1,反之为0，这个若为1表明两个操作数相等或者某个操作数等于0
Sign flag (SF):若结果最高位为1,则为1,反之为0
Overflow flag(OF):有符号数溢出则为1,反之为0
Carry flag(CF):无符号数溢出则为1,反之为0
Parity flag(PF):结果的低8位包含奇数个1则为1，反之为0

je destination

若ZF为1则跳转到destination处

开干

Phase 1 字符串比较

终端输入gdb bomb
在输入disas phase_1,结果如下

   0x0000000000400ee0 <+0>:	sub    $0x8,%rsp // 把栈指针减少8，给局部变量提供空间0x0000000000400ee4 <+4>:	mov    $0x402400,%esi // 将0x402400存储到%esi中，这个有可能是存放我们输入的值或者存放内置字符串的0x0000000000400ee9 <+9>:	call   0x401338 <strings_not_equal>//调用了函数strings_not_equal,估计是判断输入的字符串和内置字符串是否相同，相同返回00x0000000000400eee <+14>:	test   %eax,%eax  //判断%eax(函数strings_not_equal的返回值)是否为0，若为0则ZF=10x0000000000400ef0 <+16>:	je     0x400ef7 <phase_1+23> // ZF为1就跳转，反之顺序执行0x0000000000400ef2 <+18>:	call   0x40143a <explode_bomb>//拆弹失败，炸弹爆炸0x0000000000400ef7 <+23>:	add    $0x8,%rsp //回收栈指针0x0000000000400efb <+27>:	ret

把断点打到0x0000000000400ee9的位置,开始run,随便输点东西

b *0x400ee9
run
x/s 0x402400

结果发现0x402400就是我们想要的东西:Border relations with Canada have never been better.
那么我们输入的东西到哪里去了?断点打到strings_not_equal里面,查看strings_not_equal汇编代码（在gdb中输入disas strings_not_equal）

Dump of assembler code for function strings_not_equal:0x0000000000401338 <+0>:	push   %r120x000000000040133a <+2>:	push   %rbp 0x000000000040133b <+3>:	push   %rbx0x000000000040133c <+4>:	mov    %rdi,%rbx0x000000000040133f <+7>:	mov    %rsi,%rbp0x0000000000401342 <+10>:	call   0x40131b <string_length>0x0000000000401347 <+15>:	mov    %eax,%r12d0x000000000040134a <+18>:	mov    %rbp,%rdi0x000000000040134d <+21>:	call   0x40131b <string_length>0x0000000000401352 <+26>:	mov    $0x1,%edx0x0000000000401357 <+31>:	cmp    %eax,%r12d0x000000000040135a <+34>:	jne    0x40139b <strings_not_equal+99>0x000000000040135c <+36>:	movzbl (%rbx),%eax0x000000000040135f <+39>:	test   %al,%al0x0000000000401361 <+41>:	je     0x401388 <strings_not_equal+80>0x0000000000401363 <+43>:	cmp    0x0(%rbp),%al0x0000000000401366 <+46>:	je     0x401372 <strings_not_equal+58>0x0000000000401368 <+48>:	jmp    0x40138f <strings_not_equal+87>0x000000000040136a <+50>:	cmp    0x0(%rbp),%al0x000000000040136d <+53>:	nopl   (%rax)0x0000000000401370 <+56>:	jne    0x401396 <strings_not_equal+94>0x0000000000401372 <+58>:	add    $0x1,%rbx

断点打到0x401338的位置，运行程序
不停的stepi，知道运行到了第一次调用string_length函数,字符串一般来说是需要一个基址的,所以找能充当基指指针的寄存器,下面是试探过程

x/s $rbp //这个是内置字符串
x/s $rbx //这个是我们输入的字符串

答案

Border relations with Canada have never been better.

进入strings_not_equal函数才能看到我们输入的字符串是保存在%rbx这个寄存器当中的

phase_2 循环

disas phase_2得到如下代码(我分成了两部分,这个是前面一部分)

   0x0000000000400efc <+0>:	push   %rbp  0x0000000000400efd <+1>:	push   %rbx 0x0000000000400efe <+2>:	sub    $0x28,%rsp0x0000000000400f02 <+6>:	mov    %rsp,%rsi0x0000000000400f05 <+9>:	call   0x40145c <read_six_numbers> //这里从名字可以知道要输入6个数字，那么是整形还是浮点数呢?这里先输入6个整形试试

输入stepi进入到read_six_numbers函数中，disas read_six_numbers得到下面的代码

Dump of assembler code for function read_six_numbers:0x000000000040145c <+0>:	sub    $0x18,%rsp  // 这个不用管0x0000000000401460 <+4>:	mov    %rsi,%rdx0x0000000000401463 <+7>:	lea    0x4(%rsi),%rcx0x0000000000401467 <+11>:	lea    0x14(%rsi),%rax0x000000000040146b <+15>:	mov    %rax,0x8(%rsp)0x0000000000401470 <+20>:	lea    0x10(%rsi),%rax0x0000000000401474 <+24>:	mov    %rax,(%rsp)0x0000000000401478 <+28>:	lea    0xc(%rsi),%r90x000000000040147c <+32>:	lea    0x8(%rsi),%r80x0000000000401480 <+36>:	mov    $0x4025c3,%esi   //看看%esi寄存器的内容0x0000000000401485 <+41>:	mov    $0x0,%eax0x000000000040148a <+46>:	call   0x400bf0 <__isoc99_sscanf@plt>0x000000000040148f <+51>:	cmp    $0x5,%eax0x0000000000401492 <+54>:	jg     0x401499 <read_six_numbers+61>0x0000000000401494 <+56>:	call   0x40143a <explode_bomb>0x0000000000401499 <+61>:	add    $0x18,%rsp0x000000000040149d <+65>:	ret

注意这一行mov $0x4025c3,%esi,因为字符串是不可变的，地址固定死了，所以找立即数
esi寄存器的内容为
在这里插入图片描述
六个整形数据猜测是对的，我们输入1 2 3 4 5 6试试
继续阅读phase_2后部分的代码

0x0000000000400f05 <+9>:	call   0x40145c <read_six_numbers>0x0000000000400f0a <+14>:	cmpl   $0x1,(%rsp) // (%rsp)=*rsp 就是我们输入的第一个数字10x0000000000400f0e <+18>:	je     0x400f30 <phase_2+52> // 判断是否相等，相等就跳转0x0000000000400f10 <+20>:	call   0x40143a <explode_bomb> //否则就炸了0x0000000000400f15 <+25>:	jmp    0x400f30 <phase_2+52>0x0000000000400f17 <+27>:	mov    -0x4(%rbx),%eax // eax保存的是我们输入的第一个数，把rbx存放的值减40x0000000000400f1a <+30>:	add    %eax,%eax  // eax*=20x0000000000400f1c <+32>:	cmp    %eax,(%rbx) // 比较eax的值和rbx(就是第二个值)是否相等0x0000000000400f1e <+34>:	je     0x400f25 <phase_2+41> // 相等就跳转0x0000000000400f20 <+36>:	call   0x40143a <explode_bomb> //反之爆炸0x0000000000400f25 <+41>:	add    $0x4,%rbx // 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 // 0x4(%rsp)=我们输入的第二个数,加4的原因是因为int类型是4个字节0x0000000000400f35 <+57>:	lea    0x18(%rsp),%rbp// 0x18转换为十进制数为24,也就是第6个数字后面的第一个存储单元0x0000000000400f3a <+62>:	jmp    0x400f17 <phase_2+27>0x0000000000400f3c <+64>:	add    $0x28,%rsp

意思如下
程序开始时,将 (%rsp) 的值与立即数$0x1进行比较，所以第一个输入数必须为1，跳转至400f30，用lea指令分别加载%rsp+4和%rsp+24对应的地址到%rbx和%rbp，因为int型数据占4个字节，所以%rbx和%rbp分别存放第2个输入数的地址和第6个输入数的后一块的地址
后跳转至400f17，此时(%rbx-4)对应的值即(%rsp)对应的值，将其存放值%eax中，将该值*2后与(%rbx)对应的值（即第二个输入值）进行比较，即后一个数是前一个数的2倍，所以第二个输入值必须为2，后跳转至400f25，得到%rbx=%rbx+4，与%rbp进行比较（%rbx对应的值(地址)是否为%rbp对应的值(地址)），若不相等则又跳转至400f17重复操作，若相等，则跳转至400f3c，结束循环，可知这是一个循环操作，看是否比较完6个数。

循环中寄存器对应的值为:

%rbx	%rbp	%eax
%rsp+4	%rsp+24	(%rsp)*2=2
%rsp+8		(%rsp)*2=4
%rsp+12		(%rsp)*2=8
%rsp+16		(%rsp)*2=16
%rsp+20		(%rsp)*2=32
%rsp+24

c代码如下

int main(){int[] array = new int[6];for(int i=1;i<6;i++)array[i]=array[i-1]*2;return 0;
}

答案

1 2 4 8 16 32

输入的第一个数时保存在(%rsp)中

phase_3 分支语句

对汇编代码进行分析

Dump of assembler code for function phase_3:0x0000000000400f43 <+0>:	sub    $0x18,%rsp0x0000000000400f47 <+4>:	lea    0xc(%rsp),%rcx //这个可能是存储第二个数的0x0000000000400f4c <+9>:	lea    0x8(%rsp),%rdx//这个可能是存储第一个数的0x0000000000400f51 <+14>:	mov    $0x4025cf,%esi  //出现立即数了,后面调用了scanf，这里应该是初始化的，在gdb 中用x/s $esi 可以得到 %d %d0x0000000000400f56 <+19>:	mov    $0x0,%eax0x0000000000400f5b <+24>:	call   0x400bf0 <__isoc99_sscanf@plt>0x0000000000400f60 <+29>:	cmp    $0x1,%eax//%eax存储函数的返回值的，scanf的函数返回值就是输入数据的个数0x0000000000400f63 <+32>:	jg     0x400f6a <phase_3+39>//若大于1就跳转0x0000000000400f65 <+34>:	call   0x40143a <explode_bomb>//否则就爆炸0x0000000000400f6a <+39>:	cmpl   $0x7,0x8(%rsp)0x0000000000400f6f <+44>:	ja     0x400fad <phase_3+106>//无符号大于则跳转，跳转就爆炸了，所以第一个数必须小于7，可以等于,但是不能是负数0x0000000000400f71 <+46>:	mov    0x8(%rsp),%eax//%eax存储的是输入的第一个数0x0000000000400f75 <+50>:	jmp    *0x402470(,%rax,8) //*0x402470 = 124,通过x/d 0x402470得到, rax是64位的，eax是32位的，就是说eax是rax的低32位，这里应该是124+%rax*8(%rax就是我们输入的第一个数)来实现跳转。0x0000000000400f7c <+57>:	mov    $0xcf,%eax0x0000000000400f81 <+62>:	jmp    0x400fbe <phase_3+123>0x0000000000400f83 <+64>:	mov    $0x2c3,%eax0x0000000000400f88 <+69>:	jmp    0x400fbe <phase_3+123>0x0000000000400f8a <+71>:	mov    $0x100,%eax0x0000000000400f8f <+76>:	jmp    0x400fbe <phase_3+123>0x0000000000400f91 <+78>:	mov    $0x185,%eax0x0000000000400f96 <+83>:	jmp    0x400fbe <phase_3+123>0x0000000000400f98 <+85>:	mov    $0xce,%eax
--Type <RET> for more, q to quit, c to continue without paging--0x0000000000400f9d <+90>:	jmp    0x400fbe <phase_3+123>0x0000000000400f9f <+92>:	mov    $0x2aa,%eax0x0000000000400fa4 <+97>:	jmp    0x400fbe <phase_3+123>0x0000000000400fa6 <+99>:	mov    $0x147,%eax0x0000000000400fab <+104>:	jmp    0x400fbe <phase_3+123>0x0000000000400fad <+106>:	call   0x40143a <explode_bomb>0x0000000000400fb2 <+111>:	mov    $0x0,%eax0x0000000000400fb7 <+116>:	jmp    0x400fbe <phase_3+123>0x0000000000400fb9 <+118>:	mov    $0x137,%eax0x0000000000400fbe <+123>:	cmp    0xc(%rsp),%eax0x0000000000400fc2 <+127>:	je     0x400fc9 <phase_3+134>0x0000000000400fc4 <+129>:	call   0x40143a <explode_bomb>0x0000000000400fc9 <+134>:	add    $0x18,%rsp0x0000000000400fcd <+138>:	ret    
End of assembler dump.

第一个数的范围是在[0,7]之间，开始试探
n1=0,跳转到0x400f7c,若n2!=0xcf,则爆炸
n1=1,跳转到0x400fb9,若n2!=0x137,则爆炸
n1=2,跳转到0x400f83,若n2!=0x2c3,则爆炸
n1=3,跳转到0x400f8a,若n2!=0x100,则爆炸
n1=4,跳转到0x400f91,若n2!=0x185,则爆炸
n1=5,跳转到0x400f98,若n2!=0xce,则爆炸
n1=6,跳转到0x400f9f,若n2!=0x2aa,则爆炸
n1=7,跳转到0x400fa6,若n2!=0x147,则爆炸

c代码

void phase_3(char* input){//0x8(%rsp) 0xc(%rsp)int n1,n2;//res存放返回输入数据的个数int res = sscanf(input,"%d %d",&n1,&n2);if(res<=1)explode_bomb();switch(n1){case 0:if(n2!=0xcf)explode_bomb();break;case 1:if(n2!=0x137)explode_bomb();break;case 2:if(n2!=0x2c3)explode_bomb();break;case 3:if(n2!=0x100)explode_bomb();break;case 4:if(n2!=0x185)explode_bomb();break;case 5:if(n2!=0xce)explode_bomb();break;case 6:if(n2!=0x2aa)explode_bomb();break;case 7:if(n2!=0x147)explode_bomb();break;}
}

答案

0 207
1 311
2 707
3 256
4 389
5 206
6 682
7 327

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	# 通过x/s 0x4025cf 可以得到是格式化字符串"%d %d"0x000000000040101f <+19>:	mov    $0x0,%eax        # 这个就不说了0x0000000000401024 <+24>:	call   0x400bf0 <__isoc99_sscanf@plt> # 调用了scanf函数0x0000000000401029 <+29>:	cmp    $0x2,%eax	# 如果输入的数字个数不等于2就爆炸了0x000000000040102c <+32>:	jne    0x401035 <phase_4+41>0x000000000040102e <+34>:	cmpl   $0xe,0x8(%rsp)  # 比较第一个数与14的大小，若小于就跳转，若大于就爆炸，第一个数的范围[0,14]0x0000000000401033 <+39>:	jbe    0x40103a <phase_4+46>0x0000000000401035 <+41>:	call   0x40143a <explode_bomb>0x000000000040103a <+46>:	mov    $0xe,%edx       0x000000000040103f <+51>:	mov    $0x0,%esi0x0000000000401044 <+56>:	mov    0x8(%rsp),%edi0x0000000000401048 <+60>:	call   0x400fce <func4> #调用func4 应该是需要%edx %esi %edi这几个参数0x000000000040104d <+65>:	test   %eax,%eax	# 按位逻辑与操作0x000000000040104f <+67>:	jne    0x401058 <phase_4+76> # 如果%eax不等于0,则跳转至爆炸0x0000000000401051 <+69>:	cmpl   $0x0,0xc(%rsp)	#比较第二个数与0的大小关系0x0000000000401056 <+74>:	je     0x40105d <phase_4+81> #相等就跳转结尾0x0000000000401058 <+76>:	call   0x40143a <explode_bomb> #不相等就爆炸0x000000000040105d <+81>:	add    $0x18,%rsp0x0000000000401061 <+85>:	ret

接下来看看func4干了什么

Dump of assembler code for function func4:0x0000000000400fce <+0>:	sub    $0x8,%rsp   # 为局部变量腾出空间0x0000000000400fd2 <+4>:	mov    %edx,%eax   # 0xe0x0000000000400fd4 <+6>:	sub    %esi,%eax   # 0xe-0x00x0000000000400fd6 <+8>:	mov    %eax,%ecx   # ecx = 0xe0x0000000000400fd8 <+10>:	shr    $0x1f,%ecx  # %ecx的值逻辑右移31位=1110>>31=14/2^31 =00x0000000000400fdb <+13>:	add    %ecx,%eax   # ecx = ecx + eax = 0 + e0x0000000000400fdd <+15>:	sar    %eax	   # 算数右移1位 %eax = %eax /2 = 0xe/2 = 7 0x0000000000400fdf <+17>:	lea    (%rax,%rsi,1),%ecx # %eax是%rax的低32位，%esi是%rsi的低32位  %rax + %rsi * 1 = 7 + 0=7 %ecx=70x0000000000400fe2 <+20>:	cmp    %edi,%ecx  #  %edi保存的是输入的第一个数字 %ecx = 7 0x0000000000400fe4 <+22>:	jle    0x400ff2 <func4+36>0x0000000000400fe6 <+24>:	lea    -0x1(%rcx),%edx  # 7 -1 =>edx=60x0000000000400fe9 <+27>:	call   0x400fce <func4> # 递归调用0x0000000000400fee <+32>:	add    %eax,%eax	# eax*=20x0000000000400ff0 <+34>:	jmp    0x401007 <func4+57>  # 出口0x0000000000400ff2 <+36>:	mov    $0x0,%eax  # %eax = 00x0000000000400ff7 <+41>:	cmp    %edi,%ecx  # n1, 7 0x0000000000400ff9 <+43>:	jge    0x401007 <func4+57> # n1>=7跳转到func7 出口0x0000000000400ffb <+45>:	lea    0x1(%rcx),%esi  # ecx是rcx的低32位     0x1+7=>esi=8 0x0000000000400ffe <+48>:	call   0x400fce <func4>	  # 跳转0x0000000000401003 <+53>:	lea    0x1(%rax,%rax,1),%eax # 0x1 + func4+func4=>eax0x0000000000401007 <+57>:	add    $0x8,%rsp0x000000000040100b <+61>:	ret

看看这个

 0x0000000000401051 <+69>:	cmpl   $0x0,0xc(%rsp)	#比较第二个数与0的大小关系0x0000000000401056 <+74>:	je     0x40105d <phase_4+81> #相等就跳转结尾0x000000000040104d <+65>:	test   %eax,%eax	# 按位逻辑与操作0x000000000040104f <+67>:	jne    0x401058 <phase_4+76> # 如果%eax不等于0,则跳转至爆炸

所以n2必须等于0，n1的值要让函数func4的返回值为4，且n1∈[0,14]

//a: %edi b:%esi c:%edx d: %ecx e:%eax
int func4(int a,int b,int c)
{//a in %rdi,b in %rsi,c in %rdx,e in %rax,d in %ecx//y的初始值为0，z的初始值为14int t=c-b;int d=e>>31;e=(e+d)>>1;d=e+b;if(k>a){c=d-1;func4(a,b,c);e*=2;return e;}else{e=0;if(d<a){b=da+1;func4(a,b,c);e=2*e+1;return e;}elsereturn e;   //要使返回值e（%eax）为0，其中一个答案为a=d=7}
}