🥇BPF लहान मुलांसाठी, भाग शून्य: क्लासिक BPF

बर्कले पॅकेट फिल्टर्स (BPF) हे लिनक्स कर्नल तंत्रज्ञान आहे जे अनेक वर्षांपासून इंग्रजी-भाषेच्या तंत्रज्ञान प्रकाशनांच्या पहिल्या पानांवर आहे. परिषदा BPF च्या वापर आणि विकासाच्या अहवालांनी भरलेल्या आहेत. डेव्हिड मिलर, लिनक्स नेटवर्क सबसिस्टम मेंटेनर, लिनक्स प्लंबर्स 2018 मध्ये त्यांचे भाषण कॉल करते "ही चर्चा XDP बद्दल नाही" (XDP बीपीएफसाठी एक वापर केस आहे). ब्रेंडन ग्रेग या शीर्षकाखाली भाषणे देतात लिनक्स बीपीएफ सुपरपॉवर्स. टोके हाईलँड-जॉर्गेनसेन हसतोकी कर्नल आता मायक्रोकर्नल आहे. थॉमस ग्राफ या कल्पनेला प्रोत्साहन देतात बीपीएफ कर्नलसाठी जावास्क्रिप्ट आहे.

Habré वर BPF चे अद्याप कोणतेही पद्धतशीर वर्णन नाही, आणि म्हणूनच लेखांच्या मालिकेत मी तंत्रज्ञानाच्या इतिहासाबद्दल बोलण्याचा प्रयत्न करेन, आर्किटेक्चर आणि विकास साधनांचे वर्णन करेन आणि BPF वापरण्याच्या अनुप्रयोग आणि सरावाच्या क्षेत्रांची रूपरेषा सांगेन. हा लेख, शून्य, मालिकेतील, क्लासिक बीपीएफचा इतिहास आणि आर्किटेक्चर सांगतो आणि त्याच्या ऑपरेटिंग तत्त्वांचे रहस्य देखील प्रकट करतो. tcpdump, seccomp, strace, आणि बरेच काही.

बीपीएफचा विकास लिनक्स नेटवर्किंग समुदायाद्वारे नियंत्रित केला जातो, बीपीएफचे मुख्य विद्यमान अनुप्रयोग नेटवर्कशी संबंधित आहेत आणि म्हणून परवानगीसह @eucariot, मी या मालिकेला "लहान मुलांसाठी BPF" म्हटले आहे, महान मालिकेच्या सन्मानार्थ "लहान मुलांसाठी नेटवर्क".

BPF च्या इतिहासातील एक छोटा कोर्स (c)

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

गेल्या शतकाच्या ऐंशीच्या दशकाच्या शेवटी, प्रसिद्ध लॉरेन्स बर्कले प्रयोगशाळेतील अभियंत्यांना गेल्या शतकाच्या ऐंशीच्या दशकाच्या उत्तरार्धात आधुनिक असलेल्या हार्डवेअरवर नेटवर्क पॅकेट्स योग्यरित्या कसे फिल्टर करायचे या प्रश्नात रस निर्माण झाला. फिल्टरिंगची मूळ कल्पना, मूळत: CSPF (CMU/Stanford Packet Filter) तंत्रज्ञानामध्ये अंमलात आणली गेली, अनावश्यक पॅकेट्स शक्य तितक्या लवकर फिल्टर करणे, म्हणजे. कर्नल स्पेसमध्ये, कारण यामुळे वापरकर्ता स्पेसमध्ये अनावश्यक डेटा कॉपी करणे टाळले जाते. कर्नल स्पेसमध्ये वापरकर्ता कोड चालविण्यासाठी रनटाइम सुरक्षा प्रदान करण्यासाठी, सँडबॉक्स केलेले व्हर्च्युअल मशीन वापरले गेले.

तथापि, विद्यमान फिल्टर्ससाठी व्हर्च्युअल मशीन स्टॅक-आधारित मशीनवर चालण्यासाठी डिझाइन केल्या होत्या आणि नवीन RISC मशीनवर कार्यक्षमतेने चालत नाहीत. परिणामी, बर्कले लॅबमधील अभियंत्यांच्या प्रयत्नातून, एक नवीन बीपीएफ (बर्कले पॅकेट फिल्टर) तंत्रज्ञान विकसित केले गेले, ज्याचे आभासी मशीन आर्किटेक्चर मोटोरोला 6502 प्रोसेसरवर आधारित डिझाइन केले गेले - अशा सुप्रसिद्ध उत्पादनांचे वर्कहोर्स. ऍपल दुसरा किंवा एनईएस. नवीन व्हर्च्युअल मशीनने विद्यमान सोल्यूशन्सच्या तुलनेत फिल्टर कामगिरी दहापट वाढवली आहे.

