C++反汇编学习笔记1——选择判断语句

来源：互联网发布：centos 安装desktop 编辑：程序博客网时间：2024/05/01 14:17

逆向第一篇，两年前写的，欢迎大家吐槽！

转载请注明出处。

1.流程控制语句的识别

If…else…语句比较简单，这里就不做详细说明。这里对switch语句和循环语句进行判断。

1.1 switch语句

1.1.1 case语句块不大于3条（模拟if…else…结构，也有可能不止3条，表示比较少）

此时，switch语句块反汇编的代码与if…else…的相差无几，只是switch语句将所有条件跳转都放到了一起并与case语句块分开，而if…else…则是每一条跳转语句后都跟着语句块，反汇编都比较简单，这里不再赘述。下面举出一个例子：

8: switch(i){

0042B3F6 mov eax,dword ptr [i]

0042B3F9 mov dword ptr[ebp-0D0h],eax

//取出i的值

0042B3FF cmp dword ptr [ebp-0D0h],1 //和1比较

0042B406 je test_switch_if+5Ch (42B41Ch) //条件成立跳转到case1

0042B408 cmp dword ptr [ebp-0D0h],3 //和3比较

0042B40F je test_switch_if+6Bh(42B42Bh) //条件成立跳转到case3

0042B411 cmp dword ptr [ebp-0D0h],64h //和100比较

0042B418 je test_switch_if+7Ah (42B43Ah) //条件成立跳转到case100

0042B41A jmp test_switch_if+87h(42B447h) //否则跳转至switch结束处

9: case 1:

10: printf("i == 1");

0042B41C push offset string "i== 1" (47DC80h)

0042B421 call @ILT+4100(_printf) (42A009h)

0042B426 add esp,4

//调用printf函数

11: break;

//跳转至switch结束处，下面两个结构相同

0042B429 jmp test_switch_if+87h (42B447h)

12: case 3:

13: printf("i == 3");

0042B42B push offset string "i == 3" (47DC78h)

0042B430 call @ILT+4100(_printf) (42A009h)

0042B435 add esp,4

14: break;

0042B438 jmp test_switch_if+87h (42B447h)

15: case 100:

16: printf("i == 100");

0042B43A push offset string "i== 100" (47DC6Ch)

0042B43F call @ILT+4100(_printf) (42A009h)

0042B444 add esp,4

17: break;

18: }

1.1.2 有序线性表的switch

当case的最大值和最小值之间差距较小时使用这种方法优化，一半差距不会大于10（VC++6.0似乎是不大于7，下面会看到和VS2010编译器的区别）。

直接看例子：

26: switch(nIndex)

0042B4C6 mov eax,dword ptr[nIndex]

0042B4C9 mov dword ptr[ebp-0D0h],eax

0042B4CF mov ecx,dword ptr [ebp-0D0h]

//到此为止的三行是取出i的值

0042B4D5 sub ecx,1

//这里的减1则是为了与线性表的对齐，线性表第一个为0

0042B4D8 mov dword ptr [ebp-0D0h],ecx

0042B4DE cmp dword ptr [ebp-0D0h],6

//这里和6比较是因为case最大值为7，减1后为6，若超过最大值则直接跳出语句或跳向default

0042B4E5 ja $LN1+0Dh (42B54Ch)

0042B4E7 mov edx,dword ptr [ebp-0D0h]

0042B4ED jmp dword ptr (42B59Ch)[edx*4]

//决定跳向哪个case

27: {

28: case 1:

29: printf("nIndex == 1");

0042B4F4 push offset string"nIndex == 1" (47DCECh)

0042B4F9 call @ILT+4100(_printf) (42A009h)

0042B4FE add esp,4

//Printf函数的调用

30: break;

0042B501 jmp $LN1+0Dh (42B54Ch)

//跳向结束或是default语句块，以下的case都类似

31: case 2:

32: printf("nIndex == 2");

0042B503 push offset string "nIndex == 2" (47DCDCh)

0042B508 call @ILT+4100(_printf) (42A009h)

0042B50D add esp,4

33: break;

0042B510 jmp $LN1+0Dh (42B54Ch)

34: case 3:

35: printf("nIndex == 3");

0042B512 push offset string "nIndex == 3" (47DCCCh)

0042B517 call @ILT+4100(_printf) (42A009h)

0042B51C add esp,4

36: break;

0042B51F jmp $LN1+0Dh(42B54Ch)

37: case 5:

38: printf("nIndex == 5");

0042B521 push offset string "nIndex == 5" (47DCBCh)

0042B526 call @ILT+4100(_printf) (42A009h)

0042B52B add esp,4

39: break;

0042B52E jmp $LN1+0Dh (42B54Ch)

40: case 6:

41: printf("nIndex == 6");

0042B530 push offset string "nIndex == 6" (47DCACh)

0042B535 call @ILT+4100(_printf) (42A009h)

0042B53A add esp,4

42: break;

0042B53D jmp $LN1+0Dh (42B54Ch)

43: case 7:

44: printf("nIndex == 7");

0042B53F push offset string"nIndex == 7" (47DC9Ch)

0042B544 call @ILT+4100(_printf) (42A009h)

0042B549 add esp,4

45: break;

46: }

在这种情况下编译器会生成一张地址表来帮助寻找case，如下所示：

0x0042B59C f4 b4 42 00

0x0042B5A0 03 b5 42 00

0x0042B5A4 12 b5 42 00

0x0042B5A8 4c b5 42 00

0x0042B5AC 21 b5 42 00

0x0042B5B0 30b5 42 00

0x0042B5B4 3f b5 42 00

这里的每个元素代表着一个case的地址，例如f4 b4 4200地址是0x0042b4f4，再看看书上面case1的地址发现是一样的，依次类推。你还会看到那些没有的元素，就是第四个元素4c b5 42 00，这里就把没有的case都定为default或是switch的结束地址。

以上是debug版本的程序反汇编的结果，release版本的差不多，就是在每个case的最后一句有所不同，因为这个程序在switch语句后就直接返回了且每个case都以break结尾所以编译器决定减少一个跳转，直接在case结束后返回以节约时间提高效率。

1.1.3 难以构成线性表的switch

当两个case值相差较大采取上面的方法会浪费许多空间，而采取以下索引表的结构则不会浪费太多。下面是一个简单的例子：

