【易语言 源码】 通过特征码搜索内存地址源码

叶子分享

1. .版本 2
   
2. .支持库 spec
   
3. 
   
4. .程序集 窗口程序集_启动窗口
   
5. .程序集变量 进程句柄, 整数型
   
6. 
   
7. .子程序 __启动窗口_创建完毕
   
8. 
   
9. 
   
10. 进程句柄 ＝ 0  ' ？？？没有句柄？我搜什么？
    
11. 
    
12. .子程序 搜索, 整数型
    
13. .参数 通配符, 文本型
    
14. .局部变量 搜索内容, 字节集, , , 欲搜索的内容  其他类型-需自行转换为字节集类型
    
15. .局部变量 字节集段, 通配符集, , "0"
    
16. .局部变量 长度, 整数型
    
17. .局部变量 内存地址, 整数型
    
18. .局部变量 内存块信息, MEMORY_BASIC_INFORMATION
    
19. .局部变量 数据缓冲区, 字节集
    
20. .局部变量 找到位置, 整数型
    
21. .局部变量 计次, 整数型
    
22. .局部变量 算偏移, 整数型
    
23. .局部变量 完全匹配, 逻辑型
    
24. 
    
25. .如果真 (进程句柄 ＝ 0)
    
26.     返回 (0)
    
27. .如果真结束
    
28. 搜索内容 ＝ 通配符处理 (通配符, 字节集段, 算偏移)
    
29. 长度 ＝ 取字节集长度 (搜索内容)
    
30. .判断循环首 (VirtualQueryEx (进程句柄, 内存地址, 内存块信息, 28) ≠ 0)
    
31.     .如果真 (内存块信息.Protect ＝ 4 且 内存块信息.Type ＝ 131072)
    
32.         数据缓冲区 ＝ 取空白字节集 (内存块信息.RegionSize)
    
33.         .如果真 (ReadProcessMemory (进程句柄, 内存地址, 数据缓冲区, 内存块信息.RegionSize, 0))
    
34.             找到位置 ＝ 寻找字节集 (数据缓冲区, 搜索内容, )
    
35.             .判断循环首 (找到位置 ≠ -1)
    
36.                 完全匹配 ＝ 真
    
37.                 .计次循环首 (取数组成员数 (字节集段), 计次)
    
38.                     .如果 (数据匹配 (数据缓冲区, 找到位置, 字节集段 [计次]))
    
39. 
    
40.                     .否则
    
41.                         完全匹配 ＝ 假
    
42.                     .如果结束
    
43. 
    
44.                 .计次循环尾 ()
    
45.                 .如果真 (完全匹配)
    
46.                     调试输出 (“找到了一个地址 > ” ＋ 取文本右边 (“0000000” ＋ 取十六进制文本 (内存地址 ＋ 找到位置 － 算偏移), 8))
    
47.                 .如果真结束
    
48.                 找到位置 ＝ 寻找字节集 (数据缓冲区, 搜索内容, 找到位置 ＋ 长度)
    
49.             .判断循环尾 ()
    
50.         .如果真结束
    
51. 
    
52.     .如果真结束
    
53.     内存地址 ＝ 内存地址 ＋ 内存块信息.RegionSize
    
54.     处理事件 ()
    
55. .判断循环尾 ()
    
56. 返回 (0)
    
57. 
    
58. .子程序 数据匹配, 逻辑型
    
59. .参数 缓冲区数据, 字节集
    
60. .参数 找到位置, 整数型
    
61. .参数 字节集段, 通配符集
    
62. .局部变量 长度, 整数型
    
63. 
    
64. 长度 ＝ 取字节集长度 (字节集段.数据)
    
65. 返回 (取字节集中间 (缓冲区数据, 字节集段.位置 ＋ 找到位置, 长度) ＝ 字节集段.数据)
    
66. 
    
67. .子程序 通配符处理, 字节集
    
68. .参数 通配符, 文本型
    
69. .参数 处理好的字节集组, 通配符集, 参考 数组
    
70. .参数 计算偏移用的, 整数型, 参考
    
71. .局部变量 待处理文本, 文本型
    
72. .局部变量 文本位置, 整数型
    
73. .局部变量 任何字节, 逻辑型
    
74. .局部变量 当前字节, 文本型
    
75. .局部变量 临时, 通配符集
    
76. .局部变量 数组, 通配符集, , "0"
    
77. .局部变量 寻找的内容, 字节集
    
78. .局部变量 计次, 整数型
    
79. .局部变量 最长长度, 整数型
    
80. .局部变量 当前长度, 整数型
    
81. .局部变量 数组位置, 整数型
    
82. 
    
83. ' 先把通配符转为字节集并记录位置
    
84. 待处理文本 ＝ 删全部空 (通配符)
    
85. .变量循环首 (1, 取文本长度 (待处理文本), 2, 文本位置)
    
86.     当前字节 ＝ 取文本中间 (待处理文本, 文本位置, 2)
    
87.     .如果 (当前字节 ＝ “??”)
    
88.         .如果真 (临时.数据 ≠ {  })
    
