पुस्तक "लिनक्स मॉनिटरिंग के लिए बीपीएफ"

नमस्कार, खाब्रो निवासियों! बीपीएफ वर्चुअल मशीन लिनक्स कर्नेल के सबसे महत्वपूर्ण घटकों में से एक है। इसका उचित उपयोग सिस्टम इंजीनियरों को दोष ढूंढने और यहां तक ​​कि सबसे जटिल समस्याओं को हल करने की अनुमति देगा। आप सीखेंगे कि कर्नेल के व्यवहार की निगरानी और संशोधन करने वाले प्रोग्राम कैसे लिखें, कर्नेल में घटनाओं की निगरानी के लिए कोड को सुरक्षित रूप से कैसे लागू किया जाए, और भी बहुत कुछ। डेविड कैलावेरा और लोरेंजो फोंटाना आपको बीपीएफ की शक्ति को अनलॉक करने में मदद करेंगे। प्रदर्शन अनुकूलन, नेटवर्किंग, सुरक्षा के बारे में अपने ज्ञान का विस्तार करें। - लिनक्स कर्नेल के व्यवहार की निगरानी और संशोधन के लिए बीपीएफ का उपयोग करें। - कर्नेल को पुन: संकलित किए बिना या सिस्टम को रिबूट किए बिना कर्नेल घटनाओं की सुरक्षित रूप से निगरानी करने के लिए कोड इंजेक्ट करें। - सी, गो या पायथन में सुविधाजनक कोड उदाहरणों का उपयोग करें। - बीपीएफ कार्यक्रम जीवनचक्र का स्वामी बनकर नियंत्रण रखें।

लिनक्स कर्नेल सुरक्षा, इसकी विशेषताएं और Seccomp

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

लिनक्स सुरक्षा मॉड्यूल (एलएसएम) एक ढांचा है जो कार्यों का एक सेट प्रदान करता है जिसका उपयोग मानकीकृत तरीके से विभिन्न सुरक्षा मॉडल को लागू करने के लिए किया जा सकता है। LSM का उपयोग सीधे कर्नेल स्रोत ट्री में किया जा सकता है, जैसे कि Apparmor, SELinux और Tomoyo।

आइए लिनक्स की क्षमताओं पर चर्चा करके शुरुआत करें।

क्षमताओं

लिनक्स की क्षमताओं का सार यह है कि आपको एक निश्चित कार्य को करने के लिए एक विशेषाधिकार रहित प्रक्रिया को अनुमति देने की आवश्यकता है, लेकिन उस उद्देश्य के लिए suid का उपयोग किए बिना, या अन्यथा प्रक्रिया को विशेषाधिकार प्राप्त बनाना, हमले की संभावना को कम करना और प्रक्रिया को कुछ कार्य करने की अनुमति देना। उदाहरण के लिए, यदि आपके एप्लिकेशन को एक विशेषाधिकार प्राप्त पोर्ट खोलने की आवश्यकता है, मान लीजिए 80, तो प्रक्रिया को रूट के रूप में चलाने के बजाय, आप इसे केवल CAP_NET_BIND_SERVICE क्षमता दे सकते हैं।

Main.go नाम के एक गो प्रोग्राम पर विचार करें:

package main
import (
            "net/http"
            "log"
)
func main() {
     log.Fatalf("%v", http.ListenAndServe(":80", nil))
}

यह प्रोग्राम पोर्ट 80 पर एक HTTP सर्वर पर कार्य करता है (यह एक विशेषाधिकार प्राप्त पोर्ट है)। आमतौर पर हम इसे संकलन के तुरंत बाद चलाते हैं:

$ go build -o capabilities main.go
$ ./capabilities

हालाँकि, चूँकि हम रूट विशेषाधिकार नहीं दे रहे हैं, इसलिए यह कोड पोर्ट को बाइंड करते समय एक त्रुटि देगा:

2019/04/25 23:17:06 listen tcp :80: bind: permission denied
exit status 1

कैपश (शेल मैनेजर) एक उपकरण है जो क्षमताओं के एक विशिष्ट सेट के साथ एक शेल चलाता है।

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

# capsh --caps='cap_net_bind_service+eip cap_setpcap,cap_setuid,cap_setgid+ep' 
   --keep=1 --user="nobody" 
   --addamb=cap_net_bind_service -- -c "./capabilities"

आइये इस टीम को थोड़ा समझते हैं.

