深入分析C#键盘勾子(Hook)拦截器,屏蔽键盘活动的详解

钩子(hook)，是windows消息处理机制的一个平台,应用程序可以在上面设置子程以监视指定窗口的某种消息，而且所监视的窗口可以是其他进程所创建的。当消息到达后，在目标窗口处理函数之前处理它。钩子机制允许应用程序截获处理window消息或特定事件。
钩子实际上是一个处理消息的程序段，通过系统调用，把它挂入系统。每当特定的消息发出，在没有到达目的窗口前，钩子程序就先捕获该消息，亦即钩子函数先得到控制权。这时钩子函数即可以加工处理（改变）该消息，也可以不作处理而继续传递该消息，还可以强制结束消息的传递。
运行机制
1、钩子链表和钩子子程：
每一个hook都有一个与之相关联的指针列表，称之为钩子链表，由系统来维护。这个列表的指针指向指定的，应用程 序定义的，被hook子程调用的回调函数，也就是该钩子的各个处理子程。当与指定的hook类型关联的消息发生时，系统就把这个消息传递到hook子程。 一些hook子程可以只监视消息，或者修改消息，或者停止消息的前进，避免这些消息传递到下一个hook子程或者目的窗口。最近安装的钩子放在链的开始， 而最早安装的钩子放在最后，也就是后加入的先获得控制权。

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

钩子子程是一个应用程序定义的回调函数(callback function),不能定义成某个类的成员函数，只能定义为普通的c函数。用以监视系统或某一特定类型的事件，这些事件可以是与某一特定线程关联的，也可以是系统中所有线程的事件。
钩子子程必须按照以下的语法：

