[翻译]反调试：对象句柄

梦幻的彼岸

备注
原文地址：https://anti-debug.checkpoint.com/techniques/object-handles.html
原文标题：Anti-Debug: Object Handles
更新日期：2021年6月9日
此文后期：根据自身所学进行内容扩充
因自身技术有限，只能尽自身所能翻译国外技术文章，供大家学习，若有不当或可完善的地方，希望可以指出，用于共同完善这篇文章。



目录

• 对象句柄
• 1. OpenProcess()
• 2. CreateFile()
• 3. CloseHandle()
• 4. LoadLibrary()
• 5. NtQueryObject()
• 反制措施
  

对象句柄
下面的一组技术代表了使用内核对象句柄来检测调试器存在的检查。一些接受内核对象句柄作为参数的WinAPI函数在调试时可能会有不同的行为，或者会因为调试器的实现而产生副作用。此外，在调试开始时，操作系统会创建特定的内核对象。
1. OpenProcess()
一些调试器可以通过在csrss.exe进程上使用kernel32！OpenProcess()函数来检测。只有当该进程的用户是管理员组的成员并且有调试权限时，该调用才会成功。
C/C++ 代码：

1. typedef DWORD (WINAPI *TCsrGetProcessId)(VOID);
   
2. 
   
3. bool Check()
   
4. {   
   
5.     HMODULE hNtdll = LoadLibraryA("ntdll.dll");
   
6.     if (!hNtdll)
   
7.         return false;
   
8.    
   
9.     TCsrGetProcessId pfnCsrGetProcessId = (TCsrGetProcessId)GetProcAddress(hNtdll, "CsrGetProcessId");
   
10.     if (!pfnCsrGetProcessId)
    
11.         return false;
    
12. 
    
13.     HANDLE hCsr = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pfnCsrGetProcessId());
    
14.     if (hCsr != NULL)
    
15.     {
    
16.         CloseHandle(hCsr);
    
17.         return true;
    
18.     }        
    
19.     else
    
20.         return false;
    
21. }

复制代码

2. CreateFile()
当CREATE_PROCESS_DEBUG_EVENT事件发生时，被调试文件的句柄被保存在CREATE_PROCESS_DEBUG_INFO结构中。因此，调试器可以从这个文件中读取调试信息。如果这个句柄没有被调试器关闭，这个文件就不会被打开独占访问。有些调试器会忘记关闭这个句柄。

这个技巧使用kernel32！CreateFileW()（或者kernel32！CreateFileA()）来独占打开当前进程的文件。如果调用失败，我们可以认为当前进程是在有调试器的情况下运行的。
C/C++ 代码：

1. bool Check()
   
2. {
   
3.     CHAR szFileName[MAX_PATH];
   
4.     if (0 == GetModuleFileNameA(NULL, szFileName, sizeof(szFileName)))
   
5.         return false;
   
6.    
   
7.     return INVALID_HANDLE_VALUE == CreateFileA(szFileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0);
   
8. }

复制代码

3. CloseHandle()
如果一个进程在调试器下运行，并且一个无效的句柄被传递给ntdll!NtClose()或kernel32!CloseHandle()函数，那么将引发EXCEPTION_INVALID_HANDLE（0xC0000008）异常。这个异常可以被一个异常处理程序缓存起来。如果控制被传递给异常处理程序，表明有一个调试器存在。
C/C++ 代码：

1. bool Check()
   
2. {
   
3.     __try
   
4.     {
   
5.         CloseHandle((HANDLE)0xDEADBEEF);
   
6.         return false;
   
7.     }
   
8.     __except (EXCEPTION_INVALID_HANDLE == GetExceptionCode()
   
9.                 ? EXCEPTION_EXECUTE_HANDLER
   
10.                 : EXCEPTION_CONTINUE_SEARCH)
    
11.     {
    
12.         return true;
    
13.     }
    
14. }

复制代码

4. LoadLibrary()
当使用kernel32!LoadLibraryW()(或kernel32!LoadLibraryA())函数将一个文件加载到进程内存时，LOAD_DLL_DEBUG_EVENT事件发生。被加载文件的句柄将被保存在LOAD_DLL_DEBUG_INFO结构中。因此，调试器可以从这个文件中读取调试信息。如果这个句柄没有被调试器关闭，这个文件就不会被打开独占访问。有些调试器会忘记关闭这个句柄。

为了检查调试器的存在，我们可以用kernel32!LoadLibraryA()加载任何文件，并尝试用kernel32!CreateFileA()独家打开它。如果kernel32!CreateFileA()调用失败，说明调试器是存在的。
C/C++ 代码：

1. bool Check()
   
