浅谈HOOK

摘要： 本文针对HOOK技术在VC编程中的应用进行讨论，并着重对应用比较广泛的全局HOOK做了阐述。

　　一、引言

　　Windows操作系统是建立在事件驱动机制之上的，系统各部分之间的沟通也都是通过消息的相互传递而实现的。但在通常情况下，应用程序只能处理来自进程内部的消息或是从其他进程发过来的消息，如果需要对在进程外传递的消息进行拦截处理就必须采取一种被称为HOOK（钩子）的技术。钩子是Windows操作系统中非常重要的一种系统接口，用它可以轻松截获并处理在其他应用程序之间传递的消息，并由此可以完成一些普通应用程序难以实现的特殊功能。基于钩子在消息拦截处理中的强大功能，本文即以VC++ 6.0为编程背景对钩子的基本概念及其实现过程展开讨论。为方便理解，在文章最后还给出了一个简单的有关鼠标钩子的应用示例。

　　二、钩子的基本原理

　　钩子的本质是一段用以处理系统消息的程序，通过系统调用，将其挂入到系统。钩子的种类有很多，每一种钩子负责截获并处理相应的消息。钩子机制允许应用程序截获并处理发往指定窗口的消息或特定事件，其监视的窗口即可以是本进程内的也可以是由其他进程所创建的。在特定的消息发出，并在到达目的窗口之前，钩子程序先行截获此消息并得到对其的控制权。此时在钩子函数中就可以对截获的消息进行各种修改处理，甚至强行终止该消息的继续传递。 

　　任何一个钩子都由系统来维护一个指针列表（钩子链表），其指针指向钩子的各个处理函数。最近安装的钩子放在链的开始，最早安装的钩子则放在最后，当钩子监视的消息出现时，操作系统调用链表开始处的第一个钩子处理函数进行处理，也就是说最后加入的钩子优先获得控制权。在这里提到的钩子处理函数必须是一个回调函数（callback function），而且不能定义为类成员函数，必须定义为普通的C函数。在使用钩子时可以根据其监视范围的不同将其分为全局钩子和线程钩子两大类，其中线程钩子只能监视某个线程，而全局钩子则可对在当前系统下运行的所有线程进行监视。显然，线程钩子可以看作是全局钩子的一个子集，全局钩子虽然功能强大但同时实现起来也比较烦琐：其钩子函数的实现必须封装在动态链接库中才可以使用。

　　钩子的安装与卸载

　　由于全局钩子具有相当的广泛性而且在功能上完全覆盖了线程钩子，因此下面就主要对应用较多的全局钩子的安装与使用进行讨论。前面已经提过，操作系统是通过调用钩子链表开始处的第一个钩子处理函数而进行消息拦截处理的。因此，为了设置钩子，只需将回调函数放置于链首即可，操作系统会使其首先被调用。在具体实现时由函数SetWindowsHookEx()负责将回调函数放置于钩子链表的开始位置。SetWindowsHookEx()函数原型声明如下:

HHOOK SetWindowsHookEx(int idHook;
HOOKPROC lpfn;
HINSTANCE hMod;
DWORD dwThreadId);

　　其中：参数idHook 指定了钩子的类型，总共有如下13种： 

　　　WH_CALLWNDPROC 系统将消息发送到指定窗口之前的"钩子" 
　　　WH_CALLWNDPROCRET 消息已经在窗口中处理的"钩子" 
　　　WH_CBT 基于计算机培训的"钩子" 
　　　WH_DEBUG 差错"钩子" 
　　　WH_FOREGROUNDIDLE 前台空闲窗口"钩子" 
　　　WH_GETMESSAGE 接收消息投递的"钩子" 
　　　WH_JOURNALPLAYBACK 回放以前通过WH_JOURNALRECORD"钩子"记录的输入消息 
　　　WH_JOURNALRECORD 输入消息记录"钩子" 
　　　WH_KEYBOARD 键盘消息"钩子" 
　　　WH_MOUSE 鼠标消息"钩子" 
　　　WH_MSGFILTER 对话框、消息框、菜单或滚动条输入消息"钩子" 
　　　WH_SHELL 外壳"钩子" 
　　　WH_SYSMSGFILTER 系统消息"钩子" 

　　参数lpfn为指向钩子处理函数的指针，即回调函数的首地址；参数hMod则标识了钩子处理函数所处模块的句柄；第四个参数dwThreadId 指定被监视的线程，如果明确指定了某个线程的ID就只监视该线程，此时的钩子即为线程钩子；如果该参数被设置为0，则表示此钩子为监视系统所有线程的全局钩子。此函数在执行完后将返回一个钩子句柄。

　　虽然对于线程钩子并不要求其象全局钩子一样必须放置于动态链接库中，但是推荐其也在动态链接库中实现。因为这样的处理不仅可使钩子可为系统内的多个进程访问，也可以在系统中被直接调用，而且对于一个只供单进程访问的钩子，还可以将其钩子处理过程放在安装钩子的同一个线程内，此时SetWindowsHookEx()函数的第三个参数也就是该线程的实例句柄。

　　在SetWindowsHookEx()函数完成对钩子的安装后，如果被监视的事件发生，系统马上会调用位于相应钩子链表开始处的钩子处理函数进行处理，每一个钩子处理函数在进行相应的处理时都要考虑是否需要把事件传递给下一个钩子处理函数。如果要传递，就通过函数CallNestHookEx()来解决。尽管如此，在实际使用时还是强烈推荐无论是否需要事件传递而都在过程的最后调用一次CallNextHookEx( )函数，否则将会引起一些无法预知的系统行为或是系统锁定。该函数将返回位于钩子链表中的下一个钩子处理过程的地址，至于具体的返回值类型则要视所设置的钩子类型而定。该函数的原型声明如下：

LRESULT CallNextHookEx(HHOOK hhk;int nCode;WPARAM wParam;LPARAM lParam);

　　其中，参数hhk为由SetWindowsHookEx()函数返回的当前钩子句柄；参数nCode为传给钩子过程的事件代码；参数wParam和lParam 则为传给钩子处理函数的参数值，其具体含义同设置的钩子类型有关。

　　最后，由于安装钩子对系统的性能有一定的影响，所以在钩子使用完毕后应及时将其卸载以释放其所占资源。释放钩子的函数为UnhookWindowsHookEx()，该函数比较简单只有一个参数用于指定此前由SetWindowsHookEx()函数所返回的钩子句柄，原型声明如下：

BOOL UnhookWindowsHookEx(HHOOK hhk);

　　三、鼠标钩子的简单示例 

　　最后，为更清楚展示HOOK技术在VC编程中的应用，给出一个有关鼠标钩子使用的简单示例。在钩子设置时采用的是全局钩子。下面就对鼠标钩子的安装、使用以及卸载等过程的实现进行讲述：

