Bomb Lab

Lab链接
这次的任务一共有七关,六个常规关卡和一个隐藏关卡,每次我们需要输入正确的拆弹密码才能进入下一关,而具体的拆弹密码藏在汇编代码中。进入隐藏关卡的方式也在其中,这就需要我们通过阅读汇编,理解不同寄存器的常用方法,也要弄明白具体的操作符。

需要了解的一些命令

# 检查符号表
# 然后可以寻找跟 bomb 有关的内容
objdump -t bomb | less 

# 反编译
# 搜索 explode_bomb
objdump -d bomb > bomb.txt

# 显示所有字符
strings bomb | less

GDB

gdb bomb

# 获取帮助
help

# 设置断点
break explode_bomb
break phase_1

# 开始运行
run

# 检查汇编 会给出对应的代码的汇编
disas 

# 查看寄存器内容
info registers

# 打印指定寄存器
print $eax

# 单步执行
stepi

# 检查寄存器或某个地址
x/s $esi

开始

第一关

先来看看符号表 objdump -t bomb | less
20211121092420
搜索bomb相关内容,发现以下内容:

  • bomb.c
  • initialize_bomb_solve
  • explode_bomb
  • bomb_id
  • initialize_bomb

explode_bomb,通过名字知道是在拆弹失败的时候用来爆炸的,所以我们可以直接设个断点,暂停运行,不让它爆炸。

下一步反编译源文件:objdump -d bomb > bomb.txt,然后通过vim bomb.txt查看bomb.txt,搜索关键字explode_bomb
20211121094421

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

分析汇编程序:callq 的两行就是调用 strings_not_equal 和 explode_bomb 这两个函数的,而这里 %esi 对应的是第二个参数,第一个参数就是我们拆弹时需要输入的字符串了。之后的 test 是用来判断函数的返回值 %eax 是否为 0, 如果为 0 则进行跳转,否则炸弹爆炸,所以我们实际上要做的,就是看看 $0x402400 这个地址里对应存放的是什么字符串,也就是拆炸弹的关键了。

先 gdb bomb,然后设置断点 break explode_bomb 和 break phase_1,
20211121095057
接着运行 run,就会在断点处停下,这里会先让我们输入第一关的密码,随便输入一个抵达断点再说。
20211121095149
现在到断点了,可以利用 disas 来看看对应的汇编代码
20211121100653
可以用info registers查看寄存器目前存储的值,可以用x/s $eax 来查看我们输入的字符串qq。用 stepi 来逐步执行,就可以看到箭头的变化
20211121101057
这里看到 mov 语句已经执行完成了,那么可以直接用 x/s $esi 来看看传进去的到底是什么内容了:
20211121101309
这就是第一关的答案了,赶紧记下来!(注意每个人的都是不同的)
Border relations with Canada have never been better.
然后输入 quit 退出 gdb,新建一个文本文件 vim ans.txt,方便以后输入答案。

第二关

我们已经把第一关的答案存储在文件中了,想要使用它,需要进入gdb,设置好断点后,设置命令参数
20211121102027
然后run,在 phase_1 停住了,我们输入 continue,来看看答案是否正确,如果正确,应该会在 phase_2 停住,如果错误,则会在 explode_bomb 停住。
20211121102759
可以看到第一关已经顺利完成了,然后进入第二关。我们再随便输入一些内容,触发 phase_2 的断点。(这次输入 ww,结果如下):
20211121102922
分析汇编代码:

=> 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   

从函数名可以得知,这一次要读入六个数字 read_six_numbers,esi存栈指针当前值作为参数传入,所以六个数字是存储在栈上的。

以不触发炸弹为前提,即比较全部为true。从 cmpl $0x1, (%rsp) 看出第一个数字一定是 1,然后跳转到 +52 的位置,%rsp的值+4存入%rbx,%rsp的值+0x18存入%rbp,跳转到 +27 的位置,执行mov指令,即%eax=(%rbx - 4)(又指向了第一个数字)即1存入%eax,%eax的值加倍即为2,%eax与(%rbx)比较,得出第二个数字为2.

接着跳转到 +41 的位置,%rbx的值+4,%rbx与%rbp比较,前面%rbp是在%rsp的基础上加0x18的,所以不目前%rbx只加了8,还未达到19。跳转到+27,执行mov指令,即%eax=(%rbx-4)(指向了第二个数字)即2存入%eax,%eax的值加倍即为4,%eax与(%rbx)比较,得出第三个数字为4.

然后进行循环的累加并返回到 +27 的位置,继续循环,直到%rbx==%rbp,每次%rbx+4,6个数字即为0x18,刚好为%rbp初始赋予的值。分析可以得到每次增大一倍,答案就是 1 2 4 8 16 32。

后面几关是同样的方法,只不过代码更长更复杂一些,仔细分析指令即可,就不再详细描述了。

