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

हॅलो, खबरो रहिवासी! बीपीएफ व्हर्च्युअल मशीन लिनक्स कर्नलमधील सर्वात महत्त्वाच्या घटकांपैकी एक आहे. त्याचा योग्य वापर सिस्टम अभियंत्यांना दोष शोधण्यास आणि अगदी जटिल समस्या सोडविण्यास अनुमती देईल. कर्नलच्या वर्तनाचे परीक्षण आणि सुधारणा करणारे प्रोग्राम कसे लिहायचे, कर्नलमधील इव्हेंट्सचे निरीक्षण करण्यासाठी कोड सुरक्षितपणे कसा लागू करायचा आणि बरेच काही आपण शिकू शकाल. David Calavera आणि Lorenzo Fontana तुम्हाला BPF ची शक्ती अनलॉक करण्यात मदत करतील. कार्यप्रदर्शन ऑप्टिमायझेशन, नेटवर्किंग, सुरक्षितता याविषयी तुमचे ज्ञान वाढवा. - लिनक्स कर्नलच्या वर्तनाचे परीक्षण आणि सुधारणा करण्यासाठी BPF वापरा. - कर्नल रीकंपाइल किंवा सिस्टम रीबूट न ​​करता कर्नल इव्हेंट्सचे सुरक्षितपणे निरीक्षण करण्यासाठी कोड इंजेक्ट करा. — C, Go किंवा Python मध्ये सोयीस्कर कोड उदाहरणे वापरा. - BPF प्रोग्राम लाइफसायकलचे मालक करून नियंत्रण मिळवा.

लिनक्स कर्नल सुरक्षा, त्याची वैशिष्ट्ये आणि Seccomp

BPF स्थिरता, सुरक्षितता किंवा गतीचा त्याग न करता कर्नल वाढवण्याचा एक शक्तिशाली मार्ग प्रदान करते. या कारणास्तव, कर्नल डेव्हलपर्सना वाटले की BPF प्रोग्रामद्वारे समर्थित Seccomp फिल्टर लागू करून Seccomp मध्ये प्रक्रिया अलगाव सुधारण्यासाठी त्याची अष्टपैलुत्व वापरणे चांगली कल्पना आहे, ज्याला Seccomp BPF म्हणूनही ओळखले जाते. या धड्यात आपण Seccomp म्हणजे काय आणि ते कसे वापरले जाते हे सांगू. मग तुम्ही BPF प्रोग्राम वापरून Seccomp फिल्टर कसे लिहायचे ते शिकाल. त्यानंतर, आम्ही लिनक्स सिक्युरिटी मॉड्यूल्ससाठी कर्नलमध्ये अंतर्भूत असलेले बिल्ट-इन बीपीएफ हुक पाहू.

लिनक्स सिक्युरिटी मॉड्युल्स (LSM) हे एक फ्रेमवर्क आहे जे फंक्शन्सचा एक संच प्रदान करते ज्याचा वापर विविध सुरक्षा मॉडेल्स प्रमाणित पद्धतीने अंमलात आणण्यासाठी केला जाऊ शकतो. LSM थेट कर्नल सोर्स ट्रीमध्ये वापरले जाऊ शकते, जसे की Apparmor, SELinux आणि Tomoyo.

चला लिनक्सच्या क्षमतांवर चर्चा करून सुरुवात करूया.

वैशिष्ट्ये

Linux च्या क्षमतांचे सार हे आहे की तुम्हाला विशिष्ट कार्य करण्यासाठी एक विशेषाधिकार नसलेली प्रक्रिया परवानगी देणे आवश्यक आहे, परंतु त्या हेतूसाठी 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 (शेल व्यवस्थापक) हे एक साधन आहे जे क्षमतांच्या विशिष्ट संचासह शेल चालवते.

या प्रकरणात, आधीच नमूद केल्याप्रमाणे, संपूर्ण रूट अधिकार देण्याऐवजी, तुम्ही प्रोग्राममध्ये आधीपासून असलेल्या इतर सर्व गोष्टींसह cap_net_bind_service क्षमता प्रदान करून विशेषाधिकारित पोर्ट बाइंडिंग सक्षम करू शकता. हे करण्यासाठी, आम्ही आमचा प्रोग्राम कॅपशमध्ये संलग्न करू शकतो:

# 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"

या संघाला थोडे समजून घेऊ.

• capsh - एक शेल म्हणून capsh वापरा.
• —caps='cap_net_bind_service+eip cap_setpcap,cap_setuid,cap_setgid+ep' - आम्हाला वापरकर्ता बदलण्याची आवश्यकता असल्याने (आम्हाला रूट म्हणून चालवायचे नाही), आम्ही cap_net_bind_service आणि प्रत्यक्षात वापरकर्ता आयडी बदलण्याची क्षमता निर्दिष्ट करू. root to nobody, म्हणजे cap_setuid आणि cap_setgid.
• —keep=1 — रूट खात्यातून स्विच करताना आम्हाला स्थापित क्षमता ठेवायची आहे.
• —user=“कोणीही नाही” — प्रोग्राम चालवणारा अंतिम वापरकर्ता कोणीही नसेल.
• —addamb=cap_net_bind_service — रूट मोडवरून स्विच केल्यानंतर संबंधित क्षमतांचे क्लिअरिंग सेट करा.
• - -c "./capabilities" - फक्त प्रोग्राम चालवा.

लिंक्ड क्षमता ही एक विशेष प्रकारची क्षमता आहे ज्या चाइल्ड प्रोग्राम्सद्वारे वारशाने मिळतात जेव्हा वर्तमान प्रोग्राम त्यांना execve() वापरून कार्यान्वित करतो. केवळ क्षमता ज्यांना संबद्ध करण्याची परवानगी आहे, किंवा दुसऱ्या शब्दांत, पर्यावरण क्षमता म्हणून, वारशाने मिळू शकते.

--caps पर्यायामध्ये क्षमता निर्दिष्ट केल्यानंतर +eip चा अर्थ काय असा तुम्ही विचार करत असाल. हे ध्वज क्षमता निर्धारित करण्यासाठी वापरले जातात:

-सक्रिय करणे आवश्यक आहे (p);

- वापरासाठी उपलब्ध (ई);

-बाल प्रक्रियांद्वारे वारसा मिळू शकतो (i).

आम्हाला cap_net_bind_service वापरायची असल्याने, आम्हाला हे ई ध्वजाने करावे लागेल. मग आपण कमांडमध्ये शेल सुरू करू. हे क्षमता बायनरी चालवेल आणि आम्हाला ते i ध्वजाने चिन्हांकित करणे आवश्यक आहे. शेवटी, आम्हाला p सह वैशिष्ट्य सक्षम करायचे आहे (आम्ही हे UID न बदलता केले आहे). हे cap_net_bind_service+eip सारखे दिसते.

तुम्ही ss वापरून निकाल तपासू शकता. पृष्ठावर बसण्यासाठी आउटपुट थोडे लहान करू, परंतु ते 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

या उदाहरणात आम्ही कॅपश वापरले, परंतु तुम्ही लिबकॅप वापरून शेल लिहू शकता. अधिक माहितीसाठी, man 3 libcap पहा.

प्रोग्राम लिहिताना, बरेचदा विकासकाला प्रोग्रामला रन टाइममध्ये आवश्यक असलेल्या सर्व वैशिष्ट्यांची आगाऊ माहिती नसते; शिवाय, ही वैशिष्ट्ये नवीन आवृत्त्यांमध्ये बदलू शकतात.

आमच्या प्रोग्रामच्या क्षमता चांगल्या प्रकारे समजून घेण्यासाठी, आम्ही BCC सक्षम टूल घेऊ शकतो, जे cap_capable कर्नल फंक्शनसाठी 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

cap_capable कर्नल फंक्शनमध्ये वन-लाइनर 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 म्हणजे सुरक्षित संगणन आणि Linux कर्नलमध्ये लागू केलेला एक सुरक्षा स्तर आहे जो विकासकांना विशिष्ट सिस्टम कॉल फिल्टर करण्यास अनुमती देतो. Seccomp क्षमतांमध्ये लिनक्सशी तुलना करता येत असली तरी, विशिष्ट सिस्टम कॉल व्यवस्थापित करण्याची त्याची क्षमता त्यांच्या तुलनेत ते अधिक लवचिक बनवते.

