लिनक्स सुरक्षा मॉड्यूल लिखना

लिनक्स सुरक्षा मॉड्यूल (एलएसएम) एक ढांचा है जो लिनक्स में विभिन्न सुरक्षा मॉडल के लिए समर्थन जोड़ता है। लिनक्स वर्जन 2.6 के बाद से एलएसएम कर्नेल का हिस्सा रहा है। वर्तमान में, SELinux, AppArmor, Tomoyo, और स्मैक सुरक्षा मॉड्यूल आधिकारिक कोर में "निवास" करते हैं।

मॉड्यूल "देशी" लिनक्स सुरक्षा मॉडल के साथ समानांतर में काम करते हैं - विवेकाधीन अभिगम नियंत्रण (डीएसी)। LSM चेक को DAC द्वारा अधिकृत कार्यों के लिए कहा जाता है।

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

आइए आरेख पर एक नज़र डालें और यह पता लगाने की कोशिश करें कि एलएसएम हुक कैसे काम करता है (उदाहरण के रूप में ओपन सिस्टम कॉल का उपयोग करके)।



कुछ भी जटिल नहीं है। एलएसएम का मुख्य कार्य कर्नेल ऑब्जेक्ट्स तक पहुंच को नियंत्रित करने के लिए एक तंत्र के साथ सुरक्षा मॉड्यूल प्रदान करना है (हुक वस्तुओं को एक्सेस करने से ठीक पहले कर्नेल कोड में डाला जाता है)। इससे पहले कि कर्नेल आंतरिक ऑब्जेक्ट तक पहुंच जाए, एलएसएम द्वारा प्रदान किए गए सत्यापन फ़ंक्शन को लागू किया जाएगा।

दूसरे शब्दों में, LSM मॉड्यूल को प्रश्न का उत्तर देने की अनुमति देता है: "क्या OB कोर के आंतरिक ऑब्जेक्ट पर S एक OP क्रिया कर सकता है?"
यह बहुत अच्छा है। यह अधिकांश संकेत पर हुक करने के लिए sys_call_table नहीं है।

एक मसौदा सुरक्षा मॉड्यूल लिखकर शुरू करना उचित है। वह बहुत विनम्र होगा और हर चीज में डीएसी के साथ सहमत होगा। हमें जिन स्रोतों की आवश्यकता है वे कर्नेल स्रोतों के बीच सुरक्षा निर्देशिका में हैं।

स्रोत खोदो

हम / linux / security.h को शामिल करने के लिए जाते हैं (मेरे पास कर्नेल संस्करण 2.6.39.4 के लिए स्रोत कोड है)। यहाँ सबसे महत्वपूर्ण बात शक्तिशाली सुरक्षा_ संरचना है।
यहाँ इसका एक टुकड़ा है:

struct security_operations { char name[SECURITY_NAME_MAX + 1]; int (*ptrace_access_check) (struct task_struct *child, unsigned int mode); int (*ptrace_traceme) (struct task_struct *parent); int (*capget) (struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted); … }; 

यह पूर्वनिर्धारित और प्रलेखित कॉलबैक फ़ंक्शन की एक सूची है जो चेक करने के लिए सुरक्षा मॉड्यूल के लिए उपलब्ध हैं। डिफ़ॉल्ट रूप से, ये अधिकांश भाग 0 के लिए कार्य करते हैं, जिससे किसी भी कार्रवाई की अनुमति मिलती है। लेकिन कुछ POSIX सुरक्षा मॉड्यूल का उपयोग करते हैं। ये सामान्य क्षमता वाले कार्य हैं; इन्हें फ़ाइल सुरक्षा / commoncap.c में पाया जा सकता है।

इस मामले में, निम्नलिखित कार्य शामिल हैं / linux / security.c हमारे लिए महत्वपूर्ण है:

  /** * register_security –     . * @ops:    security_options,   * . * * This function allows a security module to register itself with the * kernel security subsystem. Some rudimentary checking is done on the @ops * value passed to this function. You'll need to check first if your LSM * is allowed to register its @ops by calling security_module_enable(@ops). * *       ,   .  *   0. */ int __init register_security(struct security_operations *ops) { if (verify(ops)) { printk(KERN_DEBUG "%s could not verify " "security_operations structure.\n", __func__); return -EINVAL; } if (security_ops != &default_security_ops) return -EAGAIN; security_ops = ops; return 0; } 

खाली लिखना

मेरे पास वितरण किट बैकट्रैक 5 आर 1 (कर्नेल संस्करण 2.6.39.4) है। उदाहरण के लिए, SELinux (निर्देशिका / सुरक्षा / selinux /) पर तैयार सुरक्षा मॉड्यूल पर एक नज़र डालें। इसका मुख्य तंत्र हुक फ़ाइल में वर्णित है। इस फ़ाइल के आधार पर, मैंने एक नया सुरक्षा मॉड्यूल का कंकाल बनाया (थोड़ी देर बाद हम इसमें से कुछ दिलचस्प बनाएंगे)।

हम अपने कार्यों के लिए संकेत के साथ राक्षसी सुरक्षा_ संरचना को भरते हैं। ऐसा करने के लिए, सभी कार्यों के लिए सेलिनक्स को उनके मॉड्यूल (मेरे उदाहरण में PtLSM) के नाम से बदलना पर्याप्त है। हम सभी कार्यों के निकायों को संपादित करते हैं: हम शून्य को खाली करते हैं, int को वापस लौटना चाहिए। परिणाम एक एलएसएम है जो कुछ भी नहीं करता है, देशी रक्षा तंत्र की अनुमति देता है। (मॉड्यूल का स्रोत कोड: pastebin.com/Cst0VVQh )।

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

PtLSM मॉड्यूल के नाम से एक निर्देशिका बनाएं: /usr/src/linux-2.6.39.4/security/ptlsm/।
मॉड्यूल का निर्माण करने के लिए, निम्न चरणों का पालन करें।

1. एक Makefile बनाएँ:

obj-m: = ptlsm.o

2. Kconfig फ़ाइल बनाएँ:

SECURITY_PTLSM को कॉन्फ़िगर करें
बूल "सकारात्मक संरक्षण"
डिफ़ॉल्ट एन
मदद
यह मॉड्यूल सकारात्मक तरह से कुछ भी नहीं करता है।

यदि आप अनिश्चित हैं कि इस प्रश्न का उत्तर कैसे दिया जाए, तो N का उत्तर दें।


3. हम एडिट / सिक्योरिटी / मेकफाइल और / सिक्योरिटी / कॉन्कफिग - ताकि पूरी दुनिया को नए मॉड्यूल के बारे में पता हो। अन्य मॉड्यूल की तरह - लाइनें जोड़ें।

जोड़ी गई PtLSM वाली मेरी फाइलें:
1) मेकफाइल - pastebin.com/k7amsnQK
2) कोन्कफिग - pastebin.com/YDsPBGAz

अगला, कर्नेल स्रोतों के साथ निर्देशिका में, मेनुकोनफिग बनाएं, "सुरक्षा विकल्प" आइटम में PtLSM का चयन करें।



अब बनाते हैं, मॉड्यूल_स्थापित करते हैं, स्थापित करते हैं। मॉड्यूल को कर्नेल में रखा गया है, और dmesg उपयोगिता का उपयोग करके आप देख सकते हैं कि यह लॉग को क्या लिखता है।

सुपर कूल मॉड्यूल लिखना

यह हमारे मॉड्यूल को सुपर कूल बनाने का समय है! यदि कंप्यूटर पर कोई डिवाइस निर्दिष्ट वेंडर आईडी और उत्पाद आईडी से जुड़ा नहीं है, तो मॉड्यूल को कुछ भी करने से मना करें (मेरे उदाहरण में, ये गैलेक्सी एस II फोन आईडी होगी)।



मैंने ptlsm_inode_create फ़ंक्शन के शरीर को बदल दिया, जो यह जांचता है कि क्या किसी प्रक्रिया में फ़ाइलों को बनाने की क्षमता है। यदि फ़ंक्शन को "उच्च प्राधिकरण का उपकरण" मिला है, तो वह निष्पादित करने की अनुमति देगा। इसी तरह की जाँच किसी भी अन्य कार्यों के साथ की जा सकती है।

 static int ptlsm_inode_create(struct inode *dir, struct dentry *dentry, int mask) { if (find_usb_device() != 0) { printk(KERN_ALERT "You shall not pass!\n"); return -EACCES; } else { printk(KERN_ALERT "Found supreme USB device\n"); } return 0; } 

अब find_usb_device फ़ंक्शन लिखना अच्छा होगा। वह सिस्टम में सभी यूएसबी उपकरणों का विश्लेषण करेगा और वांछित आईडी वाले व्यक्ति की तलाश करेगा। USB उपकरणों पर डेटा उन पेड़ों के रूप में संग्रहीत किया जाता है जिनकी जड़ें रूट हब डिवाइस कहलाती हैं। सभी जड़ों की एक सूची usb_bus_list बस सूची में निहित है।

 static int find_usb_device(void) { struct list_head* buslist; struct usb_bus* bus; int retval = -ENODEV; mutex_lock(&usb_bus_list_lock); for (buslist = usb_bus_list.next; buslist != &usb_bus_list; buslist = buslist->next) { bus = container_of(buslist, struct usb_bus, bus_list); retval = match_device(bus->root_hub); if (retval == 0) { break; } } mutex_unlock(&usb_bus_list_lock); return retval; } 

और अंत में, match_device फ़ंक्शन, जो वेंडर आईडी और उत्पाद आईडी की जांच करता है।

 static int match_device(struct usb_device* dev) { int retval = -ENODEV; int child; if ((dev->descriptor.idVendor == vendor_id) && (dev->descriptor.idProduct == product_id)) { return 0; } for (child = 0; child < dev->maxchild; ++child) { if (dev->children[child]) { retval = match_device(dev->children[child]); if (retval == 0) { return retval; } } } return retval; } 

यूएसबी के साथ काम करने के लिए, हेडर के एक जोड़े को कनेक्ट करें।

 #include <linux/usb.h> #include <linux/usb/hcd.h> 

हम मॉड्यूल को सम्मिलित करने के चरणों को दोहराते हैं - और कंप्यूटर का उपयोग करने के लिए एक शांत फोन खरीदते हैं।