具体操作如下：

在终端服务器上做如下修改
KEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\ Control\Terminal Server\Wds\rdpwd\Tds\tcp
和
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp
下都有一个PortNumber值，通常为3389，将其修改为自己的值，如9876(可自己指定端口，但最好不要设为低端端口，以免冲突)；

2.重新启动服务器。 

在客户端做如下改动 

1. 打开客户端连接管理器； 
2. 输入主机地址，后面跟端口号，例如: 202.100.4.15:9876

　　图1

　　通过这个命令，如果我们发现一个异常的端口号在监听，可以先去网上查找常见木马的端口号对照一下，如果发现有木马使用的端口，就应该用杀除木马的软件检查系统了。

　　二、关闭无用端口

　　知道怎么查看机器的端口情况之后，接下来一个问题是，哪些端口是必需的，哪些端口是可以关闭的？这个问题稍微复杂一点，因为除了Windows XP默认开放的135、137、138、139和445，有些跟网络有关的软件需要使用到一些端口，最常用的比如QQ使用4000端口。这里笔者把情况想像成最简单：一台只需要浏览网页的电脑。那么针对这个系统，我们自己来配置一下以提高安全性。

　　1、关闭软件开启的端口。可以打开本地连接的“属性→Internet协议（TCP/IP）→属性→高级→选项→TCP/IP筛选属性”，然后都选上“只允许”（如图2）。请注意，如果发现某个常用的网络工具不能起作用的时候，请搞清它在你主机所开的端口，然后在“TCP/IP筛选”中添加相应的端口。

　　图2

　　2、禁用NetBIOS。打开本地连接的“属性→Internet协议（TCP/IP）→属性→高级→WINS→禁用TCP/IP上的NetBIOS”（如图3）。这样一来就关闭了137、138以及139端口，从而预防IPC$入侵。

　　图3

　　3、开启Windows XP自带的网络防火墙。打开本地连接的“属性→高级”，启用防火墙之后，单击设置可以设置系统开放关闭哪些服务。一般来说，这些服务都可以不要，关闭这些服务后，这些服务涉及的端口就不会被轻易打开了。

　　4、禁用445端口。向注册表“HKEY_LO-CAL_MACHINE\SYSTEM\CurrentControlSet\Servi ces\NetBT\Parameters”中追加名为“SMBDeviceEnabled”的DWORD值，并将其设置为0，就好了。

　　通过以上设置，你的Windows XP系统的安全性将大大提高。要补充的是，文章是针对那些直接拨号上网的机器，而不包括通过网关代理上网的机器。

　　 2）使用socket函数得到socket句柄，m_hSocket:=Socket(AF_INET, SOCK_RAW, IPPROTO_IP); 用法如下：

　　在程序里m_hSocket为socket句柄，AF_INET，SOCK_RAW，IPPROTO_IP均为常量。

　　3)定义SOCK_ADDR类型，跟据我们的网卡IP给Sock_ADDR类型附值，然后我们使用bind函数来绑定我们的网卡，Bind函

数用法如下：

4)用WSAIoctl来注册WSA的输入输出组件，其用法如下：

　　5)下面做死循环，在死循环块里，来实现数据的接收。但是徇环中间要用Sleep()做延时，不然程序会出错。

　　6)在循环块里，用recv函数来接收数据，recv函数用法如下：

　　7)在buffer里就是我们接收回来的数据了，如果我们想要知道数据是什么地方发来的，那么，我们要定义一定IP包结

构，用CopyMemory()把IP信息从buffer里面读出来就可以了，不过读出来的是十六进制的数据需要转换一下。

　　看了封包捕获的全过程序，对你是不是有点起发，然而在这里要告诉大家的是封包的获得是很容易的，但是许多游戏

的封包都是加密的，如果你想搞清楚所得到的是什么内容还需要自己进行封包解密。

四种网络游戏外挂的设计方法

[文章导读]
 
在几年前我看到别人玩网络游戏用上了外挂，做为程序员的我心里实在是不爽

在几年前我看到别人玩网络游戏用上了外挂，做为程序员的我心里实在是不爽，想搞清楚这到底是怎么回事。就拿了一些

来研究，小有心得，拿出来与大家共享，外挂无非就是分几种罢了（依制作难度）：

　1、动作式，所谓动作式，就是指用API发命令给窗口或API控制鼠标、键盘等，使游戏里的人物进行流动或者攻击，最

早以前的“石器”外挂就是这种方式。（这种外挂完全是垃圾，TMD，只要会一点点API的人都知道该怎么做，不过这种外

挂也是入门级的好东东，虽然不能提高你的战斗力，但是可以提高你的士气）

　　2、本地修改式，这种外挂跟传统上的一些游戏修改器没有两样，做这种外挂在编程只需要对内存地址有一点认识并

且掌握API就可以实现，“精灵”的外挂这是这种方式写成的，它的难点在于找到那些地址码，找地址一般地要借助于别

人的工具，有的游戏还有双码校验，正正找起来会比较困难。（这种外挂，比上一种有一点点难度，但是这种外挂做起来

能够用，也是有一定难度的啦~~，这种外挂可以很快提升你对内存地址的理解及应用，是你编程技术提高的好东东）

　　3、木马式，这种外挂的目的是帮外挂制作者偷到用户的密码（TMD，“烂”就一个字，不过要知已知彼所以还是要谈

一下啦~~），做这种外挂有一定的难度，需要HOOK或键盘监视技术做底子，才可以完成，它的原理是先首截了用户的帐号

或密码，然后发到指定邮箱。（我以前写过这样的东东，但是从来没有用过，我知道这种东东很不道德，所以以后千万别

用呀！）

　　4、加速式，这种外挂可以加快游戏的速度……（对不起大家，这种东东我没有实际做过，所以不能妄自评，惭愧）

　　这几种外挂之中，前三种可以用VB，Delphi等语言比较好实现，后两种则要用VC等底层支持比较好的编程工具才好实

现。

　　动作式外挂

　　首先，先来谈一下动作式的外挂，这也是我第一次写外挂时做的最简单的一种。

　　记得还在“石器”时代的时候，我看到别人挂着一种软件（外挂）人物就可以四外游走（当时我还不知道外挂怎么回

事），于是找了这种软件过来研究（拿来后才听别人说这叫外挂），发现这种东东其实实现起来并不难，仔佃看其实人物

的行走无非就是鼠标在不同的地方点来点去而已，看后就有实现这功能的冲动，随后跑到MSDN上看了一些资料，发现这种

实现这几个功能，只需要几个简单的API函数就可以搞定：

　　1、首先我们要知道现在鼠标的位置（为了好还原现在鼠标的位置）所以我们就要用到API函数GetCursorPos，它的使

用方法如下：

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

下：

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

　　在它的dwFlags处，可用的事件很多如移动MOUSEEVENTF_MOVE，左键按下MOUSEEVENTF_LEFTDOWN，左键放开

MOUSEEVENTF_LEFTUP，具体的东东还是查一下MSDN吧~~~~~

　　 好了，有了前面的知识，我们就可以来看看人物移走是怎么实现的了：

　　看了以上的代码，是不是觉得人物的游走很简单啦~~，举一仿三，还有好多好东东可以用这个技巧实现（我早就说过

，TMD，这是垃圾外挂的做法，相信了吧~~~），接下来，再看看游戏里面自动攻击的做法吧（必需游戏中攻击支持快捷键

的），道理还是一样的，只是用的API不同罢了~~~，这回我们要用到的是keybd_event函数，其用法如下：

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

下：

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

　　首先模拟按下了CTRL键，再模拟按下A键，再模拟放开A键，最后放开CTRL键，这就是一个模拟按快捷键的周期。

　　（看到这里，差不多对简易外挂有了一定的了解了吧~~~~做一个试试？如果你举一仿三还能有更好的东东出来，这就

要看你的领悟能力了~~，不过不要高兴太早这只是才开始，以后还有更复杂的东东等着你呢~~）

本地修改式外挂

　　现在我们来看看，比动作式外挂更进一步的外挂——本地修改式外挂的整个制作过程进行一个详细的分解。

　　具我所知，本地修改式外挂最典型的应用就是在“精灵”游戏上面，因为我在近一年前（“精灵”还在测试阶段），

我所在的公司里有很多同事玩“精灵”，于是我看了一下游戏的数据处理方式，发现它所发送到服务器上的信息是存在于

内存当中（我看后第一个感受是：修改这种游戏和修改单机版的游戏没有多大分别，换句话说就是在他向服务器提交信息

之前修改了内存地址就可以了），当时我找到了地址于是修改了内存地址，果然，按我的想法修改了地址，让系统自动提

交后，果然成功了~~~~~，后来“精灵”又改成了双地址校检，内存校检等等，在这里我就不废话了~~~~，OK，我们就来

看看这类外挂是如何制作的：

　　在做外挂之前我们要对Windows的内存有个具体的认识，而在这里我们所指的内存是指系统的内存偏移量，也就是相

对内存，而我们所要对其进行修改，那么我们要对几个Windows API进行了解，OK，跟着例子让我们看清楚这种外挂的制

作和API的应用（为了保证网络游戏的正常运行，我就不把找内存地址的方法详细解说了）：

　　1、首先我们要用FindWindow,知道游戏窗口的句柄，因为我们要通过它来得知游戏的运行后所在进程的ID，下面就是

FindWindow的用法：

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

DWORD GetWindowThreadProcessId(

HWND hWnd, // handle of window
LPDWORD lpdwProcessId // address of variable for process identifier
);

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

　　在dwDesiredAccess之处就是设存取方式的地方，它可设的权限很多，我们在这里使用只要使用PROCESS_ALL_ACCESS

来打开进程就可以，其他的方式我们可以查一下MSDN。

　　4、打开进程后，我们就可以用函数对存内进行操作，在这里我们只要用到WriteProcessMemory来对内存地址写入数

据即可（其他的操作方式比如说：ReadProcessMemory等，我在这里就不一一介绍了），我们看一下WriteProcessMemory

的用法：

　　5、下面用CloseHandle关闭进程句柄就完成了。

　　这就是这类游戏外挂的程序实现部份的方法，好了，有了此方法，我们就有了理性的认识，我们看看实际例子，提升

