Nhắc đến Windows, người ta thường nghĩvềnó nhưmột hệ điều hành (HĐH) 
dễsửdụng, ở đó, sựtương tác giữa người dùng với các ứng dụng cũng nhưvới các 
thành phần tiện ích của Windows thông qua giao diện đồhọa (GUI) bằng các thao tác 
trên bàn phím và chuột vô cùng đơn giản. Một câu hỏi được đặt ra là: “Các ứng dụng 
làm thếnào đểphân loại, lưu giữcũng nhưphản hồi lại những tương tác đó cho người 
dùng?”. Đối với Windows vấn đềnày được giải quyết một cách trọn vẹn: HĐH đưa ra 
cơchếthông điệp (message) và hàng đợi thông điệp (message queue) cùng với tập 
hợp các cấu trúc dữliệu và các hàm API hỗtrợ ứng dụng trong việc giao tiếp với 
người dùng. 
              
                                            
                                
            
 
            
                 17 trang
17 trang | 
Chia sẻ: Mr Hưng | Lượt xem: 2613 | Lượt tải: 1 
              
            Nội dung tài liệu Kỹ thuật lập trình Hook, để tải tài liệu về máy bạn click vào nút DOWNLOAD ở trên
 Trang 1
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net
Kỹ thuật lập trình Hook 
s
Reverse Engineering Association 
Win32 Programming Tutorials 
For more updated info, please check 
 .spaces.l ve.com 
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net
MỤC LỤC 
I. Các khái niệm cơ bản .................................................................................................................... 3 
1. Sự khác biệt giữa lập trình Windows và DOS........................................................................... 3 
2. Lập trình Windows .................................................................................................................... 3 
a) Thông điệp và hàng đợi thông điệp ....................................................................................... 3 
b) Lập trình sự kiện .................................................................................................................... 4 
II. Tìm hiểu về Hook.......................................................................................................................... 7 
1. Hook là gì?................................................................................................................................. 7 
2. Phân loại Hook .......................................................................................................................... 9 
a) Phân loại theo phạm vi hoạt động.......................................................................................... 9 
b) Phân loại theo thông điệp xử lý ........................................................................................... 10 
3. Thủ tục Hook – Chuỗi Hook ................................................................................................... 12 
a) Thủ tục Hook ....................................................................................................................... 12 
b) Chuỗi Hook.......................................................................................................................... 13 
III. Minh họa cách lập trình Hook ................................................................................................. 15 
1. Cài đặt thủ tục Hook................................................................................................................ 15 
2. Chuyển thông điệp đến thủ tục Hook kế tiếp .......................................................................... 16 
3. Hủy bỏ cài đặt Hook................................................................................................................ 17 
 Trang 2 
Reverse Engineering Association 
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net
I. Các khái niệm cơ bản 
1. Sự khác biệt giữa lập trình Windows và DOS 
Windows DOS 
Lập trình sự kiện dựa vào thông điệp Thực hiện tuần tự theo chỉ định 
Đa nhiệm Đơn nhiệm 
Hỗ trợ 32 bits hay hơn nữa Ứng dụng 16 bits 
Hỗ trợ nhiều công nghệ DLL, OLE, DDE, 
COM, OpenGL, DirectX 
Không có 
....... ....... 
2. Lập trình Windows 
a) Thông điệp và hàng đợi thông điệp 
 Nhắc đến Windows, người ta thường nghĩ về nó như một hệ điều hành (HĐH) 
dễ sử dụng, ở đó, sự tương tác giữa người dùng với các ứng dụng cũng như với các 
thành phần tiện ích của Windows thông qua giao diện đồ họa (GUI) bằng các thao tác 
trên bàn phím và chuột vô cùng đơn giản. Một câu hỏi được đặt ra là: “Các ứng dụng 
làm thế nào để phân loại, lưu giữ cũng như phản hồi lại những tương tác đó cho người 
dùng?”. Đối với Windows vấn đề này được giải quyết một cách trọn vẹn: HĐH đưa ra 
cơ chế thông điệp (message) và hàng đợi thông điệp (message queue) cùng với tập 
hợp các cấu trúc dữ liệu và các hàm API hỗ trợ ứng dụng trong việc giao tiếp với 
người dùng. 
 Windows có 2 loại hàng đợi thông điệp: Hàng đợi hệ thống (system queue) và 
