WhoUseMe--枚举句柄查找文件占用

最新推荐文章于 2024-06-20 14:15:00 发布
最新推荐文章于 2024-06-20 14:15:00 发布
阅读量1.5k 收藏 3
点赞数 1
分类专栏： windows编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18218335/article/details/62884657
版权

枚举句柄-查找谁占用了我们的文件

平时偶尔会遇见文件无法删除的情况，通常使用PE 或者 PH 来查找谁占用了我们的文件，然后有一天就想自己实现查询占用文件情况的功能。

占用文件或目录，就会打开文件或目录（加载的DLL 例外），然后我们的任务变成：枚举所有的句柄，如果不是自己进程的句柄，先DuplicateObject然后得到句柄类型（或者设置全局的类型数据，然后根据TypeIndex进行类型比较即可，请参考上一篇文章）找到File 类型的句柄，得到对象名，即文件名然后进行比较即可。

 

枚举句柄的方法很简单：NtQueryObject(NULL,SystemHandleInformation/SystemExtendHandleInformation(Xp+),),问题是：当遇到访问权限为0x0012019f 0x001a019f 0x0016019f 还有 0 （或者其它还没发现的访问权限）时会出现NtQueryObject 获取对象名称将线程挂起的情况。有人说GetFileInformationByHandleEx 并不会将线程挂起，但是经过测试，函数依然会挂起。

上两张图展示了PE 在普通模式和UAC 模式下搜索令WhoUseMe 线程挂起的对象的结果，我们发现，PE 也无法在普通权限下获得该类型的对象的名称。而在UAC模式下可以搜索到该对象，分别在两个进程中，一个是NVDisplay.Container.exe进程，即原来的进程，WhoUseMe.exe 则是在DuplicateObject之后才获得的这个句柄，然后在NtQueryObject获得对象名称的时候线程被挂起。

那么UAC 代表权限，而我们自己的程序UAC 也会挂起，之后想起了驱动，只要有自己的驱动在挂载，就可以直接通过对象数据结构来获得对象名，使用Everything 搜索发现：

然后分别在普通权限和UAC 搜索该驱动：

而用更方便的PH 查找即可发现：

PE 在UAC 权限确实加载了该驱动，然后PE 通过驱动来获得对象名，而不会遇见线程挂起的情况。

另外，我们发现并不是所有的具有上述罗列的访问权限的文件对象都会导致线程挂起，为了在普通权限可以得到尽量全的文件名，我们不可以仅仅过滤那些访问权限。

那么现在如果我们想要得到文件对象的名称而不至于让线程挂起有两种解决方案：

1.      普通权限，让单独的线程执行NtQueryObject 获得对象名，如果线程挂起，直接杀死线程，为了避免频繁的线程创建和退出操作，我们将任务放在一个while(1)循环中，然后等待一个通知的同步事件，主线程如果需要执行操作，设置一个变量指示句柄并触发事件并在一个事件上等待（设置超时），然后子线程执行NtQueryObject 操作，成功后触发主线程所等待的事件，如果超时，KillThread并新生成一个线程。

2.      UAC，加载驱动，通过句柄获得对象，通过对象获得对象名即可。

 

普通模式代码如下

 头文件

 

#pragma once
#ifndef UNICODE
#define UNICODE
#endif
#include <afxstr.h>
#include <windows.h>
#define NTSTATUS	long
#define NT_SUCCESS(x) ((x) >= 0)
#define STATUS_INFO_LENGTH_MISMATCH 0xc0000004

#define SystemHandleInformation 16
#define SystemExtendedHandleInformation 64
#define ObjectBasicInformation 0
#define ObjectNameInformation 1
#define ObjectTypeInformation 2

typedef NTSTATUS(NTAPI *_NtQuerySystemInformation)(
	ULONG SystemInformationClass,
	PVOID SystemInformation,
	ULONG SystemInformationLength,
	PULONG ReturnLength
	);
