前言

本文中涉及结构体的信息依据的是Windows 10 22H2 (2022 Update, Vibranium R5) x64版本中的内容,因os版本不同会和实际情况有差异

进程

每个 进程 都提供执行程序所需的资源。 进程具有虚拟地址空间、可执行代码、系统对象的开放句柄、安全上下文、唯一进程标识符、环境变量、优先级类、最小和最大工作集大小以及至少一个执行线程。 每个进程都使用单个线程(通常称为 主线程)启动,但可以从其任何线程创建其他线程。

线程

线程是进程内可计划执行的实体。 进程的所有线程共享其虚拟地址空间和系统资源。 此外,每个线程都维护异常处理程序、计划优先级、线程本地存储、唯一线程标识符以及系统将用于保存线程上下文的一组结构,直到计划线程上下文为止。 线程上下文包括线程的计算机寄存器集、内核堆栈、线程环境块以及线程进程的地址空间中的用户堆栈。 线程还可以有自己的安全上下文,可用于模拟客户端。

windows内核结构

ntdll

Ntdll.dll是链接用户模式代码和内核模式系统服务的桥梁。对于内核提供的每一个系统服务,该DLL都提供一个相应的存根函数,这些存根函数的名称以“Nt”作为前缀,关于函数前缀:

  • Nt: 这些函数通常是 Windows Native API 的一部分,提供了底层的系统调用接口。这些函数通常用于与操作系统的内部交互,访问系统资源和执行特权操作。例如,NtCreateFileNtReadFile 等。

  • Ps: 这些函数通常属于进程和线程管理模块,用于处理进程和线程相关的操作。例如,PsCreateSystemThreadPsLookupProcessByProcessId 等。

  • Ob: 这些函数通常属于对象管理模块,用于管理内核对象(如进程、线程、文件等)。例如,ObCreateObjectObReferenceObjectByHandle 等。

  • Io: 这些函数通常属于输入输出管理模块,用于处理设备驱动、文件系统和输入输出操作。例如,IoCreateDeviceIoCreateSymbolicLink 等。

  • Ex: 这些函数通常是扩展函数,提供了额外的功能或者是对标准功能的扩展。例如,ExAllocatePoolWithTagExAcquireResourceSharedLite 等。

  • Rtl: 这些函数通常属于运行时库模块,提供了一些常用的运行时支持函数,如字符串操作、内存操作等。例如,RtlCopyMemoryRtlUnicodeStringToAnsiString 等。

  • Zw: 与 Nt 前缀类似,这些函数也属于 Windows Native API,但是它们提供了与 Nt 前缀的函数稍有不同的行为。通常,Zw 前缀的函数会直接返回系统调用的结果,而 Nt 前缀的函数则会进行额外的处理。例如,ZwCreateFileZwReadFile 等。

执行体

执行体是运行在内核模式的一组系统服务子模块集合,是内核的上层部分,构建了 Windows 的大部分内核服务逻辑,执行体API函数接收的参数来自于各种应用程序,因此为了保证系统的安全以及抵抗来自用户模式的恶意攻击,所有的执行体API都必须保证参数的有效性。通常执行体系统服务函数会在其开始处,对所接收的参数逐一探查它们的可访问性

执行体包含以下组件:

  • 进程和线程管理器,负责创建进程和线程,以及终止进程和线程。对于进程和线程的底层支持是在内核层中提供的,执行体在内核层的基础上又添加了一些语义和功能。

  • 内存管理器。此组件提供了虚拟内存功能,既负责系统地址空间的内存管理,又为每个进程提供了一个私有的地址空间,并且也支持进程间的内存共享。

  • 安全引用监视器,该组件强制在本地计算机上实施安全策略,守护操作系统的资源,执行对象的保护和审计。

  • I/O管理器。实现与设备无关的输入和输出功能,负责将I/O请求分发给争取的设备驱动程序以便进一步处理。

  • 缓存管理器。为文件系统提供统一的数据缓存执行,允许文件系统驱动程序将磁盘上的数据映射到内存中,并通过内存管理器来协调物理内存的分配。

  • 配置管理器。负责系统注册表的实现和管理。

  • 即插即用管理器。负责列举设备,并为每个列举到的设备确定哪些驱动程序是必须的,然后加载并初始化这些驱动程序。当它检测到系统中的设备变化时,负责发送合适的事件通知。

  • 电源管理器。负责协调电源事件,向设备驱动程序发送电源I/O通知。

内核

它是内核模块ntoskrnl.exe下层部分(上层为执行体),最接近HAL层,负责线程调度中断、异常的处理。对于多处理器系统,它还负责同步处理器之间的行为,以优化系统的性能。

硬件抽象层

硬件抽象层(Hardware Abstraction Layer,HAL),这一层把所有与硬件相关联的代码逻辑隔离到一个专门的模块中,为操作系统的上层提供一个抽象的、一致的硬件资源模型。这使得上层的模块无须考虑硬件的差异,它们通过HAL而不是直接访问硬件。

在Windows中,HAL是一个独立的动态链接库。HAL提供了一些例程供其他内核模块或设备驱动程序调用,这使得一个驱动程序可以支持同样的设备在各种硬件平台上运行。HAL不仅涵盖了处理器的体系结构,也涉及了中断控制器、单处理器或多处理器等硬件条件。

进程数据结构

PEB

进程环境模块(process environment block),位于用户态,每个进程对应一个,PEB 由内核创建,它主要包含提供诸如已加载模块、进程参数、环境变量等信息的字段。

//0x7c8 bytes (sizeof)
struct _PEB
{
    UCHAR InheritedAddressSpace;                                            //0x0   // 是否继承父进程地址空间
    UCHAR ReadImageFileExecOptions;                                         //0x1   // 控制映像执行选项读取行为
    UCHAR BeingDebugged;                                                    //0x2   // 进程是否被调试器附加 (1=被调试)
    union
    {
        UCHAR BitField;                                                     //0x3   // 位标志组合
        struct
        {
            UCHAR ImageUsesLargePages:1;                                    //0x3   // 是否使用大内存页加载映像
            UCHAR IsProtectedProcess:1;                                     //0x3   // 是否为受保护进程
            UCHAR IsImageDynamicallyRelocated:1;                            //0x3   // 映像是否动态重定位
            UCHAR SkipPatchingUser32Forwarders:1;                           //0x3   // 是否跳过user32转发器修补
            UCHAR IsPackagedProcess:1;                                      //0x3   // 是否为UWP应用容器进程
            UCHAR IsAppContainer:1;                                         //0x3   // 是否在AppContainer沙箱中运行
            UCHAR IsProtectedProcessLight:1;                                //0x3   // 是否为轻量受保护进程
            UCHAR IsLongPathAwareProcess:1;                                 //0x3   // 是否支持长路径
        };
    };
    UCHAR Padding0[4];                                                      //0x4   // 结构对齐填充
    VOID* Mutant;                                                           //0x8   // 指向进程互斥体对象的指针
    VOID* ImageBaseAddress;                                                 //0x10  // 进程主模块基地址(EXE/DLL)
    struct _PEB_LDR_DATA* Ldr;                                              //0x18  // 指向PEB装载器数据结构的指针
    struct _RTL_USER_PROCESS_PARAMETERS* ProcessParameters;                 //0x20  // 进程启动参数(命令行/环境变量等)
    VOID* SubSystemData;                                                    //0x28  // 子系统专用数据
    VOID* ProcessHeap;                                                      //0x30  // 进程默认堆指针
    struct _RTL_CRITICAL_SECTION* FastPebLock;                              //0x38  // 同步访问PEB的快速锁
    union _SLIST_HEADER* volatile AtlThunkSListPtr;                         //0x40  // ATL thunk列表指针
    VOID* IFEOKey;                                                          //0x48  // 映像文件执行选项注册表键
    union
    {
        ULONG CrossProcessFlags;                                            //0x50  // 跨进程标志位
        struct
        {
            ULONG ProcessInJob:1;                                           //0x50  // 进程是否在作业中
            ULONG ProcessInitializing:1;                                    //0x50  // 进程是否正在初始化
            ULONG ProcessUsingVEH:1;                                        //0x50  // 是否使用向量化异常处理
            ULONG ProcessUsingVCH:1;                                        //0x50  // 是否使用VCH异常处理
            ULONG ProcessUsingFTH:1;                                        //0x50  // 是否使用故障跟踪处理程序
            ULONG ProcessPreviouslyThrottled:1;                             //0x50  // 进程是否曾被限制
            ULONG ProcessCurrentlyThrottled:1;                              //0x50  // 进程当前是否被限制
            ULONG ProcessImagesHotPatched:1;                                //0x50  // 是否应用了热补丁
            ULONG ReservedBits0:24;                                         //0x50  // 保留位
        };
    };
    UCHAR Padding1[4];                                                      //0x54  // 结构对齐填充
    union
    {
        VOID* KernelCallbackTable;                                          //0x58  // 内核回调函数表
        VOID* UserSharedInfoPtr;                                            //0x58  // 用户态共享信息指针
    };
    ULONG SystemReserved;                                                   //0x60  // 系统保留字段
    ULONG AtlThunkSListPtr32;                                               //0x64  // ATL thunk列表指针(32位)
    VOID* ApiSetMap;                                                        //0x68  // API Set映射方案指针
    ULONG TlsExpansionCounter;                                              //0x70  // TLS扩展槽计数器
    UCHAR Padding2[4];                                                      //0x74  // 结构对齐填充
    VOID* TlsBitmap;                                                        //0x78  // TLS位图指针
    ULONG TlsBitmapBits[2];                                                 //0x80  // TLS位图数据
    VOID* ReadOnlySharedMemoryBase;                                         //0x88  // 只读共享内存基址
    VOID* SharedData;                                                       //0x90  // 用户态共享数据页
    VOID** ReadOnlyStaticServerData;                                        //0x98  // 只读服务器数据指针
    VOID* AnsiCodePageData;                                                 //0xa0  // ANSI代码页数据
    VOID* OemCodePageData;                                                  //0xa8  // OEM代码页数据
    VOID* UnicodeCaseTableData;                                             //0xb0  // Unicode大小写转换表
    ULONG NumberOfProcessors;                                               //0xb8  // 系统处理器数量
    ULONG NtGlobalFlag;                                                     //0xbc  // 全局标志(调试/堆检查等)
    union _LARGE_INTEGER CriticalSectionTimeout;                            //0xc0  // 关键段超时时间
    ULONGLONG HeapSegmentReserve;                                           //0xc8  // 堆保留内存大小
    ULONGLONG HeapSegmentCommit;                                            //0xd0  // 堆提交内存大小
    ULONGLONG HeapDeCommitTotalFreeThreshold;                               //0xd8  // 堆释放总阈值
    ULONGLONG HeapDeCommitFreeBlockThreshold;                               //0xe0  // 堆释放块阈值
    ULONG NumberOfHeaps;                                                    //0xe8  // 进程堆数量
    ULONG MaximumNumberOfHeaps;                                             //0xec  // 最大堆数量
    VOID** ProcessHeaps;                                                    //0xf0  // 堆句柄数组指针
    VOID* GdiSharedHandleTable;                                             //0xf8  // GDI共享句柄表
    VOID* ProcessStarterHelper;                                             //0x100 // 进程启动助手函数
    ULONG GdiDCAttributeList;                                               //0x108 // GDI设备上下文属性列表
    UCHAR Padding3[4];                                                      //0x10c // 结构对齐填充
    struct _RTL_CRITICAL_SECTION* LoaderLock;                               //0x110 // 加载器锁指针
    ULONG OSMajorVersion;                                                   //0x118 // 操作系统主版本号
    ULONG OSMinorVersion;                                                   //0x11c // 操作系统次版本号
    USHORT OSBuildNumber;                                                   //0x120 // 操作系统构建号
    USHORT OSCSDVersion;                                                    //0x122 // 操作系统补丁版本号
    ULONG OSPlatformId;                                                     //0x124 // 操作系统平台ID
    ULONG ImageSubsystem;                                                   //0x128 // 映像子系统类型
    ULONG ImageSubsystemMajorVersion;                                       //0x12c // 子系统主版本号
    ULONG ImageSubsystemMinorVersion;                                       //0x130 // 子系统次版本号
    UCHAR Padding4[4];                                                      //0x134 // 结构对齐填充
    ULONGLONG ActiveProcessAffinityMask;                                    //0x138 // 进程亲和性掩码
    ULONG GdiHandleBuffer[60];                                              //0x140 // GDI句柄缓冲区
    VOID (*PostProcessInitRoutine)();                                       //0x230 // 进程初始化后回调函数
    VOID* TlsExpansionBitmap;                                               //0x238 // TLS扩展位图指针
    ULONG TlsExpansionBitmapBits[32];                                       //0x240 // TLS扩展位图数据
    ULONG SessionId;                                                        //0x2c0 // 终端会话ID
    UCHAR Padding5[4];                                                      //0x2c4 // 结构对齐填充
    union _ULARGE_INTEGER AppCompatFlags;                                   //0x2c8 // 应用程序兼容性标志
    union _ULARGE_INTEGER AppCompatFlagsUser;                               //0x2d0 // 用户层兼容性标志
    VOID* pShimData;                                                        //0x2d8 // 应用程序兼容垫片数据
    VOID* AppCompatInfo;                                                    //0x2e0 // 兼容性信息指针
    struct _UNICODE_STRING CSDVersion;                                      //0x2e8 // 服务包版本字符串
    struct _ACTIVATION_CONTEXT_DATA* ActivationContextData;                 //0x2f8 // 激活上下文数据
    struct _ASSEMBLY_STORAGE_MAP* ProcessAssemblyStorageMap;                //0x300 // 进程程序集存储映射
    struct _ACTIVATION_CONTEXT_DATA* SystemDefaultActivationContextData;    //0x308 // 系统默认激活上下文
    struct _ASSEMBLY_STORAGE_MAP* SystemAssemblyStorageMap;                 //0x310 // 系统程序集存储映射
    ULONGLONG MinimumStackCommit;                                           //0x318 // 线程栈最小提交大小
    VOID* SparePointers[4];                                                 //0x320 // 备用指针数组
    ULONG SpareUlongs[5];                                                   //0x340 // 备用ULONG数组
    VOID* WerRegistrationData;                                              //0x358 // Windows错误报告数据
    VOID* WerShipAssertPtr;                                                 //0x360 // WER断言处理指针
    VOID* pUnused;                                                          //0x368 // 保留未使用
    VOID* pImageHeaderHash;                                                 //0x370 // 映像头哈希值
    union
    {
        ULONG TracingFlags;                                                 //0x378 // 跟踪标志位
        struct
        {
            ULONG HeapTracingEnabled:1;                                     //0x378 // 是否启用堆跟踪
            ULONG CritSecTracingEnabled:1;                                  //0x378 // 是否启用关键段跟踪
            ULONG LibLoaderTracingEnabled:1;                                //0x378 // 是否启用库加载器跟踪
            ULONG SpareTracingBits:29;                                      //0x378 // 备用跟踪位
        };
    };
    UCHAR Padding6[4];                                                      //0x37c // 结构对齐填充
    ULONGLONG CsrServerReadOnlySharedMemoryBase;                            //0x380 // CSRSS只读共享内存基址
    ULONGLONG TppWorkerpListLock;                                           //0x388 // 线程池工作线程列表锁
    struct _LIST_ENTRY TppWorkerpList;                                      //0x390 // 线程池工作线程列表头
    VOID* WaitOnAddressHashTable[128];                                      //0x3a0 // 地址等待哈希表
    VOID* TelemetryCoverageHeader;                                          //0x7a0 // 遥测数据头
    ULONG CloudFileFlags;                                                   //0x7a8 // 云文件标志
    ULONG CloudFileDiagFlags;                                               //0x7ac // 云文件诊断标志
    CHAR PlaceholderCompatibilityMode;                                      //0x7b0 // 占位符兼容模式
    CHAR PlaceholderCompatibilityModeReserved[7];                           //0x7b1 // 保留字段
    struct _LEAP_SECOND_DATA* LeapSecondData;                               //0x7b8 // 闰秒数据
    union
    {
        ULONG LeapSecondFlags;                                              //0x7c0 // 闰秒处理标志
        struct
        {
            ULONG SixtySecondEnabled:1;                                     //0x7c0 // 是否启用60秒闰秒
            ULONG Reserved:31;                                              //0x7c0 // 保留位
        };
    };
    ULONG NtGlobalFlag2;                                                    //0x7c4 // 第二全局标志(扩展功能)
};

