32位windows的全局hook

最新推荐文章于 2024-07-15 23:08:41 发布
最新推荐文章于 2024-07-15 23:08:41 发布
阅读量635 收藏
点赞数 1
分类专栏： windows内核学习笔记 文章标签： 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46308946/article/details/114501440
版权

1、思路：

整理以前的代码，顺便写个帖子。该方法是利用驱动构建调用门和中断门，然后利用调用门修改页相关dll的页属性，再利用中断门来hook相关的函数。当然也有更简单的方法，此方法是利用调用门和中断门的使用，当然64位下是行不通的，会触发pg。64需要切换gs，（x86是fs寄存器指向teb和kpcr）

2、驱动

#include <ntifs.h>
#include <ntddk.h>
#include <stdio.h>
#define DEVICENAME L"\\Device\\FuncHook"
#define SYMBOLNAME L"\\??\\Hook"

#define	StartHook CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ANY_ACCESS)
#define	StopHook CTL_CODE(FILE_DEVICE_UNKNOWN,0x900,METHOD_BUFFERED,FILE_ANY_ACCESS)
CHAR* GdtrTable[0x6] = { 0 };
CHAR* LdtrTale[0x6] = { 0 };
ULONG FuncAddress = 0;
ULONG MessageHwnd = 0;
ULONG MessageString = 0;
ULONG MessageTitle = 0;
ULONG MessageSelect = 0;
BOOLEAN FuncHook() {
	/**该方法由于不是目标程序的CR3，无法读取到目标程序内存，用调用门提权的方式**/
	/*
	ULONG CR3 = *(int*)((char*)Process + 0x18);
	KdPrint((CR3));
	if (CR3 == 0) {
		KdPrint(("寻找CR3失败"));
		return -1;
	//改变PTE属性
	__asm {
		pushad
		pushfd
		mov ecx,cr3
		mov ebx,CR3
		mov eax, FuncAddress
		//右移动18位置，相当于右移21位，再左移3位。2-9-9-12分页
		shr eax, 0x12
		mov esi,0x3ff8
		and eax,esi
		//想到与add eax,0xC0600000，找到PTE
		sub eax,0x3FA00000
		//取出PTE
		mov edx,[eax]
		//改变PTE属性为可读可写，or edx,0x0110     U/S=1 普通用户，
		or edx,0x5
		//右移动9位，取出PDT
		popfd
		popad
	*/
	//1、获取GDT的值

	__asm {
		pushad
		pushfd
		sgdt GdtrTable
		lea eax, [GdtrTable + 2]
		mov eax, [eax]
		//在0x90偏移处构建调用们
		lea eax, [eax + 0x94]
		mov ecx, FuncAddress      //0x77D517EA
		mov esi, ecx              //esi = 0x77D517EA					      
		and esi, 0xffff0000		 //esi = 0x77D50000
		add esi, 0xec00			//esi = 0x77D5ec00	
		mov[eax], esi
		lea eax, [eax - 4]
		and ecx, 0xffff
		add ecx, 0x00080000
		mov[eax], ecx
		popfd
		popad

	}

	return STATUS_SUCCESS;
}

