Помогите пожалуйста с NtCreateFile

Здравствуйте. Вот нашел исходник , подработал под свои задачи , а он не работает. Пои идеи когда я буду пытаться прочитать test.txt блокнот его не откроет , но такого не происходит .Вот код.
#include <ntddk.h>
//#include <winnt.h>
#include "Driver.h"



VOID UnloadRoutine(IN PDRIVER_OBJECT pDriverObject);
NTSTATUS Create_File_IRProcessing(IN PDEVICE_OBJECT fdo,IN PIRP Irp);
NTSTATUS Close_HandleIRProcessing(IN PDEVICE_OBJECT fdo,IN PIRP Irp);
NTSTATUS ReadWrite_IRPhandler(IN PDEVICE_OBJECT fdo,IN PIRP Irp);
NTSTATUS DeviceControlRutine(IN PDEVICE_OBJECT fdo,IN PIRP Irp);

KSPIN_LOCK MySpinLock;



typedef PVOID* PNTPROC;
typedef DWORD (ULONG);
typedef DWORD* PDWORD;
typedef unsigned char (BYTE);
typedef BYTE* PBYTE;

typedef struct _SYSTEM_SERVICE_TABLE
{
PNTPROC ServiceTable;
PDWORD CounterTable;
ULONG ServiceLimit;
PBYTE ArgumentTable;
}
SYSTEM_SERVICE_TABLE ,
* PSYSTEM_SERVICE_TABLE ,
* * PPSYSTEM_SERVICE_TABLE ;


typedef struct _SERVICE_DESCRIPTOR_TABLE {
SYSTEM_SERVICE_TABLE ntoskrnl; //SST для ntoskrnl.exe
SYSTEM_SERVICE_TABLE win32k; //SST для win32k.sys
SYSTEM_SERVICE_TABLE unused1; //не используется
SYSTEM_SERVICE_TABLE unused2; //не используется
}
SERVICE_DESCRIPTOR_TABLE ,
* PSERVICE_DESCRIPTOR_TABLE,
* * PPSERVICE_DESCRIPTOR_TABLE ;

//макрос для простого доступа к SST ядра
#define NTCALL(_function) KeServiceDescriptorTable->ntoskrnl.ServiceTable[_function]

//импортируем указатель на SDT
extern PSERVICE_DESCRIPTOR_TABLE KeServiceDescriptorTable;

//импортируем версию ядра NT
extern PUSHORT NtBuildNumber;

//обьявляем прототип True функции для перехватываемой функции
typedef NTSTATUS (*NtCreateFile) (OUT PHANDLE FileHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PLARGE_INTEGER AllocationSize OPTIONAL,
IN ULONG FileAttributes,
IN ULONG ShareAccess,
IN ULONG CreateDisposition,
IN ULONG CreateOptions,
IN PVOID EaBuffer OPTIONAL,
IN ULONG EaLength );


//обьявляем True функцию
NtCreateFile TrueNtCreateFile;

//номер системного вызова NtOpenProcess
ULONG OpenProcId;
ULONG PID=20320;


