🙆🏻 🏳️ 👨🏿‍🎨 मिनीफिल्टर चालक विकास 👩‍👩‍👧‍👦 🧑🏿‍🤝‍🧑🏽 👏🏼

किसी तरह मुझे कुछ प्रक्रियाओं के हिस्से के रूप में फ़ाइल सिस्टम तक पहुंच और पुनर्निर्देशन अनुरोधों को प्रबंधित करने के कार्य में भाग लेने का अवसर मिला। एक सरल, आसानी से कॉन्फ़िगर करने योग्य समाधान को लागू करना आवश्यक था।

मैंने एक मिनीफिल्टर ड्राइवर विकसित करने का फैसला किया, जो एक टेक्स्ट फ़ाइल का उपयोग करके कॉन्फ़िगर किया गया है।

विचार करें कि मिनीफिल्टर सामान्य शब्दों में क्या है:

फ़िल्टरिंग को तथाकथित फ़िल्टर प्रबंधक के माध्यम से किया जाता है, जो विंडोज ऑपरेटिंग सिस्टम के साथ आता है, केवल मिनी फिल्टर लोड करने पर सक्रिय होता है। फ़िल्टर प्रबंधक सीधे फाइल सिस्टम स्टैक से जुड़ता है। फ़िल्टर प्रबंधक कार्यक्षमता का उपयोग करके इनपुट / आउटपुट संचालन पर डेटा को संसाधित करने के लिए मिनी फ़िल्टर पंजीकृत होते हैं, इस प्रकार फ़ाइल सिस्टम में अप्रत्यक्ष पहुंच प्राप्त करते हैं। पंजीकरण करने और शुरू करने के बाद, मिनी-फिल्टर आई / ओ संचालन पर डेटा का एक सेट प्राप्त करता है जो कॉन्फ़िगरेशन के दौरान निर्दिष्ट किया गया था, और यदि आवश्यक हो, तो इन डेटा में परिवर्तन कर सकता है, जिससे फ़ाइल सिस्टम के संचालन को प्रभावित होता है।

निम्न आरेख सरल रूप में दिखाता है कि फ़िल्टर प्रबंधक कैसे कार्य करता है।

आप लेख के अंत में लिंक का उपयोग करके MSDN वेबसाइट पर अधिक विस्तृत सैद्धांतिक जानकारी प्राप्त कर सकते हैं। बहुत बुरा नहीं है, सब कुछ अलग ले लिया जाता है।

हम विकास की ओर बढ़ेंगे और कुछ बुनियादी संरचनाओं पर विचार करेंगे जिन्हें भरने की जरूरत है।

सामान्य वैश्विक डेटा।

typedef struct _MINIFILTER { PDRIVER_OBJECT pDriverObject; PFLT_FILTER pFilter; } MINIFILTER, *PMINIFILTER; MINIFILTER fileManager;

इस संरचना में हम अपने ड्राइवर के ऑब्जेक्ट के लिंक और फिल्टर इंस्टेंस के लिंक को स्टोर करेंगे। मैं यह नोट करना चाहता हूं कि PFLT_FILTER विशिष्ट रूप से एक मिनी फिल्टर की पहचान करता है और चालक की पूरी अवधि के लिए स्थिर रहता है। फ़िल्टरिंग प्रक्रिया को सक्रिय या रोकते समय उपयोग किया जाता है।

