程序博客网 > 南京浦口行知中学官网

外挂编写完全攻略

来源：互联网 发布：南京浦口行知中学官网 编辑：程序博客网 时间：2024/04/30 05:01

外挂编写完全攻略
一、先说一下写一个外挂需要什么条件
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<OP2 )
   JA/JNBE 不小于或不等于时转移.
   JAE/JNB 大于或等于转移.
   JB/JNAE 小于转移.
   JBE/JNA 小于或等于转移.
   以上四条,测试无符号整数运算的结果(标志C和Z).
   JG/JNLE 大于转移.
   JGE/JNL 大于或等于转移.
   JL/JNGE 小于转移.
   JLE/JNG 小于或等于转移.
   以上四条,测试带符号整数运算的结果(标志S,O和Z).
   JE/JZ 等于转移.
   JNE/JNZ 不等于时转移.
   JC 有进位时转移.
   JNC 无进位时转移.
   JNO 不溢出时转移.
   JNP/JPO 奇偶性为奇数时转移.
   JNS 符号位为 "0" 时转移.
   JO 溢出转移.
   JP/JPE 奇偶性为偶数时转移.
   JS 符号位为 "1" 时转移.
3>循环控制指令(短转移)
   LOOP CX不为零时循环.
   LOOPE/LOOPZ CX不为零且标志Z=1时循环.
   LOOPNE/LOOPNZ CX不为零且标志Z=0时循环.
   JCXZ CX为零时转移.
   JECXZ ECX为零时转移.
4>中断指令
   INT 中断指令
   INTO 溢出中断
   IRET 中断返回
5>处理器控制指令
   HLT 处理器暂停, 直到出现中断或复位信号才继续.
   WAIT 当芯片引线TEST为高电平时使CPU进入等待状态.
   ESC 转换到外处理器.
   LOCK 封锁总线.
   NOP 空操作.
   STC 置进位标志位.
   CLC 清进位标志位.
   CMC 进位标志取反.
   STD 置方向标志位.
   CLD 清方向标志位.
   STI 置中断允许位.
   CLI 清中断允许位.
六、伪指令
   DW 定义字(2字节).
   PROC 定义过程.
   ENDP 过程结束.
   SEGMENT 定义段.
   ASSUME 建立段寄存器寻址.
   ENDS 段结束.
   END 程序结束.

    当然不是所有的指令都能用的上的，我在这里全部写出来是为了让大家认识一下，方便大家以后的学习，我归纳了一下常用的指令，这些指令大家一定要熟练掌握才可以啊。
MOV 数据传送指令
PUSH,POP 堆栈指令
CMP 比较指令
LEA 取地址指令
XOR 异或指令
JE,JZ,JMP...(所有的转移指令)

FPE修改全教程
很早的时候,当出现了视窗系统以后,图形界面就深得人们的喜爱,从古老的DOS界面的幼稚的波斯王子开始,便逐渐的出现了更高意义上的游戏,更优良的界面吸引了更多的人来进行游戏的娱乐。
于是,GAME的意义便逐渐的深远和丰富多彩起来,便逐渐出现了游戏内容的分化,形成了一些源于早期形式上AVG,SLG,RPG,等趋势,这是早期的比较笼统的分化,期间,很多RPG的游戏就有很多繁琐枯燥乏味的升级及练习的系统,当时便有了一个思想,如何摆脱这些令人反感的东西?修改游戏的源程序吗?不是,便出现了一种类似于附加的程序,可以对人物的资料进行一定的修改,物品等等,便是早期修改的雏形,至后来,经过越来越多的人的发展,思想,逐步逐步的形成了一个比较完善的体系和共同的认识,后便有了风靡人心的FPE.
   
一个人物,有很多数据与之相关或者说与之有联系,那么,如何在众多的数据中寻找到人物所需要的部分呢?很容易想到的就是,当我们在游戏进行的过程中,我们的人物一旦发生数据上的变化,那么数据就会在寄存器中发生变动,当我们在前一次的周期中将全部的数据数值都记录下来,在将这个周期的数据全部记录,然后相比较,就能够寻找到一个发生变化的部分,这个部分可能有很多很多
简单的来说,可能是一个药,吃下去了,那么数值变了,量减少了,血槽的颜色变了,人物的属性恢复了,等等很多很多很多,所以,变动的地址就有很多很多,那么我们的目标数值呢?很简单,当一个数值按照我们的要求来变化,我们买,卖.买.卖.买.卖.那么,钱就是少,多,少,多,少,多,这样一来,符合我们的这个连续的正确的变化的形式的地址就只有几个,正确的或者表观的,或者镜象的,所谓表观,就是钱的那个样子要变化吧~~~```哈哈`````能明白吗?就是说,一个人脸胖,瘦变了,但是总有个脸在那里吧?然后就是所谓的肉的多少的地址,然后````````````?然后`````看看地址是什么类型,进制的选择,然后,删除掉现在的数值,写上一个我们需要的数值,刷新,就产生了一个结果,我们称为:表现:这就是修改的核心的原理
   好了,我们拿到了一个修改器,FPE,金山游侠,东方不败,大刀,傻瓜修改器,王者修改,随便什么都可以.然后执行那个图标,就是.EXE的文件,然后进入目标游戏,然后,选定一个我们所需要的修改的一个数值,比如比如~~~~~~~~~~~~~~~~~~~```
最最基本的,钱.然后呢,我们记住现在你所有的数量,然后切换出去到修改器,按组合键,如果不行,就按快捷键*,常见的,如果还不行,看看是不是冲突,换掉快捷键位,或者组合键,退出键位试试,还不行,自己可以对游戏的目录文件做点相关修改,我不赘叙,然后在那个新建任务那里选上,然后填上你记住的那个数值,就是你记住的,
然后我们切换回游戏,然后随便买个东西,让游戏金钱发生变化,然后我们再次切换出来,在数据那里填上新的数量,就会在上次的寻找的结果里寻找你现在的数量符合的地址,OK,有几个剩下了?如果很多FF也就是256以上,不能显示,那么重复以上过程,如果能够在你的修改器那个:框原谅我用这么不专业的说法~~~~``)出现的话,
那么可以开始了,如果你的水平不行,看不,那么再尽量多找几次吧,控制在2----5个地址内.然后我们开始,如果你什么都不会,就直接选锁定,然后填上一个10机制的数量,就可以了.?什么?你不知道进制是什么???~?~?那我没有办法了.
如果你懂任何一点点,那么跟着我,选择编辑,这是你踏上真正意义上的修改的路途
   我们模拟一次
   02FE32A...
   02FE30b...
   -----等几个我们假设有5个   
   打开一个
   你可能看到这个
   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
   说明什么呢?  不正确
   第二个
   0F 0E A3 B4 F5 EE FF ED D2 A3 D2 E1 A2 B4 F9 F1
   .....................
   你看不出任何规律的
   说明什么呢? 也不大正确
   第三个
   32 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
   如果你有50元钱的话,说明什么呢?50的16进制是多少?50=32
   对的
   第四个
   32 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
   00 00 00 00 00 00 00 ................
   一样的?不是镜象变是表观,也是对的
   第五个```````` 一样?
   呵呵`````不错,我们找到了钱的地址了
   开始修改
   我要多少? 999? 9999?   
   填上E7 03 或者 0F 27  自己去写吧!如果你不是电脑文盲,如果还不会,找个换算器,自己换换就可以了,写上去刷新,回去看看吧.
   编辑就是这样简单.
   
   武器,攻击,药水.........速度.一切有数字的东西,都这样做吧.
   
   好了,基础完了,我们这部分很熟悉了,继续
   我在这里写上一个人的资料
   等级  01
   经验  100
   HP    100
   MP    100
   药水  99
   .........                             
   那么正确的地址是什么呢`?
   01 00 00 00 64 00 00 00 64 00 00 00 64 00 00 00
   63 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00       不要和我说看不懂
   第二个例子
   武器  初级  刀   
               机关枪  子弹  10 / 100
               火箭炮  子弹  04 / 100
               药      小药  3 个
                       中药  5 个
                       大药  8 个
   我们来写这部分
   01 01 00 00 04 01 0A 64 0F 03 00 00 10 05 00 00
   11 08 00 00 00 00 00 00 00 00 00 00 00 00 00 00
   这个难看点,是什么意思?
   01一定是最初级的武器的代码 后面的01一定是表示数量 一把 ,你改02就是两把刀,03就是3把...04是机关枪的代码,为什么不是02?游戏里有没有什么小枪?步枪?如果有就是说明机关枪是厉害一点的枪,前面肯定还有一点小枪 01 是一把,02是两把,OA 数量是10的子弹.64是子弹上限,以此类推....自己对着看看``````
   
   中级别的会了吗~?~?熟练吧```多找游戏试试````别告诉我你看不懂
   
   高级别的找什么??? 我拿精灵开刀
   随便两个武器,弹出FPE,寻找地址,就是如下的部分
   
   00 00 武器代码部分  最小攻击  最低攻击   
   射程  速度  命中  必杀率   00 0 00 0 0
   00 00 00 0 0  -------------------  --
   00 0 00 0 00 0 武器基本要求   000 00 00
   000000000000000000000000000000000000000
   00000000000000000000000000000000000000
   0000000000000000000000000000000000000000
   00000000     特效    攻击加成
                ------------------------ 有几个特效就有个附加
                                         前面你都看懂了,这里你就找的到
                                         往下翻翻页面就是
   你要改什么?
   去掉要求?      要求部分全部改00 00 00 00 00 00
   攻击?           FE 00 FF 00   ==     254 255
   速度?          OA=10  1E=30 32=50
                  我改到50都没有问题
   必杀?        64 == 100%       你要改的变态我也不拦你
   射程?        随你吧,还要我说吗~?  
   1级的屠龙枪怎么来的? 就这么来的
   会了吗~?自己去改吧.不要再问我要了,*自己吧.
   以后你还想做什么`~~?我提示吧,现在的修改器有低阶搜索的功能.什么意思,游戏里的东西不知道数值的部分,我们用搜索,输入? 然后增加+ 减少- 这就是基本的格式,地址就是这样找到的,找到了地址,加个锁定的代码,做个启动文件,最后``````````自己去做外挂吧.装备吗?有数值,自己想吧!
   世界上通向罗马的路很多.你总得找一条属于你自己吧?