一下我们的感性认识吧，下面就是XX游戏的外挂代码，我们照上面的方法对应去研究一下吧：

　　这个游戏是用了多地址对所要提交的数据进行了校验，所以说这类游戏外挂制作并不是很难，最难的是要找到这些地

址。

木马式外挂

　　木马式外挂，可能大多像木马吧，是帮助做外挂的人偷取别人游戏的帐号及密码的东东。因为网络上有此类外挂的存

在，所以今天不得不说一下（我个人是非常讨厌这类外挂的，请看过本文的朋友不要到处乱用此技术，谢谢合作）。要做

此类外挂的程序实现方法很多（比如HOOK，键盘监视等技术），因为HOOK技术对程序员的技术要求比较高并且在实际应用

上需要多带一个动态链接库，所以在文中我会以键盘监视技术来实现此类木马的制作。键盘监视技术只需要一个.exe文件

就能实现做到后台键盘监视，这个程序用这种技术来实现比较适合。

　　在做程序之前我们必需要了解一下程序的思路：

　　1、我们首先知道你想记录游戏的登录窗口名称。

　　2、判断登录窗口是否出现。

　　3、如果登录窗口出现，就记录键盘。

　　4、当窗口关闭时，把记录信息，通过邮件发送到程序设计者的邮箱。

　　第一点我就不具体分析了，因为你们比我还要了解你们玩的是什么游戏，登录窗口名称是什么。从第二点开始，我们

就开始这类外挂的程序实现之旅：

　　那么我们要怎么样判断登录窗口虽否出现呢？其实这个很简单，我们用FindWindow函数就可以很轻松的实现了：

　　实际程序实现中，我们要找到'xx'窗口，就用FindWindow(nil,'xx')如果当返回值大于0时表示窗口已经出现，那么

我们就可以对键盘信息进行记录了。

　　先首我们用SetWindowsHookEx设置监视日志，而该函数的用法如下：

　　在这里要说明的是在我们程序当中我们要对HOOKPROC这里我们要通过写一个函数，来实现而HINSTANCE这里我们直接

用本程序的HINSTANCE就可以了，具体实现方法为：

　　而HOOKPROC里的函数就要复杂一点点：

　　以上就是记录键盘的整个过程，简单吧，如果记录完可不要忘记释放呀，UnHookWindowsHookEx(hHook)，而hHOOK,就

是创建setwindowshookex后所返回的句柄。

　　我们已经得到了键盘的记录，那么现在最后只要把记录的这些信息发送回来，我们就大功造成了。其他发送这块并不

是很难，只要把记录从文本文件里边读出来，用DELPHI自带的电子邮件组件发一下就万事OK了。代码如下：

　　这个程序全部功能已经实现，编编试试。

加速型外挂

　　原本我一直以为加速外挂是针对某个游戏而写的，后来发现我这种概念是不对的，所谓加速外挂其实是修改时钟频率

达到加速的目的。

　　以前DOS时代玩过编程的人就会马上想到，这很简单嘛不就是直接修改一下8253寄存器嘛，这在以前DOS时代可能可以

行得通，但是windows则不然。windows是一个32位的操作系统，并不是你想改哪就改哪的（微软的东东就是如此霸气，说

不给你改就不给你改），但要改也不是不可能，我们可以通过两种方法来实现：第一是写一个硬件驱动来完成，第二是用

Ring0来实现（这种方法是CIH的作者陈盈豪首用的，它的原理是修改一下IDE表->创建一个中断门->进入Ring0->调用中断

修改向量，但是没有办法只能用ASM汇编来实现这一切*_*，做为高级语言使用者惨啦！），用第一种方法用点麻烦，所以

我们在这里就用第二种方法实现吧~~~

　　在实现之前我们来理一下思路吧：

　　1、我们首先要写一个过程在这个过程里嵌入汇编语言来实现修改IDE表、创建中断门，修改向量等工作

　　2、调用这个过程来实现加速功能

　　好了，现在思路有了，我们就边看代码边讲解吧：

　　首先我们建立一个过程，这个过程就是本程序的核心部份：

　　最核心的东西已经写完了，大部份读者是知其然不知其所以然吧，呵呵，不过不知其所以然也然。下面我们就试着用

一下这个过程来做一个类似于“变速齿轮”的一个东东吧！

　　先加一个窗口，在窗口上放上一个trackbar控件把其Max设为20，Min设为1，把Position设为10，在这个控件的

Change事件里写上：

　　因为windows默认的值为$1742，所以我们把1742做为基数，又因为值越小越快，反之越慢的原理，所以写了这样一个

公式，好了，这就是“变速齿轮”的一个Delphi＋ASM版了（只适用于win9X），呵呵，试一下吧，这对你帮助会很大的，

呵呵。

　　在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、我们在我们新建的工程加入我们的接口文件

　　3、我们建立一个过程

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

Change事件里写上：

　　就这么容易。

在内存中修改数据的网游外挂

[文章导读]
 
现在很多游戏都是把一些信息存入内存单元的，那么我们只需要修改具体内存值就能修改游戏中的属性，很多网络游戏也

不外于此

　　现在很多游戏都是把一些信息存入内存单元的，那么我们只需要修改具体内存值就能修改游戏中的属性，很多网络游

戏也不外于此。

　　曾几何时，一些网络游戏也是可以用内存外挂进行修改的，后来被发现后，这些游戏就把单一内存地址改成多内存地

址校验，加大了修改难度，不过仍然可以通过内存分析器可以破解的。诸如“FPE”这样的软件便提供了一定的内存分析

功能。

　　“FPE”是基于内存外挂的佼佼者，是家喻户晓的游戏修改软件。很多同类的软件都是模仿“FPE”而得到玩家的认可

。而“FPE”实现的技术到现在都没有公开，很多人只能够通过猜测“FPE”的实现方法，实现同类外挂。笔者也曾经模仿

过“FPE”实现相应的功能，如“内存修改”、“内存查询”等技术。稍后会对此技术进行剖析。

　　既然要做内存外挂，那么就必须对Windows的内存机制有所了解。计算机的内存(RAM)总是不够用的，在操作系统中内

存就有物理内存和虚拟内存之分，因为程序创建放入物理内存的地址都是在变化的，所以在得到游戏属性时并不能够直接

访问物理内存地址。在v86模式下，段寄存器使用方法与实模式相同，那么可以通过段寄存器的值左移4位加上地址偏移量

就可以得到线性地址，而程序创建时在线性地址的中保留4MB-2GB的一段地址，游戏中属性便放于此。在windows中把虚拟

内存块称之为页，而每页为4KB，在访问内存时读取游戏属性时，为了不破坏数据完整性的快速浏览内存地址值，最好一

次访问一页。

　　在操作进程内存时，不需要再使用汇编语言，Windows中提供了一些访问进程内存空间的API，便可以直接对进程内存

进行操作。但初学者一般掌握不了这一项技术，为了使初学者也能够对内存进行操作，做出基于内存控制的外挂，笔者把

一些内存操作及一些内存操作逻辑进行了封装，以控件形式提供给初学者。控件名为：MpMemCtl。

　　初学者在使用此控件时，要先安装外挂引擎控件包（在此后的每篇文章中外挂引擎控件包仅提供与该文章相应的控制

控件），具体控件安装方式，请参阅《Delphi指南》，由于篇幅所限，恕不能详细提供。

　　在引擎安装完成后，便可以在Delphi中的组件栏内，找到[MP GameControls]控件组，其中可以找到[MpMemCtl]控件

。初学者可以使用此控件可以对内存进行控制。

　　一、 得到进程句柄

　　需要操作游戏内存,那么首先必须确认要操作的游戏,而游戏程序在运行时所产生的每一个进程都有一个唯一的句柄。

　　使用控件得到句柄有三种方法：

　　1、 通过控件打开程序得到句柄。

　　在控件中，提供了startProgram方法，通过该方法，可以打开程序得到进程句柄，并且可以返回进程信息。

　　该方法提供了两个参数，第一个参数为要打开的程序路径，第二个参数为打开程序后所创建进程的进程信息。使用这

个方法在得到进程信息的同时，并给控件的ProcHandle（进程句柄）属性进行了附值，这时可以使用控件直接对内存进程

读写操作。其应用实例如下：

　　2、通过控件根据程序名称得到句柄。

　　在控件中，对系统运行进程也有了相应的描述，控件提供了两个方法，用于根据程序名称得到相应的进程句柄。

getProcIDs()可以得到系统现在所运行的所有程序的名称列表。getProcID()可以通过所运行程序名称，得到相应进程的

句柄。

　　其应用实例如下：

　　首先可以通过getProcIDs()并把参数列表返回ComboBox1.Items里：

　　接着可以通过getProcID()得到相应的进程句柄，并给控件的ProcHandle（进程句柄）属性进行了附值，这时可以使

用控件直接对内存进程读写操作。

　　3、通过控件根据窗口名称得到句柄。

　　在控件中，控件提供了两个方法，用于根据窗口名称得到相应的进程句柄。可以通过getALLWindow()得到所有在进程

中运行的窗口。getWinProcHandle()可以通过相应的窗口名称，得到相应的进程的句柄。

　　其应用实例如下：

　　首先可以通过getALLWindow ()并把参数列表返回ComboBox1.Items里：

　　接着可以通过getWinProcHandle ()得到相应的进程句柄，并给控件的ProcHandle（进程句柄）属性进行了附值，这

时可以使用控件直接对内存进程读写操作。

　　二、使游戏暂停

　　在程序中，为了便于更好的得到游戏的当前属性。在控件中提供了游戏暂停方法。只需要调用该方法，游戏便可以自

由的暂停或启动。该方法为：pauseProc()

　　控制类型只能够传入参数0或1，0代表使游戏暂停，1代表取消暂停。其应用实例如下：

　　三、读写内存值

　　游戏属性其实寄存在内存地址值里，游戏中要了解或修改游戏属性，可以通过对内存地值的读出或写入完成。

　　通过控件，要读写内存地址值很容易。可以通过调用控件提供的getAddressValue（）及setAddressValue（）两个方

法即可，在使用方法之前，要确认的是要给ProcHandle属性进行附值，因为对内存的操作必须基于进程。给ProcHandle属

性附值的方法，在上文中已经介绍。无论是对内存值进行读还是进行写，都要明确所要操作的内存地址。

