用驱动遍历进程的IAT表

于 2023-05-02 16:27:33 发布
阅读量191 收藏
点赞数 1
分类专栏： Windows 文章标签： Windows 安全 驱动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/misaka10046/article/details/130464640
版权

WIN7 X86

驱动

#include<ntifs.h>
#include <WinDef.h>

#define DEVICE_NAME L"\\Device\\wangliang"
#define SYM_NAME L"\\??\\wangliang"

#define _COMM_ID 0x12345678

typedef NTSTATUS(*QUERY_INFO_PROCESS)(
	__in HANDLE ProcessHandle,
	__in PROCESSINFOCLASS ProcessInformationClass,
	__out_bcount(ProcessInformationLength) PVOID ProcessInformation,
	__in ULONG ProcessInformationLength,
	__out_opt PULONG ReturnLength
);

typedef struct _SYSTEM_PROCESS_INFORMATION {
	ULONG NextEntryOffset;
	ULONG NumberOfThreads;
	LARGE_INTEGER Reserved[3];
	LARGE_INTEGER CreateTime;
	LARGE_INTEGER UserTime;
	LARGE_INTEGER KernelTime;
	UNICODE_STRING ImageName;
	ULONG BasePriority;
	HANDLE ProcessId;
	HANDLE InheritedFromProcessId;
} SYSTEM_PROCESS_INFORMATION, * PSYSTEM_PROCESS_INFORMATION;

QUERY_INFO_PROCESS ZwQueryInformationProcess;


typedef struct _CommPackage {
	ULONG64 id;
	ULONG64 pid;
	ULONG Handle;
	CHAR name[64];
}CommPackage, * PCommPackage;

typedef NTSTATUS(NTAPI* CommCallback)(PCommPackage package);
CommCallback gCommCallback = NULL;

NTSTATUS DefDispatch(DEVICE_OBJECT* DeviceObject, IRP* Irp)
{
	Irp->IoStatus.Status = STATUS_SUCCESS;
	IoCompleteRequest(Irp, 0);
	return STATUS_SUCCESS;
}

VOID DriverUnload(PDRIVER_OBJECT pDriver) {
	UNICODE_STRING symName = { 0 };
	RtlInitUnicodeString(&symName, SYM_NAME);
	IoDeleteSymbolicLink(&symName);

	IoDeleteDevice(pDriver->DeviceObject);

	DbgPrint("Driver UnLoad!");
}


NTSTATUS process_enum(DEVICE_OBJECT* DeviceObject, IRP* Irp) {

	PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp);
	LARGE_INTEGER ByteOffset = ioStack->Parameters.Read.ByteOffset;
	int Length = ioStack->Parameters.Read.Length;
	PCommPackage package = Irp->UserBuffer;
	NTSTATUS status = STATUS_UNSUCCESSFUL;

	HANDLE hProc = NULL;
	PEPROCESS pEprocess = NULL;
	
	PVOID pBuf = NULL;
	ULONG ulSize = 1000;
	ANSI_STRING ansi_buffer_target = { 0 };


	pEprocess = PsGetCurrentProcess();
	if (pEprocess == NULL) {
		DbgPrintEx(77, 0, "GRT ERROR");
		return STATUS_SUCCESS;

	}
	
	if (package->pid > 1) {
		ULONG64 i = (ULONG64)1;
		for (; i < package->pid; i++) {
			pEprocess = (PEPROCESS)(*(ULONG*)((ULONG)pEprocess + 0xB8) - 0xB8);
		}
	}
	
	if (*(ULONG*)((ULONG)pEprocess + 0xB4) == NULL) {
		Irp->IoStatus.Information = 0;
		Irp->IoStatus.Status = status;
		IoCompleteRequest(Irp, 0);
		return STATUS_SUCCESS;
	}
	package->Handle = pEprocess;
	NTSTATUS NtStatus = ObOpenObjectByPointer(pEprocess, NULL, NULL, 0, NULL, KernelMode, &hProc);

	if (!NT_SUCCESS(NtStatus)) {
		ZwClose(hProc);
		Irp->IoStatus.Information = 0;
		Irp->IoStatus.Status = status;
		IoCompleteRequest(Irp, 0);
		return STATUS_SUCCESS;
	}
	
	pBuf = ExAllocatePool(PagedPool, ulSize);
	
	if (!pBuf) {
		ZwClose(hProc);
		Irp->IoStatus.Information = 0;
		Irp->IoStatus.Status = status;
		IoCompleteRequest(Irp, 0);
		return STATUS_SUCCESS;
	}
	RtlZeroMemory(pBuf, ulSize);
	
	if (NULL == ZwQueryInformationProcess) {

		UNICODE_STRING routineName;

		RtlInitUnicodeString(&routineName, L"ZwQueryInformationProcess");

		ZwQueryInformationProcess =(QUERY_INFO_PROCESS)MmGetSystemRoutineAddress(&routineName);

		if (NULL == ZwQueryInformationProcess) {
			DbgPrint("Cannot resolve ZwQueryInformationProcess\n");
		}
	}
	NtStatus = ZwQueryInformationProcess(hProc, ProcessImageFileName, pBuf, ulSize,NULL);
	if (!NT_SUCCESS(NtStatus)) {
		ZwClose(hProc);
		Irp->IoStatus.Information = 0;
		Irp->IoStatus.Status = status;
		IoCompleteRequest(Irp, 0);
		return STATUS_SUCCESS;
	}
	RtlUnicodeStringToAnsiString(&ansi_buffer_target, (PUNICODE_STRING)pBuf, TRUE);
	strcpy(package->name, ansi_buffer_target.Buffer);
	RtlFreeAnsiString(&ansi_buffer_target);
	