hàng đợi ứng dụng (application queue). Hàng đợi hệ thống là hàng đợi duy nhất và 
được dùng chung cho toàn hệ thống, mọi tiến trình đang chạy đều chia sẻ hàng đợi 
này. Nhiệm vụ của hàng đợi hệ thống là nó ghi lại những sự kiện phần cứng (chuột, 
bàn phím, ) khi chúng xảy ra. 
 Trang 3 
Reverse Engineering Association 
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net
 Mỗi sự kiện sẽ được nhanh chóng chuyển thành thông điệp, sau đó Windows sẽ 
lần lượt lấy thông điệp từ hàng đợi hệ thống để xem xét và chuyển những thông điệp 
đó đến chương trình ứng dụng tương ứng. Những thông điệp này khi được chuyển đến 
ứng dụng, chúng tạo thành hàng đợi ứng dụng. 
b) Lập trình sự kiện 
 Mỗi ứng dụng có một hàng đợi ứng dụng khác nhau. Một ứng dụng nhận các 
thông điệp từ hàng đợi ứng dụng bằng cách gọi hàm GetMessage, sau đó lại gọi tiếp 
TranslateMessage để dịch thông điệp, cuối cùng gọi hàm DispatchMessage để trả lại 
thông điệp cho Windows. Việc lấy thông điệp này cứ lặp đi lặp lại, tạo thành vòng lặp 
thông điệp. Vòng lặp này kết thúc khi hàm GetMessage trả về giá trị 0 nếu thông điệp 
có định danh là WM_QUIT (0x0012). 
 Trang 4 
Reverse Engineering Association 
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net
Thông thường, chúng ta chỉ chặn để xử lý các thông điệp có liên quan đến chức năng 
của ứng dụng, các thông điệp khác thì giao cho hàm xử lý mặc định làm việc (hàm 
DefWindowsProc). Để dễ tưởng tượng, ta sẽ lấy một ví dụ khi chương trình xử lý 
thông điệp bàn phím. Khi đó, sơ đồ của quá trình xử lý sự kiện bàn phím như sau: 
 Trình điều khiển bàn phím (Keyboard Device Driver) sẽ thông dịch mã quét và 
chuyển nó thành mã phím ảo (vitual-key code), một giá trị độc lập thiết bị, được định 
nghĩa bởi hệ thống. Sau đó, trình điều khiển tạo một thông điệp bao gồm scancode, 
virtual-key code cùng một số thông tin khác (sự lặp phím, trạng thái các phím Alt, 
Ctrl...) , đặt vào hàng đợi hệ thống. Hệ thống lấy thông điệp này ra khỏi hàng đợi hệ 
thống và gửi đến hàng đợi thông điệp của ứng dụng. Cuối cùng, vòng lặp thông điệp 
(Message Loop) sẽ lấy thông điệp ra khỏi hàng đợi ứng dụng và chuyển nó đến hàm 
xử lý thông điệp thích hợp để xử lý. 
 Trang 5 
Reverse Engineering Association 
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net
Ta có sơ đồ của hàng đợi thông điệp như sau: 
 Trang 6 
Reverse Engineering Association 
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net
II. Tìm hiểu về Hook 
1. Hook là gì? 
 Hook là một cơ chế trong lập trình sự kiện, cho phép ứng dụng có thể cài đặt một 
hàm giám sát vào quá trình lưu chuyển các thông điệp. Hay nói cách khác hook là 1 cơ chế 
cho phép chặn các sự kiện (chuột, bàn phím, thông điệp) trước khi chúng được gửi tới hàng 
đợi của ứng dụng. 
 Trang 7 
Reverse Engineering Association 
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net
Các hàm này có thể được dùng để xử lý các sự kiện và trong nhiều trường hợp, chúng cũng 
có thể thay đổi hoặc huỷ bỏ các sự kiện đó. Một điểm quan trọng cần lưu ý là các hàm này 
được hệ điều hành gọi chứ không phải là chương trình ứng dụng của ta gọi. Các hàm nhận sự 
kiện được gọi là hàm lọc (filter function) và được phân loại theo loại sự kiện mà chúng chặn. 
 Ví dụ: 1 hàm lọc chặn các sự kiện chuột khác với hàm lọc chặn các sự kiện bàn phím. 
 Trước khi Windows gọi 1 hàm lọc, hàm lọc đó phải được cài đặt, nghĩa là phải được 