EPROCESS

EPROCESS是 Windows 内核中的一种对象,用于保存关于一个进程的所有信息,处于内核态,属于执行体,它包含一个指向该进程peb的指针和一个指向kprocess的指针(pcb)。

//0x500 bytes (sizeof)
struct _EPROCESS
{
    struct _KPROCESS Pcb;                                                   //0x0    // 进程控制块(内核部分)
    struct _EX_PUSH_LOCK ProcessLock;                                       //0xe0   // 进程结构锁
    VOID* UniqueProcessId;                                                  //0xe4   // 进程ID (PID)
    struct _LIST_ENTRY ActiveProcessLinks;                                  //0xe8   // 活动进程链表(系统进程链)
    struct _EX_RUNDOWN_REF RundownProtect;                                  //0xf0   // 进程退出保护锁
    VOID* VdmObjects;                                                       //0xf4   // 虚拟DOS机对象
    union
    {
        ULONG Flags2;                                                       //0xf8   // 标志位2
        struct
        {
            ULONG JobNotReallyActive:1;                                     //0xf8   // 作业非活动状态
            ULONG AccountingFolded:1;                                       //0xf8   // 已合并统计
            ULONG NewProcessReported:1;                                     //0xf8   // 新进程已报告
            ULONG ExitProcessReported:1;                                    //0xf8   // 进程退出已报告
            ULONG ReportCommitChanges:1;                                    //0xf8   // 报告提交更改
            ULONG LastReportMemory:1;                                       //0xf8   // 上次报告内存
            ULONG ForceWakeCharge:1;                                        //0xf8   // 强制唤醒计数
            ULONG CrossSessionCreate:1;                                     //0xf8   // 跨会话创建
            ULONG NeedsHandleRundown:1;                                     //0xf8   // 需要句柄清理
            ULONG RefTraceEnabled:1;                                        //0xf8   // 引用跟踪启用
            ULONG PicoCreated:1;                                            //0xf8   // Pico进程创建
            ULONG EmptyJobEvaluated:1;                                      //0xf8   // 空作业已评估
            ULONG DefaultPagePriority:3;                                    //0xf8   // 默认页面优先级
            ULONG PrimaryTokenFrozen:1;                                     //0xf8   // 主令牌冻结
            ULONG ProcessVerifierTarget:1;                                  //0xf8   // 进程验证器目标
            ULONG RestrictSetThreadContext:1;                               //0xf8   // 限制设置线程上下文
            ULONG AffinityPermanent:1;                                      //0xf8   // 亲和性永久设置
            ULONG AffinityUpdateEnable:1;                                   //0xf8   // 允许更新亲和性
            ULONG PropagateNode:1;                                          //0xf8   // 传播NUMA节点
            ULONG ExplicitAffinity:1;                                       //0xf8   // 显式亲和性
            ULONG ProcessExecutionState:2;                                 //0xf8   // 进程执行状态
            ULONG EnableReadVmLogging:1;                                    //0xf8   // 启用读虚拟内存日志
            ULONG EnableWriteVmLogging:1;                                   //0xf8   // 启用写虚拟内存日志
            ULONG FatalAccessTerminationRequested:1;                        //0xf8   // 请求终止致命访问
            ULONG DisableSystemAllowedCpuSet:1;                             //0xf8   // 禁用系统允许CPU集
            ULONG ProcessStateChangeRequest:2;                              //0xf8   // 进程状态变更请求
            ULONG ProcessStateChangeInProgress:1;                           //0xf8   // 进程状态变更中
            ULONG InPrivate:1;                                              //0xf8   // 隐私模式(InPrivate)
        };
    };
    union
    {
        ULONG Flags;                                                        //0xfc   // 进程标志
        struct
        {
            ULONG CreateReported:1;                                         //0xfc   // 创建已报告
            ULONG NoDebugInherit:1;                                         //0xfc   // 禁止调试继承
            ULONG ProcessExiting:1;                                         //0xfc   // 进程正在退出
            ULONG ProcessDelete:1;                                          //0xfc   // 进程待删除
            ULONG ManageExecutableMemoryWrites:1;                           //0xfc   // 管理可执行内存写入
            ULONG VmDeleted:1;                                              //0xfc   // 虚拟内存已删除
            ULONG OutswapEnabled:1;                                         //0xfc   // 允许换出
            ULONG Outswapped:1;                                             //0xfc   // 已换出
            ULONG FailFastOnCommitFail:1;                                   //0xfc   // 提交失败时快速失败
            ULONG Wow64VaSpace4Gb:1;                                        //0xfc   // Wow64使用4GB地址空间
            ULONG AddressSpaceInitialized:2;                                //0xfc   // 地址空间初始化状态
            ULONG SetTimerResolution:1;                                     //0xfc   // 设置定时器分辨率
            ULONG BreakOnTermination:1;                                     //0xfc   // 终止时中断
            ULONG DeprioritizeViews:1;                                      //0xfc   // 视图降级
            ULONG WriteWatch:1;                                             //0xfc   // 写入监视
            ULONG ProcessInSession:1;                                       //0xfc   // 会话中进程
            ULONG OverrideAddressSpace:1;                                   //0xfc   // 覆盖地址空间
            ULONG HasAddressSpace:1;                                        //0xfc   // 拥有地址空间
            ULONG LaunchPrefetched:1;                                       //0xfc   // 预取启动
            ULONG Background:1;                                             //0xfc   // 后台进程
            ULONG VmTopDown:1;                                              //0xfc   // 自顶向下分配虚拟内存
            ULONG ImageNotifyDone:1;                                        //0xfc   // 映像通知完成
            ULONG PdeUpdateNeeded:1;                                        //0xfc   // 需要更新PDE
            ULONG VdmAllowed:1;                                             //0xfc   // 允许VDM
            ULONG ProcessRundown:1;                                         //0xfc   // 进程正在清理
            ULONG ProcessInserted:1;                                        //0xfc   // 进程已插入
            ULONG DefaultIoPriority:3;                                      //0xfc   // 默认I/O优先级
            ULONG ProcessSelfDelete:1;                                      //0xfc   // 进程自删除
            ULONG SetTimerResolutionLink:1;                                 //0xfc   // 定时器分辨率链表
        };
    };
    union _LARGE_INTEGER CreateTime;                                        //0x100  // 进程创建时间
    ULONG ProcessQuotaUsage[2];                                             //0x108  // 进程配额使用量
    ULONG ProcessQuotaPeak[2];                                              //0x110  // 进程配额峰值
    ULONG PeakVirtualSize;                                                  //0x118  // 虚拟大小峰值
    ULONG VirtualSize;                                                      //0x11c  // 当前虚拟大小
    struct _LIST_ENTRY SessionProcessLinks;                                 //0x120  // 会话进程链表
    union
    {
        VOID* ExceptionPortData;                                            //0x128  // 异常端口数据
        ULONG ExceptionPortValue;                                           //0x128  // 异常端口值
        ULONG ExceptionPortState:3;                                         //0x128  // 异常端口状态
    };
    struct _EX_FAST_REF Token;                                              //0x12c  // 进程令牌(快速引用)
    ULONG MmReserved;                                                       //0x130  // 内存管理保留字段
    struct _EX_PUSH_LOCK AddressCreationLock;                               //0x134  // 地址创建锁
    struct _EX_PUSH_LOCK PageTableCommitmentLock;                           //0x138  // 页表提交锁
    struct _ETHREAD* RotateInProgress;                                      //0x13c  // 旋转中线程
    struct _ETHREAD* ForkInProgress;                                        //0x140  // fork中线程
    struct _EJOB* volatile CommitChargeJob;                                 //0x144  // 提交计费作业
    struct _RTL_AVL_TREE CloneRoot;                                         //0x148  // 克隆AVL树根
    volatile ULONG NumberOfPrivatePages;                                    //0x14c  // 私有页数量
    volatile ULONG NumberOfLockedPages;                                     //0x150  // 锁定页数量
    VOID* Win32Process;                                                     //0x154  // Win32k进程结构
    struct _EJOB* volatile Job;                                             //0x158  // 作业对象
    VOID* SectionObject;                                                    //0x15c  // 映像区段对象
    VOID* SectionBaseAddress;                                               //0x160  // 映像基地址
    ULONG Cookie;                                                           //0x164  // 安全Cookie
    struct _PAGEFAULT_HISTORY* WorkingSetWatch;                             //0x168  // 工作集监视点
    VOID* Win32WindowStation;                                               //0x16c  // Win32窗口站
    VOID* InheritedFromUniqueProcessId;                                     //0x170  // 父进程PID
    VOID* LdtInformation;                                                   //0x174  // LDT信息
    volatile ULONG OwnerProcessId;                                          //0x178  // 所有者进程ID
    struct _PEB* Peb;                                                       //0x17c  // 进程环境块(PEB)
    struct _MM_SESSION_SPACE* Session;                                      //0x180  // 会话空间
    VOID* Spare1;                                                           //0x184  // 保留字段1
    struct _EPROCESS_QUOTA_BLOCK* QuotaBlock;                               //0x188  // 配额块
    struct _HANDLE_TABLE* ObjectTable;                                      //0x18c  // 句柄表
    VOID* DebugPort;                                                        //0x190  // 调试端口
    VOID* PaeTop;                                                           //0x194  // PAE页目录
    VOID* DeviceMap;                                                        //0x198  // 设备映射
    VOID* EtwDataSource;                                                    //0x19c  // ETW数据源
    ULONGLONG PageDirectoryPte;                                             //0x1a0  // 页目录PTE
    struct _FILE_OBJECT* ImageFilePointer;                                  //0x1a8  // 映像文件对象
    UCHAR ImageFileName[15];                                                //0x1ac  // 映像文件名
    UCHAR PriorityClass;                                                    //0x1bb  // 进程优先级
    VOID* SecurityPort;                                                     //0x1bc  // LSA安全端口
    struct _SE_AUDIT_PROCESS_CREATION_INFO SeAuditProcessCreationInfo;      //0x1c0  // 审计信息
    struct _LIST_ENTRY JobLinks;                                            //0x1c4  // 作业链表
    VOID* HighestUserAddress;                                               //0x1cc  // 用户空间最高地址
    struct _LIST_ENTRY ThreadListHead;                                      //0x1d0  // 线程链表头
    volatile ULONG ActiveThreads;                                           //0x1d8  // 活动线程数
    ULONG ImagePathHash;                                                    //0x1dc  // 映像路径哈希
    ULONG DefaultHardErrorProcessing;                                       //0x1e0  // 默认错误处理模式
    LONG LastThreadExitStatus;                                              //0x1e4  // 最后线程退出状态
    struct _EX_FAST_REF PrefetchTrace;                                      //0x1e8  // 预取跟踪
    VOID* LockedPagesList;                                                  //0x1ec  // 锁定页面列表
    union _LARGE_INTEGER ReadOperationCount;                                //0x1f0  // 读操作计数
    union _LARGE_INTEGER WriteOperationCount;                               //0x1f8  // 写操作计数
    union _LARGE_INTEGER OtherOperationCount;                               //0x200  // 其他操作计数
    union _LARGE_INTEGER ReadTransferCount;                                 //0x208  // 读传输字节数
    union _LARGE_INTEGER WriteTransferCount;                                //0x210  // 写传输字节数
    union _LARGE_INTEGER OtherTransferCount;                                //0x218  // 其他传输字节数
    ULONG CommitChargeLimit;                                                //0x220  // 提交内存限制
    volatile ULONG CommitCharge;                                            //0x224  // 当前提交内存
    volatile ULONG CommitChargePeak;                                        //0x228  // 提交内存峰值
    struct _MMSUPPORT_FULL Vm;                                              //0x240  // 虚拟内存支持结构
    struct _LIST_ENTRY MmProcessLinks;                                      //0x340  // 内存管理进程链表
    ULONG ModifiedPageCount;                                                //0x348  // 修改页计数
    LONG ExitStatus;                                                        //0x34c  // 进程退出状态
    struct _RTL_AVL_TREE VadRoot;                                           //0x350  // VAD树根
    VOID* VadHint;                                                          //0x354  // VAD搜索提示
    ULONG VadCount;                                                         //0x358  // VAD数量
    volatile ULONG VadPhysicalPages;                                        //0x35c  // VAD物理页数
    ULONG VadPhysicalPagesLimit;                                            //0x360  // VAD物理页限制
    struct _ALPC_PROCESS_CONTEXT AlpcContext;                               //0x364  // ALPC上下文
    struct _LIST_ENTRY TimerResolutionLink;                                 //0x374  // 定时器分辨率链表
    struct _PO_DIAG_STACK_RECORD* TimerResolutionStackRecord;               //0x37c  // 定时器栈记录
    ULONG RequestedTimerResolution;                                         //0x380  // 请求的定时器分辨率
    ULONG SmallestTimerResolution;                                          //0x384  // 最小定时器分辨率
    union _LARGE_INTEGER ExitTime;                                          //0x388  // 进程退出时间
    ULONG ActiveThreadsHighWatermark;                                       //0x390  // 活动线程峰值
    ULONG LargePrivateVadCount;                                             //0x394  // 大型私有VAD计数
    struct _EX_PUSH_LOCK ThreadListLock;                                    //0x398  // 线程链表锁
    VOID* WnfContext;                                                       //0x39c  // WNF通知上下文
    struct _EJOB* ServerSilo;                                               //0x3a0  // 服务器Silo
    UCHAR SignatureLevel;                                                   //0x3a4  // 代码签名级别
    UCHAR SectionSignatureLevel;                                            //0x3a5  // 区段签名级别
    struct _PS_PROTECTION Protection;                                       //0x3a6  // 进程保护级别
    UCHAR HangCount:3;                                                      //0x3a7  // 挂起计数
    UCHAR GhostCount:3;                                                     //0x3a7  // Ghost计数
    UCHAR PrefilterException:1;                                             //0x3a7  // 异常预过滤
    union
    {
        ULONG Flags3;                                                       //0x3a8  // 标志位3
        struct
        {
            ULONG Minimal:1;                                                //0x3a8  // 最小进程
            ULONG ReplacingPageRoot:1;                                      //0x3a8  // 替换页根
            ULONG Crashed:1;                                                //0x3a8  // 进程已崩溃
            ULONG JobVadsAreTracked:1;                                      //0x3a8  // 跟踪作业VAD
            ULONG VadTrackingDisabled:1;                                    //0x3a8  // 禁用VAD跟踪
            ULONG AuxiliaryProcess:1;                                       //0x3a8  // 辅助进程
            ULONG SubsystemProcess:1;                                       //0x3a8  // 子系统进程
            ULONG IndirectCpuSets:1;                                        //0x3a8  // 间接CPU集
            ULONG RelinquishedCommit:1;                                     //0x3a8  // 已释放提交
            ULONG HighGraphicsPriority:1;                                   //0x3a8  // 高图形优先级
            ULONG CommitFailLogged:1;                                       //0x3a8  // 提交失败已记录
            ULONG ReserveFailLogged:1;                                      //0x3a8  // 保留失败已记录
            ULONG SystemProcess:1;                                          //0x3a8  // 系统进程
            ULONG HideImageBaseAddresses:1;                                 //0x3a8  // 隐藏映像基址
            ULONG AddressPolicyFrozen:1;                                    //0x3a8  // 地址策略冻结
            ULONG ProcessFirstResume:1;                                     //0x3a8  // 进程首次恢复
            ULONG ForegroundExternal:1;                                     //0x3a8  // 外部前台进程
            ULONG ForegroundSystem:1;                                       //0x3a8  // 系统前台进程
            ULONG HighMemoryPriority:1;                                     //0x3a8  // 高内存优先级
            ULONG EnableProcessSuspendResumeLogging:1;                      //0x3a8  // 启用作业挂起/恢复日志
            ULONG EnableThreadSuspendResumeLogging:1;                       //0x3a8  // 启用线程挂起/恢复日志
            ULONG SecurityDomainChanged:1;                                  //0x3a8  // 安全域已更改
            ULONG SecurityFreezeComplete:1;                                 //0x3a8  // 安全冻结完成
            ULONG VmProcessorHost:1;                                        //0x3a8  // 虚拟机处理器主机
            ULONG VmProcessorHostTransition:1;                              //0x3a8  // 虚拟机处理器主机转换
            ULONG AltSyscall:1;                                             //0x3a8  // 备用系统调用
            ULONG TimerResolutionIgnore:1;                                  //0x3a8  // 忽略定时器分辨率
            ULONG DisallowUserTerminate:1;                                  //0x3a8  // 禁止用户终止
        };
    };
    LONG DeviceAsid;                                                        //0x3ac  // 设备ASID
    VOID* SvmData;                                                          //0x3b0  // SVM数据
    struct _EX_PUSH_LOCK SvmProcessLock;                                    //0x3b4  // SVM进程锁
    ULONG SvmLock;                                                          //0x3b8  // SVM锁
    struct _LIST_ENTRY SvmProcessDeviceListHead;                            //0x3bc  // SVM设备链表头
    ULONGLONG LastFreezeInterruptTime;                                      //0x3c8  // 最后冻结中断时间
    struct _PROCESS_DISK_COUNTERS* DiskCounters;                            //0x3d0  // 磁盘计数器
    VOID* PicoContext;                                                      //0x3d4  // Pico上下文
    ULONG HighPriorityFaultsAllowed;                                        //0x3d8  // 允许高优先级缺页
    VOID* InstrumentationCallback;                                          //0x3dc  // 检测回调
    struct _PO_PROCESS_ENERGY_CONTEXT* EnergyContext;                       //0x3e0  // 能源跟踪上下文
    VOID* VmContext;                                                        //0x3e4  // 虚拟机上下文
    ULONGLONG SequenceNumber;                                               //0x3e8  // 序列号
    ULONGLONG CreateInterruptTime;                                          //0x3f0  // 创建中断时间
    ULONGLONG CreateUnbiasedInterruptTime;                                  //0x3f8  // 无偏创建时间
    ULONGLONG TotalUnbiasedFrozenTime;                                      //0x400  // 总无偏冻结时间
    ULONGLONG LastAppStateUpdateTime;                                       //0x408  // 最后应用状态更新时间
    ULONGLONG LastAppStateUptime:61;                                        //0x410  // 最后应用状态运行时间
    ULONGLONG LastAppState:3;                                               //0x410  // 最后应用状态
    volatile ULONG SharedCommitCharge;                                      //0x418  // 共享提交内存
    struct _EX_PUSH_LOCK SharedCommitLock;                                  //0x41c  // 共享提交锁
    struct _LIST_ENTRY SharedCommitLinks;                                   //0x420  // 共享提交链表
    union
    {
        struct
        {
            ULONG AllowedCpuSets;                                           //0x428  // 允许的CPU集
            ULONG DefaultCpuSets;                                           //0x42c  // 默认CPU集
        };
        struct
        {
            ULONG* AllowedCpuSetsIndirect;                                  //0x428  // 间接允许CPU集
            ULONG* DefaultCpuSetsIndirect;                                  //0x42c  // 间接默认CPU集
        };
    };
    VOID* DiskIoAttribution;                                                //0x430  // 磁盘I/O归属
    VOID* DxgProcess;                                                       //0x434  // DirectX图形进程
    ULONG Win32KFilterSet;                                                  //0x438  // Win32k过滤器集
    union volatile _PS_INTERLOCKED_TIMER_DELAY_VALUES ProcessTimerDelay;     //0x440  // 进程定时器延迟
    volatile ULONG KTimerSets;                                              //0x448  // 内核定时器集
    volatile ULONG KTimer2Sets;                                             //0x44c  // 内核定时器集2
    volatile ULONG ThreadTimerSets;                                         //0x450  // 线程定时器集
    ULONG VirtualTimerListLock;                                             //0x454  // 虚拟定时器链表锁
    struct _LIST_ENTRY VirtualTimerListHead;                                //0x458  // 虚拟定时器链表头
    union
    {
        struct _WNF_STATE_NAME WakeChannel;                                 //0x460  // 唤醒通道
        struct _PS_PROCESS_WAKE_INFORMATION WakeInfo;                       //0x460  // 唤醒信息
    };
    union
    {
        ULONG MitigationFlags;                                              //0x490  // 安全缓解标志
        struct
        {
            ULONG ControlFlowGuardEnabled:1;                                //0x490  // CFG启用
            ULONG ControlFlowGuardExportSuppressionEnabled:1;               //0x490  // CFG导出抑制
            ULONG ControlFlowGuardStrict:1;                                 //0x490  // CFG严格模式
            ULONG DisallowStrippedImages:1;                                 //0x490  // 禁止剥离映像
            ULONG ForceRelocateImages:1;                                    //0x490  // 强制重定位映像
            ULONG HighEntropyASLREnabled:1;                                 //0x490  // 高熵ASLR
            ULONG StackRandomizationDisabled:1;                             //0x490  // 禁用栈随机化
            ULONG ExtensionPointDisable:1;                                  //0x490  // 禁用扩展点
            ULONG DisableDynamicCode:1;                                     //0x490  // 禁用动态代码
            ULONG DisableDynamicCodeAllowOptOut:1;                          //0x490  // 动态代码禁用允许退出
            ULONG DisableDynamicCodeAllowRemoteDowngrade:1;                 //0x490  // 允许远程降级
            ULONG AuditDisableDynamicCode:1;                                //0x490  // 审计动态代码
            ULONG DisallowWin32kSystemCalls:1;                              //0x490  // 禁止Win32k系统调用
            ULONG AuditDisallowWin32kSystemCalls:1;                         //0x490  // 审计Win32k调用
            ULONG EnableFilteredWin32kAPIs:1;                               //0x490  // 启用过滤的Win32k API
            ULONG AuditFilteredWin32kAPIs:1;                                //0x490  // 审计过滤的Win32k API
            ULONG DisableNonSystemFonts:1;                                  //0x490  // 禁用非系统字体
            ULONG AuditNonSystemFontLoading:1;                              //0x490  // 审计非系统字体
            ULONG PreferSystem32Images:1;                                   //0x490  // 首选System32映像
            ULONG ProhibitRemoteImageMap:1;                                 //0x490  // 禁止远程映像映射
            ULONG AuditProhibitRemoteImageMap:1;                            //0x490  // 审计远程映像映射
            ULONG ProhibitLowILImageMap:1;                                  //0x490  // 禁止低IL映像映射
            ULONG AuditProhibitLowILImageMap:1;                             //0x490  // 审计低IL映像映射
            ULONG SignatureMitigationOptIn:1;                               //0x490  // 签名缓解选择加入
            ULONG AuditBlockNonMicrosoftBinaries:1;                         //0x490  // 审计非微软二进制
            ULONG AuditBlockNonMicrosoftBinariesAllowStore:1;               //0x490  // 允许应用商店二进制
            ULONG LoaderIntegrityContinuityEnabled:1;                       //0x490  // 加载器完整性连续性
            ULONG AuditLoaderIntegrityContinuity:1;                         //0x490  // 审计加载器连续性
            ULONG EnableModuleTamperingProtection:1;                        //0x490  // 启用模块篡改保护
            ULONG EnableModuleTamperingProtectionNoInherit:1;               //0x490  // 篡改保护不继承
            ULONG RestrictIndirectBranchPrediction:1;                       //0x490  // 限制间接分支预测
            ULONG IsolateSecurityDomain:1;                                  //0x490  // 隔离安全域
        } MitigationFlagsValues;
    };
    union
    {
        ULONG MitigationFlags2;                                             //0x494  // 安全缓解标志2
        struct
        {
            ULONG EnableExportAddressFilter:1;                              //0x494  // 启用导出地址过滤
            ULONG AuditExportAddressFilter:1;                               //0x494  // 审计导出地址过滤
            ULONG EnableExportAddressFilterPlus:1;                          //0x494  // 启用增强导出过滤
            ULONG AuditExportAddressFilterPlus:1;                           //0x494  // 审计增强导出过滤
            ULONG EnableRopStackPivot:1;                                    //0x494  // 启用ROP栈枢轴检测
            ULONG AuditRopStackPivot:1;                                     //0x494  // 审计ROP栈枢轴
            ULONG EnableRopCallerCheck:1;                                   //0x494  // 启用ROP调用检查
            ULONG AuditRopCallerCheck:1;                                    //0x494  // 审计ROP调用检查
            ULONG EnableRopSimExec:1;                                       //0x494  // 启用ROP模拟执行
            ULONG AuditRopSimExec:1;                                        //0x494  // 审计ROP模拟执行
            ULONG EnableImportAddressFilter:1;                              //0x494  // 启用导入地址过滤
            ULONG AuditImportAddressFilter:1;                               //0x494  // 审计导入地址过滤
            ULONG DisablePageCombine:1;                                     //0x494  // 禁用页面合并
            ULONG SpeculativeStoreBypassDisable:1;                          //0x494  // 禁用推测存储旁路
            ULONG CetUserShadowStacks:1;                                    //0x494  // 用户态影子栈
            ULONG AuditCetUserShadowStacks:1;                               //0x494  // 审计影子栈
            ULONG AuditCetUserShadowStacksLogged:1;                         //0x494  // 影子栈审计已记录
            ULONG UserCetSetContextIpValidation:1;                          //0x494  // 用户Cet上下文IP验证
            ULONG AuditUserCetSetContextIpValidation:1;                     //0x494  // 审计上下文IP验证
            ULONG AuditUserCetSetContextIpValidationLogged:1;               //0x494  // IP验证审计已记录
            ULONG CetUserShadowStacksStrictMode:1;                          //0x494  // 影子栈严格模式
            ULONG BlockNonCetBinaries:1;                                    //0x494  // 阻止非Cet二进制
            ULONG BlockNonCetBinariesNonEhcont:1;                           //0x494  // 阻止非连续异常处理
            ULONG AuditBlockNonCetBinaries:1;                               //0x494  // 审计非Cet二进制
            ULONG AuditBlockNonCetBinariesLogged:1;                         //0x494  // 非Cet审计已记录
            ULONG Reserved1:1;                                              //0x494  // 保留位1
            ULONG Reserved2:1;                                              //0x494  // 保留位2
            ULONG Reserved3:1;                                              //0x494  // 保留位3
            ULONG Reserved4:1;                                              //0x494  // 保留位4
            ULONG Reserved5:1;                                              //0x494  // 保留位5
            ULONG CetDynamicApisOutOfProcOnly:1;                            //0x494  // Cet动态API仅限进程外
            ULONG UserCetSetContextIpValidationRelaxedMode:1;               //0x494  // 用户CetIP验证宽松模式
        } MitigationFlags2Values;
    };
    VOID* PartitionObject;                                                  //0x498  // 分区对象
    ULONGLONG SecurityDomain;                                               //0x4a0  // 安全域
    ULONGLONG ParentSecurityDomain;                                         //0x4a8  // 父安全域
    VOID* CoverageSamplerContext;                                           //0x4b0  // 覆盖采样上下文
    VOID* MmHotPatchContext;                                                //0x4b4  // 热补丁上下文
    struct _RTL_AVL_TREE DynamicEHContinuationTargetsTree;                  //0x4b8  // 动态异常处理目标树
    struct _EX_PUSH_LOCK DynamicEHContinuationTargetsLock;                  //0x4bc  // 异常处理目标锁
    struct _PS_DYNAMIC_ENFORCED_ADDRESS_RANGES DynamicEnforcedCetCompatibleRanges; //0x4c0  // Cet兼容强制地址范围
    ULONG DisabledComponentFlags;                                           //0x4c8  // 禁用组件标志
    ULONG* volatile PathRedirectionHashes;                                  //0x4cc  // 路径重定向哈希
};

