C++反汇编代码分析–函数调用

转载：http://shitouer.cn/2010/06/method-called/

代码如下：
#include “stdlib.h”

int sum(int a,int b,int m,int n)
{

return a+b;

}

void main()
{

int result = sum(1,2,3,4);

system(“pause”);

}

有四个参数的sum函数，接着在main方法中调用sum函数。在debug环境下，单步调试如下：

11:   void main()
12:   {
00401060   push        ebp

;保存ebp，执行这句之前，ESP = 0012FF4C EBP = 0012FF88

;执行后，ESP = 0012FF48 EBP = 0012FF88，ESP减小，EBP不变
00401061   mov         ebp,esp

；将esp放入ebp中，此时ebp和esp相同，即执行后ESP = 0012FF48 EBP = 0012FF48

；原EBP值已经被压栈（位于栈顶），而新的EBP又恰恰指向栈顶。
；此时EBP寄存器就已经处于一个非常重要的地位，该寄存器中存储着栈中的一个地址（原EBP入栈后的栈顶），
；从该地址为基准，向上（栈底方向）能获取返回地址、参数值（假如main中有参数，“获取参数值”会比较容易理解，

；不过在看下边的sum函数调用时会有体会的），向下（栈顶方向）能获取函数局部变量值，
；而该地址处又存储着上一层函数调用时的EBP值！
00401063   sub         esp,44h

；把esp往上移动一个范围
；等于在栈中空出一片空间来存局部变量
；执行这句后ESP = 0012FF04 EBP = 0012FF48

00401066   push        ebx
00401067   push        esi
00401068   push        edi

；保存三个寄存器的值
00401069   lea         edi,[ebp-44h]

；把ebp-44h加载到edi中，目的是保存局部变量的区域
0040106C   mov         ecx,11h
00401071   mov         eax,0CCCCCCCCh
00401076   rep stos    dword ptr [edi]

；从ebp-44h开始的区域初始化成全部0CCCCCCCCh，就是int3断点，初始化局部变量空间

；REP           ;CX不等于0 ，则重复执行字符串指令

；格式: STOS OPRD

；功能: 把AL(字节)或AX(字)中的数据存储到DI为目的串地址指针所寻址的存储器单元中去.指针DI将根据DF的值进行自动

；调整. 其中OPRD为目的串符号地址.

；以上的语句就是在栈中开辟一块空间放局部变量
；然后把这块空间都初始化为0CCCCCCCCh，就是int3断点，一个中断指令。
；因为局部变量不可能被执行，执行了就会出错，这时候发生中断提示开发者。
13:       int result = sum(1,2,3,4);
00401078   push        4
0040107A   push        3
0040107C   push        2
0040107E   push        1

；各个参数入栈，注意查看寄存器ESP值的变化

；亦可以看到参数入栈的顺序，从右到左

；变化为：ESP = 0012FEF8–>ESP = 0012FEF4–>ESP = 0012FEF0–>ESP = 0012FEEC–>ESP = 0012FEE8
00401080   call        @ILT+15(boxer) (00401014)

；调用sum函数，可以按F11跟进

；注：f10（step over），单步调试，遇到函数调用，直接执行，不会进入函数内部

；f11（step into），单步调试，遇到函数调用，会进入函数内部

；shift+f11（step out），进入函数内部后，想从函数内部跳出，用此快捷方式

；ctrl+f10（run to cursor），呵呵，看英语注释就应该知道是什么意思了，不再解释
00401085   add         esp,10h

；调用完函数后恢复/释放栈，执行后ESP = 0012FEF8，与sum函数的参数入栈前的数值一致

00401088   mov         dword ptr [ebp-4],eax

；将结果存放在result中，原因详看最后有关ss的注释
14:       system(“pause”);
0040108B   push        offset string “pause” (00422f6c)
00401090   call        system (0040eed0)
00401095   add   esp ,4

；有关system（“pause”）的处理，此处不讨论

15:   }
00401098   pop         edi
00401099   pop         esi
0040109A   pop         ebx

；恢复原来寄存器的值，怎么“吃”进去，怎么“吐”出来
0040109B   add         esp,44h

；恢复ESP，对应上边的sub esp,44h
0040109E   cmp         ebp,esp

；检查esp是否正常，不正常就进入下边的call里面debug
004010A0   call        __chkesp (004010b0)

