【黑客免杀攻防】读书笔记7 - 软件逆向工程基础1(函数调用约定、Main函数查找)

0x1 准备工作

1.1、准备工具

IDA：交互式反汇编工具
OllyDbg：用户层调试工具
Visual Studio：微软开发工具

1.2、基础知识

C++开发
汇编语言

0x2 查找真正的main()函数

入口点开始到Main()函数之间的代码都是编译器加进去用于初始化环境用的。

main()函数其实是有3个参数的，这取决于Windows系统的机制。

查找方法：

1、字符串搜索法

2、栈回溯法

3、逐步分析法

4、小例子

C源代码：

程序执行的时候会将路径保存在argv字符数组中，因此argc的值始终是等于1的。程序未经处理会显示”Helllo world“。

#include "stdafx.h"

int _tmain(int argc, _TCHAR* argv[])

{

	if (argc)

	{

		printf("Hello world!\r\n");

	}

	else

	{

		printf("Hello everybody!\r\n");

	}

	return 0;

}

反汇编后的代码：

ESP是栈指针，也就是当前栈的所在位置。+4就是在当前堆栈+4的地方取内容。

CMP指令是对两个操作数做减法操作，仅影响标志位。

00041000 >/$  55            push ebp

00041001  |.  8BEC          mov ebp,esp

00041003  |.  837D 08 00    cmp [arg.1],0x0

00041007  |.  74 11         je X9-3.0004101A

00041009  |.  68 48640500   push 9-3.00056448           ; /Hello world!\r\n

0004100E  |.  E8 2D000000   call 9-3.printf             ; \printf

00041013  |.  83C4 04       add esp,0x4                 ;  esp+4的意思就是在当前堆栈+4的地方取其内容

00041016  |.  33C0          xor eax,eax

00041018  |.  5D            pop ebp

00041019  |.  C3            retn

0004101A  |>  68 58640500   push 9-3.00056458           ; /Hello everybody!\r\n

0004101F  |.  E8 1C000000   call 9-3.printf             ; \printf

00041024  |.  83C4 04       add esp,0x4

00041027  |.  33C0          xor eax,eax

00041029  |.  5D            pop ebp

0004102A  \.  C3            retn

0x3 函数识别初探

1、函数调用约定的参数入栈书序、回收堆栈的规则

C规范 _cdecl 参数入栈顺序从右到左调用者负责回收堆栈
pascal规范 pascal 参数入站从左到右被调用者负责回收堆栈
快速调用规范 __fastcall 从右到左被调用者负责回收堆栈
标准调用规范 __stdcall 从右到左被调用者负责回收堆栈

2、调用方式示例

调用约定	关键字	参数入栈顺序	回收堆栈
C规范	_cdecl	从右到左	调用者负责
Pascal规范	pascal	从左到右	被调用者负责
快速调用规范	_fastcall	从右到左，使用寄存器传参	被调用者负责
标准调用规范	_stdcall	从右到左	被调用者负责

示例程序：

#include "stdafx.h"

int __cdecl fun_a(int nNumA, int nNumB, int nNumC)	// C规范

{

	return nNumA+nNumB+nNumC;

}

int __fastcall fun_b(int nNumA, int nNumB, int nNumC)// 快速调用

{

	return nNumA+nNumB-nNumC;

}

int __stdcall fun_c(int nNumA, int nNumB, int nNumC)	// 标准调用

{

	return nNumA-nNumB-nNumC;

}

int _tmain(int argc, _TCHAR* argv[])

{

	printf("11111111111111111111111111111");

	fun_a(argc, 1, 2); //func_a,入栈顺序从右向左，调用者平衡堆栈

	fun_b(argc, 1, 2); //fun_b，入栈顺序从右向左，被调用者平衡堆栈

	fun_c(argc, 1, 2);//fun_c，入栈顺序从右向左，被调用者平衡堆栈

	return 0;

}

反汇编程序：

Main()函数

.text:004016A0 main__ proc near ; CODE XREF: j_main__j

.text:004016A0

................

.text:00401707   push    2          ; 参数3入栈

.text:00401709   push    1          ; 参数2入栈

.text:0040170B   mov     eax, [ebp+arg_0]

.text:0040170E   push    eax        ; 参数1入栈

.text:0040170F   call    j_fun_a__  ; func_a,cdecl调用方式,入栈顺序从右向左，调用者平衡堆栈

