外挂编写完全攻略

外挂编写完全攻略
一、先说一下写一个外挂需要什么条件
1、熟练的C语言知识
目前的外挂大部分都是用BC或者是vc写的，拥有熟练的C语言知识是写外挂的基本条件
2、具有很强的汇编基础 一般游戏都不可能有原代码的，必须*反汇编或者跟踪的办
法来探索其中的机理 ，所以有强的汇编基础也是必不可少的条件
3、熟练掌握跟踪和调试的工具
有了上面2个条件后，掌握一些工具也是很有必要的
跟踪的工具，softice当然是不二之选，至于反汇编的工具，我推荐用IDA PRO
这个工具反汇编出来的代码结构清晰，非常好读
如果你不具有上面的条件，还是先把基础打好，再来写外挂吧，一分耕耘，一分收获，天下没有白掉的馅饼的
二、写外挂面临的基本技术问题
1、修改进程的执行代码 要修改进程的执行代码，要先取得进程的ID,如果是由外挂程序启动，返回值里就有进程ID,
如果不是的话，
需要用findwindow找到窗口句柄，再用GetWindowProcessID取得进程ID,取得进程ID以后，就可以用
writeprocessmemory来修改进程的执行代码了，使程序按照我们的意愿来执行，石器外挂里的不遇敌、寸步遇敌
就是用这样的方法来实现的
2、截获外挂发送和接收的封包
除了通过修改代码来实现的功能以外，很多的功能都是通过修改封包来实现的，要修改封包，首先要能截获它。
第一步是要跟踪出发和收的位置，至于怎么跟踪，我以后会提到，找到位置以后，有2个办法，一是在那个位置加一
个jmp语句，跳到你的处理函数位置，处理完后，再跳回来，这种方法要求比较高，需要处理好很多事情，另一种办法
是往那个位置写条能造成例外的指令，比如int 3,然后用DebugActiveProcess调试游戏进程，这样每当游戏执行到那个
位置的时候，就会停下来，到外挂程序里面去，等外挂程序处理完以后，用ContinueDebugEvent 继续运行程序。
今天先写这么多，下回将讨论外挂的具体功能该怎么实现

今天来谈谈地址的调查问题，地址调查是写外挂中最艰辛，最富有挑战性的事情，
很多朋友问我要外挂的原程序，其实有了外挂原程序，如果你不会调查地址，还是
没用的， 原程序和地址的关系就象武学中招式与内功的关系，没有内功的招式，
只是一个花架子。而内功精深以后，任何普通的招式，都有可能化腐朽为神奇，外
挂中的地址分为两类，一类是程序地址，一类是数据地址。象石器中的双石器，真
彩，不遇敌，寸步遇敌，发送接收封包等，都属于第一类，而人物坐标，状态等，
都属于第二类。对于第一类地址，主要依*softice来调查地址，对第二类地址，
可以用一些游戏工具，比如fpe,game expert,game master等来调查，我一直用game
expert,因为我找不到2000下能用的fpe, 各位以前用fpe改游戏的时候，没想过他
也能用来干这个吧 对于第二类数据的调查方法，大部分人都很熟习了，我就不多
说了，现在主要来谈谈第一类数据的详细调查过程，比如我们要调查发送封包的位
置，如何着手呢，客户端往服务器要发很多封包，但最简单的办法莫过从说话的封
包入手，先说一句很长的话，最好是英文，查起来方便，说完以后，用任意一种办
法进入游戏程序的进程空间（比如先用spy查出游戏程序的窗口句柄，再切换到sof
tice打入bmsg 窗口句柄 wm_lbuttondown,这样在游戏程序中一点鼠标就进入了他
的进程空间）然后用s命令查出这句话所放的内存地址，记下这个地址，在softice
中打入bpm 刚才调查到的地址，这个指令的意思是只要有访问这个内存的动作，立刻
中断，然后再切换到游戏，说一句话，你会发现softice自动中断到某一个位置了，从
这个位置跟踪下去，发送封包的位置也就不远了。 上面所说的都是针对一个全新的游
戏程序而言，如果是一个老的程序，有前辈做了大量的工作，还可以用些别的办法，
如反汇编等，来调查。以后游戏版本的更新也是如此，只要把老版本的地址位置附近的
代码记下来，去新版本的代码里面search一下，就ok了。 恩，休息一会儿，休息一会儿

我主要对外挂的技术进行分析,至于游戏里面的内部结构每个都不一样,这里就不做讲解了,我也没有那么厉害,所有的都知道,呵呵!
1 首先游戏外挂的原理
外挂现在分为好多种,比如模拟键盘的,鼠标的,修改数据包的,还有修改本地内存的,但好像没有修改服务器内存的哦,呵呵!其实修改服务器也是有办法的,只是技术太高一般人没有办法入手而已!(比如请GM去夜总会,送礼,收黑钱等等办法都可以修改服务器数据,哈哈)
修改游戏无非是修改一下本地内存的数据,或者截获api函数等等,这里我把所能想到的方法都作一个介绍,希望大家能做出很好的外挂来使游戏厂商更好的完善自己的技术.
我见到一片文章是讲魔力宝贝的理论分析,写的不错,大概是那个样子.
下来我就讲解一下技术方面的东西,以作引玉之用
2 技术分析部分
1 模拟键盘或鼠标的响应
我们一般使用UINT SendInput(
UINT nInputs, // count of input events
LPINPUT pInputs, // array of input events
int cbSize // size of structure
);api函数
第一个参数是说明第二个参数的矩阵的维数的,第二个参数包含了响应事件,这个自己填充就可以,最后是这个结构的大小,非常简单,这是最简单的方法模拟键盘鼠标了,呵呵
注意:这个函数还有个替代函数:
VOID keybd_event(
BYTE bVk, // 虚拟键码
BYTE bScan, // 扫描码
DWORD dwFlags,
ULONG_PTR dwExtraInfo // 附加键状态
);和
VOID mouse_event(
DWORD dwFlags, // motion and click options
DWORD dx, // horizontal position or change
DWORD dy, // vertical position or change
DWORD dwData, // wheel movement
ULONG_PTR dwExtraInfo // application-defined information
);
这两个函数非常简单了,我想那些按键精灵就是用的这个吧,呵呵,上面的是模拟键盘,下面的是模拟鼠标的.
这个仅仅是模拟部分,要和游戏联系起来我们还需要找到游戏的窗口才行,或者包含快捷键,就象按键精灵的那个激活键一样,我们可以用GetWindow函数来枚举窗口,也可以用Findwindow函数来查找制定的窗口(注意还有一个FindWindowEx),FindwindowEx可以找到窗口的子窗口,比如按钮,等什么东西.当游戏切换场景的时候我们可以用FindWindowEx来确定一些当前窗口的特征,从而判断是否还在这个场景,方法很多了,比如可以GetWindowInfo来确定一些东西,比如当查找不到某个按钮的时候就说明游戏场景已经切换了,等等办法.有的游戏没有控件在里面,这是对图像做坐标变换的话,这种方法就要受到限制了.这就需要我们用别的办法来辅助分析了.
至于快捷键我们要用动态连接库实现了,里面要用到hook技术了,这个也非常简单,大家可能都会了,其实就是一个全局的hook对象然后SetWindowHook就可以了,回调函数都是现成的,而且现在网上的例子多如牛毛,这个实现在外挂中已经很普遍了.如果还有谁不明白,那就去看看msdn查找SetWindowHook就可以了.
这个动态连接库的作用很大,不要低估了哦,它可以切入所有的进程空间,也就是可以加载到所有的游戏里面哦,只要用对,你会发现很有用途的!
这个需要你复习一下win32编程的基础知识了,呵呵,赶快去看书吧!
2截获消息
有些游戏的响应机制比较简单,是基于消息的,或者用什么定时器的东西,这个时候你就可以用拦截消息来实现一些有趣的功能了.
我们拦截消息使用的也是hook技术,里面包括了键盘消息,鼠标消息,系统消息,日志等,别的对我们没有什么大的用处,我们只用拦截消息的回调函数就可以了,这个不会让我写例子吧,其实这个和上面的一样,都是用SetWindowHook来写的,看看就明白了很简单的.
至于拦截了以后做什么就是你的事情了,比如在每个定时器消息里面处理一些我们的数据判断,或者在定时器里面在模拟一次定时器,那么有些数据就会处理两次,呵呵,后果嘛,不一定是好事情哦,呵呵,不过如果数据计算放在客户端的游戏就可以真的改变数据了,呵呵,试试看吧!用途还有很多,自己想也可以想出来的,呵呵!
3拦截socket包
这个技术难度要比原来的高很多哦,要有思想准备.
首先我们要替换winSock.dll或者winsock32.dll,我们写的替换函数要和原来的函数一致才行,就是说它的函数输出什么样的,我们也要输出什么样子的函数,而且参数,参数顺序都要一样才行,然后在我们的函数里面调用真正的winSock32.dll里面的函数就可以了
首先:我们可以替换动态库到系统路径
其次:我们应用程序启动的时候可以加载原有的动态库,用这个函数LoadLibary
然后定位函数入口用GetProcAddress函数获得每个真正socket函数的入口地址
当游戏进行的时候它会调用我们的动态库,然后从我们的动态库中处理完毕后才跳转到真正动态库的函数地址,这样我们就可以在里面处理自己的数据了,应该是一切数据.呵呵!
兴奋吧,拦截了数据包我们还要分析之后才能进行正确的应答,不要以为这样工作就完成了,呵呵!还早呢,等分析完毕以后我们还要仿真应答机制来和服务器通信,一个不小心就会被封号,呵呵,呜~~~~我就被封了好多啊!
分析数据才是工作量的来源呢,游戏每次升级有可能加密方式会有所改变,因此我们写外挂的人都是亡命之徒啊,被人娱乐了还不知道,呵呵!(声明我可没有赚钱,我是免费的)
好了,给大家一个不错的起点,这里有完整的替换socket源代码,呵呵!
http://www.vchelp.net/vchelp/zsrc/wsock32_sub.zip ;
4截获api
上面的技术如果可以灵活运用的话我们就不用截获api函数了,其实这种技术是一种补充技术.比如我们需要截获socket以外的函数作为我们的用途,我们就要用这个技术了,其实我们也可以用它直接拦截在socket中的函数,这样更直接.
现在拦截api的教程到处都是,我就不列举了,我用的比较习惯的方法是根据输入节进行拦截的,这个方法可以用到任何一种操作系统上,比如98/2000等,有些方法不是跨平台的,我不建议使用.这个技术大家可以参考windows核心编程里面的545页开始的内容来学习,如果是98系统可以用window系统奥秘那个最后一章来学习.
好了方法就是这么多了,看大家怎么运用了,其它的一些针对性的技巧这里我就不说了,要不然会有人杀了我的,呵呵!
记住每个游戏的修改方法都不一样,如果某个游戏数据处理全部在服务器端,那么你还是别写外挂了,呵呵,最多写个自动走路的外挂,哈哈!
数据分析的时候大家一定要注意,不要轻易尝试和服务器的连接,因为那有很危险,切忌!等你掌握了大量的数据分析结果以后,比较有把握了在试试,看看你的运气好不好,很有可能会成功的哦,呵呵!
其实像网金也疯狂的那种模拟客户端的程序也是不错的,很适合office的人用,就看大家产品定位了.
好了不说了,大家努力吧!切忌不要被游戏厂商招安哦,那样有损我们的形象,我们是为了让游戏做的更好而开发的,也不愿意打乱游戏的平衡,哎,好像现在不是这样了!不说了随其自然吧!

