从进制换算与数据宽度讲起,梳理 x86 汇编的寄存器、常用指令与函数调用约定,并结合 OllyDbg、CE 的调试实例讲解 if / switch / 循环语句的逆向识别方法。

课程进度:认识 OD 未开始

进制

主要了解进制换算的方法以及计算机常用的二进制和十六进制

二进制数据:1101

十六进制数据:E10F

十进制转其他进制(二进制为例):除以对应进制取余即可

计算机使用二进制,这里学习十六进制的原因是:

  • 十六进制与二进制之间的转换相对简单
  • 十六进制数表示方式紧凑
十六进制 二进制
1 0001
2 0010
4 0100
8 1000

计算机存储数据是有宽度的

计算机中存储数据的单位术语:

  • 位(bit):最小单位,由0和1表示
  • 字节(Byte): ,是计算机中最基本的可寻址单元
  • 字(WORD)
  • 双字(DWORD)

计算机存在 32 位操作系统(x86)和 64 位操作系统(x64),32或64分别表示什么?

以下面的64位程序为例进行说明:

image-20261010233257985

在程序中设置断点,确保程序运行至断点时临时变量 a 已经生成。

顶部菜单:调试 (Debug) → 窗口 (Windows) → 内存 (Memory) 调出内存窗口,使用取地址符查找变量 a 所在的地址,可以看到使用 16 进制表示的地址一共有 16 位,转换为二进制就是 64 位。

image-20261010233626764

数据的存储模式

大端模式:指数据的低位保存在内存的高地址中,而数据的高位,保存在内存的低地址中;
小段模式(x86):是指数据的低位保存在内存的低地址中,而数据的高位,保存在内存的高地址中

举例来理解大端模式和小端模式

定义一个较大的数 0x12345678 将其赋值给某个 int 类型变量 a,由于数字较大,单个字节无法存储。我们来观察其对应的数据存储模式

image-20261011011042937

可以看到两个十六进制为一组,正好为 8 位一个字节,78 为数据低位因此保存在地址中的较低的位置。12 为数据的高位因此保存在地址中的较高的位置。

将数据值改为 2,结果如下,只有地址中的低位被占据,而高位留空:

image-20261011011605227

寄存器

寄存器在 CPU 内。

计算机存储数据的位置有(读取速度排列)

CPU > 内存 > 硬盘

32 位通用寄存器的指定名称以及用途

1 ,eax 累加器操作数以及结果数据的累加器,也经常用作一个 call 的返回值
2 ,ecx 计数器 字符串和循环操作的计数器
3 ,edx 用于保存乘法形成的的部分结果或者除法之前部分被除数
4 ,ebx 基地址, DS 段的数据指针,在内存寻址时存放基地址
5 ,esp 堆栈指针,经常被称为栈顶指针
6 .ebp 栈底指针
7 ,esi 字符串操作的源指针
8 ,edi 字符串操作的目标指针

上述寄存器都是通用的,只是通常执行对应功能。

x86 架构下上述寄存器都是 4 个字节宽度。

通用寄存器的逻辑结构

16-31 0-15 15-0 8-15 0-7
ea x ax ah al
ec x cx ch cl
ed x dx dh dl
eb x bx bh bl
es p sp
eb p bp
es i si
ed i di

尝试利用寄存器存储数据:

在 C++ 中嵌入汇编代码使用关键字 __asm

1
2
3
4
5
6
7
8
int main()
{
__asm
{
mov eax, 1
}
return 0;
}

上述代码中 mov 相当于 C++ 中的赋值语句。为该语句下断点进行调试(注意将调试器改为 x64Debug 模式):

顶部菜单:调试 (Debug) → 窗口 (Windows) → 寄存器 (Register) 调出寄存器窗口

image-20261011162314084

可以看到累加器的值为 CCCCCCCC 即空值,执行赋值操作(逐过程),可以发现累加器的数值发生变化,即数值写入成功

image-20261011162544822

执行以下代码,可以发现只对 0-15 的数据进行了更改

1
2
mov eax, 0xAAAAAAAA
mov ax, 0xBBB
image-20261011163220970

