[原创]实现简易ARK工具(3) 遍历进程和内核模块-编程技术-看雪安全社区

[TOC]

## 前言

大家好，本文讨论了ARK工具在XP/WIN7 32位在内核通过ActiveProcessLinks手动遍历进程的方法，文末贴了遍历进程和内核模块的代码。在下新手，不足之处多多包涵~

## 为什么要遍历进程

在进行进程附加读写操作之前，我们首先需要找到目标进程，传进程PID给读写函数。遍历系统中的所有进程是ARK工具的基础功能之一，用于：

+ 枚举所有运行的进程，查看进程的基本信息（PID、进程名、路径等）
+ 查找特定进程（如检测隐藏进程、rootkit等恶意软件）
+ 分析进程的父子关系、模块加载情况
+ 为后续的附加读写提供目标进程的EPROCESS指针

## 如何遍历进程

下面看看遍历进程的方法，看雪上有些相关文章:

[[原创\]简单利用_CSR_PROCESS结构枚举出进程-软件逆向-看雪-安全社区|安全招聘|kanxue.com](https://bbs.kanxue.com/thread-286312.htm)

[[原创\]驱动遍历系统进程-软件逆向-看雪-安全社区|安全招聘|kanxue.com](https://bbs.kanxue.com/thread-263982.htm)

本文讲通过`ActiveProcessLinks`获取进程链表的方法

在Windows内核中，每个进程都对应一个`EPROCESS`结构体，所有活跃进程通过`ActiveProcessLinks`字段形成一个双向循环链表。

**EPROCESS结构简化示意：**

```cpp
typedef struct _EPROCESS {
    // ... 
    LIST_ENTRY ActiveProcessLinks;     // 用于链接所有进程 偏移: 0x088 (XP)
    HANDLE UniqueProcessId;            // 进程ID  
    CHAR ImageFileName[16];            // 进程名(最多15字符)
    // ... 其他字段
} EPROCESS, *PEPROCESS;

具体结构在文末
```

要遍历进程，我们需要：

1. **找到入口点**：获取当前进程的`EPROCESS`结构

2. **遍历链表**：通过`ActiveProcessLinks`访问其他进程，只要拿到当前进程在`ActiveProcessLinks`中的节点，我们就可以遍历列表拿到数据。

3. **循环检测**：当回到起始进程的节点时停止遍历

------

获取EPROCESS涉及了大量的结构体

> 硬件层面：
> **FS**寄存器 → 指向当前处理器的**KPCR**
>
> 内核层面：
> **KPCR** (处理器控制区域)
> ├── PrcbData → KPRCB (处理器控制块)
> 	└── CurrentThread → **ETHREAD** (当前执行线程)
>
> 线程层面：
> ETHREAD (执行线程)
> ├── ApcState → KAPC_STATE (APC状态)
> │      └── Process → **EPROCESS** (所属进程)
> └── ThreadsProcess → **EPROCESS** (直接指向所属进程)
>
> 进程层面：
> **EPROCESS** (执行进程)   
> ├── Pcb → KPROCESS (内核进程块)
> ├── ActiveProcessLinks → LIST_ENTRY (进程链表)
> ├── UniqueProcessId → 进程ID
> ├── InheritedFromUniqueProcessId → 父进程ID
> ├── ImageFileName[16] → 进程名
> └── 其他进程相关信息
>
> 关注这条路径：FS → KPCR → KPRCB → ETHREAD → EPROCESS → 找链表遍历其他进程的EPROCESS

由于影响观感，截取了部分XP下的结构体贴在文末，建议在windbg中查看这些结构体进行学习，命令:

```
dt!_KPCR       
dt!_KPRCB      
dt!_ETHREAD    
dt!_EPROCESS   
dt!_KAPC_STATE 
dt!_LIST_ENTRY

!pcr                    ; 查看当前处理器的KPCR
!prcb                   ; 查看当前处理器的KPRCB
!thread                 ; 查看当前线程的ETHREAD
!process                ; 查看当前进程的EPROCESS
!process 0 0            ; 列出所有进程

; 查看ActiveProcessLinks链表
dt _EPROCESS nt!PsInitialSystemProcess ActiveProcessLinks

```

要拿`EPROCESS`就得计算这些结构体的偏移，然而windows各个版本的结构体是不同的，工作量不小，这里有几种方法:

**1.人肉计算结构体偏移量**，在驱动启动时`RtlGetVersion(&versionInfo)`获得当前windows版本然后设置对应的偏移量。我刚开始也是这样干的，文末有使用这种方式的代码

```
DriverEntry启动时： 
├─ DetectWindowsVersion() 检测系统版本
├─ InitProcessOffsets() 根据版本设置偏移量

FS寄存器到ETHREAD:
├─ FS:[0x124] → 当前ETHREAD指针
└─ 这个0x124是KPCR结构中CurrentThread字段的偏移

WinXP偏移量：
├─ ProcessId: 0x84          // EPROCESS + 0x84 → UniqueProcessId字段
├─ ActiveProcessLinks: 0x88 // EPROCESS + 0x88 → ActiveProcessLinks字段
├─ ParentProcessId: 0x14C   // EPROCESS + 0x14C → InheritedFromUniqueProcessId字段
├─ ImageFileName: 0x174     // EPROCESS + 0x174 → ImageFileName[16]字段
└─ DirectoryTableBase: 0x18 // EPROCESS + 0x18 → DirectoryTableBase字段

Win7偏移量：  
├─ ProcessId: 0xB4          // EPROCESS + 0xB4 → UniqueProcessId字段
├─ ActiveProcessLinks: 0xB8 // EPROCESS + 0xB8 → ActiveProcessLinks字段  
├─ ParentProcessId: 0x140   // EPROCESS + 0x140 → InheritedFromUniqueProcessId字段
├─ ImageFileName: 0x16C     // EPROCESS + 0x16C → ImageFileName[16]字段
└─ DirectoryTableBase: 0x18 // EPROCESS + 0x18 → DirectoryTableBase字段 (两个版本相同)
```

**2.特征API**: `PsGetCuurentProcessId`  、`PsGetNextProcess`直接拿链表头。缺陷：如果API被hook需要考虑被改jmp的情况，且如果需要的函数没有导出，定位不到函数入口点，需要利用api调用层级进行逐级特征定位。(真有人这么干吗0.0

![](./upload/attach/202507/1003898_Z72YZ8RUQXV9H67.png)

看这个偏移[eax+0x1EC]，Cid 可以拿到`UniqueProcess`和`UniqueThread`的指针

![./images/image-20250715194555452](./upload/attach/202507/1003898_KF4UZNCZRTWF9N6.png)

![./images/image-20250715194434123](./upload/attach/202507/1003898_FX8XKET9K22A8PG.png)

这里可以特征到链表头`PsActiveProcessHead`

![./images/image-20250715195108134](./upload/attach/202507/1003898_S7D9DZ4MKHB785Y.png)

**3.解析pdb**：下载pdb，写工具代码解析pdp获取偏移量。解析pdb很累？其实可以调用`symsrv.dll`和`dbghelp.dll`的导出函数解析，也可以使用VS目录下自带的`DIA2dump`,以及它已经编译好的dll。<a href="elink@47bK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6D9k6h3q4J5L8W2)9J5k6h3#2A6j5%4u0G2M7$3!0X3N6q4)9J5k6h3y4G2L8g2)9J5c8Y4A6Z5i4K6u0V1j5$3&6Q4x3V1k6$3K9i4y4#2j5h3I4K6N6s2g2V1K9h3!0Q4x3V1k6V1k6h3u0#2k6$3N6W2M7W2)9J5c8X3c8W2j5Y4g2Y4i4K6u0V1K9h3&6@1k6i4u0X3j5h3y4W2i4K6u0V1j5h3y4U0k6i4y4K6i4K6u0r3k6r3W2S2x3X3c8#2L8i4m8Q4x3X3c8K6j5h3#2H3L8r3g2Q4x3@1k6$3K9h3g2%4i4K6y4p5N6Y4y4Q4x3X3b7J5x3o6t1J5">Dia2dump 示例 - Visual Studio (Windows) | Microsoft Learn</a>

有相关文章介绍`DIA2DUMP`[[原创\]通过pdb解析SSDT表地址-编程技术-看雪-安全社区|安全招聘|kanxue.com](https://bbs.kanxue.com/thread-273226.htm)

![./images/image-20250715203136528](./upload/attach/202507/1003898_VET387Z89SXPGEY.png)

cmd输入`regsvr32 msdia140.dll`之后就可以在工程里下断点调试？

**4.调API，哎谁爱解析谁解析，我先调了=。=**

<a href="elink@fe6K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6D9k6h3q4J5L8W2)9J5k6h3#2A6j5%4u0G2M7$3!0X3N6q4)9J5k6h3y4G2L8g2)9J5c8Y4A6Z5i4K6u0V1j5$3&6Q4x3V1k6%4K9h3&6V1L8%4N6K6i4K6u0r3N6$3W2F1x3K6u0Q4x3V1k6S2M7r3W2Q4x3V1k6%4K9h3&6@1k6i4u0F1L8q4)9J5c8X3&6X3i4K6u0V1N6$3W2F1N6r3g2J5L8X3I4Q4x3X3c8F1N6s2q4#2k6i4u0&6M7%4W2K6N6r3g2E0K9h3&6X3L8%4u0E0j5i4c8A6L8$3^5`.">NtQuerySystemInformation 函数 (winternl.h) - Win32 apps | Microsoft Learn</a>)在文档中找到`SYSTEM_PROCESS_INFORMATION`

**SYSTEM_PROCESS_INFORMATION** 算是半公开的结构体，直接查微软文档他会有一些保留字段显示Reserved，可以使用SourceInsight查看WRK1.2的源码观察他。

SourceInsight官网:	562K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6%4N6%4N6Q4x3X3g2K6L8%4g2J5j5$3g2A6L8Y4y4A6k6$3S2@1i4K6u0W2j5$3!0E0i4K6u0r3N6s2u0A6j5h3I4Q4x3V1j5`.

WRK1.2下载:	21aK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6S2P5i4W2#2j5$3g2V1k6h3#2A6M7X3u0S2M7#2)9J5c8W2N6A6L8X3c8G2N6%4y4Q4x3X3c8d9k6i4y4W2j5i4u0U0K9q4)9J5k6p5E0W2M7X3&6W2L8q4)9J5k6q4N6d9d9#2)9J5k6l9`.`.

看一下这个结构体，想要什么自己说（狗头

![./images/image-20250715205947789](./upload/attach/202507/1003898_AUS4USYX2EPVBBJ.png)

微软自己也会使用这些API，所以直接抄他代码就行。WRK1.2中搜索`PerInfoProcessRundown`与`PerfInfoSysModuleRunDown`。文末代码中遍历模块使用了这些API

注意![./images/image-20250715214924638](./upload/attach/202507/1003898_B4U7F35FNY9EXTR.png)
高版本看NT开头的函数

## 数据流动

都是第一次获取数量，申请缓冲区，第二次获取数据。你直接申请巨大缓冲区也行。

```
进程遍历流程
R3                    		R0
│                           │
├─1. UI响应             ─────┤
├─2. ProcessGetCount()调用──┤
├─3. DeviceIoControl────────►│
│   [CTL_ENUM_PROCESS_COUNT] ├─4. EnumProcessEx第一次调用
│                           │   ├─ GetCurrentEprocess()获取起始进程
│                           │   │   ├─ mov eax, fs:[0x124] 获取ETHREAD
│                           │   │   └─ mov eax, [eax + 0x44/0x150] 获取EPROCESS
│                           │   ├─ 遍历ActiveProcessLinks双向链表
│                           │   │   ├─ 只统计进程数量，不提取数据
│                           │   │   ├─ 获取Flink指针: *(CurrentProcess + 0x88/0xB8)
│                           │   │   └─ 计算下一个EPROCESS: Flink - 0x88/0xB8
│                           │   └─ 返回进程总数
│◄─5. 返回[进程数量]────────┤
├─6. ProcessGetVec()调用────┤
├─7. DeviceIoControl────────►│
│   [CTL_ENUM_PROCESS]       ├─8. 分配PROCESS_INFO数组缓冲区
│                           ├─9. EnumProcessEx第二次调用
│                           │   ├─ 参数: (buffer, false, &processCount)
│                           │   ├─ 重复相同的链表遍历过程
│                           │   ├─ 但这次提取并填充进程信息：
│                           │   │   ├─ ProcessId: *(EPROCESS + 0x84/0xB4)
│                           │   │   ├─ ParentProcessId: *(EPROCESS + 0x14C/0x140)
│                           │   │   ├─ DirectoryTableBase: *(EPROCESS + 0x18)
│                           │   │   ├─ ImageFileName: RtlCopyMemory(EPROCESS + 0x174/0x16C)
│                           │   │   └─ EprocessAddr: EPROCESS指针本身
│                           │   └─ 将数据复制到SystemBuffer
│                           ├─10. 转换为PROCESS_INFO格式
│◄─11. 返回[PROCESS_INFO数组]┤
```

```
内核模块遍历流程
R3                    		R0
│                           │
├─1. UI响应			  ─────┤
├─2. ModuleGetCount()调用───┤
├─3. DeviceIoControl────────►│
│   [CTL_ENUM_MODULE_COUNT]  ├─4. ZwQuerySystemInformation第一次调用
│                           │   ├─ SystemInformationClass = SystemModuleInformation
│◄─5. 返回[模块数量]────────┤
├─6. ModuleGetVec()调用─────┤
├─7. DeviceIoControl────────►│
│   [CTL_ENUM_MODULE]       ├─8. 分配足够大小的缓冲区
│                           ├─9. ZwQuerySystemInformation第二次调用
│                           │   ├─ 传入充足的缓冲区
│                           │   ├─ 获取SYSTEM_MODULE_INFORMATION数组
│                           │   └─ 解析每个模块信息：
│                           │       ├─ ImageBase (模块基址)
│                           │       ├─ ImageSize (模块大小)  
│                           │       ├─ FullPathName (完整路径)
│                           │       └─ 提取模块名 (路径最后部分)
│                           ├─10. 转换为MODULE_INFO格式
│◄─11. 返回[MODULE_INFO数组]─┤
```

## 效果图和代码

这里没有处理头节点？ 有个空的
 ![图片描述](upload/attach/202507/1003898_XVYZS6WEDCT88YX.webp)
遍历模块列表，看到了一堆sys
 ![图片描述](upload/attach/202507/1003898_DAKM7E5M4K9XPYW.webp)

**遍历进程的代码** 检测Windows版本手动设置偏移量 然后遍历`ActiveProcessLinks`拿进程信息

```c++
//R0的

ULONG g_WindowsVersion = 0;  //windows版本
ENUM_PROCESS_OFFSETS g_ProcessOffsets;

enum WindowsVersion
{
    WinXP,
    Win7,
    Other
};

//检测windows版本 设置到全局变量
NTSTATUS DetectWindowsVersion()
{
    RTL_OSVERSIONINFOW versionInfo = { 0 };
    versionInfo.dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOW);
    NTSTATUS status = RtlGetVersion(&versionInfo);
    if (!NT_SUCCESS(status)) {
        return status;
    }

if (versionInfo.dwMajorVersion == 5) {
        g_WindowsVersion = WinXP;
        KdPrint(("[test] Version: WinXP\n"));
    }
    else if (versionInfo.dwMajorVersion == 6 && versionInfo.dwMinorVersion == 1) {
        g_WindowsVersion = Win7;
        KdPrint(("[test] Version: Win7\n"));
    }
    else {
        KdPrint(("[test] Version: Other\n"));
        return STATUS_NOT_SUPPORTED;
    }

return STATUS_SUCCESS;
}

// 解析进程需要的偏移量
typedef struct ENUM_PROCESS_OFFSETS {
    ULONG EThreadToProcess;     // ETHREAD -> EPROCESS 偏移
    ULONG ProcessId;           // UniqueProcessId 偏移
    ULONG ActiveProcessLinks;  // ActiveProcessLinks 偏移  
    ULONG ParentProcessId;     // InheritedFromUniqueProcessId 偏移
    ULONG ImageFileName;       // ImageFileName 偏移
    ULONG DirectoryTableBase;  // CR3 偏移
}*PENUM_PROCESS_OFFSETS;

// 这里可以看下各个版本的偏移
NTSTATUS InitProcessOffsets() {
    if (g_WindowsVersion == WinXP) {
        g_ProcessOffsets.EThreadToProcess = 0x44;

g_ProcessOffsets.ProcessId = 0x84;
        g_ProcessOffsets.ActiveProcessLinks = 0x88;
        g_ProcessOffsets.ParentProcessId = 0x14C;
        g_ProcessOffsets.ImageFileName = 0x174;
        g_ProcessOffsets.DirectoryTableBase = 0x18;
    }
    else if (g_WindowsVersion == Win7) {
        g_ProcessOffsets.EThreadToProcess = 0x150;

g_ProcessOffsets.ProcessId = 0xB4;
        g_ProcessOffsets.ActiveProcessLinks = 0xB8;
        g_ProcessOffsets.ParentProcessId = 0x140;
        g_ProcessOffsets.ImageFileName = 0x16C;
        g_ProcessOffsets.DirectoryTableBase = 0x18;
    }

return STATUS_SUCCESS;
}

PEPROCESS GetCurrentEprocess() {
    PEPROCESS Process = NULL;

__asm {
        mov eax, fs: [0x124]                    //ETHREAD
        mov ebx, g_ProcessOffsets.EThreadToProcess     // 0x44  或 0x150
        mov eax, [eax + ebx]                    // ETHREAD.ThreadsProcess
        mov Process, eax
    }

return Process;
}

//onlyGetCount判断 获取进程数量还是遍历进程数据。
//如果只需要判断数量,我会传processBuffer为NULL。
NTSTATUS EnumProcessEx(PPROCESS_INFO processBuffer, bool onlyGetCount, PULONG processCount) {
    PEPROCESS CurrentProcess = NULL;
    PEPROCESS StartProcess = NULL;//记录开始的进程避免循环 双向链表
    ULONG Counter = 0;

__try {
        StartProcess = GetCurrentEprocess();
        CurrentProcess = StartProcess;

KdPrint(("[test] 开始遍历进程，起始EPROCESS: %p\n", CurrentProcess));

do {
            // 如果需要拿进程数据
            if (!onlyGetCount&& processBuffer!=NULL) {
                PPROCESS_INFO pInfo = &processBuffer[Counter];
                RtlZeroMemory(pInfo, sizeof(PROCESS_INFO));

// 提取进程信息 
                pInfo->ProcessId = *(PULONG)((PUCHAR)CurrentProcess + g_ProcessOffsets.ProcessId);
                pInfo->ParentProcessId = *(PULONG)((PUCHAR)CurrentProcess + g_ProcessOffsets.ParentProcessId);
                pInfo->EprocessAddr = CurrentProcess;
                pInfo->DirectoryTableBase = *(PULONG)((PUCHAR)CurrentProcess + g_ProcessOffsets.DirectoryTableBase);

// 复制进程名
                PUCHAR ImageFileName = (PUCHAR)CurrentProcess + g_ProcessOffsets.ImageFileName;
                RtlCopyMemory(pInfo->ImageFileName, ImageFileName, 16);
                pInfo->ImageFileName[15] = '\0';

KdPrint(("[test] 进程[%d]: PID=%d, Name=%s, EPROCESS=%p\n",
                    Counter, pInfo->ProcessId, pInfo->ImageFileName, CurrentProcess));
            }

Counter++;

//下一个进程
            PULONG ActiveProcessLinksPtr = (PULONG)((PUCHAR)CurrentProcess + g_ProcessOffsets.ActiveProcessLinks);
            ULONG NextLinkAddress = *ActiveProcessLinksPtr;  // 获取Flink
            CurrentProcess = (PEPROCESS)(NextLinkAddress - g_ProcessOffsets.ActiveProcessLinks);  // 减去偏移得到EPROCESS地址

} while (CurrentProcess != StartProcess && Counter < 1000);//怕无限循环

*processCount = Counter;
        KdPrint(("[test] 遍历完成，总共找到 %d 个进程\n", Counter));

return STATUS_SUCCESS;

}
    __except (EXCEPTION_EXECUTE_HANDLER) {
        KdPrint(("[test] err EnumerateProcessCount \n"));
        return STATUS_UNSUCCESSFUL;
    }
}

//DispatchDeviceControl中
    case CTL_ENUM_PROCESS_COUNT:
    {
        ULONG processCount = 0;
        status = EnumProcessEx(NULL, true, &processCount); 
        if (NT_SUCCESS(status)) {
            *(PULONG)Irp->AssociatedIrp.SystemBuffer = processCount;
            info = sizeof(ULONG);
            KdPrint(("[test] CTL_ENUM_PROCESS_COUNT: %d 个进程\n", processCount));
        }
    }
    break;
    case CTL_ENUM_PROCESS:
    {
        ULONG processCount = 0;
        status = EnumProcessEx((PPROCESS_INFO)Irp->AssociatedIrp.SystemBuffer,
            false, &processCount);
        if (NT_SUCCESS(status)) {
            info = processCount * sizeof(PROCESS_INFO);
            KdPrint(("[test] CTL_ENUM_PROCESS: 返回 %d 个进程信息\n", processCount));
        }
    }
    break;

```

```c++
//R3的

DWORD ArkR3::ProcessGetCount()
{
    DWORD dwBytes;
    DWORD dwEntryNum = NULL;

DeviceIoControl(m_hDriver, CTL_ENUM_PROCESS_COUNT, NULL, NULL, &dwEntryNum, sizeof(DWORD), &dwBytes, NULL);

return dwEntryNum;
}

std::vector<PROCESS_INFO> ArkR3::ProcessGetVec(DWORD processCount)
{
 DWORD dwRetBytes;
 DWORD dwBufferSize = sizeof(PROCESS_INFO) * processCount;
 PPROCESS_INFO pEntryInfo = (PPROCESS_INFO)malloc(dwBufferSize);
 BOOL bResult = DeviceIoControl(m_hDriver, CTL_ENUM_PROCESS, NULL, NULL, pEntryInfo, dwBufferSize, &dwRetBytes, NULL);

ProcVec_.clear();
 
 DWORD Count = 0;
 if (bResult) {
 Count = dwRetBytes / sizeof(PROCESS_INFO);
 for (DWORD i = 0; i < Count; i++) {
 PROCESS_INFO pInfo = pEntryInfo[i]; 
 ProcVec_.emplace_back(pInfo);

Log("ProcessGetVec 进程[%d]: PID=%d, 父PID=%d, 名称=%s, EPROCESS=%p\n",
                i, pInfo.ProcessId, pInfo.ParentProcessId,
                pInfo.ImageFileName, pInfo.EprocessAddr);
        }
    }
    
    free(pEntryInfo);

return ProcVec_;
}

```

**遍历模块的代码** 直接调用API

```c++
//.h

typedef struct PROCESS_INFO {
    ULONG ProcessId;                    // 进程ID
    ULONG ParentProcessId;              // 父进程ID
    CHAR ImageFileName[16];             // 进程名称（短名）
    PVOID EprocessAddr;                 // EPROCESS地址
    ULONG DirectoryTableBase;           // CR3页目录基地址

}*PPROCESS_INFO;

typedef struct MODULE_INFO {
    CHAR Name[64];                      // 模块名称（短名）
    CHAR FullPath[256];                 // 模块完整路径
    PVOID ImageBase;                    // 模块基地址
    ULONG ImageSize;                    // 模块大小
    USHORT LoadOrderIndex;              // 加载顺序索引
    USHORT LoadCount;                   // 加载计数

//CHAR Company[128];                // 厂商信息（暂时为空，需要解析PE?）
}*PMODULE_INFO;

typedef struct PROCESS_MODULE_REQ {
    HANDLE ProcessId;                   // 目标进程ID
    ULONG ModuleCount;                  // 模块数量（输出参数）
}*PPROCESS_MODULE_REQ;

```

```c++
//R0的

extern "C" //声明API 直接调用
NTSTATUS NTAPI ZwQuerySystemInformation(
    __in SYSTEM_INFORMATION_CLASS SystemInformationClass,
    __out_bcount_opt(SystemInformationLength) PVOID SystemInformation,
    __in ULONG SystemInformationLength,
    __out_opt PULONG ReturnLength
);

NTSTATUS EnumModuleEx(PMODULE_INFO ModuleBuffer, bool CountOnly, PULONG ModuleCount)
{
    NTSTATUS Status;
    PRTL_PROCESS_MODULES Modules;
    PRTL_PROCESS_MODULE_INFORMATION ModuleInfo;
    PVOID Buffer;
    ULONG BufferSize = 4096;
    ULONG ReturnLength;
    ULONG i;
    ULONG Count = 0;

KdPrint(("[test] EnumModuleEx: CountOnly=%d\n", CountOnly));

retry:
    Buffer = ExAllocatePoolWithTag(NonPagedPool, BufferSize, 'MDLE');
    if (!Buffer) {
        return STATUS_NO_MEMORY;
    }

Status = ZwQuerySystemInformation(SystemModuleInformation,
        Buffer,
        BufferSize,
        &ReturnLength
    );

if (Status == STATUS_INFO_LENGTH_MISMATCH) {
        ExFreePool(Buffer);
        BufferSize = ReturnLength;
        goto retry;
    }

if (!NT_SUCCESS(Status)) {
        ExFreePool(Buffer);
        return Status;
    }

Modules = (PRTL_PROCESS_MODULES)Buffer;
    Count = Modules->NumberOfModules;

if (CountOnly) {
        *ModuleCount = Count;
        ExFreePool(Buffer);
        return STATUS_SUCCESS;
    }

// 填充模块信息
 for (i = 0, ModuleInfo = &(Modules->Modules[0]);
 i < Modules->NumberOfModules && ModuleBuffer;
 i++, ModuleInfo++) {
 
 __try {
 // 清空结构体
 RtlZeroMemory(&ModuleBuffer[i], sizeof(MODULE_INFO));
 
 // 提取模块名称（从完整路径中提取文件名）
 CHAR* fileName = (CHAR*)ModuleInfo->FullPathName + ModuleInfo->OffsetToFileName;
 RtlCopyMemory(ModuleBuffer[i].Name, fileName, 
 min(strlen(fileName), sizeof(ModuleBuffer[i].Name) - 1));
 
 // 完整路径
 RtlCopyMemory(ModuleBuffer[i].FullPath, ModuleInfo->FullPathName,
 min(strlen((CHAR*)ModuleInfo->FullPathName), sizeof(ModuleBuffer[i].FullPath) - 1));
 
 // 基地址和大小
 ModuleBuffer[i].ImageBase = ModuleInfo->ImageBase;
 ModuleBuffer[i].ImageSize = ModuleInfo->ImageSize;
 ModuleBuffer[i].LoadOrderIndex = ModuleInfo->LoadOrderIndex;
 ModuleBuffer[i].LoadCount = ModuleInfo->LoadCount;
 
 
 KdPrint(("[test] Module[%d]: Name=%s, Base=%p, Size=0x%X\n",
 i, ModuleBuffer[i].Name, ModuleBuffer[i].ImageBase, ModuleBuffer[i].ImageSize));
 }
 __except (EXCEPTION_EXECUTE_HANDLER) {
 KdPrint(("[test] EnumModuleEx: Exception processing module %d\n", i));
 continue;
 }
 }

*ModuleCount = Count;
    ExFreePool(Buffer);
    return STATUS_SUCCESS;
}

//DispatchDeviceControl中
	case CTL_ENUM_MODULE_COUNT:
    {
        ULONG moduleCount = 0;
        status = EnumModuleEx(NULL, TRUE, &moduleCount);
        if (NT_SUCCESS(status)) {
            *(PULONG)Irp->AssociatedIrp.SystemBuffer = moduleCount;
            info = sizeof(ULONG);
            KdPrint(("[test] CTL_ENUM_MODULE_COUNT: %d 个模块\n", moduleCount));
        }
    }
    break;
    case CTL_ENUM_MODULE:
    {
        ULONG moduleCount = 0;
        status = EnumModuleEx((PMODULE_INFO)Irp->AssociatedIrp.SystemBuffer,
            FALSE, &moduleCount);
        if (NT_SUCCESS(status)) {
            info = moduleCount * sizeof(MODULE_INFO);
            KdPrint(("[test] CTL_ENUM_MODULE: 返回 %d 个模块信息\n", moduleCount));
        }
    }
```

```c++
//R3的

// 获取内核模块数量
DWORD ArkR3::ModuleGetCount()
{
    DWORD dwBytes = 0;
    DWORD dwEntryNum = 0;

DeviceIoControl(m_hDriver, CTL_ENUM_MODULE_COUNT, NULL, NULL, &dwEntryNum, sizeof(DWORD), &dwBytes, NULL);

return dwEntryNum;
}

//获取内核模块信息
std::vector<MODULE_INFO> ArkR3::ModuleGetVec(DWORD moduleCount)
{
 DWORD dwRetBytes;
 DWORD dwBufferSize = sizeof(MODULE_INFO) * moduleCount;
 PMODULE_INFO pEntryInfo = (PMODULE_INFO)malloc(dwBufferSize);
 BOOL bResult = DeviceIoControl(m_hDriver, CTL_ENUM_MODULE, NULL, NULL, pEntryInfo, dwBufferSize, &dwRetBytes, NULL);

MoudleVec_.clear();
 
 DWORD Count = 0;
 if (bResult) {
 Count = dwRetBytes / sizeof(MODULE_INFO);
 for (DWORD i = 0; i < Count; i++) {
 MODULE_INFO mInfo = pEntryInfo[i]; 
 MoudleVec_.emplace_back(mInfo);

Log("ModuleGetVec 模块[%d]: 名称=%s, 基地址=%p, 大小=0x%X, 路径=%s\n",
                i, mInfo.Name, mInfo.ImageBase, mInfo.ImageSize, mInfo.FullPath);
        }
    }

free(pEntryInfo);
    return MoudleVec_;
}
```

## XP下的相关结构体

![img](upload/attach/202507/1003898_M5Z62WGCEUKFNA9.png)

![img](upload/attach/202507/1003898_WRJQ4CRRX22MKKF.png)

![img](upload/attach/202507/1003898_SVRPYF3RP9HWQ6M.png)

![img](upload/attach/202507/1003898_222Z7UXVXQUXAKM.png)

```
0: kd> dt!_EPROCESS
ntdll!_EPROCESS
   +0x000 Pcb              : _KPROCESS  	包含CR3(DirectoryTableBase)
   +0x06c ProcessLock      : _EX_PUSH_LOCK
   +0x070 CreateTime       : _LARGE_INTEGER
   +0x078 ExitTime         : _LARGE_INTEGER
   +0x080 RundownProtect   : _EX_RUNDOWN_REF
   +0x084 UniqueProcessId  : Ptr32 Void  	进程ID (PID)
   +0x088 ActiveProcessLinks : _LIST_ENTRY	进程链表，用于遍历所有进程
   +0x090 QuotaUsage       : [3] Uint4B
   +0x09c QuotaPeak        : [3] Uint4B
   +0x0a8 CommitCharge     : Uint4B
   +0x0ac PeakVirtualSize  : Uint4B
   +0x0b0 VirtualSize      : Uint4B
   +0x0b4 SessionProcessLinks : _LIST_ENTRY
   +0x0bc DebugPort        : Ptr32 Void
   +0x0c0 ExceptionPort    : Ptr32 Void
   +0x0c4 ObjectTable      : Ptr32 _HANDLE_TABLE 句柄表，句柄遍历时需要
   +0x0c8 Token            : _EX_FAST_REF
   +0x0cc WorkingSetLock   : _FAST_MUTEX
   +0x0ec WorkingSetPage   : Uint4B
   +0x0f0 AddressCreationLock : _FAST_MUTEX
   +0x110 HyperSpaceLock   : Uint4B
   +0x114 ForkInProgress   : Ptr32 _ETHREAD
   +0x118 HardwareTrigger  : Uint4B
   +0x11c VadRoot          : Ptr32 Void
   +0x120 VadHint          : Ptr32 Void
   +0x124 CloneRoot        : Ptr32 Void
   +0x128 NumberOfPrivatePages : Uint4B
   +0x12c NumberOfLockedPages : Uint4B
   +0x130 Win32Process     : Ptr32 Void
   +0x134 Job              : Ptr32 _EJOB
   +0x138 SectionObject    : Ptr32 Void
   +0x13c SectionBaseAddress : Ptr32 Void
   +0x140 QuotaBlock       : Ptr32 _EPROCESS_QUOTA_BLOCK
   +0x144 WorkingSetWatch  : Ptr32 _PAGEFAULT_HISTORY
   +0x148 Win32WindowStation : Ptr32 Void
   +0x14c InheritedFromUniqueProcessId : Ptr32 Void 父进程ID (PPID)
   +0x150 LdtInformation   : Ptr32 Void
   +0x154 VadFreeHint      : Ptr32 Void
   +0x158 VdmObjects       : Ptr32 Void
   +0x15c DeviceMap        : Ptr32 Void
   +0x160 PhysicalVadList  : _LIST_ENTRY
   +0x168 PageDirectoryPte : _HARDWARE_PTE_X86
   +0x168 Filler           : Uint8B
   +0x170 Session          : Ptr32 Void
   +0x174 ImageFileName    : [16] UChar  进程名称（最多15字符+null）
   +0x184 JobLinks         : _LIST_ENTRY
   +0x18c LockedPagesList  : Ptr32 Void
   +0x190 ThreadListHead   : _LIST_ENTRY  线程链表头，线程遍历时需要
   +0x198 SecurityPort     : Ptr32 Void
   +0x19c PaeTop           : Ptr32 Void
   +0x1a0 ActiveThreads    : Uint4B  活跃线程数
   +0x1a4 GrantedAccess    : Uint4B
   +0x1a8 DefaultHardErrorProcessing : Uint4B
   +0x1ac LastThreadExitStatus : Int4B
   +0x1b0 Peb              : Ptr32 _PEB  PEB指针，获取进程详细信息时需要
   +0x1b4 PrefetchTrace    : _EX_FAST_REF
   +0x1b8 ReadOperationCount : _LARGE_INTEGER
   +0x1c0 WriteOperationCount : _LARGE_INTEGER
   +0x1c8 OtherOperationCount : _LARGE_INTEGER
   +0x1d0 ReadTransferCount : _LARGE_INTEGER
   +0x1d8 WriteTransferCount : _LARGE_INTEGER
   +0x1e0 OtherTransferCount : _LARGE_INTEGER
   +0x1e8 CommitChargeLimit : Uint4B
   +0x1ec CommitChargePeak : Uint4B
   +0x1f0 AweInfo          : Ptr32 Void
   +0x1f4 SeAuditProcessCreationInfo : _SE_AUDIT_PROCESS_CREATION_INFO
   +0x1f8 Vm               : _MMSUPPORT
   +0x238 LastFaultCount   : Uint4B
   +0x23c ModifiedPageCount : Uint4B
   +0x240 NumberOfVads     : Uint4B
   +0x244 JobStatus        : Uint4B
   +0x248 Flags            : Uint4B
   +0x248 CreateReported   : Pos 0, 1 Bit
   +0x248 NoDebugInherit   : Pos 1, 1 Bit
   +0x248 ProcessExiting   : Pos 2, 1 Bit
   +0x248 ProcessDelete    : Pos 3, 1 Bit
   +0x248 Wow64SplitPages  : Pos 4, 1 Bit
   +0x248 VmDeleted        : Pos 5, 1 Bit
   +0x248 OutswapEnabled   : Pos 6, 1 Bit
   +0x248 Outswapped       : Pos 7, 1 Bit
   +0x248 ForkFailed       : Pos 8, 1 Bit
   +0x248 HasPhysicalVad   : Pos 9, 1 Bit
   +0x248 AddressSpaceInitialized : Pos 10, 2 Bits
   +0x248 SetTimerResolution : Pos 12, 1 Bit
   +0x248 BreakOnTermination : Pos 13, 1 Bit
   +0x248 SessionCreationUnderway : Pos 14, 1 Bit
   +0x248 WriteWatch       : Pos 15, 1 Bit
   +0x248 ProcessInSession : Pos 16, 1 Bit
   +0x248 OverrideAddressSpace : Pos 17, 1 Bit
   +0x248 HasAddressSpace  : Pos 18, 1 Bit
   +0x248 LaunchPrefetched : Pos 19, 1 Bit
   +0x248 InjectInpageErrors : Pos 20, 1 Bit
   +0x248 VmTopDown        : Pos 21, 1 Bit
   +0x248 Unused3          : Pos 22, 1 Bit
   +0x248 Unused4          : Pos 23, 1 Bit
   +0x248 VdmAllowed       : Pos 24, 1 Bit
   +0x248 Unused           : Pos 25, 5 Bits
   +0x248 Unused1          : Pos 30, 1 Bit
   +0x248 Unused2          : Pos 31, 1 Bit
   +0x24c ExitStatus       : Int4B
   +0x250 NextPageColor    : Uint2B
   +0x252 SubSystemMinorVersion : UChar
   +0x253 SubSystemMajorVersion : UChar
   +0x252 SubSystemVersion : Uint2B
   +0x254 PriorityClass    : UChar
   +0x255 WorkingSetAcquiredUnsafe : UChar
   +0x258 Cookie           : Uint4B

```

挖坑，后续补充一下ARK集成DIA2dump解析PDB的方法~

回复或点赞可查看完整内容

传递专业知识、拓宽行业人脉——看雪讲师团队等你加入！！

最后于 2025-7-16 14:56 被X66iaM编辑，原因：

#基础知识 #系统内核 #驱动开发

最新回复 (23)
mb_ypahlgjn 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 1 粉丝 0 关注私信	mb_ypahlgjn 2 楼有偿咨询，怎么联系，给个联系方式 2025-7-16 14:18 0
李翔_702165 雪币： 0 活跃值： (903) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 14 粉丝 0 关注私信	李翔_702165 3 楼感谢分享 2025-7-16 20:56 0
wodexinren 雪币： 74 活跃值： (1173) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 227 粉丝 0 关注私信	wodexinren 4 楼感谢分享 2025-7-17 10:09 0
wx_五角星雪币： 10 活跃值： (1704) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 40 粉丝 0 关注私信	wx_五角星 5 楼感谢分享 2025-7-17 12:05 0
wx_q 雪币： 0 活跃值： (1031) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 46 粉丝 0 关注私信	wx_q 6 楼看下思路 2025-7-17 18:02 0
TkBinary 雪币： 7307 活跃值： (13379) 能力值： (RANK：385 ) 在线值：发帖 26 回帖 533 粉丝 250 关注私信	TkBinary 5 7 楼如果不做ark 简单的做个系统信息查看工具的话. 目前使用 PsLookupProcessByProcessId 去拿信息就行或者说现在使用这个也算是最优解. 因为隐藏进程断链等骚操作在目前PG状态下.都凉凉. 当然一山还有一山高.对抗无止境. 能满足日常80%的需求也可以除非特别需要20%. 但这20%会付出更多. 比如上面的我需要找系统特征码来定位.(更好的是解析pdb) 最后于 2025-7-18 09:51 被TkBinary编辑，原因：错别字 2025-7-18 09:50 0
JAYceMS 雪币： 9125 活跃值： (6361) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 98 粉丝 0 关注私信	JAYceMS 8 楼感谢分享 2025-7-18 10:27 0
mb_umadhuev 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 20 粉丝 0 关注私信	mb_umadhuev 9 楼牛逼 2025-7-18 13:51 0
mb_osuntufu 雪币： 200 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 15 粉丝 0 关注私信	mb_osuntufu 10 楼 very good 2025-7-20 17:42 0
神奇的人鱼雪币： 34 活跃值： (726) 能力值： ( LV2，RANK：15 ) 在线值：发帖 1 回帖 29 粉丝 2 关注私信	神奇的人鱼 11 楼感谢分享 2025-7-31 16:14 0
ShaShen4404 雪币： 469 活跃值： (670) 能力值： ( LV3，RANK：20 ) 在线值：发帖 8 回帖 32 粉丝 14 关注私信	ShaShen4404 12 楼感谢分享 2025-8-3 11:12 0
mb_yalauklc 雪币： 7 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 21 粉丝 0 关注私信	mb_yalauklc 13 楼 mark 2025-8-26 18:27 0
chipower 雪币： 239 活跃值： (323) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 23 粉丝 0 关注私信	chipower 14 楼感谢分享 2025-8-28 18:53 0
byhk 雪币： 2734 活跃值： (8968) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 206 粉丝 1 关注私信	byhk 15 楼谢谢分享 2025-9-19 07:50 0
CreateFile 雪币： 250 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 10 粉丝 0 关注私信	CreateFile 16 楼 123 2025-10-5 13:08 0
wx_我要折断你的旗雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 2 粉丝 0 关注私信	wx_我要折断你的旗 17 楼感谢分享 2025-10-18 17:33 0
mb_dmpagumk 雪币： 205 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 6 粉丝 0 关注私信	mb_dmpagumk 18 楼谢谢分享 2025-12-24 18:50 0
prgasm 雪币： 1 活跃值： (327) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 12 粉丝 0 关注私信	prgasm 19 楼 666 2026-1-5 04:56 0
mb_htgcgule 雪币： 232 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 18 粉丝 0 关注私信	mb_htgcgule 20 楼谢谢分享 2026-1-17 16:56 0
mb_htgcgule 雪币： 232 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 18 粉丝 0 关注私信	mb_htgcgule 21 楼谢谢分享 2026-1-17 16:56 0
wx_小屁孩雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 1 粉丝 0 关注私信	wx_小屁孩 22 楼谢谢分享 2026-5-29 16:55 0
is-SG 雪币： 104 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 25 粉丝 1 关注私信	is-SG 23 楼感谢分享 2026-8-1 22:14 0
Fzzz 雪币： 3691 活跃值： (360) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 62 粉丝 0 关注私信	Fzzz 24 楼 ActiveProcessLinks讲得很清楚 2026-8-26 14:55 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复