Seccomp आणि Linux वैशिष्ट्ये परस्पर अनन्य नाहीत आणि दोन्ही पद्धतींचा फायदा घेण्यासाठी अनेकदा एकत्र वापरले जातात. उदाहरणार्थ, तुम्ही एखाद्या प्रक्रियेला CAP_NET_ADMIN क्षमता देऊ इच्छित असाल परंतु त्यास सॉकेट कनेक्शन स्वीकारण्याची परवानगी देऊ नका, स्वीकार आणि स्वीकारा4 सिस्टम कॉल अवरोधित करा.

Seccomp फिल्टरिंग पद्धत SECOMP_MODE_FILTER मोडमध्ये कार्यरत असलेल्या BPF फिल्टरवर आधारित आहे आणि सिस्टम कॉल फिल्टरिंग पॅकेट्सप्रमाणेच केले जाते.

Seccomp फिल्टर्स prctl वापरून PR_SET_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 पॅकेट प्राप्त केल्यानंतर, फिल्टरने अंतिम निर्णय घेण्यासाठी प्रक्रिया करणे आवश्यक आहे आणि कर्नलला पुढे काय करायचे ते सांगणे आवश्यक आहे. अंतिम निर्णय रिटर्न व्हॅल्यूंपैकी एक (स्थिती कोड) द्वारे व्यक्त केला जातो.

- SECOMP_RET_KILL_PROCESS - सिस्टीम कॉल फिल्टर केल्यानंतर लगेच संपूर्ण प्रक्रिया नष्ट करते जी यामुळे कार्यान्वित होत नाही.

- SECOMP_RET_KILL_THREAD - सिस्टीम कॉल फिल्टर केल्यानंतर ताबडतोब चालू थ्रेड बंद करते जे यामुळे कार्यान्वित होत नाही.

— SECOMP_RET_KILL — SECOMP_RET_KILL_THREAD साठी उर्फ, बॅकवर्ड सुसंगततेसाठी बाकी.

- SECOMP_RET_TRAP - सिस्टम कॉल प्रतिबंधित आहे, आणि SIGSYS (खराब सिस्टम कॉल) सिग्नल तो कॉल करणार्‍या कार्याला पाठविला जातो.

- SECOMP_RET_ERRNO - सिस्टम कॉल कार्यान्वित होत नाही, आणि SECOMP_RET_DATA फिल्टर रिटर्न मूल्याचा भाग वापरकर्त्याच्या जागेवर त्रुटी मूल्य म्हणून पास केला जातो. त्रुटीच्या कारणावर अवलंबून, भिन्न त्रुटी मूल्ये परत केली जातात. पुढील भागात त्रुटी क्रमांकांची यादी दिली आहे.

- SECOMP_RET_TRACE - ptrace ट्रेसरला सूचित करण्यासाठी वापरला जातो - PTRACE_O_TRACESECCOMP जेव्हा सिस्टम कॉल कार्यान्वित केला जातो तेव्हा ती प्रक्रिया पाहण्यासाठी आणि नियंत्रित करण्यासाठी. ट्रेसर कनेक्ट केलेले नसल्यास, त्रुटी परत केली जाते, त्रुटी -ENOSYS वर सेट केली जाते आणि सिस्टम कॉल कार्यान्वित होत नाही.

- SECOMP_RET_LOG - सिस्टम कॉलचे निराकरण झाले आणि लॉग केले गेले.

- SECOMP_RET_ALLOW - सिस्टम कॉलला परवानगी आहे.

