键盘过滤程序 C语言

于 2022-01-26 20:22:23 发布
阅读量729 收藏 1
点赞数 3
文章标签： c语言 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51929595/article/details/122708080
版权

 简单的键盘过滤程序实现

#include <NTDDK.h>
#define KDB_DRIVER_NAME L"\\Driver\\Kbdclass"
#define DELAY_ONE_MILLISECOND -10
ULONG gC2pKeyCount;
NTSTATUS
ObReferenceObjectByName(
	PUNICODE_STRING ObjectName,
	ULONG Attributes,
	PACCESS_STATE PassedAccessState,
	ACCESS_MASK DesiredAccess,
	POBJECT_TYPE ObjectType,
	KPROCESSOR_MODE AccessMode,
	PVOID ParseContext,
	PVOID* Object);
extern POBJECT_TYPE IoDriverObjectType;
typedef struct _C2P_DEV_EXT
{
	ULONG NodeSize;
	PDEVICE_OBJECT pFilterDeviceObject;
	KSPIN_LOCK IoRequestspinLock;
	KEVENT IoInProgressEvent;
	PDEVICE_OBJECT TargetDeviceObject;
	PDEVICE_OBJECT LowerDeviceObject;
}C2P_DEV_EXT, * PC2P_DEV_EXT;
typedef struct _KEYBOARD_INPUT_DATA {
	USHORT UnitId;
	USHORT MakeCode;
	USHORT Flags;
	USHORT Reserved;
	ULONG ExtraInformation;
}KEYBOARD_INPUT_DATA, * PKEYBOARD_INPUT_DATA;
#include <ntddk.h>
VOID MakeCodeToASCII(USHORT MakeCode, USHORT Flags, PCHAR Ascii)//Ascii为16字节
{
	if (Flags >= 2)
	{
		if (Flags == 2)
		{
			switch (MakeCode)
			{
			case 0x2a:
			{
				strncpy(Ascii, " ", 16);
				break;
			}
			case 0x5b:
			case 0x5c:
			{
				strncpy(Ascii, "Windows按下", 16);
				break;
			}
			case 0x48:
			{
				strncpy(Ascii, "Up按下", 16);
				break;
			}
			case 0x50:
			{
				strncpy(Ascii, "Down按下", 16);
				break;
			}
			case 0x4b:
			{
				strncpy(Ascii, "Left按下", 16);
				break;
			}
			case 0x4d:
			{
				strncpy(Ascii, "Right按下", 16);
				break;
			}
			case 0x53:
			{
				strncpy(Ascii, "Del按下", 16);
				break;
			}
			default:
			{
				strncpy(Ascii, "Error", 16);
				break;
			}
			}
		}
		if (Flags == 3)
		{
			switch (MakeCode)
			{
			case 0x2a:
			{
				strncpy(Ascii, " ", 16);
				break;
			}
			case 0x5b:
			case 0x5c:
			{
				strncpy(Ascii, "Windows弹起", 16);
				break;
			}
			case 0x48:
			{
				strncpy(Ascii, "Up弹起", 16);
				break;
			}
			case 0x50:
			{
				strncpy(Ascii, "Down弹起", 16);
				break;
			}
			case 0x4b:
			{
				strncpy(Ascii, "Left弹起", 16);
				break;
			}
			case 0x4d:
			{
				strncpy(Ascii, "Right弹起", 16);
				break;
			}
			case 0x53:
			{
				strncpy(Ascii, "Del弹起", 16);
				break;
			}
			default:
			{
				strncpy(Ascii, "Error", 16);
				break;
			}
			}
		}
		return;
	}
	switch (MakeCode)
	{
	case 0x1d:
	{
		strncpy(Ascii, "Ctrl", 12);
		break;
	}
	case 0x1c:
	{
		strncpy(Ascii, "Enter", 12);
		break;
	}
	case 0x3a:
	{
		strncpy(Ascii, "CapsLock", 12);
		break;
	}
	case 0x2a:
	case 0x36:
	{
		strncpy(Ascii, "Shift", 12);
		break;
	}
	case 0x02:
	{
		strncpy(Ascii, "1", 12);
		break;
	}
	case 0x4f:
	{
		strncpy(Ascii, "Num1", 12);
		break;
	}
	case 0x03:
	{
		strncpy(Ascii, "2", 12);
		break;
	}
	case 0x50:
	{
		strncpy(Ascii, "Num2", 12);
		break;
	}
	case 0x04:
	{
		strncpy(Ascii, "3", 12);
		break;
	}
	case 0x51:
	{
		strncpy(Ascii, "Num3", 12);
		break;
	}
	case 0x05:
	{
		strncpy(Ascii, "4", 12);
		break;
	}
	case 0x4b:
	{
		strncpy(Ascii, "Num4", 12);
		break;
	}
	case 0x06:
	{
		strncpy(Ascii, "5", 12);
		break;
	}
	case 0x4c:
	{
		strncpy(Ascii, "Num5", 12);
		break;
	}
	case 0x07:
	{
		strncpy(Ascii, "6", 12);
		break;
	}
	case 0x4d:
	{
		strncpy(Ascii, "Num6", 12);
		break;
	}
	case 0x08:
	{
		strncpy(Ascii, "7", 12);
		break;
	}
	case 0x47:
	{
		strncpy(Ascii, "Num7", 12);
		break;
	}
	case 0x09:
	{
		strncpy(Ascii, "8", 12);
		break;
	}
	case 0x48:
	{
		strncpy(Ascii, "Num8", 12);
		break;
	}
	case 0x0a:
	{
		strncpy(Ascii, "9", 12);
		break;
	}
	case 0x49:
	{
		strncpy(Ascii, "Num9", 12);
		break;
	}
	case 0x0b:
	{
		strncpy(Ascii, "0", 12);
		break;
	}
	case 0x52:
	{
		strncpy(Ascii, "Num0", 12);
		break;
	}
	case 0x1e:
	{
		strncpy(Ascii, "a", 12);
		break;
	}
	case 0x30:
	{
		strncpy(Ascii, "b", 12);
		break;
	}
	case 0x2e:
	{
		strncpy(Ascii, "c", 12);
		break;
	}
	case 0x20:
	{
		strncpy(Ascii, "d", 12);
		break;
	}
	case 0x12:
	{
		strncpy(Ascii, "e", 12);
		break;
	}
	case 0x21:
	{
		strncpy(Ascii, "f", 12);
		break;
	}
	case 0x22:
	{
		strncpy(Ascii, "g", 12);
		break;
	}
	case 0x23:
	{
		strncpy(Ascii, "h", 12);
		break;
	}
	case 0x17:
	{
		strncpy(Ascii, "i", 12);
		break;
	}
	case 0x24:
	{
		strncpy(Ascii, "j", 12);
		break;
	}
	case 0x25:
	{
		strncpy(Ascii, "k", 12);
		break;
	}
	case 0x26:
	{
		strncpy(Ascii, "l", 12);
		break;
	}
	case 0x32:
	{
		strncpy(Ascii, "m", 12);
		break;
	}
	case 0x31:
	{
		strncpy(Ascii, "n", 12);
		break;
	}
	case 0x18:
	{
		strncpy(Ascii, "o", 12);
		break;
	}
	case 0x19:
	{
		strncpy(Ascii, "p", 12);
		break;
	}
	case 0x10:
	{
		strncpy(Ascii, "q", 12);
		break;
	}
	case 0x13:
	{
		strncpy(Ascii, "r", 12);
		break;
	}
	case 0x1f:
	{
		strncpy(Ascii, "s", 12);
		break;
	}
	case 0x14:
	{
		strncpy(Ascii, "t", 12);
		break;
	}
	case 0x16:
	{
		strncpy(Ascii, "u", 12);
		break;
	}
	case 0x2f:
	{
		strncpy(Ascii, "v", 12);
		break;
	}
	case 0x11:
	{
		strncpy(Ascii, "w", 12);
		break;
	}
	case 0x2d:
	{
		strncpy(Ascii, "x", 12);
		break;
	}
	case 0x15:
	{
		strncpy(Ascii, "y", 12);
		break;
	}
	case 0x2c:
	{
		strncpy(Ascii, "z", 12);
		break;
	}
	case 0x39:
	{
		strncpy(Ascii, "Space", 12);
		break;
	}
	case 0x0e:
	{
		strncpy(Ascii, "BackSpace", 12);
		break;
	}
	case 0x0f:
	{
		strncpy(Ascii, "Tab", 12);
		break;
	}
	case 0x45:
	{
		strncpy(Ascii, "NumLock", 12);
		break;
	}
	case 0x33:
	{
		strncpy(Ascii, ",", 12);
		break;
	}
	case 0x34:
	{
		strncpy(Ascii, ".", 12);
		break;
	}
	case 0x35:
	{
		strncpy(Ascii, "/", 12);
		break;
	}
	case 0x27:
	{
		strncpy(Ascii, ";", 12);
		break;
	}
	case 0x28:
	{
		strncpy(Ascii, "'", 12);
		break;
	}
	case 0x1a:
	{
		strncpy(Ascii, "[", 12);
		break;
	}
	case 0x1b:
	{
		strncpy(Ascii, "]", 12);
		break;
	}
	case 0x2b:
	{
		strncpy(Ascii, "\\", 12);
		break;
	}
	case 0x0c:
	{
		strncpy(Ascii, "-", 12);
		break;
	}
	case 0x0d:
	{
		strncpy(Ascii, "=", 12);
		break;
	}
	default:
	{
		strncpy(Ascii, "Error", 12);
		return;
	}
	}
	if (Flags == 0)
	{
		strncat(Ascii, "按下", 4);
	}
	else
	{
		strncat(Ascii, "弹起", 4);
	}
	return;
}
VOID DriverUnload(PDRIVER_OBJECT driver)
{
	PC2P_DEV_EXT devExt;
	PDEVICE_OBJECT DeviceObject;
	LARGE_INTEGER lDelay;
	PRKTHREAD CurrentThread;
	lDelay = RtlConvertLongToLargeInteger(100 * DELAY_ONE_MILLISECOND);
	CurrentThread = KeGetCurrentThread();
	KeSetPriorityThread(CurrentThread, LOW_REALTIME_PRIORITY);
	UNREFERENCED_PARAMETER(driver);
	DeviceObject = driver->DeviceObject;
	while (DeviceObject)
	{
		devExt = (PC2P_DEV_EXT)(DeviceObject->DeviceExtension);
		IoDetachDevice(devExt->LowerDeviceObject);
		IoDeleteDevice(DeviceObject);
		DeviceObject = DeviceObject->NextDevice;
	}
	ASSERT(NULL == driver->DeviceObject);
	while (gC2pKeyCount)
	{
		KeDelayExecutionThread(KernelMode, FALSE, &lDelay);
	}
	DbgPrint("键盘过滤驱动:驱动关闭");
	return;
}
NTSTATUS kbDispatchGeneral(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
	DbgPrint("键盘过滤驱动:其他信息");
	IoSkipCurrentIrpStackLocation(Irp);
	return IoCallDriver(((PC2P_DEV_EXT)DeviceObject->DeviceExtension)->LowerDeviceObject, Irp);
}
NTSTATUS kbpower(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
	PC2P_DEV_EXT devExt;
	PoStartNextPowerIrp(Irp);
	IoSkipCurrentIrpStackLocation(Irp);
	devExt = (PC2P_DEV_EXT)DeviceObject->DeviceExtension;
	return PoCallDriver(devExt->LowerDeviceObject, Irp);
}
NTSTATUS kbpnp(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
	NTSTATUS status = STATUS_SUCCESS;
	PC2P_DEV_EXT devExt;
	PIO_STACK_LOCATION irpstack;
	devExt = (PC2P_DEV_EXT)(DeviceObject->DeviceExtension);
	irpstack = IoGetCurrentIrpStackLocation(Irp);
	switch (irpstack->MinorFunction)
	{
	case IRP_MN_REMOVE_DEVICE:
	{
		DbgPrint("键盘过滤驱动:有一个USB键盘退出了(PNP请求)");
		IoSkipCurrentIrpStackLocation(Irp);
		IoCallDriver(devExt->LowerDeviceObject, Irp);
		IoDetachDevice(devExt->LowerDeviceObject);
		IoDeleteDevice(DeviceObject);
		status = STATUS_SUCCESS;
		break;
	}
	default:
	{
		IoSkipCurrentIrpStackLocation(Irp);
		status = IoCallDriver(devExt->LowerDeviceObject, Irp);
		break;
	}
	}
	return status;
}
NTSTATUS kbReadComplete(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
{
	PIO_STACK_LOCATION stackirp;
	ULONG buf_len = 0;
	ULONG i;
	PKEYBOARD_INPUT_DATA KeyData;
	PCHAR Ascii = "1234567890123456";
	stackirp = IoGetCurrentIrpStackLocation(Irp);
	if (NT_SUCCESS(Irp->IoStatus.Status))
	{
		buf_len = Irp->IoStatus.Information / sizeof(KEYBOARD_INPUT_DATA);
		KeyData = Irp->AssociatedIrp.SystemBuffer;
		for (i = 0; i < buf_len; i++)
		{
			MakeCodeToASCII(KeyData->MakeCode, KeyData->Flags, Ascii);
			//DbgPrint("键盘过滤驱动:键盘扫描码-%2x%s",KeyData->MakeCode,KeyData->Flags?"弹起":"按下");
			DbgPrint("键盘过滤驱动:%s", Ascii);
		}
	}
	gC2pKeyCount--;
	if (Irp->PendingReturned)
	{
		IoMarkIrpPending(Irp);
	}
	return Irp->IoStatus.Status;
}
NTSTATUS kbread(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
	NTSTATUS status = STATUS_SUCCESS;
	PC2P_DEV_EXT devExt;
	PIO_STACK_LOCATION currentirpstack;
	KEVENT waitEvent;
	KeInitializeEvent(&waitEvent, NotificationEvent, FALSE);
	if (Irp->CurrentLocation == 1)
	{
		DbgPrint("键盘过滤驱动:捕获驱动遇到了虚假的当前位置");
		status = STATUS_INVALID_DEVICE_REQUEST;
		Irp->IoStatus.Status = status;
		Irp->IoStatus.Information = 0;
		IoCompleteRequest(Irp, IO_NO_INCREMENT);
		return status;
	}
	gC2pKeyCount++;
	devExt = (PC2P_DEV_EXT)(DeviceObject->DeviceExtension);
	currentirpstack = IoGetCurrentIrpStackLocation(Irp);
	IoCopyCurrentIrpStackLocationToNext(Irp);
	IoSetCompletionRoutine(Irp, kbReadComplete, DeviceObject, TRUE, TRUE, TRUE);
	return IoCallDriver(devExt->LowerDeviceObject, Irp);
}
NTSTATUS DriverEntry(PDRIVER_OBJECT driver, PUNICODE_STRING RegistryPath)
{
	ULONG i;
	UNICODE_STRING kbdname;
	NTSTATUS status;
	PDRIVER_OBJECT kbddriver = NULL;
	PC2P_DEV_EXT devExt;

	PDEVICE_OBJECT pFilterDriver = NULL;//过滤驱动
	PDEVICE_OBJECT pTargetDriver = NULL;//目标驱动
	PDEVICE_OBJECT pLowerDriver = NULL;//下方驱动

	DbgPrint("键盘过滤驱动:驱动开启");



	gC2pKeyCount = 0;
	for (i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; i++)
	{
		driver->MajorFunction[i] = kbDispatchGeneral;
	}
	driver->MajorFunction[IRP_MJ_READ] = kbread;
	driver->MajorFunction[IRP_MJ_POWER] = kbpower;
	driver->MajorFunction[IRP_MJ_PNP] = kbpnp;
	driver->DriverUnload = DriverUnload;
	RtlInitUnicodeString(&kbdname, KDB_DRIVER_NAME);
	status = ObReferenceObjectByName(&kbdname, OBJ_CASE_INSENSITIVE, NULL, FILE_ALL_ACCESS, IoDriverObjectType, KernelMode, NULL, &kbddriver);
	if (!NT_SUCCESS(status))
	{
		DbgPrint("键盘过滤驱动:ObReferenceObjectByName函数返回错误");
		return(status);
	}
	else
	{
		ObDereferenceObject(driver);
	}

	pTargetDriver = kbddriver->DeviceObject;
	while (pTargetDriver)
	{
		status = IoCreateDevice(driver, sizeof(C2P_DEV_EXT), NULL, pTargetDriver->DeviceType, pTargetDriver->Characteristics, FALSE, &pFilterDriver);
		if (!NT_SUCCESS(status))
		{
			DbgPrint("键盘过滤驱动:创建过滤设备失败");
			return status;
		}
		pLowerDriver = IoAttachDeviceToDeviceStack(pFilterDriver, pTargetDriver);
		if (!pLowerDriver)
		{
			DbgPrint("键盘过滤驱动:绑定设备失败");
			IoDeleteDevice(pFilterDriver);
			pFilterDriver = NULL;
			return status;
		}
		devExt = (PC2P_DEV_EXT)(pFilterDriver->DeviceExtension);
		memset(devExt, 0, sizeof(C2P_DEV_EXT));
		devExt->NodeSize = sizeof(C2P_DEV_EXT);
		//KeInitializeSpinLock(详情参见windows自旋锁系列函数
		KeInitializeSpinLock(&(devExt->IoRequestspinLock));
		KeInitializeEvent(&(devExt->IoInProgressEvent), NotificationEvent, FALSE);
		devExt->TargetDeviceObject = pTargetDriver;
		devExt->LowerDeviceObject = pLowerDriver;
		pFilterDriver->DeviceType = pLowerDriver->DeviceType;
		pFilterDriver->Characteristics = pLowerDriver->Characteristics;
		pFilterDriver->StackSize = pLowerDriver->StackSize + 1;
		pFilterDriver->Flags |= pLowerDriver->Flags & (DO_BUFFERED_IO | DO_DIRECT_IO | DO_POWER_PAGABLE);
		pTargetDriver = pTargetDriver->NextDevice;
	}

	return STATUS_SUCCESS;
}

Mr.bean.
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
键盘过滤驱动源代码
坦然
08-22 2213
#include "ntddk.h" #include "ntddkbd.h" #include "stdio.h" #define KEY_UP 1 #define KEY_DOWN 0 #define LCONTROL ((USHORT)0x1D) #define CAPS_LOCK ((USHORT)0x3A
_KEYBOARD_INPUT_DATA
test
05-17 3346
_KEYBOARD_INPUT_DATA
键盘驱动系列---JIURL键盘驱动 5
多媒体编程、网络编程、系统编程、网络安全编程、驱动编程
08-10 1691
7 键盘驱动的运作 7.1 输入数据队列简介 i8042prt 和 kbdclass 各有一个输入数据队列，他们是循环使用的缓冲区。他们的每个单元是一个 KEYBOARD_INPUT_DATA 结构。 i8042prt 的自定义的设备扩展中，保存着一些指针和计数值，用来使用它的那个输入数据队列。 PKEYBOARD_INPUT_DATA 类型的 InputData , Da
寒江独钓 第四章 按键信息 扫描码和Ascii码
流星的专栏
11-26 1081
4.4.1从缓冲区中获得KEYBOARD_INPUT_DATA     请求完成之后,读到的信息在Irp->AssociatedIrp.SystemBuffer中,这个缓冲区可能含有n个KEYBOARD_INPUT_DATA结构     这个结构定义如下 typedef struct _KEYBOARD_INPUT_DATA{ //对设备\Device\Keyboa
通用键盘鼠标模拟(包括USB和PS2)
热门推荐
mergerly的专栏
11-19 1万+
通过直接调用Kbdclass的回调函数KeyboardClassServiceCallback直接给上层发送键盘驱动。这个方法网上已经公开，参考Hook KeyboardClassServiceCallback实现键盘 Logger，其他的还有很多，可以到网上去查。简单说一下没有公开的部分，就是按下和松开的模拟，已经扩展键的模拟。模拟主要是构造KEYBOARD_INPUT_DATA结构，按
驱动开发之 一个简单的截取键盘按键的驱动
Lydia的博客
07-24 4055
近来在学驱动开发，自己写了一个简单地驱动程序，截取键盘按键，另外写的应用程序会显示按键。下面是驱动部分的关键代码，完整代码点击：猛戳这里 /**************************************************************/ #include "KeyFilter.h" /*****************************************
C语言捕获键盘敲击的方法kbhit
狼行Bit
11-25 8133
本文主要简单实现了对于c语言在程序中捕捉键盘敲击，进行程序控制的操作，以及典型通用的C语言菜单实现。
C语言实现滤波器
liu_chengfa的博客
03-23 3268
** 利用MATLAB求解滤波器参数后用C实现滤波器 ** 1、先打开MATLAB的APP-》Filter Designer，如下图所示。 2、设置好滤波器的参数，并点击Designer Filter。 3、点击file,选择Export导出SOS和G。 4、在MATLAB的命令窗口中输入[b a]=sos2tf(SOS,G);，得到滤波器的系数。 5、C实现滤波器的代码是： void filter(float x0[], int length,float x1[])//x0需要处理的数组地址 length
ctrl2cap.rar_键盘过滤驱动
09-24
标题“ctrl2cap.rar_键盘过滤驱动”暗示我们关注的是一个与键盘输入过滤相关的驱动程序，它是用面向对象的C语言编写的，并且是针对Windows操作系统进行开发的。在这个领域，驱动程序是操作系统与硬件之间的重要桥梁...
键盘过滤驱动程序源代码
04-23
标题中的“键盘过滤驱动程序源代码”指的是一个用于监控或拦截键盘输入的内核级驱动程序，这种程序通常被编写成设备驱动的形式，以便在操作系统级别处理键盘事件。这类驱动程序能够捕获用户按下和释放的键，有时用于...
KeyBoard 模拟键盘
03-11
void NotifyKBEvent(wchar_t ch) { SHORT vks = VkKeyScanW(ch); BYTE vk = LOBYTE(vks); BYTE Shift = HIBYTE(vks); if (vk == (BYTE)-1/* || Shift == (BYTE)-1*/) {//UNICODE 字符 INPUT input[2]; input[0].type = INPUT_KEYBOARD; input[0].ki.wVk = 0; input[0].ki.wScan = ch; input[0].ki.dwFlags = 0x4;//KEYEVENTF_UNICODE; input[1].type = INPUT_KEYBOARD; input[1].ki.wVk = 0; input[1].ki.wScan = ch; input[1].ki.dwFlags = KEYEVENTF_KEYUP | 0x4;//KEYEVENTF_UNICODE; SendInput(2, input, sizeof(INPUT)); } else {// if (Shift) { INPUT input[4] = {0}; input[0].type = INPUT_KEYBOARD; input[0].ki.wVk = Shift;//VK_SHIFT; input[1].type = INPUT_KEYBOARD; input[1].ki.wVk = ch; input[2].type = INPUT_KEYBOARD; input[2].ki.wVk = ch; input[2].ki.dwFlags = KEYEVENTF_KEYUP; input[3].type = INPUT_KEYBOARD; input[3].ki.wVk = Shift;//VK_SHIFT; input[3].ki.dwFlags = KEYEVENTF_KEYUP; SendInput(4, input, sizeof(INPUT)); } else { INPUT input[2] = {0}; input[0].type = INPUT_KEYBOARD; input[0].ki.wVk = vks; input[1].type = INPUT_KEYBOARD; input[1].ki.wVk = vks; input[1].ki.dwFlags = KEYEVENTF_KEYUP; SendInput(2, input, sizeof(INPUT)); } } } void NotifyKBEvent(wchar_t* chs) { if (chs == NULL) return ; while(*chs) NotifyKBEvent(*chs++); } void SendKBEvent(WORD wVk, DWORD dwFlags = 0, DWORD dwExtraInfo = 0) { INPUT input[1] = {0}; input[0].type = INPUT_KEYBOARD; input[0].ki.wVk = wVk; input[0].ki.wScan = MapVirtualKey(wVk, 0); input[0].ki.dwFlags = dwFlags; input[0].ki.dwExtraInfo = dwExtraInfo; input[0].ki.time = GetTickCount(); SendInput(1, input, sizeof(INPUT)); } //去掉任务栏图标 和 始终不处于活动状态 ModifyStyleEx(WS_EX_APPWINDOW,WS_EX_TOOLWINDOW | 0x08000000); //初始不活动 SetWindowPos(&CWnd;::wndTopMost, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
键盘扫描程序
10-30
【键盘扫描程序】是一种在嵌入式系统中常见的软件组件，尤其在使用C语言编程的单片机、ARM或DSP等硬件平台中。这个程序的主要目的是读取物理键盘上按键的状态，将用户输入转化为可处理的数据。对于一个4x4的键盘来说...
单片机C语言实例-软件消抖的独立式键盘输入实验.zip
最新发布
12-14
本实验“单片机C语言实例-软件消抖的独立式键盘输入实验”着重于如何利用C语言编程实现单片机对独立式键盘的稳定输入处理，特别是针对按键抖动问题进行软件消抖的设计。 独立式键盘是指每个按键都直接连接到单片机...
C语言-坦克大战小游戏(纯控制台显示)
12-05
同时，这也是一个很好的实践，可以帮助学习者提高C语言编程技巧，理解游戏开发的基本原理，并掌握控制台程序的开发方法。 总之，C语言实现的坦克大战小游戏是一个挑战性和趣味性并存的项目，它不仅能够锻炼程序员的...
Windows驱动之编写键盘记录器
Aaron的博客
12-15 1万+
【1】方式：替换Kbdclass驱动的ReadFile IRP函数处理指针 编写.sys文件： 头文件： #pragma once //只编译1次头文件 #include //驱动函数头文件,类似于Win
获取按键信息
一介码农，热爱金融。
11-19 1673
Windows程序都是基于消息设计的。当你按下一个按键，或者点击一下鼠标，都会想操作系统的内核发送一个Irp消息。你只要捕获这个消息，将这个消息复制下，然后将消息放行。将复制的消息传送给你的应用程序。这就是获取键盘按键消息的实现方法。         很多黑客软件获取别人计算的密码，大多也用这种方法。建议广大用户在使用计算机进行输入游戏账号密码或者银行账号密码等，多用软键盘。防止别人通过这种
《Windows内核安全与驱动编程》-第八章-键盘的过滤学习-day3
WocW的博客
04-27 379
键盘的过滤 8.5 Hook 分发函数 ​ 前面讲述了进行键盘的过滤。本节开始更加深入地探讨键盘的过滤与反过滤的对抗。无论是过滤还是反过滤，其原理都是进行过滤。取胜的关键在于: 谁将第一个得到消息。 ​ 前面学到的键盘过滤方法，是通过在设备栈上绑定一个新的设备实现的。这样就有了一个简单的设想来防止黑客对键盘进行过滤: 检查设备栈，看上面是否有不明的设备。 ​ 但是一般的黑客软件如果想进行过滤的话，...
驱动笔记15 - 键盘过滤驱动学习笔记
kingswb的博客
05-03 1172
键盘过滤驱动对于分层驱动的学习是一个很好的例子，它相对文件过滤驱动来说较为简单，也更容易理解。    并不是所有的驱动都需要直接访问硬件的，事实上几乎所有的硬件设备都存在着驱动程序链，最底层的驱动程序可以直接访问硬件，并对上层提供透明服务，最上层的驱动程序只要对接收到的数据进行过滤、格式化等处理即可，这样大大减少了开发的难度。 我这次学习的对象是KLOG，但我将它的代码进行了精简，这样使得它的
c语言模拟按键win d,Windows平台模拟按键方法总结
weixin_39994665的博客
05-18 1230
Reference获取KeyboardClassServiceCallback函数的地址SendMessage/PostMessage是Ring3层的一种方法，SendMessage和PostMessage是User32.dll中的函数。可以直接在程序中调用，实现对另一个软件上的按钮的点击。发消息给固定HWND的窗口，不需要窗口是处于顶层。代码：SendInput这个函数发消息给Activewi...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值