• कैपश - कैपश को शेल के रूप में उपयोग करें।
• —caps='cap_net_bind_service+eipcap_setpcap,cap_setuid,cap_setgid+ep' - चूंकि हमें उपयोगकर्ता को बदलने की आवश्यकता है (हम रूट के रूप में नहीं चलाना चाहते हैं), हम कैप_नेट_बिंड_सर्विस और वास्तव में उपयोगकर्ता आईडी को बदलने की क्षमता निर्दिष्ट करेंगे किसी के लिए रूट नहीं, अर्थात् कैप_सेटुइड और कैप_सेटगिड।
• —कीप=1 — हम रूट खाते से स्विच करते समय स्थापित क्षमताओं को रखना चाहते हैं।
• - उपयोगकर्ता = "कोई नहीं" - प्रोग्राम चलाने वाला अंतिम उपयोगकर्ता कोई नहीं होगा।
• —addamb=cap_net_bind_service — रूट मोड से स्विच करने के बाद संबंधित क्षमताओं का समाशोधन सेट करें।
• - -सी "./क्षमताएं" - बस प्रोग्राम चलाएं।

लिंक की गई क्षमताएं एक विशेष प्रकार की क्षमताएं हैं जो चाइल्ड प्रोग्राम को विरासत में मिलती हैं जब वर्तमान प्रोग्राम उन्हें execve() का उपयोग करके निष्पादित करता है। केवल वे क्षमताएँ जिन्हें संबद्ध होने की अनुमति है, या दूसरे शब्दों में, पर्यावरण क्षमताओं के रूप में, विरासत में मिल सकती हैं।

आप शायद सोच रहे होंगे कि --caps विकल्प में क्षमता निर्दिष्ट करने के बाद +eip का क्या अर्थ है। इन झंडों का उपयोग यह निर्धारित करने के लिए किया जाता है कि क्षमता:

-सक्रिय होना चाहिए (पी);

- उपयोग के लिए उपलब्ध (ई);

-बाल प्रक्रियाओं द्वारा विरासत में प्राप्त किया जा सकता है (i)।

चूँकि हमcap_net_bind_service का उपयोग करना चाहते हैं, हमें इसे e ध्वज के साथ करने की आवश्यकता है। फिर हम कमांड में शेल शुरू करेंगे। यह क्षमताओं को बाइनरी चलाएगा और हमें इसे i ध्वज के साथ चिह्नित करने की आवश्यकता है। अंत में, हम चाहते हैं कि सुविधा को पी के साथ सक्षम किया जाए (हमने यूआईडी को बदले बिना ऐसा किया)। यह कैप_नेट_बाइंड_सर्विस+ईआईपी जैसा दिखता है।

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

# ss -tulpn -e -H | cut -d' ' -f17-
128 *:80 *:*
users:(("capabilities",pid=30040,fd=3)) uid:65534 ino:11311579 sk:2c v6only:0

इस उदाहरण में हमने कैपश का उपयोग किया है, लेकिन आप लिबकैप का उपयोग करके एक शेल लिख सकते हैं। अधिक जानकारी के लिए, मैन 3 लिबकैप देखें।

प्रोग्राम लिखते समय, अक्सर डेवलपर को उन सभी सुविधाओं के बारे में पहले से पता नहीं होता है जिनकी प्रोग्राम को रन टाइम के दौरान आवश्यकता होती है; इसके अलावा, नए संस्करणों में ये सुविधाएँ बदल सकती हैं।

अपने प्रोग्राम की क्षमताओं को बेहतर ढंग से समझने के लिए, हम BCC सक्षम टूल ले सकते हैं, जो कैप_कैपेबल कर्नेल फ़ंक्शन के लिए kprobe सेट करता है:

/usr/share/bcc/tools/capable
TIME      UID  PID   TID   COMM               CAP    NAME           AUDIT
10:12:53 0 424     424     systemd-udevd 12 CAP_NET_ADMIN         1
10:12:57 0 1103   1101   timesync        25 CAP_SYS_TIME         1
10:12:57 0 19545 19545 capabilities       10 CAP_NET_BIND_SERVICE 1

हम कैप_कैपेबल कर्नेल फ़ंक्शन में एक-लाइनर kprobe के साथ bpftrace का उपयोग करके एक ही चीज़ प्राप्त कर सकते हैं:

bpftrace -e 
   'kprobe:cap_capable {
      time("%H:%M:%S ");
      printf("%-6d %-6d %-16s %-4d %dn", uid, pid, comm, arg2, arg3);
    }' 
    | grep -i capabilities