ptrace हा ट्रेसी नावाच्या प्रक्रियेत ट्रेसिंग यंत्रणा कार्यान्वित करण्यासाठी एक सिस्टम कॉल आहे, ज्यामध्ये प्रक्रियेच्या अंमलबजावणीचे निरीक्षण आणि नियंत्रण करण्याची क्षमता असते. ट्रेस प्रोग्राम प्रभावीपणे अंमलबजावणीवर प्रभाव टाकू शकतो आणि ट्रेसीच्या मेमरी रजिस्टरमध्ये बदल करू शकतो. Seccomp संदर्भामध्ये, SECOMP_RET_TRACE स्टेटस कोडद्वारे ट्रिगर केल्यावर ptrace चा वापर केला जातो, त्यामुळे ट्रेसर सिस्टम कॉल कार्यान्वित होण्यापासून रोखू शकतो आणि स्वतःचे तर्क लागू करू शकतो.

Seccomp त्रुटी

वेळोवेळी, Seccomp सह काम करताना, तुम्हाला विविध त्रुटी आढळतील, ज्या SECOMP_RET_ERRNO प्रकाराच्या रिटर्न व्हॅल्यूद्वारे ओळखल्या जातात. त्रुटीची तक्रार करण्यासाठी, seccomp सिस्टम कॉल 1 ऐवजी -0 परत येईल.

खालील त्रुटी शक्य आहेत:

- EACCESS - कॉलरला सिस्टम कॉल करण्याची परवानगी नाही. हे सहसा घडते कारण त्यात CAP_SYS_ADMIN विशेषाधिकार नाहीत किंवा prctl वापरून no_new_privs सेट केलेले नाही (आम्ही याबद्दल नंतर बोलू);

— EFAULT — पास झालेल्या वितर्कांना (seccomp_data संरचनेतील args) वैध पत्ता नाही;

— EINVAL — येथे चार कारणे असू शकतात:

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

- विनंती केलेल्या ऑपरेशनसाठी निर्दिष्ट ध्वज वैध नाहीत;

-ऑपरेशनमध्ये BPF_ABS समाविष्ट आहे, परंतु निर्दिष्ट ऑफसेटमध्ये समस्या आहेत, जे seccomp_data संरचनेच्या आकारापेक्षा जास्त असू शकतात;

-फिल्टरला दिलेल्या सूचनांची संख्या कमाल मर्यादा ओलांडते;

— ENOMEM — प्रोग्राम कार्यान्वित करण्यासाठी पुरेशी मेमरी नाही;

- EOPNOTSUPP - ऑपरेशनने सूचित केले की SECOMP_GET_ACTION_AVAIL सह क्रिया उपलब्ध होती, परंतु कर्नल वितर्कांमध्ये परताव्यांना समर्थन देत नाही;

— ESRCH — दुसरा प्रवाह समक्रमित करताना समस्या आली;

- ENOSYS - SECOMP_RET_TRACE क्रियेला कोणताही ट्रेसर जोडलेला नाही.

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

Seccomp तुम्हाला सँडबॉक्स तंत्रज्ञानासारखे वाटेल, परंतु तसे नाही. Seccomp ही एक उपयुक्तता आहे जी वापरकर्त्यांना सँडबॉक्स यंत्रणा विकसित करण्यास अनुमती देते. आता Seccomp सिस्टम कॉलद्वारे थेट कॉल केलेल्या फिल्टरचा वापर करून वापरकर्ता परस्परसंवाद कार्यक्रम कसे तयार केले जातात ते पाहू.

BPF 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 फंक्शन आहे. पहिल्या भागात आमच्या BPF फिल्टरिंग सूचनांची यादी आहे:

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, arch))) - सिस्टम लोड होते आणि BPF_LD वरून BPF_W शब्दाच्या रूपात जमा होते, पॅकेट डेटा निश्चित ऑफसेट BPF_ABS वर स्थित असतो.

- BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, arch, 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 व्हेरिएबलच्या मूल्याशी तुलना करते. जर ते समान असतील, तर पुढील सूचनांकडे जातात आणि सिस्टम कॉल अक्षम करते, अन्यथा SECOMP_RET_ALLOW सह सिस्टम कॉलला अनुमती देते.