KPROCESS

kprocess被eprocess包含,处于内核态,属于内核,KPROCESS对象中记录的信息主要包括两类:一类跟进程的内存环境相关,比如页目录表、交换状态等;另一类是与其线程相关的一些属性,比如线程列表以及线程所需要的优先级、时限设置等。

// 0x438 bytes (sizeof)
struct _KPROCESS
{
    struct _DISPATCHER_HEADER Header;              // 0x000 调度器通用头(用于等待队列、信号等机制)
    struct _LIST_ENTRY ProfileListHead;            // 0x018 采样分析器列表(如性能分析器使用)
    ULONGLONG DirectoryTableBase;                  // 0x028 页目录基地址(内核地址空间使用)
    struct _LIST_ENTRY ThreadListHead;             // 0x030 链接所有属于该进程的线程列表
    ULONG ProcessLock;                             // 0x040 进程结构的自旋锁(用于同步)
    ULONG ProcessTimerDelay;                       // 0x044 延迟计时器控制字段
    ULONGLONG DeepFreezeStartTime;                 // 0x048 冻结状态开始时间(DeepFreeze 功能)
    struct _KAFFINITY_EX Affinity;                 // 0x050 CPU 亲和性(进程允许在哪些处理器上运行)
    ULONGLONG AffinityPadding[12];                 // 0x0F8 对齐填充,确保结构大小一致
    struct _LIST_ENTRY ReadyListHead;              // 0x158 就绪线程队列头(就绪状态的线程挂这里)
    struct _SINGLE_LIST_ENTRY SwapListEntry;       // 0x168 交换列表项(换出/换入使用)
    volatile struct _KAFFINITY_EX ActiveProcessors;// 0x170 当前活跃使用的处理器掩码
    ULONGLONG ActiveProcessorsPadding[12];         // 0x218 填充对齐
    union                                          
    {
        struct
        {
            ULONG AutoAlignment:1;                // 0x278 自动对齐处理启用
            ULONG DisableBoost:1;                 // 禁用线程优先级提升
            ULONG DisableQuantum:1;               // 禁用时间片
            ULONG DeepFreeze:1;                   // 是否进入 DeepFreeze 状态
            ULONG TimerVirtualization:1;          // 虚拟定时器启用(例如用于容器)
            ULONG CheckStackExtents:1;            // 启用堆栈边界检查
            ULONG CacheIsolationEnabled:1;        // 启用缓存隔离(安全特性)
            ULONG PpmPolicy:3;                    // 电源策略标志
            ULONG VaSpaceDeleted:1;               // 虚拟地址空间已被删除
            ULONG ReservedFlags:21;               // 保留未用
        };
        volatile LONG ProcessFlags;               // 整体标志字段
    };
    ULONG ActiveGroupsMask;                       // 0x27C 当前激活的处理器组掩码(支持多处理器组)
    CHAR BasePriority;                            // 0x280 基本优先级(用于调度器)
    CHAR QuantumReset;                            // 0x281 重置时间片值
    CHAR Visited;                                 // 0x282 调度器用于优化决策的标志
    union _KEXECUTE_OPTIONS Flags;                // 0x283 执行选项(如禁止动态代码等)
    USHORT ThreadSeed[20];                        // 0x284 每组的线程随机种子(调度器用)
    USHORT ThreadSeedPadding[12];                 // 0x2AC 填充对齐
    USHORT IdealProcessor[20];                    // 0x2C4 每组的理想处理器编号
    USHORT IdealProcessorPadding[12];             // 0x2EC 填充对齐
    USHORT IdealNode[20];                         // 0x304 每组的理想 NUMA 节点
    USHORT IdealNodePadding[12];                  // 0x32C 填充对齐
    USHORT IdealGlobalNode;                       // 0x344 全局理想 NUMA 节点
    USHORT Spare1;                                // 0x346 保留字段
    unionvolatile _KSTACK_COUNT StackCount;       // 0x348 活动线程栈计数(堆栈用量管理)
    struct _LIST_ENTRY ProcessListEntry;          // 0x350 KPROCESS 全局链表项(进程枚举)
    ULONGLONG CycleTime;                          // 0x360 累积 CPU 周期时间
    ULONGLONG ContextSwitches;                    // 0x368 上下文切换次数
    struct _KSCHEDULING_GROUP* SchedulingGroup;   // 0x370 调度组指针(用于分组调度)
    ULONG FreezeCount;                            // 0x378 被冻结线程计数
    ULONG KernelTime;                             // 0x37C 累积的内核模式时间(ms)
    ULONG UserTime;                               // 0x380 累积的用户模式时间(ms)
    ULONG ReadyTime;                              // 0x384 线程在就绪状态的时间
    ULONGLONG UserDirectoryTableBase;             // 0x388 用户模式页表基地址(地址隔离)
    UCHAR AddressPolicy;                          // 0x390 地址空间策略(影响内存布局)
    UCHAR Spare2[71];                             // 0x391 保留字段(填充至对齐)
    VOID* InstrumentationCallback;                // 0x3D8 分析/追踪工具的回调指针
    union
    {
        ULONGLONG SecureHandle;                   // 0x3E0 安全进程句柄
        struct
        {
            ULONGLONG SecureProcess:1;            // 是否是安全进程(如 LSASS 等)
            ULONGLONG Unused:1;                   // 未使用位
        } Flags;
    } SecureState;                                // 安全状态联合体
    ULONGLONG KernelWaitTime;                     // 0x3E8 等待时间(在内核模式下等待)
    ULONGLONG UserWaitTime;                       // 0x3F0 等待时间(在用户模式下等待)
    ULONGLONG EndPadding[8];                      // 0x3F8 填充到 0x438 结构末尾
};

