🙅🏼 🚱 🔇 सबसे सरल WDM ड्राइवर 🥢 👩🏾‍🤝‍👩🏽 🏡

यह आलेख एक साधारण ड्राइवर लिखने की प्रक्रिया का वर्णन करता है जो दबाए गए कुंजी के स्कैन कोड प्रदर्शित करता है।
यह लेख ड्राइवरों को लिखने के लिए एक कार्यस्थल स्थापित करने की प्रक्रिया का भी वर्णन करता है।
यदि आप रुचि रखते हैं, तो कृपया बिल्ली के नीचे।

स्टैंड की तैयारी

एक साधारण ड्राइवर लिखने के लिए आवश्यक सॉफ़्टवेयर स्थापित करना

आवश्यक सॉफ्टवेयर:

विंडोज डीडीके (चालक विकास किट);
VMware कार्य केंद्र या वर्चुअल बॉक्स;
विंडोज एक्सपी
विजुअल स्टूडियो 2005;
DDKWizard;
KmdManager
DebugView;

मैं दो आभासी मशीनों का उपयोग करता हूं, एक पर ड्राइवर लिखता हूं, और दूसरे पर चलता हूं। यदि आप भी ऐसा करने का निर्णय लेते हैं, तो जिस मशीन पर आप ड्राइवर चलाएंगे, उसके लिए 4 जीबी हार्ड डिस्क और 256 एमबी रैम पर्याप्त हैं।

कार्यस्थल सेटअप

DDK स्थापना

स्थापना अत्यंत सरल है। केवल एक चीज जिस पर आपको ध्यान देने की आवश्यकता है वह वह संवाद है जिसमें आपको उन घटकों का चयन करने के लिए कहा जाता है जिन्हें इंस्टॉल किया जाएगा। मैं दृढ़ता से अनुशंसा करता हूं कि सभी दस्तावेज और उदाहरण नोट किए जाएं।

Microsoft® Visual Studio 2005 को स्थापित और कॉन्फ़िगर करें

Microsoft® Visual Studio 2005 स्थापित करना DDK को स्थापित करने से अधिक कठिन नहीं है। यदि आप इसे केवल ड्राइवरों को लिखने के लिए उपयोग करेंगे, तो जब इंस्टॉलर पूछता है कि कौन से घटकों को स्थापित किया जाना चाहिए, तो केवल दृश्य C ++ का चयन करें।
अगला, आप विजुअल असिस्ट एक्स को स्थापित कर सकते हैं। इस प्रोग्राम (ऐड-ऑन) का उपयोग करके, आप आसानी से सुविधाजनक लेखन ड्राइवरों के लिए युक्तियों को कॉन्फ़िगर कर सकते हैं।
विजुअल असिस्टेंट एक्स को विजुअल स्टूडियो 2005 में स्थापित करने के बाद, नया VAssistX मेनू दिखाई देता है। इस मेनू में आगे: Visual Assist X Options -> Projects -> C/C++ Directories -> Platform: Custom, Show Directories for: Stable include files । Ins क्लिक करें या आइकन में एक नई निर्देशिका जोड़ें और दिखाई देने वाली पंक्ति में, यदि आपके पास Windows XP टाइप %WXPBASE%\inc\ddk\wxp ।

DDKWizard स्थापित करें और कॉन्फ़िगर करें

ड्राइवरों को संकलित करने के लिए Visual Studio के लिए, आपको DDKWizard स्थापित करने की आवश्यकता है। इसे ddkwizard.assarbad.net से डाउनलोड किया जा सकता है। इस साइट से ddkbuild.cmd स्क्रिप्ट भी डाउनलोड करें।
विज़ार्ड स्थापित होने के बाद, आपको निम्न चरण करने चाहिए:

निम्न नामों के साथ सिस्टम (अनुशंसित) या उपयोगकर्ता चर बनाएं और एक मान जो DDK के लिए पथ से मेल खाता है

