驱动开发：内核注册并监控对象回调

在笔者上一篇文章《驱动开发：内核枚举进程与线程ObCall回调》简单介绍了如何枚举系统中已经存在的进程与线程回调，本章LyShark将通过对象回调实现对进程线程的句柄监控，在内核中提供了ObRegisterCallbacks回调，使用这个内核回调函数，可注册一个对象回调，不过目前该函数只能监控进程与线程句柄操作，通过监控进程或线程句柄，可实现保护指定进程线程不被终止的目的。
由于目前对象回调只能监控进程与线程，而这个监控是通过ObjectType这么一个成员控制的，如果成员是PsProcessType则代表监控进程，反之PsThreadType则是监控线程，无论监控进程还是线程都调用ObRegisterCallbacks这个函数来完成注册。
函数ObRegisterCallbacks其微软对他的定义是这样的，用户传入OB_OPERATION_REGISTRATION结构，以及OB_CALLBACK_REGISTRATION回调结构，其中PreOperation则是传入的回调函数，也是最重要的，其次是ObjectType指定成进程回调。

1. NTSTATUS ObRegisterCallbacks(
2.   [in]  POB_CALLBACK_REGISTRATION CallbackRegistration,
3.   [out] PVOID                     *RegistrationHandle
4. );

复制代码

首先来实现一个检测的案例，注册一个进程回调对象MyLySharkComObjectCallBack，通过ObRegisterCallbacks注册的回调只需要传入一个填充好的OB_CALLBACK_REGISTRATION回调结构体，以及一个全局句柄即可，这个全局句柄的作用仅仅只是在程序结束时，调用ObUnRegisterCallbacks卸载监控而已，实现代码如下所示。

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: me@lyshark.com
5. #include <ntddk.h>
6. #include <ntstrsafe.h>
8. PVOID Globle_Object_Handle;
10. // 绕过签名检测
11. void BypassCheckSign(PDRIVER_OBJECT pDriverObj)
12. {
13.         typedef struct _LDR_DATA
14.         {
15.                 struct _LIST_ENTRY InLoadOrderLinks;
16.                 struct _LIST_ENTRY InMemoryOrderLinks;
17.                 struct _LIST_ENTRY InInitializationOrderLinks;
18.                 VOID*        DllBase;
19.                 VOID*        EntryPoint;
20.                 ULONG32      SizeOfImage;
21.                 UINT8        _PADDING0_[0x4];
22.                 struct _UNICODE_STRING FullDllName;
23.                 struct _UNICODE_STRING BaseDllName;
24.                 ULONG32      Flags;
25.         }LDR_DATA, *PLDR_DATA;
27.         PLDR_DATA ldr;
28.         ldr = (PLDR_DATA)(pDriverObj->DriverSection);
29.         ldr->Flags |= 0x20;
30. }
32. // 自定义回调
33. OB_PREOP_CALLBACK_STATUS MyLySharkComObjectCallBack(PVOID RegistrationContext, POB_PRE_OPERATION_INFORMATION OperationInformation)
34. {
35.         DbgPrint("[lyshark] 执行回调函数... \n");
36.         return STATUS_SUCCESS;
37. }
39. VOID UnDriver(PDRIVER_OBJECT driver)
40. {
41.         ObUnRegisterCallbacks(Globle_Object_Handle);
42.         DbgPrint("回调卸载完成... \n");
43. }
45. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
46. {
47.         DbgPrint("hello lyshark.com \n");
49.         BypassCheckSign(Driver);
51.         OB_OPERATION_REGISTRATION Base;                          // 回调函数结构体
52.         OB_CALLBACK_REGISTRATION CallbackReg;                    // 回调函数
54.         CallbackReg.RegistrationContext = NULL;                  // 注册上下文(你回调函数返回参数)
55.         CallbackReg.Version = OB_FLT_REGISTRATION_VERSION;       // 注册回调版本
56.         CallbackReg.OperationRegistration = &Base;               // 回调结构体
57.         CallbackReg.OperationRegistrationCount = 1;              // 操作计数(下钩数量)
59.         RtlUnicodeStringInit(&CallbackReg.Altitude, L"600000");   // 长度
60.         Base.ObjectType = PsProcessType;                          // 进程操作类型.此处为进程操作
61.         Base.Operations = OB_OPERATION_HANDLE_CREATE;             // 操作句柄创建
62.         Base.PreOperation = MyLySharkComObjectCallBack;           // 你自己的回调函数
63.         Base.PostOperation = NULL;
65.         // 注册回调
66.         if (ObRegisterCallbacks(&CallbackReg, &Globle_Object_Handle))
67.         {
68.                 DbgPrint("[lyshark message] 回调注册成功...");
69.         }
70.         Driver->DriverUnload = UnDriver;
71.         return STATUS_SUCCESS;
72. }

