二进制炸弹实验报告Word格式文档下载.docx

二进制炸弹实验报告Word格式文档下载.docx

《二进制炸弹实验报告Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《二进制炸弹实验报告Word格式文档下载.docx（26页珍藏版）》请在冰豆网上搜索。

8048c22:

e81d040000call8049044<

strings_not_equal>

//判断%eax是否为0，为0跳转，不为0引爆

8048c27:

85c0test%eax,%eax

8048c29:

7405je8048c30<

phase_1+0x20>

8048c2b:

e8a3090000call80495d3<

explode_bomb>

//撤销栈桢，返回

8048c30:

83c41cadd$0x1c,%esp

8048c33:

c3ret

程序流程：

1.取内存地址0x8049a04处的内容；

2.取用户输入的内容（即密码）；

3.比较两者的值，相等则%eax置为0，进入下一关，不相等则调用引爆程序引爆炸弹。

破解思路：

通过p（char*）0x8049a04指令取出该地址的字符串，得到：

因此第一关的密码：

ForNASA,spaceisstillahighpriority.

五、第二关炸弹拆除

08048c34<

phase_2>

8048c34:

53push%ebx

8048c35:

83ec38sub$0x38,%esp

8048c38:

8d442418lea0x18（%esp）,%eax

8048c3c:

89442404mov%eax,0x4（%esp）

//取用户输入的内容，存入%esp

8048c40:

8b442440mov0x40（%esp）,%eax

8048c44:

//调用函数read_six_numbers

8048c47:

e88c0a0000call80496d8<

read_six_numbers>

//比较第一个输入的的数是否为1

8048c4c:

837c241801cmpl$0x1,0x18（%esp）

//若为1则跳转下一步，否则引爆

8048c51:

7405je8048c58<

phase_2+0x24>

8048c53:

e87b090000call80495d3<

//设置循环变量初始值%ebx=1

8048c58:

bb01000000mov$0x1,%ebx

//循环开始

//保存当前循环变量%eax<

-%ebx

8048c5d:

89d8mov%ebx,%eax

//循环变量后移%edx<

-%ebx+=1

8048c5f:

83c301add$0x1,%ebx

8048c62:

89damov%ebx,%edx

//%edx*=*（%esp+%eax*4+14）

8048c64:

0faf548414imul0x14（%esp,%eax,4）,%edx

//比较%edx与*（%esp+%eax*4+18）

8048c69:

39548418cmp%edx,0x18（%esp,%eax,4）

//相等则跳转下一步，否则引爆

8048c6d:

7405je8048c74<

phase_2+0x40>

8048c6f:

e85f090000call80495d3<

//比较%ebx是否为6，不等则继续循环

8048c74:

83fb06cmp$0x6,%ebx

8048c77:

75e4jne8048c5d<

phase_2+0x29>

//循环结束，撤销栈桢，返回

8048c79:

83c438add$0x38,%esp

8048c7c:

5bpop%ebx

8048c7d:

1.读取用户输入内容（为6个数字）；

2.判断输入的第一个值是否为1，不是则引爆炸弹；

3.做一个6次循环，判断后一个数是否等于前一个数乘当前循环变量，不是则引爆炸弹；

4.六个数字判断相等结束后，进入下一关

设输入内容为一个数组Key[6]，则可知Key[0]=1，Key[i+1]=Key[i]*（i+1）。

因此第二关的密码是：

12624120720

六、第三关炸弹拆除

08048c7e<

phase_3>

8048c7e:

83ec2csub$0x2c,%esp

//用户输入的参数2存在%esp+1c

8048c81:

8d44241clea0x1c（%esp）,%eax

8048c85:

8944240cmov%eax,0xc（%esp）

//用户输入的参数1存在%esp+18

8048c89:

8048c8d:

89442408mov%eax,0x8（%esp）

//取出地址8049dfa中的内容”%d%d”

8048c91:

c7442404fa9d04movl$0x8049dfa,0x4（%esp）

8048c98:

8048c99:

8b442430mov0x30（%esp）,%eax

8048c9d:

//调用sscanf函数，传入输入参数

8048ca0:

e86bfcffffcall8048910<

__isoc99_sscanf@plt>

//判断返回值是否大于1，大于则引爆

8048ca5:

83f801cmp$0x1,%eax

8048ca8:

7f05jg8048caf<

phase_3+0x31>

8048caa:

e824090000call80495d3<

//比较参数1是否大于7，大于则引爆

8048caf:

837c241807cmpl$0x7,0x18（%esp）

8048cb4:

7766ja8048d1c<

phase_3+0x9e>

//把参数1存入%eax，作为地址搜索变量

8048cb6:

8b442418mov0x18（%esp）,%eax

//跳转到地址0x8049a60+4*%eax处

8048cba:

ff2485609a0408jmp*0x8049a60（,%eax,4）

//参数1为1时跳转到此处，并继续跳转

8048cc1:

b800000000mov$0x0,%eax//1

8048cc6:

eb05jmp8048ccd<

phase_3+0x4f>

//参数1为0时跳转到此处，并继续跳转

8048cc8:

b840010000mov$0x140,%eax//0

8048ccd:

2da6000000sub$0xa6,%eax

8048cd2:

eb05jmp8048cd9<

phase_3+0x5b>

//参数1为2时跳转到此处，并继续跳转

8048cd4:

b800000000mov$0x0,%eax//2

8048cd9:

05b6010000add$0x1b6,%eax

8048cde:

eb05jmp8048ce5<

phase_3+0x67>

//参数1为3时跳转到此处，并继续跳转

8048ce0:

b800000000mov$0x0,%eax//3

8048ce5:

2ddb010000sub$0x1db,%eax

8048cea:

eb05jmp8048cf1<

phase_3+0x73>

//参数1为4时跳转到此处，并继续跳转

8048cec:

b800000000mov$0x0,%eax//4

8048cf1:

056d030000add$0x36d,%eax

8048cf6:

eb05jmp8048cfd<

phase_3+0x7f>

//参数1为5时跳转到此处，并继续跳转

8048cf8:

b800000000mov$0x0,%eax//5

8048cfd:

2df4000000sub$0xf4,%eax

8048d02:

eb05jmp8048d09<

phase_3+0x8b>

//参数1为6时跳转到此处，并继续跳转

8048d04:

b800000000mov$0x0,%eax//6

8048d09:

05f4000000add$0xf4,%eax

8048d0e:

eb05jmp8048d15<

phase_3+0x97>

//参数1为7时跳转到此处，并继续跳转

8048d10:

b800000000mov$0x0,%eax//7

8048d15:

2d9e020000sub$0x29e,%eax

8048d1a:

eb0ajmp8048d26<

phase_3+0xa8>

8048d1c:

e8b2080000call80495d3<

8048d21:

b800000000mov$0x0,%eax

//比较参数1是否大于5，大于则引爆

8048d26:

837c241805cmpl$0x5,0x18（%esp）

8048d2b:

7f06jg8048d33<

phase_3+0xb5>

//比较参数2与计算得到的%eax是否相等

8048d2d:

3b44241ccmp0x1c（%esp）,%eax

//相等则返回，不相等则引爆

8048d31:

7405je8048d38<

phase_3+0xba>

8048d33:

e89b080000call80495d3<

8048d38:

83c42cadd$0x2c,%esp

8048d3b:

1.读取输入参数1和参数2，调用ssanf函数传入两个参数；

2.比较参数1与7的大小，小于等于7继续，大于7引爆；

3.根据参数1的值来搜索跳转地址，计算得到最终的%eax；

4.比较参数1与5的大小，小于等于5继续，大于5引爆；

5.比较参数2与计算得到的%eax是否相等，相等则进入下一关，不相等则引爆。

首先我们通过p（char*）8049dfa读取该内存地址中的内容：

可知输入的两个参数都是整数，并且进一步我们知道参数1小于等于7（无符合数），那么参数1只能是01234567。

根据参数1的值得到跳转地址向量表：

因此我们可以得到一个Switch函数表：

Case参数1==0：

参数2=0x（140+a6+1b6-1db+36d-f4+f4-29e）=0x290=656；

Case参数1==1：

参数2=0x（a6+1b6-1db+36d-f4+f4-29e）=0x150=336；

Case参数1==2：

参数2=0x（1b6-1db+36d-f4+f4-29e）=0xaa=170；

Case参数1==3：

参数2=0x（-1db+36d-f4+f4-29e）=0xfef4=-268；

Case参数1==4：

参数2=0x（36d-f4+f4-29e）=0xcf=207；

Case参数1==5：

参数2=0x（-f4+f4-29e）=0xfd62=-670；

Case参数1==6：

参数2=0x（f4-29e）=0xfe56=-426；

Case参数1==7：

参数2=0x（-29e）=0xfd62=-670；

注意到最后有个判断条件要求参数1小于等于5：

因此第三关的密码是（以下任一组）：

0656；

1336；

2170；

3-268；

4207；

5-670

七、第四关炸弹拆除：

08048d7b<

phase_4>

8048d7b:

//用户输入的参数存在%esp+1c

8048d7e:

8048d82:

//读取地址0x8049dfd的内容

8048d86:

