开源C++ DXF手动倍功源码

昨晚也不是我

开源C++ DXF手动倍功源码

1. #include<string>
   
2. #include<vector>
   
3. #include<Windows.h>
   
4. #include"BaseAddr.h"
   
5. using namespace std;
   
6. #define Base_NoticeCallAddr    0x002E1F260 //喇叭公告
   
7. #define Base_NoticeCallECXAddr 0x0062E04CC // 商店基质
   
8. 
   
9. CONST INT 技能CALL = 0x28D9EF0;
   
10. void Bulletin(wstring text);
    
11. 
    
12. BOOL Writebyte(int Addr, vector<byte> by)
    
13. {
    
14.         int len = by.size();
    
15.         byte *address = new byte[len];
    
16.         for (int i = 0; i < len; i++)
    
17.         {
    
18.                 address = by;
    
19.         }
    
20. 
    
21.         if (!WriteProcessMemory(GetCurrentProcess(), (LPVOID)Addr, address, len, 0))
    
22.         {
    
23.                 return FALSE;
    
24.         }
    
25.         else
    
26.         {
    
27.                 return TRUE;
    
28.         }
    
29. }
    
30. void 技能Call(int 触发指针, int 代码, int 伤害, int X, int Y, int Z)
    
31. {
    
32.          
    
33.         int 空白地址, 技能结构[25] = { 0 };
    
34.         技能结构[0] = 触发指针;
    
35.         技能结构[2] = 代码;
    
36.         技能结构[3] = 伤害;
    
37.         技能结构[6] = X;
    
38.         技能结构[7] = Y;
    
39.         技能结构[8] = Z;
    
40.         技能结构[15] = 0;
    
41.         空白地址 = (int)&技能结构;
    
42.         __asm
    
43.         {
    
44. 
    
45. mov ecx,空白地址
    
46. mov eax,技能CALL
    
47. call eax
    
48.         }
    
49. }
    
50. INT ReadIit(INT ADDR)
    
51. {
    
52.         INT 结果;
    
53.         if (!ReadProcessMemory(GetCurrentProcess(), (LPVOID)ADDR, &结果, 4, 0))
    
54.                 return 0;
    
55.         else
    
56.                 return 结果;
    
57. }
    
58. 
    
59. 
    
60. 
    
61. void 缓冲Call(int cpy)
    
62. {
    
63.         _asm
    
64.         {
    
65.                 push cpy
    
66.                 mov ecx, 发包基址
    
67.                 mov ecx, [ecx]
    
68.                 mov eax, 缓冲CALL
    
69.                 call eax
    
70.         }
    
71. }
    
72. 
    
73. void 发包Call()
    
74. {
    
75.         __asm
    
76.         {
    
77.                 mov eax, 发包CALL
    
78.                 call eax
    
79.         }
    
80. }
    
81. 
    
82. void 加密Call(int py, int size)
    
83. {
    
84.         int Com;
    
85.         if (size == 1)
    
86.         {
    
87.                 Com = 加密包CALL;
    
88.         }
    
89.         else if (size == 2)
    
90.         {
    
91.                 Com = 加密包CALL + 0x30;
    
92.         }
    
93.         else if (size == 4)
    
94.         {
    
95.                 Com = 加密包CALL + 0x60;
    
96.         }
    
97.         else if (size == 8)
    
98.         {
    
99.                 Com = 加密包CALL + 0x90;
    
100.         }
     
101.         __asm
     
102.         {
     
103.                 push py
     
104.                 mov ecx, 发包基址
     
105.                 mov ecx, [ecx]
     
106.                 call Com
     
107.         }
     
108. }
     
109. 
     
110. void 剑歌组包拾取(int 物品地址)
     
111. {
     
112.         缓冲Call(43);
     
113.         加密Call(物品地址, 4);
     
114.         加密Call(0, 1);
     
115.         加密Call(0, 1);   //（2，1）
     
116.         加密Call(0, 2);
     
117.         加密Call(0, 2);
     
118.         加密Call(0, 2);
     
119.         加密Call(0, 2);
     
120.         加密Call(0, 2);
     
121.         加密Call(0, 2);
     
122.         加密Call(0, 2);
     
123.         发包Call();
     
124. }
     
125. 
     
126. 
     
127. int 剑歌解密(int addr)
     
