🚌 🗻 🥀 Windows मूल अनुप्रयोग और Acronis सक्रिय पुनर्स्थापना 👩🏿‍⚖️ 🎲 Ⓜ️

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

पिछली पोस्टों में, हमने पहले से ही बात की थी कि सक्रिय पुनर्स्थापना क्या है और इनोपोलिस के छात्रों ने सेवा कैसे विकसित की। आज मैं मूल अनुप्रयोगों पर ध्यान केंद्रित करना चाहता हूं, जिस स्तर पर हम अपनी सक्रिय पुनर्प्राप्ति सेवा "दफनाना" चाहते हैं। अगर सब कुछ काम करता है, तो हम कर सकते हैं:

बहुत पहले ही सेवा शुरू करने के लिए
बहुत पहले क्लाउड से संपर्क करने के लिए जिसमें बैकअप निहित है
यह समझने के लिए बहुत पहले है कि सिस्टम किस मोड में है - सामान्य बूट या रिकवरी
अग्रिम में बहुत कम फ़ाइलों को पुनर्स्थापित करने के लिए
उपयोगकर्ता को और भी तेज़ी से आरंभ करने की अनुमति दें।

सामान्य रूप से एक मूल आवेदन क्या है?

इस प्रश्न का उत्तर देने के लिए, आइए उन कॉल के अनुक्रम को देखें जो सिस्टम करता है, उदाहरण के लिए, यदि कोई प्रोग्रामर अपने एप्लिकेशन में फ़ाइल बनाने की कोशिश करता है।

पावेल योसिफ़ोविच - विंडोज कर्नेल प्रोग्रामिंग (2019)

प्रोग्रामर CreateFile फ़ंक्शन का उपयोग करता है, जिसे fileapi.h शीर्ष लेख फ़ाइल में घोषित किया गया है और इसे कर्नेल 32.ll में कार्यान्वित किया गया है। हालाँकि, यह फ़ंक्शन स्वयं कोई फ़ाइल नहीं बनाता है; यह केवल इनपुट पर तर्कों की जाँच करता है और NtCreateFile फ़ंक्शन को कॉल करता है (Nt उपसर्ग केवल इंगित करता है कि फ़ंक्शन मूल है)। यह फ़ंक्शन winternl.h हेडर फ़ाइल में घोषित किया गया है और इसे ntdll.dll में लागू किया गया है। वह परमाणु अंतरिक्ष में कूदने की तैयारी करता है, जिसके बाद वह एक फाइल बनाने के लिए एक सिस्टम कॉल करता है। इस स्थिति में, यह पता चलता है कि कर्नेल 32 एनडीटीएल के लिए एक आवरण है। ऐसा करने के कारणों में से एक, Microsoft इस प्रकार देशी दुनिया के कार्यों को बदलने की क्षमता रखता है, लेकिन मानक इंटरफेस को नहीं छूता है। Microsoft सीधे देशी कार्यों को लागू करने की अनुशंसा नहीं करता है और उनमें से अधिकांश का दस्तावेजीकरण नहीं करता है। वैसे, यहां अनकम्फर्टेबल फीचर्स मिल सकते हैं ।

देशी अनुप्रयोगों का मुख्य लाभ यह है कि ktd32 की तुलना में बहुत पहले ntdll सिस्टम में लोड होता है। यह तार्किक है, क्योंकि कर्नेल 32 को काम करने के लिए ntdll की आवश्यकता होती है। नतीजतन, देशी कार्यों का उपयोग करने वाले एप्लिकेशन बहुत पहले काम करना शुरू कर सकते हैं।

इस प्रकार, विंडोज नेटिव एप्लिकेशन ऐसे प्रोग्राम हैं जो विंडोज को बूट करने के शुरुआती चरण में चल सकते हैं। वे ntdll से केवल फ़ंक्शन का उपयोग करते हैं। इस तरह के एक आवेदन का एक उदाहरण: ऑटोचेक जो मुख्य सेवाओं को शुरू करने से पहले त्रुटियों के लिए डिस्क की जांच करने के लिए chkdisk उपयोगिता निष्पादित करता है। यह इस स्तर पर है कि हम अपने सक्रिय पुनर्स्थापना को देखना चाहते हैं।

हमें क्या चाहिए?

DDK (चालक विकास किट), जिसे अब WDK 7 (विंडोज ड्राइवर किट) के रूप में भी जाना जाता है।
वर्चुअल मशीन (उदाहरण के लिए विंडोज़ 7 x64)
जरूरी नहीं, लेकिन हेडर फाइल को यहां डाउनलोड किया जा सकता है।

