windows7 《寒江独钓》传统键盘过滤驱动学习

本人驱动方面小白一枚，如果有什么不足之处与不正确之处还请各位大佬多多指正。
另外，本篇博客参考了以下博客，非常感谢原作者的分享！我在学习的时候真的受到了很大的帮助！
IRP相关：
http://blog.csdn.net/whatday/article/details/7106721
http://bbs.fishc.com/thread-59944-1-1.html
http://blog.csdn.net/zacklin/article/details/7612499
设备对象结构：
http://www.cnblogs.com/xuankuwa/p/3657968.html
卸载后蓝屏问题解决：
http://blog.sina.com.cn/s/blog_538396fd0100zgef.html

1：原理：

通过ObReferenceByName打开KbdClass驱动对象，然后遍历KbdClass的设备栈，对上面的设备逐一绑定。随后发送到KbdClass的IRP都会先经过我们自己的设备对象，就可以在读派遣函数中设置完成例程，当IRP完成后在完成历程中得到按键信息。

2:实现：

A：宏定义与数据结构：

extern POBJECT_TYPE *IoDriverObjectType;
ULONG count = 0;
#define KBD_DRIVER_NAME L"\\Driver\\Kbdclass"
#define  DELAY_ONE_MICROSECOND  (-10)
#define  DELAY_ONE_MILLISECOND (DELAY_ONE_MICROSECOND*1000)
#define  DELAY_ONE_SECOND (DELAY_ONE_MILLISECOND*1000)

typedef struct
{
    ULONG NodeSize;
    PDEVICE_OBJECT filterdevice;
    PDEVICE_OBJECT lowerdevice;
    PDEVICE_OBJECT targetdevice;
    KSPIN_LOCK IoRequestsSpinLock;
    KEVENT IoInProcessEvent;
}C2P_DEV_EXT,*PC2P_DEV_EXT;

B：DriverEntry：

程序入口部分，设定卸载函数，分发函数等等。

NTSTATUS DriverEntry(IN PDRIVER_OBJECT driver,IN PUNICODE_STRING path)
{
    ULONG i;
    NTSTATUS status;
    KdPrint(("Entering the filter driver\r\n"));
    for (i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; i++)
        driver->MajorFunction[i] = Gdispatch;                       
    driver->MajorFunction[IRP_MJ_READ] = Dispatchread;               //读分发函数
    driver->MajorFunction[IRP_MJ_POWER] = Power;                     //电源事件分发函数
    driver->MajorFunction[IRP_MJ_PNP] = Pnp;                         //PNP事件分发函数
    driver->DriverUnload = Unload;                                   //卸载函数
    status = AttachDevices(driver,path);
    return status;
}

C：绑定函数：

本部分功能是寻找KbdClass和绑定设备，首先需要用到的是通过设备名打开驱动对象的函数ObReference().该函数在官方文档里面虽然没有给出，但是的确已经被导出。所以只需要在函数里面声明一下即可使用。

NTSTATUS ObReferenceObjectByName
(
    PUNICODE_STRING ObjectName,
    ULONG Attributes,
    PACCESS_STATE AccessState,
    ACCESS_MASK DesiredAccess,
    POBJECT_TYPE ObjectType,
    KPROCESSOR_MODE AccessMode,
    PVOID ParseContext,
    PVOID *Object
);

然后通过获取到的驱动对象kbddriver指向的设备链进行遍历。对遍历得到的每一个设备对象进行绑定。
为了便于后面IRP请求以及卸载的操作，我们为设备扩展（DeviceExtensions）定义了数据结构，有兴趣的为了保证内核线程的安全性，可以把时间和锁加上去。

NTSTATUS AttachDevices(PDRIVER_OBJECT driver,PUNICODE_STRING path)
{
    NTSTATUS status=0;
    UNICODE_STRING string;
    PC2P_DEV_EXT ext;
    PDEVICE_OBJECT filter = NULL;
    PDEVICE_OBJECT lower = NULL;
    PDEVICE_OBJECT target = NULL;

    PDRIVER_OBJECT kbd = NULL;

    //获取Kbdclass驱动对象
    RtlInitUnicodeString(&string, KBD_DRIVER_NAME);
    status = ObReferenceObjectByName(&string,OBJ_CASE_INSENSITIVE,NULL,0,*IoDriverObjectType,KernelMode,NULL,&kbd);
    if (!NT_SUCCESS(status))
    {
        KdPrint(("attach failed\r\n"));
        return( status );
    }
    else
    {
        ObDereferenceObject(kbd);
    }
    //遍历设备链
    target = kbd->DeviceObject;
    while (target != NULL)
    {
        //创建过滤设备
        status = IoCreateDevice(driver, sizeof(C2P_DEV_EXT), NULL, target->DeviceType, target->Characteristics,TRUE, &filter);
        if (!NT_SUCCESS(status))
        {
            KdPrint(("could not create device\r\n"));
            return (status);
        }
        lower=IoAttachDeviceToDeviceStack(filter, target);
        if (!lower)
        {
            KdPrint(("could not attach device\r\n"));
            IoDeleteDevice(filter);
            filter = NULL;
            return (status);
        }
        //初始化设备扩展项，便于后来操作
        ext = (PC2P_DEV_EXT)(filter->DeviceExtension);
        memset(ext,0,sizeof(C2P_DEV_EXT));
        ext->lowerdevice = lower;
        ext->filterdevice = filter;
        ext->targetdevice = target;
        //KeInitializeSpinLock(&(ext->IoRequestsSpinLock));
        //KeInitializeEvent(&(ext->IoInProcessEvent), NotificationEvent, FALSE);

        //设置过滤设备的一些参数，具体作用参看引用博客
        filter->Characteristics = lower->Characteristics;
        filter->DeviceType = lower->DeviceType;
        filter->StackSize = lower->StackSize;
        filter->Flags |= lower->Flags & (DO_DIRECT_IO | DO_BUFFERED_IO | DO_POWER_PAGABLE);


        target = target->NextDevice;
    }
    return status;
}

