रजिस्ट्री में चालक फिल्टर संचालन। अभ्यास

नमस्कार, हेब्र!

जब मुझे अपने स्वयं के ड्राइवर को लिखने के कार्य का सामना करना पड़ा, जो रजिस्ट्री में संचालन की निगरानी करता है, तो, मैं, ज़ाहिर है, इस बारे में कम से कम कुछ जानकारी के लिए इंटरनेट पर खोज कर रहा हूं। लेकिन केवल एक चीज जो "रजिस्ट्री के ड्राइवर-फ़िल्टर" के अनुरोध पर निकली थी, एक ड्राइवर-फ़िल्टर (चीयर्स) लिखने पर लेखों की एक धारा थी, लेकिन इन सभी लेखों को केवल फ़ाइल सिस्टम फ़िल्टर (उदासी) से संबंधित था।

दुर्भाग्य से, केवल एक चीज जो 2003 में मिली थी, वह कोड था, जिसमें से आप कभी भी अपने नए वीएस 19 में इकट्ठा नहीं करेंगे।

सौभाग्य से, GitHub पर Microsoft का एक शानदार उदाहरण है (मैं तुरंत एक लिंक फेंक दूंगा), जिस पर इस विश्लेषण का अधिकांश निर्माण किया जाएगा।

शायद 5 मिनट में सब कुछ पता लगाने के लिए सुपरप्रोग्रामर्स के लिए एक उदाहरण का लिंक पर्याप्त है। लेकिन मेरे जैसे, शुरुआती, छात्र भी हैं, जिनके लिए, सबसे अधिक संभावना है, यह लेख होगा। मुझे उम्मीद है कि यह वास्तव में किसी की मदद करता है।

ठीक है। पीछा किया। हम एक उदाहरण खोलते हैं। चेतावनी! हम बड़ी संख्या में फ़ाइलों से डरते नहीं हैं, 80% हमें ज़रूरत नहीं है।

हम परियोजना में 2 फ़ोल्डर देखते हैं: exe और sys। पहले वाले में एक प्रोग्राम होता है जो ड्राइवर को शुरू करता है, इसे सिस्टम में रजिस्टर करता है, और ड्राइवर के साथ काम पूरा होने पर, इसे हटा देता है। हम उसके साथ शुरू करेंगे।

Regctrl.c खोलें

यहां हमें लगभग सभी प्रोग्राम कोड की आवश्यकता है।

तुरंत wmain फ़ंक्शन पर जाएं। हम वहां क्या देखते हैं? UtilLoadDriver (use.c) फ़ंक्शन के साथ ड्राइवर लोड हो रहा है, और फिर कुछ सेटिंग्स के लिए निर्देश:

printf("\treg add \"HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Debug Print Filter\" /v IHVDRIVER /t REG_DWORD /d 0x8\n\n"); 

हां, आपको निर्दिष्ट फ़ोल्डर में रजिस्ट्री में पैरामीटर दर्ज करने की आवश्यकता है (आप सेमी का उपयोग कर सकते हैं, या आप पेन का उपयोग कर सकते हैं)। यह आवश्यक है ताकि हम ड्राइवर से अधिक संदेश देख सकें
वैसे, एक एप्लिकेशन डाउनलोड करना न भूलें जो आपको डिबगिंग जानकारी देखने की अनुमति देता है, मैंने DbgView का उपयोग किया।

इसके अलावा, हमें 2 दिलचस्प कार्य दिखाई देते हैं: DoKernelModeSamples और DoUserModeSamples - उन्हें ड्राइवर के संचालन को प्रदर्शित करने की आवश्यकता है। यहां पहला उदाहरण है, उदाहरण के लिए, IIOL ड्राइवर को DeviceIoControl फ़ंक्शन के साथ एक अनुरोध भेजता है, ड्राइवर, बदले में, दूसरे पैरामीटर IOCTL_DO_KERNELMODE -SAMPLES का उपयोग करके आवश्यक फ़ंक्शन लॉन्च करेगा।

DeviceIoControl फ़ंक्शन के विवरण से, हम देखते हैं कि यह ड्राइवर को एक बफर पास कर सकता है और इसे स्वीकार भी कर सकता है। हमें भविष्य में इसकी आवश्यकता होगी। इस बीच, इस फाइल में हमारे लिए कुछ भी दिलचस्प नहीं है।

चलिए sys फोल्डर में जाते हैं, driver.c फाइल

DriverEntry फ़ंक्शन के साथ शुरू करते हैं। वहां, ड्राइवर किसी प्रकार की डिबगिंग जानकारी प्रदर्शित करता है, फिर IoCreateDeviceSecure फ़ंक्शन एक नामित डिवाइस ऑब्जेक्ट बनाता है और निर्दिष्ट सुरक्षा मापदंडों को लागू करता है, एक दिलचस्प बिट हमें आगे इंतजार करता है:

 DriverObject->MajorFunction[IRP_MJ_CREATE] = DeviceCreate; DriverObject->MajorFunction[IRP_MJ_CLOSE] = DeviceClose; DriverObject->MajorFunction[IRP_MJ_CLEANUP] = DeviceCleanup; DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DeviceControl; DriverObject->DriverUnload = DeviceUnload; 

