学习之路三十八：Hook(钩子)的学习

好久没写文章了，还记得年前面试了一家公司，为了检测一下我的学习能力，给了我一个任务，做一个自动登录并自动操作菜单的程序。

花了几天的时间研究了Hook以及使用WindowsAPI操作程序的知识，现在记录一下，也算是一次温习。

一丶Hook

　　在我看来Hook就是监测用户操作键盘(或虚拟键盘)以及鼠标的行为，对于Hook的理解我也不是很深入，也只是一点皮毛。

　　1. 实现Hook的步骤

　　　　①安装钩子

　　　　②监测键盘和鼠标的操作，用来实现相应的逻辑

　　　　③卸载钩子

　　2.安装钩子

　　　　钩子分两种：键盘钩子和鼠标钩子，而每一种钩子又可以分为全局钩子或局部勾子。

　　　　下面是安装钩子需要的Windows Message常量(网上找的)。

    public enum HookType : int
    {
        /// <summary>
        /// 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。通过使用这 
        ///个函数，应用程序能够在模式循环期间使用相同的代码去过滤消息，如同在主消息循 
        ///环里一样
        /// </summary>
        WH_MSGFILTER = -1,
        /// <summary>
        /// WH_JOURNALRECORD Hook用来监视和记录输入事件。典型的，可以使用这 
        ///个Hook记录连续的鼠标和键盘事件，然后通过使用WH_JOURNALPLAYBACK Hook 
        ///来回放。WH_JOURNALRECORD Hook是全局Hook，它不能象线程特定Hook一样 
        ///使用。WH_JOURNALRECORD是system-wide local hooks，它们不会被注射到任何行 
        ///程地址空间
        /// </summary>
        WH_JOURNALRECORD = 0,
        /// <summary>
        /// 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，它们不会被 
        ///注射到任何行程地址空间
        /// </summary>
        WH_JOURNALPLAYBACK = 1,
        /// <summary>
        /// 在应用程序中，WH_KEYBOARD Hook用来监视WM_KEYDOWN and  
        ///WM_KEYUP消息，这些消息通过GetMessage or PeekMessage function返回。可以使 
        ///用这个Hook来监视输入到消息队列中的键盘消息
        /// </summary>
        WH_KEYBOARD = 2,
        /// <summary>
        /// 应用程序使用WH_GETMESSAGE Hook来监视从GetMessage or PeekMessage函 
        ///数返回的消息。你可以使用WH_GETMESSAGE Hook去监视鼠标和键盘输入，以及 
        ///其它发送到消息队列中的消息
        /// </summary>
        WH_GETMESSAGE = 3,
        /// <summary>
        /// 监视发送到窗口过程的消息，系统在消息发送到接收窗口过程之前调用
        /// </summary>
        WH_CALLWNDPROC = 4,
        /// <summary>
        /// 在以下事件之前，系统都会调用WH_CBT Hook子过程，这些事件包括： 
        ///1. 激活，建立，销毁，最小化，最大化，移动，改变尺寸等窗口事件； 
        ///2. 完成系统指令； 
        ///3. 来自系统消息队列中的移动鼠标，键盘事件； 
        ///4. 设置输入焦点事件； 
        ///5. 同步系统消息队列事件。
        ///Hook子过程的返回值确定系统是否允许或者防止这些操作中的一个
        /// </summary>
        WH_CBT = 5,
        /// <summary>
        /// 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。通过使用这 
        ///个函数，应用程序能够在模式循环期间使用相同的代码去过滤消息，如同在主消息循 
        ///环里一样
        /// </summary>
        WH_SYSMSGFILTER = 6,
        /// <summary>
        /// WH_MOUSE Hook监视从GetMessage 或者 PeekMessage 函数返回的鼠标消息。 
        ///使用这个Hook监视输入到消息队列中的鼠标消息
        /// </summary>
        WH_MOUSE = 7,
        /// <summary>
        /// 当调用GetMessage 或 PeekMessage 来从消息队列种查询非鼠标、键盘消息时
        /// </summary>
        WH_HARDWARE = 8,
        /// <summary>
        /// 在系统调用系统中与其它Hook关联的Hook子过程之前，系统会调用 
        ///WH_DEBUG Hook子过程。你可以使用这个Hook来决定是否允许系统调用与其它 
        ///Hook关联的Hook子过程
        /// </summary>
        WH_DEBUG = 9,
        /// <summary>
        /// 外壳应用程序可以使用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注册它自 
        ///己
        /// </summary>
        WH_SHELL = 10,
        /// <summary>
        /// 当应用程序的前台线程处于空闲状态时，可以使用WH_FOREGROUNDIDLE  
        ///Hook执行低优先级的任务。当应用程序的前台线程大概要变成空闲状态时，系统就 
        ///会调用WH_FOREGROUNDIDLE Hook子过程
        /// </summary>
        WH_FOREGROUNDIDLE = 11,
        /// <summary>
        /// 监视发送到窗口过程的消息，系统在消息发送到接收窗口过程之后调用
        /// </summary>
        WH_CALLWNDPROCRET = 12,
        /// <summary>
        /// 监视输入到线程消息队列中的键盘消息
        /// </summary>
        WH_KEYBOARD_LL = 13,
        /// <summary>
        /// 监视输入到线程消息队列中的鼠标消息
        /// </summary>
        WH_MOUSE_LL = 14
    }

 　　　　而用的最多的也就是：WH_KEYBOARD，WH_MOUSE， WH_KEYBOARD_LL，WH_MOUSE_LL。

