1.易语言X64安卓手游封包教程（C++/模拟器）
2.屏幕取词
3.XP系统中屏蔽Ctrl+Esc键序列的方法

易语言X64安卓手游封包教程（C++/模拟器）

       本教程专注于计算机协议安全技术研究，仅提供学习资料和工具，禁止用于非法目的。教程采用针对X游戏程序及安卓模拟器的独特技术方案，无需代理、驱动，美容贷 源码操作简便，支持多框架，提供部分源码，确保学员获取高质量资源。课程以易语言为核心，同时支持其他编程语言的学习者，每节课时长约分钟。以下为教程大纲：

       第一部分：基础原理（小白入门）

       1. 封包协议TCP、UDP介绍

       2. 代理框架搭建与WPE工具使用

       3. 查尔斯全局代理软件数据拦截

       4. 远程hook发送代码实操

       5. 发送包中控台代码编写

       6. 套接字、IP端口与发送功能

       7. 封包筛选与工具完善

       8. 远程hook与dll代理拦截

       第二部分：X远程hook实操

       1. X远程hook工具与封包数据分析

       2. 配置远程Xhook框架与代码编写

       3. X注入安卓发包NPC对话测试

       4. 发送与接收包HOOK筛选数据

       5. NPC对话包分析与代码封装

       6. X安卓模拟器注入源码call函数

       7. 易语言写滤镜修改发包功能

       8. 替换包与免恢复构造发包

       第三部分：封包数据分析与实战

       1. 字符编码分析与封包广告

       2. 商人封包组包代码

       3. 某X网游地图传送数据

       4. 人物传送组包实战

       5. 某仙日常副本任务分析

       6. 自动过副本与材料刷取

       7. 封包修改人物名字

       8. 接收包识别游戏数据

       9. 某网游修改名字组包编写

       第四部分：加密解密

       1. 封包加密解密基础

       2. 全图玩家与NPC信息代码

       3. 人物批量加人、加好友代码

       4. 常规运算与加密分析

       5. base加密解密与密匙实例

       第五部分：多开框架讲解

       1. 拦截模块与源码

       2. X远线程多开发包测试

       3. 模拟器多开消息发包框架

       4. C语言写模拟器发包插件

       第六部分：C++模拟器独控多开

       1. C++框架与环境搭建

       2. 框架、游戏端界面与C++源码

       3. MFC拦截与发送独控

       4. 安卓模拟器UDP和TCP全开独控

       第七部分：新封包框架

       1. 封包两个版本与模块框架实例

       2. recv和send拦截原理与实例

       第八部分：易语言新封包框架多开+多开图色

       1. 手游封包多开功能实现

       2. 手游大漠图色模拟配合封包框架

       第九部分：热门手游抢拍项目实战

       1. 拍卖行抢拍原理与思路

       2. 接收包获取抢拍物品信息

       3. 物品种类分析与代码编写

       4. 抢拍物品信息中控界面

       5. 自动刷新与价格设置

       附录：提供加密工具、开发作品例子、X注入dll框架与网游实例分析，确保学习者全面掌握所需技能。