98下是可以的，但到了2000时代，不同进程间不允许互相访问了，：（

偶找了篇文章，有点参考性，如下：

利用鼠标钩子获得Win2000密码框密码
获得Windows下的密码框密码，似乎是很多人感兴趣的话题，CSDN上问这类问题的人不计其数……这样看来，老罗也不能免俗啦，今天就让我跟大家探讨一下如何实现这一功能吧。^_^
我们知道，Windows下有一条功能很强劲的函数——SendMessage()，利用它能够实现很多意想不到的功能，例如获得密码框的密码就是其中一例。我们可以这样做：
char szPsw[255];
SendMessage(hWnd, WM_GETTEXT, 255, (LPARAM)(LPCTSTR)szPsw);
通过发送消息 WM_GETTEXT 给目标窗口句柄，我们就能够获得密码框的密码了，可是它还有一点不足，就是无法在 Win2000/WinXP 里面获得密码。这是因为 Win2000 对这个方法作了防范（当然啦，老比因为这个问题已经业界被骂死了），只要你是对其他进程进行这个操作，就会失效。呵呵，这也就是为什么很多同类的软件到了 Win2000 就死翘翘的原因。 ：）
那么是否就毫无办法了呢？当然不是！我们已经知道了失败的原因，就是不能在别的进程中使用这一函数……嗯？……聪明的你是不是已经想到了什么？
对了，只要我们能够在同一个进程中使用它，就可以实现了！如何做到“同一个进程”？呵呵，这又是一个问题。《Windows核心编程》的大牛 Jeffrey Richter 告诉我们，实现“同一进程”的办法有很多种，例如有通过注册表来插入DLL、使用远程线程插入DLL、使用特洛伊DLL来插入DLL、通过内存映射文件插入DLL……方法真的是有很多种，它们都能实现“同一个进程”这一目的，不过老罗觉得都不太理想，例如，使用远程线程是通过 CreateRemoteThread() 来插入DLL，但是这个 CreateRemoteThread() 在MSDN中是明确指出了不能在 Win9X 中使用的，也就是说，通用性要大打折扣。所以最后我决定使用鼠标钩子函数来实现！
聪明的读者可能还会问道：为什么用鼠标钩子就能实现了？其实答案很简单，因为密码框是一个 EDIT 控件，它肯定能够接收到鼠标消息，这样，我们的鼠标钩子函数就能够注入到远程的目标进程，这时的 SendMessage() 就是跟目标进程在同一个进程里面，是可以取出密码的。而且它有个非常好的地方：就是通用性强，理论上任何一个版本的 Windows 都能使用！！（我没有 WinXP ，所以只好说“理论上”啦，请有装 XP 的朋友帮忙试试，OK？）
明白了吧？最后还有一个细节问题——密码是在鼠标钩子函数里面获得的，那么如何返回给我们的主程序？老罗的做法是把密码作为全局共享变量，这样就可以在两个进程里面共享，我们的主程序就可以输出结果啦！
说了一大通废话，希望大家不要介意。下面我给出一个完整的例子，通过鼠标钩子函数注入远程进程获得任何一个版本 Windows 的密码框密码。（呵呵，好拗口啊！啊！别扔番茄！！）

———- 鼠标钩子函数的DLL ———-

文件名： HookDll.asm

;********************************************
.386
.model flat, stdcall
option casemap:none
include /masm32/include/windows.inc
include /masm32/include/user32.inc
includelib /masm32/lib/user32.lib
DllEntry proto :HINSTANCE, WORD, WORD
MouseProc proto WORD, WORD, WORD
GetPsw proto
InstallHook proto WORD
UninstallHook proto
.const
WM_MOUSEHOOK equ WM_USER + 6
;共享段：
.data?
hHook dd ?
hWnd dd ?
szPsw db 255 dup(?) ;关键语句！！！共享这个变量szPsw，以便在主程序中也能得到密码！
.data
hInstance HINSTANCE 0
.code
DllEntry proc hInst:HINSTANCE, reasonWORD, reserved1WORD
.if reason == DLL_PROCESS_ATTACH
push hInst
pop hInstance
.endif
mov eax, TRUE
ret
DllEntry endp
GetPsw proc
;关键！！返回密码！（前提是密码必须放在共享段！）
lea eax, szPsw
ret
GetPsw endp
MouseProc proc uses edx nCodeWORD, wParamWORD, lParamWORD
invoke CallNextHookEx, hHook, nCode, wParam, lParam
mov edx, lParam
assume edx: PTR MOUSEHOOKSTRUCT
;获得当前鼠标位置的窗口句柄：
invoke WindowFromPoint, [edx].pt.x, [edx].pt.y
;发送一个消息给当前窗口，获得它的标题：
invoke SendMessage, eax, WM_GETTEXT, 255, addr szPsw
;发送一个消息给主程序，以便在主程序中能处理鼠标钩子函数：
invoke PostMessage, hWnd, WM_MOUSEHOOK, 0, 0
assume edx: nothing
xor eax, eax
ret
MouseProc endp
InstallHook proc hwndWORD
;启动鼠标钩子函数：
push hwnd
pop hWnd
invoke SetWindowsHookEx, WH_MOUSE, addr MouseProc, hInstance, NULL
mov hHook, eax
ret
InstallHook endp
UninstallHook proc
;卸载鼠标钩子函数：
invoke UnhookWindowsHookEx, hHook
ret
UninstallHook endp
end DllEntry
;********** over **********
;by LC

编译这个DLL的时候记住要这样：（否则会失败哦！）
ml /c /coff HookDll.asm
link /section:.bss,S /DLL /subsystem:windows /def:HookDll.def HookDll.obj

———- 主程序调用 ———-

文件名： GetPsw.asm

;********************************************
;程序名称：获取密码框的密码，适用于Win9x/WinMe/Win2000/WinXP
;作者：罗聪
;日期：2002-10-8
;出处：http://www.luocong.com（老罗的缤纷天地）
;注意事项：如欲转载，请保持本程序的完整，并注明：
;转载自“老罗的缤纷天地”（http://www.luocong.com）
;********************************************
.386
.model flat, stdcall
option casemap:none
include /masm32/include/windows.inc
include /masm32/include/kernel32.inc
include /masm32/include/user32.inc
include HookDll.inc
includelib /masm32/lib/kernel32.lib
includelib /masm32/lib/user32.lib
includelib HookDll.lib
WndProc proto WORD, WORD, WORD, WORD
.const
IDC_EDIT_OUTPUT equ 3000
WM_MOUSEHOOK equ WM_USER + 6
.data
szDlgName db “lc_dialog”, 0
szPsw db 255 dup(0)
.code
main:
invoke GetModuleHandle, NULL
invoke DialogBoxParam, eax, offset szDlgName, 0, WndProc, 0
invoke ExitProcess, eax
WndProc proc hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM
LOCAL rect: RECT
.if uMsg == WM_CLOSE
;卸载鼠标钩子：
invoke UninstallHook
invoke EndDialog, hWnd, 0
.elseif uMsg == WM_INITDIALOG
;获得主程序的rect：
invoke GetWindowRect, hWnd, addr rect
;把主程序设置成“始终在最前面”：
invoke SetWindowPos, hWnd, HWND_TOPMOST, rect.left, rect.top, rect.right, rect.bottom, SWP_SHOWWINDOW
;鼠标钩子函数启动：
invoke InstallHook, hWnd
;处理鼠标钩子函数的消息：
.elseif uMsg == WM_MOUSEHOOK
;获得密码：
invoke GetPsw
;输出：
invoke SetDlgItemText, hWnd, IDC_EDIT_OUTPUT, eax
.else
mov eax, FALSE
ret
.endif
mov eax, TRUE
ret
WndProc endp
end main
;********** over **********
;by LC

———- 主程序的资源文件 ———-

文件名： GetPsw.rc

include “resource.h”

define IDC_EDIT_OUTPUT 3000

define IDC_STATIC -1

LC_DIALOG DIALOGEX 0, 0, 195, 30
STYLE DS_SETFONT | WS_MINIMIZEBOX | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
CAPTION “Get Password by LC, 2002-10-8”
FONT 9, “宋体”, 0, 0, 0x0
BEGIN
LTEXT “看看有什么：”, IDC_STATIC, 5, 12, 50, 12
EDITTEXT IDC_EDIT_OUTPUT, 60, 10, 130, 12, ES_AUTOHSCROLL | NOT WS_BORDER, WS_EX_STATICEDGE
END

怎么样？看明白了吗？如果你还不太懂得鼠标钩子函数的编写，请先参考 Iczelion 的教程，到处都有哦！假如还有什么疑问，那是

其中网络封包的拦截源代码可以作为是我的游戏外挂分析那篇文章的例子讲解吧。封包的分析要看经验了，这里不好多讲，如果仔细分析的话可能会讲1000页以上的内容，一般的分析大家可以用通用加密和解密算法来试试，如果不行的话那就是商家自己的加密算法，这就比较难办了，根据经验自己试试吧，比如同时放大缩小数据，看看有没有匹配字符串，异或一个自己的编码库等等，查看有没有明文结果，总之这些都是非常随机的，所以你分析出来了一个，但不一定可以分析出另外一个的，呵呵！祝大家好运！！
[DISABLELBCODE]