lresult callbackhookproc
(
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函数。

hhooksetwindowshookex(
int idhook,      // 钩子的类型，即它处理的消息类型
hookproc lpfn,   // 钩子子程的地址指针。如果dwthreadid参数为0
      // 或是一个由别的进程创建的线程的标识，
      // lpfn必须指向dll中的钩子子程。
      // 除此以外，lpfn可以指向当前进程的一段钩子子程代码。
      // 钩子函数的入口地址，当钩子钩到任何消息后便调用这个函数。
hinstance hmod, // 应用程序实例的句柄。标识包含lpfn所指的子程的
dll。
      // 如果dwthreadid 标识当前进程创建的一个线程，
      // 而且子程代码位于当前进程，hmod必须为null。
      // 可以很简单的设定其为本应用程序的实例句柄。
dword dwthreadid // 与安装的钩子子程相关联的线程的标识符。
      // 如果为0，钩子子程与所有的线程关联，即为全局钩子。
            );

函数成功则返回钩子子程的句柄，失败返回null。
以上所说的钩子子程与线程相关联是指在一钩子链表中发给该线程的消息同时发送给钩子子程，且被钩子子程先处理。
在钩子子程中调用得到控制权的钩子函数在完成对消息的处理后，如果想要该消息继续传递，那么它必须调用另外一个 sdk中的api函数callnexthookex来传递它，以执行钩子链表所指的下一个钩子子程。这个函数成功时返回钩子链中下一个钩子过程的返回值， 返回值的类型依赖于钩子的类型。这个函数的原型如下：

lresultcallnexthookex
   (
    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预处理指令用于设置共享数据段。例如：

#pragmadata_seg("shareddataname")
hhook hhook=null;
#pragma data_seg()

在#pragma data_seg("shareddataname")和#pragma data_seg()之间的所有变量将被访问该dll的所有进程看到和共享。再加上一条指令#pragmacomment(linker,"/section:.shareddataname,rws"),那么这个数据节中的数据可以在所有dll的实例之间共 享。所有对这些数据的操作都针对同一个实例的，而不是在每个进程的地址空间中都有一份。
当进程隐式或显式调用一个动态库里的函数时，系统都要把这个动态库映射到这个进程的虚拟地址空间里(以下简称"地址空间")。这使得dll成为进程的一部分，以这个进程的身份执行，使用这个进程的堆栈。
4、系统钩子与线程钩子：
setwindowshookex()函数的最后一个参数决定了此钩子是系统钩子还是线程钩子。
线程勾子用于监视指定线程的事件消息。线程勾子一般在当前线程或者当前线程派生的线程内。
系统勾子监视系统中的所有线程的事件消息。因为系统勾子会影响系统中所有的应用程序，所以勾子函数必须放在独立的动态链接库(dll) 中。系统自动将包含"钩子回调函数"的dll映射到受钩子函数影响的所有进程的地址空间中，即将这个dll注入了那些进程。
几点说明：
（1）如果对于同一事件（如鼠标消息）既安装了线程勾子又安装了系统勾子，那么系统会自动先调用线程勾子，然后调用系统勾子。
（2）对同一事件消息可安装多个勾子处理过程，这些勾子处理过程形成了勾子链。当前勾子处理结束后应把勾子信息传递给下一个勾子函数。
（3）勾子特别是系统勾子会消耗消息处理时间，降低系统性能。只有在必要的时候才安装勾子，在使用完毕后要及时卸载
c#键盘勾子(hook)拦截器,屏蔽键盘活动源代码:

using system;
using system.collections.generic;
using system.componentmodel;
using system.data;
using system.drawing;
using system.text;
using system.windows.forms;
using system.runtime.interopservices;
using system.reflection;
using system.diagnostics;
using microsoft.win32;
namespace vjsdn.tech.keyboardhook
{
   public partial class frmkeyboardhook : form
   {
      //勾子管理类
      private keyboardhooklib _keyboardhook = null;

      public frmkeyboardhook()
      {
         initializecomponent();
      }

      private void button1_click(object sender, eventargs e)
      {
         //安装勾子
         _keyboardhook = new keyboardhooklib();
         _keyboardhook.installhook(this.onkeypress);
      }

      private void button2_click(object sender, eventargs e)
      {
         //取消勾子
         if (_keyboardhook != null) _keyboardhook.uninstallhook();
      }

      /// <summary>
      /// 客户端键盘捕捉事件.
      /// </summary>
      /// <param name="hookstruct">由hook程序发送的按键信息</param>
      /// <param name="handle">是否拦截</param>
      public void onkeypress(keyboardhooklib.hookstruct hookstruct, out bool handle)
      {
         handle = false; //预设不拦截任何键

         if (hookstruct.vkcode == 91) // 截获左win(开始菜单键)
         {
            handle = true;
         }

         if (hookstruct.vkcode == 92)// 截获右win
         {
            handle = true;
         }

         //截获ctrl+esc
         if (hookstruct.vkcode == (int)keys.escape && (int)control.modifierkeys == (int)keys.control)
         {
            handle = true;
         }

         //截获alt+f4
         if (hookstruct.vkcode == (int)keys.f4 && (int)control.modifierkeys == (int)keys.alt)
         {
            handle = true;
         }

         //截获alt+tab
         if (hookstruct.vkcode == (int)keys.tab && (int)control.modifierkeys == (int)keys.alt)
         {
            handle = true;
         }

         //截获f1
         if (hookstruct.vkcode == (int)keys.f1)
         {
            handle = true;
         }

         //截获ctrl+alt+delete
         if ((int)control.modifierkeys == (int)keys.control + (int)keys.alt + (int)keys.delete)
         {
            handle = true;
         }

         //如果键a~z
         if (hookstruct.vkcode >= (int)keys.a && hookstruct.vkcode <= (int)keys.z)
         {
            //挡掉b键
            if (hookstruct.vkcode == (int)keys.b)
            hookstruct.vkcode = (int)keys.none; //设键为0

            handle = true;
         }

         keys key = (keys)hookstruct.vkcode;
         label1.text = "你按下:" + (key == keys.none ? "" : key.tostring());

      }
   }
}

keyboardhooklib.cs
键盘管理类

using system;
using system.collections.generic;
using system.text;
using system.runtime.interopservices;
using system.reflection;
using system.diagnostics;
using microsoft.win32;
using system.windows.forms;
namespace vjsdn.tech.keyboardhook
{
   /// <summary>
   /// 键盘hook管理类, by www.vjsdn.com 易学原创
   /// </summary>
   public class keyboardhooklib
   {
      private const int wh_keyboard_ll = 13; //键盘

      //键盘处理事件委托 ,当捕获键盘输入时调用定义该委托的方法.
      private delegate int hookhandle(int ncode, int wparam, intptr lparam);

      //客户端键盘处理事件
      public delegate void processkeyhandle(hookstruct param, out bool handle);

      //接收setwindowshookex返回值
      private static int _hhookvalue = 0;

      //勾子程序处理事件
      private hookhandle _keyboardhookprocedure;

      //hook结构
      [structlayout(layoutkind.sequential)]
      public class hookstruct
      {
         public int vkcode;
         public int scancode;
         public int flags;
         public int time;
         public int dwextrainfo;
      }

      //设置钩子
      [dllimport("user32.dll")]
      private static extern int setwindowshookex(int idhook, hookhandle lpfn, intptr hinstance, int threadid);

      //取消钩子
      [dllimport("user32.dll", charset = charset.auto, callingconvention = callingconvention.stdcall)]
      private static extern bool unhookwindowshookex(int idhook);

      //调用下一个钩子
      [dllimport("user32.dll")]
      private static extern int callnexthookex(int idhook, int ncode, int wparam, intptr lparam);

      //获取当前线程id
      [dllimport("kernel32.dll")]
      private static extern int getcurrentthreadid();

      //gets the main module for the associated process.
      [dllimport("kernel32.dll")]
      private static extern intptr getmodulehandle(string name);

      private intptr _hookwindowptr = intptr.zero;

      //构造器
      public keyboardhooklib() { }

      //外部调用的键盘处理事件
      private static processkeyhandle _clientmethod = null;

      /// <summary>
      /// 安装勾子
      /// </summary>
      /// <param name="hookprocess">外部调用的键盘处理事件</param>
      public void installhook(processkeyhandle clientmethod)
      {
         _clientmethod = clientmethod;

         // 安装键盘钩子
         if (_hhookvalue == 0)
         {
            _keyboardhookprocedure = new hookhandle(onhookproc);

            _hookwindowptr = getmodulehandle(process.getcurrentprocess().mainmodule.modulename);

            _hhookvalue = setwindowshookex(
            wh_keyboard_ll,
            _keyboardhookprocedure,
            _hookwindowptr,
            0);

            //如果设置钩子失败.
            if (_hhookvalue == 0) uninstallhook();
         }
      }

      //取消钩子事件
      public void uninstallhook()
      {
         if (_hhookvalue != 0)
         {
            bool ret = unhookwindowshookex(_hhookvalue);
            if (ret) _hhookvalue = 0;
         }
      }

      //钩子事件内部调用,调用_clientmethod方法转发到客户端应用。
      private static int onhookproc(int ncode, int wparam, intptr lparam)
      {
         if (ncode >= 0)
         {
            //转换结构
            hookstruct hookstruct = (hookstruct)marshal.ptrtostructure(lparam, typeof(hookstruct));

            if (_clientmethod != null)
            {
               bool handle = false;
               //调用客户提供的事件处理程序。
               _clientmethod(hookstruct, out handle);
               if (handle) return 1; //1:表示拦截键盘,return 退出
            }
         }
         return callnexthookex(_hhookvalue, ncode, wparam, lparam);
      }

   }
}