备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

4.2 Windows驱动开发：内核中进程线程与模块

2023-11-17 70
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
实时计算 Flink 版，5000CU*H 3个月
推荐场景：
实时发现最热Github项目
简介： 内核进程线程和模块是操作系统内核中非常重要的概念。它们是操作系统的核心部分，用于管理系统资源和处理系统请求。在驱动安全开发中，理解内核进程线程和模块的概念对于编写安全的内核驱动程序至关重要。内核进程是在操作系统内核中运行的程序。每个进程都有一个唯一的进程标识符（PID），它用于在系统中唯一地标识该进程。在内核中，进程被表示为一个进程控制块（PCB），它包含有关进程的信息，如进程状态、优先级、内存使用情况等。枚举进程可以让我们获取当前系统中所有正在运行的进程的PID和其他有用的信息，以便我们可以监视和管理系统中的进程。

内核进程线程和模块是操作系统内核中非常重要的概念。它们是操作系统的核心部分，用于管理系统资源和处理系统请求。在驱动安全开发中，理解内核进程线程和模块的概念对于编写安全的内核驱动程序至关重要。

内核进程是在操作系统内核中运行的程序。每个进程都有一个唯一的进程标识符（PID），它用于在系统中唯一地标识该进程。在内核中，进程被表示为一个进程控制块（PCB），它包含有关进程的信息，如进程状态、优先级、内存使用情况等。枚举进程可以让我们获取当前系统中所有正在运行的进程的PID和其他有用的信息，以便我们可以监视和管理系统中的进程。

线程是在进程内部执行的轻量级执行单元。与进程不同，线程不拥有自己的地址空间和系统资源，它们共享它们所属进程的资源。在内核中，线程被表示为线程控制块（TCB），它包含有关线程的信息，如线程状态、调度信息、执行上下文等。枚举线程可以让我们获取当前系统中所有正在运行的线程的PID、线程ID和其他有用的信息，以便我们可以监视和管理系统中的线程。

内核模块是一种可加载的内核组件，它可以动态地添加到内核中。内核模块通常用于向内核添加新的设备驱动程序或系统功能。在驱动安全开发中，理解内核模块的概念对于编写安全的内核驱动程序非常重要。枚举内核模块可以让我们获取当前系统中加载的所有内核模块的名称、版本号和其他有用的信息，以便我们可以分析和调试内核模块。

在总体上，内核进程线程和模块是操作系统内核中非常重要的概念。通过了解这些概念，我们可以更好地理解操作系统内部的工作原理，从而编写更安全的内核驱动程序。

4.2.1 内核中实现枚举进程

进程就是活动起来的程序，每一个进程在内核里，都有一个名为 EPROCESS 的结构记录它的详细信息，其中就包括进程名，PID，PPID，进程路径等，通常在应用层枚举进程只列出所有进程的编号即可，不过在内核层需要把它的 EPROCESS 地址给列举出来。

在内核中枚举进程我们可通过循环语句遍历进程句柄0-100000以内的值，每次通过PsLookupProcessByProcessId打开一个进程并得到进程EPROCESS结构，当获取到该结构体时只需要调用不同的三个内核函数即可获取到当前句柄所对应的进程相关信息。

当我们需要通过EPROCESS得到进程名时可使用PsGetProcessImageFileName()这个内核函数，该函数的具体定义规范如下所示；

PCHAR PsGetProcessImageFileName(
  PEPROCESS Process
);

其中，参数Process是一个PEPROCESS类型的指针，表示要获取映像文件名的进程的EPROCESS结构体指针；返回值是一个PCHAR类型的指针，指向包含指定进程映像文件名的空字符结尾字符串。

与之功能类似，当我们需要通过EPROCESS获取进程PID时，则可以调用PsGetProcessId()来获取到，该函数的具体定义规范如下所示；

HANDLE PsGetProcessId(
  PEPROCESS Process
);

其中，参数Process是一个PEPROCESS类型的指针，表示要获取进程ID的进程的EPROCESS结构体指针；返回值是一个HANDLE类型的进程ID值。

而如果当我们想要获取到进程的父进程时，则同样可使用PsGetProcessInheritedFromUniqueProcessId()来获取，该函数的具体定义规范如下所示；

HANDLE PsGetProcessInheritedFromUniqueProcessId(
  PEPROCESS Process
);

其中，参数Process是一个PEPROCESS类型的指针，表示要获取父进程ID的进程的EPROCESS结构体指针；返回值是一个HANDLE类型的父进程ID值。

有了这三个函数的支持，我们就可以实现遍历当前所有运行的进程啦，具体实现代码如下所示；

#include <ntifs.h>

// 未公开的进行导出即可
NTKERNELAPI UCHAR* PsGetProcessImageFileName(IN PEPROCESS Process);

// 未公开进行导出
NTKERNELAPI HANDLE PsGetProcessInheritedFromUniqueProcessId(IN PEPROCESS Process);

// 根据进程ID返回进程EPROCESS结构体,失败返回NULL
PEPROCESS LookupProcess(HANDLE Pid)
{
   
   
    PEPROCESS eprocess = NULL;
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
    Status = PsLookupProcessByProcessId(Pid, &eprocess);
    if (NT_SUCCESS(Status))
        return eprocess;
    return NULL;
}

VOID EnumProcess()
{
   
   
    PEPROCESS eproc = NULL;
    for (int temp = 0; temp < 100000; temp += 4)
    {
   
   
        eproc = LookupProcess((HANDLE)temp);
        if (eproc != NULL)
        {
   
   
            DbgPrint("进程名: %s --> 进程PID = %d --> 父进程PPID = %d\r\n",PsGetProcessImageFileName(eproc),PsGetProcessId(eproc),
                PsGetProcessInheritedFromUniqueProcessId(eproc));
            ObDereferenceObject(eproc);
        }
    }
}

