[翻译]反调试：进程内存

梦幻的彼岸

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


目录

• 进程内存
• 1.断点
• 1.1.软件断点(INT3)
• 1.2.反步过
• 1.2.1.直接修改内存
• 1.2.2. ReadFile()
• 1.2.3. WriteProcessMemory()
• 1.2.4. Toolhelp32ReadProcessMemory()
• 1.3.内存断点
• 1.4.硬件断点
• 2.其他内存检查
• 2.1.NtQueryVirtualMemory()
• 2.2.检测一个函数补丁
• 2.3.  ntdll!DbgBreakPoint()补丁
• 2.4.  ntdll!DbgUiRemoteBreakin()补丁
• 2.5执行代码校验和
• 反制措施
  

进程内存
进程可以检查自己的内存，以检测调试器的存在或干扰调试器。

本节包括进程内存和检查线程上下文、搜索断点以及作为反附加方法的函数修补。

1.断点
我们总是可以检查进程内存并在代码中搜索软件断点，或者检查CPU的调试寄存器以确定是否设置了硬件断点。

1.1.软件断点(INT3)
其思想是将某些函数的机器码识别为0xCC字节，代表INT 3汇编指令。

这种方法会产生许多误报情况，因此应谨慎使用。
C/C++ 代码：

1. bool CheckForSpecificByte(BYTE cByte, PVOID pMemory, SIZE_T nMemorySize = 0)
   
2. {
   
3.     PBYTE pBytes = (PBYTE)pMemory;
   
4.     for (SIZE_T i = 0; ; i++)
   
5.     {
   
6.         // Break on RET (0xC3) if we don't know the function's size
   
7.         if (((nMemorySize > 0) && (i >= nMemorySize)) ||
   
8.             ((nMemorySize == 0) && (pBytes[i] == 0xC3)))
   
9.             break;
   
10. 
    
11.         if (pBytes[i] == cByte)
    
12.             return true;
    
13.     }
    
14.     return false;
    
15. }
    
16. 
    
17. bool IsDebugged()
    
18. {
    
19.     PVOID functionsToCheck[] = {
    
20.         &Function1,
    
21.         &Function2,
    
22.         &Function3,
    
23.     };
    
24.     for (auto funcAddr : functionsToCheck)
    
25.     {
    
26.         if (CheckForSpecificByte(0xCC, funcAddr))
    
27.             return true;
    
28.     }
    
29.     return false;
    
30. }

复制代码

1.2.反步过
调试器允许你步过函数调用。在这种情况下，调试器隐含地在调用后的指令（即被调用函数的返回地址）上设置一个软件断点。

为了检测是否有跨函数的企图，我们可以检查返回地址的第一个字节的内存。如果软件断点（0xCC）位于返回地址处，我们可以用一些其他指令（如NOP）来修补它。这很可能会破坏代码并使进程崩溃。另一方面，我们可以用一些有意义的代码代替NOP来修补返回地址，改变程序的控制流程。


1.2.1.直接修改内存
可以从函数内部检查调用该函数后是否有软件断点。我们可以在返回地址读取一个字节，如果该字节等于0xCC (INT 3)，它可以被0x90 (NOP)重写。这个过程可能会崩溃，因为我们在返回地址破坏了指令。但是，如果知道函数调用之后是哪条指令，可以用这条指令的第一个字节重写断点。
C/C++ 代码：

1. #include <intrin.h>
   
2. #pragma intrinsic(_ReturnAddress)
   
3. 
   
4. void foo()
   
5. {
   
6.     // ...
   
7.    
   
8.     PVOID pRetAddress = _ReturnAddress();
   
9.     if (*(PBYTE)pRetAddress == 0xCC) // int 3
   
10.     {
    
11.         DWORD dwOldProtect;
    
12.         if (VirtualProtect(pRetAddress, 1, PAGE_EXECUTE_READWRITE, &dwOldProtect))
    
13.         {
    
14.             *(PBYTE)pRetAddress = 0x90; // nop
    
15.             VirtualProtect(pRetAddress, 1, dwOldProtect, &dwOldProtect);
    
16.         }
    
17.     }
    
18.    
    
19.     // ...
    
20. }

