x86上的二进制炸弹对于反汇编的练习来说还是比较经典的，由于网上有很多该程序的讲解，所以在此我打算写一下arm平台上的二进制拆炸弹这个游戏。
环境的搭建
由于是arm平台的环境，所以需要在linux环境下安装一个模拟器，在此我选择了qemu该模拟器，具体操作如下(该操作对Ubuntu环境有效，其他linux版本可自行查找方法)
sudo apt-get install qemu-user
运行ARM指令集模拟器并运行开启gdbserver和运行bomb_1程序
qemu-arm -g 8009 bomb_1
其中，-g参数是为了添加调试信息，为了使远程gdb调试能够起作用，8009为自定义的端口号。
另外启动一个终端，通过命令远程开启gdb调试器并加载待调试程序。
arm-linux-gdb bomb_1
输命令来连接模拟器中的gdbserver
target remote localhost:8009
辅助工具IDA pro。IDA pro是一款静态分析的反汇编工具，利用它可以查看数据段的具体数据，用起来十分方便。
具体分析
Phase 1
- Arm指令
0000844c <phase_1>:
844c: e92d4800 push {fp, lr}
8450: e28db004 add fp, sp, #4
8454: e24dd008 sub sp, sp, #8
8458: e50b0008 str r0, [fp, #-8]
845c: e51b0008 ldr r0, [fp, #-8]
8460: e59f101c ldr r1, [pc, #28] ; 8484 <phase_1+0x38>
8464: eb000241 bl 8d70 <strings_not_equal>
8468: e1a03000 mov r3, r0
846c: e3530000 cmp r3, #0
8470: 0a000000 beq 8478 <phase_1+0x2c>
8474: eb000321 bl 9100 <explode_bomb>
8478: e24bd004 sub sp, fp, #4
847c: e8bd4800 pop {fp, lr}
8480: e12fff1e bx lr
8484: 0006483c .word 0x0006483c- 反汇编分析
从标重点的三行汇编可以看出，该代码从把输入的字符串为参数1，把8484里存的字符串作为参数2，然后再调用函数strings_not_equal,判断两个函数是否相等。所以关键是找8484处的地址存的字符串。有IDA pro可以看出8484处存的是数据段6483c处存的字符串，所以用ida可以找出该处的字符串。 - 密码
密码为Let’s begin now!
利用gdb及arm服务器验证该答案正确。
Phase 2
- Arm指令
00008488 <phase_2>:
8488: e92d4800 push {fp, lr}
848c: e28db004 add fp, sp, #4
8490: e24dd028 sub sp, sp, #40 ; 0x28
8494: e50b0028 str r0, [fp, #-40] ; 0xffffffd8
8498: e24b3020 sub r3, fp, #32
849c: e51b0028 ldr r0, [fp, #-40] ; 0xffffffd8
84a0: e1a01003 mov r1, r3
84a4: eb0001f4 bl 8c7c <read_six_numbers> ○1
84a8: e51b3020 ldr r3, [fp, #-32] ; 0xffffffe0
84ac: e3530001 cmp r3, #1
84b0: 0a000000 beq 84b8 <phase_2+0x30> ○2
84b4: eb000311 bl 9100 <explode_bomb>
84b8: e3a03001 mov r3, #1
84bc: e50b3008 str r3, [fp, #-8]
84c0: e51b3008 ldr r3, [fp, #-8]
84c4: e2432001 sub r2, r3, #1
84c8: e3e0301b mvn r3, #27
84cc: e1a02102 lsl r2, r2, #2
84d0: e24b0004 sub r0, fp, #4
84d4: e0802002 add r2, r0, r2
84d8: e0823003 add r3, r2, r3
84dc: e5933000 ldr r3, [r3]
84e0: e51b2008 ldr r2, [fp, #-8]
84e4: e2421001 sub r1, r2, #1 ○3
84e8: e0020391 mul r2, r1, r3
84ec: e51b1008 ldr r1, [fp, #-8]
84f0: e3e0301b mvn r3, #27
84f4: e1a01101 lsl r1, r1, #2
84f8: e24b0004 sub r0, fp, #4
84fc: e0801001 add r1, r0, r1
8500: e0813003 add r3, r1, r3 ○4
8504: e5933000 ldr r3, [r3]
//
8508: e1520003 cmp r2, r3
850c: 0a000000 beq 8514 <phase_2+0x8c> ○5
8510: eb0002fa bl 9100 <explode_bomb>
//
8514: e51b3008 ldr r3, [fp, #-8]
8518: e2833001 add r3, r3, #1
851c: e50b3008 str r3, [fp, #-8]
8520: e51b3008 ldr r3, [fp, #-8]
8524: e3530005 cmp r3, #5
8528: daffffe4 ble 84c0 <phase_2+0x38>
852c: e24bd004 sub sp, fp, #4
8530: e8bd4800 pop {fp, lr}
8534: e12fff1e bx lr
- 反汇编分析
该炸弹的逻辑是for循环。
○1处那两行由函数名可以看出为从终端读取六个数，并将其存入一个数组中，且地址从fp-32开始。○2处那四行是读取数组第一个数判断是否为1，如果是1继续判断，如果不是就会explode_bomb。如果是1 的话就会使i = 1到5，然后判断每一个数值。○3那四行及以上几行的逻辑是取出a[i-1]的值，并将a[i-1]*(i-1),然后存入r2中。○4那两行及以上几行的逻辑是取出a[i]的数据，并将其存入r3中。○5处的逻辑是判断r2和r3的值，如果相等则i+1，继续判断，如果不行等则explode_bomb。
其大致的c语言逻辑如下：
if(a[0] != 1)
explode_bomb();
for(i = 1;i <= 5;i++)
{
if(a[i] != a[i-1]*(i-1))
explode_bomb();
}所以a[0] = 1;a[1] = a[2] = a[3] = a[4] = a[5] = 0;
- 密码
1 0 0 0 0 0
Phase 3
- arm指令
00008538 <phase_3>:
8538: e92d4800 push {fp, lr}
853c: e28db004 add fp, sp, #4
8540: e24dd020 sub sp, sp, #32
8544: e50b0018 str r0, [fp, #-24] ; 0xffffffe8
8548: e51b0018 ldr r0, [fp, #-24] ; 0xffffffe8
854c: e59f119c ldr r1, [pc, #412] ; 86f0 <phase_3+0x1b8>○1
8550: e24b2014 sub r2, fp, #20
8554: e24b300d sub r3, fp, #13
8558: e24bc00c sub ip, fp, #12
855c: e58dc000 str ip, [sp]
8560: eb000976 bl ab40 <_IO_sscanf>
8564: e1a03000 mov r3, r0
8568: e3530002 cmp r3, #2
856c: ca000000 bgt 8574 <phase_3+0x3c> ○2
8570: eb0002e2 bl 9100 <explode_bomb>
///
8574: e51b3014 ldr r3, [fp, #-20] ; 0xffffffec
8578: e3530007 cmp r3, #7
857c: 979ff103 ldrls pc, [pc, r3, lsl #2]
8580: ea000041 b 868c <phase_3+0x154>
8584: 000085a4 .word 0x000085a4
8588: 000085c4 .word 0x000085c4
858c: 000085e0 .word 0x000085e0 ○3
8590: 00008600 .word 0x00008600
8594: 0000861c .word 0x0000861c
8598: 00008638 .word 0x00008638
859c: 00008658 .word 0x00008658
85a0: 00008670 .word 0x00008670
/
85a4: e3a03071 mov r3, #113 ; 0x71 ○4
85a8: e54b3005 strb r3, [fp, #-5]
85ac: e51b200c ldr r2, [fp, #-12]
85b0: e59f313c ldr r3, [pc, #316] ; 86f4 <phase_3+0x1bc>
85b4: e1520003 cmp r2, r3
85b8: 0a000037 beq 869c <phase_3+0x164>
85bc: eb0002cf bl 9100 <explode_bomb>
85c0: ea000042 b 86d0 <phase_3+0x198>
85c4: e3a03062 mov r3, #98 ; 0x62○5
85c8: e54b3005 strb r3, [fp, #-5]
85cc: e51b300c ldr r3, [fp, #-12]
85d0: e35300d6 cmp r3, #214 ; 0xd6
85d4: 0a000032 beq 86a4 <phase_3+0x16c>
85d8: eb0002c8 bl 9100 <explode_bomb>
85dc: ea00003b b 86d0 <phase_3+0x198>
85e0: e3a03062 mov r3, #98 ; 0x62○6
85e4: e54b3005 strb r3, [fp, #-5]
85e8: e51b200c ldr r2, [fp, #-12]
85ec: e59f3104 ldr r3, [pc, #260] ; 86f8 <phase_3+0x1c0>
85f0: e1520003 cmp r2, r3
85f4: 0a00002c beq 86ac <phase_3+0x174>
85f8: eb0002c0 bl 9100 <explode_bomb>
85fc: ea000033 b 86d0 <phase_3+0x198>
8600: e3a0306b mov r3, #107 ; 0x6b ○7
8604: e54b3005 strb r3, [fp, #-5]
8608: e51b300c ldr r3, [fp, #-12]
860c: e35300fb cmp r3, #251 ; 0xfb
8610: 0a000027 beq 86b4 <phase_3+0x17c>
8614: eb0002b9 bl 9100 <explode_bomb>
8618: ea00002c b 86d0 <phase_3+0x198>
861c: e3a0306f mov r3, #111 ; 0x6f○8
8620: e54b3005 strb r3, [fp, #-5]
8624: e51b300c ldr r3, [fp, #-12]
8628: e35300a0 cmp r3, #160 ; 0xa0
862c: 0a000022 beq 86bc <phase_3+0x184>
8630: eb0002b2 bl 9100 <explode_bomb>
8634: ea000025 b 86d0 <phase_3+0x198>
8638: e3a03074 mov r3, #116 ; 0x74○9
863c: e54b3005 strb r3, [fp, #-5]
8640: e51b200c ldr r2, [fp, #-12]
8644: e59f30b0 ldr r3, [pc, #176] ; 86fc <phase_3+0x1c4>
8648: e1520003 cmp r2, r3
864c: 0a00001c beq 86c4 <phase_3+0x18c>
8650: eb0002aa bl 9100 <explode_bomb>
8654: ea00001d b 86d0 <phase_3+0x198>
8658: e3a03076 mov r3, #118 ; 0x76○10
865c: e54b3005 strb r3, [fp, #-5]
8660: e51b300c ldr r3, [fp, #-12]
8664: e3530fc3 cmp r3, #780 ; 0x30c
8668: 0a000000 beq 8670 <phase_3+0x138>
866c: eb0002a3 bl 9100 <explode_bomb>
8670: e3a03062 mov r3, #98 ; 0x62○11
8674: e54b3005 strb r3, [fp, #-5]
8678: e51b300c ldr r3, [fp, #-12]
867c: e3530f83 cmp r3, #524 ; 0x20c
8680: 0a000011 beq 86cc <phase_3+0x194>
8684: eb00029d bl 9100 <explode_bomb>
8688: ea000010 b 86d0 <phase_3+0x198>
868c: e3a03078 mov r3, #120 ;0x78 ○12
8690: e54b3005 strb r3, [fp, #-5]
8694: eb000299 bl 9100 <explode_bomb>
8698: ea00000c b 86d0 <phase_3+0x198>
869c: e1a00000 nop ; (mov r0, r0)
86a0: ea00000a b 86d0 <phase_3+0x198>
86a4: e1a00000 nop ; (mov r0, r0)
86a8: ea000008 b 86d0 <phase_3+0x198>
86ac: e1a00000 nop ; (mov r0, r0)
86b0: ea000006 b 86d0 <phase_3+0x198>
86b4: e1a00000 nop ; (mov r0, r0)
86b8: ea000004 b 86d0 <phase_3+0x198>
86bc: e1a00000 nop ; (mov r0, r0)
86c0: ea000002 b 86d0 <phase_3+0x198>
86c4: e1a00000 nop ; (mov r0, r0)
86c8: ea000000 b 86d0 <phase_3+0x198>
86cc: e1a00000 nop ; (mov r0, r0)
86d0: e55b300d ldrb r3, [fp, #-13]
86d4: e55b2005 ldrb r2, [fp, #-5]
86d8: e1520003 cmp r2,r3○13
86dc: 0a000000 beq 86e4 <phase_3+0x1ac>
86e0: eb000286 bl 9100 <explode_bomb>
86e4: e24bd004 sub sp, fp, #4
86e8: e8bd4800 pop {fp, lr}
86ec: e12fff1e bx lr
86f0: 00064850 .word 0x00064850
86f4: 00000309 .word 0x00000309
86f8: 000002f3 .word 0x000002f3
86fc: 000001ca .word 0x000001ca
- 反汇编分析
○1处将pc+412的数据传入r1，借助IDA pro可以查看pc+412引用的是
00064850处的数据，如图：
所以该处的数据为”%d %c %d”,由此可知输入的数据的形式为int，char，int。
○2处判断第一个参数int是否大于2，如果大于2则进行switch操作，如果不是则explode_bomb。○3处是对输入的第一个int进行switch判断，其伪代码如下：
switch(int c)
{
case 0:
jmp 85a4;
break;
case 1:
jmp 85c4;
break;
case 2:
jmp 85e0;
break;
case 3:
jmp 8600;
break;
case 4:
jmp 861c;
break;
case 5:
jmp 8638;
break;
case 6:
jmp 8658;
break;
case 7:
jmp 8670;
break;
default:
jmp 868c;
break;
}
○4-○11是对case 0 –case 7这八种情况的具体判断，其逻辑都是一样的，所以在此只分析一种情况（由于必须要求第一个int大于2，所以分析为3,4,5,6,7这五种情况）。现分析○7，首先将0x6b放入fp-5,然后将fp-12的值(即第三个传入的int的值)与0xfb(十进制为251)进行比较，如果相等则跳转86b4,如果不是的话就会explode_bomb;然后相等的话跳转86b4，我们发现从869c到86cc的逻辑都是先nop，什么都不做，然后再b 86d0
00008760 <phase_4>:
8760: e92d4800 push {fp, lr}
8764: e28db004 add fp, sp, #4
8768: e24dd010 sub sp, sp, #16
876c: e50b0010 str r0, [fp, #-16]
8770: e51b1010 ldr r1, [fp, #-16]
8774: e59f2054 ldr r2, [pc, #84] ; 87d0 <phase_4+0x70> ○1
8778: e24b3008 sub r3, fp, #8
877c: e1a00001 mov r0, r1
8780: e1a01002 mov r1, r2
8784: e1a02003 mov r2, r3
8788: eb0008ec bl ab40 <_IO_sscanf>
878c: e1a03000 mov r3, r0
8790: e3530001 cmp r3, #1
8794: 1a000002 bne 87a4 <phase_4+0x44>
8798: e51b3008 ldr r3, [fp, #-8]
879c: e3530000 cmp r3, #0
87a0: ca000000 bgt 87a8 <phase_4+0x48> ○2
87a4: eb000255 bl 9100 <explode_bomb>
87a8: e51b3008 ldr r3, [fp, #-8]
87ac: e1a00003 mov r0, r3 ○3
87b0: ebffffd2 bl 8700 <func4>
///
87b4: e1a03000 mov r3, r0
87b8: e3530008 cmp r3, #8
87bc: 0a000000 beq 87c4 <phase_4+0x64> ○8
87c0: eb00024e bl 9100 <explode_bomb>
87c4: e24bd004 sub sp, fp, #4
87c8: e8bd4800 pop {fp, lr}
87cc: e12fff1e bx lr
87d0: 0006485c .word 0x0006485c
00008700 <func4>:
8700: e92d4810 push {r4, fp, lr}
8704: e28db008 add fp, sp, #8
8708: e24dd00c sub sp, sp, #12
870c: e50b0010 str r0, [fp, #-16]
8710: e51b3010 ldr r3, [fp, #-16]
8714: e3530001 cmp r3, #1 ○4
8718: da00000b ble 874c <func4+0x4c>
871c: e51b3010 ldr r3, [fp, #-16]
8720: e2433001 sub r3, r3, #1
8724: e1a00003 mov r0, r3 ○5
8728: ebfffff4 bl 8700 <func4>
/
872c: e1a04000 mov r4, r0
8730: e51b3010 ldr r3, [fp, #-16]
8734: e2433002 sub r3, r3, #2 ○6
8738: e1a00003 mov r0, r3
873c: ebffffef bl 8700 <func4>
8740: e1a03000 mov r3, r0
8744: e0843003 add r3, r4, r3
8748: ea000000 b 8750 <func4+0x50>
874c: e3a03001 mov r3, #1
8750: e1a00003 mov r0, r3
8754: e24bd008 sub sp, fp, #8 ○7
8758: e8bd4810 pop {r4, fp, lr}
875c: e12fff1e bx lr
- 反汇编分析
○1处是输入的参数的形式，位于87d0处，利用IDA pro找到了87d0引用了0006485C数据段的数据，为
即要求输入一个数字。○2处判断是否是输入的参数是否大于0，如果大于0则继续判断，如果不是则explode_bomb。○3处将输入的数传入r0中作为参数然后调用func4()。○4首先将传入的参数存入fp-16中，然后判断参数是否小于等于1，如果小于等于1的话就跳到○7处，○7处将返回值赋值为1，然后pop返回值和参数；如果大于1的话就到○5，○5和○6的逻辑就是分别让参数-1和-2，然后再分别调用func4，由此可以看出该bomb的逻辑是一个递归的调用。其c语言的伪代码如下：
func4(int i)
{
if(i < = 1)
return 1;
else
return func4(i-1) + func4(i-2);
}
然后看代码块○8，其将func4函数的返回值与8进行比较，如果等于8就通过，否则explode_bomb。所以通过计算可以得出输入的值为5。
- 密码
5
Phase 5
- Arm指令
000087d4 <phase_5>:
87d4: e92d4800 push {fp, lr}
87d8: e28db004 add fp, sp, #4
87dc: e24dd018 sub sp, sp, #24
87e0: e50b0018 str r0, [fp, #-24] ; 0xffffffe8
87e4: e51b0018 ldr r0, [fp, #-24] ; 0xffffffe8
87e8: eb000144 bl 8d00 <string_length>
87ec: e1a03000 mov r3, r0
87f0: e3530006 cmp r3, #6 ○1
87f4: 0a000000 beq 87fc <phase_5+0x28>
87f8: eb000240 bl 9100 <explode_bomb>
////////////////////////////////////////
87fc: e3a03000 mov r3, #0
8800: e50b3008 str r3, [fp, #-8]○2
8804: ea00000f b 8848 <phase_5+0x74>
////////////////////////////////////////
8808: e51b1008 ldr r1, [fp, #-8]
880c: e51b3008 ldr r3, [fp, #-8]
8810: e51b2018 ldr r2, [fp, #-24] ; 0xffffffe8
8814: e0823003 add r3, r2, r3○4
8818: e5d33000 ldrb r3, [r3]
881c: e203300f and r3, r3, #15
///////////////////////////////////////
8820: e59f2060 ldr r2, [pc, #96] ; 8888 <phase_5+0xb4>
8824: e7d22003 ldrb r2, [r2, r3] ○5
///////////////////////////////////////
8828: e3e0300b mvn r3, #11
882c: e24b0004 sub r0, fp, #4
8830: e0801001 add r1, r0, r1 ○6
8834: e0813003 add r3, r1, r3
8838: e5c32000 strb r2, [r3]
////////////////////////////////////
883c: e51b3008 ldr r3, [fp, #-8]
8840: e2833001 add r3, r3, #1 ○7
8844: e50b3008 str r3, [fp, #-8]
////////////////////////////////////
8848: e51b3008 ldr r3, [fp, #-8]
884c: e3530005 cmp r3, #5 ○3
8850: daffffec ble 8808 <phase_5+0x34>
///////////////////////////////////
8854: e3a03000 mov r3, #0
8858: e54b300a strb r3, [fp, #-10]
885c: e24b3010 sub r3, fp, #16
8860: e1a00003 mov r0, r3 ○8
8864: e59f1020 ldr r1, [pc, #32] ; 888c <phase_5+0xb8>
8868: eb000140 bl 8d70 <strings_not_equal>
886c: e1a03000 mov r3, r0
8870: e3530000 cmp r3, #0
8874: 0a000000 beq 887c <phase_5+0xa8>
8878: eb000220 bl 9100 <explode_bomb>
887c: e24bd004 sub sp, fp, #4
8880: e8bd4800 pop {fp, lr}
8884: e12fff1e bx lr
8888: 0008216c .word 0x0008216c
888c: 00064860 .word 0x00064860
- 反汇编分析
○1中代码首先判断读入的字符串的长度，如果长度等于6则跳到代码块○2中去，如果不等于6则explode_bomb。在代码块○2中，首先将计数变量i置为0，然后跳到代码块○3中去，在代码块○3中先判断i是否小于等于5，如果小于等于5的话就跳入○4中，其中○4○5○6○7为for循环的主体，我将其化成了这4部分。其中在○4的逻辑如下：取出字符串的第i个字符s[i],
然后将s[i]与0xF相与，其中一个char为一个字节，由两个16进制数组成，做相与运算后就只取出char的后4个b，将数值存入r3中。然后到代码块○5中，找到数据pc+96（8888）处的数据，根据IDA pro得出其引用的是0008216C处的数据，数据如图：
，然后根据r3中的数值作为索引取得相应的字符，将得到的字符存入r2中，然后到代码块○6中，其将r2的数据存入(fp-4-11)+i的地址处。代码○7是将i++。所以该段代码的伪代码如下：
for(i = 0;i <= 5;i++)
{
int a = (int)(s[i]&0xF);
s1[i] = 0x0008216c+a;
}
其中s为输入的字符串，s1为找到的字符串。
for循环结束了之后，得到长度为6的s1字符串，到了代码块○8中，该逻辑是将s1与（pc-32）即888c处的字符串进行比较，根据IDA pro得到引用了数据段00064860处的数据为：
所以只有当s1为”giants”时，才能通过，即索引顺序为0xF,0x0,0x5,0xB,0xD,0x1，查ascii表得到后4个b分别为这些的十六进制的数的字符分别为opeka（可能有多重情况，只要后4个b分别对应那五个十六进制数的字符即可）。
- 密码
opeka
Phase 6
指令及逻辑分析：
由于该炸弹的指令及逻辑较长，所以指令分开了几份分别进行分析。
00008890 :
1：读入六个数
8890: e92d4800 push {fp, lr}
8894: e28db004 add fp, sp, #4
8898: e24dd048 sub sp, sp, #72 ; 0x48
889c: e50b0048 str r0, [fp, #-72] ; 0xffffffb8
88a0: e59f3234 ldr r3, [pc, #564] ; 8adc <phase_6+0x24c>
88a4: e50b3010 str r3, [fp, #-16]
88a8: e24b3028 sub r3, fp, #40 ; 0x28
88ac: e51b0048 ldr r0, [fp, #-72] ; 0xffffffb8
88b0: e1a01003 mov r1, r3
88b4: eb0000f0 bl 8c7c <read_six_numbers>
以上的指令的逻辑比较简单，是首先读入六个数字，并将其放入数组中，假设数组为a。
2：对这六个数的值进行判定
88b8: e3a03000 mov r3, #0
88bc: e50b300c str r3, [fp, #-12]
88c0: e51b200c ldr r2, [fp, #-12] ○1
////////////////////////////////////
88c4: e3e03023 mvn r3, #35 ; 0x23
88c8: e1a02102 lsl r2, r2, #2
88cc: e24b0004 sub r0, fp, #4
88d0: e0802002 add r2, r0, r2 ○2
88d4: e0823003 add r3, r2, r3
88d8: e5933000 ldr r3, [r3]
///////////////////////////////////
88dc: e2433001 sub r3, r3, #1
88e0: e3530005 cmp r3, #5 ○3
88e4: 9a000000 bls 88ec <phase_6+0x5c>
88e8: eb000204 bl 9100 <explode_bomb>
//////////////////////////////////
88ec: e51b300c ldr r3, [fp, #-12]
88f0: e2833001 add r3, r3, #1 ○4
88f4: e50b3008 str r3, [fp, #-8]
88f8: ea000013 b 894c <phase_6+0xbc>
//////////////////////////////////
88fc: e51b200c ldr r2, [fp, #-12]
8900: e3e03023 mvn r3, #35 ; 0x23
8904: e1a02102 lsl r2, r2, #2
8908: e24b1004 sub r1, fp, #4 ○6
890c: e0812002 add r2, r1, r2
8910: e0823003 add r3, r2, r3
8914: e5932000 ldr r2, [r3]
//////////////////////////////////
8918: e51b1008 ldr r1, [fp, #-8]
891c: e3e03023 mvn r3, #35 ; 0x23
8920: e1a01101 lsl r1, r1, #2
8924: e24b0004 sub r0, fp, #4 ○7
8928: e0801001 add r1, r0, r1
892c: e0813003 add r3, r1, r3
8930: e5933000 ldr r3, [r3]
/////////////////////////////////
8934: e1520003 cmp r2, r3
8938: 1a000000 bne 8940 <phase_6+0xb0>
893c: eb0001ef bl 9100 <explode_bomb>
8940: e51b3008 ldr r3, [fp, #-8]○8
8944: e2833001 add r3, r3, #1
8948: e50b3008 str r3, [fp, #-8]
///////////////////////////////////
894c: e51b3008 ldr r3, [fp, #-8]
8950: e3530005 cmp r3, #5 ○5
8954: daffffe8 ble 88fc <phase_6+0x6c>
//////////////////////////////////
8958: e51b300c ldr r3, [fp, #-12]
895c: e2833001 add r3, r3, #1
8960: e50b300c str r3, [fp, #-12] ○9
8964: e51b300c ldr r3, [fp, #-12]
8968: e3530005 cmp r3, #5
896c: daffffd3 ble 88c0 <phase_6+0x30>
8970: e3a03000 mov r3, #0
8974: e50b300c str r3, [fp, #-12]
以上的指令为两个for循环的嵌套。
其中○1为(fp-12)处存的变量假设为i，把变量i的值存入r2，然后代码段○2处为取出a[i]的值并将其存入r3中，紧接着代码段○3处判断r3的值是否大于6，如果大于6就explode_bomb。然后进入代码块○4中，在此就进入了第二个for循环，首先初始化(fp-8)处的变量，设为j，j = i+1;然后进入代码段○5处对j的值进行判断，如果大于5就进入代码段○9，其中代码○9是将i增1并进行判断，如果i大于5就跳出for循环，如果小于5则跳至○1再进行一次for循环，对于代码○5处的判断如果j小于等于5的话，则跳入代码○6处，其中逻辑为取出a[i]的值将其放入r2中，然后进入○7中，取出a[j]的值将其放入r3中，然后进入○8，将r2和r3进行比较，如果相等的话就explode_bomb,不行等就进入○5，又进行了一次循环。其伪代码如下：
for(int i = 0;i <= 5;i++)
{if(a[i]>6)
explode_bomb();
for(int j = i+1;j<=5;j++)
{if(a[j] == a[i])
explode_bomb();
}
}3：根据输入的6个数把链表的6个node进行索引排序
8978: e59f315c ldr r3, [pc, #348] ; 8adc <phase_6+0x24c>
897c: e50b3010 str r3, [fp, #-16]
8980: e3a03001 mov r3, #1 ○1
8984: e50b3008 str r3, [fp, #-8]
8988: ea000005 b 89a4 <phase_6+0x114>
/////////////////////////////////////////////
898c: e51b3010 ldr r3, [fp, #-16]
8990: e5933008 ldr r3, [r3, #8]
8994: e50b3010 str r3, [fp, #-16] ○3
8998: e51b3008 ldr r3, [fp, #-8]
899c: e2833001 add r3, r3, #1
89a0: e50b3008 str r3, [fp, #-8]
////////////////////////////////////////
89a4: e51b200c ldr r2, [fp, #-12]
89a8: e3e03023 mvn r3, #35 ; 0x23
89ac: e1a02102 lsl r2, r2, #2
89b0: e24b1004 sub r1, fp, #4
89b4: e0812002 add r2, r1, r2 ○2
89b8: e0823003 add r3, r2, r3
89bc: e5932000 ldr r2, [r3]
89c0: e51b3008 ldr r3, [fp, #-8]
89c4: e1520003 cmp r2, r3
89c8: caffffef bgt 898c <phase_6+0xfc>
////////////////////////////////////////////
89cc: e51b200c ldr r2, [fp, #-12]
89d0: e3e0303b mvn r3, #59 ; 0x3b
89d4: e1a02102 lsl r2, r2, #2
89d8: e24b0004 sub r0, fp, #4 ○4
89dc: e0802002 add r2, r0, r2
89e0: e0823003 add r3, r2, r3
89e4: e51b2010 ldr r2, [fp, #-16]
89e8: e5832000 str r2, [r3]
///////////////////////////////////////////
89ec: e51b300c ldr r3, [fp, #-12]
89f0: e2833001 add r3, r3, #1
89f4: e50b300c str r3, [fp, #-12] ○5
89f8: e51b300c ldr r3, [fp, #-12]
89fc: e3530005 cmp r3, #5
8a00: daffffdc ble 8978 <phase_6+0xe8>
///////////////////////////////////////////
8a04: e51b3040 ldr r3, [fp, #-64] ; 0xffffffc0
8a08: e50b3010 str r3, [fp, #-16]○9
8a0c: e3a03001 mov r3, #1
8a10: e50b300c str r3, [fp, #-12]
/////////////////////////////////////////
8a14: e51b200c ldr r2, [fp, #-12]
8a18: e3e0303b mvn r3, #59 ; 0x3b
8a1c: e1a02102 lsl r2, r2, #2
8a20: e24b1004 sub r1, fp, #4
8a24: e0812002 add r2, r1, r2○6
8a28: e0823003 add r3, r2, r3
8a2c: e5932000 ldr r2, [r3]
8a30: e51b3010 ldr r3, [fp, #-16]
8a34: e5832008 str r2, [r3, #8]
///////////////////////////////////////
8a38: e51b200c ldr r2, [fp, #-12]
8a3c: e3e0303b mvn r3, #59 ; 0x3b
8a40: e1a02102 lsl r2, r2, #2○7
8a44: e24b0004 sub r0, fp, #4
8a48: e0802002 add r2, r0, r2
8a4c: e0823003 add r3, r2, r3
8a50: e5933000 ldr r3, [r3]
8a54: e50b3010 str r3, [fp, #-16]
////////////////////////////////////
8a58: e51b300c ldr r3, [fp, #-12]
8a5c: e2833001 add r3, r3, #1
8a60: e50b300c str r3, [fp, #-12] ○8
8a64: e51b300c ldr r3, [fp, #-12]
8a68: e3530005 cmp r3, #5
8a6c: daffffe8 ble 8a14 <phase_6+0x184>
该段代码也有一个for循环的嵌套。
首先初始化，将(PC+348)的索引的数存入r3中，由ida pro得出具体数据为
所以将node1的索引传入r3，然后跳入到代码块○2，其逻辑是先取出a[i]的数据至r2，然后取出j至r3，比较这两个数据的大小，如果r2 >r3,就跳到代码段○3，该逻辑是将r3+0x8的数据存入fp-16中，有以上的数据可知该数据为0x20A0，用IDA pro查找到为：
以此类推，根据每个节点的第8个字节处的数据作为下一个节点的地址，直到找到链表的a[i]个元素，就会跳出该内层的for循环，然后进入代码块○4，该逻辑是将该node的地址存入-0x3c+[R11] + 4 * i中，然后进入代码块○5，其逻辑是使变量i增1，然后判断是否大于5，如果小于5再跳入○1中继续循环。
其for循环的伪代码如下：
for(int i = 0;i <=5;i++)
{
node = 0x000820AC;
for(int j = 1;j<a[i];j++)
node = *(node+0x8);
-0x3c+[R11] + 4 * i = node;
}
所以经过上一个for循环的嵌套，从-0x3c+[R11]开始就有了这些节点的地址的索引，然后进入代码段○9，其逻辑是先将fp-12处的变量i初始化为1，目的是进入for循环。进入代码段○6,其目的是将*((-0x3c+[R11]+i-1)+0x8) = (-0x3c+[R11]+i)；然后进入代码段○7，其目的是将当前节点设为-0x3c+[R11]+i处的地址所指向的节点，进入代码块○8，使i增1并判断和5的大小关系。
4：判断链表的节点的数值是否是按从大到小的顺序排列的
8a70: e51b3010 ldr r3, [fp, #-16]
8a74: e3a02000 mov r2, #0
8a78: e5832008 str r2, [r3, #8]
8a7c: e3a03000 mov r3, #0 ○1
8a80: e50b300c str r3, [fp, #-12]
8a84: e51b3040 ldr r3, [fp, #-64] ; 0xffffffc0
8a88: e50b3010 str r3, [fp, #-16]
//////////////////////////////////////
8a8c: e51b3010 ldr r3, [fp, #-16]
8a90: e5932000 ldr r2, [r3]
8a94: e51b3010 ldr r3, [fp, #-16]
8a98: e5933008 ldr r3, [r3, #8] ○2
8a9c: e5933000 ldr r3, [r3]
8aa0: e1520003 cmp r2, r3
8aa4: aa000000 bge 8aac <phase_6+0x21c>
8aa8: eb000194 bl 9100 <explode_bomb>
//////////////////////////////////////////
8aac: e51b3010 ldr r3, [fp, #-16]
8ab0: e5933008 ldr r3, [r3, #8] ○3
8ab4: e50b3010 str r3, [fp, #-16]
///////////////////////////////////////
8ab8: e51b300c ldr r3, [fp, #-12]
8abc: e2833001 add r3, r3, #1
8ac0: e50b300c str r3, [fp, #-12] ○4
8ac4: e51b300c ldr r3, [fp, #-12]
8ac8: e3530004 cmp r3, #4
8acc: daffffee ble 8a8c <phase_6+0x1fc>
首先进入○1进行初始化，将（fp-16）处的地址换为链表的第一个node，并对（fp-12）的变量i初始化为0。然后进入代码块○2，首先获得当前node的地址，并将该node的数据存入r2中，地址存入r3中，然后通过[r3+8]获得下一个node的地址，并将下一个node的地址存入r3中，然后比较r2和r3的值，如果r2小于r3，就explode_bomb,
如果不小于就进入代码块○3，该逻辑是将当前节点（fp-16）的地址改为[r3+8]处的数值，即为下一个节点的地址，然后进入代码○4，对变量i进行增1操作，并判断和4的大小。其伪代码如下：
其中node的数据结构如下：
struct node
{
int x, y;
node *next; };
//进行判断：
node a = firstNode;
for(int i = 0; i < 5; i++)
{
node b = a->next;
if (a->x >= b->x)
a = b;
else
explode_bomb();
}
所以根据逻辑，先找出每个节点的数据，然后再根据输入的数进行排序，保证其是从大到小的顺序排列的。根据IDA pro找到每个node所在的地址为：
地址 数据 下个节点地址
0x820AC 0xFD 0x820A0
0x820A0 0x2D5 0x82094
0x82094 0x12D 0x82088
0x82088 0x3E5 0x8207C
0x8207C 0xD4 0x82070
0x82070 0x1B0
所以由大到小排列的话就为4 2 6 3 1 5
密码
4 2 6 3 1 5
扫一扫
670
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