.text:00401714   add     esp, 0Ch   ; 由Main()函数销毁fun_a用到的局部变量平衡堆栈

.text:00401714                      ;

.text:00401717   push    2          ; 参数3入栈

.text:00401719   mov     edx, 1     ; 参数2入栈

.text:0040171E   mov     ecx, [ebp+arg_0] ; 参数1传递给ecx

.text:00401721   call    j_fun_b__  ; fun_b，fastcall调用方式，入栈顺序从右向左，被调用者平衡堆栈

.text:00401726   push    2          ; 参数3入栈

.text:00401728   push    1          ; 参数2入栈

.text:0040172A   mov     eax, [ebp+arg_0]

.text:0040172D   push    eax        ; 参数1入栈

.text:0040172E   call    j_fun_c__  ; fun_c，stdcall调用方式，入栈顺序从右向左，被调用者平衡堆栈

.text:00401733   xor     eax, eax

.text:00401735   pop     edi

.text:00401736   pop     esi

.text:00401737   pop     ebx

.text:00401738   add     esp, 0C0h  ; 销毁局部变量，平衡堆栈

.text:0040173E   cmp     ebp, esp   ; 比较esp的值是否正常

.text:00401740   call    sub_4010B4 ; 调用检查esp的函数

.text:00401745   mov     esp, ebp

.text:00401747   pop     ebp

.text:00401748   retn

.text:00401748 main__          endp

fun_a()函数是cdecl调用，所以没有堆栈平衡，由调用者main()函数进行堆栈平衡

.text:00401480 fun_a__         proc near               ; CODE XREF: j_fun_a__j

.text:00401480

.text:00401480 var_C0 = byte ptr -0C0h

.text:00401480 arg_0  = dword ptr  8

.text:00401480 arg_4  = dword ptr  0Ch

.text:00401480 arg_8  = dword ptr  10h

.text:00401480

.text:00401480   push    ebp             ; EBP入栈保存

.text:00401481   mov     ebp, esp        ; 然后将堆栈指针ESP的值传递给EBP

.text:00401481                           ; 如此一来在这个函数内只需要使用EBP就可对栈进行操作了。

.text:00401481                           ; 这样做的好处是不需要对ESP做过多的操作

.text:00401483   sub     esp, 0C0h       ; 将ESP减0xC0

.text:00401489   push    ebx

.text:0040148A   push    esi

.text:0040148B   push    edi             ; 保存EBX、ESI、EDI

.text:0040148C   lea     edi, [ebp+var_C0]

.text:00401492   mov     ecx, 30h

.text:00401497   mov     eax, 0CCCCCCCCh

.text:0040149C   rep stosd

.text:0040149E   mov     eax, [ebp+arg_0] ; 将参数1传递给eax

.text:004014A1   add     eax, [ebp+arg_4] ; 将eax与参数2相加

.text:004014A4   add     eax, [ebp+arg_8] ; 将eax与参数3相加

.text:004014A7   pop     edi

.text:004014A8   pop     esi

.text:004014A9   pop     ebx

.text:004014AA   mov     esp, ebp

.text:004014AC   pop     ebp

.text:004014AD   retn

.text:004014AD fun_a__         endp

fun_b()函数是fastcall调用，参数是由ECX与EDX这两个寄存器完成的，超出部分的参数依然采用压栈方式传递。被调用者fun_b()负责堆栈平衡。

.text:004014C0 fun_b__         proc near               ; CODE XREF: j_fun_b__j

.text:004014C0

.text:004014C0 var_D8 = byte ptr -0D8h

.text:004014C0 var_14 = dword ptr -14h

.text:004014C0 var_8  = dword ptr -8

.text:004014C0 arg_0  = dword ptr  8

.text:004014C0

.text:004014C0    push    ebp

.text:004014C1    mov     ebp, esp

.text:004014C3    sub     esp, 0D8h

.text:004014C9    push    ebx

.text:004014CA    push    esi

.text:004014CB    push    edi

.text:004014CC    push    ecx

.text:004014CD    lea     edi, [ebp+var_D8]

.text:004014D3    mov     ecx, 36h

.text:004014D8    mov     eax, 0CCCCCCCCh

.text:004014DD    rep stosd

.text:004014DF    pop     ecx

.text:004014E0    mov     [ebp+var_14], edx ; 将参数2的值传递给局部变量2

.text:004014E3    mov     [ebp+var_8], ecx ; 将参数1的值传递给局部变量1

