🥇छोटों के लिए बीपीएफ, भाग शून्य: क्लासिक बीपीएफ

बर्कले पैकेट फिल्टर (बीपीएफ) एक लिनक्स कर्नेल तकनीक है जो कई वर्षों से अंग्रेजी भाषा के तकनीकी प्रकाशनों के पहले पन्ने पर है। सम्मेलन बीपीएफ के उपयोग और विकास पर रिपोर्टों से भरे रहते हैं। लिनक्स नेटवर्क सबसिस्टम मेंटेनर डेविड मिलर ने लिनक्स प्लंबर 2018 में अपनी बात कही "यह बातचीत XDP के बारे में नहीं है" (एक्सडीपी बीपीएफ के लिए एक उपयोग का मामला है)। ब्रेंडन ग्रेग हकदार वार्ता देते हैं लिनक्स बीपीएफ सुपरपावर. टोके होइलैंड-जोर्गेनसेन हंसते हुएकि कर्नेल अब एक माइक्रोकर्नेल है। थॉमस ग्राफ इस विचार को बढ़ावा देते हैं बीपीएफ कर्नेल के लिए जावास्क्रिप्ट है.

हैबे पर अभी भी बीपीएफ का कोई व्यवस्थित विवरण नहीं है, और इसलिए लेखों की एक श्रृंखला में मैं प्रौद्योगिकी के इतिहास के बारे में बात करने, वास्तुकला और विकास उपकरणों का वर्णन करने और बीपीएफ का उपयोग करने के अनुप्रयोग और अभ्यास के क्षेत्रों की रूपरेखा तैयार करने का प्रयास करूंगा। श्रृंखला का यह लेख, शून्य, क्लासिक बीपीएफ के इतिहास और वास्तुकला को बताता है, और इसके संचालन सिद्धांतों के रहस्यों को भी उजागर करता है। tcpdump, seccomp, strace, और भी बहुत कुछ।

बीपीएफ का विकास लिनक्स नेटवर्किंग समुदाय द्वारा नियंत्रित किया जाता है, बीपीएफ के मुख्य मौजूदा अनुप्रयोग नेटवर्क से संबंधित हैं और इसलिए, अनुमति के साथ @यूकेरियोट, मैंने महान श्रृंखला के सम्मान में श्रृंखला का नाम "छोटे बच्चों के लिए बीपीएफ" रखा "छोटों के लिए नेटवर्क".

बीपीएफ के इतिहास में एक संक्षिप्त पाठ्यक्रम(c)

आधुनिक बीपीएफ तकनीक इसी नाम से पुरानी तकनीक का एक उन्नत और विस्तारित संस्करण है, जिसे अब भ्रम से बचने के लिए क्लासिक बीपीएफ कहा जाता है। क्लासिक बीपीएफ के आधार पर एक प्रसिद्ध उपयोगिता बनाई गई थी tcpdump, तंत्र seccomp, साथ ही कम ज्ञात मॉड्यूल भी xt_bpf के लिए iptables और वर्गीकरणकर्ता cls_bpf. आधुनिक लिनक्स में, क्लासिक बीपीएफ प्रोग्राम स्वचालित रूप से नए रूप में अनुवादित होते हैं, हालांकि, उपयोगकर्ता के दृष्टिकोण से, एपीआई यथावत बनी हुई है और क्लासिक बीपीएफ के लिए नए उपयोग, जैसा कि हम इस लेख में देखेंगे, अभी भी पाए जा रहे हैं। इस कारण से, और इसलिए भी कि लिनक्स में शास्त्रीय बीपीएफ के विकास के इतिहास के बाद, यह स्पष्ट हो जाएगा कि यह अपने आधुनिक रूप में कैसे और क्यों विकसित हुआ, मैंने शास्त्रीय बीपीएफ के बारे में एक लेख के साथ शुरुआत करने का फैसला किया।

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

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

बीपीएफ मशीन वास्तुकला

हम उदाहरणों का विश्लेषण करते हुए कामकाजी तरीके से वास्तुकला से परिचित होंगे। हालाँकि, आरंभ करने के लिए, मान लें कि मशीन में उपयोगकर्ता के लिए दो 32-बिट रजिस्टर, एक संचायक उपलब्ध थे A और सूचकांक रजिस्टर X, 64 बाइट्स मेमोरी (16 शब्द), लिखने और बाद में पढ़ने के लिए उपलब्ध, और इन वस्तुओं के साथ काम करने के लिए कमांड की एक छोटी प्रणाली। सशर्त अभिव्यक्तियों को लागू करने के लिए जंप निर्देश भी कार्यक्रमों में उपलब्ध थे, लेकिन कार्यक्रम के समय पर पूरा होने की गारंटी के लिए, जंप केवल आगे की ओर किया जा सकता था, यानी, विशेष रूप से, लूप बनाने से मना किया गया था।

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

उपरोक्त हमारे लिए उदाहरणों को देखना शुरू करने के लिए पर्याप्त होगा: हम आवश्यकतानुसार सिस्टम और कमांड प्रारूप से परिचित होंगे। यदि आप किसी वर्चुअल मशीन के कमांड सिस्टम का तुरंत अध्ययन करना चाहते हैं और उसकी सभी क्षमताओं के बारे में जानना चाहते हैं, तो आप मूल लेख पढ़ सकते हैं बीएसडी पैकेट फ़िल्टर और/या फ़ाइल का पहला भाग दस्तावेज़ीकरण/नेटवर्किंग/फ़िल्टर.txt कर्नेल दस्तावेज़ से. इसके अलावा, आप प्रेजेंटेशन का अध्ययन कर सकते हैं libpcap: पैकेट कैप्चर के लिए एक वास्तुकला और अनुकूलन पद्धति, जिसमें बीपीएफ के लेखकों में से एक, मैककैन, सृजन के इतिहास के बारे में बात करते हैं libpcap.

अब हम Linux पर क्लासिक BPF का उपयोग करने के सभी महत्वपूर्ण उदाहरणों पर विचार करने के लिए आगे बढ़ते हैं: tcpdump (libpcap), सेकम्प, xt_bpf, cls_bpf.

टीसीपीडम्प

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

(मैंने इस आलेख के सभी उदाहरण लिनक्स पर चलाए 5.6.0-rc6. बेहतर पठनीयता के लिए कुछ कमांड के आउटपुट को संपादित किया गया है।)

उदाहरण: IPv6 पैकेट का अवलोकन करना

आइए कल्पना करें कि हम एक इंटरफ़ेस पर सभी IPv6 पैकेट देखना चाहते हैं eth0. ऐसा करने के लिए हम प्रोग्राम चला सकते हैं tcpdump एक साधारण फिल्टर के साथ ip6:

$ sudo tcpdump -i eth0 ip6

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