FPE修改教程进阶(地址编辑部分)
   
需要具备的几个初步知识
1.十六进制
   十六进制是进制中的一种,是我们在进行编辑的时候将要碰到的最多的问题,你接触修改,就不可避免的会遇到进制上的换算,简单的说来,十六进制就是满十六就进一位,同十进制的满十进一是一样的道理,我在这里要求大家记住最基本的前十六位的代码换算,和几个最常用的数值具体十六进制的代码,而不是去临时的找个什么进制换算器来进行换算,这点非常重要,有很多时候,一个地址的编辑,在某个标志码数值上不是很大,但是要求你有很高的数据敏感性,这点很重要,我在这里将要求记住的一些代码写出来
  01=01 02=02 03=03 04=04 05=05 06=06 07=07 08=08
  09=09 10=0A 11=0B 12=0C 13=0D 14=0E 15=OF 16=10
  特征数值
  0F=15  FF=255  FF FF =65535     32=50     64=100
  63=99  03 E7=999  27 0F=9999        01 86 9F=99999
2.真/假址的基本识别问题
  我在这里举一个例子
  一个正常的全空地址
  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  
  正常数据全满地址
  FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
  FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
  FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
  FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
  FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
  FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
  假设我们寻求的目标是一个金钱的数量
  假设初始数量是1000的话,我们就开始以1000作为寻找目标
  1000>990>980>970> OK,我们找到了两个地址
   
  024F6A5C7BE..
  024F7BCDD3A..
  地址一我们打开以后看到
  CA 03 00 00 CA 03 00 00 00 00 00 00 00 00 00 00
  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  地址二我们打开以后看到
  DE CA D3 B6 A7 D8 E9 FF D1 A3 A3 A3 DE FA FE D2
  D6 F7 F2 F8 FA 32 21 2F 2D 3E 4E 2D 6A 4E 5F 3A
  F6 5A 8D 8D 6E 7D 6E 7E 8A 9D 21 41 3A 3C D2 F2
如何判断呢，这是一个很明显的一个常见的真假地址并存的情况，我们的目标数值是970 ，换算过来是 CA 03 那么地址中有那个出现了这个十六进制的970呢？很明显是在第一个地址，我们就称为真址，而第二个没有任何的数字的规律的地址，我们称之为假址，但是并不因为其真正意义上的假址，其实，这个地址也是反映了一个关联的变量，只是所包涵的信息不是我们所需要的当前变量值，但这种地址在某种情况下仍然非常有用，起一个验证的作用，我稍后会详细解说。这就是基本的真/假地址的构成，很多时候，真实的地址通常不是这种“清版”（我们的术语，就是非常干净好认识，整版地址代码全表，无关的全部显示空码，只表达一个有关变量数值）而是在一大串没有用的数据中夹在一段特定的段落
  
  以下是一个样本
  
  DE CA D3 B6 00 02 00 00 D1 A3 A3 A3 DE FA FE D2
  D6 F7 F2 F8 FA 32 21 2F 2D 3E 4E 2D 6A 4E 5F 3A
  F6 5A 8D 8D 00 02 00 00 8A 9D 21 41 3A 3C D2 F2
  这是一个比较标准的夹码，在第二个段落的四位，一，三行包涵了一个角色的等级信息，其余部分是关于一个角色的等级相关的外表及外观，在这里就出现了非清版的地址全代码，需要大家仔细看，如果寻找的结果是2到3个这样的非清码的地址码表，不能够认为是误报而很简单的清除重新寻找，需要鉴别一下，这里不同于无规律的假址，望大家铭记。
  
  3，镜象修改
  我们知道，一个角色的资料有很多部分，最简单的比如体力数值，就有几个部分
  一具体的数值
  二表观的印象
  三显示出加成或者减少的效果
  我们在大范围的搜寻一个变动的地址的时候，会将这个真数值址所能产生的变化的及连带影响的部分全部搜寻在内，故同时间的搜寻，我们可以找出几个相关的变量数值址，我们在进行地址编辑的时候，要注意到这点区别，具体的语言描述就是，你可能修改了一个你认为是正确的，合法的地址，但当你切换到游戏部分的时候，却发现没有产生变动，但你在切换回编辑器，却发现数据已经自动恢复了原本没有修改的前样，这点我们称为，镜象修改，或者影子修改，被视同为不成功的修改，此时你要做的就是正确的分析你的地址，然后试着去修改另外的相同的或者数据上有对等点的地址，如果你不放心，就连镜象连同真址一起改动，但值得注意一点，我要提出，有时侯，真址和镜象不是绝对，在某种情况下，我们没有办法寻找真址，只有通过表观来间接修改，类似的有《骑士团》有时改掉镜象就可以把真址影响，很明显的例子PC版本的〈心跳回忆〉你可以追寻到7个地址 ，但是你改掉任何一个都没有用，要么连带修改7个，直接实现变动，要么你改任意一个，通过游戏的日历切换，对地址进行校验，换行为真址，达到修改。这点需要注意。
  正题：
  准备要求做好以后，我开始述说修改正题部分，我将以实例来分析，对读代码编辑做说明，会包涵目前的所有部分，希望大家认真想想，只要你能明白全部机理，就能很轻松明白修改学问的90%，我所写的代码部分只写主要，无关代码我不写，这样一来对初学者好看一点，而且也便于研究，真实的地址形式还是有一定出入，主要在于非清码的部分而不是00 00 00 00 之类的空节，就可能会增加认识上的困难，具体实践需要大家自己去亲自动手修改
  
  一 纯具体数值类型   
     对象举例：金钱
     在谈到一个具体数值的修改，我们很容易的就能想到一个非常常见的数据，金钱，我们在这里就以金钱做为目标，做第一个分析
   
     以益智力类型的游戏 《大富翁三》为例子
      
     初始   金钱10000     存款 10000
      
     寻找以后
     10 27 00 00 10 27 00 00 00 00 00 00 00 00 00 00
     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     你看到的应该有这么一个部分
     好的，下面开始写上我要的数值
     ** ** ** ** ** ** ** ** 00 00 00 00 00 00 00 00
     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     *部分很简单，也就是你所需要修改的部分，你可以填上你所需要的数值
     E7 03 00 00 E7 03 00 00 00 00 00 00 00 00 00 00
     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     或者
     DA 34 00 00 DA 34 00 00 00 00 00 00 00 00 00 00
     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     这就是金钱的修改了，这一步非常简单，我们完成了以后，不能停留在这一步，继续，我们来讨论更深层次的一个问题，在这一行真码，我到底能将金钱的数量改到多少？
      
   是FF FF FF 00 FF FF FF FF 00 00 00 00 00 00 00 00
     三邻位字节数
   还是四位
     FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00 00
   或者说根本就是
     FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
    这个是个很简单的问题
    四位的全满
     FF FF FF FF = 4294967295 数值上换算过来就是这么多，我们再回头看看正常没有修改代码构成，很明显四邻位中E7 03 00 00 E7 03 00 00 中间有一个数位一定是间隔码，肯定是用来区别钱和存款的起始部分，具体是3位还是4位？鉴于游戏里有正常的钱数是2位不能足够显示的，我们可以确定是4位，所以我们能过理论上的正常的钱数 FF FF FF =16777215，所以通常我们能见到的正常的游戏的设定的钱的最大也就是10000000
   
    当然也有很多例外
    如果金钱单独是一个地址
    00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
    全部占用了第一个四位的话很常见的就是 999 999 999 为最高上限数值，这里只要对比四数位全代码 FF FF FF FF 就能明白，取一个正常的惯用的9尾数，也就得出了4294967295 经过我们的取位数的话，也就是999 999 999 ，这就是大多数游戏金钱的最高数值的由来，这里道理大家仔细想一下，应该能明白的了。
    所以我们能做的修改，也就只在数位正常的情况下修改那个最大数值，这里就很明显的能够想到问题，当我们修改出一个数值超过间隔码，在理论上只能存在的时候，就会在显示上出了问题，很常见的就是数值溢出了那个数据框，被外面的文字，常见是：钱：字，或者一个黄色的图标盖住了，然后你再继续捡钱，怎么算呢？最后就是死机，循环错误，内存报错。精灵里面的这钟现象大家应该见到的很多。
   明白了这些，具体数值类型的，大家应该都能明白修改的基本道理和注意，也就是同上述没有太大的区别。常见的有钱，人物体力数值，级别，等等，此不繁琐的述说，请大家自行动手试验。
  
  二 非具体数据，非纯物品类的修改；连带修改
   
     这里大家首先要明白一个意思，非具体数据，非纯物品类的数据是指的什么？
   
     简单的说，拿游戏来举例，绝代双骄
     里面有很多种药水，从草药到解毒药，到还魂丹，到仙丹，本身具备物品的基本代码的编号，同时又具备单项上有数量的部分代码，我们假设现在全部的药水种类一共是100种，那么我们在真址，看到的全码，假设你一样都有一个，写出来就是
   
   
     01 01 00 00 02 01 00 00 03 01 00 00 04 01 00 00
     05 01 00 00 06 01 00 00 07 01 00 00 08 01 00 00
     09 01 00 00 0A 01 00 00 0B 01 00 00 0C 01 00 00
     0D 01 00 00 0E 01 00 00 0F 01 00 00 10 01 00 00
     11 01 00 00 12 01 00 00 13 01 00 00 14 01 00 00
     15 01 00 00 16 01 00 00 17 01 00 00 18 01 00 00
     19 01 00 00 1A 01 00 00 1B 01 00 00 1C 01 00 00
     如何解读这段代码？很明显的就是01 是对应的第一种草药的地址 后面的01 表示数量，02表示第2种药的名称的代码，01是第二种药的数量，依此类推，很明显的，我们可以以买卖的药水的数量来得到真址的获取，这就是非纯数据物品类型的意思，我们寻找地址类似于单纯的数据型，在看代码上，我们就要稍微注意下其区别。
      
     假设你并没有获得其中很多种类的药水，那么你看到就是这种形式
     00 00 00 00 02 01 00 00 03 01 00 00 04 01 00 00
     00 00 00 00 06 01 00 00 07 01 00 00 08 01 00 00
     09 01 00 00 0A 01 00 00 00 00 00 00 0C 01 00 00
     0D 01 00 00 00 00 00 00 00 00 00 00 10 01 00 00
     11 01 00 00 12 01 00 00 13 01 00 00 14 01 00 00
     00 00 00 00 16 01 00 00 00 00 00 00 18 01 00 00
     19 01 00 00 00 00 00 00 1B 01 00 00 1C 01 00 00
  
     残缺了一部分，我们看到这个时候，就应当吗上联想自己见过的东西。有草药，大草药，等等，再看看这段代码的形式，残缺的部分很多都很有规律，每四位一节，说明了什么呢，这里就是全部的药代码所在地，我现在需要做的就是把00 00 00 00 的地方按照顺序填上物品代码，就全部拥有了100种物品，恢复部分如下
     01 01 00 00 02 01 00 00 03 01 00 00 04 01 00 00
     05 01 00 00 06 01 00 00 07 01 00 00 08 01 00 00
     09 01 00 00 0A 01 00 00 0B 01 00 00 0C 01 00 00
     0D 01 00 00 0E 01 00 00 0F 01 00 00 10 01 00 00
     11 01 00 00 12 01 00 00 13 01 00 00 14 01 00 00
     15 01 00 00 16 01 00 00 17 01 00 00 18 01 00 00
     19 01 00 00 1A 01 00 00 1B 01 00 00 1C 01 00 00
     。。。。。。。。。。。。。。。。。
     。。。。。。。。。。。。。。。。。。。
     然后我们明白了四位结构就是名称代码，数量代码，间隔码，那么全部改上我们想要的数量数值以后，就变成如下
      
     01 OF 27 00 02 0F 27 00 03 0F 27 00 04 0F 27 00
     05 0F 27 00 06 0F 27 00 07 0F 27 00 08 0F 27 00
     09 0F 27 00 0A 0F 27 00 0B 0F 27 00 0C 0F 27 00
     0D 0F 27 00 0E 0F 27 00 0F 0F 27 00 10 0F 27 00
     11 0F 27 00 12 0F 27 00 13 0F 27 00 14 0F 27 00
     15 0F 27 00 16 0F 27 00 17 0F 27 00 18 0F 27 00
     19 0F 27 00 1A 0F 27 00 1B 0F 27 00 1C 0F 27 00
     。。。。。。。。。。。。。
     。。。。。。。。。。。 。。
     这样一来，我们就实现了全部的药的全部拥有及数量上的9999，看明白了吗，这里修改的数量的时候，要参照第一例，纯数据类型的修改的部分，而且事实上我们最初的获得地址的时候，可能残缺程度会更严重，这里就需要你有高敏感的数据感受能力和地址感受能力，并且，我们在这里就是通过一个草药的数量，实现了全程物品的代码获知和修改，这就是连带修改的最简单的一个实例，这里希望大家反复看，力求看懂。