；处理可能出现的堆栈异常，如果有的话，就会陷入debug
004010A5   mov         esp,ebp
004010A7   pop         ebp

；恢复原来的esp和ebp，让上一个调用函数正常使用
004010A8   ret

；将返回地址存入eip，转移流程

；如果函数有返回值，返回值将放在eax返回（这就是很多软件给秒杀爆破的原因了，因为eax的返回值是可以改的）

—————————————————————————————————————————–

；以上即是主函数调用的反汇编过程，下边来看调用sum函数的过程：

；上边有说在00401080   call        @ILT+15(boxer) (00401014)这一句处，用f11单步调试，f11后如下句：

00401014   jmp         sum (00401020)

；即跳转到sum函数的代码段中，再f11如下：

6:    int sum(int a,int b,int m,int n)
7:    {
00401020   push        ebp
00401021   mov         ebp,esp
00401023   sub         esp,40h
00401026   push        ebx
00401027   push        esi
00401028   push        edi
00401029   lea         edi,[ebp-40h]
0040102C   mov         ecx,10h
00401031   mov         eax,0CCCCCCCCh
00401036   rep stos    dword ptr [edi]

；可见，上边几乎与主函数调用相同，每一步不再赘述，可对照上边主函数调用的注释
8:        return a+b;
00401038   mov         eax,dword ptr [ebp+8]

；取第一个参数放在eax
0040103B   add         eax,dword ptr [ebp+0Ch]

；取第二个参数，与eax中的数值相加并存在eax中
9:    }
0040103E   pop         edi
0040103F   pop         esi
00401040   pop         ebx
00401041   mov         esp,ebp
00401043   pop         ebp
00401044   ret
；收尾操作，比前边只是少了检查esp操作罢了

有关ss部分的注释：

；一般而言，ss:[ebp+4]处为返回地址
；ss:[ebp+8]处为第一个参数值（这里是a），ss:[ebp+0Ch]处为第二个参数（这里是b，这里8+4=12=0Ch）
；ss:[ebp-4]处为第一个局部变量（如main中的result），ss:[ebp]处为上一层EBP值
；ebp和函数返回值是32位，所以占4个字节

LINUX平台可以用GDB进行反汇编和调试

2. 最简C代码分析

为简化问题，来分析一下最简的c代码生成的汇编代码：

# vi test1.c

int main()

{

return 0;

}

编译该程序，产生二进制文件：

# gcc test1.c -o test1

# file test1

test1: ELF 32-bit LSB executable 80386 Version 1, dynamically linked, not stripped

test1是一个ELF格式32位小端(Little Endian)的可执行文件，动态链接并且符号表没有去除。

这正是Unix/Linux平台典型的可执行文件格式。

用mdb反汇编可以观察生成的汇编代码：

# mdb test1

Loading modules: [ libc.so.1 ]

> main::dis                       ; 反汇编main函数，mdb的命令一般格式为  <地址>::dis

main:          pushl   %ebp       ; ebp寄存器内容压栈，即保存main函数的上级调用函数的栈基地址

main+1:        movl    %esp,%ebp  ; esp值赋给ebp，设置main函数的栈基址

main+3:          subl    $8,%esp

main+6:          andl    $0xf0,%esp

main+9:          movl    $0,%eax

main+0xe:        subl    %eax,%esp

main+0x10:     movl    $0,%eax    ; 设置函数返回值0

main+0x15:     leave              ; 将ebp值赋给esp，pop先前栈内的上级函数栈的基地址给ebp，恢复原栈基址

main+0x16:     ret                ; main函数返回，回到上级调用

>

注：这里得到的汇编语言语法格式与Intel的手册有很大不同，Unix/Linux采用AT&T汇编格式作为汇编语言的语法格式

如果想了解AT&T汇编可以参考文章：Linux AT&T 汇编语言开发指南

问题：谁调用了 main函数？

在C语言的层面来看，main函数是一个程序的起始入口点，而实际上，ELF可执行文件的入口点并不是main而是_start。

mdb也可以反汇编_start：

> _start::dis                       ;从_start 的地址开始反汇编

_start:              pushl   $0

_start+2:            pushl   $0

_start+4:            movl    %esp,%ebp

_start+6:            pushl   %edx