बीपीएफ मशीन आर्किटेक्चर

उदाहरणांचे विश्लेषण करून आम्ही वास्तुकलाशी कार्यशील मार्गाने परिचित होऊ. तथापि, सुरुवातीला, असे म्हणूया की मशीनमध्ये वापरकर्त्यासाठी प्रवेशयोग्य दोन 32-बिट रजिस्टर होते, एक संचयक A आणि इंडेक्स रजिस्टर X, 64 बाइट्स मेमरी (16 शब्द), लेखन आणि त्यानंतरच्या वाचनासाठी उपलब्ध, आणि या ऑब्जेक्ट्ससह कार्य करण्यासाठी कमांडची एक छोटी प्रणाली. कार्यक्रमांमध्ये सशर्त अभिव्यक्ती लागू करण्यासाठी जंप सूचना देखील उपलब्ध होत्या, परंतु कार्यक्रम वेळेवर पूर्ण होण्याची हमी देण्यासाठी, जंप फक्त पुढे केल्या जाऊ शकतात, म्हणजे, विशेषतः, लूप तयार करण्यास मनाई होती.

मशीन सुरू करण्याची सर्वसाधारण योजना खालीलप्रमाणे आहे. वापरकर्ता BPF आर्किटेक्चरसाठी एक प्रोग्राम तयार करतो आणि वापरून काही कर्नल मेकॅनिझम (जसे की सिस्टम कॉल), प्रोग्राम लोड करते आणि कनेक्ट करते काही साठी कर्नलमधील इव्हेंट जनरेटरला (उदाहरणार्थ, इव्हेंट म्हणजे नेटवर्क कार्डवरील पुढील पॅकेटचे आगमन). जेव्हा एखादी घटना घडते, तेव्हा कर्नल प्रोग्राम चालवते (उदाहरणार्थ, दुभाष्यामध्ये), आणि मशीन मेमरी त्याच्याशी संबंधित असते काही साठी कर्नल मेमरी प्रदेश (उदाहरणार्थ, इनकमिंग पॅकेटचा डेटा).

उदाहरणे पाहण्यास सुरुवात करण्यासाठी वरील गोष्टी पुरेसे असतील: आवश्यकतेनुसार आम्ही सिस्टम आणि कमांड फॉरमॅटशी परिचित होऊ. जर तुम्हाला व्हर्च्युअल मशीनच्या कमांड सिस्टमचा ताबडतोब अभ्यास करायचा असेल आणि त्यातील सर्व क्षमता जाणून घ्यायच्या असतील तर तुम्ही मूळ लेख वाचू शकता. बीएसडी पॅकेट फिल्टर आणि/किंवा फाइलचा पहिला भाग Documentation/networking/filter.txt कर्नल दस्तऐवजीकरणातून. याव्यतिरिक्त, आपण सादरीकरणाचा अभ्यास करू शकता libpcap: पॅकेट कॅप्चरसाठी एक आर्किटेक्चर आणि ऑप्टिमायझेशन पद्धत, ज्यामध्ये मॅककेन, बीपीएफच्या लेखकांपैकी एक, निर्मितीच्या इतिहासाबद्दल बोलतो libpcap.

आम्ही आता लिनक्सवर क्लासिक बीपीएफ वापरण्याच्या सर्व महत्त्वपूर्ण उदाहरणांवर विचार करू: tcpdump (libpcap), seccomp, xt_bpf, cls_bpf.

tcpdump

बीपीएफचा विकास पॅकेट फिल्टरिंगसाठी फ्रंटएंडच्या विकासाच्या समांतरपणे केला गेला - एक सुप्रसिद्ध उपयुक्तता tcpdump. आणि, हे क्लासिक BPF वापरण्याचे सर्वात जुने आणि सर्वात प्रसिद्ध उदाहरण असल्याने, अनेक ऑपरेटिंग सिस्टीमवर उपलब्ध आहे, आम्ही त्याद्वारे तंत्रज्ञानाचा आमचा अभ्यास सुरू करू.

(मी लिनक्सवर या लेखातील सर्व उदाहरणे चालवली 5.6.0-rc6. चांगल्या वाचनीयतेसाठी काही कमांड्सचे आउटपुट संपादित केले गेले आहे.)

उदाहरण: IPv6 पॅकेटचे निरीक्षण करणे