89.             临时.位置 ＝ 文本位置 ÷ 2 － 取字节集长度 (临时.数据) ＋ 1
    
90.             加入成员 (数组, 临时)
    
91.             临时.数据 ＝ {  }
    
92.         .如果真结束
    
93. 
    
94.     .否则
    
95.         临时.数据 ＝ 临时.数据 ＋ 到十进制 (当前字节)
    
96.     .如果结束
    
97. 
    
98. .变量循环尾 ()
    
99. .如果真 (临时.数据 ≠ {  })
    
100.     临时.位置 ＝ 文本位置 ÷ 2 － 取字节集长度 (临时.数据) ＋ 1
     
101.     加入成员 (数组, 临时)
     
102. .如果真结束
     
103. 
     
104. 
     
105. ' 然后筛选最少结果的字节集段，只是简单演示我知道我这种方法有时候会拖累搜索的速度
     
106. ' 但只是做个例子而已，之后你们可以自己优化
     
107. .计次循环首 (取数组成员数 (数组), 计次)
     
108.     当前长度 ＝ 取字节集长度 (数组 [计次].数据)
     
109.     .如果真 (最长长度 ≤ 当前长度)
     
110.         .如果 (最长长度 ＝ 当前长度)
     
111.             .判断开始 (当前长度 ≥ 4)
     
112.                 .如果真 (到整数 (数组 [计次].数据) ＞ 到整数 (寻找的内容))
     
113.                     寻找的内容 ＝ 数组 [计次].数据
     
114.                     数组位置 ＝ 计次
     
115.                 .如果真结束
     
116. 
     
117.             .判断 (当前长度 ≥ 2)
     
118.                 .如果真 (到短数 (数组 [计次].数据) ＞ 到短数 (寻找的内容))
     
119.                     寻找的内容 ＝ 数组 [计次].数据
     
120.                     数组位置 ＝ 计次
     
121.                 .如果真结束
     
122. 
     
123.             .默认
     
124.                 .如果真 (数组 [计次].数据 [1] ＞ 寻找的内容 [1])
     
125.                     寻找的内容 ＝ 数组 [计次].数据
     
126.                     数组位置 ＝ 计次
     
127.                 .如果真结束
     
128. 
     
129.             .判断结束
     
130. 
     
131.         .否则
     
132.             寻找的内容 ＝ 数组 [计次].数据
     
133.             最长长度 ＝ 取字节集长度 (数组 [计次].数据)
     
134.             数组位置 ＝ 计次
     
135.         .如果结束
     
136. 
     
137.     .如果真结束
     
138. 
     
139. .计次循环尾 ()
     
140. .如果真 (数组位置 ≠ 0)
     
141.     计算偏移用的 ＝ 数组 [数组位置].位置
     
142.     删除成员 (数组, 数组位置, 1)
     
143. .如果真结束
     
144. ' 后面还有几段过滤的,上面的代码是减少搜索得到的结果 简单粗暴
     
145. ' 至于下面怎么过滤优化自己看着办吧 | 第一个 万一遇到最长的字节集 全部是0怎么办？ 第二个 最长的不一定结果最少的(同上) 第三个 最长的搜索效率不一定是最快的
     
146. 
     
147. 
     
148. 
     
149. ' 接下来就是调整好其他字节集段的位置
     
150. .计次循环首 (取数组成员数 (数组), 计次)
     
151.     数组 [计次].位置 ＝ 数组 [计次].位置 － 计算偏移用的
     
152. .计次循环尾 ()
     
153. ' 完毕!
     
154. 处理好的字节集组 ＝ 数组
     
155. 返回 (寻找的内容)
     
156. 
     
157. .子程序 到十进制, 字节集
     
158. .参数 str, 文本型
     
159. .局部变量 a, 文本型
     
160. .局部变量 b, 文本型
     
161. .局部变量 c, 文本型
     
162. 
     
163. a ＝ 到大写 (str)
     
164. b ＝ 取文本中间 (a, 2, 1)
     
165. .如果 (b ＝ “”)
     
166.     b ＝ 取文本左边 (a, 1)
     
167. .否则
     
168.     c ＝ 取文本左边 (a, 1)
     
169. .如果结束
     
170. 返回 (到字节集 (到字节 ((寻找文本 (“0123456789ABCDEF”, c, , 真) － 1) × 16 ＋ 寻找文本 (“0123456789ABCDEF”, b, , 真) － 1)))
     
171. 
     
172. .子程序 到整数, 整数型
     
173. .参数 字节集, 字节集
     
174. 
     
175. 返回 (取字节集数据 (取字节集左边 (字节集, 4), #整数型, ))
     
176. 
     
177. .子程序 到短数, 整数型
     
178. .参数 字节集, 字节集
     
179. 
     
180. 返回 (取字节集数据 (取字节集左边 (字节集, 2), #短整数型, ))
     
181. 
     
182. .子程序 _按钮1_被单击
     
183. 
     
184. 搜索 (编辑框1.内容)  ' 编辑框，按钮自行创建！
     

复制代码