如果你明白了这一点，接下来我们在看一个例子，比较难一点，我给大家演示的是CAPCOM的冒险类型的游戏，BIO HAZARD 2
   
     我们要通过一个开始的子弹的20发数量，实现全程道具，武器的修改。
      
     代码部分如下
   
     由于武器方面，很明显的初级给你的武器就是一把刀，所以很自然的联想到代码是01
这在真实地址中也确实如此，所以。开始就需要大家有一个比较清楚的修改的思想和猜测，然后我们在开枪模式下 20/19/18/17/10 OK
     代码出来，去掉假址
     进入真址
     你就会看到如下形式
   
     00 00 00 00 02 0A 01 00 16 01 00 00 3C 63 01 00
     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     这是代码部分，身上装备为手枪 一把 子弹 10发  草药一个  99发子弹合一个
   
     对照上述代码，我们就知道。02 是手枪 OA 是剩余数量 16  后面的01 一顶是表示枪存在身上，是一把，也就是物品存在码 00 间隔 16就一定是草药 01 是一个。由于草药是吃的，所以其后不会有存在码，当然你也可以试着写上，并不影响，系统会自动帮你消失掉，3C就是一定是物品属性中，表示子弹合的代码了 63 ==99没有错，正确 ，01 存在码，就这样很清楚的就分析了出来，现在我们要改掉物品道具，很简单，程序一般相近的物品在一起，那么03可能是大枪 04 可能是冲锋枪，17可能是中药 18 可能是大药 3D就是下一个道具，就这样依此类推就可以做到全程物品的代码修改，按照其标准存在格式，自己往上面写就是了，但要注意，你的身上能装几个，就改几个，类似于金钱的溢出问题，还有要注意一点，限于一个游戏的开发人员的习惯，有很多东西在初期设计上，存在，但是在正式发行以后，可能就不要了，但是程序员为了赶时间，没有彻底删除掉，做了个屏蔽，本身也有编号，夹在正常物品中间，所以你在修改的时候，装备，道具可能就不是连续出现，而是出现一个垃圾码的装备，你可以试试，生化危机3的物品在2代里面就已经见到了，此点注意一下就可以了。修改的时候不要以为是自己的错误，也有可能是游戏里没有开放的东西，理解了这点，再去理解精灵的修改过程的问题就很容易了。
      
   三 人物属性的修改
     终于到了这部分了，如果大家对于上面所讲的理解很透彻，那么这里，你只要看看，就彻底明白了，包括精灵，请自己联想。
     连带修改可以是药水，可以是相同的装备，也一定可以是人物的属性，很简单《魔奇梦幻团传奇》人物作比方
      
      等级 01
      HP 100
      MP 100
      回合数 3
      带兵 20
      武器 小刀
      国家属性 特里斯雅
      队伍属性 敌军
      攻击  3
      经验 20
      金钱 50
      
      这就非常简单了
      
      01 01 00 00 64 00 00 00 64 00 00 00 03 00 00 00
      14 00 00 00 01 00 00 00 0A 00 00 00 02 00 00 00
      03 00 00 00 14 00 00 00 32 00 00 00 00 00 00 00
      已变化的经验数值找到这里，然后修改
   
      01 01 ？ 一定是人物 名称 代码 等级  02 01 就是女主角 一级
      64 00 00 00  64 00 00 00 两个100的数值
      03 回合数量 14 带兵量 01 就是小刀那
      0A 国家的名称，你换个0B看看就变成了临近的国家的名称
      02 敌军 ，很简单的联想   01 是不是友军呢？
      03     14        32       就是剩下的三项了
      呵呵，全部都改掉吧！
     很简单吗~？  就这样？我还要说点什么呢？自己去试修改精灵吧！
      
     我写上常见的几大数据类型，大家参考之。
      
     一 夹码类型
        DE CA D3 B6 00 02 00 00 D1 A3 A3 A3 DE FA FE D2
        D6 F7 F2 F8 FA 32 21 2F 2D 3E 4E 2D 6A 4E 5F 3A
        F6 5A 8D 8D 00 02 00 00 8A 9D 21 41 3A 3C D2 F2
      
     二 清版类型
        10 27 00 00 10 27 00 00 00 00 00 00 00 00 00 00
        00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
        00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
        00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
      
     三 无间隔码类型（与假址很类似，但含有真址数据）
        ** ** ** ** A7 D8 E9 FF D1 A3 A3 A3 DE FA FE D2
        D6 F7 F2 F8 FA 32 21 2F 2D 3E 4E 2D 6A 4E 5F 3A
        F6 5A 8D 8D 6E 7D 6E 7E 8A 9D 21 41 3A 3C D2 F2
        
        ** ** ** ** 部分是常见的数据所在地址
     四 纵向码类型
        31 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
        64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
        45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
        67 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
        3E 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
        5D 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     五 换行码类型
        01 01 00 00 01 01 00 00 01 01 00 00 01 01 00 00
        00 01 01 00 00 01 01 00 00 01 01 00 00 01 01 00
        00 00 01 01 00 00 01 01 00 00 01 01 00 00 01 01
        01 00 00 01 01 00 00 01 01 00 00 01 01 00 00 01
        00 01 00 00 01 01 00 00 01 01 00 00 01 01 00 00
        00 00 01 00 00 01 01 00 00 01 01 00 00 01 01 00
        (这个见于恋爱游戏，人偶情缘里的地址之一）
     六 镜象地址
        也就是全部需要你一起手动修改
         
        大概就这么些了
        
       希望大家耐着性子看完，并好好的想想这部分的意思。
    四  最后篇  模糊查找
      如果我们对一个游戏里的数据并不大清楚，换句话说，就是不是一个具体数值，而是一个感性的认识，游戏是有地址的，但是我们常规的找不到，比如，血条又降了一点，好感度又上升了一点，等等，我们就在修改器里写下？然后变化的时候。模糊的上升+ 模糊的减少-这样反复的搜寻，最后依旧可以找到在游戏中以数据形式的方式存放的地址，找到了以后，依旧可以修改，大同小异，这里，大家可以试验一下，修改一下电脑上的KOF97的1P 和 2P 的体力数值，试试看！
  
  
   实际的修改还有很多很多的东西要学习，并不是这里一句两句就说的清楚，希望大家在不断的修改试验中，理解我说的，不断创新，成为修改的高手，专家，神。
用FPE-学会用浮点修改法-学会用二进制分析修改游戏-巧用FPE的刷新-特殊存档
巧用FPE  
用FPE改游戏，一定要做到既狠又准。
比如用FPE改游戏，你知道有两个数值肯定在一起，象42，215，那么可用FPE进行一次搜索，输入“42，215”（若是16进制请在数后面加个H），这样一次找到的机率很大。
一些游戏在运行时将一些主要数值换了个方法存，用FPE直接找不到，怎么办呢。那么要转转弯，比如大家喜爱的足球经理，用任何方法都找不到金钱的地址，就这样放弃了？NO，动动脑筋，进入建设菜单，看见造看台所需的费用了吗，这里就是突破口，FPE不费力就发现了目标，下面么，将其改为负数，譬如原数为E4 07 00 00，就将最高位加个F，为E4 07 00 F0，就发现负数一大笔，按确定就发财了！
“帝国时代”大家都玩过，当你造了奇迹后，有2000年的倒记时，你的第一印象是搜索2000？那么，错！没看见它是成50递减的吗，所以，应该搜索2000/50=40，然后减1减1地搜索（要不就是2000/10=200，减5进行搜索，这东东改了没实用价值，只不过举个例子罢了）。而有些则是要加上位数，如显示200，却要搜索2000，变化多样，大家自己慢慢的体会吧！
FPE的修改内存功能很有用，多用用它，看看找出的地址周围的数，说不定有惊喜呢。反正我从不用什么内存锁定，一般都用内存编辑。然后看上下数，对于普通游戏，应该不试就看出这个存的是什么数值，而那里应该是存放魔法的地址，或这个地址肯定不是我 所要的……如果你还未达到看看就知的地步，那么快练练吧，以后可省许多时间呢。
一时想不出了，下次有再说吧。

　 学会用浮点修改法

这个游戏是使用浮点数来存放的，在这里我说明一下如何以 FPE 2000修改他们。FPE 2000 可以直接分析浮点数，只要 直接输入就好了，例如 "100.0"。
或许你会问: TA 或 AoE 的资源量在画面上显示只有整数部分呢? 是的，他们隐藏了小数部分的数值，如果画面上显示的是 "1000"，因为它隐藏了小数的部 分，若你直接在 FPE 2000 以 "1000" 或 "1000.0" 去分析他，可能是找不到的。那我们要怎麽办呢? 其实程式设计师还是比较喜欢整数的，例如我们刚刚进入游戏时，TA 或 AoE 的资源都有个初始值，例如 "400"。这时候这个值很可能 就是 400.0，一个农夫能够采的资源最大量是 10，也很可能是 10.0。如果你派个农夫去采资源，一直到他采完 10 搬回基地前不要做任何其他的事，一搬 回基地马上停止农夫的动作。这时你整的资源量变成 410，很可能就是 410.0。依照这个原则，一开始我们分析 "400.0"，派农夫采满 10，搬回基地前不要做 任何其他的事，一搬回基地马上停止农夫的动作，分析 "410.0"。依此类推，就大概可以找到目标了。我们这个原则是猜想程式设计师会对每一个初始值及最大 值以 ***.0 的方式定义(一般人的习性嘛)。但是如果你在农夫搬回基地前做其他消耗资源的事或是在农夫没有采满 10 就搬回基地，那可能就会有小数点後的 数出现了，那就不能很准确的分析了。以前有网友说 100.0 到 100.9 的翻成四个十六进位 bytes 时，前两个 bytes 会一样。其实这不正确，根据测试，有些浮点数(如120.4和120.5)只有第一个 byte 会一样而已. 而且这个 byte 很难变动，必须整个浮点数有很大的变动才会变。所以比较好的分析方法如同刚刚说的才会比较正确。FPE 2000 也 可以把浮点数转换为十六进位数，在 "Others" 左下方那两个中间有个 "Hex"按钮的栏位，你只要在上面栏位输入浮点数，下面会出现十六进位值，你可以自行试试。
也许有的朋友看到标题时摸不到头脑，那么望下看吧。（仅适合FPE5.x）
我改金色步行鸟时，好不容易用名字找出步行鸟地址的大概位置时，却看见满屏陌生的数据而无从下手。茫茫的数据中，哪个是要害字节呢？要找步行鸟的什么速度、耐力之类的，游戏中又没有具体数据，高阶分析无从下手。用低阶分析？那可是本人最忌讳的。
山穷水尽想放弃时，眼睛一亮，OK，且听我慢慢道来。找到步行鸟名字的地址后，按E键进入内存编辑，不按任何键，切回游戏中。给步行鸟喂食，使它某一项能力增长，切到FPE，怎么还是上次的数据，那么按ESC键，恩，有几个数据在动啊（改变了），没看清？那么再照上面的方法来一边吧！发现改动的数据了吗，分析其上下的值，怎么样，有几行是很有规律的，对啦，那就是步行鸟的数据了。
没听懂？自己实践一下吧，这个方法可是很有用的喔！
学会用二进制分析修改游戏

不少游戏中都有什么诸如人物的特殊能力，比如DIABLO。那么它的魔法是如何存放的呢，每个魔法用一个字节，00代表无，01代表有？那也太浪费了吧，一般来说程序员都爱用二进制来存放各项能力，大家知道，一个字节有8位（如FFh化为二进制是11111111），游戏中的能力就是占了一位（bit），0代表无，1代表有。如果某一游戏的能力排放为00000011，那么在内存（硬盘）中存放就是03h，显然用二进制能有效地减少存储空间。
由上面看来，直接搜索能力的地址是不明智的，一般我们修改都找出这个人物（或其他什么东东）的数据所在地，然后找到能力的具体地址，将其改为FFh，一般就可拥有全部的能力。
下面我以早期的战略游戏经典“信长之野望——天翔记”为例来分析（当年还没有FPE4和5，用其他的内存修改工具会死机，只得用PCTOOLS）。记得当年我修改的时候，差点想破脑袋。天翔记中个各人物都有“智力/智才、政治/政才、战斗/战才”三项能力，你直接找智力或找智才，都是找不到的。而我拐了个弯，寻找他的勋功，然后上下分析，才得出结果。原来他的智力是按智才的百分比存放，而智才是将游戏中的数据除以2存放，怪不得找不到哩（光荣这个混蛋）！水到渠成，修改其它诸如兵力，训练……就是简单的事了。
找到了人物的特技和带兵能力后，按习惯都改为FF，特技到是PASS了，但带兵能力却不对，怎么都变一个个的O O O O了（应是S、A、B、C、D），思考良久，由于能力有6级，故一位是放不下的。两位？两位只有00、01、10、11四级啊，放不下6个级别，那么只有3位了，可从来没有一个游戏用了3位存放的，要么4位，要么2位，再说共有“陆、骑、枪、水”四个，4x3共12位，不足2个字节16位，而且3位能放8级的能力，难道见鬼了？又思考晾久并试出确是只有两个字节，干脆，赌一把。000代表E级，001代表D级，010代表C级，011代表B级，100代表A级，101代表S级，一个字节存2个能力，OK，把2个字节改为2Dh，2Dh（00101101），进入游戏，不对，怎么“X”都出来了。反回来再改，改为6D FB（01101101 11111011），哦（欢呼），对啦，全是S级喽，还有铁骑呢！
怎么样，够艰难吧，别看现在说说简单，在不知道的情况下要想出来是很难的。而这，也是修改游戏乐趣的所在之一。希望看了上面的分析，能给你有所收获（尽管以后可能用不到）。
巧用FPE的刷新

也许有的朋友看到标题时摸不到头脑，那么望下看吧。（仅适合FPE5.x）
我改金色步行鸟时，好不容易用名字找出步行鸟地址的大概位置时，却看见满屏陌生的数据而无从下手。茫茫的数据中，哪个是要害字节呢？要找步行鸟的什么速度、耐力之类的，游戏中又没有具体数据，高阶分析无从下手。用低阶分析？那可是本人最忌讳的。
山穷水尽想放弃时，眼睛一亮，OK，且听我慢慢道来。找到步行鸟名字的地址后，按E键进入内存编辑，不按任何键，切回游戏中。给步行鸟喂食，使它某一项能力增长，切到FPE，怎么还是上次的数据，那么按ESC键，恩，有几个数据在动啊（改变了），没看清？那么再照上面的方法来一边吧！发现改动的数据了吗，分析其上下的值，怎么样，有几行是很有规律的，对啦，那就是步行鸟的数据了。
没听懂？自己实践一下吧，这个方法可是很有用的喔！
　
特殊存档

   FPE2000一个很好的功能是能把你已经修改好的东西存下来，下次你再打开游戏时可重新调入，这个存盘文件的后缀名就是FPE。方法很简单，只要按CTRL-2到表格处，按LOAD（读档），选择想要的FPE文件名即可。FPE2000会自动把那些地址锁定。不过要注意，存盘的文件名不能为中文名。另外，欢迎大家把自己修改了的游戏做成FPE存档，拿出来和大家分享。

从游戏中得到动态内存数据
工具：
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<OP2 )
JA/JNBE 不小于或不等于时转移.
JAE/JNB 大于或等于转移.
JB/JNAE 小于转移.
JBE/JNA 小于或等于转移.
以上四条,测试无符号整数运算的结果(标志C和Z).
JG/JNLE 大于转移.
JGE/JNL 大于或等于转移.
JL/JNGE 小于转移.
JLE/JNG 小于或等于转移.
以上四条,测试带符号整数运算的结果(标志S,O和Z).
JE/JZ 等于转移.
JNE/JNZ 不等于时转移.
JC 有进位时转移.
JNC 无进位时转移.
JNO 不溢出时转移.
JNP/JPO 奇偶性为奇数时转移.
JNS 符号位为 "0" 时转移.
JO 溢出转移.
JP/JPE 奇偶性为偶数时转移.
JS 符号位为 "1" 时转移.
3>循环控制指令(短转移)
LOOP CX不为零时循环.
LOOPE/LOOPZ CX不为零且标志Z=1时循环.
LOOPNE/LOOPNZ CX不为零且标志Z=0时循环.
JCXZ CX为零时转移.
JECXZ ECX为零时转移.
4>中断指令
INT 中断指令
INTO 溢出中断
IRET 中断返回
5>处理器控制指令
HLT 处理器暂停, 直到出现中断或复位信号才继续.
WAIT 当芯片引线TEST为高电平时使CPU进入等待状态.
ESC 转换到外处理器.
LOCK 封锁总线.
NOP 空操作.
STC 置进位标志位.
CLC 清进位标志位.
CMC 进位标志取反.
STD 置方向标志位.
CLD 清方向标志位.
STI 置中断允许位.
CLI 清中断允许位.
六、伪指令
  DW 定义字(2字节).
