易语言内存操作技巧大揭秘！

易语言内存操作技巧大揭秘！

引用

CSDN

等

10

来源

1.

https://blog.csdn.net/bbdxf/article/details/6993847

2.

https://jingyan.baidu.com/article/495ba841ee7e2a38b30edeb1.html

3.

https://blog.csdn.net/hzw320/article/details/99441159

4.

https://blog.csdn.net/weixin_34598113/article/details/142428739

5.

https://blog.csdn.net/Religion_/article/details/119878097

6.

https://wenku.csdn.net/doc/4cdeeqqo0w

7.

https://wenku.csdn.net/doc/1apukihihj

8.

https://www.eyuyan.la/post/10867.html

9.

https://www.eyuyan.la/post/16802.html

10.

https://www.zovps.com/article/index.php/post/331163.html

在编程领域，内存操作是一项重要的技术，尤其是在系统级编程和游戏开发中。易语言作为一门简洁易懂的中文编程语言，提供了丰富的内存操作功能，使得开发者能够方便地进行内存读取、写入和监控等操作。本文将深入探讨易语言中的内存操作技术，从基础概念到具体实现，帮助读者掌握这些实用的编程技巧。

在计算机系统中，内存是程序运行时存放数据和指令的地方。每个进程都有其独立的虚拟内存空间，而内存操作就是指在程序运行时对这些内存空间进行读取、写入或监控等操作。在易语言中，内存操作主要通过调用Windows API函数和使用易语言内置的内存操作命令来实现。

易语言提供了多个用于内存操作的命令，这些命令使得开发者能够方便地进行内存读取、写入以及分配等操作。

读取内存数据

易语言中的读内存命令用于从指定进程的内存空间中读取数据。其基本格式如下：

变量 = 读内存(进程句柄, 内存起始地址, 读取字节数)

• 进程句柄：指向需要操作内存的进程句柄。
• 内存起始地址：需要读取数据的内存起始地址。
• 读取字节数：需要从内存中读取的字节数。

示例代码：

.版本 2
.程序集 程序集1
.子程序 _启动子程序, 整数型, 公开
    .局部变量 进程句柄, 整数型
    .局部变量 读取数据, 字节集
    进程句柄 = 打开进程("目标进程名.exe")
    如果 (进程句柄 = 0) 则返回 0
    读取数据 = 读内存(进程句柄, 内存地址, 1024)
    关闭进程(进程句柄)
    返回 真
.子程序结束

写入内存数据

与读取内存相对应，易语言中的写内存命令可以将数据写入到指定进程的内存空间。其基本格式如下：

成功 = 写内存(进程句柄, 内存起始地址, 要写入的数据, 写入字节数)

• 进程句柄：指向需要操作内存的进程句柄。
• 内存起始地址：需要写入数据的内存起始地址。
• 要写入的数据：需要写入内存的数据内容。
• 写入字节数：需要从内存中写入的字节数。

示例代码：

.版本 2
.程序集 程序集1
.子程序 _启动子程序, 整数型, 公开
    .局部变量 进程句柄, 整数型
    .局部变量 写入数据, 字节集
    写入数据 = 字节集("待写入的字节数据")
    进程句柄 = 打开进程("目标进程名.exe")
    如果 (进程句柄 = 0) 则返回 0
    如果 (写内存(进程句柄, 内存地址, 写入数据, 长度(写入数据)) = 假) 则
        输出 "写入失败"
    否则
        输出 "写入成功"
    结束如果
    关闭进程(进程句柄)
    返回 真
.子程序结束

动态分配内存

易语言的分配内存命令可以用于在指定进程的内存空间中动态分配一块新的内存区域。其基本格式如下：

内存句柄 = 分配内存(进程句柄, 分配大小, 保护方式)

• 进程句柄：指向需要操作内存的进程句柄。
• 分配大小：需要分配的内存大小（以字节为单位）。
• 保护方式：内存的保护方式，通常为可读写。