gắn với hook của Windows (ví dụ như hook bàn phím). Gắn 1 hay nhiều hàm lọc vào 1 hook 
được gọi là thiết lập hook (setting a hook). Nếu hook có hơn 1 hàm lọc thì Windows tạo ra 1 
dãy các hàm lọc (hook chain). Khi 1 hook có nhiều hàm lọc và có 1 sự kiện xảy ra bị hook 
bắt được, Windows sẽ gọi hàm lọc đầu tiên trong dãy hàm lọc. Hành động này được gọi là 
“gọi hook”. 
 Ví dụ: nếu 1 hàm lọc được gắn vào hook CBT và có 1 sự kiện bị bắt được (ví dụ: tạo 1 
cửa sổ), Windows sẽ gọi hook CBT bằng cách gọi hàm đầu tiên trong dãy hàm lọc. Như vậy, 
ta có sơ đồ hook như sau: 
 Trang 8 
Reverse Engineering Association 
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net
 Hook có khả năng can thiệp rất sâu vào trong hệ thống, nó có thể làm cho hệ thống 
hoạt động chậm chạp hơn hoặc thậm chí có thể làm treo hệ thống nếu không được xử lý tốt. 
Bới vậy, ta chỉ nên dùng hook trong trường hợp cần thiết và phải huỷ bỏ ngay hook khi 
không cần dùng đến. Để cài đặt và gỡ cài đặt hook, chương trình cần dùng các hàm 
SetWindowsHookEx và UnhookWindowsHookEx. 
2. Phân loại Hook 
a) Phân loại theo phạm vi hoạt động 
 Hook cục bộ (Thread Hook hay Local Hook): hàm giám sát được cài đặt 
vào sau hàng đợi thông điệp ứng dụng (Thread message Queue hay 
Application Queue), chỉ kiểm soát các thông điệp trong một tiến trình hay 
một ứng dụng cụ thể nào đó được xác định lúc cài đặt thủ tục Hook 
 Hook toàn cục (Global Hook): hàm giám sát được cài đặt vào sau hàng đợi 
thông điệp hệ thống, kiểm soát toàn bộ các tiến trình trong hệ thống 
 Thủ tục hook toàn cục phải được khai báo ở một DLL tách biệt. 
 Trang 9 
Reverse Engineering Association 
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net
b) Phân loại theo thông điệp xử lý 
Loại Hook Công dụng 
WH_CALLWNDPROC 
và 
WH_CALLWNDPROCRET 
 Cho phép giám sát các thông điệp được gởi tới một 
cửa sổ. Hệ thống gọi thủ tục Hook của 
WH_CALLWNDPROC trước khi gởi thông điệp đến 
cửa sổ đích và gọi WH_CALLWNDPROCRET sau 
khi thủ tục ở cửa sổ đích xử lý xong thông điệp. 
 Hook WH_CALLWNDPROCRET truyền một con trỏ 
có cấu trúc CWPRETSTRUCT tới thủ tục Hook. Cấu 
trúc này chứa giá trị trả về của thủ tục cửa sổ đã xử 
lý thông điệp 
WH_CBT 
Windows gọi hàm Hook CBT trước khi tạo lập, kích 
hoạt, hủy, thu nhỏ, phóng to, di chuyển, thay đổi kích 
thước, ... của cửa sổ giao diện; hoặc trước khi hoàn 
thành một lệnh của hệ thống; hoặc trước khi hủy bỏ một 
sự kiện chuột hay bàn phím khỏi hàng đợi hệ thống; 
hoặc trước khi đặt một điều khiển vào 1 input nào đó; 
hoặc trong lúc đồng bộ hàng đợi thông điệp hệ thống. 
Giá trị trả về của thủ tục hook cho biết hệ thống sẽ chấp 
nhận hay là hủy bỏ những hành động đó hay không. 
Hook WH_CBT thường được dùng cho các chương 
trình đào tạo trên máy tính. 
WH_DEBUG 
Hệ thống gọi thủ tục WH_DEBUG trước khi gọi các thu 
tục hook khác trong hệ thống. Ta có thể dùng hook này 
để xác định xem có cho phép gọi các thủ tục hook khác 
hay không. 
WH_FOREGROUNDIDLE 
Hook này cho phép ta thực thi các tác vụ với mức ưu 
tiên thấp khi các tiến trình chạy nền của nó được đặt ở 
trạng thái nghỉ ngơi. Hệ thống gọi thủ tục 
WH_FOREGROUNDIDLE khi chương trình chạy nền 
chuẩn bị chuyển sang chế độ nghỉ ngơi (idle). 
 Trang 10 