128. {
     
129.         int eax, esi, edx;
     
130.         eax = *(int*)addr;
     
131.         esi = *(int*)解密基址;
     
132.         edx = eax;
     
133.         edx >>= 16;
     
134.         edx = *(int*)(esi + edx * 4 + 36);
     
135.         eax = eax & 0xffff;
     
136.         eax = *(int*)(edx + eax * 4 + 8468);
     
137.         edx = WORD(eax);
     
138.         esi = edx;
     
139.         esi <<= 16;
     
140.         esi = esi ^ edx;
     
141.         edx = *(int*)(addr + 4);
     
142.         eax = esi ^ edx;
     
143.         return eax;
     
144. }
     
145. 
     
146. 
     
147. int 剑歌汇编加法(int t1, int t2)
     
148. {
     
149.         int sum;
     
150.         _asm
     
151.         {
     
152.                 mov eax, t1
     
153.                 mov ebx, t2
     
154.                 add eax, ebx
     
155.                 mov sum, eax
     
156.         }
     
157.         return sum;
     
158. }
     
159. 
     
160. 
     
161. BOOL 是否开门()
     
162. {
     
163.         int 人物指针, sum;
     
164.         人物指针 = *(int*)人物基址;
     
165.         sum = *(int*)剑歌汇编加法(人物指针, 地图偏移);
     
166.         if (剑歌解密(剑歌汇编加法(sum, 280)) == 0)
     
167.         {
     
168.                 return true;
     
169.         }
     
170.         else
     
171.         {
     
172.                 return false;
     
173.         }
     
174. }
     
175. 
     
176. 
     
177. 
     
178. BOOL 是否在城镇()
     
179. {
     
180.         int 人物指针, sum;
     
181.         人物指针 = *(int*)人物基址;
     
182.         sum = *(int*)剑歌汇编加法(人物指针, 地图偏移);
     
183.         if (sum == 0)
     
184.         {
     
185.                 return true;
     
186.         }
     
187.         else
     
188.         {
     
189.                 return false;
     
190.         }
     
191. }
     
192. void 剑歌拾取遍历()
     
193. {
     
194.         int 人物指针, 地图, 首地址1, 尾地址1, 物品数量, 物品计次 = 1, 临时地址, 物品类型, 阵营, 物品ID;
     
195.         if (是否在城镇() == TRUE)
     
196.         {
     
197.                 return;
     
198.         }
     
199.         人物指针 = *(int*)人物基址;
     
200.         地图 = *(int*)剑歌汇编加法(人物指针, 地图偏移);
     
201.         首地址1 = *(int*)剑歌汇编加法(地图, 首地址);
     
202.         尾地址1 = *(int*)剑歌汇编加法(地图, 尾地址);
     
203.         物品数量 = (尾地址1 - 首地址1) / 4;
     
204.         while (物品计次 <= 物品数量)
     
205.         {
     
206.                 临时地址 = *(int*)剑歌汇编加法(首地址1, 4 * 物品计次);
     
207.                 物品类型 = *(int*)剑歌汇编加法(临时地址, 类型偏移);
     
208.                 阵营 = *(int*)剑歌汇编加法(临时地址, 阵营偏移);
     
209.                 if (物品类型 == 289 && 阵营 == 200)
     
210.                 {
     
211.                         if (人物指针 != 临时地址)
     
212.                         {
     
213.                                 物品ID = 剑歌解密(临时地址 + 188);
     
214.                                 剑歌组包拾取(物品ID);
     
215.                         }
     
216. 
     
217.                 }
     
218.                 物品计次++;
     
219.         }
     
220. }
     
221. 
     
222. 
     
223. 
     
224. 
     
225. void 撿垃圾()
     
226. {
     
227. 
     
228.         if(是否开门()==TRUE)
     
229.         {
     
230.                 剑歌拾取遍历();
     
231. 
     
232.         }
     
233. }
     
234. 
     
235. void Send_发包()
     
236. {
     
237.         _asm
     
238.         {
     
239.                 mov eax, 发包CALL
     
240.                 call eax
     
241.         }
     
242. }
     
243. void  Send_加密Call(int 参数, int 长度)
     
244. {
     
245.         int 加密包Call;
     
246.         if (长度 == 1)
     
247.                 加密包Call = 加密包CALL;
     
248.         if (长度 == 2)
     
249.                 加密包Call = 加密包CALL + 48;
     
250.         if (长度 == 3)
     
251.                 加密包Call = 加密包CALL + 96;
     
252.         if (长度 == 4)
     
253.                 加密包Call = 加密包CALL + 144;
     
254.         
     
255. 
     
256.         _asm
     
257.         {
     
258.                 push 参数
     
259.                 mov ecx, 发包基址
     
260.                 mov ecx, [ecx]
     
261.                 mov eax, 加密包Call
     
262.                 call eax
     
263.         }
     
264. }
     