कोष्ठक में IRP के लिए मुख्य फ़ंक्शन कोड हैं। यही है, ये पैकेज के प्रकार हैं जो हमारे ड्राइवर का ध्यान आकर्षित करेंगे। "=" संकेत के बाद, आने वाले पैकेट को संसाधित करने वाले फ़ंक्शन को इंगित किया जाता है। तो फिर, थोड़ा दिलचस्प। लेकिन। यहां आपको एक दिलचस्प फीचर जोड़ना होगा। इस जगह को याद रखें, हम यहां वापस आएंगे
तो, अगर DeviceCreate, DeviceClose, DeviceCleanup और DeviceUnload के साथ सब कुछ स्पष्ट है, तो DeviceControl में क्या होता है? और वहाँ हमारे कार्यक्रम का अनुरोध उड़ जाएगा, जिसे हमने DeviceIoControl फ़ंक्शन के साथ भेजा था। हम स्टैक से अनुरोध को पकड़ते हैं और (दूसरे उदाहरण में) सिर्फ दूसरे पैरामीटर के बारे में बात करते हैं, जिसके बारे में मैंने बात की थी:

 IrpStack = IoGetCurrentIrpStackLocation(Irp); Ioctl = IrpStack->Parameters.DeviceIoControl.IoControlCode; 

IoControlCode के आधार पर, चालक एक विशेष कार्य करने के लिए जाएगा। मैं आपको सलाह देता हूं कि उदाहरण के लिए, पूर्व की फ़ाइल पर विचार करें और समझें कि वहां क्या होता है।

और हम अंतिम दिलचस्प बिंदु के साथ उदाहरण पर विचार करेंगे - बेशक, कॉलबैक फ़ंक्शन।

यह वह जगह है जहां रजिस्ट्री में होने वाले संचालन की सूचनाएं उड़ेंगी। मुझे याद करने के लिए कहा गया स्थान याद है? यह थोड़ा अधिक है। यहाँ हम CmRegisterCallbackEx छोड़ देंगे। वे कॉलबैक फ़ंक्शन को "बैग" के रूप में घोषित करेंगे, जिसमें आईआरपी पैकेट प्रसंस्करण के लिए उड़ जाएगा। CallbackCtx-> Altitude हमारे ड्राइवर के स्तर को निर्धारित करेगा (हम रजिस्ट्री की निगरानी करने वाले एकमात्र व्यक्ति नहीं हैं), अर्थात, किस ऊंचाई पर हमारा ड्राइवर पैकेट को इंटरसेप्ट करेगा और उनके साथ कुछ करेगा (फिर से, pre.c में, यह बहुत अच्छा है कि यह कैसे और कैसे होता है) : हम फ़ंक्शन को पंजीकृत करते हैं, रजिस्ट्री के साथ कुछ करते हैं, सब कुछ तय हो गया है, जानकारी ड्राइवर द्वारा प्रदर्शित की जाती है, और फिर हम विपरीत कार्रवाई करते हैं - CmUnRegisterCallback - ताकि हमारे पास कुछ और न पहुंचे)।

अरे हाँ। जब आप DbgView में ड्राइवर से संदेशों की एक अंतहीन स्ट्रीम पाते हैं, तो घबराएं नहीं - रजिस्ट्री में हमेशा कुछ हैंगआउट होते हैं।

दरअसल, कॉलबैक फ़ंक्शन के तर्कों से, आप सभी आवश्यक जानकारी निकाल सकते हैं - दोनों ऑपरेशन कुछ कुंजी पर किए गए हैं (यह सिर्फ कोड में है - NotifyClass), और प्रमुख नाम

अब इस उदाहरण से हटते हैं। विचार करें कि क्या दिलचस्प तरीके से किया जा सकता है।

ऐसा कार्य: हमें प्रोग्राम और रजिस्ट्री कुंजी का नाम एक फाइल में रखना चाहिए, हम प्रोग्राम एक्सेस अधिकारों को एक निश्चित कुंजी पर निर्दिष्ट करते हैं (हम खुद को सरल तक सीमित रखते हैं: इसमें एक्सेस नहीं है)।

हमारा कार्यक्रम (exe फ़ोल्डर में एक) कॉन्फ़िगरेशन को पढ़ेगा और IOCL अनुरोध का उपयोग करके इसे ड्राइवर को भेज देगा। तीसरे तर्क के रूप में DeviceIoControl फ़ंक्शन में, हम बफर पास करेंगे। आप अपनी इच्छानुसार कॉन्फ़िगरेशन को स्थानांतरित और व्यवस्थित कर सकते हैं।