_start+7:            movl    $0x80504b0,%eax

_start+0xc:          testl   %eax,%eax

_start+0xe:          je      +0xf            <_start+0x1d>

_start+0x10:         pushl   $0x80504b0

_start+0x15:         call    -0x75           <atexit>

_start+0x1a:         addl    $4,%esp

_start+0x1d:         movl    $0x8060710,%eax

_start+0x22:         testl   %eax,%eax

_start+0x24:         je      +7              <_start+0x2b>

_start+0x26:         call    -0x86           <atexit>

_start+0x2b:         pushl   $0x80506cd

_start+0x30:         call    -0x90           <atexit>

_start+0x35:         movl    +8(%ebp),%eax

_start+0x38:         leal    +0x10(%ebp,%eax,4),%edx

_start+0x3c:         movl    %edx,0x8060804

_start+0x42:         andl    $0xf0,%esp

_start+0x45:         subl    $4,%esp

_start+0x48:         pushl   %edx

_start+0x49:         leal    +0xc(%ebp),%edx

_start+0x4c:         pushl   %edx

_start+0x4d:         pushl   %eax

_start+0x4e:         call    +0x152          <_init>

_start+0x53:         call    -0xa3           <__fpstart>

_start+0x58:        call    +0xfb        <main>              ;在这里调用了main函数

_start+0x5d:         addl    $0xc,%esp

_start+0x60:         pushl   %eax

_start+0x61:         call    -0xa1           <exit>

_start+0x66:         pushl   $0

_start+0x68:         movl    $1,%eax

_start+0x6d:         lcall   $7,$0

_start+0x74:         hlt

>

问题：为什么用EAX寄存器保存函数返回值？

实际上IA32并没有规定用哪个寄存器来保存返回值。但如果反汇编Solaris/Linux的二进制文件，就会发现，都用EAX保存函数返回值。

这不是偶然现象，是操作系统的ABI(Application Binary Interface)来决定的。

Solaris/Linux操作系统的ABI就是Sytem V ABI。

概念：SFP (Stack Frame Pointer) 栈框架指针

正确理解SFP必须了解：

IA32 的栈的概念

CPU 中32位寄存器ESP/EBP的作用

PUSH/POP 指令是如何影响栈的

CALL/RET/LEAVE 等指令是如何影响栈的

如我们所知：

1)IA32的栈是用来存放临时数据，而且是LIFO，即后进先出的。栈的增长方向是从高地址向低地址增长，按字节为单位编址。

2) EBP是栈基址的指针，永远指向栈底（高地址），ESP是栈指针，永远指向栈顶（低地址）。

3) PUSH一个long型数据时，以字节为单位将数据压入栈，从高到低按字节依次将数据存入ESP-1、ESP-2、ESP-3、ESP-4的地址单元。

4) POP一个long型数据，过程与PUSH相反，依次将ESP-4、ESP-3、ESP-2、ESP-1从栈内弹出，放入一个32位寄存器。

5) CALL指令用来调用一个函数或过程，此时，下一条指令地址会被压入堆栈，以备返回时能恢复执行下条指令。

6) RET指令用来从一个函数或过程返回，之前CALL保存的下条指令地址会从栈内弹出到EIP寄存器中，程序转到CALL之前下条指令处执行

7) ENTER是建立当前函数的栈框架，即相当于以下两条指令：

pushl   %ebp

movl    %esp,%ebp

8) LEAVE是释放当前函数或者过程的栈框架，即相当于以下两条指令：

movl ebp esp

popl  ebp

如果反汇编一个函数，很多时候会在函数进入和返回处，发现有类似如下形式的汇编语句：

pushl   %ebp            ; ebp寄存器内容压栈，即保存main函数的上级调用函数的栈基地址

movl    %esp,%ebp       ; esp值赋给ebp，设置 main函数的栈基址

...........             ; 以上两条指令相当于 enter 0,0

...........

leave                   ; 将ebp值赋给esp，pop先前栈内的上级函数栈的基地址给ebp，恢复原栈基址

ret                     ; main函数返回，回到上级调用

这些语句就是用来创建和释放一个函数或者过程的栈框架的。

原来编译器会自动在函数入口和出口处插入创建和释放栈框架的语句。

函数被调用时：

1) EIP/EBP成为新函数栈的边界