कोड में क्या है?

आइए थोड़ा अभ्यास करें और एक उदाहरण के लिए हम एक छोटा सा आवेदन लिखेंगे जो:

स्क्रीन पर एक संदेश प्रदर्शित करता है।
थोड़ी याददाश्त आवंटित करता है
कीबोर्ड इनपुट की प्रतीक्षा की जा रही है
पेड़ व्यस्त स्मृति

मूल अनुप्रयोगों में, प्रवेश बिंदु मुख्य या वाइनमैन नहीं है, लेकिन NtProcessStartup फ़ंक्शन, क्योंकि हम वास्तव में सीधे सिस्टम में नई प्रक्रिया शुरू करते हैं।

स्क्रीन पर संदेश प्रदर्शित करके शुरू करते हैं। ऐसा करने के लिए, हमारे पास एक देशी फ़ंक्शन NtDisplayString है , जो UNICODE_STRING संरचना के ऑब्जेक्ट के लिए एक संकेतक के रूप में लेता है। RtlInitUnicodeString हमें इसे आरंभ करने में मदद करेगा। परिणामस्वरूप, स्क्रीन पर पाठ प्रदर्शित करने के लिए, हम इस तरह के एक छोटे से कार्य को लिख सकते हैं:

//usage: WriteLn(L"Here is my text\n"); void WriteLn(LPWSTR Message) { UNICODE_STRING string; RtlInitUnicodeString(&string, Message); NtDisplayString(&string); }

चूंकि केवल ntdll से कार्य हमारे लिए उपलब्ध हैं, और स्मृति में अभी तक कोई अन्य पुस्तकालय नहीं हैं, इसलिए हमें निश्चित रूप से स्मृति को आवंटित करने के तरीके के साथ समस्याएं होंगी। नया ऑपरेटर अभी तक मौजूद नहीं है (क्योंकि यह बहुत उच्च-स्तरीय C ++ दुनिया से आता है), कोई मॉलॉक फ़ंक्शन भी नहीं है (इसे रनटाइम सी लाइब्रेरी की आवश्यकता है)। आप निश्चित रूप से केवल स्टैक का उपयोग कर सकते हैं। लेकिन अगर हमें गतिशील रूप से मेमोरी आवंटित करने की आवश्यकता है, तो हमें यह ढेर (यानी ढेर) पर करना होगा। इसलिए, आइए हम अपने लिए एक गुच्छा बनाएं और जब हमें इसकी आवश्यकता होगी तो हम इससे स्मृति लेंगे।

फ़ंक्शन RtlCreateHeap इस कार्य के लिए उपयुक्त है। इसके अलावा, RtlAllocateHeap और RtlFreeHeap का उपयोग करते हुए, हम ज़रूरत पड़ने पर मेमोरी को कब्ज़े और मुक्त कर लेंगे।

 PVOID memory = NULL; PVOID buffer = NULL; ULONG bufferSize = 42; // create heap in order to allocate memory later memory = RtlCreateHeap( HEAP_GROWABLE, NULL, 1000, 0, NULL, NULL ); // allocate buffer of size bufferSize buffer = RtlAllocateHeap( memory, HEAP_ZERO_MEMORY, bufferSize ); // free buffer (actually not needed because we destroy heap in next step) RtlFreeHeap(memory, 0, buffer); RtlDestroyHeap(memory);

चलो कीबोर्ड इनपुट की प्रतीक्षा कर रहे हैं।

 // https://docs.microsoft.com/en-us/windows/win32/api/ntddkbd/ns-ntddkbd-keyboard_input_data typedef struct _KEYBOARD_INPUT_DATA { USHORT UnitId; USHORT MakeCode; USHORT Flags; USHORT Reserved; ULONG ExtraInformation; } KEYBOARD_INPUT_DATA, *PKEYBOARD_INPUT_DATA; //... HANDLE hKeyBoard, hEvent; UNICODE_STRING skull, keyboard; OBJECT_ATTRIBUTES ObjectAttributes; IO_STATUS_BLOCK Iosb; LARGE_INTEGER ByteOffset; KEYBOARD_INPUT_DATA kbData; // inialize variables RtlInitUnicodeString(&keyboard, L"\\Device\\KeyboardClass0"); InitializeObjectAttributes(&ObjectAttributes, &keyboard, OBJ_CASE_INSENSITIVE, NULL, NULL); // open keyboard device NtCreateFile(&hKeyBoard, SYNCHRONIZE | GENERIC_READ | FILE_READ_ATTRIBUTES, &ObjectAttributes, &Iosb, NULL, FILE_ATTRIBUTE_NORMAL, 0, FILE_OPEN,FILE_DIRECTORY_FILE, NULL, 0); // create event to wait on InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL); NtCreateEvent(&hEvent, EVENT_ALL_ACCESS, &ObjectAttributes, 1, 0); while (TRUE) { NtReadFile(hKeyBoard, hEvent, NULL, NULL, &Iosb, &kbData, sizeof(KEYBOARD_INPUT_DATA), &ByteOffset, NULL); NtWaitForSingleObject(hEvent, TRUE, NULL); if (kbData.MakeCode == 0x01) // if ESC pressed { break; } }