typedef NTSTATUS(NTAPI *_NtDuplicateObject)(
	HANDLE SourceProcessHandle,
	HANDLE SourceHandle,
	HANDLE TargetProcessHandle,
	PHANDLE TargetHandle,
	ACCESS_MASK DesiredAccess,
	ULONG Attributes,
	ULONG Options
	);
typedef NTSTATUS(NTAPI *_NtQueryObject)(
	HANDLE ObjectHandle,
	ULONG ObjectInformationClass,
	PVOID ObjectInformation,
	ULONG ObjectInformationLength,
	PULONG ReturnLength
	);

typedef struct _UNICODE_STRING
{
	USHORT Length;
	USHORT MaximumLength;
	PWSTR Buffer;
} UNICODE_STRING, *PUNICODE_STRING;

typedef struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX
{
	PVOID Object;
	ULONG_PTR UniqueProcessId;
	HANDLE HandleValue;
	ULONG GrantedAccess;
	USHORT CreatorBackTraceIndex;
	USHORT ObjectTypeIndex;
	ULONG HandleAttributes;
	ULONG Reserved;
} SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX, *PSYSTEM_HANDLE_TABLE_ENTRY_INFO_EX;

typedef struct _SYSTEM_HANDLE_INFORMATION_EX
{
	ULONG_PTR NumberOfHandles;
	ULONG_PTR Reserved;
	SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX Handles[1];
} SYSTEM_HANDLE_INFORMATION_EX, *PSYSTEM_HANDLE_INFORMATION_EX;

typedef enum _POOL_TYPE
{
	NonPagedPool,
	PagedPool,
	NonPagedPoolMustSucceed,
	DontUseThisType,
	NonPagedPoolCacheAligned,
	PagedPoolCacheAligned,
	NonPagedPoolCacheAlignedMustS
} POOL_TYPE, *PPOOL_TYPE;

typedef struct _OBJECT_TYPE_INFORMATION
{
	UNICODE_STRING Name;
	ULONG TotalNumberOfObjects;
	ULONG TotalNumberOfHandles;
	ULONG TotalPagedPoolUsage;
	ULONG TotalNonPagedPoolUsage;
	ULONG TotalNamePoolUsage;
	ULONG TotalHandleTableUsage;
	ULONG HighWaterNumberOfObjects;
	ULONG HighWaterNumberOfHandles;
	ULONG HighWaterPagedPoolUsage;
	ULONG HighWaterNonPagedPoolUsage;
	ULONG HighWaterNamePoolUsage;
	ULONG HighWaterHandleTableUsage;
	ULONG InvalidAttributes;
	GENERIC_MAPPING GenericMapping;
	ULONG ValidAccess;
	BOOLEAN SecurityRequired;
	BOOLEAN MaintainHandleCount;
	USHORT MaintainTypeList;
	POOL_TYPE PoolType;
	ULONG PagedPoolUsage;
	ULONG NonPagedPoolUsage;
} OBJECT_TYPE_INFORMATION, *POBJECT_TYPE_INFORMATION;

VOID WhoUsesFile(CString trFilePath, CString& strShow);
实现 

#include "stdafx.h"
#include "QuerySystemHandleInformationAndFindWhoUseMe.h"
#include "F:\Common\\fordebug.h"
#include <Psapi.h>
TCHAR	szNtPath[MAX_PATH] = { 0 };
WCHAR	processName[0x200] = { 0 };


PVOID GetLibraryProcAddress(PSTR LibraryName, PSTR ProcName)
{
	return GetProcAddress(GetModuleHandleA(LibraryName), ProcName);
}
_NtQueryObject NtQueryObject =
(_NtQueryObject)GetLibraryProcAddress("ntdll.dll", "NtQueryObject");
void ToCaps(PWCHAR lpFileName)
{
	if (!lpFileName)
	{
		return;
	}
	PWCHAR	travel = lpFileName;
	WCHAR	wChar = *travel;
	while (wChar != 0)
	{
		if (wChar >= 0x61 && wChar <= 0x7a)
		{
			*travel = wChar - 0x20;
		}
		travel += 1;
		wChar = *travel;
	}
}