डीडीके संस्करण	चर नाम	डिफ़ॉल्ट पथ
विंडोज एक्सपी डीडीके	WXPBASE	C: \ WINDDK \ 2600
विंडोज 2003 सर्वर डीडीके	WNETBASE	C: \ WINDDK \ 3790.1830
विंडोज विस्टा / विंडोज 2008 सर्वर डब्ल्यूडीके	WLHBASE
विंडोज 7 / विंडोज 2008 सर्वर आर 2 डब्ल्यूडीके	W7BASE

उदाहरण के लिए, यदि मैं Windows XP DDK का उपयोग करता हूं, तो मुझे एक WXPBASE वैरिएबल बनाना होगा, जो DDK के पथ से मेल खाता हो। चूंकि मैंने स्थापना पथ नहीं बदला है, इसलिए मेरे पास मूल्य C: \ WINDDK \ 2600 होगा।

डाउनलोड किए गए ddkbuild.cmd स्क्रिप्ट की प्रतिलिपि बनाएँ, उदाहरण के लिए, DDK के साथ फ़ोल्डर में। मेरे पास यह C: \ WINDDK \ है।
पथ सिस्टम चर के अंत में ddkbuild.cmd स्क्रिप्ट में पथ जोड़ें।

सब कुछ, जिस मशीन पर हम ड्राइवरों को चलाएंगे, वह तैयार है।

ड्राइवरों को चलाने के लिए आवश्यक सॉफ़्टवेयर स्थापित करना

अब उस मशीन को कॉन्फ़िगर करें जिस पर हम लिखित ड्राइवर चलाएंगे।
हमें निम्नलिखित कार्यक्रमों की आवश्यकता होगी:

डीबग व्यू ( लिंक ) एक उपयोगिता है जो आपको उपयोगकर्ता मोड और कर्नेल मोड दोनों के डिबग आउटपुट को देखने की अनुमति देती है।
KmdManager ( लिंक ) - गतिशील रूप से लोड / अनलोड करने वाले ड्राइवरों के लिए एक उपयोगिता

सब कुछ, कार ड्राइवरों को चलाने के लिए तैयार है।

समस्या का बयान

टास्क: एक ड्राइवर को लिखें जो प्रेस किए गए कुंजियों के स्कैन कोड और डिबग के उनके संयोजन को आउटपुट करेगा।

सिद्धांत की बिट

एक ड्राइवर फ़ंक्शन का एक सेट है जिसे ऑपरेटिंग सिस्टम द्वारा कॉल किया जाता है जब डिवाइस या उपयोगकर्ता मोड से कुछ घटनाएं होती हैं।
ड्राइवरों के कई प्रकार हैं, जिनमें से कुछ नीचे सूचीबद्ध हैं:

क्लास ड्राइवर
minidriver;
कार्यात्मक चालक;
छानने वाले ड्राइवर।

क्लास ड्राइवर वे ड्राइवर होते हैं जिन्हें Microsoft लिखता है। ये (वास्तव में!) उपकरणों के एक निश्चित वर्ग के लिए सामान्य ड्राइवर हैं।
मिनीड्राइवर ऐसे ड्राइवर होते हैं जो किसी डिवाइस को नियंत्रित करने के लिए क्लास ड्राइवर का उपयोग करते हैं।
कार्यात्मक चालक वे ड्राइवर होते हैं जो स्वतंत्र रूप से काम करते हैं और डिवाइस से संबंधित सब कुछ निर्धारित करते हैं।
फ़िल्टरिंग ड्राइवर वे ड्राइवर होते हैं जिनका उपयोग किसी अन्य ड्राइवर के तर्क को मॉनिटर करने या बदलने के लिए किया जाता है, जो उस पर जाने वाले डेटा को बदलकर करता है।

अपने ड्राइवर में सभी संभावित कार्यों को परिभाषित करना आवश्यक नहीं है, लेकिन इसमें DriverEntry और AddDevice होना आवश्यक है।

IRP वह संरचना है जिसका उपयोग चालक डेटा का आदान-प्रदान करने के लिए करते हैं।