认识 OD

OD(OllyDbg):32 位程序调试工具(将二进制程序转为汇编语言)

image-20261011185212608

寄存器窗口只在程序运行至断点时才会有值(因为寄存器一直在输入输出数据)

反汇编窗口:主要查看代码,将二进制硬编码数据转化为汇编语言

数据窗口:主要查看数据,比如人物的血量数据为 100,那么在数据窗口就会出现 100 的十六进制编码数据

基本操作

开始调试:打开文件或将程序拖动至调试窗口内

剥离:右键→StrongOD→Detach

我们以之前课程所编译的 x86 程序为例

image-20261011184610729

无论是汇编窗口、数据窗口,本质都是对于内存地址进行不同类型的解析。

跳转:Ctrl + G 输入地址即可进行跳转

image-20261011191421551 image-20261011191452857

调试快捷键
F7:单步步入(进入到函数内部)
F8:单步步过(直接将函数执行完)
Ctrl + F9:执行到返回(从函数中出来)

设置断点(int3断点 软件断点 cc断点):F2 (变红)

CPU 指令集

参考文档

英特尔资源和文档中心

汉化版:Intel IA-32 指令集 By:网事如风(主要)

文档界面:

image-20261028205530580

OllyDBG 编码

(1)打开汇编窗口:

image-20261028210220203

(2)编写一段汇编指令:

image-20261028210445767

表示将寄存器 ah 段的数据赋值到 al 段

查看硬编码为 8AC4 ,即表示

操作码 指令 说明
8A /r MOV r8,r/m8 将 r/m8 移到 r8

将寄存器的数据赋值给寄存器

(3)单步运行:

EAX 寄存器原数据为 006FFE5C

运行后数据为 006FFEFE

证明赋值操作执行成功

mov 指令

下面继续编写另一条指令:

1
mov [0x0],bh

语法上通过,硬编码为 883D

操作码 指令 说明
88 /r MOV r/m8,r8 将 r8 移到 r/m8

将寄存器数据写入某个地址

在执行过程中会出现错误,涉及计算机中地址分配的内容:

地址段 功能
0x00000000 64kb 空指针赋值分区
0x00010000 未映射区
(用户区 2G) 代码段
初始化数据区
堆
---
栈
命令行参数和环境变量
0xfffeffff 64kb 禁入分区
0x7fffffff
(内核区 2G)
0xffffffff

上面的代码使用了用户区外的地址,因此会导致程序直接崩溃

(1)编写一段代码将立即数 7 写入到寄存器 bh 中

立即数:常量

1
mov bh,7

(2)将 7 赋值到某段内存地址中(在编写的过程中 ptr 和 ds 都可省略)

1
2
mov dword ptr ds:[0x003CFCC8],7
mov dword [003CFCC8],7

由于立即数和内存地址都无法确定宽度,就需要提前声明数据大小

76325D49->00000007

lea 指令

操作码 指令 说明
8D /r LEA r16,m 将 m 的有效地址存储到寄存器 r16
8D /r LEA r32,m 将 m 的有效地址存储到寄存器 r32

观察以下两行代码:

1
2
lea eax,dword ptr ds:[0x3CFCC8]
mov eax,dword ptr ds:[0x3CFCC8]

运行结果

1
2
0x003CFCC8:00000007
eax:003CFD1C->003CFCC8->00000007

不难发现,lea 直接将地址写入了寄存器,而 mov 是取地址内的值再将其赋值给寄存器

在 C++ 中进一步说明:

编写一条赋值语句,查看反汇编代码:

image-20261028221506904

使用的是 mov 指令:

image-20261028221640402

关闭显示符号名后汇编代码为:

1
001518DB  mov dword ptr [ebp-8],1
  • 其中 ebp-8 为局部变量,可以将其理解为某个地址

继续编写另一条取地址语句:

1
2
int a = 1;
int* b = &a;

反汇编代码为:

1
2
3
007344AB  mov         dword ptr [ebp-8],1  
007344B2 lea eax,[ebp-8]
007344B5 mov dword ptr [ebp-14h],eax