//функция - обработчик перехвата
NTSTATUS NewNtCreateFile (
OUT PHANDLE FileHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PLARGE_INTEGER AllocationSize OPTIONAL,
IN ULONG FileAttributes,
IN ULONG ShareAccess,
IN ULONG CreateDisposition,
IN ULONG CreateOptions,
IN PVOID EaBuffer OPTIONAL,
IN ULONG EaLength )
{
PWCHAR wcsFileName;
NTSTATUS status;
wchar_t *pdest;
wchar_t ch = '\\';
void* pMdl1;
void* pMdl2;
void* pMdl3;
UNICODE_STRING uniFileName, uniHideDirFile;
BOOLEAN locked1 = FALSE, locked2 = FALSE, locked3 = FALSE;

RtlInitUnicodeString(&uniHideDirFile, L"test.txt");
DbgPrint("Started");
if (ExGetPreviousMode() == UserMode) {
pMdl1 = IoAllocateMdl(ObjectAttributes, sizeof(ObjectAttributes), FALSE, FALSE, NULL);
if (pMdl1 == NULL)
goto done;
__try {
MmProbeAndLockPages(pMdl1, KernelMode, IoModifyAccess);
} __except(EXCEPTION_EXECUTE_HANDLER) {
DbgPrint("bla-bla-bla1: error");
goto done;
}
locked1 = TRUE;
pMdl2 = IoAllocateMdl(ObjectAttributes->ObjectName, sizeof(UNICODE_STRING), FALSE, FALSE, NULL);
if (pMdl2 == NULL)
goto done;
__try {
MmProbeAndLockPages(pMdl2, KernelMode, IoModifyAccess);
} __except(EXCEPTION_EXECUTE_HANDLER) {
DbgPrint("bla-bla-bla2: error");
goto done;
}
locked2 = TRUE;
pMdl3 = IoAllocateMdl(ObjectAttributes->ObjectName->Buffer, ObjectAttributes->ObjectName->Length, FALSE, FALSE, NULL);
if (pMdl3 == NULL)
goto done;
__try {
MmProbeAndLockPages(pMdl3, KernelMode, IoModifyAccess);
} __except(EXCEPTION_EXECUTE_HANDLER) {
DbgPrint("bla-bla-bla3: error");
goto done;
}
locked3 = TRUE;

// Start
wcsFileName = ObjectAttributes->ObjectName->Buffer;
pdest = wcsrchr(wcsFileName, ch);
if (pdest > 0) {
RtlInitUnicodeString(&uniFileName, pdest+1);
if (RtlCompareUnicodeString(&uniFileName, &uniHideDirFile, TRUE ) == 0){
status = STATUS_OBJECT_NAME_NOT_FOUND;
goto done;
}
} else {
if (wcslen(wcsFileName) > 0)
RtlInitUnicodeString(&uniFileName, wcsFileName);
if (RtlCompareUnicodeString(&uniFileName, &uniHideDirFile, TRUE ) == 0) {
status = STATUS_OBJECT_NAME_NOT_FOUND;
goto done;
}
}
// End

// End
done:
if (locked1)
MmUnlockPages(pMdl1);
if (locked2)
MmUnlockPages(pMdl2);
if (locked3)
MmUnlockPages(pMdl3);
if (pMdl1 != NULL)
IoFreeMdl(pMdl1);
if (pMdl2 != NULL)
IoFreeMdl(pMdl2);
if (pMdl3 != NULL)
IoFreeMdl(pMdl3);
}
if (status == STATUS_SUCCESS)
TrueNtCreateFile(FileHandle,DesiredAccess,ObjectAttributes,IoStatusBlock,
AllocationSize,FileAttributes,ShareAccess,CreateDisposition,
CreateOptions,EaBuffer,EaLength);
return status;
// return TrueNtCreateFile(FileHandle,DesiredAccess,ObjectAttributes,IoStatusBlock,
// AllocationSize,FileAttributes,ShareAccess,CreateDisposition,
CreateOptions,EaBuffer,EaLength);
}




NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
{



ULONG CR0Reg;
NTSTATUS status;
UNICODE_STRING fullFileName;
HANDLE fileHandle;
IO_STATUS_BLOCK iostatus;
OBJECT_ATTRIBUTES oa;
UNICODE_STRING devName;

PDEVICE_OBJECT fdo;
PEXAMPLE_DEVICE_EXTENSION dx;
UNICODE_STRING symLinkName;




DriverObject->DriverUnload=UnloadRoutine;
DriverObject->MajorFunction[IRP_MJ_CREATE]=Create_File_IRProcessing;
DriverObject->MajorFunction[IRP_MJ_CLOSE]=Close_HandleIRProcessing;
DriverObject->MajorFunction[IRP_MJ_READ]=ReadWrite_IRPhandler;
DriverObject->MajorFunction[IRP_MJ_WRITE]=ReadWrite_IRPhandler;

DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]=DeviceControlRutine;










RtlInitUnicodeString(&devName,L"\\Device\\EXAMPLE");
status=IoCreateDevice(DriverObject,sizeof(EXAMPLE_DEVICE_EXTENSION), &devName,FILE_DEVICE_UNKNOWN,
0,
FALSE,
&fdo);
dx=(PEXAMPLE_DEVICE_EXTENSION) fdo->DeviceExtension;
dx->fdo=fdo;

#define SYM_LINK_NAME L"\\DosDevices\\Example"
RtlInitUnicodeString(&symLinkName,SYM_LINK_NAME);
dx->ustrSymLinkName=symLinkName;
status=IoCreateSymbolicLink(&symLinkName,&devName);

KeInitializeSpinLock(&MySpinLock);



RtlInitUnicodeString(&fullFileName,L"\\??\\C:\\make my driver.txt");
InitializeObjectAttributes(&oa,
&fullFileName,
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
NULL,
NULL);

status=ZwCreateFile(&fileHandle,
GENERIC_WRITE | SYNCHRONIZE,
&oa,
&iostatus,
0,
FILE_ATTRIBUTE_NORMAL,
FILE_SHARE_WRITE,
FILE_OPEN_IF,
FILE_SYNCHRONOUS_IO_NONALERT,
NULL,
0);
ZwClose(fileHandle);











//определяем версию ядра системы
switch (*NtBuildNumber)
{
case 2195 : //win 2k
OpenProcId = 0x06A;
break;

case 2600 : //win xp
OpenProcId = 0x026;
break;

default :
return STATUS_NOT_IMPLEMENTED;
break;
}

//устанавливаем перехват
TrueNtCreateFile = NTCALL(OpenProcId);

__asm
{
cli // запрещаем прерывания
mov eax, cr0
mov CR0Reg,eax
and eax,0xFFFEFFFF // сбросить WP bit
mov cr0, eax
}

NTCALL(OpenProcId) = NewNtCreateFile;

__asm
{
mov eax, CR0Reg
mov cr0, eax // востановить содержимое CR0
sti // разрешаем прерывания
}









return status;

}



NTSTATUS CompleteIrp(PIRP Irp,NTSTATUS status,ULONG info)
{
Irp->IoStatus.Status=status;
Irp->IoStatus.Information=info;
IoCompleteRequest(Irp,IO_NO_INCREMENT);
return status;
}

NTSTATUS ReadWrite_IRPhandler(IN PDEVICE_OBJECT fdo,IN PIRP Irp)
{
ULONG BytesTdx=0;
NTSTATUS status=STATUS_SUCCESS;
return CompleteIrp(Irp,status,BytesTdx);
}

NTSTATUS Create_File_IRProcessing(IN PDEVICE_OBJECT fdo,IN PIRP Irp)
{
PIO_STACK_LOCATION IrpStack=IoGetCurrentIrpStackLocation(Irp);
return CompleteIrp(Irp,STATUS_SUCCESS,0);
}

NTSTATUS Close_HandleIRProcessing(IN PDEVICE_OBJECT fdo,IN PIRP Irp){

return CompleteIrp(Irp,STATUS_SUCCESS,0);
}

NTSTATUS DeviceControlRutine(IN PDEVICE_OBJECT fdo,IN PIRP Irp)
{
NTSTATUS status=STATUS_SUCCESS;
PEXAMPLE_DEVICE_EXTENSION dx;
PIO_STACK_LOCATION IrpStack;
KIRQL irql;
KIRQL currentIrql;
ULONG BytesTdx=0;
ULONG ControlCode;
ULONG method;
IrpStack=IoGetCurrentIrpStackLocation(Irp);
IrpStack=IoGetCurrentIrpStackLocation(Irp);
dx=(PEXAMPLE_DEVICE_EXTENSION) fdo->DeviceExtension;
ControlCode=(ULONG)(IrpStack->Parameters.DeviceIoControl.IoControlCode);
method=ControlCode & 0x03;
irql=KeGetCurrentIrql();
currentIrql=KeGetCurrentIrql();
KeAcquireSpinLock(&MySpinLock,&irql);

PID=ControlCode;
KeReleaseSpinLock(&MySpinLock,irql);
return CompleteIrp(Irp,status,BytesTdx);

}