游戏外挂分析
石器 / MU和魔力会出现顺移外挂，是因为它的移动消息机制是客户端直接向服务器报告自己新坐标和人物方向，客户端又不是每走一步汇报一次，而是达到一定时间汇报一次，可能是一秒一次吧。正常情况下，每秒最大可走三步，顺移外挂直接向服务器发送新坐标就可以了。以前石器的服务器根本不检查两次坐标的距离差，所以能大顺移。后来大概修改了代码，新坐标如果与旧坐标距离超过3就视作外挂，立即断线。但3步顺移还是禁止不了，跳个沟或者跳到BOSS后面都可以，因为3步汇报一次坐标是这个引擎的最低要求。
服务器又不能去检查两个坐标之间是否有障碍或者有无BOSS（可能设计上根本没顾及到这个要求，又或者是检查它们会导致CPU占用率太高机器受不了）。
反观UO，传奇，顺移外挂一直没出过，因为他们的移动消息机制不同，他们每次移动都是向服务器汇报自己的移动方向，每移动一次汇报一次。而坐标是服务器回传给客户端的，客户端只有决定自己移动方向的权利，没有决定坐标的权利。如果你想向墙或者其他人物方向移动，服务器会发现并可能把你弹回来（传奇好象不弹，UO是肯定弹）。
根据这个结论，三步顺移是石器类型引擎的“死穴”，解决方法为：把围墙做厚把沟做宽，超过三步。象熊男这种BOSS不要放在路中央，他身后要有厚的门，打败他让门消失一段时间也可以实现偷渡，三步顺移就无效了。
再说加速：
1、普通网络加速，这是不可防和封的。一般情况下，网络程序发送消息出去时，如果消息很短，系统会自动把它保留0.1秒，看后面是否跟一个或几个消息，如果有跟的消息，系统把它们合成一个完整包发送出去。这是网络固有延迟，有程序的方法使这种延迟不存在。去掉这种延迟是种合法的行为，系统本身给了用户这个选择权。但通常情况下这是不道德的行为，因为消息包的小而碎，包数量大大增加，加大了交换机和路由器的负荷，对骨干网会造成不利影响，和在街上乱扔垃圾属于同一性质。有些外挂通过设置通信的模式实现这种加速，它对没用外挂的玩家来说很不公平。这类加速对魔力宝贝的效果可能不大，对UO和传奇有明显的效果，PK中你快那么一点别人就打不着你。
2、利用系统BUG加速：
石器的加速属于这种类型。石器客户程序内部固化一个定时器，人物动作快慢由这个定时器决定。石器外挂（台湾版SADE源代码我看过）是用反汇编方法获取定时器代码地址，并对内存中代码进行修改来实现时间片控制的，黑客高手所为（对其反汇编水平深感佩服）。这个外挂一度盛行，直到华义买到石器源代码，才针对它进行了修改。后来服务器可能做了如下设置：为每次移动和战斗开始记录时间片，客户端每移动数步比较时间差，如果超出系统允许的速度就断线。战斗结束比较时间差，如果过快也是外挂所为。也就是说从服务器设计上进行防护而不是*设备，这类外挂不难清理。怕的只是运营方没有源代码，或者有源代码技术又不足，或者开发方技术不足，这都会导致无法及时修正BUG。
再说改封包：
改封包的BUG其实也是系统设计导致的。（我不是说有BUG就是水平不行，这么大的程序百密一疏，BUG总是难免）。但有些BUG完全是设计水平低下造成的，比如石器的遇敌与否，居然是由客户端来决定。这件事交给服务器我想并不是难事，也不增加多少开销。黑客既然能反汇编石器代码，修改通信包更不是难事，所以原地、寸步、不遇敌太容易实现了。反过来如果遇敌交给服务器决定，这个功能外挂就根本实现不了。
再说看血外挂：
服务器在通信中告诉了客户端各怪物多少血，这个功能大概是游戏调试阶段所需要的，用于检查服务器的BUG。正式版本这个开关当然是关掉了，但问题是开关放在客户端而不是服务器，黑客们轻松地找到了这个开关，把它打开，于是大家可以看对面所有怪物的血了。
作为和石器差不多的引擎，魔力宝贝在系统设计上到底对这些因有BUG进行了多大程度的修正，我就不得而知了。如果没修正，某些针对引擎设计上固有BUG的外挂是根本防不住的。
现在魔力没有多少外挂，并不意味着将来没有。外挂的技术水平和游戏风行程度成正比，当前魔力还不是十分热门，如果它获得了大成功（根据网星的收费和服务水平暂时看不到这种希望），恐怕会变成下一个石器。
现在的RO也一样，在外挂打击的现在，必定也会有游状态的外挂出现~
期待。。。