Reverse Engineering Association 
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net
WH_GETMESSAGE 
hook này cho phép một chương trình giám sát các 
thông điệp được trả về bởi các hàm GetMessage và 
PeekMessage. Ta có thể dùng hook 
WH_GETMESSAGE để giám sát sự kiện chuột và bàn 
phím và các sự kiện khác được gửi đến hàng đợi thông 
điệp. 
WH_JOURNALPLAYBACK 
cho phép một chương trình có thể chèn thông điệp vào 
hàng đợi thông điệp hệ thống. Ta có thể dùng hook này 
để chạy lại (play back) các sự kiện chuột và bàn phím 
được ghi lại (record) trước đó bởi hook 
WH_JOURNALRECORD. Khi hook 
WH_JOURNALPLAYBACK được cài đặt, chuột và bàn 
phím sẽ bị đóng băng. Hook này chỉ dành riêng để hook 
hệ thống, ta không thể dùng để cài đặt hook cục bộ. 
Hook này trả về một giá trị time-out. Giá trị này cho hệ 
thống biết phải đợi bao nhiêu mili-giây trước khi xử lý 
thông điệp hiện tại nhận được từ hook 
WH_JOURNALPLAYBACK. Điều này cho phép hook có 
thể điều khiển khoảng thời gian của sự kiện mà nó play 
back. 
WH_JOURNALRECORD 
Cho phép giám sát và ghi lại các sự kiện vào (input 
event). Hook này thường được dùng để ghi lại chuỗi các 
sự kiện chuột và bàn phím để sau đó được phát lại nhờ 
hook WH_JOURNALPLAYBACKHOOK. Hook này chỉ 
dành riêng để hook hệ thống, ta không thể dùng để cài 
đặt hook cục bộ. 
WH_KEYBOARD_LL 
Cho phép giám sát sự kiện vào của bàn phím được gửi 
tới hàng đợi ứng dụng. 
WH_KEYBOARD 
Hook giám sát thông điệp từ bàn phím WM_KEYDOWN, 
WM_KEYUP 
WH_MOUSE_LL 
Cho phép giám sát sự kiện vào của chuột được gửi tới 
hàng đợi ứng dụng. 
 Trang 11 
Reverse Engineering Association 
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net
WH_MOUSE 
Cho phép giám sát thông điệp của chuột được trả về 
bới hàm GetMessage hoặc PeekMessage. Ta có thể 
dùng hàm này để theo dõi sự kiện nhập từ chuột 
(mouse input) được gửi tới hàng đợi thông điệp. 
WH_MSGFILTER 
Xử lý hoặc thay đổi tất cả các thông điệp cho hộp thoại 
cửa sổ, hộp thoại thông điệp hoặc là menu của chương 
trình 
WH_SYSMSGFILTER 
Xử lý hoặc thay đổi tất cả các thông điệp cho hộp thoại 
cửa sổ, hộp thoại thông điệp hoặc là menu của hệ thống
WH_SHELL 
Một chương trình shell có thể dùng hook WH_SHELL để 
nhận các thông báo quan trọng. Hệ thống gọi một thủ 
tục WH_SHELL khi chương trình shell được kích hoạt 
và khi một cửa sổ mức cao (top-level) được khởi tạo 
hoặc huỷ bỏ. 
3. Thủ tục Hook – Chuỗi Hook 
a) Thủ tục Hook 
 Là một thủ tục được cài đặt để xử lý cho một loại hook nào đó. Thủ tục này được 
gọi bởi HĐH, nó là hàm CallBack. 
 Dạng chung của Hook Function: 
LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam); 
Trong đó: 
 nCode: tham số này thường được gọi là “hook code”, thủ tục Hook sử dụng giá trị 
