一、什么是裸函数
在函数名前面加上 __deplspec(naked)，此时，编译器对该函数不会进行任何处理。
想要在c语言里面写汇编的语法，使用vc中输入__asm
对于一个裸函数而言，就是编译器不会为这个函数生成代码，想用汇编怎么写就怎么写，如果什么都不写，一定会报错，因为没有生成ret。
无参数无返回值的函数框架
void __declspec(naked) Function()
{
__asm
{
push ebp
mov ebp, esp
sub esp, 0x40
push ebx
push esi
push edi
lea edi, dword ptr ds : [ebp - 0x40]
mov eax, 0xCCCCCCCC
mov ecx, 0x10
rep stosd
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret
}
}
有参数有返回值的函数框架
int __declspec(naked) Function(int x, int y)
{
__asm
{
push ebp
mov ebp, esp
sub esp, 0x40
push ebx
push esi
push edi
lea edi, dword ptr ds : [ebp - 0x40]
mov eax, 0xCCCCCCCC
mov ecx, 0x10
rep stosd
mov eax, dword ptr ds : [ebp + 8]
add eax, dword ptr ds : [ebp + 0xC]
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret
}
}
带局部变量的函数框架
int __declspec(naked) Function(int x,int y)
{
__asm
{
push ebp
mov ebp,esp
sub esp,0x40
push ebx
push esi
push edi
lea edi,dword ptr ds:[ebp-0x40]
mov eax,0xCCCCCCCC
mov ecx,0x10
rep stosd
mov dword ptr ds:[ebp-4],2
mov dword ptr ds:[ebp-8],3
mov eax,dword ptr ds:[ebp+8]
add eax,dword ptr ds:[ebp+0xC]
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
}
}
二、调用约定
| 调用约定 | 参数压栈顺序 | 平衡堆栈 |
|---|---|---|
| __cdecl | 从右至左入栈 | 调用者清理栈 |
| __stdcall | 从右至左入栈 | 自身清理堆栈 |
| __fastcall | ECX/EDX传送前两个，剩下:从右至左入栈 | 自身清理堆栈 |
1. __cdecl
int __cdecl Plus(int a, int b)
{
return a + b;
}
push 2
push 1
call @ILT+15(Plus) (00401014)
add esp,8
2. __stdcall
int __stdcall Plus(int a, int b)
{
return a+b;
}
push 2
push 1
call @ILT+10(Plus) (0040100f)
函数内部：
ret 8
3. __fastcall
3.1 参数个数<=2
int __fastcall Plus(int a, int b)
{
return a+b;
}
mov edx,2
mov ecx,1
call @ILT+0(Plus) (00401005)
函数内部：
ret
3.2 参数个数>2
int __fastcall Plus4(int a, int b,int c,int d)
{
return a+b+c+d;
}
push 4
push 3
mov edx,2
mov ecx,1
call @ILT+5(Plus) (0040100a)
函数内部：
ret 8
三、判断函数有几个参数
一般情况：
# 步骤一：观察调用处的代码
push 3
push 2
push 1
call 0040100f
# 步骤二：找到平衡堆栈的代码继续论证
call 0040100f
add esp,0Ch
# 或者函数内部
ret 4/8/0xC/0x10
# 最后，两者一综合，函数的参数个数基本确定.
上面的分析存在的问题
1、参数传递未必都是通过堆栈，还可能通过使用寄存器
push ebx
push eax
mov ecx,dword ptr ds:[esi]
mov edx,dword ptr ds:[edi]
push 45
push 33
call 函数地址
2、函数调用处的代码无法查看
观察步骤
1、不考虑ebp、esp
2、只找给别人赋值的寄存器
eax/ecx/edx/ebx/esi/edi
3、找到以后追查其来源，如果，该寄存器中的值不是在函数内存赋值的，那一定是传进来的参数
# 公式一：寄存器 + ret 4 = 参数个数
# 公式二：寄存器 + [ebp+8] +[ebp+0x] = 参数个数
00401050 push ebp
00401051 mov ebp,esp
00401053 sub esp,48h
00401056 push ebx
00401057 push esi
00401058 push edi
00401059 push ecx
0040105A lea edi,[ebp-48h]
0040105D mov ecx,12h
00401062 mov eax,0CCCCCCCCh
00401067 rep stos dword ptr [edi]
00401069 pop ecx
0040106A mov dword ptr [ebp-8],edx
0040106D mov dword ptr [ebp-4],ecx
00401070 mov eax,dword ptr [ebp-4]
00401073 add eax,dword ptr [ebp-8]
00401076 add eax,dword ptr [ebp+8]
00401079 mov [g_x (00427958)],eax
0040107E pop edi
0040107F pop esi
00401080 pop ebx
00401081 mov esp,ebp
00401083 pop ebp
00401084 ret 4
四、查找main方法入口
1、程序的真正入口
main 或WinMain 是“语法规定的用户入口”，而不是“应用程序入口”。应用程序入口通常是启动函数。
2、 main 函数的识别:
main 函数被调用前要先调用的函数如下：
GetVersion()
_heap_init()
GetCommandLineA()
_crtGetEnvironmentStringsA()
_setargv()
_setenvp()
_cinit()
这些函数调用结束后就会调用main 函数，根据main 函数调用的特征，将3 个参数压入栈内作为函数的参数
我们可以根据三个参数的方法来判断是否是main函数
接下来，往下面找
五、数据类型
学习数据类型的三个要素
1、存储数据的宽度
2、存储数据的格式
3、作用范围(作用域)
整数类型
C语言中
char 8bit 1字节
short 16bit 2字节
int 32bit 4字节
long 32bit 4字节
反汇编
char a = 0xFF; mov byte ptr [a],0FFh 1字节
short b = 0xFF; mov word ptr [b],ax 2字节
int c = 0xFF; mov dword ptr [c],0FFh 3字节
//若超过数据宽度，则会省略前面的数据
char a = 0x12345678; mov byte ptr [a],78h
short b = 0x12345678; mov word ptr [b],5678h
int c = 0x12345678; mov dword ptr [c],12345678h
//unsigned 和 signed 在汇编的储存是一样的，正负只是人为规定的方式
signed int c = 0x12345678; mov dword ptr [c],12345678h
unsigned int d = 0x12345678; mov dword ptr [d],12345678h
浮点类型
float和double在存储方式上都是遵从IEEE的规范的
根据国际标准IEEE 754，任意一个二进制浮点数V可以表示成下面的形式：
（1）(-1)^s表示符号位，当s=0，V为正数；当s=1，V为负数。
（2）M表示有效数字，大于等于1，小于2。
（3）2^E表示指数位。
举例来说，十进制的5.0，写成二进制是101.0，相当于1.01×2^2。那么，按照上面V的格式，可以得出s=0，M=1.01，E=2。
十进制的-5.0，写成二进制是-101.0，相当于-1.01×2^2。那么，s=1，M=1.01，E=2。
IEEE 754规定，对于32位的浮点数，最高的1位是符号位s，接着的8位是指数E，剩下的23位为有效数字M。
对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M。
IEEE 754对有效数字M和指数E，还有一些特别规定。
有效数字M
前面说过，1≤M<2，也就是说，M可以写成1.xxxxxx的形式，其中xxxxxx表示小数部分。**IEEE 754规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的xxxxxx部分。**比如保存1.01的时候，只保存01，等到读取的时候，再把第一位的1加上去。这样做的目的，是节省1位有效数字。以32位浮点数为例，留给M只有23位，将第一位的1舍去以后，等于可以保存24位有效数字。
指数E
至于指数E，情况就比较复杂。
首先，E为一个无符号整数（unsigned int）。这意味着，如果E为8位，它的取值范围为0~255；如果E为11位，它的取值范围为0~2047。但是，我们知道，科学计数法中的E是可以出现负数的，所以IEEE 754规定，E的真实值必须再减去一个中间数，对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。
比如，2^10的E是10，所以保存成32位浮点数时，必须保存成10+127=137，即10001001。
然后，指数E还可以再分成三种情况：
**（1）E不全为0或不全为1。**这时，浮点数就采用上面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将有效数字M前加上第一位的1。
**（2）E全为0。**这时，浮点数的指数E等于1-127（或者1-1023），有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于0的很小的数字。
**（3）E全为1。**这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）；如果有效数字M不全为0，表示这个数不是一个数（NaN）。
转化方式
1.先将这个实数的绝对值化为二进制格式
以8.25为例
整数部分8转成2进制 (自下而上)
8/2 = 4 0
4/2 = 2 0
2/2 = 1 0
1/2 = 0 1
小数部分0.25转成二进制：(自上而下)
0.25*2 = 0.5 0
0.5*2 = 1.0 1
8.25用二进制表示可表示为1000.01
2.将二进制转化为科学计数法
1000.01 ->> 1.00001 * 10^3
3.得出结果
因为是正数 -> S=0
M = 1.00001
E = 3
若为float，E需要加上127，为130，转化为二进制为1000 0010
所以最后结果是S+E+M = 0 1000 0010 00001000000000000000000 = 0x 4104 0000
若为double，E需要加上1023，为1026，转化为二进制为100 0000 0010
所以最后结果是S+E+M = 0 100 0000 0010 0000100000000000000000000000000000000000000000000000 = 0x 4020 8000 0000 0000
Comments | 0 条评论