《Undocumented Windows 2000 Secrets》翻译 --- 第五章（4）

最新推荐文章于 2024-11-03 15:24:53 发布
最新推荐文章于 2024-11-03 15:24:53 发布
阅读量3k 收藏
点赞数
分类专栏： 翻译/心得、总结 深入探索Windows系统 文章标签： windows api header null attributes buffer

第五章  监控Native API调用

翻译：Kendiv( fcczj@263.net )

更新：Tuesday, April 12, 2005

 

声明：转载请注明出处，并保证文章的完整性，本人保留译文的所有权利。

 

管理句柄

要特别注意的是：SpyHookProtocol()函数仅在它内部包含SpyWriteFilter()函数的条件语句返回TRUE时，才会记录API函数调用。这种行为是为了减少Hook协议中的无用信息。例如，移动鼠标将触发一系列NtReadFile()函数调用。其他产生无用信息的源头和物理实验中的测量有些相似：比如，你在实验环境下测量某种物理效果时，测量方法本身也会对要测量的物理效果产生影响，这将导致测量结果的“失真”。这同样发生在记录API时。注意：NtDeviceIoControlFile()函数也包含在列表5-6中的格式化字符串数组中。不过，Spy设备的客户端采用Device I/O Control调用来读取API Hook协议。这意味着客户端将在协议数据中发现它自己的NtDeviceIoControlFile()调用。根据IOCTL事务的频率，你所期望的数据可能会淹没在它自己的函数调用记录中（译注：此处是指，如果客户端频繁的使用IOCTL，那么记录下的IOCTL函数调用中，仅有少量是我们所期望关注的，而大部分都是客户端自己产生的），Spy设备通过记录安装API Hook的那个线程的ID，并忽略来自该线程的API调用来解决这一问题。

 

对于所有产生句柄，并且产生的句柄未被记录的API调用，SpyWriteFilter()都将忽略，以消除无用信息。如果Spy设备发现一个句柄已经关闭或已返回给系统，那么任何使用该句柄的函数序列都将被忽略。更有效的是，如果API调用包含由系统或其他在启动API Hook协议之前就存在的进程创建的句柄（这种句柄的生命期都很长），那么该API调用将会被禁止。当然，客户端可以通过IOCTL禁止或允许这种过滤。你可以使用本章稍后将介绍的一个简单的客户端程序来来测试这种过滤机制。你将会很惊讶这个简单的“噪音过滤”功能的强大。

 

在列表5-6中，产生句柄的函数有：NtCreateFile()、NtCreateKey()、NtOpenFile()、NtOpenKey()、NtOpenProcess()和NtOpenThread()。所有这些函数的格式字符串中都包含一个%+控制符，该控制符用于表示表5-2中的“句柄（注册）”。对于关闭或释放句柄的函数：NtClose()和NtDeleteKey()，在二者的格式字符串中均包含一个%-控制符，对应表5-2中的“句柄（撤销注册）”。其他函数只是简单的使用句柄（这些函数并不会创建获释放这些句柄），在它们的格式字符串中包含%！。基本上，句柄是在进程的上下文中，用于唯一标识一个对象的数字。当一个API函数产生一个新的句柄时，客户端通常必须传入一个OBJECT_ATTRIBUTES结构来存放该句柄以及其他的一些东西，对于对象的名字来说，它应该是可以访问的。稍后，将不再需要该名称，因为系统可以使用对象句柄在句柄表中查寻其对应的对象的属性。这对于API Spy的用户来说却不是好消息，因为它必需在大量的协议项中用毫无疑义的数字代替符号名称。因此，我的Spy设备将注册所有的对象名称及其对应的句柄和该句柄所有者进程的ID，每当一个新的句柄出现，就会更新这一列表。当一个注册的句柄/进程对在稍后出现时，API记录者将会从列表中检索出其对应的原始符号名称，并将其加入的协议中。

 

已注册的句柄在被某个API函数显示关闭前，都是有效的。如果在某个可产生新的句柄的API调用中，再次出现已注册句柄，那么该句柄将不再处于已注册状态。对于Windows 2000，我频繁的观测系统有时会返回相同的句柄值，尽管在此之前，协议里没有包含任何关闭该句柄的调用。我不记得在Windows NT 4.0中是否也存在类似的情况。一个已注册的句柄，若再次代表不同的对象属性出现时，会被显示的由某种方式关闭掉，因此必须要撤销此种句柄的注册。否则，Spy设备的句柄目录将最终进入溢出状态。

 