चला कल्पना करूया की आपल्याला इंटरफेसवर सर्व IPv6 पॅकेट्स पहायचे आहेत eth0. हे करण्यासाठी आपण प्रोग्राम चालवू शकतो tcpdump साध्या फिल्टरसह ip6:

$ sudo tcpdump -i eth0 ip6

अशा प्रकारे tcpdump फिल्टर संकलित करते ip6 BPF आर्किटेक्चर बाइटकोडमध्ये आणि कर्नलवर पाठवा (विभागातील तपशील पहा Tcpdump: लोड होत आहे). लोड केलेले फिल्टर इंटरफेसमधून जाणाऱ्या प्रत्येक पॅकेटसाठी चालवले जाईल 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आणि हे म्हणजेपॅकेट असे दिसते (साधेपणासाठी, आम्ही गृहीत धरतो की पॅकेटमध्ये कोणतेही VLAN टॅग नाहीत):

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

तर आज्ञा अंमलात आणल्यानंतर ldh [12] रजिस्टर मध्ये A एक फील्ड असेल Ether Type — या इथरनेट फ्रेममध्ये प्रसारित केलेल्या पॅकेटचा प्रकार. ओळ 1 वर आम्ही रजिस्टरमधील सामग्रीची तुलना करतो A (पॅकेज प्रकार) c 0x86ddआणि हे आणि आहे आम्हाला स्वारस्य असलेला प्रकार IPv6 आहे. ओळ 1 वर, तुलना आदेशाव्यतिरिक्त, आणखी दोन स्तंभ आहेत - jt 2 и jf 3 तुलना यशस्वी झाल्यास तुम्हाला ज्या गुणांवर जावे लागेल (A == 0x86dd) आणि अयशस्वी. म्हणून, यशस्वी केसमध्ये (IPv6) आपण ओळ 2 वर जातो, आणि अयशस्वी प्रकरणात - 3 व्या ओळीवर. ओळी 3 वर प्रोग्राम कोड 0 सह समाप्त होतो (पॅकेट कॉपी करू नका), 2 व्या ओळीवर प्रोग्राम कोडसह समाप्त होतो. 262144 (मला जास्तीत जास्त 256 किलोबाइट्सचे पॅकेज कॉपी करा).

एक अधिक क्लिष्ट उदाहरण: आम्ही गंतव्य पोर्टद्वारे TCP पॅकेट्स पाहतो

एक फिल्टर कसा दिसतो ते पाहू या जे सर्व TCP पॅकेट्स गंतव्य पोर्ट 666 सह कॉपी करते. आम्ही IPv4 केसचा विचार करू, कारण IPv6 केस सोपे आहे. या उदाहरणाचा अभ्यास केल्यानंतर, तुम्ही स्वतःला एक व्यायाम म्हणून 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 वर आम्ही आधीच तपासले आहे की हे IPv4 पॅकेट आहे (इथर प्रकार = 0x800) आणि ते रजिस्टरमध्ये लोड करा A पॅकेटचा 24 वा बाइट. आमचे पॅकेज असे दिसते

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