तो, स्कैन कोड को आउटपुट करने के लिए ( यह क्या है? ) डिबग करने के लिए, हम एक फ़िल्टरिंग ड्राइवर का उपयोग करेंगे।
फ़िल्टरिंग ड्राइवर दो प्रकार के होते हैं:

शीर्ष फ़िल्टरिंग ड्राइवर;
नीचे फिल्टर ड्राइवरों।

आपके पास ड्राइवर का प्रकार इस बात पर निर्भर करता है कि ड्राइवर डिवाइस ड्राइवर स्टैक में कहाँ स्थित है। यदि आपका ड्राइवर कार्यात्मक चालक से ऊपर है, तो इसे ऊपरी फ़िल्टरिंग ड्राइवर कहा जाता है, यदि कम है, तो, निम्न फ़िल्टरिंग ड्राइवर।

ऊपरी और निचले फ़िल्टरिंग ड्राइवरों के बीच अंतर

सभी अनुरोध ऊपरी फ़िल्टरिंग ड्राइवरों के माध्यम से जाते हैं, जिसका अर्थ है कि वे कार्यात्मक ड्राइवर को जाने वाली जानकारी को बदल सकते हैं और / या फ़िल्टर कर सकते हैं, और फिर, संभवतः, डिवाइस पर।
शीर्ष फ़िल्टरिंग ड्राइवरों का उपयोग करने का एक उदाहरण:
फ़िल्टर हुक ड्राइवर, जो ट्रैफ़िक को ट्रैक करने और फ़िल्टर करने के लिए IpFilterDirver सिस्टम ड्राइवर के लिए अपना हुक फ़ंक्शन सेट करता है। ऐसे ड्राइवरों का उपयोग फायरवॉल में किया जाता है।

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

समन्‍वय समस्‍याएँ

ड्राइवर में जो हम लिखेंगे, कई "समस्या" अनुभाग हैं। हमारे ड्राइवर के लिए हमारी विधानसभा आवेषण का उपयोग करना पर्याप्त है:

 __asm { lock dec «,     » }

या

 __asm { lock inc «,     » }

lock उपसर्ग आपको निम्नलिखित के बाद कमांड को सुरक्षित रूप से निष्पादित करने की अनुमति देता है। कमांड चलने के दौरान यह बाकी प्रोसेसर्स को ब्लॉक कर देता है।

शूटर

