一些命令：
objdump -d bomb >bomb.s//将反汇编代码放在bomb.s文本中方便查看
gdb bomb//用gdb调试器调试代码
b phase_1//设置断点 截断代码 进入第一个炸弹的拆除
run//试运行代码
info x //查看寄存器
disas phase_1//查看第一个炸弹的汇编代码
x/s 0x402400//查看对应地址存放的内容 找到解题的线索
quit//退出
目录
一、phase_1
二、phase_2
三、phase_3
四、phase_4
五、phase_5
六、phase_6
一、phase_1
进入调试模式之后，首先输入"disas phase_1"查看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.
第一行准备栈帧,第二行就是将地址存入%esi, 这是一个字符串的地址, 可以猜测下面string_not_equal就是比较这个字符串与输入字符串是否相等的函数。先比较长度,然后逐一比较，找到这个地址0x402400存储的字符串即可。输入"x/s 0x804a264"查看此处的信息，得到字符串"Border relations with Canada have never been better."
综上，phase_1的通关密码为 ："Border relations with Canada have never been better."
二、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)//比较%rsp和1
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//%eax = -0x4(%ebx)
0x0000000000400f1a <+30>: add %eax,%eax//%eax中的值翻倍
0x0000000000400f1c <+32>: cmp %eax,(%rbx)//将%eax中的值与*(%rbx)作比较
0x0000000000400f1e <+34>: je 0x400f25 <phase_2+41>//相等则不会爆炸
0x0000000000400f20 <+36>: callq 0x40143a <explode_bomb>
0x0000000000400f25 <+41>: add $0x4,%rbx#%rbx += 0x4
0x0000000000400f29 <+45>: cmp %rbp,%rbx//比较%rbx和%rbp
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.
<phase_2+14> - <phase_2+20>：将第一个参数和1比较，如果两者相等则不会爆炸，这里得出第一个数必为1
<phase_2+27> - <phase_2+48>： 这一段代码相当于一个do-while循环，因为前面的代码限制第一个数只能为1，下面的代码就是对剩下的5个数进行限制。首先得到第一个数（-0x4(%rbx)）的值，然后将它的2倍存入%eax寄存器，然后将(%rbx)在内存中的值（也就是输入的第二个数）和%eax进行比较，只有两个值相等时才不会爆炸，然后将%rbx加4（也就是下一个数的地址），最后判断当的%rbx和%rbp是否相等，如果相等则跳出循环，否则再次进入循环。
综上分析，输入的6个数应该满足后一个数为前一个数的2倍，而因为第一个数只能为1，因此phase_2的通关密码为：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//用gdb查看, 得到“%d %d”,说明输入两个数字
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)//第一个参数是否小于等于7,大于则boom
0x0000000000400f6f <+44>: ja 0x400fad <phase_3+106>
0x0000000000400f71 <+46>: mov 0x8(%rsp),%eax
0x0000000000400f75 <+50>: jmpq *0x402470(,%rax,8)//以下是switch, 根据rax,即第一个输入的参数跳转
0x0000000000400f7c <+57>: mov $0xcf,%eax//由此容易得到答案, 比如这里是rax=0时, 则 另一个参数为0xcf = 207
0x0000000000400f81 <+62>: jmp 0x400fbe <phase_3+123>
0x0000000000400f83 <+64>: mov $0x2c3,%eax//如果rax=2时, 则 另一个参数为0x2c3 = 707
0x0000000000400f88 <+69>: jmp 0x400fbe <phase_3+123>
0x0000000000400f8a <+71>: mov $0x100,%eax//如果rax=3时, 则 另一个参数为0x100 = 256
0x0000000000400f8f <+76>: jmp 0x400fbe <phase_3+123>
0x0000000000400f91 <+78>: mov $0x185,%eax//如果rax=4时, 则 另一个参数为0x185 = 389
0x0000000000400f96 <+83>: jmp 0x400fbe <phase_3+123>
0x0000000000400f98 <+85>: mov $0xce,%eax//如果rax=5时, 则 另一个参数为0xce = 206
0x0000000000400f9d <+90>: jmp 0x400fbe <phase_3+123>
0x0000000000400f9f <+92>: mov $0x2aa,%eax//如果rax=6时, 则 另一个参数为0x2aa = 682
0x0000000000400fa4 <+97>: jmp 0x400fbe <phase_3+123>
0x0000000000400fa6 <+99>: mov $0x147,%eax//如果rax=7时, 则 另一个参数为0x147 = 327
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//如果rax=1时, 则 另一个参数为0x137 = 311
0x0000000000400fbe <+123>: cmp 0xc(%rsp),%eax
0x0000000000400fc2 <+127>: je 0x400fc9 <phase_3+134>
综上，swith跳转表如下（%rax 跳转地址 0xc(%rsp)）：
0 0x0000000000400f7c 0xcf 207
1 0x0000000000400fb9 0x137 311
2 0x0000000000400f83 0x2c3 707
3 0x0000000000400f8a 0x100 256
4 0x0000000000400f91 0x185 389
5 0x0000000000400f98 0xce 206
6 0x0000000000400f9f 0x2aa 682
7 0x0000000000400fa6 0x147 327
所以，phase_3的通关密码有以下8组:
0 207
1 311
2 707
3 256
4 389
5 206
6 682
7 327
四、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//gdb 中x /s，知道输入两个数字
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)//判断每个数是否≤14 ,大于则boom
0x0000000000401033 <+39>: jbe 0x40103a <phase_4+46>
0x0000000000401035 <+41>: callq 0x40143a <explode_bomb>
0x000000000040103a <+46>: mov $0xe,%edx//构造func4的参数
0x000000000040103f <+51>: mov $0x0,%esi
0x0000000000401044 <+56>: mov 0x8(%rsp),%edi
0x0000000000401048 <+60>: callq 0x400fce <func4>
0x000000000040104d <+65>: test %eax,%eax//测试, func4返回0, 若不,则boom
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.
将func4转换为c语言,并用0–14测试：
int func4(int a, int b, int c)
{
int result;
result = c;
result = result - b;
int tmp = result;
tmp = (unsigned)tmp >> 31;
result = result + tmp;
result = result / 2;
tmp = result + b;
if(tmp > a)
{
c = tmp - 1;
result = func4(a, b, c);
return (2 * result);
}
result = 0;
if(tmp < a)
{
b = tmp + 1;
result = func4(a, b, c);
return (1 + 2 * result);
}
return result;
}
// 一开始传入的参数为func4(x,0,14)
// 首次传入进入func4的mid值为7，因而若x=7，可以直接return 0
// 其他的答案可通过编译运行得出，下面测试从0~14范围内满足条件的值
int main()
{
for(int input = 0; input < 15; ++input)
{
int result = func4(input, 0, 14);
if(result == 0)
{
printf("input = %d, func4 = %d\n", input, result);
}
}
return 0;
}
通过编译运行得到可行解为
0 0
1 0
3 0
7 0
综上可得phase_4的通关密码。
五、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//从栈帧中取出各个字符,记为x
0x000000000040108f <+45>: mov %cl,(%rsp)
0x0000000000401092 <+48>: mov (%rsp),%rdx
0x0000000000401096 <+52>: and $0xf,%edx//y=0xf & x, 即将一个byte的高4位置0
0x0000000000401099 <+55>: movzbl 0x4024b0(%rdx),%edx//用gdb查看x /s 0x4024b0 得到字符串"maduiersnfotvbyl",所以这一行是以y作为偏移量,取字符数组的第几个字符
0x00000000004010a0 <+62>: mov %dl,0x10(%rsp,%rax,1)//将取得的存于栈帧中
0x00000000004010a4 <+66>: add $0x1,%rax
0x00000000004010a8 <+70>: cmp $0x6,%rax//循环6次
0x00000000004010ac <+74>: jne 0x40108b <phase_5+41>
0x00000000004010ae <+76>: movb $0x0,0x16(%rsp)
0x00000000004010b3 <+81>: mov $0x40245e,%esi//此为要比较的字符串, 用gdb查看得到 "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
对flyers的每个字符, 得到在字符数组中的index, 也就是输入的字符的后4位bit, 而键盘输入一般是字母, 所以很可能有两种可能,字符byte的高四位为‘0100’或‘0110’,而且可以发现刚好这是大写字母/小写字母开始的前一个ascii。
综上，phase_5的通关密码为"ionefg"或是"IONEFG"。
六、phase_6
(gdb) disas phase_6
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 //%rsp = 0x7fffffffe2c0
0x00000000004010fc<+8>:sub $0x50,%rsp //分配栈空间 %rsp = 0x7fffffffe270
0x0000000000401100 <+12>: mov %rsp,%r13
0x0000000000401103 <+15>: mov %rsp,%rsi
0x0000000000401106 <+18>: callq 0x40145c <read_six_numbers> //读入6个值,保存至从 %rsi 开始的地址
0x000000000040110b <+23>: mov %rsp,%r14
0x000000000040110e <+26>: mov $0x0,%r12d //%r12 置0,并且%r13 %r14 %rbp 均和 %rsp 指向相同地址 0x7fffffffe270
0x0000000000401114 <+32>: mov %r13,%rbp
0x0000000000401117 <+35>: mov 0x0(%r13),%eax //将第 %r13 指向的输入数复制到 %eax
0x000000000040111b <+39>: sub $0x1,%eax //将输入数减1
0x000000000040111e <+42>: cmp $0x5,%eax //判断输入数是否小于等于6,因为上一步中减1操作
0x0000000000401121 <+45>: jbe 0x401128 <phase_6+52> //若大于6,则调用 explode_bomb
0x0000000000401123 <+47>: callq 0x40143a <explode_bomb>
0x0000000000401128 <+52>: add $0x1,%r12d //将 %r12 加1
0x000000000040112c <+56>: cmp $0x6,%r12d //判断 %r12 是否等于6
0x0000000000401130 <+60>: je 0x401153 <phase_6+95> //若等于6,跳转,否则继续执行 0x0000000000401132 <+62>: mov %r12d,%ebx //将 %r12 复制到 %ebx
0x0000000000401135 <+65>: movslq %ebx,%rax //将 %ebx 符号位扩展复制到 %rax 0x0000000000401138 <+68>: mov (%rsp,%rax,4),%eax //将第 %ebx 输入数复制到 %eax 0x000000000040113b <+71>: cmp %eax,0x0(%rbp) //比较 %r13 指向的输入数和 第 %ebx 输入数 是否相等
0x000000000040113e <+74>: jne 0x401145 <phase_6+81> //如果相等,则调用 explode_bomb
0x0000000000401140 <+76>: callq 0x40143a <explode_bomb>
0x0000000000401145 <+81>: add $0x1,%ebx //将 %ebx 加1
0x0000000000401148 <+84>: cmp $0x5,%ebx //判断 %ebx 是否小于等于5
0x000000000040114b <+87>: jle 0x401135 <phase_6+65> //若小于等于,跳转,否则继续执行;该循环判断 %r13 指向的数据和其后输入数不相等
0x000000000040114d <+89>: add $0x4,%r13 //将 %r13 指向下一个输入数,该循环判断所有的输入数全部不相等
0x0000000000401151 <+93>: jmp 0x401114 <phase_6+32>
0x0000000000401153 <+95>: lea 0x18(%rsp),%rsi //将 %rsi 指向栈中跳过读入数据位置作为结束标记,并且 %r14 仍和 %rsp 指向同一个位置
0x0000000000401158 <+100>: mov %r14,%rax //将 %r14 复制到 %rax
0x000000000040115b <+103>: mov $0x7,%ecx
0x0000000000401160 <+108>: mov %ecx,%edx //将立即数0x7复制到 %edx
0x0000000000401162 <+110>: sub (%rax),%edx //立即数7减去 %r14 指向的数据 0x0000000000401164 <+112>: mov %edx,(%rax) //将7减的结果存回 %r14 执行的内存单元
0x0000000000401166 <+114>: add $0x4,%rax //%rax 指向下一个输入数
0x000000000040116a <+118>: cmp %rsi,%rax //比较是否达到输入数组的末尾,
0x000000000040116d <+121>: jne 0x401160 <phase_6+108> //该循环使用立即数7减去每个输入数据
0x000000000040116f <+123>: mov $0x0,%esi //将 %rsi 置0
0x0000000000401174 <+128>: jmp 0x401197 <phase_6+163>
0x0000000000401176 <+130>: mov 0x8(%rdx),%rdx //将 0x8(%rdx) 指向内存单元的内容复制到 %rdx, 指向链表下一个元素
0x000000000040117a <+134>: add $0x1,%eax //将 %eax 加1
0x000000000040117d <+137>: cmp %ecx,%eax //比较 %ecx 和 %eax 是否相等
0x000000000040117f <+139>: jne 0x401176 <phase_6+130> //不相等,继续遍历链表,最终 %rdx 指向链表的第 %ecx 个节点
0x0000000000401181 <+141>: jmp 0x401188 <phase_6+148>
0x0000000000401183 <+143>: mov $0x6032d0,%edx //重置链表首地址
0x0000000000401188 <+148>: mov %rdx,0x20(%rsp,%rsi,2)
0x000000000040118d <+153>: add $0x4,%rsi
0x0000000000401191 <+157>: cmp $0x18,%rsi
0x0000000000401195 <+161>: je 0x4011ab <phase_6+183>
0x0000000000401197 <+163>: mov (%rsp,%rsi,1),%ecx //将 (%rsp + %rsi)指向的数据复制到 %ecx
0x000000000040119a <+166>: cmp $0x1,%ecx //比较 %ecx 是否小于等于1
0x000000000040119d <+169>: jle 0x401183 <phase_6+143> //若小于等于,跳转,否则继续执行, 等于1, %edx 直接指向链表首地址
0x000000000040119f <+171>: mov $0x1,%eax //将 %eax 置1
0x00000000004011a4 <+176>: mov $0x6032d0,%edx //将 %rdx 指向内存单元 0x6032d0 0x00000000004011a9 <+181>: jmp 0x401176 <phase_6+130> //跳转; 该循环根据输入数将链表中对应的第输入数个节点的地址复制到 0x20(%rsp) 开始的栈中
0x00000000004011ab <+183>: mov 0x20(%rsp),%rbx //将0x20(%rsp)的链表节点地址复制到 %rbx
0x00000000004011b0 <+188>: lea 0x28(%rsp),%rax //将 %rax 指向栈中下一个链表节点的地址
0x00000000004011b5 <+193>: lea 0x50(%rsp),%rsi //将 %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 //判断6个节点是否遍历完毕
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) //该循环按照7减去输入数据的索引重新调整链表
0x00000000004011da <+230>: mov $0x5,%ebp
0x00000000004011df <+235>: mov 0x8(%rbx),%rax //将 %rax 指向 %rbx 下一个链表节点
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 //将 %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.
(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
%rsi存储调用者phase_2栈帧的局部变量开始地址
%rdx = %rsi + 0
%rcx = %rsi + 4
%r8 = %rsi + 8
%r9 = %rsi + 12
(%rsp) = %rsi + 16
8(%rsp) = %rsi + 20
%rbp %rbx %r12~%15 被调用者保存寄存器
%r10 %r11 调用者保存寄存器
%rdi %rsi %rdx %rcx %r8 %r9 依次保存输入数1~6
假设输入数据为4 3 2 1 6 5，猜测0x6032d8为链表首地址,链表中每个节点占用12个Byte,前8字节保存两个4字Byte的整型数,剩余的4Byte存放下个节点地址。
GDB查看使用7减去对应的输入后的数据：
(gdb) p /x rsprsp1 = 0x7fffffffe270
(gdb) x/6dw 0x7fffffffe270
0x7fffffffe270: 3 4 5 6
0x7fffffffe280: 1 2
重新调整链表前的链表的结构
(gdb) x/24xw 0x006032d0
0x6032d0 : 0x0000014c 0x00000001 0x006032e0 0x00000000
0x6032e0 : 0x000000a8 0x00000002 0x006032f0 0x00000000
0x6032f0 : 0x0000039c 0x00000003 0x00603300 0x00000000
0x603300 : 0x000002b3 0x00000004 0x00603310 0x00000000
0x603310 : 0x000001dd 0x00000005 0x00603320 0x00000000
0x603320 : 0x000001bb 0x00000006 0x00000000 0x00000000
保存在栈中链表节点信息
(gdb) x/6xg 0x7fffffffe290
0x7fffffffe290: 0x00000000006032f0 0x0000000000603300
0x7fffffffe2a0: 0x0000000000603310 0x0000000000603320
0x7fffffffe2b0: 0x00000000006032d0 0x00000000006032e0
按照7减去对应的输入后重新调整链表后的链表结构,索引顺序为 3 4 5 6 1 2
(gdb) x/24xw 0x006032d0
0x6032d0 : 0x0000014c 0x00000001 0x006032e0 0x00000000
0x6032e0 : 0x000000a8 0x00000002 0x00000000 0x00000000
0x6032f0 : 0x0000039c 0x00000003 0x00603300 0x00000000
0x603300 : 0x000002b3 0x00000004 0x00603310 0x00000000
0x603310 : 0x000001dd 0x00000005 0x00603320 0x00000000
0x603320 : 0x000001bb 0x00000006 0x006032d0 0x00000000
将链表中每个节点按照前4字节降序排序，因为在前面使用7减去对应的值，所以phase_6的通关密码为4 3 2 1 6 5。
最终运行结果图：
扫一扫
7475
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
