钩子技术、HOOK技术应用（三）

最新推荐文章于 2021-09-27 15:08:01 发布
最新推荐文章于 2021-09-27 15:08:01 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： VC++ 文章标签： hook null callback keyboard access file
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yc_8301/article/details/1897804
版权

下文是参考
http://blog.csdn.net/jayky/archive/2006/11/16/1388212.aspx
而改写的。。。

钩取输入法的例子

      最近用键盘钩子截获字符输入时是截不到特殊字符的,比方说中文输入法之类的.后来用到了消息钩子去HOOK WM_IME_CHAR,这时候大部分已经能够获取了,但是对于其他一些程序,比方说WORD之类的也就不能截获了.后来到MSDN上查到, 要用到WM_IME_COMPOSITION消息,并且在处理该消息时要用到IMM的一些库函数从输入法数据区中获取.比方说ImmGetContext,ImmGetCompositionString等等.
以下是源代码:

#define HC_IME_COPYDATA WM_USER+100
#define SH_IMMMESSAGE -3

HookProc UserMouseHookCallback = NULL;
HookProc UserKeyboardHookCallback = NULL;
HookProc UseImeMessageHookCallback = NULL;
HookProc SystemHookCallback = NULL;

HHOOK hookMouse = NULL;
HHOOK hookKeyboard = NULL;
HHOOK hookImeMessage = NULL;
HHOOK hookSystem = NULL;

//
// Store the application instance of this module to pass to
// hook initialization. This is set in DLLMain().
//
HINSTANCE g_appInstance = NULL;

MessageFilter mouseFilter;
MessageFilter keyboardFilter;
MessageFilter imeFilter;

static LRESULT CALLBACK InternalKeyboardHookCallback(int code, WPARAM wparam, LPARAM lparam);
static LRESULT CALLBACK InternalMouseHookCallback(int code, WPARAM wparam, LPARAM lparam);
static LRESULT CALLBACK InternalImeMessageHookCallback(int code, WPARAM wparam, LPARAM lparam);

// 仅内部用
static LRESULT CALLBACK privateImeMessageHookCallback(int code, WPARAM wparam, LPARAM lparam);

extern HINSTANCE g_appInstance;

BOOL APIENTRY DllMain(HINSTANCE hinstDLL, DWORD ul_reason_for_call, LPVOID lpReserved)
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
        //
        // Capture the application instance of this module to pass to
        // hook initialization.
        //
        if (g_appInstance == NULL)
        {
            g_appInstance = hinstDLL;
        }
        break;

    case DLL_THREAD_ATTACH:
        break;

    case DLL_THREAD_DETACH:
        break;

    case DLL_PROCESS_DETACH:
        break;

    default:
        OutputDebugString("Not sure what just happened./n");
        break;
    }

    return TRUE;
}

static HANDLE SetSystemHookHandler()
{
    // 在当前进程做一个局部钩子接受其它进程钩子发来的消息
    HANDLE hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS,FALSE,"SystemHookHandler");
    if (hMap == NULL)
    {
        hMap = CreateFileMapping((HANDLE)0xFFFFFFFF,NULL,PAGE_READWRITE,0,1024,"SystemHookHandler");
    }

    LPVOID lpMapAddr = MapViewOfFile(hMap,FILE_MAP_ALL_ACCESS, 0,0,0);
    DWORD tid = GetCurrentThreadId();//GetCurrentProcessId();
    char data[50];
    sprintf(data,"%ul",tid);
    memcpy(lpMapAddr,data,strlen(data));
    FlushViewOfFile(lpMapAddr,strlen(data)+1);
    UnmapViewOfFile(hMap);

    return hMap;
}

static DWORD GetSystemHookHandler()
{
    HANDLE hMap = OpenFileMapping(FILE_MAP_READ, 0, "SystemHookHandler");
    if (hMap == NULL)return NULL;
    LPVOID lpMapAddr = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0);
    DWORD tid = atol((char*)lpMapAddr);
    UnmapViewOfFile(hMap);
    return tid;
}