分析客户端的有关资料
自己作外挂，大多时候要分析封包，不过因为有的功能是由客户端来辨别的，所以分析客户端的程序同样也很重要，分析客户端首先要求你能看懂汇编指令（只要”看懂”，要求很低的），其次是要能够熟练的运用一些工具，然后能剩下的也就是运气和游戏公司的漏洞了。（哈，不是每次都能成功的啊）下边我分步教给大家。
第一章 8086汇编指令
注：AX,BX,CX…,EAX,EBX,ECX…这些都是CPU用来存储数据的地方。
一、数据传输指令
作用：它们在存贮器和寄存器、寄存器和输入输出端口之间传送数据.
1. 通用数据传送指令.
MOV 传送字或字节.
MOVSX 先符号扩展,再传送.
MOVZX 先零扩展,再传送.
PUSH 把字压入堆栈.
POP 把字弹出堆栈.
PUSHA 把AX,CX,DX,BX,SP,BP,SI,DI依次压入堆栈.
POPA 把DI,SI,BP,SP,BX,DX,CX,AX依次弹出堆栈.
PUSHAD 把EAX,ECX,EDX,EBX,ESP,EBP,ESI,EDI依次压入堆栈.
POPAD 把EDI,ESI,EBP,ESP,EBX,EDX,ECX,EAX依次弹出堆栈.
BSWAP 交换32位寄存器里字节的顺序
XCHG 交换字或字节.( 至少有一个操作数为寄存器,段寄存器不可作为操作数)
CMPXCHG 比较并交换操作数.( 第二个操作数必须为累加器AL/AX/EAX )
XADD 先交换再累加.( 结果在第一个操作数里 )
XLAT 字节查表转换.
BX 指向一张 256 字节的表的起点, AL 为表的索引值 (0-255,即 0-FFH); 返回 AL 为查表结果. ( [BX+AL]->AL )
2. 输入输出端口传送指令.
IN I/O端口输入. ( 语法: IN 累加器, {端口号│DX} )
OUT I/O端口输出. ( 语法: OUT {端口号│DX},累加器 )
输入输出端口由立即方式指定时, 其范围是 0-255; 由寄存器 DX 指定时,其范围是 0-65535.
3. 目的地址传送指令.
LEA 装入有效地址.
例: LEA DX,string ;把偏移地址存到DX.
LDS 传送目标指针,把指针内容装入DS.
例: LDS SI,string ;把段地址:偏移地址存到DS:SI.
LES 传送目标指针,把指针内容装入ES.
例: LES DI,string ;把段地址:偏移地址存到ESI.
LFS 传送目标指针,把指针内容装入FS.
例: LFS DI,string ;把段地址:偏移地址存到FSI.
LGS 传送目标指针,把指针内容装入GS.
例: LGS DI,string ;把段地址:偏移地址存到GSI.
LSS 传送目标指针,把指针内容装入SS.
例: LSS DI,string ;把段地址:偏移地址存到SSI.
4. 标志传送指令.
LAHF 标志寄存器传送,把标志装入AH.
SAHF 标志寄存器传送,把AH内容装入标志寄存器.
PUSHF 标志入栈.
POPF 标志出栈.
PUSHD 32位标志入栈.
POPD 32位标志出栈.
二、算术运算指令
ADD 加法.
ADC 带进位加法.
INC 加 1.
AAA 加法的ASCII码调整.
DAA 加法的十进制调整.
SUB 减法.
SBB 带借位减法.
DEC 减 1.
NEC 求反(以 0 减之).
CMP 比较.(两操作数作减法,仅修改标志位,不回送结果).
AAS 减法的ASCII码调整.
DAS 减法的十进制调整.
MUL 无符号乘法.
IMUL 整数乘法.
以上两条,结果回送AH和AL(字节运算),或DX和AX(字运算),
AAM 乘法的ASCII码调整.
DIV 无符号除法.
IDIV 整数除法.
以上两条,结果回送:
商回送AL,余数回送AH, (字节运算);
或 商回送AX,余数回送DX, (字运算).
AAD 除法的ASCII码调整.
CBW 字节转换为字. (把AL中字节的符号扩展到AH中去)
CWD 字转换为双字. (把AX中的字的符号扩展到DX中去)
CWDE 字转换为双字. (把AX中的字符号扩展到EAX中去)
CDQ 双字扩展. (把EAX中的字的符号扩展到EDX中去)
三、逻辑运算指令
AND 与运算.
OR 或运算.
XOR 异或运算.
NOT 取反.
TEST 测试.(两操作数作与运算,仅修改标志位,不回送结果).
SHL 逻辑左移.
SAL 算术左移.(=SHL)
SHR 逻辑右移.
SAR 算术右移.(=SHR)
ROL 循环左移.
ROR 循环右移.
RCL 通过进位的循环左移.
RCR 通过进位的循环右移.
以上八种移位指令,其移位次数可达255次.
移位一次时, 可直接用操作码. 如 SHL AX,1.
移位>1次时, 则由寄存器CL给出移位次数.
如 MOV CL,04
SHL AX,CL
四、串指令
DS:SI 源串段寄存器 :源串变址.
ESI 目标串段寄存器:目标串变址.
CX 重复次数计数器.
AL/AX 扫描值.
D标志 0表示重复操作中SI和DI应自动增量; 1表示应自动减量.
Z标志 用来控制扫描或比较操作的结束.
MOVS 串传送.
( MOVSB 传送字符. MOVSW 传送字. MOVSD 传送双字. )
CMPS 串比较.
( CMPSB 比较字符. CMPSW 比较字. )
SCAS 串扫描.
把AL或AX的内容与目标串作比较,比较结果反映在标志位.
LODS 装入串.
把源串中的元素(字或字节)逐一装入AL或AX中.
( LODSB 传送字符. LODSW 传送字. LODSD 传送双字. )
STOS 保存串.
是LODS的逆过程.
REP 当CX/ECX<>0时重复.
REPE/REPZ 当ZF=1或比较结果相等,且CX/ECX<>0时重复.
REPNE/REPNZ 当ZF=0或比较结果不相等,且CX/ECX<>0时重复.
REPC 当CF=1且CX/ECX<>0时重复.
REPNC 当CF=0且CX/ECX<>0时重复.
五、程序转移指令
1>无条件转移指令 (长转移)
JMP 无条件转移指令
CALL 过程调用
RET/RETF过程返回.
2>条件转移指令 (短转移,-128到+127的距离内)
( 当且仅当(SF XOR OF)=1时,OP1

SoftICE动态调试程序，游戏修改工具（金山游侠），反汇编（W32Dasm），Hex Workshop

一、找到内存中坦克X坐标
　　1、用金山游侠搜索，方法如下（金山游侠的使用我就不说了）
　　　　把坦克往左移动一些，就搜索“减少”；坦克往右移动，就搜索“增大”
　　　　反复搜索将会找到一个地址（当然其他游戏可能不止一个），这里是08BFAACC
　　　　注：动态的内存分配就是下次你如果再次搜索，地址将不再是08BFAACC
　　2、找到那条代码修改了这个数据（X坐标）
　　　　加载 SoftIce
　　　　在游戏状态 Ctrl+D 调出SoftIce，输入 BPM 08BFAACC W，这里的W表示如果这个地 址被写将中断
　　　　回到游戏，移动坦克，左移一下，程序中断，SoftIce指向的上面一句是
　　　　　　004640B3 MOV DWORD PTR [ESI+000001A4],EAX
　　　　这句就是修改坦克坐标的代码，当然右移也能找到一句，这里就不重复了
　　3、修改程序使动态的数据变成静态
　　　　这里说点题外话，修改程序包括两种，一种是直接修改程序，一种是修改内存中的程序（内存补丁），这里由于我懒，所以用了第一种
　　修改程序：
　　　　疯狂坦克程序存在Fortress2.dat当中，如果你把这个文件改名为EXE文件一样可以运行，这里我们就把他修改成Fortress2.exe
　　　　打开W32Dasm反汇编，SHIFT+F12跳到004046B3，你看到这几行
　　　　　　004046B3 8986A4010000 MOV DWORD PTR [ESI+000001A4],EAX
　　　　　　004046B9 8B8644020000 MOV EAX,DWORD PTR [ESI+00000244]
　　　　　　004046BF C744241001000000 MOV [ESP+10],00000001
　　　　刚才我们说了004046B3是修改X坐标的那条语句，现在我们要让他每次修改完程序就能够把X坐标存储到一个固定的地址
　　　　现在要让它运行到这里就JMP到一个我们自己的代码的地方，于是在程序的尾部我们找到一段空白的区域00465A52，于是我修改004046BF为代码
　　　　JMP 00465A52，机器码为E98E130600，因为这句的长度不够以前的那句长，所以要加入几个NOP，机器码为90，所以我们打开HEX Workshop修改程序，CTRL+G跳到位移为000046BF的地方，看到了C744241001000000，我们把它修改为E98E130600909090，现在程序将一运行到这里就跳到00465A52运行我们的代码。
　　4、实现我们自己的代码，然后跳回
　　　　我们的代码要做的是把动态变成静态，
PUSH EAX
MOV EAX,[ESI+000001A4]
MOV [00470000],EAX
POP EAX
JMP 004046C7
　　　　这样这个数值无论运行多少次，只要你移动（当然右移也要修改）就能在00470000中找到X坐标，这段机器码为
　　　　50 8B86A4010000 A300004700 58 E95BECF9FF
　　　　忘了说刚才我们把004046BF替换掉的那句MOV [ESP+10],00000001也必须加上，所以打开HEX Workshop,CTRL+G跳到00465A52，修改加入
　　　　C744241001000000 50 8B86A4010000 A300004700 58 E95BECF9FF

　　　　这样动态数据就变成了静态

现在回顾一下
　　　　首先搜索坐标地址
　　　　找到改变这个地址的代码
　　　　修改代码让他跳到自己的代码中运行
　　　　在程序的空白段加入自己的代码，当然要补上被替换了的那句，还有修改了寄存器，必须先PUSH,再POP

　　　　下面的工作就是写一个程序读取这个地址了，我用VC写了一个，顺便贴一下关键代码

CProcess m_process;
bool m_ret=m_process.FindProcess(“FortressII”;
if (m_ret)
{
BYTE tank1xL = m_process.ReadByte(0x00470000);
BYTE tank1xR = m_process.ReadByte(0x00470001);
WORD tank1x = tank1xL+tank1xR*256;
temp = tank1x;
str.Format(“%d”,temp);
m_tank1x=str;
UpdateData(FALSE);
return TRUE;
}
else

return FALSE;

CProcess是一个我编写的修改类，这里用到的函数代码如下
HANDLE CProcess::OpenProcess(char *p_ClassName, char *p_WindowTitle)
{
HWND hWindow;
DWORD pid;
hWindow = FindWindow(p_ClassName, p_WindowTitle);
if (hWindow)
{
GetWindowThreadProcessId(hWindow, &pid);
return ::OpenProcess(PROCESS_ALL_ACCESS, false, pid);
}
return NULL;
}
bool CProcess::FindProcess(char *p_WindowTitle)
{
if (m_hProcess == NULL)
{
m_hProcess = this->OpenProcess(NULL, p_WindowTitle);
if (m_hProcess)
m_bGameRunning = true;
return m_bGameRunning;
}
else
return false;
}
BYTE CProcess::ReadByte(DWORD p_Address)
{
DWORD bytes;
BYTE tmpvalue;
if (m_bGameRunning)
{
if (ReadProcessMemory(m_hProcess, (void*)p_Address,
(void *)&tmpvalue, 1, &bytes) == 0)
return 0;
else
return tmpvalue;
}
return 0;
}

位运算基础（菜鸟看的）（有点像课本）
首先我们将WPE截获的封包保存为文本文件，然后打开它，这时会看到如下的数据（这里我们以金庸群侠传里PK店小二客户端发送的数据为例来讲解）：
第一个文件：
SEND-> 0000 E6 56 0D 22 7E 6B E4 17 13 13 12 13 12 13 67 1B
SEND-> 0010 17 12 DD 34 12 12 12 12 17 12 0E 12 12 12 9B
SEND-> 0000 E6 56 1E F1 29 06 17 12 3B 0E 17 1A
SEND-> 0000 E6 56 1B C0 68 12 12 12 5A
SEND-> 0000 E6 56 02 C8 13 C9 7E 6B E4 17 10 35 27 13 12 12
SEND-> 0000 E6 56 17 C9 12
第二个文件：
SEND-> 0000 83 33 68 47 1B 0E 81 72 76 76 77 76 77 76 02 7E
SEND-> 0010 72 77 07 1C 77 77 77 77 72 77 72 77 77 77 6D
SEND-> 0000 83 33 7B 94 4C 63 72 77 5E 6B 72 F3
SEND-> 0000 83 33 7E A5 21 77 77 77 3F
SEND-> 0000 83 33 67 AD 76 CF 1B 0E 81 72 75 50 42 76 77 77
SEND-> 0000 83 33 72 AC 77
我们发现两次PK店小二的数据格式一样，但是内容却不相同，我们是PK的同一个NPC，为什么会不同呢？
原来金庸群侠传的封包是经过了加密运算才在网路上传输的，那么我们面临的问题就是如何将密文解密成明文再分析了。
因为一般的数据包加密都是异或运算，所以这里先讲一下什么是异或。
简单的说，异或就是”相同为0，不同为1”（这是针对二进制按位来讲的），举个例子，0001和0010异或，我们按位对比，得到异或结果是0011，计算的方法是：0001的第4位为0，0010的第4位为0，它们相同，则异或结果的第4位按照”相同为0，不同为1”的原则得到0，0001的第3位为0，0010的第3位为0，则异或结果的第3位得到0，0001的第2位为0，0010的第2位为1，则异或结果的第2位得到1，0001的第1位为1，0010的第1位为0，则异或结果的第1位得到1，组合起来就是0011。异或运算今后会遇到很多，大家可以先熟悉熟悉，熟练了对分析很有帮助的。
下面我们继续看看上面的两个文件，按照常理，数据包的数据不会全部都有值的，游戏开发时会预留一些字节空间来便于日后的扩充，也就是说数据包里会存在一些”00”的字节，观察上面的文件，我们会发现文件一里很多”12”，文件二里很多”77”，那么这是不是代表我们说的”00”呢？推理到这里，我们就开始行动吧！
我们把文件一与”12”异或，文件二与”77”异或，当然用手算很费事，我们使用”M2M 1.0 加密封包分析工具”来计算就方便多了。得到下面的结果：
第一个文件：
1 SEND-> 0000 F4 44 1F 30 6C 79 F6 05 01 01 00 01 00 01 75 09
SEND-> 0010 05 00 CF 26 00 00 00 00 05 00 1C 00 00 00 89
2 SEND-> 0000 F4 44 0C E3 3B 13 05 00 29 1C 05 08
3 SEND-> 0000 F4 44 09 D2 7A 00 00 00 48
4 SEND-> 0000 F4 44 10 DA 01 DB 6C 79 F6 05 02 27 35 01 00 00
5 SEND-> 0000 F4 44 05 DB 00
第二个文件：
1 SEND-> 0000 F4 44 1F 30 6C 79 F6 05 01 01 00 01 00 01 75 09
SEND-> 0010 05 00 70 6B 00 00 00 00 05 00 05 00 00 00 1A
2 SEND-> 0000 F4 44 0C E3 3B 13 05 00 29 1C 05 84
3 SEND-> 0000 F4 44 09 D2 56 00 00 00 48
4 SEND-> 0000 F4 44 10 DA 01 B8 6C 79 F6 05 02 27 35 01 00 00
5 SEND-> 0000 F4 44 05 DB 00
哈，这一下两个文件大部分都一样啦，说明我们的推理是正确的，上面就是我们需要的明文！
接下来就是搞清楚一些关键的字节所代表的含义，这就需要截获大量的数据来分析。
首先我们会发现每个数据包都是”F4 44”开头，第3个字节是变化的，但是变化很有规律。我们来看看各个包的长度，发现什么没有？对了，第3个字节就是包的长度！
通过截获大量的数据包，我们判断第4个字节代表指令，也就是说客户端告诉服务器进行的是什么操作。例如向服务器请求战斗指令为”30”，战斗中移动指令为”D4”等。
接下来，我们就需要分析一下上面第一个包”F4 44 1F 30 6C 79 F6 05 01 01 00 01 00 01 75 09 05 00 CF 26 00 00 00 00 05 00 1C 00 00 00 89”，在这个包里包含什么信息呢？应该有通知服务器你PK的哪个NPC吧，我们就先来找找这个店小二的代码在什么地方。
我们再PK一个小喽罗（就是大理客栈外的那个咯）：
SEND-> 0000 F4 44 1F 30 D4 75 F6 05 01 01 00 01 00 01 75 09
SEND-> 0010 05 00 8A 19 00 00 00 00 11 00 02 00 00 00 C0
我们根据常理分析，游戏里的NPC种类虽然不会超过65535（FFFF），但开发时不会把自己限制在字的范围，那样不利于游戏的扩充，所以我们在双字里看看。通过”店小二”和”小喽罗”两个包的对比，我们把目标放在”6C 79 F6 05”和”CF 26 00 00”上。（对比一下很容易的，但你不能太迟钝咯，呵呵）我们再看看后面的包，在后面的包里应该还会出现NPC的代码，比如移动的包，游戏允许观战，服务器必然需要知道NPC的移动坐标，再广播给观战的其他玩家。在后面第4个包”SEND-> 0000 F4 44 10 DA 01 DB 6C 79 F6 05 02 27 35 01 00 00”里我们又看到了”6C 79 F6 05”，初步断定店小二的代码就是它了！
（这分析里边包含了很多工作的，大家可以用WPE截下数据来自己分析分析）
第一个包的分析暂时就到这里（里面还有的信息我们暂时不需要完全清楚了）
我们看看第4个包”SEND-> 0000 F4 44 10 DA 01 DB 6C 79 F6 05 02 27 35 01 00 00”，再截获PK黄狗的包，（狗会出来2只哦）看看包的格式：
SEND-> 0000 F4 44 1A DA 02 0B 4B 7D F6 05 02 27 35 01 00 00
SEND-> 0010 EB 03 F8 05 02 27 36 01 00 00
根据上面的分析，黄狗的代码为”4B 7D F6 05”（100040011），不过两只黄狗服务器怎样分辨呢？看看”EB 03 F8 05”（100140011），是上一个代码加上100000，呵呵，这样服务器就可以认出两只黄狗了。我们再通过野外遇敌截获的数据包来证实，果然如此。
那么，这个包的格式应该比较清楚了：第3个字节为包的长度，”DA”为指令，第5个字节为NPC个数，从第7个字节开始的10个字节代表一个NPC的信息，多一个NPC就多10个字节来表示。
大家如果玩过网金，必然知道随机遇敌有时会出现增援，我们就利用游戏这个增援来让每次战斗都会出现增援的NPC吧。
通过在战斗中出现增援截获的数据包，我们会发现服务器端发送了这样一个包：
F4 44 12 E9 EB 03 F8 05 02 00 00 03 00 00 00 00 00 00
第5-第8个字节为增援NPC的代码（这里我们就简单的以黄狗的代码来举例）。
那么，我们就利用单机代理技术来同时欺骗客户端和服务器吧！

如何操作内存
进程：用最简洁的话来说，进程就是一个正在执行的程序，一个或多个线程在进程中运行。
线程：线程是操作系统分配CPU运算时间的最小单位。
每一个进程都提供了运行一个程序所必需的资源，一个进程具有4GB的虚拟地址空间，可执行代码，数据，对
象句柄，环境变量，优先权以及设置最大化最小化的功能。每一个进程都从一个主线程开始执行，但可以在它所拥有
的线程中创建额外的线程。如果在某个线程中创建了一个子线程，那么当它开始执行后，就是一匹脱缰的野马，很难
再控制它了。因此，多线程技术在Win32平台下是需要很高的技巧的。一个进程的所有线程共享进程的虚拟地址空间和
系统资源，一个线程的资源包括线程的机器寄存器设置，内核堆栈，线程环境变量和进程虚拟地址中的用户堆栈。
对于不同的操作系统，每个进程的虚拟地址空间的分配是不同的。Windows NT Server Enterprise Edition
及Windows 2000 Advanced Server中低3GB虚拟地址空间供进程使用，高1GB供操作系统的内核代码使用。Windows
NT/2000中低2GB供进程使用，高2GB供操作系统内核代码使用。Windows9X：0——64K只读空间用来装入Microsoft DOS
信息，64K——4M装入DOS的兼容代码，4M——2GB的私有空间供进程使用，2GB——3GB的共享空间装入各种DLL代码，
3GB——4GB为共享的系统内核代码空间，其中共享的2GB——4GB的空间是99%的“内存无效页错误”、“General
Protect Error(GPE)”及蓝屏的罪魁祸首。
当然，操作系统不会真的给每个进程分配4GB的内存空间，否则，别说内存，连虚拟内存都不够用。操作系统
会将需要用到的某段虚拟地址的内容映射到物理内存，这种映射操作是操作系统内核完成的，无需程序员来控制。
基本概念就是这样，现在我们开始学习如何操作某个所需的进程的内存（严格来讲，是操作它的虚拟地址上
的数据，下同）。
首先，用CreateToolhelp32Snapshot创建当前内存的一个快照，将返回的句柄传递给Process32First、
Process32Next来遍历内存中的所有进程，一旦遇到所需修改的某个游戏的进程，就将其进程ID保存下来，再用
OpenProcess打开这个进程，从而获得该进程的进程句柄。最后，利用这个句柄，使用ReadProcessMemory、
WriteProcessMemory来读写虚拟地址。
以下是一段例子代码（结构及API函数的声明略去）：
保存API函数返回值的临时变量
Dim lngAPIReturn As Long
内存快照的句柄
Dim lngHSnapShot As Long
保存进程可执行文件名的临时变量
Dim strExe As String
某个你感兴趣的可执行文件执行后的进程的ID
Dim lngProcessID As Long
某个你感兴趣的可执行文件执行后的进程的句柄
Dim lngHProcess As Long
字节缓冲区，保存从内存中读取的数据
Dim bytBuffer as Byte
保存ReadProcessMemory函数返回信息的临时变量
Dim lngCharaWrite As Long
保存进程信息的结构
Dim tProcessEntry As PROCESSENTRY32
tProcessEntry.dwSize = Len(tProcessEntry)
获得当前内存快照的句柄
lngHSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
查找内存中第一个进程
lngAPIReturn = Process32First(lngHSnapShot, tProcessEntry)
Do
strExe = “”
If InStr(tProcessEntry.szExeFile, Chr(0)) > 1 Then
对win9X，strExe为带路径的文件名，对win2K为不带路径的文件名
strExe = Left(tProcessEntry.szExeFile, InStr(tProcessEntry.szExeFile, Chr(0)) -
1)
tProcessEntry.szExeFile = Space(MAX_PATH)
End If
查看可执行文件名是不是某个感兴趣的文件
If UCase(strExe) = UCase(“某个可执行文件名” Then
保存下该进程的ID
lngProcessID = tProcessEntry.th32ProcessID
Exit Do
End If
查找内存中下一个进程
lngAPIReturn = Process32Next(lngHSnapShot, tProcessEntry)
Loop While (lngAPIReturn <> 0)
打开进程
lngHProcess = OpenProcess(PROCESS_VM_READ + PROCESS_VM_WRITE + PROCESS_VM_OPERATION, 0,
lngProcessID)
读取进程虚拟地址1048576中的数据
lngAPIReturn = ReadProcessMemory(lngHProcess, 1048576, bytBuffer, 1, lngCharaWrite)
写入进程虚拟地址1048576中的数据
lngAPIReturn = WriteProcessMemory(lngHProcess, 1048576, bytBuffer, 1, lngCharaWrite)
关闭句柄
lngAPIReturn = CloseHandle(lngHProcess)

Hook Win32 API 的应用研究
之一：网络监控
绝大多数具有网络功能的软件都是基于socket(网络套接字)实现的，或者是使用了更高层的接口(例如：WinInet API)而最底层仍然是基于socket实现的。在大多数操作系统中都实现了socket接口，在WINDOWS操作系统中的实现称为WinSock。WinSock是以DLL的形式实现的，现在WinSock有两个版本的实现：WinSock 1.1(winsock.dll)和WinSock 2(ws2_32.dll)，ws2_32.dll既支持WinSock 1.1的函数又支持WinSock 2规范中增加的许多额外的函数，我们可以像Win32 API一样的使用它，只是需要额外链接一个库而已。这里不讨论具体的WinSock编程，只是让大家了解，WinSock是WINDOWS应用程序与网络打交道的接口，是我们实现网络监控这个目的的突破口。
好了，那我们就开始吧！“网络监控”这个范围有点太泛了，我们先把范围缩小到监控网络连接请求这个具体的操作上面吧，这也就是我的作品：IPGate 网址过滤器 的核心技术。我们先来看看一个TCP/IP连接是如何建立的：
客户机端 服务器端
======== ========
监听套接字 连接套接字
========= =========
socket() socket()
bind() bind()
listen()
connect()—–>accept()——>创建连接套接字
send()———————–>recv()
recv()<———————–send()
.
.
.
closesocket() closesocket() closesocket()
我们可以看出，是客户机端的connect()执行实际的连接请求动作，我们再来看看connect函数的参数：
int connect(
SOCKET s, // 指定对哪个套接字进行操作
const struct sockaddr FAR *name, // 这是一个描述服务器IP地址的结构
int namelen // 指明上面这个结构的大小
);
对于name参数，由于sockaddr结构内容依赖于具体的协议，所以对于TCP/IP协议，我们传递sockaddr_in这个结构，再来看看这个结构：
struct sockaddr_in{
short sin_family; // 必须为AF_INET
unsigned short sin_port; // IP端口号
struct in_addr sin_addr; // 标识IP地址的一个结构体
char sin_zero[8]; // 为了兼容sockaddr而设置的占位空间
};
到这儿，我们可以看出，对于一次连接请求的目的地信息，已经全部在传入的参数中描述清楚了，接下来要做的就设置一个全局API钩子，钩住所有程序的connect()调用，在进行实际的connect()操作之前，我们先分析传入的参数，如果发现连接目的地是我们不允许访问的，就不进行连接操作，仅返回一个错误码就可以了。就这么简单，就能实现一夫当关，万夫莫开的效果。
同样的道理，也可以Hook其它函数而实现监控整个网络通讯各方面的内容，比如说截取发送和接收的数据包进行分析等等，这就取决于设计者的意图了，大家不妨动手试试看，感受一下Hook API的魅力。
之二：进程防杀
在WINDOWS操作系统下，当我们无法结束或者不知道怎样结束一个程序的时候，或者是懒得去找“退出”按钮的时候，通常会按“CTRL+ALT+DEL”呼出任务管理器，找到想结束的程序，点一下“结束任务”就了事了，呵呵，虽然有点粗鲁，但大多数情况下都很有效，不是吗？
设想一下，如果有这么一种软件，它所要做的工作就是对某个使用者在某台电脑上的活动作一定的限制，而又不能被使用者通过“结束任务”这种方式轻易地解除限制，那该怎么做？无非有这么三种方法：1.屏蔽“CTRL+ALT+DEL”这个热键的组合；2.让程序不出现在任务管理器的列表之中；3.让任务管理器无法杀掉这个任务。对于第一种方法，这样未免也太残酷了，用惯了“结束任务”这种方法的人会很不习惯的；对于第二种方法，在WINDOWS 9X下可以很轻易地使用注册服务进程的方法实现，但是对于WINDOWS NT架构的操作系统没有这个方法了，进程很难藏身，虽然仍然可以实现隐藏，但实现机制较为复杂；对于第三种方法，实现起来比较简单，我的作品：IPGate 网址过滤器 就是采用的这种方式防杀的，接下来我就来介绍这种方法。
任务管理器的“结束任务”实际上就是强制终止进程，它所使用的杀手锏是一个叫做TerminateProcess()的Win32 API函数，我们来看看它的定义：
BOOL TerminateProcess(
HANDLE hProcess; // 将被结束进程的句柄
UINT uExitCode; // 指定进程的退出码
);
看到这里，是不是觉得不必往下看都知道接下来要做什么：Hook TerminateProcess()函数，每次TerminateProcess()被调用的时候先判断企图结束的进程是否是我的进程，如果是的话就简单地返回一个错误码就可以了。真的是这么简单吗？先提出一个问题，如何根据hProcess判断它是否是我的进程的句柄？答案是：在我的进程当中先获得我的进程的句柄，然后通过进程间通讯机制传递给钩子函数，与hProcess进行比较不就行了？错！因为句柄是一个进程相关的值，不同进程中得到的我的进程的句柄的值在进程间进行比较是无意义的。
怎么办？我们来考察一下我的hProcess它是如何得到的。一个进程只有它的进程ID是独一无二的，操作系统通过进程ID来标识一个进程，当某个程序要对这个进程进行访问的话，它首先得用OpenProcess这个函数并传入要访问的进程ID来获得进程的句柄，来看看它的参数：
HANDLE OpenProcess(
DWORD dwDesiredAccess, // 希望获得的访问权限
BOOL bInheritHandle, // 指明是否希望所获得的句柄可以继承
DWORD dwProcessId // 要访问的进程ID
);
脉络渐渐显现：在调用TerminateProcess()之前，必先调用OpenProcess()，而OpenProcess()的参数表中的dwProcessId是在系统范围内唯一确定的。得出结论：要Hook的函数不是TerminateProcess()而是OpenProcess()，在每次调用OpenProcess()的时候，我们先检查dwProcessId是否为我的进程的ID(利用进程间通讯机制)，如果是的话就简单地返回一个错误码就可以了，任务管理器拿不到我的进程的句柄，它如何结束我的进程呢？
至此，疑团全部揭开了。由Hook TerminateProcess()到Hook OpenProcess()的这个过程，体现了一个逆向思维的思想。其实我当初钻进了TerminateProcess()的死胡同里半天出也不来，但最终还是蹦出了灵感的火花，注意力转移到了OpenProcess()上面，实现了进程防杀

之三：变速控制
这是Hook Win32 API的一个比较另类和有趣的应用方面。
这里所指的变速控制，并不是说可以改变任何程序的运行速度，只能改变符合这些条件的程序的运行速度：程序的运行速度依赖于定时控制，也就是说，程序的执行单元执行的频率是人为的依*定时机制控制的，不是依赖于CPU的快慢。比如说，某个程序每隔1秒钟发出“滴答”声，它在快的电脑上和慢的电脑上所表现出来的行为是一致的。这样的依赖于定时控制的程序才是我们的研究“变速”对象。
一个WINDOWS应用程序的定时机制有很多。像上面提到的例子程序可以采用WM_TIMER消息来实现，通过函数SetTimer()可以设定产生WM_TIMER消息的时间间隔。其它的方法还有通过GetTickCount()和timeGetTime()等函数得到系统时间，然后通过比较时间间隔来定时，还有timerSetEvent()设置时钟事件等等方式。先来看看这些函数的定义：
UINT_PTR SetTimer(
HWND hWnd, // 接收WM_TIMER消息的窗口句柄
UINT_PTR nIDEvent, // 定时器的ID号
UINT uElapse, // 发生WM_TIMER消息的时间间隔
TIMERPROC lpTimerProc // 处理定时发生时的回调函数入口地址
);
MMRESULT timeSetEvent(
UINT uDelay, // 时钟事件发生的时间间隔
UINT uResolution, // 设置时钟事件的分辨率
LPTIMERCALLBACK lpTimerProc, // 处理时钟事件发生时的回调函数入口地址
DWORD dwUser, // 用户提供的回调数据
UINT fuEvent // 设置事件的类型
);
DWORD GetTickCount(VOID) // 返回系统启动以来经过了多少毫秒了
DWORD timeGetTime(VOID) // 类似于GetTickCount()，但分辨率更高
那么我们来看，如果能控制SetTimer()的uElapse参数、timeSetEvent()的uDelay参数、GetTickCount()和timeGetTime()的返回值，就能实现变速控制，除非应用程序使用的是其它的定时机制，不过大多数应用程序采用的定时机制不外乎都是这些。
该轮到Hook大法出场了。因为我们一般只想改变某个程序的速度，比如是说某个游戏程序，所以我们不设置全局钩子。又因为我们不清楚那个应用程序到底使用的是那种定时机制，所以上述几个函数我们全部都要接管，然后把关于定时参数或返回值按比例缩放就可以了。

之四：屏幕取词
用过金山词霸吧？用过的人一定对它的屏幕取词功能印象很深刻，因为这种功能使翻译过程更加简便快捷，屏幕取词是金山词霸的核心技术之一。
大家有没有想过这样神奇的功能是如何实现的呢？经历过DOS年代系统编程的人可能知道，屏幕上显示的字符是存放在显存里的，每个坐标的字符对应显存的一个特定的现存单元存储的字符，直接操作显存，就可以进行字符的显示和读取，若WINDOWS是这样就好了，可惜事实上相去甚远。那WINDOWS的字符是怎样显示的呢？WINDOWS是图形界面，显示的最小单位是像素(Pixel)，上面的所有东西都是“画”上去的，当然也包括了字符，也就没有什么字符显存的概念了。没有了直接操作显存而获得屏幕上字符内容的办法了，那还有什么方法呢？
让我们来设身处地地想想看，假如我们要在自己的程序中显示一个字符串，我们会怎样做呢？不要回答是MessageBox()，我们不是指的这种“显示”方法，我指的是最低阶的方法，也就是直接操作DC的方法，我想一般就是调用上面提到过的Win32 API函数TextOut()了，当然，还有类似的一些其它函数，例如：ExtTextOut()、DrawText()、DrawTextEx()等等。好了，找到点眉目了，我们来看看这些函数的参数能提供哪些信息，这里只列出TextOut()函数的定义，其它的函数基本都包含这些参数，另外提供了更多的附加选项而已，请查阅MSDN相关文档：
BOOL TextOut(
HDC hdc, // 设备上下文句柄
int nXStart, // 开始绘制字符串的位置的x坐标
int nYStart, // 开始绘制字符串的位置的y坐标
LPCTSTR lpString, // 指向字符串的指针
int cbString // 指明要绘制多少个字符
);
我们看到，坐标和内容都有了，这不正是我们想要的信息吗？只要Hook住这个函数，这些信息不都唾手可得了吗？于是祭出Hook大法来做个实验：先随便用VC的向导开辟一个单文档应用程序，在OnDraw()函数里调用TextOut()在某个位置随便输出一个字符串(不论是调用pDC->TextOut(…)或者是::TextOut(…)都一样，CDC类只不过把TextOut()封装了一下而已)，然后在OnInitialUpdate()里设置Hook(用现成的库)，钩住TextOut()，截获TextOut之后，让TextOut()输出另外一个字符串而不输出原来的字符串。还要记住在OnDestroy()里解除Hook。最后编译连接，测试程序。你会发现不仅是你调用TextOut()输出的地方的字符串被替换了，而且连才旦、对话框等等有字的地方也变了，在实验成功之余，是不是个意外的收获？其实WINDOWS内部的大多数文字输出也是调用了TextOut()函数来实现的。现在水落石出了，我们只要Hook住文字输出函数，包括我上面提到的和没有提到的函数，就能截获屏幕上文字输出的坐标和内容等等信息，只要我们一一作记录，并加以分析转换，跟鼠标的位置进行比较，我们就能得到屏幕上某个位置的文字内容是什么了，要翻译怎么的，就看你的了，这就是屏幕取词，虽然实际上实现的过程并不像说得那么简单。
出了词霸的屏幕取词，还有一些动态汉化、外挂中文平台之类的软件，也是基于这种技术的，现在看来，它们是不是已经不再神秘了？

关于API HOOK拦截封包原理

利用hook截获进程的API调用
截获API是个很有用的东西，比如你想分析一下别人的程序是怎样工作的。这里我介绍一下一种我自己试验通过的方法。
首先，我们必须设法把自己的代码放到目标程序的进程空间里去。Windows Hook可以帮我们实现这一点。SetWindowsHookEx的声明如下：
HHOOK SetWindowsHookEx(
int idHook, // hook type
HOOKPROC lpfn, // hook procedure
HINSTANCE hMod, // handle to application instance
DWORD dwThreadId // thread identifier
);
具体的参数含义可以翻阅msdn，没有msdn可谓寸步难行。
这里Hook本身的功能并不重要，我们使用它的目的仅仅只是为了能够让Windows把我们的代码植入别的进程里去。hook Type我们任选一种即可，只要保证是目标程序肯定会调用到就行，这里我用的是WH_CALLWNDPROC。lpfn和hMod分别指向我们的钩子代码及其所在的dll，dwThreadId设为0，表示对所有系统内的线程都挂上这样一个hook，这样我们才能把代码放到别的进程里去。
之后，我们的代码就已经进入了系统内的所有进程空间了。必须注意的是，我们只需要截获我们所关心的目标程序的调用，因此还必须区分一下进程号。我们自己的钩子函数中，第一次运行将进行最重要的API重定向的工作。也就是通过将所需要截获的API的开头几个字节改为一个跳转指令，使其跳转到我们的API中来。这是最关键的部分。这里我想截三个调用，ws2_32.dll中的send和recv、user32.dll中的GetMessageA。
DWORD dwCurrentPID = 0;
HHOOK hOldHook = NULL;
DWORD pSend = 0;
DWORD pRecv = 0;
GETMESSAGE pGetMessage = NULL;
BYTE btNewBytes[8] = { 0x0B8, 0x0, 0x0, 0x40, 0x0, 0x0FF, 0x0E0, 0 };
DWORD dwOldBytes[3][2];
HANDLE hDebug = INVALID_HANDLE_value;
LRESULT CALLBACK CallWndProc( int nCode, WPARAM wParam, LPARAM lParam )
{
DWORD dwSize;
DWORD dwPIDWatched;
HMODULE hLib;
if( dwCurrentPID == 0 )
{
dwCurrentPID = GetCurrentProcessId();
HWND hwndMainHook;
hwndMainHook = ::FindWindow( 0, “MainHook” );
dwPIDWatched = ::SendMessage( hwndMainHook, (WM_USER+100), 0, 0 );
hOldHook = (HHOOK)::SendMessage( hwndMainHook, (WM_USER+101), 0, 0 );
if( dwCurrentPID == dwPIDWatched )
{
hLib = LoadLibrary( “ws2_32.dll” );
pSend = (DWORD)GetProcAddress( hLib, “send” );
pRecv = (DWORD)GetProcAddress( hLib, “recv” );
::ReadProcessMemory( INVALID_HANDLE_value, (void )pSend, (void )dwOldBytes[0], sizeof(DWORD)*2, &dwSize );
(DWORD )( btNewBytes + 1 ) = (DWORD)new_send;
::WriteProcessMemory( INVALID_HANDLE_value, (void )pSend, (void )btNewBytes, sizeof(DWORD)*2, &dwSize );
::ReadProcessMemory( INVALID_HANDLE_value, (void )pRecv, (void )dwOldBytes[1], sizeof(DWORD)*2, &dwSize );
(DWORD )( btNewBytes + 1 ) = (DWORD)new_recv;
::WriteProcessMemory( INVALID_HANDLE_value, (void )pRecv, (void )btNewBytes, sizeof(DWORD)*2, &dwSize );
hLib = LoadLibrary( “user32.dll” );
pGetMessage = (GETMESSAGE)GetProcAddress( hLib, “GetMessageA” );
::ReadProcessMemory( INVALID_HANDLE_value, (void )pGetMessage, (void )dwOldBytes[2], sizeof(DWORD)*2, &dwSize );
(DWORD )( btNewBytes + 1 ) = (DWORD)new_GetMessage;
::WriteProcessMemory( INVALID_HANDLE_value, (void )pGetMessage, (void )btNewBytes, sizeof(DWORD)*2, &dwSize );
hDebug = ::CreateFile( “C://Trace.log”, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0 );
}
}
if( hOldHook != NULL )
{
return CallNextHookEx( hOldHook, nCode, wParam, lParam );
}
return 0;
}
上面的钩子函数，只有第一次运行时有用，就是把三个函数的首8字节修改一下（实际上只需要7个）。btNewBytes中的指令实际就是
mov eax, 0x400000
jmp eax
这里的0x400000就是新的函数的地址，比如new_recv/new_send/new_GetMessage，此时，偷梁换柱已经完成。再看看我们的函数中都干了些什么。以GetMessageA为例：
BOOL _stdcall new_GetMessage( LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax )
{
DWORD dwSize;
char szTemp[256];
BOOL r = false;
//Watch here before its executed.
sprintf( szTemp, “Before GetMessage : HWND 0x%8.8X, msgMin 0x%8.8X, msgMax 0x%8.8x /r/n”, hWnd, wMsgFilterMin, wMsgFilterMax );
::WriteFile( hDebug, szTemp, strlen(szTemp), &dwSize, 0 );
//Watch over
// restore it at first
::WriteProcessMemory( INVALID_HANDLE_value, (void )pGetMessage, (void )dwOldBytes[2], sizeof(DWORD)*2, &dwSize );
// execute it
r = pGetMessage( lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax );
// hook it again
(DWORD )( btNewBytes + 1 ) = (DWORD)new_GetMessage;
::WriteProcessMemory( INVALID_HANDLE_value, (void )pGetMessage, (void )btNewBytes, sizeof(DWORD)*2, &dwSize );
//Watch here after its executed
sprintf( szTemp, “Result of GetMessage is %d./r/n”, r );
::WriteFile( hDebug, szTemp, strlen( szTemp ), &dwSize, 0 );
if( r )
{
sprintf( szTemp, “Msg : HWND 0x%8.8X, MSG 0x%8.8x, wParam 0x%8.8X, lParam 0x%8.8X/r/nTime 0x%8.8X, X %d, Y %d/r/n”,
lpMsg->hwnd, lpMsg->message,
lpMsg->wParam, lpMsg->lParam, lpMsg->time,
lpMsg->pt.x, lpMsg->pt.y );
::WriteFile( hDebug, szTemp, strlen( szTemp ), &dwSize, 0 );
}
strcpy( szTemp, “/r/n” );
::WriteFile( hDebug, szTemp, strlen( szTemp ), &dwSize, 0 );
//Watch over
return r;
}
先将截获下来的参数，写入到一个log文件中，以便分析。然后恢复原先保留下来的GetMessageA的首8字节，然后执行真正的GetMessageA调用，完毕后再将执行结果也写入log文件，然后将GetMessageA的执行结果返回给调用者。
整个截获的过程就是这样。你可以把其中的写log部分改成你自己想要的操作。这里有个不足的地方是，截获动作是不能够并发进行的，如果目标进程是多线程的，就会有问题。解决办法是，可以在每次new_GetMessage中加入一个CriticalSection的锁和解锁，以使调用变为串行进行，但这个我没有试验过。

截获WINSOCKET
截获WINSOCKET
TCP/IP协议是目前各网络操作系统主要的通讯协议，也是 INTERNET的通讯协议，WIN95/NT平台提供了TCP/IP协议的实现 函数库WINSOCKET（WSOCKET.DLL）动态库，因而可以利用WINSOCKET 编写基于TCP/IP协议的应用系统。（UNIX平台提供BSD-SOCKET）
—- 在实际应用开发中，我们总希望在调用正常的WINSOCKET接口 函数时，先进行各自的特殊处理，如对于开发基于WIN95/NT平台 的VPN客户端软件时，我们希望应用信息在发送前即在调用SEND函 数时，先对信息进行加密后再发送。又如有的应用系统调用CONNECT 函数进行连接请求，我们需要截获此调用，插入我们自己的身份认证。 模块，只有合法的身份，才可以调用正常的CONNECT函数，而非法的 身份则不进行CONNECT调用。因而需要开发一种截获WINSOCKET函数调用 的方法（INTERCEPT WINSOCKET），使在进行WINSOCK正常函数调用之前， 使其先调用我们的身份认证模块，加解密模块。由于在WIN95/NT平台 WINSOCKET是以动态连接库（DLL）形式提供的，应而使各种应用系统在 进行TCP/IP协议通讯时，无须任何修改，就先调用我们的应用模块， 实现应用的透明性。
—- 一般要截获动态库（DLL）的调用，可以用HOOK（钩子技术），或外包DLL 技术，即将原来的DLL库改名（如将WINSOCK库WSOCK32.DLL改为A.DLL）， 新建一个DLL库，WSOCKET32.DLL，在新的DLL库中调用旧的DLL库。
—- 以下给出了利用VISUAL C++实现的截获WINSOCK的应用程序的源代码。Zip 4KB
—- 先将WINSOCK库WSOCK32.DLL该名为AAA.DLL，WSOCK32.AAA
—- 利用VISUAL C++创建一个DLL项目 WSOCK32.DLL
—- 目前加入的模块为一个日志处理。

网络游戏的封包
网络游戏的封包技术是大多数编程爱好者都比较关注的关注的问题之一，在这一篇里就让我们一起研究一下这一个问题吧。
别看这是封包这一问题，但是涉及的技术范围很广范，实现的方式也很多（比如说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做以下封装：
const
WSADESCRIPTION_LEN = 256;
WSASYS_STATUS_LEN = 128;
type
PWSA_DATA = ^TWSA_DATA;
WSA_DATA = record
wVersion: Word;
wHighVersion: Word;
szDescription: array[0..WSADESCRIPTION_LEN] of Char;
szSystemStatus: array[0..WSASYS_STATUS_LEN] of Char;
iMaxSockets: Word;
iMaxUdpDg: Word;
lpVendorInfo: PChar;
end;
TWSA_DATA = WSA_DATA;
2）我们要从WS2_32.DLL引入winsock2的函数，在此我们也是以WSAStartup为例做函数引入：
function WSAStartup(wVersionRequired: word; var WSData: TWSAData): Integer; stdcall;
implementation
const WinSocket2 = ‘WS2_32.DLL’;
function WSAStartup; external winsocket name ‘WSAStartup’;
通过以上方法，我们便可以对winsock2做接口，下面我们就可以用winsock2做封包捕获了，不过首先要有一块网卡。因为涉及到正在运作的网络游戏安全问题，所以我们在这里以IP数据包为例做封包捕获，如果下面的某些数据类型您不是很清楚，请您查阅MSDN：
1）我们要起动WSA，这时个要用到的WSAStartup函数，用法如下：
INTEGER WSAStartup(
wVersionRequired: word，
WSData: TWSA_DATA
)；
2）使用socket函数得到socket句柄，m_hSocket:=Socket(AF_INET, SOCK_RAW, IPPROTO_IP); 用法如下：
INTEGER socket(af: Integer,
Struct: Integer,
protocol: Integer
);
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函数用法如下：
Type
IN_ADDR = record
S_addr : PChar;
End;
Type
TSOCK_ADDR = record
sin_family: Word;
sin_port: Word;
sin_addr : IN_ADDR
sin_zero: array[0..7] of Char;
End;
var
LocalAddr:TSOCK_ADDR;
LocalAddr.sin_family: = AF_INET;
LocalAddr.sin_port: = 0;
LocalAddr.sin_addr.S_addr: = inet_addr(‘192.168.1.1’); ／／这里你自己的网卡的IP地址,而inet_addr这个函数是winsock2的函数。
bind(m_hSocket, LocalAddr, sizeof(LocalAddr))；
4)用WSAIoctl来注册WSA的输入输出组件，其用法如下：
INTEGER WSAIoctl(s:INTEGER,
dwIoControlCode : INTEGER,
lpvInBuffer :INTEGER,
cbInBuffer : INTEGER,
lpvOutBuffer : INTEGER,
cbOutBuffer: INTEGER,
lpcbBytesReturned : INTEGER,
lpOverlapped : INTEGER,
lpCompletionRoutine : INTEGER
);
5)下面做死循环，在死循环块里，来实现数据的接收。但是徇环中间要用Sleep()做延时，不然程序会出错。
6)在循环块里，用recv函数来接收数据，recv函数用法如下：
INTEGER recv (s : INTEGER,
buffer:Array[0..4095] of byte,
length : INTEGER,
flags : INTEGER,
)；
7)在buffer里就是我们接收回来的数据了，如果我们想要知道数据是什么地方发来的，那么，我们要定义一定IP包结构，用CopyMemory()把IP信息从buffer里面读出来就可以了，不过读出来的是十六进制的数据需要转换一下。
看了封包捕获的全过程序，对你是不是有点起发，然而在这里要告诉大家的是封包的获得是很容易的，但是许多游戏的封包都是加密的，如果你想搞清楚所得到的是什么内容还需要自己进行封包解密。

