1. Если вы только начинаете программировать на ассемблере и не знаете с чего начать, тогда попробуйте среду разработки ASM Visual IDE
    (c) на правах рекламы
    Скрыть объявление

Как правильно обрабатывать IRP_MJ_PNP и IRP_MJ_POWER в фильтре клавиатуры?

Тема в разделе "WASM.NT.KERNEL", создана пользователем mshunko, 25 мар 2021.

  1. mshunko

    mshunko New Member

    Публикаций:
    0
    Регистрация:
    25 мар 2021
    Сообщения:
    2
    Пишу драйвер фильтр для клавиатуры на С под Windows 10 x64, в написании драйверов я не бельмеса, но неплохо знаю C++.
    Я устанавливаю фильтрацию для всех KeyboardClasses.
    Устанавливаю фильтр с помощью sc create, sc start
    Драйвер фильтрует и работает нормально но есть проблема, BSOD.
    Если к ноутбуку подключить дополнительную клавиатуру, установить мой драйвер, зайти в диспетчер задач, удалить подключенную клавиатуру, отказаться от перезагрузки, все работает, но если потом отключить клавиатуру из USB порта я ловлю BSOD. Или BSOD наступает в момент удаления устройства из диспетчера.
    Как я понимаю у меня проблемы с обработкой IRP_MJ_POWER , IRP_MJ_PNP что я только не пробывал :to_take_umbrage: ничего не получается, ловлю BSOD но по дампу он не в моем файле а в HIDCLASS.SYS.

    filter.c
    Код (Text):
    1.  
    2. wchar_t* SrcNameF = L"\\??\\MY.KbFilter%lu\0";
    3. wchar_t* DevNameF = L"\\Device\\MY.KbFilter%lu\0";
    4.  
    5. static
    6. VOID
    7. _Function_class_(DRIVER_UNLOAD)
    8. DriverUnload(PDRIVER_OBJECT DriverObject)
    9. {
    10.     DbgPrint("DriverUnload");
    11.     UNREFERENCED_PARAMETER(DriverObject);
    12.     DECLARE_UNICODE_STRING_SIZE(srcName, 255);
    13.     LONG SuccessfulDetachments = 0;
    14.     LARGE_INTEGER WaitInterval;
    15.     WaitInterval.QuadPart = -10 * 1000 * 1000;
    16.  
    17.     PDEVICE_OBJECT KeyboardClassFilterDevice = DriverObject->DeviceObject;
    18.  
    19.     while (KeyboardClassFilterDevice != NULL)
    20.     {
    21.         const PDEVICE_OBJECT KeyboardClassFilterDeviceNext = KeyboardClassFilterDevice->NextDevice;
    22.         const PDEVICE_EXTENSION DeviceExtension = KeyboardClassFilterDevice->DeviceExtension;
    23.         MyIoAcquireRemoveLock(&DeviceExtension->RemoveLock, NULL);
    24.         if (DeviceExtension->Deleted == FALSE)
    25.         {
    26.             IoDetachDevice(DeviceExtension->AttachedDevice);
    27.  
    28.             do
    29.             {
    30.                 KeDelayExecutionThread(KernelMode, FALSE, &WaitInterval);
    31.             }         while (InterlockedCompareExchange(&DeviceExtension->PendingIrp, 0, 0) > 0);
    32.            
    33.  
    34.             IoDeleteDevice(DeviceExtension->ThisDevice);
    35.         }
    36.  
    37.         DbgPrint("[*] Keyboard filter device #%lu has been detached\n", SuccessfulDetachments++);
    38.         RtlUnicodeStringPrintf(&srcName, SrcNameF, DeviceExtension->DeviceIndex);
    39.         IoDeleteSymbolicLink(&srcName);
    40.  
    41.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, NULL);
    42.         KeyboardClassFilterDevice = KeyboardClassFilterDeviceNext;
    43.     }
    44. }
    45.  
    46. static
    47. NTSTATUS
    48. _Function_class_(DRIVER_DISPATCH)
    49. DispatchPassThrough(PDEVICE_OBJECT DeviceObject, PIRP Irp)
    50. {
    51.     PDEVICE_EXTENSION DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
    52.     NTSTATUS status = MyIoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
    53.     if (!NT_SUCCESS(status))
    54.     {
    55.         status = CompleteRequest(Irp, status, 0);
    56.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    57.         return status;
    58.     }
    59.     PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    60.     if (irpStack->MajorFunction == IRP_MJ_CLOSE)
    61.     {
    62.         Irp->IoStatus.Status = STATUS_SUCCESS;
    63.         Irp->IoStatus.Information = 0;
    64.         IoCompleteRequest(Irp, IO_NO_INCREMENT);
    65.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    66.         return STATUS_SUCCESS;
    67.     }
    68.     IoSkipCurrentIrpStackLocation(Irp);
    69.  
    70.      status = IoCallDriver(((PDEVICE_EXTENSION)DeviceObject->DeviceExtension)->AttachedDevice, Irp);
    71.     MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    72.     return status;
    73. }
    74.  
    75. static
    76. NTSTATUS
    77. _Function_class_(IO_COMPLETION_ROUTINE)
    78. CompletionRoutine(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
    79. {
    80.     UNREFERENCED_PARAMETER(Context);
    81.  
    82.     const PDEVICE_EXTENSION DeviceExtenstion = DeviceObject->DeviceExtension;
    83.  
    84.     if (Irp->PendingReturned)
    85.     {
    86.         IoMarkIrpPending(Irp);
    87.     }
    88.  
    89.     if (Irp->IoStatus.Status == STATUS_SUCCESS)
    90.     {
    91.         const ULONG ScanCodesCount = (ULONG)(Irp->IoStatus.Information / sizeof(KEYBOARD_INPUT_DATA));
    92.         const PKEYBOARD_INPUT_DATA KeyboardInputData = Irp->AssociatedIrp.SystemBuffer;
    93.  
    94.         for (ULONG I = 0; I < ScanCodesCount; ++I)
    95.         {
    96.             const PKEYBOARD_INPUT_DATA ScanCodeInformation = &KeyboardInputData[I];
    97.  
    98.             if (ScanCodeInformation->Flags == PUSH_BUTTON1 || ScanCodeInformation->Flags == PUSH_BUTTON2)
    99.             {
    100.                 PushButton(ScanCodeInformation->MakeCode);
    101.             }
    102.             else if (ScanCodeInformation->Flags == RELEASE_BUTTON1 || ScanCodeInformation->Flags == RELEASE_BUTTON2)
    103.             {
    104.                 ReleaseButton(ScanCodeInformation->MakeCode);
    105.             }
    106.  
    107.             if (IsCancelCombination() && KeysDisabled == TRUE)
    108.             {
    109.                 ScanCodeInformation->MakeCode = 0;
    110.                 DbgPrint(("COMBINATION CANCELED\n"));
    111.             }
    112.         }
    113.     }
    114.  
    115.     InterlockedDecrement(&DeviceExtenstion->PendingIrp);
    116.  
    117.     return STATUS_SUCCESS;
    118. }
    119.  
    120. NTSTATUS DispatchPower(IN PDEVICE_OBJECT deviceObject, IN PIRP Irp)
    121. {
    122.     PDEVICE_EXTENSION DeviceExtension = (PDEVICE_EXTENSION)deviceObject->DeviceExtension;
    123.     PoStartNextPowerIrp(Irp);
    124.     NTSTATUS status;
    125.     status = MyIoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
    126.     if (!NT_SUCCESS(status))
    127.     {
    128.         status = CompleteRequest(Irp, status, 0);
    129.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    130.         return status;
    131.     }
    132.     IoSkipCurrentIrpStackLocation(Irp);
    133.     status = PoCallDriver(DeviceExtension->AttachedDevice, Irp);
    134.     MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    135.     return status;
    136. }
    137.  
    138. NTSTATUS DispatchPNP(IN PDEVICE_OBJECT deviceObject, IN PIRP Irp)
    139. {
    140.     NTSTATUS ntStatus;
    141.     PDEVICE_EXTENSION DeviceExtension = (PDEVICE_EXTENSION)deviceObject->DeviceExtension;
    142.     NTSTATUS                status = STATUS_SUCCESS;
    143.     status = MyIoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
    144.     if (!NT_SUCCESS(status))
    145.     {
    146.         status = CompleteRequest(Irp, status, 0);
    147.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    148.         return status;
    149.     }
    150.  
    151.     PIO_STACK_LOCATION stackLOCATE = IoGetCurrentIrpStackLocation(Irp);
    152.     ULONG function = stackLOCATE->MinorFunction;
    153.  
    154.     DbgPrint("DispatchPNP1functio :%lu\n", (LONG)function);
    155.     if (DeviceExtension == NULL)
    156.     {
    157.         DbgPrint("DispatchPNP2");
    158.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    159.         return STATUS_DEVICE_REMOVED;
    160.     }
    161.  
    162.     if (DeviceExtension->Deleted == FALSE &&
    163.         (function == IRP_MN_REMOVE_DEVICE ||
    164.          function == IRP_MN_SURPRISE_REMOVAL ||
    165.          function == IRP_MN_CANCEL_REMOVE_DEVICE ||
    166.         function == IRP_MN_QUERY_REMOVE_DEVICE))
    167.     {
    168.         DbgPrint("DispatchPNP3");
    169.         IoDetachDevice(DeviceExtension->AttachedDevice);
    170.         IoDeleteDevice(DeviceExtension->ThisDevice);
    171.         DECLARE_UNICODE_STRING_SIZE(srcName, 255);
    172.         RtlUnicodeStringPrintf(&srcName, SrcNameF, DeviceExtension->DeviceIndex);
    173.         IoDeleteSymbolicLink(&srcName);
    174.         DeviceExtension->Deleted = TRUE;
    175.         KeysDisabled = FALSE;
    176.  
    177.         Irp->IoStatus.Status = STATUS_SUCCESS;
    178.         Irp->IoStatus.Information = 0;
    179.         IoCompleteRequest(Irp, IO_NO_INCREMENT);
    180.  
    181.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    182.         return STATUS_SUCCESS;
    183.     }
    184.     if (DeviceExtension->Deleted == TRUE)
    185.     {
    186.         DbgPrint("DispatchPNP4");
    187.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    188.         return STATUS_DEVICE_REMOVED;
    189.     }
    190.     DbgPrint("DispatchPNP5");
    191.     IoSkipCurrentIrpStackLocation(Irp);
    192.     ntStatus = IoCallDriver(DeviceExtension->AttachedDevice, Irp);
    193.     MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    194.     return ntStatus;
    195. }
    196.  
    197. static
    198. NTSTATUS
    199. _Function_class_(DRIVER_DISPATCH)
    200. DispatchRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
    201. {
    202.     DbgPrint("DispatchRead");
    203.     const PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
    204.     NTSTATUS                status = STATUS_SUCCESS;
    205.     status = MyIoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
    206.     if (!NT_SUCCESS(status))
    207.     {
    208.         status = CompleteRequest(Irp, status, 0);
    209.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    210.         return status;
    211.     }
    212.     InterlockedIncrement(&DeviceExtension->PendingIrp);
    213.     IoCopyCurrentIrpStackLocationToNext(Irp);
    214.  
    215.     status = IoSetCompletionRoutineEx(DeviceObject, Irp, CompletionRoutine, NULL, TRUE, TRUE, TRUE);
    216.     if (!NT_SUCCESS(status))
    217.     {
    218.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    219.         return status;
    220.     }
    221.  
    222.     MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    223.  
    224.     return IoCallDriver(DeviceExtension->AttachedDevice, Irp);
    225. }
    226.  
    227. NTSTATUS
    228. NTAPI
    229. DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
    230. {
    231.     DbgPrint("DriverEntry");
    232.     UNREFERENCED_PARAMETER(RegistryPath);
    233.  
    234.     DriverObject->DriverUnload = DriverUnload;
    235.  
    236.     for (ULONG I = 0; I < IRP_MJ_MAXIMUM_FUNCTION; ++I)
    237.     {
    238.         DriverObject->MajorFunction[I] = DispatchPassThrough;
    239.     }
    240.  
    241.     DriverObject->MajorFunction[IRP_MJ_READ] = DispatchRead;
    242.     DriverObject->MajorFunction[IRP_MJ_CREATE] = DispatchCreate;
    243.     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchDeviceControl;
    244.     DriverObject->MajorFunction[IRP_MJ_POWER] = DispatchPower;
    245.     DriverObject->MajorFunction[IRP_MJ_PNP] = DispatchPNP;
    246.  
    247.     DECLARE_UNICODE_STRING_SIZE(devName, 255);
    248.     DECLARE_UNICODE_STRING_SIZE(srcName, 255);
    249.     NTSTATUS Status;
    250.     LONG SuccessfulAttachments = 0;
    251.     UNICODE_STRING Unicode;
    252.     ULONG totalDevices = 0;
    253.  
    254.     RtlInitUnicodeString(&Unicode, L"IoDriverObjectType");
    255.     const POBJECT_TYPE* IoDriverObjectType = MmGetSystemRoutineAddress(&Unicode);
    256.  
    257.     RtlInitUnicodeString(&Unicode, L"IoDeviceObjectType");
    258.     const POBJECT_TYPE* IoDeviceObjectType = MmGetSystemRoutineAddress(&Unicode);
    259.  
    260.     DbgPrint("DispatchDeviceControl u");
    261.     if (IoDriverObjectType != NULL && IoDeviceObjectType != NULL)
    262.     {
    263.         RtlInitUnicodeString(&Unicode, L"ObReferenceObjectByName");
    264.         const FPN_OB_REFERENCE_OBJECT_BY_NAME ObReferenceObjectByName = (FPN_OB_REFERENCE_OBJECT_BY_NAME)MmGetSystemRoutineAddress(&Unicode);
    265.  
    266.         if (ObReferenceObjectByName != NULL)
    267.         {
    268.             RtlInitUnicodeString(&Unicode, L"\\Driver\\KbdClass");
    269.             PDRIVER_OBJECT KbdClassDriver;
    270.             Status = ObReferenceObjectByName(&Unicode,
    271.                 OBJ_CASE_INSENSITIVE,
    272.                 0,
    273.                 0,
    274.                 *IoDriverObjectType,
    275.                 KernelMode,
    276.                 NULL,
    277.                 (PVOID)&KbdClassDriver);
    278.             if (NT_SUCCESS(Status))
    279.             {
    280.                 PDEVICE_OBJECT KeyboardClassDevice = KbdClassDriver->DeviceObject;
    281.                 while (KeyboardClassDevice != NULL)
    282.                 {
    283.                     Status = ObReferenceObjectByPointer(KeyboardClassDevice,
    284.                         0,
    285.                         *IoDeviceObjectType,
    286.                         KernelMode);
    287.                     if (NT_SUCCESS(Status))
    288.                     {
    289.                         RtlUnicodeStringPrintf(&devName, DevNameF, totalDevices);
    290.                         RtlUnicodeStringPrintf(&srcName, SrcNameF, totalDevices);
    291.                         Status = IoCreateSymbolicLink(&srcName, &devName);
    292.                         PDEVICE_OBJECT KeyboardClassFilterDevice;
    293.                         Status = IoCreateDevice(DriverObject,
    294.                             sizeof(DEVICE_EXTENSTION),
    295.                             &devName,
    296.                             FILE_DEVICE_KEYBOARD,
    297.                             0,
    298.                             TRUE,
    299.                             &KeyboardClassFilterDevice);
    300.  
    301.                         if (NT_SUCCESS(Status))
    302.                         {
    303.                             const PDEVICE_EXTENSION DeviceExtenstion = KeyboardClassFilterDevice->DeviceExtension;
    304.                             DeviceExtenstion->PendingIrp = 0;
    305.                             DeviceExtenstion->Deleted = FALSE;
    306.                             DeviceExtenstion->DeviceIndex = totalDevices;
    307.                             DeviceExtenstion->AttachedDevice = IoAttachDeviceToDeviceStack(KeyboardClassFilterDevice, KeyboardClassDevice);
    308.                             MyIoInitializeRemoveLock(&DeviceExtenstion->RemoveLock, 0, 0, 255);
    309.                             if (DeviceExtenstion->AttachedDevice == NULL)
    310.                             {
    311.                                 IoDeleteDevice(KeyboardClassFilterDevice);
    312.                             }
    313.                             else
    314.                             {
    315.                                 DeviceExtenstion->ThisDevice = KeyboardClassFilterDevice;
    316.                                 KeyboardClassFilterDevice->Flags |= DO_BUFFERED_IO;
    317.                                 KeyboardClassFilterDevice->Flags &= ~DO_DEVICE_INITIALIZING;
    318.                                 ++SuccessfulAttachments;
    319.                                 totalDevices++;
    320.                             }
    321.                         }
    322.                         ObDereferenceObject(KeyboardClassDevice);
    323.                     }
    324.                     KeyboardClassDevice = KeyboardClassDevice->NextDevice;
    325.                 }
    326.                 ObDereferenceObject(KbdClassDriver);
    327.             }
    328.         }
    329.     }
    330.     return SuccessfulAttachments != 0 ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
    331. }
    332. NTSTATUS DispatchCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp)
    333. {
    334.     DbgPrint("DispatchCreate");
    335.     DEVICE_EXTENSTION* DeviceExtension = (DEVICE_EXTENSTION*)DeviceObject->DeviceExtension;
    336.     NTSTATUS                status = STATUS_SUCCESS;
    337.     status = MyIoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
    338.     if (!NT_SUCCESS(status))
    339.     {
    340.         status = CompleteRequest(Irp, status, 0);
    341.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    342.         return status;
    343.     }
    344.     PIO_STACK_LOCATION      ioStackLocation;
    345.  
    346.     ioStackLocation = IoGetCurrentIrpStackLocation(Irp);
    347.     DbgPrint("DispatchCreate :%lu\n", (LONG)ioStackLocation->MinorFunction);
    348.     Irp->IoStatus.Status = status;
    349.     Irp->IoStatus.Information = 0;
    350.  
    351.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
    352.     MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    353.     return(STATUS_SUCCESS);
    354. }
    355. NTSTATUS DispatchDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
    356. {
    357.     DbgPrint("DispatchDeviceControl");
    358.     ULONG                   operation;
    359.     PIO_STACK_LOCATION      ioStack;
    360.     NTSTATUS                status = STATUS_SUCCESS;
    361.     DEVICE_EXTENSTION* DeviceExtension = (DEVICE_EXTENSTION*)DeviceObject->DeviceExtension;
    362.     status = MyIoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
    363.     if (!NT_SUCCESS(status))
    364.     {
    365.         status = CompleteRequest(Irp, status, 0);
    366.         MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    367.         return status;
    368.     }
    369.  
    370.     ioStack = IoGetCurrentIrpStackLocation(Irp);
    371.  
    372.     operation = ioStack->Parameters.DeviceIoControl.IoControlCode;
    373.     DbgPrint("DispatchDeviceControl :%lu\n", (LONG)operation);
    374.     switch (operation)
    375.     {
    376.         case IOCTL_NEXT_KBFILTER_ON:
    377.         {
    378.             KeysDisabled = TRUE;
    379.         }
    380.         break;
    381.         case IOCTL_NEXT_KBFILTER_OFF:
    382.         {
    383.             KeysDisabled = FALSE;
    384.         }
    385.         break;
    386.         default:
    387.             status = STATUS_INVALID_PARAMETER;
    388.             break;
    389.     }
    390.  
    391.     Irp->IoStatus.Status = status;
    392.  
    393.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
    394.  
    395.     MyIoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
    396.  
    397.     return(status);
    398. }
    399.  

    filter.h
    Код (Text):
    1.  
    2. #pragma once
    3. #include <ntddk.h>
    4.  
    5.  
    6. #define PUSH_BUTTON1     0
    7. #define RELEASE_BUTTON1     1
    8. #define PUSH_BUTTON2     2
    9. #define RELEASE_BUTTON2     3
    10.  
    11.  
    12. //
    13. // The following value is arbitrarily chosen from the space defined by Microsoft
    14. // as being "for non-Microsoft use"
    15. //
    16. #define FILE_DEVICE_KBFILTER 0xCF52
    17. //
    18. // Device control codes - values between 2048 and 4095 arbitrarily chosen
    19. //
    20. #define IOCTL_NEXT_KBFILTER_ON    CTL_CODE(FILE_DEVICE_KBFILTER, 2049, METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
    21. #define IOCTL_NEXT_KBFILTER_OFF  CTL_CODE(FILE_DEVICE_KBFILTER, 2050, METHOD_BUFFERED, FILE_ANY_ACCESS)
    22.  
    23.  
    24. volatile LONG KeysDisabled = 0;
    25. NTSTATUS DispatchCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp);
    26. NTSTATUS DispatchDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp);
    27.  
    28.  
    29. typedef struct _MY_IO_REMOVE_LOCK {
    30.    LONG usage;  // reference count
    31.    BOOLEAN removing;  // true if removal is pending
    32.    KEVENT evRemove;  // event to wait on
    33. } MY_IO_REMOVE_LOCK, * PMY_IO_REMOVE_LOCK;
    34.  
    35. typedef struct
    36. {
    37.    LONG       PendingIrp;
    38.    PDEVICE_OBJECT   AttachedDevice;
    39.    PDEVICE_OBJECT   ThisDevice;
    40.    LONG       DeviceIndex;
    41.    BOOLEAN       Deleted;
    42.    MY_IO_REMOVE_LOCK RemoveLock;
    43. } DEVICE_EXTENSTION, * PDEVICE_EXTENSION;
    44.  
    45.  
    46. typedef NTSTATUS(NTAPI* FPN_OB_REFERENCE_OBJECT_BY_NAME)(PUNICODE_STRING ObjectName,
    47.    ULONG Attributes,
    48.    PACCESS_STATE AccessState,
    49.    ACCESS_MASK DesiredAccess,
    50.    POBJECT_TYPE ObjectType,
    51.    KPROCESSOR_MODE AccessMode,
    52.    PVOID ParseContext,
    53.    PVOID* Object);
    54.  
    55. typedef struct _KEYBOARD_INPUT_DATA {
    56.    USHORT UnitId;
    57.    USHORT MakeCode;
    58.    USHORT Flags;
    59.    USHORT Reserved;
    60.    ULONG  ExtraInformation;
    61. } KEYBOARD_INPUT_DATA, * PKEYBOARD_INPUT_DATA;
    62.  
    63.  
    64. VOID MyIoInitializeRemoveLock(PMY_IO_REMOVE_LOCK lock, ULONG tag, ULONG minutes, ULONG maxcount)
    65. {
    66.    KeInitializeEvent(&lock->evRemove, NotificationEvent, FALSE);
    67.    lock->usage = 1;
    68.    lock->removing = FALSE;
    69. }
    70.  
    71. NTSTATUS MyIoAcquireRemoveLock(PMY_IO_REMOVE_LOCK lock, PVOID tag)
    72. {
    73.    LONG usage = InterlockedIncrement(&lock->usage);
    74.    if (lock->removing)
    75.    {  // removal in progress
    76.      if (InterlockedDecrement(&lock->usage) == 0)
    77.        KeSetEvent(&lock->evRemove, 0, FALSE);
    78.      return STATUS_DELETE_PENDING;
    79.    }  // removal in progress
    80.    return STATUS_SUCCESS;
    81. }
    82. //-------------------------------------------------------------------------------
    83. VOID MyIoReleaseRemoveLock(PMY_IO_REMOVE_LOCK lock, PVOID tag)
    84. {
    85.    if (InterlockedDecrement(&lock->usage) == 0)
    86.      KeSetEvent(&lock->evRemove, 0, FALSE);
    87. }
    88.  
    89. VOID MyIoReleaseRemoveLockAndWait(PMY_IO_REMOVE_LOCK lock, PVOID tag)
    90. {
    91.    lock->removing = TRUE;
    92.    MyIoReleaseRemoveLock(lock, tag);
    93.    MyIoReleaseRemoveLock(lock, NULL);
    94.    KeWaitForSingleObject(&lock->evRemove, Executive, KernelMode, FALSE, NULL);
    95. }
    96.  
    97. NTSTATUS CompleteRequest(IN PIRP Irp, IN NTSTATUS status, IN ULONG_PTR info)
    98. {
    99.    Irp->IoStatus.Status = status;
    100.    Irp->IoStatus.Information = info;
    101.    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    102.    return status;
    103. }
    104.  

    Dump
    Код (Text):
    1.  
    2.  KEY_VALUES_STRING: 1
    3.  
    4.   Key  : Analysis.CPU.Sec
    5.   Value: 0
    6.  
    7.   Key  : Analysis.DebugAnalysisProvider.CPP
    8.   Value: Create: 8007007e on DESKTOP
    9.  
    10.   Key  : Analysis.DebugData
    11.   Value: CreateObject
    12.  
    13.   Key  : Analysis.DebugModel
    14.   Value: CreateObject
    15.  
    16.   Key  : Analysis.Elapsed.Sec
    17.   Value: 0
    18.  
    19.   Key  : Analysis.Memory.CommitPeak.Mb
    20.   Value: 59
    21.  
    22.   Key  : Analysis.System
    23.   Value: CreateObject
    24.  
    25.  
    26. ADDITIONAL_DEBUG_TEXT:  
    27. You can run '.symfix; .reload' to try to fix the symbol path and load symbols.
    28.  
    29. WRONG_SYMBOLS_TIMESTAMP: b5a82e62
    30.  
    31. WRONG_SYMBOLS_SIZE: ab5000
    32.  
    33. FAULTING_MODULE: fffff80239400000 nt
    34.  
    35. BUGCHECK_CODE:  a
    36.  
    37. BUGCHECK_P1: 48
    38.  
    39. BUGCHECK_P2: 2
    40.  
    41. BUGCHECK_P3: 1
    42.  
    43. BUGCHECK_P4: fffff80239417bf3
    44.  
    45. Unable to get size of nt!_MMPTE - probably bad symbols
    46.  0000000000000048
    47.  
    48. STACK_TEXT:  
    49. ffffa18e`4ca6f148 fffff802`395d5929 : 00000000`0000000a 00000000`00000048 00000000`00000002 00000000`00000001 : nt!KeBugCheckEx
    50. ffffa18e`4ca6f150 fffff802`395d1c69 : 00000000`00000000 00000000`00000000 00000000`00000000 fffff802`39452785 : nt!setjmpex+0x81f9
    51. ffffa18e`4ca6f290 fffff802`39417bf3 : 00000000`40420088 00000000`00000000 00000000`00000000 fffff802`394be1c5 : nt!setjmpex+0x4539
    52. ffffa18e`4ca6f420 fffff802`42a353f9 : ffffce0d`36af1650 00000000`00000000 00000000`00000002 00000003`05080e42 : nt!KeAcquireSpinLockRaiseToDpc+0x53
    53. ffffa18e`4ca6f450 fffff802`3951c541 : ffffce0d`35d26010 ffffce0d`3980aab0 fffff802`40628000 fffff802`42a35350 : HIDCLASS+0x53f9
    54. ffffa18e`4ca6f4c0 fffff802`4062c3b8 : ffffce0d`36d664b0 fffff802`40628040 ffffa18e`4ca6f500 ffffce0d`00000000 : nt!IoCancelIrp+0x71
    55. ffffa18e`4ca6f500 fffff802`394467f9 : ffffffff`ffb3b4c0 ffffce0d`36d664b0 ffffce0d`36d66ad8 ffffce0d`35c4ada0 : kbdhid+0xc3b8
    56. ffffa18e`4ca6f570 fffff802`46fc43db : ffffce0d`36d664b0 ffffce0d`35c4ada0 ffffce0d`35c4ada0 00000000`00000670 : nt!IofCallDriver+0x59
    57. ffffa18e`4ca6f5b0 fffff802`394467f9 : 00000000`00000000 00000000`c00000bb ffffce0d`35c4ac50 00000000`69706e00 : kbdclass+0x43db
    58. ffffa18e`4ca6f620 fffff802`39a56e0c : ffffa18e`4ca6f6c0 ffffce0d`35c4ac50 ffffa18e`4ca6f720 ffffce0d`36d664b0 : nt!IofCallDriver+0x59
    59. ffffa18e`4ca6f660 fffff802`39b311ca : 00000000`00000002 ffffce0d`38ee2c90 ffffce0d`36af1500 ffffce0d`36af1500 : nt!FsRtlNotifyVolumeEventEx+0x78c
    60. ffffa18e`4ca6f6e0 fffff802`39572c70 : ffffa307`4a2103c0 ffffce0d`38ee2c90 00000000`0000000a 00000000`00000000 : nt!IoSetDevicePropertyData+0x2ada
    61. ffffa18e`4ca6f7a0 fffff802`39b30b7f : ffffce0d`38ee2c90 ffffa307`00000015 00000000`00000000 cb3a4008`00200001 : nt!RtlCrc64+0x13d0
    62. ffffa18e`4ca6f800 fffff802`39b3081a : ffffce0d`38ee2c90 ffffa18e`4ca6f880 00000000`00000015 ffffce0d`38ee2c90 : nt!IoSetDevicePropertyData+0x248f
    63. ffffa18e`4ca6f840 fffff802`39c01b52 : ffffce0d`36af1500 00000000`00000002 ffffce0d`36af1500 00000000`00000001 : nt!IoSetDevicePropertyData+0x212a
    64. ffffa18e`4ca6f8c0 fffff802`39aff04e : ffffa18e`4ca6fa10 ffffce0d`38ee2c00 ffffa18e`4ca6fa00 ffffa307`00000001 : nt!FsRtlRegisterFltMgrCalls+0x76722
    65. ffffa18e`4ca6f9b0 fffff802`39a5f9b8 : ffffa307`4a2103c0 ffffa307`49fa2a20 ffffa307`49fa2a20 00000000`00000000 : nt!RtlGetGroupSecurityDescriptor+0x12be
    66. ffffa18e`4ca6f9e0 fffff802`394693d5 : ffffce0d`28660cf0 ffffce0d`305e6040 ffffce0d`28660cf0 ffffce0d`00000800 : nt!FsRtlAllocateExtraCreateParameterFromLookasideList+0x10b8
    67. ffffa18e`4ca6fa70 fffff802`39527c35 : ffffce0d`305e6040 00000000`00000080 ffffce0d`2867e040 0000256f`b19bbfff : nt!PsReturnProcessNonPagedPoolQuota+0xcd5
    68. ffffa18e`4ca6fb10 fffff802`395cb0b8 : ffffba81`27c20180 ffffce0d`305e6040 fffff802`39527be0 00000000`00000000 : nt!RtlIsNonEmptyDirectoryReparsePointAllowed+0x415
    69. ffffa18e`4ca6fb60 00000000`00000000 : ffffa18e`4ca70000 ffffa18e`4ca69000 00000000`00000000 00000000`00000000 : nt!KeSynchronizeExecution+0x6408
    70.  
    71.  
    72. STACK_COMMAND:  .thread ; .cxr ; kb
    73.  
    74. EXCEPTION_CODE_STR:  B5A82E62
    75.  
    76. EXCEPTION_STR:  WRONG_SYMBOLS
    77.  
    78. PROCESS_NAME:  ntoskrnl.wrong.symbols.exe
    79.  
    80. IMAGE_NAME:  ntoskrnl.wrong.symbols.exe
    81.  
    82. MODULE_NAME: nt_wrong_symbols
    83.  
    84. SYMBOL_NAME:  nt_wrong_symbols!B5A82E62AB5000
    85.  
    86. FAILURE_BUCKET_ID:  WRONG_SYMBOLS_X64_18362.1.amd64fre.19h1_release.190318-1202_TIMESTAMP_660730-064658_B5A82E62_nt_wrong_symbols!B5A82E62AB5000
    87.  
    88. OS_VERSION:  10.0.18362.1
    89.  
    90. BUILDLAB_STR:  19h1_release
    91.  
    92. OSPLATFORM_TYPE:  x64
    93.  
    94. OSNAME:  Windows 10
    95.  
    96. FAILURE_ID_HASH:  {bd622a0a-c89a-73d9-3319-bcef0893192c}
    97.  
    98. Followup:  MachineOwner
    99. ---------
    100.  
    101.  
    102.  
     
  2. mshunko

    mshunko New Member

    Публикаций:
    0
    Регистрация:
    25 мар 2021
    Сообщения:
    2
    Как не бился ответа не нашел, взял пример из WDK Keyboard_Input_WDF_Filter_Driver__Kbfiltr_
    Чуток подправил ini там в устройствах нужно указать
    HID_DEVICE_SYSTEM_KEYBOARD
    и легко установил через devcon
    Код (Text):
    1. devcon update KbFilter.inf HID_DEVICE_SYSTEM_KEYBOARD