c7442404fd9d04movl$0x8049dfd,0x4（%esp）

8048d8d:

8048d8e:

8048d92:

//调用函数sscanf

8048d95:

e876fbffffcall8048910<

//比较返回值是否等于1，不等则引爆

8048d9a:

8048d9d:

7507jne8048da6<

phase_4+0x2b>

//比较输入参数与0的大小，小于等于则引爆

8048d9f:

837c241c00cmpl$0x0,0x1c（%esp）

8048da4:

7f05jg8048dab<

phase_4+0x30>

8048da6:

e828080000call80495d3<

//把输入参数传入函数func4，调用函数func4

8048dab:

8b44241cmov0x1c（%esp）,%eax

8048daf:

8048db2:

e885ffffffcall8048d3c<

func4>

//比较返回值是否等于0x1055，不等则引爆

8048db7:

3d55100000cmp$0x1055,%eax

8048dbc:

7405je8048dc3<

phase_4+0x48>

8048dbe:

e810080000call80495d3<

//相等则撤销栈桢，返回

8048dc3:

8048dc6:

主程序流程：

1.读取参数，调用sscanf函数传入参数；

2.比较输入参数与0的大小，小于等于则引爆；

3.把输入参数传入函数func4，并调用函数func4；

4.若函数func4返回值等于0x1055，则返回，进入下一关，否则引爆炸弹。

08048d3c<

8048d3c:

83ec1csub$0x1c,%esp

8048d3f:

895c2414mov%ebx,0x14（%esp）

8048d43:

89742418mov%esi,0x18（%esp）

//把参数传入%ebx

8048d47:

8b5c2420mov0x20（%esp）,%ebx

8048d4b:

b801000000mov$0x1,%eax

//比较%ebx与1的大小，大于则继续

8048d50:

83fb01cmp$0x1,%ebx

8048d53:

7e1ajle8048d6f<

func4+0x33>

//%eax<

-%ebx-1并传入func4继续递归

8048d55:

8d43fflea-0x1（%ebx）,%eax

8048d58:

8048d5b:

e8dcffffffcall8048d3c<

//%esi=%eax,%ebx-=2

8048d60:

89c6mov%eax,%esi

8048d62:

83eb02sub$0x2,%ebx

//%esp<

-%ebx，并传入fun4继续递归

8048d65:

891c24mov%ebx,（%esp）

8048d68:

e8cfffffffcall8048d3c<

//%eax+=%esi

8048d6d:

01f0add%esi,%eax

//%ebx<

=1，返回

8048d6f:

8b5c2414mov0x14（%esp）,%ebx

8048d73:

8b742418mov0x18（%esp）,%esi

8048d77:

8048d7a:

func4函数流程：

1.比较传入参数是否大于1，大于1则继续，小于等于1则返回1；

2.循环%eax<

-%ebx-1，并递归调用函数func4，直到参数小于等于1；

3.循环变量%ebx每次减2，并传入%esp继续递归调用函数func4；

4.函数返回的所得值加到%eax；

首先我们通过p（char*）0x8049dfd读取该内存地址中的内容：

可知输入参数为一个整数，进一步我们发现它大于0。

为了更好地理解func4函数，我们可以写出其大致的框架：

通过列举或用C程序跑该函数可以得到：

Func4（0）=1；

Func4

（1）=1；

Func4

（2）=2；

Func4（3）=3；

Func4（4）=5；

Func4（5）=8；

Func4（6）=13；

Func4（7）=21；

Func4（8）=34；

Func4（9）=55；

Func4（10）=89；

Func4（11）=144；

Func4（12）=233；

Func4（13）=377；

Func4（14）=610；

Func4（15）=987；

Func4（16）=1597；

Func4（17）=2584；

Func4（18）=4181=0x1055。

因此第四关的密码是：

18

八、第五关炸弹拆除

08048dc7<

phase_5>

8048dc7:

8048dc8:

83ec18sub$0x18,%esp

8048dcb:

8048dcf:

//调用string_length函数

8048dd2:

e854020000call804902b<

string_length>

//比较字符串长度，不等于6则引爆

8048dd7:

83f806cmp$0x6,%eax

8048dda:

7405je8048de1<

phase_5+0x1a>

8048ddc:

e8f2070000call80495d3<

//把%edx和%eax初始化置0

8048de1:

ba00000000mov$0x0,%edx

8048de6:

//%ecx<

-（%ebx+%eax）

8048deb:

0fbe0c03movsbl（%ebx,%eax,1）,%ecx

//取%ecx中的内容的低四位

8048def:

83e10fand$0xf,%ecx

//%edx+=*（0x8049a80+4*%ecx）

8048df2:

03148d809a