　　要注意的是，传入内存地址时，内存地址必须为Pointer型。其应用实例如下：

　　读取地址值（如果“主角”等级所存放的地址为4549632）：

　　这时aValue变量里的值为内存地址[4549632]的值。

　　写入地址值：

　　通过该方法可以把要修改的内存地址值改为87，即把“主角”等级改为87。

　　四、内存地址值分析

　　在游戏中要想要到游戏属性存放的内存地址，那么就对相应内存地址进行内存分析，经过分析以后才可得到游戏属性

存放的人存地址。

　　控件提供两种基于内存地址的分析方法。一种是按精确地址值进行搜索分析，另一种是按内存变化增减量进行搜索分

析。

　　1、 如果很明确的知道当前想要修改的地址值，那么就用精确地址值进行搜索分析

　　在游戏中，需要修改人物的经验值，那么首先要从游戏画面上获得经验值信息，如游戏人物当前经验值为9800，需要

把经验值调高，那么这时候就需要对人物经验值在内存中搜索得到相应的内存地址，当然很可能在内存中地址值为9800的

很多，第一次很可能搜索出若干个地址值为9800的地址。等待经验值再有所变化，如从9800变为了20000时，再次进行搜

索，那么从刚刚所搜索到的地址中，便可以进一步获得范围更少的内存地址，以此类推，那么最后可得到经验值具体存放

的地址。

　　如要用控件来实现内存值精确搜索，其实方法很简单，只需要调用该控件的Search（）方法即可。但是在搜索之前要

确认搜索的范围，正如前文中所说：“而程序创建时在线性地址的中保留4MB-2GB的一段地址”，所以要搜索的地址应该

是4MB-2GB之间，所以要把控件的MaxAddress属性设为2GB，把控件的MinAddress属性设为4MB。还有一个需要确认的是需

要搜索的值，那么应该把SearchValue属性设置为当前搜索的值。如果需要显示搜索进度那么可以把ShowGauge属性挂上一

个相应的TGauge控件（该控件为进度条控件）。

　　在搜索分析时为了提高搜索效率、实现业务逻辑，那么需要传入一个参数，从而确认是否是第一次进行内存。其应用

实例如下：

　　2、 如果不明确当前想要修改的地址值，只知道想要修改的值变大或变小，那么就按内存变化增减量进行搜索分析。

　　如有些游戏的人物血值不显示出来，但要对人物血值进行修改，那么只有借助于内存量增减变化而进行搜索分析出该

人物血值存放的地址。如果人物被怪物打了一下，那么人物血值就会减少，那么这时候就用减量进行搜索分析，如果人物

吃了“血”人物血值就会增加，那么这时候就用增量进行搜索分析。经过不断搜索，最后会把范围放血值的内存地址给搜

索出来。

　　如要用控件来实现内存值精确搜索，其实方法很简单，只需要调用该控件的compare()方法即可。MaxAddress、

MinAddress属性设置上面章节中有详细介绍，在此不再重提。在此分析中不需要再指定SearchValue属性。如果需要显示

搜索进度那么可以把ShowGauge属性挂上一个相应的TGauge控件。

　　在搜索分析时为了提高搜索效率、实现业务逻辑，那么需要传入一个参数，从而确认是否是第一次进行内存。搜索分

析类型有两种：如果参数值为0，那么就代表增量搜索。如果参数值为1，那么就代表减量搜索。其应用实例如下：

　　五、得到内存地址值

　　在控件中，提供获得分析后内存地址列表的方法，只需要调用getAddressList()方法，便可以获得分析过程中或分析

结果地址列表。但如果使用的是按内存变化增减量进行搜索分析的方法，那么第一次可能会搜索出来很多的地址，致使返

回速度过长，那么建议使用getAddressCount（）方法确定返回列表为一定长度后才给予返回。

　　其应用实例如下：

　　通过以上五个步骤，便可以整合成一个功能比较完备的，基于内存控制方法的游戏外挂。有了“FPE”的关键部份功

能。利用此工具，通过一些方法，不仅仅可以分析出来游戏属性单内存地址，而且可以分析出一部份多内存游戏属性存放

地址。

存在两种字节顺序：NBO与HBO

网络字节顺序NBO（Network Byte Order）：
按从高到低的顺序存储，在网络上使用统一的网络字节顺序，可以避免兼容性问题。

主机字节顺序（HBO，Host Byte Order）：
不同的机器HBO不相同，与CPU设计有关

计算机数据存储有两种字节优先顺序：高位字节优先和低位字节优先。Internet上数据以高位字节优先顺序在网络上传输，所以对于在内部是以低位字节优先方式存储数据的机器，在Internet上传输数据时就需要进行转换。
　　我们要讨论的第一个结构类型是：struct sockaddr，该类型是用来保存socket信息的：
　　struct sockaddr {
　　unsigned short sa_family; /* 地址族， AF_xxx */
　 char sa_data[14]; /* 14 字节的协议地址 */ };
　　sa_family一般为AF_INET；sa_data则包含该socket的IP地址和端口号。
　　另外还有一种结构类型：
　　struct sockaddr_in {
　　 short int sin_family; /* 地址族 */
　　 unsigned short int sin_port; /* 端口号 */
　　 struct in_addr sin_addr; /* IP地址 */
　　 unsigned char sin_zero[8]; /* 填充0 以保持与struct sockaddr同样大小 */
　　};
　　这个结构使用更为方便。sin_zero(它用来将sockaddr_in结构填充到与struct sockaddr同样的长度)应该用bzero()或memset()函数将其置为零。指向sockaddr_in 的指针和指向sockaddr的指针可以相互转换，这意味着如果一个函数所需参数类型是sockaddr时，你可以在函数调用的时候将一个指向sockaddr_in的指针转换为指向sockaddr的指针；或者相反。sin_family通常被赋AF_INET；sin_port和sin_addr应该转换成为网络字节优先顺序；而sin_addr则不需要转换。
　　我们下面讨论几个字节顺序转换函数：
　　htons()--"Host to Network Short" ; htonl()--"Host to Network Long"
　　ntohs()--"Network to Host Short" ; ntohl()--"Network to Host Long"
　　在这里， h表示"host" ，n表示"network"，s 表示"short"，l表示 "long"。
　　打开socket 描述符、建立绑定并建立连接
　　socket函数原型为：
　　int socket(int domain, int type, int protocol);
　　domain参数指定socket的类型：SOCK_STREAM 或SOCK_DGRAM；protocol通常赋值“0”。Socket()调用返回一个整型socket描述符，你可以在后面的调用使用它。
　　一旦通过socket调用返回一个socket描述符，你应该将该socket与你本机上的一个端口相关联（往往当你在设计服务器端程序时需要调用该函数。随后你就可以在该端口监听服务请求;而客户端一般无须调用该函数）。 Bind函数原型为：
　　int bind(int sockfd,struct sockaddr *my_addr, int addrlen);
　　Sockfd是一个socket描述符，my_addr是一个指向包含有本机IP地址及端口号等信息的sockaddr类型的指针;addrlen常被设置为sizeof(struct sockaddr)。
　　最后，对于bind 函数要说明的一点是，你可以用下面的赋值实现自动获得本机IP地址和随机获取一个没有被占用的端口号：
　　my_addr.sin_port = 0; /* 系统随机选择一个未被使用的端口号 */
　　my_addr.sin_addr.s_addr = INADDR_ANY; /* 填入本机IP地址 */
　　通过将my_addr.sin_port置为0，函数会自动为你选择一个未占用的端口来使用。同样，通过将my_addr.sin_addr.s_addr置为INADDR_ANY，系统会自动填入本机IP地址。Bind()函数在成功被调用时返回0；遇到错误时返回“-1”并将errno置为相应的错误号。另外要注意的是，当调用函数时，一般不要将端口号置为小于1024的值，因为1~1024是保留端口号，你可以使用大于1024中任何一个没有被占用的端口号。
　　Connect()函数用来与远端服务器建立一个TCP连接，其函数原型为：
　　int connect(int sockfd, struct sockaddr *serv_addr, int addrlen);
　　Sockfd是目的服务器的sockt描述符；serv_addr是包含目的机IP地址和端口号的指针。遇到错误时返回-1，并且errno中包含相应的错误码。进行客户端程序设计无须调用bind()，因为这种情况下只需知道目的机器的IP地址，而客户通过哪个端口与服务器建立连接并不需要关心，内核会自动选择一个未被占用的端口供客户端来使用。
　　Listen()——监听是否有服务请求
　　在服务器端程序中，当socket与某一端口捆绑以后，就需要监听该端口，以便对到达的服务请求加以处理。
　　int listen(int sockfd， int backlog);
　　Sockfd是Socket系统调用返回的socket 描述符；backlog指定在请求队列中允许的最大请求数，进入的连接请求将在队列中等待accept()它们（参考下文）。Backlog对队列中等待服务的请求的数目进行了限制，大多数系统缺省值为20。当listen遇到错误时返回-1，errno被置为相应的错误码。
　　故服务器端程序通常按下列顺序进行函数调用：
　　socket(); bind(); listen(); /* accept() goes here */
　　accept()——连接端口的服务请求。
　　当某个客户端试图与服务器监听的端口连接时，该连接请求将排队等待服务器accept()它。通过调用accept()函数为其建立一个连接，accept()函数将返回一个新的socket描述符，来供这个新连接来使用。而服务器可以继续在以前的那个 socket上监听，同时可以在新的socket描述符上进行数据send()（发送）和recv()（接收）操作：
　　int accept(int sockfd, void *addr, int *addrlen);
　　sockfd是被监听的socket描述符，addr通常是一个指向sockaddr_in变量的指针，该变量用来存放提出连接请求服务的主机的信息（某台主机从某个端口发出该请求）；addrten通常为一个指向值为sizeof(struct sockaddr_in)的整型指针变量。错误发生时返回一个-1并且设置相应的errno值。
　　Send()和recv()——数据传输
　　这两个函数是用于面向连接的socket上进行数据传输。
　　Send()函数原型为：
　　int send(int sockfd, const void *msg, int len, int flags);
　　Sockfd是你想用来传输数据的socket描述符，msg是一个指向要发送数据的指针。
　　Len是以字节为单位的数据的长度。flags一般情况下置为0（关于该参数的用法可参照man手册）。
　　char *msg = "Beej was here!"; int len， bytes_sent; ... ...
　　len = strlen(msg); bytes_sent = send(sockfd, msg,len,0); ... ...
　　Send()函数返回实际上发送出的字节数，可能会少于你希望发送的数据。所以需要对send()的返回值进行测量。当send()返回值与len不匹配时，应该对这种情况进行处理。
　　recv()函数原型为：
　　int recv(int sockfd,void *buf,int len,unsigned int flags);
　　Sockfd是接受数据的socket描述符；buf 是存放接收数据的缓冲区；len是缓冲的长度。Flags也被置为0。Recv()返回实际上接收的字节数，或当出现错误时，返回-1并置相应的errno值。
　　Sendto()和recvfrom()——利用数据报方式进行数据传输
　　在无连接的数据报socket方式下，由于本地socket并没有与远端机器建立连接，所以在发送数据时应指明目的地址，sendto()函数原型为：
　　int sendto(int sockfd, const void *msg,int len,unsigned int flags,const struct sockaddr *to, int tolen);
　　该函数比send()函数多了两个参数，to表示目地机的IP地址和端口号信息，而tolen常常被赋值为sizeof (struct sockaddr)。Sendto 函数也返回实际发送的数据字节长度或在出现发送错误时返回-1。
　　Recvfrom()函数原型为：
　　int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct sockaddr *from,int *fromlen);
　　from是一个struct sockaddr类型的变量，该变量保存源机的IP地址及端口号。fromlen常置为sizeof (struct sockaddr)。当recvfrom()返回时，fromlen包含实际存入from中的数据字节数。Recvfrom()函数返回接收到的字节数或当出现错误时返回-1，并置相应的errno。
　　应注意的一点是，当你对于数据报socket调用了connect()函数时，你也可以利用send()和recv()进行数据传输，但该socket仍然是数据报socket，并且利用传输层的UDP服务。但在发送或接收数据报时，内核会自动为之加上目地和源地址信息。
　　Close()和shutdown()——结束数据传输
　　当所有的数据操作结束以后，你可以调用close()函数来释放该socket，从而停止在该socket上的任何数据操作：close(sockfd);
　　你也可以调用shutdown()函数来关闭该socket。该函数允许你只停止在某个方向上的数据传输，而一个方向上的数据传输继续进行。如你可以关闭某socket的写操作而允许继续在该socket上接受数据，直至读入所有数据。
　　int shutdown(int sockfd,int how);
　　Sockfd的含义是显而易见的，而参数 how可以设为下列值：
　　·0-------不允许继续接收数据
　　·1-------不允许继续发送数据
　　·2-------不允许继续发送和接收数据，均为允许则调用close ()
　　shutdown在操作成功时返回0，在出现错误时返回-1（并置相应errno）。
　　DNS——域名服务相关函数
　　由于IP地址难以记忆和读写，所以为了读写记忆方便，人们常常用域名来表示主机，这就需要进行域名和IP地址的转换。函数gethostbyname()就是完成这种转换的，函数原型为：
　　struct hostent *gethostbyname(const char *name);
　　函数返回一种名为hosten的结构类型，它的定义如下：
　　struct hostent {
　　 char *h_name; /* 主机的官方域名 */
　　 char **h_aliases; /* 一个以NULL结尾的主机别名数组 */
　　 int h_addrtype; /* 返回的地址类型，在Internet环境下为AF-INET */
　　 int h_length; /*地址的字节长度 */
　　 char **h_addr_list; /* 一个以0结尾的数组，包含该主机的所有地址*/
　　};
　#define h_addr h_addr_list[0] /*在h-addr-list中的第一个地址*/