ड्राइवर इन अधिकारों को प्राप्त करता है और खुद को कुछ वैश्विक बफर में सहेजता है। इनपुट एरे को इस तरह से प्राप्त किया जा सकता है:

 in_buf = Irp->AssociatedIrp.SystemBuffer; 

अब कुंजी पर कुछ प्रोग्राम एक्सेस को अस्वीकार करने का प्रयास करें
कॉलबैक फ़ंक्शन पर जाएं।

आइए हमारे कार्यक्रम के नाम और उस कुंजी को सूचित करें जिसके पास पहुँच नहीं है, क्रमशः MyProg और MyKey।

हमें यह पता लगाने की आवश्यकता है कि वर्तमान में कौन सा प्रोग्राम कुंजी को एक्सेस करने की कोशिश कर रहा है और इसके नाम की तुलना हमारे कॉन्फ़िगरेशन में पंजीकृत है। प्रक्रिया का नाम इस तरह से प्राप्त किया जा सकता है:

 PUNICODE_STRING processName = NULL; GetProcessImageName(PsGetCurrentProcess(), &processName); if (wcsstr(processName->Buffer, MyProg) != NULL) { <>} 

GetProcessImageName फ़ंक्शन लाइब्रेरी (लेकिन इंटरनेट) नहीं है, इसके विभिन्न रूपों को कई मंचों पर पाया जा सकता है। मैं उसे यहाँ छोड़ दूँगा:

 typedef NTSTATUS(*QUERY_INFO_PROCESS) ( __in HANDLE ProcessHandle, __in PROCESSINFOCLASS ProcessInformationClass, __out_bcount(ProcessInformationLength) PVOID ProcessInformation, __in ULONG ProcessInformationLength, __out_opt PULONG ReturnLength ); QUERY_INFO_PROCESS ZwQueryInformationProcess; NTSTATUS GetProcessImageName( PEPROCESS eProcess, PUNICODE_STRING* ProcessImageName ) { NTSTATUS status = STATUS_UNSUCCESSFUL; ULONG returnedLength; HANDLE hProcess = NULL; PAGED_CODE(); // this eliminates the possibility of the IDLE Thread/Process if (eProcess == NULL) { return STATUS_INVALID_PARAMETER_1; } status = ObOpenObjectByPointer(eProcess, 0, NULL, 0, 0, KernelMode, &hProcess); if (!NT_SUCCESS(status)) { DbgPrint("ObOpenObjectByPointer Failed: %08x\n", status); return status; } if (ZwQueryInformationProcess == NULL) { UNICODE_STRING routineName = RTL_CONSTANT_STRING(L"ZwQueryInformationProcess"); ZwQueryInformationProcess = (QUERY_INFO_PROCESS)MmGetSystemRoutineAddress(&routineName); if (ZwQueryInformationProcess == NULL) { DbgPrint("Cannot resolve ZwQueryInformationProcess\n"); status = STATUS_UNSUCCESSFUL; goto cleanUp; } } /* Query the actual size of the process path */ status = ZwQueryInformationProcess(hProcess, ProcessImageFileName, NULL, // buffer 0, // buffer size &returnedLength); if (STATUS_INFO_LENGTH_MISMATCH != status) { DbgPrint("ZwQueryInformationProcess status = %x\n", status); goto cleanUp; } *ProcessImageName = ExAllocatePoolWithTag(NonPagedPoolNx, returnedLength, '2gat'); if (ProcessImageName == NULL) { status = STATUS_INSUFFICIENT_RESOURCES; goto cleanUp; } /* Retrieve the process path from the handle to the process */ status = ZwQueryInformationProcess(hProcess, ProcessImageFileName, *ProcessImageName, returnedLength, &returnedLength); if (!NT_SUCCESS(status)) ExFreePoolWithTag(*ProcessImageName, '2gat'); cleanUp: ZwClose(hProcess); return status; } 

हमने पाया कि अभी MyProg रजिस्ट्री तक पहुँच बना रहा है। अब आपको यह पता लगाना है कि कौन सी कुंजी है।

दूसरे तर्क से, हम उस कुंजी के बारे में जानकारी निकालते हैं जिसे एक्सेस किया जा रहा है

 REG_PRE_OPEN_KEY_INFORMATION* pRegPreCreateKey = (REG_PRE_OPEN_KEY_INFORMATION*)Argument2; if (pRegPreCreateKey != NULL) { if (wcscmp(pRegPreCreateKey->CompleteName->Buffer, MyKey) == 0) { if (){// return STATUS_SUCCESS; } else {// return STATUS_ACCESS_DENIED; } } } 

बस प्रतिबंध का संकेत देने वाला मान लौटाएं। और वह सब है।

यह लेख यह सुनिश्चित करने के लिए नहीं है कि जो कोई भी पढ़ता है वह सुपर ड्राइवरों को देखता है।

यह कहने के लिए, मामलों के पाठ्यक्रम के लिए एक परिचय है :) क्योंकि यह आमतौर पर यह वास्तव में पर्याप्त नहीं है जब आप बस समझना शुरू करते हैं।