यदि हमारे प्रोग्राम की क्षमताएं kprobe के बाद सक्षम हैं तो यह कुछ इस तरह आउटपुट करेगा:

12:01:56 1000 13524 capabilities 21 0
12:01:56 1000 13524 capabilities 21 0
12:01:56 1000 13524 capabilities 21 0
12:01:56 1000 13524 capabilities 12 0
12:01:56 1000 13524 capabilities 12 0
12:01:56 1000 13524 capabilities 12 0
12:01:56 1000 13524 capabilities 12 0
12:01:56 1000 13524 capabilities 10 1

पाँचवाँ कॉलम वह क्षमताएँ हैं जिनकी प्रक्रिया को आवश्यकता है, और चूँकि इस आउटपुट में गैर-ऑडिट घटनाएँ शामिल हैं, हम सभी गैर-ऑडिट जाँचें देखते हैं और अंत में ऑडिट फ़्लैग (आउटपुट में अंतिम) के साथ आवश्यक क्षमता 1 पर सेट करते हैं। क्षमता। हमारी रुचि CAP_NET_BIND_SERVICE में है, इसे पहचानकर्ता 10 के साथ include/uapi/linux/ability.h फ़ाइल में कर्नेल स्रोत कोड में एक स्थिरांक के रूप में परिभाषित किया गया है:

/* Allows binding to TCP/UDP sockets below 1024 */
/* Allows binding to ATM VCIs below 32 */
#define CAP_NET_BIND_SERVICE 10<source lang="go">

रनसी या डॉकर जैसे कंटेनरों के लिए क्षमताओं को अक्सर रनटाइम पर सक्षम किया जाता है ताकि उन्हें विशेषाधिकार प्राप्त मोड में चलाने की अनुमति मिल सके, लेकिन उन्हें केवल अधिकांश अनुप्रयोगों को चलाने के लिए आवश्यक क्षमताओं की अनुमति दी जाती है। जब किसी एप्लिकेशन को कुछ क्षमताओं की आवश्यकता होती है, तो डॉकर उन्हें --cap-add का उपयोग करके प्रदान कर सकता है:

docker run -it --rm --cap-add=NET_ADMIN ubuntu ip link add dummy0 type dummy

यह कमांड कंटेनर को CAP_NET_ADMIN क्षमता देगा, जिससे वह डमी0 इंटरफ़ेस जोड़ने के लिए एक नेटवर्क लिंक कॉन्फ़िगर कर सकेगा।

अगला अनुभाग दिखाता है कि फ़िल्टरिंग जैसी सुविधाओं का उपयोग कैसे करें, लेकिन एक अलग तकनीक का उपयोग करके जो हमें अपने स्वयं के फ़िल्टर को प्रोग्रामेटिक रूप से कार्यान्वित करने की अनुमति देती है।

Seccomp

Seccomp का मतलब सिक्योर कंप्यूटिंग है और यह लिनक्स कर्नेल में लागू एक सुरक्षा परत है जो डेवलपर्स को कुछ सिस्टम कॉल को फ़िल्टर करने की अनुमति देता है। हालाँकि Seccomp क्षमताओं में Linux से तुलनीय है, लेकिन कुछ सिस्टम कॉलों को प्रबंधित करने की इसकी क्षमता इसे उनकी तुलना में अधिक लचीला बनाती है।

Seccomp और Linux सुविधाएँ परस्पर अनन्य नहीं हैं और अक्सर दोनों दृष्टिकोणों से लाभ उठाने के लिए एक साथ उपयोग की जाती हैं। उदाहरण के लिए, हो सकता है कि आप किसी प्रक्रिया को CAP_NET_ADMIN क्षमता देना चाहें, लेकिन उसे सॉकेट कनेक्शन स्वीकार करने की अनुमति न दें, स्वीकार और स्वीकार4 सिस्टम कॉल को अवरुद्ध कर दें।

Seccomp फ़िल्टरिंग विधि SECCOMP_MODE_FILTER मोड में काम करने वाले BPF फ़िल्टर पर आधारित है, और सिस्टम कॉल फ़िल्टरिंग पैकेट के समान ही किया जाता है।