इससे पता चलता है कि हम आसानी से पता लगा सकते हैं कि कर्नेल को कौन सा बाइटकोड भेजा गया था tcpdump की मदद से tcpdump, यदि हम इसे विकल्प के साथ चलाते हैं -d:

$ sudo tcpdump -i eth0 -d ip6
(000) ldh      [12]
(001) jeq      #0x86dd          jt 2    jf 3
(002) ret      #262144
(003) ret      #0

लाइन जीरो पर हम कमांड चलाते हैं ldh [12], जिसका अर्थ है "रजिस्टर में लोड करें"। A आधा शब्द (16 बिट्स) पता 12” पर स्थित है और एकमात्र सवाल यह है कि हम किस प्रकार की मेमोरी को संबोधित कर रहे हैं? इसका उत्तर यह है कि x शुरू होता है (x+1)विश्लेषित नेटवर्क पैकेट का वां बाइट। हम ईथरनेट इंटरफ़ेस से पैकेट पढ़ते हैं eth0और यह साधनपैकेट इस तरह दिखता है (सरलता के लिए, हम मानते हैं कि पैकेट में कोई वीएलएएन टैग नहीं हैं):

       6              6          2
|Destination MAC|Source MAC|Ether Type|...|

तो आदेश निष्पादित करने के बाद ldh [12] रजिस्टर में A वहाँ एक मैदान होगा Ether Type - इस ईथरनेट फ्रेम में प्रसारित पैकेट का प्रकार। पंक्ति 1 पर हम रजिस्टर की सामग्री की तुलना करते हैं A (पैकेज प्रकार) सी 0x86ddऔर यह और वहाँ है जिस प्रकार में हम रुचि रखते हैं वह IPv6 है। लाइन 1 पर, तुलना कमांड के अलावा, दो और कॉलम हैं - jt 2 и jf 3 - तुलना सफल होने पर आपको जिन अंकों पर जाने की आवश्यकता है (A == 0x86dd) और असफल. तो, एक सफल मामले (आईपीवी 6) में हम लाइन 2 पर जाते हैं, और एक असफल मामले में - लाइन 3 पर। लाइन 3 पर प्रोग्राम कोड 0 के साथ समाप्त होता है (पैकेट की प्रतिलिपि न बनाएं), लाइन 2 पर प्रोग्राम कोड के साथ समाप्त होता है 262144 (अधिकतम 256 किलोबाइट पैकेज मुझे कॉपी करें)।

एक अधिक जटिल उदाहरण: हम गंतव्य पोर्ट द्वारा टीसीपी पैकेट को देखते हैं

आइए देखें कि एक फ़िल्टर कैसा दिखता है जो गंतव्य पोर्ट 666 के साथ सभी टीसीपी पैकेटों को कॉपी करता है। हम आईपीवी4 मामले पर विचार करेंगे, क्योंकि आईपीवी6 मामला सरल है। इस उदाहरण का अध्ययन करने के बाद, आप एक अभ्यास के रूप में स्वयं IPv6 फ़िल्टर का पता लगा सकते हैं (ip6 and tcp dst port 666) और सामान्य मामले के लिए एक फ़िल्टर (tcp dst port 666). तो, जिस फ़िल्टर में हम रुचि रखते हैं वह इस तरह दिखता है:

$ sudo tcpdump -i eth0 -d ip and tcp dst port 666
(000) ldh      [12]
(001) jeq      #0x800           jt 2    jf 10
(002) ldb      [23]
(003) jeq      #0x6             jt 4    jf 10
(004) ldh      [20]
(005) jset     #0x1fff          jt 10   jf 6
(006) ldxb     4*([14]&0xf)
(007) ldh      [x + 16]
(008) jeq      #0x29a           jt 9    jf 10
(009) ret      #262144
(010) ret      #0

हम पहले से ही जानते हैं कि पंक्तियाँ 0 और 1 क्या करती हैं। लाइन 2 पर हमने पहले ही जांच कर ली है कि यह एक आईपीवी4 पैकेट है (ईथर प्रकार = 0x800) और इसे रजिस्टर में लोड करें A पैकेट की 24वीं बाइट. हमारा पैकेज जैसा दिखता है

       14            8      1     1
|ethernet header|ip fields|ttl|protocol|...|

जिसका अर्थ है कि हम रजिस्टर में लोड करते हैं A आईपी हेडर का प्रोटोकॉल फ़ील्ड, जो तर्कसंगत है, क्योंकि हम केवल टीसीपी पैकेट कॉपी करना चाहते हैं। हम प्रोटोकॉल की तुलना करते हैं 0x6 (IPPROTO_TCP) लाइन 3 पर।

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

इस सूची में पंक्ति 6 सबसे दिलचस्प है। अभिव्यक्ति ldxb 4*([14]&0xf) इसका मतलब है कि हम रजिस्टर में लोड करते हैं X पैकेट के पंद्रहवें बाइट के सबसे कम महत्वपूर्ण चार बिट्स को 4 से गुणा किया जाता है। पंद्रहवें बाइट के सबसे कम महत्वपूर्ण चार बिट्स फ़ील्ड है इंटरनेट हेडर की लंबाई IPv4 हेडर, जो हेडर की लंबाई को शब्दों में संग्रहीत करता है, इसलिए आपको फिर 4 से गुणा करना होगा। दिलचस्प बात यह है कि अभिव्यक्ति 4*([14]&0xf) एक विशेष संबोधन योजना के लिए एक पदनाम है जिसका उपयोग केवल इस रूप में और केवल एक रजिस्टर के लिए किया जा सकता है X, अर्थात। हम भी नहीं कह सकते ldb 4*([14]&0xf) न ही ldxb 5*([14]&0xf) (हम केवल एक अलग ऑफसेट निर्दिष्ट कर सकते हैं, उदाहरण के लिए, ldxb 4*([16]&0xf)). यह स्पष्ट है कि यह संबोधन योजना बीपीएफ में प्राप्त करने के लिए ही जोड़ी गई थी X (सूचकांक रजिस्टर) आईपीवी4 हेडर लंबाई।

तो पंक्ति 7 पर हम आधा शब्द लोड करने का प्रयास करते हैं (X+16). याद रखें कि ईथरनेट हेडर 14 बाइट्स पर कब्जा कर लेता है, और X इसमें IPv4 हेडर की लंबाई शामिल है, हम इसे समझते हैं A टीसीपी गंतव्य पोर्ट लोड किया गया है:

       14           X           2             2
|ethernet header|ip header|source port|destination port|

अंत में, लाइन 8 पर हम गंतव्य पोर्ट की तुलना वांछित मान से करते हैं और लाइन 9 या 10 पर हम परिणाम लौटाते हैं - पैकेट की प्रतिलिपि बनाना है या नहीं।

टीसीपीडम्प: लोड हो रहा है