- BPF_STMT(BPF_RET + BPF_K, SECOMP_RET_ERRNO | (त्रुटी आणि SECCOMP_RET_DATA)) - BPF_RET सह प्रोग्राम समाप्त करते आणि परिणामी एरर व्हेरिएबलमधील क्रमांकासह SECOMP_RET_ERRNO त्रुटी निर्माण करते.

- BPF_STMT(BPF_RET + BPF_K, SECOMP_RET_ALLOW) - BPF_RET सह प्रोग्राम समाप्त करते आणि SECCOMP_RET_ALLOW वापरून सिस्टम कॉल कार्यान्वित करण्यास अनुमती देते.

SECOMP म्हणजे CBPF
संकलित ELF ऑब्जेक्ट किंवा JIT संकलित C प्रोग्राम ऐवजी सूचनांची सूची का वापरली जाते असा प्रश्न तुम्हाला पडला असेल.

याची दोन कारणे आहेत.

• सर्वप्रथम, 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;

सॉकेट_फिल्टर स्ट्रक्चरमध्ये फिल्टर कोड परिभाषित केल्यानंतर, तुम्हाला कोड आणि फिल्टरची गणना केलेली लांबी असलेला सॉक_एफप्रोग परिभाषित करणे आवश्यक आहे. या डेटा स्ट्रक्चरची प्रक्रिया नंतर चालवण्याची घोषणा करण्यासाठी युक्तिवाद म्हणून आवश्यक आहे:

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

install_filter फंक्शनमध्ये फक्त एक गोष्ट बाकी आहे - प्रोग्राम स्वतः लोड करा! हे करण्यासाठी, आम्ही prctl वापरतो, सुरक्षित संगणकीय मोडमध्ये प्रवेश करण्यासाठी PR_SET_SECCOMP हा पर्याय म्हणून घेतो. मग आम्ही मोडला SECOMP_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 कसे कार्य करते हे समजले आहे आणि तुम्ही त्याद्वारे काय करू शकता याची चांगली कल्पना आहे. पण तुम्हाला cBPF ऐवजी eBPF ची पूर्ण शक्ती वापरून तेच साध्य करायला आवडणार नाही का?

eBPF प्रोग्राम्सबद्दल विचार करताना, बहुतेक लोक विचार करतात की ते फक्त ते लिहितात आणि प्रशासक विशेषाधिकारांसह लोड करतात. हे विधान सर्वसाधारणपणे खरे असले तरी, कर्नल विविध स्तरांवर eBPF वस्तूंचे संरक्षण करण्यासाठी यंत्रणांचा संच लागू करते. या यंत्रणांना BPF LSM सापळे म्हणतात.

BPF LSM सापळे

सिस्टम इव्हेंटचे आर्किटेक्चर-स्वतंत्र निरीक्षण प्रदान करण्यासाठी, LSM सापळ्याची संकल्पना लागू करते. एक हुक कॉल तांत्रिकदृष्ट्या सिस्टम कॉल सारखाच असतो, परंतु सिस्टम स्वतंत्र आणि पायाभूत सुविधांसह एकत्रित असतो. LSM एक नवीन संकल्पना प्रदान करते ज्यामध्ये अॅब्स्ट्रॅक्शन लेयर वेगवेगळ्या आर्किटेक्चर्सवर सिस्टम कॉल्स हाताळताना येणाऱ्या समस्या टाळण्यास मदत करू शकते.

लेखनाच्या वेळी, कर्नलमध्ये BPF प्रोग्रामशी संबंधित सात हुक आहेत आणि SELinux हे एकमेव अंगभूत LSM आहे जे त्यांना लागू करते.

सापळ्यांचा स्त्रोत कोड फाइलमधील कर्नल ट्रीमध्ये समाविष्ट आहे/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 — अंमलात आणलेल्या BPF सिस्टम कॉलची प्रारंभिक तपासणी करते;

- security_bpf_map - कर्नल नकाशासाठी फाइल डिस्क्रिप्टर परत केल्यावर तपासते;

- security_bpf_prog - कर्नल eBPF प्रोग्रामसाठी फाइल डिस्क्रिप्टर केव्हा परत करते ते तपासते;