BOOL DosPathToNtPath(LPTSTR pszDosPath, LPTSTR pszNtPath)
{
	TCHAR			szDriveStr[500];
	TCHAR			szDrive[3];
	TCHAR			szDevName[100];
	INT				cchDevName;
	INT				i;

	//检查参数
	if (!pszDosPath || !pszNtPath)
		return FALSE;

	//获取本地磁盘字符串
	if (GetLogicalDriveStrings(sizeof(szDriveStr), szDriveStr))
	{
		for (i = 0; szDriveStr[i]; i += 4)
		{
			if (!lstrcmpi(&(szDriveStr[i]), _T("A:\\")) || !lstrcmpi(&(szDriveStr[i]), _T("B:\\")))
				continue;

			szDrive[0] = szDriveStr[i];
			szDrive[1] = szDriveStr[i + 1];
			szDrive[2] = '\0';
			if (!QueryDosDevice(szDrive, szDevName, 100))//查询 Dos 设备名
				return FALSE;

			cchDevName = lstrlen(szDevName);
			if (_tcsnicmp(pszDosPath, szDevName, cchDevName) == 0)//命中
			{
				lstrcpy(pszNtPath, szDrive);//复制驱动器
				lstrcat(pszNtPath, pszDosPath + cchDevName);//复制路径

				return TRUE;
			}
		}
	}

	lstrcpy(pszNtPath, pszDosPath);

	return FALSE;
}