其中第二段代码就是执行的取地址运算

add sub inc dec

add:加法指令(需要保证位数相等)

1
add al, 7

sub:减法指令(类似)

inc:自增1

1
inc eax

dec:自减1

标志寄存器(EFL)

共有四个字节,按位进行查看,每一位都代表一个标志

image-20261029002159100
标志位(外语缩写)标志位名称及外语全称=1=0
CF进位标志/Carry FlagCY/Carry/进位NC/No Carry/无进位
PF奇偶标志/Parity FlagPE/Parity Even/偶PO/Parity Odd/奇
AF辅助进位标志/Auxiliary Carry FlagAC/Auxiliary Carry/进位NA/No Auxiliary Carry/无进位
ZF零标志/Zero FlagZR/Zero/等于零NZ/Not Zero/不等于零
SF符号标志/Sign FlagNG/Negative/负PL/Positive/非负
TF跟踪标志/Trace Flag
IF中断标志/Interrupt FlagEI/Enable Interrupt/允许DI/Disable Interrupt/禁止
IF中断标志/Interrupt FlagEI/Enable Interrupt/允许DI/Disable Interrupt/禁止
DF方向标志/Direction FlagDN/Down/减少UP/增加
OF溢出标志/Overflow FlatOV/Overflow/溢出NV/Not Overflow/未溢出

学习标志寄存器的意义:判断跳转与否

1、JE, JZ结果为零则跳转(相等时跳转) ZF=1

2、JNE, JNZ结果不为零则跳转(不相等时跳转) ZF=0

3、JS结果为负则跳转 SF=1

4、JNS结果为非负则跳转 SF=0

5、JP, JPE结果中1的个数为偶数则跳转 PF=1

6、JNP, JPO结果中1的个数为偶数则跳转 PF=0

7、JO结果溢出了则跳转 OF=1

8、JNO结果没有溢出则跳转 OF=0

9、JB, JNAE小于则跳转 (无符号数) CF=1

10、JNB, JAE大于等于则跳转 (无符号数) CF=0

11、JBE, JNA小于等于则跳转 (无符号数) CF=1 or ZF=1

12、JNBE, JA大于则跳转(无符号数) CF=0 and ZF=0

13、JL, JNGE小于则跳转 (有符号数) SF≠ OF

14、JNL, JGE大于等于则跳转 (有符号数) SF=OF

15、JLE, JNG小于等于则跳转 (有符号数) ZF=1 or SF≠ OF

16、JNLE, JG大于则跳转(有符号数) ZF=0 and SF=OF

位运算

and:按位与(&&)

or:按位或

not:按位取反

上面的概念在 C++ 中都讲解过,注意只能对二进制进行操作即可

cmp test

cmp:执行了一次减法操作但只影响标志位,但是不改变寄存器内的值,经常与条件跳转共同使用

逐步运行以下代码,观察寄存器 eax 值的变化和标志寄存器的数值变化情况:

image-20261029005956192 image-20261029010136700

执行 add 指令,寄存器数据发生变化

零标志判定为否,因此有

1的个数为偶数,因此有

image-20261029010500388

执行 cmp 指令,寄存器数据不发生改变,但是标志寄存器中数据发生变化。

零标志判定为否,因此有

1的个数为奇数,因此有

JZ结果为零时跳转(cmp 的两数相等,即相减为零, 时发生跳转),所以该步执行完毕后应该不跳转继续顺序执行下一步

image-20261029012454358

验证了上述的分析正确。

对比 cmp 和 sub 的关系,test 和 add 的关系也类似

push pushad pop popad

push:将字或双字压入堆栈(寄存器,内存地址,立即数等)

ESP 通用寄存器内存放的数据为栈点地址

EBP 栈底地址寄存器

image-20261102221110595

pop:将栈顶的值弹出堆栈(弹出至寄存器/内存地址)

image-20261102222018565

pushad:将通用寄存器中的内容一次性压入堆栈