PR_SET_SECCOMP ऑपरेशन के माध्यम से prctl का उपयोग करके Seccomp फ़िल्टर लोड किए जाते हैं। ये फ़िल्टर एक BPF प्रोग्राम का रूप लेते हैं जो seccomp_data संरचना द्वारा दर्शाए गए प्रत्येक Seccomp पैकेट के लिए निष्पादित होता है। इस संरचना में संदर्भ आर्किटेक्चर, सिस्टम कॉल के समय प्रोसेसर निर्देशों के लिए एक संकेतक और अधिकतम छह सिस्टम कॉल तर्क शामिल हैं, जिन्हें uint64 के रूप में व्यक्त किया गया है।

linux/seccomp.h फ़ाइल में कर्नेल स्रोत कोड से seccomp_data संरचना इस तरह दिखती है:

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

जैसा कि आप इस संरचना से देख सकते हैं, हम सिस्टम कॉल, उसके तर्कों या दोनों के संयोजन द्वारा फ़िल्टर कर सकते हैं।

प्रत्येक Seccomp पैकेट प्राप्त करने के बाद, फ़िल्टर को अंतिम निर्णय लेने के लिए प्रसंस्करण करना होगा और कर्नेल को बताना होगा कि आगे क्या करना है। अंतिम निर्णय रिटर्न मानों (स्थिति कोड) में से एक द्वारा व्यक्त किया जाता है।

- SECCOMP_RET_KILL_PROCESS - सिस्टम कॉल को फ़िल्टर करने के तुरंत बाद पूरी प्रक्रिया को समाप्त कर देता है जो इसके कारण निष्पादित नहीं होती है।

- SECCOMP_RET_KILL_THREAD - सिस्टम कॉल को फ़िल्टर करने के तुरंत बाद वर्तमान थ्रेड को समाप्त कर देता है जो इसके कारण निष्पादित नहीं होता है।

— SECCOMP_RET_KILL — SECCOMP_RET_KILL_THREAD के लिए उपनाम, पश्चगामी संगतता के लिए छोड़ा गया।

- SECCOMP_RET_TRAP - सिस्टम कॉल निषिद्ध है, और SIGSYS (खराब सिस्टम कॉल) सिग्नल उस कार्य को भेजा जाता है जो इसे कॉल करता है।

- SECCOMP_RET_ERRNO - सिस्टम कॉल निष्पादित नहीं होती है, और SECCOMP_RET_DATA फ़िल्टर रिटर्न वैल्यू का हिस्सा इरनो वैल्यू के रूप में यूजर स्पेस में भेज दिया जाता है। त्रुटि के कारण के आधार पर, अलग-अलग त्रुटिपूर्ण मान लौटाए जाते हैं। अगले भाग में त्रुटि संख्याओं की एक सूची प्रदान की गई है।

- SECCOMP_RET_TRACE - उस प्रक्रिया को देखने और नियंत्रित करने के लिए सिस्टम कॉल निष्पादित होने पर इंटरसेप्ट करने के लिए - PTRACE_O_TRACESECCOMP का उपयोग करके ptrace ट्रेसर को सूचित करने के लिए उपयोग किया जाता है। यदि कोई ट्रैसर कनेक्ट नहीं है, तो एक त्रुटि वापस आती है, इरनो को -ENOSYS पर सेट किया जाता है, और सिस्टम कॉल निष्पादित नहीं होती है।

- SECCOMP_RET_LOG - सिस्टम कॉल का समाधान और लॉग किया गया है।

- SECCOMP_RET_ALLOW - सिस्टम कॉल की अनुमति है।

ptrace ट्रेसी नामक प्रक्रिया में ट्रेसिंग तंत्र को लागू करने के लिए एक सिस्टम कॉल है, जिसमें प्रक्रिया के निष्पादन की निगरानी और नियंत्रण करने की क्षमता होती है। ट्रेस प्रोग्राम निष्पादन को प्रभावी ढंग से प्रभावित कर सकता है और ट्रेसी के मेमोरी रजिस्टर को संशोधित कर सकता है। Seccomp संदर्भ में, SECCOMP_RET_TRACE स्थिति कोड द्वारा ट्रिगर होने पर ptrace का उपयोग किया जाता है, इसलिए ट्रेसर सिस्टम कॉल को निष्पादित होने से रोक सकता है और अपने स्वयं के तर्क को लागू कर सकता है।

Seccomp त्रुटियाँ

समय-समय पर, Seccomp के साथ काम करते समय, आपको विभिन्न त्रुटियों का सामना करना पड़ेगा, जिन्हें SECCOMP_RET_ERRNO प्रकार के रिटर्न मान द्वारा पहचाना जाता है। किसी त्रुटि की रिपोर्ट करने के लिए, seccomp सिस्टम कॉल 1 के बजाय -0 लौटाएगा।