पिछले उदाहरणों में, हमने विशेष रूप से इस बात पर विस्तार से ध्यान नहीं दिया कि हम पैकेट फ़िल्टरिंग के लिए बीपीएफ बाइटकोड को कर्नेल में कैसे लोड करते हैं। आम तौर पर बोलना, tcpdump कई प्रणालियों में पोर्ट किया गया और फ़िल्टर के साथ काम करने के लिए tcpdump लाइब्रेरी का उपयोग करता है libpcap. संक्षेप में, एक इंटरफ़ेस का उपयोग करके फ़िल्टर लगाने के लिए libpcap, आपको निम्नलिखित कार्य करने होंगे:

एक टाइप डिस्क्रिप्टर बनाएं pcap_t इंटरफ़ेस नाम से: pcap_create,
इंटरफ़ेस सक्रिय करें: pcap_activate,
संकलित फ़िल्टर: pcap_compile,
फ़िल्टर कनेक्ट करें: pcap_setfilter.

यह देखने के लिए कि कार्य कैसा है pcap_setfilter लिनक्स में लागू, हम उपयोग करते हैं strace (कुछ पंक्तियाँ हटा दी गई हैं):

$ sudo strace -f -e trace=%network tcpdump -p -i eth0 ip
socket(AF_PACKET, SOCK_RAW, 768)        = 3
bind(3, {sa_family=AF_PACKET, sll_protocol=htons(ETH_P_ALL), sll_ifindex=if_nametoindex("eth0"), sll_hatype=ARPHRD_NETROM, sll_pkttype=PACKET_HOST, sll_halen=0}, 20) = 0
setsockopt(3, SOL_SOCKET, SO_ATTACH_FILTER, {len=4, filter=0xb00bb00bb00b}, 16) = 0
...

आउटपुट की पहली दो पंक्तियों पर हम बनाते हैं कच्चा सॉकेट सभी ईथरनेट फ़्रेमों को पढ़ने और इसे इंटरफ़ेस से बांधने के लिए eth0। से हमारा पहला उदाहरण हम जानते हैं कि फ़िल्टर ip इसमें चार बीपीएफ निर्देश शामिल होंगे, और तीसरी पंक्ति में हम देखेंगे कि विकल्प का उपयोग कैसे किया जाता है SO_ATTACH_FILTER सिस्टम कॉल setsockopt हम लंबाई 4 का फ़िल्टर लोड करते हैं और कनेक्ट करते हैं। यह हमारा फ़िल्टर है।

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

छिपा सत्य

आउटपुट का थोड़ा और पूर्ण संस्करण इस तरह दिखता है:

$ sudo strace -f -e trace=%network tcpdump -p -i eth0 ip
socket(AF_PACKET, SOCK_RAW, 768)        = 3
bind(3, {sa_family=AF_PACKET, sll_protocol=htons(ETH_P_ALL), sll_ifindex=if_nametoindex("eth0"), sll_hatype=ARPHRD_NETROM, sll_pkttype=PACKET_HOST, sll_halen=0}, 20) = 0
setsockopt(3, SOL_SOCKET, SO_ATTACH_FILTER, {len=1, filter=0xbeefbeefbeef}, 16) = 0
recvfrom(3, 0x7ffcad394257, 1, MSG_TRUNC, NULL, NULL) = -1 EAGAIN (Resource temporarily unavailable)
setsockopt(3, SOL_SOCKET, SO_ATTACH_FILTER, {len=4, filter=0xb00bb00bb00b}, 16) = 0
...

जैसा कि ऊपर उल्लेख किया गया है, हम अपने फ़िल्टर को लाइन 5 पर सॉकेट में लोड और कनेक्ट करते हैं, लेकिन लाइन 3 और 4 पर क्या होता है? यह पता चला है कि यह libpcap हमारा ख्याल रखता है - ताकि हमारे फ़िल्टर के आउटपुट में ऐसे पैकेट शामिल न हों जो इसे संतुष्ट नहीं करते हैं, लाइब्रेरी जोड़ता है डमी फ़िल्टर ret #0 (सभी पैकेट ड्रॉप करें), सॉकेट को नॉन-ब्लॉकिंग मोड पर स्विच करता है और उन सभी पैकेटों को घटाने का प्रयास करता है जो पिछले फ़िल्टर से रह सकते हैं।

कुल मिलाकर, क्लासिक बीपीएफ का उपयोग करके लिनक्स पर पैकेजों को फ़िल्टर करने के लिए, आपके पास संरचना के रूप में एक फ़िल्टर होना चाहिए struct sock_fprog और एक खुला सॉकेट, जिसके बाद फ़िल्टर को सिस्टम कॉल का उपयोग करके सॉकेट से जोड़ा जा सकता है setsockopt.

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

उपयोग के बारे में अधिक जानकारी setsockopt फ़िल्टर कनेक्ट करने के लिए, देखें सॉकेट(7), लेकिन जैसे अपने स्वयं के फ़िल्टर लिखने के बारे में struct sock_fprog बिना मदद के tcpdump हम अनुभाग में बात करेंगे अपने हाथों से बीपीएफ प्रोग्रामिंग.

क्लासिक बीपीएफ और XNUMXवीं सदी

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

JIT कंपाइलर परिवर्तनों की श्रृंखला में पहला था: 2012 में दिखाई दिया के लिए फ़िल्टर लिखने की क्षमता सेकंड, बीपीएफ का उपयोग करते हुए, जनवरी 2013 में वहाँ था जोड़ा मॉड्यूल xt_bpf, जो आपको नियम लिखने की अनुमति देता है iptables बीपीएफ की मदद से, और अक्टूबर 2013 में था जोड़ा एक मॉड्यूल भी cls_bpf, जो आपको BPF का उपयोग करके ट्रैफ़िक क्लासिफायर लिखने की अनुमति देता है।

हम जल्द ही इन सभी उदाहरणों को और अधिक विस्तार से देखेंगे, लेकिन पहले हमारे लिए यह सीखना उपयोगी होगा कि बीपीएफ के लिए मनमाने प्रोग्राम कैसे लिखें और संकलित करें, क्योंकि लाइब्रेरी द्वारा प्रदान की जाने वाली क्षमताएं libpcap सीमित (सरल उदाहरण: फ़िल्टर उत्पन्न हुआ libpcap केवल दो मान लौटा सकते हैं - 0 या 0x40000) या आम तौर पर, जैसा कि seccomp के मामले में होता है, लागू नहीं होते हैं।

अपने हाथों से बीपीएफ प्रोग्रामिंग

आइए बीपीएफ निर्देशों के बाइनरी प्रारूप से परिचित हों, यह बहुत सरल है:

   16    8    8     32
| code | jt | jf |  k  |