हमें केवल एक खुली डिवाइस पर NtReadFile का उपयोग करने की आवश्यकता है, और जब तक कीबोर्ड हमें एक क्लिक नहीं देता है तब तक प्रतीक्षा करें। यदि ईएससी कुंजी दबाया जाता है, तो हम काम करना जारी रखेंगे। डिवाइस को खोलने के लिए, हमें NtCreateFile फ़ंक्शन को कॉल करना होगा (आपको \ Device \ KeyboardClass0 खोलने की आवश्यकता होगी)। प्रतीक्षा को ऑब्जेक्ट प्रारंभ करने के लिए हम NtCreateEvent को भी कॉल करेंगे। हम स्वतंत्र रूप से KEYBOARD_INPUT_DATA संरचना की घोषणा करेंगे जो कीबोर्ड डेटा का प्रतिनिधित्व करता है। इससे हमारे काम में आसानी होगी।

मूल एप्लिकेशन NtTerminateProcess फ़ंक्शन के लिए कॉल के साथ समाप्त होता है, क्योंकि हम सिर्फ अपनी प्रक्रिया को मारते हैं।

हमारे छोटे से आवेदन के सभी कोड:

 #include "ntifs.h" // \WinDDK\7600.16385.1\inc\ddk #include "ntdef.h" //------------------------------------ // Following function definitions can be found in native development kit // but I am too lazy to include `em so I declare it here //------------------------------------ NTSYSAPI NTSTATUS NTAPI NtTerminateProcess( IN HANDLE ProcessHandle OPTIONAL, IN NTSTATUS ExitStatus ); NTSYSAPI NTSTATUS NTAPI NtDisplayString( IN PUNICODE_STRING String ); NTSTATUS NtWaitForSingleObject( IN HANDLE Handle, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout ); NTSYSAPI NTSTATUS NTAPI NtCreateEvent( OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN EVENT_TYPE EventType, IN BOOLEAN InitialState ); // https://docs.microsoft.com/en-us/windows/win32/api/ntddkbd/ns-ntddkbd-keyboard_input_data typedef struct _KEYBOARD_INPUT_DATA { USHORT UnitId; USHORT MakeCode; USHORT Flags; USHORT Reserved; ULONG ExtraInformation; } KEYBOARD_INPUT_DATA, *PKEYBOARD_INPUT_DATA; //---------------------------------------------------------- // Our code goes here //---------------------------------------------------------- // usage: WriteLn(L"Hello Native World!\n"); void WriteLn(LPWSTR Message) { UNICODE_STRING string; RtlInitUnicodeString(&string, Message); NtDisplayString(&string); } void NtProcessStartup(void* StartupArgument) { // it is important to declare all variables at the beginning HANDLE hKeyBoard, hEvent; UNICODE_STRING skull, keyboard; OBJECT_ATTRIBUTES ObjectAttributes; IO_STATUS_BLOCK Iosb; LARGE_INTEGER ByteOffset; KEYBOARD_INPUT_DATA kbData; PVOID memory = NULL; PVOID buffer = NULL; ULONG bufferSize = 42; //use it if debugger connected to break //DbgBreakPoint(); WriteLn(L"Hello Native World!\n"); // inialize variables RtlInitUnicodeString(&keyboard, L"\\Device\\KeyboardClass0"); InitializeObjectAttributes(&ObjectAttributes, &keyboard, OBJ_CASE_INSENSITIVE, NULL, NULL); // open keyboard device NtCreateFile(&hKeyBoard, SYNCHRONIZE | GENERIC_READ | FILE_READ_ATTRIBUTES, &ObjectAttributes, &Iosb, NULL, FILE_ATTRIBUTE_NORMAL, 0, FILE_OPEN,FILE_DIRECTORY_FILE, NULL, 0); // create event to wait on InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL); NtCreateEvent(&hEvent, EVENT_ALL_ACCESS, &ObjectAttributes, 1, 0); WriteLn(L"Keyboard ready\n"); // create heap in order to allocate memory later memory = RtlCreateHeap( HEAP_GROWABLE, NULL, 1000, 0, NULL, NULL ); WriteLn(L"Heap ready\n"); // allocate buffer of size bufferSize buffer = RtlAllocateHeap( memory, HEAP_ZERO_MEMORY, bufferSize ); WriteLn(L"Buffer allocated\n"); // free buffer (actually not needed because we destroy heap in next step) RtlFreeHeap(memory, 0, buffer); RtlDestroyHeap(memory); WriteLn(L"Heap destroyed\n"); WriteLn(L"Press ESC to continue...\n"); while (TRUE) { NtReadFile(hKeyBoard, hEvent, NULL, NULL, &Iosb, &kbData, sizeof(KEYBOARD_INPUT_DATA), &ByteOffset, NULL); NtWaitForSingleObject(hEvent, TRUE, NULL); if (kbData.MakeCode == 0x01) // if ESC pressed { break; } } NtTerminateProcess(NtCurrentProcess(), 0); }

