[初级入狱教程]通用型内存读写源码与炫++避坑不完全指南

C@iNi@o

先纪念一下踩过的坑

1、模块混用时各种数据类型套娃（特别是WINDOWS API中各种数据类型套娃）引发的报错，详见大神花姐的解答
[公告] 炫语言常见错误以及解决方法

这里再记录一个C语言风格的结构体强转方法
例如有位置型、坐标型结构体，成员都是2个整型

1. 坐标 = *(坐标型*)&位置  // &位置表示取<span style="background-color: rgb(255, 255, 255);">变量（</span><span style="background-color: rgb(255, 255, 255);">位置型结构体</span><span style="background-color: rgb(255, 255, 255);">）的指针，可理解为将</span><span style="background-color: rgb(255, 255, 255);">位置型结构体指针强转为</span>坐标型结构体指针，再解引用赋值

复制代码

2、重点来了，外部宏的使用。炫++目前模块比较少，C++借助AI可以填补这个缺憾，那么问题来了，各种常量怎么整？
例如OpenProcess()函数，系统API模块中叫打开进程()，AI给出的示例代码如下

1. HANDLE hProcess = OpenProcess(PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, processId)

复制代码

第一个常量，以及取PID需要的套娃类型（DWORD）用外部宏就轻松解决了

1. #外部宏 DWORD
   
2. #外部宏 PROCESS_ALL_ACCESS
   
3. 
   
4. HWND 窗口句柄_游戏 = 查找窗口("MainWindow", "Plants vs. Zombies")
   
5. DWORD pid
   
6. 取窗口线程进程ID(窗口句柄_游戏, &pid)
   
7. 打开进程(PROCESS_ALL_ACCESS, 假, pid)

复制代码

过了上面2个坑，写代码就轻松多了，以下是本人手搓的通用型内存读写源码（以植物大战僵尸为例），写的太烂，请勿喷

1. #外部宏 DWORD
   
2. #外部宏 PROCESS_ALL_ACCESS
   
3. 
   
4. //@备注 返回10进制内存地址
   
5. 函数 变整型 取基址(DWORD 进程pid, 变整型 内存地址)
   
6.         变整型 读到的内存地址 = 0
   
7.         句柄型 进程权限句柄 = 打开进程(PROCESS_ALL_ACCESS, 假, 进程pid)
   
8.         读进程内存(进程权限句柄, (空类型*)内存地址, &读到的内存地址, 4, 空)
   
9.         如果 (进程权限句柄)
   
10.                 关闭句柄(进程权限句柄)
    
11.         返回 读到的内存地址
    
12. 
    
13. //@备注 欲读取的数据类型0-字节,1-2字节,2-4字节,3-8字节,4-单浮点,5-双浮点
    
14. 函数 逻辑型 读内存(DWORD 进程pid, 变整型 内存地址, 整型 欲读取的数据类型, 空类型* 数据)
    
15.         句柄型 进程权限句柄 = 打开进程(PROCESS_ALL_ACCESS, 假, 进程pid)
    
16.         逻辑型 状态 = 假
    
17.         分支判断 (欲读取的数据类型)
    
18.                 分支 0
    
19.                         字节型 返回的数据
    
20.                         字节型 *数据指针 = (字节型*)数据
    
21.                         状态 = 读进程内存(进程权限句柄, (空类型*)内存地址, (空类型*)&返回的数据, 1, 空)
    
22.                         *数据指针 = 返回的数据
    
23.                         跳出
    
24.                 分支 1
    
25.                         短整型 返回的数据
    
26.                         短整型 *数据指针 = (短整型*)数据
    
27.                         状态 = 读进程内存(进程权限句柄, (空类型*)内存地址, (空类型*)&返回的数据, 2, 空)
    
28.                         *数据指针 = 返回的数据
    
29.                         跳出
    
30.                 分支 2
    
31.                         整型 返回的数据
    
32.                         整型 *数据指针 = (整型*)数据
    
33.                         状态 = 读进程内存(进程权限句柄, (空类型*)内存地址, (空类型*)&返回的数据, 4, 空)
    
34.                         *数据指针 = 返回的数据
    
35.                         跳出
    
36.                 分支 3
    
37.                         长整型 返回的数据
    
38.                         长整型 *数据指针 = (长整型*)数据
    
39.                         状态 = 读进程内存(进程权限句柄, (空类型*)内存地址, (空类型*)&返回的数据, 8, 空)
    
40.                         *数据指针 = 返回的数据
    
41.                         跳出
    
42.                 分支 4
    
43.                         浮点型 返回的数据
    
44.                         浮点型 *数据指针 = (浮点型*)数据
    
45.                         状态 = 读进程内存(进程权限句柄, (空类型*)内存地址, (空类型*)&返回的数据, 4, 空)
    
46.                         *数据指针 = 返回的数据
    
47.                         跳出
    
48.                 分支 5
    
49.                         双浮点型 返回的数据
    
50.                         双浮点型 *数据指针 = (双浮点型*)数据
    
