C++内嵌汇编(一):反汇编分析C++代码

转载 2013年12月05日 10:03:12

http://chuanwang66.iteye.com/blog/1433218 

这是一篇好文章的,赞一个!

 

Sam: 使用binutils-2.23.1这个软件中的小工具objdump -d *.o 可以对一个目标文件进行反汇编:)

了解反汇编的一些小知识对于我们在开发软件时进行编程与调试大有好处,下面以 VS2008 环境下的 VC++ 简单介绍一下反汇编的一些小东西!

1  、新建简单的  VC  控制台应用程序

A 、打开 Microsoft Visual Studio 2008 ,选择主菜单 “File”

B 、选择子菜单 “New” 下面的 “Project” ,打开 “New Project” 对话框。

C 、左边选择 Visual C++ 下的 win32 ,右边选择 Win32 Console Application ,然后输入一个工程名,点击 “OK” 即可,在出现的向导中,一切默认,点击 Finish 即可。

D 、在出现的编辑区域内会出现以你设定的工程名命名的 CPP 文件。内容如下:

Cpp代码 复制代码 收藏代码
  1. #include "stdafx.h" 
  2. int _tmain(int argc, _TCHAR* argv[]) 
  3.      return 0; 
  4. }  
#include "stdafx.h"int _tmain(int argc, _TCHAR* argv[]){     return 0;} 

2  、  VS  查看汇编代码

A 、 VC 处于调试状态才能看到汇编指令窗口 。因此,可以在  return 0  上设置一个断点:把光标移到  return 0  那一行上,然后按下 F9 键设置一个断点。

B 、按下 F5 键进入调试状态,当程序停在  return 0  这一行上时,打开菜单 “Debug” 下的 “Windows” 子菜单,选择 “Disassembly” 。这样,出现一个反汇编的窗口,显示下面的信息:

汇编代码 复制代码 收藏代码
  1. <span>--- d:\my documents\visual studio 2008\projects\casmtest\casmtest\casmtest_main.cpp</span> 
  2.  
  3.  
  4. // CAsmTest.cpp : 定义控制台应用程序的入口点。 
  5.  
  6. #include "stdafx.h" 
  7.  
  8. int _tmain(int argc, _TCHAR* argv[]) 
  9. 00411370  push        ebp  
  10. 00411371  mov         ebp,esp                   // 此后 ,ebp 寄存器中实际保存的是原来 esp 的内容 
  11. 00411373  sub         esp,0C0h 
  12. 00411379  push        ebx  
  13. 0041137A  push        esi  
  14. 0041137B  push        edi  
  15. 0041137C  lea         edi,[ebp-0C0h]         // 作用: 将 (ebp-0C0h) 这个数值放入 edi 
  16. 00411382  mov         ecx,30h 
  17. 00411387  mov         eax,0CCCCCCCCh 
  18. 0041138C  rep stos    dword ptr es:[edi] 
  19. return 0; 
  20. 0041138E  xor         eax,eax            // 嵌入汇编时,如果函数没有指定返回值,则 eax 为默认返回值 
  21. 00411390  pop         edi  
  22. 00411391  pop         esi  
  23. 00411392  pop         ebx  
  24. 00411393  mov        esp,ebp 
  25. 00411395  pop         ebp  
  26. 00411396  ret  
--- d:\my documents\visual studio 2008\projects\casmtest\casmtest\casmtest_main.cpp// CAsmTest.cpp : 定义控制台应用程序的入口点。#include "stdafx.h"int _tmain(int argc, _TCHAR* argv[]){00411370  push        ebp 00411371  mov         ebp,esp                   // 此后 ,ebp 寄存器中实际保存的是原来 esp 的内容00411373  sub         esp,0C0h00411379  push        ebx 0041137A  push        esi 0041137B  push        edi 0041137C  lea         edi,[ebp-0C0h]         // 作用: 将 (ebp-0C0h) 这个数值放入 edi00411382  mov         ecx,30h00411387  mov         eax,0CCCCCCCCh0041138C  rep stos    dword ptr es:[edi] return 0;0041138E  xor         eax,eax            // 嵌入汇编时,如果函数没有指定返回值,则 eax 为默认返回值}00411390  pop         edi 00411391  pop         esi 00411392  pop         ebx 00411393  mov        esp,ebp00411395  pop         ebp 00411396  ret 

      上面就是系统生成的 main 函数原型,确切的说是 _tmain() 的反汇编的相关信息,相信学过汇编语言的肯定就能够了解它所做的操作了。

3  、简单了解一下常见的汇编指令

为了照顾到没学过汇编程序的同志们,这里简单介绍一下常见的几种汇编指令。