VOID UnloadRoutine(IN PDRIVER_OBJECT pDriverObject)
{


ULONG CR0Reg;


//снимаем перехват
__asm
{
cli // запрещаем прерывания
mov eax, cr0
mov CR0Reg,eax
and eax,0xFFFEFFFF // сбросить WP bit
mov cr0, eax
}

NTCALL(OpenProcId) = TrueNtCreateFile;

__asm
{
mov eax, CR0Reg
mov cr0, eax // востановить содержимое CR0
sti // разрешаем прерывания
}

return;

}


Запускаю dryver.sys с помощью DriverMonitor.
Подскажите пожалуйста , в чем ошибка?

 

[ code][/ code] учили оформлять? совершенно нечитабельно. исправь

 

del (нето)

 

Код (Text):

1. #include <ntddk.h>
2. //#include <winnt.h>      
3. #include "Driver.h"
4.  
5.  
6.  
7. VOID UnloadRoutine(IN PDRIVER_OBJECT pDriverObject);
8. NTSTATUS Create_File_IRProcessing(IN PDEVICE_OBJECT fdo,IN PIRP Irp);
9. NTSTATUS Close_HandleIRProcessing(IN PDEVICE_OBJECT fdo,IN PIRP Irp);
10. NTSTATUS ReadWrite_IRPhandler(IN PDEVICE_OBJECT fdo,IN PIRP Irp);
11. NTSTATUS DeviceControlRutine(IN PDEVICE_OBJECT fdo,IN PIRP Irp);
12.  
13. KSPIN_LOCK MySpinLock;  
14.  
15.  
16.  
17. typedef PVOID* PNTPROC;
18. typedef DWORD (ULONG);
19. typedef DWORD*    PDWORD;
20. typedef unsigned char (BYTE);
21. typedef BYTE* PBYTE;
22.  
23. typedef struct _SYSTEM_SERVICE_TABLE
24. {
25.     PNTPROC ServiceTable;
26.     PDWORD  CounterTable;
27.     ULONG   ServiceLimit;
28.     PBYTE   ArgumentTable;
29. }
30. SYSTEM_SERVICE_TABLE ,
31. * PSYSTEM_SERVICE_TABLE ,
32. * * PPSYSTEM_SERVICE_TABLE ;
33.  
34.  
35. typedef struct _SERVICE_DESCRIPTOR_TABLE {
36.    SYSTEM_SERVICE_TABLE ntoskrnl;  //SST для ntoskrnl.exe
37.    SYSTEM_SERVICE_TABLE win32k;    //SST для win32k.sys
38.    SYSTEM_SERVICE_TABLE unused1;   //не используется
39.    SYSTEM_SERVICE_TABLE unused2;   //не используется
40. }
41. SERVICE_DESCRIPTOR_TABLE ,
42. * PSERVICE_DESCRIPTOR_TABLE,
43. * * PPSERVICE_DESCRIPTOR_TABLE ;
44.  
45. //макрос для простого доступа к SST ядра
46. #define NTCALL(_function) KeServiceDescriptorTable->ntoskrnl.ServiceTable[_function]
47.  
48. //импортируем указатель на SDT
49. extern PSERVICE_DESCRIPTOR_TABLE KeServiceDescriptorTable;
50.  
51. //импортируем версию ядра NT
52. extern PUSHORT NtBuildNumber;
53.  
54. //обьявляем прототип True функции для перехватываемой функции
55. typedef NTSTATUS (*NtCreateFile) (OUT PHANDLE             FileHandle,
56.   IN ACCESS_MASK          DesiredAccess,
57.   IN POBJECT_ATTRIBUTES   ObjectAttributes,
58.   OUT PIO_STATUS_BLOCK    IoStatusBlock,
59.   IN PLARGE_INTEGER       AllocationSize OPTIONAL,
60.   IN ULONG                FileAttributes,
61.   IN ULONG                ShareAccess,
62.   IN ULONG                CreateDisposition,
63.   IN ULONG                CreateOptions,
64.   IN PVOID                EaBuffer OPTIONAL,
65.   IN ULONG                EaLength );
66.  
67.  
68. //обьявляем True функцию
69. NtCreateFile TrueNtCreateFile;
70.  
71. //номер системного вызова NtOpenProcess
72. ULONG OpenProcId;
73. ULONG PID=20320;
74.  
75.  
76. //функция - обработчик перехвата
77. NTSTATUS NewNtCreateFile (
78. OUT PHANDLE             FileHandle,
79.   IN ACCESS_MASK          DesiredAccess,
80.   IN POBJECT_ATTRIBUTES   ObjectAttributes,
81.   OUT PIO_STATUS_BLOCK    IoStatusBlock,
82.   IN PLARGE_INTEGER       AllocationSize OPTIONAL,
83.   IN ULONG                FileAttributes,
84.   IN ULONG                ShareAccess,
85.   IN ULONG                CreateDisposition,
86.   IN ULONG                CreateOptions,
87.   IN PVOID                EaBuffer OPTIONAL,
88.   IN ULONG                EaLength )
89. {
90.     PWCHAR wcsFileName;
91.     NTSTATUS status;
92.     wchar_t *pdest;
93.     wchar_t ch = '\\';
94.     void* pMdl1;
95.     void* pMdl2;
96.     void* pMdl3;
97.     UNICODE_STRING uniFileName, uniHideDirFile;
98.     BOOLEAN locked1 = FALSE, locked2 = FALSE, locked3 = FALSE;
99.  
100.     RtlInitUnicodeString(&uniHideDirFile, L"test.txt");
101.     DbgPrint("Started");
102.     if (ExGetPreviousMode() == UserMode) {
103.         pMdl1 = IoAllocateMdl(ObjectAttributes, sizeof(ObjectAttributes), FALSE, FALSE, NULL);
104.         if (pMdl1 == NULL)
105.             goto done;
106.         __try {
107.             MmProbeAndLockPages(pMdl1, KernelMode, IoModifyAccess);
108.         } __except(EXCEPTION_EXECUTE_HANDLER) {
109.             DbgPrint("bla-bla-bla1: error");
110.             goto done;
111.         }
112.         locked1 = TRUE;
113.         pMdl2 = IoAllocateMdl(ObjectAttributes->ObjectName, sizeof(UNICODE_STRING), FALSE, FALSE, NULL);
114.         if (pMdl2 == NULL)
115.             goto done;
116.         __try {
117.             MmProbeAndLockPages(pMdl2, KernelMode, IoModifyAccess);
118.         } __except(EXCEPTION_EXECUTE_HANDLER) {
119.             DbgPrint("bla-bla-bla2: error");
120.             goto done;
121.         }
122.         locked2 = TRUE;
123.         pMdl3 = IoAllocateMdl(ObjectAttributes->ObjectName->Buffer, ObjectAttributes->ObjectName->Length, FALSE, FALSE, NULL);
124.         if (pMdl3 == NULL)
125.             goto done;
126.         __try {
127.             MmProbeAndLockPages(pMdl3, KernelMode, IoModifyAccess);
128.         } __except(EXCEPTION_EXECUTE_HANDLER) {
129.             DbgPrint("bla-bla-bla3: error");
130.             goto done;
131.         }
132.         locked3 = TRUE;
133.    
134. // Start
135.         wcsFileName = ObjectAttributes->ObjectName->Buffer;
136.         pdest = wcsrchr(wcsFileName, ch);
137.         if (pdest > 0) {
138.             RtlInitUnicodeString(&uniFileName, pdest+1);
139.             if (RtlCompareUnicodeString(&uniFileName, &uniHideDirFile, TRUE ) == 0){
140.                 status = STATUS_OBJECT_NAME_NOT_FOUND;
141.                 goto done;
142.             }
143.         } else {
144.         if (wcslen(wcsFileName) > 0)
145.             RtlInitUnicodeString(&uniFileName, wcsFileName);
146.             if (RtlCompareUnicodeString(&uniFileName, &uniHideDirFile, TRUE ) == 0) {
147.                 status = STATUS_OBJECT_NAME_NOT_FOUND;
148.                 goto done;
149.             }
150.     }
151. // End
152.  
153. // End
154. done:
155.         if (locked1)
156.                  MmUnlockPages(pMdl1);
157.         if (locked2)
158.             MmUnlockPages(pMdl2);
159.         if (locked3)
160.                      MmUnlockPages(pMdl3);
161.             if (pMdl1 != NULL)
162.             IoFreeMdl(pMdl1);
163.         if (pMdl2 != NULL)
164.                      IoFreeMdl(pMdl2);
165.             if (pMdl3 != NULL)
166.             IoFreeMdl(pMdl3);
167.     }
168. if (status == STATUS_SUCCESS)
169.     TrueNtCreateFile(FileHandle,DesiredAccess,ObjectAttributes,IoStatusBlock,
170.                     AllocationSize,FileAttributes,ShareAccess,CreateDisposition,
171.                             CreateOptions,EaBuffer,EaLength);
172. return status;
173. //    return TrueNtCreateFile(FileHandle,DesiredAccess,ObjectAttributes,IoStatusBlock,
174. //                    AllocationSize,FileAttributes,ShareAccess,CreateDisposition,
175.                             CreateOptions,EaBuffer,EaLength);
176. }
177.  
178.  
179.  
180.  
181. NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
182. {
183.  
184.  
185.  
186. ULONG CR0Reg;
187. NTSTATUS status;
188. UNICODE_STRING    fullFileName;
189. HANDLE fileHandle;
190. IO_STATUS_BLOCK    iostatus;
191. OBJECT_ATTRIBUTES    oa;
192. UNICODE_STRING devName;
193.        
194. PDEVICE_OBJECT fdo;
195. PEXAMPLE_DEVICE_EXTENSION dx;
196. UNICODE_STRING symLinkName;
197.  
198.  
199.  
200.  
201. DriverObject->DriverUnload=UnloadRoutine;
202. DriverObject->MajorFunction[IRP_MJ_CREATE]=Create_File_IRProcessing;
203. DriverObject->MajorFunction[IRP_MJ_CLOSE]=Close_HandleIRProcessing;
204. DriverObject->MajorFunction[IRP_MJ_READ]=ReadWrite_IRPhandler;
205. DriverObject->MajorFunction[IRP_MJ_WRITE]=ReadWrite_IRPhandler;
206.  
207. DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]=DeviceControlRutine;
208.  
209.  
210.  
211.  
212.  
213.  
214.  
215.  
216.  
217.  
218. RtlInitUnicodeString(&devName,L"\\Device\\EXAMPLE");
219. status=IoCreateDevice(DriverObject,sizeof(EXAMPLE_DEVICE_EXTENSION), &devName,FILE_DEVICE_UNKNOWN,
220.                       0,
221.                       FALSE,
222.                       &fdo);
223. dx=(PEXAMPLE_DEVICE_EXTENSION) fdo->DeviceExtension;
224. dx->fdo=fdo;
225.  
226. #define SYM_LINK_NAME L"\\DosDevices\\Example"
227. RtlInitUnicodeString(&symLinkName,SYM_LINK_NAME);
228. dx->ustrSymLinkName=symLinkName;
229. status=IoCreateSymbolicLink(&symLinkName,&devName);
230.  
231. KeInitializeSpinLock(&MySpinLock);
232.  
233.  
234.  
235. RtlInitUnicodeString(&fullFileName,L"\\??\\C:\\make my driver.txt");
236. InitializeObjectAttributes(&oa,
237.                 &fullFileName,
238.                 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
239.                 NULL,
240.                 NULL);
241.  
242. status=ZwCreateFile(&fileHandle,
243.             GENERIC_WRITE | SYNCHRONIZE,
244.             &oa,
245.             &iostatus,
246.             0,
247.             FILE_ATTRIBUTE_NORMAL,
248.             FILE_SHARE_WRITE,
249.             FILE_OPEN_IF,
250.             FILE_SYNCHRONOUS_IO_NONALERT,
251.             NULL,
252.             0);
253. ZwClose(fileHandle);
254.  
255.  
256.  
257.  
258.  
259.  
260.  
261.  
262.  
263.  
264.  
265.     //определяем версию ядра системы
266.     switch (*NtBuildNumber)
267.     {
268.         case 2195 :  //win 2k
269.          OpenProcId = 0x06A;
270.          break;
271.        
272.         case 2600 : //win xp
273.          OpenProcId = 0x026;
274.          break;
275.        
276.         default :
277.          return STATUS_NOT_IMPLEMENTED;
278.          break;
279.     }
280.    
281.     //устанавливаем перехват    
282.         TrueNtCreateFile  = NTCALL(OpenProcId);
283.  
284.     __asm
285.     {
286.         cli                     // запрещаем прерывания
287.         mov eax, cr0
288.         mov CR0Reg,eax
289.         and eax,0xFFFEFFFF      // сбросить WP bit
290.         mov cr0, eax
291.     }
292.  
293.     NTCALL(OpenProcId) = NewNtCreateFile;
294.  
295.     __asm
296.     {
297.         mov eax, CR0Reg    
298.         mov cr0, eax            // востановить содержимое CR0
299.         sti                     // разрешаем прерывания
300.     }
301.    
302.  
303.  
304.  
305.  
306.  
307.  
308.  
309.  
310. return status;
311.  
312. }
313.  
314.  
315.  
316. NTSTATUS CompleteIrp(PIRP Irp,NTSTATUS status,ULONG info)
317. {
318.     Irp->IoStatus.Status=status;
319.     Irp->IoStatus.Information=info;
320.     IoCompleteRequest(Irp,IO_NO_INCREMENT);
321.     return status;
322. }
323.  
324. NTSTATUS ReadWrite_IRPhandler(IN PDEVICE_OBJECT fdo,IN PIRP Irp)
325. {
326.     ULONG BytesTdx=0;
327.     NTSTATUS status=STATUS_SUCCESS;
328.     return CompleteIrp(Irp,status,BytesTdx);
329. }
330.  
331. NTSTATUS Create_File_IRProcessing(IN PDEVICE_OBJECT fdo,IN PIRP Irp)
332. {
333.     PIO_STACK_LOCATION IrpStack=IoGetCurrentIrpStackLocation(Irp);
334.     return CompleteIrp(Irp,STATUS_SUCCESS,0);
335. }
336.  
337. NTSTATUS Close_HandleIRProcessing(IN PDEVICE_OBJECT fdo,IN PIRP Irp){
338.  
339.     return CompleteIrp(Irp,STATUS_SUCCESS,0);
340. }
341.  
342. NTSTATUS DeviceControlRutine(IN PDEVICE_OBJECT fdo,IN PIRP Irp)
343. {
344. NTSTATUS status=STATUS_SUCCESS;
345. PEXAMPLE_DEVICE_EXTENSION dx;
346. PIO_STACK_LOCATION IrpStack;
347. KIRQL irql;
348. KIRQL currentIrql;
349. ULONG BytesTdx=0;
350. ULONG ControlCode;
351. ULONG method;
352. IrpStack=IoGetCurrentIrpStackLocation(Irp);
353. IrpStack=IoGetCurrentIrpStackLocation(Irp);
354. dx=(PEXAMPLE_DEVICE_EXTENSION) fdo->DeviceExtension;
355. ControlCode=(ULONG)(IrpStack->Parameters.DeviceIoControl.IoControlCode);
356. method=ControlCode & 0x03;
357. irql=KeGetCurrentIrql();
358. currentIrql=KeGetCurrentIrql();
359. KeAcquireSpinLock(&MySpinLock,&irql);
360.  
361. PID=ControlCode;
362. KeReleaseSpinLock(&MySpinLock,irql);
363. return CompleteIrp(Irp,status,BytesTdx);
364.  
365. }
366.  
367. VOID UnloadRoutine(IN PDRIVER_OBJECT pDriverObject)
368. {
369.  
370.  
371. ULONG CR0Reg;
372.  
373.  
374.     //снимаем перехват
375.     __asm
376.     {
377.         cli                     // запрещаем прерывания
378.         mov eax, cr0
379.         mov CR0Reg,eax
380.         and eax,0xFFFEFFFF     // сбросить WP bit
381.         mov cr0, eax
382.     }
383.  
384.     NTCALL(OpenProcId) = TrueNtCreateFile;
385.  
386.     __asm
387.     {
388.         mov eax, CR0Reg    
389.         mov cr0, eax            // востановить содержимое CR0
390.         sti                     // разрешаем прерывания
391.     }
392.  
393.     return;
394.  
395. }

 

_Aspire что значит del (нето)?