这里插接下传奇赌场封包的用法

由于不同区不同服务器的的数据不同，一个封包要想在每个服务器都能使用是不可能的。
这就需要我们对原有的封包进行修改。

大家在发封包之前，都会和NPC说话，然后进行搜寻，得到一批数据，就是16进制代码
我们要做的是打开所要发送的封包，然后选择要发送的命令如：Packet n 1，发送。现在
一个封包命令就发出去了，这就是WPE的用法，我要说的是怎么修改，大家继续看：
现在，我们双击左边的Packet n 1，会出来一条对话框，里面也有16进制代码我所需要
做的是把第一排第3。4。5。6。4组数据修改成你刚才搜索的相应数据（注意：他的相应数
据是在搜索的时候，左边带S符号的那几排数据）
如果在搜索的时候，出现了许多带S符号的数据排，则证明，有地方出错，你退出传奇
再进或者再次搜索一遍，一般只会出现2-3排的S，而其他带R的不用管他。你现在已经把其
他服务器的封包改成你这个服务器能用的封包了。
比如赌场封包，在1号房搜索并修改1号封包数据后发送，撒6到了7号房，再搜索并修改
2号封包数据后发送，依次类推就可以到40号房间。注意，修改9号封包也就是拿钱封包的
时候必须等你出来与NPC对话出现成功字样的时候才能修改，如果你拿不到钱，你所修改的
封包则无任何用处，所以要修改拿钱封包，必须你先得拿到一次钱，但是如果成功了和NPC
说话后立即开始修改，而且要一次成功，慢点都无所谓，想想修改步骤，否则你失败了再
点NPC就会送你回去。