प्रत्येक निर्देश में 64 बिट्स होते हैं, जिसमें पहले 16 बिट्स निर्देश कोड होते हैं, फिर दो आठ-बिट इंडेंट होते हैं, jt и jf, और तर्क के लिए 32 बिट्स K, जिसका उद्देश्य अलग-अलग कमांड में अलग-अलग होता है। उदाहरण के लिए, आदेश ret, जो प्रोग्राम को समाप्त करता है उसके पास कोड है 6, और रिटर्न मान स्थिरांक से लिया जाता है K. सी में, एक एकल बीपीएफ निर्देश को एक संरचना के रूप में दर्शाया जाता है

struct sock_filter {
        __u16   code;
        __u8    jt;
        __u8    jf;
        __u32   k;
}

और पूरा प्रोग्राम एक संरचना के रूप में है

struct sock_fprog {
        unsigned short len;
        struct sock_filter *filter;
}

इस प्रकार, हम पहले से ही प्रोग्राम लिख सकते हैं (उदाहरण के लिए, हम निर्देश कोड जानते हैं [1]). फ़िल्टर इस प्रकार दिखेगा ip6 से हमारा पहला उदाहरण:

struct sock_filter code[] = {
        { 0x28, 0, 0, 0x0000000c },
        { 0x15, 0, 1, 0x000086dd },
        { 0x06, 0, 0, 0x00040000 },
        { 0x06, 0, 0, 0x00000000 },
};
struct sock_fprog prog = {
        .len = ARRAY_SIZE(code),
        .filter = code,
};

कार्यक्रम prog हम कानूनी तौर पर कॉल में उपयोग कर सकते हैं

setsockopt(sk, SOL_SOCKET, SO_ATTACH_FILTER, &prog, sizeof(prog))

मशीन कोड के रूप में प्रोग्राम लिखना बहुत सुविधाजनक नहीं है, लेकिन कभी-कभी यह आवश्यक होता है (उदाहरण के लिए, डिबगिंग के लिए, यूनिट परीक्षण बनाना, हैबे पर लेख लिखना आदि)। सुविधा के लिए, फ़ाइल में <linux/filter.h> सहायक मैक्रोज़ को परिभाषित किया गया है - ऊपर दिए गए समान उदाहरण को फिर से लिखा जा सकता है

struct sock_filter code[] = {
        BPF_STMT(BPF_LD|BPF_H|BPF_ABS, 12),
        BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, ETH_P_IPV6, 0, 1),
        BPF_STMT(BPF_RET|BPF_K, 0x00040000),
        BPF_STMT(BPF_RET|BPF_K, 0),
}

हालाँकि, यह विकल्प बहुत सुविधाजनक नहीं है। लिनक्स कर्नेल प्रोग्रामर्स ने यही तर्क दिया है, और इसलिए निर्देशिका में tools/bpf कर्नेल में आप क्लासिक बीपीएफ के साथ काम करने के लिए एक असेंबलर और डिबगर पा सकते हैं।

असेंबली भाषा डिबग आउटपुट के समान ही है tcpdump, लेकिन इसके अतिरिक्त हम प्रतीकात्मक लेबल निर्दिष्ट कर सकते हैं। उदाहरण के लिए, यहां एक प्रोग्राम है जो TCP/IPv4 को छोड़कर सभी पैकेट ड्रॉप कर देता है:

$ cat /tmp/tcp-over-ipv4.bpf
ldh [12]
jne #0x800, drop
ldb [23]
jneq #6, drop
ret #-1
drop: ret #0

डिफ़ॉल्ट रूप से, असेंबलर प्रारूप में कोड उत्पन्न करता है <количество инструкций>,<code1> <jt1> <jf1> <k1>,..., टीसीपी के साथ हमारे उदाहरण के लिए यह होगा

$ tools/bpf/bpf_asm /tmp/tcp-over-ipv4.bpf
6,40 0 0 12,21 0 3 2048,48 0 0 23,21 0 1 6,6 0 0 4294967295,6 0 0 0,

C प्रोग्रामर की सुविधा के लिए, एक अलग आउटपुट प्रारूप का उपयोग किया जा सकता है:

$ tools/bpf/bpf_asm -c /tmp/tcp-over-ipv4.bpf
{ 0x28,  0,  0, 0x0000000c },
{ 0x15,  0,  3, 0x00000800 },
{ 0x30,  0,  0, 0x00000017 },
{ 0x15,  0,  1, 0x00000006 },
{ 0x06,  0,  0, 0xffffffff },
{ 0x06,  0,  0, 0000000000 },

इस पाठ को प्रकार संरचना परिभाषा में कॉपी किया जा सकता है struct sock_filter, जैसा कि हमने इस खंड की शुरुआत में किया था।

लिनक्स और नेटस्निफ-एनजी एक्सटेंशन

मानक बीपीएफ के अलावा, लिनक्स और tools/bpf/bpf_asm समर्थन और गैर मानक सेट. मूल रूप से, निर्देशों का उपयोग किसी संरचना के क्षेत्रों तक पहुंचने के लिए किया जाता है struct sk_buff, जो कर्नेल में एक नेटवर्क पैकेट का वर्णन करता है। हालाँकि, उदाहरण के लिए, अन्य प्रकार के सहायक निर्देश भी हैं ldw cpu रजिस्टर में लोड होगा A कर्नेल फ़ंक्शन चलाने का परिणाम raw_smp_processor_id(). (बीपीएफ के नए संस्करण में, इन गैर-मानक एक्सटेंशन को मेमोरी, संरचनाओं तक पहुंचने और घटनाओं को उत्पन्न करने के लिए कर्नेल हेल्पर्स के एक सेट के साथ प्रोग्राम प्रदान करने के लिए बढ़ाया गया है।) यहां एक फिल्टर का एक दिलचस्प उदाहरण है जिसमें हम केवल कॉपी करते हैं एक्सटेंशन का उपयोग करके उपयोगकर्ता स्थान में पैकेट हेडर poff, पेलोड ऑफसेट:

ld poff
ret a

BPF एक्सटेंशन का उपयोग नहीं किया जा सकता tcpdump, लेकिन उपयोगिता पैकेज से परिचित होने का यह एक अच्छा कारण है netsniff-ng, जिसमें अन्य बातों के अलावा, एक उन्नत कार्यक्रम शामिल है netsniff-ng, जिसमें बीपीएफ का उपयोग करके फ़िल्टर करने के अलावा, एक प्रभावी ट्रैफ़िक जनरेटर भी शामिल है, और इससे भी अधिक उन्नत है tools/bpf/bpf_asm, एक बीपीएफ असेंबलर को बुलाया गया bpfc. पैकेज में काफी विस्तृत दस्तावेज़ शामिल हैं, लेख के अंत में लिंक भी देखें।

सेकंड

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

