windows驱动 hid虚拟鼠标简单实现

实现一个虚拟鼠标驱动程序需要进行多层次的开发，包括内核驱动程序编写、报告描述符的编写、设备接口的注册以及用户模式应用程序的编写。以下是一个基本的实现例子，包括内核驱动程序和用户模式应用程序。

 1.内核驱动程序

首先，我们需要编写一个内核模式驱动程序，用于创建和管理虚拟鼠标设备。

#### 1. 驱动头文件 (VirtualMouse.h)

```c
#ifndef VIRTUALMOUSE_H
#define VIRTUALMOUSE_H

#include <ntddk.h>
#include <wdf.h>
#include <hidport.h>

DEFINE_GUID(GUID_DEVINTERFACE_VIRTUAL_MOUSE, 
0x78A1C341, 0x4539, 0x11d3, 0xB8, 0x8D, 0x00, 0xC0, 0x4F, 0xAD, 0x51, 0x71);

#define VIRTUAL_MOUSE_POOL_TAG 'VMPT'

typedef struct _DEVICE_EXTENSION {
    WDFDEVICE Device;
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;

WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(DEVICE_EXTENSION, DeviceGetExtension)

DRIVER_INITIALIZE DriverEntry;
EVT_WDF_DRIVER_DEVICE_ADD VirtualMouseEvtDeviceAdd;
EVT_WDF_IO_QUEUE_IO_DEVICE_CONTROL VirtualMouseEvtIoDeviceControl;

#endif
```

#### 2. 驱动实现文件 (VirtualMouse.c)