याचा अर्थ आम्ही रजिस्टरमध्ये लोड करतो A IP हेडरचे प्रोटोकॉल फील्ड, जे लॉजिकल आहे, कारण आम्हाला फक्त TCP पॅकेट्स कॉपी करायचे आहेत. आम्ही प्रोटोकॉलशी तुलना करतो 0x6 (IPPROTO_TCPओळ 3 वर.

ओळी 4 आणि 5 वर आम्ही पत्ता 20 वर स्थित अर्धशब्द लोड करतो आणि कमांड वापरतो jset तीनपैकी एक सेट आहे का ते तपासा झेंडे - जारी केलेला मास्क परिधान jset तीन सर्वात लक्षणीय बिट साफ केले आहेत. तीन बिट्सपैकी दोन पॅकेट खंडित IP पॅकेटचा भाग आहे की नाही हे आम्हाला सांगतात आणि तसे असल्यास, तो शेवटचा तुकडा आहे की नाही. तिसरा बिट आरक्षित आहे आणि शून्य असणे आवश्यक आहे. आम्ही एकतर अपूर्ण किंवा तुटलेली पॅकेट तपासू इच्छित नाही, म्हणून आम्ही तिन्ही बिट्स तपासतो.

या सूचीमध्ये लाइन 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 (इंडेक्स रजिस्टर) IPv4 शीर्षलेख लांबी.

तर ७व्या ओळीवर आपण अर्धा शब्द येथे लोड करण्याचा प्रयत्न करतो (X+16). इथरनेट शीर्षलेखाने 14 बाइट्स व्यापलेले आहेत हे लक्षात ठेवणे, आणि X IPv4 शीर्षलेखाची लांबी समाविष्ट आहे, आम्ही समजतो की मध्ये A TCP गंतव्य पोर्ट लोड केले आहे:

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

शेवटी, 8 व्या ओळीवर आम्ही इच्छित मूल्यासह गंतव्य पोर्टची तुलना करतो आणि 9 किंवा 10 व्या ओळींवर आम्ही परिणाम परत करतो - पॅकेट कॉपी करायचे की नाही.

Tcpdump: लोड होत आहे

मागील उदाहरणांमध्ये, आम्ही विशेषत: पॅकेट फिल्टरिंगसाठी कर्नलमध्ये बीपीएफ बायकोड कसे लोड करतो याबद्दल तपशीलवार विचार केला नाही. साधारणतः बोलातांनी, 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 चार BPF सूचनांचा समावेश असेल आणि तिसऱ्या ओळीवर आपण पर्याय कसा वापरायचा ते पाहू 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 (सर्व पॅकेट्स ड्रॉप करा), सॉकेटला नॉन-ब्लॉकिंग मोडवर स्विच करते आणि मागील फिल्टर्समधून राहिलेली सर्व पॅकेट्स वजा करण्याचा प्रयत्न करते.

एकंदरीत, क्लासिक BPF वापरून लिनक्सवर पॅकेजेस फिल्टर करण्यासाठी, तुमच्याकडे संरचनेच्या स्वरूपात फिल्टर असणे आवश्यक आहे जसे की struct sock_fprog आणि एक ओपन सॉकेट, ज्यानंतर फिल्टरला सिस्टम कॉल वापरून सॉकेटशी संलग्न केले जाऊ शकते setsockopt.

विशेष म्हणजे, फिल्टर कोणत्याही सॉकेटशी संलग्न केला जाऊ शकतो, केवळ कच्चा नाही. येथे उदाहरण एक प्रोग्राम जो सर्व येणार्‍या UDP डेटाग्राममधून पहिल्या दोन बाइट्सशिवाय सर्व कापतो. (लेखात गोंधळ होऊ नये म्हणून मी कोडमध्ये टिप्पण्या जोडल्या आहेत.)

वापराबद्दल अधिक तपशील setsockopt फिल्टर कनेक्ट करण्यासाठी, पहा सॉकेट(७), पण जसे तुमचे स्वतःचे फिल्टर लिहिण्याबद्दल struct sock_fprog मदतीशिवाय tcpdump आम्ही विभागात बोलू आमच्या स्वत: च्या हातांनी बीपीएफ प्रोग्रामिंग.

क्लासिक BPF आणि 21 वे शतक

BPF 1997 मध्ये लिनक्समध्ये समाविष्ट केले गेले आणि बर्याच काळापासून ते कार्यरत आहे libpcap कोणत्याही विशेष बदलांशिवाय (लिनक्स-विशिष्ट बदल, अर्थातच, तो होता, परंतु त्यांनी जागतिक चित्र बदलले नाही). बीपीएफ विकसित होण्याची पहिली गंभीर चिन्हे 2011 मध्ये आली, जेव्हा एरिक डुमाझेटने प्रस्तावित केले. पॅच, जे कर्नलमध्ये Just In Time Compiler जोडते - BPF bytecode नेटिव्हमध्ये रूपांतरित करण्यासाठी अनुवादक x86_64 कोड

जेआयटी कंपाइलर बदलांच्या साखळीतील पहिले होते: 2012 मध्ये दिसू लागले साठी फिल्टर लिहिण्याची क्षमता सेकॉम्प, BPF वापरून, जानेवारी 2013 मध्ये होते जोडले मॉड्यूल xt_bpf, जे तुम्हाला नियम लिहिण्याची परवानगी देते iptables BPF च्या मदतीने, आणि ऑक्टोबर 2013 मध्ये होते जोडले एक मॉड्यूल देखील cls_bpf, जे तुम्हाला BPF वापरून रहदारी वर्गीकरण लिहिण्याची परवानगी देते.

आम्ही लवकरच ही सर्व उदाहरणे अधिक तपशीलवार पाहू, परंतु प्रथम BPF साठी अनियंत्रित प्रोग्राम कसे लिहावे आणि संकलित करावे हे शिकणे आपल्यासाठी उपयुक्त ठरेल, कारण लायब्ररीद्वारे प्रदान केलेल्या क्षमता libpcap मर्यादित (साधे उदाहरण: फिल्टर व्युत्पन्न libpcap फक्त दोन मूल्ये परत करू शकतात - 0 किंवा 0x40000) किंवा सामान्यतः, seccomp च्या बाबतीत, लागू होत नाहीत.

आमच्या स्वत: च्या हातांनी बीपीएफ प्रोग्रामिंग

चला बीपीएफ निर्देशांच्या बायनरी स्वरूपाशी परिचित होऊया, हे अगदी सोपे आहे:

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

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

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 क्लासिक 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>,..., TCP सह आमच्या उदाहरणासाठी ते असेल

$ 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,

सी प्रोग्रामरच्या सोयीसाठी, भिन्न आउटपुट स्वरूप वापरले जाऊ शकते:

$ 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(). (BPF च्या नवीन आवृत्तीमध्ये, हे नॉन-स्टँडर्ड विस्तार मेमरी, स्ट्रक्चर्स आणि जनरेटिंग इव्हेंटमध्ये प्रवेश करण्यासाठी कर्नल सहाय्यकांच्या संचासह प्रोग्राम प्रदान करण्यासाठी विस्तारित केले गेले आहेत.) येथे फिल्टरचे एक मनोरंजक उदाहरण आहे ज्यामध्ये आम्ही फक्त कॉपी करतो. विस्तार वापरून वापरकर्ता स्पेसमध्ये पॅकेट शीर्षलेख poff, पेलोड ऑफसेट:

ld poff
ret a

मध्ये BPF विस्तार वापरले जाऊ शकत नाहीत tcpdump, परंतु युटिलिटी पॅकेजशी परिचित होण्याचे हे एक चांगले कारण आहे netsniff-ng, ज्यामध्ये, इतर गोष्टींबरोबरच, एक प्रगत प्रोग्राम आहे netsniff-ng, ज्यामध्ये, BPF वापरून फिल्टर करण्याव्यतिरिक्त, एक प्रभावी रहदारी जनरेटर देखील आहे आणि त्यापेक्षा अधिक प्रगत tools/bpf/bpf_asm, BPF असेंबलर बोलावले bpfc. पॅकेजमध्ये तपशीलवार दस्तऐवज आहेत, लेखाच्या शेवटी दुवे देखील पहा.

सेकॉम्प

त्यामुळे, अनियंत्रित जटिलतेचे BPF प्रोग्राम कसे लिहायचे हे आम्हाला आधीच माहित आहे आणि नवीन उदाहरणे पाहण्यास तयार आहोत, त्यापैकी पहिले seccomp तंत्रज्ञान आहे, जे BPF फिल्टर वापरून, उपलब्ध सिस्टम कॉल वितर्कांचा सेट आणि संच व्यवस्थापित करण्यास अनुमती देते. दिलेली प्रक्रिया आणि त्याचे वंशज.

seccomp ची पहिली आवृत्ती कर्नलमध्ये 2005 मध्ये जोडली गेली होती आणि ती फारशी लोकप्रिय नव्हती, कारण ती फक्त एकच पर्याय प्रदान करते - प्रक्रियेसाठी उपलब्ध असलेल्या सिस्टम कॉल्सच्या सेटला खालील गोष्टींपर्यंत मर्यादित करण्यासाठी: read, write, exit и sigreturn, आणि नियमांचे उल्लंघन करणारी प्रक्रिया वापरून मारली गेली SIGKILL. तथापि, 2012 मध्ये, seccomp ने BPF फिल्टर वापरण्याची क्षमता जोडली, ज्यामुळे तुम्हाला अनुमत सिस्टीम कॉल्सचा संच परिभाषित करता येतो आणि त्यांच्या युक्तिवादांची तपासणी देखील करता येते. (मजेची गोष्ट म्हणजे, क्रोम या कार्यक्षमतेच्या पहिल्या वापरकर्त्यांपैकी एक होता, आणि क्रोम लोक सध्या BPF च्या नवीन आवृत्तीवर आधारित KRSI यंत्रणा विकसित करत आहेत आणि Linux सुरक्षा मॉड्यूल्सच्या सानुकूलनास अनुमती देत आहेत.) अतिरिक्त दस्तऐवजीकरणाच्या लिंक्स शेवटी आढळू शकतात. लेखाचा.

लक्षात घ्या की seccomp वापरण्याबद्दल हबवर आधीच लेख आले आहेत, कदाचित कोणीतरी खालील उपविभाग वाचण्यापूर्वी (किंवा त्याऐवजी) ते वाचू इच्छित असेल. लेखात कंटेनर आणि सुरक्षा: seccomp seccomp वापरण्याची उदाहरणे देते, 2007 आवृत्ती आणि BPF वापरून आवृत्ती दोन्ही (libseccomp वापरून फिल्टर तयार केले जातात), डॉकरसह seccomp च्या कनेक्शनबद्दल बोलतात आणि अनेक उपयुक्त दुवे देखील प्रदान करते. लेखात सिस्टमड किंवा "यासाठी तुम्हाला डॉकरची गरज नाही!" सह डिमन वेगळे करणे यामध्ये, विशेषतः, systemd रनिंग डिमनसाठी सिस्टम कॉलची ब्लॅकलिस्ट किंवा व्हाईटलिस्ट कशी जोडायची हे समाविष्ट आहे.

पुढे आपण फिल्टर कसे लिहायचे आणि लोड करायचे ते पाहू seccomp बेअर सी मध्ये आणि लायब्ररी वापरून 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 कार्यक्रमांसाठी अनुपलब्ध आहे, ते जोडल्यापासून खंडित होईल ABI.)