/*
	ulProcessName = (char*)((ULONG)pEprocess + 0x16C);
	ulProcessID = *(ULONG*)((ULONG)pEprocess + 0xB4);

	DbgPrintEx(77, 0, "PID=%d,process_name=%s\r\n", ulProcessID, ulProcessName);
	strcpy(package->name, ulProcessName);
*/
	Irp->IoStatus.Information = 0;
	Irp->IoStatus.Status = status;

	//APChangeThreadMode(EThread, PreviousMode);

	ZwClose(hProc);
	IoCompleteRequest(Irp, 0);

	return STATUS_SUCCESS;
}

NTSTATUS DriverEntry(PDRIVER_OBJECT pDriver, PUNICODE_STRING registeryPat) {
	UNICODE_STRING unName = { 0 };
	RtlInitUnicodeString(&unName, DEVICE_NAME);

	UNICODE_STRING symName = { 0 };
	RtlInitUnicodeString(&symName, SYM_NAME);

	PDEVICE_OBJECT pDevice = NULL;

	NTSTATUS status = IoCreateDevice(pDriver, NULL, &unName, FILE_DEVICE_UNKNOWN, FILE_DEVICE_SECURE_OPEN, FALSE, &pDevice);

	if (!NT_SUCCESS(status))
	{
		DbgPrint("[db]:%x\r\n", status);
		return status;
	}

	status = IoCreateSymbolicLink(&symName, &unName);

	if (!NT_SUCCESS(status))
	{
		IoDeleteDevice(pDevice);
		DbgPrint("[db]:%x\r\n", status);
		return status;
	}

	pDevice->Flags &= ~DO_DEVICE_INITIALIZING;
	pDevice->Flags |= DO_BUFFERED_IO;

	pDriver->MajorFunction[IRP_MJ_CREATE] = DefDispatch;
	pDriver->MajorFunction[IRP_MJ_CLOSE] = DefDispatch;
	pDriver->MajorFunction[IRP_MJ_READ] = process_enum;

	pDriver->DriverUnload = DriverUnload;

	return STATUS_SUCCESS;

}

R3

#include <stdio.h>
#include <Windows.h>
#include<psapi.h>

#pragma comment(lib,"psapi.lib")

#define SYM_NAME   "\\\\.\\wangliang"

typedef struct _CommPackage {
	ULONG64 id;
	ULONG64 pid;
	ULONG Handle;
	CHAR name[64];
}CommPackage, * PCommPackage;

#define _COMM_ID 0x12345678

int check_address(HANDLE hProcess, int Address) {
	MEMORY_BASIC_INFORMATION memInfo;
	SIZE_T size = VirtualQueryEx(hProcess, Address, &memInfo, sizeof(memInfo));
	int value = 0;
	DWORD oldProtect;
	if (size == sizeof(memInfo)) {
		// 检查memInfo保护位，如果包含PAGE_NOACCESS标志，则地址无效
		if ((memInfo.State != MEM_COMMIT) ||
			((memInfo.Protect & PAGE_GUARD) != 0) ||
			((memInfo.Protect & PAGE_NOACCESS) != 0)) {
			return 0;
		}
		else {
			if (Address >= (int)memInfo.BaseAddress && Address < (int)memInfo.BaseAddress + memInfo.RegionSize) {
				if (ReadProcessMemory(hProcess, Address, &value, sizeof(int), NULL) == FALSE) {
					return 0;
				}
				else {
					if (VirtualProtect(memInfo.BaseAddress, memInfo.RegionSize, PAGE_READONLY, &oldProtect)) {
						VirtualProtect(memInfo.BaseAddress, memInfo.RegionSize, oldProtect, &oldProtect);
						return 1;
					}
					else {
						return 0;
					}
				}
			}
			else {
				return 0;
			}
		}
	}

}