PROC 定义过程.
ENDP 过程结束.
SEGMENT 定义段.
ASSUME 建立段寄存器寻址.
ENDS 段结束.
END 程序结束.
  
五节 分析技术
    在进行软件的破解、解密以及计算机病毒分析工作中，一个首要的问题是对软件及病毒进行分析。这些软件都是机器代码程序，对于它们分析必须使用静态或动态调试工具，分析跟踪其汇编代码。
一、从软件使用说明和操作中分析软件
    欲破解一软件，首先应该先用用这软件，了解一下功能是否有限制，最好阅读一下软件的说明或手册,特别是自己所关心的关键部分的使用说明，这样也许能够找点线索。
二、静态反汇编
  所谓静态分析即从反汇编出来的程序清单上分析，从提示信息入手进行分析。目前，大多数软件在设计时，都采用了人机对话方式。所谓人机对话，即在软件运行过程中，需要由用户选择的地方，软件即显示相应的提示信息，并等待用户按键选择。而在执行完某一段程序之后，便显示一串提示信息，以反映该段程序运行后的状态，是正常运行，还是出现错误，或者提示用户进行下一步工作的帮助信息。为此，如果我们对静态反汇编出来的程序清单进行阅读，可了解软件的编程思路，以便顺利破解。 常用的静态分析工具是W32DASM、IDA和HIEW等。
  