2、将主机的unsigned long值转换为网络字节顺序(32位)：为什么要这样做呢？因为不同的计算机使用不同的字节顺序存储数据。因此任何从Winsock函数对IP地址和端口号的引用和传给Winsock函数的IP地址和端口号均时按照网络顺序组织的。
      u_long  htonl(u_long hostlong);
      举例：htonl(0)=0
      htonl(80)= 1342177280

3、将unsigned long数从网络字节顺序转换位主机字节顺序，是上面函数的逆函数。       u_long  ntohl(u_long netlong);
      举例：ntohl(0)=0
      ntohl(1342177280)= 80

4、将主机的unsigned short值转换为网络字节顺序(16位)：原因同2：       u_short  htons(u_short hostshort);
      举例：htonl(0)=0
      htonl(80)= 20480

5、将unsigned short数从网络字节顺序转换位主机字节顺序，是上面函数的逆函数。       u_short  ntohs(u_short netshort);
      举例：ntohs(0)=0
      ntohsl(20480)= 80

　　接着，我们还需要创建一个外壳程序将全局钩子安装了Windows系统中，这个外壳程序编写步骤如下：

　　(1).创建一个对话框模式的应用程序，项目名为Simulate。

　　(2).在主对话框中加入一个按钮，使用ClassWizard为其创建CLICK事件。

　　(3).将ActiveKey项目Debug目录下的ActiveKey.DLL和ActiveKey.lib拷贝到Simulate项目目录下。

　　(4).从“工程”菜单中选择“设置”，弹出Project Setting对话框，选择Link标签，在“对象/库模块”中输入

ActiveKey.lib。

　　(5).将ActiveKey项目中的ActiveKey.h头文件加入到Simulate项目中，并在Stdafx.h中加入#include ActiveKey.h。

　　(6).在按钮单击事件函数输入如下代码：

　　　void CSimulateDlg::OnButton1()
　　　{
// TODO: Add your control notification handler code here
if( !bSetup )
{
m_hook.Start();//激活全局钩子。
}
else
{
m_hook.Stop();//撤消全局钩子。
}
bSetup = !bSetup;

　　　} 

　　(7).编译项目，并运行程序，单击按钮激活外挂。

　　(8).启动画笔程序，选择文本工具并将笔的颜色设置为红色，将鼠标放在任意位置后，按F10键，画笔程序自动移动

鼠标并写下一个红色的大写R。图一展示了按F10键前的画笔程序的状态，图二展示了按F10键后的画笔程序的状态。

图一：按F10前状态(001.jpg)

图二：按F10后状态(002.jpg)

　五、封包技术

　　通过对动作模拟技术的介绍，我们对游戏外挂有了一定程度上的认识，也学会了使用动作模拟技术来实现简单的动作

模拟型游戏外挂的制作。这种动作模拟型游戏外挂有一定的局限性，它仅仅只能解决使用计算机代替人力完成那么有规律

、繁琐而无聊的游戏动作。但是，随着网络游戏的盛行和复杂度的增加，很多游戏要求将客户端动作信息及时反馈回服务

器，通过服务器对这些动作信息进行有效认证后，再向客户端发送下一步游戏动作信息，这样动作模拟技术将失去原有的

效应。为了更好地“外挂”这些游戏，游戏外挂程序也进行了升级换代，它们将以前针对游戏用户界面层的模拟推进到数

据通讯层，通过封包技术在客户端挡截游戏服务器发送来的游戏控制数据包，分析数据包并修改数据包；同时还需按照游

戏数据包结构创建数据包，再模拟客户端发送给游戏服务器，这个过程其实就是一个封包的过程。

　　封包的技术是实现第二类游戏外挂的最核心的技术。封包技术涉及的知识很广泛，实现方法也很多，如挡截WinSock

、挡截API函数、挡截消息、VxD驱动程序等。在此我们也不可能在此文中将所有的封包技术都进行详细介绍，故选择两种

在游戏外挂程序中最常用的两种方法：挡截WinSock和挡截API函数。

　　1． 挡截WinSock

　　众所周知，Winsock是Windows网络编程接口，它工作于Windows应用层，它提供与底层传输协议无关的高层数据传输

编程接口。在Windows系统中，使用WinSock接口为应用程序提供基于TCP/IP协议的网络访问服务，这些服务是由

Wsock32.DLL动态链接库提供的函数库来完成的。

　　由上说明可知，任何Windows基于TCP/IP的应用程序都必须通过WinSock接口访问网络，当然网络游戏程序也不例外。

由此我们可以想象一下，如果我们可以控制WinSock接口的话，那么控制游戏客户端程序与服务器之间的数据包也将易如

反掌。按着这个思路，下面的工作就是如何完成控制WinSock接口了。由上面的介绍可知，WinSock接口其实是由一个动态

链接库提供的一系列函数，由这些函数实现对网络的访问。有了这层的认识，问题就好办多了，我们可以制作一个类似的

动态链接库来代替原WinSock接口库，在其中实现WinSock32.dll中实现的所有函数，并保证所有函数的参数个数和顺序、

返回值类型都应与原库相同。在这个自制作的动态库中，可以对我们感兴趣的函数（如发送、接收等函数）进行挡截，放

入外挂控制代码，最后还继续调用原WinSock库中提供的相应功能函数，这样就可以实现对网络数据包的挡截、修改和发

送等封包功能。

　　下面重点介绍创建挡截WinSock外挂程序的基本步骤：

　　(1) 创建DLL项目，选择Win32 Dynamic-Link Library，再选择An empty DLL project。

　　(2) 新建文件wsock32.h，按如下步骤输入代码：

　　① 加入相关变量声明：

　　　HMODULE hModule=NULL; //模块句柄
　　　char buffer[1000]; //缓冲区
　　　FARPROC proc; //函数入口指针 

　　② 定义指向原WinSock库中的所有函数地址的指针变量，因WinSock库共提供70多个函数，限于篇幅，在此就只选择

几个常用的函数列出，有关这些库函数的说明可参考MSDN相关内容。

　　　//定义指向原WinSock库函数地址的指针变量。
　　　SOCKET (__stdcall *socket1)(int ,int,int);//创建Sock函数。
　　　int　(__stdcall *WSAStartup1)(WORD,LPWSADATA);//初始化WinSock库函数。
　　　int　(__stdcall *WSACleanup1)();//清除WinSock库函数。
　　　int (__stdcall *recv1)(SOCKET ,char FAR * ,int ,int );//接收数据函数。
　　　int (__stdcall *send1)(SOCKET ,const char * ,int ,int);//发送数据函数。
　　　int (__stdcall *connect1)(SOCKET,const struct sockaddr *,int);//创建连接函数。
　　　int (__stdcall *bind1)(SOCKET ,const struct sockaddr *,int );//绑定函数。
　　　......其它函数地址指针的定义略。 

