कर्नेल-ब्रिज फ्रेमवर्क: ब्रिज इन रिंग0

क्या आप कभी भी ऑपरेटिंग सिस्टम के हुड के नीचे देखना चाहते हैं, इसके तंत्र की आंतरिक संरचना को देखते हैं, शिकंजा घुमाते हैं और उन अवसरों को देखते हैं जो खुल गए हैं? शायद वे भी सीधे हार्डवेयर के साथ काम करना चाहते थे, लेकिन लगा कि ड्राइवर रॉकेट थे?

मैं पुल के साथ कोर तक चलने का प्रस्ताव करता हूं और देखता हूं कि खरगोश छेद कितना गहरा है।

इसलिए, मैं कर्नेल हैकिंग के लिए ड्राइवर फ्रेमवर्क प्रस्तुत करता हूं, जिसे C ++ 17 में लिखा गया है, और डिज़ाइन किया गया है, यदि संभव हो तो कर्नेल और उपयोगकर्ता मोड के बीच की बाधाओं को दूर करने या यथासंभव उनकी उपस्थिति को सुचारू करने के लिए। और यह भी, शुरुआती और उन्नत दोनों के लिए Ring0 में त्वरित और सुविधाजनक विकास के लिए उपयोगकर्ता-मोड और कर्नेल एपीआई और रैपर का एक सेट।

मुख्य विशेषताएं:

• IOP के माध्यम से उपयोगकर्ता मोड में I / O पोर्ट तक पहुँच, साथ ही, बाहर , cli और sti निर्देशों को अग्रेषित करना
• सिस्टम ट्वीटर पर लपेटता है
• एक्सेस MSR (मॉडल-विशिष्ट रजिस्टर)
• अन्य प्रक्रियाओं और कर्नेल मेमोरी के उपयोगकर्ता-मोड मेमोरी तक पहुंचने के लिए फ़ंक्शन का एक सेट
• भौतिक मेमोरी, DMI / SMBIOS के साथ काम करें
• उपयोगकर्ता-मोड और परमाणु प्रवाह का निर्माण, एपीसी वितरण
• उपयोगकर्ता-मोड ओब *** और पीएस *** कॉलबैक और फ़ाइल सिस्टम फ़िल्टर
• अहस्ताक्षरित ड्राइवर और कर्नेल लाइब्रेरी डाउनलोड करें

... और भी बहुत कुछ।

और हम अपने C ++ प्रोजेक्ट को फ्रेमवर्क लोड करके और कनेक्ट करके शुरू करेंगे।

GitHub

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

परीक्षण के लिए, विंडोज के साथ मुफ्त VMware प्लेयर स्थापित, किसी भी क्षमता के विंडोज 7 से कम नहीं, एकदम सही है।

असेंबली तुच्छ है और इससे सवाल नहीं होंगे:

1. कर्नेल-ब्रिज खोलें
2. आवश्यक बिट गहराई चुनें
3. Ctrl + Shift + B

नतीजतन, हमें एक ड्राइवर, एक उपयोगकर्ता-मोड लाइब्रेरी, साथ ही संबंधित उपयोगिता फाइलें ( * स्थापना के लिए * .ff , Microsoft हार्डवेयर प्रमाणन प्रकाशक, आदि पर ड्राइवर पर हस्ताक्षर करने के लिए * .cab) मिलती हैं ।

ड्राइवर को स्थापित करने के लिए (यदि x64 के लिए कोई डिजिटल हस्ताक्षर आवश्यक नहीं है - संबंधित ईवी प्रमाण पत्र), आपको ड्राइवरों के डिजिटल हस्ताक्षर को अनदेखा करते हुए सिस्टम को परीक्षण मोड में डालने की आवश्यकता है। ऐसा करने के लिए, कमांड लाइन को व्यवस्थापक के रूप में चलाएं:

bcdedit.exe /set loadoptions DISABLE_INTEGRITY_CHECKS
bcdedit.exe /set TESTSIGNING ON

... और मशीन को रिबूट करें। यदि सब कुछ सही ढंग से किया गया है, तो एक शिलालेख निचले दाएं कोने में दिखाई देगा जो कि विंडोज परीक्षण मोड में है।

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

रूपरेखा में निम्नलिखित पदानुक्रम है:

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

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

तो, C ++ में कंसोल प्रोजेक्ट बनाएं, आवश्यक हेडर फ़ाइलों को कनेक्ट करें और ड्राइवर को लोड करें:

 #include <Windows.h> #include "WdkTypes.h" //    x32/x64    WDK #include "CtlTypes.h" //   IOCTL-   #include "User-Bridge.h" // API,   int main() { using namespace KbLoader; BOOL Status = KbLoadAsFilter( L"X:\\Folder\\Path\\To\\Kernel-Bridge.sys", L"260000" //       ); if (!Status) return 0; //   ! //     API ... // : KbUnload(); return 0; } 