int SetUserHookCallback(HookProc userProc, UINT hookID)
{   

    if (userProc == NULL)
    {
        return HookCoreErrors::SetCallBack::ARGUMENT_ERROR;
    }

    if (hookID == WH_KEYBOARD_LL)//键盘
    {
        if (UserKeyboardHookCallback != NULL)
        {
            return HookCoreErrors::SetCallBack::ALREADY_SET;
        }

        UserKeyboardHookCallback = userProc;
        keyboardFilter.Clear();
        return HookCoreErrors::SetCallBack::SUCCESS;
    }
    else if (hookID == WH_MOUSE_LL)//鼠标
    {
        if (UserMouseHookCallback != NULL)
        {
            return HookCoreErrors::SetCallBack::ALREADY_SET;
        }

        UserMouseHookCallback = userProc;
        mouseFilter.Clear();
        return HookCoreErrors::SetCallBack::SUCCESS;
    }
    else if (hookID == SH_IMMMESSAGE)//输入法
    {
        if (UseImeMessageHookCallback != NULL)
        {
            return HookCoreErrors::SetCallBack::ALREADY_SET;
        }

        if (SetSystemHookHandler() == NULL)
        {
            return HookCoreErrors::SetCallBack::HANDLE_ERROR;
        }

        hookSystem = SetWindowsHookEx(3, (HOOKPROC)privateImeMessageHookCallback, g_appInstance, 0);
        if (hookSystem != NULL)
        {
            UseImeMessageHookCallback = userProc;
            imeFilter.Clear();
            return HookCoreErrors::SetCallBack::SUCCESS;
        }

        return HookCoreErrors::SetCallBack::HANDLE_ERROR;
    }

    return HookCoreErrors::SetCallBack::NOT_IMPLEMENTED;
}

bool InitializeHook(UINT hookID, int threadID)
{
    if (g_appInstance == NULL)
    {
        return false;
    }

    if (hookID == WH_KEYBOARD_LL)
    {
        if (UserKeyboardHookCallback == NULL)
        {
            return false;
        }

        hookKeyboard = SetWindowsHookEx(hookID, (HOOKPROC)InternalKeyboardHookCallback, g_appInstance, threadID);
        return hookKeyboard != NULL;
    }
    else if (hookID == WH_MOUSE_LL)
    {
        if (UserMouseHookCallback == NULL)
        {
            return false;
        }

        hookMouse = SetWindowsHookEx(hookID, (HOOKPROC)InternalMouseHookCallback, g_appInstance, threadID);
        return hookMouse != NULL;
    }
    else if (hookID == SH_IMMMESSAGE)
    {
        if (UseImeMessageHookCallback == NULL)
        {
            return false;
        }

        hookImeMessage = SetWindowsHookEx(3, (HOOKPROC)InternalImeMessageHookCallback, g_appInstance, threadID);
        return hookImeMessage != NULL;
    }

    return false;
}

void UninitializeHook(UINT hookID)
{

    if (hookID == WH_KEYBOARD_LL)
    {
        if (hookKeyboard != NULL)
        {
            UnhookWindowsHookEx(hookKeyboard);
        }
        hookKeyboard = NULL;
    }
    else if (hookID == WH_MOUSE_LL)
    {
        if (hookMouse != NULL)
        {
            UnhookWindowsHookEx(hookMouse);
        }
        hookMouse = NULL;
    }
    else if (hookID == SH_IMMMESSAGE)
    {
        if (hookImeMessage != NULL)
        {
            UnhookWindowsHookEx(hookImeMessage);
        }
        hookImeMessage = NULL;


    }

}

void Dispose(UINT hookID)
{
    if (hookID == WH_KEYBOARD_LL)
    {
        UserKeyboardHookCallback = NULL;
    }
    else if (hookID == WH_MOUSE_LL)
    {
        UserMouseHookCallback = NULL;
    }
    else if (hookID == SH_IMMMESSAGE)
    {
        UseImeMessageHookCallback = NULL;

        // 关闭内部的消息循环
        if (hookSystem != NULL)
        {
            UnhookWindowsHookEx(hookSystem);
        }
        hookSystem = NULL;
    }


}

int FilterMessage(UINT hookID, int message)
{
    if (hookID == WH_KEYBOARD_LL)
    {
        if (keyboardFilter.AddMessage(message))
        {
            return HookCoreErrors::FilterMessage::SUCCESS;
        }
        else
        {
            return HookCoreErrors::FilterMessage::FAILED;
        }
    }
    else if (hookID == WH_MOUSE_LL)
    {
        if(mouseFilter.AddMessage(message))
        {
            return HookCoreErrors::FilterMessage::SUCCESS;
        }
        else
        {
            return HookCoreErrors::FilterMessage::FAILED;
        }
    }
    else if (hookID == SH_IMMMESSAGE)
    {
        if(imeFilter.AddMessage(message))
        {
            return HookCoreErrors::FilterMessage::SUCCESS;
        }
        else
        {
            return HookCoreErrors::FilterMessage::FAILED;
        }
    }

    return HookCoreErrors::FilterMessage::NOT_IMPLEMENTED;
}

