Bomb

Posted on | Edited on | In

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指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
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语言逻辑如下：

1
2
3
4
5
6
7
8
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指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
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判断，其伪代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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 ，所以现在就到了86d0的代码块○13，其逻辑为先取fp-13(输入的第二个参数char)放到r3，然后再去fp-5的值放到r2，其中fp-5的值为刚才放的0x6b，查ascii表为k，所以结果就为3 k 0xfb,其余的case 为4,5,6,7的情况和case 3的情况类似。代码○12为default情况，其逻辑是先把0x78存入fp-5,然后就explode_bomb;所以总之就是default情况就会碰到炸弹。

密码

3 k 0xfb

Phase 4

Arm指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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语言的伪代码如下：

1
2
3
4
5
6
7
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指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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++。所以该段代码的伪代码如下：

1
2
3
4
5
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
2
3
4
5
6
7
8
9
10
 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。

对这六个数的值进行判定

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
    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，又进行了一次循环。其伪代码如下：

1
2
3
4
5
6
7
8
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();
}
}

根据输入的6个数把链表的6个node进行索引排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
    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循环的伪代码如下：

1
2
3
4
5
6
7
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的大小关系。

判断链表的节点的数值是否是按从大到小的顺序排列的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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的数据结构如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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