Wrote by CS 20.4 隋春雨
参考文章：
常见指令
stack如何保存现场？
常见寄存器：
1. 第一关
从beqz指令那里可以看出，如果是字符串相等的话，那么我们就直接跳到
0x400da4，可以看到0x00400d9c是炸弹爆炸的地方，所以这一关的要点就变成了，查出原来的函数中保存的string的内容，然后输入即可
本来我最开始看到这个\就不太理解，后来用pycharm输出了一下'的asc码发现就是39,才发现是哪个'太小了没看到，所以最终拆除炸弹的结果就是Let's begin now!
PS:
GDB中X的用法
x /16c $a0类似于事后诸葛亮了，因为这是我们在知道这个结果是16位的情况下，才能x /16c $a0,才平时做实验的时候，可以多扩展几位看一看结果
2. 第二关
li
$v0:子函数调用返回的结果
参考了一下
关于mips-fp（帧指针）寄存器的理解
和
MIPS汇编角度看C语言的指针
和
mips中gp寄存器的用法
简单来说，用fp保存栈底的位置
fp:栈基址寄存器
值得注意的是：
0x00400dc0 <+4>: sw ra,60(sp)
这条指令，按照mips官方文档的解释，是这样的
个人感觉可能用lw更合适一点，为了验证一下是否保存的是返回地址，找了一下资料
可以看出作者认为，它保存的确实是返回地址。。。。Ok。。。。。那就先这样
对于move指令，查找了一下资料，
可以发现move $a0 $a1的含义就是把$a1的值送到$a0寄存器
思考：为什么
0x00400dbc <+0>: addiu sp,sp,-64
0x00400dc0 <+4>: sw ra,60(sp)
0x00400dc4 <+8>: sw s8,56(sp)
0x00400dc8 <+12>: move s8,sp
0x00400dcc <+16>: lui gp,0x42
0x00400dd0 <+20>: addiu gp,gp,-20080
0x00400dd4 <+24>: sw gp,16(sp)
0x00400dd8 <+28>: sw a0,64(s8)
0x00400ddc <+32>: addiu v0,s8,28
0x00400de0 <+36>: lw a0,64(s8)
0x00400de4 <+40>: move a1,v0
0x00400de8 <+44>: jal 0x401ba8 <read_six_numbers>
0x00400dec <+48>: nop
0x00400df0 <+52>: lw gp,16(s8)
0x00400df4 <+56>: lw v1,28(s8)
0x00400df8 <+60>: li v0,1
0x00400dfc <+64>: beq v1,v0,0x400e10 <phase_2+84>
0x00400e00 <+68>: nop
0x00400e04 <+72>: jal 0x4021f0 <explode_bomb>
0x00400e08 <+76>: nop
0x00400e0c <+80>: lw gp,16(s8)
0x00400e10 <+84>: li v0,1
0x00400e14 <+88>: sw v0,24(s8)
0x00400e18 <+92>: b 0x400ea8 <phase_2+236>
0x00400e1c <+96>: nop
0x00400e20 <+100>: lw v0,24(s8)
0x00400e24 <+104>: nop
每条指令之间的间隔都是4呢？
解决：查了一下MIPS指令的构成发现，无论是R、I、J型指令，都是
32位的，4个字节，所以MIPS指令的间隔都是4
同时查了一下beqz指令的用法
beqz $v location:若$v寄存器的值为0，那么程序跳转到location
在实验二中的0x00400dfc <+64>: beq v1,v0,0x400e10 <phase_2+84>指令中
如果$v1==$v0,那么跳转到0x400e10,不会爆炸。
如果没有,那么一定会因为0x00400e04 <+72>: jal 0x4021f0 <explode_bomb>而爆炸
到这里的时候，总是遇到
---Type <return> to continue, or q <return> to quit---q的问题，查了一下，发现设置一下不分页显示就好了
set pagination off
Dump of assembler code for function phase_2:
0x00400dbc <+0>: addiu sp,sp,-64
0x00400dc0 <+4>: sw ra,60(sp)
0x00400dc4 <+8>: sw s8,56(sp)
0x00400dc8 <+12>: move s8,sp
0x00400dcc <+16>: lui gp,0x42
0x00400dd0 <+20>: addiu gp,gp,-20080
0x00400dd4 <+24>: sw gp,16(sp)
0x00400dd8 <+28>: sw a0,64(s8)
0x00400ddc <+32>: addiu v0,s8,28
0x00400de0 <+36>: lw a0,64(s8)
0x00400de4 <+40>: move a1,v0
0x00400de8 <+44>: jal 0x401ba8 <read_six_numbers>
0x00400dec <+48>: nop
0x00400df0 <+52>: lw gp,16(s8)
0x00400df4 <+56>: lw v1,28(s8)
0x00400df8 <+60>: li v0,1
0x00400dfc <+64>: beq v1,v0,0x400e10 <phase_2+84>
0x00400e00 <+68>: nop
0x00400e04 <+72>: jal 0x4021f0 <explode_bomb>
0x00400e08 <+76>: nop
0x00400e0c <+80>: lw gp,16(s8)
0x00400e10 <+84>: li v0,1
0x00400e14 <+88>: sw v0,24(s8)
0x00400e18 <+92>: b 0x400ea8 <phase_2+236>
0x00400e1c <+96>: nop
0x00400e20 <+100>: lw v0,24(s8)// 当前循环次数
0x00400e24 <+104>: nop
0x00400e28 <+108>: addiu v0,v0,-1//上一次的循环次数
0x00400e2c <+112>: sll v0,v0,0x2
0x00400e30 <+116>: addiu v1,s8,24//v1保存的起始位置
0x00400e34 <+120>: addu v0,v1,v0//找到上一个元素的位置
0x00400e38 <+124>: lw a0,4(v0)//当前的数组中的元素放到了$a0
0x00400e3c <+128>: li v1,12
0x00400e40 <+132>: lw v0,24(s8)//循环次数
0x00400e44 <+136>: nop
0x00400e48 <+140>: subu v0,v1,v0//$v0=12-循环次数
0x00400e4c <+144>: lw v1,-32660(gp)//$v1=$gp-32660
0x00400e50 <+148>: sll v0,v0,0x2//$v0=(12-循环次数)*4
0x00400e54 <+152>: addu v0,v1,v0//$v0=$gp-32660+(12-循环次数)*4
0x00400e58 <+156>: lw v0,0(v0)//$v0=Memory[$v0]
0x00400e5c <+160>: nop
0x00400e60 <+164>: mult a0,v0
0x00400e64 <+168>: mflo a0 //这里是a0最后一次被改变的位置
0x00400e68 <+172>: lw v0,24(s8)//这里是v0被改变的有效位置，$v0=循环次数
0x00400e6c <+176>: nop
0x00400e70 <+180>: sll v0,v0,0x2//$v0=循环次数*4
0x00400e74 <+184>: addiu v1,s8,24//$v1=2147479848
0x00400e78 <+188>: addu v0,v1,v0
0x00400e7c <+192>: lw v0,4(v0)
0x00400e80 <+196>: nop
0x00400e84 <+200>: beq a0,v0,0x400e98 <phase_2+220>
0x00400e88 <+204>: nop
0x00400e8c <+208>: jal 0x4021f0 <explode_bomb>
0x00400e90 <+212>: nop
0x00400e94 <+216>: lw gp,16(s8)
0x00400e98 <+220>: lw v0,24(s8)
0x00400e9c <+224>: nop
0x00400ea0 <+228>: addiu v0,v0,1
0x00400ea4 <+232>: sw v0,24(s8)
0x00400ea8 <+236>: lw v0,24(s8)
0x00400eac <+240>: nop
0x00400eb0 <+244>: slti v0,v0,6
0x00400eb4 <+248>: bnez v0,0x400e20 <phase_2+100>
0x00400eb8 <+252>: nop
0x00400ebc <+256>: move sp,s8
0x00400ec0 <+260>: lw ra,60(sp)
0x00400ec4 <+264>: lw s8,56(sp)
0x00400ec8 <+268>: addiu sp,sp,64
0x00400ecc <+272>: jr ra
0x00400ed0 <+276>: nop
End of assembler dump.
其中对于
0x00400e18 <+92>: b 0x400ea8 <phase_2+236>：猜也能猜到跳转到
0x400ea8 <phase_2+236>，查了一下官方文档
发现确实是这样
然后我想像vs那样单步查看变量的值，于是查询了一下单步执行的命令
ni
例子：
在第一个值得怀疑的地方设置一个断点
p $v0发现是1，当然从上一行的指令中我们也能看到。所以第一个数字一定是1
然后一步一步使用ni指令一步一步走，如下图
然后碰到了0x00400eb0 <+244>: slti v0,v0,6
查了一下
这条指令的含义是if $v0<6,then $v0=1,else $v0=0
继续就这么执行，直到跳转到了0x00400e20 <+100>: lw v0,24(s8)
我们之前手动分析的时候，这个地方保存的值就是1，如果不放心的话可以打印看一看
(gdb) x/1ub $s8+24
结果
继续执行，发现程序总是在调用
$gp-32660相当于基址
打印一下发现
这正好是我输入的ID-number
就 这么一步一步拆，最后发现结果是
170000，当然这组数据可能跟我取的值有关系，我输入的ID-number=996007，
结果：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aAZTJfK3-1637201619105)(拆除二进制炸弹.assets/image-20211118100337336.png)]](https://img-blog.csdnimg.cn/ebaed2b5939a4802a4800f426d597813.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQ2Fwc2ZseQ==,size_20,color_FFFFFF,t_70,g_se,x_16)
3. 第三关
Dump of assembler code for function phase_3:
0x00400ed4 <+0>: addiu sp,sp,-56
0x00400ed8 <+4>: sw ra,52(sp)
0x00400edc <+8>: sw s8,48(sp)
0x00400ee0 <+12>: move s8,sp
0x00400ee4 <+16>: lui gp,0x42
0x00400ee8 <+20>: addiu gp,gp,-20080
0x00400eec <+24>: sw gp,24(sp)
0x00400ef0 <+28>: sw a0,56(s8)
0x00400ef4 <+32>: lw a0,56(s8)
0x00400ef8 <+36>: lui v0,0x40
0x00400efc <+40>: addiu a1,v0,10112
0x00400f00 <+44>: addiu v1,s8,44
0x00400f04 <+48>: addiu v0,s8,40
0x00400f08 <+52>: addiu a2,s8,36
0x00400f0c <+56>: sw a2,16(sp)
0x00400f10 <+60>: move a2,v1
0x00400f14 <+64>: move a3,v0
0x00400f18 <+68>: lw v0,-32636(gp)
0x00400f1c <+72>: nop
0x00400f20 <+76>: move t9,v0
0x00400f24 <+80>: jalr t9
0x00400f28 <+84>: nop
0x00400f2c <+88>: lw gp,24(s8)
0x00400f30 <+92>: slti v0,v0,3
0x00400f34 <+96>: beqz v0,0x400f48 <phase_3+116>
0x00400f38 <+100>: nop
0x00400f3c <+104>: jal 0x4021f0 <explode_bomb>
0x00400f40 <+108>: nop
0x00400f44 <+112>: lw gp,24(s8)
0x00400f48 <+116>: lw v0,44(s8)
0x00400f4c <+120>: nop
0x00400f50 <+124>: sltiu v1,v0,8
0x00400f54 <+128>: beqz v1,0x401190 <phase_3+700>
0x00400f58 <+132>: nop
0x00400f5c <+136>: sll v1,v0,0x2
0x00400f60 <+140>: lui v0,0x40
0x00400f64 <+144>: addiu v0,v0,10124
0x00400f68 <+148>: addu v0,v1,v0
0x00400f6c <+152>: lw v0,0(v0)
0x00400f70 <+156>: nop
0x00400f74 <+160>: jr v0
0x00400f78 <+164>: nop
0x00400f7c <+168>: li v0,113
0x00400f80 <+172>: sb v0,32(s8)
0x00400f84 <+176>: lw v0,-32660(gp)
0x00400f88 <+180>: nop
0x00400f8c <+184>: lw v1,44(v0)
0x00400f90 <+188>: lw v0,36(s8)
0x00400f94 <+192>: nop
0x00400f98 <+196>: mult v1,v0
0x00400f9c <+200>: mflo v1
0x00400fa0 <+204>: li v0,777
0x00400fa4 <+208>: beq v1,v0,0x4011ac <phase_3+728>
0x00400fa8 <+212>: nop
0x00400fac <+216>: jal 0x4021f0 <explode_bomb>
0x00400fb0 <+220>: nop
0x00400fb4 <+224>: lw gp,24(s8)
0x00400fb8 <+228>: b 0x4011f8 <phase_3+804>
0x00400fbc <+232>: nop
0x00400fc0 <+236>: li v0,98
0x00400fc4 <+240>: sb v0,32(s8)
0x00400fc8 <+244>: lw v0,-32660(gp)
0x00400fcc <+248>: nop
0x00400fd0 <+252>: lw v1,44(v0)
0x00400fd4 <+256>: lw v0,36(s8)
0x00400fd8 <+260>: nop
0x00400fdc <+264>: mult v1,v0
0x00400fe0 <+268>: mflo v1
0x00400fe4 <+272>: li v0,214
0x00400fe8 <+276>: beq v1,v0,0x4011b8 <phase_3+740>
0x00400fec <+280>: nop
0x00400ff0 <+284>: jal 0x4021f0 <explode_bomb>
0x00400ff4 <+288>: nop
0x00400ff8 <+292>: lw gp,24(s8)
0x00400ffc <+296>: b 0x4011f8 <phase_3+804>
0x00401000 <+300>: nop
0x00401004 <+304>: li v0,98
0x00401008 <+308>: sb v0,32(s8)
0x0040100c <+312>: lw v0,-32660(gp)
0x00401010 <+316>: nop
0x00401014 <+320>: lw v1,44(v0)
0x00401018 <+324>: lw v0,36(s8)
0x0040101c <+328>: nop
0x00401020 <+332>: mult v1,v0
0x00401024 <+336>: mflo v1
0x00401028 <+340>: li v0,755
0x0040102c <+344>: beq v1,v0,0x4011c4 <phase_3+752>
0x00401030 <+348>: nop
0x00401034 <+352>: jal 0x4021f0 <explode_bomb>
0x00401038 <+356>: nop
0x0040103c <+360>: lw gp,24(s8)
0x00401040 <+364>: b 0x4011f8 <phase_3+804>
0x00401044 <+368>: nop
0x00401048 <+372>: li v0,107
0x0040104c <+376>: sb v0,32(s8)
0x00401050 <+380>: lw v0,-32660(gp)
0x00401054 <+384>: nop
0x00401058 <+388>: lw v1,44(v0)
0x0040105c <+392>: lw v0,36(s8)
0x00401060 <+396>: nop
0x00401064 <+400>: mult v1,v0
0x00401068 <+404>: mflo v0
0x0040106c <+408>: beqz v0,0x4011d0 <phase_3+764>
0x00401070 <+412>: nop
0x00401074 <+416>: jal 0x4021f0 <explode_bomb>
0x00401078 <+420>: nop
0x0040107c <+424>: lw gp,24(s8)
0x00401080 <+428>: b 0x4011f8 <phase_3+804>
0x00401084 <+432>: nop
0x00401088 <+436>: li v0,111
0x0040108c <+440>: sb v0,32(s8)
0x00401090 <+444>: lw v0,-32660(gp)
0x00401094 <+448>: nop
0x00401098 <+452>: lw v1,44(v0)
0x0040109c <+456>: lw v0,36(s8)
0x004010a0 <+460>: nop
0x004010a4 <+464>: mult v1,v0
0x004010a8 <+468>: mflo v1
0x004010ac <+472>: li v0,228
0x004010b0 <+476>: beq v1,v0,0x4011dc <phase_3+776>
0x004010b4 <+480>: nop
0x004010b8 <+484>: jal 0x4021f0 <explode_bomb>
0x004010bc <+488>: nop
0x004010c0 <+492>: lw gp,24(s8)
0x004010c4 <+496>: b 0x4011f8 <phase_3+804>
0x004010c8 <+500>: nop
0x004010cc <+504>: li v0,116
0x004010d0 <+508>: sb v0,32(s8)
0x004010d4 <+512>: lw v0,-32660(gp)
0x004010d8 <+516>: nop
0x004010dc <+520>: lw v1,44(v0)
0x004010e0 <+524>: lw v0,36(s8)
0x004010e4 <+528>: nop
0x004010e8 <+532>: mult v1,v0
0x004010ec <+536>: mflo v1
0x004010f0 <+540>: li v0,513
0x004010f4 <+544>: beq v1,v0,0x4011e8 <phase_3+788>
0x004010f8 <+548>: nop
0x004010fc <+552>: jal 0x4021f0 <explode_bomb>
0x00401100 <+556>: nop
0x00401104 <+560>: lw gp,24(s8)
0x00401108 <+564>: b 0x4011f8 <phase_3+804>
0x0040110c <+568>: nop
0x00401110 <+572>: li v0,118
0x00401114 <+576>: sb v0,32(s8)
0x00401118 <+580>: lw v0,-32660(gp)
0x0040111c <+584>: nop
0x00401120 <+588>: lw v1,44(v0)
0x00401124 <+592>: lw v0,36(s8)
0x00401128 <+596>: nop
0x0040112c <+600>: mult v1,v0
0x00401130 <+604>: mflo v1
0x00401134 <+608>: li v0,780
0x00401138 <+612>: beq v1,v0,0x40114c <phase_3+632>
0x0040113c <+616>: nop
0x00401140 <+620>: jal 0x4021f0 <explode_bomb>
0x00401144 <+624>: nop
0x00401148 <+628>: lw gp,24(s8)
0x0040114c <+632>: li v0,98
0x00401150 <+636>: sb v0,32(s8)
0x00401154 <+640>: lw v0,-32660(gp)
0x00401158 <+644>: nop
0x0040115c <+648>: lw v1,44(v0)
0x00401160 <+652>: lw v0,36(s8)
0x00401164 <+656>: nop
0x00401168 <+660>: mult v1,v0
0x0040116c <+664>: mflo v1
0x00401170 <+668>: li v0,824
0x00401174 <+672>: beq v1,v0,0x4011f4 <phase_3+800>
0x00401178 <+676>: nop
0x0040117c <+680>: jal 0x4021f0 <explode_bomb>
0x00401180 <+684>: nop
0x00401184 <+688>: lw gp,24(s8)
0x00401188 <+692>: b 0x4011f8 <phase_3+804>
0x0040118c <+696>: nop
0x00401190 <+700>: li v0,120
0x00401194 <+704>: sb v0,32(s8)
0x00401198 <+708>: jal 0x4021f0 <explode_bomb>
0x0040119c <+712>: nop
0x004011a0 <+716>: lw gp,24(s8)
0x004011a4 <+720>: b 0x4011f8 <phase_3+804>
0x004011a8 <+724>: nop
0x004011ac <+728>: nop
0x004011b0 <+732>: b 0x4011f8 <phase_3+804>
0x004011b4 <+736>: nop
0x004011b8 <+740>: nop
0x004011bc <+744>: b 0x4011f8 <phase_3+804>
0x004011c0 <+748>: nop
0x004011c4 <+752>: nop
0x004011c8 <+756>: b 0x4011f8 <phase_3+804>
0x004011cc <+760>: nop
0x004011d0 <+764>: nop
0x004011d4 <+768>: b 0x4011f8 <phase_3+804>
0x004011d8 <+772>: nop
0x004011dc <+776>: nop
0x004011e0 <+780>: b 0x4011f8 <phase_3+804>
0x004011e4 <+784>: nop
0x004011e8 <+788>: nop
0x004011ec <+792>: b 0x4011f8 <phase_3+804>
0x004011f0 <+796>: nop
0x004011f4 <+800>: nop
0x004011f8 <+804>: lb v0,40(s8)
0x004011fc <+808>: lb v1,32(s8)
0x00401200 <+812>: nop
0x00401204 <+816>: beq v1,v0,0x401218 <phase_3+836>
0x00401208 <+820>: nop
0x0040120c <+824>: jal 0x4021f0 <explode_bomb>
0x00401210 <+828>: nop
0x00401214 <+832>: lw gp,24(s8)
0x00401218 <+836>: move sp,s8
0x0040121c <+840>: lw ra,52(sp)
0x00401220 <+844>: lw s8,48(sp)
0x00401224 <+848>: addiu sp,sp,56
0x00401228 <+852>: jr ra
0x0040122c <+856>: nop
End of assembler dump.
做实验的时候发生了很多问题，比如说，输出寄存器的值没有得到预期的结果，后来发现，是x的用法有错误，sw指令，读取的时候应该读出来的是一个word而不是byte,像以下的结果就是正确的，输入一个byte,读取一个byte
在拆除实验三的时候，我跟我数学建模的队(lxr巨巨)发现了一个问题，
在这条指令中，我们执行后输出$v0发现是2137465136，但是x/1ub $gp-32636发现却是48，最后经过一个形势政策的讨论，也没有结果
经过顽强的debug发现是输出格式的错误，应该是x/1uw %gp-32636，这样就是2137465136了，确认过眼神（下次一定好好看输出格式）
我输入的是1 4 6，但是因为它是按照字符读取的，所以我们输出它的4的 asc
可以发现，是一样的，同时我们观察stack中保存变量的顺序，正好从低到高
做到这里我产生了一个疑问，如何知道s8和sp中间的东西都是什么？
于是查了一下，
fp和sp的相关知识
简单来说，fp和sp都是保存的调用她的函数的栈底和栈顶
然后我继续看汇编代码，发现
这一行其实是令$v0=Memory[$v0],同时结合上下文我们推断出来$v0=0x400000+10124+a[0]*4，其中a[0]是我们输入的数字的第一位，那么这样以来，实验平台就能检测出来我们输入的第一个数字是什么了
我们调用一下寄存器
发现$v0保存的是一个地址
那么问题来了，如果我们输入的第一位数字不是1而是别的数字会怎么办？
打印输出了10个值，结果发现正符合预期，最后2个乱码是因为8 9是UI直接爆炸，根本不会执行到这里
我们检测一下，
发现正好有（当然也必须有），同时看上下文，这个地址后面也只有一个li指令，符合我们的预期
看到这几行指令，我认为那里保存的是我输入的数据，输出一看，确实是ID-num,同时温馨提示，尽量不要选择特别奇怪的数字，比如连着2个0，你很有可能理解为那个是未初始化的内存单元的值
在分析的过程中，观察这段代码，最终发现这段其实就做了两件事情
1.将v0寄存器的值放到了Memory[$s8+32]
2. ID-num的最后一位和输入的最后一个数字相乘 ，最终和$v0比较是否相等，若相等，则跳转，否则爆炸。因为我输入的学号的最后一位是7，所以需要找到一个7的倍数的$v0,最终发现是第一个函数段，所以我们输入的第一个数字应该是0
最终我们成功跳转到了
从上文的分析中，我们知道Memory[$s8+40]保存的是输入的第2个参数，而Memory[$s8+32]保存的是113
经过分析得出，这个113其实表示的是一个字符，所以我们第2个输入q即可
4. 第四关
碰到的难点如下
func4做了什么？我们看一下func4的代码
Dump of assembler code for function func4:
0x00401230 <+0>: addiu sp,sp,-40
0x00401234 <+4>: sw ra,36(sp)
0x00401238 <+8>: sw s8,32(sp)
0x0040123c <+12>: sw s0,28(sp)
0x00401240 <+16>: move s8,sp
0x00401244 <+20>: sw a0,40(s8)
0x00401248 <+24>: lw v0,40(s8)
0x0040124c <+28>: nop
0x00401250 <+32>: slti v0,v0,2
0x00401254 <+36>: bnez v0,0x40129c <func4+108>
0x00401258 <+40>: nop
0x0040125c <+44>: lw v0,40(s8)
0x00401260 <+48>: nop
0x00401264 <+52>: addiu v0,v0,-1
0x00401268 <+56>: move a0,v0
0x0040126c <+60>: jal 0x401230 <func4>
0x00401270 <+64>: nop
0x00401274 <+68>: move s0,v0
0x00401278 <+72>: lw v0,40(s8)
0x0040127c <+76>: nop
0x00401280 <+80>: addiu v0,v0,-2
0x00401284 <+84>: move a0,v0
0x00401288 <+88>: jal 0x401230 <func4>
0x0040128c <+92>: nop
0x00401290 <+96>: addu v0,s0,v0
0x00401294 <+100>: b 0x4012a0 <func4+112>
0x00401298 <+104>: nop
0x0040129c <+108>: li v0,1
0x004012a0 <+112>: move sp,s8
0x004012a4 <+116>: lw ra,36(sp)
0x004012a8 <+120>: lw s8,32(sp)
0x004012ac <+124>: lw s0,28(sp)
0x004012b0 <+128>: addiu sp,sp,40
0x004012b4 <+132>: jr ra
0x004012b8 <+136>: nop
End of assembler dump.
我们先看这么几个关键点
看这一段汇编代码，我们可以很明显的看出，这一段调用了func4($v0-1)
再看
它调用了func($v0-2)
这是什么？这不是斐波那契数列吗？！
再看这一段
果然
所以接下来的问题就变成了，斐波那契的第几项是8
我们打表看一下
所以答案很明显，是5
5. 第五关
0x004013e8 <+0>: addiu sp,sp,-72
0x004013ec <+4>: sw ra,68(sp)
0x004013f0 <+8>: sw s8,64(sp)
0x004013f4 <+12>: move s8,sp
0x004013f8 <+16>: sw a0,72(s8)
0x004013fc <+20>: lw a0,72(s8)
0x00401400 <+24>: jal 0x401c78 <string_length>
0x00401404 <+28>: nop
0x00401408 <+32>: move v1,v0
0x0040140c <+36>: li v0,6
0x00401410 <+40>: beq v1,v0,0x401420 <phase_5+56>
0x00401414 <+44>: nop
0x00401418 <+48>: jal 0x4021f0 <explode_bomb>
0x0040141c <+52>: nop
0x00401420 <+56>: sw zero,24(s8)
0x00401424 <+60>: b 0x4014a8 <phase_5+192>
0x00401428 <+64>: nop
0x0040142c <+68>: lw v0,24(s8)
0x00401430 <+72>: lw v1,24(s8)
0x00401434 <+76>: lw a0,72(s8)
0x00401438 <+80>: nop
0x0040143c <+84>: addu v1,a0,v1
0x00401440 <+88>: lb v1,0(v1)
0x00401444 <+92>: nop
0x00401448 <+96>: andi v1,v1,0xff
0x0040144c <+100>: andi v1,v1,0xf
0x00401450 <+104>: sll v0,v0,0x2
0x00401454 <+108>: addiu a0,s8,24
0x00401458 <+112>: addu v0,a0,v0
0x0040145c <+116>: sw v1,12(v0)
0x00401460 <+120>: lw a0,24(s8)
0x00401464 <+124>: lw v0,24(s8)
0x00401468 <+128>: nop
0x0040146c <+132>: sll v0,v0,0x2
0x00401470 <+136>: addiu v1,s8,24
0x00401474 <+140>: addu v0,v1,v0
0x00401478 <+144>: lw v1,12(v0)
0x0040147c <+148>: lui v0,0x41
0x00401480 <+152>: addiu v0,v0,12524
0x00401484 <+156>: addu v0,v1,v0
0x00401488 <+160>: lb v1,0(v0)
0x0040148c <+164>: addiu v0,s8,24
0x00401490 <+168>: addu v0,v0,a0
0x00401494 <+172>: sb v1,4(v0)
0x00401498 <+176>: lw v0,24(s8)
0x0040149c <+180>: nop
0x004014a0 <+184>: addiu v0,v0,1
0x004014a4 <+188>: sw v0,24(s8)
0x004014a8 <+192>: lw v0,24(s8)
0x004014ac <+196>: nop
0x004014b0 <+200>: slti v0,v0,6
0x004014b4 <+204>: bnez v0,0x40142c <phase_5+68>
0x004014b8 <+208>: nop
0x004014bc <+212>: sb zero,34(s8)
0x004014c0 <+216>: addiu v0,s8,28
0x004014c4 <+220>: move a0,v0
0x004014c8 <+224>: lui v0,0x40
0x004014cc <+228>: addiu a1,v0,10160
0x004014d0 <+232>: jal 0x401cf8 <strings_not_equal>
0x004014d4 <+236>: nop
0x004014d8 <+240>: beqz v0,0x4014e8 <phase_5+256>
0x004014dc <+244>: nop
0x004014e0 <+248>: jal 0x4021f0 <explode_bomb>
0x004014e4 <+252>: nop
0x004014e8 <+256>: move sp,s8
0x004014ec <+260>: lw ra,68(sp)
0x004014f0 <+264>: lw s8,64(sp)
0x004014f4 <+268>: addiu sp,sp,72
0x004014f8 <+272>: jr ra
0x004014fc <+276>: nop
首先我们要看一下string_length的代码，我们大体猜测，这个函数应该是计算我们输入的字符串的长度，不过还需要看看代码验证一下
0x00401c78 <+0>: addiu sp,sp,-24
0x00401c7c <+4>: sw s8,20(sp)
0x00401c80 <+8>: move s8,sp
0x00401c84 <+12>: sw a0,24(s8)
0x00401c88 <+16>: lw v0,24(s8)
0x00401c8c <+20>: nop
0x00401c90 <+24>: sw v0,12(s8)
0x00401c94 <+28>: sw zero,8(s8)
0x00401c98 <+32>: b 0x401cb0 <string_length+56>
0x00401c9c <+36>: nop
0x00401ca0 <+40>: lw v0,8(s8)
0x00401ca4 <+44>: nop
0x00401ca8 <+48>: addiu v0,v0,1
0x00401cac <+52>: sw v0,8(s8)
0x00401cb0 <+56>: lw v0,12(s8)
0x00401cb4 <+60>: nop
0x00401cb8 <+64>: lb v0,0(v0)
0x00401cbc <+68>: nop
0x00401cc0 <+72>: sltu v0,zero,v0
0x00401cc4 <+76>: andi v0,v0,0xff
0x00401cc8 <+80>: lw v1,12(s8)
0x00401ccc <+84>: nop
0x00401cd0 <+88>: addiu v1,v1,1
0x00401cd4 <+92>: sw v1,12(s8)
0x00401cd8 <+96>: bnez v0,0x401ca0 <string_length+40>
0x00401cdc <+100>: nop
0x00401ce0 <+104>: lw v0,8(s8)
0x00401ce4 <+108>: move sp,s8
0x00401ce8 <+112>: lw s8,20(sp)
0x00401cec <+116>: addiu sp,sp,24
0x00401cf0 <+120>: jr ra
0x00401cf4 <+124>: nop
End of assembler dump.
做实验的时候，遇到了这行代码，不太理解，翻了一下指令集手册，发现这样
本来以为，这是个寄存器值和立即数的比较，但是看了一下，发现是两个寄存器，我就不太理解，后来恍然大悟，这个 zero有没有可能是0号寄存器？！
于是输出了一下，果然是
当然，这个$zero保存的一直都是0
继续分析string_length的代码
因为lb中()的参数一定是一个地址，所以我们往前找，
我们推测$s8+12的值也一定是一个地址
继续往下看
这行代码其实是最令我无法理解的，我最开始以为，难道它的循环次数是从负数开始？
其次，那他怎么判断循环终结？（当然，最后我都搞懂了这些东西）
不过分析还是要一步一步来
我们推测，$v1才是保存的循环次数，因为他有很明显的+1并且保存到了$s8+12,那么原来的$v0就肯定不是了,并且我们结合上下文也能发现,$v0中的值并没有保存，所以我们推测，v0中的保存的值有别的含义
我们想，如果它读取结束了，那么它一定会退出，也就是
那么我们往前看
什么时候$v0会等于0呢？
我们突然想起，上一个实验的113其实是q的asc码
那么这个0是什么？
这个不是'\0'的asc码吗？！
我们输出一下看看
所以这样，这个函数就完全搞清除了
对于第5关，我的输入是half
对于这几行代码，我的猜测就是$a0中保存的地址存放着输入的字符串，
输出一看
确实是
在做实验的时候，也遇到这样的错误
我想进入string_length函数单步调试，但是使用ni直接跳过，使用step直接爆炸，后来发现，应该使用si命令（或者stepi）
同时，对于一个函数，如果被调用了很多次，我们不应该直接在那个位置上设置断电，在它前面的某个位置设置一个断点，然后si即可
否侧一直c会很麻烦
同时
我最开始读这段代码的时候没有搞懂，为什么v0中存放的是保存的循环次数，你刚开始就+1然后保存，不怕读取到了'\0'吗？
后来仔细阅读发现，这个+1加的其实是上一次读取到的，如果上一次读取到了'\0'
那么它根本不会跳转到这里！
它就直接退出了！
所以它保存的一定是循环次数！也就是，字符串的长度！
然后继续往下看
不难猜出来，Memory[$s8+24]保存的是for循环的执行次数
从这两行代码中，我们可以才出来,a0保存的是一个内存地址
那么我们输出一下
是我们输入的字符串
所以以下这两行的代码的作用就明晰了
22行是用来保存当前读取到的位置
v1用来保存读取出来的字符
所以
0x00401448 <+96>: andi v1,v1,0xff
0x0040144c <+100>: andi v1,v1,0xf//字符的asc和0xf相与
那我们输出一下我们输入的字符 的asc和0xf相与之后的结果
那么我们在虚拟机上看一看，第一位字符处理之后的结果是不是3
果然
并且我们知道
那么我们来调用一下看看
对于
$v1=Memory[$s8+36+4*循环次数],读取到的字符asc和0xf相与的结果
查看寄存器
果然
对于这一段，基本上看到就能猜到，这肯定是一个地址了，那么我们输出一下，最开始我的猜测是，这个可能是我们输入的信息之类的，比如学号或者你输入的字符串
but…
又因为
所以我们再次输出，发现是118,猜测是某个字符的asc
输出一下验证
的确！也正好是我们推测的结果！
对于
0x00401494 <+172>: sb v1,4(v0)
我们知道，把$v1储存到了循环次数在内存中的地址+循环次数
再检验一次
设置断点在0x0040144c <+100>: andi v1,v1,0xf//字符的asc和0xf相与
这里，输出一下register
我们之前用pycharm输出了scytcl的asc如下
发现正确
事实上，形如这种的指令（虽然对解题无帮助，但是个人觉得还是很有必要理解的）
0x0040145c <+116>: sw v1,12(v0)
这种，修改了系统内存的东西（类似于c++中修改类内私有变量的成员的值，曾经在这个点上WA了无数次。。。。）
对于0x0040145c <+116>的指令，验证第1次循环如下（循环从0计数）
对于0x00401478 <+144>: lw v1,12(v0)//$v1=Memory[$s8+36+4*循环次数]
指令，验证如下
对于0x00401488 <+160>: lb v1,0(v0)//一个固定的地址+读取到的字符asc和0xf相与的结果
验证如下
对于0x00401494 <+172>: sb v1,4(v0)//把$v1储存到了循环次数在内存中的地址+循环次数+4
验证如下
哦对了，验证了时候发生了一点小的事故，其实从我的输入中也能看出来错在了哪里，输出格式不正确(这个也是我数学建模的队友lxr巨巨跟我讨论了一节课的问题)，观察一下汇编的输入
这个是store byte不是store word!!!
再然后就碰到了这么一个函数
Dump of assembler code for function strings_not_equal:
0x00401cf8 <+0>: addiu sp,sp,-48
0x00401cfc <+4>: sw ra,44(sp)
0x00401d00 <+8>: sw s8,40(sp)
0x00401d04 <+12>: move s8,sp
0x00401d08 <+16>: sw a0,48(s8)
0x00401d0c <+20>: sw a1,52(s8)
0x00401d10 <+24>: lw a0,48(s8)
0x00401d14 <+28>: jal 0x401c78 <string_length>
0x00401d18 <+32>: nop
0x00401d1c <+36>: sw v0,36(s8)
0x00401d20 <+40>: lw a0,52(s8)
0x00401d24 <+44>: jal 0x401c78 <string_length>
0x00401d28 <+48>: nop
0x00401d2c <+52>: sw v0,32(s8)
0x00401d30 <+56>: lw v0,48(s8)
0x00401d34 <+60>: nop
0x00401d38 <+64>: sw v0,28(s8)
0x00401d3c <+68>: lw v0,52(s8)
0x00401d40 <+72>: nop
0x00401d44 <+76>: sw v0,24(s8)
0x00401d48 <+80>: lw v1,36(s8)
0x00401d4c <+84>: lw v0,32(s8)
0x00401d50 <+88>: nop
0x00401d54 <+92>: beq v1,v0,0x401dc4 <strings_not_equal+204>
0x00401d58 <+96>: nop
0x00401d5c <+100>: li v0,1
0x00401d60 <+104>: b 0x401de4 <strings_not_equal+236>
0x00401d64 <+108>: nop
0x00401d68 <+112>: lw v0,28(s8)
0x00401d6c <+116>: nop
0x00401d70 <+120>: lb v1,0(v0)
0x00401d74 <+124>: lw v0,24(s8)
0x00401d78 <+128>: nop
0x00401d7c <+132>: lb v0,0(v0)
0x00401d80 <+136>: nop
0x00401d84 <+140>: xor v0,v1,v0
0x00401d88 <+144>: sltu v0,zero,v0
0x00401d8c <+148>: andi v0,v0,0xff
0x00401d90 <+152>: lw v1,28(s8)
0x00401d94 <+156>: nop
0x00401d98 <+160>: addiu v1,v1,1
0x00401d9c <+164>: sw v1,28(s8)
0x00401da0 <+168>: lw v1,24(s8)
0x00401da4 <+172>: nop
0x00401da8 <+176>: addiu v1,v1,1
0x00401dac <+180>: sw v1,24(s8)
0x00401db0 <+184>: beqz v0,0x401dc8 <strings_not_equal+208>
0x00401db4 <+188>: nop
0x00401db8 <+192>: li v0,1
0x00401dbc <+196>: b 0x401de4 <strings_not_equal+236>
0x00401dc0 <+200>: nop
0x00401dc4 <+204>: nop
0x00401dc8 <+208>: lw v0,28(s8)
0x00401dcc <+212>: nop
0x00401dd0 <+216>: lb v0,0(v0)
0x00401dd4 <+220>: nop
0x00401dd8 <+224>: bnez v0,0x401d68 <strings_not_equal+112>
0x00401ddc <+228>: nop
0x00401de0 <+232>: move v0,zero
0x00401de4 <+236>: move sp,s8
0x00401de8 <+240>: lw ra,44(sp)
0x00401dec <+244>: lw s8,40(sp)
0x00401df0 <+248>: addiu sp,sp,48
0x00401df4 <+252>: jr ra
0x00401df8 <+256>: nop
End of assembler dump.
我们看这一行
0x00401d5c <+100>: li v0,1
0x00401d60 <+104>: b 0x401de4 <strings_not_equal+236>
我们结合函数调用的上下文可以得出，如果这一行被执行了，那么一定会爆炸
如果很幸运，我们没有爆炸
那么我们继续往下看
毫无疑问，从内存中读取出来了一组数据，我们非常有理由怀疑
读取出来的是我们在phase_5中经过处理后的数据或者是本来我们输入的数据
我们往前找一下，因为s8很少改变
所以我们在phase_5中找一找
我们发现
所以更坚定了我们认为这里读取到的是经过处理后的数据
我们再往下看
0x00401d84 <+140>: xor v0,v1,v0//按位或
0x00401db0 <+184>: beqz v0,0x401dc8 <strings_not_equal+208>
这两行其实是这个函数的精髓所在（虽然其实也没有多难）
如果$v0 xor $v1==0，那么$v0==$v1
然后
最后
判断是否为0，如果是，则跳转，否则$v0=1,爆炸
所以到这里，我们猜测，是要进行处理后的字符串和给定的字符串进行比较，如果处理后的字符串和给定的字符串相同，那么不爆炸，否则爆炸
那么接下来的问题就变成了
- 它给定的字符串是什么？
- 找到那个转换函数，使得经过映射后的字符串等于给定的字符串
好，知道这些后，我们先来看一下上文中提到的，那个位置存储的是不是我们经过处理后的字符串
我们重新开
果然
我们再从
写到这里我突然产生了疑问，如果按位或的话，那岂不是最小值取决于给定的字符串？
于是百度了一下xor
发现是异或
但是我们的思路方向还是正确的，必须相等，否则爆炸
这里，查看一下给定的字符串
当然，我相信你从我的繁杂的输入中也能看到我错在了哪里
如果没有，请仔细阅读前文
输出这个字符串
可以看出
字符串为giants（当然，如果只知道asc其实不影响我们拆炸弹）
那么接下来我们就需要找到那个函数
经过分析，函数主要就是这一段
注释写的比较详细
分析可得，我们只需要找到是giants在内存中的地址即可
好的，问题来了
我们需要查看多少内存空间？
ans:16
因为是输入的字符和0xf相与，所以结果一定是0-e，共16个
所以我们接下来只需要寻找giants在内存中的地址即可
我们从这几段代码中可以发现，我们先从一个偏移的位置找到了函数映射后的结果，然后将这个映射后的结果保存到了一个位置，也正是strings_not_equal调用出来的位置
所以这样问题就化简成了，在那段地址中，寻找giants
可以发现，这段内存中的值包含giants
最终查找发现，偏移量是
15 0 5 12 14 1
那么我们需要输入什么呢？
很显然
a 1
b 2
c 3
d 4
e 5
f 6
g 7
h 8
i 9
j 10
k 11
l 12
m 13
n 14
o 15
p 0
q 1
r 2
s 3
t 4
u 5
v 6
w 7
x 8
y 9
z 10
最终结果opekma
6. 第六关
我们猜测$s8+36+4*$v0保存的是我们输入的6个数字，输出一看，果然是
写到这里csdn的 编辑器已经无比的卡，简单说一下思路吧
首先它判定了一下你输入的6个数字是否处于(0,7)之间，并且必须是全排列
然后它看了一下你的学号的最后一位，是奇数还是偶数，
最后你发现它用了一个链表存储，需要在循环中找到单调不减或者单调不增加的一个序列
我的学号最后一位为奇数，所以是单调不减少的
最后结果就是426315
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