函数被调用时，返回时的EIP首先被压入堆栈；创建栈框架时，上级函数栈的EBP被压入堆栈，与EIP一道行成新函数栈框架的边界

2) EBP成为栈框架指针SFP，用来指示新函数栈的边界

栈框架建立后，EBP指向的栈的内容就是上一级函数栈的EBP，可以想象，通过EBP就可以把层层调用函数的栈都回朔遍历一遍，调试器就是利用这个特性实现 backtrace功能的

3) ESP总是作为栈指针指向栈顶，用来分配栈空间

栈分配空间给函数局部变量时的语句通常就是给ESP减去一个常数值，例如，分配一个整型数据就是 ESP-4

4) 函数的参数传递和局部变量访问可以通过SFP即EBP来实现

由于栈框架指针永远指向当前函数的栈基地址，参数和局部变量访问通常为如下形式：

+8+xx(%ebp)         ; 函数入口参数的的访问

-xx(%ebp)           ; 函数局部变量访问

假如函数A调用函数B，函数B调用函数C ，则函数栈框架及调用关系如下图所示：

+-------------------------+----> 高

frame of C         图 1-1

再分析test1反汇编结果中剩余部分语句的含义：

# mdb test1

Loading modules: [ libc.so.1 ]

> main::dis                        ; 反汇编main函数

main:          pushl   %ebp

main+1:        movl    %esp,%ebp        ; 创建Stack Frame(栈框架)

main+3:       subl    $8,%esp       ; 通过ESP-8来分配8字节堆栈空间

main+6:       andl    $0xf0,%esp    ; 使栈地址16字节对齐

main+9:       movl    $0,%eax       ; 无意义

main+0xe:     subl    %eax,%esp     ; 无意义

main+0x10:     movl    $0,%eax          ; 设置main函数返回值

main+0x15:     leave                    ; 撤销Stack Frame(栈框架)

main+0x16:     ret                      ; main 函数返回

>

以下两句似乎是没有意义的，果真是这样吗？

movl    $0,%eax

subl     %eax,%esp

用gcc的O2级优化来重新编译test1.c:

# gcc -O2 test1.c -o test1

# mdb test1

> main::dis

main:         pushl   %ebp

main+1:       movl    %esp,%ebp

main+3:       subl    $8,%esp

main+6:       andl    $0xf0,%esp

main+9:       xorl    %eax,%eax      ; 设置main返回值，使用xorl异或指令来使eax为0

main+0xb:     leave

main+0xc:     ret

>

新的反汇编结果比最初的结果要简洁一些，果然之前被认为无用的语句被优化掉了，进一步验证了之前的猜测。

提示：编译器产生的某些语句可能在程序实际语义上没有用处，可以用优化选项去掉这些语句。

问题：为什么用xorl来设置eax的值？

注意到优化后的代码中，eax返回值的设置由 movl $0,%eax 变为 xorl %eax,%eax ，这是因为IA32指令中，xorl比movl有更高的运行速度。

概念：Stack aligned 栈对齐

那么，以下语句到底是和作用呢？

subl    $8,%esp

andl    $0xf0,%esp     ; 通过andl使低4位为0，保证栈地址16字节对齐

表面来看，这条语句最直接的后果是使ESP的地址后4位为0，即16字节对齐，那么为什么这么做呢？

原来，IA32 系列CPU的一些指令分别在4、8、16字节对齐时会有更快的运行速度，因此gcc编译器为提高生成代码在IA32上的运行速度，默认对产生的代码进行16字节对齐

andl $0xf0,%esp 的意义很明显，那么 subl $8,%esp 呢，是必须的吗？

这里假设在进入main函数之前，栈是16字节对齐的话，那么，进入main函数后，EIP和EBP被压入堆栈后，栈地址最末4位二进制位必定是1000，esp -8则恰好使后4位地址二进制位为0000。看来，这也是为保证栈16字节对齐的。

如果查一下gcc的手册，就会发现关于栈对齐的参数设置：

-mpreferred-stack-boundary=n    ; 希望栈按照2的n次的字节边界对齐, n的取值范围是2-12

默认情况下，n是等于4的，也就是说，默认情况下，gcc是16字节对齐，以适应IA32大多数指令的要求。

让我们利用-mpreferred-stack-boundary=2来去除栈对齐指令：

