鼠标和键盘操作的全局钩子(较好)
using System;
using https://www.360docs.net/doc/e417639511.html,ponentModel;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Windows.Forms;
namespace UserActivityMonitor
{
///
///This class monitors all mouse activities globally (also outside of the application)
///and provides appropriate events.
///
public static class HookManager
{
///
///Occurs when the mouse pointer is moved.
///
public static event MouseEventHandler MouseMove
{
add
{
EnsureSubscribedToGlobalMouseEvents();
s_MouseMove += value;
}
remove
{
s_MouseMove -= value;
TryUnsubscribeFromGlobalMouseEvents();
}
}
///
///Occurs when a click was performed by the mouse.
///
public static event MouseEventHandler MouseClick
{
add
{
EnsureSubscribedToGlobalMouseEvents();
s_MouseClick += value;
}
remove
{
s_MouseClick -= value;
TryUnsubscribeFromGlobalMouseEvents();
}
}
///
///Occurs when the mouse a mouse button is pressed.
///
public static event MouseEventHandler MouseDown
{
add
{
EnsureSubscribedToGlobalMouseEvents();
s_MouseDown += value;
}
remove
{
s_MouseDown -= value;
TryUnsubscribeFromGlobalMouseEvents();
}
}
///
///Occurs when a mouse button is released.
///
public static event MouseEventHandler MouseUp
{
add
{
EnsureSubscribedToGlobalMouseEvents();
s_MouseUp += value;
}
remove
{
s_MouseUp -= value;
TryUnsubscribeFromGlobalMouseEvents();
}
}
///
///Occurs when the mouse wheel moves.
///
public static event MouseEventHandler MouseWheel {
add
{
EnsureSubscribedToGlobalMouseEvents();
s_MouseWheel += value;
}
remove
{
s_MouseWheel -= value;
TryUnsubscribeFromGlobalMouseEvents();
}
}
///
///Occurs when a double clicked was performed by the mouse.
///
public static event MouseEventHandler MouseDoubleClick
{
add
{
EnsureSubscribedToGlobalMouseEvents();
if (s_MouseDoubleClick == null)
{
s_DoubleClickTimer = new Timer
{
Interval = GetDoubleClickTime(),
Enabled = false };
s_DoubleClickTimer.Tick += DoubleClickTimeElapsed; MouseUp += OnMouseUp;
}
s_MouseDoubleClick += value;
}
remove
{
if (s_MouseDoubleClick != null)
{
s_MouseDoubleClick -= value;
if (s_MouseDoubleClick == null)
{
MouseUp -= OnMouseUp;
s_DoubleClickTimer.Tick -= DoubleClickTimeElapsed; s_DoubleClickTimer = null;
}
}
TryUnsubscribeFromGlobalMouseEvents();
}
}
///
///Occurs when a key is released.
///
public static event KeyEventHandler KeyUp
{
add
{
EnsureSubscribedToGlobalKeyboardEvents();
s_KeyUp += value;
}
remove
{
s_KeyUp -= value;
TryUnsubscribeFromGlobalKeyboardEvents();
}
}
///
///Occurs when a key is preseed.
///
public static event KeyEventHandler KeyDown
{
add
{
EnsureSubscribedToGlobalKeyboardEvents(); s_KeyDown += value;
}
remove
{
s_KeyDown -= value;
TryUnsubscribeFromGlobalKeyboardEvents(); }
}
///
///Occurs when a key is pressed.
///
///
///Key events occur in the following order:
///
///
///
///
///
///The KeyPress event is not raised by noncharacter keys; however, the noncharacter keys do raise the KeyDown and KeyUp events.
///Use the KeyChar property to sample keystrokes at run time and to consume or modify a subset of common keystrokes.
///To handle keyboard events only in your application and not enable other applications to receive keyboard events,
///set the KeyPressEventArgs.Handled property in your form's KeyPress event-handling method to true.
///
public static event KeyPressEventHandler KeyPress
{
add
{
EnsureSubscribedToGlobalKeyboardEvents();
s_KeyPress += value;
}
remove
{
s_KeyPress -= value;
TryUnsubscribeFromGlobalKeyboardEvents();
}
}
private static event MouseEventHandler s_MouseMove;
private static event MouseEventHandler s_MouseClick;
private static event MouseEventHandler s_MouseDown;
private static event MouseEventHandler s_MouseUp;
private static event MouseEventHandler s_MouseWheel;
private static event MouseEventHandler s_MouseDoubleClick;
private static MouseButtons s_PrevClickedButton;
private static Timer s_DoubleClickTimer;
private static void DoubleClickTimeElapsed(object sender, EventArgs e) {
s_DoubleClickTimer.Enabled = false;
s_PrevClickedButton = MouseButtons.None;
}
private static void OnMouseUp(object sender, MouseEventArgs e)
{
if (e.Clicks < 1)
{
return;
}
if(e.Button.Equals(s_PrevClickedButton))
{
if (s_MouseDoubleClick != null)
{
s_MouseDoubleClick.Invoke(null, e);
}
s_DoubleClickTimer.Enabled = false;
s_PrevClickedButton = MouseButtons.None;
}
else {
s_DoubleClickTimer.Enabled = true;
s_PrevClickedButton = e.Button;
}
}
private static event KeyPressEventHandler s_KeyPress;
private static event KeyEventHandler s_KeyUp;
private static event KeyEventHandler s_KeyDown;
private const int WH_MOUSE_LL = 14;
private const int WH_KEYBOARD_LL = 13;
private const int WM_LBUTTONDOWN = 0x201;
private const int WM_RBUTTONDOWN = 0x204;
private const int WM_LBUTTONUP = 0x202;
private const int WM_RBUTTONUP = 0x205;
private const int WM_LBUTTONDBLCLK = 0x203;
private const int WM_RBUTTONDBLCLK = 0x206;
private const int WM_MOUSEWHEEL = 0x020A;
private const int WM_KEYDOWN = 0x100;
private const int WM_KEYUP = 0x101;
private const int WM_SYSKEYDOWN = 0x104;
private const int WM_SYSKEYUP = 0x105;
private const byte VK_SHIFT = 0x10;
private const byte VK_CAPITAL = 0x14;
[DllImport("user32.dll", CharSet = CharSet.Auto,
CallingConvention = CallingConvention.StdCall)]
private static extern int CallNextHookEx(
int idHook,
int nCode,
int wParam,
IntPtr lParam);
[DllImport("user32.dll", CharSet = CharSet.Auto,
CallingConvention = CallingConvention.StdCall, SetLastError = true)] private static extern int SetWindowsHookEx(
int idHook,
HookProc lpfn,
IntPtr hMod,
int dwThreadId);
[DllImport("user32.dll", CharSet = CharSet.Auto,
CallingConvention = CallingConvention.StdCall, SetLastError = true)] private static extern int UnhookWindowsHookEx(int idHook);
[DllImport("user32")]
private static extern int GetDoubleClickTime();
[DllImport("user32")]
private static extern int ToAscii(
int uVirtKey,
int uScanCode,
byte[] lpbKeyState,
byte[] lpwTransKey,
int fuState);
[DllImport("user32")]
private static extern int GetKeyboardState(byte[] pbKeyState);
[DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
private static extern short GetKeyState(int vKey);
[StructLayout(LayoutKind.Sequential)]
private struct Point
{
internal readonly int X;
internal readonly int Y;
}
[StructLayout(LayoutKind.Sequential)]
private struct MouseLLHookStruct
{
internal Point Point;
internal readonly int MouseData;
private readonly int Flags;
private readonly int Time;
private readonly int ExtraInfo;
}
[StructLayout(LayoutKind.Sequential)]
private struct KeyboardHookStruct
{
internal readonly int VirtualKeyCode;
internal readonly int ScanCode;
internal readonly int Flags;
private readonly int Time;
private readonly int ExtraInfo;
}
private delegate int HookProc(int nCode, int wParam, IntPtr lParam);
private static HookProc s_MouseDelegate;
private static int s_MouseHookHandle;
private static int m_OldX;
private static int m_OldY;
private static int MouseHookProc(int nCode, int wParam, IntPtr lParam)
{
if (nCode >= 0)
{
var mouseHookStruct = (MouseLLHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseLLHookStruct));
var button = MouseButtons.None;
short mouseDelta = 0;
var clickCount = 0;
var mouseDown = false;
switch(wParam)
{
case WM_LBUTTONDOWN:
mouseDown = true;
button = MouseButtons.Left; clickCount = 1;
break;
case WM_LBUTTONUP:
mouseUp = true;
button = MouseButtons.Left; clickCount = 1;
break;
case WM_LBUTTONDBLCLK:
button = MouseButtons.Left; clickCount = 2;
break;
case WM_RBUTTONDOWN:
mouseDown = true;
button = MouseButtons.Right; clickCount = 1;
break;
case WM_RBUTTONUP:
button = MouseButtons.Right;
clickCount = 1;
break;
case WM_RBUTTONDBLCLK:
button = MouseButtons.Right;
clickCount = 2;
break;
case WM_MOUSEWHEEL:
mouseDelta = (short)((mouseHookStruct.MouseData >> 16) & 0xffff);
break;
}
var e = new MouseEventExtArgs(
button,
clickCount,
mouseHookStruct.Point.X,
mouseHookStruct.Point.Y,
mouseDelta);
if (s_MouseUp != null && mouseUp)
{
s_MouseUp.Invoke(null, e);
if (s_MouseDown != null && mouseDown)
{
s_MouseDown.Invoke(null, e);
}
if (s_MouseClick != null && clickCount > 0)
{
s_MouseClick.Invoke(null, e);
}
if (s_MouseDoubleClick != null && clickCount == 2)
{
s_MouseDoubleClick.Invoke(null, e);
}
if (s_MouseWheel != null && mouseDelta != 0)
{
s_MouseWheel.Invoke(null, e);
}
if((s_MouseMove != null) && (m_OldX != mouseHookStruct.Point.X || m_OldY != mouseHookStruct.Point.Y))
m_OldX = mouseHookStruct.Point.X;
m_OldY = mouseHookStruct.Point.Y;
if (s_MouseMove != null)
{
s_MouseMove.Invoke(null, e);
}
}
if(e.Handled)
{
return -1;
}
}
return CallNextHookEx(s_MouseHookHandle, nCode, wParam, lParam); }
private static void EnsureSubscribedToGlobalMouseEvents()
{
if (s_MouseHookHandle != 0)
{
return;
}
s_MouseDelegate = MouseHookProc;
s_MouseHookHandle = SetWindowsHookEx(
WH_MOUSE_LL,
s_MouseDelegate,
Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]),
0);
if (s_MouseHookHandle != 0)
{
return;
}
throw new Win32Exception(Marshal.GetLastWin32Error());
}
private static void TryUnsubscribeFromGlobalMouseEvents()
{
if(s_MouseClick == null&& s_MouseDown == null&& s_MouseMove == null&& s_MouseUp == null&& s_MouseWheel == null)
{
ForceUnsunscribeFromGlobalMouseEvents();
}
}
private static void ForceUnsunscribeFromGlobalMouseEvents()
{
if (s_MouseHookHandle == 0)
{
return;
}
var result = UnhookWindowsHookEx(s_MouseHookHandle);
s_MouseHookHandle = 0;
s_MouseDelegate = null;
if (result != 0)
{
return;
}
throw new Win32Exception(Marshal.GetLastWin32Error());
}
private static HookProc s_KeyboardDelegate;
private static int s_KeyboardHookHandle;
private static int KeyboardHookProc(int nCode, Int32 wParam, IntPtr lParam)
{
var handled = false;
if (nCode >= 0)
{
var MyKeyboardHookStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam,
typeof(KeyboardHookStruct));
if(s_KeyDown != null&& (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN))
{
var keyData = (Keys)MyKeyboardHookStruct.VirtualKeyCode;
var e = new KeyEventArgs(keyData);
s_KeyDown.Invoke(null, e);
handled = e.Handled;
}
if (s_KeyPress != null && wParam == WM_KEYDOWN)
{
var isDownShift = ((GetKeyState(VK_SHIFT) & 0x80) == 0x80);
var isDownCapslock = (GetKeyState(VK_CAPITAL) != 0);
var keyState = new byte[256];
GetKeyboardState(keyState);
var inBuffer = new byte[2];
if(ToAscii(MyKeyboardHookStruct.VirtualKeyCode,
MyKeyboardHookStruct.ScanCode,
keyState,
inBuffer,
MyKeyboardHookStruct.Flags) == 1)
{
var key = (char)inBuffer[0];
if ((isDownCapslock ^ isDownShift) && Char.IsLetter(key)) key = Char.ToUpper(key);
var e = new KeyPressEventArgs(key);
s_KeyPress.Invoke(null, e);
C#键盘勾子(Hook)拦截器,屏蔽键盘活动 钩子(Hook)，是Windows消息处理机制的一个平台,应用程序可以在上面设置子程以监视指定窗口的某种消息，而且所监视的窗口可以是其他进程所创建的。当消息到达后，在目标窗口处理函数之前处理它。钩子机制允许应用程序截获处理window消息或特定事件。 钩子实际上是一个处理消息的程序段，通过系统调用，把它挂入系统。每当特定的消息发出，在没有到达目的窗口前，钩子程序就先捕获该消息，亦即钩子函数先得到控制权。这时钩子函数即可以加工处理（改变）该消息，也可以不作处理而继续传递该消息，还可以强制结束消息的传递。 运行机制 1、钩子链表和钩子子程： 每一个Hook都有一个与之相关联的指针列表，称之为钩子链表，由系统来维护。这个列表的指针指向指定的，应用程序定义的，被Hook 子程调用的回调函数，也就是该钩子的各个处理子程。当与指定的Ho ok类型关联的消息发生时，系统就把这个消息传递到Hook子程。一些Hook子程可以只监视消息，或者修改消息，或者停止消息的前进，避免这些消息传递到下一个Hook子程或者目的窗口。最近安装的钩子放在链的开始，而最早安装的钩子放在最后，也就是后加入的先获得控制权。
Windows 并不要求钩子子程的卸载顺序一定得和安装顺序相反。每当有一个钩子被卸载，Windows 便释放其占用的内存，并更新整个Ho ok链表。如果程序安装了钩子，但是在尚未卸载钩子之前就结束了，那么系统会自动为它做卸载钩子的操作。 钩子子程是一个应用程序定义的回调函数(CALLBACK Function),不能定义成某个类的成员函数，只能定义为普通的C函数。用以监视系统或某一特定类型的事件，这些事件可以是与某一特定线程关联的，也可以是系统中所有线程的事件。 钩子子程必须按照以下的语法： LRESULT CALLBACK HookProc ( int nCode, WPARAM wParam, LPARAM lParam ); HookProc是应用程序定义的名字。 nCode参数是Hook代码，Hook子程使用这个参数来确定任务。这个参数的值依赖于Hook类型，每一种Hook都有自己的Hook代码特征字符集。
利用鼠标键盘钩子截获密码。 源码示例：https://www.360docs.net/doc/e417639511.html,/soft/GetPass_Src.rar 钩子能截获系统并得理发送给其它应用程序的消息，能完成一般程序无法完成的功能。掌握钩子的编程方法是很有必要的 钩子分类： 1、WH_CALLWNDPROC和WH_CALLWNDPROCRET：使你可以监视发送到窗口过程的消息 3、WH_DEBUG 调试钩子 4、WH_FOREGROUNDIDLE 当当应用程序的前台线程大概要变成空闲状态时，系统就会调用 WH_FOREGROUNDIDL 5、WH_JOURNALRECORD 监视和记录输入事件 6、WH_JOURNALPLAYBACK 回放用WH_JOURNALRECORD记录事件 7、WH_KEYBOARD 键盘钩子 9、WH_KEYBOARD_LL 低层键盘钩子 10、WH_MOUSE 鼠标钩子 11、WH_MOUSE_LL 底层鼠标钩子 12、WH_SHELL 外壳钩子 13、WH_MSGFILTER 和WH_SYSMSGFILTER 使我们可以监视菜单，滚动条，消息框等 安装钩子： 调用函数SetWindowsHookEx安装钩子。其函数原型为： HHOOK SetWindowsHookEx( int idHook,HOOKPROC lpfn, INSTANCE hMod,DWORD dwThreadId ) idHook表示钩子类型，它是和钩子函数类型一一对应的。如，
WH_KEYBOARD,WH_MOUSE。 Lpfn是钩子函数的地址。 HMod是钩子函数所在的实例的句柄。对于线程钩子，该参数为NULL；对于系统钩子，该参数为钩子函数所在的DLL句柄。(系统钩子必须在DLL中） dwThreadId 指定钩子所监视的线程的线程号。对于全局钩子，该参数为NULL。 SetWindowsHookEx返回所安装的钩子句柄。 卸载钩子 调用函数BOOL UnhookWindowsHookEx( HHOOK hhk)卸载钩子 定义钩子函数 钩子函数是一种特殊的回调函数。钩子监视的特定事件发生后，系统会调用钩子函数进行处理。一般为下： LRESULT WINAPI MyHookProc(int nCode ,WPARAM wParam,LPARAM lParam) 参数wParam和lParam包含所钩消息的信息，比如鼠标位置、状态，键盘按键等。nCode 包含有关消息本身的信，比如是否从消息队列中移出。 实例： 下面我们通过安装鼠标钩子。和键盘钩子还截获输入的密码，并可查看*密码为例，来说明何何使用钩子。 1，进入向导，新建MFC AppWizard(dll) 取名为GetPass，选择MFC Extension DLL，完成。 2，新建一个CGetPassHook 类，基类:CObject,并加入StartHook,StopHook,函数，如下：class AFX_EXT_CLASS CGetPassHook : public CObject { public: BOOL StopHook();
Windows钩子函数的概念和实现方法 首先我们必须大致了解Windows的基本运作机理，Windows作为一个多任务操作系统，它是分有层次概念的，运行在最底下的称为Ring 0层，在这一层里基本上都是一些硬件驱动程序和Windows的总内核，一般的应用程序极少极少运行在这层，当然也有例外，例如调试软件SoftICE(不过基本上这个软件的作用是Crack软件而不是调试)、还原精灵还有分区魔法大师，就是运行在Ring 0层的，另外就是著名的CIH病毒。运行在Ring 0级的程序能够对所有硬件进行直接地址级访问，所受到的限制也最小。 消息(Message)传递是Windows独有的一种机制，因为Windows规定运行在Ring 0以上的程序是没有权利知道究竟硬件发生了怎样的中断变化的，Windows统一将这些中断变化封装成一系列的消息(黑箱作业，也就是常说的Black Box)，比如鼠标移动，系统产生一个OnMouseMove消息(但这条消息从何而来，相关的硬件中断向量是什么，程序无从得知)，OnMouseMove这条消息最后送达每一个窗口程序以供处理。在更高层次的地方，比如说控件级，所有的消息还被封装成一系列“事件”，比如TextBox控件有KeyPress事件，实际上，这些事件都是林林种种的消息映射。事件的概念使得程序员能够更加傻瓜化地进行编程，但是从另一个角度来说，这种黑箱作业也使得程序员过分依赖系统的安排，限制了程序员的思维，举个例子，Windows为按钮控件封装了大部分常用的属性和事件，完成一般的常规妈作是没有问题的，但是很遗憾，或许是Windows的疏忽，按钮控件的字体颜色永远默认是黑色，而且Windows没有为此提供一个专门的接口来修改，碰到这种情况，程序员就会非常头疼。 钩子函数(Hook Function)，就像一把钩子，它的作用是将消息在抵达窗口程序之前先钩到一个地方以便程序员进行分析，这个地方称为挂接函数链，消息在这里先被一系列的函数处理然后由程序员决定是否交还给Windows系统，在这里，你可以“吞噬”(Lickup)一些你不希望发生的消息，比如说你吞掉所有的键盘消息而不交还给系统，那么键盘将会失灵。当然，经过了这道周折，系统效率将会有极其微小的降低，但是，由于Windows规定所有不运行在Ring 0层的程序都不能直接访问硬件中断，因此作为一种中断驱动程序的补充，钩子函数在很多场合下是非常有用的，有时候甚至是唯一的方法。 下面就以键盘拦截为例讲述钩子函数的使用方法： 首先定义以下API： Public Declare Function SetWindowsHookEx Lib "user32" _ Alias "SetWindowsHookExA" (ByVal idHook As Long, _ ByVal lpfn As Long, _ ByVal hmod As Long, _ ByVal dwThreadId As Long) As Long SetWindowsHookEx,这个函数是一切钩子函数的根本，其作用是通知Windows进行钩子妈作并定义钩子函数。 参数1，idHook为定义需要进行的拦截类型，是键盘拦截？鼠标拦截？还是别的。如 WH_KEYBOARD捕捉键盘消息，而WH_MOUSE捕捉鼠标消息。
C#键盘钩子，本文以C#语言为例，演示拦截键盘按键。首先打开VS创建一个窗体应用程序。如图： 需要引入以下两个命名空间。 using System.Runtime.InteropServices; using System.Diagnostics; 以下是全部源码： using System; using System.Collections.Generic; using https://www.360docs.net/doc/e417639511.html,ponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Runtime.InteropServices;
using System.Diagnostics; namespace WindowsForms5107 { public partial class Form1 : Form { public Form1() { InitializeComponent(); } //定¨义?一?个?结á构1 public struct HookStruck { public int vkCode; public int scanCode; public int time; } public delegate int FunctionAddr(int ncode,IntPtr wParam,IntPtr iparam); [DllImport("user32.dll")] //参?数簓介é绍Θ?：阰hookID表括?示?参?数簓类え?型í，?有瓺鼠酣?标括?钩3子哩?，?键ü盘ì钩3子哩?等台?类え?型í，?callfunction：阰回?调獭?函ˉ数簓地?址·，?即′你?要癮转羇而?执′行D的?程ì序?地?址·。￡ //hInstance:钩3子哩?程ì序?的?实害??柄括?。￡threadID线?程ìId,你?要癮监à视酣?的?程ì序?的?iD,当獭纈d=0时骸?，?为a系μ统?钩3子哩?，?监à控?整?个?系μ统?
C#键盘钩子实现全局快捷键 本文介绍如何使用Win32Api创建键盘钩子，并编写一个使用全局快捷键的实例。 工具/原料 Visual Studio（本文使用VS2013，其他版本亦可）。 基础知识 1 使用钩子之前，需要使用SetWindowsHookEx()函数创建钩子，使用完毕之后要UnhookWindowsHookEx()函数卸载钩子，“钩”到消息后操作系统会自动调用在创建钩子时注册的回调函数来处理消息，处理完后调用CallNextHookEx()函数等待或处理下一条消息。有关钩子的详细信息请见参考--C#鼠标钩子，其中已介绍。 2 对于键盘钩子，钩子类型为WH_KEYBOARD_LL=13，只需要设置SetWindowsHookEx的idHook 参数为13即可“钩”到键盘消息。关于钩子类型的资料见参考资料--钩子类型。 END 键盘钩子实例 启动VS，新建C# WinForm项目，命名为“Cs键盘钩子”，如下： 对主窗口布局，如下： 添加Win32Api引用，代码如下： using System; using System.Collections.Generic; using System.Linq;
using System.Text; using System.Runtime.InteropServices; using System.Reflection; using System.Threading; using System.Windows.Forms; using System.Diagnostics; public class Win32Api { #region常数和结构 public const int WM_KEYDOWN = 0x100; public const int WM_KEYUP = 0x101; public const int WM_SYSKEYDOWN = 0x104; public const int WM_SYSKEYUP = 0x105; public const int WH_KEYBOARD_LL = 13; [StructLayout(LayoutKind.Sequential)] //声明键盘钩子的封送结构类型public class KeyboardHookStruct { public int vkCode; //表示一个在1到254间的虚似键盘码 public int scanCode; //表示硬件扫描码 public int flags; public int time; public int dwExtraInfo; } #endregion #region Api public delegate int HookProc(int nCode, Int32 wParam, IntPtr lParam); //安装钩子的函数 [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)] public static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId); //卸下钩子的函数 [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)] public static extern bool UnhookWindowsHookEx(int idHook); //下一个钩挂的函数 [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)] public static extern int CallNextHookEx(int idHook, int nCode, Int32wParam, IntPtr lParam); [DllImport("user32")] public static extern int ToAscii(int uVirtKey, int uScanCode, byte[] lpbKeyState, byte[] lpwTransKey, int fuState);
键盘钩子.txt7温暖是飘飘洒洒的春雨；温暖是写在脸上的笑影；温暖是义无反顾的响应；温暖是一丝不苟的配合。8尊重是一缕春风，一泓清泉，一颗给人温暖的舒心丸，一剂催人奋进的强心剂给DLL初学者——全程键盘钩子的一种简单实现 作者：未知来源：月光软件站加入时间：2005-2-28 月光软件站 - 随着中间件技术的发展， DLL越来越为程序员所关注，因为使用DLL具有一系列优点，所以程序设计人员可能更多的在自己的软件中采用这种技术。 下面我就把以前做过的一个简单的全程键盘钩子分析一下。 钩子[以下简称Hook]是应用程序在Microsoft Windows 消息处理过程中设置的用来监控消息流并且处理系统中尚未到达目的窗口的某一类型消息过程的机制。如果Hook过程在应用程序中实现，若应用程序不是当前窗口时，该Hook就不起作用；如果Hook在DLL中实现，程序在运行中动态调用它，它能实时对系统进行监控。根据需要，我们采用的是在DLL中实现Hook 的方式[关于HOOK更详细的资料请查阅资料]。 在VC中新建一Win32 Dynamic-Link Library 工程，工程名为KBLock。AppWizard会生成相关文件，编译生成的KBLock.cpp： #include "stdafx.h" #include "KBLock.h" HHOOK hhkHook=NULL; //定义钩子句柄 HINSTANCE hInstance=NULL; //程序实例 //下面的DLLMain相当于Win32程序中的WinMain函数，是入口点 BOOL APIENTRY DllMain( HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved
利用钩子函数来捕捉键盘响应的windows应用程序一：引言： 你也许一直对金山词霸的屏幕抓词的实现原理感到困惑，你也许希望将你的键盘，鼠标的活动适时的记录下来，甚至你想知道木马在windows操作系统是怎样进行木马dll的加载的…..其实这些都是用到了windows的钩子函数。因此本文将对钩子函数的相关知识进行阐述。当然，本文的目的并不是想通过此程序让读者去窃取别人的密码，只是由于钩子函数在windows系统中是一个非常重要的系统接口函数，所以想和大家共同的探讨，当然本文也对怎样建立动态连结库（DLL）作了一些简单的描述。（本文的程序为vc6.0的开发环境，语言是：C和win32 api）。 二：钩子概述： 微软的windowsX操作系统是建立在事件驱动的机制上的，也就是通过消息传递来实现。而钩子在windows操作系统中，是一种能在事件（比如：消息、鼠标激活、键盘响应）到达应用程序前中途接获事件的机制。而且，钩子函数还可以通过修改、丢弃等手段来对事件起作用。 Windows 有两种钩子，一种是特定线程钩子（Thread specific hooks），一种是全局系统钩子(Systemwide hooks)。特定线程钩子只是监视指定的线程，而全局系统钩子则可以监视系统中所有的线程。无论是特定线程钩子，还是全局系统钩子，都是通过SetWindowsHookEx ()来设置钩子的。对于特定线程钩子，钩子的函数既可以是包含在一个.exe也可以是一个.dll。但是对于一个全局系统钩子，钩子函数必须包含在独立的dll中，因此，当我们要捕捉键盘响应时，我们必须创建一个动态链接库。但是当钩子函数在得到了控制权，并对相关的事件处理完后，如果想要该消息得以继续的传递，那么则必须调用另一个函数：CallNextHookEx。由于系统必须对每个消息处理，钩子程序因此增加了处理的负担，因此也降低了系统的性能。鉴于这一点，在windows ce中对钩子程序并不支持。所以当程序完成并退出时，应当释放钩子，调用函数：UnhookWindowsHookEx。 下面我们将举一个例子（捕捉键盘）来详细的讲解钩子函数的程序设计。 三：程序的设计： I:设置钩子 设置钩子是通过SetWindowsHookEx ()的API函数. 原形: HHOOK SetWindowsHookEx(int idHook,HOOKPROC lpfn,HINSTANCE hMod,DWORD dwThreadId) idhook:装入钩子的类型. lpfn: 钩子进程的入口地址 hMod: 应用程序的事件句柄 dwThreadId: 装入钩子的线程标示 参数： idHook: 这个参数可以是以下值： WH_CALLWNDPROC、WH_CALLWNDPROCRET、WH_CBT、WH_DEBUG、WH_FOREGROUNDIDLE、 WH_GETMESSAGE、WH_JOURNALPLAYBACK、WH_JOURNALRECORD、WH_KEYBOARD、WH_KEYBOARD_LL、
系统钩子和DLL 钩子的本质是一段用以处理系统消息的程序，通过系统调用，将其挂入系统。钩子的种类有很多，每种钩子可以截获并处理相应的消息，每当特定的消息发出，在到达目的窗口之前，钩子程序先行截获该消息、得到对此消息的控制权。此时在钩子函数中就可以对截获的消息进行加工处理，甚至可以强制结束消息的传递。 在本程序中我们需要捕获在任意窗口上的键盘输入，这就需要采用全局钩子以便拦截整个系统的消息，而全局钩子函数必须以DLL（动态连接库）为载体进行封装，VC6中有三种形式的MFC DLL可供选择，即Regular statically linked to MFC DLL（标准静态链接MFC DLL）、Regular using the shared MFC DLL（标准动态链接MFC DLL）以及Extension MFC DLL（扩展MFC DLL）。在本程序中为方便起见采用了标准静态连接MFC DLL。 键盘钩子程序示例 本示例程序用到全局钩子函数，程序分两部分：可执行程序KeyKook和动态连接库LaunchDLL。首先创建一个MFC AppWizard(DLL)工程，并选择Regular statically linked to MFC DLL （标准静态链接MFC DLL）选项，以建立MFC扩展动态连接库LaunchDLL.dll。之后，在相应的头文件中添加宏定义和待导出函数的声明： #define DllExport __declspec(dllexport) …… DllExport void WINAPI InstallLaunchEv(); …… class CLaunchDLLApp : public CWinApp { public: CLaunchDLLApp(); //{{AFX_VIRTUAL(CLaunchDLLApp) //}}AFX_VIRTUAL //{{AFX_MSG(CLaunchDLLApp) // NOTE - the ClassWizard will add and remove member functions here. // DO NOT EDIT what you see in these blocks of generated code ! //}}AFX_MSG DECLARE_MESSAGE_MAP() }; 同时在实现文件中添加全局变量Hook和全局函数LauncherHook（）、SaveLog（）： HHOOK Hook; LRESULT CALLBACK LauncherHook(int nCode,WPARAM wParam,LPARAM lParam); void SaveLog(char* c); 最后，完成以上提到的这几个函数的具体编码实现：
键盘钩子实例 一、界面样式如下： 主要功能如下：安装钩子拦截按键，允许按键有效和无效，可以记录按键，以及取消钩子。 二、定义界面控件：label1 标记按键、button1 安装钩子按钮、button2 取消钩子按钮 三、源码 1、主界面Form1 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; using WinformHook; namespace WinformHook { public partial class Form1 : Form { //钩子管理对象 private KeyboardHookLib _keyboardHook = null; public Form1() { 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(); } ///
VB: è????ü?ì?￠êó±ê13×ó '--------------------------------- 'Form '°2×°13×ó Private sub AddHook() '?ü?ì13×ó lHook(0) = SetWindowsHookEx(WH_KEYBOARD_LL, AddressOf CallKeyHookProc, App.hInstance, 0) 'êó±ê13×ó lHook(1) = SetWindowsHookEx(WH_MOUSE_LL, AddressOf CallMouseHookProc, App.hInstance, 0) End Sub 'D?13×ó Private sub DelHook() UnhookWindowsHookEx lHook(0) UnhookWindowsHookEx lHook(1) End Sub '--------------------------------- '?￡?é Public Declare Function SetWindowsHookEx Lib "user32" Alias "SetWindowsHookExA" (ByVal idHook As Long, ByVal lpfn As Long, ByVal hmod As Long, ByVal dwThreadId As Long) As Long Public Declare Function UnhookWindowsHookEx Lib "user32" (ByVal hHook As Long) As Long Public Declare Function GetKeyState Lib "user32" (ByVal nVirtKey As Long) As Integer Public Declare Function CallNextHookEx Lib "user32" (ByVal hHook As Long, ByVal ncode As Long, ByVal wParam As Long, lParam As Any) As Long Public Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (lpvDest As Any, ByVal lpvSource As Long, ByVal cbCopy As Long) Public Type KEYMSGS vKey As Long 'Dé?a?? (and &HFF) sKey As Long 'é¨?è?? flag As Long '?ü°′??￡o128 ì§?e￡o0 time As Long 'Window??DDê±?? End Type Public Type MOUSEMSGS X As Long 'x×ù±ê Y As Long 'y×ù±ê a As Long b As Long time As Long 'Window??DDê±?? End Type Public Type POINTAPI
Windows系统是建立在事件驱动的机制上的，说穿了就是整个系统都是通过消息的传递来实现的。而钩子是Windows系统中非常重要的系统接口，用它可以截获并处理送给其他应用程序的消息，来完成普通应用程序难以实现的功能。钩子可以监视系统或进程中的各种事件消息，截获发往目标窗口的消息并进行处理。这样，我们就可以在系统中安装自定义的钩子，监视系统中特定事件的发生，完成特定的功能，比如截获键盘、鼠标的输入，屏幕取词，日志监视等等。可见，利用钩子可以实现许多特殊而有用的功能。因此，对于高级编程人员来说，掌握钩子的编程方法是很有必要的。 钩子的类型 一．按事件分类，有如下的几种常用类型 （1）键盘钩子和低级键盘钩子可以监视各种键盘消息。 （2）鼠标钩子和低级鼠标钩子可以监视各种鼠标消息。 （3）外壳钩子可以监视各种Shell事件消息。比如启动和关闭应用程序。 （4）日志钩子可以记录从系统消息队列中取出的各种事件消息。 （5）窗口过程钩子监视所有从系统消息队列发往目标窗口的消息。 此外，还有一些特定事件的钩子提供给我们使用，不一一列举。 下面描述常用的Hook类型： 1、WH_CALLWNDPROC和WH_CALLWNDPROCRET Hooks WH_CALLWNDPROC和WH_CALLWNDPROCRET Hooks使你可以监视发送到窗口过程的消息。系统在消息发送到接收窗口过程之前调用WH_CALLWNDPROC Hook子程，并且在窗口过程处理完消息之后调用WH_CALLWNDPRO CRET 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
c# è???13×ó???ü?ì (êμày) D??¨????WinAPIMessage D??¨ò???form1′°ì?.???ó2??button￡????óê??t?￡?￡è?oó?′??è?????′ú??ì???form1μ?′ú??(×￠òa2?òaíü?????óbuttonê??t. using System; using System.Collections.Generic; using https://www.360docs.net/doc/e417639511.html,ponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; using System.Runtime.InteropServices; using System.Reflection; using System.Diagnostics; namespace WinAPIMessage { public partial class Form1 : Form { public Form1() { InitializeComponent(); } //?ˉíD public delegate int HookProc(int nCode, int wParam, IntPtr lParam); static int hHook = 0; public const int WH_KEYBOARD_LL = 13; //LowLevel?ü?ì????￡?è?1?ê?WH_KEYBOARD￡?2￡?2￠2??ü???μí3?ü?ì??è?￡?Ac robat Reader?á?ú????è????°??μ??ü?ì?￡ HookProc KeyBoardHookProcedure; //?ü?ìHook?á11oˉêy [StructLayout(LayoutKind.Sequential)] public class KeyBoardHookStruct { public int vkCode; public int scanCode; public int flags; public int time; public int dwExtraInfo; } #region DllImport
软件实现监听键盘事件 using System; using System.Collections.Generic; using System.Text; using System.Runtime.InteropServices; using System.Windows.Forms; using System.Reflection; class KeyboardHook { public event KeyEventHandler KeyDownEvent; public event KeyPressEventHandler KeyPressEvent; public event KeyEventHandler KeyUpEvent; public delegate int HookProc(int nCode, Int32 wParam, IntPtr lParam); static int hKeyboardHook = 0; //声明键盘钩子处理的初始值 //值在Microsoft SDK的Winuser.h里查询 public const int WH_KEYBOARD_LL = 13; //线程键盘钩子监听鼠标消息设为2，全局键盘监听鼠标消息设为13
HookProc KeyboardHookProcedure; //声明KeyboardHookProcedure作为HookProc类型 //键盘结构 [StructLayout(LayoutKind.Sequential)] public class KeyboardHookStruct { public int vkCode; //定一个虚拟键码。该代码必须有一个价值的范围1至254 public int scanCode; // 指定的硬件扫描码的关键 public int flags; // 键标志 public int time; // 指定的时间戳记的这个讯息 public int dwExtraInfo; // 指定额外信息相关的信息 } //使用此功能，安装了一个钩子 [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)] public static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId); //调用此函数卸载钩子 [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
键盘事件的挂钩监控原理及其应用 键盘事件的挂钩监控原理及其应用 键盘事件的挂钩监控原理及其应用 2019-10-03 计算机信息技术 键盘事件的挂钩监控原理及其应用 WINDOWS的消息处理机制为了能在应用程序中监控系统的各种事件消息，提供了挂接各种反调函数(HOOK)的功能。这种挂钩函数(HOOK)类似扩充中断驱动程序，挂钩上可以挂接多个反调函数构成一个挂接函数链。系统产生的各种消息首先被送到各种挂接函数，挂接函数根据各自的功能对消息进行监视、修改和控制等，然后交还控制权或将消息传递给下一个挂接函数以致最终达到窗口函数。WINDOW系统的这种反调函数挂接方法虽然会略加影响到系统的运行效率，但在很多场合下是非常有用的，通过合理有效地利用键盘事件的挂钩函数监控机制可以达到预想不到的良好效果。一、在WINDOWS键盘事件上挂接监控函数的方法WINDOW下可进行挂接的过滤函数包括11种：WH_CALLWNDPROC 窗口函数的过滤函数WH_CBT计算机培训过滤函数WH_DEBUG 调试过滤函数WH_GETMESSAGE 获取消息过滤函数WH_HARDWARE 硬件消息过滤函数WH_JOURNALPLAYBACK 消息重放过滤函数WH_JOURNALRECORD 消息记录过滤函数WH_MOUSE 鼠标过滤函数WH_MSGFILTER 消息过滤函数WH_SYSMSGFILTER 系统消息过滤函数WH_KEYBOARD 键盘过滤函数其中键盘过滤函数是最常用最有用的过滤函数类型，不管是哪一种类型的过滤函数，其挂接的基本方法都是相同的。 WINDOW调用挂接的反调函数时总是先调用挂接链首的那个函数，因此必须将键盘挂钩函数利用函数SetWindowsHookEx()将其挂接在函数链首。至于消息是否传递给函数链的下一个函数是由每个具体函数功能确定的，如果消息需要传统给下一个函数，可调
全局键盘钩子 C#.NET2005 using System; using System.Runtime.InteropServices; using System.Reflection; using System.Threading; using System.Windows.Forms; using System.Diagnostics; using System.Collections.Generic; namespace HookGlobal { ///
课程报告 windows钩子程序实现 班级： 学号： 姓名： 教师评语： 教师签名： 2010年7月
课程设计题目 windows钩子程序实现 目的和背景目的： 1）更深入的学习C++，并学会在Visual C++ 6.0上编写应用程序2）了解windows钩子程序的基本原理，类型和实现过程 3）掌握用C++来设计一个钩子程序 背景：钩子的本质是一段用以处理系统消息的程序，通过系统调用，把他挂入系统。钩子的种类很多，每种钩子可以截获并处理相应的消息，每当特定的消息发出，在到达目的窗口之前，钩子程序先行截获该消息、得到对此消息的控制权。此时钩子函数可以对截获的消息进行加工处理，甚至可以强制结束消息的传递。鼠标钩子是能截获鼠标的操作，包括单击，双击，鼠标所在的位置等；而键盘钩子是截获从键盘输入的信息。 主要内容1）熟悉钩子程序在Windows操作系统的作用 2）通过找资料，学习钩子程序的基本原理，包括Windows的消息传递机制，钩子的概念，钩子的类型，钩子的实现过程 3）学习和掌握钩子函数，Win32全局钩子的运行机制，VC6中MFC DLL的分类及特点和在VC6中全局共享数据的实现 4）用C++编写一个windows钩子程序；实现适时获取当前鼠标所在窗口的标题和监视各种键盘消息，如，把把鼠标所在窗口标题显示在一个EDITBOX中，从键盘输入的信息记录在一个文档里 采用的工具方法Windows XP 操作系统，Visual C++ 6.0 进度安排1）18周周（三）—18周周（四）：查找相关的资料，对钩子程序的相关知识进行全面的了解 2）18周周（五）—19周周（一）：对程序进行分析，并加强有关方面的知识，如，C++编程的能力 3）19周周（二）—19周周（三）：学习了解Win32全局钩子的运行机制，VC6中MFC DLL的分类及特点和在VC6中全局共享数据的实现 4）19周周（四）—20周周（一）：编码实现windows钩子程序，并实现相应的功能 5）20周周（二）—20周周（三）：进行程序测试 参考资料[1] 王育坚.Visual C++面向对象编程教程（第2版）[M].北京：清华 大学出版社，2007.10. [2] 王西武，阎梅，赵怀勋. 在VC6下应用Windows系统钩子技术 [J]. 现代电子技术 . 2004：27(17) . [3] 徐士良.常用算法程序集:C++语言描述（第4版）[M].北京：清华 大学出版社，2009.7. [4] 钱能.C++程序设计教程:设计思想与实现(修订版)[M].北京：清华 大学出版社.2009.7. [5] 游洪跃, 伍良富, 王景熙.C++面向对象程序设计实验和课程设计 教程[M].北京：清华大学出版社，2009.2. [6]倪步喜.Windows的钩子技术及实现[J].计算机与现代化.2007，28