PS: हम डिबगर में रोकने के लिए कोड में DbgBreakPoint () फ़ंक्शन का उपयोग आसानी से कर सकते हैं। सच है, आपको कर्नेल डीबगिंग के लिए WinDbg को वर्चुअल मशीन से कनेक्ट करना होगा। ऐसा करने के निर्देश यहां दिए जा सकते हैं या बस VirtualKD का उपयोग कर सकते हैं ।

संकलन और सभा

देशी एप्लिकेशन बनाने का सबसे आसान तरीका डीडीके (ड्राइवर डेवलपमेंट किट) का उपयोग करना है। हमें वास्तव में पुराने सातवें संस्करण की आवश्यकता है, क्योंकि बाद के संस्करणों में थोड़ा अलग दृष्टिकोण है और विजुअल स्टूडियो के साथ मिलकर काम करते हैं। यदि हम DDK का उपयोग करते हैं, तो हमारी परियोजना को केवल Makefile और स्रोतों की आवश्यकता है।

makefile

 !INCLUDE $(NTMAKEENV)\makefile.def

सूत्रों का कहना है:

 TARGETNAME = MyNative TARGETTYPE = PROGRAM UMTYPE = nt BUFFER_OVERFLOW_CHECKS = 0 MINWIN_SDK_LIB_PATH = $(SDK_LIB_PATH) SOURCES = source.c INCLUDES = $(DDK_INC_PATH); \ C:\WinDDK\7600.16385.1\ndk; TARGETLIBS = $(DDK_LIB_PATH)\ntdll.lib \ $(DDK_LIB_PATH)\nt.lib USE_NTDLL = 1

आपका मेकफाइल बिल्कुल वैसा ही होगा, लेकिन अधिक विस्तार से सूत्रों पर ध्यान दें। इस फ़ाइल में आपके प्रोग्राम (.c फ़ाइलें), बिल्ड विकल्प और अन्य पैरामीटर शामिल हैं।

