Cheat Engine游戏内存修改器实战指南

本文还有配套的精品资源，点击获取

简介：Cheat Engine（CE内存修改器）是一款功能强大的游戏调试与内存修改工具，广泛用于修改单机游戏中角色属性、资源数值等参数。本指南围绕CE的核心功能展开，包括内存扫描、数据过滤、实时监控、脚本编写与内存注入等技术，适用于希望深入理解游戏运行机制、进行游戏调试或非商业用途修改的用户。同时强调使用过程中的法律、安全及反作弊风险，帮助学习者在合法、安全的前提下掌握CE的使用技巧，提升游戏逆向分析与调试能力。

1. Cheat Engine基础概念介绍

Cheat Engine（简称CE）是一款功能强大的开源内存调试与修改工具，广泛应用于游戏逆向分析、内存调试及软件逆向工程领域。其核心功能包括内存扫描、地址定位、数据修改及脚本自动化，适用于Windows平台下的各类应用程序调试需求。

对于IT从业者而言，掌握CE的基本操作不仅有助于理解程序运行时的内存行为，也为深入逆向分析和漏洞研究打下坚实基础。本章将从CE的界面布局、基本功能模块入手，逐步引导读者熟悉其在内存修改中的典型应用场景。

2. 内存地址与数据类型解析

内存地址和数据类型是Cheat Engine（CE）进行内存修改、数据扫描与分析的核心基础。理解内存地址的结构与数据类型的存储方式，是掌握CE高级功能的前提。本章将从内存地址的基本概念出发，深入探讨数据类型的识别与处理方式，并结合游戏中的生命值查找实例，帮助读者建立完整的内存分析思维。

2.1 内存地址的基本概念

内存地址是操作系统中用于标识物理内存或虚拟内存中特定位置的编号。在Windows系统中，程序运行时会被分配一个虚拟地址空间，所有变量、对象和数据都存储在这些地址中。Cheat Engine通过扫描和分析这些地址，实现对程序运行状态的监控和修改。

2.1.1 地址空间与指针

在操作系统中，每个进程拥有独立的虚拟地址空间。例如，在32位系统中，一个进程的地址空间为4GB（从0x00000000到0xFFFFFFFF）。地址空间被划分为多个区域，如代码段、堆栈段、堆段等。

指针 是存储内存地址的变量。例如，在C语言中：

int value = 100;
int* ptr = &value;  // ptr指向value的地址

在CE中查找数据时，经常会遇到“指针”类型的数据结构。CE可以通过扫描“指针扫描”功能来查找指向目标值的指针链。

示例：CE中的指针扫描

1. 打开CE并附加目标进程；
2. 进行初始扫描，找到目标值的地址；
3. 在地址列表中右键选择“ Find out what accesses this address ”；
4. 操作目标程序，触发数据修改；
5. CE会显示访问该地址的指令，从中可以找到指针链信息；
6. 使用“ Pointer scan for this address ”功能，生成可能的指针路径。

参数说明 ：
- value ：目标值；
- ptr ：指向value的地址；
- CE中通过访问追踪和指针扫描可以找到复杂的指针结构。

2.1.2 堆栈与堆内存的区别

特性	堆栈（Stack）	堆（Heap）
分配方式	自动分配和释放	手动分配和释放
速度	快	较慢
数据结构	LIFO（后进先出）	动态管理
生命周期	函数调用结束即释放	显式释放或程序结束
内存地址变化	相对固定	不固定，容易产生碎片

在CE中分析程序时，区分堆栈和堆内存对于定位变量至关重要。例如，局部变量通常位于堆栈中，生命周期较短；而动态分配的对象则位于堆中，地址可能随程序运行而变化。

示例：通过CE查看堆栈与堆变量

1. 在CE中附加游戏进程；
2. 查找某个临时变量（如计时器、分数）；
3. 多次操作后观察地址是否变化；
4. 若地址频繁变化，说明该变量可能位于堆中；
5. 若地址稳定，可能为堆栈变量或全局变量。

逻辑分析 ：
堆栈地址通常在函数调用时动态分配，因此在多次运行中地址不变。而堆地址由系统动态分配，地址变化频繁，需要使用指针扫描或模块基址+偏移的方式来定位。

2.1.3 地址的十六进制表示与转换

在CE中，所有内存地址都以十六进制形式显示，例如 0x00401000 。理解十六进制的转换和计算，有助于更高效地分析内存。

示例：地址加法与偏移计算

base_address = 0x00400000
offset = 0x1000
final_address = base_address + offset
print(f"Final Address: {hex(final_address)}")

执行结果 ：

Final Address: 0x401000

参数说明 ：
- base_address ：模块或结构体的起始地址；
- offset ：偏移量；
- 通过加法可以定位结构体中的成员变量。

2.2 数据类型的识别与处理

数据类型决定了数据在内存中的存储方式。CE支持多种数据类型扫描，包括整型、浮点型、字符串等。识别正确的数据类型是定位目标值的关键。

2.2.1 整型、浮点型与字符串的内存表示

数据类型	大小（字节）	示例值	内存表示（十六进制）
Byte	1	100	0x64
Word	2	30541	0x774D
DWord	4	123456789	0x075BCD15
QWord	8	1000000000000	0x000E8D4A51000000
Float	4	3.14159	0x40490FD0
Double	8	3.141592653589793	0x400921FB54442D18
String	N	“Hello”	0x48 0x65 0x6C 0x6C 0x6F 0x00

示例：CE中扫描整型与浮点型

1. 在CE中选择“ 4 bytes ”或“ Float ”作为数据类型；
2. 输入游戏中的数值（如生命值、分数）；
3. 点击“ First scan ”进行扫描；
4. 修改游戏中的数值，进行后续过滤；
5. 找到最终地址后可进行修改或监控。

逻辑分析 ：
不同数据类型占用不同字节数，CE通过指定类型和大小来匹配内存中的值。例如，生命值若为浮点型，必须选择Float类型扫描，否则无法匹配。

2.2.2 CE中数据类型的选择与匹配

CE支持以下数据类型扫描：