265. void Send_缓冲CALL(int 包头)
     
266. {
     
267. 
     
268.         _asm
     
269.         {       push 0x00000000
     
270.                 push 包头
     
271.                 mov ecx, 发包地址
     
272.                 mov ecx, [ecx]
     
273.                 mov eax, 缓冲CALL
     
274.                 call eax
     
275.         }
     
276. }
     
277. 
     
278. void 组包拾取(int 物品地址, int x, int y)
     
279. {
     
280. 
     
281.         int 物品X = x + 7;
     
282.         int 物品Y = y + 5;
     
283.         Send_缓冲CALL(43);
     
284.         Send_加密Call(物品地址, 4);
     
285.         Send_加密Call(0, 1);
     
286.         Send_加密Call(2, 1);
     
287.         Send_加密Call(x, 2);
     
288.         Send_加密Call(y, 2);
     
289.         Send_加密Call(0, 2);
     
290.         Send_加密Call(物品X, 2);
     
291.         Send_加密Call(物品Y, 2);
     
292.         Send_加密Call(0, 2);
     
293.         Send_加密Call(0, 2);
     
294.         Send_发包();
     
295. }
     
296. 
     
297. 
     
298. DWORD  WINAPI 按键线程(LPVOID Param)
     
299. {
     
300.         int hmodule, Tenrpcs;
     
301.         INT  P;//人物指针
     
302.         MSG msg = { 0 };
     
303.         RegisterHotKey(NULL, 0x24, 0, VK_HOME);
     
304.         RegisterHotKey(NULL, 0x70, 0, VK_F1);
     
305.         RegisterHotKey(NULL, 0x71, 0, VK_F2);
     
306.         RegisterHotKey(NULL, 0x72, 0, VK_F3);
     
307.         RegisterHotKey(NULL, 0x73, 0, VK_F4);
     
308.         RegisterHotKey(NULL, 0x74, 0, VK_END);
     
309.         RegisterHotKey(NULL, 0x80, 0, VK_F7);
     
310.         while (GetMessage(&msg, 0, 0, 0))
     
311.         {
     
312. 
     
313. 
     
314.                 if (WM_HOTKEY == msg.message)
     
315.                 {
     
316.                         if (VK_HOME == HIWORD(msg.lParam))
     
317.                         {
     
318.                                 RegisterHotKey(NULL, 0x74, 0, VK_F5);
     
319.                                 RegisterHotKey(NULL, 0x75, 0, VK_F6);
     
320.                                 RegisterHotKey(NULL, 0x81, 0, 'V');
     
321.                                 Bulletin(L"内心毫无波澜甚至笑出了声");
     
322.                                 Bulletin(L"F1  全屏钩子");
     
323.                                 Bulletin(L"F2  独家倍功");
     
324.                                 Bulletin(L"F3  技能无CD");
     
325.                                 Bulletin(L"F4  Hook技能");
     
326.                                 Bulletin(L"F6  人物无敌");
     
327.                                 Bulletin(L"F7  释放秒杀");
     
328.                                 Bulletin(L"End  自動入包");
     
329.                                 Bulletin(L"V  直接入包");
     
330.                                 Bulletin(L"Hello My Loneliness");
     
331.                                 //初始化TenRPCS.dll+1A6E90 - C3                    - ret
     
332.                                 //TenRPCS.dll+1A6ECB - E9 8D000000           - jmp TenRPCS.dll+1A6F5D
     
333. 
     
334. 
     
335.                                 hmodule = (int)GetModuleHandle(L"dnf.exe");
     
336.                                 Tenrpcs = (int)GetModuleHandle(L"TenRpcs.dll");
     
337.                                 Writebyte(Tenrpcs + 0x1A6E90, { 0xC3 });
     
338.                                 Writebyte(Tenrpcs + 0x1A6ECB, { 0xE9,0x8D,0x00,0x00,0x00 });
     
339.                                 //Writebyte(hmodule + 0x44B9BD2, {0x90 });//注释一条检测试试。
     
340.                                 WritePrivateProfileString(L"剑歌", L"技能代码", L"39002", L"C:\\Users\\Administrator\\Desktop\\剑歌.ini");
     
341.                         }
     
342.                 }
     
343.                 if (VK_END == HIWORD(msg.lParam))
     
344.                 {
     
345.                         SetTimer(NULL, 3, 1000, (TIMERPROC)撿垃圾);
     
346.                 }
     
347.                 if (VK_F1 == HIWORD(msg.lParam))
     
348.                 {
     
349. 
     
350.                         Writebyte(hmodule + 0x4C680, { 0xC3 });
     
351.                         Bulletin(L"全屏攻击  - Open");
     
352. 
     
353.                 }
     
354.                 if (VK_F2 == HIWORD(msg.lParam))
     
355.                 {
     
356.                         Writebyte(hmodule + 0x28286F9, { 0xB8,0x99,0x99,0x99 });//独家伤害基质
     
357.                         Bulletin(L"独家倍功  - Open");
     
358.                 }
     
359.                 if (VK_F3 == HIWORD(msg.lParam))
     
360.                 {
     
361.                         Writebyte(hmodule + 0x27E6F52, { 0xEB,0x33 });
     
362.                         Bulletin(L"技能无CD  - Open");
     
363.                 }
     
364. 
     
365.                 if (VK_F4 == HIWORD(msg.lParam))
     
366.                 {
     
367.                         Writebyte(hmodule + 0x32AFC49, { 0xE9,0xB2,0x0B,0xD5,0xFC });
     
368.                         Writebyte(hmodule + 0x32AFC4E, { 0x90 });
     
369.                         Writebyte(hmodule + 0x800, { 0xBA,0xD9,0x11,0x01,0x00 });
     
370.                         Writebyte(hmodule + 0x805, { 0xE9,0x45,0xF4,0x2A,0x03 });
     
371.                         
     
372.                         Bulletin(L"HOOK技能  - Open");
     
373.                 }
     
374.                 if (VK_F5 == HIWORD(msg.lParam))
     
375.                 {
     
376.                         
     
377.                 }
     
378.                 if (VK_F6 == HIWORD(msg.lParam))
     
379.                 {
     
380.                         P = ReadIit(0x642B240); //人物基质
     
381.                         P += 0xAA4;            //无敌偏移
     
382.                         Writebyte(P, { 100 });
     
383. 
     
384.                         Bulletin(L"无敌  - Open");
     
385.                 }
     
386.                
     
387.                         if (VK_F7 == HIWORD(msg.lParam))
     
388.                 {
     
389.                         技能Call(P, GetPrivateProfileInt(L"剑歌", L"技能代码", NULL, L"C:\\Users\\Administrator\\Desktop\\剑歌.ini"), 999999, 200, 500, 0);
     
390.         
     
391.                         Bulletin(L"释放Call  - Open");
     
392.                 }
     
393.                         
     
394.                         if ('V' == HIWORD(msg.lParam))
     
395.                         {
     
396. 
     
397.                                 剑歌拾取遍历();
     
398.                         }
     
399. 
     
400.         }
     
401. 
     
402.         return 0;
     
403. }
     