操作码 指令 说明
60 PUSHA 压入 AX、CX、DX、BX、原始 SP、BP、SI 及 DI
60 PUSHAD 压入 EAX、ECX、EDX、EBX、原始 ESP、EBP、ESI 及 EDI

popad:同理

jmp call ret eip

EIP:保存即将要执行的代码段地址的寄存器

1
jmp short 地址
  • short:代表跳转的位置距离当前代码较近(128 字节内)

call:与 jmp 类似也是跳转到对应代码段,但是 call 在跳转到函数实现的位置时会将 call 代码下一个代码段的地址 push 到堆栈中,方便函数执行完毕后返回原位置继续执行。

ret:相当于

1
2
pop EIP
jmp EIP

演示堆栈:

C++ 代码如下:

1
2
3
4
5
6
7
8
9
10
11
int add(int a, int b)
{
return a + b;
}

int main()
{
int res = add(1, 2);

return 0;
}

汇编代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
003713ED  jmp         003717D0

003717D0 push ebp // EBP:栈底,把外层栈底 PUSH 保存到堆栈里
003717D1 mov ebp,esp // 将当前的栈顶作为新的栈底
003717D3 sub esp,0C0h // 开辟新的堆栈空间用来存储 add 函数中的数据
003717D9 push ebx
003717DA push esi
003717DB push edi // 保存 main 函数寄存器的当前状态

003717DC mov eax,dword ptr [ebp+8] // ebp + 8 即为第一个参数 2
003717DF add eax,dword ptr [ebp+0Ch] // ebp + 0Ch(12) 即为第二个参数

003717E2 pop edi
003717E3 pop esi
003717E4 pop ebx // 还原 main 函数中寄存器状态
003717E5 mov esp,ebp // 还原开辟的堆栈空间,此时栈顶指向存储 main 函数栈底的位置
003717E7 pop ebp // 将 main 函数栈底还原
003717E8 ret // 弹出 返回地址
->
003726CB push 2 // 先 push 后面的参数,ESP 寄存器提升 4 个字节
003726CD push 1
003726CF call 003713ED // jmp 到指定位置,并 push 003726D4 到堆栈
003726D4 add esp,8 // 将堆栈中的保存的参数弹出
003726D7 mov dword ptr [ebp-8],eax
  • 每个函数都有自己的栈底,当前在哪个函数内部,ebp寄存器所存储的栈底即为哪个函数的
image-20261103182708487

数据类型的边界和溢出

char

char:一个字节,8位,共256个数据,数据取值范围

至于为什么采用这种取值类型,后续在 int 类型中会进行说明

int

int:四个字节,32位,4,294,967,296个数据,我们知道 int 是整型数据,既可以是正整数也可以是负整数,为了保证规范性,char 也采用了类似的数据值计算方法,这就解释了为什么 char 类型也会取到负值。

0000 0000 0000 0000 0000 0000 0000 0011=3

0111 1111 1111 1111 1111 1111 1111 1111=2,147,483,647

1000 0000 0000 0000 0000 0000 0000 0000=-2,147,483,648

1111 1111 1111 1111 1111 1111 1111 1111=-1

此处涉及了补码这一操作,比如我们希望获得 -3 的 32 位二进制编码:

  • 先取反:1111 1111 1111 1111 1111 1111 1111 1100
  • 再加1:1111 1111 1111 1111 1111 1111 1111 1101=-3

补码的核心优势:减法可以变为加法

数组指针与多维数组内存

数组本身为指针类型。多维数组同样是按顺序存储在内存中的。

字符串指针与编码

字符串指针

单个 char 在内存地址中占一个字节 8 位,编写一段 C++ 代码观察字符串在内存中的存储方式

1
2
char* b = (char*)"12345fedba";
char c[] = "123ABC123";
image-20261107004259275 image-20261107004346044

字符串在内存中是直接按顺序进行存储的

字符串编码

ascii:中文占两个字节(代码页)
unicode:所有字符都占两个字节
utf- 8:中文占三个字节,ascii 码只占单个字节
big5

浮点在内存中如何存放

