x64驱动 遍历 PspCidTable 枚举隐进程和线程

最新推荐文章于 2023-12-01 15:24:44 发布
最新推荐文章于 2023-12-01 15:24:44 发布
阅读量2.8k 收藏 15
点赞数 3
分类专栏： Windows 驱动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Simon798/article/details/106572336
版权

介绍

PspCidTable 是一个内核句柄表，存放进程和线程的内核对象（EPROCESS 和 ETHREAD），并通过 PID 和 TID 进行索引（所以进程ID和线程ID不可能相同），ID 号以 4 递增。

获取 PspCidTable 地址

win7：

PsLookupProcessByProcessId（被导出） -> PspCidTable

win10：

PsLookupProcessByProcessId（被导出） -> PspReferenceCidTableEntry -> PspCidTable

手动查询 PspTable

打开 WinDbg，输入： dp PspCidTable
得到 PspTable 地址 ——
在这里插入图片描述
输入 dt _handle_table 0xffffc300d9016a80
在这里插入图片描述
TableCode 是指向句柄表的指针，低二位（二进制）记录句柄表的等级：0（00）表示一级表，1（01）表示二级表，2（10）表示三级表。这里的 0xffffc300`dda6f001 就说名它是一个二级表。

一级表里存放的就是进程和线程对象（加密过的，需要一些计算来解密），二级表里存放的是指向某个一级表的指针，同理三级表存放的是指向二级表的指针。

x64 系统中，每张表的大小是 0x1000（4096），一级表中存放的是 _handle_table_entry 结构（大小 = 16），二级表和三级表存放的是指针（大小 = 8）。

我们对 0xffffc300dda6f001 抹去低二位，输入 dp 0xffffc300dda6f000
在这里插入图片描述
可以看到我这张二级表中有 50个一级表指针。查看第一张一级表：dp 0xffffc300d901a000
在这里插入图片描述
我们知道一级句柄表是根据 进程或线程ID来索引的，且以 ‘4’ 累加，所以第一行对应 id = 0，第二行对应 id = 4。 根据尝试，PID = 4 的进程是 System：
在这里插入图片描述
所以 0x9888c5afd440d84f 解密后就应该是 System 进程的 EPROCESS。
解密算法：

系统版本计算方法
win7value & 0xfffffffffffffff0
win8(value >> 0x13) & 0xfffffffffffffff0
win10(value >> 0x10) & 0xfffffffffffffff0

我的系统是 win10，按照上面的计算方式得到的结果是 0xFFFF9888C5AFD440
输入 dt _eprocess 0xFFFF9888C5AFD440 验证：
在这里插入图片描述
成功！

代码

// 获取 PspCidTable
BOOLEAN get_PspCidTable(ULONG64* tableAddr) {

	// 获取 PsLookupProcessByProcessId 地址
	UNICODE_STRING uc_funcName;
	RtlInitUnicodeString(&uc_funcName, L"PsLookupProcessByProcessId");
	ULONG64 ul_funcAddr = MmGetSystemRoutineAddress(&uc_funcName);
	if (ul_funcAddr == NULL) {
		//DbgPrint("[LYSM] MmGetSystemRoutineAddress error.\n");
		return FALSE;
	}
	//DbgPrint("[LYSM] PsLookupProcessByProcessId:%p\n", ul_funcAddr);

	// 前 40 字节有 call（PspReferenceCidTableEntry）
	ULONG64 ul_entry = 0;
	for (INT i = 0; i < 40; i++) {
		if (*(PUCHAR)(ul_funcAddr + i) == 0xe8) {
			ul_entry = ul_funcAddr + i;
			break;
		}
	}
	if (ul_entry != 0) {
		// 解析 call 地址
		INT i_callCode = *(INT*)(ul_entry + 1);
		//DbgPrint("[LYSM] i_callCode:%X\n", i_callCode);
		ULONG64 ul_callJmp = ul_entry + i_callCode + 5;
		//DbgPrint("[LYSM] ul_callJmp:%p\n", ul_callJmp);
		// 来到 call（PspReferenceCidTableEntry） 内找 PspCidTable
		for (INT i = 0; i < 20; i++) {
			if (*(PUCHAR)(ul_callJmp + i) == 0x48 &&
				*(PUCHAR)(ul_callJmp + i + 1) == 0x8b &&
				*(PUCHAR)(ul_callJmp + i + 2) == 0x05) {
				// 解析 mov 地址
				INT i_movCode = *(INT*)(ul_callJmp+i + 3);
				//DbgPrint("[LYSM] i_movCode:%X\n", i_movCode);
				ULONG64 ul_movJmp = ul_callJmp+i + i_movCode + 7;
				//DbgPrint("[LYSM] ul_movJmp:%p\n", ul_movJmp);
				// 得到 PspCidTable
				*tableAddr = ul_movJmp;
				return TRUE;
			}
		}
	}

	// 前 40字节没有 call
	else {
		// 直接在 PsLookupProcessByProcessId 找 PspCidTable
		for (INT i = 0; i < 70; i++) {
			if(*(PUCHAR)(ul_funcAddr + i) == 0x49 &&
				*(PUCHAR)(ul_funcAddr + i + 1) == 0x8b &&
				*(PUCHAR)(ul_funcAddr + i + 2) == 0xdc &&
				*(PUCHAR)(ul_funcAddr + i + 3) == 0x48 &&
				*(PUCHAR)(ul_funcAddr + i + 4) == 0x8b &&
				*(PUCHAR)(ul_funcAddr + i + 5) == 0xd1 &&
				*(PUCHAR)(ul_funcAddr + i + 6) == 0x48 &&
				*(PUCHAR)(ul_funcAddr + i + 7) == 0x8b){
				// 解析 mov 地址
				INT i_movCode = *(INT*)(ul_funcAddr+i+6 + 3);
				//DbgPrint("[LYSM] i_movCode:%X\n", i_movCode);
				ULONG64 ul_movJmp = ul_funcAddr+i+6 + i_movCode + 7;
				//DbgPrint("[LYSM] ul_movJmp:%p\n", ul_movJmp);
				// 得到 PspCidTable
				*tableAddr = ul_movJmp;
				return TRUE;
			}
		}
	}

	return FALSE;
}

/* 解析一级表
	BaseAddr：一级表的基地址
	index1：第几个一级表
	index2：第几个二级表
*/
VOID parse_table_1(ULONG64 BaseAddr,INT index1,INT index2) {

	//DbgPrint("[LYSM] BaseAddr 1:%p\n", BaseAddr);

	// 获取系统版本
	RTL_OSVERSIONINFOEXW OSVersion = { 0 };
	OSVersion.dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOEXW);
	RtlGetVersion((PRTL_OSVERSIONINFOW)&OSVersion);

	// 遍历一级表（每个表项大小 16 ），表大小 4k，所以遍历 4096/16 = 526 次
	PEPROCESS p_eprocess = NULL;
	PETHREAD p_ethread = NULL;
	INT i_id = 0;
	for (INT i = 0; i < 256; i++) {
		if (!MmIsAddressValid((PVOID64)(BaseAddr + i * 16))) { 
			//DbgPrint("[LYSM] 非法地址:%p\n", BaseAddr + i * 16);
			continue; 
		}
		// win10
		if (OSVersion.dwMajorVersion == 10 && OSVersion.dwMinorVersion == 0) {
			ULONG64 ul_recode = *(PULONG64)(BaseAddr + i * 16);
			// 解密
			ULONG64 ul_decode = (LONG64)ul_recode >> 0x10;
			ul_decode &= 0xfffffffffffffff0;
			// 判断是进程还是线程
			i_id = i*4 + 1024*index1 + 512*index2*1024;	
			if (PsLookupProcessByProcessId(i_id , &p_eprocess) == STATUS_SUCCESS) {
				DbgPrint("[LYSM] PID:%d , i:%d , addr:%p , object:%p\n", i_id , i, BaseAddr + i*0x10, ul_decode);
			}
			else if (PsLookupThreadByThreadId(i_id , &p_ethread) == STATUS_SUCCESS) {
				DbgPrint("[LYSM] TID:%d , i:%d , addr:%p , object:%p\n", i_id , i, BaseAddr + i*0x10, ul_decode);
			}
			
		}
		// win7
		if (OSVersion.dwMajorVersion == 6 && OSVersion.dwMinorVersion == 1) {
			ULONG64 ul_recode = *(PULONG64)(BaseAddr + i * 16);
			// 解密
			ULONG64 ul_decode = ul_recode & 0xfffffffffffffff0;
			// 判断是进程还是线程
			i_id = i*4 + 1024*index1 + 512*index2*1024;
			if (PsLookupProcessByProcessId(i_id , &p_eprocess) == STATUS_SUCCESS) {
				DbgPrint("[LYSM] PID:%d , i:%d , addr:%p , object:%p\n", i_id , i, BaseAddr + i*0x10, ul_decode);
			}
			else if (PsLookupThreadByThreadId(i_id , &p_ethread) == STATUS_SUCCESS) {
				DbgPrint("[LYSM] TID:%d , i:%d , addr:%p , object:%p\n", i_id , i, BaseAddr + i*0x10, ul_decode);
			}
			else { continue; }
		}
	}
}

/* 解析二级表
	BaseAddr：二级表基地址
	index2：第几个二级表
*/
VOID parse_table_2(ULONG64 BaseAddr, INT index2) {

	//DbgPrint("[LYSM] BaseAddr 2:%p\n", BaseAddr);

	// 遍历二级表（每个表项大小 8）,表大小 4k，所以遍历 4096/8 = 512 次
	ULONG64 ul_baseAddr_1 = 0;
	for (INT i = 0; i < 512; i++) {
		if (!MmIsAddressValid((PVOID64)(BaseAddr + i * 8))) { 
			//DbgPrint("[LYSM] 非法二级表指针（1）:%p\n", BaseAddr + i * 8);
			continue; 
		}
		if (!MmIsAddressValid((PVOID64)*(PULONG64)(BaseAddr + i * 8))) { 
			//DbgPrint("[LYSM] 非法二级表指针（2）:%p\n", BaseAddr + i * 8);
			continue;
		}
		ul_baseAddr_1 = *(PULONG64)(BaseAddr + i * 8);
		parse_table_1(ul_baseAddr_1, i, index2);
	}
}

/* 解析三级表
	BaseAddr：三级表基地址
*/
VOID parse_table_3(ULONG64 BaseAddr) {

	//DbgPrint("[LYSM] BaseAddr 3:%p\n", BaseAddr);

	// 遍历三级表（每个表项大小 8）,表大小 4k，所以遍历 4096/8 = 512 次
	ULONG64 ul_baseAddr_2 = 0;
	for (INT i = 0; i < 512; i++) {
		if (!MmIsAddressValid((PVOID64)(BaseAddr + i * 8))) { continue; }
		if (!MmIsAddressValid((PVOID64) * (PULONG64)(BaseAddr + i * 8))) { continue; }
		ul_baseAddr_2 = *(PULONG64)(BaseAddr + i * 8);
		parse_table_2(ul_baseAddr_2, i);
	}
}

/* 遍历进程和线程
	cidTableAddr：PspCidTable 地址
*/
BOOLEAN enum_PspCidTable(ULONG64 cidTableAddr) {

	// 获取 _HANDLE_TABLE 的 TableCode
	ULONG64 ul_tableCode = *(PULONG64)(((ULONG64)*(PULONG64)cidTableAddr) + 8);
	//DbgPrint("[LYSM] ul_tableCode:%p\n", ul_tableCode);

	// 取低 2位（二级制11 = 3）
	INT i_low2 = ul_tableCode & 3;
	//DbgPrint("[LYSM] i_low2:%X\n", i_low2);

	// 一级表
	if (i_low2 == 0) {
		// TableCode 低 2位抹零（二级制11 = 3）
		parse_table_1(ul_tableCode & (~3),0,0);
	}
	// 二级表
	else if (i_low2 == 1) {
		// TableCode 低 2位抹零（二级制11 = 3）
		parse_table_2(ul_tableCode & (~3),0);
	}
	// 三级表
	else if (i_low2 == 2) {
		// TableCode 低 2位抹零（二级制11 = 3）
		parse_table_3(ul_tableCode & (~3));
	}
	else {
		DbgPrint("[LYSM] i_low2 非法！\n");
		return FALSE;
	}

	return TRUE;
}

调用：

NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObj, PUNICODE_STRING pRegistryString)
{
	// 初始化省略...
	// ...
	// ...


	// 测试
	ULONG64 tableAddr = 0;
	if (get_PspCidTable(&tableAddr) == FALSE) {
		DbgPrint("[LYSM] get_PspCidTable error.\n");
	}
	else {
		enum_PspCidTable(tableAddr);    
	}      
	
	
	return STATUS_SUCCESS;
}
(-: LYSM :-)
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
在Win7 x64通过PspCidTable枚举进程
qq269813279的博客
06-13 2061
PspCidTable存放着一个结构为_HANDLE_TABLE的指针，_HANDLE_TABLE结构记录句柄表的相关信息，句柄表存放着所有进程和线程的对象，其索引就是PID和TID，在WinDbg看一下相关的结构。我们遍历进程对象需要关注两个成员，第一个是TableCode，第二个是NextHandleNeedingPool。TableCode：该成员记录表级和表地址，低2位记录着表的级数，掩掉...
驱动开发：内核中枚举进线程与模块
CSDN
10-14 1万+
内核枚举进程使用`PspCidTable` 这个未公开的函数，它能最大的好处是能得到进程的EPROCESS地址，由于是未公开的函数，所以我们需要变相的调用这个函数，通过`PsLookupProcessByProcessId`函数查到进程的EPROCESS，如果`PsLookupProcessByProcessId`返回失败，则证明此进程不存在，如果返回成功则把EPROCESS、PID、PPID、进程名等通过DbgPrint打印到屏幕上。
驱动开发：内核枚举PspCidTable句柄表
热门推荐
CSDN
10-16 1万+
在上一篇文章中我们通过枚举特征码的方式找到了DPC定时器基址并输出了内核中存在的定时器列表，本章将学习如何通过特征码定位的方式寻找Windows 10系统下面的内核句柄表地址。首先引入一段基础概念；windowsPspCidTable 就是这样的一种表(内核句柄表)，表的内部存放的是进程EPROCESS和线程ETHREAD的内核对象，并通过进程PID和线程TID进行索引，ID号以4递增，内核句柄表不属于任何进程，也不连接在系统的句柄表上，通过它可以返回系统的任何对象。
驱动开发：内核操作进线程与模块
CSDN
10-21 5568
进程就是活动起来的程序，每一个进程在内核里，都有一个名为EPROCESS的结构记录它的详细信息，其中就包括进程名，PID，PPID，进程路径等，通常在应用层枚举进程只列出所有进程的编号即可，不过在内核层需要把它的 EPROCESS 地址给列举出来。
PspCidTable进程枚举
rongwenbin的专栏
02-25 1448
-------------------------------------这是分割线--------------------------------------- Windows句柄表格式 句柄是Windows对象管理中引入的一个东西，它的实际意义是对象在句柄表中的索引。Windows2000使用的是固定的三层句柄表，而WindowsXP和Windows2003都是使用的动态可扩展的
(Win7) PspCidTable遍历进程句柄表，枚举进程
h2995527的博客
04-10 533
搞了一阵子的PHP，今天又来继续自己的C++了，翻阅了一下自己之前写的代码和说明，自己也有点儿稀里糊涂了，于是又仔细的从头研究了一下，遂写此文以记之，文中有不当的地方欢迎大家拍砖. 先说一下句柄表是什么 在windows内核中定义了很多内核对象，像文件对象，线程对象，信号量对象啊等等；而Windows中并没有让我们直接去使用这些对象资源，而是通过句柄让我们去引用这些资源，句柄表就相当于资源的数组，而句柄就是对应资源的索引，每个进程内部都有一个自己的私有句柄表，这也就是说句柄是不能跨进程使用的。 PspCi
6.5 Windows驱动开发：内核枚举PspCidTable句柄表
最新发布
CSDN
12-01 4253
在 Windows 操作系统内核中，PspCidTable 通常是与进程（Process）管理相关的数据结构之一。它与进程的标识和管理有关，每个进程都有一个唯一的标识符，称为进程 ID（PID）。与之相关的是客户端 ID，它是一个结构，其中包含唯一标识进程的信息。这样的标识符在进程管理、线程管理和内核对象的创建等方面都起到关键作用。
全局句柄表 —— 遍历全局句柄表
walker的博客
03-16 1450
简介 进程句柄表是私有的，每个进程都有自己的进程句柄表。除此之外，系统还有一个全局句柄表，全局变量 PspCidTable 指向该表。 全局句柄表存储的是操作系统中所有创建的进程、线程的句柄（不会出现重复）。每个进程和线程都有一个唯一的编号：PID 和 CID ， 这两个值其实就是全局句柄表中的索引。 也就是说，即使我们实现了对进程、线程的断链，但是只要操作系统中创建了进程、线程，全局句柄表中就会记录其对应的句柄（PID/CID），仍然可以通过全局句柄实现对线程、进程的遍历。 EnumPspCidTab
windows内核情景分析---进程线程1
mmmsss987的博客
06-23 592
本篇主要讲述进程的启动过程、线程的调度与切换、进程挂靠 一、进程的启动过程： BOOLCreateProcess ( LPCTSTRlpApplicationName,// LPTSTRlpCommandLine,//commandlinestring LPSECURITY_ATTRI...
Windows内核驱动EPROCESS遍历进程模块
12-14
总的来说，"Windows内核驱动EPROCESS遍历进程模块"是一项深入的操作系统级任务，它可以帮助我们更好地理解和监控系统运行状态，但同时也需要开发者具备高级的编程技能和对系统安全的深刻理解。通过学习和实践这一...
cid.zip_pspcidtable_进程_驱动
09-21
标题中的"cid.zip_pspcidtable_进程_驱动"表明这是一个关于Windows系统内核编程的项目，主要涉及了PspCidTable、进程管理和驱动程序的使用。PspCidTable是Windows操作系统内部用于存储进程控制信息的数据结构，而...
Process--thread-enumeration.rar_delphi thread_delphi枚举进程_进程的线程
09-14
本文将深入探讨如何在Delphi中进行进程和线程的枚举，以及如何利用窗体组件调用例程来实现相关功能。 首先，我们要理解进程与线程的基本概念。进程是程序在内存中的运行实例，它拥有独立的资源，如内存空间、文件...
驱动保护进程_隐藏进程_遍历内核句柄
07-02
1、改进程PID,隐藏自己的进程 2、断链隐藏自己的进程，防PG ...5、遍历进程的句柄，并降低指定进程PID的句柄权限，里面有遍历内存进程和每个进程句柄的方法 6、操作debugport,防止调试或者使自己脱离调试，检测调试
C# 遍历枚举类型的所有元素
12-31
比如定义了一个错误的枚举类型 代码如下:public enum eErrorDetailCode : int { 登陆... 然后在循环中，遍历枚举对象的所有元素 代码如下:foreach (int myCode in Enum.GetValues(typeof(eErrorDetailCode))) 
x64驱动 使用 InfinityHook
LYSM
06-18 4843
准备 首先，下载 InfinityHook 项目： git clone https://github.com/everdox/InfinityHook 打开 sln ，编译一下： 得到我们需要的 lib 文件（以 x64 为例）： 再找到 这个 .h 头文件，需要的就这么多 ???? 新建项目 新建一个驱动项目，将刚才的 .lib 和 .h 文件拷贝到工程目录中： 项目中添加现有项： 注意，这里的 lib 文件必须添加到工程目录中，如果只单纯的设置附加依赖项和附加库目录，会报 “无法解析的外部符号
c++ 驱动【加载，启动，停止，卸载】
LYSM
05-16 4780
驱动代码参考：https://blog.csdn.net/Simon798/article/details/103308039 exe 代码： #include <iostream> #include <Windows.h> using namespace std; // 安装驱动 BOOL installDvr(CONST WCHAR drvPath[50], CONST WCHAR serviceName[20]) { // 打开服务控制管理器数据库
C++ 第一个驱动程序
LYSM
11-29 4658
驱动入口 // NTSTATUS : (LONG) 0~0X7FFFFFFF 正确状态，0X80000000~0XFFFFFFFF 错误状态。参考：https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-erref/596a1078-e883-4972-9bbc-49e60bebca55 /* PDRIVER_OBJECT...
Windows C语言驱动遍历进程获取进程参数
05-30
要在Windows C语言驱动程序中遍历进程并获取进程参数，可以使用以下步骤： 1. 获取当前进程的EPROCESS结构体指针，可以使用PsGetCurrentProcess函数。 2. 使用PsLookupProcessByProcessId函数遍历系统中所有的进程并获取每个进程的EPROCESS结构体指针。 3. 遍历每个进程的双向链表来获取进程参数，可以使用以下代码： ``` PEB* peb = PsGetProcessPeb(Process); // 获取进程的PEB结构体指针 RTL_USER_PROCESS_PARAMETERS* params = peb->ProcessParameters; // 获取进程参数结构体指针 UNICODE_STRING imagePath = params->ImagePathName; // 获取进程的可执行文件路径 ``` 注意：在驱动程序中访问用户空间的数据需要使用特殊函数，如ProbeForRead和ProbeForWrite，以确保内存访问的安全性。此外，要在驱动程序中进行此类操作需要管理员权限。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值