# gcc -mpreferred-stack-boundary=2 test1.c -o test1

> main::dis

main:       pushl   %ebp

main+1:     movl    %esp,%ebp

main+3:     movl    $0,%eax

main+8:     leave

main+9:     ret

>

可以看到，栈对齐指令没有了，因为，IA32的栈本身就是4字节对齐的，不需要用额外指令进行对齐。

那么，栈框架指针SFP是不是必须的呢？

# gcc -mpreferred-stack-boundary=2 -fomit-frame-pointer test1.c -o test

> main::dis

main:       movl    $0,%eax

main+5:     ret

>

由此可知，-fomit-frame-pointer 可以去除SFP。

问题：去除SFP后有什么缺点呢？

1)增加调式难度

由于SFP在调试器backtrace的指令中被使用到，因此没有SFP该调试指令就无法使用。

2)降低汇编代码可读性

函数参数和局部变量的访问，在没有ebp的情况下，都只能通过+xx(esp)的方式访问，而很难区分两种方式，降低了程序的可读性。

问题：去除SFP有什么优点呢？

1)节省栈空间

2)减少建立和撤销栈框架的指令后，简化了代码

3)使ebp空闲出来，使之作为通用寄存器使用，增加通用寄存器的数量

4)以上3点使得程序运行速度更快

概念：Calling Convention  调用约定和 ABI (Application Binary Interface) 应用程序二进制接口

函数如何找到它的参数？

函数如何返回结果？

函数在哪里存放局部变量？

那一个硬件寄存器是起始空间？

那一个硬件寄存器必须预先保留？

Calling Convention  调用约定对以上问题作出了规定。Calling Convention也是ABI的一部分。

因此，遵守相同ABI规范的操作系统，使其相互间实现二进制代码的互操作成为了可能。

例如：由于Solaris、Linux都遵守System V的ABI，Solaris 10就提供了直接运行Linux二进制程序的功能。

详见文章：关注： Solaris 10的10大新变化

3. 小结

本文通过最简的C程序，引入以下概念：

SFP 栈框架指针

Stack aligned 栈对齐

Calling Convention  调用约定 和 ABI (Application Binary Interface) 应用程序二进制接口

今后，将通过进一步的实验，来深入了解这些概念。通过掌握这些概念，使在汇编级调试程序产生的core dump、掌握C语言高级调试技巧成为了可能。

反汇编深入分析函数调用

函数：

intfun(inta,intb) {

charvar[128] = "A";

a = 0x4455;

b = 0x6677;

returna + b;

}

intmain() {

fun(0x8899,0x1100);

return0;

}

F11跟踪到fun,alt+8看反汇编代码：

//参数压栈，遵循__cdecl调用规范，参数由右向左

00401078  push       1100h//第一个参数压栈

0040107D  push       8899h//第二个参数压栈

00401082  call       @ILT+0(_fun) (00401005)//调用函数

00401087  add        esp,8//被调用函数的堆栈由主调函数来清空堆栈，使堆栈平衡。

由上图的EIP可以看到0040B500就是下条要执行的指令，在Memory窗口中可以看到内存数据99880000和11000000,实质上是0x8899,0x1100,(intel处理器一般都是小端存储)，还可以看到有内存数据87104000，实质上是00401087,在主调函数中，可以很清楚的看到00401087被调函数返回以后执行的第一条指令，也就是堆栈清空指令(遵循__cdecl调用规范)。Call指令隐含做了一个操作：就是把函数返回后执行的第一条指令压入堆栈（push）。