　　　　 WH_KEYBOARD和WH_MOUSE是全局钩子，而WH_KEYBOARD_LL和WH_MOUSE_LL是针对某个线程的。

　　　　 所以说安装全局还是局部钩子取决于传入的消息常量。

　　　　 安装钩子需要调用的API：

        /// <summary>
        /// 安装勾子
        /// </summary>
        /// <param name="idHook">钩子类型，此处用整形的枚举表示</param>
        /// <param name="hookCallBack">钩子发挥作用时的回调函数</param>
        /// <param name="moudleHandle">应用程序实例的模块句柄(一般来说是你钩子回调函数所在的应用程序实例模块句柄)</param>
        /// <param name="threadID">与安装的钩子子程相关联的线程的标识符
        /// <remarks>如果线程ID是0则针对系统级别的，否则是针对当前线程</remarks>
        /// </param>
        /// <returns>返回钩子句柄</returns>
        [DllImport("user32.dll")]
        public static extern int SetWindowsHookEx(int idHook, HookProcCallBack hookCallBack, IntPtr moudleHandle, int threadID);

        public delegate int HookProcCallBack(int nCode, int wParam, IntPtr lParam);

　　　　　☆：上面方法的第二个需要是个委托参数，必须把它设置为静态变量，因为监测钩子相当于一个定时器一直在跑，如果委托变量不是静态的话，会被GC给回收掉的。

　　3.监测键盘和鼠标行为

　　　　键盘操作分为：keyDown，keyPress，keyUp；鼠标操作分为：rightClick，leftClick，doubleClick，wheel，move。

　　　　所以为了要监测上面的所有行为，需要使用事件来实现。

　　4.卸载钩子

　　　　主要还是调用API就可以了。

        /// <summary>
        /// 卸载勾子
        /// </summary>
        /// <param name="handle">要取消的钩子的句柄</param>
        /// <returns>卸载钩子是否成功</returns>
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern bool UnhookWindowsHookEx(int handle);　

　　5.HookManager

　　　　发现写不下去，不知道该讲什么了，很多细节上都没有讲到，比如每个参数的含义，怎么调用等等，算是给出个思路，我也是下载了很多源码摸索过来的。

　　　　给出主要实现代码：

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Forms;

using SharpCommon.Windows;

/*
 
 * 2014-1-28 完善第一个版本
 * 
 *  1.关于KeyPress的解释
 *      在控件有焦点的情况下按下键时发生。
 *      键事件按下列顺序发生： 
            KeyDown
            KeyPress
            KeyUp

            非字符键不会引发 KeyPress 事件；但非字符键却可以引发 KeyDown 和 KeyUp 事件。
            使用 KeyChar 属性在运行时对键击进行取样，并且使用或修改公共键击的子集。
            若要仅在窗体级别处理键盘事件而不允许其他控件接收键盘事件，
 *         请将窗体的 KeyPress 事件处理方法中的 KeyPressEventArgs.Handled 属性设置为 true。
 *         
 *      摘自MSDN上的说明
 *      KeyPressEventArgs 指定在用户按键时撰写的字符。例如，当用户按 Shift + K 时，KeyChar 属性返回一个大写字母 K。
         当用户按下任意键时，发生 KeyPress 事件。与 KeyPress 事件紧密相关的两个事件为 KeyUp 和 KeyDown。
 *      当用户按下某个键时，KeyDown 事件先于每个 KeyPress 事件发生；当用户释放某个键时发生 KeyUp 事件。
 *      当用户按住某个键时，每次字符重复时，KeyDown 和 KeyPress 事件也都重复发生。一个 KeyUp 事件在释放按键时生成。

         KeyPressEventArgs 随着 KeyPress 事件的每次发生而被传递。
 *      KeyEventArgs 随着 KeyDown 和 KeyUp 事件的每次发生而被传递。
 *      KeyEventArgs 指定是否有任一个组合键（Ctrl、Shift 或 Alt）在另一个键按下的同时也曾按下。
 *      此修饰符信息也可以通过 Control 类的 ModifierKeys 属性获得。

         将 Handled 设置为 true，以取消 KeyPress 事件。这可防止控件处理按键。

         注意注意： 
         有些控件将会在 KeyDown 上处理某些击键。
 *      例如，RichTextBox 在调用 KeyPress 前处理 Enter 键。
 *      在这种情况下，您无法取消 KeyPress 事件，而是必须从 KeyDown 取消击键。
 *      
 * 
 *  2014-1-28 1:00 PM
 *      1. 完成了对组合键的监测代码，通过获取KeyState来判断是否按了组合键
 
 */

namespace SharpCommon.Hook
{
    public sealed class HookManager
    {
        #region Event And Field
        public event CustomKeyEventHandler KeyUp;
        public event CustomKeyEventHandler KeyDown;
        public event CustomKeyEventHandler KeyPress;

        public event MouseEventHandler MouseMove;
        public event MouseEventHandler MouseWheel;
        public event MouseEventHandler LeftMouseClickUp;
        public event MouseEventHandler RightMouseClickUp;
        public event MouseEventHandler LeftMouseClickDown;
        public event MouseEventHandler RightMouseClickDown;
        public event MouseEventHandler LeftMouseDoubleClick;
        public event MouseEventHandler RightMouseDoubleClick;

        private static int _mouseHookHandle;
        private static int _keyboardHookHandlel;

        private static HookProcCallBack _mouseHookCallBack;
        private static HookProcCallBack _keyboardHookCallBack;

        private static readonly HookManager _instance = new HookManager();

        private static readonly int _currentThreadID = AppDomain.GetCurrentThreadId();
        private static readonly IntPtr _currentMoudleHandle = WindowsAPI.GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName);
        
        #endregion

        #region Instance

        private HookManager()
        { }

        public static HookManager Instance
        {
            get { return _instance; }
        } 

        #endregion

        #region Install Hook

        /// <summary>
        /// Install the hook.
        /// </summary>
        /// <param name="installType">Select the hook install type.</param>
        public void InstallHook(HookInstallType installType = HookInstallType.MouseAndKeyBoard)
        {
            switch (installType)
            {
                case HookInstallType.Mouse:
                    this.InstallMouseHook();
                    break;
                case HookInstallType.KeyBoard:
                    this.InstallKeyBoardHook();
                    break;
                case HookInstallType.MouseAndKeyBoard:
                    this.InstallMouseHook();
                    this.InstallKeyBoardHook();
                    break;
            }
        } 

        #endregion

        #region Mouse Hook Monitor

        /// <summary>
        /// Install the mouse hook.
        /// Default install mouse global hook - [14];
        /// </summary>
        /// <param name="hookType">Select mouse hook type.</param>
        public void InstallMouseHook(HookType hookType = HookType.WH_MOUSE_LL)
        {
            if (_mouseHookHandle == default(int))
            {
                _mouseHookCallBack = new HookProcCallBack(this.MouseHookCallBack);
                if (hookType == HookType.WH_MOUSE)
                {
                    _mouseHookHandle = HookAPI.SetWindowsHookEx((int)hookType, _mouseHookCallBack, IntPtr.Zero, _currentThreadID);
                }
                else
                {
                    _mouseHookHandle = HookAPI.SetWindowsHookEx((int)hookType, _mouseHookCallBack, _currentMoudleHandle, 0);
                }
                this.CheckHandleIsZero(_mouseHookHandle);
            }
        }

        private int MouseHookCallBack(int nCode, int wParam, IntPtr lParam)
        {
            MouseButtons mouseOperation = MouseButtons.None;
            Point mousePoint = (Point)Marshal.PtrToStructure(lParam, typeof(Point));

            switch (wParam)
            {
                case (int)WindowsMessage.WM_LBUTTONDOWN:
                    mouseOperation = MouseButtons.Left;
                    this.InvokeMouseEvent(this.LeftMouseClickDown, mouseOperation, mousePoint);
                    break;
                case (int)WindowsMessage.WM_LBUTTONUP:
                    mouseOperation = MouseButtons.Left;
                    this.InvokeMouseEvent(this.LeftMouseClickUp, mouseOperation, mousePoint);
                    break;
                case (int)WindowsMessage.WM_LBUTTONDBLCLK:
                    mouseOperation = MouseButtons.Left;
                    this.InvokeMouseEvent(this.LeftMouseDoubleClick, mouseOperation, mousePoint);
                    break;
                case (int)WindowsMessage.WM_RBUTTONDOWN:
                    mouseOperation = MouseButtons.Right;
                    this.InvokeMouseEvent(this.RightMouseClickDown, mouseOperation, mousePoint);
                    break;
                case (int)WindowsMessage.WM_RBUTTONUP:
                    mouseOperation = MouseButtons.Right;
                    this.InvokeMouseEvent(this.RightMouseClickUp, mouseOperation, mousePoint);
                    break;
                case (int)WindowsMessage.WM_RBUTTONDBLCLK:
                    mouseOperation = MouseButtons.Right;
                    this.InvokeMouseEvent(this.RightMouseDoubleClick, mouseOperation, mousePoint);
                    break;
                case (int)WindowsMessage.WM_MOUSEMOVE:
                    this.InvokeMouseEvent(this.MouseMove, mouseOperation, mousePoint);
                    break;
                case (int)WindowsMessage.WM_MOUSEWHEEL:
                    this.InvokeMouseEvent(this.MouseWheel, mouseOperation, mousePoint);
                    break;
            }

            return HookAPI.CallNextHookEx(_mouseHookHandle, nCode, wParam, lParam);
        }