复制代码

1.2.2. ReadFile()
该方法使用kernel32!ReadFile()函数来修补返回地址的代码。

其思路是读取当前进程的可执行文件，并将返回地址作为输出缓冲区传递给kernel32!ReadFile()。返回地址的字节将被打上'M'字符（PE图像的第一个字节），进程可能会崩溃。
C/C++ 代码：

1. #include <intrin.h>
   
2. #pragma intrinsic(_ReturnAddress)
   
3. 
   
4. void foo()
   
5. {
   
6.     // ...
   
7.    
   
8.     PVOID pRetAddress = _ReturnAddress();
   
9.     if (*(PBYTE)pRetAddress == 0xCC) // int 3
   
10.     {
    
11.         DWORD dwOldProtect, dwRead;
    
12.         CHAR szFilePath[MAX_PATH];
    
13.         HANDLE hFile;
    
14. 
    
15.         if (VirtualProtect(pRetAddress, 1, PAGE_EXECUTE_READWRITE, &dwOldProtect))
    
16.         {
    
17.             if (GetModuleFileNameA(NULL, szFilePath, MAX_PATH))
    
18.             {
    
19.                 hFile = CreateFileA(szFilePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
    
20.                 if (INVALID_HANDLE_VALUE != hFile)
    
21.                     ReadFile(hFile, pRetAddress, 1, &dwRead, NULL);
    
22.             }
    
23.             VirtualProtect(pRetAddress, 1, dwOldProtect, &dwOldProtect);
    
24.         }
    
25.     }
    
26.    
    
27.     // ...
    
28. }

复制代码

1.2.3. WriteProcessMemory()
这个方法使用kernel32!WriteProcessMemory()函数来修补返回地址的代码。
C/C++ 代码：

1. #include <intrin.h>
   
2. #pragma intrinsic(_ReturnAddress)
   
3. 
   
4. void foo()
   
5. {
   
6.     // ...
   
7.    
   
8.     BYTE Patch = 0x90;
   
9.     PVOID pRetAddress = _ReturnAddress();
   
10.     if (*(PBYTE)pRetAddress == 0xCC)
    
11.     {
    
12.         DWORD dwOldProtect;
    
13.         if (VirtualProtect(pRetAddress, 1, PAGE_EXECUTE_READWRITE, &dwOldProtect))
    
14.         {
    
15.             WriteProcessMemory(GetCurrentProcess(), pRetAddress, &Patch, 1, NULL);
    
16.             VirtualProtect(pRetAddress, 1, dwOldProtect, &dwOldProtect);
    
17.         }
    
18.     }
    
19.    
    
20.     // ...
    
21. }

复制代码

1.2.4. Toolhelp32ReadProcessMemory()
函数kernel32！Toolhelp32ReadProcessMemory()允许你读取其他进程的内存。但是，它可以用于检查反步过情况。
C/C++ 代码：

1. #include <TlHelp32.h>
   
2. 
   
3. bool foo()
   
4. {
   
5.     // ..
   
6.    
   
7.     PVOID pRetAddress = _ReturnAddress();
   
8.     BYTE uByte;
   
9.     if (FALSE != Toolhelp32ReadProcessMemory(GetCurrentProcessId(), _ReturnAddress(), &uByte, sizeof(BYTE), NULL))
   
10.     {
    
11.         if (uByte == 0xCC)
    
12.             ExitProcess(0);
    
13.     }
    
14.    
    
15.     // ..
    
16. }

复制代码

1.3.内存断点
内存断点是通过使用保护页实现的(至少在OllyDbg和ImmunityDebugger中是这样)。保护页为内存页访问提供一次性警报。当一个保护页被执行时，异常STATUS_GUARD_PAGE_VIOLATION 被引发。
通过在kernel32！VirtualAlloc()、kernel32！VirtualAllocEx()、kernel32!VirtualProtect()和kernel32!VirtualProtect()函数中设置PAGE_GUARD页面保护修改器，可以创建一个保护页面。
但是，我们可以滥用调试器实现内存断点的方式来检查程序是否在调试器下执行。我们可以分配一个只包含一个字节0xC3（表示RET指令）的可执行缓冲区。然后，我们将这个缓冲区标记为保护页，将处理存在调试器的情况的地址推送到堆栈中，然后跳转到分配的缓冲区。指令RET将被执行，如果调试器（OllyDbg或ImmunityDebugger）存在，我们将获得推送到堆栈的地址。如果程序在没有调试器的情况下执行，我们将得到一个异常处理程序。
C/C++ 代码：

1. bool IsDebugged()
   
2. {
   
3.     DWORD dwOldProtect = 0;
   
4.     SYSTEM_INFO SysInfo = { 0 };
   
5. 
   
6.     GetSystemInfo(&SysInfo);
   
7.     PVOID pPage = VirtualAlloc(NULL, SysInfo.dwPageSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
   
8.     if (NULL == pPage)
   
9.         return false;
   
10. 
    
11.     PBYTE pMem = (PBYTE)pPage;
    
12.     *pMem = 0xC3;
    
13. 
    
14.     // Make the page a guard page         
    
15.     if (!VirtualProtect(pPage, SysInfo.dwPageSize, PAGE_EXECUTE_READWRITE | PAGE_GUARD, &dwOldProtect))
    
16.         return false;
    
17. 
    
18.     __try
    
19.     {
    
20.         __asm
    
21.         {
    
22.             mov eax, pPage
    
23.             push mem_bp_being_debugged
    
24.             jmp eax
    
25.         }
    
26.     }
    
27.     __except(EXCEPTION_EXECUTE_HANDLER)
    
28.     {
    
29.         VirtualFree(pPage, NULL, MEM_RELEASE);
    
30.         return false;
    
31.     }
    
32. 
    
33. mem_bp_being_debugged:
    
34.     VirtualFree(pPage, NULL, MEM_RELEASE);
    
35.     return true;
    
36. }

复制代码

1.4.硬件断点
调试寄存器DR0、DR1、DR2和DR3可以从线程上下文中检索到。如果它们包含非零值，可能意味着该进程是在调试器下执行的，并且设置了一个硬件断点。
C/C++ 代码：

1. bool IsDebugged()
   
2. {
   
3.     CONTEXT ctx;
   
4.     ZeroMemory(&ctx, sizeof(CONTEXT));
   
5.     ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;
   
6. 
   
7.     if(!GetThreadContext(GetCurrentThread(), &ctx))
   
8.         return false;
   
9. 
   
10.     return ctx.Dr0 || ctx.Dr1 || ctx.Dr2 || ctx.Dr3;
    
11. }

复制代码

2.其他内存检查
本节包含直接检查或控制正在运行的进程的虚拟内存以检测或阻止调试的技术。


2.1.NtQueryVirtualMemory()
代码所在进程的内存页在所有进程之间共享，直到写入一个页面。之后，操作系统会对这个页面进行复制，并将其映射到进程的虚拟内存中，所以这个页面不再是 "共享 "的。

因此，我们可以查询当前进程的工作集，用代码检查工作集块中的共享和ShareCount字段的页面。如果代码中存在软件断点，这些字段一定不会被设置。
NTDLL declarations：

1. namespace ntdll
   
2. {
   
3. //...
   
4. 
   
5. #define STATUS_INFO_LENGTH_MISMATCH 0xC0000004
   
6. 
   
7. // ...
   
8. 
   
9. typedef enum _MEMORY_INFORMATION_CLASS {
   
10.     MemoryBasicInformation,
    
11.     MemoryWorkingSetList,
    
12. } MEMORY_INFORMATION_CLASS;
    
13. 
    
14. // ...
    
15. 
    
16. typedef union _PSAPI_WORKING_SET_BLOCK {
    
17.     ULONG Flags;
    
18.     struct {
    
19.         ULONG Protection :5;
    
20.         ULONG ShareCount :3;
    
21.         ULONG Shared     :1;
    
22.         ULONG Reserved   :3;
    
23.         ULONG VirtualPage:20;
    
24.     };
    
25. } PSAPI_WORKING_SET_BLOCK, *PPSAPI_WORKING_SET_BLOCK;
    
26. 
    
27. typedef struct _MEMORY_WORKING_SET_LIST
    
28. {
    
29.     ULONG NumberOfPages;
    
30.     PSAPI_WORKING_SET_BLOCK WorkingSetList[1];
    
31. } MEMORY_WORKING_SET_LIST, *PMEMORY_WORKING_SET_LIST;
    
32. 
    
33. // ...
    
34. }

复制代码

C/C++ 代码：

1. bool IsDebugged()
   
2. {
   
3. #ifndef _WIN64
   
4.     NTSTATUS status;
   
5.     PBYTE pMem = nullptr;
   
6.     DWORD dwMemSize = 0;
   
7. 
   
8.     do
   
9.     {
   
10.         dwMemSize += 0x1000;
    
11.         pMem = (PBYTE)_malloca(dwMemSize);
    
12.         if (!pMem)
    
13.             return false;
    
14. 
    
15.         memset(pMem, 0, dwMemSize);
    
16.         status = ntdll::NtQueryVirtualMemory(
    
17.             GetCurrentProcess(),
    
18.             NULL,
    
19.             ntdll::MemoryWorkingSetList,
    
20.             pMem,
    
21.             dwMemSize,
    
22.             NULL);
    
23.     } while (status == STATUS_INFO_LENGTH_MISMATCH);
    
24. 
    
25.     ntdll::PMEMORY_WORKING_SET_LIST pWorkingSet = (ntdll::PMEMORY_WORKING_SET_LIST)pMem;
    
26.     for (ULONG i = 0; i < pWorkingSet->NumberOfPages; i++)
    
27.     {
    
28.         DWORD dwAddr = pWorkingSet->WorkingSetList[i].VirtualPage << 0x0C;
    
29.         DWORD dwEIP = 0;
    
30.         __asm
    
31.         {
    
32.             push eax
    
33.             call $+5
    
34.             pop eax
    
35.             mov dwEIP, eax
    
36.             pop eax
    
37.         }
    
38. 
    
39.         if (dwAddr == (dwEIP & 0xFFFFF000))
    
40.             return (pWorkingSet->WorkingSetList[i].Shared == 0) || (pWorkingSet->WorkingSetList[i].ShareCount == 0);
    
41.     }
    
42. #endif // _WIN64
    
43.     return false;
    
44. }

复制代码

这项技术归功于：Virus Bulletin

2.2.检测一个函数补丁
检测调试器的一个常用方法是调用kernel32!IsDebuggerPresent()。缓解这种检查很简单，例如，改变EAX寄存器中的结果或修补kernel32!IsDebuggerPresent()函数的代码。

因此，我们可以不检查进程内存的断点，而是验证kernel32!IsDebuggerPresent()是否被修改。我们可以读取这个函数的第一个字节，并与其他进程中相同函数的这些字节进行比较。即使启用了ASLR，Windows库在所有进程中都被加载到相同的基础地址。基准地址只有在重启后才会改变，但对所有进程来说，它们在会话期间会保持不变。
C/C++ 代码：

1. bool IsDebuggerPresent()
   
2. {
   
3.     HMODULE hKernel32 = GetModuleHandleA("kernel32.dll");
   
4.     if (!hKernel32)
   
5.         return false;
   
6. 
   
7.     FARPROC pIsDebuggerPresent = GetProcAddress(hKernel32, "IsDebuggerPresent");
   
8.     if (!pIsDebuggerPresent)
   
9.         return false;
   
10. 
    
11.     HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    
12.     if (INVALID_HANDLE_VALUE == hSnapshot)
    
13.         return false;
    
14. 
    
15.     PROCESSENTRY32W ProcessEntry;
    
16.     ProcessEntry.dwSize = sizeof(PROCESSENTRY32W);
    
17. 
    
18.     if (!Process32FirstW(hSnapshot, &ProcessEntry))
    
19.         return false;
    
20. 
    
21.     bool bDebuggerPresent = false;
    
22.     HANDLE hProcess = NULL;
    
23.     DWORD dwFuncBytes = 0;
    
24.     const DWORD dwCurrentPID = GetCurrentProcessId();
    
25.     do
    
26.     {
    
27.         __try
    
28.         {
    
29.             if (dwCurrentPID == ProcessEntry.th32ProcessID)
    
30.                 continue;
    
31. 
    
32.             hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcessEntry.th32ProcessID);
    
33.             if (NULL == hProcess)
    
34.                 continue;
    
35. 
    
36.             if (!ReadProcessMemory(hProcess, pIsDebuggerPresent, &dwFuncBytes, sizeof(DWORD), NULL))
    
37.                 continue;
    
38. 
    
39.             if (dwFuncBytes != *(PDWORD)pIsDebuggerPresent)
    
40.             {
    
41.                 bDebuggerPresent = true;
    
42.                 break;
    
43.             }
    
44.         }
    
45.         __finally
    
46.         {
    
47.             if (hProcess)
    
48.                 CloseHandle(hProcess);
    
49.         }
    
50.     } while (Process32NextW(hSnapshot, &ProcessEntry));
    
51. 
    
52.     if (hSnapshot)
    
53.         CloseHandle(hSnapshot);
    
54.     return bDebuggerPresent;
    
55. }

复制代码

这项技术归功于：Rouse_

2.3.  ntdll!DbgBreakPoint()补丁
函数ntdll!DbgBreakPrint()有以下执行情况:

当调试器附加在一个正在运行的进程上时，它被调用。它允许调试器获得控制权，因为一个异常被引发，它可以拦截。如果我们擦除ntdll!DbgBreakPrint()里面的断点，调试器就不会闯入，线程就会退出。
C/C++ 代码：

1. void Patch_DbgBreakPoint()
   
2. {
   
3.     HMODULE hNtdll = GetModuleHandleA("ntdll.dll");
   
4.     if (!hNtdll)
   
5.         return;
   
6. 
   
7.     FARPROC pDbgBreakPoint = GetProcAddress(hNtdll, "DbgBreakPoint");
   
8.     if (!pDbgBreakPoint)
   
9.         return;
   
10. 
    
11.     DWORD dwOldProtect;
    
12.     if (!VirtualProtect(pDbgBreakPoint, 1, PAGE_EXECUTE_READWRITE, &dwOldProtect))
    
13.         return;
    
14. 
    
15.     *(PBYTE)pDbgBreakPoint = (BYTE)0xC3; // ret
    
16. }

复制代码

2.4.  ntdll!DbgUiRemoteBreakin()补丁
当调试器调用kernel32!DebugActiveProcess()时，调试器会相应地调用ntdll!DbgUiRemoteBreakin()。为了防止调试器附着在进程上，我们可以修补ntdll!DbgUiRemoteBreakin()代码，以调用kernel32!TerminateProcess()。
在下面的例子中，我们用以下代码修补了ntdll!DbgUiRemoteBreakin()：

1. 6A 00             push 0
   
2. 68 FF FF FF FF    push -1 ; GetCurrentProcess() result
   
3. B8 XX XX XX XX    mov  eax, kernel32!TreminateProcess
   
4. FF D0             call eax

复制代码

结果是，一旦我们试图将调试器连接到该程序，该程序将自行终止。
C/C++ 代码：

1. #pragma pack(push, 1)
   
2.     struct DbgUiRemoteBreakinPatch
   
3.     {
   
4.         WORD  push_0;
   
5.         BYTE  push;
   
6.         DWORD CurrentPorcessHandle;
   
7.         BYTE  mov_eax;
   
8.         DWORD TerminateProcess;
   
9.         WORD  call_eax;
   
10.     };
    
11. #pragma pack(pop)
    
12. 
    
13. void Patch_DbgUiRemoteBreakin()
    
14. {
    
15.     HMODULE hNtdll = GetModuleHandleA("ntdll.dll");
    
16.     if (!hNtdll)
    
17.         return;
    
18. 
    
19.     FARPROC pDbgUiRemoteBreakin = GetProcAddress(hNtdll, "DbgUiRemoteBreakin");
    
20.     if (!pDbgUiRemoteBreakin)
    
21.         return;
    
22. 
    
23.     HMODULE hKernel32 = GetModuleHandleA("kernel32.dll");
    
24.     if (!hKernel32)
    
25.         return;
    
26. 
    
27.     FARPROC pTerminateProcess = GetProcAddress(hKernel32, "TerminateProcess");
    
28.     if (!pTerminateProcess)
    
29.         return;
    
30. 
    
31.     DbgUiRemoteBreakinPatch patch = { 0 };
    
32.     patch.push_0 = '\x6A\x00';
    
33.     patch.push = '\x68';
    
34.     patch.CurrentPorcessHandle = 0xFFFFFFFF;
    
35.     patch.mov_eax = '\xB8';
    
36.     patch.TerminateProcess = (DWORD)pTerminateProcess;
    
37.     patch.call_eax = '\xFF\xD0';
    
38. 
    
39.     DWORD dwOldProtect;
    
40.     if (!VirtualProtect(pDbgUiRemoteBreakin, sizeof(DbgUiRemoteBreakinPatch), PAGE_READWRITE, &dwOldProtect))
    
41.         return;
    
42. 
    
43.     ::memcpy_s(pDbgUiRemoteBreakin, sizeof(DbgUiRemoteBreakinPatch),
    
44.         &patch, sizeof(DbgUiRemoteBreakinPatch));
    
45.     VirtualProtect(pDbgUiRemoteBreakin, sizeof(DbgUiRemoteBreakinPatch), dwOldProtect, &dwOldProtect);
    
46. }

复制代码

该项技术归公于：Rouse_

2.5执行代码校验和
验证代码校验和是检测软件断点、调试器的跨步、函数的内联拦截或数据修改的可靠方法。

下面的例子显示了如何验证一个函数的校验和。
C/C++ 代码：

1. PVOID g_pFuncAddr;
   
2. DWORD g_dwFuncSize;
   
3. DWORD g_dwOriginalChecksum;
   
4. 
   
5. static void VeryImportantFunction()
   
6. {
   
7.     // ...
   
8. }
   
9. 
   
10. static DWORD WINAPI ThreadFuncCRC32(LPVOID lpThreadParameter)
    
11. {
    
12.     while (true)
    
13.     {
    
14.         if (CRC32((PBYTE)g_pFuncAddr, g_dwFuncSize) != g_dwOriginalChecksum)
    
15.             ExitProcess(0);
    
16.         Sleep(10000);
    
17.     }
    
18.     return 0;
    
19. }
    
20. 
    
21. size_t DetectFunctionSize(PVOID pFunc)
    
22. {
    
23.     PBYTE pMem = (PBYTE)pFunc;
    
24.     size_t nFuncSize = 0;
    
25.     do
    
26.     {
    
27.         ++nFuncSize;
    
28.     } while (*(pMem++) != 0xC3);
    
29.     return nFuncSize;
    
30. }
    
31. 
    
32. int main()
    
33. {
    
34.     g_pFuncAddr = (PVOID)&VeryImportantFunction;
    
35.     g_dwFuncSize = DetectFunctionSize(g_pFuncAddr);
    
36.     g_dwOriginalChecksum = CRC32((PBYTE)g_pFuncAddr, g_dwFuncSize);
    
37.    
    
38.     HANDLE hChecksumThread = CreateThread(NULL, NULL, ThreadFuncCRC32, NULL, NULL, NULL);
    
39.    
    
40.     // ...
    
41.    
    
42.     return 0;
    
43. }

复制代码

反制措施
调试期间：

• 对于反步过的技巧：进入执行步过检查的函数，并一直执行到结束(OllyDbg/x32/x64dbg中的Ctrl+F9)。
• 反制所有 "内存 "技巧（包括反步过）的最好方法是找到确切的检查，并用NOP来修补它，或者设置允许应用程序进一步执行的返回值。
  

对于反调试绕过工具的开发：
1.断点扫描：

• 软件断点与反反调试：没有干扰这些检查的可能性，因为它们不需要使用API，直接访问内存。
• 内存断点：一般来说，有可能跟踪被调用的函数序列来应用这种检查。
• 硬件断点：钩住kernel32！GetThreadContext()并修改调试寄存器。
  

2.其他检查：没有反制措施。