मुळात, 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`

नेटिव्ह कोडमध्ये किंवा BPF असेंब्लीमध्ये फिल्टर लिहिल्याने तुम्हाला निकालावर पूर्ण नियंत्रण ठेवता येते, परंतु त्याच वेळी, काही वेळा पोर्टेबल आणि/किंवा वाचनीय कोड असणे श्रेयस्कर असते. यासाठी ग्रंथालय आम्हाला मदत करेल 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 वर सेट केल्याने फिल्टर बायनरी शोध प्रोग्राममध्ये रूपांतरित होईल.

बायनरी शोध फिल्टर कसे कार्य करतात ते तुम्हाला पहायचे असल्यास, पहा साधी लिपी, जे सिस्टम कॉल नंबर डायल करून BPF असेंबलरमध्ये असे प्रोग्राम तयार करते, उदाहरणार्थ:

$ 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

लक्षणीयरीत्या वेगाने काहीही लिहिणे अशक्य आहे, कारण BPF प्रोग्राम इंडेंटेशन जंप करू शकत नाहीत (आम्ही करू शकत नाही, उदाहरणार्थ, jmp A किंवा jmp [label+X]) आणि म्हणून सर्व संक्रमणे स्थिर आहेत.

seccomp आणि strace

प्रत्येकाला उपयुक्तता माहित आहे 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 पासून सुरू होणार्‍या, IP हेडरचे 6 बिट्स लोड करतात आणि त्यांना मास्क लागू करतात 0xFF (लो बाइट घ्या). हे क्षेत्र protocol IP हेडर आणि आम्ही त्याची 1 (ICMP) शी तुलना करतो. आपण एका नियमात अनेक चेक एकत्र करू शकता आणि आपण ऑपरेटरला कार्यान्वित देखील करू शकता @ — X बाइट्स उजवीकडे हलवा. उदाहरणार्थ, नियम

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

TCP अनुक्रम संख्या समान नाही का ते तपासते 0x29. मी अधिक तपशीलात जाणार नाही, कारण हे आधीच स्पष्ट आहे की असे नियम हाताने लिहिणे फार सोयीचे नाही. लेखात बीपीएफ - विसरलेला बायकोड, साठी वापर आणि नियम निर्मितीच्या उदाहरणांसह अनेक दुवे आहेत xt_u32. या लेखाच्या शेवटी लिंक्स देखील पहा.

2013 पासून मॉड्यूल ऐवजी मॉड्यूल xt_u32 तुम्ही BPF आधारित मॉड्यूल वापरू शकता xt_bpf. ज्याने हे आतापर्यंत वाचले आहे त्यांनी त्याच्या ऑपरेशनच्या तत्त्वाबद्दल आधीच स्पष्ट केले पाहिजे: iptables नियम म्हणून BPF bytecode चालवा. तुम्ही एक नवीन नियम तयार करू शकता, उदाहरणार्थ, याप्रमाणे:

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

या उदाहरणात आपण सर्व UDP पॅकेट्स फिल्टर करत आहोत. मॉड्यूलमधील बीपीएफ प्रोग्रामसाठी संदर्भ xt_bpf, अर्थातच, पॅकेट डेटाकडे निर्देश करते, iptables च्या बाबतीत, IPv4 शीर्षलेखाच्या सुरूवातीस. बीपीएफ प्रोग्राममधून परतावा मूल्य बुलियनकुठे false म्हणजे पॅकेट जुळत नाही.

हे स्पष्ट आहे की मॉड्यूल xt_bpf वरील उदाहरणापेक्षा अधिक जटिल फिल्टरचे समर्थन करते. क्लाउडफेअरमधील वास्तविक उदाहरणे पाहू. अलीकडे पर्यंत त्यांनी मॉड्यूल वापरले xt_bpf DDoS हल्ल्यांपासून संरक्षण करण्यासाठी. लेखात BPF टूल्स सादर करत आहोत ते BPF फिल्टर कसे तयार करतात (आणि का) ते स्पष्ट करतात आणि असे फिल्टर तयार करण्यासाठी उपयुक्ततेच्या संचाच्या लिंक्स प्रकाशित करतात. उदाहरणार्थ, उपयुक्तता वापरणे bpfgen तुम्ही नावासाठी DNS क्वेरीशी जुळणारा BPF प्रोग्राम तयार करू शकता 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 कंपाइलर कोड प्रकाशित केला. लेखात p0f BPF कंपाइलर सादर करत आहे ते 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, क्लासिक BPF बद्दल ज्ञानाच्या दृष्टिकोनातून हे आम्हाला काहीही देणार नाही - आम्ही आधीच सर्व कार्यक्षमतेशी परिचित झालो आहोत. याव्यतिरिक्त, विस्तारित BPF बद्दल बोलत असलेल्या पुढील लेखांमध्ये, आम्ही या वर्गीकरणकर्त्याला एकापेक्षा जास्त वेळा भेटू.

क्लासिक BPF वापरण्याबद्दल न बोलण्याचे आणखी एक कारण c cls_bpf समस्या अशी आहे की, विस्तारित बीपीएफच्या तुलनेत, या प्रकरणात लागू होण्याचा व्याप्ती पूर्णपणे संकुचित आहे: शास्त्रीय प्रोग्राम पॅकेजमधील सामग्री बदलू शकत नाहीत आणि कॉल दरम्यान स्थिती वाचवू शकत नाहीत.

त्यामुळे क्लासिक BPF ला निरोप घेण्याची आणि भविष्याकडे पाहण्याची वेळ आली आहे.

क्लासिक BPF ला निरोप

नव्वदच्या दशकाच्या सुरुवातीला विकसित झालेले बीपीएफ तंत्रज्ञान एक चतुर्थांश शतक यशस्वीरित्या कसे जगले आणि शेवटपर्यंत नवीन अनुप्रयोग कसे सापडले ते आम्ही पाहिले. तथापि, स्टॅक मशीन्सपासून RISC मधील संक्रमणाप्रमाणेच, ज्याने क्लासिक BPF च्या विकासासाठी प्रेरणा म्हणून काम केले, 32 च्या दशकात 64-बिट मधून XNUMX-बिट मशीनमध्ये संक्रमण झाले आणि क्लासिक BPF अप्रचलित होऊ लागले. याव्यतिरिक्त, क्लासिक BPF च्या क्षमता खूप मर्यादित आहेत, आणि कालबाह्य आर्किटेक्चर व्यतिरिक्त - आमच्याकडे BPF प्रोग्राम्सवर कॉल दरम्यान स्थिती जतन करण्याची क्षमता नाही, थेट वापरकर्ता परस्परसंवादाची शक्यता नाही, संवाद साधण्याची कोणतीही शक्यता नाही. कर्नलसह, मर्यादित संख्येच्या स्ट्रक्चर फील्ड वाचण्याशिवाय sk_buff आणि सर्वात सोपी हेल्पर फंक्शन्स लाँच केल्याने, तुम्ही पॅकेट्सची सामग्री बदलू शकत नाही आणि त्यांना पुनर्निर्देशित करू शकत नाही.

खरेतर, सध्या लिनक्समधील क्लासिक बीपीएफचे जे काही शिल्लक आहे ते एपीआय इंटरफेस आहे, आणि कर्नलच्या आत सर्व क्लासिक प्रोग्राम्स, मग ते सॉकेट फिल्टर्स किंवा सेककॉम्प फिल्टर्स असोत, विस्तारित बीपीएफ या नवीन फॉरमॅटमध्ये स्वयंचलितपणे अनुवादित केले जातात. (हे नेमके कसे घडते याबद्दल आपण पुढील लेखात बोलू.)

नवीन आर्किटेक्चरमध्ये संक्रमण 2013 मध्ये सुरू झाले, जेव्हा अॅलेक्सी स्टारोवोइटोव्हने बीपीएफ अद्यतन योजना प्रस्तावित केली. 2014 मध्ये संबंधित पॅच दिसू लागले कोर मध्ये. जोपर्यंत मला समजले आहे, प्रारंभिक योजना केवळ आर्किटेक्चर आणि JIT कंपाइलरला 64-बिट मशीनवर अधिक कार्यक्षमतेने चालविण्यासाठी ऑप्टिमाइझ करण्यासाठी होती, परंतु त्याऐवजी या ऑप्टिमायझेशनने लिनक्सच्या विकासातील नवीन अध्यायाची सुरुवात केली.

या मालिकेतील पुढील लेख नवीन तंत्रज्ञानाच्या आर्किटेक्चर आणि अनुप्रयोगांचा समावेश करतील, सुरुवातीला अंतर्गत BPF, नंतर विस्तारित BPF आणि आता फक्त BPF म्हणून ओळखले जाते.

संदर्भ

स्टीव्हन मॅककेन आणि व्हॅन जेकबसन, "द बीएसडी पॅकेट फिल्टर: ए न्यू आर्किटेक्चर फॉर युजर-लेव्हल पॅकेट कॅप्चर", 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/
IPtable U32 मॅच ट्यूटोरियल.
BPF - विसरलेला बायकोड: https://blog.cloudflare.com/bpf-the-forgotten-bytecode/
BPF टूल सादर करत आहे: https://blog.cloudflare.com/introducing-the-bpf-tools/
bpf_cls: http://man7.org/linux/man-pages/man8/tc-bpf.8.html
एक seccomp विहंगावलोकन: https://lwn.net/Articles/656307/
https://github.com/torvalds/linux/blob/master/Documentation/userspace-api/seccomp_filter.rst
habr: कंटेनर आणि सुरक्षा: seccomp
habr: systemd सह डिमन वेगळे करणे किंवा "यासाठी तुम्हाला डॉकरची गरज नाही!"
पॉल चैगनॉन, "strace --seccomp-bpf: अ लुक अंडर द हुड", https://fosdem.org/2020/schedule/event/debugging_strace_bpf/
netsniff-ng: http://netsniff-ng.org/

स्त्रोत: www.habr.com

लहान मुलांसाठी BPF, भाग शून्य: क्लासिक BPF

BPF च्या इतिहासातील एक छोटा कोर्स (c)

बीपीएफ मशीन आर्किटेक्चर

tcpdump

उदाहरण: IPv6 पॅकेटचे निरीक्षण करणे

एक अधिक क्लिष्ट उदाहरण: आम्ही गंतव्य पोर्टद्वारे TCP पॅकेट्स पाहतो

Tcpdump: लोड होत आहे

क्लासिक BPF आणि 21 वे शतक

आमच्या स्वत: च्या हातांनी बीपीएफ प्रोग्रामिंग

लिनक्स आणि नेटस्निफ-एनजी विस्तार

सेकॉम्प

seccomp साठी फिल्टर लिहिणे आणि लोड करणे

आम्ही seccomp वापरून फिल्टर लिहितो आणि लोड करतो `libseccomp`

seccomp आणि strace

`xt_bpf`

`cls_bpf`

क्लासिक BPF ला निरोप

संदर्भ

एक टिप्पणी जोडा Отменить ответ

लहान मुलांसाठी BPF, भाग शून्य: क्लासिक BPF

BPF च्या इतिहासातील एक छोटा कोर्स (c)

बीपीएफ मशीन आर्किटेक्चर

tcpdump

उदाहरण: IPv6 पॅकेटचे निरीक्षण करणे

एक अधिक क्लिष्ट उदाहरण: आम्ही गंतव्य पोर्टद्वारे TCP पॅकेट्स पाहतो

Tcpdump: लोड होत आहे

क्लासिक BPF आणि 21 वे शतक

आमच्या स्वत: च्या हातांनी बीपीएफ प्रोग्रामिंग

लिनक्स आणि नेटस्निफ-एनजी विस्तार

सेकॉम्प

seccomp साठी फिल्टर लिहिणे आणि लोड करणे

आम्ही seccomp वापरून फिल्टर लिहितो आणि लोड करतो libseccomp

seccomp आणि strace

xt_bpf

cls_bpf

क्लासिक BPF ला निरोप

संदर्भ

एक टिप्पणी जोडा Отменить ответ

आम्ही seccomp वापरून फिल्टर लिहितो आणि लोड करतो `libseccomp`

`xt_bpf`

`cls_bpf`