线程数据结构

TEB

线程环境模块(thread environment block),位于用户态,每个线程对应一个,它包含了当前线程的相关信息,比如堆栈信息、线程ID、异常处理、TLS(Thread Local Storage)等,它包含一个指向自己进程的peb的指针

//0x1000 bytes (sizeof)
struct _TEB
{
    struct _NT_TIB NtTib;                                                   //0x0    // 线程信息块(包含异常链/堆栈基址等)
    VOID* EnvironmentPointer;                                               //0x1c   // 进程环境块指针
    struct _CLIENT_ID ClientId;                                             //0x20   // 线程ID和进程ID
    VOID* ActiveRpcHandle;                                                  //0x28   // 活动RPC句柄
    VOID* ThreadLocalStoragePointer;                                        //0x2c   // TLS数组指针
    struct _PEB* ProcessEnvironmentBlock;                                   //0x30   // 进程环境块(PEB)指针
    ULONG LastErrorValue;                                                   //0x34   // 线程最后错误码
    ULONG CountOfOwnedCriticalSections;                                     //0x38   // 线程拥有的关键区数量
    VOID* CsrClientThread;                                                  //0x3c   // CSRSS客户端线程指针
    VOID* Win32ThreadInfo;                                                  //0x40   // Win32k线程信息结构
    ULONG User32Reserved[26];                                               //0x44   // User32保留字段
    ULONG UserReserved[5];                                                  //0xac   // 用户保留字段
    VOID* WOW32Reserved;                                                    //0xc0   // WOW64模拟层保留
    ULONG CurrentLocale;                                                    //0xc4   // 当前区域设置标识
    ULONG FpSoftwareStatusRegister;                                         //0xc8   // 浮点软件状态寄存器
    VOID* ReservedForDebuggerInstrumentation[16];                           //0xcc   // 调试器检测保留区
    VOID* SystemReserved1[26];                                              //0x10c  // 系统保留字段1
    CHAR PlaceholderCompatibilityMode;                                      //0x174  // 兼容模式标志
    UCHAR PlaceholderHydrationAlwaysExplicit;                               //0x175  // 显式水合标记
    CHAR PlaceholderReserved[10];                                           //0x176  // 保留字段
    ULONG ProxiedProcessId;                                                 //0x180  // 代理进程ID
    struct _ACTIVATION_CONTEXT_STACK _ActivationStack;                      //0x184  // 激活上下文堆栈
    UCHAR WorkingOnBehalfTicket[8];                                         //0x19c  // 代执行安全凭证
    LONG ExceptionCode;                                                     //0x1a4  // 当前异常代码
    struct _ACTIVATION_CONTEXT_STACK* ActivationContextStackPointer;        //0x1a8  // 激活上下文栈指针
    ULONG InstrumentationCallbackSp;                                        //0x1ac  // 检测回调堆栈指针
    ULONG InstrumentationCallbackPreviousPc;                                //0x1b0  // 检测回调前指令指针
    ULONG InstrumentationCallbackPreviousSp;                                //0x1b4  // 检测回调前堆栈指针
    UCHAR InstrumentationCallbackDisabled;                                  //0x1b8  // 检测回调禁用标志
    UCHAR SpareBytes[23];                                                   //0x1b9  // 备用字节
    ULONG TxFsContext;                                                      //0x1d0  // 事务文件系统上下文
    struct _GDI_TEB_BATCH GdiTebBatch;                                      //0x1d4  // GDI批处理结构(保存绘图调用)
    struct _CLIENT_ID RealClientId;                                         //0x6b4  // 真实客户端ID(用于伪装)
    VOID* GdiCachedProcessHandle;                                           //0x6bc  // GDI缓存进程句柄
    ULONG GdiClientPID;                                                     //0x6c0  // GDI客户端进程ID
    ULONG GdiClientTID;                                                     //0x6c4  // GDI客户端线程ID
    VOID* GdiThreadLocalInfo;                                               //0x6c8  // GDI线程本地信息
    ULONG Win32ClientInfo[62];                                              //0x6cc  // Win32k客户端信息
    VOID* glDispatchTable[233];                                             //0x7c4  // OpenGL分发表
    ULONG glReserved1[29];                                                  //0xb68  // OpenGL保留字段1
    VOID* glReserved2;                                                      //0xbdc  // OpenGL保留字段2
    VOID* glSectionInfo;                                                    //0xbe0  // OpenGL区段信息
    VOID* glSection;                                                        //0xbe4  // OpenGL区段对象
    VOID* glTable;                                                          //0xbe8  // OpenGL函数表
    VOID* glCurrentRC;                                                      //0xbec  // OpenGL当前渲染上下文
    VOID* glContext;                                                        //0xbf0  // OpenGL上下文指针
    ULONG LastStatusValue;                                                  //0xbf4  // 最后NT状态码
    struct _UNICODE_STRING StaticUnicodeString;                             //0xbf8  // 静态Unicode字符串缓存
    WCHAR StaticUnicodeBuffer[261];                                         //0xc00  // 静态Unicode字符串缓冲区
    VOID* DeallocationStack;                                                //0xe0c  // 堆栈释放边界
    VOID* TlsSlots[64];                                                     //0xe10  // TLS槽位数组
    struct _LIST_ENTRY TlsLinks;                                            //0xf10  // TLS链表节点
    VOID* Vdm;                                                              //0xf18  // 虚拟DOS机信息
    VOID* ReservedForNtRpc;                                                 //0xf1c  // RPC子系统保留
    VOID* DbgSsReserved[2];                                                 //0xf20  // 调试子系统保留
    ULONG HardErrorMode;                                                    //0xf28  // 严重错误处理模式
    VOID* Instrumentation[9];                                               //0xf2c  // 检测回调指针数组
    struct _GUID ActivityId;                                                //0xf50  // ETW活动ID
    VOID* SubProcessTag;                                                    //0xf60  // 子进程标记
    VOID* PerflibData;                                                      //0xf64  // 性能计数器数据
    VOID* EtwTraceData;                                                     //0xf68  // ETW跟踪数据
    VOID* WinSockData;                                                      //0xf6c  // WinSock数据
    ULONG GdiBatchCount;                                                    //0xf70  // GDI批处理计数
    union
    {
        struct _PROCESSOR_NUMBER CurrentIdealProcessor;                     //0xf74  // 当前理想处理器
        ULONG IdealProcessorValue;                                          //0xf74  // 理想处理器值
        struct
        {
            UCHAR ReservedPad0;                                             //0xf74  // 填充字节0
            UCHAR ReservedPad1;                                             //0xf75  // 填充字节1
            UCHAR ReservedPad2;                                             //0xf76  // 填充字节2
            UCHAR IdealProcessor;                                           //0xf77  // 理想处理器编号
        };
    };
    ULONG GuaranteedStackBytes;                                             //0xf78  // 保证堆栈大小
    VOID* ReservedForPerf;                                                  //0xf7c  // 性能分析保留
    VOID* ReservedForOle;                                                   //0xf80  // OLE保留
    ULONG WaitingOnLoaderLock;                                              //0xf84  // 加载器锁等待计数
    VOID* SavedPriorityState;                                               //0xf88  // 保存的优先级状态
    ULONG ReservedForCodeCoverage;                                          //0xf8c  // 代码覆盖保留
    VOID* ThreadPoolData;                                                   //0xf90  // 线程池数据
    VOID** TlsExpansionSlots;                                               //0xf94  // TLS扩展槽指针
    ULONG MuiGeneration;                                                    //0xf98  // 多语言UI生成标识
    ULONG IsImpersonating;                                                  //0xf9c  // 线程伪装状态
    VOID* NlsCache;                                                         //0xfa0  // NLS缓存指针
    VOID* pShimData;                                                        //0xfa4  // 兼容垫片数据
    ULONG HeapData;                                                         //0xfa8  // 堆管理数据
    VOID* CurrentTransactionHandle;                                         //0xfac  // 当前事务句柄
    struct _TEB_ACTIVE_FRAME* ActiveFrame;                                  //0xfb0  // 活动帧指针
    VOID* FlsData;                                                          //0xfb4  // 纤程本地存储数据
    VOID* PreferredLanguages;                                               //0xfb8  // 首选语言列表
    VOID* UserPrefLanguages;                                                //0xfbc  // 用户偏好语言
    VOID* MergedPrefLanguages;                                              //0xfc0  // 合并语言列表
    ULONG MuiImpersonation;                                                 //0xfc4  // 多语言UI伪装标志
    union
    {
        volatile USHORT CrossTebFlags;                                      //0xfc8  // 跨TEB标志
        USHORT SpareCrossTebBits:16;                                        //0xfc8  // 备用位
    };
    union
    {
        USHORT SameTebFlags;                                                //0xfca  // TEB内部标志
        struct
        {
            USHORT SafeThunkCall:1;                                         //0xfca  // 安全Thunk调用
            USHORT InDebugPrint:1;                                          //0xfca  // 在调试输出中
            USHORT HasFiberData:1;                                          //0xfca  // 包含纤程数据
            USHORT SkipThreadAttach:1;                                      //0xfca  // 跳过线程附加
            USHORT WerInShipAssertCode:1;                                   //0xfca  // WER在断言代码中
            USHORT RanProcessInit:1;                                        //0xfca  // 已执行进程初始化
            USHORT ClonedThread:1;                                          //0xfca  // 克隆线程
            USHORT SuppressDebugMsg:1;                                      //0xfca  // 禁止调试消息
            USHORT DisableUserStackWalk:1;                                  //0xfca  // 禁用用户堆栈遍历
            USHORT RtlExceptionAttached:1;                                  //0xfca  // RTL异常已附加
            USHORT InitialThread:1;                                         //0xfca  // 初始线程
            USHORT SessionAware:1;                                          //0xfca  // 会话感知
            USHORT LoadOwner:1;                                             //0xfca  // 加载所有者
            USHORT LoaderWorker:1;                                          //0xfca  // 加载器工作线程
            USHORT SkipLoaderInit:1;                                        //0xfca  // 跳过加载器初始化
            USHORT SpareSameTebBits:1;                                      //0xfca  // 备用位
        };
    };
    VOID* TxnScopeEnterCallback;                                            //0xfcc  // 事务进入回调
    VOID* TxnScopeExitCallback;                                             //0xfd0  // 事务退出回调
    VOID* TxnScopeContext;                                                  //0xfd4  // 事务上下文
    ULONG LockCount;                                                        //0xfd8  // 锁计数器
    LONG WowTebOffset;                                                      //0xfdc  // WOW64 TEB偏移
    VOID* ResourceRetValue;                                                 //0xfe0  // 资源返回地址
    VOID* ReservedForWdf;                                                   //0xfe4  // WDF保留字段
    ULONGLONG ReservedForCrt;                                               //0xfe8  // CRT保留字段
    struct _GUID EffectiveContainerId;                                      //0xff0  // 有效容器GUID
};