typedef struct _THREAD_CONTEXT_
{
	HANDLE	CompletedEventHandle;
	HANDLE	StartEventHandle;
	HANDLE	TargetHandle;
	HANDLE	ThreadHandle;
	PVOID	ObjectName;
}THREAD_CONTEXT,*PTHREAD_CONTEXT;
DWORD WINAPI CallWithTimeoutThreadStart(
	_In_ PVOID Parameter
)
{
	PTHREAD_CONTEXT threadContext = (PTHREAD_CONTEXT)Parameter;
	
	DWORD	dwReturnedLength = 0x200;
	DWORD	dwNewLength = 0x200;
	NTSTATUS	status = 0;
	while (TRUE)
	{
		if (WaitForSingleObject(threadContext->StartEventHandle, INFINITE) != STATUS_WAIT_0)
			continue;
		PUNICODE_STRING	objectName = (PUNICODE_STRING)threadContext->ObjectName;
		objectName->Length = objectName->MaximumLength  = 0;
		objectName->Buffer = NULL;
		if (!NT_SUCCESS(status = NtQueryObject(
			threadContext->TargetHandle,
			ObjectNameInformation,
			threadContext->ObjectName,
			dwReturnedLength,
			&dwNewLength
			)))
		{
			if (status == 0xc0000008) // STATUS_INVALID_HANDLE
			{
				objectName->Length = 0;
			}
			else if (status == 0xC0000039) // STATUS_OBJECT_PATH_INVALID
			{
				objectName->Length = 0;
			}
			else if (status == 0xC00000BB)// STATUS_NOT_SUPPORTED
			{
				objectName->Length = 0;
			}
			else
			{
				// 仅仅作为测试，其实失败了就应该将Length 置0
			}
		}
		SetEvent(threadContext->CompletedEventHandle);
	}

	return 0;
}
#define MAX_TYPE_COUNT 80
struct _TYPE_AND_INDEX_
{
	BOOL	bNew;
	BOOL	bTarget;
}g_Type[MAX_TYPE_COUNT];
VOID WhoUsesFile(CString strFileName, CString& strShow)
{

	NTSTATUS Status;
	PSYSTEM_HANDLE_INFORMATION_EX handleInfo;
	HANDLE	processHandle = NULL;
	static ULONG initialBufferSize = 0x10000;
	PVOID buffer;
	ULONG bufferSize;
	ToCaps(strFileName.GetBuffer());
	_NtQuerySystemInformation NtQuerySystemInformation =
		(_NtQuerySystemInformation)GetLibraryProcAddress("ntdll.dll", "NtQuerySystemInformation");
	_NtDuplicateObject NtDuplicateObject =
		(_NtDuplicateObject)GetLibraryProcAddress("ntdll.dll", "NtDuplicateObject");
	for (int i = 0; i < MAX_TYPE_COUNT; i++)
	{
		g_Type[i].bTarget = FALSE;
		g_Type[i].bNew = TRUE;
	}
	bufferSize = initialBufferSize;
	buffer = malloc(bufferSize);

	while ((Status = NtQuerySystemInformation(
		SystemExtendedHandleInformation,
		buffer,
		bufferSize,
		NULL
	)) == STATUS_INFO_LENGTH_MISMATCH)
	{
		free(buffer);
		bufferSize *= 2;

		// Fail if we're resizing the buffer to something very large.
		if (bufferSize > 256 * 1024 * 1024)
		{
			MessageBox(NULL, _T("需要的内存太大了"), NULL, MB_OK);
			return;
		}

		buffer = malloc(bufferSize);
	}

	if (!NT_SUCCESS(Status))
	{
		free(buffer);
		return;
	}

	if (bufferSize <= 0x200000) initialBufferSize = bufferSize;

	handleInfo = (PSYSTEM_HANDLE_INFORMATION_EX)buffer;
	DWORD dwThreadId;
	ULONG objectNameInfo_returnLength = 0x10000;
	ULONG objectTypeInfo_returnLength = 0x10000;
	POBJECT_TYPE_INFORMATION objectTypeInfo = (POBJECT_TYPE_INFORMATION)malloc(objectTypeInfo_returnLength);
	PFILE_NAME_INFO	ObjectName = (PFILE_NAME_INFO)malloc(0x1000);
	PTHREAD_CONTEXT ThreadContext = (PTHREAD_CONTEXT)malloc(sizeof(THREAD_CONTEXT));

	ThreadContext->ThreadHandle = ThreadContext->CompletedEventHandle = ThreadContext->StartEventHandle = ThreadContext->TargetHandle = NULL;
	ThreadContext->ObjectName = malloc(0x200);
	for (ULONG i = 0; i < handleInfo->NumberOfHandles; i++)
	{
		PSYSTEM_HANDLE_TABLE_ENTRY_INFO_EX handle = (PSYSTEM_HANDLE_TABLE_ENTRY_INFO_EX)&handleInfo->Handles[i];
		HANDLE dupHandle = NULL;
		UNICODE_STRING objectName;
		if (!g_Type[handle->ObjectTypeIndex].bNew && !g_Type[handle->ObjectTypeIndex].bTarget)
		{
			continue;
		}
		/* 拷贝过来. */
		if (handle->UniqueProcessId == GetCurrentProcessId())
		{
			continue;
		}
		
		processHandle = OpenProcess(PROCESS_DUP_HANDLE | PROCESS_QUERY_LIMITED_INFORMATION | PROCESS_VM_READ, FALSE, handle->UniqueProcessId);
		if (processHandle == NULL)
		{
			continue;
		}
		if (!NT_SUCCESS(NtDuplicateObject(
			processHandle,
			handle->HandleValue,
			GetCurrentProcess(),
			&dupHandle,
			0,
			0,
			DUPLICATE_SAME_ACCESS
		)))
		{
			continue;
		}
		/* 得到对象类型 */
		if (g_Type[handle->ObjectTypeIndex].bNew)
		{
			g_Type[handle->ObjectTypeIndex].bNew = FALSE;
			if (!NT_SUCCESS(NtQueryObject(
				dupHandle,
				ObjectTypeInformation,
				objectTypeInfo,
				objectTypeInfo_returnLength,
				NULL
			)))
			{
				MessageBox(NULL, _T("NtQueryObject失败"), NULL, MB_OK);
				CloseHandle(dupHandle);
				continue;
			}
			/*
			if (wcsicmp(objectTypeInfo->Name.Buffer, L"DmaAdapter") == 0 ||
			wcsicmp(objectTypeInfo->Name.Buffer, L"DmaDomain") == 0 ||
			wcsicmp(objectTypeInfo->Name.Buffer, L"DxgkSharedResource") == 0 ||
			wcsicmp(objectTypeInfo->Name.Buffer, L"DxgkSharedSyncObject") == 0 ||
			wcsicmp(objectTypeInfo->Name.Buffer, L"DxgkSharedSwapChainObject") == 0 ||
			wcsicmp(objectTypeInfo->Name.Buffer, L"FilterCommunicationPort") == 0 ||
			wcsicmp(objectTypeInfo->Name.Buffer, L"FilterConnectionPort") == 0 ||
			wcsicmp(objectTypeInfo->Name.Buffer, L"NdisCmState") == 0 ||
			wcsicmp(objectTypeInfo->Name.Buffer, L"PcwObject") == 0 ||
			wcsicmp(objectTypeInfo->Name.Buffer, L"VirtualKey") == 0 ||
			wcsicmp(objectTypeInfo->Name.Buffer, L"VRegConfigurationContext") == 0)
			{
			//if (wcsicmp(objectTypeInfo->Name.Buffer, L"DxgkSharedResource") != 0)
			{
			//if (wcsicmp(objectTypeInfo->Name.Buffer, L"DxgkSharedSyncObject") != 0)
			{
			//GetModuleFileNameEx(processHandle, NULL, processName, MAX_PATH);
			//MessageBox(NULL, _T("找到了"), NULL, MB_OK);
			}
			}
			//continue;
			}
			*/

			if (wcsicmp(objectTypeInfo->Name.Buffer, L"File") != 0 && wcsicmp(objectTypeInfo->Name.Buffer, L"Directory") != 0)
			{
				CloseHandle(dupHandle);
				CloseHandle(processHandle);
				g_Type[handle->ObjectTypeIndex].bTarget = FALSE;
				continue;
			}
			g_Type[handle->ObjectTypeIndex].bTarget = TRUE;
		}
		else
		{
			if (!g_Type[handle->ObjectTypeIndex].bTarget)
			{
				CloseHandle(dupHandle);
				CloseHandle(processHandle);
				continue;
			}
		}
		if (!ThreadContext->StartEventHandle)
		{
			if (!(ThreadContext->StartEventHandle = CreateEvent(NULL, FALSE, FALSE, NULL)))
			{
				MessageBox(NULL, L"创建事件失败", NULL, MB_OK);
				free(ThreadContext->ObjectName);
				break;
			}
		}

		if (!ThreadContext->CompletedEventHandle)
		{
			if (!(ThreadContext->CompletedEventHandle = CreateEvent(NULL, FALSE, FALSE, NULL)))
			{
				MessageBox(NULL, L"创建事件失败", NULL, MB_OK);
				free(ThreadContext->ObjectName);
				break;
			}
		}

		// 创建Query线程.
		if (!ThreadContext->ThreadHandle)
		{
			
			if (!(ThreadContext->ThreadHandle = (HANDLE)_beginthreadex(NULL, 0,(_beginthreadex_proc_type) CallWithTimeoutThreadStart, ThreadContext, 0, (unsigned int*)&dwThreadId)))
			{
				MessageBox(NULL, L"创建线程失败", NULL, MB_OK);
				break;
			}
		}
		ThreadContext->TargetHandle = dupHandle;
		
		SetEvent(ThreadContext->StartEventHandle);
		if ((Status = WaitForSingleObject(ThreadContext->CompletedEventHandle, 100)) != WAIT_OBJECT_0)
		{
			// 操作超时或者发生错误，KillThread
			TerminateThread(ThreadContext->ThreadHandle,0);
			WaitForSingleObject(ThreadContext->ThreadHandle,0);
			CloseHandle(ThreadContext->ThreadHandle);
			CloseHandle(ThreadContext->CompletedEventHandle);
			CloseHandle(ThreadContext->StartEventHandle);
			CloseHandle(dupHandle);
			CloseHandle(processHandle);
			ThreadContext->CompletedEventHandle = NULL;
			ThreadContext->StartEventHandle = NULL;
			ThreadContext->ThreadHandle = NULL;
			continue;
		}

	/*	if (handle->GrantedAccess == 0x0012019f || handle->GrantedAccess == 0 || handle->GrantedAccess == 0x001a019f || handle->GrantedAccess == 0x0016019f)
		{
			CloseHandle(dupHandle);
			continue;
		}*/

		/* Query the object name (unless it has an access of
		0x0012019f, on which NtQueryObject could hang. */
		// READ_CONTROL | SYNCHRONIZE[同步] | 读写执行，访问系统访问控制列表
		// 100100000    0001    1001      1111(EWR)
		// 1	   0000 0000    1000      0000
		//		     typedef struct _ACCESS_MASK {
		//          WORD   SpecificRights;	12
		//          BYTE  StandardRights;	1
		//          BYTE  AccessSystemAcl : 1;	1
		//          BYTE  Reserved : 3;			1
		//          BYTE  GenericAll : 1;		1
		//          BYTE  GenericExecute : 1;	1
		//          BYTE  GenericWrite : 1;		1
		//          BYTE  GenericRead : 1;		1
		//      } ACCESS_MASK;
	
		
		PUNICODE_STRING	strObjectName = (PUNICODE_STRING)ThreadContext->ObjectName;
		
		if (strObjectName->Buffer && (strObjectName->Buffer == (PWCHAR)(strObjectName + 1)) && strObjectName->Length)
		{
			wcsncpy(processName, strObjectName->Buffer, 0x200);
			ToCaps(strObjectName->Buffer);
			if (wcsstr(strObjectName->Buffer, strFileName))
			{
				DosPathToNtPath(processName, szNtPath);
				GetModuleFileNameEx(processHandle, NULL, processName, MAX_PATH);
				strShow.AppendFormat(L"文件名:%s\r\n进程名：%s\r\n\r\n", szNtPath, processName);
			}
		}
		CloseHandle(dupHandle);
		CloseHandle(processHandle);
	}
	
	free(objectTypeInfo);
	free(ThreadContext->ObjectName);
	free(ThreadContext);
	free(buffer);
	free(ObjectName);
	TerminateThread(ThreadContext->ThreadHandle, 0);//  这里我们就直接Kill了，不设置让线程自动退出了
	WaitForSingleObject(ThreadContext->ThreadHandle, 0);
	return;
}
使用 