IoAttachDeviceToDeviceStack是将调用方的设备对象附加到设备对象链中的最高层，并返回之前在设备对象链中最高的设备对象。靠着这个函数，我们的设备对象从低层的kbdclass指向的设备链对象绑定到了设备链的最顶层。也就是说，我们创建的filterdevice载设备链里紧贴着的并不一定是Kbdclass设备链的对象。故此我们使用C2P_DEV_EXT结构中的plowerdevice存储filterdevice下面的那个设备对象。这个设备对象我们一般称为真实设备。
但是在接触绑定的时候，传递的参数依然是最开始绑定的那个设备对象。所以在C2P_DEV_EXT结构中，我们使用ptargetdevice存储最开始的kbdclass的设备链中的设备对象。

D：分发函数：

a:电源事件分发函数：

调用PoStartNextPowerIrp()后把请求下发即可。

NTSTATUS Power( IN PDEVICE_OBJECT device,IN PIRP irp)
{
    KdPrint(("power dispatch\r\n"));
    PoStartNextPowerIrp(irp);
    IoSkipCurrentIrpStackLocation(irp);
    return IoCallDriver(((C2P_DEV_EXT *)(device->DeviceExtension))->lowerdevice, irp);
}

b:pnp（即插即拔）事件分发函数：

将请求下发，解除绑定，删除绑定的设备。
在触发pnp请求的时候，毫无疑问所有的击键与中断都已经由系统完成。所以不需要考虑会有中断滞留的情况。

NTSTATUS Pnp(IN PDEVICE_OBJECT device,IN PIRP irp)
{
    NTSTATUS status;
    KdPrint(("PNP dispatch\r\n"));
    PC2P_DEV_EXT ext = (PC2P_DEV_EXT)(device->DeviceExtension);
    PIO_STACK_LOCATION irpsp = IoGetCurrentIrpStackLocation(irp);
    switch(irpsp->MinorFunction)
    {
        case IRP_MN_CANCEL_REMOVE_DEVICE:
            IoSkipCurrentIrpStackLocation(irp);
            IoCallDriver(ext->lowerdevice,irp);
            IoDetachDevice(ext->lowerdevice);
            IoDeleteDevice(device);
            status = STATUS_SUCCESS;
            break;
        default:
            IoSkipCurrentIrpStackLocation(irp);
            IoCallDriver(ext->lowerdevice, irp);
            break;
    }
}

c：读请求分发函数：

在我们没有击键的时候，系统的函数会创建一个IRP_MJ_READ的请求到内核，然后该请求会滞留在那里。一直到我们击键触发中断。在这种情况下，我们卸载驱动的时候，如果直接删除驱动，那么这个IRP_MJ_READ在我们下一次击键触发中断的时候会导致系统的蓝屏。所以为了解决这个问题，我们必须在一次中断得到满足的时候卸载驱动，count用来标记当前的IRP_MJ_READ有没有得到满足。
如此一来，键盘的读请求就应该分成两个状态：击键和击键完成上一个IRP_MJ_READ请求被满足。故此我们设定两个函数Dispatchread和readcomplete。将readcomplete设为回调函数。

NTSTATUS Dispatchread(IN PDEVICE_OBJECT device,IN PIRP irp)
{
    PC2P_DEV_EXT ext;
    NTSTATUS status = STATUS_SUCCESS;
    PIO_STACK_LOCATION currentstack;
    //KEVENT event;
    //KeInitializeEvent(&event, NotificationEvent, FALSE);


    //当请求已经到达了栈底的时候，设置请求已经完成，开始回调
    if (irp->CurrentLocation == 1)
    {
        ULONG Returnedinformation=0;
        KdPrint(("Dispatch encountered bogus current location\r\n"));
        status = STATUS_INVALID_DEVICE_REQUEST;
        irp->IoStatus.Status = status;
        irp->IoStatus.Information = 0;
        IoCompleteRequest(irp,IO_NO_INCREMENT);
        return (status);
    }

    count++;
    ext = (PC2P_DEV_EXT)(device->DeviceExtension);

    //将请求传递到下一层
    currentstack = IoGetCurrentIrpStackLocation(irp);
    IoCopyCurrentIrpStackLocationToNext(irp);

    //设置回调函数
    IoSetCompletionRoutine(irp, readcomplete, device, TRUE, TRUE, TRUE);
    return IoCallDriver(ext->lowerdevice, irp);
}