int main()
{
	HANDLE Handle;
	PIMAGE_DOS_HEADER pDosHeader;
	PIMAGE_NT_HEADERS pNTHeaders;
	PIMAGE_OPTIONAL_HEADER pOptHeader;
	PIMAGE_IMPORT_DESCRIPTOR pImportDescriptor;
	HMODULE hMods[1024];
	DWORD cbNeeded;
	DWORD processID; // 目标进程 ID

	CommPackage packag;
	packag.id = _COMM_ID;
	packag.pid = (ULONG64)1;

	for (int i = 0; i < 64; i++) {
		packag.name[i] = 0;
	}
	HANDLE hDevice = CreateFileA(SYM_NAME, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);


	if (hDevice == NULL || hDevice == INVALID_HANDLE_VALUE)
	{
		printf("%d", hDevice);
		system("pause");
		return 0;
	}

	DWORD p = 0;

	int j = 0;

	ReadFile(hDevice, &packag, sizeof(CommPackage), &p, NULL);
	char First[64] = { 0 };
	strcpy_s(First, 64, packag.name);
	printf("%s\r\n", packag.name);

	DWORD dwProcessID[0x500] = { 0 };  //开始的预先分配较大的缓冲区，用来存放进程ID
	DWORD dwNeeded = 0;
	BOOL bEnumRes = EnumProcesses(dwProcessID, sizeof(dwProcessID), &dwNeeded);
	UINT uCount = dwNeeded / sizeof(DWORD); //获得枚举到进程的数量


	do {

		j = 0;

		for (int i = 0; i < 64; i++) {
			if (packag.name[i] == 92) {
				j = i;
			}
		}
		char name[64] = { 0 };
		for (int i = 0; i + j + 1 < 64; i++) {
			name[i] = packag.name[j + i + 1];
		}

		for (UINT x = 0; x < uCount; x++)
		{

			//只对进程进程枚举，所以申请QUERY权限，具体还得根据应用申请权限

			HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, dwProcessID[x]);
			if (NULL != hProcess)
			{
				CHAR szProcessName[0x50] = { 0 };
				DWORD dwNameLen = 0x50;
				BOOL bRet = QueryFullProcessImageNameA(hProcess, 0, szProcessName, &dwNameLen);
				if (bRet)
				{
					//printf("ID:%4d\tprocessName(%s)\n", dwProcessID[i], szProcessName);
					j = 0;

					for (int i = 0; i < sizeof(szProcessName); i++) {
						if (szProcessName[i] == 92) {
							j = i;
						}
					}
					char name2[64] = { 0 };
					for (int i = 0; i + j + 1 < sizeof(szProcessName); i++) {
						name2[i] = szProcessName[j + i + 1];
					}

					if (strcmp(name2, name) == 0) {
						//_asm int 3;
						processID = dwProcessID[x];
					}
				}
			}
		}
		//DWORD processID; // 目标进程 ID
		//_asm int 3;
		HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID); // 打开目标进程句柄

		_asm int 3;
		if (EnumProcessModules(hProcess, hMods, sizeof(hMods), &cbNeeded)) { // 枚举目标进程所有模块
			for (unsigned int i = 0; i < (cbNeeded / sizeof(HMODULE)); i++) {
				TCHAR szModName[MAX_PATH];
				//_asm int 3;
				if (GetModuleBaseName(hProcess, hMods[i], szModName, sizeof(szModName) / sizeof(TCHAR))) { // 获取模块名和基址
					if (check_address(hProcess, hMods[i]) == 0) {
						goto new_Mods;
					}
					
					printf("Module base address:%s ", hMods[i]);
					printf("Module name: %s", szModName);
					pDosHeader = (PIMAGE_DOS_HEADER)hMods[i];

					pNTHeaders = (PIMAGE_NT_HEADERS)((BYTE*)hMods[i] + pDosHeader->e_lfanew);
					pOptHeader = (PIMAGE_OPTIONAL_HEADER) & (pNTHeaders->OptionalHeader);

					//获取本进程的函数导入表结构体
					pImportDescriptor = (PIMAGE_IMPORT_DESCRIPTOR)((BYTE*)hMods[i] + pOptHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);

					//循环遍历函数导入表的IMAGE_IMPORT_DESCRIPTOR结构体
					while (pImportDescriptor->FirstThunk && pOptHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress)
					{
						//获取函数名地址IMAGE_THUNK_DATA结构体
						PIMAGE_THUNK_DATA pFuncNameAddr = (PIMAGE_THUNK_DATA)((BYTE*)hMods[i] + pImportDescriptor->OriginalFirstThunk);

						//获取函数在内存中的地址IMAGE_THUNK_DATA结构体
						PIMAGE_THUNK_DATA pFuncAddr = (PIMAGE_THUNK_DATA)((BYTE*)hMods[i] + pImportDescriptor->FirstThunk);
						//获取本导入dll的dll文件名
						char* pDllName = (char*)((BYTE*)hMods[i] + pImportDescriptor->Name);
						if (check_address(hProcess, pDllName) == 0) {
							goto new_DLL;
						}
						printf("%s\n", pDllName);

						//循环遍历函数导入表的函数名列表
						while (pFuncNameAddr->u1.Function)
						{
							//获取函数导入序号
							WORD* iNo = ((BYTE*)hMods[i] + (DWORD)pFuncNameAddr->u1.AddressOfData);

							//获取函数名
							char* pFuncName = (char*)((BYTE*)hMods[i] + (DWORD)pFuncNameAddr->u1.AddressOfData + 2);

							if (check_address(hProcess, pFuncName) == 0) {
								goto new_Fun;
							}
							
							//获取函数名对应的函数在内存中的地址
							PDWORD lpAddr = pFuncAddr->u1.AddressOfData;

							printf("%0 4X : %s    %#X\n", *iNo, pFuncName, lpAddr);

						new_Fun:
							//指向下一个函数
							pFuncNameAddr++;
							pFuncAddr++;
						}
						//_asm int 3;
						//getchar();

					new_DLL:				//指向下一个dll
						pImportDescriptor++;
					}
				new_Mods:

					;
				}
			}
		}
			packag.pid = packag.pid + 1;
			for (int i = 0; i < 64; i++) {
				packag.name[i] = 0;
			}
			ReadFile(hDevice, &packag, sizeof(CommPackage), &p, NULL);
			printf("%s\r\n", packag.name);
			Sleep(1000);
	}while (strcmp(First, packag.name) != NULL);

	CloseHandle(hDevice);

	system("pause");
	return 0;
}