　　由于本例程需要使用全局钩子，因此首先构造全局钩子的载体--动态链接库。考虑到　Win32 DLL与Win16 DLL存在的差别，在Win32环境下要在多个进程间共享数据，就必须采取一些措施将待共享的数据提取到一个独立的数据段，并通过def文件将其属性设置为读写共享：

#pragma data_seg("TestData")
HWND glhPrevTarWnd=NULL; // 窗口句柄
HWND glhHook=NULL; // 鼠标钩子句柄
HINSTANCE glhInstance=NULL; // DLL实例句柄
#pragma data_seg()
……
SECTIONS // def文件中将数据段TestData设置为读写共享
TestData READ WRITE SHARED 


　　在安装全局鼠标钩子时使用函数SetWindowsHookEx()，并设定鼠标钩子的处理函数为MouseProc()，安装函数返回的钩子句柄保存于变量glhHook中：

void StartHook(HWND hWnd)
{
……
glhHook=(HWND)SetWindowsHookEx(WH_MOUSE,MouseProc,glhInstance,0);
} 


　　鼠标钩子安装好后，在移动、点击鼠标时将会发出鼠标消息，这些消息均经过消息处理函数MouseProc()的拦截处理。在此，每当捕获到系统各线程发出的任何鼠标消息后首先获取当前鼠标所在位置下的窗口句柄，并进一步通过GetWindowText()函数获取到窗口标题。在处理函数完成后，通过CallNextHookEx()函数将事件传递到钩子列表中的下一个钩子处理函数：

LRESULT WINAPI MouseProc(int nCode,WPARAM wParam,LPARAM lParam)
{
LPMOUSEHOOKSTRUCT pMouseHook=(MOUSEHOOKSTRUCT FAR *) lParam;
if(nCode>=0)
{
HWND glhTargetWnd=pMouseHook->hwnd; 
//取目标窗口句柄 
HWND ParentWnd=glhTargetWnd; 
while(ParentWnd !=NULL)
{
glhTargetWnd=ParentWnd; 
//取应用程序主窗口句柄 
ParentWnd=GetParent(glhTargetWnd); 
} 
if(glhTargetWnd!=glhPrevTarWnd) 
{ 
char szCaption[100]; 
//取目标窗口标题 
GetWindowText(glhTargetWnd,szCaption,100); 
……
} 
}
//继续传递消息 
return CallNextHookEx((HHOOK)glhHook,nCode,wParam,lParam); 
} 


　　最后，调用UnhookWindowsHookEx()函数完成对钩子的卸载：

void StopHook()
{
……
UnhookWindowsHookEx((HHOOK)glhHook);
} 


　　现在完成的是鼠标钩子的动态链接库，经过编译后需要经应用程序的调用才能实现对当前系统下各线程间鼠标消息的拦截处理。这部分同普通动态链接库的使用没有任何区别，在将其加载到进程后，首先调用动态链接库的StartHook()函数安装好钩子，此时即可对系统下的鼠标消息实施拦截处理，在动态链接库被卸载即终止鼠标钩子时通过动态链接库中的StopHook()函数卸载鼠标钩子。

　　经上述编程，在安装好鼠标钩子后，鼠标在移动到系统任意窗口上时，马上就会通过对鼠标消息的拦截处理而获取到当前窗口的标题。实验证明此鼠标钩子的安装、使用和卸载过程是正确的。

　　四、小结

　　钩子，尤其是系统钩子具有相当强大的功能，通过这种技术可以对几乎所有的Windows系统消息和事件进行拦截处理。这种技术广泛应用于各种自动监控系统对进程外消息的监控处理。本文只对钩子的一些基本原理和一般的使用方法做了简要的探讨，感兴趣的读者完全可以在本文所述代码基础之上用类似的方法实现对诸如键盘钩子、外壳钩子等其他类型钩子的安装与使用。本文所述代码在Windows 98下由Microsoft Visual C++ 6.0编译通过。

Hook机制

一、基本概念：

 

    钩子(Hook)，是Windows消息处理机制的一个平台,应用程序可以在上面设置子程以监视指定窗口的某种消息，而且所监视的窗口可以是其他进程所创建的。当消息到达后，在目标窗口处理函数之前处理它。钩子机制允许应用程序截获处理window消息或特定事件。

 

    钩子实际上是一个处理消息的程序段，通过系统调用，把它挂入系统。每当特定的消息发出，在没有到达目的窗口前，钩子程序就先捕获该消息，亦即钩子函数先得到控制权。这时钩子函数即可以加工处理（改变）该消息，也可以不作处理而继续传递该消息，还可以强制结束消息的传递。

 

二、运行机制：

 

1、钩子链表和钩子子程：

 

    每一个Hook都有一个与之相关联的指针列表，称之为钩子链表，由系统来维护。这个列表的指针指向指定的、应用程序定义的、被Hook子程调用的回调函数，也就是该钩子的各个处理子程。当与指定的Hook类型关联的消息发生时，系统就把这个消息传递到Hook子程。一些Hook子程可以只监视消息，或者修改消息，或者停止消息的前进，避免这些消息传递到下一个Hook子程或者目的窗口。最近安装的钩子放在链的开始，而最早安装的钩子放在最后，也就是后加入的先获得控制权。

 

       Windows 并不要求钩子子程的卸载顺序一定得和安装顺序相反。每当有一个钩子被卸载，Windows 便释放其占用的内存，并更新整个Hook链表。如果程序安装了钩子，但是在尚未卸载钩子之前就结束了，那么系统会自动为它做卸载钩子的操作。

 

    钩子子程是一个应用程序定义的回调函数(CALLBACK Function),不能定义成某个类的成员函数（#add static 成员函数则可），只能定义为普通的C函数。用以监视系统或某一特定类型的事件，这些事件可以是与某一特定线程关联的，也可以是系统中所有线程的事件。

 

    钩子子程必须按照以下的语法：

    LRESULT CALLBACK HookProc

       (

              int nCode,

          WPARAM wParam,

          LPARAM lParam

     );

HookProc是应用程序定义的名字。

 

nCode参数是Hook代码，Hook子程使用这个参数来确定任务。这个参数的值依赖于Hook类型，每一种Hook都有自己的Hook代码特征字符集。

wParam和lParam参数的值依赖于Hook代码，但是它们的典型值是包含了关于发送或者接收消息的信息。

 

2、钩子的安装与释放：

 

    使用API函数SetWindowsHookEx()把一个应用程序定义的钩子子程安装到钩子链表中。SetWindowsHookEx函数总是在Hook链的开头安装Hook子程。当指定类型的Hook监视的事件发生时，系统就调用与这个Hook关联的Hook链的开头的Hook子程。每一个Hook链中的Hook子程都决定是否把这个事件传递到下一个Hook子程。Hook子程传递事件到下一个Hook子程需要调用CallNextHookEx函数。

   