1:   int fun(int a, int b) {

0040B500  push       ebp

0040B501  mov        ebp,esp //调用函数通常的做法，通过ebp基址寄存器来操作堆//栈数据

0040B503  sub        esp,0C0h//为什么是C0h（不是因为堆栈保护，T网KX提;2NvU_d'O

防止缓冲区overflow，而是DEBUG选项造成的）

0040B509  push       ebx

0040B50A  push       esi

0040B50B  push       edi

0040B50C  lea        edi,[ebp-0C0h]

0040B512  mov        ecx,30h //C0h除以4，就是30h，因为rep stos用的是dword

0040B517  mov        eax,0CCCCCCCCh

0040B51C  rep stos   dword ptr [edi] //用0CCCCCCCCh初始化堆栈

2:      char var[128] = "A";

0040B51E  mov        ax,[string "A" (0041f10c)] //此时EBP = 0012FF24

0040B524  mov        word ptr [ebp-80h],ax //80h也就是128，写了一个字

0040B528  mov        ecx,1Fh              //1Fh是31

0040B52D  xor        eax,eax              //清零

0040B52F  lea        edi,[ebp-7Eh]

0040B532  rep stos   dword ptr [edi]      //一共是32个双字，开始写了一个字，rep stos

0040B534  stos       word ptr [edi]       //写入了31个双字，还剩下一个字由stos完成

//var的地址是：0x0012fea4

3:      a = 0x4455;

0040B536  mov        dword ptr [ebp+8],4455h

4:      b = 0x6677;

0040B53D  mov        dword ptr [ebp+0Ch],6677h

5:      return a + b;

0040B544  mov        eax,dword ptr [ebp+8]

0040B547  add        eax,dword ptr [ebp+0Ch] //返回值通过eax保存

6:   }

0040B54A  pop        edi

0040B54B  pop        esi

0040B54C  pop        ebx //弹栈(windows的API都会有这三个寄存器的保存，回复工作)

0040B54D  mov        esp,ebp

0040B54F  pop        ebp //恢复ebp寄存器

0040B550  ret             //默认操作，D网管2j中TKg4h_O理C=育管`网O理k发达 地专%X无2|p.x1QcZ的_U恢复EIP：将堆栈中的00401087pop给EIP

执行完：0040B50B  push       edi如下图：

ESP

：0012FE58与刚进入函数的时候的ESP：0012FF28之间的堆栈图如下：

执行完：0040B51C  rep stos   dword ptr [edi]后EDI为：0012FF24，如下图：

理解调用栈最重要的两点是：栈的结构，EBP寄存器的作用。

首先要认识到这样两个事实：

1、一个函数调用动作可分解为：零到多个PUSH指令（用于参数入栈），一个CALL指令。CALL指令内部其实还暗含了一个将返回地址（即CALL指令下一条指令的地址）压栈的动作。

2、几乎所有本地编译器都会在每个函数体之前插入类似如下指令：PUSH EBP; MOV EBP ESP;

即，在程序执行到一个函数的真正函数体时，已经有以下数据顺序入栈：参数，返回地址，EBP。
由此得到类似如下的栈结构（参数入栈顺序跟调用方式有关，这里以C语言默认的CDECL为例）：

+| (栈底方向，高位地址) |
 | .................... |
 | .................... |
 | 参数3                |
 | 参数2                |
 | 参数1                |
 | 返回地址             |
-| 上一层[EBP]          | <-------- [EBP]

“PUSH EBP”“MOV EBP ESP”这两条指令实在大有深意：首先将EBP入栈，然后将栈顶指针ESP赋值给EBP。“MOV EBP ESP”这条指令表面上看是用ESP把EBP原来的值覆盖了，其实不然——因为给EBP赋值之前，原EBP值已经被压栈（位于栈顶），而新的EBP又恰恰指向栈顶。

此时EBP寄存器就已经处于一个非常重要的地位，该寄存器中存储着栈中的一个地址（原EBP入栈后的栈顶），从该地址为基准，向上（栈底方向）能获取返回地址、参数值，向下（栈顶方向）能获取函数局部变量值，而该地址处又存储着上一层函数调用时的EBP值！

一般而言，ss:[ebp+4]处为返回地址，ss:[ebp+8]处为第一个参数值（最后一个入栈的参数值，此处假设其占用4字节内存），ss:[ebp-4]处为第一个局部变量，ss:[ebp]处为上一层EBP值。

由于EBP中的地址处总是“上一层函数调用时的EBP值”，而在每一层函数调用中，都能通过当时的EBP值“向上（栈底方向）能获取返回地址、参数值，向下（栈顶方向）能获取函数局部变量值”。
如此形成递归，直至到达栈底。这就是函数调用栈。

编译器对EBP的使用实在太精妙了。

从当前EBP出发，逐层向上找到所有的EBP是非常容易的：

unsigned int _ebp;
__asm _ebp, ebp;
while (not stack bottom)
{
    //...
    _ebp = *(unsigned int*)_ebp;
}

转载：http://blog.csdn.net/dolphin98629/article/details/6047665