APIHOOK之在NT系列操作系统里让自己“消失”中2

最新推荐文章于 2024-01-01 17:06:58 发布

转载最新推荐文章于 2024-01-01 17:06:58 发布 · 1.2k 阅读

文章标签：

#basic #attributes #struct #integer #thread #access

本文详细介绍如何在NT系列操作系统中实现进程隐身，包括通过全局挂钩、感染新进程、挂钩DLL及修改内存读取等功能，确保进程不被发现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在NT系列操作系统里让自己“消失”中

2007-03-31 09:04

=====[ 7.2 全局挂钩 ]=======================================

     枚举进程通过前面提到的API函数NtQuerySystemInformation来完成。因为系统中还有一些内部native进程，所以使用重写函数第一个指令的方法来挂钩。对每个正在运行的进程我们需要做的都一样。首先在目标进程里分配一部分内存用来写入我们用来挂钩函数的新代码，然后把每个函数开始的5个字节改为跳转指令(jmp)，这个跳转会转为执行我们的代码。所以当被挂钩的函数被调用时跳转指令能立刻被执行。我们需要保存每个函数开始被改写的指令，需要它们来调用被挂钩函数的原始代码。保存指令的过程在"挂钩Windows API"的3.2.3节有描述。
     首先通过NtOpenProcess打开目标进程并获取句柄。如果我们没有足够权限的话就会失败。

     NTSTATUS NtOpenProcess(
         OUT PHANDLE ProcessHandle,
         IN ACCESS_MASK DesiredAccess,
         IN POBJECT_ATTRIBUTES ObjectAttributes,
         IN PCLIENT_ID ClientId OPTIONAL
     );

     ProcessHandle是指向保存进程对象句柄的指针。DesiredAccess应该被设置为PROCESS_ALL_ACCESS。我们要在ClientId结构里设置UniqueProcess为目标进程的PID，UniqueThread应该为0。被打开的句柄可以通过NtClose关闭。

     #define PROCESS_ALL_ACCESS 0x001F0FFF

     现在我们为我们的代码分配部分内存。这通过NtAllocateVirtualMemory来完成。

     NTSTATUS NtAllocateVirtualMemory(
         IN HANDLE ProcessHandle,
         IN OUT PVOID BaseAddress,
         IN ULONG ZeroBits,
         IN OUT PULONG AllocationSize,
         IN ULONG AllocationType,
         IN ULONG Protect
     );

     ProcessHandle是来自NtOpenProcess相同参数。BaseAddress是一个指针，指向被分配虚拟内存基地址的开始处，它的输入参数应该为NULL。AllocationSize指向我们要分配的字节数的变量，同样它也用来接受实际分配的字节数大小。最好把AllocationType在设置成MEM_COMMIT之外再加上MEM_TOP_DOWN因为内存要在接近DLL地址的尽可能高的地址分配。

     #define MEM_COMMIT     0x00001000
     #define MEM_TOP_DOWN     0x00100000

     然后我们就可以通过调用NtWriteVirtualMemory来写入我们的代码。

     NTSTATUS NtWriteVirtualMemory(
         IN HANDLE ProcessHandle,
         IN PVOID BaseAddress,
         IN PVOID Buffer,
         IN ULONG BufferLength,
         OUT PULONG ReturnLength OPTIONAL
     );

     BaseAddress是NtAllocateVirtualMemory返回的地址。Buffer指向我们要写入的字节，BufferLength是我们要写入的字节数。

     现在我们来挂钩单个进程。被加载入所有进程的动态链接库只有ntdll.dll。所以我们要检查被导入进程要挂钩的函数是否来自ntdll.dll。但是这些来自其它DLL的函数所在的内存可能已经被分配，这时重写它的代码会在目标进程里导致错误。这就是我们必须去检查我们要挂钩的函数来自的动态链接库是否被目标进程加载的原因。
     我们需要通过NtQueryInformationProcess获取目标进程的PEB(进程环境块)。

     NTSTATUS NtQueryInformationProcess(
         IN HANDLE ProcessHandle,
         IN PROCESSINFOCLASS ProcessInformationClass,
         OUT PVOID ProcessInformation,
         IN ULONG ProcessInformationLength,
         OUT PULONG ReturnLength OPTIONAL
     );

     我们把ProcessInformationClass设置为ProcessBasicInformation，然后PROCESS_BASIC_INFORMATION结构会返回到ProcessInformation缓冲区中，大小为给定的ProcessInformationLength。

     #define ProcessBasicInformation 0

     typedef struct _PROCESS_BASIC_INFORMATION {
         NTSTATUS ExitStatus;
         PPEB PebBaseAddress;
         KAFFINITY AffinityMask;
         KPRIORITY BasePriority;
         ULONG UniqueProcessId;
         ULONG InheritedFromUniqueProcessId;
     } PROCESS_BASIC_INFORMATION, *PPROCESS_BASIC_INFORMATION;

     PebBaseAddress就是我们要寻找的东西。在PebBaseAddress+0C处是PPEB_LDR_DATA的地址。这些通过调用NtReadVirtualMemory来获得。

     NTSTATUS NtReadVirtualMemory(
         IN HANDLE ProcessHandle,
         IN PVOID BaseAddress,
         OUT PVOID Buffer,
         IN ULONG BufferLength,
         OUT PULONG ReturnLength OPTIONAL
     );

     变量和NtWriteVirtualMemory的很相似。
     在PPEB_LDR_DATA+01C处是InInitializationOrderModuleList的地址。它是被加载进进程的动态链接库的列表。我们只对这个结构中的一些部分感兴趣。

     typedef struct _IN_INITIALIZATION_ORDER_MODULE_LIST {
         PVOID Next,
         PVOID Prev,
         DWORD ImageBase,
         DWORD ImageEntry,
         DWORD ImageSize,
         ...
     );

     Next是指向下一个记录的指针，Prev指向前一个，最后一个记录的会指向第一个。ImageBase是内存中模块的地址，ImageEntry是模快的入口点，ImageSize是它的大小。

     对所有我们想要挂钩的库我们需要获得它们的ImageBase(比方调用GetModuleHandle或者LoadLibrary)。然后把这个ImageBase和InInitializationOrderModuleList的ImageBase比较。
     现在我们已经为挂钩准备就绪。因为我们是挂钩正在运行的进程，所以可能我们正在改写代码的同时代码被执行，这时就会导致错误。所以首先我们就得停止目标进程里的所有线程。它的所有线程列表可以通过设置了SystemProcessAndThreadInformation的NtQuerySystemInformation来获得。有关这个函数的描述参考第4节。但是还得加入SYSTEM_THREADS结构的描述，用来保存线程的信息。

     typedef struct _SYSTEM_THREADS {
         LARGE_INTEGER KernelTime;
         LARGE_INTEGER UserTime;
         LARGE_INTEGER CreateTime;
         ULONG WaitTime;
         PVOID StartAddress;
         CLIENT_ID ClientId;
         KPRIORITY Priority;
         KPRIORITY BasePriority;
         ULONG ContextSwitchCount;
         THREAD_STATE State;
         KWAIT_REASON WaitReason;
     } SYSTEM_THREADS, *PSYSTEM_THREADS;

     对每个线程调用NtOpenThread获取它们的句柄，通过使用ClientId。

     NTSTATUS NtOpenThread(
         OUT PHANDLE ThreadHandle,
         IN ACCESS_MASK DesiredAccess,
         IN POBJECT_ATTRIBUTES ObjectAttributes,
         IN PCLIENT_ID ClientId
     );

     我们需要的句柄被保存在ThreadHandle。我们需要把DesiredAccess设置为THREAD_SUSPEND_RESUME。

     #define THREAD_SUSPEND_RESUME 2

     ThreadHandle用来调用NtSuspendThread。

     NTSTATUS NtSuspendThread(
         IN HANDLE ThreadHandle,
         OUT PULONG PreviousSuspendCount OPTIONAL
     );

     被挂起的进程就可以被改写了。我们按照"挂钩Windows API"里3.2.2节里描述的方法处理。唯一的不同是使用其它进程的函数。

     挂钩完后我们就可以调用NtResumeThread恢复所有线程的运行。

     NTSTATUS NtResumeThread(
         IN HANDLE ThreadHandle,
         OUT PULONG PreviousSuspendCount OPTIONAL
     );