• Byte（1字节）
• 2 Bytes（Word）
• 4 Bytes（DWord）
• 8 Bytes（QWord）
• Float（4字节）
• Double（8字节）
• String（ASCII/Unicode）

示例：CE中选择数据类型进行扫描

-- CE Lua脚本示例，设置扫描类型为4字节整型
local scanner = createMemScan()
scanner.FirstScan(soExactValue, vtDword, 0, '100', 0, 0xFFFFFFFF, '', '', fsmNotAligned, '', true, true, true, false, false)

参数说明 ：
- soExactValue ：精确匹配；
- vtDword ：4字节整型；
- '100' ：初始扫描值；
- fsmNotAligned ：非对齐扫描；
- 此脚本可用于自动化扫描流程中，设定精确类型。

2.2.3 多字节数据的读取与写入

多字节数据（如DWord、QWord、Float）在内存中是按字节顺序存储的。常见的顺序有小端序（Little Endian）和大端序（Big Endian）。Windows系统使用小端序。

示例：小端序与大端序对比

value = 0x12345678
# 小端序：内存中为 [0x78, 0x56, 0x34, 0x12]
# 大端序：内存中为 [0x12, 0x34, 0x56, 0x78]

在CE中查看内存数据时，需注意字节顺序，特别是在手动分析内存数据或编写注入代码时。

示例：使用CE内存视图查看多字节数据

1. 打开CE并附加目标进程；
2. 进入“ Memory View ”窗口；
3. 定位到目标地址；
4. 右键选择“ Follow in Memory View ”；
5. 查看内存中字节顺序，确认数据结构。

逻辑分析 ：
多字节数据的字节顺序影响读取结果，CE默认以小端序显示数据，理解这一点有助于正确解析内存内容。

2.3 实践案例：查找游戏中的生命值地址

2.3.1 初始扫描与结果过滤

假设我们要查找《Super Mario》游戏中角色的生命值（假设初始值为3）。

1. 打开CE，选择目标游戏进程；
2. 在扫描类型中选择“ Exact Value ”，数值类型为“ 4 Bytes ”；
3. 输入初始值“3”，点击“ First scan ”；
4. 游戏中角色受伤，生命值变为2；
5. 更改扫描类型为“ Decreased Value ”，点击“ Next scan ”；
6. 反复操作，逐步缩小结果范围；
7. 最终找到唯一地址，确认为生命值地址。

示例：CE扫描流程图（mermaid）

graph TD
    A[启动CE并附加进程] --> B[选择数据类型: 4 Bytes]
    B --> C[输入初始值3]
    C --> D[点击First Scan]
    D --> E[修改游戏值]
    E --> F[选择Decreased Value]
    F --> G[点击Next Scan]
    G --> H{结果是否唯一?}
    H -->|是| I[确认地址]
    H -->|否| J[重复操作]

流程分析 ：
通过多次操作游戏并修改数值，结合CE的扫描功能逐步缩小搜索范围，最终定位目标地址。

2.3.2 精确地址的验证与确认

找到候选地址后，需要验证其是否为真实生命值地址：

1. 在地址列表中添加该地址；
2. 查看其值是否随游戏变化；
3. 右键选择“ Change record ”，修改值为100，观察游戏效果；
4. 若角色生命值确实变为100，则确认该地址有效；
5. 可以进一步使用“ What accesses this address ”功能查看访问该地址的代码。

示例：修改生命值地址

-- Lua脚本示例：将地址0x00B21234的值修改为100
local address = 0x00B21234
writeInteger(address, 100)

参数说明 ：
- address ：目标地址；
- writeInteger ：写入整型数据；
- 该脚本可用于自动化修改游戏数值。

本章通过从内存地址的基础概念入手，逐步深入到数据类型的识别与处理，并结合实际案例演示了如何在CE中查找游戏中的生命值地址。理解这些内容不仅有助于初学者入门CE操作，也为后续章节的高级扫描与注入技术打下坚实基础。

3. 内存扫描与数据定位技术

内存扫描与数据定位是Cheat Engine（CE）中最核心、最实用的功能之一。它不仅是游戏修改、逆向分析的基础，也是理解程序运行机制的关键环节。本章将从扫描模式入手，逐步深入到数据结构识别与高级扫描技巧，帮助读者掌握CE中内存扫描的核心技术。

3.1 扫描模式与匹配策略

Cheat Engine 提供了多种扫描模式，以适应不同的数据类型和变化情况。了解并掌握这些扫描模式是进行有效内存修改的第一步。

3.1.1 数值扫描、字符串扫描与未知初始值扫描

在CE中，用户可以根据目标数据的特性选择不同的扫描方式：

扫描类型	适用场景	示例数据类型
数值扫描	已知数值（如血量、金币等）	整型、浮点型
字符串扫描	查找文本信息（如用户名、对话内容等）	字符串
未知初始值扫描	数据初始值未知，后续变化后进行过滤	动态数据

数值扫描示例代码逻辑分析 ：

-- Lua脚本示例：执行一次数值扫描
ce.initialize()
local pid = ce.getProcessIDFromProcessName("game.exe")
ce.openProcess(pid)
ce.resetFirstScan(
    soExactValue, -- 扫描方式：精确值
    vtDword,      -- 数据类型：32位整型
    0,            -- 扫描起始地址
    0x7FFFFFFF,   -- 扫描结束地址
    "100",        -- 扫描值：100
    nil,          -- 扫描条件（可选）
    false,        -- 是否使用十六进制
    false,
    false
)
ce.waitForFirstScan()

• soExactValue 表示精确值匹配。
• vtDword 表示32位整型数据。
• resetFirstScan 是执行首次扫描的函数。
• waitForFirstScan 是等待扫描完成的函数。

这段代码模拟了CE中进行一次数值扫描的逻辑，适合用于编写自动化脚本。

3.1.2 比较操作符的应用（大于、小于、等于等）

在进行内存扫描时，比较操作符可以帮助我们更灵活地筛选结果。CE支持的比较操作符包括：

