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
搜索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
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,
接着运行 run,就会在断点处停下,这里会先让我们输入第一关的密码,随便输入一个抵达断点再说。
现在到断点了,可以利用 disas 来看看对应的汇编代码
可以用info registers查看寄存器目前存储的值,可以用x/s $eax 来查看我们输入的字符串qq。用 stepi 来逐步执行,就可以看到箭头的变化
这里看到 mov 语句已经执行完成了,那么可以直接用 x/s $esi 来看看传进去的到底是什么内容了:
这就是第一关的答案了,赶紧记下来!(注意每个人的都是不同的)
Border relations with Canada have never been better.
然后输入 quit 退出 gdb,新建一个文本文件 vim ans.txt,方便以后输入答案。
第二关
我们已经把第一关的答案存储在文件中了,想要使用它,需要进入gdb,设置好断点后,设置命令参数
然后run,在 phase_1 停住了,我们输入 continue,来看看答案是否正确,如果正确,应该会在 phase_2 停住,如果错误,则会在 explode_bomb 停住。
可以看到第一关已经顺利完成了,然后进入第二关。我们再随便输入一些内容,触发 phase_2 的断点。(这次输入 ww,结果如下):
分析汇编代码:
=> 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
回到正题,从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.