VOID UnDriver(PDRIVER_OBJECT driver)
{
   
   
    DbgPrint(("Uninstall Driver Is OK \n"));
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
{
   
   
    EnumProcess();
    Driver->DriverUnload = UnDriver;
    return STATUS_SUCCESS;
}

输出效果图如下所示：

4.2.2 内核中实现枚举线程

内核线程的枚举与枚举进程十分相似，内核线程中也存在一个ETHREAD结构，但在枚举线程之前需要先来枚举到指定进程的eprocess结构，然后再根据eprocess结构对指定线程进行枚举。

在内核中实现枚举线程需要遵循以下步骤：

  • 枚举指定进程的eprocess结构：在内核中，每个进程都有一个唯一的eprocess结构表示，该结构包含了该进程的各种信息，包括其线程列表。首先，需要枚举到指定进程的eprocess结构。可以通过访问系统的进程链表，找到该进程的eprocess结构。
  • 遍历线程列表：一旦枚举到了指定进程的eprocess结构，就可以通过该结构中的线程列表来枚举该进程的所有线程。线程列表中包含每个线程的ETHREAD结构。
  • 枚举每个线程的ETHREAD结构：遍历线程列表，对于每个线程，可以通过其ETHREAD结构访问该线程的各种信息，包括其状态、优先级、CPU时间等等。
  • 处理枚举结果：枚举过程中可以将每个线程的ETHREAD结构存储到一个缓冲区中，以便后续处理。

需要注意的是，在枚举线程的过程中，需要保证访问的安全性和正确性。例如，需要确保在访问每个线程的ETHREAD结构时，该线程不会被销毁或修改。同时，还需要考虑内核与用户空间的交互，以及多处理器系统中的并发访问等问题。

为了能写出完整的代码，这里我们还需要介绍三个未导出函数，PsGetProcessImageFileName，PsLookupThreadByThreadId，IoThreadToProcess这三个函数是实现枚举线程的关键，它们提供了枚举线程相关的关键功能；

PsGetProcessImageFileName 函数的作用是获取指定进程的可执行文件名。在枚举线程时，可以使用该函数获取线程所属进程的可执行文件名，从而可以更方便地识别线程。

NTKERNELAPI PCHAR PsGetProcessImageFileName(IN PEPROCESS Process)

其中，PEPROCESS是一个指向进程对象的指针，该函数将返回一个指向进程可执行文件名的指针。

PsLookupThreadByThreadId 函数的作用是根据线程ID查找线程对象。在枚举线程时，可以使用该函数根据线程ID获取线程对象的指针，进而获取线程的相关信息。

NTKERNELAPI PETHREAD PsLookupThreadByThreadId(IN HANDLE ThreadId)

其中，HANDLE是一个线程ID，该函数将返回一个指向线程对象的指针。

IoThreadToProcess 函数的作用是获取线程所属进程的指针。在枚举线程时，可以使用该函数获取线程所属进程的指针，进而获取进程的相关信息。

NTKERNELAPI PEPROCESS IoThreadToProcess(IN PETHREAD Thread)

其中，PETHREAD是一个指向线程对象的指针，该函数将返回一个指向线程所属进程的指针。

有了上述三个函数的支持，那么实现枚举线程就变得非常简单了，EnumThread则是用于实现线程枚举的核心代码；

  • 首先，定义了一个用于循环遍历线程ID的变量i，并且初始化为4，因为Windows系统的线程ID从4开始。
  • 定义了两个指针类型的变量ethrd和eproc，用于保存获取到的线程对象和线程所属进程对象的指针。
  • 循环遍历线程ID，每次增加4，直到262144为止。这个范围应该是保守估计，实际上可能更小，因为一般来说系统中并不会存在那么多的线程。
  • 调用LookupThread函数，根据线程ID查找线程对象。如果找到了线程对象，则获取线程所属进程对象的指针，并且判断该进程对象是否与指定的进程对象相同。
  • 如果是指定的进程对象，则打印出线程对象和线程ID。最后释放线程对象的引用计数。

其完整实现代码如下所示；

#include <ntddk.h>
#include <windef.h>

// 声明API
NTKERNELAPI UCHAR* PsGetProcessImageFileName(IN PEPROCESS Process);
NTKERNELAPI NTSTATUS PsLookupProcessByProcessId(HANDLE Id, PEPROCESS *Process);
NTKERNELAPI NTSTATUS PsLookupThreadByThreadId(HANDLE Id, PETHREAD *Thread);
NTKERNELAPI PEPROCESS IoThreadToProcess(PETHREAD Thread);

// 根据进程ID返回进程EPROCESS，失败返回NULL
PEPROCESS LookupProcess(HANDLE Pid)
{
   
   
    PEPROCESS eprocess = NULL;
    if (NT_SUCCESS(PsLookupProcessByProcessId(Pid, &eprocess)))
        return eprocess;
    else
        return NULL;
}

// 根据线程ID返回线程ETHREAD，失败返回NULL
PETHREAD LookupThread(HANDLE Tid)
{
   
   
    PETHREAD ethread;
    if (NT_SUCCESS(PsLookupThreadByThreadId(Tid, &ethread)))
        return ethread;
    else
        return NULL;
}

// 枚举指定进程中的线程
VOID EnumThread(PEPROCESS Process)
{
   
   
    ULONG i = 0, c = 0;
    PETHREAD ethrd = NULL;
    PEPROCESS eproc = NULL;

  // 一般来说没有超过100000的PID和TID
    for (i = 4; i<262144; i = i + 4)
    {
   
   
        ethrd = LookupThread((HANDLE)i);
        if (ethrd != NULL)
        {
   
   
            // 获得线程所属进程
            eproc = IoThreadToProcess(ethrd);
            if (eproc == Process)
            {
   
   
                // 打印出ETHREAD和TID
                DbgPrint("线程: ETHREAD=%p TID=%ld\n",ethrd,(ULONG)PsGetThreadId(ethrd));
            }
            ObDereferenceObject(ethrd);
        }
    }
}

// 通过枚举的方式定位到指定的进程，这里传递一个进程名称
VOID MyEnumThread(char *ProcessName)
{
   
   
    ULONG i = 0;
    PEPROCESS eproc = NULL;
    for (i = 4; i<100000000; i = i + 4)
    {
   
   
        eproc = LookupProcess((HANDLE)i);
        if (eproc != NULL)
        {
   
   
            ObDereferenceObject(eproc);
            if (strstr(PsGetProcessImageFileName(eproc), ProcessName) != NULL)
            {
   
   
        // 相等则说明是我们想要的进程，直接枚举其中的线程
                EnumThread(eproc);
            }
        }
    }
}

VOID DriverUnload(IN PDRIVER_OBJECT DriverObject)
{
   
   

}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
{
   
   
    MyEnumThread("lyshark.exe");
    DriverObject->DriverUnload = DriverUnload;
    return STATUS_SUCCESS;
}

输出效果图如下所示：

4.2.3 内核中实现枚举进程模块

枚举进程中的所有模块信息，DLL模块信息被记录在PEB的LDR链表里，LDR是一个双向链表枚举链表即可。

在操作系统内核中实现枚举进程模块的过程中，需要首先访问进程的PEB（进程环境块）数据结构。PEB是一个系统数据结构，记录了进程的各种信息，包括进程的内存布局、环境变量、进程的模块列表等。

进程的模块信息被记录在PEB的LDR（Loader）链表中。这个链表是一个双向链表，记录了进程的所有模块，包括已加载和未加载的模块。

要枚举进程中的所有模块信息，需要遍历LDR链表。在遍历LDR链表时，可以通过遍历双向链表中的节点来获取每个模块的详细信息，如模块的基址、模块的大小、模块的名称等。

遍历LDR链表的过程中，可以使用双向链表的常见操作，如while循环遍历，或使用指针的操作来访问下一个或上一个节点。在访问每个节点时，可以通过节点的指针访问节点中记录的模块信息，例如通过节点的指针访问模块的基址、大小、名称等信息。

通过枚举LDR链表，可以获取进程中的所有模块信息，并且可以在内核中对这些模块进行操作，如卸载模块、加载模块等。

在开始实现枚举进程模块之前，我们需要手动寻找peb.ldr以及peb.ldr.InLoadOrderModuleList的实际偏移地址，该偏移地址在不同的系统内是不同的，通过WinDBG调试Windows系统，并输入如下命令，即可找到我们所需的内核偏移值；

1: kd> dt _PEB
ntdll!_PEB
   +0x000 InheritedAddressSpace : UChar
   +0x001 ReadImageFileExecOptions : UChar
   +0x002 BeingDebugged    : UChar
   +0x003 BitField         : UChar
   +0x003 ImageUsesLargePages : Pos 0, 1 Bit
   +0x003 IsProtectedProcess : Pos 1, 1 Bit
   +0x003 IsImageDynamicallyRelocated : Pos 2, 1 Bit
   +0x003 SkipPatchingUser32Forwarders : Pos 3, 1 Bit
   +0x003 IsPackagedProcess : Pos 4, 1 Bit
   +0x003 IsAppContainer   : Pos 5, 1 Bit
   +0x003 IsProtectedProcessLight : Pos 6, 1 Bit
   +0x003 IsLongPathAwareProcess : Pos 7, 1 Bit
   +0x004 Padding0         : [4] UChar
   +0x008 Mutant           : Ptr64 Void
   +0x010 ImageBaseAddress : Ptr64 Void
   +0x018 Ldr              : Ptr64 _PEB_LDR_DATA                   // LDR结构
   +0x020 ProcessParameters : Ptr64 _RTL_USER_PROCESS_PARAMETERS

1: kd> dt _PEB_LDR_DATA
ntdll!_PEB_LDR_DATA
   +0x000 Length           : Uint4B
   +0x004 Initialized      : UChar
   +0x008 SsHandle         : Ptr64 Void
   +0x010 InLoadOrderModuleList : _LIST_ENTRY                     // 链表结构
   +0x020 InMemoryOrderModuleList : _LIST_ENTRY
   +0x030 InInitializationOrderModuleList : _LIST_ENTRY
   +0x040 EntryInProgress  : Ptr64 Void
   +0x048 ShutdownInProgress : UChar
   +0x050 ShutdownThreadId : Ptr64 Void

获取到这两个关键偏移值以后，接下来就是封装EnumModule实现函数了，如下方核心代码的核心是在内核模式下枚举指定进程的模块列表，并打印每个模块的基址、大小和路径。它首先获取指定进程的 PEB，然后通过访问进程的 Ldr 数据结构获取模块列表信息，并使用 ProbeForRead 函数测试访问内存的可读性。

通过循环将所有的Module格式化为PLDR_DATA_TABLE_ENTRY结构并打印每个模块的信息，输出结束后取消对进程的依附，以此来实现枚举进程内所有的加载模块信息；

#include <ntddk.h>
#include <windef.h>

// 声明结构体
typedef struct _KAPC_STATE
{
   
   
    LIST_ENTRY ApcListHead[2];
    PKPROCESS Process;
    UCHAR KernelApcInProgress;
    UCHAR KernelApcPending;
    UCHAR UserApcPending;
} KAPC_STATE, *PKAPC_STATE;

typedef struct _LDR_DATA_TABLE_ENTRY
{
   
   
    LIST_ENTRY64    InLoadOrderLinks;
    LIST_ENTRY64    InMemoryOrderLinks;
    LIST_ENTRY64    InInitializationOrderLinks;
    PVOID           DllBase;
    PVOID           EntryPoint;
    ULONG           SizeOfImage;
    UNICODE_STRING  FullDllName;
    UNICODE_STRING  BaseDllName;
    ULONG           Flags;
    USHORT          LoadCount;
    USHORT          TlsIndex;
    PVOID           SectionPointer;
    ULONG           CheckSum;
    PVOID           LoadedImports;
    PVOID           EntryPointActivationContext;
    PVOID           PatchInformation;
    LIST_ENTRY64    ForwarderLinks;
    LIST_ENTRY64    ServiceTagLinks;
    LIST_ENTRY64    StaticLinks;
    PVOID           ContextInformation;
    ULONG64         OriginalBase;
    LARGE_INTEGER   LoadTime;
} LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;

// peb.ldr
ULONG64 LdrInPebOffset = 0x018;

// peb.ldr.InLoadOrderModuleList
ULONG64 ModListInPebOffset = 0x010;

// 声明API
NTKERNELAPI UCHAR* PsGetProcessImageFileName(IN PEPROCESS Process);
NTKERNELAPI PPEB PsGetProcessPeb(PEPROCESS Process);
NTKERNELAPI HANDLE PsGetProcessInheritedFromUniqueProcessId(IN PEPROCESS Process);

// 根据进程ID返回进程EPROCESS失败返回NULL
PEPROCESS LookupProcess(HANDLE Pid)
{
   
   
    PEPROCESS eprocess = NULL;
    if (NT_SUCCESS(PsLookupProcessByProcessId(Pid, &eprocess)))
        return eprocess;
    else
        return NULL;
}

// 枚举指定进程的模块
VOID EnumModule(PEPROCESS Process)
{
   
   
    SIZE_T Peb = 0;
    SIZE_T Ldr = 0;
    PLIST_ENTRY ModListHead = 0;
    PLIST_ENTRY Module = 0;
    ANSI_STRING AnsiString;
    KAPC_STATE ks;

  // EPROCESS地址无效则退出
    if (!MmIsAddressValid(Process))
        return;

  // 获取PEB地址
    Peb = (SIZE_T)PsGetProcessPeb(Process);

  // PEB地址无效则退出
    if (!Peb)
        return;

  // 依附进程
    KeStackAttachProcess(Process, &ks);
    __try
    {
   
   
        // 获得LDR地址
        Ldr = Peb + (SIZE_T)LdrInPebOffset;

    // 测试是否可读，不可读则抛出异常退出
        ProbeForRead((CONST PVOID)Ldr, 8, 8);

    // 获得链表头
        ModListHead = (PLIST_ENTRY)(*(PULONG64)Ldr + ModListInPebOffset);

    // 再次测试可读性
        ProbeForRead((CONST PVOID)ModListHead, 8, 8);

    // 获得第一个模块的信息
        Module = ModListHead->Flink;
        while (ModListHead != Module)
        {
   
   
            // 打印信息：基址、大小、DLL路径
            DbgPrint("模块基址=%p 大小=%ld 路径=%wZ\n",(PVOID)(((PLDR_DATA_TABLE_ENTRY)Module)->DllBase),
                (ULONG)(((PLDR_DATA_TABLE_ENTRY)Module)->SizeOfImage),&(((PLDR_DATA_TABLE_ENTRY)Module)->FullDllName));

      Module = Module->Flink;

      // 测试下一个模块信息的可读性
            ProbeForRead((CONST PVOID)Module, 80, 8);
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER){
   
   ;}

  // 取消依附进程
    KeUnstackDetachProcess(&ks);
}

// 通过枚举的方式定位到指定的进程，这里传递一个进程名称
VOID MyEnumModule(char *ProcessName)
{
   
   
    ULONG i = 0;
    PEPROCESS eproc = NULL;
    for (i = 4; i<100000000; i = i + 4)
    {
   
   
        eproc = LookupProcess((HANDLE)i);
        if (eproc != NULL)
        {
   
   
            ObDereferenceObject(eproc);
            if (strstr(PsGetProcessImageFileName(eproc), ProcessName) != NULL)
            {
   
   
        // 相等则说明是我们想要的进程，直接枚举其中的线程
                EnumModule(eproc);
            }
        }
    }
}

VOID DriverUnload(IN PDRIVER_OBJECT DriverObject)
{
   
   

}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
{
   
   
    MyEnumModule("calc.exe");
    DriverObject->DriverUnload = DriverUnload;
    return STATUS_SUCCESS;
}

输出效果图如下所示：

4.2.4 内核中实现枚举加载的驱动

内核中的SYS文件也是通过双向链表的方式相连接的，我们可以通过遍历驱动自身LDR_DATA_TABLE_ENTRY结构(遍历自身DriverSection成员)，就能够得到全部的模块信息。

在操作系统内核中，SYS文件通常作为设备驱动程序的一部分加载到内存中。为了管理这些模块，Windows使用了一个双向链表来维护已加载模块的信息。链表中的每个节点是一个LDR_DATA_TABLE_ENTRY结构，它包含了模块的各种信息，如模块名、模块基地址、模块大小、模块导入表等等。

当一个SYS文件被加载到内存中时，系统会创建一个LDR_DATA_TABLE_ENTRY结构并将其插入到内核模块列表的末尾。在插入时，系统会将新节点的前一个节点的ForwardLink指向新节点，将新节点的BackLink指向前一个节点，并将新节点的ForwardLink指向链表尾部的哨兵节点。

遍历内核模块列表时，可以通过遍历LDR_DATA_TABLE_ENTRY结构中的DriverSection成员，找到所有已加载的SYS文件，并获得它们的基本信息。从链表头部开始遍历链表，可以使用ForwardLink指针来访问下一个节点，直到访问到链表尾部的哨兵节点为止。

如下代码中，在DriverEntry()开始处，定义了一些变量，包括pLdr、pListEntry、pModule和pCurrentListEntry，它们分别代表当前驱动程序的LDR_DATA_TABLE_ENTRY结构、模块列表中的链表头、当前模块的LDR_DATA_TABLE_ENTRY结构和当前遍历到的链表节点。

接着，使用DriverObject->DriverSection获取当前驱动程序的LDR_DATA_TABLE_ENTRY结构，并通过pLdr->InLoadOrderLinks.Flink获取模块列表中的链表头。使用pListEntry->Flink获取链表中的第一个节点，并将其赋值给pCurrentListEntry。

之后，通过一个循环遍历整个模块列表。在每次循环中，使用CONTAINING_RECORD宏获取当前节点对应的LDR_DATA_TABLE_ENTRY结构，并检查该模块的基本信息是否为空。如果不为空，将该模块的基址、结束地址、大小和模块名打印到调试窗口中。

最后，在函数结尾处设置了驱动程序的卸载例程DriverUnload，并返回STATUS_SUCCESS表示函数执行成功，至此枚举内核模块就完成了，其完整代码如下；

#include <ntddk.h>
#include <wdm.h>

typedef struct _LDR_DATA_TABLE_ENTRY {
   
   
    LIST_ENTRY InLoadOrderLinks;
    LIST_ENTRY InMemoryOrderLinks;
    LIST_ENTRY InInitializationOrderLinks;
    PVOID DllBase;
    PVOID EntryPoint;
    ULONG SizeOfImages;
    UNICODE_STRING FullDllName;
    UNICODE_STRING BaseDllName;
    ULONG Flags;
    USHORT LoadCount;
    USHORT TlsIndex;
    union {
   
   
        LIST_ENTRY HashLinks;
        struct {
   
   
            PVOID SectionPointer;
            ULONG CheckSum;
        };
    };
    union {
   
   
        struct {
   
   
            ULONG TimeDateStamp;
        };
        struct {
   
   
            PVOID LoadedImports;
        };
    };
}LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;

VOID DriverUnload(IN PDRIVER_OBJECT DriverObject)
{
   
   

}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
   
   
    ULONG count = 0;
    NTSTATUS Status;
    DriverObject->DriverUnload = DriverUnload;

    PLDR_DATA_TABLE_ENTRY pLdr = NULL;
    PLIST_ENTRY pListEntry = NULL;
    PLDR_DATA_TABLE_ENTRY pModule = NULL;
    PLIST_ENTRY pCurrentListEntry = NULL;

    pLdr = (PLDR_DATA_TABLE_ENTRY)DriverObject->DriverSection;
    pListEntry = pLdr->InLoadOrderLinks.Flink;
    pCurrentListEntry = pListEntry->Flink;

    while (pCurrentListEntry != pListEntry)
    {
   
   
        pModule = CONTAINING_RECORD(pCurrentListEntry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
        if (pModule->BaseDllName.Buffer != 0)
        {
   
   
            DbgPrint("基址：%p ---> 偏移：%p ---> 结束地址：%p---> 模块名：%wZ \r\n", pModule->DllBase, pModule->SizeOfImages - (LONGLONG)pModule->DllBase, 
                (LONGLONG)pModule->DllBase + pModule->SizeOfImages,pModule->BaseDllName);
        }
        pCurrentListEntry = pCurrentListEntry->Flink;
    }

    DriverObject->DriverUnload = DriverUnload;
    return STATUS_SUCCESS;
}

输出效果图如下所示：

4.2.5 内核中实现获取特定进程PID

用户传入指定进程名称，调用GetPidByProcessName()可得到该进程名称所对应的进程PID号。这段代码其大多数功能实现已经在前面的章节中实现了，需要注意的是GetProcessID()函数内部，通过strstr(PsGetProcessImageFileName(eproc), ProcessName) != NULL对比如果是我们所需要提取的进程结构，则直接PsGetProcessId(eproc)返回该进程的PID号。

#include <ntifs.h>
#include <windef.h>

// 声明API
NTKERNELAPI UCHAR* PsGetProcessImageFileName(IN PEPROCESS Process);
NTKERNELAPI PPEB PsGetProcessPeb(PEPROCESS Process);
NTKERNELAPI HANDLE PsGetProcessInheritedFromUniqueProcessId(IN PEPROCESS Process);

// 根据进程ID返回进程EPROCESS，失败返回NULL
PEPROCESS LookupProcess(HANDLE Pid)
{
   
   
  PEPROCESS eprocess = NULL;
  if (NT_SUCCESS(PsLookupProcessByProcessId(Pid, &eprocess)))
    return eprocess;
  else
    return NULL;
}

// 根据用户传入进程名得到该进程PID
HANDLE GetProcessID(char *ProcessName)
{
   
   
  ULONG i = 0;
  PEPROCESS eproc = NULL;
  for (i = 4; i<100000000; i = i + 4)
  {
   
   
    eproc = LookupProcess((HANDLE)i);
    if (eproc != NULL)
    {
   
   
      ObDereferenceObject(eproc);
      if (strstr(PsGetProcessImageFileName(eproc), ProcessName) != NULL)
      {
   
   
        return PsGetProcessId(eproc);
      }
    }
  }
  return NULL;
}

VOID DriverUnload(IN PDRIVER_OBJECT DriverObject)
{
   
   

}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
{
   
   
  HANDLE ref = GetProcessID("KmdManager.exe");
  DbgPrint("[LyShark.com] 进程PID = %d \n", ref);

  DriverObject->DriverUnload = DriverUnload;
  return STATUS_SUCCESS;
}

输出效果图如下所示：

4.2.6 内核中实现判断进程状态

内核中实现判断进程状态的方法，通过传入一个 EProcess 结构体来判断指定进程的状态，包括进程是否存在、是否为僵尸进程等。这些功能通常被用于反内核工具的开发。

接下来，将逐个介绍并实现几个相关的功能，包括 IsProcessDie 函数用于验证进程空间是否有效，IsRealProcess 函数用于验证进程是否是真实进程，以及 GetProcessCreateTime 函数用于获取进程创建时间戳等功能。

IsProcessDie 函数用于验证特定进程空间是否有效，函数接受一个 PEPROCESS 类型的参数 EProcess，表示待验证的进程。函数会检查传入的 EProcess 参数是否为有效地址，并且会检查进程对象表的地址是否为有效地址。如果传入的参数或进程对象表地址无效，函数将返回 TRUE，表示进程空间已经无效或不存在。反之，如果地址有效，函数将返回 FALSE，表示进程空间有效。

函数的执行步骤如下：

  • 首先判断 MmIsAddressValid 函数是否存在且有效，如果无效则直接返回 TRUE，表示进程空间无效。
  • 检查传入的 EProcess 参数是否为有效地址，如果地址无效则直接返回 TRUE，表示进程空间无效。
  • 通过计算 EProcess 结构体中进程对象表的偏移量，并检查该地址是否为有效地址。如果进程对象表地址无效，表示进程空间已经无效或不存在，直接返回 TRUE。
  • 如果传入的参数和进程对象表地址均为有效地址，则获取进程对象表指针并进行进一步检查。
  • 如果进程对象表指针为 NULL 或者其地址无效，则表示进程空间已经无效或不存在，返回 TRUE，否则返回 FALSE，表示进程空间有效。
// 验证进程空间是否有效
BOOLEAN IsProcessDie(PEPROCESS EProcess)
{
   
   
  BOOLEAN bDie = FALSE;

  if (MmIsAddressValid &&
    EProcess &&
    MmIsAddressValid(EProcess) &&
    MmIsAddressValid((PVOID)((ULONG_PTR)EProcess + ObjectTableOffsetOf_EPROCESS)))
  {
   
   
    PVOID ObjectTable = *(PVOID*)((ULONG_PTR)EProcess + ObjectTableOffsetOf_EPROCESS);

    if (!ObjectTable || !MmIsAddressValid(ObjectTable))
    {
   
   
      bDie = TRUE;
    }
  }
  else
  {
   
   
    bDie = TRUE;
  }
  return bDie;
}

IsRealProcess 函数的功能是验证进程是否是僵尸进程。该函数接受一个 PEPROCESS 类型的参数 EProcess，表示待验证的进程。函数内部会先通过 KeGetObjectType 函数获取传入的进程对象的类型，然后将其与进程类型进行比较，如果相同且进程空间有效，则说明该进程不是僵尸进程，返回 TRUE，否则返回 FALSE。

在 KeGetObjectType 函数中，先判断输入参数是否为有效地址，如果无效则返回 NULL，表示取对象类型失败。如果地址有效，则通过 GetFunctionAddressByName 函数获取 ObGetObjectType 函数的地址，然后调用 ObGetObjectType 函数获取对象类型。最后将对象类型作为返回值返回。

在IsRealProcess主函数中，首先获取进程类型，然后检查传入的进程对象是否为有效地址。如果进程类型和获取的对象类型相同，且进程空间有效，则说明该进程不是僵尸进程，返回 TRUE。反之，如果进程对象无效或进程类型不匹配，则说明该进程是僵尸进程，返回 FALSE。

// 取出对象类型
ULONG_PTR KeGetObjectType(PVOID Object)
{
   
   
  ULONG_PTR ObjectType = NULL;
  pfnObGetObjectType ObGetObjectType = NULL;

  if (!MmIsAddressValid || !Object || !MmIsAddressValid(Object))
  {
   
   
    return NULL;
  }
  ObGetObjectType = (pfnObGetObjectType)GetFunctionAddressByName(L"ObGetObjectType");
  if (ObGetObjectType)
  {
   
   
    ObjectType = ObGetObjectType(Object);
  }
  return ObjectType;
}

// 验证进程是否是僵尸进程
BOOLEAN IsRealProcess(PEPROCESS EProcess)
{
   
   
  ULONG_PTR ObjectType;
  ULONG_PTR    ObjectTypeAddress;
  BOOLEAN bRet = FALSE;

  ULONG_PTR ProcessType = ((ULONG_PTR)*PsProcessType);

  if (ProcessType && MmIsAddressValid && EProcess && MmIsAddressValid((PVOID)(EProcess)))
  {
   
   
    ObjectType = KeGetObjectType((PVOID)EProcess);
    if (ObjectType &&
      ProcessType == ObjectType &&
      !IsProcessDie(EProcess))
    {
   
   
      bRet = TRUE;
    }
  }

  return bRet;
}

GetProcessCreateTime 函数用于获取指定进程的创建时间戳。通过调用PsLookupProcessByProcessId函数获取到进程对象，然后调用PsGetProcessCreateTimeQuadPart函数获取进程的创建时间戳。在获取时间戳之前，需要将当前线程的Previous Mode设置为内核模式，以便访问EPROCESS结构体中的成员。在获取时间戳之后，需要将Previous Mode恢复到之前的值，并释放进程对象。

函数的执行步骤如下：

  • 通过调用PsLookupProcessByProcessId函数获取指定进程的进程对象。
  • 调用PsGetCurrentThread函数获取当前线程的ETHREAD对象，调用ChangePreMode函数将当前线程的Previous Mode设置为内核模式，并保存之前的Previous Mode的值。
  • 调用PsGetProcessCreateTimeQuadPart函数获取指定进程的创建时间戳，并将时间戳保存到OutputBuffer指向的缓冲区中。
  • 最后调用RecoverPreMode函数将当前线程的Previous Mode恢复到之前的值，并释放进程对象。
// 获取进程时间戳
BOOLEAN GetProcessCreateTime(ULONG_PTR ProcessID, LONGLONG* OutputBuffer)
{
   
   
  NTSTATUS  Status;
  PEPROCESS EProcess = NULL;
  PETHREAD  EThread = NULL;
  CHAR      PreMode = 0;

  Status = PsLookupProcessByProcessId((HANDLE)ProcessID, &EProcess);
  if (!NT_SUCCESS(Status))
  {
   
   
    return FALSE;
  }

  EThread = PsGetCurrentThread();
  PreMode = ChangePreMode(EThread);
  *OutputBuffer = PsGetProcessCreateTimeQuadPart(EProcess);
  RecoverPreMode(EThread, PreMode);
  ObfDereferenceObject(EProcess);
  return TRUE;
}

我们将上述三个功能进行整合，并最终得到一段完整的代码，如下所示；

#include <ntifs.h>

ULONG_PTR ObjectTableOffsetOf_EPROCESS = 0;   // 句柄表偏移
ULONG_PTR PreviousModeOffsetOf_KTHREAD = 0;   // 权限相关的偏移

typedef ULONG_PTR(*pfnObGetObjectType)(PVOID pObject);

// 验证进程空间是否有效
BOOLEAN IsProcessDie(PEPROCESS EProcess)
{
   
   
    BOOLEAN bDie = FALSE;

    if (MmIsAddressValid &&
        EProcess &&
        MmIsAddressValid(EProcess) &&
        MmIsAddressValid((PVOID)((ULONG_PTR)EProcess + ObjectTableOffsetOf_EPROCESS)))
    {
   
   
        PVOID ObjectTable = *(PVOID*)((ULONG_PTR)EProcess + ObjectTableOffsetOf_EPROCESS);

        if (!ObjectTable || !MmIsAddressValid(ObjectTable))
        {
   
   
            bDie = TRUE;
        }
    }
    else
    {
   
   
        bDie = TRUE;
    }
    return bDie;
}

//通过 函数名称 得到函数地址
PVOID GetFunctionAddressByName(WCHAR *szFunction)
{
   
   
    UNICODE_STRING uniFunction;
    PVOID AddrBase = NULL;

    if (szFunction && wcslen(szFunction) > 0)
    {
   
   
        RtlInitUnicodeString(&uniFunction, szFunction);
        AddrBase = MmGetSystemRoutineAddress(&uniFunction);
    }
    return AddrBase;
}

// 取出对象类型
ULONG_PTR KeGetObjectType(PVOID Object)
{
   
   
    ULONG_PTR ObjectType = NULL;
    pfnObGetObjectType ObGetObjectType = NULL;

    if (!MmIsAddressValid || !Object || !MmIsAddressValid(Object))
    {
   
   
        return NULL;
    }
    ObGetObjectType = (pfnObGetObjectType)GetFunctionAddressByName(L"ObGetObjectType");
    if (ObGetObjectType)
    {
   
   
        ObjectType = ObGetObjectType(Object);
    }
    return ObjectType;
}

// 验证进程是否是僵尸进程
BOOLEAN IsRealProcess(PEPROCESS EProcess)
{
   
   
    ULONG_PTR ObjectType;
    ULONG_PTR    ObjectTypeAddress;
    BOOLEAN bRet = FALSE;

    ULONG_PTR ProcessType = ((ULONG_PTR)*PsProcessType);

    if (ProcessType && MmIsAddressValid && EProcess && MmIsAddressValid((PVOID)(EProcess)))
    {
   
   
        ObjectType = KeGetObjectType((PVOID)EProcess);
        if (ObjectType &&
            ProcessType == ObjectType &&
            !IsProcessDie(EProcess))
        {
   
   
            bRet = TRUE;
        }
    }

    return bRet;
}

CHAR ChangePreMode(PETHREAD EThread)
{
   
   
    CHAR PreMode = *(PCHAR)((ULONG_PTR)EThread + PreviousModeOffsetOf_KTHREAD);
    *(PCHAR)((ULONG_PTR)EThread + PreviousModeOffsetOf_KTHREAD) = KernelMode;
    return PreMode;
}

VOID RecoverPreMode(PETHREAD EThread, CHAR PreMode)
{
   
   
    *(PCHAR)((ULONG_PTR)EThread + PreviousModeOffsetOf_KTHREAD) = PreMode;
}

// 获取进程时间戳
BOOLEAN GetProcessCreateTime(ULONG_PTR ProcessID, LONGLONG* OutputBuffer)
{
   
   
    NTSTATUS  Status;
    PEPROCESS EProcess = NULL;
    PETHREAD  EThread = NULL;
    CHAR PreMode = 0;

    Status = PsLookupProcessByProcessId((HANDLE)ProcessID, &EProcess);
    if (!NT_SUCCESS(Status))
    {
   
   
        return FALSE;
    }

    EThread = PsGetCurrentThread();
    PreMode = ChangePreMode(EThread);
    *OutputBuffer = PsGetProcessCreateTimeQuadPart(EProcess);
    RecoverPreMode(EThread, PreMode);
    ObfDereferenceObject(EProcess);
    return TRUE;
}

VOID UnDriver(PDRIVER_OBJECT driver)
{
   
   
    DbgPrint("驱动卸载成功 \n");
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
{
   
   
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
    PEPROCESS EProcess = NULL;
    HANDLE pid = (HANDLE)6932;

    // 根据PID获取进程EProcess结构
    Status = PsLookupProcessByProcessId(pid, &EProcess);

    // 判断进程是否有效
    if (NT_SUCCESS(Status) && IsProcessDie(EProcess))
    {
   
   
        DbgPrint("[LyShark.com] 进程有效 \n");
    }

    // 判断是否为僵尸进程
    if (NT_SUCCESS(Status) && IsRealProcess(EProcess))
    {
   
   
        DbgPrint("[LyShark.com] 僵尸进程 \n");
    }

    // 验证进程时间戳
    LONGLONG time;
    BOOLEAN ref = GetProcessCreateTime(pid, &time);
    if (NT_SUCCESS(Status) && ref)
    {
   
   
        DbgPrint("[LyShark.com] 该进程时间戳: %x \n", time);
    }

    Driver->DriverUnload = UnDriver;
    return STATUS_SUCCESS;
}

输出效果图如下所示：

文章标签：
实时计算 Flink版
Windows
安全
流计算
调度
存储
关键词：
Windows开发
线程模块
内核进程
Windows线程
进程线程
相关实践学习
基于Hologres轻松玩转一站式实时仓库
本场景介绍如何利用阿里云MaxCompute、实时计算Flink和交互式分析服务Hologres开发离线、实时数据融合分析的数据大屏应用。
Linux入门到精通
本套课程是从入门开始的Linux学习课程，适合初学者阅读。由浅入深案例丰富，通俗易懂。主要涉及基础的系统操作以及工作中常用的各种服务软件的应用、部署和优化。即使是零基础的学员，只要能够坚持把所有章节都学完，也一定会受益匪浅。
lyshark
目录
相关文章
1941623231718325
|
17天前
|
安全 Java 数据处理
Python网络编程基础（Socket编程）多线程/多进程服务器编程
【4月更文挑战第11天】在网络编程中，随着客户端数量的增加，服务器的处理能力成为了一个重要的考量因素。为了处理多个客户端的并发请求，我们通常需要采用多线程或多进程的方式。在本章中，我们将探讨多线程/多进程服务器编程的概念，并通过一个多线程服务器的示例来演示其实现。
1941623231718325
33 0
泡沫o0
|
1月前
|
消息中间件 安全 Linux
线程同步与IPC：单进程多线程环境下的选择与权衡
线程同步与IPC：单进程多线程环境下的选择与权衡
泡沫o0
58 0
泡沫o0
|
1月前
|
消息中间件 存储 算法
【软件设计师备考 专题 】操作系统的内核（中断控制）、进程、线程概念
【软件设计师备考 专题 】操作系统的内核（中断控制）、进程、线程概念
泡沫o0
83 0
暴风雨中的白杨
|
18天前
|
调度 Windows
Windows线程
Windows线程
暴风雨中的白杨
22 0
泡沫o0
|
1月前
|
消息中间件 Linux 调度
【Linux 进程/线程状态 】深入理解Linux C++中的进程/线程状态：阻塞，休眠，僵死
【Linux 进程/线程状态 】深入理解Linux C++中的进程/线程状态：阻塞，休眠，僵死
泡沫o0
69 0
L&ecirc;v&iuml;
|
4天前
|
Java 数据库连接 数据处理
Python从入门到精通：3.1.2多线程与多进程编程
Python从入门到精通：3.1.2多线程与多进程编程
L&ecirc;v&iuml;
11 1
长梦
|
10天前
|
调度 Python
Python多线程、多进程与协程面试题解析
【4月更文挑战第14天】Python并发编程涉及多线程、多进程和协程。面试中，对这些概念的理解和应用是评估候选人的重要标准。本文介绍了它们的基础知识、常见问题和应对策略。多线程在同一进程中并发执行，多进程通过进程间通信实现并发，协程则使用`asyncio`进行轻量级线程控制。面试常遇到的问题包括并发并行混淆、GIL影响多线程性能、进程间通信不当和协程异步IO理解不清。要掌握并发模型，需明确其适用场景，理解GIL、进程间通信和协程调度机制。
长梦
28 0
是阿超
|
26天前
|
安全 Linux API
Android进程与线程
Android进程与线程
是阿超
18 0
泡沫o0
|
1月前
|
存储 算法 Linux
【Linux 系统标准 进程资源】Linux 创建一个最基本的进程所需的资源分析,以及线程资源与之的差异
【Linux 系统标准 进程资源】Linux 创建一个最基本的进程所需的资源分析,以及线程资源与之的差异
泡沫o0
25 0
hopegrace
|
Windows
7、Windows驱动开发技术详解笔记(3) 基本语法回顾
    3、文件读写   在ring3 我们可以使用CreateFile、ReadFile 、WriteFile 等API，在ring0 同样很相似，不过函数变成了ZwCreateFile、ZwReadFile、ZwWriteFile 等内核函数。
hopegrace
940 0

热门文章

最新文章

  • 1
    Linux进程和计划任务管理
  • 2
    【Linux C/C++ 堆内存分布】深入理解Linux进程的堆空间管理
  • 3
    Linux IPC 进程间通讯方式的深入对比与分析和权衡
  • 4
    掌握 SOME/IP ：访问进程数据 构建高效通信系统的关键技术
  • 5
    Linux 进程问题调查探秘：分析和排查频繁创建进程问题
  • 6
    linux下监控java进程 实现自动重启服务
  • 7
    【Linux】进程排队的理解&&进程状态的表述&&僵尸进程和孤儿进程的理解
  • 8
    深入理解操作系统：进程管理与调度策略
  • 9
    ChaosBlade常见问题之阻止chaosblade和沙盒进程如何解决
  • 10
    深度解析：Linux内核的进程调度机制
  • 1
    Windows公网远程连接MongoDB数据库【无公网IP】
    52
  • 2
    Windows环境下面启动jar包，输出的日志出现乱码的解决办法
    56
  • 3
    Qt5.14.2 轻松掌握Qt中的压缩与解压缩：QuaZIP的神秘面纱与实战演练之windows环境编译
    79
  • 4
    无远不至的掌控力：探索Windows Server 2019的远程访问绝招
    22
  • 5
    windows server 2019 安装NET Framework 3.5失败，提示：“安装一个或多个角色、角色服务或功能失败” 解决方案
    147
  • 6
    解锁安全之门，Windows Server 2019密码修改攻略大揭秘
    80
  • 7
    铁壁如墙-WINDOWS SERVER 2019勒索病毒终极防御指南
    57
  • 8
    Windows Server 2019 IIS HTTPS证书部署流程详解
    82
  • 9
    windows下快速安装nginx 并配置开机自启动
    62
  • 10
    windows下采用 nginx配置websocket支持wss流程
    37

    • 相关课程

    更多
  • 操作系统学习
  • 服务器硬件基础

    • 相关电子书

    更多
  • 多IO线程优化版
  • TAKING WINDOWS 10 KERNEL
  • ECS运维指南之Windows系统诊断

    • 相关实验场景

    更多
  • 观察进程的并发性
  • 快速配置Windows云服务器
  • 手动搭建FTP站点（Windows）
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）