设为首页收藏本站
开启辅助访问 切换到窄版

安全矩阵

 找回密码
 立即注册
搜索
安全矩阵»安全矩阵 › 安全矩阵实验室 › 技术转载 › 网络安全编程：C语言逆向之循环结构分析 ...
返回列表 发新帖
查看: 2335|回复: 0

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

[复制链接]
gclome

991

主题

1063

帖子

4315

积分

论坛元老

Rank: 8Rank: 8

积分
4315
发表于 2021-4-13 20:25:52 | 显示全部楼层 |阅读模式
原文链接：网络安全编程：C语言逆向之循环结构分析

C语言的循环结构有for循环、while循环、do循环和goto循环。本文介绍前3种循环方式。
1. for循环结构
for循环也可以称为步进循环，它的特点是常用于已经明确了循环的范围。看一个简单的C语言代码，具体如下：
  1. #include <stdio.h>
  2. int main()
  3. {
  4.   int nNum = 0, nSum = 0;
  5.   for ( nNum = 1; nNum <= 100; nNum ++ )
  6.   {
  7.     nSum += nNum;
  8.   }
  9.   printf("nSum = %d \r\n", nSum);
  10.   return 0;
  11. }
复制代码
这是很典型的求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 = 1, nSum = 0;
  5.   do
  6.   {
  7.     nSum += nNum;
  8.     nNum ++;
  9.   } while ( nNum <= 100 );
  10.   printf("nSum = %d \r\n", nSum);
  11.   return 0;
  12. }
复制代码

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. LOC_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 = 1, nSum = 0;
  5.   while ( nNum <= 100 )
  6.   {
  7.     nSum += nNum;
  8.     nNum ++;
  9.   }
  10.   printf("nSum = %d \r\n", nSum);
  11.   return 0;
  12. }
复制代码
再来看一下它的反汇编代码，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循环效率又高些。

参考文献：C++ 黑客编程揭秘与防范（第3版）





















回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|安全矩阵

GMT+8, 2024-9-21 03:29 , Processed in 0.012840 second(s), 19 queries .

Powered by Discuz! X4.0

Copyright © 2001-2020, Tencent Cloud.

快速回复 返回顶部 返回列表