này để quyết định cách thức xử lý đối với sự kiện. Việc xử lý với mỗi sự kiện như 
thế nào là hoàn toàn phụ thuộc vào người lập trình. Giá trị của hook code tùy 
thuộc vào từng loại hook cụ thể, và mỗi loại hook sẽ có tập hợp những giá trị 
hook code đặc trưng của riêng mình. Khi Windows truyền cho hàm giá trị hook 
code âm, thủ tục không được xử lý sự kiện mà phải gọi hàm CallNextHookEx với 
 Trang 12 
Reverse Engineering Association 
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net
chính những tham số mà HĐH truyền cho nó. Sau đó, nó phải trả về giá trị được 
trả về bởi hàm CallNextHookEx. 
 wParam, lParam: Đây là những thông tin cần thiết cho thủ tục Hook trong quá 
trình xử lý sự kiện. Các giá trị này sẽ có ý nghĩa khác nhau tuỳ thuộc vào từng loại 
hook. 
Ví dụ: thủ tục gắn với hook WH_KEYBOARD sẽ nhận mã phím ảo (Virtual-Key 
Code) từ wParam, đồng thời có được từ lParam thông tin mô tả trạng thái của bàn 
phím khi sự kiện gõ phím xảy ra. 
 Mỗi loại Hook cần có cách xử lý khác nhau khi xây dựng thủ tục Hook. 
 Có thể cài đặt nhiều thủ tục Hook bằng cách dùng hàm SetWindowsHook hay 
SetWindowsHookEx 
 Thủ tục Hook cài sau sẽ luôn nằm ở vị trí đầu tiên trong chuỗi Hook 
b) Chuỗi Hook 
Là một dãy các thủ tục Hook được liên kết theo thứ tự ưu tiên thực hiện giảm dần 
 Đặc điểm Chuỗi Hook: 
 Hệ thống có khả năng hỗ trợ nhiều loại hook khác nhau, mỗi loại được quy 
định một cách thức truy nhập khác nhau  Hệ thống duy trì từng chuỗi Hook 
riêng biệt cho mỗi loại hook 
 Khi có một message được sinh ra thuộc một loại hook nào đó, nó sẽ được hệ 
thống đẩy vào hàm hook đầu tiên trong chuỗi, sau đó được chuyển lần lượt đến 
các thủ tục Hook kế tiếp nhờ xử lý trong thủ tục Hook. 
 Một chuỗi hook là một danh sách các con trỏ đặc biệt, nó được trỏ tới các hàm 
CallBack gọi là hook procedure (thủ tục hook). Như vậy khi một sự kiện xuất 
hiện, hệ thống sẽ chuyển sự kiện đó tới các thủ tục hook được tham chiếu bới 
chuỗi hook theo thứ tự lần lượt. Vì thế phải thực hiện xong thủ tục này mới 
được gọi thủ tục kế tiếp. 
 Trang 13 
Reverse Engineering Association 
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net
Sơ đồ Hook Chain 
 Trang 14 
Reverse Engineering Association 
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net
III. Minh họa cách lập trình Hook 
1. Cài đặt thủ tục Hook 
 Một ứng dụng cần phải thực hiện việc Cài đặt thủ tục Hook khi muốn giám sát 
thông điệp 
 Hàm SetWindowsHookEx sẽ cài đặt thủ tục Hook vào điểm bắt đầu của chuỗi 
Hook 
 HHOOK SetWindowsHookEx( 
 int hookMsg, HOOKPROC hookProc, 
 HINSTANCE hIns, DWORD threadId); 
Trong đó, 
 hookMsg: loại Hook 
 hookProc: con trỏ đến thủ tục Hook. Trường hợp Hook toàn cục, thủ tục 
Hook phải lưu trong DLL; với Thread Hook, thủ tục Hook có thể chứa 
trong chính thread tương ứng 
 hIns: handle của module chứa thủ tục Hook 
 threadId: ID của thread. Nếu là 0, Hook sẽ là Global 