HHOOK SetWindowsHookEx(

　　　　　int idHook,      // 钩子的类型，即它处理的消息类型

　　　　　HOOKPROC lpfn,   // 钩子子程的地址指针。如果dwThreadId参数为0

                        // 或是一个由别的进程创建的线程的标识，

                        // lpfn必须指向DLL中的钩子子程。

                        // 除此以外，lpfn可以指向当前进程的一段钩子子程代码。

                        // 钩子函数的入口地址，当钩子钩到任何消息后便调用这个函数。

　　　　　HINSTANCE hMod, // 应用程序实例的句柄。标识包含lpfn所指的子程的DLL。

                        // 如果dwThreadId 标识当前进程创建的一个线程，

                        // 而且子程代码位于当前进程，hMod必须为NULL。

                        // 可以很简单的设定其为本应用程序的实例句柄。

　　　　　DWORD dwThreadId // 与安装的钩子子程相关联的线程的标识符。

                        // 如果为0，钩子子程与所有的线程关联，即为全局钩子。

　　　　　            );

　　函数成功则返回钩子子程的句柄，失败返回NULL。

 

　　以上所说的钩子子程与线程相关联是指在一钩子链表中发给该线程的消息同时发送给钩子子程，且被钩子子程先处理。

 

    在钩子子程中调用得到控制权的钩子函数在完成对消息的处理后，如果想要该消息继续传递，那么它必须调用另外一个SDK中的API函数CallNextHookEx来传递它，以执行钩子链表所指的下一个钩子子程。这个函数成功时返回钩子链中下一个钩子过程的返回值，返回值的类型依赖于钩子的类型。这个函数的原型如下：

 

LRESULT CallNextHookEx

                     (

                            HHOOK hhk;

                            int nCode;

                            WPARAM wParam;

                            LPARAM lParam;

                      );

                    

hhk为当前钩子的句柄，由SetWindowsHookEx()函数返回。

NCode为传给钩子过程的事件代码。

wParam和lParam 分别是传给钩子子程的wParam值，其具体含义与钩子类型有关。

             

    钩子函数也可以通过直接返回TRUE来丢弃该消息，并阻止该消息的传递。否则的话，其他安装了钩子的应用程序将不会接收到钩子的通知而且还有可能产生不正确的结果。

 

    钩子在使用完之后需要用UnHookWindowsHookEx()卸载，否则会造成麻烦。释放钩子比较简单，UnHookWindowsHookEx()只有一个参数。函数原型如下：

 

UnHookWindowsHookEx

              (

              HHOOK hhk;

              );

函数成功返回TRUE，否则返回FALSE。

 

3、一些运行机制：

 

    在Win16环境中，DLL的全局数据对每个载入它的进程来说都是相同的；而在Win32环境中，情况却发生了变化，DLL函数中的代码所创建的任何对象（包括变量）都归调用它的线程或进程所有。当进程在载入DLL时，操作系统自动把DLL地址映射到该进程的私有空间，也就是进程的虚拟地址空间，而且也复制该DLL的全局数据的一份拷贝到该进程空间。也就是说每个进程所拥有的相同的DLL的全局数据，它们的名称相同，但其值却并不一定是相同的，而且是互不干涉的。

      

       因此，在Win32环境下要想在多个进程中共享数据，就必须进行必要的设置。在访问同一个Dll的各进程之间共享存储器是通过存储器映射文件技术实现的。也可以把这些需要共享的数据分离出来，放置在一个独立的数据段里，并把该段的属性设置为共享。必须给这些变量赋初值，否则编译器会把没有赋初始值的变量放在一个叫未被初始化的数据段中。

 

       #pragma data_seg预处理指令用于设置共享数据段。例如：

#pragma data_seg("SharedDataName")

HHOOK hHook=NULL;

#pragma data_seg()

       在#pragma data_seg("SharedDataName")和#pragma data_seg()之间的所有变量 将被访问该Dll的所有进程看到和共享。

 

    当进程隐式或显式调用一个动态库里的函数时，系统都要把这个动态库映射到这个进程的虚拟地址空间里(以下简称"地址空间")。这使得DLL成为进程的一部分，以这个进程的身份执行，使用这个进程的堆栈。

 

4、系统钩子与线程钩子：

 

    SetWindowsHookEx()函数的最后一个参数决定了此钩子是系统钩子还是线程钩子。

   

    线程勾子用于监视指定线程的事件消息。线程勾子一般在当前线程或者当前线程派生的线程内。

   

    系统勾子监视系统中的所有线程的事件消息。因为系统勾子会影响系统中所有的应用程序，所以勾子函数必须放在独立的动态链接库(DLL) 中。系统自动将包含"钩子回调函数"的DLL映射到受钩子函数影响的所有进程的地址空间中，即将这个DLL注入了那些进程。

 

几点说明：

 （1）如果对于同一事件（如鼠标消息）既安装了线程勾子又安装了系统勾子，那么系统会自动先调用线程勾子，然后调用系统勾子。

 

 （2）对同一事件消息可安装多个勾子处理过程，这些勾子处理过程形成了勾子链。当前勾子处理结束后应把勾子信息传递给下一个勾子函数。

 

 （3）勾子特别是系统勾子会消耗消息处理时间，降低系统性能。只有在必要的时候才安装勾子，在使用完毕后要及时卸载。

 

三、钩子类型

 

    每一种类型的Hook可以使应用程序能够监视不同类型的系统消息处理机制。下面描述所有可以利用的Hook类型。

 

1、WH_CALLWNDPROC和WH_CALLWNDPROCRET Hooks

 

    WH_CALLWNDPROC和WH_CALLWNDPROCRET Hooks使你可以监视发送到窗口过程的消息。系统在消息发送到接收窗口过程之前调用WH_CALLWNDPROC Hook子程，并且在窗口过程处理完消息之后调用WH_CALLWNDPROCRET Hook子程。

 

    WH_CALLWNDPROCRET Hook传递指针到CWPRETSTRUCT结构，再传递到Hook子程。CWPRETSTRUCT结构包含了来自处理消息的窗口过程的返回值，同样也包括了与这个消息关联的消息参数。

 

2、WH_CBT Hook

 

    在以下事件之前，系统都会调用WH_CBT Hook子程，这些事件包括：

    1. 激活，建立，销毁，最小化，最大化，移动，改变尺寸等窗口事件；

    2. 完成系统指令；

    3. 来自系统消息队列中的移动鼠标，键盘事件；

    4. 设置输入焦点事件；

    5. 同步系统消息队列事件。

   

    Hook子程的返回值确定系统是否允许或者防止这些操作中的一个。

 

3、WH_DEBUG Hook

 

    在系统调用系统中与其他Hook关联的Hook子程之前，系统会调用WH_DEBUG Hook子程。你可以使用这个Hook来决定是否允许系统调用与其他Hook关联的Hook子程。

 

4、WH_FOREGROUNDIDLE Hook

 

    当应用程序的前台线程处于空闲状态时，可以使用WH_FOREGROUNDIDLE Hook执行低优先级的任务。当应用程序的前台线程大概要变成空闲状态时，系统就会调用WH_FOREGROUNDIDLE Hook子程。

 