.text:004014E6    mov     eax, [ebp+var_8] ; 将局部变量1的值传递给eax

.text:004014E9    add     eax, [ebp+var_14] ; 将eax与局部变量2相加

.text:004014EC    sub     eax, [ebp+arg_0] ; 将eax与参数3相减

.text:004014EC                            ;

.text:004014EC                            ; 采用快速调用的函数参数是由exc与edx这两个寄存器完成的，

.text:004014EC                            ; 而超出部分的参数则依然要使用传统的压栈方式传递，以下就是本函数的参数与局部变量的结构

.text:004014EC                            ;

.text:004014EC                            ; 参数1：ecx

.text:004014EC                            ; 参数2：edx

.text:004014EC                            ; 参数3：ebp+0x8

.text:004014EC                            ; 局部变量1：ebp-0x8

.text:004014EC                            ; 局部变量2：ebp-0x1

.text:004014EF    pop     edi

.text:004014F0    pop     esi

.text:004014F1    pop     ebx

.text:004014F2    mov     esp, ebp

.text:004014F4    pop     ebp

.text:004014F5    retn    4

.text:004014F5 fun_b__         endp

fun_c函数是stdcall调用，函数返回时销毁局部变量，平衡堆栈。

.text:00401510 fun_c__         proc near               ; CODE XREF: j_fun_c__j

.text:00401510

.text:00401510 var_C0 = byte ptr -0C0h

.text:00401510 arg_0  = dword ptr  8

.text:00401510 arg_4  = dword ptr  0Ch

.text:00401510 arg_8  = dword ptr  10h

.text:00401510

.text:00401510   push    ebp

.text:00401511   mov     ebp, esp

.text:00401513   sub     esp, 0C0h

.text:00401519   push    ebx

.text:0040151A   push    esi

.text:0040151B   push    edi

.text:0040151C   lea     edi, [ebp+var_C0]

.text:00401522   mov     ecx, 30h

.text:00401527   mov     eax, 0CCCCCCCCh

.text:0040152C   rep stosd

.text:0040152E   mov     eax, [ebp+arg_0] ; 将参数1传递给eax

.text:00401531   sub     eax, [ebp+arg_4] ; 将eax与参数2相减

.text:00401534   sub     eax, [ebp+arg_8] ; 将eax与参数3相减

.text:00401537   pop     edi

.text:00401538   pop     esi

.text:00401539   pop     ebx

.text:0040153A   mov     esp, ebp

.text:0040153C   pop     ebp

.text:0040153D   retn    0Ch             ; 函数返回时销毁局部变量，平衡堆栈。

.text:0040153D fun_c__         endp

3、汇编改变特征小技巧

并不是所有的函数都只有用call指令才能调用，使用lea、push加jmp的组合也可以达到相同的目的。

例如将call Demo.013A1127可以转换为以下形式：

lea esi,return_addr ; 取到jmp Demo.013A1127指令后面的地址

push esi            ; 将这个地址压入栈

jmp Demo.013A1127   ; 跳转到Demo.013A1127处执行函数代码

4、裸函数

C++使用naked标识创建的裸函数将不包含任何用户代码以外的指令，即便是函数末尾的retn也要用户自己来实现。

代码如下：

#include "stdafx.h"

__declspec(naked) int fun(int nNumA, int nNumB, int nNumC)

{

	__asm

	{

		push ebp

		mov ebp, esp

		sub esp, 0x4

	}

	 nNumA += (nNumB+nNumC);	// 注意，此行为c语句。

	__asm

	{

		mov eax, nNumA

		add esp, 0x4

		mov esp, ebp

		pop ebp

		retn

	}

}

int _tmain(int argc, _TCHAR* argv[])

{

	printf("fun=%d", fun(argc,1,2));

	return 0;

}

5、小结

采用不同的调用方式，反汇编代码不同。

a) 几乎全部函数调用方式都会用栈来传递参数，只有使用快速调用约定后且参数少于等于2时才会全部采用寄存器传参。
b) 函数起始部分：以push ebp和mov ebp，esp汇编指令开始
c) 每个函数由call指令调用，且以retn指令结尾。
d) 裸函数进行内联汇编可以改变以上的某些规律。

注：裸函数是指编译器生成汇编代码时不添加任何额外的指令，包括retn。

0x5 参考文章

《黑客免杀攻防》软件逆向工程1-3

http://blog.csdn.net/dalerkd/article/details/41173623