A 、 add :加法指令,第一个是目标操作数,第二个是源操作数,格式为:目标操作数  =  目标操作数  +  源操作数。

B 、 sub :减法指令,格式同  add 。

C 、 call :调用函数,一般函数的参数放在寄存器中。

D 、 ret :跳转会调用函数的地方。对应于 call ,返回到对应的 call 调用的下一条指令,若有返回值,则放入 eax 中。

E 、 push :把一个 32 位的操作数压入堆栈中,这个操作在 32 位机中会使得 esp 被减 4 (字节), esp 通常是指向栈顶的(这里要指出的是:学过单片机的同学请注意单片机种的堆栈与 Windows 下的堆栈是不同的,请参考相应资料),这里顶部是地址小的区域,那么,压入堆栈的数据越多, esp 也就越来越小。

F 、 pop :与 push 相反, esp 每次加 4 (字节),一个数据出栈。 pop 的参数一般是一个寄存器,栈顶的数据被弹出到这个寄存器中。

一般不会把 sub 、 add 这样的算术指令,以及 call 、 ret 这样的跳转指令归入堆栈相关指令中。但是实际上在函数参数传递过程中, sub 和 add 最常用来操作堆栈; call 和 ret 对堆栈也有影响。

G 、 mov :数据传送。第一个参数是目的操作数,第二个参数是源操作数,就是把源操作数拷贝到目的一份。

H 、 xor :异或指令,这本身是一个逻辑运算指令,但在汇编指令中通常会见到它被用来实现清零功能。用  xor eax,eax 这种操作来实现  mov eax,0 ,可以使速度更快,占用字节数更少。

I 、 lea : load effect address.  取得第二个参数的有效地址(也就是去偏移地址)后放入到前面的寄存器(第一个参数)中。

然而 lea 也同样可以实现 mov 的操作,例如:

                                  lea edi,[ebx-0ch]

方括号表示存储单元,也就是提取方括号中的数据所指向的内容,然而 lea 提取内容的地址,这样就实现了把( ebx-0ch )放入到了 edi 中,但是 mov 指令是不支持第二个操作数是一个寄存器减去一个数值的。

J 、 stos :串行存储指令,它实现把 eax 中的数据放入到 edi 所指的地址中,同时 edi 后移 4 个字节,这里的 stos 实际上对应的是 stosd  ,其他的还有 stosb,stosw 分别对应 1 , 2 个字节。

注意:

(1) stosb:   [esi] 中一个字节送入 AL

(2) stosw: [esi] 中一个字送入 AX

(3) stosd:   [esi] 中一个双字送入 EAX

K 、 jmp :无条件跳转指令,对应于大量的条件跳转指令。

L 、 jg :条件跳转,大于时成立,进行跳转,通常条件跳转之前会有一条比较指令(用于设置标志位)。

M 、 jl :小于时跳转。

N 、 jge :大于等于时跳转。

O 、 cmp :比较大小指令,结果用来设置标志位。

P 、 rep:

重复执行后面的指令

rep stos dword ptr [edi]

是将 edi 指向的区域初始化为 0CCCCCCCCh

应该是 12h*4 个字节,可以理解为一个函数,传来的某个参数为指针,然后将这个指针指向的区域初始化

void fun(long *p)

{

int i;

// 12h=18

for(i=0;i<18;i++)

{

p[i]=0CCCCCCCCh;

}

}

相当于这个函数的功能

4  、函数参数传递方式

函数调用规则 指的是调用者和被调用函数间传递参数及返回参数的方法,在 Windows 上,常用的有 Pascal 方式、 WINAPI 方式( _stdcall )、 C 方式( _cdecl )。

A 、 _cdecl C 调用规则:

( a )参数从右到左进入堆栈;

( b )在函数返回后,调用者要负责清除堆栈,这种调用方式通常会生成较大的可执行程序。

B 、 _stdcall 又称为 WINAPI ,调用规则如下:

( a )参数从右到左进入堆栈;

( b )被调用的函数在返回前自行清理堆栈,这种方式生成的代码比 cdecl 小。

C 、 Pascal 调用规则(主要用于 Win16 函数库中,现在基本不用):

( a )参数从左到右进入堆栈;

( b )被调用的函数在返回前自行清理堆栈。

( c )不支持可变参数的函数调用。

5  、  VC  中访问无效变量出错原因

我们看上面主函数反汇编后的其中一段代码如下:

0041137C  lea         edi,[ebp-0C0h]
00411382  mov         ecx,30h
00411387  mov         eax,0CCCCCCCCh
0041138C  rep stos    dword ptr es:[edi]