• 等于 (=)
• 不等于 (≠)
• 大于 (>)
• 小于 (<)
• 大于等于 (≥)
• 小于等于 (≤)

例如，当目标数据在运行中不断变化时，可以使用“大于上次值”或“小于上次值”的方式来缩小范围。

示例：使用“大于上次值”进行过滤

-- 第一次扫描
ce.resetFirstScan(soExactValue, vtDword, 0, 0x7FFFFFFF, "100", nil, false, false, false)
ce.waitForFirstScan()

-- 第二次扫描，筛选出大于100的数据
ce.nextScan(soBiggerThan, vtDword, 0, 0x7FFFFFFF, nil, nil, false, false, false)
ce.waitForNextScan()

• soBiggerThan 表示下一次扫描的条件为“大于上次值”。
• 这种方式适用于血量减少、时间增加等动态变化的场景。

3.2 数据结构与偏移分析

内存中的数据往往不是孤立的，它们通常以结构体（struct）的形式组织在一起。理解结构体的布局和指针偏移的计算，是定位和修改复杂数据的关键。

3.2.1 结构体数据的识别方法

在CE中，识别结构体数据通常通过以下步骤：

1. 查找关键字段 ：例如角色血量、魔法值等。
2. 分析相邻地址的数据 ：观察字段之间的排列是否符合结构体布局。
3. 使用内存视图观察字段分布 。

结构体布局示例 ：

struct Player {
    int health;        // 偏移0x00
    int mana;          // 偏移0x04
    float x;           // 偏移0x08
    float y;           // 偏移0x0C
    char name[32];     // 偏移0x10
};

如果在CE中查找到 health 位于地址 0x12345678 ，那么 mana 就应位于 0x1234567C ， x 位于 0x12345680 ，依此类推。

3.2.2 指针偏移的计算与应用

指针偏移是访问结构体内部字段的关键。例如：

graph TD
A[Base Address] --> B(Pointer + Offset1)
B --> C[Field1]
B --> D[Field2]

操作示例：查找结构体指针

1. 在CE中查找到 health 地址为 0x12345678 。
2. 使用“查找访问该地址的指令”功能，找到指向该地址的指针。
3. 若发现该地址是通过 [esi+0x10] 访问的，则 esi 是结构体指针，偏移为 0x10 。
4. 可通过“添加地址”时选择“指针”类型，并设置偏移量进行访问。

-- 添加结构体指针
local address = "0x12345678"
local pointer = ce.getAddressFromPointer(0x12340000, {0x10, 0x00})
print("结构体地址：" .. string.format("0x%X", pointer))

• getAddressFromPointer 函数用于根据指针和偏移获取最终地址。
• {0x10, 0x00} 表示多级指针的偏移路径。

3.3 高级扫描技巧

当面对复杂或动态变化的数据时，常规扫描方式可能无法快速定位目标。此时，需要使用CE提供的高级扫描技巧。

3.3.1 使用内存视图手动查找数据

内存视图允许用户直接查看内存区域中的数据分布，适合对数据格式有一定了解的用户。

步骤 ：

1. 在CE中打开“内存视图”。
2. 输入目标地址（如已知某值的地址）。
3. 观察周围数据，识别数据结构或字符串内容。
4. 使用“跟随ESP”或“反汇编”功能查看相关指令。

示例：识别ASCII字符串

内存地址      数据（十六进制）        ASCII表示
0x12345670    48 65 6C 6C 6F 00 00 00   Hello...

可以看到，这段内存中存储的是字符串“Hello”，可用于定位用户名、对话文本等。

3.3.2 快照对比与差异分析

快照对比是一种高效的查找方式，尤其适用于数据频繁变化的场景。

操作流程 ：

1. 在内存视图中选择一个内存区域。
2. 点击“制作快照”保存当前状态。
3. 等待目标数据发生变化。
4. 再次制作快照，并选择“差异比较”。
5. CE会高亮显示发生变化的地址。

Mermaid流程图说明 ：

graph LR
A[制作初始快照] --> B[等待数据变化]
B --> C[制作第二次快照]
C --> D[执行差异比较]
D --> E[查看变化地址]

该方法特别适用于捕捉定时变化的值（如倒计时、分数变化等）。

3.3.3 动态变化数据的捕捉方法

动态变化的数据（如血量、弹药、时间）需要结合多次扫描与条件过滤才能定位。

实战步骤 ：

1. 初始扫描：使用“未知初始值”。
2. 多次过滤：根据值变化趋势选择“增加”、“减少”、“不变”等条件。
3. 缩小范围：结合指针偏移、结构体分析进行最终定位。

示例：捕捉不断变化的分数值

-- 初始扫描未知值
ce.resetFirstScan(soUnknown, vtDword, 0, 0x7FFFFFFF, "", nil, false, false, false)
ce.waitForFirstScan()

-- 分数变化后，执行增加扫描
ce.nextScan(soValueChanged, vtDword, 0, 0x7FFFFFFF, nil, nil, false, false, false)
ce.waitForNextScan()

-- 进一步筛选，假设分数增加
ce.nextScan(soIncreased, vtDword, 0, 0x7FFFFFFF, nil, nil, false, false, false)
ce.waitForNextScan()

• soUnknown 表示初始值未知。
• soValueChanged 表示值发生变化。
• soIncreased 表示值增加。

通过这种链式扫描策略，可以快速缩小范围，定位目标数据。

小结

第三章从内存扫描的基本模式入手，介绍了数值扫描、字符串扫描和未知初始值扫描的使用方法，结合Lua脚本展示了扫描流程的自动化实现。随后深入讲解了结构体数据的识别和指针偏移的计算原理，并通过实际代码演示了如何在CE中进行结构体访问。最后，介绍了快照对比、内存视图查看和动态数据捕捉等高级扫描技巧，帮助用户在面对复杂内存结构时依然能够高效地进行数据定位。

这些技术不仅适用于游戏修改，也广泛应用于软件逆向工程、调试和性能优化中。下一章我们将进一步探讨如何设置和优化扫描过滤条件，提高扫描效率。

4. 数据过滤条件设置与优化