— security_bpf_map_alloc — BPF नकाशे मधील सुरक्षा फील्ड सुरू केले आहे की नाही ते तपासते;

- security_bpf_map_free - BPF नकाशांमध्ये सुरक्षा फील्ड साफ केले आहे की नाही ते तपासते;

— security_bpf_prog_alloc — BPF प्रोग्राम्समध्ये सुरक्षा फील्ड सुरू केले आहे की नाही ते तपासते;

- security_bpf_prog_free - BPF प्रोग्राम्समध्ये सुरक्षा फील्ड साफ केले आहे की नाही ते तपासते.

आता, हे सर्व पाहून, आम्हाला समजले: LSM BPF इंटरसेप्टर्समागील कल्पना ही आहे की ते प्रत्येक eBPF ऑब्जेक्टला संरक्षण देऊ शकतात, हे सुनिश्चित करून की फक्त योग्य विशेषाधिकार असलेले कार्ड आणि प्रोग्रामवर ऑपरेशन करू शकतात.

सारांश

सुरक्षा ही अशी गोष्ट नाही जी तुम्ही संरक्षित करू इच्छित असलेल्या प्रत्येक गोष्टीसाठी एक-आकार-फिट-सर्व प्रकारे लागू करू शकता. वेगवेगळ्या स्तरांवर आणि वेगवेगळ्या प्रकारे सिस्टमचे संरक्षण करण्यात सक्षम असणे महत्त्वाचे आहे. यावर विश्वास ठेवा किंवा नाही, सिस्टम सुरक्षित करण्याचा सर्वोत्तम मार्ग म्हणजे वेगवेगळ्या पोझिशन्समधून विविध स्तरांचे संरक्षण आयोजित करणे, जेणेकरून एका स्तराची सुरक्षा कमी केल्याने संपूर्ण सिस्टममध्ये प्रवेश मिळत नाही. मुख्य विकासकांनी आम्हाला विविध स्तरांचा आणि टचपॉइंटचा संच देण्याचे उत्तम काम केले आहे. आम्‍हाला आशा आहे की आम्‍ही तुम्‍हाला लेयर्स कोणते आहेत आणि त्‍यांच्‍यासोबत काम करण्‍यासाठी BPF प्रोग्रॅम कसे वापरायचे याची चांगली समज दिली आहे.

लेखकांबद्दल

डेव्हिड कॅलवेरा Netlify येथे CTO आहे. त्यांनी डॉकर सपोर्टमध्ये काम केले आणि Runc, Go आणि BCC टूल्स तसेच इतर ओपन सोर्स प्रकल्पांच्या विकासात योगदान दिले. डॉकर प्रकल्पांवरील काम आणि डॉकर प्लगइन इकोसिस्टमच्या विकासासाठी ओळखले जाते. डेव्हिडला फ्लेम आलेखांबद्दल खूप आवड आहे आणि तो नेहमी कार्यप्रदर्शन ऑप्टिमाइझ करण्याचा प्रयत्न करतो.

लोरेन्झो फोंटाना Sysdig येथे ओपन सोर्स टीमवर काम करतो, जिथे तो Falco या क्लाउड नेटिव्ह कंप्युटिंग फाऊंडेशन प्रकल्पावर प्रामुख्याने लक्ष केंद्रित करतो जो कर्नल मॉड्यूल आणि eBPF द्वारे कंटेनर रनटाइम सुरक्षा आणि विसंगती शोधणे प्रदान करतो. तो वितरित प्रणाली, सॉफ्टवेअर परिभाषित नेटवर्किंग, लिनक्स कर्नल आणि कार्यप्रदर्शन विश्लेषणाबद्दल उत्कट आहे.

» पुस्तकाबद्दल अधिक तपशील येथे आढळू शकतात प्रकाशकाची वेबसाइट
» सामग्री सारणी
» उतारा

Khabrozhiteley साठी कूपन वापरून 25% सूट - linux

पुस्तकाची कागदी आवृत्ती भरल्यानंतर, इलेक्ट्रॉनिक पुस्तक ई-मेलद्वारे पाठवले जाईल.

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