5、WH_GETMESSAGE Hook

 

    应用程序使用WH_GETMESSAGE Hook来监视从GetMessage or PeekMessage函数返回的消息。你可以使用WH_GETMESSAGE Hook去监视鼠标和键盘输入，以及其他发送到消息队列中的消息。

 

6、WH_JOURNALPLAYBACK Hook

 

    WH_JOURNALPLAYBACK Hook使应用程序可以插入消息到系统消息队列。可以使用这个Hook回放通过使用WH_JOURNALRECORD Hook记录下来的连续的鼠标和键盘事件。只要WH_JOURNALPLAYBACK Hook已经安装，正常的鼠标和键盘事件就是无效的。WH_JOURNALPLAYBACK Hook是全局Hook，它不能象线程特定Hook一样使用。WH_JOURNALPLAYBACK Hook返回超时值，这个值告诉系统在处理来自回放Hook当前消息之前需要等待多长时间（毫秒）。这就使Hook可以控制实时事件的回放。WH_JOURNALPLAYBACK是system-wide local hooks，它們不會被注射到任何行程位址空間。

 

7、WH_JOURNALRECORD Hook

 

    WH_JOURNALRECORD Hook用来监视和记录输入事件。典型的，可以使用这个Hook记录连续的鼠标和键盘事件，然后通过使用WH_JOURNALPLAYBACK Hook来回放。WH_JOURNALRECORD Hook是全局Hook，它不能象线程特定Hook一样使用。WH_JOURNALRECORD是system-wide local hooks，它們不會被注射到任何行程位址空間。

 

8、WH_KEYBOARD Hook

 

    在应用程序中，WH_KEYBOARD Hook用来监视WM_KEYDOWN and WM_KEYUP消息，这些消息通过GetMessage or PeekMessage function返回。可以使用这个Hook来监视输入到消息队列中的键盘消息。

 

9、WH_KEYBOARD_LL Hook

 

    WH_KEYBOARD_LL Hook监视输入到线程消息队列中的键盘消息。

 

10、WH_MOUSE Hook

 

    WH_MOUSE Hook监视从GetMessage 或者 PeekMessage 函数返回的鼠标消息。使用这个Hook监视输入到消息队列中的鼠标消息。

 

11、WH_MOUSE_LL Hook

 

    WH_MOUSE_LL Hook监视输入到线程消息队列中的鼠标消息。

 

12、WH_MSGFILTER 和 WH_SYSMSGFILTER Hooks

 

    WH_MSGFILTER 和 WH_SYSMSGFILTER Hooks使我们可以监视菜单，滚动条，消息框，对话框消息并且发现用户使用ALT+TAB or ALT+ESC 组合键切换窗口。WH_MSGFILTER Hook只能监视传递到菜单，滚动条，消息框的消息，以及传递到通过安装了Hook子程的应用程序建立的对话框的消息。WH_SYSMSGFILTER Hook监视所有应用程序消息。

   

    WH_MSGFILTER 和 WH_SYSMSGFILTER Hooks使我们可以在模式循环期间过滤消息，这等价于在主消息循环中过滤消息。

   

通过调用CallMsgFilter function可以直接的调用WH_MSGFILTER Hook。通过使用这个函数，应用程序能够在模式循环期间使用相同的代码去过滤消息，如同在主消息循环里一样。

 

13、WH_SHELL Hook

 

    外壳应用程序可以使用WH_SHELL Hook去接收重要的通知。当外壳应用程序是激活的并且当顶层窗口建立或者销毁时，系统调用WH_SHELL Hook子程。

      WH_SHELL 共有５钟情況：

1. 只要有个top-level、unowned 窗口被产生、起作用、或是被摧毁；

2. 当Taskbar需要重画某个按钮；

3. 当系统需要显示关于Taskbar的一个程序的最小化形式；

4. 当目前的键盘布局状态改变；

5. 当使用者按Ctrl+Esc去执行Task Manager（或相同级别的程序）。

 

    按照惯例，外壳应用程序都不接收WH_SHELL消息。所以，在应用程序能够接收WH_SHELL消息之前，应用程序必须调用SystemParametersInfo function注册它自己。

关于钩子HOOK函数的详细说明

钩子HOOK函数是Windows消息处理机制的一部分，通过设置“钩子”，应用程序可以在系统级对所有消息、事件进行过滤，访问在正常情况下无法访问的消息。当然，这么做也是需要付出一定的代价的。由于多了这么一道处理过程，系统性能会受到一定的影响，所以大家在必要的时候才使用“钩子”，并在使用完毕及时将其删除。

　　首先让我们看看HOOK函数是怎么安装、调用和删除的。应用程序通常是调用SetWindowsHookEx()函数来进行安装的，其函数的原型如下：

 

SetWindowsHookEx(

 

Int idHook;

 

HOOKPROC lpfn;

 

HINSTANCE hMod;

 

DWORD dwThreadId;

 

);

 

参数说明：

 

idHook 是”钩子”的类型，”钩子”的类型一共有13种，具体如下表：

 

“钩子”类型

解释

 

WH_CALLWNDPROC

系统将消息发送到指定窗口之前的“钩子”

 

WH_CALLWNDPROCRET

消息已经在窗口中处理的“钩子”

 

WH_CBT

基于计算机培训的“钩子”

 

WH_DEBUG

差错“钩子”

 

WH_FOREGROUNDIDLE

前台空闲窗口“钩子”

 

WH_GETMESSAGE

接收消息投递的“钩子”

 

WH_JOURNALPLAYBACK

回放以前通过WH_JOURNALRECORD“钩子”记录的输入消息

 

WH_JOURNALRECORD

输入消息记录“钩子”

 

WH_KEYBOARD

键盘消息“钩子”

 

WH_MOUSE

鼠标消息“钩子”

 

WH_MSGFILTER

对话框、消息框、菜单或滚动条输入消息“钩子”

 

WH_SHELL

外壳“钩子”

 

WH_SYSMSGFILTER

系统消息“钩子”

 

 

lpfn 指向“钩子”过程的指针。

 

hMod “钩子”过程所在模块的句柄。

 

dwThreadId “钩子”相关线程的标识。

 

　　通常我们都是把”钩子”做成动态链接库，这样的好处是可以是系统内的每个进程访问。但是也可以在系统中直接调用，我的建议还是用动态库。如果用动态库的话，那么SetWindowsHookEx()中的第三个参数就是该动态链接库模块的句柄；对于一个只供单个进程访问的”钩子”，可以将其”钩子”过程放在安装”钩子”的同一个线程内，此时SetWindowsHookEx()中的第三个参数为该线程的hInstance。安装”钩子”有两种方法：1.你可以把他做成动态连接库文件，和程序一起编译。2.你可以在程序的任何地方直接调用。第2种的方法太麻烦，我不建议用，在这里我就不详细介绍啦。相比之下第1种比较简单。其”钩子”的过程都在动态链接库内完成。SetWindowsHookEx()函数是一个安装函数，如故一个由某种类型的”钩子”监视的事件发生，系统就会调用相应类型的”钩子”链开始处的”钩子”过程，”钩子”链的每个”钩子”过程都要考虑是否把事件传递给下一个”钩子”过程。如果要传递的话，就要调用CallNestHookEx()函数。这个函数成功时返回”钩子”链中下一个”钩子”过程的返回值，返回值的类型依赖于”钩子”的类型。这个函数的原型如下：

 