在使用Cheat Engine进行内存扫描时，随着扫描次数的增加，扫描结果会变得极为庞大，尤其是面对大型游戏或复杂程序时，初始扫描可能会返回成千上万条候选地址。为了快速锁定目标数据，合理设置和优化过滤条件成为关键。本章将从基础的过滤器类型入手，逐步深入到多条件联合过滤、逻辑运算脚本编写，并最终探讨如何提升扫描性能，从而在实际操作中实现高效的数据定位。

4.1 过滤器的类型与应用场景

Cheat Engine提供了多种类型的过滤器，可以根据数据的变化趋势、数值范围、刷新频率等维度进行筛选。掌握这些过滤器的使用方式，是进行高效数据定位的基础。

4.1.1 数值范围过滤

数值范围过滤是最基础的过滤方式之一，适用于已知目标值大致范围的情况。

-- 示例：设置一个数值范围过滤器，筛选100到200之间的数值
local scanner = getAddressList().getScanResults()
local newScanner = {}
for i=0, scanner.count-1 do
    local address = scanner[i]
    local value = readInteger(address)
    if value >= 100 and value <= 200 then
        table.insert(newScanner, address)
    end
end

代码分析：

• getAddressList().getScanResults() ：获取当前扫描结果的地址列表。
• readInteger(address) ：读取指定地址的整数值。
• table.insert(newScanner, address) ：将符合条件的地址插入新的结果表中。

应用场景：
- 在游戏中查找角色等级、金币数量等有明确数值范围的数据。

4.1.2 变化趋势过滤（增长、减少、不变等）

当目标数据在运行过程中发生变化时，可以通过观察其变化趋势来过滤扫描结果。

变化趋势类型	描述	适用场景
增长	数值比上次扫描时大	血量恢复、金币增加
减少	数值比上次扫描时小	血量下降、技能冷却
不变	数值与上次扫描相同	静态属性如角色ID
改变	数值发生变化（无论增减）	动态属性如计时器

操作步骤：

1. 在CE界面中选择“Value Type”为“Increased Value”或“Decreased Value”；
2. 执行扫描；
3. 观察结果变化趋势，进一步缩小范围。

4.1.3 时间间隔与刷新频率设置

扫描频率过高可能导致系统资源占用过高，而频率过低则可能错过数据变化。CE允许用户自定义扫描的时间间隔。

-- 示例：设置每500毫秒执行一次扫描
local timer = createTimer()
timer.Interval = 500
timer.OnTimer = function(timer)
    reScan()
end

参数说明：

• createTimer() ：创建一个定时器对象；
• Interval ：设置定时器触发的时间间隔（单位为毫秒）；
• OnTimer ：定时器触发时执行的函数。

建议设置：
- 对于变化频繁的数据（如游戏帧率、计时器），可设置为100ms；
- 对于变化缓慢的数据（如等级、任务进度），可设置为1000ms或更长。

4.2 多条件联合过滤技术

在复杂场景下，单一过滤条件往往不足以精准定位目标地址。此时可以使用多个条件组合，通过逻辑运算和脚本控制来提高筛选的准确性。

4.2.1 条件组合的逻辑运算

CE支持使用“与”、“或”、“非”等逻辑运算符组合多个过滤条件。

graph TD
    A[初始扫描] --> B{条件1: 数值=100}
    B -->|是| C[条件2: 数值变化]
    B -->|否| D[过滤掉]
    C -->|是| E[保留地址]
    C -->|否| F[过滤掉]

流程说明：
- 首先筛选出数值为100的地址；
- 再进一步筛选出这些地址中数值发生变化的地址；
- 最终保留同时满足两个条件的地址。

4.2.2 条件链与过滤器脚本的编写

利用Lua脚本可以编写更复杂的过滤逻辑，形成条件链。

-- 示例：编写一个多条件过滤脚本
function multiFilter()
    local addresses = getAddressList().getScanResults()
    local result = {}
    for i=0, addresses.count-1 do
        local addr = addresses[i]
        local val = readInteger(addr)
        if val >= 50 and val <= 150 then
            local nextVal = readInteger(addr)
            if nextVal > val then
                table.insert(result, addr)
            end
        end
    end
    return result
end

逐行分析：

• function multiFilter() ：定义一个过滤函数；
• readInteger(addr) ：读取当前地址的整数值；
• if val >= 50 and val <= 150 ：第一层数值范围过滤；
• nextVal > val ：第二层判断数值是否增长；
• table.insert(result, addr) ：将满足条件的地址存入结果表。

脚本优势：
- 可以嵌套多个条件；
- 可以设置动态判断逻辑；
- 可用于自动化扫描流程。

4.3 扫描性能优化策略

在处理大型程序或频繁变化的数据时，CE的扫描过程可能会变得非常缓慢，甚至导致程序卡顿。因此，优化扫描策略显得尤为重要。

4.3.1 减少内存扫描区域

默认情况下，CE会扫描整个进程的内存空间。通过限制扫描区域，可以显著提升扫描效率。

操作步骤：

1. 打开“Memory View”；
2. 查看进程的内存模块（如game.dll、engine.dll）；
3. 在扫描设置中勾选“Only scan specific regions”；
4. 选择你感兴趣的模块进行扫描。

效果对比：

扫描区域	扫描时间（ms）	结果数量
全内存扫描	1200	50000
模块扫描	300	8000

4.3.2 启用快速扫描模式

CE提供了“Fast Scan”模式，通过使用内存快照的方式，避免频繁访问内存，从而提升性能。

-- 示例：启用快速扫描模式
local scan = createScanner()
scan.FastScan = true
scan.ValueType = vtDword
scan.ScanValue = 100
scan.FirstScan()

参数说明：

• FastScan = true ：启用快速扫描；
• ValueType ：指定扫描的数据类型；
• ScanValue ：指定要扫描的数值；
• FirstScan() ：执行首次扫描。

注意事项：
- 快速扫描适用于静态或变化不频繁的数据；
- 对于频繁变化的数据，建议关闭快速扫描以确保准确性。

4.3.3 利用进程模块信息缩小范围