示例代码：

.版本 2
.程序集 程序集1
.子程序 _启动子程序, 整数型, 公开
    .局部变量 进程句柄, 整数型
    .局部变量 内存句柄, 整数型
    .局部变量 分配地址, 整数型
    进程句柄 = 打开进程("目标进程名.exe")
    如果 (进程句柄 = 0) 则返回 0
    内存句柄 = 分配内存(进程句柄, 1024, 内存保护_可读写)
    如果 (内存句柄 <> 0) 则
        分配地址 = 内存句柄
        输出 "内存分配成功，地址：" + 字符串(分配地址)
    否则
        输出 "内存分配失败"
    结束如果
    关闭进程(进程句柄)
    返回 真
.子程序结束

下面是一个完整的示例，演示如何使用易语言读取指定进程的内存数据：

.版本 2

.程序集 窗口程序集1

.子程序 _启动窗口_创建完毕
    .局部变量 进程ID, 整数型
    .局部变量 内存地址, 整数型
    .局部变量 读取长度, 整数型
    .局部变量 缓冲区, 字节集
    .局部变量 返回值, 逻辑型

    ' 示例：读取 Notepad.exe 进程的内存数据
    进程ID ＝ 取进程ID (“notepad.exe”)
    内存地址 ＝ 十六进制到整数 (“00400000”)  ' 示例内存地址
    读取长度 ＝ 10  ' 读取 10 个字节

    ' 调用 ReadProcessMemory 读取内存
    返回值 ＝ ReadProcessMemory (进程ID, 内存地址, 缓冲区, 读取长度)

    .如果真 (返回值)
        信息框 (“读取成功：” ＋ 字节集到文本 (缓冲区), 0, )
    .否则
        信息框 (“读取失败”, 0, )
    .如果真结束