三、动态跟踪分析
  虽然从静态上可以了解程序的思路，但是并不可能真正了解地了解软件的细节，如静态分析找不出线索，就要动态分析程序，另外，碰到压缩程序，静态分析也无能为力了，只能动态分析了。所谓动态分析是利用SOFTICE或TRW2000一步一步地单步执行软件。为什么要对软件进行动态分析呢？这主要是因为：
1、许多软件在整体上完成的功能，一般要分解成若干模块来完成，而且后一模块在执行时，往往需要使用其前一模块处理的结果，这一结果我们把它叫中间结果。如果我们只对软件本身进行静态地分析，一般是很难分析出这些中间结果的。而只有通过跟踪执行前一模块，才能看到这些结果。另外，在程序的运行过程中，往往会在某一地方出现许多分支和转移，不同的分支和转移往往需要不同的条件，而这些条件一般是由运行该分支之前的程序来产生的。如果想知道程序运行到该分支的地方时，去底走向哪一分支，不进行动态地跟踪和分析是不得而知的。
2、有许多软件在运行时，其最初执行的一段程序往往需要对该软件的后面各个模块进行一些初始始化工作，而没有依赖系统的重定位。
3、有许多加密程序为了阻止非法跟踪和阅读，对执行代码的大部分内容进行了加密变换，而只有很短的一段程序是明文。加密程序运行时，采用了逐块解密，逐块执行和方法，首先运行最初的一段明文程序，该程序在运行过程中，不仅要完成阻止跟踪的任务，而且还要负责对下一块密码进行解密。显然仅对该软件的密码部分进行反汇编，不对该软件动态跟踪分析，是根本不可能进行解密的。
由于上述原因，在对软件静态分析不行的条件下，就要进行动态分析了。哪么如何有效地进行动态跟踪分析呢？一般来说有如下几点：
1、对软件进行粗跟踪
所谓粗跟踪，即在跟踪时要大块大块地跟踪，也就是说每次遇到调用CALL指令、重复操作指令REP.循环操作LOOP指令以及中断调用INT指令等，一般不要跟踪进去，而是根据执行结果分析该段程序的功能。
2、对关键部分进行细跟踪
  对软件进行了一定程度的粗跟踪之后，便可以获取软件中我们所关心的模块或程序段，这样就可以针对性地对该模块进行具体而详细地跟踪分析。一般情况下，对关键代码的跟踪可能要反复进行若干次才能读懂该程序，每次要把比较关键的中间结果或指令地址记录下来，这样会对下一次分析有很大的帮助。软件分析是一种比较复杂和艰苦的工作，上面的几点分析方法，只是提供了一种基本的分析方法。要积累软件分析的经验需要在实践中不断地探索和总结。

第三节 8088 汇编跳转
一、状态寄存器
PSW（Program Flag)程序状态字寄存器，是一个16位寄存器，由条件码标志（flag）和控制标志构成，如下所示：
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
            OF DF IF TF SF ZF    AF    PF    CF
  
条件码：
①OF（Overflow Flag)溢出标志。溢出时为1,否则置0。
②SF（Sign Flag）符号标志。结果为负时置1,否则置0.
③ZF（Zero Flag)零标志，运算结果为0时ZF位置1,否则置0.
④CF（Carry Flag)进位标志，进位时置1,否则置0.
⑤AF（Auxiliary carry Flag）辅助进位标志，记录运算时第3位（半个字节）产生的进位置。有进位时1,否则置0.
⑥PF（Parity Flag）奇偶标志。结果操作数中1的个数为偶数时置1,否则置0.
控制标志位：
⑦DF（Direction Flag）方向标志，在串处理指令中控制信息的方向。
⑧IF（Interrupt Flag）中断标志。
⑨TF（Trap Flag）陷井标志。
二、 直接标志转移（8位寻址）
指令格式 机器码 测试条件 如...则转移   
   指令格式 机器码 测试条件 如...则转移