सबसे पहले आपको हेडर फाइल "ntddk.h", "ntddkbd.h" को शामिल करना होगा।

 extern "C" { #include "ntddk.h" } #include "ntddkbd.h"

DEVICE_EXTENSION की संरचना का वर्णन करना भी आवश्यक है

 typedef struct _DEVICE_EXTENSION{ PDEVICE_OBJECT pLowerDO; } DEVICE_EXTENSION, *PDEVICE_EXTENSION;

pLowerDO ऑब्जेक्ट एक डिवाइस ऑब्जेक्ट है जो स्टैक पर हमारे नीचे है। हमें यह जानने की आवश्यकता है कि IRP पैकेट किसे भेजे जाएँ।
हमारे ड्राइवर के संचालन के लिए, हमें एक चर की आवश्यकता है जिसमें अपूर्ण अनुरोधों की संख्या संग्रहीत की जाएगी।

 int gnRequests;

आइए फ़ंक्शन से शुरू करें, जो हमारे ड्राइवर का मुख्य प्रवेश बिंदु है।

 extern "C" NTSTATUS DriverEntry(IN PDRIVER_OBJECT theDriverObject, IN PUNICODE_STRING ustrRegistryPath)

theDriverObject - ड्राइवर ऑब्जेक्ट, ऑपरेटिंग सिस्टम के लिए आवश्यक सभी फ़ंक्शन के लिए पॉइंटर्स समाहित करता है जिन्हें हमें आरंभ करने की आवश्यकता होगी।
ustrRegistryPath - रजिस्ट्री में उस अनुभाग का नाम जहां इस ड्राइवर के बारे में जानकारी संग्रहीत है।
सबसे पहले आपको चर घोषित करने और उन्हें रद्द करने की आवश्यकता है:

 gnRequests = 0; NTSTATUS status = {0};

अगला, जैसा कि मैंने ऊपर लिखा था, आपको फ़ंक्शन पॉइंटर्स को इनिशियलाइज़ करने की आवश्यकता है

 for (int i = 0; i<IRP_MJ_MAXIMUM_FUNCTION; ++i) { theDriverObject->MajorFunction[i] = DispatchThru; } theDriverObject->MajorFunction[IRP_MJ_READ] = DispatchRead; theDriverObject->DriverUnload = DriverUnload;

DispatchRead फ़ंक्शन रीड रिक्वेस्ट को हैंडल करेगा। यह तब कहा जाएगा जब कीबोर्ड कुंजी दबाया जाएगा या जारी किया जाएगा।
DriverUnload फ़ंक्शन तब कहा जाता है जब ड्राइवर की आवश्यकता नहीं होती है और मेमोरी से अनलोड किया जा सकता है, या जब उपयोगकर्ता ड्राइवर को DriverUnload करता DriverUnload । इस फ़ंक्शन में, "स्ट्रिपिंग" किया जाना चाहिए, अर्थात ड्राइवर द्वारा उपयोग किए जाने वाले संसाधनों को मुक्त कर दिया जाता है, सभी अपूर्ण अनुरोध पूरा हो जाते हैं, आदि।
DispatchThru फ़ंक्शन एक स्टब फ़ंक्शन है। वह जो करती है वह IRP पैकेट अगले ड्राइवर को देती है (वह ड्राइवर जो स्टैक में हमारे अधीन है, यानी pLowerDO से DEVICE_EXTENSION )।
अगला, हम डिवाइस स्टैक पर अपना डिवाइस बनाने और स्थापित करने के लिए अपने फ़ंक्शन को कॉल करते हैं:

 status = InstallFilter(theDriverObject);

मैं नीचे इस फ़ंक्शन का वर्णन करूंगा।
हम status लौटाते हैं, जिसमें, यदि InstallFilter फ़ंक्शन InstallFilter , तो STATUS_SUCCESS मान संग्रहीत किया जाता है।
हम InstallFilter फ़ंक्शन को पास करते हैं। यहाँ उसका प्रोटोटाइप है:

 NTSTATUS InstallFilter(IN PDRIVER_OBJECT theDO);

यह फ़ंक्शन एक डिवाइस ऑब्जेक्ट बनाता है, इसे कॉन्फ़िगर करता है, और इसे \\Device\\KeyboardClass0 पर डिवाइस स्टैक पर धकेलता है

घोषित चर:

 PDEVICE_OBJECT pKeyboardDevice; NTSTATUS status = {0};

pKeyboardDevice डिवाइस ऑब्जेक्ट है जिसे हमें बनाने की आवश्यकता है।
एक नया उपकरण बनाने के लिए IoCreateDevice पर कॉल करें

 status = IoCreateDevice(theDO, sizeof(DEVICE_EXTENSION), NULL, FILE_DEVICE_KEYBOARD, 0, FALSE, &pKeyboardDevice);

आइए मापदंडों का अधिक विस्तार से विश्लेषण करें:

पहला तर्क ड्राइवर ऑब्जेक्ट है जिसे हमने इंस्टालफिल्टर फ़ंक्शन के पैरामीटर के रूप में प्राप्त किया है। यह हमारे ड्राइवर और नए डिवाइस के बीच संबंध स्थापित करने के लिए IoCreateDevice को पास किया गया है।
तीसरा पैरामीटर डिवाइस का नाम है
चौथा पैरामीटर डिवाइस का प्रकार है
पांचवां पैरामीटर वह झंडे हैं जो आमतौर पर बड़े पैमाने पर भंडारण उपकरणों के लिए निर्धारित किए जाते हैं।
छठा पैरामीटर बताता है कि क्या एक से अधिक राशि में डिवाइस मैनिपुलेटर्स को खोलना संभव है। यदि FALSE है, तो आप केवल एक जोड़तोड़ खोल सकते हैं। अन्यथा, आप किसी भी संख्या में जोड़तोड़ खोल सकते हैं।
सातवां पैरामीटर वह मेमोरी है जिसमें बनाई गई डिवाइस ऑब्जेक्ट को सहेजा जाएगा।

अगला, डिवाइस के झंडे सेट करें।

 pKeyboardDevice->Flags = pKeyboardDevice->Flags | (DO_BUFFERED_IO | DO_POWER_PAGABLE); pKeyboardDevice->Flags = pKeyboardDevice->Flags & ~DO_DEVICE_INITIALIZING;

हम अपने डिवाइस के लिए जो झंडे सेट करते हैं, वह उस डिवाइस के झंडे के बराबर होना चाहिए जिसके ऊपर हम स्टैक पर धकेल दिए जाते हैं।
अगला, हमें उस उपकरण के नाम का रूपांतरण करना होगा जिसे हम स्टैक पर रख रहे हैं।

 CCHAR cName[40] = "\\Device\\KeyboardClass0"; STRING strName; UNICODE_STRING ustrDeviceName; RtlInitAnsiString(&strName, cName); RtlAnsiStringToUnicodeString(&ustrDeviceName, &strName, TRUE);

IoAttachDevice फ़ंक्शन स्टैक पर हमारे डिवाइस को IoAttachDevice । pdx->pLowerDO अगले (निचले) डिवाइस pdx->pLowerDO ऑब्जेक्ट को स्टोर किया जाएगा।

 IoAttachDevice(pKeyboardDevice, &ustrDeviceName, &pdx->pLowerDO);

संसाधनों को खाली करना:

 RtlFreeUnicodeString(&ustrDeviceName);

अगला, हम प्रोटोटाइप के साथ DispatchRead फ़ंक्शन का विश्लेषण करेंगे:

 NTSTATUS DispatchRead(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp);

जब आप कीबोर्ड कुंजी दबाते या छोड़ते हैं तो यह फ़ंक्शन ऑपरेटिंग सिस्टम द्वारा कॉल किया जाएगा
हम अपूर्ण अनुरोधों के काउंटर को बढ़ाते हैं

 __asm { lock inc gnRequests }

अगले ड्राइवर के लिए अनुरोध पारित करने से पहले, हमें ड्राइवर के लिए स्टैक पॉइंटर को कॉन्फ़िगर करना होगा। IoCopyCurrentIrpStackLocationToNext स्मृति के उस हिस्से की प्रतिलिपि बनाता है जो वर्तमान ड्राइवर के अगले ड्राइवर के मेमोरी क्षेत्र से संबंधित है।

 IoCopyCurrentIrpStackLocationToNext(theIrp);

जब कोई अनुरोध स्टैक से नीचे जाता है, तब भी हमारे पास वह डेटा नहीं होता है जिसकी हमें आवश्यकता होती है, इसलिए हमें एक फ़ंक्शन सेट करने की आवश्यकता होती है, जिसे तब कॉल किया जाएगा जब अनुरोध डेटा के साथ ढेर हो जाता है जिसकी हमें आवश्यकता होती है।

 IoSetCompletionRoutine(theIrp, ReadCompletionRoutine, pDeviceObject, TRUE, TRUE, TRUE)

जहाँ ReadCompletionRoutine हमारा कार्य है।
हम निम्नलिखित ड्राइवर IRP :

 return IoCallDriver(((PDEVICE_EXTENSION) pDeviceObject->DeviceExtension)->pLowerDO ,theIrp);

अब हम उस फ़ंक्शन का विश्लेषण करेंगे जिसे IRP पूरा होने पर हर बार बुलाया जाएगा। प्रोटोटाइप:

 NTSTATUS ReadCompletionRoutine(IN PDEVICE_OBJECT pDeviceObject, IN PIRP theIrp, IN PVOID Context);

DEVICE_EXTENSION :

 PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION)pDeviceObject->DeviceExtension;