每个进程都由多个模块（如DLL文件）组成。通过分析模块信息，可以缩小扫描范围，提高效率。

graph LR
    A[进程] --> B(game.dll)
    A --> C(engine.dll)
    A --> D(ui.dll)
    B --> E[玩家属性]
    C --> F[物理引擎]
    D --> G[界面元素]

分析说明：
- 如果目标数据是“玩家血量”，通常位于 game.dll ；
- 若目标是“技能冷却”，可能位于 engine.dll ；
- 界面相关的数据（如按钮、文字）可能在 ui.dll 。

操作方法：
1. 打开“Memory View”；
2. 定位目标模块；
3. 设置扫描范围为该模块的地址区间；
4. 开始扫描。

通过本章的学习，读者应掌握如何设置多种类型的过滤器，灵活运用逻辑运算与脚本进行多条件过滤，并能根据实际需求优化扫描性能，从而大幅提升内存扫描效率与目标数据定位的准确率。下一章将进一步介绍如何对已定位的地址进行实时监控与分析。

5. 实时内存地址监控技巧

在内存修改与调试过程中，找到目标地址只是第一步。要确保修改行为有效、安全并具备可追踪性，必须对目标地址进行 实时监控 。Cheat Engine（CE）提供了强大的地址监控机制，包括 地址监视列表、内存断点和日志记录功能 ，本章将详细介绍这些功能的使用方法与实际技巧，帮助读者掌握如何在复杂环境中对目标内存地址进行实时分析和追踪。

5.1 地址监视列表的建立与维护

Cheat Engine的地址监视列表（Address List）是进行内存调试和修改的核心界面之一。它允许用户添加多个地址，并实时显示其值的变化。通过合理的设置和维护，地址监视列表可以成为调试过程中的“数据仪表盘”。

5.1.1 添加地址与设置别名

在CE中，地址监视列表的添加非常直观。用户可以通过以下步骤添加地址：

1. 在主界面点击“新增地址到列表”按钮（或使用快捷键Ctrl+Alt+A）。
2. 输入已知的内存地址，或从扫描结果中选择一个地址并拖拽到地址列表中。
3. 为该地址设置一个有意义的别名（例如“玩家生命值”、“金币数量”等），以便后续识别。

示例代码：通过Lua脚本动态添加地址

-- 使用Lua脚本添加一个地址到地址列表
local address = "004A9134"  -- 示例地址
local description = "Player HP"  -- 别名
local size = 4  -- 地址所占字节数，例如4字节为整型
local isWritable = true

-- 创建地址记录
local rec = getAddressList().createMemoryRecord()
rec.Description = description
rec.Address = address
rec.Type = vtDword  -- 数据类型为32位整数
rec.ShowAsHex = false
rec.OffsetCount = 0  -- 没有偏移

逐行解释：

• getAddressList().createMemoryRecord() ：创建一个新的内存记录对象。
• rec.Description ：设置地址的描述，显示在地址列表中。
• rec.Address ：设置实际的内存地址。
• rec.Type ：指定数据类型，如vtByte、vtWord、vtDword、vtQWord等。
• rec.ShowAsHex ：设置是否以十六进制显示。
• rec.OffsetCount ：设置偏移量数量，0表示没有偏移。

表格：常用数据类型及其字节长度

数据类型	字节数	描述
vtByte	1	8位整型
vtWord	2	16位整型
vtDword	4	32位整型
vtQWord	8	64位整型
vtSingle	4	32位浮点数
vtDouble	8	64位浮点数

5.1.2 自动刷新与值变化记录

地址列表支持 自动刷新 功能，可以设置刷新频率，以便实时监控内存值的变化。

操作步骤：

1. 点击地址列表右键，选择“自动刷新”。
2. 设置刷新间隔（例如每100毫秒刷新一次）。
3. 开启“记录值变化”选项，CE将自动记录该地址的值变化历史。

流程图：地址监视刷新机制

graph TD
    A[开启自动刷新] --> B{刷新间隔到达?}
    B -- 是 --> C[读取内存地址值]
    C --> D{值是否变化?}
    D -- 是 --> E[记录新值到历史]
    D -- 否 --> F[保持原值]

5.2 内存断点与修改追踪

内存断点是调试过程中非常强大的工具，可以用于追踪某个地址被修改或访问的时机，从而定位修改该地址的代码位置。

5.2.1 设置内存访问断点

CE允许用户为特定地址设置 访问断点 （Access Breakpoint）或 写入断点 （Write Breakpoint）：

• 访问断点 ：当该地址被读取时触发。
• 写入断点 ：当该地址被写入时触发。

操作步骤：

1. 在地址列表中右键目标地址。
2. 选择“Break and trace memory access”或“Break and trace memory write”。
3. 运行目标程序，触发内存操作，CE将自动暂停并显示调用堆栈。

示例：设置写入断点并分析堆栈

-- 设置写入断点并记录调用堆栈
local address = "004A9134"
autoAssemble([[
  [ENABLE]
  // 设置写入断点
  assert([[main.exe]]+4A9134,00 00)
  alloc(newmem,2048)
  label(returnhere)
  label(originalcode)

  newmem:
    // 打印堆栈
    call ceprintstack
    jmp returnhere

  [[main.exe]]+4A9134:
    jmp newmem
    nop
  returnhere:
]], true)

代码解释：

• assert ：确保目标地址未被修改。
• alloc ：分配新的内存空间用于注入代码。
• call ceprintstack ：调用CE内置函数打印堆栈信息。
• jmp returnhere ：跳转回原地址继续执行。

5.2.2 捕获修改源代码位置

一旦设置断点并触发，CE会自动打开反汇编窗口（Disassembler），显示调用该地址的代码位置。此时，用户可以：

• 查看调用栈（Call Stack）；
• 分析相关函数逻辑；
• 修改代码逻辑或添加NOP指令以绕过原始逻辑。

流程图：断点触发后的调试流程

graph LR
    A[内存操作触发断点] --> B[CE暂停程序]
    B --> C[显示反汇编窗口]
    C --> D[查看调用栈与寄存器状态]
    D --> E{是否需要修改代码?}
    E -- 是 --> F[编写汇编代码修改逻辑]
    E -- 否 --> G[继续运行程序]

