#include <wdm.h>
#include <stdio.h>
#include <stdarg.h>

#define   MAX_CAPTURED_IRPS      1024

typedef struct
{
   int               Type;
    PDEVICE_OBJECT      self;
    PDEVICE_OBJECT      target;
    PDEVICE_OBJECT      attach;
}   BLOCKER_DEV_EXT;

int                  BlockingFlag = 0;

PDRIVER_OBJECT         MainDriver;

PDRIVER_OBJECT         KbdDrvObj;
unsigned             KbdDevIoCtl = 0;

PDRIVER_OBJECT         MouseDrvObj;
unsigned            MouseDevIoCtl = 0;

PIRP               CapturedIrps[ MAX_CAPTURED_IRPS ];
int                  CapturedIrpsCount = 0;

#define ExtCast(dev) ((BLOCKER_DEV_EXT *)((dev)->DeviceExtension))

char   PrintBuff[ 512 ];
int      my_printf( char *str, ... )
{
   va_list args;

   va_start( args, str );
   vsprintf( PrintBuff, str, args );
   va_end( args );

   DbgPrint( PrintBuff );

   return 0;
}

void   ReleaseIrps( void )
{
   int      i;
   KIRQL   Irql;

   KeRaiseIrql( DISPATCH_LEVEL, &Irql );

   for( i = 0; i < CapturedIrpsCount; i++ )
   {
      CapturedIrps[ i ]->IoStatus.Status = STATUS_SUCCESS;
      CapturedIrps[ i ]->IoStatus.Information = 0;
      IoCompleteRequest( CapturedIrps[ i ], IO_NO_INCREMENT );
   }
   CapturedIrpsCount = 0;

   KeLowerIrql( Irql );
}

NTSTATUS KbdDispatchStub( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp )
{
   NTSTATUS   RetVal;

   my_printf( "Fallen into DeviceIoControl stub.\n" );

   if( BlockingFlag )
   {
      CapturedIrps[ CapturedIrpsCount++ ] = Irp;
      IoMarkIrpPending( Irp );
      Irp->IoStatus.Status=STATUS_PENDING;
      return STATUS_PENDING;
   }
   else
   {
      __asm   {
         push   Irp
         push   DeviceObject
         mov      eax, KbdDevIoCtl
         call   eax
         mov      RetVal, eax
      }
      return RetVal;
   }
}

NTSTATUS MouseDispatchStub( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp )
{
   NTSTATUS   RetVal;

   my_printf( "Fallen into DeviceIoControl stub.\n" );

   if( BlockingFlag )
   {
      CapturedIrps[ CapturedIrpsCount++ ] = Irp;
      IoMarkIrpPending( Irp );
      Irp->IoStatus.Status=STATUS_PENDING;
      return STATUS_PENDING;
   }
   else
   {
      __asm   {
         push   Irp
         push   DeviceObject
         mov      eax, MouseDevIoCtl
         call   eax
         mov      RetVal, eax
      }
      return RetVal;
   }
}