从代码的表面上看,它是实现把从 ebp-0C0h 开始的 30h 个字的空间写入 0CCCCCCCCh 。其中 eax 为四位的数据,这样可以计算:

                      0C0h = 30h * 4

也就是把从 ebp-0C0h  到 ebp 之间的空间初始化为 0CC CC CC CC h 。大家在学习反汇编的过程中会发现,其实编译器会根据情况把相应长度的这样一段作为局部变量的空间,而这里把局部变量区域全都初始化成 0CCCCCCCCh 也是有其用意的,做 VC 编程的工作者,特别是初学者可能不会对 0CCCCCCCCh 这个常量陌生。 0cch 实际上是 int 3 指令的机器码,这是一个断点中断指令 (在反编译出的信息中大家会看到 int 3 ),因为局部变量不可被执行,或者如果在没有初始化的时候进行了访问,则就会出现访问失败错误。这个在 VC 编译 Debug 版本中才能看到提示这个错误,在 Release 版本中,会以另外一种错误形式体现。下面,我们修改主程序看下 new 与 delete 的反汇编的效果(注释直接加到反汇编的代码中了)。

VC 生成工程,写入源代码如下:

( 1 )情况 1

Cpp代码 复制代码 收藏代码
  1. // ASM_Test.cpp : Defines the entry point for the console application.                    (   源代码 1 ) 
  2. // 
  3. #include "stdafx.h" 
  4. #include "stdlib.h" 
  5.  
  6. int _tmain(int argc, _TCHAR* argv[]) 
  7.     int *pTest = new int(3);                // 定义一个整型指针,并初始化为 3 
  8.     printf( "*pTest = %d\r\n", *pTest );    // 调用库函数 printf 输出数据 
  9.     delete []pTest;                            // 删除这个指针 
  10.  
  11.     return 0; 
// ASM_Test.cpp : Defines the entry point for the console application.                    (   源代码 1 )//#include "stdafx.h"#include "stdlib.h"int _tmain(int argc, _TCHAR* argv[]){    int *pTest = new int(3);                // 定义一个整型指针,并初始化为 3    printf( "*pTest = %d\r\n", *pTest );    // 调用库函数 printf 输出数据    delete []pTest;                            // 删除这个指针    return 0;}

这里仅仅看下在 new 与 delete 进行空间管理时进行反汇编时可能出现的一些情况,我们把上面源代码称为源代码( 1 ),我们按照前面讲解的查看 VS 下反汇编的方法可以看到对应于上面代码的反汇编代码如下:

汇编代码 复制代码 收藏代码
  1. --- f:\mysource\asm_test\asm_test\asm_test.cpp ---------------------------------                      ( 反汇编代码 1 ) 
  2. // ASM_Test.cpp : Defines the entry point for the console application. 
  3. // 
  4. #include "stdafx.h" 
  5. #include "stdlib.h" 
  6.  
  7. int _tmain(int argc, _TCHAR* argv[]) 
  8.  
  9. ; ( 1 )函数预处理部分 
  10. 004113C0  push        ebp  
  11. 004113C1  mov         ebp,esp ; 保存堆栈的栈顶位置 
  12. 004113C3  sub         esp,0E8h ; 要置为 0CCCCCCCCh 保留变量空间长度 
  13. 004113C9  push        ebx       ; 保存寄存器 ebx 、 esi 、 edi 
  14. 004113CA  push        esi  
  15. 004113CB  push        edi  
  16. 004113CC  lea         edi,[ebp-0E8h]    ; 提出要置为 0CCCCCCCCh 的空间起始地址 
  17. 004113D2  mov         ecx,3Ah      ; 要置为 0CCCCCCCCh 的个数,每个占 4 个字节 
  18. 004113D7  mov         eax,0CCCCCCCCh  ; 于是 3Ah * 4 = 0E8h 
  19. 004113DC  rep       stos    dword ptr es:[edi]  ; 进行置为 0CCCCCCCCh 操作 
  20.  
  21. ;( 2 )定义一个 int 型指针,分配空间后,并初始化为 3 , 
  22.     int *pTest = new int(3);                 // 定义一个整型指针,并初始化为 3 
  23. 004113DE  push        4    ; 要分配的空间长度,会根据定义的数据类型而不同 
  24. 004113E0  call        operator new (411186h)   ; 分配空间,并把分配空间的起始地址放入 eax 中 
  25. 004113E5  add         esp,4    ; 由于 new 与 delete 函数本身没有对栈进行弹出操作,所以,要编写者自己处理 
  26. 004113E8  mov         dword ptr [ebp-0E0h],eax  ; 比较分配的空间是否为 0 ,如果为 0 
  27. 004113EE  cmp         dword ptr [ebp-0E0h],0 
  28. 004113F5  je          wmain+51h (411411h) 
  29. 004113F7  mov         eax,dword ptr [ebp-0E0h]      ; 对于分配的地址分配空间进行赋值为: 3 
  30. 004113FD  mov         dword ptr [eax],3 
  31. 00411403  mov         ecx,dword ptr [ebp-0E0h] 
  32. 00411409  mov         dword ptr [ebp-0E8h],ecx   ; 似乎用 [ebp - 0E0h] 和 [ebp - 0E8h] 作为了中间存储单元 
  33. 0041140F  jmp         wmain+5Bh (41141Bh) 
  34. 00411411  mov         dword ptr [ebp-0E8h],0     ; 上面分配空间失败时的操作 
  35.  
  36.  
  37. 0041141B  mov         edx,dword ptr [ebp-0E8h] 
  38. 00411421  mov         dword ptr [pTest],edx           ; 数据最后送入 pTest 变量中 
  39.  
  40. ; 调用 printf 函数进行数据输出 
  41.     printf( "*pTest = %d\r\n", *pTest );     // 调用库函数 printf 输出数据 
  42. 00411424  mov         esi,esp   ; 用于调用 printf 后的 Esp 检测,不明白编译器为什么这样做 
  43. 00411426  mov         eax,dword ptr [pTest]   ; 提取要打印的数据,先是地址,下面一条是提取具体数据 
  44. 00411429  mov         ecx,dword ptr [eax] 
  45. 0041142B  push        ecx         ; 两个参数入栈 
  46. 0041142C  push        offset string "*pTest = %d\r\n" (41573Ch) 
  47. 00411431  call        dword ptr [__imp__printf (4182C4h)]      ; 调用函数 
  48. 00411437  add         esp,8         ; 由于库函数无出栈管理操作,同 new 与 delete ,所以要加 8 ,进行堆栈处理 
  49. 0041143A  cmp         esi,esp        ; 对堆栈的栈顶进行测试 
  50. 0041143C  call        @ILT+325(__RTC_CheckEsp) (41114Ah)  
  51.  
  52. ;进行指针变量的清理工作 
  53.     delete []pTest;                             // 删除这个指针 
  54. 00411441  mov         eax,dword ptr [pTest]   ;[pTest] 中放入的是分配的地址,下面几条指令转悠一圈 
  55. 00411444  mov         dword ptr [ebp-0D4h],eax   ; 就是要把要清理的地址送入堆栈,然后调用 delete 函数 
  56. 0041144A  mov         ecx,dword ptr [ebp-0D4h] 
  57. 00411450  push        ecx  
  58. 00411451  call        operator delete (411091h) 
  59. 00411456  add         esp,4     ; 对堆栈进行处理,同 new 与 printf 函数 
  60.  
  61. ;函数结束后,进行最终的清理工作 
  62.     return 0; 
  63. 00411459  xor         eax,eax   ; 做相应的清理工作,堆栈中保存的变量送回原寄存器 
  64. 0041145B  pop         edi  
  65. 0041145C  pop         esi  
  66. 0041145D  pop         ebx  
  67. 0041145E  add         esp,0E8h       ; 进行堆栈的栈顶判断 
  68. 00411464  cmp         ebp,esp 
  69. 00411466  call        @ILT+325(__RTC_CheckEsp) (41114Ah) 
  70. 0041146B  mov         esp,ebp 
  71. 0041146D  pop         ebp  
  72. 0041146E  ret   
  73.  
  74. --- No source file -------------------------------------------------------------; 后面不再是源代码  
