👨🏻‍✈️ 🤦🏽 👨🏿‍🏭 HTTPS के लिए कर्नेल मॉड्यूल (नेटफिल्टर) या पारदर्शी प्रॉक्सी लिखना सीखना 🥘 🤦🏿 🤟🏼

यह लेख उन पाठकों के लिए लक्षित है जो शुरू कर रहे हैं या केवल लिनक्स कर्नेल मॉड्यूल और नेटवर्क अनुप्रयोगों को शुरू करना चाहते हैं। यह HTTPS ट्रैफ़िक के पारदर्शी समीपता से निपटने में भी मदद कर सकता है।

सामग्री की एक छोटी तालिका ताकि आप मूल्यांकन कर सकें कि क्या यह आगे पढ़ने लायक है:

प्रॉक्सी सर्वर कैसे काम करता है? समस्या का बयान।
क्लाइंट - नॉन-ब्लॉकिंग सॉकेट्स का उपयोग कर एक सर्वर एप्लिकेशन।
नेटफिल्टर लाइब्रेरी का उपयोग करके कर्नेल मॉड्यूल लिखना।
उपयोगकर्ता स्थान (नेटलिंक) से कर्नेल मॉड्यूल के साथ सहभागिता

PS उन लोगों के लिए जो बस HTTP और HTTPS के लिए एक पारदर्शी प्रॉक्सी सर्वर देखना चाहते हैं, बस HTTP के लिए एक पारदर्शी प्रॉक्सी सर्वर को कॉन्फ़िगर करें , उदाहरण के लिए, पारदर्शी पोर्ट 3128 के साथ स्क्विड, और शिफ्टर स्रोतों के साथ संग्रह डाउनलोड करें । संकलित करें (बनाएं) और, सफल संकलन के बाद, निष्पादित करें / रूट के रूप में आरंभ करें। यदि आवश्यक हो, तो आप संकलन से पहले shifter.h में सेटिंग्स समायोजित कर सकते हैं।

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

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

GET / HTTP/1.1 Host: www.google.ru …

जब हम ब्राउज़र सेटिंग्स में एक प्रॉक्सी सर्वर निर्दिष्ट करते हैं, तो ब्राउज़र प्रॉक्सी सर्वर से जुड़ना शुरू कर देता है और इसे पूर्ण पते के साथ एक अनुरोध भेजता है:

 GET http://www.google.ru/ HTTP/1.1 Host: www.google.ru …

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

 CONNECT mail.google.com:443 HTTP/1.1 Host: mail.google.com …

जिसके लिए प्रॉक्सी सर्वर को जवाब देना चाहिए कि कनेक्शन सफलतापूर्वक स्थापित किया गया है:

 HTTP/1.0 200 Connection established

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

बेशक, गलतियाँ हैं, उदाहरण के लिए, एक प्रॉक्सी, जो अपने पोर्ट 3128 पर एक पैकेट प्राप्त कर रहा है, इसे आगे Google में स्थानांतरित नहीं करता है, लेकिन Google के साथ एक नया संबंध बनाता है, लेकिन, सामान्य रूप से, इंटरैक्शन स्कीम लगभग निम्नलिखित है। इस आरेख से पता चलता है कि NAT प्रॉक्सी सर्वर को पैकेट भेजना शुरू कर देता है जो इसके लिए अभिप्राय नहीं है, और यह जानना आवश्यक है कि इन सभी को किसके पास भेजा जाए। HTTP ट्रैफ़िक के मामले में, कुछ प्रॉक्सी अवैध रूप से HTTP अनुरोध शीर्षक के HOST क्षेत्र से सूचना का उपयोग करने लगते हैं, जो विनिर्देश का उल्लंघन करता है। सबसे अधिक, ज़ाहिर है, HOST में होस्ट नाम बिल्कुल वही होता है जिसके लिए अनुरोध को संबोधित किया जाता है, लेकिन, सामान्य स्थिति में, HOST में कुछ भी हो सकता है। HTTPS के लिए, ऐसा समाधान बिल्कुल उपयुक्त नहीं है। यह पता लगाने के लिए कि पैकेट को किसके द्वारा संबोधित किया गया है, तुरंत एक समाधान निकलता है, जिसमें प्रॉक्सी सर्वर NAT पर नज़र रखेगा और देखेगा कि डेटा किसके लिए है और फिर कोई समस्या नहीं होगी। यह वास्तव में हम क्या करेंगे।
दुर्भाग्य से, iptables iptables में ही उपयोगी नहीं है, लेकिन सभी समान, इसके संचालन के मूल सिद्धांतों को अच्छी तरह से समझा जाएगा। योजनाबद्ध रूप से, यह निम्नानुसार दिखेगा:

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

क्लाइंट - सर्वर एप्लीकेशन (शिफ्टर)

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

कर्नेल मॉड्यूल शिफ्टर