NTSTATUS readcomplete(IN PDEVICE_OBJECT device,IN PIRP irp,IN PVOID context)
{
    PIO_STACK_LOCATION irpsp;
    PUCHAR buf = NULL;
    ULONG buf_len;
    size_t i;

    UNREFERENCED_PARAMETER(device);
    irpsp = IoGetCurrentIrpStackLocation(irp);

    //打印击键信息
    if (NT_SUCCESS(irp->IoStatus.Status))
    {
        buf = irp->AssociatedIrp.SystemBuffer;
        buf_len = irp->IoStatus.Information;
        for (i = 0; i < buf_len; i++)
            DbgPrint("ctralcap:%2x\r\n",buf[i]);
    }
    //计数器减一
    count--;

    //声明irp没有完成，用以检查irp返回值
    if (irp->PendingReturned)
    {
        IoMarkIrpPending(irp);
    }
    return irp->IoStatus.Status;
}

关于irp.Iostatus的详细信息，参看参考博客。

d:普通分发函数：

简单的将请求传到下一层即可。

NTSTATUS Gdispatch(IN PDEVICE_OBJECT device,IN PIRP irp)
{
    KdPrint(("other dispatch\r\n"));
    IoSkipCurrentIrpStackLocation(irp);
    return IoCallDriver(((C2P_DEV_EXT *)(device->DeviceExtension))->lowerdevice, irp);
}

E：卸载函数：

解除绑定删除设备这些常见的姑且不提，有一点需要注意。在读分发函数的解释里面已经说过，卸载必须在彻底完成一个请求的时候进行，否则就会导致系统蓝屏。所以我们通过判断标志位count是否为0来确定请求是否被满足。这样一来，该驱动卸载时间就变成了下一次击键的时候。

VOID Unload(IN PDRIVER_OBJECT driver)
{
    PDEVICE_OBJECT device, old;
    LARGE_INTEGER delay;
    PC2P_DEV_EXT ext;
    delay = RtlConvertLongToLargeInteger(100 * DELAY_ONE_MILLISECOND);
    PRKTHREAD current;
    current = KeGetCurrentThread();
    KeSetPriorityThread(current,LOW_REALTIME_PRIORITY);

    UNREFERENCED_PARAMETER(driver);                                   //通知编译器driver已被使用过
    KdPrint(("unloading\r\n"));

    device = driver->DeviceObject;
    //遍历设备链，解除绑定和删除设备。
    while (device != NULL)
    {
        ext = (PC2P_DEV_EXT)device->DeviceExtension;
        __try
        {
            __try{
                IoDetachDevice(ext->targetdevice);

                ext->targetdevice = NULL;
                IoDeleteDevice(device);
                ext->filterdevice = NULL;
            }
            _except(EXCEPTION_EXECUTE_HANDLER){}
        }
        __finally{}
        device = device->NextDevice;
    }
    KdPrint(("%ld\r\n",count));

    //等待IRP_MJ_READ完成
    while (count!=0)
    {
        KeDelayExecutionThread(KernelMode, FALSE, &delay);
    }
    KdPrint(("unload completely\r\n"));
    return;
}

F：关于《寒江独钓》书中代码的两个问题。

在windows7下执行书中的源代码生成的驱动的时候，会出现通过无法打开设备对象的问题。要解决这个问题，只需要修改下面两行代码即可。

原代码：

extern POBJECT_TYPE IoDriverObjectType;
status = ObReferenceObjectByName ( 
        &uniNtNameString, 
        OBJ_CASE_INSENSITIVE, 
        NULL, 
        0, 
        IoDriverObjectType, 
        KernelMode, 
        NULL, 
        &KbdDriverObject 
        ); 

修改之后：

extern POBJECT_TYPE *IoDriverObjectType;
status = ObReferenceObjectByName ( 
        &uniNtNameString, 
        OBJ_CASE_INSENSITIVE, 
        NULL, 
        0, 
        *IoDriverObjectType, 
        KernelMode, 
        NULL, 
        &KbdDriverObject 
        ); 

这个问题在windowsXP下并没有，我也搞不清楚原因，还请各位大佬指教！在这里先感谢大家了！

另一个问题是windows7下面在卸载原代码编译生成的驱动之后，再次击键的一瞬间会出现蓝屏的问题。这是因为ObDeferenceObject()里面的参数应该是ObReferenceByName得到的驱动对象，而不应该是本驱动的驱动对象。或许是windowsXP检查不严谨导致？

原代码：

ObDereferenceObject(DriverObject);

修改：

ObDereferenceObject(kbd);    //kbd是通过ObReferenceByName获取到的KbdClass的驱动对象