网络安全编程:C语言逆向之循环结构分析

网络
C语言的循环结构有for循环、while循环、do循环和goto循环。本文介绍前3种循环方式。

[[392807]]

 C语言的循环结构有for循环、while循环、do循环和goto循环。本文介绍前3种循环方式。

1. for循环结构

for循环也可以称为步进循环,它的特点是常用于已经明确了循环的范围。看一个简单的C语言代码,具体如下: 

  1. #include <stdio.h>  
  2. int main()  
  3.  
  4.   int nNum = 0nSum = 0 
  5.   for ( nNum = 1; nNum <= 100; nNum ++ )  
  6.   {  
  7.     nSum += nNum;  
  8.   }  
  9.   printf("nSum = %d \r\n", nSum); 
  10.   return 0;  

这是很典型的求1~100的累加和的程序。通过这个程序来认识关于for循环结构的反汇编代码。 

  1. .text:00401028 mov [ebp+nNum], 0  
  2. .text:0040102F mov [ebp+nSum], 0  
  3. .text:00401036 mov [ebp+nNum], 1  
  4. .text:0040103D jmp short LOC_CMP  
  5. .text:0040103F ; ---------------------------------------------------------  
  6. .text:0040103F  
  7. .text:0040103F LOC_STEP: ; CODE XREF: _main+47j  
  8. .text:0040103F mov eax, [ebp+nNum]  
  9. .text:00401042 add eax, 1  
  10. .text:00401045 mov [ebp+nNum], eax  
  11. .text:00401048 
  12. .text:00401048 LOC_CMP: ; CODE XREF: _main+2Dj  
  13. .text:00401048 cmp [ebp+nNum], 64h  
  14. .text:0040104C jg short LOC_ENDFOR  
  15. .text:0040104E mov ecx, [ebp+nSum]  
  16. .text:00401051 add ecx, [ebp+nNum]  
  17. .text:00401054 mov [ebp+nSum], ecx  
  18. .text:00401057 jmp short LOC_STEP  
  19. .text:00401059 ; ---------------------------------------------------------  
  20. .text:00401059  
  21. .text:00401059 LOC_ENDFOR: ; CODE XREF: _main+3Cj  
  22. .text:00401059 mov edx, [ebp+nSum]  
  23. .text:0040105C push edx  
  24. .text:0040105D push offset Format ; "nSum = %d \r\n"  
  25. .text:00401062 call _printf  
  26. .text:00401067 add esp, 8  
  27. .text:0040106A xor eax, eax 

这次的反汇编代码,修改了其中的变量、标号,看起来更加直观。从修改的标号来看,for结构可以分为3部分,在LOC_STEP上面的部分是初始化部分,在LOC_STEP下面的部分是修改循环变量的部分,在LOC_CMP下面和LOC_ENDFOR上面部分是比较循环条件和循环体的部分。

for循环的反汇编结构如下: 

  1. ; 初始化循环变量  
  2.   jmp LOC_CMP  
  3. LOC_STEP:  
  4.   ; 修改循环变量  
  5. LOC_CMP:  
  6.   ; 循环变量的判断  
  7.   jxx LOC_ENDFOR  
  8.   ; 循环体  
  9.   jmp LOC_STEP  
  10. LOC_ENDOF: 

再用IDA来看一下生成的流程结构图,如图1所示。

图1  for结构的流程图

2. do…while循环结构

do循环的循环体总是会被执行一次,这是do循环与while循环的区别。这里还是1~100的累加和代码,来看一下它的反汇编结构。先看C语言代码,具体如下: 

  1. #include <stdio.h>  
  2. int main()  
  3.  
  4.   int nNum = 1nSum = 0 
  5.   do  
  6.   {  
  7.     nSum += nNum;  
  8.     nNum ++;  
  9.   } while ( nNum <= 100 );  
  10.   printf("nSum = %d \r\n", nSum);  
  11.   return 0;  

do循环的结构要比for循环的结构简单很多,反汇编代码也少很多。先来看一下IDA生成的流程图,如图2所示。

图2  do循环流程图

反汇编代码如下: 

  1. .text:00401028 mov [ebp+nNum], 1  
  2. .text:0040102F mov [ebp+nSum], 0  
  3. .text:00401036  
  4. .text:00401036 LOC_DO: ; CODE XREF: _main+3Cj  
  5. .text:00401036 mov eax, [ebp+nSum] 
  6. .text:00401039 add eax, [ebp+nNum]  
  7. .text:0040103C mov [ebp+nSum], eax  
  8. .text:0040103F mov ecx, [ebp+nNum]  
  9. .text:00401042 add ecx, 1  
  10. .text:00401045 mov [ebp+nNum], ecx  
  11. .text:00401048 cmp [ebp+nNum], 64h  
  12. .text:0040104C jle short LOC_DO  
  13. .text:0040104E mov edx, [ebp+nSum]  
  14. .text:00401051 push edx  
  15. .text:00401052 push offset Format ; "nSum = %d \r\n"  
  16. .text:00401057 call _printf  
  17. .text:0040105C add esp, 8  
  18. .text:0040105F xor eax, eax 