TARGETNAME - निष्पादन योग्य फ़ाइल का नाम, जिसका परिणाम होना चाहिए।
TARGETTYPE - निष्पादन योग्य फ़ाइल का प्रकार, यह एक ड्राइवर (.sys) हो सकता है, फिर फ़ील्ड मान DRIVER होना चाहिए, यदि लाइब्रेरी (.lib), तो मान LIBRARY है। हमारे मामले में, हमें एक निष्पादन योग्य फ़ाइल (.exe) की आवश्यकता है, इसलिए हम मान को PROGRAM पर सेट करते हैं।
UMTYPE - इस क्षेत्र के लिए संभव मान: कंसोल एप्लिकेशन के लिए कंसोल, विंडो मोड में संचालन के लिए विंडो। लेकिन हमें मूल एप्लिकेशन प्राप्त करने के लिए एनटी निर्दिष्ट करने की आवश्यकता है।
BUFFER_OVERFLOW_CHECKS - बफर अतिप्रवाह के लिए स्टैक की जांच करना, दुर्भाग्य से हमारा मामला नहीं है, इसे बंद करें।
MINWIN_SDK_LIB_PATH - यह मान SDK_LIB_PATH वैरिएबल को संदर्भित करता है, चिंता न करें कि आपके पास एक समान सिस्टम वैरिएबल घोषित नहीं है, जिस पल में हम DDK से चेक बिल्ड बनाते हैं, यह वैरिएबल घोषित होगा और आवश्यक पुस्तकालयों को इंगित करेगा।
स्रोत - अपने कार्यक्रम के स्रोतों की एक सूची।
INCLUDES - असेंबली के लिए आवश्यक हेडर फाइलें। वे आमतौर पर डीडीके के साथ आने वाली फ़ाइलों के लिए पथ को इंगित करते हैं, लेकिन आप वैकल्पिक रूप से किसी अन्य को निर्दिष्ट कर सकते हैं।
TARGETLIBS - उन पुस्तकालयों की सूची, जिन्हें लिंक करने की आवश्यकता है।
USE_NTDLL एक आवश्यक फ़ील्ड है जिसे स्थिति 1 पर सेट किया जाना चाहिए। स्पष्ट कारणों के लिए।
USER_C_FLAGS - कोई भी झंडे जो आप आवेदन कोड तैयार करते समय प्रीप्रोसेसर निर्देशों में उपयोग कर सकते हैं।

तो बनाने के लिए, हमें x86 (या x64) चेक किए गए बिल्ड को चलाने, वर्किंग डायरेक्टरी को प्रोजेक्ट फ़ोल्डर में बदलने और बिल्ड कमांड को निष्पादित करने की आवश्यकता है। स्क्रीनशॉट में परिणाम से पता चलता है कि हमने एक निष्पादन योग्य फ़ाइल एकत्र की है।

बिल्ड

यह फ़ाइल इतनी आसानी से नहीं चल सकती है, सिस्टम शपथ लेता है और हमें निम्न त्रुटि के साथ इसके व्यवहार के बारे में सोचने के लिए भेजता है:

देशी एप्लिकेशन कैसे चलाएं?

ऑटोकॉक की शुरुआत में, कार्यक्रमों का स्टार्टअप अनुक्रम रजिस्ट्री कुंजी के मूल्य से निर्धारित होता है:

 HKLM\System\CurrentControlSet\Control\Session Manager\BootExecute

सत्र प्रबंधक इस सूची के कार्यक्रमों को एक-एक करके निष्पादित करता है। सेशन मैनेजर ही सिस्टम32 डायरेक्टरी में एक्जीक्यूटेबल फाइल्स की तलाश करता है। रजिस्ट्री कुंजी मान का प्रारूप निम्नानुसार है:

 autocheck autochk *MyNative

मान हेक्साडेसिमल प्रारूप में होना चाहिए, और सामान्य ASCII में नहीं, इसलिए, ऊपर प्रस्तुत की गई कुंजी में प्रारूप होगा:

 61,75,74,6f,63,68,65,63,6b,20,61,75,74,6f,63,68,6b,20,2a,00,4d,79,4e,61,74,69,76,65,00,00

नाम बदलने के लिए, आप एक ऑनलाइन सेवा का उपयोग कर सकते हैं, उदाहरण के लिए, यह एक ।

यह पता चला है कि मूल एप्लिकेशन को चलाने के लिए, हमें आवश्यकता है:

निष्पादन योग्य फ़ाइल को सिस्टम 32 फ़ोल्डर में कॉपी करें
रजिस्ट्री में एक कुंजी जोड़ें
रिबूट मशीन

सुविधा के लिए, देशी एप्लिकेशन इंस्टॉल करने के लिए यहां तैयार स्क्रिप्ट है:

install.bat

 @echo off copy MyNative.exe %systemroot%\system32\. regedit /s add.reg echo Native Example Installed pause

add.reg

 REGEDIT4 [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager] "BootExecute"=hex(7):61,75,74,6f,63,68,65,63,6b,20,61,75,74,6f,63,68,6b,20,2a,00,4d,79,4e,61,74,69,76,65,00,00

इंस्टॉलेशन और रीबूटिंग के बाद, उपयोगकर्ता चयन स्क्रीन दिखाई देने से पहले ही, हमें निम्न चित्र मिलते हैं:

परिणाम

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

अगले लेख में, हम सक्रिय पुनर्स्थापना सेवा के एक अन्य घटक, अर्थात् यूईएफआई चालक को स्पर्श करेंगे। अगली पोस्ट को याद न करने के लिए हमारे ब्लॉग को सब्सक्राइब करें