软件破解
/////////软件保护
软件的破解技术与保护技术这两者之间本身就是矛与盾的关系，它们是在互相斗争中发展进化的。这种技术上的较量归根到底是一种利益的冲突。软件开发者为了维护自身的商业利益，不断地寻找各种有效的技术来保护自身的软件版权，以增加其保护强度，推迟软件被破解的时间；而破解者则或受盗版所带来的高额利润的驱使，或出于纯粹的个人兴趣，而不断制作新的破解工具并针对新出现的保护方式进行跟踪分析以找到相应的破解方法。从理论上说，几乎没有破解不了的保护。对软件的保护仅仅技术是不够的，而这最终要人们的知识产权意识和法制观念的进步以及生活水平的提高。但是如果一种保护技术的强度强到足以让破解者在软件的生命周期内无法将其完全破解，这种保护技术就可以说是非常成功的。软件保护方式的设计应在一开始就作为软件开发的一部分来考虑，列入开发计划和开发成本中，并在保护强度、成本、易用性之间进行折衷考虑，选择一个合适的平衡点。
在桌面操作系统中，微软的产品自然是独霸天下，一般个人用户接触得最多，研究得自然也更多一些。在DOS时代之前就有些比较好的软件保护技术，而在DOS中使用得最多的恐怕要算软盘指纹防拷贝技术了。由于DOS操作系统的脆弱性，在其中运行的普通应用程序几乎可以访问系统中的任何资源，如直接访问任何物理内存、直接读写任何磁盘扇区、直接读写任何I/O端口等，这给软件保护者提供了极大的自由度，使其可以设计出一些至今仍为人称道的保护技术；自Windows 95开始（特别是WinNT和Windows 2000这样严格意义上的多用户操作系统），操作系统利用硬件特性增强了对自身的保护，将自己运行在Ring 0特权级中，而普通应用程序则运行在最低的特权级Ring 3中，限制了应用程序所能访问的资源，使得软件保护技术在一定程度上受到一些限制。开发者要想突破Ring 3的限制，一般需要编写驱动程序，如读写并口上的软件狗的驱动程序等，这增加了开发难度和周期，自然也增加了成本。同时由于Win32程序内存寻址使用的是相对来说比较简单的平坦寻址模式（相应地其采用的PE文件格式也比以前的16-bit的EXE程序的格式要容易处理一些），并且Win32程序大量调用系统提供的API，而Win32平台上的调试器如SoftICE等恰好有针对API设断点的强大功能，这些都给跟踪破解带来了一定的方便。