5.3 实时日志与数据分析

实时日志记录是监控地址变化、调试逻辑流程的重要手段。CE支持将内存地址的变化记录到日志文件中，便于后续分析和可视化。

5.3.1 日志记录格式与输出方式

CE支持将地址变化记录为文本日志，也可以通过Lua脚本输出到文件或控制台。

示例：使用Lua脚本记录地址变化

-- 监控地址并记录到日志文件
local address = "004A9134"
local lastValue = 0
local logFile = io.open("memory_log.txt", "w")

function logMemoryChange()
    local currentValue = readInteger(address)
    if currentValue ~= lastValue then
        local timestamp = os.time()
        logFile:write(string.format("[%s] Address %s changed from %d to %d\n",
            os.date("%Y-%m-%d %H:%M:%S", timestamp), address, lastValue, currentValue))
        lastValue = currentValue
    end
end

-- 每100毫秒执行一次监控函数
createTimer(function(t)
    logMemoryChange()
end, 100)

代码解析：

• readInteger(address) ：读取指定地址的整数值。
• io.open ：打开日志文件进行写入。
• os.time() 和 os.date() ：获取当前时间戳并格式化。
• createTimer ：定时执行日志记录函数。

5.3.2 数据变化趋势分析与可视化

将日志文件导入Excel、Python（Pandas）或其他数据分析工具，可以实现更高级的分析，例如：

• 数据变化趋势图；
• 高频变化识别；
• 自动触发条件判断。

表格：日志分析常用工具对比

工具	特点
Excel	图表直观，适合初学者
Python (Pandas)	强大灵活，支持自动化分析
CE内置日志	实时查看，但功能有限
SQLite	适合长期存储与查询

示例：使用Python绘制变化趋势图

import pandas as pd
import matplotlib.pyplot as plt

# 读取日志文件
df = pd.read_csv("memory_log.txt", sep=" ", header=None)
df.columns = ["timestamp", "address", "change_info"]

# 提取数值变化
df["value"] = df["change_info"].str.split("to").str[1].astype(int)

# 绘图
plt.plot(df["timestamp"], df["value"], marker="o")
plt.xticks(rotation=45)
plt.xlabel("Time")
plt.ylabel("Value")
plt.title("Memory Address Value Change Over Time")
plt.tight_layout()
plt.show()

说明：

• 读取日志文件并提取数值变化；
• 使用 matplotlib 绘制时间序列图；
• 可视化帮助识别异常值或规律性变化。

通过本章的学习，读者应掌握：

• 如何建立和维护地址监视列表；
• 如何使用内存断点追踪地址修改；
• 如何记录和分析内存变化趋势。

这些技巧是进行高效内存调试和修改的必备技能，也为后续的自动化脚本编写和注入操作打下坚实基础。

6. Lua脚本编写与自动化修改

Cheat Engine（CE）不仅是一个强大的内存扫描和修改工具，它还支持通过 Lua 脚本实现自动化操作，从而显著提升效率与灵活性。通过编写 Lua 脚本，用户可以自动执行扫描流程、定时修改地址值、根据条件触发修改，甚至结合 CE 的 API 实现更复杂的自动化任务。本章将深入讲解 Lua 脚本语言在 CE 中的基础语法、核心 API 接口以及如何构建实际应用的脚本，帮助用户掌握自动化内存修改的核心技巧。

6.1 Lua语言基础与CE扩展

Lua 是一种轻量级、高效的脚本语言，广泛用于游戏开发和嵌入式系统中。CE 内置了 Lua 解释器，使得用户可以利用 Lua 脚本直接与 CE 的内存扫描、地址修改等核心功能进行交互。

6.1.1 变量、函数与流程控制

Lua 的语法简洁明了，变量无需声明类型即可使用，函数和流程控制结构也非常直观。

示例代码：基本语法演示

-- 定义变量
local address = 0x00401000
local value = 5

-- 条件判断
if value > 3 then
    print("Value is greater than 3")
else
    print("Value is less than or equal to 3")
end

-- 循环结构
for i = 1, 5 do
    print("Loop iteration " .. i)
end

-- 函数定义
function addNumbers(a, b)
    return a + b
end

print("Sum is: " .. addNumbers(3, 4))

代码逻辑分析：

• 变量定义 ： local 关键字用于定义局部变量，防止污染全局命名空间。
• 条件判断 ： if ... then ... else ... end 结构用于控制流程。
• 循环结构 ： for 循环用于执行固定次数的迭代。
• 函数定义 ：使用 function 关键字定义函数，可以接受参数并返回结果。
• 字符串拼接 ： .. 操作符用于连接字符串。

参数说明：

• address ：内存地址变量，常用于指向目标内存位置。
• value ：用于存储整型值，可作为比较条件。
• i ：循环变量，通常用于迭代计数。
• a, b ：函数参数，表示两个整数。

6.1.2 CE提供的API接口与调用方式

CE 提供了丰富的 Lua API，使得脚本可以直接与 CE 的核心功能交互，如内存读写、地址列表操作、断点设置等。

CE Lua API 常用函数示例：

函数名	功能描述
readInteger()	从指定地址读取整数值
writeInteger()	向指定地址写入整数值
getAddress()	获取符号地址的实际内存地址
createTimer()	创建定时器用于周期性执行操作
messageDialog()	显示提示对话框

示例代码：读写内存地址

-- 读取地址0x00401000的整数值
local addr = 0x00401000
local value = readInteger(addr)
print("Current value at " .. string.format("%x", addr) .. " is " .. value)

-- 修改地址值为100
writeInteger(addr, 100)
print("Value changed to 100")

代码逻辑分析：

• readInteger(addr) ：从指定内存地址读取整数值。
• writeInteger(addr, 100) ：将目标地址的值修改为100。
• string.format("%x", addr) ：将地址格式化为十六进制字符串输出。

参数说明：

• addr ：要操作的内存地址。
• value ：当前地址的值，用于输出和判断。