　　(3) 新建wsock32.cpp文件，按如下步骤输入代码：

　　① 加入相关头文件声明：

　　　#include
　　　#include
　　　#include "wsock32.h" 

　　② 添加DllMain函数，在此函数中首先需要加载原WinSock库，并获取此库中所有函数的地址。代码如下：

　　　BOOL WINAPI DllMain (HANDLE hInst,ULONG ul_reason_for_call,LPVOID lpReserved)
　　　{
　　　　if(hModule==NULL){
　　　　　//加载原WinSock库，原WinSock库已复制为wsock32.001。
　　　hModule=LoadLibrary("wsock32.001");
　　}
　　　　else return 1;
//获取原WinSock库中的所有函数的地址并保存，下面仅列出部分代码。
if(hModule!=NULL){
　　　　　//获取原WinSock库初始化函数的地址，并保存到WSAStartup1中。
proc=GetProcAddress(hModule,"WSAStartup");
　　　WSAStartup1=(int (_stdcall *)(WORD,LPWSADATA))proc;
　　　　　//获取原WinSock库消除函数的地址，并保存到WSACleanup1中。
　　　　proc=GetProcAddress(hModule i,"WSACleanup");
　　　　WSACleanup1=(int (_stdcall *)())proc;
　　　　　//获取原创建Sock函数的地址，并保存到socket1中。
　　　　proc=GetProcAddress(hModule,"socket");
　　　　　socket1=(SOCKET (_stdcall *)(int ,int,int))proc;
　　　　　//获取原创建连接函数的地址，并保存到connect1中。
　　　　　proc=GetProcAddress(hModule,"connect");
　　　　　connect1=(int (_stdcall *)(SOCKET ,const struct sockaddr *,int ))proc;
　　　　　//获取原发送函数的地址，并保存到send1中。
　　　　　proc=GetProcAddress(hModule,"send");
　　　　　send1=(int (_stdcall *)(SOCKET ,const char * ,int ,int ))proc;
　　　　　//获取原接收函数的地址，并保存到recv1中。
　　　　　proc=GetProcAddress(hModule,"recv");
　　　　　recv1=(int (_stdcall *)(SOCKET ,char FAR * ,int ,int ))proc;
　　　　　......其它获取函数地址代码略。
　　　}
　　　else return 0;
　　　return 1;
}

　　③ 定义库输出函数，在此可以对我们感兴趣的函数中添加外挂控制代码，在所有的输出函数的最后一步都调用原

WinSock库的同名函数。部分输出函数定义代码如下：

//库输出函数定义。
//WinSock初始化函数。
　　　　int PASCAL FAR WSAStartup(WORD wVersionRequired, LPWSADATA lpWSAData)
　　　　{
　　　　　//调用原WinSock库初始化函数
　　　　　return WSAStartup1(wVersionRequired,lpWSAData);
　　　　}
　　　　//WinSock结束清除函数。
　　　　int PASCAL FAR WSACleanup(void)
　　　　{
　　　　　return WSACleanup1(); //调用原WinSock库结束清除函数。
　　　　}
　　　　//创建Socket函数。
　　　　SOCKET PASCAL FAR socket (int af, int type, int protocol)
　　　　{
　　　　　//调用原WinSock库创建Socket函数。
　　　　　return socket1(af,type,protocol);
　　　　}
　　　　//发送数据包函数
　　　　int PASCAL FAR send(SOCKET s,const char * buf,int len,int flags)
　　　　{
　　　//在此可以对发送的缓冲buf的内容进行修改，以实现欺骗服务器。
　　　外挂代码......
　　　//调用原WinSock库发送数据包函数。
　　　　　return send1(s,buf,len,flags);
　　　　}
//接收数据包函数。
　　　　int PASCAL FAR recv(SOCKET s, char FAR * buf, int len, int flags)
　　　　{
　　　//在此可以挡截到服务器端发送到客户端的数据包，先将其保存到buffer中。
　　　strcpy(buffer,buf);
　　　//对buffer数据包数据进行分析后，对其按照玩家的指令进行相关修改。
　　　外挂代码......
　　　//最后调用原WinSock中的接收数据包函数。
　　　　　return recv1(s, buffer, len, flags);
　　　　　}
　　　　.......其它函数定义代码略。

　　　LIBRARY "wsock32"
　　　EXPORTS
　　　　WSAStartup @1
　　　WSACleanup @2
　　　　recv @3
　　　　send @4
　　　　socket @5
　　　bind @6
　　　closesocket @7
　　　connect @8

　　　......其它输出函数声明代码略。

　　(5)、从“工程”菜单中选择“设置”，弹出Project Setting对话框，选择Link标签，在“对象/库模块”中输入

Ws2_32.lib。

　　(6)、编译项目，产生wsock32.dll库文件。

　　(7)、将系统目录下原wsock32.dll库文件拷贝到被外挂程序的目录下，并将其改名为wsock.001；再将上面产生的

wsock32.dll文件同样拷贝到被外挂程序的目录下。重新启动游戏程序，此时游戏程序将先加载我们自己制作的

wsock32.dll文件，再通过该库文件间接调用原WinSock接口函数来实现访问网络。上面我们仅仅介绍了挡载WinSock的实

现过程，至于如何加入外挂控制代码，还需要外挂开发人员对游戏数据包结构、内容、加密算法等方面的仔细分析（这个

过程将是一个艰辛的过程），再生成外挂控制代码。关于数据包分析方法和技巧，不是本文讲解的范围，如您感兴趣可以

到网上查查相关资料。

(3)、注入外挂代码进入被挂游戏进程中

　　完成了定位和修改程序中调用API函数代码后，我们就可以随意设计自定义的API函数的替代函数了。做完这一切后，

还需要将这些代码注入到被外挂游戏程序进程内存空间中，不然游戏进程根本不会访问到替代函数代码。注入方法有很多

，如利用全局钩子注入、利用注册表注入挡截User32库中的API函数、利用CreateRemoteThread注入（仅限于NT/2000）、

利用BHO注入等。因为我们在动作模拟技术一节已经接触过全局钩子，我相信聪明的读者已经完全掌握了全局钩子的制作

过程，所以我们在后面的实例中，将继续利用这个全局钩子。至于其它几种注入方法，如果感兴趣可参阅MSDN有关内容。

　　有了以上理论基础，我们下面就开始制作一个挡截MessageBoxA和recv函数的实例，在开发游戏外挂程序 时，可以此

实例为框架，加入相应的替代函数和处理代码即可。此实例的开发过程如下：

　　(1) 打开前面创建的ActiveKey项目。

　　(2) 在ActiveKey.h文件中加入HOOKAPI结构，此结构用来存储被挡截API函数名称、原API函数地址和替代函数地址。

　　　typedef struct tag_HOOKAPI
　　　{
　　　LPCSTR szFunc;//被HOOK的API函数名称。
　　　PROC pNewProc;//替代函数地址。
　　　PROC pOldProc;//原API函数地址。
　　　}HOOKAPI, *LPHOOKAPI; 

　　(3) 打开ActiveKey.cpp文件，首先加入一个函数，用于定位输入库在输入数据段中的IAT地址。代码如下：

　　　extern "C" __declspec(dllexport)PIMAGE_IMPORT_DESCRIPTOR
　　　LocationIAT(HMODULE hModule, LPCSTR szImportMod)
　　　//其中，hModule为进程模块句柄；szImportMod为输入库名称。
　　　{
　　　//检查是否为DOS程序，如是返回NULL，因DOS程序没有IAT。
　　　PIMAGE_DOS_HEADER pDOSHeader = (PIMAGE_DOS_HEADER) hModule;
　　　if(pDOSHeader->e_magic != IMAGE_DOS_SIGNATURE) return NULL;
　　　　//检查是否为NT标志，否则返回NULL。
　　　　PIMAGE_NT_HEADERS pNTHeader = (PIMAGE_NT_HEADERS)((DWORD)pDOSHeader+ (DWORD)(pDOSHeader-

>e_lfanew));
　　　　if(pNTHeader->Signature != IMAGE_NT_SIGNATURE) return NULL;
　　　　//没有IAT表则返回NULL。
　　　　if(pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress == 0)

return NULL;
　　　　//定位第一个IAT位置。
　　　　PIMAGE_IMPORT_DESCRIPTOR pImportDesc = (PIMAGE_IMPORT_DESCRIPTOR)((DWORD)pDOSHeader + (DWORD)

(pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress));
　　　　//根据输入库名称循环检查所有的IAT，如匹配则返回该IAT地址，否则检测下一个IAT。
　　　　while (pImportDesc->Name)
　　　　{
　　　　　//获取该IAT描述的输入库名称。
　　　PSTR szCurrMod = (PSTR)((DWORD)pDOSHeader + (DWORD)(pImportDesc->Name));
　　　if (stricmp(szCurrMod, szImportMod) == 0) break;
　　　pImportDesc++;
　　　　}
　　　　if(pImportDesc->Name == NULL) return NULL;
　　　return pImportDesc;
　　　}

　　再加入一个函数，用来定位被挡截API函数的IAT项并修改其内容为替代函数地址。代码如下：