51.                         状态 = 读进程内存(进程权限句柄, (空类型*)内存地址, (空类型*)&返回的数据, 8, 空)
    
52.                         *数据指针 = 返回的数据
    
53.                         跳出
    
54.                 其他
    
55.                         跳出
    
56.         如果 (进程权限句柄)
    
57.                 关闭句柄(进程权限句柄)
    
58.         返回 状态
    
59. 
    
60. //@备注 欲写入的数据类型0-字节,1-2字节,2-4字节,3-8字节,4-单浮点,5-双浮点
    
61. 函数 逻辑型 写内存(DWORD 进程pid, 变整型 内存地址, 整型 欲写入的数据类型, 空类型* 数据)
    
62.         句柄型 进程权限句柄 = 打开进程(PROCESS_ALL_ACCESS, 假, 进程pid)
    
63.         逻辑型 状态 = 假
    
64.         分支判断 (欲写入的数据类型)
    
65.                 分支 0
    
66.                         字节型 待写入数据
    
67.                         字节型 *数据指针 = (字节型*)数据
    
68.                         待写入数据 = *数据指针
    
69.                         状态 = 写进程内存(进程权限句柄, (空类型*)内存地址, (空类型*)&待写入数据, 1, 空)
    
70.                         跳出
    
71.                 分支 1
    
72.                         短整型 待写入数据
    
73.                         短整型 *数据指针 = (短整型*)数据
    
74.                         待写入数据 = *数据指针
    
75.                         状态 = 写进程内存(进程权限句柄, (空类型*)内存地址, (空类型*)&待写入数据, 2, 空)
    
76.                         跳出
    
77.                 分支 2
    
78.                         整型 待写入数据
    
79.                         整型 *数据指针 = (整型*)数据
    
80.                         待写入数据 = *数据指针
    
81.                         状态 = 写进程内存(进程权限句柄, (空类型*)内存地址, (空类型*)&待写入数据, 4, 空)
    
82.                         跳出
    
83.                 分支 3
    
84.                         长整型 待写入数据
    
85.                         长整型 *数据指针 = (长整型*)数据
    
86.                         待写入数据 = *数据指针
    
87.                         状态 = 写进程内存(进程权限句柄, (空类型*)内存地址, (空类型*)&待写入数据, 8, 空)
    
88.                         跳出
    
89.                 分支 4
    
90.                         浮点型 写入数据
    
91.                         浮点型 *数据指针 = (浮点型*)数据
    
92.                         写入数据 = *数据指针
    
93.                         状态 = 写进程内存(进程权限句柄, (空类型*)内存地址, (空类型*)&写入数据, 4, 空)
    
94.                         跳出
    
95.                 分支 5
    
96.                         双浮点型 写入数据
    
97.                         双浮点型 *数据指针 = (双浮点型*)数据
    
98.                         写入数据 = *数据指针
    
99.                         状态 = 写进程内存(进程权限句柄, (空类型*)内存地址, (空类型*)&写入数据, 8, 空)
    
100.                         跳出
     
101.                 其他
     
102.                         跳出
     
103.         如果 (进程权限句柄)
     
104.                 关闭句柄(进程权限句柄)
     
105.         返回 状态
     
106. 
     
107. 函数 整型 入口函数() //控制台程序入口函数, 程序启动优先进入此函数
     
108.         控制台_置中文编码()
     
109.         HWND 窗口句柄_游戏 = 查找窗口("MainWindow", "Plants vs. Zombies")
     
110.         DWORD pid
     
111.         取窗口线程进程ID(窗口句柄_游戏, &pid)
     
112.         //[[731C50]+868]+5578
     
113.         变整型 阳光基址 = 0x731C50
     
114.         阳光基址 = 取基址(pid, 阳光基址)
     
115.         阳光基址 = 取基址(pid, 阳光基址 + 0x868)
     
116.         阳光基址 = 阳光基址 + 0x5578
     
117.         整型 数据 = 0
     
118.         读内存(pid, 阳光基址, 2, &数据)
     
119.         调试输出(数据)
     
120.         整型 a = 6000
     
121.         写内存(pid, 阳光基址, 2, &a)
     
122.         控制台_暂停()
     
123.         返回 0

复制代码

呵呵仙

谢谢,学习了!原来是这样用分支的!

webyjh

感谢大佬的无私分享,非常有用,请问多级指针如何写?

花芯

函数 常量 逻辑型 读内存<T>(DWORD 进程pid, 变整型 内存地址, T 数据)
        句柄型 进程权限句柄 = A进程_打开(PROCESS_ALL_ACCESS, 假, 进程pid)
        逻辑型 状态 = 假
        T 返回的数据 = {}
        T *数据指针 = (T*)数据
        状态 = 读进程内存(进程权限句柄, (空类型*)内存地址, (空类型*)&返回的数据, 取类型大小(返回的数据), 空)
        *数据指针 = 返回的数据
        如果 (进程权限句柄)
                关闭句柄(进程权限句柄)
        返回 状态