निम्नलिखित त्रुटियाँ संभव हैं:

- आसान - कॉल करने वाले को सिस्टम कॉल करने की अनुमति नहीं है। ऐसा आमतौर पर होता है क्योंकि इसमें CAP_SYS_ADMIN विशेषाधिकार नहीं होते हैं या prctl का उपयोग करके no_new_privs सेट नहीं किया जाता है (हम इस बारे में बाद में बात करेंगे);

- EFAULT - पारित तर्क (seccomp_data संरचना में तर्क) का कोई वैध पता नहीं है;

— EINVAL — यहाँ चार कारण हो सकते हैं:

-अनुरोधित ऑपरेशन अज्ञात है या वर्तमान कॉन्फ़िगरेशन में कर्नेल द्वारा समर्थित नहीं है;

-निर्दिष्ट झंडे अनुरोधित कार्रवाई के लिए मान्य नहीं हैं;

-ऑपरेशन में BPF_ABS शामिल है, लेकिन निर्दिष्ट ऑफसेट के साथ समस्याएं हैं, जो seccomp_data संरचना के आकार से अधिक हो सकती हैं;

-फ़िल्टर को पारित निर्देशों की संख्या अधिकतम से अधिक है;

— ENOMEM — प्रोग्राम को निष्पादित करने के लिए पर्याप्त मेमोरी नहीं;

- EOPNOTSUPP - ऑपरेशन ने संकेत दिया कि SECCOMP_GET_ACTION_AVAIL के साथ कार्रवाई उपलब्ध थी, लेकिन कर्नेल तर्कों में रिटर्न का समर्थन नहीं करता है;

— ESRCH — किसी अन्य स्ट्रीम को सिंक्रनाइज़ करते समय एक समस्या उत्पन्न हुई;

- ENOSYS - SECCOMP_RET_TRACE कार्रवाई से कोई ट्रेसर संलग्न नहीं है।

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

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

बीपीएफ सेकॉम्प फ़िल्टर उदाहरण

यहां हम दिखाएंगे कि पहले चर्चा की गई दो क्रियाओं को कैसे संयोजित किया जाए, अर्थात्:

- हम एक Seccomp BPF प्रोग्राम लिखेंगे, जिसका उपयोग किए गए निर्णयों के आधार पर विभिन्न रिटर्न कोड वाले फ़िल्टर के रूप में किया जाएगा;

- prctl का उपयोग करके फ़िल्टर लोड करें।

सबसे पहले आपको मानक लाइब्रेरी और लिनक्स कर्नेल से हेडर की आवश्यकता होगी:

#include <errno.h>
#include <linux/audit.h>
#include <linux/bpf.h>
#include <linux/filter.h>
#include <linux/seccomp.h>
#include <linux/unistd.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/prctl.h>
#include <unistd.h>

इस उदाहरण को आज़माने से पहले, हमें यह सुनिश्चित करना होगा कि कर्नेल CONFIG_SECCOMP और CONFIG_SECCOMP_FILTER को y पर सेट करके संकलित किया गया है। किसी कार्यशील मशीन पर आप इसे इस प्रकार जांच सकते हैं:

cat /proc/config.gz| zcat | grep -i CONFIG_SECCOMP

शेष कोड दो-भाग वाला install_filter फ़ंक्शन है। पहले भाग में बीपीएफ फ़िल्टरिंग निर्देशों की हमारी सूची शामिल है:

static int install_filter(int nr, int arch, int error) {
  struct sock_filter filter[] = {
    BPF_STMT(BPF_LD + BPF_W + BPF_ABS, (offsetof(struct seccomp_data, arch))),
    BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, arch, 0, 3),
    BPF_STMT(BPF_LD + BPF_W + BPF_ABS, (offsetof(struct seccomp_data, nr))),
    BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, nr, 0, 1),
    BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ERRNO | (error & SECCOMP_RET_DATA)),
    BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ALLOW),
  };

निर्देश linux/filter.h फ़ाइल में परिभाषित BPF_STMT और BPF_JUMP मैक्रोज़ का उपयोग करके सेट किए गए हैं।
आइए निर्देशों पर गौर करें।

- BPF_STMT(BPF_LD + BPF_W + BPF_ABS (offsetof(struct seccomp_data, arc))) - सिस्टम BPF_LD से BPF_W शब्द के रूप में लोड और जमा होता है, पैकेट डेटा एक निश्चित ऑफसेट BPF_ABS पर स्थित होता है।

- BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, आर्क, 0, 3) - BPF_JEQ का उपयोग करके जांच करता है कि BPF_K संचायक स्थिरांक में आर्किटेक्चर मान आर्क के बराबर है या नहीं। यदि ऐसा है, तो ऑफसेट 0 पर अगले निर्देश पर कूदता है, अन्यथा ऑफसेट 3 पर कूदता है (इस मामले में) एक त्रुटि उत्पन्न करता है क्योंकि आर्क मेल नहीं खाता है।

- BPF_STMT(BPF_LD + BPF_W + BPF_ABS (offsetof(struct seccomp_data, nr))) - BPF_LD से BPF_W शब्द के रूप में लोड और जमा होता है, जो BPF_ABS के निश्चित ऑफसेट में निहित सिस्टम कॉल नंबर है।

- BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, nr, 0, 1) - सिस्टम कॉल नंबर की तुलना nr वेरिएबल के मान से करता है। यदि वे समान हैं, तो अगले निर्देश पर आगे बढ़ता है और सिस्टम कॉल को अक्षम कर देता है, अन्यथा SECCOMP_RET_ALLOW के साथ सिस्टम कॉल की अनुमति देता है।

- BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ERRNO | (त्रुटि और SECCOMP_RET_DATA)) - BPF_RET के साथ प्रोग्राम को समाप्त करता है और परिणामस्वरूप त्रुटि चर से संख्या के साथ एक त्रुटि SECCOMP_RET_ERRNO उत्पन्न होती है।

- BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ALLOW) - BPF_RET के साथ प्रोग्राम को समाप्त करता है और SECCOMP_RET_ALLOW का उपयोग करके सिस्टम कॉल को निष्पादित करने की अनुमति देता है।

SECCOMP सीबीपीएफ है
आप सोच रहे होंगे कि संकलित ईएलएफ ऑब्जेक्ट या जेआईटी संकलित सी प्रोग्राम के बजाय निर्देशों की सूची का उपयोग क्यों किया जाता है।

इसके लिए दो कारण हैं।

• सबसे पहले, Seccomp cBPF (क्लासिक BPF) का उपयोग करता है न कि eBPF का, जिसका अर्थ है: इसमें कोई रजिस्टर नहीं है, बल्कि अंतिम गणना परिणाम को संग्रहीत करने के लिए केवल एक संचायक है, जैसा कि उदाहरण में देखा जा सकता है।

• दूसरा, Seccomp सीधे BPF निर्देशों की एक श्रृंखला के लिए एक सूचक स्वीकार करता है और कुछ नहीं। हमारे द्वारा उपयोग किए गए मैक्रोज़ इन निर्देशों को प्रोग्रामर-अनुकूल तरीके से निर्दिष्ट करने में सहायता करते हैं।

यदि आपको इस असेंबली को समझने में अधिक सहायता की आवश्यकता है, तो छद्म कोड पर विचार करें जो समान कार्य करता है:

if (arch != AUDIT_ARCH_X86_64) {
    return SECCOMP_RET_ALLOW;
}
if (nr == __NR_write) {
    return SECCOMP_RET_ERRNO;
}
return SECCOMP_RET_ALLOW;

सॉकेट_फ़िल्टर संरचना में फ़िल्टर कोड को परिभाषित करने के बाद, आपको एक sock_fprog को परिभाषित करने की आवश्यकता है जिसमें कोड और फ़िल्टर की गणना की गई लंबाई हो। प्रक्रिया को बाद में चलाने की घोषणा करने के लिए एक तर्क के रूप में इस डेटा संरचना की आवश्यकता है:

struct sock_fprog prog = {
   .len = (unsigned short)(sizeof(filter) / sizeof(filter[0])),
   .filter = filter,
};

install_filter फ़ंक्शन में करने के लिए केवल एक ही काम बचा है - प्रोग्राम को स्वयं लोड करें! ऐसा करने के लिए, हम सुरक्षित कंप्यूटिंग मोड में प्रवेश करने के विकल्प के रूप में PR_SET_SECCOMP को लेते हुए, prctl का उपयोग करते हैं। फिर हम मोड को SECCOMP_MODE_FILTER का उपयोग करके फ़िल्टर लोड करने के लिए कहते हैं, जो कि sock_fprog प्रकार के प्रोग वेरिएबल में निहित है:

  if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog)) {
    perror("prctl(PR_SET_SECCOMP)");
    return 1;
  }
  return 0;
}

