精华内容
下载资源
问答
  • 屏幕取词原理.doc 屏幕取词原理.doc 屏幕取词原理.doc 屏幕取词原理.doc
  • 屏幕取词原理

    2011-12-28 00:48:44
    给出屏幕取词的一种C#实现,可供学习者尝试
  • 屏幕取词原理 -- HOOK消息功能的使用
  • 屏幕取词原理与实现

    2013-06-01 23:38:37
    屏幕取词原理与实现,介绍了windows环境下的屏幕取词技术的核心。
  • 鼠标屏幕取词原理

    千次阅读 2006-07-28 00:22:00
    鼠标屏幕取词 原理“鼠标屏幕取词”技术是在电子字典中得到广泛地应用的,如四通利方和金山词霸等软件,这个技术看似简单,其实在windows系统中实现却是非常复杂的,总的来说有两种实现方式: 第一种:采用截获对...
    鼠标屏幕取词 原理
    “鼠标屏幕取词”技术是在电子字典中得到广泛地应用的,如四通利方和金山词霸等软件,这个技术看似简单,其实在windows系统中实现却是非常复杂的,总的来说有两种实现方式:
    第一种:采用截获对部分gdi的api调用来实现,如textout,textouta等。
    第二种:对每个设备上下文(dc)做一分copy,并跟踪所有修改上下文(dc)的操作。
    第二种方法更强大,但兼容性不好,而第一种方法使用的截获windowsapi的调用,这项技术的强大可能远远超出了您的想象,毫不夸张的说,利用windowsapi拦截技术,你可以改造整个操作系统,事实上很多外挂式windows中文平台就是这么实现的!而这项技术也正是这篇文章的主题。
    截windowsapi的调用,具体的说来也可以分为两种方法:
    第一种方法通过直接改写winapi 在内存中的映像,嵌入汇编代码,使之被调用时跳转到指定的地址运行来截获;第二种方法则改写iat(import address table 输入地址表),重定向winapi函数的调用来实现对winapi的截获。
    第一种方法的实现较为繁琐,而且在win95、98下面更有难度,这是因为虽然微软说win16的api只是为了兼容性才保留下来,程序员应该尽可能地调用32位的api,实际上根本就不是这样!win 9x内部的大部分32位api经过变换调用了同名的16位api,也就是说我们需要在拦截的函数中嵌入16位汇编代码!
    我们将要介绍的是第二种拦截方法,这种方法在win95、98和nt下面运行都比较稳定,兼容性较好。由于需要用到关于windows虚拟内存的管理、打破进程边界墙、向应用程序的进程空间中注入代码、pe(portable executable)文件格式和iat(输入地址表)等较底层的知识,所以我们先对涉及到的这些知识大概地做一个介绍,最后会给出拦截部分的关键代码。
    先说windows虚拟内存的管理。windows9x给每一个进程分配了4gb的地址空间,对于nt来说,这个数字是2gb,系统保留了2gb到 4gb之间的地址空间禁止进程访问,而在win9x中,2gb到4gb这部分虚拟地址空间实际上是由所有的win32进程所共享的,这部分地址空间加载了共享win32 dll、内存映射文件和vxd、内存管理器和文件系统码,win9x中这部分对于每一个进程都是可见的,这也是win9x操作系统不够健壮的原因。win9x中为16位操作系统保留了0到4mb的地址空间,而在4mb到2gb之间也就是win32进程私有的地址空间,由于 每个进程的地址空间都是相对独立的,也就是说,如果程序想截获其它进程中的api调用,就必须打破进程边界墙,向其它的进程中注入截获api调用的代码,这项工作我们交给钩子函数(setwindowshookex)来完成,关于如何创建一个包含系统钩子的动态链接库,《电脑高手杂志》在第?期已经有过专题介绍了,这里就不赘述了。所有系统钩子的函数必须要在动态库里,这样的话,当进程隐式或显式调用一个动态库里的函数时,系统会把这个动态库映射到这个进程的虚拟地址空间里,这使得dll成为进程的一部分,以这个进程的身份执行,使用这个进程的堆栈,也就是说动态链接库中的代码被钩子函数注入了其它gui进程的地址空间(非gui进程,钩子函数就无能为力了),
    当包含钩子的dll注入其它进程后,就可以取得映射到这个进程虚拟内存里的各个模块(exe和dll)的基地址,如:
    hmodule hmodule=getmodulehandle(“mypro.exe”);
    在mfc程序中,我们可以用afxgetinstancehandle()函数来得到模块的基地址。exe和dll被映射到虚拟内存空间的什么地方是由它们的基地址决定的。它们的基地址是在链接时由链接器决定的。当你新建一个win32工程时,vc++链接器使用缺省的基地址0x00400000。可以通过链接器的base选项改变模块的基地址。exe通常被映射到虚拟内存的0x00400000处,dll也随之有不同的基地址,通常被映射到不同进程
    的相同的虚拟地址空间处。
    系统将exe和dll原封不动映射到虚拟内存空间中,它们在内存中的结构与磁盘上的静态文件结构是一样的。即pe (portable executable) 文件格式。我们得到了进程模块的基地址以后,就可以根据pe文件的格式穷举这个模块的image_import_descriptor数组,看看进程空间中是否引入了我们需要截获的函数所在的动态链接库,比如需要截获“textouta”,就必须检查“gdi32.dll”是否被引入了。说到这里,我们有必要介绍一下pe文件的格式,如右图,这是pe文件格式的大致框图,最前面是文件头,我们不必理会,从pe file optional header后面开始,就是文件中各个段的说明,说明后面才是真正的段数据,而实际上我们关心的只有一个段,那就是“.idata”段,这个段中包含了所有的引入函数信息,还有iat(import address table)的rva(relative virtual address)地址。
    说到这里,截获windowsapi的整个原理就要真相大白了。实际上所有进程对给定的api函数的调用总是通过pe文件的一个地方来转移的,这就是一个该模块(可以是exe或dll)的“.idata”段中的iat输入地址表(import address table)。在那里有所有本模块调用的其它dll的函数名及地址。对其它dll的函数调用实际上只是跳转到输入地址表,由输入地址表再跳转到dll真正的函数入口。

    具体来说,我们将通过image_import_descriptor数组来访问“.idata”段中引入的dll的信息,然后通过image_thunk_data数组来针对一个被引入的dll访问该dll中被引入的每个函数的信息,找到我们需要截获的函数的跳转地址,然后改成我们自己的函数的地址……具体的做法在后面的关键代码中会有详细的讲解。
    讲了这么多原理,现在让我们回到“鼠标屏幕取词”的专题上来。除了api函数的截获,要实现“鼠标屏幕取词”,还需要做一些其它的工作,简单的说来,可以把一个完整的取词过程归纳成以下几个步骤:
    1. 安装鼠标钩子,通过钩子函数获得鼠标消息。
    使用到的api函数:setwindowshookex
    2. 得到鼠标的当前位置,向鼠标下的窗口发重画消息,让它调用系统函数重画窗口。
    使用到的api函数:windowfrompoint,screentoclient,invalidaterect
    3. 截获对系统函数的调用,取得参数,也就是我们要取的词。
    对于大多数的windows应用程序来说,如果要取词,我们需要截获的是“gdi32.dll”中的“textouta”函数。
    我们先仿照textouta函数写一个自己的mytextouta函数,如:
    bool winapi mytextouta(hdc hdc, int nxstart, int nystart, lpcstr lpszstring,int cbstring)
    {
    // 这里进行输出lpszstring的处理
    // 然后调用正版的textouta函数
    }
    把这个函数放在安装了钩子的动态连接库中,然后调用我们最后给出的hookimportfunction函数来截获进程
    对textouta函数的调用,跳转到我们的mytextouta函数,完成对输出字符串的捕捉。hookimportfunction的
    用法:
    hookfuncdesc hd;
    proc porigfuns;
    hd.szfunc="textouta";
    hd.pproc=(proc)mytextouta;
    hookimportfunction (afxgetinstancehandle(),"gdi32.dll",&hd,porigfuns);
    下面给出了hookimportfunction的源代码,相信详尽的注释一定不会让您觉得理解截获到底是怎么实现的
    很难,ok,let’s go:

    / begin ///
    #include <crtdbg.h>

    // 这里定义了一个产生指针的宏
    #define makeptr(cast, ptr, addvalue) (cast)((dword)(ptr)+(dword)(addvalue))

    // 定义了hookfuncdesc结构,我们用这个结构作为参数传给hookimportfunction函数
    typedef struct tag_hookfuncdesc
    {
    lpcstr szfunc; // the name of the function to hook.
    proc pproc; // the procedure to blast in.
    } hookfuncdesc , * lphookfuncdesc;

    // 这个函数监测当前系统是否是windownt
    bool isnt();

    // 这个函数得到hmodule -- 即我们需要截获的函数所在的dll模块的引入描述符(import descriptor)
    pimage_import_descriptor getnamedimportdescriptor(hmodule hmodule, lpcstr szimportmodule);

    // 我们的主函数
    bool hookimportfunction(hmodule hmodule, lpcstr szimportmodule,
    lphookfuncdesc pahookfunc, proc* paorigfuncs)
    {
    /// 下面的代码检测参数的有效性
    _assert(szimportmodule);
    _assert(!isbadreadptr(pahookfunc, sizeof(hookfuncdesc)));
    #ifdef _debug
    if (paorigfuncs) _assert(!isbadwriteptr(paorigfuncs, sizeof(proc)));
    _assert(pahookfunc.szfunc);
    _assert(*pahookfunc.szfunc != '/0');
    _assert(!isbadcodeptr(pahookfunc.pproc));
    #endif
    if ((szimportmodule == null) || (isbadreadptr(pahookfunc, sizeof(hookfuncdesc))))
    {
    _assert(false);
    setlasterrorex(error_invalid_parameter, sle_error);
    return false;
    }
    //

    // 监测当前模块是否是在2gb虚拟内存空间之上
    // 这部分的地址内存是属于win32进程共享的
    if (!isnt() && ((dword)hmodule >= 0x80000000))
    {
    _assert(false);
    setlasterrorex(error_invalid_handle, sle_error);
    return false;
    }
    // 清零
    if (paorigfuncs) memset(paorigfuncs, null, sizeof(proc));

    // 调用getnamedimportdescriptor()函数,来得到hmodule -- 即我们需要
    // 截获的函数所在的dll模块的引入描述符(import descriptor)
    pimage_import_descriptor pimportdesc = getnamedimportdescriptor(hmodule, szimportmodule);
    if (pimportdesc == null)
    return false; // 若为空,则模块未被当前进程所引入

    // 从dll模块中得到原始的thunk信息,因为pimportdesc->firstthunk数组中的原始信息已经
    // 在应用程序引入该dll时覆盖上了所有的引入信息,所以我们需要通过取得pimportdesc->originalfirstthunk
    // 指针来访问引入函数名等信息
    pimage_thunk_data porigthunk = makeptr(pimage_thunk_data, hmodule,
    pimportdesc->originalfirstthunk);

    // 从pimportdesc->firstthunk得到image_thunk_data数组的指针,由于这里在dll被引入时已经填充了
    // 所有的引入信息,所以真正的截获实际上正是在这里进行的
    pimage_thunk_data prealthunk = makeptr(pimage_thunk_data, hmodule, pimportdesc->firstthunk);

    // 穷举image_thunk_data数组,寻找我们需要截获的函数,这是最关键的部分!
    while (porigthunk->u1.function)
    {
    // 只寻找那些按函数名而不是序号引入的函数
    if (image_ordinal_flag != (porigthunk->u1.ordinal & image_ordinal_flag))
    {
    // 得到引入函数的函数名
    pimage_import_by_name pbyname = makeptr(pimage_import_by_name, hmodule,
    porigthunk->u1.addressofdata);

    // 如果函数名以null开始,跳过,继续下一个函数
    if ('/0' == pbyname->name[0])
    continue;

    // bdohook用来检查是否截获成功
    bool bdohook = false;

    // 检查是否当前函数是我们需要截获的函数
    if ((pahookfunc.szfunc[0] == pbyname->name[0]) &&
    (strcmpi(pahookfunc.szfunc, (char*)pbyname->name) == 0))
    {
    // 找到了!
    if (pahookfunc.pproc)
    bdohook = true;
    }
    if (bdohook)
    {
    // 我们已经找到了所要截获的函数,那么就开始动手吧
    // 首先要做的是改变这一块虚拟内存的内存保护状态,让我们可以自由存取
    memory_basic_information mbi_thunk;
    virtualquery(prealthunk, &mbi_thunk, sizeof(memory_basic_information));
    _assert(virtualprotect(mbi_thunk.baseaddress, mbi_thunk.regionsize,
    page_readwrite, &mbi_thunk.protect));

    // 保存我们所要截获的函数的正确跳转地址
    if (paorigfuncs)
    paorigfuncs = (proc)prealthunk->u1.function;

    // 将image_thunk_data数组中的函数跳转地址改写为我们自己的函数地址!
    // 以后所有进程对这个系统函数的所有调用都将成为对我们自己编写的函数的调用
    prealthunk->u1.function = (pdword)pahookfunc.pproc;

    // 操作完毕!将这一块虚拟内存改回原来的保护状态
    dword dwoldprotect;
    _assert(virtualprotect(mbi_thunk.baseaddress, mbi_thunk.regionsize,
    mbi_thunk.protect, &dwoldprotect));
    setlasterror(error_success);
    return true;
    }
    }
    // 访问image_thunk_data数组中的下一个元素
    porigthunk++;
    prealthunk++;
    }
    return true;
    }

    // getnamedimportdescriptor函数的实现
    pimage_import_descriptor getnamedimportdescriptor(hmodule hmodule, lpcstr szimportmodule)
    {
    // 检测参数
    _assert(szimportmodule);
    _assert(hmodule);
    if ((szimportmodule == null) || (hmodule == null))
    {
    _assert(false);
    setlasterrorex(error_invalid_parameter, sle_error);
    return null;
    }

    // 得到dos文件头
    pimage_dos_header pdosheader = (pimage_dos_header) hmodule;

    // 检测是否mz文件头
    if (isbadreadptr(pdosheader, sizeof(image_dos_header)) ||
    (pdosheader->e_magic != image_dos_signature))
    {
    _assert(false);
    setlasterrorex(error_invalid_parameter, sle_error);
    return null;
    }

    // 取得pe文件头
    pimage_nt_headers pntheader = makeptr(pimage_nt_headers, pdosheader, pdosheader->e_lfanew);

    // 检测是否pe映像文件
    if (isbadreadptr(pntheader, sizeof(image_nt_headers)) ||
    (pntheader->signature != image_nt_signature))
    {
    _assert(false);
    setlasterrorex(error_invalid_parameter, sle_error);
    return null;
    }

    // 检查pe文件的引入段(即 .idata section)
    if (pntheader->optionalheader.datadirectory[image_directory_entry_import].virtualaddress == 0)
    return null;

    // 得到引入段(即 .idata section)的指针
    pimage_import_descriptor pimportdesc = makeptr(pimage_import_descriptor, pdosheader,
    pntheader->optionalheader.datadirectory[image_directory_entry_import].virtualaddress);

    // 穷举pimage_import_descriptor数组寻找我们需要截获的函数所在的模块
    while (pimportdesc->name)
    {
    pstr szcurrmod = makeptr(pstr, pdosheader, pimportdesc->name);
    if (stricmp(szcurrmod, szimportmodule) == 0)
    break; // 找到!中断循环
    // 下一个元素
    pimportdesc++;
    }

    // 如果没有找到,说明我们寻找的模块没有被当前的进程所引入!
    if (pimportdesc->name == null)
    return null;

    // 返回函数所找到的模块描述符(import descriptor)
    return pimportdesc;
    }

    // isnt()函数的实现
    bool isnt()
    {
    osversioninfo stosvi;
    memset(&stosvi, null, sizeof(osversioninfo));
    stosvi.dwosversioninfosize = sizeof(osversioninfo);
    bool bret = getversionex(&stosvi);
    _assert(true == bret);
    if (false == bret) return false;
    return (ver_platform_win32_nt == stosvi.dwplatformid);
    }
    /// end //

    不知道在这篇文章问世之前,有多少朋友尝试过去实现“鼠标屏幕取词”这项充满了挑战的技术,也只有尝试过的朋友才能体会到其间的不易,尤其在探索api函数的截获时,手头的几篇资料没有一篇是涉及到关键代码的,重要的地方都是一笔代过,msdn更是显得苍白而无力,也不知道除了image_import_descriptor和image_thunk_data,微软还隐藏了多少秘密,好在硬着头皮还是把它给攻克了,希望这篇文章对大家能有所帮助。 
    展开全文
  • 鼠标屏幕取词技术的原理和实现 “鼠标屏幕取词”技术是在电子字典中得到广泛地应用的,如四通利方和金山词霸等软件,这个技术看似简单,其实在WINDOWS系统中实现却是非常复杂的,总的来说有两种实现方式: 第一种:...
  • 鼠标屏幕取词 原理 (转)[@more@]“鼠标屏幕取词”技术是在电子字典中得到广泛地应用的,如四通利方和金山词霸等软件,这个技术看似简单,其实在windows系统中实现却是非常复杂的,总的来说有两种实现方式: 第一种:...
    鼠标屏幕取词 原理 (转)[@more@]

    “鼠标屏幕取词”技术是在电子字典中得到广泛地应用的,如四通利方和金山词霸等软件,这个技术看似简单,其实在windows系统中实现却是非常复杂的,总的来说有两种实现方式:
    第一种:采用截获对部分gdi的api调用来实现,如textout,textouta等。
    第二种:对每个设备上下文(dc)做一分copy,并跟踪所有修改上下文(dc)的操作。
    第二种方法更强大,但兼容性不好,而第一种方法使用的截获windowsapi的调用,这项技术的强大可能远远超出了您的想象,毫不夸张的说,利用windowsapi拦截技术,你可以改造整个操作系统,事实上很多外挂式windows中文平台就是这么实现的!而这项技术也正是这篇文章的主题。
    截windowsapi的调用,具体的说来也可以分为两种方法:
    第一种方法通过直接改写winapi 在内存中的映像,嵌入汇编代码,使之被调用时跳转到指定的地址运行来截获;第二种方法则改写iat(import address table 输入地址表),重定向winapi函数的调用来实现对winapi的截获。
    第一种方法的实现较为繁琐,而且在win95、98下面更有难度,这是因为虽然微软说win16的api只是为了兼容性才保留下来,程序员应该尽可能地调用32位的api,实际上根本就不是这样!win 9x内部的大部分32位api经过变换调用了同名的16位api,也就是说我们需要在拦截的函数中嵌入16位汇编代码!
    我们将要介绍的是第二种拦截方法,这种方法在win95、98和nt下面运行都比较稳定,兼容性较好。由于需要用到关于windows虚拟内存的管理、打破进程边界墙、向应用程序的进程空间中注入代码、pe(portable executable)文件格式和iat(输入地址表)等较底层的知识,所以我们先对涉及到的这些知识大概地做一个介绍,最后会给出拦截部分的关键代码。
    先说windows虚拟内存的管理。windows9x给每一个进程分配了4gb的地址空间,对于nt来说,这个数字是2gb,系统保留了2gb到 4gb之间的地址空间禁止进程访问,而在WIN9X中,2gb到4gb这部分虚拟地址空间实际上是由所有的win32进程所共享的,这部分地址空间加载了共享win32 dll、内存映射文件和vxd、内存管理器和文件系统码,win9x中这部分对于每一个进程都是可见的,这也是win9x操作系统不够健壮的原因。win9x中为16位操作系统保留了0到4mb的地址空间,而在4mb到2gb之间也就是win32进程私有的地址空间,由于 每个进程的地址空间都是相对独立的,也就是说,如果程序想截获其它进程中的api调用,就必须打破进程边界墙,向其它的进程中注入截获api调用的代码,这项工作我们交给钩子函数(setwindowshookex)来完成,关于如何创建一个包含系统钩子的动态链接库,《电脑高手杂志》在第?期已经有过专题介绍了,这里就不赘述了。所有系统钩子的函数必须要在动态库里,这样的话,当进程隐式或显式调用一个动态库里的函数时,系统会把这个动态库映射到这个进程的虚拟地址空间里,这使得dll成为进程的一部分,以这个进程的身份执行,使用这个进程的堆栈,也就是说动态链接库中的代码被钩子函数注入了其它gui进程的地址空间(非gui进程,钩子函数就无能为力了),
    当包含钩子的dll注入其它进程后,就可以取得映射到这个进程虚拟内存里的各个模块(exe和dll)的基地址,如:
    hmodule hmodule=getmodulehandle(“mypro.exe”);
    在mfc程序中,我们可以用afxgetinstancehandle()函数来得到模块的基地址。exe和dll被映射到虚拟内存空间的什么地方是由它们的基地址决定的。它们的基地址是在链接时由链接器决定的。当你新建一个win32工程时,vc++链接器使用缺省的基地址0x00400000。可以通过链接器的base选项改变模块的基地址。exe通常被映射到虚拟内存的0x00400000处,dll也随之有不同的基地址,通常被映射到不同进程
    的相同的虚拟地址空间处。
    系统将exe和dll原封不动映射到虚拟内存空间中,它们在内存中的结构与磁盘上的静态文件结构是一样的。即pe (portable executable) 文件格式。我们得到了进程模块的基地址以后,就可以根据pe文件的格式穷举这个模块的image_import_descriptor数组,看看进程空间中是否引入了我们需要截获的函数所在的动态链接库,比如需要截获“textouta”,就必须检查“gdi32.dll”是否被引入了。说到这里,我们有必要介绍一下pe文件的格式,如右图,这是pe文件格式的大致框图,最前面是文件头,我们不必理会,从pe file optional header后面开始,就是文件中各个段的说明,说明后面才是真正的段数据,而实际上我们关心的只有一个段,那就是“.idata”段,这个段中包含了所有的引入函数信息,还有iat(import address table)的rva(relative virtual address)地址。
    说到这里,截获windowsapi的整个原理就要真相大白了。实际上所有进程对给定的api函数的调用总是通过pe文件的一个地方来转移的,这就是一个该模块(可以是exe或dll)的“.idata”段中的iat输入地址表(import address table)。在那里有所有本模块调用的其它dll的函数名及地址。对其它dll的函数调用实际上只是跳转到输入地址表,由输入地址表再跳转到dll真正的函数入口。

    具体来说,我们将通过image_import_descriptor数组来访问“.idata”段中引入的dll的信息,然后通过image_thunk_data数组来针对一个被引入的dll访问该dll中被引入的每个函数的信息,找到我们需要截获的函数的跳转地址,然后改成我们自己的函数的地址……具体的做法在后面的关键代码中会有详细的讲解。
    讲了这么多原理,现在让我们回到“鼠标屏幕取词”的专题上来。除了api函数的截获,要实现“鼠标屏幕取词”,还需要做一些其它的工作,简单的说来,可以把一个完整的取词过程归纳成以下几个步骤:
    1. 安装鼠标钩子,通过钩子函数获得鼠标消息。
    使用到的api函数:setwindowshookex
    2. 得到鼠标的当前位置,向鼠标下的窗口发重画消息,让它调用系统函数重画窗口。
    使用到的api函数:windowfrompoint,screentoclient,invalidaterect
    3. 截获对系统函数的调用,取得参数,也就是我们要取的词。
    对于大多数的windows应用程序来说,如果要取词,我们需要截获的是“gdi32.dll”中的“textouta”函数。
    我们先仿照textouta函数写一个自己的mytextouta函数,如:
    bool winapi mytextouta(hdc hdc, int nxstart, int nystart, lpcstr lpszstring,int cbstring)
    {
    // 这里进行输出lpszstring的处理
    // 然后调用正版的textouta函数
    }
    把这个函数放在安装了钩子的动态连接库中,然后调用我们最后给出的hookimportfunction函数来截获进程
    对textouta函数的调用,跳转到我们的mytextouta函数,完成对输出字符串的捕捉。hookimportfunction的
    用法:
    hookfuncdesc hd;
    proc porigfuns;
    hd.szfunc="textouta";
    hd.pproc=(proc)mytextouta;
    hookimportfunction (afxgetinstancehandle(),"gdi32.dll",&hd,porigfuns);
    下面给出了hookimportfunction的源代码,相信详尽的注释一定不会让您觉得理解截获到底是怎么实现的
    很难,ok,let’s go:

    / begin ///
    #include dbg.h>

    // 这里定义了一个产生指针的宏
    #define makeptr(cast, ptr, addvalue) (cast)((dword)(ptr)+(dword)(addvalue))

    // 定义了hookfuncdesc结构,我们用这个结构作为参数传给hookimportfunction函数
    typedef struct tag_hookfuncdesc
    {
    lpcstr szfunc; // the name of the function to hook.
    proc pproc; // the procedure to blast in.
    } hookfuncdesc , * lphookfuncdesc;

    // 这个函数监测当前系统是否是windownt
    bool isnt();

    // 这个函数得到hmodule -- 即我们需要截获的函数所在的dll模块的引入描述符(import descriptor)
    pimage_import_descriptor getnamedimportdescriptor(hmodule hmodule, lpcstr szimportmodule);

    // 我们的主函数
    bool hookimportfunction(hmodule hmodule, lpcstr szimportmodule,
    lphookfuncdesc pahookfunc, proc* paorigfuncs)
    {
    /// 下面的代码检测参数的有效性
    _assert(szimportmodule);
    _assert(!isbadreadptr(pahookfunc, sizeof(hookfuncdesc)));
    #ifdef _debug
    if (paorigfuncs) _assert(!isbadwriteptr(paorigfuncs, sizeof(proc)));
    _assert(pahookfunc.szfunc);
    _assert(*pahookfunc.szfunc != ');
    _assert(!isbadcodeptr(pahookfunc.pproc));
    #endif
    if ((szimportmodule == null) || (isbadreadptr(pahookfunc, sizeof(hookfuncdesc))))
    {
    _assert(false);
    setlasterrorex(error_invalid_parameter, sle_error);
    return false;
    }
    //

    // 监测当前模块是否是在2gb虚拟内存空间之上
    // 这部分的地址内存是属于win32进程共享的
    if (!isnt() && ((dword)hmodule >= 0x80000000))
    {
    _assert(false);
    setlasterrorex(error_invalid_handle, sle_error);
    return false;
    }
    // 清零
    if (paorigfuncs) memset(paorigfuncs, null, sizeof(proc));

    // 调用getnamedimportdescriptor()函数,来得到hmodule -- 即我们需要
    // 截获的函数所在的dll模块的引入描述符(import descriptor)
    pimage_import_descriptor pimportdesc = getnamedimportdescriptor(hmodule, szimportmodule);
    if (pimportdesc == null)
    return false; // 若为空,则模块未被当前进程所引入

    // 从dll模块中得到原始的thunk信息,因为pimportdesc->firstthunk数组中的原始信息已经
    // 在应用程序引入该dll时覆盖上了所有的引入信息,所以我们需要通过取得pimportdesc->originalfirstthunk
    // 指针来访问引入函数名等信息
    pimage_thunk_data porigthunk = makeptr(pimage_thunk_data, hmodule,
    pimportdesc->originalfirstthunk);

    // 从pimportdesc->firstthunk得到image_thunk_data数组的指针,由于这里在dll被引入时已经填充了
    // 所有的引入信息,所以真正的截获实际上正是在这里进行的
    pimage_thunk_data prealthunk = makeptr(pimage_thunk_data, hmodule, pimportdesc->firstthunk);

    // 穷举image_thunk_data数组,寻找我们需要截获的函数,这是最关键的部分!
    while (porigthunk->u1.function)
    {
    // 只寻找那些按函数名而不是序号引入的函数
    if (image_ordinal_flag != (porigthunk->u1.ordinal & image_ordinal_flag))
    {
    // 得到引入函数的函数名
    pimage_import_by_name pbyname = makeptr(pimage_import_by_name, hmodule,
    porigthunk->u1.addressofdata);

    // 如果函数名以null开始,跳过,继续下一个函数
    if (' == pbyname->name[0])
    continue;

    // bdohook用来检查是否截获成功
    bool bdohook = false;

    // 检查是否当前函数是我们需要截获的函数
    if ((pahookfunc.szfunc[0] == pbyname->name[0]) &&
    (strcmpi(pahookfunc.szfunc, (char*)pbyname->name) == 0))
    {
    // 找到了!
    if (pahookfunc.pproc)
    bdohook = true;
    }
    if (bdohook)
    {
    // 我们已经找到了所要截获的函数,那么就开始动手吧
    // 首先要做的是改变这一块虚拟内存的内存保护状态,让我们可以自由存取
    memory_basic_information mbi_thunk;
    virtualquery(prealthunk, &mbi_thunk, sizeof(memory_basic_information));
    _assert(virtualprotect(mbi_thunk.baseaddress, mbi_thunk.regionsize,
    page_readwrite, &mbi_thunk.protect));

    // 保存我们所要截获的函数的正确跳转地址
    if (paorigfuncs)
    paorigfuncs = (proc)prealthunk->u1.function;

    // 将image_thunk_data数组中的函数跳转地址改写为我们自己的函数地址!
    // 以后所有进程对这个系统函数的所有调用都将成为对我们自己编写的函数的调用
    prealthunk->u1.function = (pdword)pahookfunc.pproc;

    // 操作完毕!将这一块虚拟内存改回原来的保护状态
    dword dwoldprotect;
    _assert(virtualprotect(mbi_thunk.baseaddress, mbi_thunk.regionsize,
    mbi_thunk.protect, &dwoldprotect));
    setlasterror(error_success);
    return true;
    }
    }
    // 访问image_thunk_data数组中的下一个元素
    porigthunk++;
    prealthunk++;
    }
    return true;
    }

    // getnamedimportdescriptor函数的实现
    pimage_import_descriptor getnamedimportdescriptor(hmodule hmodule, lpcstr szimportmodule)
    {
    // 检测参数
    _assert(szimportmodule);
    _assert(hmodule);
    if ((szimportmodule == null) || (hmodule == null))
    {
    _assert(false);
    setlasterrorex(error_invalid_parameter, sle_error);
    return null;
    }

    // 得到dos文件头
    pimage_dos_header pdosheader = (pimage_dos_header) hmodule;

    // 检测是否mz文件头
    if (isbadreadptr(pdosheader, sizeof(image_dos_header)) ||
    (pdosheader->e_magic != image_dos_signature))
    {
    _assert(false);
    setlasterrorex(error_invalid_parameter, sle_error);
    return null;
    }

    // 取得pe文件头
    pimage_nt_headers pntheader = makeptr(pimage_nt_headers, pdosheader, pdosheader->e_lfanew);

    // 检测是否pe映像文件
    if (isbadreadptr(pntheader, sizeof(image_nt_headers)) ||
    (pntheader->signature != image_nt_signature))
    {
    _assert(false);
    setlasterrorex(error_invalid_parameter, sle_error);
    return null;
    }

    // 检查pe文件的引入段(即 .idata section)
    if (pntheader->optionalheader.datadirectory[image_directory_entry_import].virtualaddress == 0)
    return null;

    // 得到引入段(即 .idata section)的指针
    pimage_import_descriptor pimportdesc = makeptr(pimage_import_descriptor, pdosheader,
    pntheader->optionalheader.datadirectory[image_directory_entry_import].virtualaddress);

    // 穷举pimage_import_descriptor数组寻找我们需要截获的函数所在的模块
    while (pimportdesc->name)
    {
    pstr szcurrmod = makeptr(pstr, pdosheader, pimportdesc->name);
    if (stricmp(szcurrmod, szimportmodule) == 0)
    break; // 找到!中断循环
    // 下一个元素
    pimportdesc++;
    }

    // 如果没有找到,说明我们寻找的模块没有被当前的进程所引入!
    if (pimportdesc->name == null)
    return null;

    // 返回函数所找到的模块描述符(import descriptor)
    return pimportdesc;
    }

    // isnt()函数的实现
    bool isnt()
    {
    osversioninfo stosvi;
    memset(&stosvi, null, sizeof(osversioninfo));
    stosvi.dwosversioninfosize = sizeof(osversioninfo);
    bool bret = getversionex(&stosvi);
    _assert(true == bret);
    if (false == bret) return false;
    return (ver_platform_win32_nt == stosvi.dwplatfoRmid);
    }
    /// end //

    不知道在这篇文章问世之前,有多少朋友尝试过去实现“鼠标屏幕取词”这项充满了挑战的技术,也只有尝试过的朋友才能体会到其间的不易,尤其在探索api函数的截获时,手头的几篇资料没有一篇是涉及到关键代码的,重要的地方都是一笔代过,msdn更是显得苍白而无力,也不知道除了image_import_descriptor和image_thunk_data,微软还隐藏了多少秘密,好在硬着头皮还是把它给攻克了,希望这篇文章对大家能有所帮助。



    中华技术网整理发布 sfocus.com">http://www.asfocus.com


    来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/10752043/viewspace-989455/,如需转载,请注明出处,否则将追究法律责任。

    转载于:http://blog.itpub.net/10752043/viewspace-989455/

    展开全文
  • 鼠标屏幕取词 原理

    2009-04-16 13:45:00
    鼠标屏幕取词”技术是在电子字典中得到广泛地应用的,如四通利方和金山词霸等软件,这个技术看似简单,其实在windows系统中实现却是非常复杂的,总的来说有两种实现方式: 第一种:采用截获对部分gdi的api调用来实现...

     鼠标屏幕取词”技术是在电子字典中得到广泛地应用的,如四通利方和金山词霸等软件,这个技术看似简单,其实在windows系统中实现却是非常复杂的,总的来说有两种实现方式:
    第一种:采用截获对部分gdi的api调用来实现,如textout,textouta等。
    第二种:对每个设备上下文(dc)做一分copy,并跟踪所有修改上下文(dc)的操作。
    第二种方法更强大,但兼容性不好,而第一种方法使用的截获windowsapi的调用,这项技术的强大可能远远超出了您的想象,毫不夸张的说,利用windowsapi拦截技术,你可以改造整个操作系统,事实上很多外挂式windows中文平台就是这么实现的!而这项技术也正是这篇文章的主题。
    截windowsapi的调用,具体的说来也可以分为两种方法:
    第一种方法通过直接改写winapi 在内存中的映像,嵌入汇编代码,使之被调用时跳转到指定的地址运行来截获;第二种方法则改写iat(import address table 输入地址表),重定向winapi函数的调用来实现对winapi的截获。
    第一种方法的实现较为繁琐,而且在win95、98下面更有难度,这是因为虽然微软说win16的api只是为了兼容性才保留下来,程序员应该尽可能地调用32位的api,实际上根本就不是这样!win 9x内部的大部分32位api经过变换调用了同名的16位api,也就是说我们需要在拦截的函数中嵌入16位汇编代码!
    我们将要介绍的是第二种拦截方法,这种方法在win95、98和nt下面运行都比较稳定,兼容性较好。由于需要用到关于windows虚拟内存的管理、打破进程边界墙、向应用程序的进程空间中注入代码、pe(portable executable)文件格式和iat(输入地址表)等较底层的知识,所以我们先对涉及到的这些知识大概地做一个介绍,最后会给出拦截部分的关键代码。
    先说windows虚拟内存的管理。windows9x给每一个进程分配了4gb的地址空间,对于nt来说,这个数字是2gb,系统保留了2gb到 4gb之间的地址空间禁止进程访问,而在win9x中,2gb到4gb这部分虚拟地址空间实际上是由所有的win32进程所共享的,这部分地址空间加载了共享win32 dll、内存映射文件和vxd、内存管理器和文件系统码,win9x中这部分对于每一个进程都是可见的,这也是win9x操作系统不够健壮的原因。win9x中为16位操作系统保留了0到4mb的地址空间,而在4mb到2gb之间也就是win32进程私有的地址空间,由于 每个进程的地址空间都是相对独立的,也就是说,如果程序想截获其它进程中的api调用,就必须打破进程边界墙,向其它的进程中注入截获api调用的代码,这项工作我们交给钩子函数(setwindowshookex)来完成,关于如何创建一个包含系统钩子的动态链接库,《电脑高手杂志》在第?期已经有过专题介绍了,这里就不赘述了。所有系统钩子的函数必须要在动态库里,这样的话,当进程隐式或显式调用一个动态库里的函数时,系统会把这个动态库映射到这个进程的虚拟地址空间里,这使得dll成为进程的一部分,以这个进程的身份执行,使用这个进程的堆栈,也就是说动态链接库中的代码被钩子函数注入了其它gui进程的地址空间(非gui进程,钩子函数就无能为力了),
    当包含钩子的dll注入其它进程后,就可以取得映射到这个进程虚拟内存里的各个模块(exe和dll)的基地址,如:
    hmodule hmodule=getmodulehandle(“mypro.exe”);
    在mfc程序中,我们可以用afxgetinstancehandle()函数来得到模块的基地址。exe和dll被映射到虚拟内存空间的什么地方是由它们的基地址决定的。它们的基地址是在链接时由链接器决定的。当你新建一个win32工程时,vc++链接器使用缺省的基地址0x00400000。可以通过链接器的base选项改变模块的基地址。exe通常被映射到虚拟内存的0x00400000处,dll也随之有不同的基地址,通常被映射到不同进程
    的相同的虚拟地址空间处。
    系统将exe和dll原封不动映射到虚拟内存空间中,它们在内存中的结构与磁盘上的静态文件结构是一样的。即pe (portable executable) 文件格式。我们得到了进程模块的基地址以后,就可以根据pe文件的格式穷举这个模块的image_import_descriptor数组,看看进程空间中是否引入了我们需要截获的函数所在的动态链接库,比如需要截获“textouta”,就必须检查“gdi32.dll”是否被引入了。说到这里,我们有必要介绍一下pe文件的格式,如右图,这是pe文件格式的大致框图,最前面是文件头,我们不必理会,从pe file optional header后面开始,就是文件中各个段的说明,说明后面才是真正的段数据,而实际上我们关心的只有一个段,那就是“.idata”段,这个段中包含了所有的引入函数信息,还有iat(import address table)的rva(relative virtual address)地址。
    说到这里,截获windowsapi的整个原理就要真相大白了。实际上所有进程对给定的api函数的调用总是通过pe文件的一个地方来转移的,这就是一个该模块(可以是exe或dll)的“.idata”段中的iat输入地址表(import address table)。在那里有所有本模块调用的其它dll的函数名及地址。对其它dll的函数调用实际上只是跳转到输入地址表,由输入地址表再跳转到dll真正的函数入口。

    具体来说,我们将通过image_import_descriptor数组来访问“.idata”段中引入的dll的信息,然后通过image_thunk_data数组来针对一个被引入的dll访问该dll中被引入的每个函数的信息,找到我们需要截获的函数的跳转地址,然后改成我们自己的函数的地址……具体的做法在后面的关键代码中会有详细的讲解。
    讲了这么多原理,现在让我们回到“鼠标屏幕取词”的专题上来。除了api函数的截获,要实现“鼠标屏幕取词”,还需要做一些其它的工作,简单的说来,可以把一个完整的取词过程归纳成以下几个步骤:
    1. 安装鼠标钩子,通过钩子函数获得鼠标消息。
    使用到的api函数:setwindowshookex
    2. 得到鼠标的当前位置,向鼠标下的窗口发重画消息,让它调用系统函数重画窗口。
    使用到的api函数:windowfrompoint,screentoclient,invalidaterect
    3. 截获对系统函数的调用,取得参数,也就是我们要取的词。
    对于大多数的windows应用程序来说,如果要取词,我们需要截获的是“gdi32.dll”中的“textouta”函数。
    我们先仿照textouta函数写一个自己的mytextouta函数,如:
    bool winapi mytextouta(hdc hdc, int nxstart, int nystart, lpcstr lpszstring,int cbstring)
    {
    // 这里进行输出lpszstring的处理
    // 然后调用正版的textouta函数
    }
    把这个函数放在安装了钩子的动态连接库中,然后调用我们最后给出的hookimportfunction函数来截获进程
    对textouta函数的调用,跳转到我们的mytextouta函数,完成对输出字符串的捕捉。hookimportfunction的
    用法:
    hookfuncdesc hd;
    proc porigfuns;
    hd.szfunc="textouta";
    hd.pproc=(proc)mytextouta;
    hookimportfunction (afxgetinstancehandle(),"gdi32.dll",&hd,porigfuns);
    下面给出了hookimportfunction的源代码,相信详尽的注释一定不会让您觉得理解截获到底是怎么实现的
    很难,ok,let’s go:

    / begin ///
    #include <crtdbg.h>

    // 这里定义了一个产生指针的宏
    #define makeptr(cast, ptr, addvalue) (cast)((dword)(ptr)+(dword)(addvalue))

    // 定义了hookfuncdesc结构,我们用这个结构作为参数传给hookimportfunction函数
    typedef struct tag_hookfuncdesc
    {
    lpcstr szfunc; // the name of the function to hook.
    proc pproc; // the procedure to blast in.
    } hookfuncdesc , * lphookfuncdesc;

    // 这个函数监测当前系统是否是windownt
    bool isnt();

    // 这个函数得到hmodule -- 即我们需要截获的函数所在的dll模块的引入描述符(import descriptor)
    pimage_import_descriptor getnamedimportdescriptor(hmodule hmodule, lpcstr szimportmodule);

    // 我们的主函数
    bool hookimportfunction(hmodule hmodule, lpcstr szimportmodule,
    lphookfuncdesc pahookfunc, proc* paorigfuncs)
    {
    /// 下面的代码检测参数的有效性
    _assert(szimportmodule);
    _assert(!isbadreadptr(pahookfunc, sizeof(hookfuncdesc)));
    #ifdef _debug
    if (paorigfuncs) _assert(!isbadwriteptr(paorigfuncs, sizeof(proc)));
    _assert(pahookfunc.szfunc);
    _assert(*pahookfunc.szfunc != '/0');
    _assert(!isbadcodeptr(pahookfunc.pproc));
    #endif
    if ((szimportmodule == null) || (isbadreadptr(pahookfunc, sizeof(hookfuncdesc))))
    {
    _assert(false);
    setlasterrorex(error_invalid_parameter, sle_error);
    return false;
    }
    //

    // 监测当前模块是否是在2gb虚拟内存空间之上
    // 这部分的地址内存是属于win32进程共享的
    if (!isnt() && ((dword)hmodule >= 0x80000000))
    {
    _assert(false);
    setlasterrorex(error_invalid_handle, sle_error);
    return false;
    }
    // 清零
    if (paorigfuncs) memset(paorigfuncs, null, sizeof(proc));

    // 调用getnamedimportdescriptor()函数,来得到hmodule -- 即我们需要
    // 截获的函数所在的dll模块的引入描述符(import descriptor)
    pimage_import_descriptor pimportdesc = getnamedimportdescriptor(hmodule, szimportmodule);
    if (pimportdesc == null)
    return false; // 若为空,则模块未被当前进程所引入

    // 从dll模块中得到原始的thunk信息,因为pimportdesc->firstthunk数组中的原始信息已经
    // 在应用程序引入该dll时覆盖上了所有的引入信息,所以我们需要通过取得pimportdesc->originalfirstthunk
    // 指针来访问引入函数名等信息
    pimage_thunk_data porigthunk = makeptr(pimage_thunk_data, hmodule,
    pimportdesc->originalfirstthunk);

    // 从pimportdesc->firstthunk得到image_thunk_data数组的指针,由于这里在dll被引入时已经填充了
    // 所有的引入信息,所以真正的截获实际上正是在这里进行的
    pimage_thunk_data prealthunk = makeptr(pimage_thunk_data, hmodule, pimportdesc->firstthunk);

    // 穷举image_thunk_data数组,寻找我们需要截获的函数,这是最关键的部分!
    while (porigthunk->u1.function)
    {
    // 只寻找那些按函数名而不是序号引入的函数
    if (image_ordinal_flag != (porigthunk->u1.ordinal & image_ordinal_flag))
    {
    // 得到引入函数的函数名
    pimage_import_by_name pbyname = makeptr(pimage_import_by_name, hmodule,
    porigthunk->u1.addressofdata);

    // 如果函数名以null开始,跳过,继续下一个函数
    if ('/0' == pbyname->name[0])
    continue;

    // bdohook用来检查是否截获成功
    bool bdohook = false;

    // 检查是否当前函数是我们需要截获的函数
    if ((pahookfunc.szfunc[0] == pbyname->name[0]) &&
    (strcmpi(pahookfunc.szfunc, (char*)pbyname->name) == 0))
    {
    // 找到了!
    if (pahookfunc.pproc)
    bdohook = true;
    }
    if (bdohook)
    {
    // 我们已经找到了所要截获的函数,那么就开始动手吧
    // 首先要做的是改变这一块虚拟内存的内存保护状态,让我们可以自由存取
    memory_basic_information mbi_thunk;
    virtualquery(prealthunk, &mbi_thunk, sizeof(memory_basic_information));
    _assert(virtualprotect(mbi_thunk.baseaddress, mbi_thunk.regionsize,
    page_readwrite, &mbi_thunk.protect));

    // 保存我们所要截获的函数的正确跳转地址
    if (paorigfuncs)
    paorigfuncs = (proc)prealthunk->u1.function;

    // 将image_thunk_data数组中的函数跳转地址改写为我们自己的函数地址!
    // 以后所有进程对这个系统函数的所有调用都将成为对我们自己编写的函数的调用
    prealthunk->u1.function = (pdword)pahookfunc.pproc;

    // 操作完毕!将这一块虚拟内存改回原来的保护状态
    dword dwoldprotect;
    _assert(virtualprotect(mbi_thunk.baseaddress, mbi_thunk.regionsize,
    mbi_thunk.protect, &dwoldprotect));
    setlasterror(error_success);
    return true;
    }
    }
    // 访问image_thunk_data数组中的下一个元素
    porigthunk++;
    prealthunk++;
    }
    return true;
    }

    // getnamedimportdescriptor函数的实现
    pimage_import_descriptor getnamedimportdescriptor(hmodule hmodule, lpcstr szimportmodule)
    {
    // 检测参数
    _assert(szimportmodule);
    _assert(hmodule);
    if ((szimportmodule == null) || (hmodule == null))
    {
    _assert(false);
    setlasterrorex(error_invalid_parameter, sle_error);
    return null;
    }

    // 得到dos文件头
    pimage_dos_header pdosheader = (pimage_dos_header) hmodule;

    // 检测是否mz文件头
    if (isbadreadptr(pdosheader, sizeof(image_dos_header)) ||
    (pdosheader->e_magic != image_dos_signature))
    {
    _assert(false);
    setlasterrorex(error_invalid_parameter, sle_error);
    return null;
    }

    // 取得pe文件头
    pimage_nt_headers pntheader = makeptr(pimage_nt_headers, pdosheader, pdosheader->e_lfanew);

    // 检测是否pe映像文件
    if (isbadreadptr(pntheader, sizeof(image_nt_headers)) ||
    (pntheader->signature != image_nt_signature))
    {
    _assert(false);
    setlasterrorex(error_invalid_parameter, sle_error);
    return null;
    }

    // 检查pe文件的引入段(即 .idata section)
    if (pntheader->optionalheader.datadirectory[image_directory_entry_import].virtualaddress == 0)
    return null;

    // 得到引入段(即 .idata section)的指针
    pimage_import_descriptor pimportdesc = makeptr(pimage_import_descriptor, pdosheader,
    pntheader->optionalheader.datadirectory[image_directory_entry_import].virtualaddress);

    // 穷举pimage_import_descriptor数组寻找我们需要截获的函数所在的模块
    while (pimportdesc->name)
    {
    pstr szcurrmod = makeptr(pstr, pdosheader, pimportdesc->name);
    if (stricmp(szcurrmod, szimportmodule) == 0)
    break; // 找到!中断循环
    // 下一个元素
    pimportdesc++;
    }

    // 如果没有找到,说明我们寻找的模块没有被当前的进程所引入!
    if (pimportdesc->name == null)
    return null;

    // 返回函数所找到的模块描述符(import descriptor)
    return pimportdesc;
    }

    // isnt()函数的实现
    bool isnt()
    {
    osversioninfo stosvi;
    memset(&stosvi, null, sizeof(osversioninfo));
    stosvi.dwosversioninfosize = sizeof(osversioninfo);
    bool bret = getversionex(&stosvi);
    _assert(true == bret);
    if (false == bret) return false;
    return (ver_platform_win32_nt == stosvi.dwplatformid);
    }
    /// end //

    不知道在这篇文章问世之前,有多少朋友尝试过去实现“鼠标屏幕取词”这项充满了挑战的技术,也只有尝试过的朋友才能体会到其间的不易,尤其在探索api函数的截获时,手头的几篇资料没有一篇是涉及到关键代码的,重要的地方都是一笔代过,msdn更是显得苍白而无力,也不知道除了image_import_descriptor和image_thunk_data,微软还隐藏了多少秘密,好在硬着头皮还是把它给攻克了,希望这篇文章对大家能有所帮助。

    展开全文
  • 自己写的 金山词霸类翻译软件的屏幕取词的原理性的源代码 分为三个部分 dll中是HOOK TextOutA的代码和安装钩子的代码 test是目标程序 此程序使用了TextOut函数 DLL_test是将DLL注入到目标程序的
  • “鼠标屏幕取词”技术是在电子字典中得到广泛地应用的,如四通利方和金山词霸等软件,这个技术看似简单,其实在windows系统中实现却是非常复杂的,总的来说有两种实现方式: 第一种:采用截获对部分gdi的api调用来...

    “鼠标屏幕取词”技术是在电子字典中得到广泛地应用的,如四通利方和金山词霸等软件,这个技术看似简单,其实在windows系统中实现却是非常复杂的,总的来说有两种实现方式: 
    第一种:采用截获对部分gdi的api调用来实现,如textout,textouta等。 
    第二种:对每个设备上下文(dc)做一分copy,并跟踪所有修改上下文(dc)的操作。 
    第二种方法更强大,但兼容性不好,而第一种方法使用的截获windowsapi的调用,这项技术的强大可能远远超出了您的想象,毫不夸张的说,利用windowsapi拦截技术,你可以改造整个操作系统,事实上很多外挂式windows中文平台就是这么实现的!而这项技术也正是这篇文章的主题。 
    截windowsapi的调用,具体的说来也可以分为两种方法: 
    第一种方法通过直接改写winapi 在内存中的映像,嵌入汇编代码,使之被调用时跳转到指定的地址运行来截获;第二种方法则改写iat(import address table 输入地址表),重定向winapi函数的调用来实现对winapi的截获。 
    第一种方法的实现较为繁琐,而且在win95、98下面更有难度,这是因为虽然微软说win16的api只是为了兼容性才保留下来,程序员应该尽可能地调用32位的api,实际上根本就不是这样!win 9x内部的大部分32位api经过变换调用了同名的16位api,也就是说我们需要在拦截的函数中嵌入16位汇编代码! 
    我们将要介绍的是第二种拦截方法,这种方法在win95、98和nt下面运行都比较稳定,兼容性较好。由于需要用到关于windows虚拟内存的管理、打破进程边界墙、向应用程序的进程空间中注入代码、pe(portable executable)文件格式和iat(输入地址表)等较底层的知识,所以我们先对涉及到的这些知识大概地做一个介绍,最后会给出拦截部分的关键代码。 
    先说windows虚拟内存的管理。windows9x给每一个进程分配了4gb的地址空间,对于nt来说,这个数字是2gb,系统保留了2gb到 4gb之间的地址空间禁止进程访问,而在win9x中,2gb到4gb这部分虚拟地址空间实际上是由所有的win32进程所共享的,这部分地址空间加载了共享win32 dll、内存映射文件和vxd、内存管理器和文件系统码,win9x中这部分对于每一个进程都是可见的,这也是win9x操作系统不够健壮的原因。win9x中为16位操作系统保留了0到4mb的地址空间,而在4mb到2gb之间也就是win32进程私有的地址空间,由于 每个进程的地址空间都是相对独立的,也就是说,如果程序想截获其它进程中的api调用,就必须打破进程边界墙,向其它的进程中注入截获api调用的代码,这项工作我们交给钩子函数(setwindowshookex)来完成,关于如何创建一个包含系统钩子的动态链接库,《电脑高手杂志》在第?期已经有过专题介绍了,这里就不赘述了。所有系统钩子的函数必须要在动态库里,这样的话,当进程隐式或显式调用一个动态库里的函数时,系统会把这个动态库映射到这个进程的虚拟地址空间里,这使得dll成为进程的一部分,以这个进程的身份执行,使用这个进程的堆栈,也就是说动态链接库中的代码被钩子函数注入了其它gui进程的地址空间(非gui进程,钩子函数就无能为力了), 
    当包含钩子的dll注入其它进程后,就可以取得映射到这个进程虚拟内存里的各个模块(exe和dll)的基地址,如: 
    hmodule hmodule=getmodulehandle(“mypro.exe”); 
    在mfc程序中,我们可以用afxgetinstancehandle()函数来得到模块的基地址。exe和dll被映射到虚拟内存空间的什么地方是由它们的基地址决定的。它们的基地址是在链接时由链接器决定的。当你新建一个win32工程时,vc++链接器使用缺省的基地址0x00400000。可以通过链接器的base选项改变模块的基地址。exe通常被映射到虚拟内存的0x00400000处,dll也随之有不同的基地址,通常被映射到不同进程 
    的相同的虚拟地址空间处。 
    系统将exe和dll原封不动映射到虚拟内存空间中,它们在内存中的结构与磁盘上的静态文件结构是一样的。即pe (portable executable) 文件格式。我们得到了进程模块的基地址以后,就可以根据pe文件的格式穷举这个模块的image_import_descriptor数组,看看进程空间中是否引入了我们需要截获的函数所在的动态链接库,比如需要截获“textouta”,就必须检查“gdi32.dll”是否被引入了。说到这里,我们有必要介绍一下pe文件的格式,如右图,这是pe文件格式的大致框图,最前面是文件头,我们不必理会,从pe file optional header后面开始,就是文件中各个段的说明,说明后面才是真正的段数据,而实际上我们关心的只有一个段,那就是“.idata”段,这个段中包含了所有的引入函数信息,还有iat(import address table)的rva(relative virtual address)地址。 
    说到这里,截获windowsapi的整个原理就要真相大白了。实际上所有进程对给定的api函数的调用总是通过pe文件的一个地方来转移的,这就是一个该模块(可以是exe或dll)的“.idata”段中的iat输入地址表(import address table)。在那里有所有本模块调用的其它dll的函数名及地址。对其它dll的函数调用实际上只是跳转到输入地址表,由输入地址表再跳转到dll真正的函数入口。 

    具体来说,我们将通过image_import_descriptor数组来访问“.idata”段中引入的dll的信息,然后通过image_thunk_data数组来针对一个被引入的dll访问该dll中被引入的每个函数的信息,找到我们需要截获的函数的跳转地址,然后改成我们自己的函数的地址……具体的做法在后面的关键代码中会有详细的讲解。 
    讲了这么多原理,现在让我们回到“鼠标屏幕取词”的专题上来。除了api函数的截获,要实现“鼠标屏幕取词”,还需要做一些其它的工作,简单的说来,可以把一个完整的取词过程归纳成以下几个步骤: 
    1. 安装鼠标钩子,通过钩子函数获得鼠标消息。 
    使用到的api函数:setwindowshookex 
    2. 得到鼠标的当前位置,向鼠标下的窗口发重画消息,让它调用系统函数重画窗口。 
    使用到的api函数:windowfrompoint,screentoclient,invalidaterect 
    3. 截获对系统函数的调用,取得参数,也就是我们要取的词。 
    对于大多数的windows应用程序来说,如果要取词,我们需要截获的是“gdi32.dll”中的“textouta”函数。 
    我们先仿照textouta函数写一个自己的mytextouta函数,如: 
    bool winapi mytextouta(hdc hdc, int nxstart, int nystart, lpcstr lpszstring,int cbstring) 

    // 这里进行输出lpszstring的处理 
    // 然后调用正版的textouta函数 

    把这个函数放在安装了钩子的动态连接库中,然后调用我们最后给出的hookimportfunction函数来截获进程 
    对textouta函数的调用,跳转到我们的mytextouta函数,完成对输出字符串的捕捉。hookimportfunction的 
    用法: 
    hookfuncdesc hd; 
    proc porigfuns; 
    hd.szfunc="textouta"; 
    hd.pproc=(proc)mytextouta; 
    hookimportfunction (afxgetinstancehandle(),"gdi32.dll",&hd,porigfuns); 
    下面给出了hookimportfunction的源代码,相信详尽的注释一定不会让您觉得理解截获到底是怎么实现的 
    很难,ok,let’s go: 

    / begin /// 
    #include 

    // 这里定义了一个产生指针的宏 
    #define makeptr(cast, ptr, addvalue) (cast)((dword)(ptr)+(dword)(addvalue)) 

    // 定义了hookfuncdesc结构,我们用这个结构作为参数传给hookimportfunction函数 
    typedef struct tag_hookfuncdesc 

    lpcstr szfunc; // the name of the function to hook. 
    proc pproc; // the procedure to blast in. 
    } hookfuncdesc , * lphookfuncdesc; 

    // 这个函数监测当前系统是否是windownt 
    bool isnt(); 

    // 这个函数得到hmodule -- 即我们需要截获的函数所在的dll模块的引入描述符(import descriptor) 
    pimage_import_descriptor getnamedimportdescriptor(hmodule hmodule, lpcstr szimportmodule); 

    // 我们的主函数 
    bool hookimportfunction(hmodule hmodule, lpcstr szimportmodule, 
    lphookfuncdesc pahookfunc, proc* paorigfuncs) 

    /// 下面的代码检测参数的有效性  
    _assert(szimportmodule); 
    _assert(!isbadreadptr(pahookfunc, sizeof(hookfuncdesc))); 
    #ifdef _debug 
    if (paorigfuncs) _assert(!isbadwriteptr(paorigfuncs, sizeof(proc))); 
    _assert(pahookfunc.szfunc); 
    _assert(*pahookfunc.szfunc != ''); 
    _assert(!isbadcodeptr(pahookfunc.pproc)); 
    #endif 
    if ((szimportmodule == null) || (isbadreadptr(pahookfunc, sizeof(hookfuncdesc)))) 

    _assert(false); 
    setlasterrorex(error_invalid_parameter, sle_error); 
    return false; 

    // 

    // 监测当前模块是否是在2gb虚拟内存空间之上 
    // 这部分的地址内存是属于win32进程共享的 
    if (!isnt() && ((dword)hmodule >= 0x80000000)) 

    _assert(false); 
    setlasterrorex(error_invalid_handle, sle_error); 
    return false; 

    // 清零 
    if (paorigfuncs) memset(paorigfuncs, null, sizeof(proc)); 

    // 调用getnamedimportdescriptor()函数,来得到hmodule -- 即我们需要 
    // 截获的函数所在的dll模块的引入描述符(import descriptor) 
    pimage_import_descriptor pimportdesc = getnamedimportdescriptor(hmodule, szimportmodule); 
    if (pimportdesc == null) 
    return false; // 若为空,则模块未被当前进程所引入 

    // 从dll模块中得到原始的thunk信息,因为pimportdesc->firstthunk数组中的原始信息已经 
    // 在应用程序引入该dll时覆盖上了所有的引入信息,所以我们需要通过取得pimportdesc->originalfirstthunk 
    // 指针来访问引入函数名等信息 
    pimage_thunk_data porigthunk = makeptr(pimage_thunk_data, hmodule, 
    pimportdesc->originalfirstthunk); 

    // 从pimportdesc->firstthunk得到image_thunk_data数组的指针,由于这里在dll被引入时已经填充了 
    // 所有的引入信息,所以真正的截获实际上正是在这里进行的 
    pimage_thunk_data prealthunk = makeptr(pimage_thunk_data, hmodule, pimportdesc->firstthunk); 

    // 穷举image_thunk_data数组,寻找我们需要截获的函数,这是最关键的部分! 
    while (porigthunk->u1.function) 

    // 只寻找那些按函数名而不是序号引入的函数 
    if (image_ordinal_flag != (porigthunk->u1.ordinal & image_ordinal_flag)) 

    // 得到引入函数的函数名 
    pimage_import_by_name pbyname = makeptr(pimage_import_by_name, hmodule, 
    porigthunk->u1.addressofdata); 

    // 如果函数名以null开始,跳过,继续下一个函数 
    if ('' == pbyname->name[0]) 
    continue; 

    // bdohook用来检查是否截获成功 
    bool bdohook = false; 

    // 检查是否当前函数是我们需要截获的函数 
    if ((pahookfunc.szfunc[0] == pbyname->name[0]) && 
    (strcmpi(pahookfunc.szfunc, (char*)pbyname->name) == 0)) 

    // 找到了! 
    if (pahookfunc.pproc) 
    bdohook = true; 

    if (bdohook) 

    // 我们已经找到了所要截获的函数,那么就开始动手吧 
    // 首先要做的是改变这一块虚拟内存的内存保护状态,让我们可以自由存取 
    memory_basic_information mbi_thunk; 
    virtualquery(prealthunk, &mbi_thunk, sizeof(memory_basic_information)); 
    _assert(virtualprotect(mbi_thunk.baseaddress, mbi_thunk.regionsize, 
    page_readwrite, &mbi_thunk.protect)); 

    // 保存我们所要截获的函数的正确跳转地址 
    if (paorigfuncs) 
    paorigfuncs = (proc)prealthunk->u1.function; 

    // 将image_thunk_data数组中的函数跳转地址改写为我们自己的函数地址! 
    // 以后所有进程对这个系统函数的所有调用都将成为对我们自己编写的函数的调用 
    prealthunk->u1.function = (pdword)pahookfunc.pproc; 

    // 操作完毕!将这一块虚拟内存改回原来的保护状态 
    dword dwoldprotect; 
    _assert(virtualprotect(mbi_thunk.baseaddress, mbi_thunk.regionsize, 
    mbi_thunk.protect, &dwoldprotect)); 
    setlasterror(error_success); 
    return true; 


    // 访问image_thunk_data数组中的下一个元素 
    porigthunk++; 
    prealthunk++; 

    return true; 


    // getnamedimportdescriptor函数的实现 
    pimage_import_descriptor getnamedimportdescriptor(hmodule hmodule, lpcstr szimportmodule) 

    // 检测参数 
    _assert(szimportmodule); 
    _assert(hmodule); 
    if ((szimportmodule == null) || (hmodule == null)) 

    _assert(false); 
    setlasterrorex(error_invalid_parameter, sle_error); 
    return null; 


    // 得到dos文件头 
    pimage_dos_header pdosheader = (pimage_dos_header) hmodule; 

    // 检测是否mz文件头 
    if (isbadreadptr(pdosheader, sizeof(image_dos_header)) || 
    (pdosheader->e_magic != image_dos_signature)) 

    _assert(false); 
    setlasterrorex(error_invalid_parameter, sle_error); 
    return null; 


    // 取得pe文件头 
    pimage_nt_headers pntheader = makeptr(pimage_nt_headers, pdosheader, pdosheader->e_lfanew); 

    // 检测是否pe映像文件 
    if (isbadreadptr(pntheader, sizeof(image_nt_headers)) || 
    (pntheader->signature != image_nt_signature)) 

    _assert(false); 
    setlasterrorex(error_invalid_parameter, sle_error); 
    return null; 


    // 检查pe文件的引入段(即 .idata section) 
    if (pntheader->optionalheader.datadirectory[image_directory_entry_import].virtualaddress == 0) 
    return null; 

    // 得到引入段(即 .idata section)的指针 
    pimage_import_descriptor pimportdesc = makeptr(pimage_import_descriptor, pdosheader, 
    pntheader->optionalheader.datadirectory[image_directory_entry_import].virtualaddress); 

    // 穷举pimage_import_descriptor数组寻找我们需要截获的函数所在的模块 
    while (pimportdesc->name) 

    pstr szcurrmod = makeptr(pstr, pdosheader, pimportdesc->name); 
    if (stricmp(szcurrmod, szimportmodule) == 0) 
    break; // 找到!中断循环 
    // 下一个元素 
    pimportdesc++; 


    // 如果没有找到,说明我们寻找的模块没有被当前的进程所引入! 
    if (pimportdesc->name == null) 
    return null; 

    // 返回函数所找到的模块描述符(import descriptor) 
    return pimportdesc; 


    // isnt()函数的实现 
    bool isnt() 

    osversioninfo stosvi; 
    memset(&stosvi, null, sizeof(osversioninfo)); 
    stosvi.dwosversioninfosize = sizeof(osversioninfo); 
    bool bret = getversionex(&stosvi); 
    _assert(true == bret); 
    if (false == bret) return false; 
    return (ver_platform_win32_nt == stosvi.dwplatformid); 

    /// end // 

    不知道在这篇文章问世之前,有多少朋友尝试过去实现“鼠标屏幕取词”这项充满了挑战的技术,也只有尝试过的朋友才能体会到其间的不易,尤其在探索api函数的截获时,手头的几篇资料没有一篇是涉及到关键代码的,重要的地方都是一笔代过,msdn更是显得苍白而无力,也不知道除了image_import_descriptor和image_thunk_data,微软还隐藏了多少秘密,好在硬着头皮还是把它给攻克了,希望这篇文章对大家能有所帮助。

    展开全文
  • 鼠标屏幕取词原理 (VC++)

    千次阅读 2009-09-23 10:00:00
    “鼠标屏幕取词”技术是在电子字典中得到广泛地应用的,如四通利方和金山词霸等软件,这个技术看似简单,其实在windows系统中实现却是非常复杂的,总的来说有两种实现方式: 第一种:采用截获对部分gdi的api调用来...
  • 屏幕取词技术实现原理

    千次阅读 2019-02-25 21:51:50
    屏幕取词技术实现原理
  • 1.1.鼠标取词屏幕取词技术实现原理 1.2.需要用到winapi(不推荐,传统方法、】 需要进行全局鼠标Hook然后在Hook事件里根据鼠标的位置找到相应window的handle(WindowFromPoint)再取回文本(GetWindowText) ...
  • 要用CAJViewer浏览器查看,涉及有关屏幕取词原理与实现
  • 屏幕取词原理

    千次阅读 2009-04-19 13:38:00
    有一小段的时间也想过金山词霸中的屏幕取词到底是怎么实现的,今天查资料时无意中又看到了这个词汇,网上搜了下,讲技术原理的还是满多的,随便找了一个,先放着,以后有时间再看。--------------------------------...
  • “鼠标屏幕取词”技术是在电子字典中得到广泛地应用的,如四通利方和金山词霸等软件,这个技术看似简单,其实在windows系统中实现却是非常复杂的
  • 屏幕取词技术实现原理与关键源码 2018年01月17日 16:00:18hemeinvyiqiluoben阅读数:503 转自:https://www.cnblogs.com/seacryfly/archive/2012/01/08/2316511.html 虽然屏幕取词技术早已经不是什么秘密,以...
  • 鼠标屏幕取词技术的原理和实现 “鼠标屏幕取词”技术是在电子字典中得到广泛地应用的,如四通利方和金山词霸等软件,这个技术看似简单,其实在WINDOWS系统中实现却是非常复杂的,总的来说有两种实现方式:  第...
  • 就是基本的代码。。。和原理通过这个学习。。。可以截取屏幕上的文字

空空如也

空空如也

1 2 3 4
收藏数 80
精华内容 32
关键字:

屏幕取词原理