--- f:\mysource\asm_test\asm_test\asm_test.cpp ---------------------------------                      ( 反汇编代码 1 )// ASM_Test.cpp : Defines the entry point for the console application.//#include "stdafx.h"#include "stdlib.h"int _tmain(int argc, _TCHAR* argv[]){; ( 1 )函数预处理部分004113C0  push        ebp 004113C1  mov         ebp,esp ; 保存堆栈的栈顶位置004113C3  sub         esp,0E8h ; 要置为 0CCCCCCCCh 保留变量空间长度004113C9  push        ebx       ; 保存寄存器 ebx 、 esi 、 edi004113CA  push        esi 004113CB  push        edi 004113CC  lea         edi,[ebp-0E8h]    ; 提出要置为 0CCCCCCCCh 的空间起始地址004113D2  mov         ecx,3Ah      ; 要置为 0CCCCCCCCh 的个数,每个占 4 个字节004113D7  mov         eax,0CCCCCCCCh  ; 于是 3Ah * 4 = 0E8h004113DC  rep       stos    dword ptr es:[edi]  ; 进行置为 0CCCCCCCCh 操作;( 2 )定义一个 int 型指针,分配空间后,并初始化为 3 ,    int *pTest = new int(3);                 // 定义一个整型指针,并初始化为 3004113DE  push        4    ; 要分配的空间长度,会根据定义的数据类型而不同004113E0  call        operator new (411186h)   ; 分配空间,并把分配空间的起始地址放入 eax 中004113E5  add         esp,4    ; 由于 new 与 delete 函数本身没有对栈进行弹出操作,所以,要编写者自己处理004113E8  mov         dword ptr [ebp-0E0h],eax  ; 比较分配的空间是否为 0 ,如果为 0004113EE  cmp         dword ptr [ebp-0E0h],0004113F5  je          wmain+51h (411411h)004113F7  mov         eax,dword ptr [ebp-0E0h]      ; 对于分配的地址分配空间进行赋值为: 3004113FD  mov         dword ptr [eax],300411403  mov         ecx,dword ptr [ebp-0E0h]00411409  mov         dword ptr [ebp-0E8h],ecx   ; 似乎用 [ebp - 0E0h] 和 [ebp - 0E8h] 作为了中间存储单元0041140F  jmp         wmain+5Bh (41141Bh)00411411  mov         dword ptr [ebp-0E8h],0     ; 上面分配空间失败时的操作0041141B  mov         edx,dword ptr [ebp-0E8h]00411421  mov         dword ptr [pTest],edx           ; 数据最后送入 pTest 变量中; 调用 printf 函数进行数据输出    printf( "*pTest = %d\r\n", *pTest );     // 调用库函数 printf 输出数据00411424  mov         esi,esp   ; 用于调用 printf 后的 Esp 检测,不明白编译器为什么这样做00411426  mov         eax,dword ptr [pTest]   ; 提取要打印的数据,先是地址,下面一条是提取具体数据00411429  mov         ecx,dword ptr [eax]0041142B  push        ecx         ; 两个参数入栈0041142C  push        offset string "*pTest = %d\r\n" (41573Ch)00411431  call        dword ptr [__imp__printf (4182C4h)]      ; 调用函数00411437  add         esp,8         ; 由于库函数无出栈管理操作,同 new 与 delete ,所以要加 8 ,进行堆栈处理0041143A  cmp         esi,esp        ; 对堆栈的栈顶进行测试0041143C  call        @ILT+325(__RTC_CheckEsp) (41114Ah) ;进行指针变量的清理工作    delete []pTest;                             // 删除这个指针00411441  mov         eax,dword ptr [pTest]   ;[pTest] 中放入的是分配的地址,下面几条指令转悠一圈00411444  mov         dword ptr [ebp-0D4h],eax   ; 就是要把要清理的地址送入堆栈,然后调用 delete 函数0041144A  mov         ecx,dword ptr [ebp-0D4h]00411450  push        ecx 00411451  call        operator delete (411091h)00411456  add         esp,4     ; 对堆栈进行处理,同 new 与 printf 函数;函数结束后,进行最终的清理工作    return 0;00411459  xor         eax,eax   ; 做相应的清理工作,堆栈中保存的变量送回原寄存器}0041145B  pop         edi 0041145C  pop         esi 0041145D  pop         ebx 0041145E  add         esp,0E8h       ; 进行堆栈的栈顶判断00411464  cmp         ebp,esp00411466  call        @ILT+325(__RTC_CheckEsp) (41114Ah)0041146B  mov         esp,ebp0041146D  pop         ebp 0041146E  ret  --- No source file -------------------------------------------------------------; 后面不再是源代码 

在列出反汇编程序时把反汇编代码的上下的分解注释也列了出来,亲手去查看的朋友可能会发现在这段代码的之外的其他部分会有大量的 int 3 汇编中的中断指令,这个是与上面的所说的 0CCCCCCCCh 具有一致性,这些区域是无效区域,但代码访问这些区域时就会出现非法访问提示。当然,你应该可以想到,那个提示是可以被屏蔽掉的,你可以把这部分区域填充上数据或者修改  int 3  调用的中断程序。

从以上反汇编程序,我们可以发现几点:

A 、一些内部的库函数是不会对堆栈进行出栈管理的,所以若要对反汇编程序进行操作时,一点要注意这一点

B 、编译器会自动的加上一些对栈顶的检查工作,这个是我们在做 VC 调试时经常遇到的一个问题,就是堆栈错误