2. {
   
3.     CHAR szBuffer[] = { "C:\\Windows\\System32\\calc.exe" };
   
4.     LoadLibraryA(szBuffer);
   
5.     return INVALID_HANDLE_VALUE == CreateFileA(szBuffer, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
   
6. }

复制代码

5. NtQueryObject()
当一个调试会话开始时，一个叫做 “debug object”的内核对象被创建，并有一个句柄与之关联。使用ntdll!NtQueryObject()函数，可以查询现有对象的列表，并检查与任何存在的调试对象相关的句柄数量。

然而这个技术不能确定当前进程是否正在被调试。它只能显示自系统启动以来，调试器是否在系统上运行。
C/C++ 代码：

1. typedef struct _OBJECT_TYPE_INFORMATION
   
2. {
   
3.     UNICODE_STRING TypeName;
   
4.     ULONG TotalNumberOfHandles;
   
5.     ULONG TotalNumberOfObjects;
   
6. } OBJECT_TYPE_INFORMATION, *POBJECT_TYPE_INFORMATION;
   
7. 
   
8. typedef struct _OBJECT_ALL_INFORMATION
   
9. {
   
10.     ULONG NumberOfObjects;
    
11.     OBJECT_TYPE_INFORMATION ObjectTypeInformation[1];
    
12. } OBJECT_ALL_INFORMATION, *POBJECT_ALL_INFORMATION;
    
13. 
    
14. typedef NTSTATUS (WINAPI *TNtQueryObject)(
    
15.     HANDLE                   Handle,
    
16.     OBJECT_INFORMATION_CLASS ObjectInformationClass,
    
17.     PVOID                    ObjectInformation,
    
18.     ULONG                    ObjectInformationLength,
    
19.     PULONG                   ReturnLength
    
20. );
    
21. 
    
22. enum { ObjectAllTypesInformation = 3 };
    
23. 
    
24. #define STATUS_INFO_LENGTH_MISMATCH 0xC0000004
    
25. 
    
26. bool Check()
    
27. {
    
28.     bool bDebugged = false;
    
29.     NTSTATUS status;
    
30.     LPVOID pMem = nullptr;
    
31.     ULONG dwMemSize;
    
32.     POBJECT_ALL_INFORMATION pObjectAllInfo;
    
33.     PBYTE pObjInfoLocation;
    
34.     HMODULE hNtdll;
    
35.     TNtQueryObject pfnNtQueryObject;
    
36.    
    
37.     hNtdll = LoadLibraryA("ntdll.dll");
    
38.     if (!hNtdll)
    
39.         return false;
    
40.         
    
41.     pfnNtQueryObject = (TNtQueryObject)GetProcAddress(hNtdll, "NtQueryObject");
    
42.     if (!pfnNtQueryObject)
    
43.         return false;
    
44. 
    
45.     status = pfnNtQueryObject(
    
46.         NULL,
    
47.         (OBJECT_INFORMATION_CLASS)ObjectAllTypesInformation,
    
48.         &dwMemSize, sizeof(dwMemSize), &dwMemSize);
    
49.     if (STATUS_INFO_LENGTH_MISMATCH != status)
    
50.         goto NtQueryObject_Cleanup;
    
51. 
    
52.     pMem = VirtualAlloc(NULL, dwMemSize, MEM_COMMIT, PAGE_READWRITE);
    
53.     if (!pMem)
    
54.         goto NtQueryObject_Cleanup;
    
55. 
    
56.     status = pfnNtQueryObject(
    
57.         (HANDLE)-1,
    
58.         (OBJECT_INFORMATION_CLASS)ObjectAllTypesInformation,
    
59.         pMem, dwMemSize, &dwMemSize);
    
60.     if (!SUCCEEDED(status))
    
61.         goto NtQueryObject_Cleanup;
    
62. 
    
63.     pObjectAllInfo = (POBJECT_ALL_INFORMATION)pMem;
    
64.     pObjInfoLocation = (PBYTE)pObjectAllInfo->ObjectTypeInformation;
    
65.     for(UINT i = 0; i < pObjectAllInfo->NumberOfObjects; i++)
    
66.     {
    
67. 
    
68.         POBJECT_TYPE_INFORMATION pObjectTypeInfo =
    
69.             (POBJECT_TYPE_INFORMATION)pObjInfoLocation;
    
70. 
    
71.         if (wcscmp(L"DebugObject", pObjectTypeInfo->TypeName.Buffer) == 0)
    
72.         {
    
73.             if (pObjectTypeInfo->TotalNumberOfObjects > 0)
    
74.                 bDebugged = true;
    
75.             break;
    
76.         }
    
77. 
    
78.         // Get the address of the current entries
    
79.         // string so we can find the end
    
80.         pObjInfoLocation = (PBYTE)pObjectTypeInfo->TypeName.Buffer;
    
81. 
    
82.         // Add the size
    
83.         pObjInfoLocation += pObjectTypeInfo->TypeName.Length;
    
84. 
    
85.         // Skip the trailing null and alignment bytes
    
86.         ULONG tmp = ((ULONG)pObjInfoLocation) & -4;
    
87. 
    
88.         // Not pretty but it works
    
89.         pObjInfoLocation = ((PBYTE)tmp) + sizeof(DWORD);
    
90.     }
    
91. 
    
92. NtQueryObject_Cleanup:
    
93.     if (pMem)
    
94.         VirtualFree(pMem, 0, MEM_RELEASE);
    
95. 
    
96.     return bDebugged;
    
97. }

复制代码

反制措施
反制这些检查的最简单的方法是只需手动跟踪程序直到检查，然后跳过它（例如用NOP补丁或改变指令指针或在检查后改变零标志寄存器）。

如果你写一个反调试方案，你需要拦截列出的函数，在分析其输入后改变返回值：

• ntdll！OpenProcess：如果第三个参数是csrss.exe的句柄，则返回NULL。
• ntdll!NtClose：你可以使用ntdll!NtQueryObject()检查是否可以检索到关于输入句柄的任何信息，如果句柄无效，则不显示异常。
• ntdll!NtQueryObject: 如果ObjectAllTypesInformation类被查询，从结果中过滤调试对象。
  

以下技术应该在没有拦截的情况下处理：

• ntdll!NtCreateFile: 太通用了，无法反制。然而，如果你为一个特定的调试器写一个插件，你可以确保被调试文件的句柄被关闭。
• kernel32！LoadLibraryW/A：没有反制措施。
  

H.U.C清风

谢谢分享，已回复。