JC 72 C=1 有进位 JNS 79 S=0 正号
JNC 73 C=0 无进位 JO 70 O=1 有溢出
JZ/JE 74 Z=1 零/等于 JNO 71 O=0 无溢出
JNZ/JNE 75 Z=0 不为零/不等于 JP/JPE 7A P=1 奇偶位为偶
JS 78 S=1 负号 JNP/IPO 7B P=0 奇偶位为奇
三、间接标志转移（8位寻址）
指令格式 机器码 测试格式 如...则转移
JA/JNBE(比较无符号数) 77 C或Z=0 >   高于/不低于或等于
JAE/JNB(比较无符号数) 73 C=0 >=   高于或等于/不低于
JB/JNAE(比较无符号数) 72 C=1 <   低于/不高于或等于
JBE/JNA(比较无符号数) 76 C或Z=1 <=   低于或等于/不高于
JG/JNLE(比较带符号数) 7F (S异或O）或Z=0 >   大于/不小于或等于
JGE/JNL(比较带符号数) 7D S异或O=0 >=   大于或等于/不小于
JL/JNGE(比较带符号数) 7C S异或O=1 <   小于/不大于或等于
JLE/JNG(比较带符号数) 7E (S异或O)或Z=1 <=   小于或等于/不大于
四、无条件转移指令(fisheep译 fisheep@sohu.com)
操作码 伪码指令 含义
EB   cb JMP rel8 相对短跳转（8位），使rel8处的代码位下一条指令
E9   cw JMP rel16 相对跳转（16位），使rel16处的代码位下一条指令
FF   /4 JMP r/m16 绝对跳转（16位），下一指令地址在r/m16中给出
FF   /4 JMP r/m32 绝对跳转（32位），下一指令地址在r/m32中给出
EA   cb JMP ptr16:16 远距离绝对跳转， 下一指令地址在操作数中
EA   cb JMP ptr16:32 远距离绝对跳转， 下一指令地址在操作数中
FF   /5 JMP m16:16 远距离绝对跳转， 下一指令地址在内存m16:16中
FF   /5 JMP m16:32 远距离绝对跳转， 下一指令地址在内存m16:32中
五、16位/32位寻址方式(fisheep译 fisheep@sohu.com)
  
操作码 伪码指令 跳转含义 跳转类型 跳转的条件（标志位）
0F 87   cw/cd JA rel16/32 大于 near (CF=0 and ZF=0)
0F 83   cw/cd JAE rel16/32 大于等于 near (CF=0)
0F 82   cw/cd JB rel16/32 小于 near (CF=1)
0F 86   cw/cd JBE rel16/32 小于等于 near (CF=1 or ZF=1)
0F 82   cw/cd JC rel16/32 进位 near (CF=1)
0F 84   cw/cd JE rel16/32 等于 near (ZF=1)
0F 84   cw/cd JZ rel16/32 为0 near (ZF=1)
0F 8F   cw/cd JG rel16/32 大于 near (ZF=0 and SF=OF)
0F 8D   cw/cd JGE rel16/32 大于等于 near (SF=OF)
0F 8C   cw/cd JL rel16/32 小于 near (SF<>OF)
0F 8E   cw/cd JLE rel16/32 小于等于 near (ZF=1 or SF<>OF)
0F 86   cw/cd JNA rel16/32 不大于 near (CF=1 or ZF=1)
0F 82   cw/cd JNAE rel16/32 不大于等于 near (CF=1)
0F 83   cw/cd JNB rel16/32 不小于 near (CF=0)
0F 87   cw/cd JNBE rel16/32 不小于等于 near (CF=0 and ZF=0)
0F 83   cw/cd JNC rel16/32 不进位 near (CF=0)
0F 85   cw/cd JNE rel16/32 不等于 near (ZF=0)
0F 8E   cw/cd JNG rel16/32 不大于 near (ZF=1 or SF<>OF)
0F 8C   cw/cd JNGE rel16/32 不大于等于 near (SF<>OF)
0F 8D   cw/cd JNL rel16/32 不小于 near (SF=OF)
0F 8F   cw/cd JNLE rel16/32 不小于等于 near (ZF=0 and SF=OF)
0F 81   cw/cd JNO rel16/32 未溢出 near (OF=0)
0F 8B   cw/cd JNP rel16/32 不是偶数 near (PF=0)
0F 89   cw/cd JNS rel16/32 非负数 near (SF=0)
0F 85   cw/cd JNZ rel16/32 非零（不等于） near (ZF=0)
0F 80   cw/cd JO rel16/32 溢出 near (OF=1)
0F 8A   cw/cd JP rel16/32 偶数 near (PF=1)
0F 8A   cw/cd JPE rel16/32 偶数 near (PF=1)
0F 8B   cw/cd JPO rel16/32 奇数 near (PF=0)
0F 88   cw/cd JS rel16/32 负数 near (SF=1)
0F 84   cw/cd JZ rel16/32 为零（等于） near (ZF=1)
注：一些指令操作数的含义说明：
   rel8 表示 8 位相对地址
   rel16 表示 16 位相对地址
   rel16/32 表示 16或32 位相对地址
   r/m16 表示16位寄存器
   r/m32 表示32位寄存器
  
  
  
第四节 浮点指令
    对下面的指令先做一些说明：
st(i)：代表浮点寄存器，所说的出栈、入栈操作都是对st(i)的影响
src,dst,dest,op等都是指指令的操作数，src表示源操作数，dst/dest表示目的操作数
mem8,mem16,mem32,mem64,mem80等表示是内存操作数，后面的数值表示该操作数的内存位数（8位为一字节）
x <- y 表示将y的值放入x，例st(0) <- st(0) - st(1)表示将st(0)-st(1)的值放入浮点寄存器st(0)
1． 数据传递和对常量的操作指令
指令格式
指令含义
执行的操作
  
FLD src
装入实数到st(0)
st(0) <- src (mem32/mem64/mem80)
  
FILD src
装入整数到st(0)
st(0) <- src (mem16/mem32/mem64)
  
FBLD src
装入BCD数到st(0)
st(0) <- src (mem80)
  
  
  
FLDZ
将0.0装入st(0)
st(0) <- 0.0
  
FLD1
将1.0装入st(0)
st(0) <- 1.0
  
FLDPI
将pi装入st(0)
st(0) <- ?(ie, pi)
  
FLDL2T
将log2(10)装入st(0)
st(0) <- log2(10)
  
FLDL2E
将log2(e)装入st(0)
st(0) <- log2(e)
  
FLDLG2
将log10(2)装入st(0)
st(0) <- log10(2)
  
FLDLN2
将loge(2)装入st(0)
st(0) <- loge(2)
  
  
  
FST dest
保存实数st(0)到dest
dest <- st(0) (mem32/mem64)
  
FSTP dest
  
dest <- st(0) (mem32/mem64/mem80)；然后再执行一次出栈操作
  
FIST dest
将st(0)以整数保存到dest
dest <- st(0) (mem32/mem64)
  
FISTP dest
  
dest <- st(0) (mem16/mem32/mem64)；然后再执行一次出栈操作
  
FBST dest
将st(0)以BCD保存到dest
dest <- st(0) (mem80)
  
FBSTP dest
  
dest<- st(0) (mem80)；然后再执行一次出栈操作

2．比较指令
指令格式
指令含义
执行的操作
  
FCOM
实数比较
将标志位设置为 st(0) - st(1) 的结果标志位
  
FCOM op
实数比较
将标志位设置为 st(0) - op (mem32/mem64)的结果标志位
  
  
  
FICOM op
和整数比较
将Flags值设置为st(0)-op 的结果op (mem16/mem32)
  
FICOMP op
和整数比较
将st(0)和op比较 op(mem16/mem32)后；再执行一次出栈操作
  
  
  
FTST
零检测
将st(0)和0.0比较
  
FUCOM st(i)
  
比较st(0) 和st(i) [486]
  
FUCOMP st(i)
  
比较st(0) 和st(i)，并且执行一次出栈操作
  
FUCOMPP st(i)
  
比较st(0) 和st(i)，并且执行两次出栈操作
  
FXAM
  
Examine: Eyeball st(0) (set condition codes)
  
3．运算指令
指令格式
指令含义
执行的操作
  
加法
  
FADD
加实数
st(0) <-st(0) + st(1)
  
FADD src
  
st(0) <-st(0) + src (mem32/mem64)
  
FADD st(i),st
  
st(i) <- st(i) + st(0)
  
FADDP st(i),st
  
st(i) <- st(i) + st(0)；然后执行一次出栈操作
  
FIADD src
加上一个整数
st(0) <-st(0) + src (mem16/mem32)
  
减法
  
FSUB
减去一个实数
st(0) <- st(0) - st(1)
  
FSUB src
  
st(0) <-st(0) - src (reg/mem)
  
FSUB st(i),st
  
st(i) <-st(i) - st(0)
  
FSUBP st(i),st
  
st(i) <-st(i) - st(0)，然后执行一次出栈操作
  
FSUBR st(i),st
用一个实数来减
st(0) <- st(i) - st(0)
  
FSUBRP st(i),st
  
st(0) <- st(i) - st(0)，然后执行一次出栈操作
  
FISUB src
减去一个整数
st(0) <- st(0) - src (mem16/mem32)
  
FISUBR src
用一个整数来减
st(0) <- src - st(0) (mem16/mem32)
  
乘法
  
FMUL
乘上一个实数
st(0) <- st(0) * st(1)
  
FMUL st(i)
  
st(0) <- st(0) * st(i)
  
FMUL st(i),st
  
st(i) <- st(0) * st(i)
  
FMULP st(i),st
  
st(i) <- st(0) * st(i)，然后执行一次出栈操作
  
FIMUL src
乘上一个整数
st(0) <- st(0) * src (mem16/mem32)
  
除法
  
FDIV
除以一个实数
st(0) <-st(0) /st(1)
  
FDIV st(i)
  
st(0) <- st(0) /t(i)
  
FDIV st(i),st
  
st(i) <-st(0) /st(i)
  
FDIVP st(i),st
  
st(i) <-st(0) /st(i)，然后执行一次出栈操作
  
FIDIV src
除以一个整数
st(0) <- st(0) /src (mem16/mem32)
  
FDIVR st(i),st
用实数除
st(0) <- st(i) /st(0)
  
FDIVRP st(i),st
  
FDIVRP st(i),st
  
FIDIVR src
用整数除
st(0) <- src /st(0) (mem16/mem32)
  
  
  
FSQRT
平方根
st(0) <- sqrt st(0)
  
  
FSCALE
2的st(0)次方
st(0) <- 2 ^ st(0)
  
FXTRACT
Extract exponent:
st(0) <-exponent of st(0); and gets pushed
st(0) <-significand of st(0)
  
  
FPREM
取余数
st(0) <-st(0) MOD st(1)
  
FPREM1
取余数（IEEE），同FPREM，但是使用IEEE标准[486]
  
FRNDINT
取整（四舍五入）
st(0) <- INT( st(0) ); depends on RC flag
  
FABS
求绝对值
st(0) <- ABS( st(0) ); removes sign
  
FCHS
改变符号位(求负数）
st(0) <-st(0)
  
  
F2XM1
计算(2 ^ x)-1
st(0) <- (2 ^ st(0)) - 1
  
FYL2X
计算Y * log2(X)
st(0)为Y；st(1)为X；将st(0)和st(1)变为st(0) * log2( st(1) )的值
  
  
FCOS
余弦函数Cos
st(0) <- COS( st(0) )
  
FPTAN
正切函数tan
st(0) <- TAN( st(0) )
  
FPATAN
反正切函数arctan
st(0) <- ATAN( st(0) )
  
FSIN
正弦函数sin
st(0) <- SIN( st(0) )
  
FSINCOS
sincos函数
st(0) <-SIN( st(0) )，并且压入st(1)
st(0) <- COS( st(0) )
  
FYL2XP1
计算Y * log2(X+1)
st(0)为Y； st(1)为X； 将st(0)和st(1)变为st(0) * log2( st(1)+1 )的值
  
处理器控制指令
  
FINIT
初始化FPU
  
  
FSTSW AX
保存状态字的值到AX
AX<- MSW
  
FSTSW dest
保存状态字的值到dest
dest<-MSW (mem16)
  
FLDCW src
从src装入FPU的控制字
FPU CW <-src (mem16)
  
FSTCW dest
将FPU的控制字保存到dest
dest<- FPU CW
  
FCLEX
清除异常
  
FSTENV dest
保存环境到内存地址dest处 保存状态字、控制字、标志字和异常指针的值
  
FLDENV src
从内存地址src处装入保存的环境
  
  
FSAVE dest
保存FPU的状态到dest处 94字节
  
FRSTOR src
从src处装入由FSAVE保存的FPU状态
  
FINCSTP
增加FPU的栈指针值
st(6) <-st(5); st(5) <-st(4),...,st(0) <-?
  
FDECSTP
减少FPU的栈指针值
st(0) <-st(1); st(1) <-st(2),...,st(7) <-?
  
FFREE st(i)
标志寄存器st(i)未被使用
  
FNOP
空操作，等同CPU的nop
st(0) <-st(0)
  
WAIT/FWAIT
同步FPU与CPU：停止CPU的运行，直到FPU完成当前操作码
  
FXCH
交换指令，交换st(0)和st(1)的值
st(0) <-st(1)
st(1) <- st(0)

   
第3章 动态分析技术
第一节 SoftICE与TRW2000安装安装与配制
SOFTICE有几个平台的版本，DOS,WINDOWS 3.0,Windows 95/98,WINDOWS NT,等。 由于现在最普及的操作系统是 Windows 95/98、Windows NT、Windows Millennium、Windows2000因此就讲讲SOFTICE在这几个平台安装时的一些注意事项。
一、SOFTICE for win9x安装与配制
    1、显卡安装
    2、鼠标安装
    3、Autoexec.bat和config.sys配制
    4、Symbol Loader
    5、winice.dat配制
二、SOFTICE for Windows Millennium
三、SOFTICE for NT/2K安装与配制
四、TRW2000安装

  SOFTICE的安装与配制
一、SOFTICE for win9x安装与配制
㈠、SOFTICE安装  
1、SOFTICE目前最新版本是4.05，如你的系统是win9x,就请下载for win9x版本的SOFTICE，建议下载SOFTICE的最新版本，这样稳定性好些。运行setup.exe开始安装
通过配制启动菜单，启动时根据自己的需要选择是否装载SOFTICE。
AUTOEXEC.BAT配制样例：
@ECHO OFF

goto %config%
:SICE
C:/PROGRA~1/NUMEGA/SOFTIC~1/WINICE.EXE
goto common
:NORM
goto common
:common

CONFIG.SYS配制样例：
[MENU]
MENUITEM NORM,Windows 9x
MENUITEM SICE,Windows 9x with SoftICE
MENUDEFAULT NORM,2
[NORM]
[SICE]
[common]

①General选项
在Initialization string里，你可填上需要SOFTICE一启动自动运行的命令。如：
WD 2; WC 14; FAULTS OFF; IXHERE OFF; IYHERE OFF; set font 2;lines 40;x;（各行以分号分开）
②Exports选项
在这里可添加相关的DLL文件，以便在SOFTICE下拦截这些DLL的函数。特别是破解VB程序时，定要将VB运行库装载进去。
③Keyboard Mappings选项
这里配制各功能热键。如：F5="^x;"用F5键代替命令X.
④Macro Definitions选项
宏定义，你可定制各种命令宏，以方便平时的操作。
如：s7878="S 30:0 L ffffffff '78787878' " 用命令s7878代替一串命令：S 30:0 L ffffffff '78787878'
⑤Remote Debugging
利用网络远程调试配制。
注：以上所有配制好后的参数，都保存在winice.dat文件里。
2、winice.dat配制
在Windows 9x下 SoftICE配制除了用上面的方法外，也可通过文件winice.dat来实现的。Soft-ICE 在启动的时候通过它装入一些 DLL/EXE 的信息。
你可在SOFTICE安装目录下发现winice.dat，可用任何文本编辑软件打开它（如记事本）。如我机子里的winice.dat：(你可参考我的来修改你的winice.dat）
;注意分号后是描述语言，不被执行。
PENTIUM=ON;<=Pentium Op-Codes
NMI=ON
ECHOKEYS=OFF
NOLEDS=OFF
NOPAGE=OFF
SIWVIDRANGE=ON
THREADP=ON
LOWERCASE=OFF
WDMEXPORTS=OFF
MONITOR=0
PHYSMB=128;<=这个值是你的物理内存大小
SYM=1024
HST=256;<=历史缓冲区为256K
TRA=8
MACROS=32;<=宏操作的最大个数，此处是32个
DRAWSIZE=2048;<= 我的显卡内存是2MB ，此处值是你显卡内存大小
INIT=" wd 2;wc 20;FAULTS OFF; IXHERE OFF; IYHERE OFF; set font 2;lines 40;code on;x;";<=初始化，此处默认的是800＊600分分辨率
;如你是全屏请换上：lines 57
F1="h;"
F2="^wr;"
F3="^src;"
F4="^rs;"
F5="^x;"
F6="^ec;"
F7="^here;"
F8="^t;"
F9="^bpx;"
F10="^p;"
F11="^G @SS:ESP;"
F12="^p ret;"
SF3="^format;"
CF8="^XT;"
CF9="TRACE OFF;"
CF10="^XP;"
CF11="SHOW B;"
CF12="TRACE B;"
AF1="^wr;"
AF2="^wd;"
AF3="^S 0 L FFFFFFFF 8B,CA,F3,A6,74,01,9F,92,8D,5E,08;";<=VB3特征字符串
AF4="^s 0 l ffffffff 56,57,8B,7C,24,10,8B,74,24,0C,8B,4C,24,14,33,C0,F3,66,A7;" ;<=VB4特征字符串
AF5="^s 0 l ffffffff FF,75,E0,E8,85,EF,FF,FF,DC,1D,28,10,40,00,DF,E0,9E,75,03;" ;<=VB5特征字符串
                                                      
AF8="^XT R;"
AF11="^dd dataaddr->0;"
AF12="^dd dataaddr->4;"
CF1="altscr off; lines 60; wc 32; wd 8;"
CF2="^wr;^wd;^wc;"
;<=以下是宏操作命令：
MACRO s7878="S 30:0 L ffffffff '78787878' "
MACRO sname="S 0 L FFFFFFFF 'toye' "
MACRO swide="s 0 l FFFFFFFF '7','8,'7','8,'7','8,'7','8,'7','8,'7','8,'7','8','7','8' "
MACRO reg="bpx regqueryvalueexa if *(esp->8)>='Soft' do "d(esp->14)" "
MACRO bpxpe="bpx loadlibrarya do "dd esp->4" "
MACRO bpxgeta="bpx GetDlgItemTextA; bpx getwindowtexta; bpx getdlgitemint; bpx getdlgitemtext;"
  
; ***** Examples of sym files that can be included if you have the SDK *****
; Change the path to the appropriate drive and directory
;LOAD=c:/windows/system/user.exe
;LOAD=c:/windows/system/gdi.exe
;LOAD=c:/windows/system/krnl386.exe
;LOAD=c:/windows/system/mmsystem.dll
;LOAD=c:/windows/system/win386.exe
; Exports - change the path to the appropriate drive and directory
EXP=c:/windows/system/advapi32.dll ;<=这四行前不要加分号,否则不被装载，SOFTICE可能什么也拦不到 :
EXP=c:/windows/system/kernel32.dll
EXP=c:/windows/system/user32.dll
exp=c:/windows/system/gdi32.dll
exp=c:/windows/system/comctl32.dll ;

; 如你要破解VB程序，下面的VB运行库将要装载，SOFTICE默认值是没有这几行，你需手动加上。
;EXP=c:/windows/system/msvbvm60.dll;<= Visual Basic 6 具体参考第十五课VB破解
EXP=c:/windows/system/msvbvm50.dll ;<= Visual Basic 5 注意在这五个DLL中最好不要同时装载2个以上
; EXP=c:/windows/system/vb40032.dll;<= Visual Basic 4（32bit)
; EXP=c:/windows/system/vb40016.dll;<=Visual Basic 4(16-bit)较少见
; EXP=c:/windows/system/vbrun300.dll;<=Visual Basic 3

;EXP=c:/windows/system/vga.drv;
;EXP=c:/windows/system/vga.3gr
;EXP=c:/windows/system/sound.drv
;EXP=c:/windows/system/mouse.drv
;EXP=c:/windows/system/netware.drv
;EXP=c:/windows/system/system.drv
;EXP=c:/windows/system/keyboard.drv
;EXP=c:/windows/system/toolhelp.dll
;EXP=c:/windows/system/shell.dll
;EXP=c:/windows/system/commdlg.dll
;EXP=c:/windows/system/olesvr.dll
;EXP=c:/windows/system/olecli.dll
;EXP=c:/windows/system/mmsystem.dll
;EXP=c:/windows/system/winoldap.mod
;EXP=c:/windows/progman.exe
;EXP=c:/windows/drwatson.exe
; ***** Examples of export symbols that can be included for Windows 95 *****
; Change the path to the appropriate drive and directory
EXP=c:/windows/system/kernel32.dll
EXP=c:/windows/system/user32.dll
EXP=c:/windows/system/gdi32.dll
EXP=c:/windows/system/comdlg32.dll
EXP=c:/windows/system/shell32.dll
EXP=c:/windows/system/advapi32.dll
EXP=c:/windows/system/shell232.dll
EXP=c:/windows/system/comctl32.dll
;EXP=c:/windows/system/crtdll.dll
;EXP=c:/windows/system/version.dll
EXP=c:/windows/system/netlib32.dll
;EXP=c:/windows/system/msshrui.dll
EXP=c:/windows/system/msnet32.dll
EXP=c:/windows/system/mspwl32.dll
;EXP=c:/windows/system/mpr.dll

  启动windows装载SOFTICE后，咦！怎么没反应，没调试画面！哈哈，别着急，按CTRL＋D看看，再按一下回到windows下，或按F5也能回来。此时调试窗口象windows开的一窗口，如是象全屏DOS一样窗口，那就是安装显卡时，参数没选好，此时按上文修正即可。下面的命令是调整SOFTICE窗口状态：
    set font n(n=1,2,3)设置字体;本人建议set font 2(在800*600条件下）
    set origin x,y(x,y)锁定窗口;
    lines n n=(25-128)设置显示行数；本人建议lines 40
    Ctrl+Alt+光标键 移动窗口；
    Ctrl+Alt+home 重设窗口位置原点（0,0）；
    Ctrl+L 刷新。
如你以默认winice.dat启动SOFTICE，有可能需用WD打开数据窗口;用SET FONT 2 设置字体等重复工作。你可在winice.dat文件内设置自动执行命令操作，方法是在INIT这一行，各命令用分号分开，如：
INIT=" WD 2; WC 14; FAULTS OFF; IXHERE OFF; IYHERE OFF; set font 2;lines 40;x;"这样配制后界面类似TRW2000。（这些是在800*600条件下的情况，如你不是此分辩率可调整set font n;lines n）
二、SOFTICE for Windows Millennium
  由于Windows Millennium没有了DOS平台，因此不能用常用的方法来安装SOFTICE,在此平台上可以运行SOFTICE for WIN9x版本和TRW2000版本。要实现SOFTICE在Windows Millennium平台的安装，需要工具Winice Loader，安装过程如下:
1 正常安装Windows Millennium,如在C:/WIN98ME；
2 正常安装Softice 405 Build 334；
3 复制WINICE.EXE、WINICE.DAT、SIWVID.386 三个文件到 C:/WIN98ME下；
4 从Winice Loader内解压 LOADER.EXE,复制这个文件到C:/WINME98/SYSTEM/VMM32/ 下.
5 重新启动系统。
三、SOFTICE for NT/2K安装与配制
1、SOFTICE for NT/2k的安装与for 9x版本差不多，所不同的是在第五步：装载SOFTICE方式选择
你可根据需要选择不同的装载方式，注：如你选择了Manual方式，要装载SOFTICE，需要来SOFTICE的菜单里运行选项：START SOFTICE快捷方式来装载SOFTICE。
2、在NT下，配制SOFTICE是用SOFTICE Loader（从你的开始菜单选），选择Edit/SoftICE，一般的选项是初始化，这里你可参考手册了解不同的开关选项的详细描述。如：
CODE ON; FAULTS OFF; I3HERE OFF; WD 3; WF; X;
其它两个重要的选项是Symbols & Exports。如果你拥有自己系统的SDK（软件开发工具包），你可用SOFTICE装载并调试它。那些没有SDK应该用exports选项从%WINNT%/System32 目录下增加下面的DLL文件。
advapi32.dll, comctl32.dll, comdlg32.dll, gdi32.dll, kernel32.dll, msvbvm(50/60).dll (如果需要), msvcrt.dll (如果需要), ole32.dll, oleaut32.dll, shell32.dll, user32.dll, version.dll.

四、TRW2000的安装与配制
㈠、TRW2000安装
  
TRW安装简单多了，没SOFTICE那样复杂，但目前TRW2000不支持windows NT。它发布版本是一个ZIP压缩包，才200多K。只要将其解压缩到一个目录下，然后运TRW2000.EXE即可
激活方式同SOFTICE不一样：
1. Ctrl + M 特权级0级的热键，能够立即中断Win9x。 相当于 Soft-ICE 的热键 Ctrl+D.
2. Ctrl + N 特权级3级的热键。 在绝大多数时候，我们并不需要在0级上中断。 Ctrl + N可以中断Windows的特权级3级的前台线程。 这应该是我们最常用的。
其它指令同SOFTICE兼容，也就说你在上一节学得东西完全可用在TRW2000上。
但是TRW2000有许多更新的思想，具体看后面几课介绍及范例。
另外，TRW2000可支持plug-ins，也可装载dll文件，在1.15版本以上，在安装目录下有一DLL目录，如你特别需要的dll复制到此目录，即可装载，如破解VB时，就需要将VB dll复制此目录，具体参考后面的VB破解。
其它的请读其Readme.
㈡、TRW2000的配制
TRW2000的配制是通过其安装目录下的
TRW2000.ini 来实现的，你可按自己的需要配制它（一般按默认即可）。
; TRW2000 Initialize file
; Please modify it as your habit .
;rem PLUGS=C:/PLUGS/HELLO.SYS
;No, you don't put this line. Now we have changed plug-ins load-method.
;Please copy your SYS to <TRW2000 Directory>/SYS, TRW2000 will load it
;automatic.
; Now, we don't support keyword LINES=, please use command LINES instead.
INIT="lines 35;wr 3;wd 4;wc 16"
F1=^HELP ; Command length CAN'T be longer than 15 characters !
; This command length is 5 charcaters .
F3=^SRC
F4=^RS
F5=^X
F6=^EC
F7=^HERE
F8=^T
F9=^BPX
F10=^P
F12=^PRET
;HOTKEY=320D ;Ctrl+M
;R3HOTKEY=310E ;Ctrl+N
GRAPHICS=ON ;Use graphics mode driver
VESA=OFF
VGA=ON
INTELLIMOUSE=ON ;If your mouse is a intellmouse, set this to ON
WINMOUSE=ON ;If you found your mouse is not work properly, try it to ON. But we do NOT recommend this, because it maybe decrease stabilization.
;HST=256 ;History buffer size, default = 256k
SYMBUFFER=1024
CAPITAL=ON
WONDER=ON
TESTMODE=OFF

南京浦口行知中学官网 南京浦口行知中学官网
原创粉丝点击
热门IT博客
十大即时通讯软件十大即时通讯软件
淘宝优衣库代购可信吗淘宝优衣库代购可信吗
中国近十年的gdp数据
unity3d源码下载
什么翻译软件好用
腾讯视频数据分析
access数据库查询器
杭州美工培训机构
软件测试人员招聘
北京淘宝客服地址
淘宝代销什么意思
手机吉他软件下载
数据安全保密责任书
卸载手机预装软件
主考院校知乎
linux访问samba服务器
股票箱体自动画线源码
网络电视台直播大全
ff视频软件
淘宝全球购可以退货吗
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 化肥袋厂家 化肥价格表 化肥管 硫酸铵化肥 液体化肥 红三角化肥 名牌化肥 天脊化肥 硫酸钾化肥 云天化化肥 生物化肥 黄腐酸化肥 化肥市场 化肥添加剂 化肥生产线 化肥筛 龙源化肥 黑化肥绕口令 黑化肥会挥发绕口令 史丹利化肥股份有限公司 化肥会挥发绕口令 化肥价格行情 心连心化肥有限公司 金正大化肥出事43亿 绕口令黑化肥 石家庄正元化肥有限公司 河南心连心化肥有限公司 撒可富化肥2019价格表 黑灰化肥绕口令 一吨化肥多少钱 农一网化肥产品价格表图片 硫酸钾化肥价格 中国化肥人才网 化肥名称大全 中国化肥排名 中国化肥信息网 中国化肥网尿素日报 中国化肥网今日尿素价 买化肥上什么网 史丹利化肥价格表 今日化肥价格行情

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里