static LRESULT CALLBACK InternalMouseHookCallback(int code, WPARAM wparam, LPARAM lparam)
{
    if (code < 0)
    {
        return CallNextHookEx(hookMouse, code, wparam, lparam);
    }

    if (UserMouseHookCallback != NULL && !mouseFilter.IsFiltered((int)wparam))
    {
        UserMouseHookCallback(code, wparam, lparam);
    }

    return CallNextHookEx(hookMouse, code, wparam, lparam);
}

static LRESULT CALLBACK InternalKeyboardHookCallback(int code, WPARAM wparam, LPARAM lparam)
{
    if (code < 0)
    {
        return CallNextHookEx(hookKeyboard, code, wparam, lparam);
    }

    if (UserKeyboardHookCallback != NULL && !keyboardFilter.IsFiltered((int)wparam))
    {
        UserKeyboardHookCallback(code, wparam, lparam);
    }

    return CallNextHookEx(hookKeyboard, code, wparam, lparam);
}

static void IntenralGetMessageReading(LPTSTR msg)
{
    HANDLE m_hMapFile =  OpenFileMapping(FILE_MAP_ALL_ACCESS,FALSE,"InternalImeMessageHookCallback");
    if (m_hMapFile != NULL)
    {
        LPTSTR lpMapAddr = (LPTSTR)MapViewOfFile(m_hMapFile,FILE_MAP_ALL_ACCESS,0,0,0);
        return;
    }
}
static bool isProcess = false;

static LRESULT CALLBACK InternalImeMessageHookCallback(int code, WPARAM wparam, LPARAM lparam)
{
    if (code < 0)
    {
        return CallNextHookEx(hookImeMessage, code, wparam, lparam);
    }

    PMSG pmsg = (PMSG)lparam;
    if (pmsg->message == WM_KEYUP && isProcess)
    {
        //if(pmsg->wParam == VK_SPACE || pmsg->wParam == VK_RETURN){

            // 强制false，
            // 否则有可能在接下来的无WM_KEYDOWN消息情况下产生WM_KEYUP
            isProcess = false;

            // 发送给处理进程处理消息
            DWORD tid = GetSystemHookHandler();

            if (tid != NULL)
            {
                HIMC hIMC;
                HWND hWnd=pmsg->hwnd;
                DWORD dwSize;

                char lpstr[20];
                //先获取当前正在输入的窗口的输入法句柄
                hIMC = ImmGetContext(hWnd);

                // 先将ImmGetCompositionString的获取长度设为0来获取字符串大小.
                dwSize = ImmGetCompositionString(hIMC, GCS_RESULTSTR, NULL, 0);

                // 缓冲区大小要加上字符串的NULL结束符大小,
                // 考虑到UNICODE
                dwSize += sizeof(WCHAR);

                memset(lpstr, 0, 20);

                // 再调用一次.ImmGetCompositionString获取字符串
                ImmGetCompositionString(hIMC, GCS_RESULTSTR, lpstr, dwSize);

                // 现在lpstr里面即是输入的汉字了。你可以处理lpstr,当然也可以保存为文件...
                bool isEmpty = true;
                for(int i=0;i<20;i++)
                {
                    if (lpstr[i] != '/0')
                        isEmpty = false;
                }
                if (!isEmpty)
                {
                    // 保存在共享内存并返回指向共享内存的
                    HANDLE m_hMapFile = OpenFileMapping(FILE_MAP_ALL_ACCESS,FALSE,"ImeMessage");
                    if (m_hMapFile == NULL)
                    {
                        //创建共享文件。
                        m_hMapFile = CreateFileMapping( (HANDLE)0xFFFFFFFF,NULL,PAGE_READWRITE,0,20,"ImeMessage");
                    }
                    //拷贝数据到共享文件里。
                    LPTSTR lpMapAddr = (LPTSTR)MapViewOfFile(m_hMapFile,FILE_MAP_ALL_ACCESS,0,0,0);
                    memset(lpMapAddr,0,20);
                    memcpy(lpMapAddr, lpstr,strlen(lpstr));
                    FlushViewOfFile(lpMapAddr,strlen(lpstr)+1);
                    UnmapViewOfFile(m_hMapFile);
                    ImmReleaseContext(hWnd, hIMC);

                    // 通知接受
                    PostThreadMessage(tid,HC_IME_COPYDATA,(WPARAM)(&pmsg->hwnd),lparam);
                }
            }
        //}
    }
    else if (pmsg->message == WM_KEYDOWN)
    {
        if(pmsg->wParam == VK_PROCESSKEY)
        {
            isProcess= true;
        }
        else
        {
            isProcess = false;
        }
    }
    else if (pmsg->message == WM_CHAR && !isProcess)
    {
        //if(pmsg->wParam != VK_SPACE && pmsg->wParam != VK_RETURN){

        // 发送给处理进程处理消息
        DWORD tid = GetSystemHookHandler();

        if (tid != NULL)
        {
            // 保存在共享内存并返回指向共享内存的
            HANDLE m_hMapFile = OpenFileMapping(FILE_MAP_ALL_ACCESS,FALSE,"ImeMessage");
            if (m_hMapFile == NULL)
            {
                //创建共享文件。
                m_hMapFile = CreateFileMapping( (HANDLE)0xFFFFFFFF,NULL,PAGE_READWRITE,0,20,"ImeMessage");
            }
            //拷贝数据到共享文件里。
            LPTSTR lpMapAddr = (LPTSTR)MapViewOfFile(m_hMapFile,FILE_MAP_ALL_ACCESS,0,0,0);
            memset(lpMapAddr,0,20);
            char lpstr[2];
            lpstr[0] = (char)pmsg->wParam;
            lpstr[1] = '/0';
            memcpy(lpMapAddr, lpstr,strlen(lpstr));
            FlushViewOfFile(lpMapAddr,strlen(lpstr)+1);
            UnmapViewOfFile(m_hMapFile);

            // 通知接受
            PostThreadMessage(tid,HC_IME_COPYDATA,(WPARAM)(&pmsg->hwnd),lparam);
        }
        //}
    }

    return CallNextHookEx(hookImeMessage, code, wparam, lparam);

}