seccomp का पहला संस्करण 2005 में कर्नेल में जोड़ा गया था और यह बहुत लोकप्रिय नहीं था, क्योंकि यह केवल एक ही विकल्प प्रदान करता था - एक प्रक्रिया के लिए उपलब्ध सिस्टम कॉल के सेट को निम्नलिखित तक सीमित करना: read, write, exit и sigreturn, और नियमों का उल्लंघन करने वाली प्रक्रिया का उपयोग करके उसे मार दिया गया SIGKILL. हालाँकि, 2012 में, seccomp ने BPF फ़िल्टर का उपयोग करने की क्षमता जोड़ी, जिससे आप अनुमत सिस्टम कॉल के एक सेट को परिभाषित कर सकते हैं और यहां तक कि उनके तर्कों की जांच भी कर सकते हैं। (दिलचस्प बात यह है कि क्रोम इस कार्यक्षमता के पहले उपयोगकर्ताओं में से एक था, और क्रोम लोग वर्तमान में बीपीएफ के एक नए संस्करण के आधार पर एक केआरएसआई तंत्र विकसित कर रहे हैं और लिनक्स सुरक्षा मॉड्यूल के अनुकूलन की अनुमति दे रहे हैं।) अतिरिक्त दस्तावेज़ के लिंक अंत में पाए जा सकते हैं लेख का.

ध्यान दें कि हब पर seccomp का उपयोग करने के बारे में पहले से ही लेख मौजूद हैं, हो सकता है कि कोई व्यक्ति निम्नलिखित उपखंडों को पढ़ने से पहले (या इसके बजाय) उन्हें पढ़ना चाहेगा। लेख में कंटेनर और सुरक्षा: seccomp 2007 संस्करण और BPF (फ़िल्टर libseccomp का उपयोग करके उत्पन्न होते हैं) का उपयोग करने वाले संस्करण दोनों में seccomp का उपयोग करने के उदाहरण प्रदान करता है, Docker के साथ seccomp के कनेक्शन के बारे में बात करता है, और कई उपयोगी लिंक भी प्रदान करता है। लेख में सिस्टमडी के साथ डेमॉन को अलग करना या "इसके लिए आपको डॉकर की आवश्यकता नहीं है!" इसमें, विशेष रूप से, सिस्टमडी चलाने वाले डेमॉन के लिए सिस्टम कॉल की ब्लैकलिस्ट या व्हाइटलिस्ट को कैसे जोड़ा जाए, शामिल है।

आगे हम देखेंगे कि फ़िल्टर कैसे लिखें और लोड करें seccomp नंगे C में और लाइब्रेरी का उपयोग कर रहा हूँ libseccomp और प्रत्येक विकल्प के फायदे और नुकसान क्या हैं, और अंत में, आइए देखें कि प्रोग्राम द्वारा seccomp का उपयोग कैसे किया जाता है strace.

Seccomp के लिए फ़िल्टर लिखना और लोड करना

हम पहले से ही जानते हैं कि BPF प्रोग्राम कैसे लिखें, तो आइए सबसे पहले seccomp प्रोग्रामिंग इंटरफ़ेस को देखें। आप प्रक्रिया स्तर पर एक फ़िल्टर सेट कर सकते हैं, और सभी चाइल्ड प्रक्रियाओं को प्रतिबंध प्राप्त होंगे। यह एक सिस्टम कॉल का उपयोग करके किया जाता है seccomp(2):

seccomp(SECCOMP_SET_MODE_FILTER, flags, &filter)

जहां &filter - यह उस संरचना का सूचक है जिससे हम पहले से ही परिचित हैं struct sock_fprog, अर्थात। बीपीएफ कार्यक्रम.

seccomp के प्रोग्राम सॉकेट के प्रोग्राम से किस प्रकार भिन्न हैं? प्रेषित प्रसंग. सॉकेट के मामले में, हमें पैकेट वाला एक मेमोरी क्षेत्र दिया गया था, और seccomp के मामले में हमें एक संरचना दी गई थी

struct seccomp_data {
    int   nr;
    __u32 arch;
    __u64 instruction_pointer;
    __u64 args[6];
};

यहां nr लॉन्च किए जाने वाले सिस्टम कॉल का नंबर है, arch - वर्तमान वास्तुकला (नीचे इस पर अधिक जानकारी), args - छह सिस्टम कॉल तर्क तक, और instruction_pointer उपयोगकर्ता स्थान निर्देश के लिए एक सूचक है जिसने सिस्टम कॉल किया। इस प्रकार, उदाहरण के लिए, सिस्टम कॉल नंबर को रजिस्टर में लोड करने के लिए A हमें कहना होगा

ldw [0]

seccomp प्रोग्राम के लिए अन्य विशेषताएं हैं, उदाहरण के लिए, संदर्भ को केवल 32-बिट संरेखण द्वारा एक्सेस किया जा सकता है और आप फ़िल्टर लोड करने का प्रयास करते समय आधा शब्द या बाइट लोड नहीं कर सकते हैं ldh [0] सिस्टम कॉल seccomp लौट आएगा EINVAL. फ़ंक्शन लोड किए गए फ़िल्टर की जांच करता है seccomp_check_filter() गुठली. (मजेदार बात यह है कि, मूल कमिट में जिसने seccomp कार्यक्षमता जोड़ी थी, वे इस फ़ंक्शन में निर्देश का उपयोग करने की अनुमति जोड़ना भूल गए mod (विभाजन शेष) और इसके जुड़ने के बाद से यह अब seccomp BPF कार्यक्रमों के लिए अनुपलब्ध है टूट जाएगा एबीआई.)

मूलतः, हम पहले से ही seccomp प्रोग्राम लिखने और पढ़ने के बारे में सब कुछ जानते हैं। आमतौर पर प्रोग्राम लॉजिक को सिस्टम कॉल की एक सफेद या काली सूची के रूप में व्यवस्थित किया जाता है, उदाहरण के लिए प्रोग्राम

ld [0]
jeq #304, bad
jeq #176, bad
jeq #239, bad
jeq #279, bad
good: ret #0x7fff0000 /* SECCOMP_RET_ALLOW */
bad: ret #0

304, 176, 239, 279 क्रमांकित चार सिस्टम कॉलों की ब्लैकलिस्ट की जाँच करता है। ये सिस्टम कॉल क्या हैं? हम निश्चित रूप से नहीं कह सकते, क्योंकि हम नहीं जानते कि प्रोग्राम किस आर्किटेक्चर के लिए लिखा गया था। इसलिए, seccomp के लेखक प्रस्ताव सभी प्रोग्रामों को आर्किटेक्चर जांच के साथ शुरू करें (वर्तमान आर्किटेक्चर को संदर्भ में एक फ़ील्ड के रूप में दर्शाया गया है arch संरचना struct seccomp_data). आर्किटेक्चर की जाँच के साथ, उदाहरण की शुरुआत इस तरह दिखेगी:

ld [4]
jne #0xc000003e, bad_arch ; SCMP_ARCH_X86_64

और फिर हमारे सिस्टम कॉल नंबरों को कुछ मान प्राप्त होंगे।