switch(i){

0042B5F6 mov eax,dword ptr [i]

0042B5F9 mov dword ptr[ebp-0D0h],eax

0042B5FF mov ecx,dword ptr [ebp-0D0h]

//到此为止的三行是取出i的值

0042B605 sub ecx,1

//这里的减1则是为了与线性表的对齐，线性表第一个为0

0042B608 mov dword ptr [ebp-0D0h],ecx

0042B60E cmp dword ptr [ebp-0D0h],18h

0042B615 ja $LN1+0Dh (42B692h)

//若超过最大值则直接跳转到switch结束处

0042B617 mov edx,dword ptr [ebp-0D0h]

0042B61D movzx eax,byte ptr (42B6F0h)[edx]

0042B624 jmp dword ptr (42B6D0h)[eax*4] //根据输入的元素决定跳转到哪一个case

56: case 1:

57: printf("i == 1");

0042B62B push offset string "i == 1" (47DC80h)

0042B630 call @ILT+4100(_printf) (42A009h)

0042B635 add esp,4

//以上是调用printf函数

58: break;

0042B638 jmp $LN1+0Dh (42B692h)

//直接跳到switch结束处

//下面的每个case都是一样的结构

59: case 2:

60: printf("i == 2");

0042B63A push offset string "i== 2" (47DD1Ch)

0042B63F call @ILT+4100(_printf) (42A009h)

0042B644 add esp,4

61: break;

0042B647 jmp $LN1+0Dh (42B692h)

62: case 3:

63: printf("i == 3");

0042B649 push offset string "i == 3" (47DC78h)

0042B64E call @ILT+4100(_printf) (42A009h)

0042B653 add esp,4

64: break;

0042B656 jmp $LN1+0Dh (42B692h)

65: case 5:

66: printf("i == 5");

0042B658 push offset string "i == 5" (47DD10h)

0042B65D call @ILT+4100(_printf) (42A009h)

0042B662 add esp,4

67: break;

0042B665 jmp $LN1+0Dh (42B692h)

68: case 6:

69: printf("i == 6");

0042B667 push offset string "i == 6" (47DD08h)

0042B66C call @ILT+4100(_printf) (42A009h)

0042B671 add esp,4

70: break;

0042B674 jmp $LN1+0Dh (42B692h)

71: case 7:

72: printf("i == 7 ");

0042B676 push offset string "i == 7 " (47DD00h)

0042B67B call @ILT+4100(_printf) (42A009h)

0042B680 add esp,4

73: break;

0042B683 jmp $LN1+0Dh (42B692h)

74: case 25:

75: printf("i == 25");

0042B685 push offset string "i == 255" (47DDF0h)

0042B68A call @ILT+4100(_printf) (42A009h)

0042B68F add esp,4

76: break;

这里最关键的是这一句：

0042B624 jmp dword ptr (42B6D0h)[eax*4]

也就是选择跳转到哪一个case的语句。在这种情况下，编译器会为switch建立两张表，一张是前面类似的地址表，一张则是索引表。下面来看一下具体内容是什么：

0x0042B6D0 2bb6 42 00

0x0042B6D4 3a b6 42 00

0x0042B6D8 49b6 42 00

0x0042B6DC 58b6 42 00

0x0042B6E0 67b6 42 00

0x0042B6E4 76b6 42 00

0x0042B6E8 85b6 42 00

0x0042B6EC 92b6 42 00

上面的这个就是case地址表，里面存着每个case对应的地址。如第一个2b b6 42 00，它的地址就是0x0042b62b，这正是case 1所在的地址，这就是为什么前面的代码要将i-1了，这就是地址表的第0号元素。后面的就很简单了，如果是3那么找到线性表的第三个元素内容49 b6 42 00，对应地址为0x0042b649，这就是case 3的地址。但是这里的没有case 4，所以第四个元素的地址就是default或是switch的结束地址。但是要如何找到地址表呢？这里通过一个索引表来找到：

0x0042B6F0 00 01 02 07 03 04 05 07 07 07 07 07 07 07 07 07 07 07 0707 07 07 07 07 06

说是索引不如说是地址表的下标。如果i=3，减去1之后是2，找到索引表中下标为2的内容是02，再由02去地址表中找到地址49 b6 42 00即0x0042b649，这就是要跳转的地址，接下去就很简单了，不必多说。你还会看到那些没有的索引，比如10，这里就把没有的case索引都定为地址表中的最后一个元素，这就是default或是switch的结束地址。

这里总共有25个元素，共占资源7*4+25=53个字节，若是全部按照地址表来存储则需25*4=100个字节。这样存储明显就减少了很多的存储空间。当然这也并非全是好处，由于索引表中只用一个字节存储索引，故最大只能有256个索引，比这还大的需要下面一种方法优化。

1.1.4降低判定树的高度

还是和上面一样先看例子：

85: switch(i){

0042B746 mov eax,dword ptr [i]

0042B749 mov dword ptr [ebp-0D0h],eax

//取出i的值

0042B74F cmp dword ptr[ebp-0D0h],23h

0042B756 jg test_switch_tree+7Eh (42B78Eh)

//和35比较，大于则跳转至42B78Eh

0042B758 cmp dword ptr [ebp-0D0h],23h

0042B75F je $LN6+0Fh(42B7EDh)

//等于35的跳转至case35处

0042B765 mov ecx,dword ptr [ebp-0D0h]

0042B76B sub ecx,2

//case值与地址表中的元素对齐，所以要减2

0042B76E mov dword ptr [ebp-0D0h],ecx

0042B774 cmp dword ptr [ebp-0D0h],8

0042B77B ja $LN6+4Bh (42B829h)

//大于10（-2后大于8就相当于大于10）则跳转至default处

0042B781 mov edx,dword ptr [ebp-0D0h]

0042B787 jmp dword ptr (42B874h)[edx*4]

在小于10的case中利用前面提到过的线性表进行优化，此处即为线性表的寻址

0042B78E cmp dword ptr [ebp-0D0h],25h

0042B795 je $LN6+1Eh (42B7FCh)

//和37比较，相等则跳至case37处

0042B797 cmp dword ptr [ebp-0D0h],29Ah

0042B7A1 je $LN6+2Dh (42B80Bh)

//和666比较，相等则跳至case666处

0042B7A3 cmp dword ptr[ebp-0D0h],2710h

0042B7AD je $LN6+3Ch (42B81Ah)

//和10000比较，相等则跳至case10000处

0042B7AF jmp $LN6+4Bh (42B829h)

//跳至default处

86: case 2:

87: printf("i == 2\n");

0042B7B1 push offset string "i == 2\n" (47DCF8h)

0042B7B6 call @ILT+4100(_printf) (42A009h)

0042B7BB add esp,4

88: break;

0042B7BE jmp $LN6+58h (42B836h)

89: case 3:

90: printf("i == 3\n");

0042B7C0 push offset string "i== 3\n" (47DC90h)

0042B7C5 call @ILT+4100(_printf) (42A009h)

0042B7CA add esp,4

91: break;

0042B7CD jmp $LN6+58h (42B836h)

92: case 8:

93: printf("i == 8\n");

0042B7CF push offset string "i == 8\n" (47DD74h)

0042B7D4 call @ILT+4100(_printf) (42A009h)

0042B7D9 add esp,4

94: break;

0042B7DC jmp $LN6+58h (42B836h)

95: case 10:

96: printf("i == 10\n");

0042B7DE push offset string "i == 10\n" (47DD68h)

0042B7E3 call @ILT+4100(_printf) (42A009h)

0042B7E8 add esp,4

97: break;

0042B7EB jmp $LN6+58h (42B836h)

98: case 35:

99: printf("i == 35\n");

0042B7ED push offset string "i == 35\n" (47DD5Ch)

0042B7F2 call @ILT+4100(_printf) (42A009h)

0042B7F7 add esp,4

100: break;

0042B7FA jmp $LN6+58h (42B836h)

101: case 37:

102: printf("i == 37\n");

0042B7FC push offset string "i == 37\n" (47DD50h)

0042B801 call @ILT+4100(_printf) (42A009h)

0042B806 add esp,4

103: break;

0042B809 jmp $LN6+58h (42B836h)

104: case 666:

105: printf("i == 666\n");

0042B80B push offset string "i == 666\n" (47DD44h)

0042B810 call @ILT+4100(_printf) (42A009h)

0042B815 add esp,4

106: break;

0042B818 jmp $LN6+58h (42B836h)

107: case 10000:

108: printf("i == 10000\n");

0042B81A push offset string "i== 10000\n" (47DD38h)

0042B81F call @ILT+4100(_printf) (42A009h)

0042B824 add esp,4

109: break;

0042B827 jmp $LN6+58h (42B836h)

110: default:

111: printf("default\n");

0042B829 push offset string "default\n" (47DD2Ch)

0042B82E call @ILT+4100(_printf) (42A009h)

0042B833 add esp,4

112: break;

在这里，由于case值相差过大，因此采取类似于二叉树的结构来进行查找。首先判断是否大于35，之后分成两部分进行判断，小于35的由于比较接近因此采用线性查找法，而大于35的部分则采用if...else...模拟法即使用第一种优化方式进行优化。但是在我所购买的书中是使用VC++6.0编译器，所以它的代码反汇编出的结果看出无论是大于35还是小于35的部分都使用了if...else...模拟法进行优化。

以上是用Visual Studio 2010反汇编器对Deubg版本进行的反汇编，下面可以利用IDA Pro反汇编Release版本并查看其结构，具体如下：

这是简单的结构图。

放大之后可以看到里面都有代码，利用这个分析将会事半功倍。

以上是其主要的结构流程，可以看到和二叉树的形状非常类似， Release版本的具体代码和Debug版本的差不多，具体还是像之前那样分析就可以了。

0 0