LRESULT CallNextHookEx(

 

HHOOK hhk;

 

int nCode;

 

WPARAM wParam;

 

LPARAM lParam;

 

);

 

　　其中hhk为当前”钩子”的句柄，由SetWindowsHookEx()函数返回。NCode为传给”钩子”过程的事件代码。wParam和lParam 分别是传给”钩子”过程的wParam值，其具体含义与”钩子”类型有关。

 

释放”钩子”

 

　　释放”钩子”比较简单，他只有一个参数。当不在需要”钩子”时，应及时将其释放。他是调用UnhookWindowsHookEx()函数来实现的，函数原型如下：

 

UnhookWindowsHookEx(

 

HHOOK hhk;

 

);

 

函数成功返回TRUE，否则返回FALSE。

 

如果我这样讲您还是不明白的话，请看下面给出的一些典型“钩子”代码和说明。

 

LRESULT WINAPI CallWndProc(int nCode,WPARAM wParam,LPARAM lParam)

 

{

 

if(nCode<0)

 

return CallNextHookEx(NULL,nCode,wParam,lParam);

 

switch(nCode)

 

{

 

case HC_ACTION:

 

//”钩子”程序要处理什么的代码

 

break;

 

default:

 

break;

 

}

 

return CallNextHookEx(NULL,nCode,wParam,lParam);

 

}

 

　　这是WH_CALLWNDPROC”钩子”的代码，此”钩子”允许程序监视由函数SendMessage发送给窗口过程的消息。系统将消息发送到目的窗口之前调用WH_CALLWNDPROC “钩子”过程。

 

LRESULT WINAPI CallwndProc(int nCode,WPARAM,wParam,LPARAM lParam)

 

{

 

if(nCode<0) return callNextHookEx(NULL,nCode,wParam,lParam);

 

switch(nCode)

 

{

 

case HC_ACTION:

 

switch(wParam)

 

{

 

Case PM_REMOVE:

 

//某个应用程序调用了GetMessage函数或者是带PM_REMOVE参数的//PeekMessage函数，从消息队列中移去一个消息。

 

Break;

 

Case PM_NOREMOVE:

 

//某个应用程序以PM_NOREMOVE为参数调用PeekMessage函数

 

break;

 

default:

 

break;

 

}

 

break;

 

default:

 

break;

 

}

 

return CallNextHookEx(NULL,nCode,wParam,lParam);

 

}

 

　　这是调用WH_GETMESSAGE的函数，此函数允许应用程序监视函数GetMessage和 PeekMessage返回的消息。应用程序可以用钩子WH_GETMESSAGE来监视鼠标和键盘的输入以及其他系统发送到消息队列中的消息。

 

LRESULT CALLBACK CBTProc(int nCode,WPARAM wParam,LPARAM lParam)

 

{

 

If(nCode<0) Return callNextHookEx(NULL,nCode,wParam,lParam);

 

Switch(nCode)

 

{

 

case HCBT_ACTIVATE:

 

//系统将激活一个窗口

 

break;

 

case HCBT_CLICKSKIPPED:

 

//系统从系统消息队列中移去一个鼠标消息

 

break;

 

case HCBT_CREATEWND:

 

//系统将创建一个窗口

 

break;

 

case HCBT_DESTROYWND:

 

//系统将关闭一个窗口

 

break;

 

case HCBT_KEYSKIPPED:

 

//系统从系统消息队列中移去一个键盘消息

 

break;

 

case HCBT_MINMAX:

 

//系统将最大化或最小化一个窗口

 

break;

 

case HCBT_MOVESIZE:

 

//系统将移动一个窗口或改变一个窗口的大小

 

break;

 

case HCBT_QS:

 

//系统在系统消息队列中检索到WM_QUEUESYNC消息

 

break;

 

case HCBT_SETFOCUS:

 

//系统设置键盘输入窗口

 

break;

 

case HCBT_SYSCOMMAND:

 

//将要执行一个系统命令

 

break;

 

default:

 

//可以添加其他代码

 

break;

 

}

 

return CallNextHookEx(NULL,nCode,wParam,lParam);

 

}

 

　　每种”钩子”类型都有其对应的函数，这些函数的参数都是一样的，有兴趣的朋友可以在ＭＳＤＮ中找的他们的详细说明。

 

下面我给出一个完整的”钩子”安装和删除的过程的代码。

 

#include "stdafx.h"

 

#include "hook.h"

 

HINSTANCE hInstance;

 

HHOOK hhkKeyboard;

 

BOOL APIENTRY DllMain( HANDLE hModule,DWORD ul_reason_for_call, LPVOID lpReserved)

 

{

 

switch (ul_reason_for_call)

 

{

 

case DLL_PROCESS_ATTACH:

 

case DLL_THREAD_ATTACH:

 

case DLL_THREAD_DETACH:

 

case DLL_PROCESS_DETACH:

 

break;

 

}

 

hInstance=(HINSTANCE)hModule;

 

return TRUE;

 

}

 

LRESULT KeyboardProc(int nCode,WPARAM wParam,LPARAM lParam)

 

{

 

MessageBeep(-1);

 

return CallNextHookEx(hhkKeyboard,nCode,wParam,lParam);

 

}

 

HOOK_API BOOL EnableKeyboardCapture()

 

{

 

if(!(hhkKeyboard=SetWindowsHookEx(WH_KEYBOARD,(HOOKPROC)KeyboardProc,hInstance,0)))

 

return FALSE;

 

return TRUE;

 

}

 

HOOK_API BOOL DisableKeyboardCapture()

 

{

 

return UnhookWindowsHookEx(hhkKeyboard);

 

}

 

注意：这是一个动态链接库文件。

 

在程序中要想调用“钩子”的时候，有EnableKeyboardCapture()函数就可以啦，但你按键的时候就回发出声音。

Win32的Hook一些要点

如果你看msdn中的setwindowshookex函数说明,你会发现,ms告诉你如果你想

hook全局数据,你必须把hook代码写在dll中,如果你的hook代码在.exe中,

则你只能hook本进程的数据.

 

你想过这是为什么吗?

 

win32抛弃了win16的全局内存的概念,每个进程有自己独立的内存空间,

并且不受其他进程影响.这样一来所有代码都只能访问局部资源,但很显然有些

应用必须是全局的,比如你的hook,所以ms必须提供一种折衷的安全的方法.好

在windows中的dll正好可以解决这个问题.

 

dll是一种代码摸块,它可以被映射进不同的进程空间,具体方法就不多谈了,如果