हम seccomp के उपयोग के लिए फ़िल्टर लिखते और लोड करते हैं `libseccomp`

मूल कोड या बीपीएफ असेंबली में फ़िल्टर लिखने से आप परिणाम पर पूर्ण नियंत्रण रख सकते हैं, लेकिन साथ ही, कभी-कभी पोर्टेबल और/या पढ़ने योग्य कोड रखना बेहतर होता है। पुस्तकालय इसमें हमारी सहायता करेगा libseccomp, जो काले या सफेद फ़िल्टर लिखने के लिए एक मानक इंटरफ़ेस प्रदान करता है।

आइए, उदाहरण के लिए, एक प्रोग्राम लिखें जो उपयोगकर्ता की पसंद की बाइनरी फ़ाइल चलाता है, जिसमें पहले से सिस्टम कॉल की ब्लैकलिस्ट स्थापित की गई है उपरोक्त लेख (कार्यक्रम को अधिक पठनीयता के लिए सरल बनाया गया है, पूर्ण संस्करण पाया जा सकता है यहां):

#include <seccomp.h>
#include <unistd.h>
#include <err.h>

static int sys_numbers[] = {
        __NR_mount,
        __NR_umount2,
       // ... еще 40 системных вызовов ...
        __NR_vmsplice,
        __NR_perf_event_open,
};

int main(int argc, char **argv)
{
        scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_ALLOW);

        for (size_t i = 0; i < sizeof(sys_numbers)/sizeof(sys_numbers[0]); i++)
                seccomp_rule_add(ctx, SCMP_ACT_TRAP, sys_numbers[i], 0);

        seccomp_load(ctx);

        execvp(argv[1], &argv[1]);
        err(1, "execlp: %s", argv[1]);
}

सबसे पहले हम एक ऐरे को परिभाषित करते हैं sys_numbers ब्लॉक करने के लिए 40 से अधिक सिस्टम कॉल नंबर। फिर, संदर्भ आरंभ करें ctx और लाइब्रेरी को बताएं कि हम क्या अनुमति देना चाहते हैं (SCMP_ACT_ALLOW) सभी सिस्टम कॉल डिफ़ॉल्ट रूप से (ब्लैकलिस्ट बनाना आसान है)। फिर, एक-एक करके, हम सभी सिस्टम कॉल को ब्लैकलिस्ट से जोड़ते हैं। सूची से एक सिस्टम कॉल के जवाब में, हम अनुरोध करते हैं SCMP_ACT_TRAP, इस मामले में seccomp प्रक्रिया को एक संकेत भेजेगा SIGSYS इस विवरण के साथ कि किस सिस्टम कॉल ने नियमों का उल्लंघन किया। अंत में, हम प्रोग्राम को कर्नेल में लोड करते हैं seccomp_load, जो प्रोग्राम को संकलित करेगा और सिस्टम कॉल का उपयोग करके इसे प्रक्रिया में संलग्न करेगा seccomp(2).

सफल संकलन के लिए प्रोग्राम को पुस्तकालय से जोड़ा जाना चाहिए libseccomp, उदाहरण के लिए:

cc -std=c17 -Wall -Wextra -c -o seccomp_lib.o seccomp_lib.c
cc -o seccomp_lib seccomp_lib.o -lseccomp

सफल प्रक्षेपण का उदाहरण:

$ ./seccomp_lib echo ok
ok

अवरुद्ध सिस्टम कॉल का उदाहरण:

$ sudo ./seccomp_lib mount -t bpf bpf /tmp
Bad system call

हम उपयोग करते हैं straceजानकारी के लिए:

$ sudo strace -e seccomp ./seccomp_lib mount -t bpf bpf /tmp
seccomp(SECCOMP_SET_MODE_FILTER, 0, {len=50, filter=0x55d8e78428e0}) = 0
--- SIGSYS {si_signo=SIGSYS, si_code=SYS_SECCOMP, si_call_addr=0xboobdeadbeef, si_syscall=__NR_mount, si_arch=AUDIT_ARCH_X86_64} ---
+++ killed by SIGSYS (core dumped) +++
Bad system call

हम कैसे जान सकते हैं कि प्रोग्राम अवैध सिस्टम कॉल के उपयोग के कारण समाप्त कर दिया गया था mount(2).

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

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

$ echo 1 3 6 8 13 | ./generate_bin_search_bpf.py
ld [0]
jeq #6, bad
jgt #6, check8
jeq #1, bad
jeq #3, bad
ret #0x7fff0000
check8:
jeq #8, bad
jeq #13, bad
ret #0x7fff0000
bad: ret #0

आप कुछ भी अधिक तेजी से नहीं लिख पाएंगे, क्योंकि बीपीएफ प्रोग्राम इंडेंटेशन जंप नहीं कर सकते हैं (उदाहरण के लिए, हम ऐसा नहीं कर सकते हैं, jmp A या jmp [label+X]) और इसलिए सभी संक्रमण स्थिर हैं।

सेकॉम्प और स्ट्रेस

उपयोगिता तो सभी जानते हैं strace लिनक्स पर प्रक्रियाओं के व्यवहार का अध्ययन करने के लिए एक अनिवार्य उपकरण है। हालाँकि, कईयों के बारे में सुना भी है निष्पादन मुद्दे इस उपयोगिता का उपयोग करते समय. तथ्य यह है कि strace का उपयोग करके कार्यान्वित किया गया ptrace(2), और इस तंत्र में हम यह निर्दिष्ट नहीं कर सकते कि प्रक्रिया को रोकने के लिए हमें सिस्टम कॉल के किस सेट की आवश्यकता है, यानी, उदाहरण के लिए, कमांड

$ time strace du /usr/share/ >/dev/null 2>&1

real    0m3.081s
user    0m0.531s
sys     0m2.073s

$ time strace -e open du /usr/share/ >/dev/null 2>&1

real    0m2.404s
user    0m0.193s
sys     0m1.800s

लगभग एक ही समय में संसाधित होते हैं, हालाँकि दूसरे मामले में हम केवल एक सिस्टम कॉल का पता लगाना चाहते हैं।

नया विकल्प --seccomp-bpfमें जोड़ा गया strace संस्करण 5.3, आपको प्रक्रिया को कई गुना तेज करने की अनुमति देता है और एक सिस्टम कॉल के ट्रेस के तहत स्टार्टअप समय पहले से ही एक नियमित स्टार्टअप के समय के बराबर है:

$ time strace --seccomp-bpf -e open du /usr/share/ >/dev/null 2>&1

real    0m0.148s
user    0m0.017s
sys     0m0.131s

$ time du /usr/share/ >/dev/null 2>&1

real    0m0.140s
user    0m0.024s
sys     0m0.116s

