外掛編寫完全攻略(頁 1) - 程式設計討論 - D.C.資訊交流網-[綜合論壇]-關閉註冊

seep1234567890 發表於 2007-9-21 01:44

外掛編寫完全攻略

外掛編寫完全攻略
一、先說一下寫一個外掛需要什麼條件
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源代碼,呵呵!
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

.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]

[size=4][color=#ff0000]游戲外掛分析
[/color][/size]石器 \ 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也一樣，在外掛打擊的現在，必定也會有游狀態的外掛出現~
期待。。。

[size=5][color=#ff0000]分析客戶端的有關資料
[/color][/size]自己作外掛，大多時候要分析封包，不過因為有的功能是由客戶端來辨別的，所以分析客戶端的程序同樣也很重要，分析客戶端首先要求你能看懂匯編指令（只要"看懂"，要求很低的），其次是要能夠熟練的運用一些工具，然后能剩下的也就是運氣和游戲公司的漏洞了。（哈，不是每次都能成功的啊）下邊我分步教給大家。
第一章 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...(所有的轉移指令)

[size=5][color=#ff0000]FPE修改全教程
[/color][/size]很早的時候,當出現了視窗系統以后,圖形界面就深得人們的喜愛,從古老的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級的屠龍槍怎麼來的? 就這麼來的
會了嗎~?自己去改吧.不要再問我要了,*自己吧.
以后你還想做什麼`~~?我提示吧,現在的修改器有低階搜索的功能.什麼意思,游戲里的東西不知道數值的部分,我們用搜索,輸入? 然后增加+ 減少- 這就是基本的格式,地址就是這樣找到的,找到了地址,加個鎖定的代碼,做個啟動文件,最后``````````自己去做外掛吧.裝備嗎?有數值,自己想吧!
世界上通向羅馬的路很多.你總得找一條屬於你自己吧?

[size=5][color=#ff0000]FPE修改教程進階(地址編輯部分)
[/color][/size]
需要具備的幾個初步知識
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存檔，拿出來和大家分享。

[size=5][color=#ff0000]從游戲中得到動態記憶體資料
[/color][/size]工具：
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;
}

[size=6][color=#0000ff]位運算基礎（菜鳥看的）（有點像課本）
[/color][/size]首先我們將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的代碼（這里我們就簡單的以黃狗的代碼來舉例）。
那麼，我們就利用單機代理技術來同時欺騙客戶端和服務器吧！

[size=6][color=#0000ff]如何操作記憶體
[/color][/size]進程：用最簡潔的話來說，進程就是一個正在執行的程序，一個或多個線程在進程中運行。
線程：線程是操作系統分配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)

[size=6][color=#0000ff]Hook Win32 API 的應用研究
[/color][/size]之一：網絡監控
絕大多數具有網絡功能的軟體都是基於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住文字輸出函數，包括我上面提到的和沒有提到的函數，就能截獲屏幕上文字輸出的坐標和內容等等資訊，只要我們一一作記錄，並加以分析轉換，跟滑鼠的位置進行比較，我們就能得到屏幕上某個位置的文字內容是什麼了，要翻譯怎麼的，就看你的了，這就是屏幕取詞，雖然實際上實現的過程並不像說得那麼簡單。
出了詞霸的屏幕取詞，還有一些動態漢化、外掛中文平台之類的軟體，也是基於這種技術的，現在看來，它們是不是已經不再神祕了？

[size=6][color=#0000ff]關於API HOOK攔截封包原理

[/color][/size]利用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的鎖和解鎖，以使調用變為串行進行，但這個我沒有試驗過。

[size=6][color=#0000ff]截獲WINSOCKET
[/color][/size]截獲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
---- 目前加入的模塊為一個日志處理。

[size=6]網絡游戲的封包
[/size]網絡游戲的封包技術是大多數程式化愛好者都比較關注的關注的問題之一，在這一篇里就讓我們一起研究一下這一個問題吧。
別看這是封包這一問題，但是涉及的技術範圍很廣範，實現的方式也很多（比如說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就會送你回去。

[size=6]軟體破解
[/size]/////////軟體保護
軟體的破解技術與保護技術這兩者之間本身就是矛與盾的關係，它們是在互相斗爭中發展進化的。這種技術上的較量歸根到底是一種利益的沖突。軟體開發者為了維護自身的商業利益，不斷地尋找各種有效的技術來保護自身的軟體版權，以增加其保護強度，推遲軟體被破解的時間；而破解者則或受盜版所帶來的高額利潤的驅使，或出於純粹的個人興趣，而不斷制作新的破解工具並針對新出現的保護方式進行跟蹤分析以找到相應的破解方法。從理論上說，幾乎沒有破解不了的保護。對軟體的保護僅僅*技術是不夠的，而這最終要*人們的知識產權意識和法制觀念的進步以及生活水平的提高。但是如果一種保護技術的強度強到足以讓破解者在軟體的生命周期內無法將其完全破解，這種保護技術就可以說是非常成功的。軟體保護方式的設計應在一開始就作為軟體開發的一部分來考慮，列入開發計划和開發成本中，並在保護強度、成本、易用性之間進行折衷考慮，選擇一個合適的平衡點。
在桌面操作系統中，微軟的產品自然是獨霸天下，一般個人使用者接触得最多，研究得自然也更多一些。在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 <= 小於或等於/不大於
四、無條件轉移指令
操作碼偽碼指令含義
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位尋址方式

操作碼偽碼指令跳轉含義跳轉類型跳轉的條件（標志位）
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

[[i] 本帖最後由 seep1234567890 於 2007-9-21 01:53 編輯 [/i]]

fish5477 發表於 2007-10-1 02:29

看的出來大大是高手
寫的真的很精深
不是一般半吊子再寫的

realyw999 發表於 2007-11-29 16:18

超多的东西有，需要时就会感激他内容的丰富了

Lizard0605 發表於 2007-12-4 07:56

東西好多啊...寫個外掛要懂的東西真不少...

阿嘉發表於 2008-2-7 14:50

雖然看不太董不過受益良多感ㄐ不進

世界通 發表於 2008-2-14 21:37

这贴太吊了，我收藏了~备用！

andyoun 發表於 2008-3-3 22:07

真神阿!!

原來製作一個好的外掛需要如此龐大的工程才做的出來~
真佩服那些製作出市面上那些熱門遊戲外掛的高手~

bkempemp 發表於 2008-3-13 18:46

先收藏起來等明天再好好的觀看^^非常感謝您無私分享

49227211 發表於 2008-3-19 08:40

先收藏起來等明天再好好的觀看

tttll22 發表於 2008-3-22 20:14

看来偶还有很多东西要学

1010bbq 發表於 2009-5-25 13:53

謝謝c hing 分享 ^_^

mightya 發表於 2009-8-28 10:45

”3、熟練掌握跟蹤和調試的工具“

实际操作过程中
ring0级别用softice, 静态自然用ida pro ,它有一个插件，可以把汇编码译成伪码，而涉及一般的跟踪，用ollydbg就可以了，它的功能也很强大，修改pe文件也很方便。除此之外，还要配合peid等其他工具。
--------
精力过剩的人最好学下dx和opengl两套api,也有助于理解游戏实现逻辑。
网上那本《网络游戏安全揭密》，里面提到一些技术应用，还可以。

9316 發表於 2009-9-20 17:58

大大果然是高手
建議你去出書

gameking 發表於 2010-3-5 02:04

明白明白, 學會了!

alomar0116 發表於 2010-6-16 09:30

這位大哥真的好厲害
換成一般人要看都累了
你把他打完...orz

dtfmz 發表於 2010-12-9 20:08

看后狂受教育啊，歹势

diandian0122 發表於 2011-1-14 09:11

很好啊，受益匪浅

mightya 發表於 2011-4-6 16:57

够长,
自己写过,难度最大就是代码跟踪.

頁: [1]

D.C.資訊交流網-[綜合論壇]-關閉註冊's Archiver

外掛編寫完全攻略

真神阿!!