बहुत बढ़िया! अब हम एपीआई का उपयोग कर सकते हैं और कर्नेल के साथ बातचीत कर सकते हैं।
चलो धोखा देने वाले डेवलपर्स के वातावरण में सबसे लोकप्रिय कार्यक्षमता के साथ शुरू करते हैं - एक और प्रक्रिया की स्मृति को पढ़ना और लिखना:

 using namespace Processes::MemoryManagement; constexpr int Size = 64; BYTE Buffer[Size] = {}; BOOL Status = KbReadProcessMemory( //  KbWriteProcessMemory,   ProcessId, 0x7FFF0000, //     ProcessId &Buffer, Size ); 

कुछ भी जटिल नहीं! आइए एक स्तर नीचे जाएं - परमाणु मेमोरी पढ़ना और लिखना:

 using namespace VirtualMemory; constexpr int Size = 64; BYTE Buffer[Size]; //  "",  ""    , //       : BOOL Status = KbCopyMoveMemory( reinterpret_cast<WdkTypes::PVOID>(Buffer), //  0xFFFFF80000C00000, //  Size, FALSE //  ,     ); 

लोहे के साथ बातचीत के कार्यों के बारे में क्या? उदाहरण के लिए, I / O पोर्ट।

हम उन्हें EFlags रजिस्टर में 2 IOPL बिट्स को कॉक करके उपयोगकर्ता मोड में भेजेंगे, जो विशेषाधिकार स्तर के लिए जिम्मेदार हैं, जिसमें / बाहर / cli / sti निर्देश उपलब्ध हैं।

इस प्रकार, हम उन्हें प्राक्कलन त्रुटि के बिना उपयोगकर्ता मोड में निष्पादित करने में सक्षम होंगे:

 #include <intrin.h> using namespace IO::Iopl; //  ,   ! KbRaiseIopl(); //  in/out/cli/sti   ! ULONG Frequency = 1000; // 1 kHz ULONG Divider = 1193182 / Frequency; __outbyte(0x43, 0xB6); //     //      : __outbyte(0x42, static_cast<unsigned char>(Divider)); __outbyte(0x42, static_cast<unsigned char>(Divider >> 8)); __outbyte(0x61, __inbyte(0x61) | 3); //   (   ) for (int i = 0; i < 5000; i++); //   Sleep(),  IOPL      ! __outbyte(0x61, __inbyte(0x61) & 252); //   KbResetIopl(); 

लेकिन सच्ची आजादी का क्या? सब के बाद, एक अक्सर कर्नेल विशेषाधिकारों के साथ मनमाना कोड निष्पादित करना चाहता है। हम उपयोगकर्ता मोड में सभी कर्नेल कोड लिखते हैं और नियंत्रण को इसे कर्नेल से स्थानांतरित करते हैं (SMEP स्वचालित रूप से बंद हो जाता है, इससे पहले कि ड्राइवर FPU संदर्भ को बचाता है और कॉल स्वयं try.except ब्लॉक के अंदर होती है):

 using namespace KernelShells; //    KeStallExecutionProcessor: ULONG Result = 1337; KbExecuteShellCode( []( _GetKernelProcAddress GetKernelProcAddress, PVOID Argument ) -> ULONG { //      Ring0 //     : using _KeStallExecutionProcessor = VOID(WINAPI*)(ULONG Microseconds); auto Stall = reinterpret_cast<_KeStallExecutionProcessor>( GetKernelProcAddress(L"KeStallExecutionProcessor") ); Stall(1000 * 1000); //      ULONG Value = *static_cast<PULONG>(Argument); return Value == 1337 ? 0x1EE7C0DE : 0; }, &Result, // Argument &Result // Result ); //   Result = 0x1EE7C0DE 

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

फ्रेमवर्क आपको CreateFile / ReadFile / WriteFile / DeviceIoControl , साथ ही साथ हैंडल / डुप्लिकेटिंग हैंडल ( ObRegisterCallbacks ) खोलने और प्रक्रियाओं / थ्रेड शुरू करने और मॉड्यूल ( PsSet *** NotifyRoutine ) की घटनाओं की घटनाओं को फ़िल्टर करने की अनुमति देता है। यह, उदाहरण के लिए, मनमानी फ़ाइलों तक पहुंच को अवरुद्ध करने या हार्ड डिस्क के सीरियल नंबर के बारे में जानकारी को बदलने की अनुमति देगा।

काम सिद्धांत:

1. ड्राइवर फ़िल्टर को पंजीकृत करता है और Ob *** / Ps *** कॉलबैक स्थापित करता है
2. ड्राइवर एक संचार पोर्ट खोलता है जिसमें ग्राहक ईवेंट कनेक्ट की सदस्यता लेना चाहते हैं
3. उपयोगकर्ता-मोड एप्लिकेशन पोर्ट से जुड़ते हैं और उस घटना के बारे में ड्राइवर से डेटा प्राप्त करते हैं, फ़िल्टरिंग करते हैं (अधिकारों में ट्रंकट हैंडल, फ़ाइल तक पहुंच को अवरुद्ध करते हैं, आदि) और घटना को कर्नेल पर वापस लौटाएं
4. ड्राइवर प्राप्त परिवर्तनों को लागू करता है।

ObRegisterCallbacks की सदस्यता लेने और वर्तमान प्रक्रिया तक पहुँच में कटौती का एक उदाहरण:

 #include <Windows.h> #include <fltUser.h> #include "CommPort.h" #include "WdkTypes.h" #include "FltTypes.h" #include "Flt-Bridge.h" ... //   ObRegisterCallbacks: CommPortListener<KB_FLT_OB_CALLBACK_INFO, KbObCallbacks> ObCallbacks; //        PROCESS_VM_READ: Status = ObCallbacks.Subscribe([]( CommPort& Port, MessagePacket<KB_FLT_OB_CALLBACK_INFO>& Message ) -> VOID { auto Data = static_cast<PKB_FLT_OB_CALLBACK_INFO>(Message.GetData()); if (Data->Target.ProcessId == GetCurrentProcessId()) { Data->CreateResultAccess &= ~PROCESS_VM_READ; Data->DuplicateResultAccess &= ~PROCESS_VM_READ; } ReplyPacket<KB_FLT_OB_CALLBACK_INFO> Reply(Message, ERROR_SUCCESS, *Data); Port.Reply(Reply); //   }); 

इसलिए, हम संक्षेप में फ्रेमवर्क के उपयोगकर्ता-मोड भाग के मुख्य बिंदुओं पर गए, लेकिन कोर एपीआई पर्दे के पीछे रहा।

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

कर्नेल में तार के साथ काम करने का एक उदाहरण सभी शुरुआती लोगों के लिए एक ठोकर है:

 #include <wdm.h> #include <ntstrsafe.h> #include <stdarg.h> #include "StringsAPI.h" WideString wString = L"Some string"; AnsiString aString = wString.GetAnsi().GetLowerCase() + " and another string!"; if (aString.Matches("*another*")) DbgPrint("%s\r\n", aString.GetData()); 

यदि आप अपने आईओसीएलएल कोड के लिए अपने स्वयं के हैंडलर को लागू करना चाहते हैं, तो आप निम्न योजना के अनुसार इसे आसानी से कर सकते हैं:

1. में एक हैंडलर लिखें / कर्नेल- Bridge/Kernel-Bridge/IOCTLHandlers.cpp
2. उसी फ़ाइल में, DispatchIOCTL फ़ंक्शन में हैंडलर सरणी के अंत में एक हैंडलर जोड़ें
3. Ctl में क्वेरी इंडेक्स :: KbCtlIndices enumeration को CtlTypes.h में SAME स्थिति के रूप में आइटम 2 में हैंडलर्स सरणी में जोड़ें।
4. User-Bridge.cpp में रैपर लिखकर, उपयोगकर्ता मोड से अपने हैंडलर को कॉल करें, जिससे KbSendRequest फ़ंक्शन का उपयोग करके कॉल किया जा सके।

सभी तीन प्रकार के I / O समर्थित हैं (METHOD_BUFFERED, METHOD_NEITHER और METHOD_IN_DIRECT / METHOD_OUT_DIRECT) डिफ़ॉल्ट रूप से, METHOD_NEITHER का उपयोग किया जाता है।

वह सब है! लेख में सभी संभावनाओं का एक छोटा सा अंश शामिल है। मुझे उम्मीद है कि फ्रेम कर्नेल घटकों, रिवर्स इंजीनियरों, धोखा देने वाले डेवलपर्स, एंटी-चीट्स और सुरक्षा के नौसिखिए डेवलपर्स के लिए उपयोगी होगा।

और यह भी कि, सभी को विकास में भाग लेने के लिए आमंत्रित किया जाता है। भविष्य की योजनाओं में:

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

आपका ध्यान के लिए धन्यवाद!