        private void InvokeMouseEvent(MouseEventHandler mouseEvent, MouseButtons mouseButton, Point point)
        {
            if (mouseEvent != null)
            {
                MouseEventArgs mouseArgs = new MouseEventArgs(mouseButton, 0, point.X, point.Y, 0);
                mouseEvent(this, mouseArgs);
            }
        } 

        #endregion

        #region KeyBoaed Hook Monitor

        /// <summary>
        /// Install the keyboard hook.
        /// Default install keyboard global hook - [13].
        /// </summary>
        /// <param name="hookType">Select keyboard hook type.</param>
        public void InstallKeyBoardHook(HookType hookType = HookType.WH_KEYBOARD_LL)
        {
            if (_keyboardHookHandlel == default(int))
            {
                _keyboardHookCallBack = new HookProcCallBack(this.KeyBoradHookCallBack);
                if (hookType == HookType.WH_KEYBOARD)
                {
                    _keyboardHookHandlel = HookAPI.SetWindowsHookEx((int)hookType, _keyboardHookCallBack, IntPtr.Zero, _currentThreadID);
                }
                else
                {
                    _keyboardHookHandlel = HookAPI.SetWindowsHookEx((int)hookType, _keyboardHookCallBack, _currentMoudleHandle, 0);
                }
                this.CheckHandleIsZero(_keyboardHookHandlel);
            }
        }

        private int KeyBoradHookCallBack(int nCode, int wParam, IntPtr lParam)
        {
            if (nCode >= 0)
            {
                CustomKeyBoard keyInfo = (CustomKeyBoard)Marshal.PtrToStructure(lParam, typeof(CustomKeyBoard));

                if (this.KeyDown != null
                    && (wParam == (int)WindowsMessage.WM_KEYDOWN || wParam == (int)WindowsMessage.WM_SYSKEYDOWN))
                {
                    this.InvokeKeyBoardEvent(this.KeyDown, (Keys)keyInfo.VirtualKeyCode);
                }

                if (this.KeyPress != null && wParam == (int)WindowsMessage.WM_KEYDOWN)
                {
                    this.InvokeKeyBoardEvent(this.KeyPress, (Keys)keyInfo.VirtualKeyCode);
                }

                if (this.KeyUp != null
                    && (wParam == (int)WindowsMessage.WM_KEYUP || wParam == (int)WindowsMessage.WM_SYSKEYUP))
                {
                    this.InvokeKeyBoardEvent(this.KeyUp, (Keys)keyInfo.VirtualKeyCode);
                }
            }

            return HookAPI.CallNextHookEx(_keyboardHookHandlel, nCode, wParam, lParam);
        }

        private void InvokeKeyBoardEvent(CustomKeyEventHandler keyEvent, Keys keyData)
        {
            CustomKeyEventArgs customKeyArgs = new CustomKeyEventArgs(keyData);
            keyEvent(this, customKeyArgs);
        } 

        #endregion

        #region Common

        private void CheckHandleIsZero(int handle)
        {
            if (handle == 0)
            {
                int errorID = Marshal.GetLastWin32Error();
                throw new Win32Exception(errorID);
            }
        }

        public void UninstallHook()
        {
            if (_mouseHookHandle != default(int))
            {
                if (HookAPI.UnhookWindowsHookEx(_mouseHookHandle))
                {
                    _mouseHookHandle = default(int);
                }
            }
            if (_keyboardHookHandlel != default(int))
            {
                if (HookAPI.UnhookWindowsHookEx(_keyboardHookHandlel))
                {
                    _keyboardHookHandlel = default(int);
                }
            }
        } 

        #endregion
    }
}

 　

　　全部代码：下载

 

好了就这么多了，已同步至：个人文章目录索引