NTSTATUS BlockerDispatch(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
    NTSTATUS status;
    ULONG major, minor, control;

    PIO_STACK_LOCATION pIrpStack;
    pIrpStack = IoGetCurrentIrpStackLocation( Irp );

    minor=IoGetCurrentIrpStackLocation(Irp)->MinorFunction;
    major=IoGetCurrentIrpStackLocation(Irp)->MajorFunction;
    control=IoGetCurrentIrpStackLocation(Irp)->
                Parameters.DeviceIoControl.IoControlCode;

   my_printf( "Got to the dispatch routine, device = %08X\n", ExtCast( DeviceObject )->Type );
   my_printf( "Control = %08X, Major = %08X, Minor = %08X\n", control, major, minor );

   if( major == IRP_MJ_DEVICE_CONTROL )
   {
      if( pIrpStack->Parameters.DeviceIoControl.IoControlCode == 0x100 )
         BlockingFlag = 1;

      if( pIrpStack->Parameters.DeviceIoControl.IoControlCode == 0x200 )
      {
         BlockingFlag = 0;
         ReleaseIrps( );
      }
   }

    if(major==IRP_MJ_CREATE || major==IRP_MJ_CLOSE || major==IRP_MJ_CLEANUP)
   {
      my_printf( "CREATE/CLOSE/CLEANUP request\n" );

      if( major == IRP_MJ_CREATE )
      {
         //   Keyboard
         if( !KbdDevIoCtl )
         {
            unsigned   *DevCtrl, *NewCtrl;
            NewCtrl = KbdDispatchStub;
            DevCtrl = &KbdDrvObj->MajorFunction[ IRP_MJ_READ ];

            KbdDevIoCtl = KbdDrvObj->MajorFunction[ IRP_MJ_READ ];
            __asm   {
               mov      eax, cr0
               push   eax
               and      eax, not 0x10000;
               mov      cr0, eax
               mov      ecx, dword ptr DevCtrl
               mov      eax, NewCtrl
               mov      dword ptr[ ecx ], eax
               pop      eax
               mov      cr0, eax
            }
         }
         // Mouse
         if( !MouseDevIoCtl )
         {
            unsigned   *DevCtrl, *NewCtrl;
            NewCtrl = MouseDispatchStub;
            DevCtrl = &MouseDrvObj->MajorFunction[ IRP_MJ_READ ];

            MouseDevIoCtl = MouseDrvObj->MajorFunction[ IRP_MJ_READ ];
            __asm   {
               mov      eax, cr0
               push   eax
               and      eax, not 0x10000;
               mov      cr0, eax
               mov      ecx, dword ptr DevCtrl
               mov      eax, NewCtrl
               mov      dword ptr[ ecx ], eax
               pop      eax
               mov      cr0, eax
            }
         }

      }

       Irp->IoStatus.Status=STATUS_SUCCESS;
       Irp->IoStatus.Information=0;
       IoCompleteRequest(Irp, IO_NO_INCREMENT);
       return STATUS_SUCCESS;
   }

    Irp->IoStatus.Status=STATUS_SUCCESS;
    Irp->IoStatus.Information=0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return STATUS_SUCCESS;
}

VOID BlockerUnload( IN PDRIVER_OBJECT DriverObject )
{
    WCHAR                  deviceLinkBuffer[]  = L"\\DosDevices\\BLOCKER";
    UNICODE_STRING         deviceLinkUnicodeString;

   //   Keyboard
   {
      unsigned   *DevCtrl;
      DevCtrl = &KbdDrvObj->MajorFunction[ IRP_MJ_READ ];
      __asm   {
         mov      eax, cr0
         push   eax
         and      eax, not 0x10000;
         mov      cr0, eax
         mov      ecx, dword ptr DevCtrl
         mov      eax, KbdDevIoCtl
         mov      dword ptr[ ecx ], eax
         pop      eax
         mov      cr0, eax
      }
      KbdDevIoCtl = 0;
      ReleaseIrps( );
   }

   //   Mouse
   {
      unsigned   *DevCtrl;
      DevCtrl = &MouseDrvObj->MajorFunction[ IRP_MJ_READ ];
      __asm   {
         mov      eax, cr0
         push   eax
         and      eax, not 0x10000;
         mov      cr0, eax
         mov      ecx, dword ptr DevCtrl
         mov      eax, MouseDevIoCtl
         mov      dword ptr[ ecx ], eax
         pop      eax
         mov      cr0, eax
      }
      KbdDevIoCtl = 0;
      ReleaseIrps( );
   }

    RtlInitUnicodeString( &deviceLinkUnicodeString, deviceLinkBuffer );
    IoDeleteSymbolicLink( &deviceLinkUnicodeString );

    IoDeleteDevice( DriverObject->DeviceObject );

   my_printf( "Blocker unloaded!\n" );
}