(यहाँ, निश्चित रूप से, इसमें थोड़ा सा धोखा है कि हम इस कमांड के मुख्य सिस्टम कॉल को ट्रेस नहीं कर रहे हैं। यदि हम ट्रेस कर रहे थे, उदाहरण के लिए, newfsstat, तो strace बिना ज़ोर से ब्रेक लगाएगा --seccomp-bpf.)

यह विकल्प कैसे काम करता है? उसके बिना strace प्रक्रिया से जुड़ता है और इसका उपयोग शुरू करता है PTRACE_SYSCALL. जब कोई प्रबंधित प्रक्रिया (कोई भी) सिस्टम कॉल जारी करती है, तो नियंत्रण स्थानांतरित हो जाता है strace, जो सिस्टम कॉल के तर्कों को देखता है और उसके साथ चलता है PTRACE_SYSCALL. कुछ समय के बाद, प्रक्रिया सिस्टम कॉल को पूरा करती है और इससे बाहर निकलने पर, नियंत्रण फिर से स्थानांतरित हो जाता है strace, जो रिटर्न वैल्यू को देखता है और प्रक्रिया का उपयोग शुरू करता है PTRACE_SYSCALL, और इसी तरह।

हालाँकि, seccomp के साथ, इस प्रक्रिया को ठीक वैसे ही अनुकूलित किया जा सकता है जैसा हम चाहेंगे। अर्थात्, यदि हम केवल सिस्टम कॉल को देखना चाहते हैं X, तो हम उसके लिए एक BPF फ़िल्टर लिख सकते हैं X एक मान लौटाता है SECCOMP_RET_TRACE, और उन कॉलों के लिए जिनमें हमारी रुचि नहीं है - SECCOMP_RET_ALLOW:

ld [0]
jneq #X, ignore
trace: ret #0x7ff00000
ignore: ret #0x7fff0000

इस मामले में strace प्रारंभ में प्रक्रिया प्रारंभ होती है PTRACE_CONT, यदि सिस्टम कॉल नहीं है, तो हमारा फ़िल्टर प्रत्येक सिस्टम कॉल के लिए संसाधित होता है X, तो प्रक्रिया चलती रहती है, लेकिन यदि यह X, तो seccomp नियंत्रण स्थानांतरित कर देगा straceजो तर्कों को देखेगा और प्रक्रिया शुरू करेगा PTRACE_SYSCALL (चूंकि seccomp में सिस्टम कॉल से बाहर निकलने पर प्रोग्राम चलाने की क्षमता नहीं है)। जब सिस्टम कॉल वापस आती है, strace का उपयोग करके प्रक्रिया को पुनः आरंभ करेगा PTRACE_CONT और seccomp के नए संदेशों की प्रतीक्षा करूंगा।

विकल्प का उपयोग करते समय --seccomp-bpf दो प्रतिबंध हैं. सबसे पहले, पहले से मौजूद प्रक्रिया (विकल्प) में शामिल होना संभव नहीं होगा -p कार्यक्रमों strace), चूंकि यह seccomp द्वारा समर्थित नहीं है। दूसरे, कोई संभावना नहीं है नहीं चाइल्ड प्रक्रियाओं को देखें, क्योंकि seccomp फ़िल्टर इसे अक्षम करने की क्षमता के बिना सभी चाइल्ड प्रक्रियाओं द्वारा विरासत में मिले हैं।

वास्तव में कैसे, इस पर थोड़ा और विवरण strace के साथ काम करता है seccomp से पाया जा सकता है हाल ही की रिपोर्ट. हमारे लिए, सबसे दिलचस्प तथ्य यह है कि seccomp द्वारा दर्शाया गया क्लासिक BPF आज भी उपयोग किया जाता है।

`xt_bpf`

चलिए अब नेटवर्क की दुनिया में वापस चलते हैं।

पृष्ठभूमि: बहुत समय पहले, 2007 में, मूल था जोड़ा मॉड्यूल xt_u32 नेटफ़िल्टर के लिए. इसे और भी अधिक प्राचीन यातायात वर्गीकरणकर्ता के सादृश्य द्वारा लिखा गया था cls_u32 और आपको निम्नलिखित सरल ऑपरेशनों का उपयोग करके iptables के लिए मनमाने बाइनरी नियम लिखने की अनुमति दी: एक पैकेज से 32 बिट्स लोड करें और उन पर अंकगणितीय ऑपरेशनों का एक सेट निष्पादित करें। उदाहरण के लिए,

sudo iptables -A INPUT -m u32 --u32 "6&0xFF=1" -j LOG --log-prefix "seen-by-xt_u32"

पैडिंग 32 से शुरू करके आईपी हेडर के 6 बिट्स को लोड करता है, और उन पर एक मास्क लगाता है 0xFF (धीमी बाइट लें)। यह क्षेत्र protocol आईपी हेडर और हम इसकी तुलना 1 (आईसीएमपी) से करते हैं। आप कई चेक को एक नियम में जोड़ सकते हैं, और आप ऑपरेटर को निष्पादित भी कर सकते हैं @ - एक्स बाइट्स को दाईं ओर ले जाएं। उदाहरण के लिए, नियम

iptables -m u32 --u32 "6&0xFF=0x6 && 0>>22&0x3C@4=0x29"

जाँचता है कि क्या टीसीपी अनुक्रम संख्या बराबर नहीं है 0x29. मैं अधिक विवरण में नहीं जाऊंगा, क्योंकि यह पहले से ही स्पष्ट है कि ऐसे नियमों को हाथ से लिखना बहुत सुविधाजनक नहीं है। लेख में बीपीएफ - भूला हुआ बाइटकोड, इसके उपयोग और नियम निर्माण के उदाहरणों के साथ कई लिंक हैं xt_u32. इस लेख के अंत में दिए गए लिंक भी देखें।

2013 से मॉड्यूल के बजाय मॉड्यूल xt_u32 आप बीपीएफ आधारित मॉड्यूल का उपयोग कर सकते हैं xt_bpf. जिसने भी इसे अब तक पढ़ा है उसे पहले से ही इसके संचालन के सिद्धांत के बारे में स्पष्ट होना चाहिए: बीपीएफ बाइटकोड को आईपीटेबल्स नियमों के रूप में चलाएं। उदाहरण के लिए, आप इस तरह एक नया नियम बना सकते हैं:

iptables -A INPUT -m bpf --bytecode <байткод> -j LOG

यहां <байткод> - यह असेंबलर आउटपुट फॉर्मेट में कोड है bpf_asm डिफ़ॉल्ट रूप से, उदाहरण के लिए,

$ cat /tmp/test.bpf
ldb [9]
jneq #17, ignore
ret #1
ignore: ret #0

$ bpf_asm /tmp/test.bpf
4,48 0 0 9,21 0 1 17,6 0 0 1,6 0 0 0,

# iptables -A INPUT -m bpf --bytecode "$(bpf_asm /tmp/test.bpf)" -j LOG

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