ETHREAD

ETHREAD 是 Windows 内核对线程的描述和管理核心,承载线程的执行状态、安全信息、调度信息、同步机制等,是操作系统多任务并发执行的基础结构,它处于内核态,属于执行体,有一个指向kthread的指针(tcb)。

// 0x898 bytes (sizeof)
struct _ETHREAD
{
    struct _KTHREAD Tcb;                            // 0x0   内核线程对象(线程控制块)
    union _LARGE_INTEGER CreateTime;                // 0x430 创建时间
    union
    {
        union _LARGE_INTEGER ExitTime;              // 0x438 退出时间
        struct _LIST_ENTRY KeyedWaitChain;          //       Keyed事件等待链表
    };
    union
    {
        struct _LIST_ENTRY PostBlockList;           // 0x448 IRP挂起块链表
        struct
        {
            VOID* ForwardLinkShadow;                //       向前链接影子(IRP使用)
            VOID* StartAddress;                     // 0x450 用户模式的线程入口地址
        };
    };
    union
    {
        struct _TERMINATION_PORT* TerminationPort;  // 0x458 终止端口指针
        struct _ETHREAD* ReaperLink;                //       线程回收链表
        VOID* KeyedWaitValue;                       //       Keyed事件值
    };
    ULONGLONG ActiveTimerListLock;                  // 0x460 活跃计时器锁
    struct _LIST_ENTRY ActiveTimerListHead;         // 0x468 活跃计时器链表头
    struct _CLIENT_ID Cid;                          // 0x478 线程和进程ID
    union
    {
        struct _KSEMAPHORE KeyedWaitSemaphore;      // 0x488 Keyed事件信号量
        struct _KSEMAPHORE AlpcWaitSemaphore;       //       ALPC信号量
    };
    union _PS_CLIENT_SECURITY_CONTEXT ClientSecurity; // 0x4a8 客户端安全上下文
    struct _LIST_ENTRY IrpList;                     // 0x4b0 挂起IRP链表
    ULONGLONG TopLevelIrp;                          // 0x4c0 顶层IRP指针
    struct _DEVICE_OBJECT* DeviceToVerify;          // 0x4c8 验证设备对象
    VOID* Win32StartAddress;                        // 0x4d0 Win32起始地址
    VOID* ChargeOnlySession;                        // 0x4d8 Session信息(计费相关)
    VOID* LegacyPowerObject;                        // 0x4e0 电源管理对象(历史用途)
    struct _LIST_ENTRY ThreadListEntry;             // 0x4e8 所在进程的线程链表项
    struct _EX_RUNDOWN_REF RundownProtect;          // 0x4f8 Rundown保护
    struct _EX_PUSH_LOCK ThreadLock;                // 0x500 线程对象锁
    ULONG ReadClusterSize;                          // 0x508 IO簇读取大小
    volatile LONG MmLockOrdering;                   // 0x50c 内存锁顺序检查
    union
    {
        ULONG CrossThreadFlags;                     // 0x510 跨线程标志
        struct
        {
            ULONG Terminated:1;                         // 线程已终止
            ULONG ThreadInserted:1;                     // 插入调度器
            ULONG HideFromDebugger:1;                   // 隐藏调试器
            ULONG ActiveImpersonationInfo:1;            // 活跃模拟信息
            ULONG HardErrorsAreDisabled:1;              // 禁止硬错误
            ULONG BreakOnTermination:1;                 // 终止时触发调试中断
            ULONG SkipCreationMsg:1;                    // 跳过创建消息
            ULONG SkipTerminationMsg:1;                 // 跳过终止消息
            ULONG CopyTokenOnOpen:1;                    // 打开时复制令牌
            ULONG ThreadIoPriority:3;                   // IO优先级
            ULONG ThreadPagePriority:3;                 // 页面优先级
            ULONG RundownFail:1;                        // Rundown失败
            ULONG UmsForceQueueTermination:1;           // UMS队列强制终止
            ULONG IndirectCpuSets:1;                    // 使用间接CPU集合
            ULONG DisableDynamicCodeOptOut:1;           // 禁用动态代码
            ULONG ExplicitCaseSensitivity:1;            // 显式大小写敏感
            ULONG PicoNotifyExit:1;                     // Pico进程通知退出
            ULONG DbgWerUserReportActive:1;             // 用户报告活动中
            ULONG ForcedSelfTrimActive:1;               // 自我修剪激活
            ULONG SamplingCoverage:1;                   // 采样覆盖
            ULONG ReservedCrossThreadFlags:8;           // 保留
        };
    };
    union
    {
        ULONG SameThreadPassiveFlags;               // 0x514 同线程被动标志
        struct
        {
            ULONG ActiveExWorker:1;                     // 正在作为Ex工作线程
            ULONG MemoryMaker:1;                        // 内存生成者
            ULONG StoreLockThread:2;                    // 存储锁线程状态
            ULONG ClonedThread:1;                       // 克隆线程
            ULONG KeyedEventInUse:1;                    // Keyed事件占用中
            ULONG SelfTerminate:1;                      // 自终止标志
            ULONG RespectIoPriority:1;                  // 尊重IO优先级
            ULONG ActivePageLists:1;                    // 活跃分页列表
            ULONG SecureContext:1;                      // 安全上下文
            ULONG ZeroPageThread:1;                     // 零页线程
            ULONG WorkloadClass:1;                      // 工作负载类型
            ULONG ReservedSameThreadPassiveFlags:20;    // 保留
        };
    };
    union
    {
        ULONG SameThreadApcFlags;                   // 0x518 同线程APC标志
        struct
        {
            UCHAR OwnsProcessAddressSpaceExclusive:1;   // 独占地址空间
            UCHAR OwnsProcessAddressSpaceShared:1;      // 共享地址空间
            UCHAR HardFaultBehavior:1;                  // 硬错误行为
            volatile UCHAR StartAddressInvalid:1;       // 起始地址无效
            UCHAR EtwCalloutActive:1;                   // ETW回调活动中
            UCHAR SuppressSymbolLoad:1;                 // 抑制符号加载
            UCHAR Prefetching:1;                        // 正在预取
            UCHAR OwnsVadExclusive:1;                   // 独占VAD
            UCHAR SystemPagePriorityActive:1;           // 系统页优先级激活
            UCHAR SystemPagePriority:3;                 // 系统页优先级
            UCHAR AllowUserWritesToExecutableMemory:1;  // 允许写可执行内存
            UCHAR AllowKernelWritesToExecutableMemory:1;// 内核可写执行内存
            UCHAR OwnsVadShared:1;                      // 共享VAD
        };
    };
    UCHAR CacheManagerActive;                       // 0x51c 缓存管理器活动标志
    UCHAR DisablePageFaultClustering;               // 0x51d 禁用页面聚类
    UCHAR ActiveFaultCount;                         // 0x51e 活动故障计数
    UCHAR LockOrderState;                           // 0x51f 锁顺序状态
    ULONG PerformanceCountLowReserved;              // 0x520 保留性能计数低位
    LONG PerformanceCountHighReserved;              // 0x524 保留性能计数高位
    ULONGLONG AlpcMessageId;                        // 0x528 ALPC消息ID
    union
    {
        VOID* AlpcMessage;                           // 0x530 ALPC消息指针
        ULONG AlpcReceiveAttributeSet;               //       ALPC接收属性
    };
    struct _LIST_ENTRY AlpcWaitListEntry;           // 0x538 ALPC等待链表
    LONG ExitStatus;                                // 0x548 线程退出状态
    ULONG CacheManagerCount;                        // 0x54c 缓存管理器引用计数
    ULONG IoBoostCount;                             // 0x550 IO提升计数
    ULONG IoQoSBoostCount;                          // 0x554 IO服务质量提升计数
    ULONG IoQoSThrottleCount;                       // 0x558 IO限流计数
    ULONG KernelStackReference;                     // 0x55c 内核栈引用计数
    struct _LIST_ENTRY BoostList;                   // 0x560 IO提升列表
    struct _LIST_ENTRY DeboostList;                 // 0x570 IO恢复列表
    ULONGLONG BoostListLock;                        // 0x580 提升列表锁
    ULONGLONG IrpListLock;                          // 0x588 IRP链表锁
    VOID* ReservedForSynchTracking;                 // 0x590 同步跟踪保留
    struct _SINGLE_LIST_ENTRY CmCallbackListHead;   // 0x598 注册表回调链表
    struct _GUID* ActivityId;                       // 0x5a0 活动ID(用于ETW)
    struct _SINGLE_LIST_ENTRY SeLearningModeListHead; // 0x5a8 安全学习模式链表
    VOID* VerifierContext;                          // 0x5b0 驱动验证器上下文
    VOID* AdjustedClientToken;                      // 0x5b8 调整后的客户端令牌
    VOID* WorkOnBehalfThread;                       // 0x5c0 代表工作线程
    struct _PS_PROPERTY_SET PropertySet;            // 0x5c8 线程属性集合
    VOID* PicoContext;                              // 0x5e0 Pico线程上下文
    ULONGLONG UserFsBase;                           // 0x5e8 用户FS基址
    ULONGLONG UserGsBase;                           // 0x5f0 用户GS基址
    struct _THREAD_ENERGY_VALUES* EnergyValues;     // 0x5f8 能源使用数据
    union
    {
        ULONGLONG SelectedCpuSets;                  // 0x600 选定CPU集合(直接)
        ULONGLONG* SelectedCpuSetsIndirect;         //       选定CPU集合(间接)
    };
    struct _EJOB* Silo;                             // 0x608 所属Job/Silo容器
    struct _UNICODE_STRING* ThreadName;             // 0x610 线程名
    struct _CONTEXT* SetContextState;               // 0x618 上下文设置状态
    ULONG LastExpectedRunTime;                      // 0x620 最后预期运行时间
    ULONG HeapData;                                 // 0x624 堆分配数据
    struct _LIST_ENTRY OwnerEntryListHead;          // 0x628 所有者项链表
    ULONGLONG DisownedOwnerEntryListLock;           // 0x638 失效所有者链表锁
    struct _LIST_ENTRY DisownedOwnerEntryListHead;  // 0x640 失效所有者链表头
    struct _KLOCK_ENTRY LockEntries[6];             // 0x650 锁条目(死锁检测)
    VOID* CmDbgInfo;                                // 0x890 注册表调试信息
};