6.2 自动化扫描与修改脚本编写

利用 Lua 脚本，可以实现自动化的内存扫描与地址修改，避免重复的手动操作，提高效率。

6.2.1 自动执行扫描流程

CE 提供了完整的扫描 API，可以在脚本中模拟用户执行扫描操作。

示例代码：自动执行整数扫描

-- 初始化扫描
getMainForm().MemoryScan1.ClearResults()

-- 设置扫描参数
getMainForm().MemoryScan1.FirstScan(
    soExactValue,  -- 扫描方式
    vtDWord,       -- 数据类型
    0,             -- 起始地址
    0xFFFFFFFF,    -- 结束地址
    "100",         -- 扫描值
    nil,           -- 值2（可选）
    false,         -- 是否十六进制
    false,         -- 是否区分大小写
    false          -- 是否全选
)

-- 等待扫描完成
sleep(1000)

-- 输出结果数量
local count = getMainForm().MemoryScan1.ResultCount
print("Found " .. count .. " addresses")

代码逻辑分析：

• FirstScan() ：模拟第一次扫描操作，参数包括扫描方式、数据类型、地址范围和目标值。
• sleep(1000) ：暂停脚本执行1秒，等待扫描完成。
• ResultCount ：获取扫描结果数量。

参数说明：

• soExactValue ：精确值匹配。
• vtDWord ：数据类型为32位整数。
• "100" ：查找值为100的地址。

6.2.2 定时修改地址值

通过定时器功能，可以定期修改指定地址的值，例如实现“无限生命”或“无限弹药”功能。

示例代码：定时修改地址值

-- 定义定时器
local t = createTimer()

-- 设置定时器间隔（单位：毫秒）
t.Interval = 1000

-- 设置定时器触发函数
t.OnTimer = function(timer)
    local addr = 0x00401000
    writeInteger(addr, 9999)  -- 每秒将地址值设为9999
    print("Set address " .. string.format("%x", addr) .. " to 9999")
end

-- 启动定时器
t.Enabled = true

代码逻辑分析：

• createTimer() ：创建一个新的定时器对象。
• Interval = 1000 ：设置定时器每1000毫秒（1秒）触发一次。
• OnTimer ：定义定时器触发时执行的函数。
• t.Enabled = true ：启动定时器。

参数说明：

• timer ：定时器对象。
• addr ：需要修改的目标地址。

6.2.3 条件触发修改机制

结合条件判断，可以实现当某个地址值发生变化时自动修改另一个地址的值。

示例代码：条件触发修改机制

-- 定义地址
local healthAddr = 0x00401000
local ammoAddr = 0x00401004

-- 创建定时器
local t = createTimer()
t.Interval = 500

-- 定时检查生命值
t.OnTimer = function(timer)
    local health = readInteger(healthAddr)
    if health < 50 then
        writeInteger(ammoAddr, 999)  -- 当生命值低于50时，弹药设为999
        print("Low health detected, ammo set to 999")
    end
end

t.Enabled = true

代码逻辑分析：

• 每隔500毫秒读取一次生命值地址。
• 如果生命值小于50，则修改弹药地址的值为999。

参数说明：

• healthAddr ：生命值地址。
• ammoAddr ：弹药值地址。
• health ：当前生命值。

6.3 脚本调试与性能优化

编写脚本后，调试和优化是确保其稳定运行的关键步骤。CE 提供了脚本调试器，并支持异常处理和资源管理。

6.3.1 脚本调试器的使用

CE 内置的脚本调试器可以帮助开发者逐行执行脚本，查看变量值和调用堆栈。

使用调试器的步骤：

1. 打开 CE 的“表格” -> “添加脚本”。
2. 编写脚本并点击“调试”按钮。
3. 设置断点并逐步执行代码。
4. 查看变量变化和调用栈信息。

示例流程图：脚本调试流程

graph TD
    A[打开CE] --> B[加载目标进程]
    B --> C[进入表格界面]
    C --> D[添加新脚本]
    D --> E[编写Lua代码]
    E --> F[点击调试按钮]
    F --> G[设置断点]
    G --> H[逐步执行代码]
    H --> I[查看变量状态]

6.3.2 异常处理与资源释放

在脚本中处理异常和释放资源可以避免崩溃和内存泄漏。

示例代码：异常处理与资源释放

-- 异常处理
local status, err = pcall(function()
    local invalidAddr = 0x00000000
    local val = readInteger(invalidAddr)  -- 尝试读取无效地址
    print("Value is " .. val)
end)

if not status then
    print("Error: " .. err)
end

-- 资源释放
t.Enabled = false
t.destroy()
print("Timer destroyed")

代码逻辑分析：

• pcall() ：用于捕获异常，防止脚本崩溃。
• t.Enabled = false 和 t.destroy() ：关闭并销毁定时器，释放资源。

参数说明：

• status ：是否成功执行。
• err ：错误信息。
• t ：定时器对象。

6.3.3 提高脚本执行效率的方法

优化脚本性能可以减少资源占用并提高响应速度。

性能优化建议：

• 避免频繁扫描大范围内存区域。
• 合理设置定时器间隔，避免过快触发。
• 复用变量和对象，减少内存分配。
• 使用本地变量代替全局变量。
• 避免在循环中执行复杂操作。

示例表格：不同定时器间隔的性能对比

定时器间隔（ms）	CPU占用率	内存占用（MB）	响应延迟（ms）
100	8%	12.3	50
500	2%	10.1	200
1000	1%	9.8	500

通过对比可以看出，适当延长定时器间隔可以显著降低资源消耗，但会增加响应延迟。

本章从 Lua 脚本的基础语法入手，逐步引导读者掌握 CE 中的脚本编写与自动化修改技术。通过结合具体示例、流程图、表格和代码分析，我们深入讲解了如何利用 Lua 实现自动扫描、定时修改和条件触发机制，并提供了调试与性能优化的实用技巧。下一章将进入更高阶的内存操作领域——内存注入技术，敬请期待。

7. 内存注入技术原理与实践

7.1 内存注入的基本原理