अंत में, हम अपने install_filter फ़ंक्शन का उपयोग कर सकते हैं, लेकिन इससे पहले हमें वर्तमान निष्पादन के लिए PR_SET_NO_NEW_PRIVS सेट करने के लिए prctl का उपयोग करने की आवश्यकता है और इस तरह उस स्थिति से बचें जहां बाल प्रक्रियाओं को उनके माता-पिता की तुलना में अधिक विशेषाधिकार प्राप्त होते हैं। इसके साथ, हम रूट अधिकारों के बिना install_filter फ़ंक्शन में निम्नलिखित prctl कॉल कर सकते हैं।

अब हम install_filter फ़ंक्शन को कॉल कर सकते हैं। आइए X86-64 आर्किटेक्चर से संबंधित सभी राइट सिस्टम कॉल को ब्लॉक करें और बस एक अनुमति दें जो सभी प्रयासों को ब्लॉक कर दे। फ़िल्टर स्थापित करने के बाद, हम पहले तर्क का उपयोग करके निष्पादन जारी रखते हैं:

int main(int argc, char const *argv[]) {
  if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) {
   perror("prctl(NO_NEW_PRIVS)");
   return 1;
  }
   install_filter(__NR_write, AUDIT_ARCH_X86_64, EPERM);
  return system(argv[1]);
 }

आएँ शुरू करें। अपने प्रोग्राम को संकलित करने के लिए हम या तो clang या gcc का उपयोग कर सकते हैं, किसी भी तरह से यह विशेष विकल्पों के बिना केवल main.c फ़ाइल को संकलित कर रहा है:

clang main.c -o filter-write

जैसा कि उल्लेख किया गया है, हमने कार्यक्रम में सभी प्रविष्टियों को अवरुद्ध कर दिया है। इसका परीक्षण करने के लिए आपको एक ऐसे प्रोग्राम की आवश्यकता है जो कुछ आउटपुट दे - ls एक अच्छा उम्मीदवार प्रतीत होता है। वह आमतौर पर इस तरह व्यवहार करती है:

ls -la
total 36
drwxr-xr-x 2 fntlnz users 4096 Apr 28 21:09 .
drwxr-xr-x 4 fntlnz users 4096 Apr 26 13:01 ..
-rwxr-xr-x 1 fntlnz users 16800 Apr 28 21:09 filter-write
-rw-r--r-- 1 fntlnz users 19 Apr 28 21:09 .gitignore
-rw-r--r-- 1 fntlnz users 1282 Apr 28 21:08 main.c

आश्चर्यजनक! यहां बताया गया है कि हमारे रैपर प्रोग्राम का उपयोग करना कैसा दिखता है: हम बस उस प्रोग्राम को पास करते हैं जिसे हम पहले तर्क के रूप में परीक्षण करना चाहते हैं:

./filter-write "ls -la"

निष्पादित होने पर, यह प्रोग्राम पूरी तरह से खाली आउटपुट उत्पन्न करता है। हालाँकि, क्या हो रहा है यह देखने के लिए हम स्ट्रेस का उपयोग कर सकते हैं:

strace -f ./filter-write "ls -la"

कार्य का परिणाम बहुत छोटा कर दिया गया है, लेकिन इसका संबंधित भाग दिखाता है कि रिकॉर्ड EPERM त्रुटि के साथ अवरुद्ध हैं - वही जो हमने कॉन्फ़िगर किया था। इसका मतलब यह है कि प्रोग्राम कुछ भी आउटपुट नहीं करता है क्योंकि यह राइट सिस्टम कॉल तक नहीं पहुंच सकता है:

[pid 25099] write(2, "ls: ", 4) = -1 EPERM (Operation not permitted)
[pid 25099] write(2, "write error", 11) = -1 EPERM (Operation not permitted)
[pid 25099] write(2, "n", 1) = -1 EPERM (Operation not permitted)

अब आप समझ गए हैं कि Seccomp BPF कैसे काम करता है और आपको अच्छी तरह पता है कि आप इसके साथ क्या कर सकते हैं। लेकिन क्या आप इसकी पूरी शक्ति का उपयोग करने के लिए सीबीपीएफ के बजाय ईबीपीएफ के साथ भी यही हासिल नहीं करना चाहेंगे?

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

बीपीएफ एलएसएम जाल