第三关

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.

查看0x4025cf这个值,是一个输入格式:%d %d,即输入两个整数
代码很长,但是很多比较和跳转,由此想到switch语句,并且是有0~7 8个入口的。这里我选择第一个case,即第一个参数输入0,即进入到mov $0xcf,%eax 这条指令,那么第二个参数即为0xcf,十进制为207.所以这一关的答案为:0 207

第四关

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.
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.

这一关考察函数递归。0x4025cf与上一关一样,输入两个整数,且第一个参数小于14.将func4翻译一下:

public static int fun4(int x,int y,int z){
        int res = x-y;
        int temp = res >> 5;
        res = (res + temp) >> 1;
        temp = res + y;
        if (temp > z){
            x = temp -1;
            res = fun4(x,y,z)*2;
            return res;
        }
        res = 0;
        if (temp >= z)
            return res;
        y = temp+1;
        res = fun4(x,y,z)*2+1;
        return res;
    }

由test %eax,%eax得出fun4需返回0才不会爆炸,于是乎循环调用fun4得到当参数为7的时候返回0。第二个数字由mov $0x0,%eax得出,为0.所以答案为:7 0

第五关

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 #字符串长度为6
   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>
  # 循环等价于:
  # for(int i=0;i<6;i++){
  #     narr[i] = array[input[i]&0xf]
  # }	
   0x00000000004010ae <+76>:	movb   $0x0,0x16(%rsp)
   0x00000000004010b3 <+81>:	mov    $0x40245e,%esi #入参之一:0x40245e字符串,即flyers
   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.

从0x4024b0开始的16个数据,查看的时候遇到了这个HHHH
20211125142204
回到正题,从0x4024b0开始的16(为什么16,因为是和0xf相与,故有0-15的下标,即为16个数字)个数据:

(gdb) x/16c 0x4024b0
0x4024b0 <array.3449>:	109 'm'	97 'a'	100 'd'	117 'u'	105 'i'	101 'e'	114 'r'	115 's'
0x4024b8 <array.3449+8>:	110 'n'	102 'f'	111 'o'	116 't'	118 'v'	98 'b'	121 'y'	108 'l'

也就是说,这关要求的是

// 已知有:
char array[16] = {'m','a','d','u','i','e','r','s','n','f','o','t','v','b','y','l'};
char target[6] = {'f','l','y','e','r','s'}
// 求input[i],i属于[0,5]使得
array[input[i]&0xf] = target[i];

查ASCII码表组合一下,答案有很多种,这里取9_N567

第六关

超长代码预警!

Dump of assembler code for function phase_6:
=> 0x00000000004010f4 <+0>:	push   %r14
   0x00000000004010f6 <+2>:	push   %r13
   0x00000000004010f8 <+4>:	push   %r12
   0x00000000004010fa <+6>:	push   %rbp
   0x00000000004010fb <+7>:	push   %rbx
   0x00000000004010fc <+8>:	sub    $0x50,%rsp
   0x0000000000401100 <+12>:	mov    %rsp,%r13
   0x0000000000401103 <+15>:	mov    %rsp,%rsi
   0x0000000000401106 <+18>:	callq  0x40145c <read_six_numbers>
   0x000000000040110b <+23>:	mov    %rsp,%r14
   0x000000000040110e <+26>:	mov    $0x0,%r12d
   0x0000000000401114 <+32>:	mov    %r13,%rbp
   0x0000000000401117 <+35>:	mov    0x0(%r13),%eax
   # 输入数字 1~6
  # 断点可以设置在这里简单看一下:
  # -----
  # (gdb) x/6d $rsp
    # 0x7fffffffe350: 1       2       3       4
    # 0x7fffffffe360: 5       6
    # -----
    # 可以发现输入的数字存放的位置

   0x000000000040111b <+39>:	sub    $0x1,%eax
   0x000000000040111e <+42>:	cmp    $0x5,%eax
   0x0000000000401121 <+45>:	jbe    0x401128 <phase_6+52>
   0x0000000000401123 <+47>:	callq  0x40143a <explode_bomb>
   0x0000000000401128 <+52>:	add    $0x1,%r12d
   0x000000000040112c <+56>:	cmp    $0x6,%r12d
   0x0000000000401130 <+60>:	je     0x401153 <phase_6+95>
   0x0000000000401132 <+62>:	mov    %r12d,%ebx
   0x0000000000401135 <+65>:	movslq %ebx,%rax
   0x0000000000401138 <+68>:	mov    (%rsp,%rax,4),%eax
   0x000000000040113b <+71>:	cmp    %eax,0x0(%rbp)
   0x000000000040113e <+74>:	jne    0x401145 <phase_6+81>
   0x0000000000401140 <+76>:	callq  0x40143a <explode_bomb>
   0x0000000000401145 <+81>:	add    $0x1,%ebx
   0x0000000000401148 <+84>:	cmp    $0x5,%ebx
   0x000000000040114b <+87>:	jle    0x401135 <phase_6+65>
   0x000000000040114d <+89>:	add    $0x4,%r13
   0x0000000000401151 <+93>:	jmp    0x401114 <phase_6+32>
  # 尝试解这个多重循环
  # for (int i=0; i<6; i++){
  #     if (arr[i] - 1 > 5) bomb()
  #     for (int j=i+1; j<=5; j++) {
  #         if(arr[j] == arr[i]) bomb()
  #     }
  # }
  # 即 1. 验证每一个数字都必须<=6
  #    2. 每一个数字都不一样

   0x0000000000401153 <+95>:	lea    0x18(%rsp),%rsi
   0x0000000000401158 <+100>:	mov    %r14,%rax
   0x000000000040115b <+103>:	mov    $0x7,%ecx
   0x0000000000401160 <+108>:	mov    %ecx,%edx
   0x0000000000401162 <+110>:	sub    (%rax),%edx
   0x0000000000401164 <+112>:	mov    %edx,(%rax)
   0x0000000000401166 <+114>:	add    $0x4,%rax
   0x000000000040116a <+118>:	cmp    %rsi,%rax
   0x000000000040116d <+121>:	jne    0x401160 <phase_6+108>
   0x000000000040116f <+123>:	mov    $0x0,%esi
   # 这一段循环的操作是将所有的input原地被7减并替换

   0x0000000000401174 <+128>:	jmp    0x401197 <phase_6+163>
   0x0000000000401176 <+130>:	mov    0x8(%rdx),%rdx
   0x000000000040117a <+134>:	add    $0x1,%eax
   0x000000000040117d <+137>:	cmp    %ecx,%eax
   0x000000000040117f <+139>:	jne    0x401176 <phase_6+130>
   0x0000000000401181 <+141>:	jmp    0x401188 <phase_6+148>
   0x0000000000401183 <+143>:	mov    $0x6032d0,%edx
   0x0000000000401188 <+148>:	mov    %rdx,0x20(%rsp,%rsi,2)