.子程序 ReadProcessMemory, 逻辑型
    .参数 进程ID, 整数型
    .参数 内存地址, 整数型
    .参数 缓冲区, 字节集
    .参数 读取长度, 整数型
    .局部变量 hProcess, 整数型
    .局部变量 返回值, 逻辑型
    .局部变量 实际读取长度, 整数型

    ' 打开进程
    hProcess ＝ OpenProcess (#PROCESS_VM_READ, 假, 进程ID)
    .如果真 (hProcess ＝ 0)
        返回 (假)
    .如果真结束

    ' 读取内存
    返回值 ＝ API_ReadProcessMemory (hProcess, 内存地址, 缓冲区, 读取长度, 实际读取长度)

    ' 关闭进程句柄
    CloseHandle (hProcess)

    返回 (返回值)

.子程序 API_ReadProcessMemory, 逻辑型
    .参数 hProcess, 整数型
    .参数 lpBaseAddress, 整数型
    .参数 lpBuffer, 字节集
    .参数 nSize, 整数型
    .参数 lpNumberOfBytesRead, 整数型
    .DLL 命令 ReadProcessMemory, 逻辑型, "kernel32.dll", "ReadProcessMemory"
    .参数 hProcess, 整数型
    .参数 lpBaseAddress, 整数型
    .参数 lpBuffer, 字节集
    .参数 nSize, 整数型
    .参数 lpNumberOfBytesRead, 整数型
    返回 (ReadProcessMemory (hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesRead))

.子程序 OpenProcess, 整数型
    .参数 dwDesiredAccess, 整数型
    .参数 bInheritHandle, 逻辑型
    .参数 dwProcessId, 整数型
    .DLL 命令 OpenProcess, 整数型, "kernel32.dll", "OpenProcess"
    .参数 dwDesiredAccess, 整数型
    .参数 bInheritHandle, 逻辑型
    .参数 dwProcessId, 整数型
    返回 (OpenProcess (dwDesiredAccess, bInheritHandle, dwProcessId))

.子程序 CloseHandle, 逻辑型
    .参数 hObject, 整数型
    .DLL 命令 CloseHandle, 逻辑型, "kernel32.dll", "CloseHandle"
    .参数 hObject, 整数型
    返回 (CloseHandle (hObject))

接下来是一个写入内存的示例，演示如何向指定进程的内存写入小数型数据：

.版本 2
.DLL命令 打开进程, 整数型, , "OpenProcess"
.参数 访问级别, 整数型
.参数 子进程继承, 整数型
.参数 进程ID, 整数型
.DLL命令 内存写字节集, 整数型, , "WriteProcessMemory"
.参数 hProcess, 整数型
.参数 pBaseAddress, 整数型
.参数 lpBuffer, 字节集, 传址
.参数 nSize, 整数型
.参数 lpNumberOfBytesWritten, 整数型
.DLL命令 关闭对象, 整数型, , "CloseHandle"
.参数 对象句柄, 整数型

.版本 2
.子程序 写内存小数型
.参数 进程pID, 整数型
.参数 地址, 整数型
.参数 数据, 小数型
.参数 写入长度, 整数型, 可空
.局部变量 操作句柄, 整数型
操作句柄 ＝ 打开进程 (2035711, 0, 进程pID)
内存写字节集 (操作句柄, 地址, 到字节集 (数据), 选择 (写入长度 ＝ 0, 取字节集长度 (到字节集 (数据)), 写入长度), 0)
关闭对象 (操作句柄)

.版本 2
写内存小说型 (, , )  ' 第一个为进程pid,第二个为内存地址，第三个为小数型数据

易语言还提供了内存监控功能，可以用来检测进程中的内存读写操作。这在调试程序和分析软件行为时非常有用。

.版本 2
.DLL命令 内存_安装读监视, 整数型, , "Memory_ReadMonitor_Install"
.参数 进程ID, 整数型
.参数 通知窗口句柄, 整数型
.参数 通知消息, 整数型
.DLL命令 内存_继续读监视, 整数型, , "Memory_ReadMonitor_Resume"
.参数 进程ID, 整数型
.DLL命令 内存_暂停读监视, 整数型, , "Memory_ReadMonitor_Suspend"
.参数 进程ID, 整数型
.DLL命令 内存_卸载读监视, 整数型, , "Memory_ReadMonitor_Uninstall"
.参数 进程ID, 整数型

.DLL命令 内存_安装写监视, 整数型, , "Memory_WriteMonitor_Install"
.参数 进程ID, 整数型
.参数 通知窗口句柄, 整数型
.参数 通知消息, 整数型
.DLL命令 内存_暂停写监视, 整数型, , "Memory_WriteMonitor_Suspend"
.参数 进程ID, 整数型
.DLL命令 内存_继续写监视, 整数型, , "Memory_WriteMonitor_Resume"
.参数 进程ID, 整数型
.DLL命令 内存_卸载写监视, 整数型, , "Memory_WriteMonitor_Uninstall"
.参数 进程ID, 整数型

这些命令可以用来监控指定进程的内存读写操作，当检测到读写事件时，可以通过指定的通知窗口和消息来获取相关信息。

在进行内存操作时，需要注意以下几点：

1. 管理员权限：大多数内存操作需要管理员权限才能执行。在运行程序前，确保程序以管理员身份运行。

2. 合法性：内存操作可能涉及隐私和安全问题，因此在使用这些技术时，务必确保操作的合法性和正当性。例如，未经允许读取或修改他人程序的内存数据可能构成违法行为。

3. 稳定性：不当的内存操作可能导致系统崩溃或程序异常。在进行内存操作时，需要格外小心，确保操作的正确性和安全性。

通过掌握易语言的内存操作技术，开发者能够编写出更强大、更灵活的程序。无论是进行系统级编程、游戏开发还是软件调试，这些技术都能发挥重要作用。然而，在使用这些技术时，一定要遵守相关法律法规，确保操作的合法性和正当性。