फ़िल्टर पंजीकृत करें

 CONST FLT_REGISTRATION FilterRegistration = { sizeof( FLT_REGISTRATION ), // Size FLT_REGISTRATION_VERSION, // Version 0, // Flags NULL, // Context Callbacks, // Operation callbacks FilterUnload, // FilterUnload FilterLoad, // InstanceSetup NULL, // InstanceQueryTeardown NULL, // InstanceTeardownStart NULL, // InstanceTeardownComplete NULL, // GenerateFileName NULL // NormalizeNameComponent };

यहाँ यह कई क्षेत्रों में रुकने लायक है:

कॉलबैक - एक संरचना का एक लिंक जो यह निर्धारित करता है कि हम क्या और किन कार्यों के साथ प्रक्रिया करने जा रहे हैं।
FilterUnload एक फ़ंक्शन है जिसे फ़िल्टर अक्षम होने पर कहा जाएगा।
फ़िल्टरलॉड वह फ़ंक्शन है जिसे फ़िल्टर प्रारंभ होने पर कहा जाएगा।

अगला, कॉलबैक की संरचना पर विचार करें:

 const FLT_OPERATION_REGISTRATION Callbacks[] = { { IRP_MJ_CREATE, 0, PreFileOperationCallback, PostFileOperationCallback }, { IRP_MJ_OPERATION_END } };

यहां हम इंगित करते हैं कि हम CreateFile ऑपरेशन को रोकेंगे, हम उन कार्यों को भी इंगित करते हैं जो फ़ाइल में ऑपरेशन से पहले और बाद में क्रमशः कॉल किए जाते हैं।

अगला, मैं उन फ़ंक्शंस का कोड देता हूं जिन्हें फ़िल्टर इनिशियलाइज़ और डिसेबल होने पर कहा जाता है।

 NTSTATUS FilterLoad (IN PCFLT_RELATED_OBJECTS FltObjects, IN FLT_INSTANCE_SETUP_FLAGS Flags, IN DEVICE_TYPE VolumeDeviceType, IN FLT_FILESYSTEM_TYPE VolumeFilesystemType) { if (VolumeDeviceType == FILE_DEVICE_NETWORK_FILE_SYSTEM) { return STATUS_FLT_DO_NOT_ATTACH; } return STATUS_SUCCESS; } NTSTATUS FilterUnload ( IN FLT_FILTER_UNLOAD_FLAGS Flags ) { return STATUS_SUCCESS; }

मुझे लगता है कि कोड को अतिरिक्त टिप्पणियों की आवश्यकता नहीं है, क्योंकि सब कुछ काफी मानक है। मैं केवल यह ध्यान देता हूं कि हमारा ड्राइवर नेटवर्क के लिए काम नहीं करेगा।

अब हम ड्राइवर इनिशियलाइज़ेशन फंक्शन देखें:

 NTSTATUS DriverEntry( IN PDRIVER_OBJECT theDriverObject, IN PUNICODE_STRING theRegistryPath ) { int i; NTSTATUS status; PCHAR ConfigInfo; UNICODE_STRING test; DbgPrint("MiniFilter: Started."); // Register a dispatch function for (i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; i++) { theDriverObject->MajorFunction[i] = OnStubDispatch; } theDriverObject->DriverUnload = OnUnload; fileManager.pDriverObject = theDriverObject; status = FltRegisterFilter(theDriverObject, &FilterRegistration, &fileManager.pFilter); if (!NT_SUCCESS(status)) { DbgPrint("MiniFilter: Driver not started. ERROR FltRegisterFilter - %08x\n", status); return status; } ConfigInfo = ReadConfigurationFile(); if(ConfigInfo != NULL && NT_SUCCESS(ParseConfigurationFile(ConfigInfo))) { ExFreePool(ConfigInfo); DbgPrint("MiniFilter: Configuration finished."); }else { if(ConfigInfo != NULL)ExFreePool(ConfigInfo); FltUnregisterFilter( fileManager.pFilter ); DbgPrint("MiniFilter: Driver configuration was failed. Driver not started."); return STATUS_DEVICE_CONFIGURATION_ERROR; } status = FltStartFiltering( fileManager.pFilter ); if (!NT_SUCCESS( status )) { FltUnregisterFilter( fileManager.pFilter ); FreeConfigInfo(); DbgPrint("MiniFilter: Driver not started. ERROR FltStartFiltering - %08x\n", status); return status; } DbgPrint("MiniFilter: Filter was started and configured."); return STATUS_SUCCESS; }

मिनी फिल्टर का पंजीकरण FltRegisterFilter फ़ंक्शन को कॉल करके किया जाता है, जिसमें हम इनपुट पर प्राप्त theRriverObject को पास करते हैं, FilterRegademy संरचना पहले वर्णित है और चर के लिए एक लिंक जहां बनाया गया फ़ाइल fileManager.pFilter को रखा जाएगा। फ़िल्टरिंग प्रक्रिया शुरू करने के लिए, आपको FltStartFiltering फ़ंक्शन (fileManager.pFilter) को कॉल करना होगा।

मैं यह भी ध्यान देता हूं कि कॉन्फ़िगरेशन फ़ाइल निम्न कॉल द्वारा डाउनलोड और संसाधित की जाती है कॉन्फ़िगइन्फो = ReadConfigurationFile (); और ParseConfigurationFile (ConfigInfo), क्रमशः।

कॉन्फ़िगरेशन फ़ाइल से डेटा संरचनाओं के अगले सेट में परिवर्तित हो जाता है।

 typedef struct FILE_REDIRECT_RULE { UNICODE_STRING From; UNICODE_STRING To; struct FILE_REDIRECT_RULE *NextRule; }FileRedirectRule, *PFileRedirectRule; struct PROCESS_CONFIGURATION_RULE { UNICODE_STRING ProcessName; struct FILE_REDIRECT_RULE *Rule; }; typedef struct CONFIGURATION_MAP { struct PROCESS_CONFIGURATION_RULE ProcessRule; struct REDIRECT_MAP *NextItem; }ConfigurationMap ,*PConfigurationMap;

सिर की संरचना CONFIGURATION_MAP है, जो ProcessRule प्रक्रिया के वर्णन के लिए एक लिंक संग्रहीत करती है, साथ ही अगले तत्व के लिए एक संकेतक भी है। बदले में, PROCESS_CONFIGURATION_RULE प्रक्रिया नाम के लिए और सीधे I / O पुनर्निर्देशन नियम संरचना में एक लिंक संग्रहीत करता है, जो REDIRECT_MAP की तरह एक लिंक की गई सूची है।

ड्राइवर उतारने के कार्य पर विचार करें, यह काफी सरल है:

 VOID OnUnload( IN PDRIVER_OBJECT DriverObject ) { FltUnregisterFilter(fileManager.pFilter); FreeConfigInfo(); DbgPrint("MiniFilter: Unloaded"); }

यहाँ हम सिर्फ फ़िल्टर को अनरजिस्टर्ड करते हैं और हमारे सभी विन्यास संरचनाओं को मुक्त करते हैं।

अब इनपुट / आउटपुट ऑपरेशंस के रीडायरेक्शन से संबंधित फ़ंक्शन के लिए सबसे दिलचस्प हिस्से की ओर मुड़ते हैं। चूंकि हमारे पास काफी सरल ड्राइवर है, इसलिए हम PreFileOperationCallback में यह अधिकार करेंगे।

 FLT_PREOP_CALLBACK_STATUS PreFileOperationCallback ( __inout PFLT_CALLBACK_DATA Data, __in PCFLT_RELATED_OBJECTS FltObjects, __deref_out_opt PVOID *CompletionContext ) { NTSTATUS status; PFILE_OBJECT FileObject; PFileRedirectRule redirectRuleItem; PFLT_FILE_NAME_INFORMATION pFileNameInformation; PConfigurationMap rule; UNICODE_STRING fullPath; UNICODE_STRING processName; PWCHAR Volume; FLT_PREOP_CALLBACK_STATUS returnStatus = FLT_PREOP_SUCCESS_NO_CALLBACK; if(FLT_IS_FS_FILTER_OPERATION(Data)) { return FLT_PREOP_SUCCESS_NO_CALLBACK; }

हम मुख्य चर निर्धारित करते हैं, और यह भी जांचते हैं कि क्या हमें पहले से कुछ फ़िल्टर किया गया है, और यदि ऐसा है, तो इस ऑपरेशन को छोड़ दिया जाना चाहिए, अन्यथा हम कॉल की पुनरावृत्ति प्राप्त कर सकते हैं, जिससे बीएसओडी हो सकता है।

 if (FltObjects->FileObject != NULL && Data != NULL) { FileObject = Data->Iopb->TargetFileObject; if(FileObject != NULL && Data->Iopb->MajorFunction == IRP_MJ_CREATE) {

यहां हम FilterManager से प्राप्त संरचनाओं के डेटा की ओर मुड़ते हैं। PFLT_CALLBACK_DATA संरचना - वर्तमान इनपुट / आउटपुट ऑपरेशन पर डेटा संग्रहीत करता है, फ़ाइल सिस्टम तक पहुंचते समय FilterManager को इस संरचना के क्षेत्रों द्वारा निर्देशित किया जाता है। तदनुसार, यदि हम फ़ाइलों या निर्देशिकाओं को एक्सेस करते समय विंडोज के व्यवहार को बदलना चाहते हैं, तो हमें PFLT_CALLBACK_DATA में इसे प्रतिबिंबित करना चाहिए। अधिक विशेष रूप से, हम क्षेत्र में रुचि रखते हैं डेटा-> Iopb-> TargetFileObject, इसका उपयोग करके हम वर्तमान अनुभाग में फ़ाइल का पथ प्राप्त कर सकते हैं और बाद में इसे बदल सकते हैं यदि आवश्यक हो, तो ओएस व्यवहार को बदल सकते हैं। PCFLT_RELATED_OBJECTS - इसमें I / O ऑपरेशन से जुड़ी वस्तुएं होती हैं, जैसे किसी फ़ाइल, अनुभाग, आदि का लिंक। जांचें कि हमें जिस संरचना की आवश्यकता है उसके तत्व भरे हुए हैं। हम यह भी जाँचते हैं कि जिस कार्य के संदर्भ में हम कार्य कर रहे हैं वह वास्तव में MJ_CREATE है।

 processName.Length = 0; processName.MaximumLength = NTSTRSAFE_UNICODE_STRING_MAX_CCH * sizeof(WCHAR); processName.Buffer = ExAllocatePoolWithTag(NonPagedPool, processName.MaximumLength,CURRENT_PROCESS_TAG); RtlZeroMemory(processName.Buffer, processName.MaximumLength); status = GetProcessImageName(&processName);

कोड के इस भाग में, हम पथ और प्रक्रिया के नाम के लिए मेमोरी आवंटित करते हैं। मैं कल्पना नहीं कर सकता कि स्ट्रिंग किस आकार की होगी, इसलिए अधिकतम संभव WCHAR स्ट्रिंग का चयन करें। मैं स्रोत कोड GetProcessImageName पर विचार नहीं करूंगा, मैं केवल यह कह सकता हूं कि यह निम्न रूप में फ़ाइल का पूरा रास्ता देता है: \ Device \ HarddiskVolume4 \ Windows \ notepad.exe। वह है, अनुभाग, ठीक है, वास्तव में, फ़ाइल का पथ।

  if(NT_SUCCESS(status)) { if(LoggingEnabled()== 1) { DbgPrint("MiniFilter: Process: %ws", processName.Buffer); } } else { return FLT_PREOP_SUCCESS_NO_CALLBACK; } rule = FindRuleByProcessName(&processName,GetRedirectionMap());

FindRuleByProcessName फ़ंक्शन, यदि सफल होता है, तो लिंक की गई सूची का पहला तत्व वर्तमान प्रक्रिया के लिए पुनर्निर्देशन नियमों से युक्त होता है, अन्यथा NULL।

 ExFreePool(processName.Buffer); if(rule != NULL){ if(LoggingEnabled() == 1) { DbgPrint("MiniFilter: File name %ws", FileObject->FileName.Buffer); } redirectRuleItem = rule->ProcessRule.Rule;

हम अनावश्यक मेमोरी को खाली करते हैं और जांचते हैं कि हमें किसी प्रकार की वस्तु मिली, न कि NULL। redirectRuleItem = rule-> ProcessRule.Rule - इस प्रक्रिया के लिए पहले नियम का उपयोग।

 while(redirectRuleItem) { if(RtlCompareUnicodeString(&FileObject->FileName ,&redirectRuleItem->From, FALSE) == 0) { status = FltGetFileNameInformation( Data, FLT_FILE_NAME_NORMALIZED | FLT_FILE_NAME_QUERY_ALWAYS_ALLOW_CACHE_LOOKUP, &pFileNameInformation );

हम इस प्रक्रिया के लिए सभी नियमों के अनुसार मार्ग शुरू करते हैं, कॉन्फ़िगरेशन में हमारे पास मौजूद फ़ाइल के लिंक की तुलना करें। यदि यह मेल खाता है, तो हम फ़ाइल के बारे में अतिरिक्त जानकारी प्राप्त करने का प्रयास करते हैं, उदाहरण के लिए, यह किस अनुभाग से संबंधित है। ऐसा करने के लिए, FltGetFileNameInformation फ़ंक्शन का उपयोग करें।

 if(NT_SUCCESS(status)) { fullPath.Length = 0; fullPath.MaximumLength = NTSTRSAFE_UNICODE_STRING_MAX_CCH * sizeof(WCHAR); fullPath.Buffer = ExAllocatePoolWithTag(NonPagedPool, fullPath.MaximumLength, FULL_PATH_TAG); RtlZeroMemory(fullPath.Buffer, fullPath.MaximumLength); Volume = wcssplt(pFileNameInformation->Volume.Buffer, redirectRuleItem->From.Buffer ); RtlAppendUnicodeToString(&fullPath, Volume); RtlAppendUnicodeToString(&fullPath, redirectRuleItem->To.Buffer); ExFreePool(Volume); ExFreePool(FileObject->FileName.Buffer);

यदि सब कुछ ठीक है, तो अनुभाग का चयन करने का प्रयास करें, और फिर अंतिम पंक्ति बनाएं। अंतिम पथ = वर्तमान अनुभाग + कहां से आई / ओ अनुरोध भेजना है।

  FileObject->FileName.Length = fullPath.Length; FileObject->FileName.MaximumLength = fullPath.MaximumLength; FileObject->FileName.Buffer = fullPath.Buffer; Data->Iopb->TargetFileObject->RelatedFileObject = NULL; Data->IoStatus.Information = IO_REPARSE; Data->IoStatus.Status = STATUS_REPARSE; DbgPrint("MiniFilter: Redirect done %ws", fullPath.Buffer); return FLT_PREOP_COMPLETE;

अगला, हम सिस्टम संरचनाओं को कॉन्फ़िगर करते हैं ताकि फ़ाइल प्रबंधक एक बार फिर से इस अनुरोध को संसाधित करे, लेकिन अब केवल एक अलग तरीके से। ऐसा करने के लिए, फ़ील्ड के निम्न मानों को रखना महत्वपूर्ण है डेटा-> IoStatus.Information = IO_REPARSE और डेटा-> IoStatus.Status = STATUS_REPARSE ;, साथ ही फ़ाइल के लिए एक नया पथ निर्दिष्ट करें FileObject-> FileName.Buffer = fullPath; फ़ंक्शन के परिणामस्वरूप, FLT_PROP_COMPLETE लौटें।

  } } redirectRuleItem = redirectRuleItem->NextRule; } } } } return FLT_PREOP_SUCCESS_NO_CALLBACK; }

पुनर्निर्देशन सूची के अगले तत्व पर जाने के लिए मत भूलना। यदि आप वर्तमान फ़िल्टर मेंजर ऑपरेशन के साथ कुछ नहीं करते हैं, तो FLT_PREOP_SUCCESS_NO_CALLBACK लौटें।

फिलहाल, I / O पुनर्परिभाषित केवल एक अनुभाग के ढांचे के भीतर काम करता है, जैसे ही मैं कई खंडों के समर्थन के साथ विकल्प को डीबग करता हूं, मैं इसे पोस्ट करूंगा।

विशेष रूप से डिज़ाइन की गई फ़ाइल का उपयोग करके एक मिनी फ़िल्टर स्थापित करना आवश्यक है, एक उदाहरण जो आपको इस लेख के लिए स्रोतों में मिलेगा।

कॉन्फ़िगरेशन फ़ाइल में निम्न रूप है:

 #minifilter config start { #logging : off #process : \Device\HarddiskVolume4\Windows\notepad.exe { #rule : redirect { #from : \test.txt #to : \data\test.txt } #rule : redirect { #from : \ioman.log #to : \IRCCL.ini } } }

फ़ाइल को C ड्राइव की जड़ में स्थित होना चाहिए, नाम होना चाहिए: minifilter.conf।

तो, हमारे पास फ़ाइल I / O अनुरोधों को पुनर्निर्देशित करने की क्षमता है, हालांकि, इसके अलावा, लागू करने के लिए, मान लीजिए, फ़ाइल तक पहुंच से इनकार करने का एक तंत्र काफी सरल है। उस फ़ाइल का चयन करना आवश्यक है जिस तक पहुंच से इनकार किया जाना चाहिए और सिस्टम संरचना के क्षेत्र के लिए निम्न मान निर्दिष्ट करें डेटा-> IoStatus.Status = STATUS_ACCESS_DENIED; फ़ंक्शन के परिणाम के रूप में FLT_PROP_COMPLETE को वापस करना याद रखें।

सेवा शुरू करने या बंद करने के लिए, मैं KMD प्रबंधक का उपयोग करता हूं। पूलटैग मेमोरी लीक का विश्लेषण करने के लिए। डीबगिंग के लिए, आप DbgView का उपयोग कर सकते हैं, हालाँकि, Windows Vista और इसके बाद के संस्करण के लिए डिबगिंग संदेशों को सक्रिय किया जाना चाहिए, इसके लिए आपको निम्न पथ में DWORD रजिस्ट्री कुंजी बनाने की आवश्यकता है HKEY_LOCAL_MACHINE \ SYSTEM \ Current \ontentrolSet \ Control \ Session Manager \ Debug Print फ़िल्टर नाम DEFAULT और मान के साथ फ़िल्टर करें। 8।

विंडोज 7 के 64-बिट संस्करण में ड्राइवर को शुरू करने के लिए, आपको ड्राइवर हस्ताक्षर सत्यापन को अक्षम करना होगा, ऐसा करने के लिए, कंप्यूटर को पुनरारंभ करें, सिस्टम स्टार्टअप पर F8 दबाएं और ड्राइवर हस्ताक्षर प्रवर्तन का चयन करें, या ड्राइवर हस्ताक्षर प्रवर्तन ओवरडाइडर (DSEO) उपयोगिता का उपयोग करें। यह उपयोगिता आपको डिबगिंग ड्राइवरों के लिए परीक्षण मोड को सक्रिय करने और नकली प्रमाण पत्र के साथ वांछित ड्राइवर पर हस्ताक्षर करने की अनुमति देगा, जो अंततः आपको समस्याओं के बिना उपयोग करने की अनुमति देगा।

भले ही लॉगिंग सक्षम हो या नहीं, DbgView में सेवा शुरू करने के बाद आपको कुछ इसी तरह का निरीक्षण करना चाहिए।

और इसलिए हमारा ड्राइवर डिवाइसट्री में दिखेगा

मैं यह जोड़ सकता हूं कि कोड अभी भी काफी कच्चा है और इसमें सुधार करने की आवश्यकता है, लेकिन कुल मिलाकर यह ठीक काम करता है। वास्तव में, यदि आपके पास बीएसओडी है, तो यह मेरी गलती नहीं है)। केवल विंडोज 7 X86 और विंडोज 7 IA64 पर परीक्षण किया गया।

स्रोतों और उपयोगिताओं से लिंक करें: publish.rar

क्या पढ़ें:

पुनश्च। मैं यह नोट करना चाहता हूं कि मैं सिस्टम प्रोग्रामिंग में पेशेवर नहीं हूं, इसलिए यह लेख पूरा होने का दावा नहीं करता है। मेरी गतिविधि की प्रकृति से, मैं Microsoft Dynamics CRM (.net, asp.net, आदि) के विकास में लगा हुआ हूं।

मुझे आपकी टिप्पणियों पर खुशी होगी।

मिनीफिल्टर चालक विकास

More articles: