लिनक्स कर्नेल मॉड्यूल का सरल मास्किंग DKOM का उपयोग कर

जैसा कि आप जानते हैं, उपयोगकर्ता के सर्वव्यापी "आंखों" से कर्नेल मॉड्यूल को छिपाने के कार्य में कई अनुप्रयोग हो सकते हैं। यह लेख डीकेओएम (डायरेक्ट कर्नेल ऑब्जेक्ट मैनिपुलेशन) के उपयोग पर चर्चा करता है - एक ऐसी तकनीक है जो आपको कर्नेल की आंतरिक संरचनाओं को संशोधित करके जानकारी को छिपाने की अनुमति देती है।

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



जैसा कि नाम से पता चलता है, DKOM का आधार कर्नेल की आंतरिक संरचनाओं में हेरफेर करने का संचालन है। इस मामले में, परिवर्तन के दौर से गुजरने वाली संरचना मॉड्यूल की एक आंतरिक सूची है जिसमें सिस्टम में लोड सभी मॉड्यूल के लिंक होते हैं।

कर्नेल में मॉड्यूल की प्रस्तुति

लिनक्स कर्नेल मॉड्यूल डिस्क्रिप्टर संरचना उसी नाम की संरचना है, जिसे लिनक्स / मॉड्यूल.एच में वर्णित किया गया है:

223 struct module 224 { 225 enum module_state state; 226 227 /* Member of list of modules */ 228 struct list_head list; 229 230 /* Unique handle for this module */ 231 char name[MODULE_NAME_LEN]; ... 378 }; 

अन्य बातों के अलावा, इस संरचना में list फ़ील्ड शामिल है, जो लिंक की गई सूची का एक तत्व है, जिसके माध्यम से यह मॉड्यूल कर्नेल मॉड्यूल की सामान्य सूची से जुड़ा हुआ है। उत्तरार्द्ध, बदले में, कर्नेल / मॉड्यूल। सी। फ़ाइल में घोषित एक आंतरिक गैर-निर्यात सूची है और संबंधित (निर्यात) mxx द्वारा संरक्षित है:

 103 DEFINE_MUTEX(module_mutex); 104 EXPORT_SYMBOL_GPL(module_mutex); 105 static LIST_HEAD(modules); 

मॉड्यूल लोड करते समय, कर्नेल मॉड्यूल को अपनी सूची में जोड़ता है। जब उतारना - बाहर करना। सामान्य तौर पर, इस तरह की आंतरिक सूची के कर्नेल द्वारा एक तरह से या किसी अन्य तरीके से लोड किए गए मॉड्यूल की गणना की आवश्यकता वाले सभी ऑपरेशन।

लोड किए गए मॉड्यूल की गणना

सिस्टम में लोड किए गए मॉड्यूल को सूचीबद्ध करने के लिए, यह THIS_MODULE मैक्रो का उपयोग करना सुविधाजनक है, जो वर्तमान मॉड्यूल के डिस्क्रिप्टर संरचना को संदर्भित करता है। पहले माना जाने वाला list क्षेत्र, कर्नेल के आंत्र में कहीं स्थित हेड डिस्क्रिप्टर के साथ मॉड्यूल की सामान्य सूची का एक तत्व होगा। तो, सिस्टम में लोड किए गए मॉड्यूल की सूची को सूचीबद्ध करने का कार्य निम्नानुसार है :

 static void list_modules(void) { struct module * mod; struct list_head * pos; while(!mutex_trylock(&module_mutex)) cpu_relax(); debug("List of available modules:\n"); list_for_each(pos, &THIS_MODULE->list) { bool head = (unsigned long)pos >= MODULES_VADDR; mod = container_of(pos, struct module, list); debug(" pos:%pK mod:%pK [%s]\n", pos, \ head ? mod : 0, head ? mod->name : "<- looking for"); } mutex_unlock(&module_mutex); } 

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

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

 [11025.656372] [findme] List of available modules: [11025.656377] [findme] pos:ffffffffa02a7388 mod:ffffffffa02a7380 [ipheth] [11025.656380] [findme] pos:ffffffffa02b9108 mod:ffffffffa02b9100 [pci_stub] [11025.656382] [findme] pos:ffffffffa01e7028 mod:ffffffffa01e7020 [vboxpci] [11025.656385] [findme] pos:ffffffffa01dd148 mod:ffffffffa01dd140 [vboxnetadp] [11025.656387] [findme] pos:ffffffffa01d4028 mod:ffffffffa01d4020 [vboxnetflt] ... [11025.656477] [findme] pos:ffffffffa00205c8 mod:ffffffffa00205c0 [3c59x] [11025.656480] [findme] pos:ffffffffa000c108 mod:ffffffffa000c100 [r8169] [11025.656483] [findme] pos:ffffffff81c2daf0 mod:0000000000000000 [<- looking for] 

अंतिम पंक्ति स्पष्ट रूप से इंगित करती है कि वांछित संरचना ffffffff81c2daf0 पर स्थित है, जिसे ffffffff81c2daf0 द्वारा सत्यापित किया जा सकता है:

 # grep -w modules /proc/kallsyms ffffffff81c2daf0 d modules 

इस प्रकार, किसी भी मॉड्यूल का उपयोग करके, आप आसानी से, सूची आइटम के माध्यम से छंटनी कर सकते हैं, मूल संरचना का पता लगा सकते हैं। इसकी विशिष्ट विशेषता मॉड्यूल ( ffffffff81xxxxxx बनाम ffffffffa0xxxxxx ) के लिए एक अपरिवर्तनीय पता होगी, जिसका उपयोग किया गया था:

 struct list_head * get_modules_head(void) { struct list_head * pos; while(!mutex_trylock(&module_mutex)) cpu_relax(); list_for_each(pos, &THIS_MODULE->list) { if ((unsigned long)pos < MODULES_VADDR) { break; } } mutex_unlock(&module_mutex); if (pos) { debug("Found \"modules\" head @ %pK\n", pos); } else { debug("Can't find \"modules\" head, aborting\n"); } return pos; } 

मॉड्यूल सूची हेरफेर

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

 static void hide_or_show(int new) { while(!mutex_trylock(&module_mutex)) cpu_relax(); if (new == 1) { /* 0 -> 1 : hide */ list_del(&THIS_MODULE->list); debug("Module \"%s\" unlinked\n", THIS_MODULE->name); } else { /* 1 -> 0 : show */ list_add(&THIS_MODULE->list, p_modules); debug("Module \"%s\" linked again\n", THIS_MODULE->name); } mutex_unlock(&module_mutex); } 

पहले मामले में, उनकी सूची को बाहर करने के लिए list_del का उपयोग किया जाता है। दूसरे में, list_add । संबंधित म्यूटेक्स पर कब्जा करके दोनों संचालन सुरक्षित हैं।

व्यावहारिक हिस्सा

तैयार उदाहरण में मॉड्यूल कोड होता है जो मास्किंग कार्यों को लागू करता है। जांच करने के लिए, आपको एक मॉड्यूल का निर्माण करना चाहिए और इसे make और insmod माध्यम से मानक उपकरणों के साथ लोड करना चाहिए

इसके अलावा, लोड करने के तुरंत बाद, मॉड्यूल lsmod या lsmod माध्यम से उपलब्ध होगा। निम्नलिखित कार्य मास्किंग कार्यों को सत्यापित करने के लिए क्रियाओं का एक क्रम है:

 # insmod findme.ko # lsmod | grep findme findme 12697 0 # sysctl -w findme=1 findme = 1 # lsmod | grep findme # rmmod findme libkmod: ERROR ../libkmod/libkmod-module.c:753 kmod_module_remove_module: could not remove 'findme': No such file or directory Error: could not remove module findme: No such file or directory # sysctl -w findme=0 findme = 0 # lsmod | grep findme findme 12697 0 # rmmod findme 

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

पढ़ने के लिए

1. प्रत्यक्ष कर्नेल वस्तु हेरफेर
2. लिनक्स कर्नेल लिंक्ड सूची की व्याख्या
3. लिनक्स कर्नेल डिजाइन पैटर्न - भाग 2