---Type <return> to continue, or q <return> to quit---
   0x000000000040118d <+153>:	add    $0x4,%rsi
   0x0000000000401191 <+157>:	cmp    $0x18,%rsi
   0x0000000000401195 <+161>:	je     0x4011ab <phase_6+183>
   0x0000000000401197 <+163>:	mov    (%rsp,%rsi,1),%ecx
   0x000000000040119a <+166>:	cmp    $0x1,%ecx
   0x000000000040119d <+169>:	jle    0x401183 <phase_6+143>
   0x000000000040119f <+171>:	mov    $0x1,%eax
   0x00000000004011a4 <+176>:	mov    $0x6032d0,%edx #magic number
   0x00000000004011a9 <+181>:	jmp    0x401176 <phase_6+130>
# 这一块的逻辑很绕,可以从这个magic number入手,打印它前后的信息:
  #
  # (gdb) x 0x6032d0
    # 0x6032d0 <node1>:       0x0000014c
    #
    # 结合add = *(add+8);即mov 0x8(%rdx),%rdx,猜想应该是一个数组的结构
    # 尝试打印出更多的信息,这个结构体的信息:
    #
    # (gdb) x/24w 0x6032d0
    # 0x6032d0 <node1>:       0x0000014c      0x00000001      0x006032e0      0x00000000
    # 0x6032e0 <node2>:       0x000000a8      0x00000002      0x006032f0      0x00000000
    # 0x6032f0 <node3>:       0x0000039c      0x00000003      0x00603300      0x00000000
    # 0x603300 <node4>:       0x000002b3      0x00000004      0x00603310      0x00000000
    # 0x603310 <node5>:       0x000001dd      0x00000005      0x00603320      0x00000000
    # 0x603320 <node6>:       0x000001bb      0x00000006      0x00000000      0x00000000
    # 那这个结构体是什么样子的呢
    # 在这里,输入是1 2 3 4 5 6
    # 我们看到打印出来的结果,每个node里第2个四字节的部分和我们的输入吻合;
    # 而第三个四字节的部分则是下一个node的起始地址,最后一个四字节的部分则为0,
    # 考虑到内存对齐,我们大概能推测出,这应该是一个链表,而我们的输入的数字与在第二个四字节的地方的数据有关,第一个四字节的内容表示的是什么待确定
    # 这个结构体类似:
    # struct {
  #  int sth; // 某四字节内容
  #  int input; // 与我们的输入有关
  #  node* next; // 下一个node地址
    # } node;
    # 回头再看,发现其实这一块的逻辑,是将内存中数组的指针,放到了
    # 首地址为rsp+0x20 尾地址为rsp+0x50的地方
    # 所以现在有了两个数组
    # oldArray -> {0x6032d0 0x6032e0 0x6032f0 0x603300 0x603310 0x603320}
    # 
    # 这个sth是什么我们继续看下面的操作

   0x00000000004011ab <+183>:	mov    0x20(%rsp),%rbx
   0x00000000004011b0 <+188>:	lea    0x28(%rsp),%rax
   0x00000000004011b5 <+193>:	lea    0x50(%rsp),%rsi
   0x00000000004011ba <+198>:	mov    %rbx,%rcx
   0x00000000004011bd <+201>:	mov    (%rax),%rdx
   0x00000000004011c0 <+204>:	mov    %rdx,0x8(%rcx)
   0x00000000004011c4 <+208>:	add    $0x8,%rax
   0x00000000004011c8 <+212>:	cmp    %rsi,%rax
   0x00000000004011cb <+215>:	je     0x4011d2 <phase_6+222>
   0x00000000004011cd <+217>:	mov    %rdx,%rcx
   0x00000000004011d0 <+220>:	jmp    0x4011bd <phase_6+201>
   0x00000000004011d2 <+222>:	movq   $0x0,0x8(%rdx)