यह पता लगाने के लिए कि कर्नेल मॉड्यूल क्या है, आप उदाहरण के लिए, लिनक्स में कर्नेल मॉड्यूल के साथ काम कर सकते हैं। आइए मॉड्यूल लिखना शुरू करें। सबसे पहले आपको मॉड्यूल इनिशियलाइज़ेशन करने की ज़रूरत है, जो एक बार तब आएगा, जब मॉड्यूल कर्नेल में लोड हो जाएगा। और आपको मॉड्यूल का सही शटडाउन भी करना चाहिए ताकि पिछली उपस्थिति के किसी भी अनावश्यक निशान को न छोड़ें जब मॉड्यूल कर्नेल से उतार दिया जाता है। इन उद्देश्यों के लिए, पुस्तकालय <linux / मॉड्यूल.h>: <linux / init.h> में दो मैक्रोज़ मॉड्यूल_इनिट और मॉड्यूल_एक्सिट हैं , जो एक पैरामीटर के रूप में इस उद्देश्य के लिए फ़ंक्शन नाम लेते हैं। आपके नाम को बनाए रखने के लिए मैक्रोज़ MODULE_AUTHOR , MODULE_DESCRIPTION , MODULE_LICENSE भी हैं :) लाइब्रेरी में एक बहुत ही उपयोगी आउटपुट फंक्शन int printk (const char * fmt, ...) भी है <linux \ kern.h>: <linux \ printk.h> । यह नियमित रूप से प्रिंटफ (..) से बहुत अलग नहीं है। चूंकि मॉड्यूल कर्नेल में स्थित है और कंसोल में लॉन्च नहीं किया गया है, इसलिए संदेश तदनुसार लॉग में प्रदर्शित किए जाते हैं (आप उन्हें देखने के लिए dmesg कमांड का उपयोग कर सकते हैं)। संदेश विभिन्न प्रकार के प्रदर्शित किए जा सकते हैं:

 #define KERN_EMERG "<0>" /* system is unusable */ #define KERN_ALERT "<1>" /* action must be taken immediately */ #define KERN_CRIT "<2>" /* critical conditions */ #define KERN_ERR "<3>" /* error conditions */ #define KERN_WARNING "<4>" /* warning conditions */ #define KERN_NOTICE "<5>" /* normal but significant condition */ #define KERN_INFO "<6>" /* informational */ #define KERN_DEBUG "<7>" /* debug-level messages */ #define KERN_DEFAULT "<d>" /* Use the default kernel loglevel */

अब हमारे पास हमारे पहले मॉड्यूल के कंकाल को लिखने के लिए सारी जानकारी है:

 #include <linux/module.h> #include <linux/kernel.h> MODULE_AUTHOR("Denis Dolgikh <sindo@sibmail.com>"); MODULE_DESCRIPTION("Module for the demonstration"); MODULE_LICENSE("GPL"); int Init(void) { printk(KERN_INFO "Init my module\n"); printk("Hello, World!\n"); return 0; } void Exit(void) { printk(KERN_INFO "Exit my module\n"); } module_init(Init); module_exit(Exit);

मैं आपको थोड़ा और बताऊंगा कि यह सब कैसे संकलित किया जाए और कैसे चलाया जाए। मैं तुरंत कहूंगा कि मैंने Ubuntu 11.10 (x86) कर्नेल 3.0 स्थापित किया है।
सिस्टम में एक निर्देशिका / lib / मॉड्यूल / [कर्नेल संस्करण] है / इसमें संबंधित कर्नेल संस्करण के लिए मॉड्यूल हैं। वहां एक बिल्ड भी है - यह कर्नेल लाइब्रेरीज़ (कर्नेल-हेडर्स) के हेडर्स के लिए एक प्रतीकात्मक लिंक है, जो / usr / src / linux-हेडर्स- [कर्नेल संस्करण] / डायरेक्टरी में स्थित हैं। यदि आपके पास पहले से कर्नेल-हेडर नहीं हैं, तो आपको उन्हें डाउनलोड करने की आवश्यकता है ( sudo apt-get install linux-headers- [कर्नेल संस्करण] )। आप जिस वर्तमान कर्नेल में काम कर रहे हैं उसके संस्करण का पता लगाने के लिए, आप uname –r कमांड चला सकते हैं। यदि आप वर्तमान कर्नेल के संस्करण से भिन्न संस्करण वाले पुस्तकालय का उपयोग करते हैं, तो ऐसा संकलित मॉड्यूल ठीक काम कर सकता है, या यह बिल्कुल भी शुरू नहीं हो सकता है। यह सब इस बात पर निर्भर करता है कि कर्नेल में क्या परिवर्तन हुए हैं, और आप मॉड्यूल में किन कार्यों का उपयोग करते हैं।
मॉड्यूल को संकलित करने के लिए, मेकफाइल लिखें। आइए दो लक्ष्य बनाएं: सभी (मॉड्यूल का निर्माण) और स्वच्छ (परियोजना की सफाई), उन्हें लिखने के लिए हम पहले से ही हमारे लिए लिखे गए लक्ष्यों का उपयोग करेंगे: कर्नेल-हेडर से मेकफाइल में मॉड्यूल और साफ ।

 #        # module_test.o – ,       module_test. obj-m += module_test.o #  Makefile  kernel-headers   -, #     /lib/modules/[ ]/build #     modules      obj-m # M=$(PWD)   ,      all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

अब हम आसानी से मेक कमांड का उपयोग करके मॉड्यूल को संकलित कर सकते हैं और मेक क्लीन प्रोजेक्ट को साफ कर सकते हैं । नतीजतन, हमें तैयार मॉड्यूल मॉड्यूल_टेस्ट.को मिलता है , जिसे तुरंत insmod/module_test.ko कमांड का उपयोग करके कर्नेल में लोड किया जा सकता है। मॉड्यूल को कर्नेल में लोड करने के लिए एक और विकल्प है - modprobe मॉड्यूल_test कमांड के साथ । ऐसा करने के लिए, मॉड्यूल मॉड्यूल_test.ko मॉड्यूल को / lib / मॉड्यूल / [कर्नेल के वर्तमान संस्करण] / [किसी भी निर्देशिका] / निर्देशिका में रखें और जैसे , प्रमोद चलाने के लिए याद रखें यह कमांड / निर्भरता / मॉड्यूल / में मॉड्यूल निर्भरता की एक सूची बनाता है। यहां तक कि अगर एक मॉड्यूल की कोई निर्भरता नहीं है, तो modprobe बिना मॉड्यूल के जोड़े गए मॉड्यूल को नहीं देखेगा । Insmod और modprobe के बीच मुख्य अंतर इस प्रकार हैं: मॉड्यूल लोड करते समय, modprobe स्वचालित रूप से उन सभी मॉड्यूल को लोड करता है जो इस पर निर्भर करता है, लेकिन insmod किसी भी निर्देशिका से किसी मॉड्यूल को लोड कर सकता है। कर्नेल से एक मॉड्यूल निकालें: rmmod मॉड्यूल_test । मॉड्यूल जानकारी देखें: modinfo mod_test या modinfo ./module_test.ko ।

नेटफिल्टर लाइब्रेरी

और इसलिए HTTPS के लिए प्रॉक्सी पर वापस जाएं। हमारा कार्य DNAT (iptables) द्वारा संसाधित किए जाने से पहले मॉड्यूल स्कैन नेटवर्क पैकेट बनाना है। इसके लिए नेटफिल्टर लाइब्रेरी हमारी मदद करेगी । (अधिक विस्तृत समझ के लिए, मैं अन्य स्रोतों में नेटफिल्टर के बारे में अतिरिक्त पढ़ने की सलाह देता हूं, कम से कम विकिपीडिया पर ) विचार करें कि कर्नेल में नेटवर्क पैकेट पथ कैसा दिखता है:

अधिक विवरण यहां पाया जा सकता है ।
नेटफिल्टर <linux / netfilter.h> 5 हुक फ़ंक्शन प्रदान करता है जो 5 अलग-अलग स्थानों में नेटवर्क पैकेट तक पहुंच प्रदान करता है:

NF_INET_PRE_ROUTING - फ़ंक्शन बिल्कुल सभी इनपुट पैकेट को पकड़ता है, इससे पहले कि पैकेट पहले ही सरल चेक पास कर चुके हैं (पैकेट खो नहीं गए हैं, आईपी चेकसम ठीक है, आदि);
पैकेट तब रूटिंग के माध्यम से जाता है, जो यह तय करता है कि पैकेट किसी अन्य इंटरफ़ेस या स्थानीय प्रक्रिया के लिए है या नहीं। रूटिंग एक पैकेट को छोड़ सकती है यदि यह नियमित नहीं है।
NF_INET_LOCAL_IN - अगर पैकेज स्थानीय प्रक्रिया के लिए अभिप्रेत है, तो पैकेज को पास करने से पहले;
NF_INET_FORWARD - जब एक पैकेट एक इंटरफेस से दूसरे में रूट किया जाता है;
NF_INET_LOCAL_OUT - स्थानीय प्रक्रियाओं को बनाने वाले पैकेजों के लिए जाल;
NF_INET_POST_ROUTING - नेटवर्क कार्ड ड्राइवर को पैकेट भेजने से पहले अंतिम बिंदु।

कर्नेल मॉड्यूल इन 5 स्थानों में से किसी में भी अपना कार्य पंजीकृत कर सकता है। पंजीकरण करते समय, मॉड्यूल को इस स्थान पर अपने कार्य की प्राथमिकता का संकेत देना चाहिए। <Linux / netfilter_ipv4.h> लाइब्रेरी में, आप विभिन्न मानक कार्यों के लिए प्राथमिकता पा सकते हैं:

 enum nf_ip_hook_priorities { NF_IP_PRI_FIRST = INT_MIN, NF_IP_PRI_CONNTRACK_DEFRAG = -400, NF_IP_PRI_RAW = -300, NF_IP_PRI_SELINUX_FIRST = -225, NF_IP_PRI_CONNTRACK = -200, NF_IP_PRI_MANGLE = -150, NF_IP_PRI_NAT_DST = -100, NF_IP_PRI_FILTER = 0, NF_IP_PRI_SECURITY = 50, NF_IP_PRI_NAT_SRC = 100, NF_IP_PRI_SELINUX_LAST = 225, NF_IP_PRI_CONNTRACK_CONFIRM = INT_MAX, NF_IP_PRI_LAST = INT_MAX, };

यह सूची से देखा जा सकता है कि DNAT में -100 की प्राथमिकता है, इसलिए कोई भी प्राथमिकता <-100 हमारे उद्देश्य के लिए उपयुक्त है। यदि फ़ंक्शन की प्राथमिकता> -100 है, तो यह गंतव्य आईपी के साथ पैकेट प्राप्त करेगा (गंतव्य) पहले से ही बदल गया है।
5 में से किसी भी बिंदु पर प्रत्येक पंजीकृत फ़ंक्शन को निम्न मानों में से एक को वापस करना होगा, जो इसे स्थानांतरित किए गए पैकेट के आगे के भाग्य को निर्धारित करता है:

 #define NF_DROP 0 /* discarded the packet */ #define NF_ACCEPT 1 /* the packet passes, continue iterations */ #define NF_STOLEN 2 /* gone away */ #define NF_QUEUE 3 /* inject the packet into a different queue (the target queue number is in the high 16 bits of the verdict) */ #define NF_REPEAT 4 /* iterate the same cycle once more */ #define NF_STOP 5 /* accept, but don't continue iterations */

मेरे नि: शुल्क अनुवाद में यह इस तरह लगेगा:

NF_DROP - इस पैकेज को निकालें
NF_ACCEPT - पैकेट आगे जाता है, पुनरावृत्तियाँ जारी रहती हैं
NF_STOLEN - इस पैकेज को ड्रॉप करें (कर्नेल अब इसे प्रोसेस नहीं करेगा, मॉड्यूल को इस पैकेज के लिए आवंटित मेमोरी को मुफ्त करना होगा)
NF_QUEUE - एक पैकेट कतार (आमतौर पर उपयोगकर्ता अंतरिक्ष में एक पैकेट प्रसंस्करण के लिए)
NF_REPEAT - पुनरावृत्ति दोहराएं (उसी पैकेज के साथ फ़ंक्शन को फिर से कॉल करें)
NF_STOP - पैकेट को आगे छोड़ें, लेकिन पुनरावृत्तियों को जारी न रखें

इस मामले में, पुनरावृत्ति एक पैकेज को फ़ंक्शन से फ़ंक्शन तक स्थानांतरित करने के लिए संदर्भित करता है, क्योंकि एक बिंदु पर, कई कार्यों को पंजीकृत किया जा सकता है, जो बदले में प्राथमिकता दी जा सकती है।

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

 #include <linux/module.h> #include <linux/kernel.h> #include <linux/netfilter.h> #include <linux/netfilter_ipv4.h> /*       ip  */ struct nf_hook_ops bundle; int Init(void) { printk(KERN_INFO "Start module Shifter\n"); /*     hook  */ /*   ,     */ bundle.hook = Hook_Func; /*    ,  hook */ bundle.owner = THIS_MODULE; /*    */ bundle.pf = PF_INET; /* ,       */ bundle.hooknum = NF_INET_PRE_ROUTING; /*       */ bundle.priority = NF_IP_PRI_FIRST; /*  */ nf_register_hook(&bundle); return 0; } void Exit(void) { /*    hook  */ nf_unregister_hook(&bundle); printk(KERN_INFO "End module Shifter\n"); } module_init(Init); module_exit(Exit);

अब हमारे लिए जो कुछ भी है वह हुक_फंच फ़ंक्शन को लिखना है । यह निम्नलिखित प्रोटोटाइप होना चाहिए:

 unsigned int Hook_Func(uint hooknum, struct sk_buff *skb, const struct net_device *in, const struct net_device *out, int (*okfn)(struct sk_buff *) ) { /*    firewall */ /*    ()     :) */ return NF_DROP; }

इसके मापदंडों पर विचार करें:

uint हुकुम में निम्न मान शामिल हैं: {NF_INET_PRE_ROUTING = 0, NF_INET_LOCAL_IN = 1, NF_INET_FORWARD = 2, NF_INET_LOCAL_OUT = 3, NF_INET_POST_ROUTING = 4} । इस पैरामीटर को यह पता लगाने की आवश्यकता है कि फ़ंक्शन कहाँ से बुलाया गया था, क्योंकि आप एक ही फ़ंक्शन को कई स्थानों पर पंजीकृत कर सकते हैं।
संरचना sk_buff * पैकेज संरचना के लिए skb सूचक।
इनपुट इंटरफ़ेस के बारे में जानकारी में const संरचना net_device * । यदि यह एक आउटगोइंग पैकेट है, तो पैरामीटर NULL है।
const संरचना net_device * आउटपुट इंटरफ़ेस के बारे में जानकारी। यदि यह एक आने वाला पैकेट है, तो पैरामीटर NULL है।
int (* okfn) (स्ट्रक्चर sk_buff *) एक कॉलबैक फ़ंक्शन है जिसे पैकेज के साथ कहा जाता है जब सभी पुनरावृत्तियां सकारात्मक उत्तर देती हैं।

अब पैकेज स्ट्रक्चर sk_buff * skb को पॉइंटर के बारे में और अधिक।

sk_buff पैकेज के साथ काम करने के लिए एक बफर है। जैसे ही कोई पैकेट आता है या उसे भेजने की आवश्यकता होती है, sk_buff बनाया जाता है, जहाँ पैकेट रखा जाता है, साथ ही संबंधित जानकारी, कहाँ, कहाँ, किस लिए ... पैकेट की यात्रा के दौरान, sk_buff को नेटवर्क स्टैक में उपयोग किया जाता है। जैसे ही एक पैकेट भेजा जाता है, या डेटा को उपयोगकर्ता को स्थानांतरित कर दिया जाता है, संरचना नष्ट हो जाती है, जिससे मेमोरी खाली हो जाती है।

Sk_buff संरचना का वर्णन <linux / skbuff.h> में किया गया है , इसके साथ एक सुखद कार्य के लिए विभिन्न कार्यों का भी वर्णन किया गया है।
Tcp के साथ काम करते समय, आप दो और संरचनाओं का उपयोग कर सकते हैं - ये संरचनात्मक iphdr और संरचना tcphdr हैं ।
जैसा कि नाम से ही स्पष्ट है, ये संरचनाएँ आईपी हेडर के साथ काम करने के लिए डिज़ाइन की गई हैं और तदनुसार, टीसीपी हेडर के साथ । आप skb_buff से इन संरचनाओं को इंगित करने के लिए दो कार्यों का उपयोग कर सकते हैं:

 static inline unsigned char *skb_network_header(const struct sk_buff *skb); static inline unsigned char *skb_transport_header(const struct sk_buff *skb);

इस बिंदु पर, मैं पाठक से अपील करना चाहूंगा। यह मेरे लिए बिल्कुल स्पष्ट नहीं था कि sk_buff संरचना में किसने transport_header सूचक को सेट किया, क्योंकि NF_INET_PRE_ROUTING और NF_INET_LOCAL_IN (किसी भी प्राथमिकता के साथ) बिंदुओं पर मैं tbp हैडर पर skb_transport_header का उपयोग करके संरचना प्राप्त करने में सक्षम नहीं था, हालांकि अन्य बिंदुओं पर इसने ठीक काम किया। मुझे मैन्युअल रूप से sk_buff-> डेटा पॉइंटर से transport_header के लिए ऑफ़सेट निर्दिष्ट करना था, void skb_set_transport_header (skb, ऑफ़सेट) का उपयोग करके।
उल्लिखित sk_buff-> डेटा पॉइंटर पैकेज की सामग्री के लिए एक संकेतक है, अर्थात। ईथरनेट प्रोटोकॉल के बाद मेमोरी क्षेत्र को इंगित करता है, उदाहरण के लिए, तुरंत आईपी हेडर संरचना के लिए, और इसके बाद टीसीपी हेडर संरचना या अपने स्वयं के प्रोटोकॉल का पालन कर सकते हैं।
चूंकि पैकेज में डेटा को इंगित करने के लिए खुद को हर जगह उपयोग किया जाता है, आप न केवल विभिन्न क्षेत्रों को पढ़ सकते हैं, बल्कि उन्हें बदल भी सकते हैं। हालांकि, यह याद रखना चाहिए कि बदलते समय, उदाहरण के लिए, प्रेषक या प्राप्तकर्ता का आईपी पता, आईपी पैकेट हेडर में चेकसम भी पुनर्गणना होना चाहिए।
और इसलिए, हमारा फ़ंक्शन केवल गंतव्य आईपी पते को बचाएगा जब यह एक आईपी-टीसीपी पैकेट को 443 (HTTPS) पोर्ट और SYN ध्वज से युक्त देखता है, जो कहता है कि ग्राहक HTTPS प्रोटोकॉल के लिए एक टीसीपी कनेक्शन स्थापित करना चाहता है। फ़ाइनल या RST फ़्लैग वाले पैकेटों को तब हटाएं जब कहा जाए कि tcp कनेक्शन टूट गया है और हमें अब इस IP पते की आवश्यकता नहीं है।

 #include <linux/skbuff.h> #include <linux/ip.h> #include <linux/tcp.h> #define uchar unsigned char #define ushort unsigned short #define uint unsigned int /* Hook_Func - ,       */ /*  IP  ,  : */ /* -  tcp  */ /* -   443  (HTTPS) */ /* -   SYN ( tcp ) */ uint Hook_Func(uint hooknum, struct sk_buff *skb, const struct net_device *in, const struct net_device *out, int (*okfn)(struct sk_buff *) ) { /*      ip   */ struct iphdr *ip; /*      tcp   */ struct tcphdr *tcp; /*    IP  */ if (skb->protocol == htons(ETH_P_IP)) { /*      IP */ ip = (struct iphdr *)skb_network_header(skb); /*    IP  4   TCP  */ if (ip->version == 4 && ip->protocol == IPPROTO_TCP) { /*        TCP  */ /* ip->ihl -  IP   32-  */ skb_set_transport_header(skb, ip->ihl * 4); /*      TCP */ tcp = (struct tcphdr *)skb_transport_header(skb); /*     443  (HTTPS) */ if (tcp->dest == htons(443)) { /*    SYN,   IP   */ if (tcp->syn) AddTable((uint)ip->saddr, (ushort)tcp->source, (uint)ip->daddr); /*    FIN  RST,    IP   */ if (tcp->fin || tcp->rst) DelTable((uint)ip->saddr, (ushort)tcp->source, (uint)ip->daddr); } } } /*     */ return NF_ACCEPT; }

AddTable और DelTable के दो कार्य हैं, जो प्राप्तकर्ता के आईपी पते को प्रत्येक आईपी और प्रेषक के पोर्ट के लिए मेमोरी से सहेजना और हटाना चाहिए। यह आवश्यक है ताकि शिफ्टर क्लाइंट सर्वर शिफ्टर मॉड्यूल के साथ संवाद कर सके और आईपी और क्लाइंट के पोर्ट का पता लगाने के लिए रीडटेबल फ़ंक्शन का उपयोग कर सके , जिस आईपी एड्रेस से वह वास्तव में संपर्क करना चाहता था। मैंने आईपी को बचाने के लिए डेटा प्रकार के बारे में ज्यादा नहीं सोचा और प्राथमिक हैश फ़ंक्शन का उपयोग करके सामान्य स्थिर सरणी का उपयोग किया। हैश फ़ंक्शन ( KeyHash ) इनपुट पर प्रेषक पोर्ट और इनपुट प्राप्त करता है और उस सरणी के सूचकांक को वापस करता है जहां गंतव्य आईपी पता संग्रहीत होता है। यह ध्यान में रखते हुए लिखा गया है कि क्लाइंट नैट के पीछे है और इसमें 255.255.255.0 के मास्क के साथ एक सबनेट है, इसलिए मैं प्रेषक के आईपी के केवल अंतिम बाइट का उपयोग करता हूं, और यह बाइट दो पोर्ट बाइट्स के साथ 3 बिट्स के साथ सुपरिंपल है। नतीजतन, मैं सरणी को 0x1FFFFF (~ 8 एमबी) आकार में संपीड़ित करने में कामयाब रहा। बेशक, आपको यह विचार करने की आवश्यकता है कि अब, कर्नेल में लोड होने के बाद, यह मॉड्यूल कम से कम 8 एमबी मेमोरी पर कब्जा कर लेगा, और यह कुछ एम्बेडेड सिस्टम के लिए बहुत अधिक हो सकता है। और टक्कर के बारे में मत भूलना :) लेकिन मेरे डेमो के लिए, यह सब सरलता के साथ भुगतान करता है और, इसके अलावा, डेलटेबल आम तौर पर खाली होता है।

 /*     IP   */ #define MaxTable 0x1FFFFF uint Table[MaxTable]; /* KeyHash -     */ /*    IP    */ uint KeyHash(uint src_IP, ushort src_Port) { return (uint)(((src_IP & 0xFF000000) >> 11) ^ (uint)src_Port) % MaxTable; } /* AddTable -  IP     */ /*     IP    */ void AddTable(uint src_IP, ushort src_Port, uint dst_IP) { Table[KeyHash(src_IP, src_Port)] = dst_IP; } void DelTable(uint src_IP, ushort src_Port, uint dst_IP) { /*         IP  */ /*      */ } /* ReadTable -  IP   */ /*    IP    */ uint ReadTable(uint src_IP, ushort src_Port) { return Table[KeyHash(src_IP, src_Port)]; }

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

उपयोगकर्ता स्थान (नेटलिंक) से कर्नेल मॉड्यूल के साथ सहभागिता

अब हमारा लक्ष्य शिफ्टर और शिफ्टर मॉड्यूल में एक सॉकेट बनाना और उन्हें एक साथ जोड़ना है। मॉड्यूल और शिफ्टर सर्वर के बीच विनिमय प्रोटोकॉल सरल होगा। शिफ्टर क्लाइंट आईपी के 4 बाइट्स और क्लाइंट पोर्ट के 2 बाइट्स भेजेगा, और मॉड्यूल अपने टेबल से लिए गए आईपी गंतव्य के 4 बाइट्स के साथ जवाब देगा। ऐसा करने के लिए, नेटलिंक लाइब्रेरी का उपयोग करें।
मैं टिप्पणी करना चाहते हैं कि शीर्ष लेख <linux / netlink.h> कस्टम अनुप्रयोगों के लिए /usr/include/linux/netlink.h और कर्नेल मॉड्यूल / usr / src / लिनक्स headers- [ कर्नेल संस्करण] / शामिल / linux / नेटलिंक। h के कई अंतर हैं ।

यूजर स्पेस में नेटलिंक

नेटलिंक के लिए, नेटवर्क के उपयोगकर्ता स्थान पक्ष पर बहुत सारी जानकारी है, उदाहरण के लिए:
RFC 3549 - लिनक्स नेटलिंक आईपी सेवाओं के लिए एक प्रोटोकॉल के रूप में लिनक्स पर नेटलिंक के
साथ काम करना। भाग 1
नेटलिंक का उपयोग करके लिनक्स नेटवर्क इंटरफेस का एक सरल मॉनिटर
इसलिए, यहां मैं केवल चर्चा करूंगा कि हमें कर्नेल मॉड्यूल और उपयोगकर्ता अंतरिक्ष कार्यक्रमों के बीच सूचना के आदान-प्रदान को सुनिश्चित करने की आवश्यकता है।
नेटलिंक सॉकेट सामान्य फ़ंक्शन द्वारा बनाया गया है: इंट सॉकेट (PF_NETLINK, सॉकेट_टाइप, नेटलिंक_फैमिली);
कहाँ के रूप में socket_type के रूप में इस्तेमाल किया जा सकता SOCK_RAW , और SOCK_DGRAM ; इसके बावजूद, नेटलिंक प्रोटोकॉल डेटाग्राम और कच्चे सॉकेट के बीच अंतर नहीं करता है। और netlink_family संचार के लिए कर्नेल मॉड्यूल या नेटलिंक समूह का चयन करता है। <Linux / netlink.h> , आप कर सकते हैं परिवारों की पूरी सूची देखने के ।
नेटलिंक संदेश एक या एक से अधिक msmsghdr (नेटलिंक संदेश हेडर) हेडर के साथ बाइट्स की एक धारा है । बाइट स्ट्रीम तक पहुँचने के लिए, केवल NLMSG_ * मैक्रोज़ का उपयोग करें । मैं यह भी नोट करना चाहता हूं कि नेटलिंक प्रोटोकॉल गारंटीकृत संदेश डिलीवरी प्रदान नहीं करता है। यदि पर्याप्त मेमोरी या अन्य त्रुटियां नहीं हैं, तो प्रोटोकॉल पैकेट को गिरा सकता है। संरचना
पर विचार करें sockaddr_nl, nlmsghdr (<linux / netlink.h>), iovec और msghdr (<sys / socket.h>) , जिसके साथ हम काम करेंगे -

संरचनात्मक sockaddr_nl - उपयोगकर्ता कार्यक्रमों और कर्नेल मॉड्यूल के लिए netlink पते का वर्णन करता है। संरचना का उपयोग डेटा के प्रेषक या रिसीवर का वर्णन करने के लिए किया जाता है।

 struct sockaddr_nl { sa_family_t nl_family; /*   AF_NETLINK */ unsigned short nl_pad; /*   */ __u32 nl_pid; /*     0,    ,     */ __u32 nl_groups; /* netlink  32 multicast-. nl_groups    ,         ,      */ };

संरचना nlmsghdr नेटलिंक संदेश हैडर है और भेजा / प्राप्त डेटा संरचना के तुरंत बाद मेमोरी में स्थित है, इसे एक्सेस करने के लिए NLMSG_DATA (स्ट्रक्चर nlmsghdr *) मैक्रो का उपयोग करें ।

 struct nlmsghdr { __u32 nlmsg_len; /*      */ __u16 nlmsg_type; /*   () */ __u16 nlmsg_flags; /*     */ __u32 nlmsg_seq; /*   (      ) */ __u32 nlmsg_pid; /*   (PID),   */ };

iovec एक struct - में है msghdr , यह एक संरचना करने के लिए एक सूचक शामिल होंगे nlmsghdr ।

 struct iovec { void * iov_base; /*    (  nlmsghdr) */ size_t iov_len; /*  ()  */ };

संरचना msghdr - एक पता ( sockaddr_nl ) और डेटा ( iovec ) के लिए एक सूचक होता है

 struct msghdr { void * msg_name; /*     */ socklen_t msg_namelen; /*   */ struct iovec * msg_iov; /*    */ size_t msg_iovlen; /*   */ void * msg_control; /*      */ size_t msg_controllen; /*     */ int msg_flags; /*    */ };

कुछ नेटलिंक मैक्रोज़ पर विचार करें:

 int NLMSG_ALIGN(size_t len);

निकटतम बड़े बॉर्डर-संरेखित मान के लिए राउंड्स नेटलिंक संदेश आकार।

 int NLMSG_LENGTH(size_t len);

डेटा फ़ील्ड के आकार को एक पैरामीटर के रूप में लेता है और nlmsgdr हेडर के nlmsg_len क्षेत्र के लिए लिखने के लिए एक सीमा-संरेखित आकार मान देता है।

 int NLMSG_SPACE(size_t len);

मेमोरी का आकार (बाइट्स में) लौटाता है, जो कि शम्सगड्र्र संरचना पर कब्जा कर लेगा, साथ ही नेटलिंक पैकेट में निर्दिष्ट लेन लंबाई (बाइट्स में) का डेटा।

 void *NLMSG_DATA(struct nlmsghdr *nlh);

पास किए गए nlmsghdr हेडर से जुड़े डेटा के लिए एक पॉइंटर लौटाता है।

 struct nlmsghdr *NLMSG_NEXT(struct nlmsghdr *nlh, int len);

एक संदेश के अगले भाग को कई भागों से मिलकर लौटाता है। मैक्रो एक बहु-भाग संदेश में निम्नलिखित nlmsghdr हेडर को स्वीकार करता है। कॉल करने वाले एप्लिकेशन को वर्तमान एम्‍म्‍समैगड्रर हेडर में NLMSG_DONE फ्लैग की जाँच करनी चाहिए - जब संदेश संसाधित होता है तो फ़ंक्शन NULL नहीं लौटता है। दूसरा पैरामीटर संदेश बफ़र के शेष भाग का आकार सेट करता है। मैसेज हेडर के आकार द्वारा मैक्रो इस मान को कम कर देता है।

 int NLMSG_OK(struct nlmsghdr *nlh, int len);

TRUE लौटाता है (1) यदि संदेश को छोटा नहीं किया गया है और उसका डिस्सेक्शन सफल रहा है।

 int NLMSG_PAYLOAD(struct nlmsghdr *nlh, int len);

Nlmsghdr हैडर से जुड़े डेटा का आकार लौटाता है।

नेटलिंक के साथ शिफ्टर सर्वर के लिए स्रोत कोड का हिस्सा।

नेटलिंक कर्नेल स्पेस

कर्नेल मॉड्यूल में नेटलिंक लाइब्रेरी का उपयोग करते समय, कुछ अंतर हैं, उदाहरण के लिए, <linux / netlink.h> से nlmsghdr संरचना समान है, लेकिन यह पहले से ही sk_buff संरचना में लिपटा हुआ है जो हमसे परिचित है । और सॉकेट्स के साथ काम करने के सामान्य कार्यों के बजाय, हम कार्यों के एक नए सेट का उपयोग करेंगे। आइए उनमें से कुछ पर विचार करें।
मॉड्यूल सॉकेट टाइप लगता नहीं पूर्णांक , और संरचना जुर्राब से <शुद्ध / sock.h> । संरचना जुर्राब - बहुत बड़ी मैं इसका वर्णन नहीं करूंगा, इसके अलावा इसके विवरण की आवश्यकता नहीं होगी।
नेटलिंक सॉकेट बनाने के लिए, <linux / netlink.h> में netlink_kernel_create फ़ंक्शन है । यह न केवल एक नेटलिंक सॉकेट बनाता है, बल्कि एक फ़ंक्शन को भी पंजीकृत करता है जिसे डेटा आने पर बुलाया जाएगा।

 struct sock *netlink_kernel_create( struct net *net, int unit, unsigned int groups, void (*input)(struct sk_buff *skb), struct mutex *cb_mutex, struct module *module);

नेटलिंक सॉकेट को बंद करने के लिए और "फ़ंक्शन पंजीकरण" उपयोग को हटा दें:

 void netlink_kernel_release(struct sock *sk);

हमें <net / netlink.h> से भी फ़ंक्शंस की आवश्यकता होगी , जहां आप एक अद्भुत विवरण के साथ फ़ंक्शंस पा सकते हैं।
मैं बस कुछ आवश्यक कार्यों का अनुवाद करूंगा:

 /** * nlmsg_new –     netlink  * @payload:    * @flags:     * *  NLMSG_DEFAULT_SIZE,      */ static inline struct sk_buff *nlmsg_new(size_t payload, gfp_t flags) { return alloc_skb(nlmsg_total_size(payload), flags); } /** * nlmsg_put -    NetLink  skb  * @skb:     netlink  * @pid:   * @seq:    * @type:   * @payload:    ( ) * @flags:   * *  NULL,   skb    , *        netlink , *    netlink  */ static inline struct nlmsghdr *nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq, int type, int payload, int flags) /** * nlmsg_unicast –   netlink  * @sk: netlink  * @skb:    netlink  * @pid: netlink    */ static inline int nlmsg_unicast(struct sock *sk, struct sk_buff *skb, u32 pid) /** * nlmsg_data –      * @nlh:  netlink  */ static inline void *nlmsg_data(const struct nlmsghdr *nlh) { return (unsigned char *) nlh + NLMSG_HDRLEN; }

यह मॉड्यूल Shifter जोड़ने के लिए बनी हुई है।

निष्कर्ष

अंत में, मैं कहूंगा कि एक प्रॉक्सी सर्वर पर पैकेट को पुनर्निर्देशित करने के लिए, गेटवे पर iptables के लिए एक नियम जोड़ना पर्याप्त है:

 #   nat   (-A)   PREROUTING #   tcp    443    443  iptables -t nat -A PREROUTING -p tcp --dport 443 -j REDIRECT --to-port 443

शिफ्टर स्रोतों के साथ संग्रह डाउनलोड करें

अंत।

प्रयुक्त और उपयोगी साहित्य

NetFilter.org
लिनक्स, कर्नेल, फ़ायरवॉल
कर्नेल कोर्नर - नेटलिंक सॉकेट
आरएफसी 3549 का उपयोग क्यों और कैसे करें - लिनक्स नेटलिंक लिनक्स पर नेटलिंक के साथ आईपी सेवाओं के काम के लिए एक प्रोटोकॉल के रूप में
। भाग 1
लिनक्स नेटलिंक प्रोटोकॉल

HTTPS के लिए कर्नेल मॉड्यूल (नेटफिल्टर) या पारदर्शी प्रॉक्सी लिखना सीखना