第二节 8088 汇编速查手册

一、数据传输指令
它们在存贮器和寄存器、寄存器和输入输出端口之间传送数据.
1. 通用数据传送指令.
MOV 传送字或字节.
MOVSX 先符号扩展,再传送.
MOVZX 先零扩展,再传送.
PUSH 把字压入堆栈.
POP 把字弹出堆栈.
PUSHA 把AX,CX,DX,BX,SP,BP,SI,DI依次压入堆栈.
POPA 把DI,SI,BP,SP,BX,DX,CX,AX依次弹出堆栈.
PUSHAD 把EAX,ECX,EDX,EBX,ESP,EBP,ESI,EDI依次压入堆栈.
POPAD 把EDI,ESI,EBP,ESP,EBX,EDX,ECX,EAX依次弹出堆栈.
BSWAP 交换32位寄存器里字节的顺序
XCHG 交换字或字节.( 至少有一个操作数为寄存器,段寄存器不可作为操作数)
CMPXCHG 比较并交换操作数.( 第二个操作数必须为累加器AL/AX/EAX )
XADD 先交换再累加.( 结果在第一个操作数里 )
XLAT 字节查表转换.
── BX 指向一张 256 字节的表的起点, AL 为表的索引值 (0-255,即
0-FFH); 返回 AL 为查表结果. ( [BX+AL]->AL )
2. 输入输出端口传送指令.
IN I/O端口输入. ( 语法: IN 累加器, {端口号│DX} )
OUT I/O端口输出. ( 语法: OUT {端口号│DX},累加器 )
输入输出端口由立即方式指定时, 其范围是 0-255; 由寄存器 DX 指定时,
其范围是 0-65535.
3. 目的地址传送指令.
LEA 装入有效地址.
例: LEA DX,string ;把偏移地址存到DX.
LDS 传送目标指针,把指针内容装入DS.
例: LDS SI,string ;把段地址:偏移地址存到DS:SI.
LES 传送目标指针,把指针内容装入ES.
例: LES DI,string ;把段地址:偏移地址存到ESI.
LFS 传送目标指针,把指针内容装入FS.
例: LFS DI,string ;把段地址:偏移地址存到FSI.
LGS 传送目标指针,把指针内容装入GS.
例: LGS DI,string ;把段地址:偏移地址存到GSI.
LSS 传送目标指针,把指针内容装入SS.
例: LSS DI,string ;把段地址:偏移地址存到SSI.
4. 标志传送指令.
LAHF 标志寄存器传送,把标志装入AH.
SAHF 标志寄存器传送,把AH内容装入标志寄存器.
PUSHF 标志入栈.
POPF 标志出栈.
PUSHD 32位标志入栈.
POPD 32位标志出栈.
二、算术运算指令
ADD 加法.
ADC 带进位加法.
INC 加 1.
AAA 加法的ASCII码调整.
DAA 加法的十进制调整.
SUB 减法.
SBB 带借位减法.
DEC 减 1.
NEC 求反(以 0 减之).
CMP 比较.(两操作数作减法,仅修改标志位,不回送结果).
AAS 减法的ASCII码调整.
DAS 减法的十进制调整.
MUL 无符号乘法.
IMUL 整数乘法.
以上两条,结果回送AH和AL(字节运算),或DX和AX(字运算),
AAM 乘法的ASCII码调整.
DIV 无符号除法.
IDIV 整数除法.
以上两条,结果回送:
商回送AL,余数回送AH, (字节运算);
或 商回送AX,余数回送DX, (字运算).
AAD 除法的ASCII码调整.
CBW 字节转换为字. (把AL中字节的符号扩展到AH中去)
CWD 字转换为双字. (把AX中的字的符号扩展到DX中去)
CWDE 字转换为双字. (把AX中的字符号扩展到EAX中去)
CDQ 双字扩展. (把EAX中的字的符号扩展到EDX中去)
三、逻辑运算指令
AND 与运算.
OR 或运算.
XOR 异或运算.
NOT 取反.
TEST 测试.(两操作数作与运算,仅修改标志位,不回送结果).
SHL 逻辑左移.
SAL 算术左移.(=SHL)
SHR 逻辑右移.
SAR 算术右移.(=SHR)
ROL 循环左移.
ROR 循环右移.
RCL 通过进位的循环左移.
RCR 通过进位的循环右移.
以上八种移位指令,其移位次数可达255次.
移位一次时, 可直接用操作码. 如 SHL AX,1.
移位>1次时, 则由寄存器CL给出移位次数.
如 MOV CL,04
SHL AX,CL
四、串指令
DS:SI 源串段寄存器 :源串变址.
ESI 目标串段寄存器:目标串变址.
CX 重复次数计数器.
AL/AX 扫描值.
D标志 0表示重复操作中SI和DI应自动增量; 1表示应自动减量.
Z标志 用来控制扫描或比较操作的结束.
MOVS 串传送.
( MOVSB 传送字符. MOVSW 传送字. MOVSD 传送双字. )
CMPS 串比较.
( CMPSB 比较字符. CMPSW 比较字. )
SCAS 串扫描.
把AL或AX的内容与目标串作比较,比较结果反映在标志位.
LODS 装入串.
把源串中的元素(字或字节)逐一装入AL或AX中.
( LODSB 传送字符. LODSW 传送字. LODSD 传送双字. )
STOS 保存串.
是LODS的逆过程.
REP 当CX/ECX<>0时重复.
REPE/REPZ 当ZF=1或比较结果相等,且CX/ECX<>0时重复.
REPNE/REPNZ 当ZF=0或比较结果不相等,且CX/ECX<>0时重复.
REPC 当CF=1且CX/ECX<>0时重复.
REPNC 当CF=0且CX/ECX<>0时重复.
五、程序转移指令
1>无条件转移指令 (长转移)
JMP 无条件转移指令
CALL 过程调用
RET/RETF过程返回.
2>条件转移指令 (短转移,-128到+127的距离内)
( 当且仅当(SF XOR OF)=1时,OP1