=====[ 7.3 新进程 ]================================================

     感染所有正在运行的进程并不能影响将要被运行的进程。我们可以每隔一定时间获取一次进程的列表，然后感染新的列表里的进程。但这种方法很不可靠。
     更好的方法是挂钩新进程开始时肯定会调用的函数。因为所有系统中正在运行的进程都已经被挂钩，所以这种方法不会漏掉任何新的进程。我们可以挂钩NtCreateThread，但这不是最简单的方法。我们可以挂钩NtResumeThread，因为它也是每当新进程创建时被调用，它在NtCreateThread之后被调用。
     唯一的问题在于，这个函数并不只在新进程被创建时调用。但我们能很容易解决这点。NtQueryInformationThread能给我们指定线程是属于哪个进程的信息。最后我们要做的就是检查进程是否已经被挂钩了。这通过读取我们要挂钩的函数的开始5个字节来完成。

     NTSTATUS NtQueryInformationThread(
         IN HANDLE ThreadHandle,
         IN THREADINFOCLASS ThreadInformationClass,
         OUT PVOID ThreadInformation,
         IN ULONG ThreadInformationLength,
         OUT PULONG ReturnLength OPTIONAL
     );

     ThreadInformationClass是信息分类，在这里它被设置为ThreadBasicInformation。ThreadInformation是保存结果的缓冲区，大小按字节计算为ThreadInformationLength。

     #define ThreadBasicInformation 0

     对ThreadBasicInformation返回这个结构:

     typedef struct _THREAD_BASIC_INFORMATION {
         NTSTATUS ExitStatus;
         PNT_TIB TebBaseAddress;
         CLIENT_ID ClientId;
         KAFFINITY AffinityMask;
         KPRIORITY Priority;
         KPRIORITY BasePriority;
     } THREAD_BASIC_INFORMATION, *PTHREAD_BASIC_INFORMATION;

     ClientId是线程所属进程的PID。

     现在我们来感染新进程。问题就是新进程的地址空间中只有ntdll.dll，其他的模块在调用NtResumeThread之后被加载。有几种方法可以解决这个问题，比方说我们可以挂钩一个名为LdrInitializeThunk的API函数，它在进程初始化时被调用。

     NTSTATUS LdrInitializeThunk(
         DWORD Unknown1,
         DWORD Unknown2,
         DWORD Unknown3
     );

     首先我们先运行原始的代码，然后挂钩新进程里所有要挂钩的函数。但最好对LdrInitializeThunk解除挂钩，因为这个函数在之后要被调用很多次，我们并不需要重新再挂钩所有的函数。这时在程序执行第一个指令前所有工作已经完成。这就是为什么在我们挂钩它之前它没有机会调用任何一个被挂钩过的函数的原因。
     对自己挂钩和动态挂钩正在运行的进程一样，只是这里我们不需要关心正在运行的线程。