VOID writefile() {
	OBJECT_ATTRIBUTES objectAttributes;
	IO_STATUS_BLOCK iostatus;
	HANDLE hFile;
	UNICODE_STRING logFileUnicodeString;
	//初始花unicode_string字符串
	RtlInitUnicodeString(&logFileUnicodeString, L"\\??\\C:\\1.txt");
	//初始化对象属性宏
	InitializeObjectAttributes(&objectAttributes, &logFileUnicodeString, OBJ_CASE_INSENSITIVE, NULL, NULL);
	NTSTATUS ntstatus = ZwCreateFile(&hFile, FILE_APPEND_DATA, &objectAttributes, &iostatus, NULL,
		FILE_ATTRIBUTE_NORMAL, FILE_SHARE_WRITE, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
	UCHAR pBuffer[200] = { 0 };
	char* ProcessName = (char*)PsGetCurrentProcess() + 0x174;  //偏移0x174处，是fileImageName
	sprintf(pBuffer, "进程名称:%s HWND:%X Text:%s Caption:%s Type:%X \r\n", ProcessName, MessageHwnd,
		MessageString, MessageTitle, MessageSelect);
	KdPrint(("%s", pBuffer));
	ZwWriteFile(hFile, NULL, NULL, NULL, &iostatus, pBuffer, strlen(pBuffer), NULL, NULL);
	KdPrint(("The program really appended %d bytes\n", iostatus.Information));
	ZwClose(hFile);//关闭文件句柄
}

//建立中断门
VOID _declspec(naked) HookFunc() {
	__asm {
		pushad
		pushfd
		int 3
	}
	DbgPrint("%s", "HookFunc");
	_asm {
	//找到三环esp
		lea eax, [esp + 0x30]
		mov eax, [eax]
		//第一个参数
		mov ebx, eax
		lea eax, [ebx + 0x4]
		mov eax, [eax]
		mov [MessageHwnd], eax
		lea eax, [ebx + 0x8]
		mov eax, [eax]
		mov [MessageString], eax
		lea eax, [ebx + 0xc]
		mov eax, [eax]
		mov [MessageTitle], eax
		lea eax,[ebx+0x10]
		mov eax,[eax]
		mov [MessageSelect],eax
		
	}
	writefile();
	__asm {
		popfd
		popad
	}
	__asm {
		push 0x3b
		pop fs
		iretd
	}

}
BOOLEAN SetIntDoor(PVOID HookFunc) {
	__asm {
		pushad
		pushfd
			sidt LdtrTale
			mov eax,[LdtrTale+2]   //获取ldtr的地址
			add eax,0x100
			//构建调用们
			mov ebx,HookFunc
			mov esi,ebx
			//计算低四位
			and ebx,0xffff
			add ebx,0x00080000
			mov [eax],ebx
			//计算高四位
			and esi,0xffff0000
			add esi,0xee00
			add eax,0x4
			mov [eax],esi
		popfd
		popad
		
	}
	return STATUS_SUCCESS;

}


NTSTATUS DriverUnload(PDRIVER_OBJECT pDriver) {
	UNICODE_STRING symbolLink;
	RtlInitUnicodeString(&symbolLink, SYMBOLNAME);
	IoDeleteSymbolicLink(&symbolLink);
	IoDeleteDevice(pDriver->DeviceObject);
	KdPrint(("卸载成功"));
	return STATUS_SUCCESS;
}

NTSTATUS ChangePage(DEVICE_OBJECT* DeviceObject, IRP* Irp) {
	NTSTATUS status;
	PIO_STACK_LOCATION pIrpStack;
	ULONG uIoControlCode;
	PVOID pIoBuffer;
	ULONG InLength;
	ULONG OutLength;

	__asm {
		int 3
	}
	//获取IRP数据
	pIrpStack = IoGetCurrentIrpStackLocation(Irp);
	//获取控制码
	uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
	//获取缓冲区地址
	pIoBuffer = Irp->AssociatedIrp.SystemBuffer;
	//获取3环数据长度
	InLength = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
	//获取0环发送的数据长度
	OutLength = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
	PEPROCESS Process = 0;
	switch (uIoControlCode) {
	case StartHook:
		//获取三环发送过来的函数地址
		
		memcpy(&FuncAddress, pIoBuffer, 4);
		if (FuncAddress == 0) {
			KdPrint(("FuncAddress地址为0"));
			IoCompleteRequest(Irp, IO_NO_INCREMENT);
			return -1;
		}
		if (!Process) {
			
			if (NT_SUCCESS(FuncHook()) && NT_SUCCESS(SetIntDoor(HookFunc))){           //&& NT_SUCCESS(SetIntDoor(FuncAddress))
				*(int*)(pIoBuffer) = 1;
				Irp->IoStatus.Status = STATUS_SUCCESS;
				Irp->IoStatus.Information = 1;
				IoCompleteRequest(Irp, IO_NO_INCREMENT);
				return STATUS_SUCCESS;
			}
			else {
				KdPrint(("创建调用门失败"));
				Irp->IoStatus.Status = -1;
				Irp->IoStatus.Information = 0;
				IoCompleteRequest(Irp, IO_NO_INCREMENT);
				return -1;
			}
			
		}
		else
		{
			KdPrint(("没有获取到CR3或PID"));
			Irp->IoStatus.Status = -1;
			Irp->IoStatus.Information = 0;
			IoCompleteRequest(Irp, IO_NO_INCREMENT);
			return -1;
		}

	}
	
}
NTSTATUS IrpCreate(DEVICE_OBJECT* DeviceObject, IRP* Irp) {
	KdPrint(("设备连接"));
	Irp->IoStatus.Status = STATUS_SUCCESS;
	Irp->IoStatus.Information = 0;
	IoCompleteRequest(Irp, IO_NO_INCREMENT);
	return STATUS_SUCCESS;



}
NTSTATUS IrpClose(DEVICE_OBJECT* DeviceObject, IRP* Irp) {

	KdPrint(("设备断开"));
	Irp->IoStatus.Status = STATUS_SUCCESS;
	Irp->IoStatus.Information = 0;
	IoCompleteRequest(Irp, IO_NO_INCREMENT);
	return STATUS_SUCCESS;



}
NTSTATUS DriverEntry(PDRIVER_OBJECT pDriver, PUNICODE_STRING Path) {
	//测试用函数
	


	NTSTATUS status;
	pDriver->DriverUnload = DriverUnload;

	UNICODE_STRING DeviceName;
	UNICODE_STRING SymbolName;
	DEVICE_OBJECT Device;
	//初始化设备对象名
	RtlInitUnicodeString(&SymbolName, SYMBOLNAME);
	RtlInitUnicodeString(&DeviceName, DEVICENAME);
	//创建符号链接
	status = IoCreateSymbolicLink(&SymbolName, &DeviceName);
	if (!NT_SUCCESS(status)) {
		KdPrint(("创建符号连接失败"));
		return status;
	}
	//创建设备对象
	status = IoCreateDevice(pDriver, NULL, &DeviceName, FILE_DEVICE_UNKNOWN, FILE_DEVICE_SECURE_OPEN, TRUE, &Device);
	if (!NT_SUCCESS(status)) {
		KdPrint(("创建设备对象失败"));
		return status;
	}
	//设置设备交互模式
	pDriver->Flags |= DO_BUFFERED_IO;
	//设置派遣函数
	pDriver->MajorFunction[IRP_MJ_CREATE] = IrpCreate;
	pDriver->MajorFunction[IRP_MJ_CLOSE] = IrpClose;
	pDriver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ChangePage;

	return STATUS_SUCCESS;
}

3、3环

#include "stdafx.h"
#include "resource.h"
#include <windows.h>
#include <WinIoCtl.h>
#define SYMBOLNAME L"\\\\.\\Hook"
#define IN_BUFFER_MAXLENGTH	            0x10		//输入缓存最大长度
#define OUT_BUFFER_MAXLENGTH	        0x4		//输出缓存最大长度
#define	StartHook CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ANY_ACCESS)
#define	StopHook CTL_CODE(FILE_DEVICE_UNKNOWN,0x900,METHOD_BUFFERED,FILE_ANY_ACCESS)

TCHAR szFilePath[MAX_PATH + 1]={0};
LPCWSTR SysName = L"\\FuncHook.sys";
LPCWSTR ServiceName = L"FuncHook";
HANDLE g_hDriver = 0;
DWORD FuncAddress = 0;
SC_HANDLE ScHandle = 0;
DWORD Start =0;
DWORD MessageBoxAddress  = 0;
DWORD HookFuncAddresss =0;
DWORD CR3get=0;

DWORD First = 0;
DWORD Second = 0;
DWORD Thirst = 0;
DWORD Foure = 0;

//构造调用门修改页表属性
void _declspec(naked) StartListen(){
	__asm{
		int 3
		pushad
		pushfd
			//改变messagebox的地址为write/read
			int 3
			mov eax,MessageBoxAddress
			mov esi,eax
			//chage PTE
			shr esi,0x12
			and esi,0x3FF8
			sub esi,0x3FA00000
			mov edx,[esi]
			or edx,0x3
			mov [esi],edx
			//change PDT
			shr eax,0x9
			and eax,0x7FFFF8
			add eax,0xc0000000
			mov edx,[eax]
			or edx,0x3
			mov [eax],edx
		/*	mov eax,cr3
			mov CR3,eax*/
		popfd
		popad
		retf
	}
}

//修改MessageBoxA的前两个字节为int 20

BOOL ChangeMeeageBoxA(){
	char * address = (char *)MessageBoxAddress;
	*(address) =0xcd;
	*(address+1)=0x20;
	if(*(address+1)!=0x20 && *(address)!=0xcd){
		return FALSE;
	}
	else{
		return TRUE;
	}

}

BOOL RecoverMessageBoxA(){
	char * address = (char *)MessageBoxAddress;
	*(address) =0x8b;
	*(address+1)=0xFF;
	if(*(address+1)!=0xFF && *(address)!=0x8b){
		return FALSE;
	}
	else{
		return TRUE;
	}

}

//void _declspec(naked) HookStart(){
//	__asm{
//		mov esi,cr3
//		mov edi,CR3get
//		mov cr3,edi     //
//		jmp HookFuncAddresss
//	}
//
//}
//void __declspec(naked) FuncHook(){
//	__asm{
//		push ebp
//		mov ebp,esp
//		push esi    //保存原来的CR3
//		pushad      //保存原来环境
//		pushfd
//		获取 参数 1
//		mov eax,[ebp+4]
//		mov First,eax
//		mov eax,[ebp+8]
//		mov Second,eax
//		mov eax,[ebp+0xc]
//		mov Thirst,eax
//		mov eax,[ebp+0x10]
//		mov Foure,eax
//		
//	}
//
//}
//打开驱动服务句柄
BOOL Open(LPCWSTR pLinkName){
	TCHAR szBuffer[10] ={0};
	g_hDriver = CreateFile(pLinkName,GENERIC_READ|GENERIC_WRITE,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
	if(g_hDriver ==INVALID_HANDLE_VALUE){
		DWORD error = ::GetLastError();
		wsprintf(szBuffer,L"打开服务句柄失败%d\n",error);
		MessageBox(0,szBuffer,0,0);
		CloseHandle(g_hDriver);
		return FALSE;
	}
	return TRUE;
}
//注册驱动服务

BOOL Register(){
		//获取驱动管理器
		ScHandle = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
		if (ScHandle == NULL) {
			DWORD error = GetLastError();
		/*MessageBox(0, TEXT("获取服务管理器失败"), 0, 0);*/
			TCHAR ErrorMessage[0x30] = { 0 };
			wsprintf(ErrorMessage, TEXT("获取服务管理器失败:%x"), error);
			MessageBox(0,ErrorMessage,0,0);
			CloseServiceHandle(ScHandle);
			return FALSE;
		}
		//创建服务
		SC_HANDLE ScService = CreateService(ScHandle,ServiceName,ServiceName,SERVICE_ALL_ACCESS,SERVICE_KERNEL_DRIVER,SERVICE_DEMAND_START,SERVICE_ERROR_NORMAL,szFilePath,NULL,NULL,NULL,NULL,NULL);
		if(ScService==NULL){
			DWORD error = GetLastError();
		if (error == ERROR_SERVICE_EXISTS) {
			CloseServiceHandle(ScService);

			return TRUE;
		}
		else {
			TCHAR ErrorMessage[0x30] = { 0 };
			wsprintf(ErrorMessage, TEXT("创建服务错误:%x"), error);
			MessageBox(0,ErrorMessage,0,0);
			CloseServiceHandle(ScService);
			CloseServiceHandle(ScHandle);
			return FALSE;
		}
	}
		CloseServiceHandle(ScService);
		return TRUE;	
}
//运行驱动
BOOL StartSys(){
	SC_HANDLE ServiceHandle = OpenService(ScHandle,ServiceName,SERVICE_ALL_ACCESS);
	if(ServiceHandle ==NULL){
		DWORD error = GetLastError();
		if (error == ERROR_SERVICE_DOES_NOT_EXIST) {
			TCHAR ErrorMessage[0x30] = { 0 };
			wsprintf(ErrorMessage, TEXT("服务已经不存在:%x"), error);
			MessageBox(0, ErrorMessage,0,0);
			CloseServiceHandle(ServiceHandle);
			
		}
		else {
			TCHAR ErrorMessage[0x30] = { 0 };
			wsprintf(ErrorMessage, TEXT("打开服务错误:%x"), error);
			MessageBox(0, ErrorMessage,0,0);
			CloseServiceHandle(ServiceHandle);
			
		}
		return FALSE;
	}
	if(!StartService(ServiceHandle,0,NULL)){
		DWORD error = GetLastError();
		if (error == ERROR_SERVICE_ALREADY_RUNNING)
		{
			return TRUE;
		}
		else
		{
			TCHAR ErrorMessage[0x30] = { 0 };
			wsprintf(ErrorMessage, TEXT("启动服务出错:%x"), error);
			MessageBox(0,ErrorMessage,0,0);
			CloseServiceHandle(ServiceHandle);
			return FALSE;
		}
	}
	return TRUE;
}
//停止驱动
BOOL StopSys(){
	SC_HANDLE serviceHandle = OpenService(ScHandle, ServiceName, SERVICE_ALL_ACCESS);
	if (serviceHandle == NULL) {
		DWORD error = GetLastError();
		if (error == ERROR_SERVICE_DOES_NOT_EXIST) {
			MessageBox(0,_T("服务已不存在"),0,0);
			CloseServiceHandle(serviceHandle);
		
		}
		else {
			TCHAR ErrorMessage[0x30] = { 0 };
			wsprintf(ErrorMessage, TEXT("打开服务错误:%x"), error);
			MessageBox(0,ErrorMessage,0,0);
			CloseServiceHandle(serviceHandle);
		}
		return FALSE;
	}
	SERVICE_STATUS error = {0};
	if(!ControlService(serviceHandle,SERVICE_CONTROL_STOP,&error)){
		DWORD errorCode = GetLastError();
		if (errorCode == ERROR_SERVICE_NOT_ACTIVE)
		{	
			CloseServiceHandle(serviceHandle);
			return TRUE;
		}
		else
		{
			TCHAR ErrorMessage[0x30] = { 0 };
			wsprintf(ErrorMessage, TEXT("停止驱动出错:%x"), errorCode);
			MessageBox(0,ErrorMessage,0,0);
			CloseServiceHandle(serviceHandle);
			return FALSE;
		}
	
	}
	SERVICE_STATUS status;
	QueryServiceStatus(serviceHandle,&status);
	if(status.dwCurrentState ==SERVICE_STOP_PENDING){
		DWORD dwWaitTime = status.dwWaitHint/10;
		if(dwWaitTime<1000){
			dwWaitTime=1000;
		}
		else if(dwWaitTime>10000){
			dwWaitTime=10000;
		}
		Sleep(dwWaitTime);
	}
	if(QueryServiceStatus(serviceHandle,&status)){
		if(status.dwCurrentState ==SERVICE_STOPPED){
				CloseServiceHandle(serviceHandle);
		}
	}
	CloseServiceHandle(serviceHandle);
	return TRUE;
}
//卸载驱动
BOOL DeleteSys(){
	SC_HANDLE serviceHandle = OpenService(ScHandle,ServiceName,SERVICE_ALL_ACCESS);
	if (serviceHandle == NULL) {
		DWORD error = GetLastError();
		if (error != ERROR_SERVICE_DOES_NOT_EXIST) {
			TCHAR ErrorMessage[0x30] = { 0 };
			wsprintf(ErrorMessage, TEXT("打开服务错误:%x"), error);
			MessageBox(0,ErrorMessage,0,0);
			CloseServiceHandle(serviceHandle);
			CloseServiceHandle(ScHandle);
			return FALSE;
		}
		
	}
	if (!DeleteService(serviceHandle) ){
		DWORD error = GetLastError();
			TCHAR ErrorMessage[0x30] = { 0 };
			wsprintf(ErrorMessage, TEXT("卸载驱动出错:%x"), error);
			MessageBox(0,ErrorMessage,0,0);
			CloseServiceHandle(serviceHandle);
			CloseServiceHandle(ScHandle);
			return FALSE;	
	}
	SERVICE_STATUS status;
	QueryServiceStatus(serviceHandle,&status);
	
	CloseServiceHandle(serviceHandle);
	CloseServiceHandle(ScHandle);
	ScHandle = NULL;
	return TRUE;
	
}
BOOL IoControl(DWORD dwIoCode,PVOID InBuffer,DWORD InBufferLength,PVOID OutBuffer,DWORD OutBufferLength){
	DWORD dw;
	DeviceIoControl(g_hDriver,dwIoCode,InBuffer,InBufferLength,OutBuffer,OutBufferLength,&dw,NULL);
	return TRUE;
}

INT_PTR CALLBACK  DiagBoxCallBackProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
	switch (uMsg)
	{
	case WM_CLOSE: {
		
		if(Start){
			RecoverMessageBoxA();
			StopSys();
			DeleteSys();
			
		}
		EndDialog(hwnd,0);
		return TRUE;
	}
	case WM_COMMAND: {
		switch (LOWORD(wParam))
		{
		case IDC_START:{
			DWORD selcet = MessageBoxA(0,"开始监控?",0,MB_OKCANCEL);
			if(selcet == IDCANCEL){
				return TRUE;
			}
			
			DWORD out = 0;
			if(Register()){
				if(StartSys()){
					Open(SYMBOLNAME);

					IoControl(StartHook,&FuncAddress,IN_BUFFER_MAXLENGTH,&out,OUT_BUFFER_MAXLENGTH);			
					if(out ==1){
						Start = 1;
						CHAR CallAddress[] = {0x00,0x00,0x00,0x00,0x93,0x00};
						__asm{
							call fword ptr ds:[CallAddress]
							push 0x3b
							pop fs
						}
						if(!ChangeMeeageBoxA()){
							MessageBox(0,_T("修改MessageBoxA内容失败"),0,0);
						}
						MessageBoxA(0,"hello",0,0);
						//Hook MessageBoxA
						
					}
				}
			}
			return TRUE;
		}
		case IDC_STOP:
			
			if(Start ==1){
				RecoverMessageBoxA();
				StopSys();
				DeleteSys();
				Start=0;
				
			}
			return TRUE;
	}
	default:
		return FALSE;
		break;
	}
	return FALSE;	
	}
}

int APIENTRY wWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance,
	_In_ LPWSTR    lpCmdLine, _In_ int       nCmdShow)
{

	GetCurrentDirectory(MAX_PATH,szFilePath);
	//拼接成驱动的路径

	lstrcatW(szFilePath,SysName);
	DWORD JmpAddress = (DWORD)StartListen;      //0x000322e9         E9 22 03 00 00
	DWORD Offset_W = (*(int*)((char*)JmpAddress+1));    //0x00 00 03 22     

	//*dword offset  = ((offset_w&0x000000ff)<<24)+((offset_w&0x0000ff00)<<8)+((offset_w&0x00ff0000)>>8)+((0xff000000&offset_w)>>24);*/
	FuncAddress = JmpAddress+5+Offset_W;
	
	MessageBoxAddress = (DWORD)&MessageBoxA;
	
	CHAR LDTR[6]={0};
	
	HookFuncAddresss = (DWORD)VirtualAlloc(NULL,0x1000,MEM_COMMIT,PAGE_EXECUTE_READWRITE);
	DialogBox(hInstance,MAKEINTRESOURCE(IDD_MAIN),0,DiagBoxCallBackProc);

	return 0;
}
寒江独钓(MCC)
关注
专栏目录
WIN32 Inline HOOK
hambaga的博客
08-14 522
Inline hook 和CE里面的代码注入很像（应该是一个东西），这个技术的原理是，修改汇编指令，让某个指令跳转到我们定义的函数，然后在函数内完成被替换的指令，然后再跳转回去。在我们定义的函数内，我们可以实时获取寄存器的值，从而可以完成对函数行为的监视和修改。 在我们定义的函数内，需要注意，寄存器的值和堆栈状态，执行前后必须完全一致，否则程序会出错。为了实现这个目的，我们需要用到裸函数。 下面是代码，要注意代码中使用的地址仅在我的机器上有效，如果你要编译这个程序，第一次运行会失败，请根据生成的汇编代码，找
C# 键盘鼠标全局钩子（拦截键盘鼠标所有操作）全局HOOK
01-05
C#实现键盘鼠标全局钩子 VS2013，可编译运行，带DEMO 可全局拦截鼠标单击/双击/滚动事件 可全局拦截键盘按键事件 可锁定键盘鼠标输入，比如锁屏！ 该代码无法屏蔽Ctrl +alt +delete 需要实现所有拦截，请参考相关...
windows 全局hook
weixin_34289454的博客
02-11 177
最近有用到全局hook，其实可参考windows核心编程，全局hook也是Dll注入的一种方式。首先，必须是一个Dll，可导出一个接口，在其中设置全局hook，类型为WH_GETMESSAGE(这样，应该是所有进程都会被hook到了)，这样成功后，系统会把这个Dll注入到有getmessage的所有进程中，即会为每个进程隐式调用下loadlibrary。然后每次getmess...
Win32-HOOK技术
最新发布
qq_36318563的博客
07-15 278
1. HOOK技术本质是利用 API 来提前拦截并处理 Windows 消息的一种技术。2. 运行机制：钩子实际上是一个处理消息的程序段，通过系统调用，把它挂入系统中，每当特定的消息发出，在到达目的窗口之前，钩子程序就先截获该消息，这时钩子函数即可以加工处理（改变）该消息，也可以不作处理而继续传递该消息，还可以强制结束消息的传递。
win32-Hook技术简单了解
GoingJack博客
08-06 1160
//以下代码定义了一个简单的进程鼠标移动事件钩子 详细内容参考链接: https://www.bilibili.com/video/av57998681 关于如何创建一个Win32窗口的知识可参考：https://blog.csdn.net/qq_42418668/article/details/88917947 如何钩子的回调函数的返回值为1即代表消息不发送到操作系统为应用程序维护的消息...
WIN32钩子
weixin_33717298的博客
08-12 545
摘译自Win32 Hooks 作者：Kyle Marsh 本文描述钩子及其子MS Win32应用编程接口中的使用，讨论钩子函数、 过滤函数、以及以下类型的钩子： WH_CALLWNDPROC WH_CBT WH_DEBUG WH_FOREGROUNDIDLE WH_GETMESSAGE WH_JOURNALPLAYBA...
全局钩子详解
ccfxue的博客
05-03 6672
监控程序的实现       我们发现一些木马或其他病毒程序常常会将我们的键盘或鼠标的操作消息记录下来然后再将它发到他们指定的地方以实现监听.这种功能其他是利用了全局钩子将鼠标或键盘消息进行了截取,从而获得了操作的消息.要得到鼠标和键盘的控制权,我们要用SetWindowsHookEx这个函数:  HHOOK SetWindowsHookEx(     int idHook,        /
Hook MessageBox 全局Hook
11-01
全局Hook是一种技术，它允许一个程序监控或修改其他程序的行为，而无需修改这些程序的代码。在本场景中，我们关注的是Hook MessageBox，也就是对Windows系统中的消息框函数MessageBox进行拦截。MessageBox是Windows ...
Keyboard-Hook.rar_c 全局键盘_全局 HOOK_全局 键盘_进程监视
09-21
全局键盘钩子是Windows编程中一个重要的技术，用于在系统层面捕获键盘事件，无论焦点在哪个应用程序上，都能监控到用户的键盘输入。这个“Keyboard-Hook.rar_c”压缩包内容可能包含了一个C语言实现的全局键盘钩子...
Windows miniHook hookapi demo
09-14
总结，"Windows miniHook hookapi demo" 提供了一个使用MiniHook库实现Win32钩子的实例，通过这个项目，开发者可以学习到如何在用户模式下设置和管理钩子，以及如何处理钩子事件。了解和掌握这些技能有助于进行系统...
vc全局hook
08-25
VC全局Hook是一种在Windows操作系统中实现的编程技术，主要用于拦截和修改系统或应用程序中的函数调用。这个技术常被用于调试、监控、日志记录、安全分析等多种目的。在这个项目中，开发者已经实现了一个简单的VC...
Win32HOOK 就是
04-08
Win32 HOOK 技术的良好示范实例。。。还是很有价值的。
简述hook，并且解释在Win32系统下，如何使用hook编程
04-22
hook指出了系统消息处理机制。利用hook，可以在应用程序中安装子程序监视系统和进程之间的消息传递，这个监视过程是在消息到达目的窗口过程之前
鼠标键盘全局钩子以及windows api hook代码
07-22
鼠标键盘全局钩子以及windows api hook代码， 鼠标键盘全局钩子以及windows api hook代码 vs2013 工程
全局hook键盘监控
10-17
通过hook全局消息队列实现键盘监控。vs2017+Qt4.5.0，msvc2015编译环境编译。已经处理组合键与符号键。有图像界面，自带缓存类。
MD5Win32(HOOK方式)
10-19
MD5Win32(HOOK) MD5Win32(HOOK) MD5Win32(HOOK)
Win32全局钩子在VC5中的实现 (转)
circularr9834的博客
08-13 128
Win32全局钩子在VC5中的实现 (转)[@more@]win32全局钩子在VC5中的实现 　　·windows系统是建立在事件驱动的机制上的，说穿了就是整个系统都是通过消息的传递来实现的。而钩子是Windows系统中非常...
WIN32 消息Hook API
不会写代码的丝丽
06-23 773
前言 在Win32中存在一个消息机制，程序任何点击或者消息都会通过窗口过程下发，而微软提供SetWindowsHookExAPI来来允许我们进行相关事件监听，并且这个监听操作是优先于原始的函数调用的。 微软setwindowshookexa相关文档 HHOOK SetWindowsHookExA( int idHook, HOOKPROC lpfn, HINSTANCE hmod, DWORD dwThreadId ); 微软把Hook分为两种： 线程钩子 全局钩子
Windows全局热键实现：Delphi与Win32键盘Hook技术
"Win32键盘Hook的Delphi编程主要探讨了如何在Windows环境下使用Delphi实现系统范围的热键功能。通过键盘Hook技术，开发者可以创建程序，即使在后台或非活动状态下也能响应特定的热键组合。本文详细介绍了Win32按键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值