当然 以上只是对 debug 版本下的程序进行反汇编 ,如果为 release  版本,代码就会进行大量的优化,在理解时会有一定的难度 ,有兴趣朋友可以试着反汇编一下,推荐大家有 IDA 返回工具,感觉挺好用的。

**********************************************************************************

**********************************************************************************

5   、补充示例

Cpp代码 复制代码 收藏代码
  1. #include<stdio.h> 
  2.  
  3. int fun(int a, int b) { 
  4.    a = 0x4455; 
  5.    b = 0x6677; 
  6.    return a + b; 
  7.  
  8. int main(void){ 
  9.     fun(0x8899,0x1100); 
  10.     return 0; 
#include<stdio.h>int fun(int a, int b) {   a = 0x4455;   b = 0x6677;   return a + b;}int main(void){	fun(0x8899,0x1100);	return 0;}

反汇编后可以看到汇编代码如下:

   第一部分为main函数框架的汇编代码:

汇编代码 复制代码 收藏代码
  1. int main(void){ 
  2. 002813F0  push        ebp   
  3. 002813F1  mov         ebp,esp  
  4. 002813F3  sub         esp,0C0h  
  5. 002813F9  push        ebx   
  6. 002813FA  push        esi   
  7. 002813FB  push        edi   
  8. 002813FC  lea         edi,[ebp-0C0h]  
  9. 00281402  mov         ecx,30h  
  10. 00281407  mov         eax,0CCCCCCCCh  
  11. 0028140C  rep stos    dword ptr es:[edi]  
  12.  
  13.     fun(0x8899,0x1100); 
  14. 0028140E  push        1100h 
  15. 00281413  push        8899h  
  16. 00281418  call        fun (2811CCh)   ;002811CCh地址处为指令: jmp fun(2813A0h),即fun函数的入口 
  17. 0028141D  add         esp,8  
  18.     return 0; 
  19. 00281420  xor         eax,eax  
  20. 00281422  pop         edi   
  21. 00281423  pop         esi   
  22. 00281424  pop         ebx   
  23. 00281425  add         esp,0C0h  
  24. 0028142B  cmp         ebp,esp  
  25. 0028142D  call        @ILT+310(__RTC_CheckEsp) (28113Bh)  
  26. 00281432  mov         esp,ebp  
  27. 00281434  pop         ebp   
  28. 00281435  ret  
int main(void){002813F0  push        ebp  002813F1  mov         ebp,esp 002813F3  sub         esp,0C0h 002813F9  push        ebx  002813FA  push        esi  002813FB  push        edi  002813FC  lea         edi,[ebp-0C0h] 00281402  mov         ecx,30h 00281407  mov         eax,0CCCCCCCCh 0028140C  rep stos    dword ptr es:[edi] 	fun(0x8899,0x1100);0028140E  push        1100h00281413  push        8899h 00281418  call        fun (2811CCh)   ;002811CCh地址处为指令: jmp fun(2813A0h),即fun函数的入口0028141D  add         esp,8 	return 0;00281420  xor         eax,eax }00281422  pop         edi  00281423  pop         esi  00281424  pop         ebx  00281425  add         esp,0C0h 0028142B  cmp         ebp,esp 0028142D  call        @ILT+310(__RTC_CheckEsp) (28113Bh) 00281432  mov         esp,ebp 00281434  pop         ebp  00281435  ret 

   第二部分为fun函数的汇编代码:

汇编代码 复制代码 收藏代码
  1. int fun(int a, int b) { 
  2. 002813A0  push        ebp   
  3. 002813A1  mov         ebp,esp    ;注意:其实pop和push操作,只用到了esp指针 
  4. 002813A3  sub         esp,0C0h  
  5. 002813A9  push        ebx   
  6. 002813AA  push        esi   
  7. 002813AB  push        edi   
  8. 002813AC  lea         edi,[ebp-0C0h]  
  9. 002813B2  mov         ecx,30h  
  10. 002813B7  mov         eax,0CCCCCCCCh  
  11. 002813BC  rep stos    dword ptr es:[edi]       ;(重复) eax --放入--> es:[edi] 
  12.    a = 0x4455; 
  13. 002813BE  mov         dword ptr [a],4455h     ;将0x00004455放入地址[a]中,即地址0x17493处 
  14.    b = 0x6677; 
  15. 002813C5  mov         dword ptr [b],6677h     ;将0x00006677放入地址[b]中,即地址0x26231处 
  16.    return a + b; 
  17. 002813CC  mov         eax,dword ptr [a]  
  18. 002813CF  add         eax,dword ptr [b]  
  19.  
  20. 002813D2  pop         edi   
  21. 002813D3  pop         esi   
  22. 002813D4  pop         ebx   
  23. 002813D5  mov         esp,ebp            
  24. 002813D7  pop         ebp   
  25. 002813D8  ret  
int fun(int a, int b) {002813A0  push        ebp  002813A1  mov         ebp,esp    ;注意:其实pop和push操作,只用到了esp指针002813A3  sub         esp,0C0h 002813A9  push        ebx  002813AA  push        esi  002813AB  push        edi  002813AC  lea         edi,[ebp-0C0h] 002813B2  mov         ecx,30h 002813B7  mov         eax,0CCCCCCCCh 002813BC  rep stos    dword ptr es:[edi]       ;(重复) eax --放入--> es:[edi]   a = 0x4455;002813BE  mov         dword ptr [a],4455h     ;将0x00004455放入地址[a]中,即地址0x17493处   b = 0x6677;002813C5  mov         dword ptr [b],6677h     ;将0x00006677放入地址[b]中,即地址0x26231处   return a + b;002813CC  mov         eax,dword ptr [a] 002813CF  add         eax,dword ptr [b] } 002813D2  pop         edi  002813D3  pop         esi  002813D4  pop         ebx  002813D5  mov         esp,ebp           002813D7  pop         ebp  002813D8  ret 

FAQ:

1、在main()函数编译后的汇编代码中,call fun前将参数压入堆栈;可以再fun()函数编译后的汇编代码中怎么没见pop出这些参数呢?在fun()编译后的指令中通过什么来获得输入参数呢?

     回答:

     A. 将esp内容传给ebp,通过ebp来获取输入参数

     call fun指令背着我做了一件事情——将call fun的下一条语句地址压栈。fun()函数编译后的最后一条指令是ret,ret指令pop了push给他的地址,然后返回到这个地址==>“调 用函数前的call”和“调用函数后的ret”一个push、一个pop,肯定不会让堆栈不平衡,老外叫做no stack unwinding。因此,如果在fun()函数汇编后的代码中上来就pop eax取出参数,就等于根ret抢返回地址了,这样fun()使用完就回不到主函数的断点了╮(╯▽╰)╭

     那么怎么在被调用函数中获取参数呢?Easy! 既然参数已经在堆栈中,我们只要指定“esp+某个偏移”就可以访问了。

     然而,只要被调用函数中出现push或者pop指令,就会用到esp指针,esp就会变化,不方便定位传入的参数位置。其实,在调用过程中被调用函数的传入参数位置是固定的。于是,我们用ebp来获取他!

     地球人都知道,ebp指向栈底,故在fun()进入后要先将ebp内容压栈,fun()返回前将栈中“原来 ebp的值”pop到ebp中:)于是,才有了下面两句指令:

汇编代码 复制代码 收藏代码
  1. 002813A0  push        ebp   
  2. 002813A1  mov         ebp,esp 
002813A0  push        ebp  002813A1  mov         ebp,esp

   B. ebp如何获取输入参数

   mov ebp, esp; 后堆栈应该变成这个样子:


/-------------------\  Higher Address
  | 参数2:  0x1100h | 
  +-----------------+
  | 参数1:  0x8899h |
  +-----------------+
  |   函数返回地址  |
  |    0x00401087   |
  +-----------------+
  |       ebp       |
\-------------------/   Lower Address <== stack pointer
& ebp all point to here, now

   ∵一个int是32位,可以分析出,第一个参数的地址是ebp + 08h,第二个参数就是ebp + 0ch。主要到,此时ebp中的值就是esp的值!

2、一个简单的问题休息一下:

汇编代码 复制代码 收藏代码
  1. 0028140E  push        1100h 
  2. 00281413  push        8899h  
  3. 00281418  call        fun (2811CCh)   ;002811CCh地址处为指令: jmp fun(2813A0h),即fun函数的入口 
  4. 0028141D  add         esp,8 
0028140E  push        1100h00281413  push        8899h 00281418  call        fun (2811CCh)   ;002811CCh地址处为指令: jmp fun(2813A0h),即fun函数的入口0028141D  add         esp,8

这个代码中最后一行add esp, 8指令作用是什么?

    回答:平衡堆栈,相当于弹出(just throw out)传入被调用函数的参数。

关键点:

     注意:其实pop和push操作,只用到了esp指针! ebp指定了栈底,但并没有什么实际作用——在16位汇编和32位汇编中均如此!

3、calling convention 调用传统

这个历史遗留问题。如果认真思考过,你一定想函数的参数为什么偏用堆栈转递呢,寄存器不也可以传递吗?而且很快阿。参数的传递顺序不
一定要是由后到前的,从前到后传递也不会出现任何问题啊?再有为什么一定要等到函数返回了再处理堆栈平衡的问题呢,能否在函数返回前就让堆栈平衡呢?
所有上述提议都是绝对可行的,而他们之间不同的组合就造就了函数不同的调用方法。也就是你常看到或听到的stdcall,pascal,

fastcall,WINAPI,cdecl等等。这些不同的处理函数调用方式就叫做calling convention。
默认情况下C语言使用的是cdecl方式,也就是上面提到的。参数由右到左进栈,调用函数者处理堆栈平衡。如果你在我们刚才的程序中fun函数前加入

__stdcall,再来用上面的方法分析一下。
8:        fun(0x8899,0x1100);
00401058   push        1100h  ; <== 参数仍然是由右到左传递的
0040105D   push        8899h  
00401062   call        fun (00401000)
;<== 这里没有了 add esp, 08h

1:    int __stdcall fun(int a, int b) {
00401000   push        ebp
00401001   mov         ebp,esp
00401003   sub         esp,40h
00401006   push        ebx
00401007   push        esi
00401008   push        edi
00401009   lea         edi,[ebp-40h]
0040100C   mov         ecx,10h
00401011   mov         eax,0CCCCCCCCh
00401016   rep stos    dword ptr [edi]
2:       a = 0x4455;
00401018   mov         dword ptr [ebp+8],4455h
3:       b = 0x6677;
0040101F   mov         dword ptr [ebp+0Ch],6677h
4:       return a + b;
00401026   mov         eax,dword ptr [ebp+8]
00401029   add         eax,dword ptr [ebp+0Ch]
5:    }
0040102C   pop         edi
0040102D   pop         esi
0040102E   pop         ebx
0040102F   mov         esp,ebp
00401031   pop         ebp
00401032   ret         8; <== ret 取出返回地址后,
                        ; 给esp加上 8。看!堆栈平衡在函数内完成了。
                        ; ret指令这个语法设计就是专门用来实现函数
                        ; 内完成堆栈平衡的
于是得出结论,stdcall是由右到左传递参数,被调用函数恢复堆栈的calling convention. 其他几种calling convention的修饰关键词分别是__pascal,__fastcall,WINAPI(这个要包含windows.h才可以用)。现在,你可以用上面说的方法自己分析一下他们各自的特点了。

 

相关文章推荐

查看 并发请求数及其TCP连接状态

服务器上的一些统计数据: 1)统计80端口连接数 netstat -nat|grep -i "80"|wc -l 2)统计httpd协议连接数 ps -ef|grep httpd|wc...

[CSAPP笔记][第十章 系统级I/O]

第十章 系统级I/O输入/输出(I/O) : 是指主存和外部设备(如磁盘,终端,网络)之间拷贝数据过程。 高级别I/O函数scanf和printf 使用系统级I/O函数实现 系统级I/O函数。Q:大...

C++内嵌汇编(一):反汇编分析C++代码

Sam: 使用binutils-2.23.1这个软件中的小工具objdump -d *.o 可以对一个目标文件进行反汇编:) 了解反汇编的一些小知识对于我们在开发软件时进行编程与调试大有好处,下面以 ...