复制代码

当驱动程序被加载以后，一旦有进程运行则会执行我们自己的MyLySharkComObjectCallBack回调，而在回调函数内则可以执行任意功能，运行如下所示。

如上所示只是演示基本的回调申请流程，回调函数通常需要包含两个值，其一RegistrationContext用于标注上下文，其二POB_PRE_OPERATION_INFORMATION则用于标注进程或者线程创建的信息结构体。

1. OB_PREOP_CALLBACK_STATUS MyLySharkComObjectCallBack(PVOID RegistrationContext, POB_PRE_OPERATION_INFORMATION OperationInformation)

复制代码

那么如何实现拦截进程启动这个功能呢，我们可以在回调函数中写入以下代码进行拦截。

• CreateHandleInformation.DesiredAccess 将打开句柄的权限清零
  
• CreateHandleInformation.OriginalDesiredAccess 判断是否终止
  

1. if (pOperationInformation->Operation == OB_OPERATION_HANDLE_CREATE)
2. {
3.         DbgPrint("lyshark.exe 进程打开 \n");
4.         pOperationInformation->Parameters->CreateHandleInformation.DesiredAccess=0;
5.         if ((pOperationInformation->Parameters->CreateHandleInformation.OriginalDesiredAccess & PROCESS_TERMINATE) == PROCESS_TERMINATE)
6.         {
7.                 pOperationInformation->Parameters->CreateHandleInformation.DesiredAccess &= ~PROCESS_TERMINATE;
8.         }
9. }

复制代码