　　　extern "C" __declspec(dllexport)
　　　HookAPIByName( HMODULE hModule, LPCSTR szImportMod, LPHOOKAPI pHookApi)
　　　//其中，hModule为进程模块句柄；szImportMod为输入库名称；pHookAPI为HOOKAPI结构指针。
　　　{
　　　　//定位szImportMod输入库在输入数据段中的IAT地址。
　　　　PIMAGE_IMPORT_DESCRIPTOR pImportDesc = LocationIAT(hModule, szImportMod);
　　if (pImportDesc == NULL) return FALSE;
　　　　//第一个Thunk地址。
　　　　PIMAGE_THUNK_DATA pOrigThunk = (PIMAGE_THUNK_DATA)((DWORD)hModule + (DWORD)(pImportDesc-

>OriginalFirstThunk));
　　 //第一个IAT项的Thunk地址。
　　　　PIMAGE_THUNK_DATA pRealThunk = (PIMAGE_THUNK_DATA)((DWORD)hModule + (DWORD)(pImportDesc-

>FirstThunk));
　　　　//循环查找被截API函数的IAT项，并使用替代函数地址修改其值。
　　　while(pOrigThunk->u1.Function)
{
　//检测此Thunk是否为IAT项。
if((pOrigThunk->u1.Ordinal & IMAGE_ORDINAL_FLAG) != IMAGE_ORDINAL_FLAG)
{
　 //获取此IAT项所描述的函数名称。
　PIMAGE_IMPORT_BY_NAME pByName =(PIMAGE_IMPORT_BY_NAME)((DWORD)hModule+(DWORD)(pOrigThunk-

>u1.AddressOfData));
　if(pByName->Name[0] == '\0') return FALSE;
　　//检测是否为挡截函数。
if(strcmpi(pHookApi->szFunc, (char*)pByName->Name) == 0)
　 {
　　　　　　　MEMORY_BASIC_INFORMATION mbi_thunk;
　　　　　　　//查询修改页的信息。
　　　　　　　VirtualQuery(pRealThunk, &mbi_thunk, sizeof(MEMORY_BASIC_INFORMATION));
//改变修改页保护属性为PAGE_READWRITE。
　　　　　　　VirtualProtect(mbi_thunk.BaseAddress,mbi_thunk.RegionSize, PAGE_READWRITE,

&mbi_thunk.Protect);
//保存原来的API函数地址。
　　　 　　if(pHookApi->pOldProc == NULL)
pHookApi->pOldProc = (PROC)pRealThunk->u1.Function;
　 //修改API函数IAT项内容为替代函数地址。
pRealThunk->u1.Function = (PDWORD)pHookApi->pNewProc;
//恢复修改页保护属性。
DWORD dwOldProtect;
　　　　　　　VirtualProtect(mbi_thunk.BaseAddress, mbi_thunk.RegionSize, mbi_thunk.Protect,

&dwOldProtect);
　　　　　 }
}
　 pOrigThunk++;
　 pRealThunk++;
}
　　SetLastError(ERROR_SUCCESS); //设置错误为ERROR_SUCCESS，表示成功。
　　return TRUE;
　　　} 

　　(4) 定义替代函数，此实例中只给MessageBoxA和recv两个API进行挡截。代码如下：

　　　static int WINAPI MessageBoxA1 (HWND hWnd , LPCTSTR lpText, LPCTSTR lpCaption, UINT uType)
　　　{
　　　　//过滤掉原MessageBoxA的正文和标题内容，只显示如下内容, 。
return MessageBox(hWnd, "Hook API OK!", "Hook API", uType);
　　　}
　　　static int WINAPI recv1(SOCKET s, char FAR *buf, int len, int flags )
　　　{
　　　//此处可以挡截游戏服务器发送来的网络数据包，可以加入分析和处理数据代码。
　　　return recv(s,buf,len,flags);
　　　} 

　　(5) 在KeyboardProc函数中加入激活挡截API代码，在if( wParam == 0X79 )语句中后面加入如下else if语句：

　　　......
　　　//当激活F11键时，启动挡截API函数功能。
　　　else if( wParam == 0x7A )
　　　{
　　　　HOOKAPI api[2];
api[0].szFunc ="MessageBoxA";//设置被挡截函数的名称。
api[0].pNewProc = (PROC)MessageBoxA1;//设置替代函数的地址。
api[1].szFunc ="recv";//设置被挡截函数的名称。
api[1].pNewProc = (PROC)recv1; //设置替代函数的地址。
//设置挡截User32.dll库中的MessageBoxA函数。
HookAPIByName(GetModuleHandle(NULL),"User32.dll",&api[0]);
//设置挡截Wsock32.dll库中的recv函数。
HookAPIByName(GetModuleHandle(NULL),"Wsock32.dll",&api[1]);
　　　}
　　　...... 

　　(6) 在ActiveKey.cpp中加入头文件声明 "#include "wsock32.h"。 从“工程”菜单中选择“设置”，弹出Project

Setting对话框，选择Link标签，在“对象/库模块”中输入Ws2_32..lib。

　　(7) 重新编译ActiveKey项目，产生ActiveKey.dll文件，将其拷贝到Simulate.exe目录下。运行Simulate.exe并启动

全局钩子。激活任意应用程序，按F11键后，运行此程序中可能调用MessageBoxA函数的操作，看看信息框是不是有所变化

。同样，如此程序正在接收网络数据包，就可以实现封包功能了。

　　六、结束语

　　除了以上介绍的几种游戏外挂程序常用的技术以外，在一些外挂程序中还使用了游戏数据修改技术、游戏加速技术等

。在这篇文章里，就不逐一介绍了。

网络游戏外挂核心封包揭密

[文章导读]
 
网络游戏的封包技术是大多数编程爱好者都比较关注的关注的问题之一，在这里就让我们一起研究一下这一个问题吧
　　网络游戏的封包技术是大多数编程爱好者都比较关注的关注的问题之一，在这里就让我们一起研究一下这一个问题吧

。

　　别看这是封包这一问题，但是涉及的技术范围很广范，实现的方式也很多（比如说APIHOOK,VXD,Winsock2都可以实现

），在这里我们不可能每种技术和方法都涉及，所以我在这里以Winsock2技术作详细讲解，就算作抛砖引玉。

　　由于大多数读者对封包类编程不是很了解，我在这里就简单介绍一下相关知识：

　　APIHooK：

　　由于Windows的把内核提供的功能都封装到API里面，所以大家要实现功能就必须通过API，换句话说就是我们要想捕

获数据封包，就必须先要得知道并且捕获这个API，从API里面得到封包信息。

　　VXD：

　　直接通过控制VXD驱动程序来实现封包信息的捕获，不过VXD只能用于win9X。

　　winsock2：

　　winsock是Windows网络编程接口，winsock工作在应用层，它提供与底层传输协议无关的高层数据传输编程接口，

winsock2是winsock2.0提供的服务提供者接口，但只能在win2000下用。

　　好了，我们开始进入winsock2封包式编程吧。

　　在封包编程里面我准备分两个步骤对大家进行讲解：1、封包的捕获，2、封包的发送。

　　首先我们要实现的是封包的捕获：

　　Delphi的封装的winsock是1.0版的，很自然winsock2就用不成。如果要使用winsock2我们要对winsock2在Delphi里面

做一个接口，才可以使用winsock2。

　　1、如何做winsock2的接口？

　　1）我们要先定义winsock2.0所用得到的类型，在这里我们以WSA_DATA类型做示范，大家可以举一仿三的来实现

winsock2其他类型的封装。

　　我们要知道WSA_DATA类型会被用于WSAStartup(wVersionRequired: word; var WSData: TWSAData): Integer;，大家

会发现WSData是引用参数，在传入参数时传的是变量的地址，所以我们对WSA_DATA做以下封装：

　　2）我们要从WS2_32.DLL引入winsock2的函数，在此我们也是以WSAStartup为例做函数引入：

　　通过以上方法，我们便可以对winsock2做接口，下面我们就可以用winsock2做封包捕获了，不过首先要有一块网卡。

因为涉及到正在运作的网络游戏安全问题，所以我们在这里以IP数据包为例做封包捕获，如果下面的某些数据类型您不是

很清楚，请您查阅MSDN：

一、 前言

　　所谓游戏外挂，其实是一种游戏外辅程序，它可以协助玩家自动产生游戏动作、修改游戏网络数据包以及修改游戏内

存数据等，以实现玩家用最少的时间和金钱去完成功力升级和过关斩将。虽然，现在对游戏外挂程序的“合法”身份众说

纷纭，在这里我不想对此发表任何个人意见，让时间去说明一切吧。

　　随着网络游戏的时代的来临，游戏外挂在原有的功能之上进行了新的发展，它变得更加多种多样，功能更加强大，操

作更加简单，以至有些游戏的外挂已经成为一个体系，比如《石器时代》，外挂品种达到了几十种，自动战斗、自动行走

、自动练级、自动补血、加速、不遇敌、原地遇敌、快速增加经验值、按键精灵……几乎无所不包。

　　游戏外挂的设计主要是针对于某个游戏开发的，我们可以根据它针对的游戏的类型可大致可将外挂分为两种大类。

　　一类是将游戏中大量繁琐和无聊的攻击动作使用外挂自动完成，以帮助玩家轻松搞定攻击对象并可以快速的增加玩家

的经验值。比如在《龙族》中有一种工作的设定，玩家的工作等级越高，就可以驾驭越好的装备。但是增加工作等级却不

是一件有趣的事情，毋宁说是重复枯燥的机械劳动。如果你想做法师用的杖，首先需要做基本工作--?砍树。砍树的方法

很简单，在一棵大树前不停的点鼠标就可以了，每10000的经验升一级。这就意味着玩家要在大树前不停的点击鼠标，这

种无聊的事情通过"按键精灵"就可以解决。外挂的"按键精灵"功能可以让玩家摆脱无趣的点击鼠标的工作。

　　另一类是由外挂程序产生欺骗性的网络游戏封包，并将这些封包发送到网络游戏服务器，利用这些虚假信息欺骗服务

器进行游戏数值的修改，达到修改角色能力数值的目的。这类外挂程序针对性很强，一般在设计时都是针对某个游戏某个

版本来做的，因为每个网络游戏服务器与客户端交流的数据包各不相同，外挂程序必须要对欺骗的网络游戏服务器的数据

包进行分析，才能产生服务器识别的数据包。这类外挂程序也是当前最流利的一类游戏外挂程序。

　　另外，现在很多外挂程序功能强大，不仅实现了自动动作代理和封包功能，而且还提供了对网络游戏的客户端程序的

数据进行修改，以达到欺骗网络游戏服务器的目的。我相信，随着网络游戏商家的反外挂技术的进展，游戏外挂将会产生

更多更优秀的技术，让我们期待着看场技术大战吧......

　　三、外挂技术综述

　　可以将开发游戏外挂程序的过程大体上划分为两个部分：

　　前期部分工作是对外挂的主体游戏进行分析，不同类型的外挂分析主体游戏的内容也不相同。如外挂为上述谈到的外