你有兴趣我们以后讨论.

 

基于以上原因,ms要求我们把全局hook放进dll,以便由win32映射进不同的进程

空间,每个进程空间中的hook代码只负责处理该进程中的数据.所有的局部

之和就是全局,这样既维护了进程空间的独立性,又可以处理全局数据.

 

你的问题是想hook一个进程的数据,但又不是本进程,所以你必须让win32帮你把

hook代码放到其他进程空间,又要有所选择.

win32在映射hook代码到其他进程空间中的方法很简单,就是在另一个进程中调用

Loadlibrary

 

只有Loadlibrary成功以后才能hook到该进程的数据.

如果某个进程执行loadlibrary失败,那么我们将无法hook到该进程的数据.

 

loadlibrary失败除了系统原因外,还有个重要因素就是dllmain没有返回TRUE!

 

根据以上理论,我们只要在 非指定程序 装载hook dll时让dllmain返回false,即可达到

你的目的了.

 

所以你需要在hook dll中添加下面的代码"

 

 

BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)

{

switch(dwReason) {

case DLL_PROCESS_ATTACH:

    ............

   if(不是指定程序)

     return FALSE

break;

.................

........

}

    return TRUE;

}

 

 

 

这里有个例子：

ftp://pub:pub@211.157.101.157/Hook和hotKey.rar

ftp://pub:pub@211.157.101.157/Hook和hotKey源码.rar

 

利用键盘钩子开发按键发音程序

作者:GDGF

一、前言

一日，看见我妈正在用电脑练习打字，频频低头看键盘，我想：要是键盘能发音的话，不就可以方便她养成"盲打"的好习惯吗？光想不做可不行，开始行动(您可千万别急着去拿工具箱啊^_^)...

按键能发音，其关键就是让程序能够知道当前键盘上是哪个键被按下，并播放相应的声音,自己的程序当然不在话下，那么其它程序当前按下哪个键如何得知呢？利用键盘钩子便可以很好地解决。

 

下载本文的全部源代码 大小:552K

 

二、挂钩(HOOK)的基本原理

WINDOWS调用挂接的回调函数时首先会调用位于函数链首的函数，我们只要将自己的回调函数置于链首，该回调函数就会首先被调用。那么如何将我们自己的回调函数置于函数链的链首呢？函数SetWindowsHookEx()实现的就是该功能。我们首先来看一下SetWindowsHookEx函数的原型:

 

 

HHOOK SetWindowsHookEx(

 int idHook,      

 HOOKPROC lpfn,    

 HINSTANCE hMod,   

 DWORD dwThreadId 

);

第一个参数:指定钩子的类型，有WH_MOUSE、WH_KEYBOARD等十多种(具体参见MSDN)

第二个参数:标识钩子函数的入口地址

第三个参数:钩子函数所在模块的句柄；

第四个参数:钩子相关函数的ID用以指定想让钩子去钩哪个线程，为0时则拦截整个系统的消息。

 

另外需要注意的是为了捕获所有事件，挂钩函数应该放在动态链接库DLL中。

 

三、具体实现

理论的话就不多说了，运行VC++6.0，新建一个MFC AppWizard(dll)工程，命名为Hook，使用默认的创建DLL类型的选项，也就是使用共享MFC DLL，点击完成后开始编写代码:

 

(1)在Hook.h中定义全局函数

BOOL installhook(); //钩子安装函数

LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam);//挂钩函数

 

(2)在Hook.cpp文件的#endif下添加定义全局变量Hook的代码:

static HHOOK hkb=NULL;

HINSTANCE hins; //钩子函数所在模块的句柄

(3)添加核心代码

BOOL installhook()

{

    hkb=SetWindowsHookEx(WH_KEYBOARD,(HOOKPROC)KeyboardProc,hins,0);

    return TRUE;

}

第一个参数指定钩子的类型，因为我们只用到键盘操作所以设定为WH_KEYBOARD；第二个参数将钩子函数的入口地址指定为KeyboardProc，当钩子钩到任何消息后便调用这个函数,即当不管系统的哪个窗口有键盘输入马上会引起KeyboardProc的动作；第三个参数是钩子函数所在模块的句柄；最后一个参数是钩子相关函数的ID用以指定想让钩子去钩哪个线程，为0时则拦截整个系统的消息；

现在，就开始定义当键盘上的键按下时程序要做什么了~

KeyboardProc动作:

 

LRESULT CALLBACK KeyboardProc(int nCode,WPARAM wParam,LPARAM lParam)

{

    if(((DWORD)lParam&0x40000000) && (HC_ACTION==nCode))

    {

       switch(wParam) //键盘按键标识

        {

        case ''1'':sndPlaySound("1.wav",SND_ASYNC);break; //当数字键1被按下

         case ''2'':sndPlaySound("2.wav",SND_ASYNC);break;

        case ''3'':sndPlaySound("3.wav",SND_ASYNC);break;

        case ''4'':sndPlaySound("4.wav",SND_ASYNC);break;

        ....

        case ''A'':sndPlaySound("a.wav",SND_ASYNC);break; //当字母键A被按下

         case ''B'':sndPlaySound("b.wav",SND_ASYNC);break;

        case ''C'':sndPlaySound("c.wav",SND_ASYNC);break;

        case ''D'':sndPlaySound("d.wav",SND_ASYNC);break;

        ....

        }

     }

     LRESULT RetVal = CallNextHookEx( hkb, nCode, wParam, lParam );

     return RetVal;

}

上面的代码中我们用播放声音做为按键被按下后的动作，API函数sndPlaySound的第一个参数定义的声音文件的绝对路径(比如要播放C盘下的a.wav，就定义成"C:\\a.wav")；第二参数定义播放模式，SND_ASYNC模式可以及时地释放正在播放的声音文件，立刻停止当前声音的播放转去播放新的声音,这样在我们连续击键时就不会有阻塞感了.为了执行sndPlaySound函数，必须在Hook.cpp的文件头加上： #include "mmsystem.h"

并且点击VC++菜单上的“工程”-“设置”进入Link属性页，在L对象/库模块下输入：winmm.lib后确定即可.

 

(4)添加输出标识

在Hook.def的末尾添加

 

 

installhook

KeyboardProc

短短的四步，键盘钩子的制作算是完成了，编译生成后的DLL文件就可以自由的用别的程序来调用了.

在程序中如何调用DLL呢？那就简单了.再用VC++6.0新建一个MFC AppWizard(exe)工程，命名为KeySound，点击"确定"后选择程序类型为对话框，直接点击确定即可.

在KeySoundDlg.cpp文件中的OnInitDialog()初始化函数的CDialog::OnInitDialog();下面添加:

 

//阻止程序反复驻留内存，也为了防止有两个程序同时读取DLL而发生错误.

 

 

CreateMutex(NULL, FALSE, "KeySound");

if(GetLastError()==ERROR_ALREADY_EXISTS)

   OnOK();

 

//读取DLL

static HINSTANCE hinstDLL;