屏幕取词

       â€œé¼ æ ‡å±å¹•å–词”技术是在电子字典中得到广泛地应用的，如四通利方和金山词霸等软件，这个技术看似简单，其实在WINDOWS系统中实现却是非常复杂的，总的来说有两种实现方式：

        第一种：采用截获对部分GDI的API调用来实现,如TextOut,TextOutA等。

        第二种：对每个设备上下文(DC)做一分Copy,并跟踪所有修改上下文(DC)的操作。

        第二种方法更强大,但兼容性不好，而第一种方法使用的截获WindowsAPI的调用，这项技术的强大可能远远超出了您的想象，毫不夸张的说，利用WindowsAPI拦截技术，你可以改造整个操作系统，事实上很多外挂式Windows中文平台就是这么实现的！而这项技术也正是这篇文章的主题。

        截WindowsAPI的调用，具体的说来也可以分为两种方法：

        第一种方法通过直接改写WinAPI 在内存中的映像，嵌入汇编代码，使之被调用时跳转到指定的地址运行来截获；第二种方法则改写IAT（Import Address Table 输入地址表），重定向WinAPI函数的调用来实现对WinAPI的截获。

        第一种方法的实现较为繁琐，而且在Win、下面更有难度，这是因为虽然微软说WIN的API只是为了兼容性才保留下来，程序员应该尽可能地调用位的API,实际上根本就不是这样！WIN 9X内部的大部分位API经过变换调用了同名的位API，也就是说我们需要在拦截的函数中嵌入位汇编代码！

        我们将要介绍的是第二种拦截方法，这种方法在Win、和NT下面运行都比较稳定，兼容性较好。由于需要用到关于Windows虚拟内存的管理、打破进程边界墙、向应用程序的进程空间中注入代码、PE（Portable Executable）文件格式和IAT（输入地址表）等较底层的知识，所以我们先对涉及到的这些知识大概地做一个介绍，最后会给出拦截部分的关键代码。

        先说Windows虚拟内存的管理。Windows9X给每一个进程分配了4GB的地址空间，对于NT来说，这个数字是2GB，系统保留了2GB到 4GB之间的地址空间禁止进程访问，而在Win9X中，2GB到4GB这部分虚拟地址空间实际上是由所有的WIN进程所共享的，这部分地址空间加载了共享Win DLL、内存映射文件和VXD、内存管理器和文件系统码，Win9X中这部分对于每一个进程都是可见的，这也是Win9X操作系统不够健壮的原因。

        Win9X中为位操作系统保留了0到4MB的地址空间，而在4MB到2GB之间也就是Win进程私有的地址空间，由于 每个进程的地址空间都是相对独立的，也就是说，如果程序想截获其它进程中的API调用，就必须打破进程边界墙，向其它的进程中注入截获API调用的代码，这项工作我们交给钩子函数（SetWindowsHookEx）来完成，关于如何创建一个包含系统钩子的动态链接库，《电脑高手杂志》已经有过专题介绍了，这里就不赘述了。

        所有系统钩子的函数必须要在动态库里，这样的话，当进程隐式或显式调用一个动态库里的函数时，系统会把这个动态库映射到这个进程的虚拟地址空间里，这使得DLL成为进程的一部分，以这个进程的身份执行，使用这个进程的堆栈，也就是说动态链接库中的代码被钩子函数注入了其它GUI进程的地址空间（非GUI进程，钩子函数就无能为力了），当包含钩子的DLL注入其它进程后，就可以取得映射到这个进程虚拟内存里的各个模块（EXE和DLL）的基地址，如：

       HMODULE hmodule=GetModuleHandle(“Mypro.exe”);

        在MFC程序中,我们可以用AfxGetInstanceHandle()函数来得到模块的基地址。EXE和DLL被映射到虚拟内存空间的什么地方是由它们的基地址决定的。它们的基地址是在链接时由链接器决定的。当你新建一个Win工程时，VC＋＋链接器使用缺省的基地址0x。可以通过链接器的BASE选项改变模块的基地址。EXE通常被映射到虚拟内存的0x处，DLL也随之有不同的基地址，通常被映射到不同进程的相同的虚拟地址空间处。

        系统将EXE和DLL原封不动映射到虚拟内存空间中，它们在内存中的结构与磁盘上的静态文件结构是一样的。即PE (Portable Executable) 文件格式。我们得到了进程模块的基地址以后，就可以根据PE文件的格式穷举这个模块的IMAGE_IMPORT_DESCRIPTOR数组，看看进程空间中是否引入了我们需要截获的函数所在的动态链接库，比如需要截获“TextOutA”，就必须检查“Gdi.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应用程序来说，如果要取词，我们需要截获的是“Gdi.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(),"gdi.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虚拟内存空间之上

       // 这部分的地址内存是属于Win进程共享的

       if (!IsNT() && ((DWORD)hModule >= 0x))

       {

       _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_WIN_NT == stOSVI.dwPlatformId);

       }

       /////////////////////////////////////////////// End //////////////////////////////////////////////////////////////////////

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