# 我们将断点打到4011da
  # 再次检视链表数据
  # (gdb) x/24w 0x6032d0
  # 0x6032d0 <node1>:       0x0000014c      0x00000001      0x00000000      0x00000000
  # 0x6032e0 <node2>:       0x000000a8      0x00000002      0x006032d0      0x00000000
  # 0x6032f0 <node3>:       0x0000039c      0x00000003      0x006032e0      0x00000000
  # 0x603300 <node4>:       0x000002b3      0x00000004      0x006032f0      0x00000000
  # 0x603310 <node5>:       0x000001dd      0x00000005      0x00603300      0x00000000
  # 0x603320 <node6>:       0x000001bb      0x00000006      0x00603310      0x00000000
  # 发现地址发生了变化,看起来头节点在node6上
  # 结合input原地被7减去,再多试几组数据后发现
  # struct {
  #  int value; // 下一部分需要比对的值
  #  int order; // node序号
  #  node* next; // 下一个node地址,会因为我们的input而改变链接顺序
    # } node;
    # 我们结合以下代码检视%rbx的值
  # (gdb) p/a $rbx
    # $4 = 0x603320 <node6>
    # 发现$rbx上存的就是头指针
    # 那么下面的逻辑也就一目了然了
    #
  # 我们输入的input序列被7减去后得到的序列,是一个向量
  # 向量中每个数字是node的序号,向量的顺序是node的链接顺序
  # 也就是说向量的第一个序号对应的node会变成头节点
  # 按照以下的逻辑
  # 我们要求这个链表按照降序排列

   0x00000000004011da <+230>:	mov    $0x5,%ebp
   0x00000000004011df <+235>:	mov    0x8(%rbx),%rax
   0x00000000004011e3 <+239>:	mov    (%rax),%eax
   0x00000000004011e5 <+241>:	cmp    %eax,(%rbx)
   0x00000000004011e7 <+243>:	jge    0x4011ee <phase_6+250>
   0x00000000004011e9 <+245>:	callq  0x40143a <explode_bomb>
   0x00000000004011ee <+250>:	mov    0x8(%rbx),%rbx
   0x00000000004011f2 <+254>:	sub    $0x1,%ebp
   0x00000000004011f5 <+257>:	jne    0x4011df <phase_6+235>
   0x00000000004011f7 <+259>:	add    $0x50,%rsp
   0x00000000004011fb <+263>:	pop    %rbx
   0x00000000004011fc <+264>:	pop    %rbp
   0x00000000004011fd <+265>:	pop    %r12
   0x00000000004011ff <+267>:	pop    %r13
   0x0000000000401201 <+269>:	pop    %r14
   0x0000000000401203 <+271>:	retq   
End of assembler dump.

打印node中的数:

(gdb) p 0x0000014c  1
$15 = 332
(gdb) p 0x000000a8  2
$16 = 168
(gdb) p 0x0000039c  3
$17 = 924
(gdb) p 0x000002b3  4
$18 = 691
(gdb) p 0x000001dd  5
$19 = 477
(gdb) p 0x000001bb  6
$20 = 443

期望的排序是:
3 4 5 6 1 2 按照7取余后,得到答案4 3 2 1 6 5
总结下来,这题的要求就是:给你6个结点,根据他们的序号按降序排列写出,并照7取余就是最终答案。
好难,要脑裂了。

彩蛋关

在第五关的时候,我不经意间发现了有关彩蛋的对话zzz。有兴趣的小伙伴可以继续盘,我。。盘不动了QAQ,最后是一个二叉树,找最后返回结果为2的输入值。

Q.E.D.


励志成为年薪百块工程师