PKEYBOARD_INPUT_DATA संरचना PKEYBOARD_INPUT_DATA उपयोग दबाए गए कुंजी का वर्णन करने के लिए किया जाता है।

 PKEYBOARD_INPUT_DATA kidData;

जांचें कि अनुरोध सफलतापूर्वक पूरा हुआ या नहीं

 if (NT_SUCCESS(theIrp->IoStatus.Status))

KEYBOARD_INPUT_DATA संरचना प्राप्त करने के लिए, आपको IRP पैकेट के सिस्टम बफर तक पहुंचने की आवश्यकता है।

 kidData = (PKEYBOARD_INPUT_DATA)theIrp->AssociatedIrp.SystemBuffer;

चाबियों की संख्या का पता लगाएं

 int n = theIrp->IoStatus.Information / sizeof(KEYBOARD_INPUT_DATA);

और प्रत्येक कुंजी प्रिंट करें:

 for(int i = 0; i<n; ++i) DbgPrint("Code: %x\n", kidData[i].MakeCode);

और संसाधित नहीं किए गए अनुरोधों की संख्या को कम करना न भूलें

 __asm { lock dec gnRequests }

अनुरोध की स्थिति लौटाएं

 return theIrp->IoStatus.Status;

चलो शटडाउन फ़ंक्शन का विश्लेषण करते हैं। प्रोटोटाइप:

 VOID DriverUnload(IN PDRIVER_OBJECT theDO);