拦截进程创建核心代码如下所示。

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: me@lyshark.com
5. #include <ntddk.h>
6. #include <ntstrsafe.h>
8. #define PROCESS_TERMINATE 0x1
10. // 导出两个API
11. NTKERNELAPI PEPROCESS IoThreadToProcess(PETHREAD Thread);
12. NTKERNELAPI char* PsGetProcessImageFileName(PEPROCESS Process);
14. // 全局句柄
15. PVOID Globle_Object_Handle = NULL;
17. // 绕过签名检测
18. void BypassCheckSign(PDRIVER_OBJECT pDriverObj)
19. {
20.         typedef struct _LDR_DATA
21.         {
22.                 struct _LIST_ENTRY InLoadOrderLinks;
23.                 struct _LIST_ENTRY InMemoryOrderLinks;
24.                 struct _LIST_ENTRY InInitializationOrderLinks;
25.                 VOID*        DllBase;
26.                 VOID*        EntryPoint;
27.                 ULONG32      SizeOfImage;
28.                 UINT8        _PADDING0_[0x4];
29.                 struct _UNICODE_STRING FullDllName;
30.                 struct _UNICODE_STRING BaseDllName;
31.                 ULONG32      Flags;
32.         }LDR_DATA, *PLDR_DATA;
34.         PLDR_DATA ldr;
35.         ldr = (PLDR_DATA)(pDriverObj->DriverSection);
36.         ldr->Flags |= 0x20;
37. }
39. // 判断是否是需要保护的进程
40. BOOLEAN CheckProcess(PEPROCESS eprocess)
41. {
42.         char *Name = PsGetProcessImageFileName(eprocess);
43.         if (!_stricmp("lyshark.exe", Name))
44.                 return TRUE;
45.         else
46.                 return FALSE;
47. }
49. // 进程回调
50. OB_PREOP_CALLBACK_STATUS MyLySharkProcessObjectCallBack(PVOID RegistrationContext, POB_PRE_OPERATION_INFORMATION pOperationInformation)
51. {
52.         HANDLE pid;
54.         // 只取出进程回调
55.         if (pOperationInformation->ObjectType != *PsProcessType)
56.         {
57.                 return OB_PREOP_SUCCESS;
58.         }
60.         // 得到所有进程的ID
61.         pid = PsGetProcessId((PEPROCESS)pOperationInformation->Object);
62.         // DbgPrint("进程PID= %ld \n", pid);
64.         UNREFERENCED_PARAMETER(RegistrationContext);
66.         // 验证是否是需要的进程
67.         if (CheckProcess((PEPROCESS)pOperationInformation->Object))
68.         {
69.                 // 创建句柄
70.                 if (pOperationInformation->Operation == OB_OPERATION_HANDLE_CREATE)
71.                 {
72.                         DbgPrint("lyshark.exe 进程打开事件 \n");
73.                         pOperationInformation->Parameters->CreateHandleInformation.DesiredAccess=0;
74.                         if ((pOperationInformation->Parameters->CreateHandleInformation.OriginalDesiredAccess & PROCESS_TERMINATE) == PROCESS_TERMINATE)
75.                         {
76.                                 DbgPrint("[LyShark Message] 拦截进程打开 \n");
77.                                 pOperationInformation->Parameters->CreateHandleInformation.DesiredAccess &= ~PROCESS_TERMINATE;
78.                         }
79.                 }
80.                 // 复制句柄
81.                 if (pOperationInformation->Operation == OB_OPERATION_HANDLE_DUPLICATE)
82.                 {
83.                         DbgPrint("lyshark.exe 进程被关闭 \n");
84.                         pOperationInformation->Parameters->DuplicateHandleInformation.DesiredAccess=0;
85.                         if ((pOperationInformation->Parameters->DuplicateHandleInformation.OriginalDesiredAccess & PROCESS_TERMINATE) == PROCESS_TERMINATE)
86.                         {
87.                                 pOperationInformation->Parameters->DuplicateHandleInformation.DesiredAccess &= ~PROCESS_TERMINATE;
88.                         }
89.                 }
90.         }
91.         return OB_PREOP_SUCCESS;
92. }
94. VOID UnDriver(PDRIVER_OBJECT driver)
95. {
96.         ObUnRegisterCallbacks(Globle_Object_Handle);
97.         DbgPrint("回调卸载完成... \n");
98. }
100. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
101. {
102.         DbgPrint("hello lyshark.com \n");
104.         BypassCheckSign(Driver);
106.         OB_OPERATION_REGISTRATION ob_process_callback;
107.         OB_CALLBACK_REGISTRATION op_process_operation;
109.         memset(&ob_process_callback, 0, sizeof(ob_process_callback));
110.         ob_process_callback.ObjectType = PsProcessType;
111.         ob_process_callback.Operations = OB_OPERATION_HANDLE_CREATE | OB_OPERATION_HANDLE_DUPLICATE;
112.         ob_process_callback.PreOperation = MyLySharkProcessObjectCallBack;
113.         ob_process_callback.PostOperation = NULL;
115.         RtlUnicodeStringInit(&op_process_operation.Altitude, L"600000");
116.         op_process_operation.RegistrationContext = NULL;
117.         op_process_operation.Version = OB_FLT_REGISTRATION_VERSION;
118.         op_process_operation.OperationRegistration = &ob_process_callback;
119.         op_process_operation.OperationRegistrationCount = 1;
121.         // 注册进程回调
122.         if (ObRegisterCallbacks(&op_process_operation, &Globle_Object_Handle))
123.         {
124.                 DbgPrint("进程回调注册成功...");
125.         }
127.         Driver->DriverUnload = UnDriver;
128.         return STATUS_SUCCESS;
129. }

复制代码

加载这个驱动，当有进程被创建时，则首先判断是否是lyshark.exe如果是则直接禁止打开，也就是终止掉。