typedef BOOL (CALLBACK *inshook)();

inshook instkbhook;

if(hinstDLL=LoadLibrary((LPCTSTR)"Hook.dll"))

{

    instkbhook=(inshook)GetProcAddress(hinstDLL,"installhook"); 

    instkbhook();

}

else

{

    MessageBox("当前目录找不到Hook.dll文件，程序初始化失败");

    OnOK();

}

将编译生成后的KeySound.exe和Hook.dll放在同一目录下，定义好声音文件，运行KeySound.exe后打开记事本或写字板，体验一下系统为您即时快速地朗读您按下的每一个键的快感吧^-^

 

有一点必须说明，标准键盘有101个键，您想让多少键发声音，就必须在上面的KeyboardProc动作里定义多少个键，常用的10个数字键和26个英文字母不会给您带来太大的困难，只要相应的''A''对应A键,''1''对应1键就可以，但如果您希望能让更多的键都有各种特色音乐的话，很可能会遇到一些键盘编码上的麻烦，比如ESC键就不能简单的用''ESC''来搞定了，得用VK_ESCAPE，又比如Alt键得用VK_MENU来定义，没有个键盘编码表的话会令人相当头疼，这里我介绍一种让程序来告诉您键盘按键名称的方法:

为一个工程添加PreTranslateMessage映射，添加如下代码:

 

 

char KeyName[50];

ZeroMemory(KeyName,50);

if(pMsg -> message == WM_KEYDOWN)

{

   GetKeyNameText(pMsg->lParam,KeyName,50);

   MessageBox(KeyName);

}