XP系统中屏蔽Ctrl+Esc键序列的方法

       对于用过Windows的人，几乎没有人不知道Ctrl+Alt+Del组合键，尤其是在使用经常死机的Windows9x时，使用它的jsp 论坛回复 源码频率更高，这一组合键是专门为了系统安全起见提供的紧急出口。VC知识库在线杂志第期，ac_z_cn在他的个人专栏中写过一篇关于这方面的文章：“WINDOWS NT/下如何屏蔽CTRL+ALT+DEL”。因此本文侧重于介绍在Windows XP中如何实现屏蔽CTRL+ALT+DEL组合键，也就是任务管理器，任务切换组合键(Alt+Tab)，任务栏和“开始”菜单(Ctrl+Esc，VK_LWIN，VK_RWIN)。这个方法也能应用于Windows 环境。

       在Windows 9x/Me系统中，屏蔽Ctrl+Alt+Del和各种任务开关键的方法是通过下面的方法实现的：

       BOOL bOldState;

       SystemParametersInfo(SPI_SETSCREENSAVERRUNNING, TRUE, bOldState, 0);

       MS大佬认为这种方法很业余，所以在Windows NT//XP中对此进行了修改。在这些较新的Windows版本中用户登陆使用Winlogon和GINA——Graphical Identification and Authentication，意思是图形化的身份认证，挺吓唬人的是不是!其实就那么回事。Winlogon是Windows系统的一部分，它专门提供交互式登陆支持，而GINA则是Winlogon用来实现认证的一个DLL——这个DLL就是msgina.dll。WlxInitialize、WlxActivateUserShell便是其中输出，当然不知这两个，还有别的。前者进行自身的下拉导航菜单源码初始化，后者激活用户的外壳程序。Windows就是用这个DLL来实现用户名+口令的身份认证的，但是开发人员可以用自己的GINA代替msgina.dll。例如，实现智能卡、视网膜扫描仪、DNA检查等等认证机制来代替输入用户名+口令形式的身份检查。 下面的表格中列出了与GINA有关的全部函数。其中有一个是WlxLoggedOnSAS，当按下Ctrl+Alt+Del 键时，Winlogon便调用这个函数。

       (表一)GINA 函数一览表 函数 描述

       WlxActivateUserShell激活用户外壳程序

       WlxDisplayLockedNotice允许GINA DLL 显示锁定信息

       WlxDisplaySASNotice 当没有用户登陆时，Winlogon调用此函数

       WlxDisplayStatusMessageWinlogon 用一个状态信息调用此函数进行显示

       WlxGetConsoleSwitchCredentials Winlogon调用此函数读取当前登陆用户的信任信息，并透明地将它们传到目标会话

       WlxGetStatusMessage Winlogon 调用此函数获取当前状态信息

       WlxInitialize 针对指定的窗口位置进行GINA DLL初始化

       WlxIsLockOk 验证工作站正常锁定

       WlxIslogoffOk 验证注销正常

       WlxLoggedOnSAS 用户已登陆并且工作站没有被加锁，如果此时接收到SAS事件，则Winlogon 调用此函数

       WlxLoggedOutSAS 没有用户登陆，如果此时收到SAS事件，则Winlogon 调用此函数

       WlxLogoff 请求注销操作时通知GINA DLL

       WlxNegotiate 表示当前的Winlogon版本是否能使用GINA DLL

       WlxNetworkProviderLoad 在加载网络服务提供程序收集了身份和认证信息后，Winlogon 调用此函数

       WlxRemoveStatusMessage Winlogon 调用此函数告诉GINA DLL 停止显示状态信息

       WlxScreensaverNotify 允许GINA与屏幕保护操作交互

       WlxShutdown 在关闭之前Winlogon 调用此函数，允许GINA实现任何关闭任务，例如从读卡器中退出智能卡

       WlxStartApplication 当系统需要在用户的上下文中启动应用程序时调用此函数

       WlxWkstaLockedSAS当工作站被锁定，如果接收到一个SAS，则Winlogon 调用此函数

       在默认情况下，GINA显示登陆对话框，c 小闹钟 源码用户输入用户名及口令。所以要想屏蔽掉Ctrl+Alt+Del，则可以写一个新的MyGina.dll，其中提供接口调用msgina.dll的函数WlxLoggedOnSAS，从而实现Ctrl+Alt+Del屏蔽。或者编写一个键盘驱动程序来实现。

       难道屏蔽Ctrl+Alt+Del真的象上述所说的那么麻烦吗?有没有更好的方法呢?答案是肯定的。所以忘掉GINA吧，使用操作系统的策略设置完全可以搞掂这个问题。方法是进入"开始"菜单，选择"运行"，然后在运行对话框中输入"gpedit.msc"，启动Windows系统的组策略编辑器。在左边窗格查看"用户配置|管理模板|系统|登录/注销"，则在右边窗格策略里不难发现"禁用任务管理器"一项。

       组策略编辑器

       通过对这个策略的设置可以屏蔽掉Ctrl+Alt+Del。如果要通过编写代码来实现，则必须操作下面的注册表项：

       HKCU/

       Software/

       Microsoft/

       Windows/

       CurrentVersion/

       Policies/

       System/DisableTaskMgr = dword:1

       如此设置之后，则在Windows XP中，如果用户按下Ctrl+Alt+Del，则会弹出一个出错对话框，

       注意这里假设在控制面板中“用户帐号”管理的“选择登录和注销选项”设置启用了“使用欢迎屏幕”一项。

       否则，XP将使用Windows的eclipse插件开发 源码传统登录模式，要求用户输入帐户名。并且Ctrl+Alt+Del组合键的 行为也和传统的行为一样，注册表中DisableTaskMgr的设置也只是将登录/注销对话框中的任务管理器按钮屏蔽或置灰。 有人可能会问，有关任务管理器的文档又没有明确说明，那你是怎么知道DisableTaskMgr是用来禁用任务管理器的呢?告诉你吧， 我是在使用GPEDIT时发现的。GPEDIT是一个非常有用的工具，不仅可以用它来编辑策略，还可以用它来发现策略。利用这个工具可以轻松控制Windows的许多东西，从许可权限的存取到是否使用IE的传统外观，从是否显示对话框中的Places Bar到是否用Ctrl+Alt+Del 启动任务管理器。总之用它可以配置上百个界面行为，因此它是一个足以让系统管理员垂延三尺的工具。一旦找到了感兴趣的策略，那如何知道相应的注册表位置呢?有两种方法。第一种是比较粗鲁的办法：在修改策略的前后将注册表输出到一个.reg文件，然后比较它们有什么不同。所有的策略无外乎以下的四个注册表键：

       // 用户指定

       HKEY_CURRENT_USER/Software/Policies

       HKEY_CURRENT_USER/Software/Microsoft/Windows/CurrentVersion/Policies

       // 机器指定

       HKEY_LOCAL_MACHINE/Software/Policies

       HKEY_LOCAL_MACHINE/Software/Microsoft/Windows/CurrentVersion/Policies

       第二种方法是直捣信息源头--检查描述策略的管理模板文件(.adm)。下面是Windows XP的system.adm文件对 DisableTaskMgr的描述：(Windows 对此的描述稍有不同，其细节请参考Windows 的资源开发包)

       CATEGORY !!CADOptions

       #if version = 4

       EXPLAIN !!CADOptions_Help

       #endif

       KEYNAME "Software/Microsoft/Windows/CurrentVersion/Policies/System"

       POLICY !!DisableTaskMgr

       #if version = 4

       SUPPORTED !!SUPPORTED_Win2k

       #endif

       EXPLAIN !!DisableTaskMgr_Help

       VALUENAME "DisableTaskMgr"

       END POLICY

       ; More Ctrl+Alt+Del policies here...

       END CATEGORY ; Ctrl+Alt+Del options

       ……

       ……

       DisableTaskMgr_Help="防止用户启动''任务管理器''(Taskmgr.exe)。/n/n如果该设置被启用，并且用户试图启动任务管理器，系统

       会显示消息，解释是一个策略禁止了这个操作。/n/n任务管理器让用户启动或终止程序，监视计算机性能，查看及监视计算机上所有运行

       中的程序 (包含系统服务)， 搜索程序的执行文件名，及更改程序运行的优先顺序。"

       DisableTaskMgr="删除任务管理器"

       以上是DisableTaskMgr的描述片断

       正是在这段描述中KEYNAME 和VALUENAME指定了注册表的键值对。利用这种方法，你可以为自己的应用程序创建管理模板和策略，但编辑和浏览.adm模板文件的编辑器必须支持Unicode字符。如Notepad或者WordPad等都可以。此外，使用管理模板文件，系统管理员可以用它为整个组织配置需要的策略——由此可以看出，此文件在系统中的地位举足轻重!有关模板管理文件格式的详细信息请参考平台SDK。最后需要强调的是DisableTaskMgr只是禁用Ctrl+Alt+Del的功能。下面我们来讨论如何捕获它的按键序列。要想截获Ctrl+Alt+Del，有三种可选择的方法：

       1、 编写一个GINA代理;此方法我们在以后的文章中介绍。实际上，ac_z_cn的个人专栏文章：“WINDOWS NT/下如何屏蔽CTRL+ALT+DEL”使用的就是这种方法。

       2、 编写一个键盘驱动程序;本文例子程序使用的方法。

       3、 用自己的程序代替任务管理器程序TaskMgr.exe。

       屏蔽Ctrl+Alt+Del解决方案的具体实现细节请参考本文的例子代码。

       下面让我们来解决屏蔽任务切换键序列的问题，这些键序列包括Alt+Tab、Ctrl+Esc、Alt+Esc、VK_LWIN/VK_RWIN以及任务栏。在很早以前的Window 3.1年代，处理这个问题的方法是通过WM_SYSKEYDOWN实现。到了Windows 9x时期，本文前面提到过对这个问题的处理方法，使用SPI_SETSCREENSAVERRUNNING。但是进入Windows NT 4.0 (SP3 +)，Windows 以及Windows XP时代，对这个问题的处理已经有所不同，必须写一个低级的键盘驱动钩子。不要怕，因为要实现这个钩子并不是很难。本文下面会介绍如何实现这个键盘钩子。一般来讲，系统级钩子必须是一个DLL。下面是本文提供的一个键盘钩子DLL的源代码片断(TaskKeyHook.dll)：

       头文件

       ////////////////////////////////////////////////////////////////

       //TaskKeyHook.h

       //

       #define DLLIMPORT __declspec(dllimport)

       DLLIMPORT BOOL DisableTaskKeys(BOOL bEnable, BOOL bBeep);

       DLLIMPORT BOOL AreTaskKeysDisabled();

       实现文件

       ////////////////////////////////////////////////////////////////

       // TaskKeyHook.cpp

       //

       #define _WIN_WINNT 0x // for KBDLLHOOKSTRUCT

       #include // MFC core and standard components

       #define DLLEXPORT __declspec(dllexport)

       //////////////////

       // App (DLL) object

       //

       class CTaskKeyHookDll : public CWinApp {

       public:

       CTaskKeyHookDll() { }

       ~CTaskKeyHookDll() { }

       } MyDll;

       ////////////////////////////////////////////////

       // 下面的代码表示这一部分在此DLL所有实例之间共享

       // 低级键盘钩子一定是系统级的钩子

       //

       #pragma data_seg (".mydata")

       HHOOK g_hHookKbdLL = NULL; // 钩子句柄

       BOOL g_bBeep = FALSE; // 按下非法键时蜂鸣响铃

       #pragma data_seg ()

       #pragma comment(linker, "/SECTION:.mydata,RWS") // 告诉链接器：建立数据共享段

       //////////////////////////////////

       // 低级键盘钩子

       // 截获任务转换键：不传递直接返回

       //

       LRESULT CALLBACK MyTaskKeyHookLL(int nCode, WPARAM wp, LPARAM lp)

       {

       KBDLLHOOKSTRUCT *pkh = (KBDLLHOOKSTRUCT *) lp;

       if (nCode==HC_ACTION) {

       BOOL bCtrlKeyDown =

       GetAsyncKeyState(VK_CONTROL)((sizeof(SHORT) * 8) - 1);

       if ((pkh-vkCode==VK_ESCAPE bCtrlKeyDown) || // Ctrl+Esc

       // Alt+TAB

       (pkh-vkCode==VK_TAB pkh-flags LLKHF_ALTDOWN) ||

       // Alt+Esc

       (pkh-vkCode==VK_ESCAPE pkh-flags LLKHF_ALTDOWN)||

       (pkh-vkCode==VK_LWIN || pkh-vkCode==VK_RWIN)) { // 开始菜单

       if (g_bBeep (wp==WM_SYSKEYDOWN||wp==WM_KEYDOWN))

       MessageBeep(0); // 蜂鸣

       return 1; // 不再往CallNextHookEx传递，直接返回

       }

       }

       return CallNextHookEx(g_hHookKbdLL, nCode, wp, lp);

       }

       ////////////////////////////////////////////////

       // 是否屏蔽任务键序列——也就是说键盘钩子是否安装?

       // 注：这里假设没有其它钩子做同样的事情

       //

       DLLEXPORT BOOL AreTaskKeysDisabled()

       {

       return g_hHookKbdLL != NULL;

       }

       ////////////////////////////////////////////////

       // 屏蔽任务键：安装低级键盘构

       // 返回当前是否屏蔽标志(TRUE/FALSE)

       //

       DLLEXPORT BOOL DisableTaskKeys(BOOL bDisable, BOOL bBeep)

       {

       if (bDisable) {

       if (!g_hHookKbdLL) {

       g_hHookKbdLL = SetWindowsHookEx(WH_KEYBOARD_LL,

       MyTaskKeyHookLL, MyDll.m_hInstance, 0);

       }

       } else if (g_hHookKbdLL != NULL) {

       UnhookWindowsHookEx(g_hHookKbdLL);

       g_hHookKbdLL = NULL;

       }

       g_bBeep = bBeep;

       return AreTaskKeysDisabled();

       }

       TaskKeyHook 输出两个函数：DisableTaskKeys 和 AreTaskKeysDisabled。前者安装WH_KEYBOARD_LL 钩子;后者判断这个钩子是否安装。此键盘钩子的处理思路是截获Alt+Tab，Ctrl+Esc，Alt+Esc以及Windows 键VK_LWIN/VK_RWIN，关于这两个键，稍候会有详细描述。当钩子碰到这些键时，它直接返回到调用者，而不是将处理传递给CallNextHookEx 。

       LRESULT CALLBACK MyTaskKeyHookLL(...)

       {

       if (/* 任务键*)

       return 1; // 立即返回

       return CallNextHookEx(...);

       }

       TaskKeyHook的大部分实现都很简单。只有一个地方用到了一点小技巧：既使用#pragma data_seg 命名包含全程数据的数据段，并且用#pragma comment (linker...)告诉链接器让这个数据段为共享段。实现细节请参考源代码。本文附带的例子程序(TrapKeys.exe)汇集了上述几个有关屏蔽键盘按键序列的功能，除此之外，它还有一个功能就是禁用任务栏。因为既然禁用了任务转换键，那么一般来说，也必然要禁用任务栏，否则禁用任务转换键就没有意义了。禁用任务栏的具体方法如下：

       HWND hwnd = FindWindow("Shell_traywnd", NULL);//找到任务栏

       EnableWindow(hwnd, FALSE); // 禁用任务栏

       如图四是例子程序运行画面：

       图四 TrapKeys程序运行画面

       以下是TrapKeys程序的实现代码：

       /////////////////////////////////////////////////

       // TrapKeys.cpp

       //

       #include "stdafx.h"

       #include "resource.h"

       #include "StatLink.h"

       #include "TaskKeyMgr.h"

       ////////////////////

       // 主对话框

       //

       class CMyDialog : public CDialog {

       public:

       CMyDialog(CWnd* pParent = NULL) : CDialog(IDD_MYDIALOG, pParent) { }

       protected:

       HICON m_hIcon;

       CStaticLink m_wndLink1;

       CStaticLink m_wndLink2;

       CStaticLink m_wndLink3;

       virtual BOOL OnInitDialog();

       // 命令/UI 的更新处理

       afx_msg void OnDisableTaskMgr();

       afx_msg void OnDisableTaskKeys();

       afx_msg void OnDisableTaskbar();

       afx_msg void OnUpdateDisableTaskMgr(CCmdUI* pCmdUI);

       afx_msg void OnUpdateDisableTaskKeys(CCmdUI* pCmdUI);

       afx_msg void OnUpdateDisableTaskbar(CCmdUI* pCmdUI);

       afx_msg LRESULT OnKickIdle(WPARAM,LPARAM);

       DECLARE_MESSAGE_MAP()

       };

       ///////////////////////////////////////////////////////

       // 标准的MFC 对话框应用类代码。

       //

       class CMyApp : public CWinApp {

       public:

       virtual BOOL InitInstance() {

       // 初始化app：运行对话框

       CMyDialog dlg;

       m_pMainWnd = dlg;

       dlg.DoModal();

       return FALSE;

       }

       virtual int ExitInstance() {

       // 为了按全起见，在退出程序的时候，将所有禁用的项目复原

       CTaskKeyMgr::Disable(CTaskKeyMgr::ALL, FALSE);

       return 0;

       }

       } theApp;

       BEGIN_MESSAGE_MAP(CMyDialog, CDialog)

       ON_COMMAND(IDC_DISABLE_TASKKEYS,OnDisableTaskKeys)

       ON_COMMAND(IDC_DISABLE_TASKBAR, OnDisableTaskbar)

       ON_COMMAND(IDC_DISABLE_TASKMGR, OnDisableTaskMgr)

       ON_UPDATE_COMMAND_UI(IDC_DISABLE_TASKKEYS, OnUpdateDisableTaskKeys)

       ON_UPDATE_COMMAND_UI(IDC_DISABLE_TASKBAR, OnUpdateDisableTaskbar)

       ON_UPDATE_COMMAND_UI(IDC_DISABLE_TASKMGR, OnUpdateDisableTaskMgr)

       ON_MESSAGE(WM_KICKIDLE,OnKickIdle)

       END_MESSAGE_MAP()

       ///////////////////////////////////////////////

       // 初始化对话框：子类化超链接柄加栽图标

       //

       BOOL CMyDialog::OnInitDialog()

       {

       CDialog::OnInitDialog();

       // 初始化超链接

       m_wndLink1.SubclassDlgItem(IDC_EMAIL,this);

       m_wndLink2.SubclassDlgItem(IDC_VCKBASEURL,this);

       m_wndLink3.SubclassDlgItem(IDC_VCKBASELINK,this);

       // 自己设置对话框图标。MFC不会为对话框应用程序设置它

       m_hIcon = AfxGetApp()-LoadIcon(IDR_MAINFRAME);

       SetIcon(m_hIcon, TRUE); // 打图标

       SetIcon(m_hIcon, FALSE); // 小图标

       return TRUE;

       }

       ////////////////////////////////////////////////////////

       // 命令/UI 更新处理：写这些东西应该很轻松。

       void CMyDialog::OnDisableTaskKeys()

       {

       CTaskKeyMgr::Disable(CTaskKeyMgr::TASKKEYS,

       !CTaskKeyMgr::AreTaskKeysDisabled(), TRUE); // 蜂鸣

       }

       void CMyDialog::OnUpdateDisableTaskKeys(CCmdUI* pCmdUI)

       {

       pCmdUI-SetCheck(CTaskKeyMgr::AreTaskKeysDisabled());

       }

       void CMyDialog::OnDisableTaskbar()

       {

       CTaskKeyMgr::Disable(CTaskKeyMgr::TASKBAR,

       !CTaskKeyMgr::IsTaskBarDisabled());

       }

       void CMyDialog::OnUpdateDisableTaskbar(CCmdUI* pCmdUI)

       {

       pCmdUI-SetCheck(CTaskKeyMgr::IsTaskBarDisabled());

       }

       void CMyDialog::OnDisableTaskMgr()

       {

       CTaskKeyMgr::Disable(CTaskKeyMgr::TASKMGR,

       !CTaskKeyMgr::IsTaskMgrDisabled());

       }

       void CMyDialog::OnUpdateDisableTaskMgr(CCmdUI* pCmdUI)

       {

       pCmdUI-SetCheck(CTaskKeyMgr::IsTaskMgrDisabled());

       }

       ////////////////////////////////////////////////////////

       // 要想让ON_UPDATE_COMMAND_UI正常工作，这是必需的。

       //

       LRESULT CMyDialog::OnKickIdle(WPARAM wp, LPARAM lCount)

       {

       UpdateDialogControls(this, TRUE);

       return 0;

       }

       按上述方法尽管禁用了任务栏，但是还有一个机关没有处理，那就是按下Windows键仍然可以弹出“开始”菜单。显然在处理VK_LWIN之前，任务栏不会检查是否被启用。一般来讲，如果某个窗口被屏蔽掉，那么它就不再会处理用户在这个窗口的输入——这就是所谓的禁用(Disable)的含义。通常调用EnableWindow(FALSE)后自然就达到了这个目的。但是处理VK_LWIN/VK_RWIN按键的代码决不会去检查任务栏启用/禁用状态。对此，本文的处理办法仍然是利用键盘钩子。修改一下TaskKeyHook实现，增加对Windows键的捕获。这样按下“开始”菜单键之后什么也不会发生。希望没有漏掉其它的按键。如果哪位读者发现漏掉了什么键，请和我联系，以便把它加到键盘钩子中去。为了简单起见，我在类CTaskKeyMgr中封装了所有禁用的函数。下面是这个类的定义击实现文件：

       TaskKeyMgr

       ////////////////////////////////////////

       // TaskKeyMgr.h

       //

       #pragma once

       #include "TaskKeyHook.h"

       /////////////////////////////////////////////////////////////////////

       // 使用这个类禁用任务键，任务管理器或任务栏。

       // 用相应的标志调用Disable，如：CTaskMgrKeys::Disable(CTaskMgrKeys::ALL);

       //

       class CTaskKeyMgr {

       public:

       enum {

       TASKMGR = 0x, // 禁用任务管理器(Ctrl+Alt+Del)

       TASKKEYS = 0x, //禁用任务转换键(Alt-TAB, etc)

       TASKBAR = 0x, //禁用任务栏

       ALL=0xFFFF //禁用所有东西L

       };

       static void Disable(DWORD dwItem,BOOL bDisable,BOOL bBeep=FALSE);

       static BOOL IsTaskMgrDisabled();

       static BOOL IsTaskBarDisabled();

       static BOOL AreTaskKeysDisabled() {

       return ::AreTaskKeysDisabled(); // 调用 DLL

       }

       };

       CPP实现

       ////////////////////////////////////////////////////////////////

       // TaskKeyMgr.cpp

       //

       #include "StdAfx.h"

       #include "TaskKeyMgr.h"

       #define HKCU HKEY_CURRENT_USER

       // 用于禁用任务管理器策略的注册表键值对

       LPCTSTR KEY_DisableTaskMgr =

       "Software//Microsoft//Windows//CurrentVersion//Policies//System";

       LPCTSTR VAL_DisableTaskMgr = "DisableTaskMgr";

       ///////////////////////////////////////////

       // 禁用相关的任务键

       //

       // dwFlags = 表示禁用什么

       // bDisable = 禁用为 (TRUE) ，否则为启用 (FALSE)

       // bBeep = 按下非法键是否蜂鸣(指针对任务键)

       //

       void CTaskKeyMgr::Disable(DWORD dwFlags, BOOL bDisable, BOOL bBeep)

       {

       // 任务管理器 (Ctrl+Alt+Del)

       if (dwFlags TASKMGR) {

       HKEY hk;

       if (RegOpenKey(HKCU, KEY_DisableTaskMgr,hk)!=ERROR_SUCCESS)

       RegCreateKey(HKCU, KEY_DisableTaskMgr, hk);

       if (bDisable) { // 禁用任务管理器(disable TM)： set policy = 1

       DWORD val=1;

       RegSetValueEx(hk, VAL_DisableTaskMgr, NULL,

       REG_DWORD, (BYTE*)val, sizeof(val));

       } else { // 启用任务管理器(enable TM)

       RegDeleteValue(hk,VAL_DisableTaskMgr);

       }

       }

       // 任务键 (Alt-TAB etc)

       if (dwFlags TASKKEYS)

       ::DisableTaskKeys(bDisable,bBeep); // 安装键盘钩

       // 任务栏

       if (dwFlags TASKBAR) {

       HWND hwnd = FindWindow("Shell_traywnd", NULL);

       EnableWindow(hwnd, !bDisable);

       }

       }

       BOOL CTaskKeyMgr::IsTaskBarDisabled()

       {

       HWND hwnd = FindWindow("Shell_traywnd", NULL);

       return IsWindow(hwnd) ? !IsWindowEnabled(hwnd) : TRUE;

       }

       BOOL CTaskKeyMgr::IsTaskMgrDisabled()

       {

       HKEY hk;

       if (RegOpenKey(HKCU, KEY_DisableTaskMgr, hk)!=ERROR_SUCCESS)

       return FALSE; // 没有此键，不禁用

       DWORD val=0;

       DWORD len=4;

       return RegQueryValueEx(hk, VAL_DisableTaskMgr,

       NULL, NULL, (BYTE*)val, len)==ERROR_SUCCESS val==1;

       }

       这个类中的函数都是静态的，实际上CTaskKeyMgr完全就是一个名字空间。你可以在自己的程序中随心所欲地使用它。例如，禁用任务转换按键和任务栏，但是不禁用Ctrl+Alt+Del：

       CTaskKeyMgr::Disable(CTaskKeyMgr::TASKKEYS |

       CTaskKeyMgr::TASKBAR, TRUE);

       此外，还有几个函数是用来检查当前禁用了哪些东西，甚至可以在用户按下禁用键时发出蜂鸣声……自己去享受Paul的源代码吧!