यह स्पष्ट है कि मॉड्यूल xt_bpf उपरोक्त उदाहरण की तुलना में अधिक जटिल फ़िल्टर का समर्थन करता है। आइए क्लाउडफ़ेयर के वास्तविक उदाहरण देखें। हाल तक वे मॉड्यूल का उपयोग करते थे xt_bpf DDoS हमलों से बचाने के लिए. लेख में बीपीएफ टूल्स का परिचय वे बताते हैं कि कैसे (और क्यों) वे बीपीएफ फ़िल्टर उत्पन्न करते हैं और ऐसे फ़िल्टर बनाने के लिए उपयोगिताओं के एक सेट के लिंक प्रकाशित करते हैं। उदाहरण के लिए, उपयोगिता का उपयोग करना bpfgen आप एक BPF प्रोग्राम बना सकते हैं जो किसी नाम के लिए DNS क्वेरी से मेल खाता है habr.com:

$ ./bpfgen --assembly dns -- habr.com
ldx 4*([0]&0xf)
ld #20
add x
tax

lb_0:
    ld [x + 0]
    jneq #0x04686162, lb_1
    ld [x + 4]
    jneq #0x7203636f, lb_1
    ldh [x + 8]
    jneq #0x6d00, lb_1
    ret #65535

lb_1:
    ret #0

प्रोग्राम में हम सबसे पहले रजिस्टर में लोड करते हैं X लाइन पते की शुरुआत x04habrx03comx00 UDP डेटाग्राम के अंदर और फिर अनुरोध की जाँच करें: 0x04686162 <-> "x04hab" आदि

थोड़ी देर बाद, क्लाउडफ़ेयर ने p0f -> BPF कंपाइलर कोड प्रकाशित किया। लेख में पी0एफ बीपीएफ कंपाइलर का परिचय वे इस बारे में बात करते हैं कि p0f क्या है और p0f हस्ताक्षरों को BPF में कैसे परिवर्तित करें:

$ ./bpfgen p0f -- 4:64:0:0:*,0::ack+:0
39,0 0 0 0,48 0 0 8,37 35 0 64,37 0 34 29,48 0 0 0,
84 0 0 15,21 0 31 5,48 0 0 9,21 0 29 6,40 0 0 6,
...

वर्तमान में क्लाउडफ़ेयर का उपयोग नहीं कर रहा हूँ xt_bpf, चूँकि वे XDP में चले गए - BPF के नए संस्करण का उपयोग करने के विकल्पों में से एक, देखें। L4Drop: XDP DDoS शमन.

`cls_bpf`

कर्नेल में क्लासिक बीपीएफ का उपयोग करने का अंतिम उदाहरण क्लासिफायरियर है cls_bpf लिनक्स में ट्रैफिक नियंत्रण सबसिस्टम के लिए, 2013 के अंत में लिनक्स में जोड़ा गया और अवधारणात्मक रूप से प्राचीन की जगह ले ली गई cls_u32.

हालाँकि, अब हम कार्य का वर्णन नहीं करेंगे cls_bpf, चूंकि क्लासिक बीपीएफ के बारे में ज्ञान के दृष्टिकोण से यह हमें कुछ नहीं देगा - हम पहले से ही सभी कार्यक्षमता से परिचित हो चुके हैं। इसके अलावा, विस्तारित बीपीएफ के बारे में बात करते हुए बाद के लेखों में, हम इस क्लासिफायरियर से एक से अधिक बार मिलेंगे।

क्लासिक बीपीएफ सी के उपयोग के बारे में बात न करने का एक और कारण cls_bpf समस्या यह है कि, विस्तारित बीपीएफ की तुलना में, इस मामले में प्रयोज्यता का दायरा मौलिक रूप से संकुचित है: शास्त्रीय कार्यक्रम पैकेज की सामग्री को नहीं बदल सकते हैं और कॉल के बीच स्थिति को सहेज नहीं सकते हैं।

तो अब क्लासिक बीपीएफ को अलविदा कहने और भविष्य की ओर देखने का समय आ गया है।

क्लासिक बीपीएफ को विदाई

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

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

एक नई वास्तुकला में परिवर्तन 2013 में शुरू हुआ, जब एलेक्सी स्टारोवोइटोव ने बीपीएफ अद्यतन योजना का प्रस्ताव रखा। 2014 में संबंधित पैच दिखाई देने लगा मूल में. जहां तक मैं समझता हूं, प्रारंभिक योजना केवल 64-बिट मशीनों पर अधिक कुशलता से चलाने के लिए आर्किटेक्चर और जेआईटी कंपाइलर को अनुकूलित करने की थी, लेकिन इसके बजाय इन अनुकूलन ने लिनक्स विकास में एक नए अध्याय की शुरुआत को चिह्नित किया।

इस श्रृंखला के आगे के लेख नई तकनीक की वास्तुकला और अनुप्रयोगों को कवर करेंगे, जिसे शुरू में आंतरिक बीपीएफ, फिर विस्तारित बीपीएफ और अब केवल बीपीएफ के रूप में जाना जाता है।

संदर्भों

स्टीवन मैक्केन और वैन जैकबसन, "बीएसडी पैकेट फ़िल्टर: उपयोगकर्ता-स्तरीय पैकेट कैप्चर के लिए एक नया आर्किटेक्चर", https://www.tcpdump.org/papers/bpf-usenix93.pdf
स्टीवन मैक्केन, "libpcap: पैकेट कैप्चर के लिए एक वास्तुकला और अनुकूलन पद्धति", https://sharkfestus.wireshark.org/sharkfest.11/presentations/McCanne-Sharkfest'11_Keynote_Address.pdf
tcpdump, libpcap: https://www.tcpdump.org/
आईपीटेबल यू32 मैच ट्यूटोरियल.
बीपीएफ - भूला हुआ बाइटकोड: https://blog.cloudflare.com/bpf-the-forgotten-bytecode/
बीपीएफ टूल का परिचय: https://blog.cloudflare.com/introducing-the-bpf-tools/
bpf_cls: http://man7.org/linux/man-pages/man8/tc-bpf.8.html
एक सेकंडकॉम्प सिंहावलोकन: https://lwn.net/Articles/656307/
https://github.com/torvalds/linux/blob/master/Documentation/userspace-api/seccomp_filter.rst
habr: कंटेनर और सुरक्षा: seccomp
habr: सिस्टमडी के साथ डेमॉन को अलग करना या "इसके लिए आपको डॉकर की आवश्यकता नहीं है!"
पॉल चैग्नन, "स्ट्रेस--सेकम्प-बीपीएफ: ए लुक अंडर द हुड", https://fosdem.org/2020/schedule/event/debugging_strace_bpf/
netsniff-ng: http://netsniff-ng.org/

स्रोत: www.habr.com

छोटों के लिए बीपीएफ, भाग शून्य: क्लासिक बीपीएफ