KTHREAD

Kernel Thread是 Windows 内核用来描述一个线程的最低级别数据结构,它管理线程的调度、同步、状态、CPU 上的运行情况等核心信息,它处于内核态,属于内核,包含一个指向该线程的teb的指针和一个指向kprocess的指针。

// 总大小 0x430 字节
struct _KTHREAD
{
    struct _DISPATCHER_HEADER Header;      // 0x0  调度器头,包含线程调度状态(如信号状态、等待原因等)
    VOID* SListFaultAddress;                // 0x18 用户模式SList错误地址(用于用户模式异常处理)
    ULONGLONG QuantumTarget;                // 0x20 当前量子的目标结束时间戳(用于时间片计算)
    VOID* InitialStack;                     // 0x28 线程初始栈指针(栈创建时的起始位置)
    VOID* volatile StackLimit;              // 0x30 当前栈限制(栈底边界)
    VOID* StackBase;                        // 0x38 当前栈基址(栈顶边界)
    ULONGLONG ThreadLock;                   // 0x40 线程自旋锁(保护线程数据结构)
    volatile ULONGLONG CycleTime;           // 0x48 累计执行的CPU周期数(性能计数)
    ULONG CurrentRunTime;                   // 0x50 当前运行时间(单位:调度tick)
    ULONG ExpectedRunTime;                  // 0x54 预期运行时间(用于调度决策)
    VOID* KernelStack;                      // 0x58 内核栈指针(内核模式执行时使用的栈)
    struct _XSAVE_FORMAT* StateSaveArea;    // 0x60 XSAVE格式的CPU状态保存区域(用于FPU/SSE等状态)
    struct _KSCHEDULING_GROUP* volatile SchedulingGroup; // 0x68 所属的调度组(用于组调度)
    union _KWAIT_STATUS_REGISTER WaitRegister; // 0x70 等待状态寄存器(记录等待结果)
    volatile UCHAR Running;                 // 0x71 线程是否正在运行(1=正在CPU上执行)
    UCHAR Alerted[2];                       // 0x72 警告标志数组(每个处理器一个,用于异步过程调用APC)
    union {                                 // 0x74 杂项标志位域
        struct {
            ULONG AutoBoostActive:1;        // 自动优先级提升激活
            ULONG ReadyTransition:1;         // 线程正从等待态转为就绪态
            ULONG WaitNext:1;               // 线程在等待链表中
            ULONG SystemAffinityActive:1;    // 系统亲和性激活(限制在特定CPU组)
            ULONG Alertable:1;               // 线程可被警告(允许APC中断等待)
            ULONG UserStackWalkActive:1;     // 用户栈遍历中(调试用)
            ULONG ApcInterruptRequest:1;     // APC中断请求挂起
            ULONG QuantumEndMigrate:1;       // 时间片结束需迁移线程
            ULONG UmsDirectedSwitchEnable:1; // 用户模式调度(UMS)定向切换启用
            ULONG TimerActive:1;             // 定时器激活
            ULONG SystemThread:1;            // 系统线程(内核线程)
            ULONG ProcessDetachActive:1;     // 进程分离中
            ULONG CalloutActive:1;           // 内核回调执行中
            ULONG ScbReadyQueue:1;           // 在SCB就绪队列中
            ULONG ApcQueueable:1;            // 允许插入APC
            ULONG ReservedStackInUse:1;      // 保留栈使用中
            ULONG UmsPerformingSyscall:1;    // UMS线程正在执行系统调用
            ULONG TimerSuspended:1;          // 定时器暂停
            ULONG SuspendedWaitMode:1;       // 在暂停状态中等待
            ULONG SuspendSchedulerApcWait:1; // 等待调度器APC以暂停线程
            ULONG CetUserShadowStack:1;      // 使用CET用户态影子栈
            ULONG BypassProcessFreeze:1;     // 绕过进程冻结(如关键线程)
            ULONG Reserved:10;               // 保留位
        };
        LONG MiscFlags;                     // 整型形式访问上述标志
    };
    union {                                 // 0x78 线程标志位域
        struct {
            ULONG ThreadFlagsSpare:2;        // 保留位
            ULONG AutoAlignment:1;           // 自动内存对齐检查
            ULONG DisableBoost:1;            // 禁用优先级提升
            ULONG AlertedByThreadId:1;       // 通过线程ID警告
            ULONG QuantumDonation:1;         // 时间片捐赠(如优先级继承)
            ULONG EnableStackSwap:1;          // 允许栈交换
            ULONG GuiThread:1;               // GUI线程(Windows子系统)
            ULONG DisableQuantum:1;           // 禁用时间片计时
            ULONG ChargeOnlySchedulingGroup:1; // 仅向调度组计费
            ULONG DeferPreemption:1;          // 延迟抢占(如持有自旋锁)
            ULONG QueueDeferPreemption:1;      // 队列延迟抢占
            ULONG ForceDeferSchedule:1;        // 强制延迟调度
            ULONG SharedReadyQueueAffinity:1;   // 共享就绪队列亲和性
            ULONG FreezeCount:1;              // 冻结计数(挂起深度)
            ULONG TerminationApcRequest:1;    // 终止APC请求
            ULONG AutoBoostEntriesExhausted:1; // 自动提升条目耗尽
            ULONG KernelStackResident:1;       // 内核栈常驻内存
            ULONG TerminateRequestReason:2;    // 终止请求原因
            ULONG ProcessStackCountDecremented:1; // 进程栈计数已减
            ULONG RestrictedGuiThread:1;        // 受限GUI线程
            ULONG VpBackingThread:1;            // 虚拟处理器(Vp)后备线程
            ULONG ThreadFlagsSpare2:1;          // 保留位
            ULONG EtwStackTraceApcInserted:8;   // ETW栈追踪APC插入计数
        };
        volatile LONG ThreadFlags;          // 整型形式访问上述标志
    };
    volatile UCHAR Tag;                     // 0x7c 对象标签(调试用)
    UCHAR SystemHeteroCpuPolicy;            // 0x7d 系统异构CPU策略(如大/小核调度)
    UCHAR UserHeteroCpuPolicy:7;            // 0x7e 用户态异构CPU策略(低7位)
    UCHAR ExplicitSystemHeteroCpuPolicy:1;  // 0x7e 显式系统异构策略(最高位)
    union {                                 // 0x7f 推测执行控制
        struct {
            UCHAR RunningNonRetpolineCode:1; // 正在运行非Retpoline代码(缓解Spectre)
            UCHAR SpecCtrlSpare:7;           // 保留位
        };
        UCHAR SpecCtrl;                     // 整型形式访问
    };
    ULONG SystemCallNumber;                 // 0x80 系统调用号(当前执行的系统调用)
    ULONG ReadyTime;                        // 0x84 线程就绪时间戳(加入就绪队列时间)
    VOID* FirstArgument;                    // 0x88 系统调用第一个参数
    struct _KTRAP_FRAME* TrapFrame;         // 0x90 陷阱帧指针(中断/异常上下文)
    union {                                 // 0x98 APC状态
        struct _KAPC_STATE ApcState;        // 标准APC状态(用户/内核APC队列)
        struct {                            // 替代布局
            UCHAR ApcStateFill[43];         // APC状态填充字节
            CHAR Priority;                  // 0xc3 当前线程优先级
            ULONG UserIdealProcessor;       // 0xc4 用户态理想处理器(亲和性)
        };
    };
    volatile LONGLONG WaitStatus;           // 0xc8 等待状态(等待结果值)
    struct _KWAIT_BLOCK* WaitBlockList;     // 0xd0 等待块链表头(线程等待的对象)
    union {                                 // 0xd8 等待链表条目
        struct _LIST_ENTRY WaitListEntry;   // 标准链表条目(如等待队列)
        struct _SINGLE_LIST_ENTRY SwapListEntry; // 单链表条目(交换上下文用)
    };
    struct _DISPATCHER_HEADER* volatile Queue; // 0xe8 线程所在的调度队列
    VOID* Teb;                              // 0xf0 线程环境块(用户态数据结构)
    ULONGLONG RelativeTimerBias;            // 0xf8 相对定时器偏差(校准计时)
    struct _KTIMER Timer;                   // 0x100 线程定时器(用于超时等待)
    union {                                 // 0x140 多用途联合体(节省空间)
        struct _KWAIT_BLOCK WaitBlock[4];   // 内联等待块(最多4个等待对象)
        struct {                            // 上下文切换计数
            UCHAR WaitBlockFill4[20];       // 填充
            ULONG ContextSwitches;          // 0x154 上下文切换次数
        };
        struct {                            // 线程状态信息
            UCHAR WaitBlockFill5[68];       // 填充
            volatile UCHAR State;           // 0x184 线程状态(就绪、运行、等待等)
            CHAR Spare13;                   // 0x185 保留
            UCHAR WaitIrql;                 // 0x186 等待时的IRQL(中断请求级别)
            CHAR WaitMode;                  // 0x187 等待模式(内核/用户)
        };
        struct {                            // 等待时间
            UCHAR WaitBlockFill6[116];      // 填充
            ULONG WaitTime;                 // 0x1b4 总等待时间(单位:tick)
        };
        struct {                            // APC禁用状态
            UCHAR WaitBlockFill7[164];      // 填充
            union {
                struct {
                    SHORT KernelApcDisable; // 0x1e4 内核APC禁用计数
                    SHORT SpecialApcDisable; // 0x1e6 特殊APC禁用计数
                };
                ULONG CombinedApcDisable;   // 整型形式访问
            };
        };
        struct {                            // 线程计数器
            UCHAR WaitBlockFill8[40];       // 填充
            struct _KTHREAD_COUNTERS* ThreadCounters; // 0x168 性能计数器指针
        };
        struct {                            // XSAVE状态保存
            UCHAR WaitBlockFill9[88];       // 填充
            struct _XSTATE_SAVE* XStateSave; // 0x198 扩展处理器状态保存区
        };
        struct {                            // Win32线程块
            UCHAR WaitBlockFill10[136];     // 填充
            VOID* volatile Win32Thread;     // 0x1c8 Win32k子系统线程块
        };
        struct {                            // 用户模式调度(UMS)
            UCHAR WaitBlockFill11[176];     // 填充
            struct _UMS_CONTROL_BLOCK* Ucb; // 0x1f0 UMS控制块
            struct _KUMS_CONTEXT_HEADER* volatile Uch; // 0x1f8 UMS上下文头
        };
    };
    union {                                 // 0x200 线程标志2
        volatile LONG ThreadFlags2;         // 整型形式
        struct {
            ULONG BamQosLevel:8;            // 后台活动管理器(BAM) QoS级别
            ULONG ThreadFlags2Reserved:24;  // 保留位
        };
    };
    ULONG Spare21;                          // 0x204 保留字段
    struct _LIST_ENTRY QueueListEntry;      // 0x208 调度队列链表条目
    union {                                 // 0x218 下一个处理器信息
        volatile ULONG NextProcessor;       // 整型形式
        struct {
            ULONG NextProcessorNumber:31;   // 下次运行的处理器编号
            ULONG SharedReadyQueue:1;       // 是否使用共享就绪队列
        };
    };
    LONG QueuePriority;                     // 0x21c 队列优先级(调度决策)
    struct _KPROCESS* Process;              // 0x220 所属进程的_KPROCESS指针
    union {                                 // 0x228 用户亲和性和优先级
        struct _GROUP_AFFINITY UserAffinity; // 用户态亲和性掩码
        struct {                            // 替代布局
            UCHAR UserAffinityFill[10];     // 填充
            CHAR PreviousMode;              // 0x232 先前模式(内核/用户)
            CHAR BasePriority;              // 0x233 基础优先级
            union {                         // 优先级调整
                CHAR PriorityDecrement;     // 优先级减量(动态提升)
                struct {
                    UCHAR ForegroundBoost:4; // 前台进程提升量
                    UCHAR UnusualBoost:4;    // 非常规提升量(如I/O完成)
                };
            };
            UCHAR Preempted;                // 0x235 是否被抢占
            UCHAR AdjustReason;             // 0x236 优先级调整原因
            CHAR AdjustIncrement;           // 0x237 调整增量
        };
    };
    ULONGLONG AffinityVersion;              // 0x238 亲和性版本号(检测变化)
    union {                                 // 0x240 当前亲和性
        struct _GROUP_AFFINITY Affinity;    // 亲和性掩码(允许运行的CPU组)
        struct {                            // 替代布局
            UCHAR AffinityFill[10];         // 填充
            UCHAR ApcStateIndex;            // 0x24a APC状态索引
            UCHAR WaitBlockCount;           // 0x24b 使用的等待块数量
            ULONG IdealProcessor;           // 0x24c 理想处理器编号
        };
    };
    ULONGLONG NpxState;                     // 0x250 NPX状态(浮点协处理器)
    union {                                 // 0x258 保存的APC状态
        struct _KAPC_STATE SavedApcState;   // 保存的APC状态(线程挂起时)
        struct {                            // 替代布局
            UCHAR SavedApcStateFill[43];    // 填充
            UCHAR WaitReason;               // 0x283 等待原因代码
            CHAR SuspendCount;              // 0x284 挂起计数
            CHAR Saturation;                // 0x285 CPU饱和度(用于QoS)
            USHORT SListFaultCount;         // 0x286 SList错误计数
        };
    };
    union {                                 // 0x288 调度器APC及相关字段
        struct _KAPC SchedulerApc;          // 调度器APC(用于线程抢占/恢复)
        struct {
            UCHAR SchedulerApcFill0[1];     // 填充
            UCHAR ResourceIndex;            // 0x289 资源索引(如锁跟踪)
        };
        struct {
            UCHAR SchedulerApcFill1[3];     // 填充
            UCHAR QuantumReset;             // 0x28b 量子重置标志
        };
        struct {
            UCHAR SchedulerApcFill2[4];    // 填充
            ULONG KernelTime;               // 0x28c 内核模式累计运行时间
        };
        struct {
            UCHAR SchedulerApcFill3[64];    // 填充
            struct _KPRCB* volatile WaitPrcb; // 0x2c8 等待的处理器控制块
        };
        struct {
            UCHAR SchedulerApcFill4[72];    // 填充
            VOID* LegoData;                 // 0x2d0 预留数据(内部调试用)
        };
        struct {
            UCHAR SchedulerApcFill5[83];    // 填充
            UCHAR CallbackNestingLevel;     // 0x2db 回调嵌套层级
            ULONG UserTime;                 // 0x2dc 用户模式累计运行时间
        };
    };
    struct _KEVENT SuspendEvent;            // 0x2e0 挂起事件(同步挂起操作)
    struct _LIST_ENTRY ThreadListEntry;     // 0x2f8 进程线程链表条目
    struct _LIST_ENTRY MutantListHead;      // 0x308 互斥体链表头(线程持有的互斥体)
    UCHAR AbEntrySummary;                   // 0x318 地址空间锁摘要(AS锁)
    UCHAR AbWaitEntryCount;                 // 0x319 等待的AS锁条目数
    UCHAR AbAllocationRegionCount;          // 0x31a AS分配区域计数
    CHAR SystemPriority;                    // 0x31b 系统优先级(内核调整后)
    ULONG SecureThreadCookie;               // 0x31c 安全线程Cookie(缓解漏洞)
    struct _KLOCK_ENTRY* LockEntries;       // 0x320 持有的锁条目数组
    struct _SINGLE_LIST_ENTRY PropagateBoostsEntry; // 0x328 优先级提升传播条目
    struct _SINGLE_LIST_ENTRY IoSelfBoostsEntry; // 0x330 I/O自提升条目
    UCHAR PriorityFloorCounts[16];          // 0x338 优先级地板计数(按优先级)
    UCHAR PriorityFloorCountsReserved[16];  // 0x348 保留
    ULONG PriorityFloorSummary;             // 0x358 优先级地板摘要(位掩码)
    volatile LONG AbCompletedIoBoostCount;  // 0x35c 完成的I/O提升计数
    volatile LONG AbCompletedIoQoSBoostCount; // 0x360 完成的I/O QoS提升计数
    volatile SHORT KeReferenceCount;        // 0x364 内核对象引用计数
    UCHAR AbOrphanedEntrySummary;           // 0x366 孤立的AS锁条目摘要
    UCHAR AbOwnedEntryCount;                // 0x367 持有的AS锁条目数
    ULONG ForegroundLossTime;               // 0x368 失去前台状态的时间戳
    union {                                 // 0x370 全局前台链表
        struct _LIST_ENTRY GlobalForegroundListEntry; // 链表条目
        struct {
            struct _SINGLE_LIST_ENTRY ForegroundDpcStackListEntry; // DPC栈条目
            ULONGLONG InGlobalForegroundList; // 0x378 是否在全局链表中
        };
    };
    LONGLONG ReadOperationCount;            // 0x380 读操作计数
    LONGLONG WriteOperationCount;           // 0x388 写操作计数
    LONGLONG OtherOperationCount;           // 0x390 其他操作计数
    LONGLONG ReadTransferCount;             // 0x398 读传输字节数
    LONGLONG WriteTransferCount;            // 0x3a0 写传输字节数
    LONGLONG OtherTransferCount;            // 0x3a8 其他传输字节数
    struct _KSCB* QueuedScb;                // 0x3b0 排队的内核栈控制块
    volatile ULONG ThreadTimerDelay;        // 0x3b8 定时器延迟(单位:tick)
    union {                                 // 0x3bc 线程标志3
        volatile LONG ThreadFlags3;         // 整型形式
        struct {
            ULONG ThreadFlags3Reserved:8;   // 保留
            ULONG PpmPolicy:2;              // 电源性能策略
            ULONG ThreadFlags3Reserved2:22; // 保留
        };
    };
    ULONGLONG TracingPrivate[1];            // 0x3c0 追踪私有数据(ETW)
    VOID* SchedulerAssist;                  // 0x3c8 调度辅助数据
    VOID* volatile AbWaitObject;            // 0x3d0 等待的AS锁对象
    ULONG ReservedPreviousReadyTimeValue;   // 0x3d8 保留字段(原就绪时间)
    ULONGLONG KernelWaitTime;               // 0x3e0 内核模式等待时间
    ULONGLONG UserWaitTime;                 // 0x3e8 用户模式等待时间
    union {                                 // 0x3f0 虚拟处理器优先级更新链表
        struct _LIST_ENTRY GlobalUpdateVpThreadPriorityListEntry; // 链表条目
        struct {
            struct _SINGLE_LIST_ENTRY UpdateVpThreadPriorityDpcStackListEntry; // DPC栈条目
            ULONGLONG InGlobalUpdateVpThreadPriorityList; // 0x3f8 是否在链表中
        };
    };
    LONG SchedulerAssistPriorityFloor;      // 0x400 调度辅助的优先级地板
    ULONG Spare28;                          // 0x404 保留字段
    ULONGLONG EndPadding[5];                // 0x408 结构体尾部填充(对齐)
};

数据结构之间的联系

从eprocess开始,他包含一个指向peb的指针,他的第一个成员就是kprocess,它的ThreadListHead链表中的节点指向了对应的ethread中的ThreadListEntry,这样根据ThreadListEntry在ethread中的偏移,就可以找到ethread。

kprocess中同样包含一个ThreadListHead链表,不同的是该链表中的节点指向的是kthread中的ThreadListEntry。

ehtread包含了kthread,kthread中有指向teb的指针。

顺便提一下,eprocess通过ActiveProcessLinks连接到一起,他指向其他eprocess成员的ActiveProcessLinks,通过遍历该链表可以遍历其他进程,也可以通过将eprocess从链表中摘除来隐藏进程