404. 
     
405. void Bulletin(wstring text)
     
406. {
     
407. 
     
408.         if (text.empty()) {
     
409.                 return;
     
410.         }
     
411. 
     
412.         wstring value = L"剑歌：2030757644 ";
     
413.         value += text;
     
414.         const TCHAR* txtAdr = value.c_str();
     
415. 
     
416.         __asm
     
417.         {
     
418.                 PUSH 0
     
419.                 PUSH 0
     
420.                 PUSH 0
     
421.                 PUSH 0
     
422.                 PUSH 0
     
423.                 PUSH 0x24//喇叭显示的位置
     
424.                 PUSH 0xFFFF00FF;//喇叭颜色
     
425.                 PUSH txtAdr;
     
426.                 MOV ECX, Base_NoticeCallECXAddr//商店基址
     
427.                 MOV ECX, [ECX]
     
428.                 MOV ECX, [ECX + 0x50]
     
429.                 MOV EAX, Base_NoticeCallAddr//喇叭公告
     
430.                 CALL EAX
     
431.         }
     
432. }
     
433. HANDLE hThreadapp;
     
434. BOOL WINAPI DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
     
435. {
     
436.         switch (ul_reason_for_call)
     
437.         {
     
438. 
     
439.         case DLL_PROCESS_ATTACH:
     
440.         {
     
441.         
     
442.              hThreadapp = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)按键线程, 0, 0, 0);
     
443.         }
     
444. 
     
445.         //break;
     
446.         case DLL_THREAD_ATTACH:
     
447.                 //break;
     
448.         case DLL_THREAD_DETACH:
     
449.                 //break;
     
450.         case DLL_PROCESS_DETACH:
     
451.                 break;
     
452.         }
     
453. 
     
454.         return  TRUE;
     
455. 
     
456. }

复制代码