```c
#include "VirtualMouse.h"

#define REPORT_DESCRIPTOR_SIZE 50
const UCHAR ReportDescriptor[REPORT_DESCRIPTOR_SIZE] = {
    0x05, 0x01, // Usage Page (Generic Desktop)
    0x09, 0x02, // Usage (Mouse)
    0xA1, 0x01, // Collection (Application)
    0x09, 0x01, // Usage (Pointer)
    0xA1, 0x00, // Collection (Physical)
    0x05, 0x09, // Usage Page (Buttons)
    0x19, 0x01, // Usage Minimum (01)
    0x29, 0x03, // Usage Maximum (03)
    0x15, 0x00, // Logical Minimum (0)
    0x25, 0x01, // Logical Maximum (1)
    0x95, 0x03, // Report Count (3)
    0x75, 0x01, // Report Size (1)
    0x81, 0x02, // Input (Data,Var,Abs)
    0x95, 0x01, // Report Count (1)
    0x75, 0x05, // Report Size (5)
    0x81, 0x03, // Input (Cnst,Var,Abs)
    0x05, 0x01, // Usage Page (Generic Desktop)
    0x09, 0x30, // Usage (X)
    0x09, 0x31, // Usage (Y)
    0x15, 0x81, // Logical Minimum (-127)
    0x25, 0x7F, // Logical Maximum (127)
    0x75, 0x08, // Report Size (8)
    0x95, 0x02, // Report Count (2)
    0x81, 0x06, // Input (Data,Var,Rel)
    0xC0,       // End Collection
    0xC0        // End Collection
};

NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT  DriverObject,
    IN PUNICODE_STRING RegistryPath
    )
{
    WDF_DRIVER_CONFIG config;
    NTSTATUS status;

    KdPrint(("VirtualMouse: DriverEntry\n"));

    WDF_DRIVER_CONFIG_INIT(&config, VirtualMouseEvtDeviceAdd);

    status = WdfDriverCreate(DriverObject,
                             RegistryPath,
                             WDF_NO_OBJECT_ATTRIBUTES,
                             &config,
                             WDF_NO_HANDLE);
    if (!NT_SUCCESS(status)) {
        KdPrint(("VirtualMouse: WdfDriverCreate failed with status 0x%x\n", status));
    }

    return status;
}

NTSTATUS
VirtualMouseEvtDeviceAdd(
    IN WDFDRIVER       Driver,
    IN PWDFDEVICE_INIT DeviceInit
    )
{
    WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
    WDF_OBJECT_ATTRIBUTES deviceAttributes;
    WDFDEVICE device;
    NTSTATUS status;

    UNREFERENCED_PARAMETER(Driver);

    KdPrint(("VirtualMouse: EvtDeviceAdd\n"));

    WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
    WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);

    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&deviceAttributes, DEVICE_EXTENSION);

    status = WdfDeviceCreate(&DeviceInit, &deviceAttributes, &device);
    if (NT_SUCCESS(status)) {
        PDEVICE_EXTENSION deviceExtension = DeviceGetExtension(device);

        WDF_IO_QUEUE_CONFIG ioQueueConfig;
        WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig, WdfIoQueueDispatchSequential);
        ioQueueConfig.EvtIoDeviceControl = VirtualMouseEvtIoDeviceControl;
        status = WdfIoQueueCreate(device, &ioQueueConfig, WDF_NO_OBJECT_ATTRIBUTES, WDF_NO_HANDLE);

        if (NT_SUCCESS(status)) {
            WDF_DEVICE_PNP_CAPABILITIES pnpCaps;
            WDF_DEVICE_PNP_CAPABILITIES_INIT(&pnpCaps);
            pnpCaps.SurpriseRemovalOK = WdfTrue;
            WdfDeviceSetPnpCapabilities(device, &pnpCaps);
        } else {
            KdPrint(("VirtualMouse: WdfIoQueueCreate failed 0x%x\n", status));
        }
    } else {
        KdPrint(("VirtualMouse: WdfDeviceCreate failed 0x%x\n", status));
    }

    return status;
}

VOID
VirtualMouseEvtIoDeviceControl(
    IN WDFQUEUE  Queue,
    IN WDFREQUEST Request,
    IN size_t OutputBufferLength,
    IN size_t InputBufferLength,
    IN ULONG IoControlCode
    )
{
    UNREFERENCED_PARAMETER(Queue);
    UNREFERENCED_PARAMETER(OutputBufferLength);
    UNREFERENCED_PARAMETER(InputBufferLength);

    NTSTATUS status = STATUS_SUCCESS;

    switch (IoControlCode) {
        case IOCTL_HID_GET_DEVICE_DESCRIPTOR:
            KdPrint(("VirtualMouse: IOCTL_HID_GET_DEVICE_DESCRIPTOR\n"));
            status = WdfRequestRetrieveOutputBuffer(Request, sizeof(HID_DESCRIPTOR), &outputBuffer, &outputBufferLength);
            break;

        case IOCTL_HID_GET_REPORT_DESCRIPTOR:
            KdPrint(("VirtualMouse: IOCTL_HID_GET_REPORT_DESCRIPTOR\n"));
            if (OutputBufferLength >= sizeof(ReportDescriptor)) {
                RtlCopyMemory(outputBuffer, ReportDescriptor, sizeof(ReportDescriptor));
                WdfRequestCompleteWithInformation(Request, status, sizeof(ReportDescriptor));
            } else {
                status = STATUS_BUFFER_TOO_SMALL;
            }
            break;

        default:
            KdPrint(("VirtualMouse: Unknown IOCTL 0x%x\n", IoControlCode));
            status = STATUS_INVALID_DEVICE_REQUEST;
            break;
    }

    WdfRequestComplete(Request, status);
}

VOID
VirtualMouseEvtCleanup(
    IN WDFOBJECT Device
    )
{
    KdPrint(("VirtualMouse: Cleanup\n"));
}
```

### 用户模式应用程序

#### 1. 应用程序头文件 (VirtualMouseApp.h)

```c
#ifndef VIRTUALMOUSEAPP_H
#define VIRTUALMOUSEAPP_H

#include <Windows.h>
#include <SetupAPI.h>
#include <hidsdi.h>
#include <initguid.h>
#include <stdio.h>

// GUID_DEVINTERFACE_VIRTUAL_MOUSE
DEFINE_GUID(GUID_DEVINTERFACE_VIRTUAL_MOUSE,
0x78A1C341, 0x4539, 0x11D3, 0xB8, 0x8D, 0x00, 0xC0, 0x4F, 0xAD, 0x51, 0x71);

#endif // VIRTUALMOUSEAPP_H
```

2.应用程序实现文件

#### 2. 应用程序实现文件 (VirtualMouseApp.c)