static int imeCount = 0;

static LRESULT CALLBACK privateImeMessageHookCallback(int code, WPARAM wparam, LPARAM lparam)
{
    if (code >= 0)
    {
        // 接受挂载进程发到当前进程上的消息
        PMSG pmsg = (PMSG)lparam;
        if (pmsg->message == HC_IME_COPYDATA)
        {
            if (imeCount % 2 != 0)
            {
                imeCount = 0;
            }
            else
            {
                imeCount++;

                if (UseImeMessageHookCallback != NULL && !imeFilter.IsFiltered((int)wparam))
                {
                    UseImeMessageHookCallback(code, pmsg->wParam, lparam);
                }

            }

        }
    }

    return CallNextHookEx(hookImeMessage, code, wparam, lparam);
}
HOOK学习笔记与心得
码莎拉蒂
10-27 4442
一、  Hook介绍 钩子(Hook)，是Windows消息处理机制的一个平台,应用程序可以在上面设置子程以监视指定窗口的某种消息，而且所监视的窗口可以是其他进程所创建的。当消息到达后，在目标窗口处理函数之前处理它。钩子机制允许应用程序截获处理window消息或特定事件。  我们知道Windows系统API函数都是被封装到DLL中，在某个应用程序要调用一个API函数的时候，如果这个函数所在的D
hook 打开对话框路径_使用OpenFileDialog调用打开对话框
weixin_39775127的博客
12-19 359
使用OpenFileDialog调用打开对话框 【实例介绍】本实例使用OpenFileDialog对话框浏览文件。 运行程序，单击“打开文 件”按钮，在弹出的“打开”对话框中选择文件， 路径在Label控件中显示，文件内容显示在TextBox 控件中。结果如图1.27所示。 【开发过程】(1) 创建一个Windows应用程序，项目名称为Ex025,窗体默认为Forml。(2) 在窗体中添加Butt...
简单的hook技术应用
02-23
学习hook的时候的一个小东西.对hook想认识的人不妨下载高手们就不用看了.
hook的应用场景
hkduan的博客
07-21 1026
vue hook应用场景: 实现了mixins的功能，并且解决了mixins的两个问题 允许相互传递状态 明确指出了逻辑来自哪里 使用 Hooks，函数的返回值会记录消费的值。 vue-hooks是简化组件定义、复用状态逻辑的一种最新尝试，且结合 Vue 实例的特点提供了适用的 Hooks hooks.js中的this为当前vue实例 react-hooks hooks只能出现在函数作用域的顶级，不能出现在条件语句、循环语句中、嵌套函数中。 一、父组件监测其他组件的生命周期 <Child @hook:
钩子hook技术
06-08
钩子Hook技术详解 钩子（Hook）是一种特殊的消息处理机制，允许开发者截获并处理Windows系统中的各种事件消息。钩子可以监视系统或进程中的各种事件消息，截获发往目标窗口的消息并进行处理，从而达到特定的功能，...
用SEH技术实现APIHook钩子
03-28
API Hook是一种广泛使用的逆向工程和系统监控技术，它允许开发者拦截并控制特定API（应用程序接口）调用的行为。在Windows环境中，有多种方法来实现API Hook，其中一种是使用结构化异常处理（Structured Exception ...
c++钩子函数：copy hook_linux函数hook
12-27
在IT领域，钩子函数（Hook Function）是一种高级技术，常用于系统监控、调试和拦截特定事件。在C++编程中，我们可以利用钩子来跟踪和控制程序的行为，例如在这个场景下，我们关注的是文件复制操作。"copy hook"特指...
ApiHook钩子和封包拦截技术.zip
03-28
**APIHook钩子技术** API钩子是一种技术，它允许程序员在其他程序调用特定API函数时插入自定义代码，以改变或监控API函数的行为。这种技术的核心是将钩子函数替换或插入到原始API函数的调用链中。API钩子通常分为几...
Qt键盘钩子Hook技术实现与应用
在了解以上知识点后，开发者在使用此资源时应注意以下几点：确保使用此键盘钩子技术不侵犯他人隐私或违反相关法律法规。在编写相关程序时，应当考虑到程序的合法性和道德规范，避免非法监听键盘事件。同时，由于描述...
易语言 拦截文件读写 APIhook
05-06
易语言 拦截文件读写 APIhook 拦截打开文件 拦截文件读入 拦截取文件长度 拦截文件读写位置
hook技术的应用-过某平台作弊检测
weixin_34272308的博客
12-08 1228
上回书说完检测方法就戛然而止了，这篇文章就来谈谈如何过检测。 首先回顾一下平台对作弊的检测方法，检测开始前平台准备一个单位列表，在列表中，有玩家可见的单位和玩家视野外的单位。 地图脚本会强迫玩家点击每个在列表里的单位。 如果玩家选中了不可见的单位（视野外或者隐身单位）或者玩家没有选中可见单位 都会提高作弊的置信程度 1 for _,__0x0150__ in ipairs(__0x7...
浅谈HOOK
weixin_30347009的博客
03-22 279
摘要： 本文针对HOOK技术在VC编程中的应用进行讨论，并着重对应用比较广泛的全局HOOK做了阐述。　　一、引言　　Windows操作系统是建立在事件驱动机制之上的，系统各部分之间的沟通也都是通过消息的相互传递而实现的。但在通常情况下，应用程序只能处理来自进程内部的消息或是从其他进程发过来的消息，如果需要对在进程外传递的消息进行拦截处理就必须采取一种被称为HOOK（钩子）的技术。钩子是Window...
黑客爱用的HOOK技术大揭秘！
MachineGunJoe666
09-27 3156
什么是HOOK技术？ 病毒木马为何惨遭杀软拦截？ 商业软件为何频遭免费破解？ 系统漏洞为何能被补丁修复？ 这一切的背后到底是人性的扭曲，还是道德的沦丧，尽请收看今天的专题文章：《什么是HOOK技术？》 上面是开个玩笑，言归正传，今天来聊的话题就是安全领域一个非常重要的技术：HOOK技术。 HOOK，英文意思是“钩子” 在计算机编程中，HOOK是一种「劫持」程序原有执行流程，添加额外处理逻辑的一种技术。 按照这个定义，其实我们Python中的装饰器和Java中的注解，这种面向切面编程的手法在某种程度上来说，
Hook技术看这篇就够了
热门推荐
shoneworn的专栏
05-28 3万+
    相信很多搞机的朋友都玩过Xposed, 它实现了很多不可思议的功能。它是怎么实现的呢？这里就得提到我们的Hook技术了。    关于 Android 中的 Hook 机制，大致有两个方式：   要 root 权限，直接 Hook 系统，可以干掉所有的 App。   免 root 权限，但是只能 Hook 自身，对系统其它 App 无能为力。    时间所限，这里不展开了。    知识点： ...
编程中老有人问hook是什么
watertekhqx的博客
05-06 1万+
HOOK就是传说中的钩子，用于劫持消息，在windows中是这样的，因为win32程序是以消息机制为基础的，比如你点击鼠标，会给窗口传递一个消息，移动鼠标，会给窗口一个消息，用钩子可以比你的窗口先检测到这个消息，从而得到这个消息进行处理，你的窗口可能就处理不到这个消息了，要看你的钩子处理程序是否把这个消息传给窗口，具体看WIN32应用程序开发吧。               随着Andro
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值