void CWhoUseMEDlg::OnBnClickedFind()
{
	CString	strFileName;
	CString strShow;
	GetDlgItemText(IDC_EDIT_FILE, strFileName);
	if (strFileName != L"")
	{
		WhoUsesFile(strFileName, strShow);
	}
	else
	{
		AfxMessageBox(_T("请输入文件名"));
		return;
	}
	SetDlgItemText(IDC_USE,strShow);
}



内核代码将来补上

kiki商
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sys port and process
nethm的专栏
12-18 839
#include "ntddk.h"#include "string.h"#define SystemHandleInformation  16#define TCPUDP_FLAG   100#define WIN2K_SOCKET_FLAG  0x1a //2k#define WINXP_SOCKET_FLAG  0x1c //xp#define WIN2K3_SOCKET_FLAG  0x1a //2k3#define WIN2K_EPROCESS_NAMEOFFSET    0x1fc //2k#d
文件句柄占用问题排查经历
m0_53246313的博客
03-22 3912
记录一次文件句柄占用的排查过程。 问题现象 部署服务器的虚拟机，文件句柄数每天都会增加，最终文件句柄数耗尽，服务无法正常工作。 排查过程 1. lsof 查看文件占用的文件句柄数 由于文件句柄数的增加，只在应用启动后开始，可以定位问题是由于应用引起。 通过【lsof -p 进程号】命令，查看进程的文件句柄占用。 发现大量的文件句柄为： java 116023 root 7485u sock 0,7 0t0 282463093 protocol:TCPv6 这意味着文件句柄占用来自于套接字，即连接请求。
采用关闭句柄的方式去掉程序多开的限制
yu_xiyan的专栏
01-23 7571
下面的文字，主要是为了分享给和我一样的菜鸟，而且这些东西都是很多大牛的文章中的一个非常小的部分。您们直接飘过吧。     一些程序限制多开的方法很多，比如采用窗口名，进程名，内核对象等等，论坛中也有很多关于这方面的介绍，但是好像没有一个具体的例子，估计是觉得太简单了吧。我研究的这程序的限制多开的方法采用的是“内核对象信号量”。     要破解其多开也有很多方法：     1、直接
_SYSTEM_INFORMATION_CLASS
denggengwen3333的博客
08-02 812
typedef enum _SYSTEM_INFORMATION_CLASS{ SystemBasicInformation, // q: SYSTEM_BASIC_INFORMATION SystemProcessorInformation, // q: SYSTEM_PROCESSOR_INFORMATION SystemPerformanceInformation, // q...
利用NtDuplicateObject进行Dump
最新发布
2401_84466225的博客
06-20 962
由于传播、利用此文所提供的信息而造成的任何直接或者间接的后果及损失，均由使用者本人负责，文章作者不为此承担任何责任。（本文仅用于交流学习）这是国外老哥2020年提出的一种蛮有意思的思路。我们先来看看大致的思路是什么样子的，然后来看看一些需要学习的点。首先我们需要获得调式权限（SeDebugPrivilege）然后我们使用NtQuerySystemInformation生成所有进程打开的所有句柄利用OpenProcess打开句柄，赋予PROCESS_DUP_HANDLE权限。
进程的枚举
kingswb的博客
05-02 655
1、利用ToolHelp API 首先创建一个系统快照，然后通过对系统快照的访问完成进程的枚举。 获取系统快照使用CreateToolhelp32Snapshot() 函数 函数原型声明如下： HANDLE WINAPI CreateToolhelp32Snapshot(                DWORD dwFlags,                DWOR
枚举进程：ring3->ring0
dog0230的博客
05-10 184
链 接: http://bbs.pediy.com/showthread.php?t=106745 用google搜索了几天相关内容的资料，将所提到的逐一实现。哎，不禁感叹自己太菜了。居然用了几天的时间。没啥新思想、内容，只是总结，当然还有其他 方法没总结到。但经常提到的ring3下的快照、psapi的EnumProcesses、暴力OpenProcess;ring0下 的ZwQuer...
- 枚举系统窗口和取得句柄例程及关闭窗口.rar
04-03
窗口句柄是Windows系统中标识窗口的唯一标识符，你可以通过窗口类名、窗口标题或者其他属性来查找特定的窗口句柄。例如，`FindWindow`函数可以用于根据窗口类名和标题找到一个窗口： ```cpp HWND FindWindow...
C++ 中CloseHandle 函数--关闭一个句柄
08-30
句柄是Windows操作系统中用于标识和访问对象的一种机制，如文件、设备、进程、线程等。使用`CloseHandle`函数能够有效地管理资源，防止内存泄漏和系统资源耗尽。 函数原型： ```cpp BOOL WINAPI CloseHandle( _In_...
易语言-易语言枚举进程所有句柄
06-25
在Windows操作系统中，进程是程序执行时的一个实例，而句柄则是操作系统分配给进程、线程、窗口、文件等对象的一种标识符，用于系统内部操作和管理。枚举进程所有句柄意味着我们可以通过编程获取当前系统中所有进程...
商业编程-源码-枚举当前打开的程序窗口.zip
06-23
然而，这里的“枚举当前打开的程序窗口”是指遍历并获取操作系统中所有可见的窗口句柄，这些句柄是操作系统用来管理和操作窗口的对象标识。这通常涉及到Windows API，特别是那些与窗口管理相关的函数。 Windows API...
- 枚举系统窗口和取得句柄例程及关闭窗口.e.rar
04-03
在给定的压缩包文件“[神2也教你学E] - 枚举系统窗口和取得句柄例程及关闭窗口.e”中，可能包含了实现这些功能的示例代码。学习这个例子，可以帮助你更好地理解和应用这些Windows API函数，从而在开发过程中实现对...
获取本进程所有句柄和资源
要把所有那些负面的信息当做对自身行为的评价，而不是对自身价值的评判。
03-09 243
获取本进程所有句柄和资源
VC++文件操作之最全篇(总结一下希望对大家有用)
独旅天涯
04-25 3696
一、剖析VC中的文件操作       各种关于文件的操作在程序设计中是十分常见，如果能对其各种操作都了如指掌，就可以根据实际情况找到最佳的解决方案，从而在较短的时间内编写出高效的代码，因而熟练的掌握文件操作是十分重要的。本文将对Visual C++中有关文件操作进行全面的介绍，并对在文件操作中经常遇到的一些疑难问题进行详细的分析。 　　1．文件的查找 　　当对一个文件操作时，如果
★★★★Excel-VBA操作文件四大方法之四
tourstar的专栏
06-05 672
四、利用API函数来处理文件通过前面三种方法的介绍，你是否已经觉得足够了？是的，前面的方法完全可以应付几乎所有的文件操作。但是为了普及一下API，展示一下API的魅力，最后向大家介绍一下如何利用API函数来处理文件。另一方面也是本人对API情有独钟，为她做一下广告，呵呵。大家对API的强大也是有所耳闻了，在文件操作方面，API自然毫不逊色。说明：为了文章简洁，我们先给出API函
从文件句柄得到文件路径的函数 （一）
求索
02-02 2668
从文件句柄得到文件路径的函数 主要思路: 1. 调用 GetFileInformationByHandle  函数得到指定文件句柄的相应文件信息, 再调用 GetLogicalDriveStrings 函数得到所有驱动器盘符, 用 GetVolumeInformation 函数遍历每个盘符, 取得盘符的卷序列号, 然后与前一步得到的文件信息比较, 找到该文件的盘符. 2. 调用 Zw
稀疏文件（Sparse File）
热门推荐
tiandyoin的专栏
02-02 1万+
稀疏文件，这是UNIX类和NTFS等文件系统的一个特性。 开始时，一个稀疏文件不包含用户数据，也没有分配到用来存储用户数据的磁盘空间。当数据被写入稀疏文件时，NTFS逐渐地为其分配磁盘空间。一个稀疏文件有可能增长得很大。 稀疏文件以64KB（不同文件系统不同）为单位增量增长，因此磁盘上稀疏文件的大小总是64KB的倍数。 稀疏文件就是在文件中留有很多空余空间，留备将来插入数据使用。如果这些空余
用户态枚举进程的几种方法
jingzhongrong
02-13 2061
最近在准备一个进程查看（当然不只进程查看功能了）的工具，总结了在用户态下查找进程的几种方法。当然，如果想要真正做到进程查看，还是要进入核心态中，因为在用户态是查不到什么东西的，但是可以用来和核心态结果进行比较找出隐藏进程。（内核级病毒、木马在Ring0中可以很容易的做到隐藏而是用户态程序检测不到）。//write by jingzhongrong1、利用ToolHelp API
如何调整vue-draggable-resizable resize的句柄样式
05-19
你可以通过修改vue-draggable-resizable组件的样式来调整resize句柄的样式。具体来说，你需要在CSS中添加以下样式： ```css .vue-draggable-resizable-handle { background-color: #ccc; /* 句柄背景颜色 */ border: 1px solid #999; /* 句柄边框样式 */ width: 8px; /* 句柄宽度 */ height: 8px; /* 句柄高度 */ padding: 2px; /* 句柄内边距 */ margin: -5px; /* 句柄外边距 */ } ``` 你可以根据需要修改这些样式属性来调整resize句柄的样式。例如，你可以修改背景颜色、边框样式、宽度、高度、内边距、外边距等属性来改变句柄的外观。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值