SpyHookPrtocol()调用的SpyWriteFilter()函数（在列表5-7中给出）是句柄跟踪机制的一个基本组成部分。任何被hook的API函数在被调用时，都会经过该函数。列表5-8给出了该函数的实现方式。

 

BOOL SpyWriteFilter (PSPY_PROTOCOL psp,

                     PBYTE         pbFormat,

                     PVOID         pParameters,

                     DWORD         dParameters)

    {

    PHANDLE            phObject = NULL;

    HANDLE             hObject  = NULL;

    POBJECT_ATTRIBUTES poa      = NULL;

    PDWORD             pdNext;

    DWORD              i, j;

 

    pdNext = pParameters;

    i = j  = 0;

 

    while (pbFormat [i])

        {

        while (pbFormat [i] && (pbFormat [i] != '%')) i++;

 

        if (pbFormat [i] && pbFormat [++i])

            {

            j++;

 

            switch (pbFormat [i++])

                {

                case 'b':

                case 'a':

                case 'w':

                case 'u':

                case 'n':

                case 'l':

                case 's':

                case 'i':

                case 'c':

                case 'd':

                case 'p':

                    {

                    break;

                    }

                case 'o':

                    {

                    if (poa == NULL)

                        {

                        poa = (POBJECT_ATTRIBUTES) *pdNext;

                        }

                    break;

                    }

                case '+':

                    {

                    if (phObject == NULL)

                        {

                        phObject = (PHANDLE) *pdNext;

                        }

                    break;

                    }

                case '!':

                case '-':

                    {

                    if (hObject == NULL)

                        {

                        hObject = (HANDLE) *pdNext;

                        }

                    break;

                    }

                default:

                    {

                    j--;

                    break;

                    }

                }

            pdNext++;

            }

        }

    return // number of arguments ok

           (j == dParameters)

           &&

            // no handles involved

           (((phObject == NULL) && (hObject == NULL))

            ||

            // new handle, successfully registered

            ((phObject != NULL) &&

             SpyHandleRegister (psp, PsGetCurrentProcessId (),

                                *phObject, OBJECT_NAME (poa)))

            ||

            // registered handle

            SpyHandleSlot (psp, PsGetCurrentProcessId (), hObject)

            ||

            // filter disabled

            (!gfSpyHookFilter));

    }

列表5-8.  SpyWriteFilter()将从协议中去除未注册的API调用

 

SpyWriteFilter()主要通过扫描协议格式字符串来查找%o（对象属性）、%+（新的句柄）、%!（打开句柄）和%-（关闭句柄），并对其中某几个控制ID的组合采取特殊的动作，如下所示：

l         如果没有涉及句柄，所有的API调用都将被记录。这涉及所有格式字符串中不包含格式控制ID%+、%!和%-的API函数。

 

l         如果格式字符串中包含%+，这表示该API函数将分配一个新的句柄，将使用帮助函数SpyHandleRegister()来注册该句柄，并且将该句柄与格式字符串中第一个%o项的名字关联起来。如果这样的名字不存在，则该句柄将以一个空字符串注册。如果注册成功，此API调用将被记录。

 

l         如果格式字符串中包含%!或%-，则被调用的函数将使用或关闭一个句柄。这种情况下，SpyWriteFilter()将使用SpyHandleSlot()函数来查询该句柄的索引，以测试该句柄是否已注册。如果测试成功，该API调用将被记录。

 

l         对于所有其他的情况，仅当过滤机制关闭时，函数调用才被记录。过滤机制是否开启由全局逻辑变量gfSpyHookFilter表示。

 

句柄目录是SPY_PROTOCOL结构的一部分，包含在Spy设备（w2k_spy.sys）的全局DEVICE_CONTEXT结构中，列表5-9给出了它的定义以及SPY_HEADER子结构的定义。在这些定义之后的是四个句柄管理函数（SpyHandleSlot()、SpyHandleName()、SpyHandleUnregister()和SpyHandleRegister()）的源代码。通过将句柄的值加入到ahObjets[]数组的末尾来注册该句柄。同时，拥有该句柄的进程ID将被保存到ahprocesses[]数组中，对象名将被复制到awNames[]缓冲区中，名字的起始偏移地址将被保存到adNames[]数组中。当注销一个句柄时，过程与上述类似，这可能需要移动数组中的其它元素以保证数组中不存在“空洞”。列表5-9顶部定义的常量定义了句柄目录的大小：它最多可存放4,096个句柄，名称的大小被限制为1,048,576个Unicode字符（2MB），协议缓冲区的大小为1MB。

 

#define SPY_HANDLES         0x00001000 // max number of handles

#define SPY_NAME_BUFFER     0x00100000 // object name buffer size

#define SPY_DATA_BUFFER     0x00100000 // protocol data buffer size

 

// -----------------------------------------------------------------

 

typedef struct _SPY_HEADER

    {

    LARGE_INTEGER liStart;  // start time

    DWORD         dRead;    // read data index

    DWORD         dWrite;   // write data index

    DWORD         dCalls;   // api usage count

    DWORD         dHandles; // handle count

    DWORD         dName;    // object name index

    }

    SPY_HEADER, *PSPY_HEADER, **PPSPY_HEADER;

 

#define SPY_HEADER_ sizeof (SPY_HEADER)

 

// -----------------------------------------------------------------

 

typedef struct _SPY_PROTOCOL

    {

    SPY_HEADER    sh;                            // protocol header

    HANDLE        ahProcesses [SPY_HANDLES];     // process id array

    HANDLE        ahObjects   [SPY_HANDLES];     // handle array

    DWORD         adNames     [SPY_HANDLES];     // name offsets

    WORD          awNames     [SPY_NAME_BUFFER]; // name strings

    BYTE          abData      [SPY_DATA_BUFFER]; // protocol data

    }

    SPY_PROTOCOL, *PSPY_PROTOCOL, **PPSPY_PROTOCOL;

 

#define SPY_PROTOCOL_ sizeof (SPY_PROTOCOL)

 

// =================================================================

// HANDLE MANAGEMENT

// =================================================================

 

DWORD SpyHandleSlot (PSPY_PROTOCOL psp,

                     HANDLE        hProcess,

                     HANDLE        hObject)

    {

    DWORD dSlot = 0;

 

    if (hObject != NULL)

        {

        while ((dSlot < psp->sh.dHandles)

               &&

               ((psp->ahProcesses [dSlot] != hProcess) ||

                (psp->ahObjects   [dSlot] != hObject ))) dSlot++;

 

        dSlot = (dSlot < psp->sh.dHandles ? dSlot+1 : 0);

        }

    return dSlot;

    }

 

// -----------------------------------------------------------------

 

DWORD SpyHandleName (PSPY_PROTOCOL psp,

                     HANDLE        hProcess,

                     HANDLE        hObject,

                     PWORD         pwName,

                     DWORD         dName)

    {

    WORD  w;

    DWORD i;

    DWORD dSlot = SpyHandleSlot (psp, hProcess, hObject);

 

    if ((pwName != NULL) && dName)

        {

        i = 0;

 

        if (dSlot)

            {

            while ((i+1 < dName) &&

                   (w = psp->awNames [psp->adNames [dSlot-1] + i]))

                {

                pwName [i++] = w;

                }

            }

        pwName [i] = 0;

        }

    return dSlot;

    }

 

// -----------------------------------------------------------------

 

DWORD SpyHandleUnregister (PSPY_PROTOCOL psp,

                           HANDLE        hProcess,

                           HANDLE        hObject,

                           PWORD         pwName,

                           DWORD         dName)

    {

    DWORD i, j;

    DWORD dSlot = SpyHandleName (psp, hProcess, hObject,

                                 pwName, dName);

    if (dSlot)

        {

        if (dSlot == psp->sh.dHandles)

            {

            // remove last name entry

            psp->sh.dName = psp->adNames [dSlot-1];

            }

        else

            {

            i = psp->adNames [dSlot-1];

            j = psp->adNames [dSlot  ];

 

            // shift left all remaining name entries

            while (j < psp->sh.dName)

                {

                psp->awNames [i++] = psp->awNames [j++];

                }

            j -= (psp->sh.dName = i);

 

            // shift left all remaining handles and name offsets

            for (i = dSlot; i < psp->sh.dHandles; i++)

                {

                psp->ahProcesses [i-1] = psp->ahProcesses [i];

                psp->ahObjects   [i-1] = psp->ahObjects   [i];

                psp->adNames     [i-1] = psp->adNames     [i] - j;

                }

            }

        psp->sh.dHandles--;

        }

    return dSlot;

    }

 

// -----------------------------------------------------------------

 

DWORD SpyHandleRegister (PSPY_PROTOCOL   psp,

                         HANDLE          hProcess,

                         HANDLE          hObject,

                         PUNICODE_STRING puName)

    {

    PWORD pwName;

    DWORD dName;

    DWORD i;

    DWORD dSlot = 0;

 

    if (hObject != NULL)

        {

        // unregister old handle with same value

        SpyHandleUnregister (psp, hProcess, hObject, NULL, 0);

 

        if (psp->sh.dHandles == SPY_HANDLES)

            {

            // unregister oldest handle if overflow

            SpyHandleUnregister (psp, psp->ahProcesses [0],

                                 psp->ahObjects [0], NULL, 0);

            }

        pwName = ((puName != NULL) && SpyMemoryTestAddress (puName)

                  ? puName->Buffer

                  : NULL);

 

        dName  = ((pwName != NULL) && SpyMemoryTestAddress (pwName)

                  ? puName->Length / WORD_

                  : 0);

 

        if (dName + 1 <= SPY_NAME_BUFFER - psp->sh.dName)

            {

            // append object to end of list

            psp->ahProcesses [psp->sh.dHandles] = hProcess;

            psp->ahObjects   [psp->sh.dHandles] = hObject;

            psp->adNames     [psp->sh.dHandles] = psp->sh.dName;

 

            for (i = 0; i < dName; i++)

                {

                psp->awNames [psp->sh.dName++] = pwName [i];

                }

            psp->awNames [psp->sh.dName++] = 0;

 

            psp->sh.dHandles++;

            dSlot = psp->sh.dHandles;

            }

        }

    return dSlot;

    }

列表5-9.   句柄管理相关的结构和函数

 

 

…….………..待续………………

