V4全套带盾开源，今年2月花1500买的

wangyize

v6呢啥时候开呢

poffen

又转1500 每天来一次

a126532655

新技能已get√

wys810301

新技能已get√

Frieza

源码部分函数有缺失，修复了一部分！RC4 枚举驱动~~修复的代码已经回帖了，等待审核！
目前发现的新问题，客户Duan与服务端通信解密有问题。目前服务端接收到的信息解密失败~~晚上继续研究下~~或者有搞好的大神，分享下~~哈哈~~~

kevmagic

好厉害，大气的人值得尊敬！

小呀小百百

大哥发财！

Frieza

媳妇你看月亮 发表于 2020-7-17 14:00
大佬，请问一下找不到RC4怎么解决啊

1. .版本 2
   
2. .支持库 dp1
   
3. 
   
4. .程序集 程序集2
   
5. 
   
6. .子程序 RC4密码, 字节集
   
7. 
   
8. 返回 (子字节集替换 ({ 194, 0, 0, 0, 0, 0, 0, 0, 0, 232, 0, 0, 0, 0, 0, 0, 0, 193, 0, 0, 0, 0, 203, 0, 184, 0, 246, 0, 177, 0, 198, 0, 0, 0, 0, 181, 0, 196, 0, 126, 0, 0, 0, 0, 177, 0, 0, 0, 0, 187, 0, 196, 0, 0, 0, 0, 227, 0, 0, 0, 0, 198, 0, 0, 0, 0, 198, 0, 189, 0, 226, 0, 0, 0, 0, 193, 0, 0, 0, 0, 0, 0, 0, 203, 0, 126, 0, 0, 0, 0 }, { 0 }, {  }, , ))
   
9. 
   
10. 
    
11. .子程序 RC4, 字节集
    
12. .参数 字节集数据, 字节集
    
13. .参数 密码文本, 字节集, 可空
    
14. .参数 加密算法, 整数型, 可空, 可以被省略。指定具体使用的加密算法，可以为以下常量值之一：1:#DES算法；2:#RC4算法。
    
15. .局部变量 匿名子程序变量_1, 字节型, , "256"
    
16. .局部变量 匿名子程序变量_2, 字节型, , "256"
    
17. .局部变量 匿名子程序变量_3, 整数型
    
18. .局部变量 匿名子程序变量_4, 整数型
    
19. .局部变量 匿名子程序变量_5, 字节型
    
20. .局部变量 匿名子程序变量_6, 整数型
    
21. .局部变量 匿名子程序变量_7, 字节集
    
22. .局部变量 匿名子程序变量_8, 整数型
    
23. .局部变量 匿名子程序变量_9, 整数型
    
24. .局部变量 匿名子程序变量_10, 整数型
    
25. .局部变量 匿名子程序变量_11, 逻辑型
    
26. 
    
27. .如果真 (取字节集长度 (字节集数据) ＝ 0)
    
28.     返回 ({  })
    
29. .如果真结束
    
30. 
    
31. .如果真 (取字节集长度 (密码文本) ＝ 0)
    
32.     匿名子程序变量_11 ＝ 真
    
33.     密码文本 ＝ RC4密码 ()
    
34. .如果真结束
    
35. 
    
36. .如果真 (加密算法 ＝ 1)
    