效果

在这里插入图片描述

0xwangliang
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Windows内核驱动EPROCESS遍历进程模块
12-14
windows驱动 遍历进程模块
驱动开发-遍历进程
Fly_Sky
10-18 884
理论来源：http://www.weixianmanbu.com/article/749.html 总结： !Process 0 0   进程列表 dt _eprocess    ----提示无改命令时使用.reload /f nt dt _eprocess 进程地址  --得到进程详细信息 DDFF进程地址+0x88  --得到下个进程地址结构指针 地址结构指针-0x88
IAT HOOK及遍历IAT
哈尔滨-猫猫
01-03 823
// ConsoleApplication2.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include // 定义MessageBoxA函数原型 typedef int (WINAPI *PFNMESSAGEBOX)(HWND, LPCSTR, LPCSTR, UINT uType); int W
驱动遍历进程的方法
qq_41071646的博客
10-27 1398
/*#include &lt;ntddk.h&gt; #define DEVICE_OBJECT_NAME L"\\Device\\BufferedIODeviceObjectName" #define DEVICE_LINK_NAME L"\\DosDevices\\BufferedIODevcieLinkName" void dirver(IN PDRIVER_OBJECT pDri...
驱动开发：内核遍历进程VAD结构体
热门推荐
CSDN
10-13 1万+
树的每一个节点代表一段虚拟地址空间。程序中的代码段，数据段，堆段都会各种占用一个或多个。结构体，需要说明的是栈并不受VAD的管理。同样这是微软定义，如果想要的到最新的，自己下载WinDBG调试内核输入命令。内存块的属性，这个内存结构定义在WinDBG中可看到。结构的偏移值，每个系统都不一样，版本不同偏移值会不同。当需要得到该进程的VAD结构时，只需要使用。结构中可以找到VAD结构的相对偏移。可以看到在本系统中VAD的偏移是。头文件，并写入如下代码，此处的。来显示该进程的VAD树。结构树，这个结构通常在。
C++获取当前进程IAT的方法
09-04
主要介绍了C++获取当前进程IAT的方法,实例讲述了IAT（导入地址表）的获取方法,在Windows应用程序开发中有着非常实用的应用价值,需要的朋友可以参考下
逆向软件后，手把手教你如何修复IAT表
最新发布
10-31
逆向软件后，教你手把手修复IAT表
iat输入表hook的源码
09-14
iat输入表hook的源码
IAT表注入模块
07-30
对应于文章的IAT表注入模块的示例，自己写的例子，直接可以运行。
x64驱动 遍历 PspCidTable 枚举隐进程和线程
LYSM
06-05 2757
介绍 PspCidTable 是一个内核句柄表，存放进程和线程的内核对象（EPROCESS 和 ETHREAD），并通过 PID 和 TID 进行索引（所以进程ID和线程ID不可能相同），ID 号以 4 递增。 获取 PspCidTable 地址 win7： PsLookupProcessByProcessId（被导出） -> PspCidTable win10： PsLookupProcessByProcessId（被导出） -> PspReferenceCidTableEntry -&g
windows下遍历进程并输出进程名，PID，进程路径
08-22
该代码为windows下遍历进程并输出进程名，PID，进程路径，由C++编写，运行成功
4.ring0-遍历IAT（特例NTOS）
hgy413的专栏
07-25 1653
原NTOS的IAT只能通过IMAGE_DIRECTORY_ENTRY_IAT（12）来获得，因为NTOS加载完后，INIT方式加载，所以IMAGE_DIRECTORY_ENTRY_IMPORT对应的区域被释放了！ 坑爹啊， 可以用windbg很直观的看到： X86： x64: 其他的IAT遍历代码如下： NTSTATUS EnumIATTable(ULO
驱动的遍历和隐藏
Mikasys的博客
10-20 273
DRIVER_OBJECT 0: kd> dt _DRIVER_OBJECT nt!_DRIVER_OBJECT +0x000 Type : Int2B +0x002 Size : Int2B +0x008 DeviceObject : Ptr64 _DEVICE_OBJECT +0x010 Flags : Uint4B +0x018 DriverStart : Ptr64 Void
驱动中获取进程完整路径名
多媒体编程、网络编程、系统编程、网络安全编程、驱动编程
10-18 1689
Submitted by boxcounter on 2009, July 23, 6:55 PM. windows编程(R0) 在OSR上无意中看到一篇文章，关于获取进程完整路径的。贴过来，最后有一点小调整。 原文地址：http://www.osronline.com/article.cfm?id=472   Over the years developers h
IAT表
crkres9527
09-27 602
A、初识IAT     B、IAT表相关结构     C、读出IAT项     D、编写代码测试分析       E、HOOK IAT     F、测试分析 A、认识IAT表 导入函数表 B、IAT表相关结构 PIMAGE_DOS_HEADER //-&gt;e_lfanew //PE文件头偏移值 PIMAGE_NT_HEADERS //-&gt;OptionalHeade...
通过暴力搜索PID遍历进程并获取进程信息
LYSM
06-23 2787
背景 通常我们在内核中使用 ZwQuerySystemInformation 函数来遍历进程模块并获取进程信息，这种是通过正常的进程遍历方式，所以，有很多 Rootkit 程序会 HOOK 这个 ZwQuerySystemInformation 函数，过滤指定进程，从而实现进程的隐藏。 本文实现的进程遍历和获取进程信息并不打算使用 ZwQuerySystemInformation 这种方式，而是直接暴力搜索进程的 PID，根据有效的 PID 获取相应进程的信息，从而实现进程的遍历。现在，我就来讲解具体的实现
遍历所有进程并找到指定进程停止
ghevinn欢迎您光临
03-26 5155
// testlog.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include #include using namespace std; int _tmain(int argc, _TCHAR* argv[]) { //HMODULE Mymhandle; //_tsystem(L"calc.exe
获取当前进程的IAT
小驹的专栏
06-14 1432
#include #include int main(int argc, char* argv[]) { HMODULE hModule = ::GetModuleHandleA(NULL); IMAGE_DOS_HEADER* pDosHeader = (IMAGE_DOS_HEADER*)hModule; IMAGE_OPTIONAL_HEADER* pOpNtHeader = (
VAD 虚拟内存
Misaka10046的博客
04-20 3061
Windows中的虚拟地址分配 使用指令dt _EPROCESS 874ed030 观察EPROCESS结构体偏移为0x278的地方，这个地方就是系统拿来存放每个进程的虚拟地址空间的分配情况 输入!vad 874ed030+278 查看该平衡二叉树 Level是二叉树的层数 start是该块虚拟地址空间的起始地址 end为结束地址 commit为请求次数 写一段程序测试下 #include<stdio.h> #include<Windows.h> int main() {
windows的IAT表
07-28
当可执行文件或DLL被加载到进程的内存空间时，操作系统会将IAT表中的函数地址填充为实际的函数地址。这个过程称为动态链接或动态导入。 IAT表的结构是一个函数地址指针数组，每个指针指向一个导入函数的地址。当...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值