Kendiv
关注
专栏目录
跟踪NtReadFile系统服务的执行过程
SaiCT的专栏
01-02 5162
由于马上就要期末考试了，操作系统这么课，关于设备这一块我还是一片狼藉，很是杂乱。由于老师之前说过不懂驱动就不可能懂设备，所以我就找了本驱动开发的书来看。还是有些收获的，至少根据书中的描述，我大致了解了处理一个IO请求的最简单最简单流程。大概流程是是Win32API——Native API——系统调用陷入——内核内部例程创建IRP——传递给相应驱动程序。至于驱动程序执行完之后的是我就不甚了解
C++ 有价值blog索引(不断更新)
yjhl982的专栏
12-28 6983
本文章的出现是因为有不少人恶劣地将垃圾文章归类到C++blog中,也包括很多可以归类到C++但没什么价值的blog出现最新的blog文档添加到最下面,老的会逐渐添加到前面.一般只归类原创和翻译的!大家如果发现blog文章只是转的,请及时告知................................................................................
win10系统调用架构分析
weixin_33904756的博客
08-02 1050
1.  操作系统模型 大多数操作系统中，都会把应用程序和内核代码分离执行在不同的模式下。内核模式訪问系统数据和硬件，应用程序执行在没有特权的模式下（用户模式），仅仅能使用有限的API，且不能直接訪问硬件。当用户模式调用系统服务时。CPU执行一个特殊的指令以切换到内核模式（Ring0），当系统服务调用完毕时。操作系统切换回用户模式（Ring3）。 Windows与大多数UNIX系统类...
Windows驱动程序开发（七）--- 派遣函数
dabenxiong的专栏
05-16 1860
派遣函数主要功能是负责处理I/O请求，其中大部分I/O
(转载)反病毒引擎设计 --- 实时监控篇
Kendiv's Box
01-17 7578
反病毒引擎设计之实时监控篇作者：NJUE    文章来源：安全焦点  2004年01月15日        编者按：绪论《反病毒引擎设计之虚拟机查毒篇》我们重点对虚拟机查毒进行了阐述。下面看看如何对病毒实时监控。  目    录3.1实时监控概论3.2病毒实时监控实现技术概论3.3 WIN9X下的病毒实时监控  3.3.1实现技术详解  3.3.2程
(转载)反病毒引擎设计 --- 虚拟机查毒篇
Kendiv's Box
01-17 4223
反病毒引擎设计之虚拟机查毒篇作者：NJUE 发文时间：2004.01.14  编者按：绪论《反病毒引擎设计之绪论篇》我们介绍了病毒技术的发展状况和一些病毒的特点和感染机制。下面我们重点对虚拟机查毒进行阐述。  目  录2.1虚拟机概论2.2加密变形病毒2.3虚拟机实现技术详解2.4虚拟机代码剖析  2.4.1不依赖标志寄存器指令模拟函数的分析   2.4
windows对象管理入门理解
vincent_1011的专栏
12-10 3047
先来一张图。下面文字参考《 Undocumented Windows 2000 Secrets》  四1. Dispatcher对象 此类对象位于系统的最底层，在它们的对象体的开始处都有一个共享 的公共数据结构----DISPATCHER_HEADER（参见列表7-1）。在它们的对象头中包含一个对象类型ID和对
代码随想录之链表刷题总结
Lllongroad的博客
10-31 744
代码随想录之链表刷题总结
内核上项目【远程call】
qq_45844442的博客
10-31 378
本次项目代码量过多，但思路相对简单，主要功能为挂起目标主线程，将主线程TrapFrame的rip进行修改跳转到指定的shellcode位置,该ShellCode我写的是弹出MessageBox,然后再恢复线程，最后创建一个工作队列，让系统将我们的ShellCode等痕迹进行清除，因为我只写了关于64位的进程操作，如果是操作32位进程，要在定位到Context结构，进而修改eip。
DataMining-FP-Growth算法Java实现
m0_73249076的博客
10-31 248
DataMining，FPGrowth算法Java实现
Vant 4官网例子使用与setup语法糖冲突解决方法
ededabo的博客
10-31 344
官网的数据处理部分使用export暴露函数写的这与 setup语法糖有冲突。冲突的原因是setup语法糖已经帮我们对数据进行暴露处理了。这个是轮播图的处理例子，其他带数据的组件都可以这样处理。然后引用组件就可以愉快的玩耍了。去除外层暴露函数及返回。例子：弹幕组件的使用。
（实战）WebApi第9讲：EFCore性能优化（IQueryable延迟查询、取消跟踪机制）
weixin_54966200的博客
10-31 582
ToList()在下图绿色框内。
链表逆置相关算法题|原地逆置|轮转链表|循环链表逆置(C)
最新发布
ChoSeitaku的博客
11-03 414
将n初始化为1，cur指向L，cur的next指向第一个节点，往后遍历直到cur的next指向NULL，cur指向最后一个节点。一个工作指针cur用来遍历链表，一个后继指针用来保存cur的下一个节点，一个前驱指针prev用来保存前一个节点。然后找到新链表的尾节点，为原链表的第n-k个节点，令L指向新链表尾节点的下一个节点，并将环断开，得到新链表。将prev指向cur，cur指向next，next指向next的下一个，三个指针往后走一步。将cur的next指向perv，将中间节点的next指向前一个节点。
驱动——线程断链和信息获取
weixin_48257887的博客
10-31 303
实验环境：win7 x32。
java开发常用工具类
810cheng
10-31 267
java常用工具类收集
sicp每日一题[2.63-2.64]
再思的博客
10-31 1082
b. 对于 tree->list-1，因为 append 需要花费线性时间，所以T(n) = 2 * T(n/2) + O(n/2)，时间复杂度为 O(n * log n);对于 tree->list-2，T(n) = 2*T(n/2) + O(1)，时间复杂度为 O(n)，第二个增长的慢一些。所以 T(n) = 2T(n/2) + O(1)，根据 Master theorem，a=2, b=2, f(n) = O(1) = O(n^0), 即 c=0.则 T(n) = O(n)，具体计算方法参考这篇。
Java8 新特性 —— Stream API 详解
m0_74620530的博客
10-31 1055
Stream作为Java 8的一大亮点，它专门针对集合的各种操作提供各种非常便利、简单、高效的API，Stream API主要是通过Lambda表达式完成，极大的提高了程序的效率和可读性，同时Stram API中自带的并行流使得并发处理集合的门槛再次降低，使用Stream API编程无需多写一行多线程的代码就可以非常方便的写出高性能的并发程序。使用Stream API能够使代码更加优雅。
Java集合使用注意事项总结
Wzideng@qq.com
10-31 346
/class java.util.ArrayList 2、最简便的方法 List list = new ArrayList(Arrays.asList("a", "b", "c")) 3、使用 Java8 的 Stream(推荐) Integer [] myArray = { 1, 2, 3 };方法的可读性更好，并且时间复杂度为 O(1)。
深入探索Windows 2000调试技术
在《Undocumented Windows 2000 Secrets》中，作者深入探讨了Windows 2000操作系统中不为人知的技术细节，特别是针对调试技术的方面。这本书不仅适用于那些对操作系统底层工作原理感兴趣的读者，也适合软件开发者和...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值