挂类型中的第一类时，其分析过程常是针对游戏的场景中的攻击对象的位置和分布情况进行分析，以实现外挂自动进行攻

击以及位置移动。如外挂为外挂类型中的第二类时，其分析过程常是针对游戏服务器与客户端之间通讯包数据的结构、内

容以及加密算法的分析。因网络游戏公司一般都不会公布其游戏产品的通讯包数据的结构、内容和加密算法的信息，所以

对于开发第二类外挂成功的关键在于是否能正确分析游戏包数据的结构、内容以及加密算法，虽然可以使用一些工具辅助

分析，但是这还是一种坚苦而复杂的工作。

　　后期部分工作主要是根据前期对游戏的分析结果，使用大量的程序开发技术编写外挂程序以实现对游戏的控制或修改

。如外挂程序为第一类外挂时，通常会使用到鼠标模拟技术来实现游戏角色的自动位置移动，使用键盘模拟技术来实现游

戏角色的自动攻击。如外挂程序为第二类外挂时，通常会使用到挡截Sock和挡截API函数技术，以挡截游戏服务器传来的

网络数据包并将数据包修改后封包后传给游戏服务器。另外，还有许多外挂使用对游戏客户端程序内存数据修改技术以及

游戏 加速技术。

　　本文主要是针对开发游戏外挂程序后期使用的程序开发技术进行探讨，重点介绍的如下几种在游戏外挂中常使用的程

序开发技术：

　　● 动作模拟技术：主要包括键盘模拟技术和鼠标模拟技术。

　　● 封包技术：主要包括挡截Sock技术和挡截API技术。

四、动作模拟技术

　　我们在前面介绍过，几乎所有的游戏都有大量繁琐和无聊的攻击动作以增加玩家的功力，还有那些数不完的迷宫，这

些好像已经成为了角色游戏的代名词。现在，外挂可以帮助玩家从这些繁琐而无聊的工作中摆脱出来，专注于游戏情节的

进展。外挂程序为了实现自动角色位置移动和自动攻击等功能，需要使用到键盘模拟技术和鼠标模拟技术。下面我们将重

点介绍这些技术并编写一个简单的实例帮助读者理解动作模拟技术的实现过程。

　　１． 鼠标模拟技术
　　
　　几乎所有的游戏中都使用了鼠标来改变角色的位置和方向，玩家仅用一个小小的鼠标，就可以使角色畅游天下。那么

，我们如何实现在没有玩家的参与下角色也可以自动行走呢。其实实现这个并不难，仅仅几个Windows API函数就可以搞

定，让我们先来认识认识这些API函数。

　　(1) 模拟鼠标动作API函数mouse_event，它可以实现模拟鼠标按下和放开等动作。

　　　　VOID mouse_event(
　　　　　　DWORD dwFlags, // 鼠标动作标识。
　　　　　　DWORD dx, // 鼠标水平方向位置。
　　　　　　DWORD dy, // 鼠标垂直方向位置。
　　　　　　DWORD dwData, // 鼠标轮子转动的数量。
　　　　　　DWORD dwExtraInfo // 一个关联鼠标动作辅加信息。
　　　　);

　　其中，dwFlags表示了各种各样的鼠标动作和点击活动，它的常用取值如下：

　　　MOUSEEVENTF_MOVE　表示模拟鼠标移动事件。

　　　MOUSEEVENTF_LEFTDOWN 表示模拟按下鼠标左键。

　　　MOUSEEVENTF_LEFTUP 表示模拟放开鼠标左键。

　　　MOUSEEVENTF_RIGHTDOWN 表示模拟按下鼠标右键。

　　　MOUSEEVENTF_RIGHTUP 表示模拟放开鼠标右键。

　　　MOUSEEVENTF_MIDDLEDOWN 表示模拟按下鼠标中键。

　　　MOUSEEVENTF_MIDDLEUP 表示模拟放开鼠标中键。

　　(2)、设置和获取当前鼠标位置的API函数。获取当前鼠标位置使用GetCursorPos()函数，设置当前鼠标位置使用

SetCursorPos()函数。

　　　　BOOL GetCursorPos(
　　　　　LPPOINT　lpPoint // 返回鼠标的当前位置。
　　　　);
　　　　BOOL SetCursorPos(
　　　　int X, // 鼠标的水平方向位置。
　　　　　　int Y //鼠标的垂直方向位置。
　　　　); 

　　通常游戏角色的行走都是通过鼠标移动至目的地，然后按一下鼠标的按钮就搞定了。下面我们使用上面介绍的API函

数来模拟角色行走过程。

　　　CPoint oldPoint,newPoint;
　　　GetCursorPos(&oldPoint); //保存当前鼠标位置。
　　　newPoint.x = oldPoint.x+40;
　　　newPoint.y = oldPoint.y+10;
　　　SetCursorPos(newPoint.x,newPoint.y); //设置目的地位置。
　　　mouse_event(MOUSEEVENTF_RIGHTDOWN,0,0,0,0);//模拟按下鼠标右键。
　　　mouse_event(MOUSEEVENTF_RIGHTUP,0,0,0,0);//模拟放开鼠标右键。 

　　2． 键盘模拟技术

　　在很多游戏中，不仅提供了鼠标的操作，而且还提供了键盘的操作，在对攻击对象进行攻击时还可以使用快捷键。为

了使这些攻击过程能够自动进行，外挂程序需要使用键盘模拟技术。像鼠标模拟技术一样，Windows API也提供了一系列

API函数来完成对键盘动作的模拟。

　　模拟键盘动作API函数keydb_event，它可以模拟对键盘上的某个或某些键进行按下或放开的动作。

　　　VOID keybd_event(
　　　　　BYTE bVk, // 虚拟键值。
　　　　　BYTE bScan, // 硬件扫描码。
　　　　　DWORD dwFlags, // 动作标识。
　　　　　DWORD dwExtraInfo // 与键盘动作关联的辅加信息。
　　　);

　　其中，bVk表示虚拟键值，其实它是一个BYTE类型值的宏，其取值范围为1-254。有关虚拟键值表请在MSDN上使用关键

字“Virtual-Key Codes”查找相关资料。bScan表示当键盘上某键被按下和放开时，键盘系统硬件产生的扫描码，我们可

以MapVirtualKey()函数在虚拟键值与扫描码之间进行转换。dwFlags表示各种各样的键盘动作，它有两种取值：

KEYEVENTF_EXTENDEDKEY和KEYEVENTF_KEYUP。

　　下面我们使用一段代码实现在游戏中按下Shift+R快捷键对攻击对象进行攻击。

　　　keybd_event(VK_CONTROL,MapVirtualKey(VK_CONTROL,0),0,0); //按下CTRL键。
　　　keybd_event(0x52,MapVirtualKey(0x52,0),0,0);//键下R键。
　　　keybd_event(0x52,MapVirtualKey(0x52,0), KEYEVENTF_KEYUP,0);//放开R键。
　　　keybd_event(VK_CONTROL,MapVirtualKey(VK_CONTROL,0),
　　　KEYEVENTF_KEYUP,0);//放开CTRL键。

　　3． 激活外挂

　　上面介绍的鼠标和键盘模拟技术实现了对游戏角色的动作部分的模拟，但要想外挂能工作于游戏之上，还需要将其与

游戏 的场景窗口联系起来或者使用一个激活键，就象按键精灵的那个激活键一样。我们可以用GetWindow函数来枚举窗口

，也可以用Findwindow函数来查找特定的窗口。另外还有一个FindWindowEx函数可以找到窗口的子窗口，当游戏切换场景

的时候我们可以用FindWindowEx来确定一些当前窗口的特征，从而判断是否还在这个场景，方法很多了，比如可以

GetWindowInfo来确定一些东西，比如当查找不到某个按钮的时候就说明游戏场景已经切换了等等办法。当使用激活键进

行关联，需要使用Hook技术开发一个全局键盘钩子，在这里就不具体介绍全局钩子的开发过程了，在后面的实例中我们将

会使用到全局钩子，到时将学习到全局钩子的相关知识。

　　4． 实例实现

　　通过上面的学习，我们已经基本具备了编写动作式游戏外挂的能力了。下面我们将创建一个画笔程序外挂，它实现自

动移动画笔字光标的位置并写下一个红色的“R”字。以这个实例为基础，加入相应的游戏动作规则，就可以实现一个完

整的游戏外挂。这里作者不想使用某个游戏作为例子来开发外挂（因没有游戏商家的授权啊！），如读者感兴趣的话可以

找一个游戏试试，最好仅做测试技术用。

　　首先，我们需要编写一个全局钩子，使用它来激活外挂，激活键为F10。创建全局钩子步骤如下：

　　(1)．选择MFC AppWizard(DLL)创建项目ActiveKey，并选择MFC Extension DLL（共享MFC拷贝）类型。

　　(2).插入新文件ActiveKey.h，在其中输入如下代码：

　　　#ifndef _KEYDLL_H
　　　#define _KEYDLL_H

　　　class AFX_EXT_CLASS CKeyHook:public CObject
　　　{
　　　　public:
　CKeyHook();
　~CKeyHook();
　HHOOK Start();　//安装钩子
　BOOL Stop(); //卸载钩子
　　　};
　　　#endif 

　　(3).在ActiveKey.cpp文件中加入声明＂#include ActiveKey.h＂。

　　(4).在ActiveKey.cpp文件中加入共享数据段，代码如下：

　　　//Shared data section
　　　#pragma data_seg("sharedata")
　　　HHOOK glhHook=NULL; //钩子句柄。
　　　HINSTANCE glhInstance=NULL; //DLL实例句柄。
　　　#pragma data_seg() 

　　(5).在ActiveKey.def文件中设置共享数据段属性，代码如下：

　　　SETCTIONS
　　　shareddata READ WRITE SHARED

　　(6).在ActiveKey.cpp文件中加入CkeyHook类的实现代码和钩子函数代码：