DEVICE_EXTENSION :

 PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION)theDO->DeviceObject->DeviceExtension;

हम डिवाइस को स्टैक से निकालते हैं:

 IoDetachDevice(pdx->pLowerDO);

हम डिवाइस निकालते हैं:

 IoDeleteDevice(theDO->DeviceObject);

जांचें कि क्या लंबित अनुरोध हैं या नहीं। यदि हम इस जांच के बिना ड्राइवर को लोड करते हैं, तो उतारने के बाद कुंजी के पहले प्रेस में एक बीएसओडी होगा।

 if (gnRequests != 0) { KTIMER ktTimer; LARGE_INTEGER liTimeout; liTimeout.QuadPart = 1000000; KeInitializeTimer(&ktTimer);        ,   while(gnRequests > 0) { KeSetTimer(&ktTimer, liTimeout, NULL); //   KeWaitForSingleObject(&ktTimer, Executive, KernelMode, FALSE, NULL); //     } }

ड्राइवर कोड:

 extern "C" { #include "ntddk.h" } #include "ntddkbd.h" typedef struct _DEVICE_EXTENSION{ PDEVICE_OBJECT pLowerDO; } DEVICE_EXTENSION, *PDEVICE_EXTENSION; int gnRequests; NTSTATUS DispatchThru(PDEVICE_OBJECT theDeviceObject, PIRP theIrp) { IoSkipCurrentIrpStackLocation(theIrp); return IoCallDriver(((PDEVICE_EXTENSION) theDeviceObject->DeviceExtension)->pLowerDO ,theIrp); } NTSTATUS InstallFilter(IN PDRIVER_OBJECT theDO) { PDEVICE_OBJECT pKeyboardDevice; NTSTATUS status = {0}; status = IoCreateDevice(theDO, sizeof(DEVICE_EXTENSION), NULL, FILE_DEVICE_KEYBOARD, 0, FALSE, &pKeyboardDevice); if (!NT_SUCCESS(status)) { DbgPrint("IoCreateDevice error.."); return status; } pKeyboardDevice->Flags = pKeyboardDevice->Flags | (DO_BUFFERED_IO | DO_POWER_PAGABLE); pKeyboardDevice->Flags = pKeyboardDevice->Flags & ~DO_DEVICE_INITIALIZING; RtlZeroMemory(pKeyboardDevice->DeviceExtension, sizeof(DEVICE_EXTENSION)); PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION)pKeyboardDevice->DeviceExtension; CCHAR cName[40] = "\\Device\\KeyboardClass0"; STRING strName; UNICODE_STRING ustrDeviceName; RtlInitAnsiString(&strName, cName); RtlAnsiStringToUnicodeString(&ustrDeviceName, &strName, TRUE); IoAttachDevice(pKeyboardDevice, &ustrDeviceName, &pdx->pLowerDO); //DbgPrint("After IoAttachDevice"); RtlFreeUnicodeString(&ustrDeviceName); return status; } VOID DriverUnload(IN PDRIVER_OBJECT theDO) { PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION)theDO->DeviceObject->DeviceExtension; IoDetachDevice(pdx->pLowerDO); IoDeleteDevice(theDO->DeviceObject); if (gnRequests != 0) { KTIMER ktTimer; LARGE_INTEGER liTimeout; liTimeout.QuadPart = 1000000; KeInitializeTimer(&ktTimer); while(gnRequests > 0) { KeSetTimer(&ktTimer, liTimeout, NULL); KeWaitForSingleObject(&ktTimer, Executive, KernelMode, FALSE, NULL); } } } NTSTATUS ReadCompletionRoutine(IN PDEVICE_OBJECT pDeviceObject, IN PIRP theIrp, IN PVOID Context) { PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION)pDeviceObject->DeviceExtension; PKEYBOARD_INPUT_DATA kidData; if (NT_SUCCESS(theIrp->IoStatus.Status)) { kidData = (PKEYBOARD_INPUT_DATA)theIrp->AssociatedIrp.SystemBuffer; int n = theIrp->IoStatus.Information / sizeof(KEYBOARD_INPUT_DATA); for(int i = 0; i<n; ++i) { DbgPrint("Code: %x\n", kidData[i].MakeCode); } } if(theIrp->PendingReturned) IoMarkIrpPending(theIrp); __asm{ lock dec gnRequests } return theIrp->IoStatus.Status; } NTSTATUS DispatchRead(IN PDEVICE_OBJECT pDeviceObject, IN PIRP theIrp) { __asm{ lock inc gnRequests } IoCopyCurrentIrpStackLocationToNext(theIrp); IoSetCompletionRoutine(theIrp, ReadCompletionRoutine, pDeviceObject, TRUE, TRUE, TRUE); return IoCallDriver(((PDEVICE_EXTENSION) pDeviceObject->DeviceExtension)->pLowerDO ,theIrp); } extern "C" NTSTATUS DriverEntry(IN PDRIVER_OBJECT theDriverObject, IN PUNICODE_STRING RegistryPath) { NTSTATUS status = {0}; gnRequests = 0; for (int i = 0; i<IRP_MJ_MAXIMUM_FUNCTION; ++i) { theDriverObject->MajorFunction[i] = DispatchThru; } theDriverObject->MajorFunction[IRP_MJ_READ] = DispatchRead; status = InstallFilter(theDriverObject); theDriverObject->DriverUnload = DriverUnload; return status; }

makefile:

 # # DO NOT EDIT THIS FILE!!! Edit .\sources. if you want to add a new source # file to this component. This file merely indirects to the real make file # that is shared by all the driver components of the Windows NT DDK # !INCLUDE $(NTMAKEENV)\makefile.def

स्रोत:

 TARGETNAME=sysfile TARGETPATH=BIN TARGETTYPE=DRIVER SOURCES = DriverMain.cpp

ड्राइवर कैसे शुरू करें और डिबगिंग जानकारी देखें

ड्राइवर को चलाने के लिए, मैंने KmdManager उपयोगिता का उपयोग किया। डिबग जानकारी देखने के लिए, DbgView उपयोगिता का उपयोग किया गया था।

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

UPD: GitHub पर प्रोजेक्ट: https://github.com/pbespechnyi/simple-wdm-driver

सबसे सरल WDM ड्राइवर