सिस्टम घटनाओं की वास्तुकला-स्वतंत्र निगरानी प्रदान करने के लिए, एलएसएम जाल की अवधारणा को लागू करता है। हुक कॉल तकनीकी रूप से सिस्टम कॉल के समान है, लेकिन सिस्टम स्वतंत्र है और बुनियादी ढांचे के साथ एकीकृत है। एलएसएम एक नई अवधारणा प्रदान करता है जिसमें एक अमूर्त परत विभिन्न आर्किटेक्चर पर सिस्टम कॉल से निपटने के दौरान आने वाली समस्याओं से बचने में मदद कर सकती है।

लेखन के समय, कर्नेल में BPF प्रोग्राम से जुड़े सात हुक हैं, और SELinux एकमात्र अंतर्निहित LSM है जो उन्हें कार्यान्वित करता है।

ट्रैप्स के लिए स्रोत कोड include/linux/security.h फ़ाइल में कर्नेल ट्री में स्थित है:

extern int security_bpf(int cmd, union bpf_attr *attr, unsigned int size);
extern int security_bpf_map(struct bpf_map *map, fmode_t fmode);
extern int security_bpf_prog(struct bpf_prog *prog);
extern int security_bpf_map_alloc(struct bpf_map *map);
extern void security_bpf_map_free(struct bpf_map *map);
extern int security_bpf_prog_alloc(struct bpf_prog_aux *aux);
extern void security_bpf_prog_free(struct bpf_prog_aux *aux);

उनमें से प्रत्येक को निष्पादन के विभिन्न चरणों में बुलाया जाएगा:

- सुरक्षा_बीपीएफ - निष्पादित बीपीएफ सिस्टम कॉल की प्रारंभिक जांच करता है;

- सुरक्षा_बीपीएफ_मैप - जांचता है कि कर्नेल मानचित्र के लिए फ़ाइल डिस्क्रिप्टर कब लौटाता है;

- Security_bpf_prog - जाँचता है कि कर्नेल eBPF प्रोग्राम के लिए फ़ाइल डिस्क्रिप्टर कब लौटाता है;

- सुरक्षा_बीपीएफ_मैप_आलोक - जांचता है कि बीपीएफ मानचित्रों के अंदर सुरक्षा क्षेत्र प्रारंभ किया गया है या नहीं;

- सुरक्षा_बीपीएफ_मैप_फ्री - जांचता है कि बीपीएफ मानचित्रों के अंदर सुरक्षा क्षेत्र साफ हो गया है या नहीं;

— Security_bpf_prog_alloc — जाँचता है कि BPF प्रोग्राम के अंदर सुरक्षा फ़ील्ड प्रारंभ की गई है या नहीं;

- Security_bpf_prog_free - जाँचता है कि BPF प्रोग्राम के अंदर सुरक्षा फ़ील्ड साफ़ हो गई है या नहीं।

अब, यह सब देखकर, हम समझते हैं: एलएसएम बीपीएफ इंटरसेप्टर के पीछे का विचार यह है कि वे प्रत्येक ईबीपीएफ ऑब्जेक्ट को सुरक्षा प्रदान कर सकते हैं, यह सुनिश्चित करते हुए कि केवल उचित विशेषाधिकार वाले लोग ही कार्ड और प्रोग्राम पर संचालन कर सकते हैं।

सारांश

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

लेखकों के बारे में

डेविड कैलावेरा Netlify पर CTO हैं। उन्होंने डॉकर सपोर्ट में काम किया और रनक, गो और बीसीसी टूल्स के साथ-साथ अन्य ओपन सोर्स प्रोजेक्ट्स के विकास में योगदान दिया। डॉकर परियोजनाओं और डॉकर प्लगइन पारिस्थितिकी तंत्र के विकास पर उनके काम के लिए जाना जाता है। डेविड को फ्लेम ग्राफ़ का बहुत शौक है और वह हमेशा प्रदर्शन को अनुकूलित करने की कोशिश में रहता है।

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

»पुस्तक के बारे में अधिक विवरण यहां पाया जा सकता है प्रकाशक की वेबसाइट
» लेख-सूची
» अंश

खाब्रोझिटेले के लिए कूपन का उपयोग करके 25% की छूट - Linux

पुस्तक के कागजी संस्करण का भुगतान करने पर, एक इलेक्ट्रॉनिक पुस्तक ई-मेल द्वारा भेजी जाएगी।

स्रोत: www.habr.com