浮点数在内存中的存储方式遵循 IEEE 754 标准,存储格式为
其中 s 是符号位, M 表示有效数字, E 表示指数 [2]。 对于 32 位浮点数,其存储结构为:
高位为符号位 接着 8 位为指数位,剩余的 23 位为有效数字。实际可保存的有数字位为 24 位

image-20261107140454811

5.125:

5:0101

0.125:0.125 * 2 = 0.250 无进位 0101.0

0.250:0.250 * 2 = 0.500 无进位 0101.00

0.500:0.500 * 2 = 1.000 有进位 0101.001

1.000:1.000 - 1 = 0 无余数 算法结束

0.1:

0.1:0.1 * 2 = 0.2 无进位 0.0

0.2:0.2 * 2 = 0.4 无进位 0.00

0.4:0.4 * 2 = 0.8 无进位 0.000

0.8:0.8 * 2 = 1.6 有进位 0.0001

1.6:1.6 - 1 = 0.6 有余数 算法继续

0.6:0.6 * 2 = 1.2 有进位 0.00011

1.2:1.2 - 1 = 0.2 有余数 算法继续

0.2 之前已经出现因此算法出现循环,会一直计算直至溢出精度,因此浮点数会丢失精度

float 究竟有多大又究竟有多小
到
遑论 double 双精度浮点数

逆向 if 语句

C++ 代码:

1
2
3
4
5
6
7
8
9
10
int a = 1;

if (a > 2)
{
printf("大于2");
}
else
{
printf("小于2");
}

反汇编代码:

1
2
3
4
5
6
7
8
9
10
11
12
000B44AB  mov         dword ptr [ebp-8],1 

000B44B2 cmp dword ptr [ebp-8],2
000B44B6 jle 000B44C7

000B44B8 push 0B7BCCh
000B44BD call 000B13CF
000B44C2 add esp,4

000B44C7 push 0B7BD4h
000B44CC call 000B13CF
000B44D1 add esp,4
  • 这里用到了之前的 mov,cmp和跳转指令
  • jle:小于等于则跳转,le 是 less equal 的缩写

逆向 switch 语句

C++ 代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int a = 1;

switch (a)
{
case 1:
{
printf("1");
break;
}
case 2:
{
printf("2");
break;
}
case 3:
{
printf("3");
break;
}
}

return 0;

反汇编代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
008D44AB  mov         dword ptr [ebp-8],1  

008D44B2 mov eax,dword ptr [ebp-8]
008D44B5 mov dword ptr [ebp+FFFFFF30h],eax
008D44BB cmp dword ptr [ebp+FFFFFF30h],1
008D44C2 je 008D44D8
008D44C4 cmp dword ptr [ebp+FFFFFF30h],2
008D44CB je 008D44E7
008D44CD cmp dword ptr [ebp+FFFFFF30h],3
008D44D4 je 008D44F6
008D44D6 jmp 008D4503

008D44D8 push 8D7BCCh
008D44DD call 008D13CF
008D44E2 add esp,4
008D44E5 jmp 008D4503

008D44E7 push 8D7BD4h
008D44EC call 008D13CF
008D44F1 add esp,4
008D44F4 jmp 008D4503

008D44F6 push 8D7BD0h
008D44FB call 008D13CF
008D4500 add esp,4

008D4503 xor eax,eax
  • 在判断前进行了多次的赋值操作,这是编译器构建的规则,我们只需要能看懂代码即可
  • 本质多次执行 if 语句

C++ 代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
int a = 2;

switch (a)
{
case 1:
{
printf("1");
break;
}
case 2:
{
printf("2");
break;
}
case 3:
{
printf("3");
break;
}
case 4:
{
printf("4");
break;
}
}

return 0;

反汇编代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
00FD44AB  mov         dword ptr [ebp-8],2  