那么当程序窗口显示在面前时按下某个键，就会弹出一个消息显示该键的名称，然后用''''包起来就可以了，比如逗号句号，就是'',''和''.''，简单吧:)

到此就全部完成了按键发音程序的编写，通过改变声音文件的名称而不用改动程序本身就可以达到更换按键声音的目的了，只是有个遗憾，声音文件在硬盘中的位置不能变更，从C盘换移动D盘程序就不能播放了，怎么样才能灵活的读取声音文件呢？可以用API函数GetModuleFileName来得到程序所在的目录，具体实现方法如下：

(1)在Hook.h的public:下面添加:

 

 

BOOL InitInstance(); //初始化函数

(2)在Hook.cpp的#endif下添加定义全局变量的代码:

 

 

char szBuf[256];

char *p;

CString msg;

(3)在Hook.cpp中适当位置添加:

 

 

BOOL CHookApp::InitInstance ()

{

   hins=AfxGetInstanceHandle();

   GetModuleFileName(AfxGetInstanceHandle( ),szBuf,sizeof(szBuf));

   p = szBuf;

   while(strchr(p,''\\''))

   {

        p = strchr(p,''\\'');

        p++;

   }

   *p = ''\0'';

   msg=szBuf;

   return TRUE;

}

(4)新建一个文件夹并命名为Sound;

 

(5)改变声音文件物理位置定义方式

case ''1'':sndPlaySound(msg+"sound\\1.wav",SND_ASYNC);break;

msg是得到程序当前所在目录，加上后面的代码就是指播放当前目录下的Sound目录里的1.wav文件，这样就将声音文件的绝对路径改成了灵活的相对路径.您只要把KeySound.exe,Hook.dll和Sound文件夹放在同一个文件夹下，以后只要搬动整个文件夹就能实现声音文件的任意移动了。

 

调试时需要注意：将Hook.dll、Sound目录放在KeySound.exe的执行目录下。假如编译链接的时候出现unresolved external symbol __imp__sndPlaySoundA@8 这样的信息，请在Project Settings中加入Winmm.lib 。

 

//////////////////////////////////////////////////////////////////////////////////////

《魔高一丈2.0》开发实例

作者:济南 宋悦

 

下载本文程序与代码

http://www.vckbase.com/code/downcode.asp?id=1578

一、开发背景:

 

我想大家都有过忙手忙脚最小化窗口（或关闭窗口）的经历吧！原因很简单——不想让突如其来的老板、老妈、老婆看到我们电脑屏幕上正在显示的游戏、日记、MM:-) 等属于个人隐私的东东。 如果能做一个程序在后台运行，当我们发出一个特殊的输入事件（我选择了鼠标左、右键同时按下）时，该程序就迅速隐藏正在显示的窗口，免去人工瞄准并按下每个窗口右上方的那个小得可怜的的最小化按扭之苦了。当危险解除再利用这个特殊事件使隐藏的窗口恢复。这对于像我这样小脑不太发达、心理素质又不过硬而又经常在老板的眼皮底下“悬崖骑马”的同志们来说是绝对有实战意义的。于是我做了这个“魔高一丈”以实现上述功能!

 

 

二、程序原理:

 

首先，我们得能截获鼠标左、右键同时按下去这个事件——这并不难——设一个标志变量当鼠标发出WM_LBUTTONDOWN并且又有WM_RBUTTONDOWN消息发出时把它置“1”罢了。而我要说明的是，这个“同时按下”只是一种宏观上的概念，鼠标是不会同时发出两个消息的。其次就是解决不管鼠标位于任何窗口之上都能在程序里截获（或者称为监听更准确）到鼠标发出的消息并加以过滤的问题了，这是很关键的。我用了钩子船长的那只钩子（Hook），而且是全局的鼠标钩子，它给了我们跟操作系统沟通的一个机会。许多比较有神秘感的程序（比如金山词霸的鼠标取词）都是用它实现的，稍后我将详细解释。最后就是剩下能得到可见的窗口的句柄（HANDLE）并根据其句柄显示、隐藏窗口的问题了，这也没什么难的有现成的API函数——EnumWindows和ShowWindow。你可以先运行一下我的程序（那个大五星，需要把它跟那个Mousehook.dll文件放在一个文件夹下）。当鼠标左右键一起按下时所有的窗口都隐藏了；再一次同时按下左右键又可恢复隐藏窗口；单击任务栏右下角（托盘）的图标可隐藏或显示本程序窗口。

 

三、开发步骤:

 

第0步、选用VC 6.0集成开发环境。

第1步、由于建立全局钩子必须把钩子函数放在DLL里面，所以我们选择MFC AppWizard(DLL)创建一个新的项目，命名为“Mousehook”，再选择选择MFC Extension DLL类型（为了方便嘛！）。为什么必须把全局钩子函数放在DLL里呢？这是因为系统会动态地调用你所添加的全局鼠标钩子，所有窗口消息数都会由于你添加了鼠标钩子而引起系统处理（何为处理？调用钩子函数也。）这必然需要操作系统能够从一个东东里动态地加入这段处理程序，而这个东东非DLL莫属。

第2步、在项目中加入Mousehook.h文件用以构造一个钩子类——CMousehook，具体如下：

 

class AFX_EXT_CLASS CMousehook:public CObject

{

public:

 CMousehook();

 ~CMousehook();

 BOOL starthook();//封装SetWindowsHookEx( int idHook, HOOK_PROC lpfn, HINSTANCE hMod,DWORD dwThreadID)用来安装钩子

 BOOL stophook(); //封装UnhookWindowsHookEx( HHOOK hhk )用来卸载钩子

 VOID SetCheck1(UINT i);//处理对话框的选择钩选框1

 VOID SetCheck2(UINT i);//处理对话框的选择钩选框2

 VOID SetCheck3(UINT i);//处理对话框的选择钩选框3

 static BOOL CALLBACK EnumWindowsProc(HWND hwnd,LPARAM lParam);//系统回调的钩子函数

 VOID UseForExit();//退出程序时恢复所有隐藏窗口

};

这里我想特别地提一下EnumWindowsProc函数前的CALLBACK跟static，对于CALLBACK我想给大家一个特别江湖的解释其就是：凡是由你设计而却由Windows系统调用的函数，统称callback函数。这些函数都有一定的类型，以配合Windows的调用操作。——引用台湾侯师傅的话。他还说，某些Windows API函数会要求以callback函数（的函数地址）作为其参数之一。我们这里用到的又比如 SetWindowsHookEx( int idHook, HOOK_PROC lpfn, HINSTANCE hMod,DWORD dwThreadID)的第二个参数。这种API通常会在进行某种行为之后或满足某种状态的情况下调用其参数中的callback函数。又由于系统在调用callback函数的时候并不会借助任何对象去调用该callback函数，所以在用类来封装callback函数时，需要用static来使callback函数能够独立于对象而又属于类的成员函数。明白了不？（啊？地球人都知道呀！太伤自尊了！）

 

第3步、在项目中加入Mousehook.cpp文件在CMousehook里封装其中加入必要的共享数据以及SetWindowsHookEx、UnhookWindowsHookEx等函数——这些API函数具体的参数的类型跟作用解释在程序代码的注释里有（网上也到处都有，我也是从网上抠下来的。一个声音高叫着——当然MSDN里也有。），而把它们写在文章里就不免有骗取稿费之嫌了。我只是想解释一下为什么需要使用一个共享的数据段，如下： #pragma data_seg("mydata")              //编译器识别的指令用以在虚拟内存中开辟一个数据段存放该指令下面的数据

 

HINSTANCE glhInstance=NULL;             //DLL实例（或者说模块）的句柄。

HHOOK glhHook=NULL;                     //鼠标钩子的句柄。

HWND GlobalWndHandle[100]={NULL,.....};//用来存放被隐藏的窗口的句柄，以数组的形式保存。

                                        //该数组必须初始化，原因见下文。我以“......”省略。

UINT Global_i=0;                       //用以在循环中序列化窗口数组的变量。

BOOL Condition1=0;                     //用以记录左键按下或释放的标志变量。

BOOL Condition2=0;                     //用以记录右键按下或释放的标志变量。

BOOL HideOrVisitableFlag=0;            //用以标识当再次有左、右键同时按下的情况发生时是隐藏还是显示窗口。

BOOL Check1=0;                         //用来表示控件Check1状态的标志变量。

BOOL Check2=0;                         //用来表示控件Check2状态的标志变量。

BOOL Check3=0;                         //用来表示控件Check3状态的标志变量。

 

#pragma data_seg()                      //与#pragma data_seg("mydata") 首尾呼应表示该数据段的结束。

加入上述数据段以后还应在项目里插入一个“Mousehook.def”文件,用："SECTIONS mydata READ WRITE SHARED"将mydata数据段设置为一个可读写的共享段。在程序里加入预编译指令，或在开发环境的项目设置里也可以达到设置数据段属性的目的，我就不一一赘述了。

我前面讲过，系统通过调用放在DLL中的钩子回调函数来实现全局钩（钩取所有窗口的鼠标消息），操作系统对DLL的操作仅仅是把DLL映射到需要它的进程的虚拟地址空间里去。也就是说，DLL函数中的代码所创建的任何对象（包括变量）都归调用它的线程或进程所有。“DLL在WIN32中什么都不拥有”——这句话很重要。比如我们在DLL里建立了一个变量a，而我们的这个DLL文件又被两个进程所调用，这两个进程的中都用到了a可这绝对是两个不同存储单元中存储的两个a，它们之间没有丝毫的联系。给其中一个赋值也绝对不会影响到另一个。而对于本程序的一些数据是需要在不同的进程中保持唯一的（也可以说是一致），比方说： HWND GlobalWndHandle[100]它是用来保存程序做了隐藏的窗口之句柄的数组。当程序运行，我在任意窗口A中同时按下了鼠标左、右键，由于设置了鼠标钩子，系统会调用DLL中的钩子处理函数截获消息并加以处理，即把目前的可见窗口隐藏并把窗口句柄保存到GlobalWndHandle[100]数组中以备将来显示之用。如果不把GlobalWndHandle[100]放到一个共享的数据段里，系统就会在目前我们截获鼠标消息的A窗口的进程的地址空间里开辟HWND GlobalWndHandle[100]来存储窗口句柄。这样对于其他进程就不能方便地得到这个进程存入GlobalWndHandle[100]数组的数据了。这时只能将GlobalWndHandle[100]等需要跨进程访问的变量数据放在一个共享的数据段里了。另外，需要特别注意——必须给这些变量赋初值（就象我在程序代码里傻呼呼地写了100个NULL一样。你可以不初始化这个数组试验一下，有助于你理解我上面的话），否则编译器会把没有赋初始值的变量放在一个叫未被初始化的数据段中。

 

第4步：编译生成dll文件，并用MFC AppWizard（exe）建立一个基于对话框的项目，在里面添加一个名为“Mousehook.h”的头文件其内容与dll项目中的“Mousehook.h”文件一致，打开菜单的“Project Settings”对话框在“Link”选项标签的“Object/library modules”编辑框里填入Mousehook.lib（此文件是与dll一起生成的，当编译一个隐式调用dll的exe时，lib文件起到提供dll引出函数接口地址的作用，如果此路径设置不正确程序是无法进行连接的）文件的存放路径。这样就可以放心使用dll里定义的CMousehook类的成员了。如下：

1 在HideWindowDlg.h中加入#include "MouseHook.h"并在CHideWindowDlg中定义一个CMousehook类对象hook。

2 在CHideWindowDlg::OnInitDialog()函数中加入hook.starthook()并初始化相关变量，这样当对话框初始时就会启动鼠标钩子。

3 在CHideWindowDlg::~CHideWindowDlg()函数中加入hook.stophook()。用以释放对话框对象时解除鼠标钩。

为了不忽略读者的智力水平我只对主要的代码进行了说明，其余有关托盘、Check控件的部分代码都比较传统也没什么好说明的。最后，编译成exe文件以后还须把Mousehook.dll文件拷贝到同exe相同的目录下才能正确运行exe。

 

临了，希望大家能对我上文中含糊、混沌的地方提出批评指正，也欢迎大家来信（me@sanlian.com.cn)切磋。