　　　//键盘钩子处理函数。
　　　extern "C" LRESULT WINAPI KeyboardProc(int nCode,WPARAM wParam,LPARAM lParam)
　　　{
　　　if( nCode >= 0 )
　　　{
　　　if( wParam == 0X79 )//当按下F10键时，激活外挂。
　{
　　//外挂实现代码。
CPoint newPoint,oldPoint;
　　 GetCursorPos(&oldPoint);
　　 newPoint.x = oldPoint.x+40;
　　 newPoint.y = oldPoint.y+10;
　　 SetCursorPos(newPoint.x,newPoint.y);
　　 mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,0);//模拟按下鼠标左键。
　　mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,0);//模拟放开鼠标左键。
　　keybd_event(VK_SHIFT,MapVirtualKey(VK_SHIFT,0),0,0); //按下SHIFT键。
　　keybd_event(0x52,MapVirtualKey(0x52,0),0,0);//按下R键。
　　keybd_event(0x52,MapVirtualKey(0x52,0),KEYEVENTF_KEYUP,0);//放开R键。
　　keybd_event(VK_SHIFT,MapVirtualKey(VK_SHIFT,0),KEYEVENTF_KEYUP,0);//放开SHIFT键。
　　　　　　SetCursorPos(oldPoint.x,oldPoint.y);
　}
　　　}
　　　return CallNextHookEx(glhHook,nCode,wParam,lParam);
　　　}

　　　CKeyHook::CKeyHook(){}
　　　CKeyHook::~CKeyHook()
　　　{　
　　　if( glhHook )
Stop();
　　　}
　　　//安装全局钩子。
　　　HHOOK CKeyHook::Start()
　　　{
glhHook = SetWindowsHookEx(WH_KEYBOARD,KeyboardProc,glhInstance,0);//设置键盘钩子。
return glhHook;
}
　　　//卸载全局钩子。
　　　BOOL CKeyHook::Stop()
　　　{
　　　BOOL bResult = TRUE;
　if( glhHook )
　　　bResult = UnhookWindowsHookEx(glhHook);//卸载键盘钩子。
　　　return bResult;
　　　} 

　　(7).修改DllMain函数，代码如下：

　　　extern "C" int APIENTRY
　　　DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
　　　{
//如果使用lpReserved参数则删除下面这行
UNREFERENCED_PARAMETER(lpReserved);

if (dwReason == DLL_PROCESS_ATTACH)
{
　　TRACE0("NOtePadHOOK.DLL Initializing!\n");
　　 //扩展DLL仅初始化一次
　　if (!AfxInitExtensionModule(ActiveKeyDLL, hInstance))
return 0;
　　new CDynLinkLibrary(ActiveKeyDLL);
　　　　　　//把DLL加入动态MFC类库中
　　glhInstance = hInstance;
　　//插入保存DLL实例句柄
}
else if (dwReason == DLL_PROCESS_DETACH)
{
　　TRACE0("NotePadHOOK.DLL Terminating!\n");
　　//终止这个链接库前调用它
　　AfxTermExtensionModule(ActiveKeyDLL);
}
return 1;
　　　}

　　现在大部分的主流外挂，包括按键精灵，自动做一些动作之类的外挂。 都是通过HOOK进游戏窗口，并且用不同的HOOK类型来完成的，比如对于 网络，通常是通过HOOK消息，把DLL弄到我们的游戏程序中，然后通过
GetProcAddress得到DLL中它们卑劣的函数的地址和真实的函数地址， 然后通过WriteProcessMemory来把我们的函数地址改成他们他们的API 地址。

　　那么在我们的游戏执行的时候，收到消息就会先触发他们的钩子，等他们布置好邪恶的陷阱，然后再执行我们的程序。那么，对于这类型的外挂，该怎么防呢？俗话说得好，以彼之道，还制彼身。所谓魔高一尺，道高一丈。所谓邪不胜正。所谓天网恢恢。所谓做贼心虚。

　　恩，WINDOWS的钩子有个特点，就是钩子链，因为对于同一个进程，即使是同一类型的钩子，能同时有多个，也就是说，对于同一个游戏，开两个功能相同的外挂也可以。那么，怎么样来决定钩子的顺序呢？所谓
后来者先得，WINDOWS的做法是，最后一个HOOK某个进程的钩子最先执行。并且振奋人心的消息是，在钩子里面可以控制下一个钩子是否执行。

　　这个函数是CallNextHookEx，也就是说，如果在某个钩子里面不执行这个函数的话，钩子链就会在这中断，那么我们的思路就很简单了，在游戏运行中，开一个进程，每隔一段时间就hook我们的主程序，然后在钩
子里面，不执行CallNextHookEx，这样就可以避免别人的钩子执行。

　　所谓，仅仅发现敌人还不够，还要消灭敌人。不急，我们来看看如何彻底把敌人打成粉碎性骨折。恩，要消灭敌人就要复杂一点了，要针对不同类型的钩子来采取不同类型的方法了，因为敌人的钩子不管怎么做，
无非是出于两种目的，一种是修改数据，另外就是过滤数据。其核心思想就是我们自己的游戏注册两个钩子，一个总是在钩子链的最底层，另外一个总是在钩子链的最上层，一比较两个钩子收到的消息，就知道中
间有没有别的钩子了。一但发现有别的钩子，不用想了，肯定是外挂，最少也用了按键精灵，封号，杀档，想怎么干就怎么干。

　　当然，敌人也不是这么脆弱的，据说有人用raw socket来截获所有的网络消息，这个跟钩子无关，这个更底层一些。不过不用怕，俗话说得好，以彼之道，还制彼身。所谓魔高一尺，道高一丈。所谓邪不胜正。所谓
天网恢恢。所谓做贼心虚。对付拦截raw socket的外挂，这里首先要把敌人分类，对于水平最次的敌人，方法也相应要简单得多。 最次的敌人一般用的方法是自己写一个wsock32.dll放在和游戏相同的目录下，来替换掉系统的wsock32.dll。对于这种愚蠢的方法，解决的办法有很多，把load time的载入wsock32.dll改成run time的载入，然后指定一下路径，就什么问题都没有了。更简单点，运行游戏的时候检查一下当前目录下有没有wsock32.dll，有的话，那就肯定是外挂钩子了。

　　比最等级高一点点的敌人，会喜欢用钩子来直接钩，一般的做法是，先通过GetProcAddress来获取SOCKET API的地址，然后通过WriteProcessMemory的方法来修改入口地址，将其改成jmp 自己的函数地址。这种方法其实很卑劣的，所谓无毒不丈夫，我们可以通过修改通用的GetProcAddress的代码来防止别人拦截SOCKET，这样，直接连防火墙都可以突破了。

　　这里的技术难点在于，我们不能用类似WriteProcessMemory的方法来写内存因为我们不知道究竟外挂是哪个进程，所以我们需要修改WINDOWS的代码段，这样讲理论上是不可能的，可惜WINDOWS自己给自己留了个后门，在kernel.dll　里面，UINT AllocCsToDsAlias(UINT)，通过把API的代码段的选择符传给它，可以返回一个可以写的数据段的选择符，然后把新的选择符和API的入口地址加在一起，就可以得到一个可以写的代码段的指针。

　　国内好多取词软件和全屏翻译软件都是用的这个原理，具体的例子如下：
　　比如GetProcAddress这个API，在kernel.dll里面，我们要做针对它的通用钩子就应该按照以下的步簇：
typedef UINT (WINAPI* FOO)(UINT);
FOO AllocCsToDsAlias;
HMODULE hKernel = GetModuleHandle("kernel");
AllocCsToDsAlias = (FOO)GetProcAddress(hKernel, "AllocCsToDsAlias");
FARPROC entry = GetProcAddress(hKernel, "GetProcAddress");
WORD offset = (WORD)(FP_OFF(entry));
UINT selector = AllocCsToDsAlias(FP_SEG(entry));
BYTE *addr = (BYTE *)MK_FP(selector, offset);

　　然后就可以往addr这个地址写5个BYTE的东西，第一个BYTE是jmp，不同的CPU　可能会不同，之后的一个DWORD是你的函数的地址。。

　　这样，可以通过保存两份addr的数据来做到钩子的开关，当钩子打开的时候，所有的GetProcAddress的调用都会调到我们的函数，这个时候可以通过检查如果有人想GetProcAddress wsock32.dll里的东西，我们就干掉它。。

　　同样，如果有人通过开启socket这个API的SOCK_RAW参数来调用RAW SOCKET监视网络，我们也可以通过上面的方法来做到先入为主，看谁在监视我们的网络传输。

　　其实查外挂的原理和捉病毒的原理一样，只是现在做外挂的技术还不成熟。当做外挂的技术和防外挂的技术在同一条线上的时候，想从技术上防住外挂是不可能的。

　　其实是无奈，杀毒软件的做法是出来一种新的病毒，在第一时间内公布其特征码，然后更新所有的客户端，看到这种特征的，就杀。其实查杀外挂也该如此，其实CS的Cheating-Death就是这个原理，不管出了什么新的外挂，CD 总是在第一时间内更新，然后客户端也就傻傻的只要一看到有这个特征的东西就把它干掉。其实仔细想想，这是个很好的主意，从外挂开发商的动机来分析。他们之所以要开发外挂，估计炫耀技术是一方面，更重要的还是想赚钱，或者用来挂机之类的，既然要赚钱，或者挂机，就必然会被其他玩家发现或者举报，这个时候应该做的就是尽快的下载一份外挂，或者根据其行为研究其特征，并在防外挂的特征码上记下一笔，其实不用太复杂，最简单的做法就是记住其外挂窗口的名称，然后只要看到这个外挂窗口，做些处理就好了。

　　那么这样一来，关键的技术就落在如何设计查外挂这个结构上了，首先客户端需要的是一个查外挂引擎，和一个外挂特征库，根据引擎和特征库生成一个固定的版本号，然后每次登陆的时候就用这个版本号，跟服务器上的版本号对比，如果不一样的话，则从服务器自动下载最新的查外挂引擎和外挂特征库。

　　这样虽然不能将外挂赶尽杀绝，却能比较大的限度上围剿使用外挂的风气，相信使用外挂的玩家也只是想更好的玩游戏，只不过动的念头有些歪了，但其出发点仍是好的，只要在他使用外挂的时候多些阻拦或者诱导他不使用外挂，这样效果就会好很多。设想一下，谁愿意每天等一个外挂的更新，而不去玩他很想玩的游戏呢。这样一来，制作外挂的人也会逐渐减少，从而进入一个良性循环。

　　就好象如今写病毒，并不如当年那么流行了。。-。-