00FD44B2 mov eax,dword ptr [ebp-8]
00FD44B5 mov dword ptr [ebp+FFFFFF30h],eax
00FD44BB mov ecx,dword ptr [ebp+FFFFFF30h]
00FD44C1 sub ecx,1 // 数组从零开始计数
00FD44C4 mov dword ptr [ebp+FFFFFF30h],ecx
00FD44CA cmp dword ptr [ebp+FFFFFF30h],3 // 大于 4 直接跳出
00FD44D1 ja 00FD451A
00FD44D3 mov edx,dword ptr [ebp+FFFFFF30h]
00FD44D9 jmp dword ptr [edx*4+00FD4530h] // 采用初始地址 + 偏移量,1,2,3,4 四个跳转点地址均存放在这一段连续的内存中

00FD44E0 push 0FD7BCCh // 1
00FD44E5 call 00FD13CF
00FD44EA add esp,4
00FD44ED jmp 00FD451A

00FD44EF push 0FD7BD4h // 2
00FD44F4 call 00FD13CF
00FD44F9 add esp,4
00FD44FC jmp 00FD451A

00FD44FE push 0FD7BD0h // 3
00FD4503 call 00FD13CF
00FD4508 add esp,4
00FD450B jmp 00FD451A

00FD450D push 0FD7BD8h // 4
00FD4512 call 00FD13CF
00FD4517 add esp,4

00FD451A xor eax,eax

image-20261029235743254

在判断数大于 3 后,汇编程序会自动采用空间换时间的方法来编译,加快程序执行的效率

逆向循环语句

while

C++ 代码:

1
2
3
4
5
int a = 2;
while (a == 2)
{
printf("a");
}

反汇编代码:

1
2
3
4
5
6
7
8
9
10
11
12
00AB17EB  mov         dword ptr [ebp-8],2  

00AB17F2 cmp dword ptr [ebp-8],2
00AB17F6 jne 00AB1807 // JNE:不相等时跳转

00AB17F8 push 0AB7BCCh
00AB17FD call 00AB13E3
00AB1802 add esp,4

00AB1805 jmp 00AB17F2 // 向上跳转,返回循环条件判断部分

00AB1807 pop edi

向上跳转是循环的一个特征

for

C ++ 代码:

1
2
3
4
5
6
7
int a = 0;

for (int i = 0; i <= 10; i++) {
a = a + 1;
}

return 0;

反汇编代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
009318AC  mov         dword ptr [ebp-8],0  

009318B3 mov dword ptr [ebp-14h],0
009318BA jmp 009318C5 // 第一次,无需自增,直接进入判断
009318BC mov eax,dword ptr [ebp-14h]
009318BF add eax,1 // 自增,i++
009318C2 mov dword ptr [ebp-14h],eax
009318C5 cmp dword ptr [ebp-14h],0Ah // 判断是否跳出循环
009318C9 jg 009318D6 // JG:大于即跳转

009318CB mov eax,dword ptr [ebp-8]
009318CE add eax,1
009318D1 mov dword ptr [ebp-8],eax

009318D4 jmp 009318BC // 一次循环执行完成,回到自增阶段

009318D6 xor eax,eax

OD 堆栈演示

程序准备

OD 堆栈演示(这将是我们第一次尝试逆向一个完整的程序)

编写一个带有提示窗口的 C++ 程序:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "windows.h"
#include <iostream>

using namespace std;

int add(int a, int b)
{
int m = 1;
int n = 2;
return a + b;
}

int main()
{
MessageBoxW(0, 0, 0, 0);

int res = add(1, 2);

return 0;
}

其中 MessageBoxW 会弹出一个错误提示窗口(Warning),可以让程序执行卡在某个位置,方便断点调试

编译并尝试运行,除了黑色控制台窗口外,程序也弹出了错误警告窗口,关闭警告窗口后程序正常退出

image-20261104203213912

代码定位

打开 OD,添加编译好的程序并运行

image-20261104213411340

搜索 MessageBoxW 函数所在位置,Ctrl + G 进行跟随,F2 在函数出口处下断点

image-20261104221507128

关闭警告窗口,程序继续执行时就会卡在刚才设置的断点处

image-20261104222007103

取消断点,F7 跳出函数后就来到了 main 函数的代码段

image-20261104222243956

函数特征

头部:

1
2
3
4
5
6
00C81810  push        ebp  // 外部函数栈底存储
00C81811 mov ebp,esp // 当前栈顶作为内部函数栈底
00C81813 sub esp,0D8h // 开辟临时变量存储空间
00C81819 push ebx
00C8181A push esi
00C8181B push edi // 保存当前寄存器状态

尾部:

1
2
3
4
5
6
00C81830  pop         edi  
00C81831 pop esi
00C81832 pop ebx
00C81833 mov esp,ebp
00C81835 pop ebp
00C81836 ret // 返回

代码调试

主函数调用阶段

  • 最好先下断点,后续再次重启程序时能够迅速定位到相应位置

  • 逐段执行代码,观察堆栈区和寄存器中数据变化

1
2
00C81963    6A 02           push 0x2
00C81965 6A 01 push 0x1
image-20261104223918843 image-20261104224134384
1
00C81967    E8 25F7FFFF     call Day2.00C81091
image-20261104224734678 image-20261104224808616
1
00C81091   /E9 7A070000     jmp Day2.add   // 无条件跳转至函数所在位置

函数体

1
2
3
4
5
6
00C81810 >  55              push ebp
00C81811 8BEC mov ebp,esp
00C81813 81EC D8000000 sub esp,0xD8
00C81819 53 push ebx
00C8181A 56 push esi
00C8181B 57 push edi
image-20261104230523165 image-20261104230600041

此处不难发现一个特点:

当前所在函数的栈底地址内存储的数据为外部函数的栈底地址

1
2
00C8181C    C745 F8 0100000>mov dword ptr ss:[ebp-0x8],0x1
00C81823 C745 EC 0200000>mov dword ptr ss:[ebp-0x14],0x2
image-20261104231842883
1
2
00C8182A    8B45 08         mov eax,dword ptr ss:[ebp+0x8]
00C8182D 0345 0C add eax,dword ptr ss:[ebp+0xC]

函数局部变量特征:

1
EBP + 0xXXX

函数传入参数特征

1
EBP - 0xXXX
1
2
3
00C81830    5F              pop edi                               ; 00B3F7B0
00C81831 5E pop esi ; 00B3F7B0
00C81832 5B pop ebx ; 00B3F7B0

还原寄存器状态

1
00C81833    8BE5            mov esp,ebp
image-20261104232553712
1
00C81835    5D              pop ebp                               ; 00B3F7B0

还原栈底地址

1
00C81836    C3              retn
  • 相当于执行:

    1
    2
    pop eip
    jmp eip

主函数还原堆栈

1
00C8196C    83C4 08         add esp,0x8
image-20261104233449043

堆栈区栈顶之前与未执行函数之前的状态应该保持一致,只不过编写文档的过程中执行了两次,因此堆栈内的数据地址发生了一些变化

函数的调用约定

函数约定就是告诉编译器怎么传递参数,怎么传递返回值,怎么平衡堆栈
__cdecl :
C/C+ + 默认方式,参数从右向左入栈,主调函数负责栈平衡。外平栈

  • 外平栈,在 call 返回后释放堆栈中的参数

    1
    2
    00C81836    C3              retn
    00C8196C 83C4 08 add esp,0x8

__stdcall.
windows API 默认方式,参数从右向左入栈,被调函数负责栈平衡。内平栈

  • 内平栈,在执行 ret 时一并释放堆栈

    1
    ret 8     // 栈顶地址 +8,相当于移动 64 位,即两个 int 数据的大小

__fastcall :
快速调用方式。所渭快速,这种方式选择将参数优先从寄存器传入 ( ECX 和 EDX) ,剩下的参数再从右向左从栈传入。因为栈是位于内存的区域,而寄存器位于 CPU 内,故存取方式快于内存,故其名曰 "__fastcall" 内平栈

CE 内存扫描

字符串扫描

尝试使用 CE 搜索某个程序中的字符串在内存中的位置,这里以自己编写的一个游戏数据管理软件为例

image-20261107125401933

首先在 CE 中附加对应程序的进程,设置搜索类型,输入想要搜索的文本

image-20261107125643782