C/C++代码分析时的一些反汇编方法

在分析/研究一些C/C++代码问题的时候,我们经常都希望了解得越深入越好,甚至希望深入到汇编级别。有时候问题很简单,例如下面比较两种整数变量自减写法的效率,这样简单的问题一定要通过写一个完整的测试程序...
  • xplizm
  • xplizm
  • 2012年04月20日 22:43
  • 1044

反汇编C++ OOP代码 分析构造函数如何被调用 以及简单的C++对象内存模型

在今天进行C++代码的思考时,产生一个疑问,就是C++类的构造函数是如何被调用的于是就做了一个简单的实验来验证自己的想法。//main.cpp #include <stdio.h>clas...

c++反汇编与逆向分析技术揭秘代码

  • 2017年08月10日 21:26
  • 3.66MB
  • 下载

在VC2008下将32位C++内嵌汇编迁移到64位

http://blog.sina.com.cn/s/blog_6296cebc0100fa5g.html 在VC2008下将32位C++内嵌汇编迁移到64位 ——东方射日—— ...

将32位C++内嵌汇编迁移到64位

现在正在做的一个项目,是关于高密度计算的,由于计算量很大,从性能考虑,除了算法的优化外,其中的的核心代码是用汇编写的,也许有人说,现在还有用汇编的吗?编译器的优化已经很好了,性能已经非常接近于汇编了,...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C++内嵌汇编(一):反汇编分析C++代码
举报原因:
原因补充:

(最多只允许输入30个字)