NTSTATUS DriverEntry(IN PDRIVER_OBJECT  DriverObject, IN PUNICODE_STRING RegistryPath)
{
    UNICODE_STRING   devname, symname;
    PDEVICE_OBJECT   dev, dstdev;
    int            i;
    NTSTATUS      status;
   PFILE_OBJECT   file;

   for (i=0; i<=IRP_MJ_MAXIMUM_FUNCTION; i++)
      DriverObject->MajorFunction[i]=BlockerDispatch;

   DriverObject->DriverUnload = BlockerUnload;

   RtlInitUnicodeString(&devname, L"\\Device\\" L"BLOCKER");
   RtlInitUnicodeString(&symname, L"\\DosDevices\\" L"BLOCKER");

    status = IoCreateDevice(DriverObject, sizeof( BLOCKER_DEV_EXT ), &devname,
            FILE_DEVICE_UNKNOWN, 0, TRUE, &dev);
    if (status!=STATUS_SUCCESS)
        return status;

    status=IoCreateSymbolicLink(&symname, &devname);
    if (status!=STATUS_SUCCESS)
   {
        IoDeleteDevice(dev);
        return status;
   }

   my_printf( "Device object %08X created, extension = %08X\n", dev, dev->DeviceExtension );

    ExtCast(dev)->self=dev;
    ExtCast(dev)->target=NULL;
    ExtCast(dev)->Type=0xDEADC0DE;

//
//   Keyboard
//
   RtlInitUnicodeString( &devname, L"\\Device\\KeyboardClass0" );
   IoGetDeviceObjectPointer( &devname, FILE_ALL_ACCESS, &file, &dstdev );

   my_printf( "Recieved file object %08X, device object %08X for keyboard\n", file, dstdev );

   if( dstdev )
   {
      my_printf( "DevIoControl address is %08X\n", dstdev->DriverObject->MajorFunction[ IRP_MJ_READ ] );
      KbdDrvObj = dstdev->DriverObject;
   }

   if( dstdev )
      ObDereferenceObject( dstdev );
   if( file )
      ObDereferenceObject( file );

//
//   Mouse
//
   RtlInitUnicodeString( &devname, L"\\Device\\PointerClass0" );
   IoGetDeviceObjectPointer( &devname, FILE_ALL_ACCESS, &file, &dstdev );

   my_printf( "Recieved file object %08X, device object %08X for keyboard\n", file, dstdev );

   if( dstdev )
   {
      my_printf( "DevIoControl address is %08X\n", dstdev->DriverObject->MajorFunction[ IRP_MJ_READ ] );
      MouseDrvObj = dstdev->DriverObject;
   }

   if( dstdev )
      ObDereferenceObject( dstdev );
   if( file )
      ObDereferenceObject( file );

   return STATUS_SUCCESS;
}

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
HINSTANCE hMod;
#pragma data_seg(".SHARDAT")
static HHOOK hookHandle=NULL;
#pragma data_seg()

typedef struct _KEY_DATA {
        DWORD isNew;
        unsigned int HotKey;
} KEY_DATA, *PKEY_DATA;

BOOL APIENTRY DllMain( HANDLE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                                         )
{
  if (ul_reason_for_call==DLL_PROCESS_ATTACH) {
    hMod=(HINSTANCE)hModule;
  }       
        return TRUE;               
}
                                                                           
//Install hook
void __declspec(dllexport)__stdcall InstallKBDHook () {
        UninstallKBDHook ();
        hookHandle=SetWindowsHookEx(WH_KEYBOARD_LL,kbd_hook_proc,hMod,0);
}

//Uninstall hook                                 
void __declspec(dllexport)__stdcall UninstallKBDHook () {
        if (hookHandle!=NULL) { UnhookWindowsHookEx(hookHandle); }
        hookHandle=NULL;
}

//Hook procedure                                 
LRESULT CALLBACK kbd_hook_proc(int nCode, WPARAM wParam,LPARAM lParam) {
       
        if (nCode==HC_ACTION) {

                if ((wParam!=WM_KEYDOWN) && (wParam!=WM_SYSKEYDOWN))
                        goto KeyboardProc_Exit;
               
                PKBDLLHOOKSTRUCT kbd=(PKBDLLHOOKSTRUCT)lParam;
                //Тут идет обработка нажатых клавиш.           
                }
        }
KeyboardProc_Exit:
        return CallNextHookEx( hookHandle, nCode, wParam, lParam );
}