do循环的主体就在LOC_DO和0040104C的jle之间。其结构整理如下: 

  1. ; 初始化循环变量  
  2. C_DO:  
  3. ; 执行循环体  
  4. ; 修改循环变量  
  5. ; 循环变量的比较  
  6. Jxx LOC_DO  

3. while循环结构

while循环与do循环的区别在于,在进入循环体之前需要先进行一次条件判断,循环体有可能因为循环条件的不成立而一次也不执行。看1~100累加和的while循环代码: 

  1. #include <stdio.h>  
  2. int main()  
  3.  
  4.   int nNum = 1nSum = 0 
  5.   while ( nNum <= 100 )  
  6.   {  
  7.     nSum += nNum;  
  8.     nNum ++;  
  9.   }  
  10.   printf("nSum = %d \r\n", nSum);  
  11.   return 0; 

再来看一下它的反汇编代码,while循环比do循环多了一个条件的判断,因此会多一条分支。反汇编代码如下: 

  1. .text:00401028 mov [ebp+nNum], 1  
  2. .text:0040102F mov [ebp+nSum], 0  
  3. .text:00401036  
  4. .text:00401036 LOC_WHILE: ; CODE XREF: _main+3Ej  
  5. .text:00401036 cmp [ebp+nNum], 64h  
  6. .text:0040103A jg short LOC_WHILEEND  
  7. .text:0040103C mov eax, [ebp+nSum]  
  8. .text:0040103F add eax, [ebp+nNum]  
  9. .text:00401042 mov [ebp+nSum], eax  
  10. .text:00401045 mov ecx, [ebp+nNum]  
  11. .text:00401048 add ecx, 1  
  12. .text:0040104B mov [ebp+nNum], ecx  
  13. .text:0040104E jmp short LOC_WHILE  
  14. .text:00401050 ; -----------------------------------------------------------  
  15. .text:00401050  
  16. .text:00401050 LOC_WHILEEND: ; CODE XREF: _main+2Aj  
  17. .text:00401050 mov edx, [ebp+nSum]  
  18. .text:00401053 push edx  
  19. .text:00401054 push offset Format ; "nSum = %d \r\n"  
  20. .text:00401059 call _printf  
  21. .text:0040105E add esp, 8  
  22. .text:00401061 xor eax, eax 

while循环的主要部分全部在LOC_WHILE和LOC_WHILEEND之间。在LOC_WHILE下面的两句是cmp和jxx指令,在LOC_WHILEEND上面是jmp指令。这两部分是固定的格式,其结构整理如下: 

  1.   ; 初始化循环变量等  
  2. LOC_WHILE:  
  3.   cmp xxx, xxx  
  4.   jxx LOC_WHILEEND  
  5.   ; 循环体  
  6.   jmp LOC_WHILE  
  7. LOC_WHILEEND: 

再来看一下IDA生成的流程图,如图3所示。

图3  while循环流程图

对于for循环、do循环和while循环这3种循环而言,do循环的效率显然高些,而while循环相对来说比for循环效率又高些。 

 

责任编辑:庞桂玉 来源: 计算机与网络安全
相关推荐

2021-04-08 11:10:22

网络安全C语言if…else…

2021-04-14 15:53:58

网络安全C语言wcslen

2021-04-06 11:04:54

网络安全C语言代码

2021-03-31 11:35:00

网络安全OllyDbg分析工具

2021-04-01 10:40:22

网络安全软件

2016-10-10 00:18:27

2011-03-17 11:24:18

2021-04-19 10:26:41

网络安全PE文件

2021-03-24 09:46:46

网络安全软件反汇编

2011-03-17 13:32:45

2011-03-17 12:49:32

2021-04-27 10:00:27

网络安全WebURL

2021-03-03 12:20:42

网络安全DLL编程

2021-05-21 12:52:47

网络安全Android App虚拟机

2021-04-30 18:50:44

网络安全PE编程添加节区

2021-12-28 00:11:40

网络安全攻击

2021-04-26 10:32:38

网络安全PE编程工具

2021-03-05 13:46:56

网络安全远程线程

2021-01-26 13:45:03

网络安全Winsock编程

2021-12-21 06:07:10

网络安全网络攻击网络威胁
点赞
收藏

51CTO技术栈公众号