同理进程可以被拦截，那么如果增加更多的过滤条件，则线程同样可以被拦截，拦截线程代码如下所示。

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: me@lyshark.com
5. #include <ntddk.h>
6. #include <ntstrsafe.h>
8. #define THREAD_TERMINATE2 0x1
10. // 导出两个API
11. NTKERNELAPI PEPROCESS IoThreadToProcess(PETHREAD Thread);
12. NTKERNELAPI char* PsGetProcessImageFileName(PEPROCESS Process);
14. // 全局句柄
15. PVOID Globle_Object_Handle = NULL;
17. // 绕过签名检测
18. void BypassCheckSign(PDRIVER_OBJECT pDriverObj)
19. {
20.         typedef struct _LDR_DATA
21.         {
22.                 struct _LIST_ENTRY InLoadOrderLinks;
23.                 struct _LIST_ENTRY InMemoryOrderLinks;
24.                 struct _LIST_ENTRY InInitializationOrderLinks;
25.                 VOID*        DllBase;
26.                 VOID*        EntryPoint;
27.                 ULONG32      SizeOfImage;
28.                 UINT8        _PADDING0_[0x4];
29.                 struct _UNICODE_STRING FullDllName;
30.                 struct _UNICODE_STRING BaseDllName;
31.                 ULONG32      Flags;
32.         }LDR_DATA, *PLDR_DATA;
34.         PLDR_DATA ldr;
35.         ldr = (PLDR_DATA)(pDriverObj->DriverSection);
36.         ldr->Flags |= 0x20;
37. }
39. // 判断是否是需要保护的进程
40. BOOLEAN CheckProcess(PEPROCESS eprocess)
41. {
42.         char *Name = PsGetProcessImageFileName(eprocess);
43.         if (!_stricmp("lyshark.exe", Name))
44.                 return TRUE;
45.         else
46.                 return FALSE;
47. }
49. // 线程回调
50. OB_PREOP_CALLBACK_STATUS MyThreadObjectCallBack(PVOID RegistrationContext, POB_PRE_OPERATION_INFORMATION pOperationInformation)
51. {
52.         PEPROCESS ep;
53.         PETHREAD et;
54.         HANDLE pid;
56.         // 线程过滤
57.         if (pOperationInformation->ObjectType != *PsThreadType)
58.         {
59.                 return OB_PREOP_SUCCESS;
60.         }
62.         et = (PETHREAD)pOperationInformation->Object;
63.         ep = IoThreadToProcess(et);
64.         pid = PsGetProcessId(ep);
66.         // DbgPrint("线程PID= %ld | TID= %ld \n", pid, PsGetThreadId(et));
67.         UNREFERENCED_PARAMETER(RegistrationContext);
69.         if (CheckProcess(ep))
70.         {
71.                 if (pOperationInformation->Operation == OB_OPERATION_HANDLE_CREATE)
72.                 {
73.                         pOperationInformation->Parameters->CreateHandleInformation.DesiredAccess=0;
74.                         if ((pOperationInformation->Parameters->CreateHandleInformation.OriginalDesiredAccess & THREAD_TERMINATE2) == THREAD_TERMINATE2)
75.                         {
76.                                 DbgPrint("[LyShark] 拦截lyshark.exe进程内 %d 线程创建 \n", PsGetThreadId(et));
77.                                 pOperationInformation->Parameters->CreateHandleInformation.DesiredAccess &= ~THREAD_TERMINATE2;
78.                         }
79.                 }
80.                 if (pOperationInformation->Operation == OB_OPERATION_HANDLE_DUPLICATE)
81.                 {
82.                         pOperationInformation->Parameters->DuplicateHandleInformation.DesiredAccess=0;
83.                         if ((pOperationInformation->Parameters->DuplicateHandleInformation.OriginalDesiredAccess & THREAD_TERMINATE2) == THREAD_TERMINATE2)
84.                         {
85.                                 pOperationInformation->Parameters->DuplicateHandleInformation.DesiredAccess &= ~THREAD_TERMINATE2;
86.                         }
87.                 }
88.         }
89.         return OB_PREOP_SUCCESS;
90. }
92. VOID UnDriver(PDRIVER_OBJECT driver)
93. {
94.         ObUnRegisterCallbacks(Globle_Object_Handle);
95.         DbgPrint("回调卸载完成... \n");
96. }
98. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
99. {
100.         DbgPrint("hello lyshark.com \n");
102.         BypassCheckSign(Driver);
104.         OB_OPERATION_REGISTRATION ob_thread_callback;
105.         OB_CALLBACK_REGISTRATION op_thread_operation;
107.         memset(&ob_thread_callback, 0, sizeof(ob_thread_callback));
108.         ob_thread_callback.ObjectType = PsThreadType;
109.         ob_thread_callback.Operations = OB_OPERATION_HANDLE_CREATE | OB_OPERATION_HANDLE_DUPLICATE;
110.         ob_thread_callback.PreOperation = MyThreadObjectCallBack;
111.         ob_thread_callback.PostOperation = NULL;
113.         RtlUnicodeStringInit(&op_thread_operation.Altitude, L"600001");
114.         op_thread_operation.RegistrationContext = NULL;
115.         op_thread_operation.Version = OB_FLT_REGISTRATION_VERSION;
116.         op_thread_operation.OperationRegistration = &ob_thread_callback;
117.         op_thread_operation.OperationRegistrationCount = 1;
119.         // 注册进程回调
120.         if (ObRegisterCallbacks(&op_thread_operation, &Globle_Object_Handle))
121.         {
122.                 DbgPrint("进程回调注册成功...");
123.         }
125.         Driver->DriverUnload = UnDriver;
126.         return STATUS_SUCCESS;
127. }

复制代码

这段驱动加载后，如果有新线程被创建，则会被拦截并打印输出，效果图如下。

参考文献

https://www.cnblogs.com/ciyze0101/p/5468175.html

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！