外挂技术(钩子)
外挂技术（钩子）
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
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，它們不會被注射到任何行程位址空間。（估计按键精灵是用这个hook做的）
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注册它自己。以上是13种常用的hook类型！
二．按使用范围分类，主要有线程钩子和系统钩子
（1）线程钩子监视指定线程的事件消息。
（2）系统钩子监视系统中的所有线程的事件消息。因为系统钩子会影响系统中所有的应用程序，所以钩子函数必须放在独立的动态链接库(DLL)
中。这是系统钩子和线程钩子很大的不同之处。
几点需要说明的地方：
（1）如果对于同一事件（如鼠标消息）既安装了线程钩子又安装了系统钩子，那么系统会自动先调用线程钩子，然后调用系统钩子。
（2）对同一事件消息可安装多个钩子处理过程，这些钩子处理过程形成了钩子链。当前钩子处理结束后应把钩子信息传递给下一个钩子函数。而且最近安装的钩子放在链的开始，而最早安装的钩子放在最后，也就是后加入的先获得控制权。
（3）钩子特别是系统钩子会消耗消息处理时间，降低系统性能。只有在必要的时候才安装钩子，在使用完毕后要及时卸载。
编写钩子程序
编写钩子程序的步骤分为三步：定义钩子函数、安装钩子和卸载钩子。
1．定义钩子函数
钩子函数是一种特殊的回调函数。钩子监视的特定事件发生后，系统会调用钩子函数进行处理。不同事件的钩子函数的形式是各不相同的。下面以鼠标钩子函数举例说明钩子函数的原型：
LRESULT CALLBACK HookProc(Int nCode ,WPARAM wParam,LPARAM lParam)
参数wParam和lParam包含所钩消息的信息，比如鼠标位置、状态，键盘按键等。nCode包含有关消息本身的信息，比如是否从消息队列中移出。
我们先在钩子函数中实现自定义的功能，然后调用函数CallNextHookEx.把钩子信息传递给钩子链的下一个钩子函数。CallNextHookEx.的原型如下：
LRESULT CallNextHookEx( HHOOK hhk, int nCode, WPARAM wParam, LPARAM lParam )
参数hhk是钩子句柄。nCode、wParam和lPAram 是钩子函数。
当然也可以通过直接返回TRUE来丢弃该消息，就阻止了该消息的传递。
2．安装钩子
在程序初始化的时候，调用函数SetWindowsHookEx安装钩子。其函数原型为：HHOOK SetWindowsHookEx( int idHook,HOOKPROc lpfn, INSTANCE hMod,DWORD dwThreadId )
参数IdHook表示钩子类型，它是和钩子函数类型一一对应的。比如，WH_KEYBOARD 表示安装的是键盘钩子，WH_MOUSE表示是鼠标钩子等等。
LpFn是钩子函数的地址。
HMod是钩子函数所在的实例的句柄。对于线程钩子，该参数为NULL；对于系统钩子，该参数为钩子函数所在的DLL句柄。
dwThreadId 指定钩子所监视的线程的线程号。对于全局钩子，该参数为NULL。
SetWindowsHookEx返回所安装的钩子句柄。
3．卸载钩子
当不再使用钩子时，必须及时卸载。简单地调用函数BOOL UnhookWindowshookEx( HHOOK hhk)即可。
值得注意的是线程钩子和系统钩子的钩子函数的位置有很大的差别。线程钩子一般在当前线程或者当前线程派生的线程内，而系统钩子必须放在独立的动态链接库中，实现起来要麻烦一些。
线程钩子的编程实例：
按照上面介绍的方法实现一个线程级的鼠标钩子。钩子跟踪当前窗口鼠标移动的位置变化信息。并输出到窗口。
(1)在VC＋＋6.0中利用MFC
APPWIzard（EXE）生成一个不使用文档/视结构的单文档应用mousehook。打开childview.cpp文件，加入全局变量：
HHOOK hHook;//鼠标钩子句柄
CPoInt poInt;//鼠标位置信息
CChildVIew ＊pView;
// 鼠标钩子函数用到的输出窗口指针
在CChildView::OnPaint()添加如下代码：
CPaintDC dc(this);
char str[256];
sprintf(str,“x=％d,y=％d",point.x,point.y);
//构造字符串
dc.TextOut(0,0,str); //显示字符串
(2)childvIew.cpp文件中定义全局的鼠标钩子函数。
LRESULT CALLBACK MouseProc
(Int nCode, WPARAM wParam, LPARAM lParam)
{//是鼠标移动消息
If(wParam==WM_MOuSEMOVE||wParam
==WM_NCMOUSEMOVE)
{
point=((MOUSeHOOKSTRUCT ＊)lParam)－>pt;
//取鼠标信息
pView－>InvalIdate(); //窗口重画
}
return CallNextHookEx(hHook,nCode,wParam,lParam);
//传递钩子信息
}
(3)CChIldVIew类的构造函数中安装钩子。
CChildView::CChildView()
{
pVIew=thIs;//获得输出窗口指针
hHook=SetWindowsHookEx(WH_MOUSE,MouseProc,0,GetCurrentThreadId());
}
(4)CChIldVIew类的析构函数中卸载钩子。
CChildView::～CChildVIew()
{
If(hHook)
UnhookWindowsHookEx(hHook);
}
系统钩子的编程实例：
由于系统钩子要用到dll，所以先介绍下win32 dll的特点：
Win32 DLL与Win16 DLL有很大的区别，这主要是由操作系统的设计思想决定的。一方面，在WIn16 DLL中程序入口点函数和出口点函数（LIbMaIn和WEP）是分别实现的；而在WIn32 DLL中却由同一函数DLLMaIn来实现。无论何时，当一个进程或线程载入和卸载DLL时，都要调用该函数，它的原型是BOOL WINAPI DllMain (HINSTANCE hinstDLL,DWORD fdwReason, LPVOID lpvReserved);，其中，第一个参数表示DLL的实例句柄；第三个参数系统保留；这里主要介绍一下第二个参数，它有四个可能的值：DLL_PROCESS_A TTACH（进程载入），DLL_THREAD_A TTACH （线程载入），DLL_THREAD_DETACH（线程卸载），DLL_PROCESS_DETACH（进程卸载），在DLLMaIn函数中可以对传递进来的这个参数的值进行判别，并根据不同的参数值对DLL进行必要的初始化或清理工作。举个例子来说，当有一个进程载入一个DLL时，系统分派给DLL的第二个参数为DLL_PROCESS_A TTACH，这时，你可以根据这个参数初始化特定的数据。另一方面，在WIn16环境下，所有应用程序都在同一地址空间；而在WIn32环境下，所有应用程序都有自己的私有空间，每个进程的空间都是相互独立的，这减少了应用程序间的相互影响，但同时也增加了编程的难度。大家知道，在Win16环境中，DLL的全局数据对每个载入它的进程来说都是相同的；而在WIn32环境中，情况却发生了变化，当进程在载入DLL时，系统自动把DLL 地址映射到该进程的私有空间，而且也复制该DLL的全局数据的一份拷贝到该进程空间，也就是说每个进程所拥有的相同的DLL的全局数据其值却并不一定是相同的。因此，在WIn32环境下要想在多个进程中共享数据，就必须进行必要的设置。亦即把这些需要共享的数据分离出来，放置在一个独立的数据段里，并把该段的属性设置为共享。
在VC6中有三种形式的MFC DLL（在该DLL中可以使用和继承已有的MFC类)可供选择，即Regular statically linked to MFC DLL（标准静态链接MFC DLL）和Regular using the shared MFC DLL（标准动态链接MFC DLL）以及Extension MFC DLL（扩展MFC DLL）。第一种DLL的特点是，在编译时把使用的MFC代码加入到DLL中，因此，在使用该程序时不需要其他MFC动态链接类库的存在，但占用磁盘空间比较大；第二种DLL的特点是，在运行时，动态链接到MFC类库，因此减少了空间的占用，但是在运行时却依赖于MFC动态链接类库；这两种DLL既可以被MFC程序使用也可以被Win32程序使用。第三种DLL的特点类似于第二种，做为MFC类库的扩展，只能被MFC程序使用。
下面说说在VC6中全局共享数据的实现
在主文件中，用#pragma data_seg建立一个新的数据段并定义共享数据，其具体格式为：
#pragma data_seg （"shareddata")
HWND sharedwnd=NULL;//共享数据
#pragma data_seg()
仅定义一个数据段还不能达到共享数据的目的，还要告诉编译器该段的属性，有两种方法可以实现该目的（其效果是相同的），一种方法是在.DEF文件中加入如下语句：
SETCTIONS shareddata READ WRITE SHARED
另一种方法是在项目设置链接选项中加入如下语句：
/SECTION:shareddata,rws
好了，准备知识已经学完了，让我们开始编写个全局的钩子程序吧！
由于全局钩子函数必须包含在动态链接库中，所以本例由两个程序体来实现。1．建立钩子Mousehook.DLL
(1)选择MFC AppWIzard(DLL)创建项目Mousehook；
(2)选择MFC Extension DLL（共享MFC拷贝）类型；
(3)由于VC5没有现成的钩子类，所以要在项目目录中创建Mousehook.h文件，在其中建立钩子类：
class AFX_eXT_CLASS Cmousehook:public CObject
{
publIc:
Cmousehook();
//钩子类的构造函数
~Cmousehook();
//钩子类的析构函数
BOOL starthook(HWND hWnd);
//安装钩子函数
BOOL stophook();
卸载钩子函数
};
(4)在Mousehook.app文件的顶部加入#include"Mousehook.h"语句；
(5)加入全局共享数据变量：
#pragma data_seg("mydata")
HWND glhPrevTarWnd=NULL;
//上次鼠标所指的窗口句柄
HWND glhDisplayWnd=NULL;
//显示目标窗口标题编辑框的句柄
HHOOK glhHook=NULL;
//安装的鼠标钩子句柄
HINSTANCE glhInstance=NULL;
//DLL实例句柄
#pragma data_seg()
(6)在DEF文件中定义段属性：
SECTIONS
mydata REAd wrITE SHARED
(7)在主文件Mousehook.cpp的DllMain函数中加入保存DLL实例句柄的语句：
DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved) {
//如果使用lpReserved参数则删除下面这行
UNREFERENCED_PARAMETER(lpReserved);
if (dwReason == DLL_prOCESS_A TTACH)
{
TRACE0("MOUSEHOOK.DLL Initializing!\n");
//扩展DLL仅初始化一次
if (!AfxInitExtensionModule(MousehookDLL, hInstance))
return 0;
new CDynLInkLibrary(MousehookDLL);
//把DLL加入动态MFC类库中
glhInstance=hInstance;
//插入保存DLL实例句柄
}
else if (dwReason == DLL_prOCESS_DETACH)
{
TRACE0("MOUSEHOOK.DLL Terminating!\n");
//终止这个链接库前调用它
AfxTermExtensionModule(MousehookDLL);
}
return 1;
}
(8)类Cmousehook的成员函数的具体实现：
Cmousehook::Cmousehook()
//类构造函数
{
}
Cmousehook::~Cmousehook()
//类析构函数
{
stophook();
}
BOOL Cmousehook::starthook(HWND hWnd)
//安装钩子并设定接收显示窗口句柄
{
BOOL bResult=FALSE;
glhHook=SetWindowsHookEx(WH_MOUSE,MouseProc,glhInstance,0);
If(glhHook!=NULL)
bResult=TRUE;
glhDisplayWnd=hWnd;
//设置显示目标窗口标题编辑框的句柄
return bResult;
}
BOOL Cmousehook::stophook()
//卸载钩子
{
BOOL bResult=FALSE;
If(glhHook)
{
bResult= UnhookWindowshookEx(glhHook);
If(bResult)
{
glhPrevTarWnd=NULL;
glhDisplayWnd=NULL;//清变量
glhHook=NULL;
}
}
return bResult;
}
(9)钩子函数的实现：
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);
//取目标窗口标题
if(IsWindow(glhDisplayWnd))
SendMessage(glhDisplayWnd,WM_SETTEXT,0,(LPARAM)(LPCTSTR)szCaption); glhPrevTarWnd=glhTargetWnd;
//保存目标窗口
}
}
return CallNextHookEx(glhHook,nCode,wparam,lparam);
//继续传递消息
}
(10)编译项目生成mouSehook.dll。
2．创建钩子可执行程序
(1)用MFC的AppWIzard(EXE)创建项目Mouse；
(2)选择“基于对话应用”并按下“完成”键；
(3)编辑对话框，删除其中原有的两个按钮，加入静态文本框和编辑框，用鼠标右键点击静态文本框，在弹出的菜单中选择“属性”，设置其标题为“鼠标所在的窗口标题”；
(4)在Mouse.h中加入对Mousehook.h的包含语句#Include"..\Mousehook\Mousehook.h"；
(5)在CMouseDlg.h的CMouseDlg类定义中添加私有数据成员：
CMouseHook m_hook;//加入钩子类作为数据成员
(6)修改CmouseDlg::OnInitDialog()函数：
BOOL CMouseDlg::OnInitDialog()
{
CDialog::OnInitDialog();
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
ASSERT(IDM_ABOUTBOX <0xF000);
CMenu* pSysMenu = GetSystemMenu(FALSE);
if (pSysMenu != NULL)
{
CString strAboutMenu;
strAboutMenu.LoadString(idS_ABOUTBOX);
if (!strAboutMenu.IsEmpty())
{
pSysMenu->AppendMenu(Mf_SEPARA TOR);
pSysMenu->AppendMenu(MF_sTRING, IDM_ABOUTBOX, strAboutMenu);
}
}
SetIcon(m_hIcon, TRUE);//Set big Icon
SetIcon(m_hIcon, FALSE);//Set small icon
//TODO: Add extra initialization here
CWnd * pwnd=GetDlgitem(IDC_EDIT1);
//取得编辑框的类指针
m_hook.starthook(pwnd->GetSafeHwnd());
//取得编辑框的窗口句柄并安装钩子
return TRUE;
//return TRUE unless you set the focus to a control
}
(7)链接DLL库，即把..\Mousehook\debug\Mousehook.lib加入到项目设置链接标签中；
(8)编译项目生成可执行文件；
(9)把Mousehook.DLL拷贝到..\mouse\debug目录中；
(10)先运行几个可执行程序，然后运行Mouse.exe程序，把鼠标在不同窗口中移动，在Mouse.exe程序窗口中的编辑框内将显示出鼠标所在的应用程序主窗口的标题
记一次键盘记录器的编写
新建win32项目 键盘记录器的思路 1.窗口消息处理的框架 一注册窗口类 MyRegisterClass 二实例化并创建窗口 InitInstance 三处理窗口消息 WndProc 2.改造窗口,让它隐藏 3.1 WM_CREATE是窗口创建函数 3.2 WM_DESTROY是窗口关闭函数 建立之初，程序默认窗口是显示的，所以会建立一个ShowWindow(hWnd, nCmdShow); 我们要让他隐藏，那就要改第二个参数ShowWindow(hWnd, SW_HIDE); 3.让这个程序运行起来了就开始监控按键操作,程序结束了就结束监控. 那么我们怎么知道程序什么时刻运行起来了呢，我们是根据其窗口的创建与关闭来判断 在建立项目之初，他没有帮我们写WM_CREATE函数，所以在处理窗口消息部分WndProc 中写入case WM_CREATE: …………………… //这一部分就是窗口建立之后所运行的程序，我们在这一部分就
开始 //写我们所要实现的记录功能，我们称之为钩子函数。 以下为建立钩子程序 这个函数我们要在解决方案里重新新建一个空项目keyhook，后选择动态程序dll（动态加载，而不是 直接运行），实现这个功能，我们只要在这里调用函数即可 在建立keyhook项目完成后要新建一个头文件和cpp文件，来实现钩子的功能 接下来在头文件自己定义两个函数来启动钩子bool installhook(); 和关闭钩子bool uninstallhook(); 并且复制到cpp文件中， 注意：要让其他文件用到这两个函数，必须要在头文件中将两个函数改写成 extern"C"_declspec(dllexport) bool installhook(); “C”是指这是c语言代码 _declspec是一个函数 dllexport参数是动态库导出 要在键盘记录器的cpp文件中使用这两个函数，所以要包含其头文件，注意，由于所要包含的是一个动态库，所以是#pragma comment(lib,"keyhook")，而不是以前的#include，除此之外还要导入动态库中的函数，也就是将函数在声明一遍，记住要改dllexport成dllimport，因为这是导入，不是导出，如下 #pragma comment(lib,"keyhook")//导入动态库 //导入动态库中的函数 //启动钩子 extern"C"_declspec(dllimport) bool installhook(); //自己定义的函数 //关闭钩子 extern"C"_declspec(dllimport) bool uninstallhook(); 然后就开始写钩子程序 要实现以下功能 //获取用户的按键消息 用到SetWindowsHookEx函数，要包含Windows.h的头文件 SetWindowsHookEx(WH_KEYBOARD,keyProc,GetModuleHandle(L"keyhook"),NULL); 第一个参数代表的是我们要获取键盘的消息 第二个参数就是自己定义的函数，就是监控这个消息之后你要做什么事情（在这里就是同时获取当前窗口的标题并同时获取当前按下的按键文本并保存到文件中），这个函数的类型是HOOKPROC，按下F12后是typedef LRESULT (CALLBACK* HOOKPROC)(int code, WPARAM wParam, LPARAM lParam); 在这里我们定义这个函数为keyProc来实现这两个功能但我们得要在头文件中声明这个函数，然后才能在cpp文件中使用 这个功能用如下程序来实现 LRESULT CALLBACK keyProc(int code, WPARAM wParam, LPARAM lParam){ char szWriteText[256]; //用来保存标题和文本 char szWindowTitle[256]; //保存标题 char szKeyText[256]; //保存文本 //并同时获取当前窗口的标题
c#钩子实例
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.sodocs.net/doc/5914673538.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();
游戏辅助制作原理
游戏辅助制作原理 目录 一、前言 (1) 二、认识辅助 (1) 三、辅助技术综述 (2) 动作模拟技术 (2) 封包技术 (9) 结束语 (13) 一、前言 游戏外辅程序，可以协助玩家自动产生游戏动作、修改游戏网络数据包以及修改游戏内存数据等，以实现玩家用最少的时间和金钱去完成功力升级和过关斩将。虽然，现在对游戏辅助程序的“合法”身份众说纷纭，在这里我不想对此发表任何个人意见，让时间去说明一切吧。 不管游戏辅助程序是不是“合法”身份，但是它却是具有一定的技术含量的，在这些小小程序中使用了许多高端技术，如拦截Sock技术、拦截API技术、模拟键盘与鼠标技术、直接修改程序内存技术等等。本文将对常见的游戏辅助中使用的技术进行全面剖析。 二、认识辅助 游戏辅助的历史可以追溯到单机版游戏时代，只不过当时它使用了另一个更通俗易懂的名字——游戏修改器。它可以在游戏中追踪锁定游戏主人公的各项能力数值。这样玩家在游戏中可以达到主角不掉血、不耗费魔法、不消耗金钱等目的。这样降低了游戏的难度，使得玩家更容易通关。 随着网络游戏的时代的来临，游戏辅助在原有的功能之上进行了新的发展，它变得更加多种多样，功能更加强大，操作更加简单，以至有些游戏的辅助已经成为一个体系，比如《石器时代》，辅助品种达到了几十种，自动战斗、自动行走、自动练级、自动补血、加速、不遇敌、原地遇敌、快速增加经验值、按键精灵……几乎无所不包。 游戏辅助的设计主要是针对于某个游戏开发的，我们可以根据它针对的游戏的类型可大致可将辅助分为两种大类。 一类是将游戏中大量繁琐和无聊的攻击动作使用辅助自动完成，以帮助玩家轻松搞定攻击对象并可以快速的增加玩家的经验值。比如在《龙族》中有一种工作的设定，玩家的工作等级越高，就可以驾驭越好的装备。但是增加工作等级却不是一件有趣的事情，毋宁说是重复枯燥的机械劳动。如果你想做法师用的杖，首先需要做基本工作--?砍树。砍树的方法很
消息钩子函数入门篇.docx
消息钩子函数入门篇 Windows系统是建立在事件驱动的机制上的，说穿了就 是整个系统都是通过消息的传递来实现的。而钩子是Windows系统中非常重要的系统接口，用它可以截获并处理送给其他应用程序的消息，来完成普通应用程序难以实现的功能。钩子可以监视系统或进程中的各种事件消息，截获发往目标窗口的消息并进行处理。这样，我们就可以在系统中安装自定义的钩子，监视系统中特定事件的发生，完成特定的功能，比如截获键盘、鼠标的输入，屏幕取词, 日志监视等等。可见，利用钩子可以实现许多特殊而有用的功能。因此，对于高级编程人员来说，掌握钩子的编程方法是很有必要的。 钩子的类型 一.按事件分类，有如下的几种常用类型 (1)键盘钩子和低级键盘钩子可以监视各种键盘消 /息、O (2)鼠标钩子和低级鼠标钩子可以监视各种鼠标消息。 (3)外壳钩子可以监视各种Shell事件消息。比如启动和关闭应用程序。 (4)日志钩子可以记录从系统消息队列中取出的各种 事件消息。 (5)窗口过程钩子监视所有从系统消息队列发往目标窗口的
消息。 此外，还有一些特定事件的钩子提供给我们使用，不列举。 下面描述常用的Hook类型： 1、WH_CA LLWNDPROC 和WH_CALLWND PROCRETHoo ks WH_CAL LWNDPROC 和W H_CALLWNDP ROCRETHook s 使你可以监视发送到窗口过程的消息。系统在消息发送到接收窗口过程之前调用WH_C ALLWNDPROC Hook子程，并且在窗口过程处理完消息之后调用WH_CALL WNDPR0 CR ETHook 子程。W H_CALLWNDP ROCRETHook 传递指针到CWPRE TSTRUCT 结构，再传递到Hook 子程。CWPRETSTR UCT 结构包含了来自处理消息的窗口过程的返回值，同样也包括了与这个消息关联的消息参数。 2、WH_CB THook 在以下事件之前，系统都会调用WH_CBTHoo k子程，这些事件包括： 1.激活，建立，销毁，最小化，最大化，移动，改变尺寸等窗口事件； 2.完成系统指令； 3.来自系统消息队列中的移动鼠标，键盘事件； 4.设置输入焦点事件; 5 ?同步系统消息队列事件。
VB 钩子详解
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语言键盘钩子
在开始贴这段垃圾代码以前，先给大家道个歉，也先扇自己一巴掌。本来说好昨天把代码搞好的，谁知道还没开始整，就过了１２点了，食言了。 代码还没有怎么写好，先把关键代码粘贴出来，等今天晚上把代码整理好，功能完善了再修改这个文章，顺便把写程序的过程、遇到的问题以及关键思路写出来。 下面是ＤＬＬ的关键代码（Ｃ语言编写，考虑ＤＬＬ的兼容性）： //////////////////////////////////// //keyhook.c //作用：DLL主文件 //作者:zaroty //时间：2008年9月9日0:54:39 //博客：https://www.sodocs.net/doc/5914673538.html,/zaroty /////////////////////////////////// #define _WIN32_WINNT 0x0500 //底层钩子需要设置系统版本号 #include
第4章钩子函数和窗口子类化
第4章钩子函数和窗口子类化 钩子是操作系统消息处理的一种机制。通过钩子，应用程序可以安装一个钩子回调过程让系统调用，从而监视系统中的消息队列，在这些消息到达目标窗口之前对这些消息进行处理。 本章主要介绍钩子函数的基本概念以及几种常用钩子的应用举例。 4.1 钩子函数 早在Windows3.x的时候，就有了钩子函数，它经历了Windows9x/NT/2000/XP/2003各个操作系统，始终保持了最大的兼容性。可以说大部分的钩子函数适用于现在所有的Win32操作系统，钩子函数在系统编程方面有着广泛的应用前景。 首先应该承认钩子会降低系统的性能，因为它增加系统处理每一个消息的开销，所以用户除非必要才安装钩子，而且还要尽可能早地去除钩子。 操作系统支持多种类型的钩子，每种类型都提供了它特有的消息处理机制，比如应用程序使用WH_MOUSE钩子只能监视鼠标的消息队列。对于每种类型的钩子，系统都维护一个各自独立的钩子链，钩子链是一个指向用户提供的回调函数钩子过程的链表指针。当与特定类型的钩子相关的窗口消息发生时，系统会把消息依次传递给钩子链中的每一个回调过程，传递的过程由用户定义的回调过程实现。一般情况下，用户提供的钩子回调过程必须调用钩子链中的下一个回调过程。否则钩子处理可能会中断，出现不可预测的结果。钩子过程可以监视窗口消息，也可以修改甚至停止钩子消息的继续传递，不让它到达钩子链中的下一个目标过程。 钩子过程需要用户调用SetWindowsHookEx函数进行安装。钩子过程一般遵循下面的调用规范。 LRESULT CALLBACK HookProc(intnCode,WPARAMwParam,LPARAMlParam);其中HookProc是应用程序提供的函数名。nCode参数是一个钩子标识码，钩子过程会利用它决定下一步进行的操作。这个标识码的值与安装的钩子类型有关。每种类型都有它的自身定义。后面两个参数的定义依赖于nCode参数，一般用于存放与窗口消息相关的内容。SetWindowsHookEx函数会自动安装一个钩子过程，这个过程位于钩子链表的头部，最后安装的钩子函数总是最先得到响应。前面的钩子处理过程可以决定是否调用钩子链中的下一个过程，这可以通过调用CallNextHookEx函数实现。 注意：某些钩子类型能够监视发生的窗口消息系统自动把消息依次传递给钩子链中的每一个钩子过程，而不管用户是否调用CallNextHookEx函数。 全局钩子会监视同一桌面环境下所有的窗口消息，而线程钩子只能监视单个线程内发生的消息。由于全局钩子能够在同一桌面的所有应用环境下调用，所有这个钩子过程必须在一个动态链接库中实现。 注意：全局钩子一般只用于调试目的，应尽可能地避免使用。全局钩子会显著地降低系统的性能，增加系统的开销，并可能会与安装同一全局钩子的应用程序发生冲突。钩子函数的处理应该尽可能简单，并要快速退出。对于处理复杂的过程，可以借助于发送异步处理窗口消息的方式实现。 操作系统提供了以下一些钩子，这些钩子允许用户监视系统消息处理的某一个方面。如表4-1所示： 安装钩子函数要用到SetWindowsHookEx函数。对于全局钩子而言，钩子过程必须在一个动态链接库模块中实现，这个过程必须作为动态链接库的输出函数，以便能够在安装钩子程序中通过调用LoadLibrary/GetProcAddress函数获得回调过程的地址，然后把回调函数的地址传递给SetWindowsHookEx函数。 HOOK PROC hkprcSys Msg; Static HINSTANCE hinstDLL; Static HHOOK hhookSysMsg; hinstDLL=LoadLibrary((LPCTSTR)"c:\\windows\\sysmsg.dll");
Python中使用PyHook监听鼠标和键盘事件实例
Python中使用PyHook监听鼠标和键盘事件实例 PyHook是一个基于Python的“钩子”库，主要用于监听当前电脑上鼠标和键盘的事件。这个库依赖于另一个Python库PyWin32，如同名字所显示的，PyWin32只能运行在Windows平台，所以PyHook也只能运行在Windows平台。关于PyHook的使用，在它的官方主页上就有一个简单的教程，大体上来说，可以这样使用 ?123456789101112131415161718192021222324252627282930 313233343536373839404142434445464748495051525354555 6 # -*- coding: utf-8 -*- # 3import pythoncom 4import pyHook 5def onMouseEvent(event): # 监听鼠标事件print "MessageName:",event.MessageName print "Message:", event.Message print "Time:", event.Time print "Window:", event.Window print "WindowName:", event.WindowName print "Position:", event.Position print "Wheel:", event.Wheel print "Injected:", event.Injected print"---" # 返回
True 以便将事件传给其它处理程序# 注意，这儿如果返回False ，则鼠标事件将被全部拦截# 也就是说你的鼠标看起来会僵在那儿，似乎失去响应了return True 23def onKeyboardEvent(event): # 监听键盘事件print "MessageName:", event.MessageName print "Message:", event.Message print "Time:", event.Time print "Window:", event.Window print "WindowName:", event.WindowName print "Ascii:", event.Ascii, chr(event.Ascii) print "Key:", event.Key print "KeyID:", event.KeyID print "ScanCode:", event.ScanCode print "Extended:", event.Extended print "Injected:", event.Injected print "Alt", event.Alt print "Transition", event.Transition print "---" # 同鼠标事件监听函数的返回值return True 42def main(): # 创建一个“钩子”管理对象hm = pyHook.HookManager() # 监听所有键盘事件 hm.KeyDown = onKeyboardEvent # 设置键盘“钩子”hm.HookKeyboard() # 监听所有鼠标事件 hm.MouseAll = onMouseEvent # 设置鼠标“钩子”hm.HookMouse() # 进入循环，如不手动关闭，程序将一直处于监听状态pythoncom.PumpMessages() 56if __name__ == "__main__": main()
综合课程设计报告--键盘输入截获系统的设计与实现
综合课程设计报告--键盘输入截获系统的设计与实现
键盘输入截获系统的设计与实现 摘要 Windows系统键盘截获系统，在我们的生活中是很常见的，比如在军方的某些系统中，为确保某些机密信息不被泄露出去，就要求在工作人员在于外界交流的时候，无意中输出的可能隐含机密信息不被发送出去，此时可以设置关键字，使用钩子来屏蔽这些信息，不让其发送出去，这样就很好的杜绝了机密信息的泄露的发生，提高军方系统的安全性，以上是一个很常见的例子，那么当提及到Windows系统信息截获，不得不想到动态链接库和钩子，动态链接库在Windows 系统中无处不在，编程过程中，调用的所有的API都是从系统动态链接库导出的，实际上，不使用动态链接库几乎是不可能的，因为Windows 提供给编程人员的几乎所有功能都驻留在动态链接库中。 Windows 应用程序的运行模块是基于消息驱动的，任何线程只要注册了窗口类都会有一个消息队列来接收用户的输入消息和系统消息。为了取得特定线程接收或者发送的消息，就要用到Windows提供的钩子。Windows钩子广泛应用
于各种检测侦查程序中，如输入监视、API截获等。一般的钩子函数都必须写在动态链接库中，以便注入到其进程。 一、需求分析 1、实验要求： 设计一个基于Windows或Linux的键盘输入捕获系统，对特定键盘输入进行检测过滤。要求如下： （1）设计一个键盘钩子程序捕获键盘动作，捕获任意窗口上的键盘输入，并进行记录； （2）能监控QQ、MSN、word、Excel、记事本、IE网页等应用程序； （3）设置一些关键词，根据键盘输入，设计一种关键词检测的方法，能在记录的键盘输入中检测出关键词出现的位置； （4）对输入的关键词，进行过滤，阻止其在相关的应用程序中输出； 2、实验环境： Microsoft Visual studio 2010 二、实验分组情况： 三、实验原理概述： 钩子：钩子是Windows中可以拦截事件的一种机制，可以指定一个函数作为特定类型的 被拦截事件的钩子过程。钩子过程可以对 拦截的每个事件进行处理。不同类型的钩 子可以为消息处理机制的不同方面提供 访问，例如，WH_MOUSE钩子可以监视与 鼠标操作相关的消息。系统为每一个类型 的钩子维护一个独立的钩子链，其中包含 指定一组作为钩子过程的回调函数指针。 当与指定类型的钩子相关联的消息发生
C#键盘钩子拦截键盘按键
C#键盘钩子，本文以C#语言为例，演示拦截键盘按键。首先打开VS创建一个窗体应用程序。如图： 需要引入以下两个命名空间。 using System.Runtime.InteropServices; using System.Diagnostics; 以下是全部源码： using System; using System.Collections.Generic; using https://www.sodocs.net/doc/5914673538.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子哩?，?监à控?整?个?系μ统?
用VB实现的全局键盘钩子
用VB实现的全局键盘钩子 2010-04-06 13:30 代码功能：实时监测Caps Lock、NumLock、Scroll Lock三个按件的状态，并显示在Label1 Label2 Label3三个标签中 '.bas模块中 Public m_hDllKbdHook As Long 'public variable holding 'the handle to the hook procedure Public Const WH_KEYBOARD_LL As Long = 13 'enables monitoring of keyboard 'input events about to be posted 'in a thread input queue Private Const HC_ACTION As Long = 0 'wParam and lParam parameters 'contain information about a 'keyboard message Public Const VK_CAPITAL As Long = &H14 Public Const VK_NUMLOCK As Long = &H90 Public Const VK_SCROLL As Long = &H91 Private Const LLKHF_UP As Long = &H80& 'test the transition-state flag Public Type KeyboardBytes kbByte(0 To 255) As Byte End Type Private Type KBDLLHOOKSTRUCT vkCode As Long 'a virtual-key code in the range 1 to 254 scanCode As Long 'hardware scan code for the key flags As Long 'specifies the extended-key flag, 'event-injected flag, context code, 'and transition-state flag time As Long 'time stamp for this message dwExtraInfo As Long 'extra info associated with the message End Type 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
钩子函数捕捉键盘消息
利用钩子函数来捕捉键盘响应的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、
C#键盘钩子实现全局快捷键
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);
VC++如何编写键盘钩子
系统钩子和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); 最后，完成以上提到的这几个函数的具体编码实现：