Ví dụ 1: Cài đặt Keyboard Hook toàn cục (load-time) 
SetWindowsHookEx(WH_KEYBOARD, KeyboardProc, hInstDLL, 0); 
Ví dụ 2: Cài đặt Keyboard Hook toàn cục (run-time) 
HOOKPROC fnKeyboardProc; 
static HINSTANCE hInstDLL; 
static HHOOK hHook; 
hInstDLL = LoadLibrary((LPCTSTR) “myKBDLL.dll"); 
fnKeyboardProc = (HOOKPROC)GetProcAddress(hInstDLL, “KeyboardProc"); 
hHook = SetWindowsHookEx(WH_KEYBOARD, fnKeyboardProc, hInstDLL, 0); 
Ví dụ 3: Cài đặt Keyboard Hook cục bộ 
SetWindowsHookEx(WH_KEYBOARD, KeyboardProc, NULL,GetCurrentThreadId()); 
 Trang 15 
Reverse Engineering Association 
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net
Ví dụ 4: Thủ tục hook cho Keyboard 
LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) 
{ 
 if (nCode >= 0 && nCode == HC_ACTION) 
 { 
 pMsg = (MSG *)lParam; 
 if (pMsg->message == WM_KEYDOWN) 
 { 
 char s[] = {LOBYTE(wParam),’\0’}; 
 MessageBox(NULL, s, “Hook”, 0); 
 } 
} 
 return CallNextHookEx(hHook, nCode,wParam, lParam); 
} 
Ví dụ 5: Hàm hook cho Mouse 
LRESULT CALLBACK MouseProc(int nCode, WPARAM wParam, LPARAM lParam) 
{ 
 if (nCode < 0) // không xử lý message 
 return CallNextHookEx(hHook, nCode,wParam, lParam); 
 // xử lý message 
 char szBuf[128]; 
 sprintf(szBuf, “MOUSE – Msg: %d, x: %d, y: %d”, 
 wParam, LOWROD(lParam), HIWORD(lParam)); 
 MessageBox(NULL, szBuf, “MouseHook”, MB_OK); 
 return CallNextHookEx(hHook, nCode, wParam, lParam); 
} 
2. Chuyển thông điệp đến thủ tục Hook kế tiếp 
 Sau khi thực hiện xong, thủ tục Hook sẽ gọi hàm CallNextHookEx để chuyển 
message đến thủ tục Hook kế tiếp trong chuỗi Hook 
 LRESULT CallNextHookEx( 
 HHOOK hHook, int code, 
 WPARAM wParam, LPARAM lParam); 
 Tham số đầu tiên là handle của hook hiện hành, giá trị này có thể lấy được từ hàm 
SetWindowsHookEx khi cài đặt hook. 
 Ba tham số tiếp theo là những giá trị mà thủ tục Hook hiện tại truyền cho thủ tục 
Hook kế tiếp trong chuỗi Hook . 
 Trang 16 
Reverse Engineering Association 
 Trang 17
Kỹ thuật lập trình Hook 
NhatPhuongLe 
www.reaonline.net 
Reverse Engineering Association 
 Trong một số tình huống, thủ tục Hook hiện hành có thể không muốn chuyển 
sự kiện cho thủ tục Hook kế tiếp khác trong cùng một chuỗi Hook. Lúc này, nếu loại 
hook ta đang cài đặt cho phép huỷ bỏ sự kiện, và thủ tục của ta cũng có cùng quyết định 
là hủy bỏ, nó sẽ không phải gọi hàm CallNextHookEx. 
 Trong thực tế, người lập trình sẽ không thể biết được vị trí thủ tục Hook của 
mình trong chuỗi các hook. Bởi vì khi ta gọi hàm CallNextHookEx, Windows mới là 
đối tượng quyết định xem phải chọn hàm nào để bàn giao sự kiện, và quá trình này dĩ 
nhiên đã được HĐH giấu kín. Do đó, người lập trình phải tuân thủ các nguyên tắc của 
Hệ điều hành khi cài đặt và sử dụng một hook. 
3. Hủy bỏ cài đặt Hook 
 Sử dụng kỹ thuật Hook sẽ làm giảm khả năng thực thi của hệ thống 
 Do đó, khi không sử dụng Hook nữa nên hủy bỏ Hook khỏi hệ thống 
BOOL UnhookWindowsHooks(HHOOK hHook); 
            Các file đính kèm theo tài liệu này:
 baigiangkythuatlaptrinhhook_3055.pdf baigiangkythuatlaptrinhhook_3055.pdf