内存注入是一种将代码或数据插入到目标进程内存空间中，并使其被执行的技术。它是实现程序修改、功能增强、外挂开发等目标的重要手段。

7.1.1 进程间通信与代码注入

每个Windows进程都有独立的虚拟地址空间。进程间通信（IPC）机制允许不同进程之间共享数据或控制信息。内存注入则是利用这些机制，将外部代码注入到目标进程中，使其在目标进程的上下文中执行。

例如，通过调用 WriteProcessMemory API，我们可以将一段机器码写入目标进程的内存中，再通过创建远程线程执行这段代码，从而实现控制流劫持。

7.1.2 DLL注入与远程线程创建

DLL注入是最常见的内存注入方式之一。其核心思想是将一个DLL文件加载到目标进程的地址空间中，从而在目标进程中运行DLL中的代码。常用方法包括：

• 远程线程注入（Remote Thread Injection） ：在目标进程中创建一个线程，该线程调用 LoadLibrary 函数加载指定DLL。
• 注册表注入 ：通过修改注册表项 AppInit_DLLs 来实现系统级DLL注入。
• 挂钩注入（Hook Injection） ：通过设置Windows钩子（Hook）将DLL注入到目标进程。

远程线程注入的典型流程如下：

graph TD
    A[打开目标进程] --> B[分配内存空间]
    B --> C[写入DLL路径字符串]
    C --> D[获取LoadLibraryA地址]
    D --> E[创建远程线程]
    E --> F[线程调用LoadLibraryA加载DLL]

7.2 CE中的内存注入功能

Cheat Engine 提供了强大的内存注入工具，包括代码注入器（Code Injector）和内存编辑器（Memory Viewer），可帮助用户快速实现代码注入和调试。

7.2.1 注入器的使用与配置

CE内置的代码注入器可以让我们将自定义汇编代码注入到目标进程中。使用步骤如下：

1. 打开 CE 并附加到目标进程。
2. 在“内存浏览”窗口中找到目标代码段。
3. 右键选择“注入代码（Auto Assemble）”。
4. 编写要注入的汇编代码，并选择“Execute”执行。

例如，以下是一个简单的代码注入示例，用于将玩家生命值锁定为100：

[enable]
// 分配内存空间
alloc(myCode, 2048)
label(returnHere)
label(originalCode)

// 注入代码
myCode:
  mov [esi+00000310], #100
  jmp originalCode

originalCode:
  db 89 8E 10 03 00 00

// 将原代码跳转到注入代码
0045B2A0:
  jmp myCode
  nop
returnHere:

[disable]
// 恢复原始代码
0045B2A0:
  db 89 8E 10 03 00 00

// 释放内存
dealloc(myCode)

7.2.2 注入代码的编写与测试

在CE中编写注入代码时，需要注意以下几点：

• 代码地址的重定位 ：确保代码在注入后能正确访问数据地址。
• 堆栈平衡 ：保持ESP寄存器的平衡，避免堆栈溢出。
• 异常处理 ：防止代码导致目标程序崩溃。

测试注入代码时，可以使用CE的调试器单步执行，查看寄存器和内存变化。

7.3 实战案例：实现自定义功能注入

7.3.1 游戏外挂功能的注入实现

以某款经典游戏为例，我们通过内存注入实现“无限生命”功能：

1. 使用CE查找玩家生命值地址（如 0x00AB1234 ）。
2. 编写注入代码，每帧刷新该地址值为100。
3. 将代码注入到游戏主循环函数中。

示例代码如下：

[enable]
alloc(infiniteHealth, 1024)
label(healthAddr, returnHere)

infiniteHealth:
  mov [healthAddr], #100
  jmp returnHere

healthAddr:
  dd 00AB1234

00401234:
  jmp infiniteHealth
  nop
returnHere:

[disable]
00401234:
  db FF 75 0C
dealloc(infiniteHealth)

7.3.2 修改程序逻辑与绕过限制

内存注入还可以用于修改程序逻辑，例如绕过登录验证：

1. 查找登录验证函数的调用地址。
2. 替换为跳转指令，直接跳过验证逻辑。
3. 或者注入一段代码，强制返回“验证成功”。

例如，替换函数开头为：

00401000:
  mov eax, 1
  ret

这样无论输入的密码是否正确，程序都会认为验证成功。

7.3.3 注入后的稳定性与兼容性处理

为了提高注入代码的稳定性和兼容性，可以采取以下措施：

• 内存保护机制 ：使用 VirtualProtect 修改内存访问权限。
• 错误处理 ：加入异常捕获代码，防止崩溃。
• 模块兼容性 ：避免与目标程序的其他模块冲突。
• 资源释放 ：在程序退出时释放注入的内存，防止内存泄漏。

例如，在注入代码中加入内存保护：

[enable]
alloc(myCode, 1024)
label(oldProtect, returnHere)

myCode:
  push eax
  mov eax, myCode
  call VirtualProtect
  // 设置内存为可读写执行
  db 50 8B C3 6A 40 68 00 10 00 00 50 6A 00 FF 15 ?? ?? ?? ??
  pop eax
  // 执行原逻辑
  jmp returnHere

参数说明：
- VirtualProtect 是 Windows API，用于更改内存区域的保护属性。
- 参数顺序为：地址、大小、新保护属性、旧保护属性地址。

通过这些技巧，我们可以在CE中高效、稳定地实现内存注入操作，为逆向分析和程序调试提供强大支持。

本文还有配套的精品资源，点击获取

简介：Cheat Engine（CE内存修改器）是一款功能强大的游戏调试与内存修改工具，广泛用于修改单机游戏中角色属性、资源数值等参数。本指南围绕CE的核心功能展开，包括内存扫描、数据过滤、实时监控、脚本编写与内存注入等技术，适用于希望深入理解游戏运行机制、进行游戏调试或非商业用途修改的用户。同时强调使用过程中的法律、安全及反作弊风险，帮助学习者在合法、安全的前提下掌握CE的使用技巧，提升游戏逆向分析与调试能力。

本文还有配套的精品资源，点击获取