=====[ 7.4 DLL ]================================================

     系统中每个进程都是一份ntdll.dll拷贝。这意味着我们可以在进程初始化阶段挂钩这个模块里的任意一个函数。但是来自其它模块比如kernel32.dll或advapi32.dll的函数该怎么办呢?还有一些进程只有ntdll.dll，其他模块都是在进程被挂钩之后在运行过程中才被动态加载的。这就是我们还得挂钩加载新模块的函数LdrLoadDll的原因。

     NTSTATUS LdrLoadDll(
         PWSTR szcwPath,
         PDWORD pdwLdrErr,
         PUNICODE_STRING pUniModuleName,
         PHINSTANCE pResultInstance
     );

     这里对我们来说最重要的是pUniModuleName，它保存模块名字。当调用成功后pResultInstance保存模块地址。
     我们首先调用原始的LdrLoadDll然后挂钩被加载模块里所有函数。

=====[ 8. 内存 ]===========================================

     当我们正在挂钩一个函数时我们会修改它开始的字节。通过调用NtReadVirtualMemory任何人都可以检测出函数被挂钩。所以我们还要挂钩NtReadVirtualMemory来防止检测。

     NTSTATUS NtReadVirtualMemory(
         IN HANDLE ProcessHandle,
         IN PVOID BaseAddress,
         OUT PVOID Buffer,
         IN ULONG BufferLength,
         OUT PULONG ReturnLength OPTIONAL
     );

     我们修改了我们挂钩的函数开始的字节并且为我们新的代码分配了内存。我们就需要检查时候有人读取了这些代码。如果我们的代码出现在BaseAddress到BaseAddress+BufferLength中我们就需要在缓冲区中改变它的一些字节。
     如果有人在我们分配的内存中查询字节我们就返回空的缓冲区和错误STATUS_PARTIAL_COPY。这个值用来表示被请求的字节并没有完全被拷贝到缓冲区中，它也同样被用在当请求了未分配的内存时。这时ReturnLength应该被设为0。

     #define STATUS_PARTIAL_COPY 0x8000000D

     如果有人查询被挂钩的函数开始的字节我们就调用原始代码并拷贝原始代码里开始的那些字节到缓冲区中。
     现在新进程已无法通过读取它的内存来检测是否被挂钩了。同样如果你调试被挂钩的进程调试器也会用问题，它会显示原始代码，但却执行我们的代码。

     为了使隐藏更完美，我们还要挂钩NtQueryVirtualMemory。这个函数用来获取虚拟内存的信息。我们挂钩它来防止探测我们分配的虚逆内存。

     NTSTATUS NtQueryVirtualMemory(
         IN HANDLE ProcessHandle,
         IN PVOID BaseAddress,
         IN MEMORY_INFORMATION_CLASS MemoryInformationClass,
         OUT PVOID MemoryInformation,
         IN ULONG MemoryInformationLength,
         OUT PULONG ReturnLength OPTIONAL
     );

     MemoryInformationClass标明了返回数据的类别。我们对开始的2种类型感兴趣。

     #define MemoryBasicInformation 0
     #define MemoryWorkingSetList 1

     对MemoryBasicInformation返回这个结构:

     typedef struct _MEMORY_BASIC_INFORMATION {
         PVOID BaseAddress;
         PVOID AllocationBase;
         ULONG AllocationProtect;
         ULONG RegionSize;
         ULONG State;
         ULONG Protect;
         ULONG Type;
     } MEMORY_BASIC_INFORMATION, *PMEMORY_BASIC_INFORMATION;

     每个区段都有它的大小RegionSize和它的类型Type。空闲内存的类型是MEM_FREE。(区段对象就是文件映射对象，是可被映射到一个进程的虚逆地址空间的对象)

     #define MEM_FREE 0x10000

     如果我们代码之前一个区段的类型是MEM_FREE我们就在它的RegionSize加上我们代码的区段的大小。如果我们代码之后的区段的类型也是MEM_FREE那么就在之前区段的RegionSize上再加上之后的空闲区段的大小。
     如果我们代码之前的区段是其它类型，我们就对我们代码的区段返回MEM_FREE。它的大小根据之后的区段来计算。

     对MemoryWorkingSetList返回这个结构:

     typedef struct _MEMORY_WORKING_SET_LIST {
         ULONG NumberOfPages;
         ULONG WorkingSetList[1];
     } MEMORY_WORKING_SET_LIST, *PMEMORY_WORKING_SET_LIST;

     NumberOfPages是WorkingSetList中列项的数目。这个数字应该减少一些。我们在WorkingSetList中找到我们代码的区段然后把之后记录前移。WorkingSetList是按DWORD排列的数组，每个元素的高20位标明了区段地址，低12位是标志。