37.     匿名子程序变量_7 ＝ 加密数据 (字节集数据, 到文本 (密码文本), #RC4算法)
    
38.     .如果真 (匿名子程序变量_11)
    
39.         密码文本 ＝ 取空白字节集 (取字节集长度 (密码文本))
    
40.     .如果真结束
    
41.     返回 (匿名子程序变量_7)
    
42. .如果真结束
    
43. 
    
44. .如果真 (加密算法 ＝ 2)
    
45.     匿名子程序变量_7 ＝ 解密数据 (字节集数据, 到文本 (密码文本), #RC4算法)
    
46.     .如果真 (匿名子程序变量_11)
    
47.         密码文本 ＝ 取空白字节集 (取字节集长度 (密码文本))
    
48.     .如果真结束
    
49.     返回 (匿名子程序变量_7)
    
50. .如果真结束
    
51. 
    
52. .计次循环首 (256, 匿名子程序变量_3)
    
53.     匿名子程序变量_1 [匿名子程序变量_3] ＝ 匿名子程序变量_3 － 1
    
54. .计次循环尾 ()
    
55. 匿名子程序变量_4 ＝ 1
    
56. 匿名子程序变量_10 ＝ 取字节集长度 (密码文本)
    
57. .计次循环首 (256, 匿名子程序变量_3)
    
58.     .如果真 (匿名子程序变量_4 ＞ 匿名子程序变量_10)
    
59.         匿名子程序变量_4 ＝ 1  '
    
60.     .如果真结束
    
61.     匿名子程序变量_2 [匿名子程序变量_3] ＝ 到字节 (取代码 (到文本 (取字节集中间 (密码文本, 匿名子程序变量_4, 1)), 1))
    
62.     匿名子程序变量_4 ＝ 匿名子程序变量_4 ＋ 1
    
63. .计次循环尾 ()
    
64. 匿名子程序变量_4 ＝ 0
    
65. .计次循环首 (256, 匿名子程序变量_3)
    
66.     匿名子程序变量_4 ＝ (匿名子程序变量_4 ＋ 匿名子程序变量_1 [匿名子程序变量_3] ＋ 匿名子程序变量_2 [匿名子程序变量_3]) ％ 256
    
67.     匿名子程序变量_5 ＝ 匿名子程序变量_1 [匿名子程序变量_3]  '
    
68.     匿名子程序变量_1 [匿名子程序变量_3] ＝ 匿名子程序变量_1 [匿名子程序变量_4 ＋ 1]
    
69.     匿名子程序变量_1 [匿名子程序变量_4 ＋ 1] ＝ 匿名子程序变量_5
    
70. .计次循环尾 ()
    
71. 匿名子程序变量_3 ＝ 0
    
72. 匿名子程序变量_4 ＝ 0
    
73. .计次循环首 (取字节集长度 (字节集数据), 匿名子程序变量_8)
    
74.     匿名子程序变量_3 ＝ (匿名子程序变量_3 ＋ 1) ％ 256
    
75.     匿名子程序变量_4 ＝ (匿名子程序变量_4 ＋ 匿名子程序变量_1 [匿名子程序变量_3 ＋ 1]) ％ 256
    
76.     匿名子程序变量_5 ＝ 匿名子程序变量_1 [匿名子程序变量_3 ＋ 1]  '
    
77.     匿名子程序变量_1 [匿名子程序变量_3 ＋ 1] ＝ 匿名子程序变量_1 [匿名子程序变量_4 ＋ 1]
    
78.     匿名子程序变量_1 [匿名子程序变量_4 ＋ 1] ＝ 匿名子程序变量_5
    
79.     匿名子程序变量_9 ＝ (匿名子程序变量_1 [匿名子程序变量_3 ＋ 1] ＋ 匿名子程序变量_1 [匿名子程序变量_4 ＋ 1] ％ 256) ％ 256
    
80.     匿名子程序变量_6 ＝ 匿名子程序变量_1 [匿名子程序变量_9 ＋ 1]  '
    
81.     匿名子程序变量_7 ＝ 匿名子程序变量_7 ＋ 到字节集 (到字节 (位异或 (字节集数据 [匿名子程序变量_8], 匿名子程序变量_6)))
    
82. .计次循环尾 ()
    
83. .如果真 (匿名子程序变量_11)
    
84.     密码文本 ＝ 取空白字节集 (取字节集长度 (密码文本))
    
85. .如果真结束
    
86. 返回 (匿名子程序变量_7)
    
87. 
    
88. 
    
89. .子程序 启动信息反调试, 逻辑型
    
90. .局部变量 启动信息, StartupInfo
    
91. 
    
92. GetStartupInfo (启动信息)
    
93. 返回 (启动信息.dwX ≠ 0 或 启动信息.dwY ≠ 0 或 启动信息.dwXCountChars ≠ 0 或 启动信息.dwYCountChars ≠ 0 或 启动信息.dwFillAttribute ≠ 0 或 启动信息.dwXSize ≠ 0 或 启动信息.dwYSize ≠ 0)
    
94. 
    
95. .子程序 操作_取路径目录, 文本型, , c:\1\1\1\1.exe取出 c:\1\1\1\
    
96. .参数 文件全名, 文本型, , c:\1\1\1\1.exe
    
97. .参数 文件名, 文本型, 参考 可空, 1.exe
    
98. .局部变量 位置, 整数型
    
99. .局部变量 x, 整数型
    
100. .局部变量 m, 整数型
     
101. .局部变量 临时数组, 文本型, , "0"
     
102. .局部变量 路径, 文本型
     
103. 
     
104. 临时数组 ＝ 分割文本 (文件全名, “\”, )
     
105. 位置 ＝ 倒找文本 (文件全名, “\”, , 假)
     
106. 路径 ＝ 取文本左边 (文件全名, 位置)
     
107. 文件名 ＝ 取文本右边 (文件全名, 取文本长度 (文件全名) － 取文本长度 (路径))
     
108. 返回 (路径)
     
109. 
     
110. .子程序 文件是否运行中, 逻辑型
     
111. .参数 文件路径, 文本型
     
112. .局部变量 文件时间, 文本型, , "3"
     
113. .局部变量 文件句柄, 整数型
     
114. 
     
115. 文件句柄 ＝ 打开文件 (文件路径, #改写, #无限制)
     
116. .如果真 (文件句柄 ≠ 0)
     
117.     关闭文件 (文件句柄)
     
118. .如果真结束
     
119. 返回 (文件句柄 ＝ 0)
     
120. ' 文件_取时间 (文件路径, 文件时间 [1], 文件时间 [2], 文件时间 [3])
     
121. ' 返回 (文件_置时间 (文件路径, 文件时间 [1], 文件时间 [2], 文件时间 [3]) ＝ 假)
     
122. 
     
123. 
     
124. .子程序 文件是否可执行, 逻辑型
     
125. .参数 文件路径, 文本型
     
126. 
     
127. 返回 (GetBinaryTypeA (文件路径, 0))
     
128. 
     
129. .子程序 枚举驱动, 整数型
     
130. .参数 保存驱动路径数组, 文本型, 参考 可空 数组
     
131. .局部变量 Ret, 整数型
     
132. .局部变量 Buffer, 整数型
     
133. .局部变量 ModulesInfo, MODULES
     
134. .局部变量 i, 整数型
     
135. .局部变量 索引, 整数型
     
136. .局部变量 找到位置, 整数型
     
137. .局部变量 分割, 文本型, , "0"
     
138. .局部变量 x, 整数型
     
139. .局部变量 位置1, 整数型
     
140. .局部变量 程序路径, 文本型
     
141. .局部变量 路径备份, 文本型
     
142. .局部变量 驱动路径, 文本型
     
143. .局部变量 启动时间, 整数型
     
144. .局部变量 次, 整数型
     
145. .局部变量 程序路径1, 文本型
     
146. .局部变量 OD路径, 文本型
     
147. 
     
148. 清除数组 (保存驱动路径数组)
     
149. NtQuerySystemInformation_整数 (11, Buffer, 0, Ret)
     
150. Buffer ＝ LocalAlloc (64, Ret × 2)
     
151. NtQuerySystemInformation_整数 (11, Buffer, Ret × 2, 0)
     
152. CopyMemory_MODULES (ModulesInfo, Buffer, 284)
     
153. i ＝ ModulesInfo.dwNumberOfModules
     
154. 找到位置 ＝ -1
     
155. .计次循环首 (i － 1, )
     
156.     Buffer ＝ Buffer ＋ 71 × 4
     
157.     CopyMemory_MODULES (ModulesInfo, Buffer, 284)
     
158.     驱动路径 ＝ 到文本 (ModulesInfo.ModuleInformation.ImageName)
     
159.     加入成员 (保存驱动路径数组, 驱动路径)
     
160. .计次循环尾 ()
     
161. LocalFree (Buffer)
     
162. 返回 (取数组成员数 (保存驱动路径数组))
     
163. 
     
164. .子程序 检测fengyue区段, 逻辑型, , 返回真 找到
     
165. .参数 Plugin目录, 文本型
     
166. .参数 是否判断运行状态, 逻辑型
     
167. .局部变量 fengyue, 字节集
     
168. .局部变量 句柄, 整数型
     
169. .局部变量 数据缓冲区, 字节集
     
170. .局部变量 找到的位置, 整数型
     
171. .局部变量 文件数组, 文本型, , "0"
     
172. .局部变量 x, 整数型
     
173. 
     
174. fengyue ＝ 到字节集 (“.fengyue”)
     
175. .计次循环首 (文件_枚举 (Plugin目录, “*.*”, 文件数组, 真), x)
     
176.     句柄 ＝ 打开文件 (文件数组 [x], #读入, )
     
177.     .如果真 (句柄 ≠ 0)
     
178.         移动读写位置 (句柄, #文件首, 500)
     
179.         数据缓冲区 ＝ 读入字节集 (句柄, 500)
     
180.         找到的位置 ＝ 寻找字节集 (数据缓冲区, fengyue, )
     
181.         关闭文件 (句柄)
     
182.         .如果真 (找到的位置 ≠ -1)
     
183.             .如果 (是否判断运行状态 ＝ 真)
     
184.                 .如果真 (文件是否运行中 (文件数组 [x]))
     
185.                     返回 (真)
     
186.                 .如果真结束
     
187. 
     
188.             .否则
     
189.                 返回 (真)
     
190.             .如果结束
     
191. 
     
192.         .如果真结束
     
193. 
     
194.     .如果真结束
     
195. 
     
196. .计次循环尾 ()
     
197. 返回 (假)
     
198. 
     
199. .子程序 文件_枚举, 整数型
     
200. .参数 欲寻找的目录, 文本型
     
201. .参数 欲寻找的文件名, 文本型
     
202. .参数 文件数组, 文本型, 参考 可空 数组
     
203. .参数 是否带路径, 逻辑型, 可空
     
204. .局部变量 局_文件名, 文本型
     
205. .局部变量 局_目录, 文本型
     
206. 
     
207. 清除数组 (文件数组)
     
208. 局_目录 ＝ 欲寻找的目录
     
209. .如果真 (取文本右边 (局_目录, 1) ≠ “\”)
     
210.     局_目录 ＝ 局_目录 ＋ “\”
     
211. .如果真结束
     
212. 局_文件名 ＝ 寻找文件 (局_目录 ＋ 欲寻找的文件名, )
     
213. .判断循环首 (局_文件名 ≠ “”)
     
214.     .如果 (是否带路径)
     
215.         加入成员 (文件数组, 局_目录 ＋ 局_文件名)
     
216.     .否则
     
217.         加入成员 (文件数组, 局_文件名)
     
218.     .如果结束
     
219.     局_文件名 ＝ 寻找文件 (, )
     
220. .判断循环尾 ()
     
221. 返回 (取数组成员数 (文件数组))
     
222. 
     
223. .子程序 枚举窗口_强力, 整数型, , 返回句柄数目   可枚举隐藏窗口
     
224. .参数 保存数组, 窗口句柄类, 参考 可空 数组
     
225. .参数 只找可见窗口, 逻辑型, 可空
     
226. .参数 句柄保存数组, 整数型, 参考 可空 数组
     
227. .局部变量 句柄数组, 整数型, , "0"
     
228. .局部变量 句柄, 整数型
     
229. .局部变量 临时, 窗口句柄类
     
230. .局部变量 x, 整数型
     
231. 
     
232. 清除数组 (保存数组)
     
233. 清除数组 (句柄保存数组)
     
234. 句柄 ＝ GetWindow (API_取屏幕句柄 (), 5)
     
235. .判断循环首 (句柄 ≠ 0)
     
236.     .如果 (只找可见窗口)
     
237.         .如果真 (窗口是否可见 (句柄))
     
238.             加入成员 (句柄数组, 句柄)
     
239.         .如果真结束
     
240. 
     
241.     .否则
     
242.         加入成员 (句柄数组, 句柄)
     
243.     .如果结束
     
244.     句柄 ＝ GetWindow (句柄, 2)
     
245. .判断循环尾 ()
     
246. .计次循环首 (取数组成员数 (句柄数组), x)
     
247.     临时.句柄 ＝ 句柄数组 [x]
     
248.     临时.标题 ＝ 窗口取标题 (句柄数组 [x])
     
249.     临时.类名 ＝ 窗口取类名 (句柄数组 [x])
     
250.     .如果真 (是否为空 (句柄保存数组) ＝ 假)
     
251.         加入成员 (句柄保存数组, 临时.句柄)
     
252.     .如果真结束
     
253.     加入成员 (保存数组, 临时)
     
254. .计次循环尾 ()
     
255. 返回 (取数组成员数 (保存数组))
     
256. 
     
257. .子程序 窗口取类名, 文本型
     
258. .参数 窗口句柄, 整数型
     
259. .局部变量 buffer, 文本型
     
260. 
     
261. buffer ＝ 取空白文本 (255)
     
262. GetClassName (窗口句柄, buffer, 255)
     
263. 返回 (buffer)
     
264. 
     
265. .子程序 窗口取标题, 文本型
     
266. .参数 hWnd, 整数型
     
267. .局部变量 String, 文本型, , , 返回的文本内容
     
268. .局部变量 nLength, 整数型
     
269. 
     
270. nLength ＝ GetWindowTextLength (hWnd)
     
271. String ＝ 取空白文本 (nLength)
     
272. GetWindowText (hWnd, String, nLength ＋ 1)
     
273. 返回 (String)
     
274. 
     
275. .子程序 窗口是否可见, 逻辑型, , 返回真为可见，否则为不可见
     
276. .参数 窗口句柄, 整数型, , 窗口句柄
     
277. .局部变量 a, 逻辑型
     
278. 
     
279. 返回 (IsWindowVisible (窗口句柄))
     
280. 
     
281. .子程序 枚举所有子窗口_强力, 整数型
     
282. .参数 父窗口句柄, 整数型
     
283. .参数 保存数组, 窗口句柄类, 参考 可空 数组
     
284. .参数 只找可见窗口, 逻辑型, 可空
     
285. .参数 句柄保存数组, 整数型, 参考 可空 数组
     
286. .局部变量 句柄, 整数型
     
287. .局部变量 句柄数组, 整数型, , "0"
     
288. .局部变量 x, 整数型
     
289. .局部变量 临时, 窗口句柄类
     
290. .局部变量 需要整理, 逻辑型
     
291. 
     
292. 句柄 ＝ GetWindow (父窗口句柄, 5)
     
293. .判断循环首 (句柄 ≠ 0)
     
294.     .如果 (只找可见窗口)
     
295.         .如果真 (窗口是否可见 (句柄))
     
296.             加入成员 (句柄数组, 句柄)
     
297.         .如果真结束
     
298. 
     
299.     .否则
     
300.         加入成员 (句柄数组, 句柄)
     
301.     .如果结束
     
302.     递归 (句柄, 句柄数组, 只找可见窗口)
     
303.     句柄 ＝ GetWindow (句柄, 2)
     
304. .判断循环尾 ()
     
305. .如果真 (是否为空 (保存数组) ＝ 假)
     
306.     清除数组 (保存数组)
     
307.     .计次循环首 (取数组成员数 (句柄数组), x)
     
308.         临时.句柄 ＝ 句柄数组 [x]
     
309.         临时.标题 ＝ 窗口取标题 (句柄数组 [x])
     
310.         临时.类名 ＝ 窗口取类名 (句柄数组 [x])
     
311.         加入成员 (保存数组, 临时)
     
312.     .计次循环尾 ()
     
313. .如果真结束
     
314. 
     
315. .如果真 (是否为空 (句柄保存数组) ＝ 假)
     
316.     清除数组 (句柄保存数组)
     
317.     .计次循环首 (取数组成员数 (句柄数组), x)
     
318.         加入成员 (句柄保存数组, 句柄数组 [x])
     
319.     .计次循环尾 ()
     
320. .如果真结束
     
321. 返回 (取数组成员数 (句柄数组))
     
322. 
     
323. .子程序 递归
     
324. .参数 父窗口, 整数型
     
325. .参数 句柄数组, 整数型, 参考 数组
     
326. .参数 只找可见窗口, 逻辑型, 可空
     
327. .局部变量 句柄, 整数型
     
328. 
     
329. 句柄 ＝ GetWindow (父窗口, 5)
     
330. .判断循环首 (句柄 ≠ 0)
     
331.     .如果 (只找可见窗口)
     
332.         .如果真 (窗口是否可见 (句柄))
     
333.             加入成员 (句柄数组, 句柄)
     
334.         .如果真结束
     
335. 
     
336.     .否则
     
337.         加入成员 (句柄数组, 句柄)
     
338.     .如果结束
     
339.     递归 (句柄, 句柄数组)
     
340.     句柄 ＝ GetWindow (句柄, 2)
     
341. .判断循环尾 ()
     
342. 
     
343. 
     
344. .子程序 文本还原, 文本型
     
345. .参数 匿名参数_1, 字节集
     
346. .局部变量 匿名子程序变量_1, 字节集
     
347. 
     
348. 返回 (到文本 (子字节集替换 (匿名参数_1, { 43, 22, 64, 56, 60, 67, 191, 197 }, {  }, , )))
     

复制代码

冬夏

祝老哥发大财！！！

冬夏

谢谢老哥的分享