```c
#include "VirtualMouseApp.h"

HANDLE OpenDevice();
void SendMouseMovement(HANDLE deviceHandle, CHAR dx, CHAR dy);

int main()
{
    HANDLE deviceHandle = OpenDevice();

    if (deviceHandle == INVALID_HANDLE_VALUE) {
        printf("Failed to open device\n");
        return 1;
    }
    
    // Simulate mouse movement
    SendMouseMovement(deviceHandle, 10, 10);

    CloseHandle(deviceHandle);
    return 0;
}

HANDLE OpenDevice()
{
    HDEVINFO deviceInfoSet;
    SP_DEVICE_INTERFACE_DATA interfaceData;
    PSP_DEVICE_INTERFACE_DETAIL_DATA detailData = NULL;
    DWORD size = 0;
    HANDLE deviceHandle = INVALID_HANDLE_VALUE;

    deviceInfoSet = SetupDiGetClassDevs(&GUID_DEVINTERFACE_VIRTUAL_MOUSE, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
    if (deviceInfoSet == INVALID_HANDLE_VALUE) {
        printf("SetupDiGetClassDevs failed\n");
        return INVALID_HANDLE_VALUE;
    }

    interfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
    if (!SetupDiEnumDeviceInterfaces(deviceInfoSet, NULL, &GUID_DEVINTERFACE_VIRTUAL_MOUSE, 0, &interfaceData)) {
        printf("SetupDiEnumDeviceInterfaces failed\n");
        SetupDiDestroyDeviceInfoList(deviceInfoSet);
        return INVALID_HANDLE_VALUE;
    }

    SetupDiGetDeviceInterfaceDetail(deviceInfoSet, &interfaceData, NULL, 0, &size, NULL);
    detailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)malloc(size);
    if (detailData == NULL) {
        printf("malloc failed\n");
        SetupDiDestroyDeviceInfoList(deviceInfoSet);
        return INVALID_HANDLE_VALUE;
    }

    detailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
    if (!SetupDiGetDeviceInterfaceDetail(deviceInfoSet, &interfaceData, detailData, size, &size, NULL)) {
        printf("SetupDiGetDeviceInterfaceDetail failed\n");
        free(detailData);
        SetupDiDestroyDeviceInfoList(deviceInfoSet);
        return INVALID_HANDLE_VALUE;
    }

    deviceHandle = CreateFile(detailData->DevicePath, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

    free(detailData);
    SetupDiDestroyDeviceInfoList(deviceInfoSet);

    return deviceHandle;
}

void SendMouseMovement(HANDLE deviceHandle, CHAR dx, CHAR dy)
{
    BYTE report[3] = {0};
    report[0] = 1; // Report ID
    report[1] = dx;
    report[2] = dy;

    DWORD bytesWritten;
    if (!WriteFile(deviceHandle, report, sizeof(report), &bytesWritten, NULL)) {
        printf("WriteFile failed\n");
    }
}
```

### 高级开发注意事项

1. **权限和签名：** 内核模式驱动程序需要数字签名才能在 Windows 上正常加载。确保您的开发和发布过程包括驱动签名步骤。

2. **测试：** 在虚拟机或安全的测试环境中进行开发和测试，以防止驱动程序错误导致的系统崩溃。

3. **设备描述符管理：** HID 设备描述符和报告描述符需要根据你的设备功能进行定义，以确保它能够正确地与操作系统和应用程序通信。

4. **用户模拟事件：** 用户模式应用程序需要发送正确格式的报告数据来模拟鼠标移动和按键事件，确保与你的报告描述符相匹配。

这只是一个基本的例子，实际应用中可能需要根据需求增加更多的细节和功能。在开发过程中，请详细参考 Windows 驱动开发文档和 HID 规范，以确保驱动程序的兼容性和稳定性。

3.inf编写

; VirtualMouse.inf  
; 安装虚拟鼠标驱动程序  

[Version]  
Signature="$Windows NT$"  
Class=Mouse  
ClassGuid={78A1C341-4539-11d3-B88D-00C04FAD5171}  
Provider=%ManufacturerName%  
DriverVer=10/01/2023,1.0.0.0  
CatalogFile=VirtualMouse.cat  

[Manufacturer]  
%ManufacturerName%=Standard,NTamd64  

[Standard.NTamd64]  
%DeviceName%=DriverInstall, USB\VID_1234&PID_5678  

[DriverInstall]  
CopyFiles=DriverCopyFiles  
DelFiles=DriverDelFiles  
AddReg=DriverAddReg  

[DriverCopyFiles]  
VirtualMouse.sys  

[DriverDelFiles]  

[DriverAddReg]  
HKR,,DevLoader,,*ntkern  
HKR,,NTMPDriver,,VirtualMouse.sys  

[SourceDisksFiles]  
VirtualMouse.sys=1  

[SourceDisksNames]  
1 = %DiskName%  

[DestinationDirs]  
DefaultDestDir = 12              ; %windir%\system32\drivers  

[Strings]  
ManufacturerName="MyCompany"  
DeviceName="Virtual Mouse Device"  
DiskName="Virtual Mouse Installation Disk"