წიგნი "BPF Linux-ის მონიტორინგისთვის"

გამარჯობა ხაბროს მოსახლეობავ! BPF ვირტუალური მანქანა Linux-ის ბირთვის ერთ-ერთი ყველაზე მნიშვნელოვანი კომპონენტია. მისი სწორად გამოყენება საშუალებას მისცემს სისტემის ინჟინრებს იპოვონ ხარვეზები და გადაჭრას ყველაზე რთული პრობლემებიც კი. თქვენ შეისწავლით როგორ დაწეროთ პროგრამები, რომლებიც აკონტროლებენ და ცვლიან ბირთვის ქცევას, როგორ უსაფრთხოდ დანერგოთ კოდი ბირთვში მოვლენების მონიტორინგისთვის და მრავალი სხვა. დევიდ კალავერა და ლორენცო ფონტანა დაგეხმარებიან განბლოკოთ BPF-ის ძალა. გააფართოვეთ თქვენი ცოდნა შესრულების ოპტიმიზაციის, ქსელის, უსაფრთხოების შესახებ. - გამოიყენეთ BPF Linux-ის ბირთვის ქცევის მონიტორინგისა და შესაცვლელად. - შეიტანეთ კოდი ბირთვის მოვლენების უსაფრთხოდ მონიტორინგისთვის, ბირთვის ხელახალი კომპილაციის ან სისტემის გადატვირთვის გარეშე. - გამოიყენეთ მოსახერხებელი კოდის მაგალითები C, Go ან Python-ში. - აიღეთ კონტროლი BPF პროგრამის სასიცოცხლო ციკლის ფლობით.

Linux Kernel Security, მისი მახასიათებლები და Seccomp

BPF უზრუნველყოფს ბირთვის გაფართოების მძლავრ გზას სტაბილურობის, უსაფრთხოების ან სიჩქარის შეწირვის გარეშე. ამ მიზეზით, ბირთვის დეველოპერებმა ჩათვალეს, რომ კარგი იდეა იქნებოდა მისი მრავალფეროვნების გამოყენება Seccomp-ში პროცესის იზოლაციის გასაუმჯობესებლად Seccomp ფილტრების დანერგვით, რომლებიც მხარდაჭერილია BPF პროგრამებით, ასევე ცნობილი როგორც Seccomp BPF. ამ თავში ჩვენ აგიხსნით რა არის Seccomp და როგორ გამოიყენება. შემდეგ თქვენ შეისწავლით თუ როგორ უნდა დაწეროთ Seccomp ფილტრები BPF პროგრამების გამოყენებით. ამის შემდეგ, ჩვენ გადავხედავთ ჩაშენებულ BPF კაკვებს, რომლებიც შედის ბირთვში Linux უსაფრთხოების მოდულებისთვის.

Linux უსაფრთხოების მოდულები (LSM) არის ჩარჩო, რომელიც უზრუნველყოფს ფუნქციების ერთობლიობას, რომელიც შეიძლება გამოყენებულ იქნას უსაფრთხოების სხვადასხვა მოდელების სტანდარტიზებული წესით განსახორციელებლად. LSM შეიძლება გამოყენებულ იქნას უშუალოდ ბირთვის წყაროს ხეში, როგორიცაა Apparmor, SELinux და Tomoyo.

დავიწყოთ Linux-ის შესაძლებლობების განხილვით.

შესაძლებლობები

Linux-ის შესაძლებლობების არსი იმაში მდგომარეობს, რომ თქვენ უნდა მიანიჭოთ არაპრივილეგირებულ პროცესს გარკვეული დავალების შესრულების ნებართვა, მაგრამ ამ მიზნით suid-ის გამოყენების გარეშე, ან სხვაგვარად გახადოთ პროცესი პრივილეგირებული, შეამციროთ თავდასხმის შესაძლებლობა და მისცეთ პროცესს გარკვეული ამოცანების შესრულების უფლება. მაგალითად, თუ თქვენს აპლიკაციას სჭირდება პრივილეგირებული პორტის გახსნა, ვთქვათ 80, პროცესის root-ის სახით გაშვების ნაცვლად, შეგიძლიათ უბრალოდ მისცეთ CAP_NET_BIND_SERVICE შესაძლებლობა.

განვიხილოთ Go პროგრამა სახელად main.go:

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

ეს პროგრამა ემსახურება HTTP სერვერს 80 პორტზე (ეს არის პრივილეგირებული პორტი). ჩვეულებრივ, ჩვენ ვაწარმოებთ მას შედგენისთანავე:

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

თუმცა, რადგან ჩვენ არ ვაძლევთ root პრივილეგიებს, ეს კოდი გამოუშვებს შეცდომას პორტის დაკავშირებისას:

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

capsh (ჭურვის მენეჯერი) არის ინსტრუმენტი, რომელიც აწარმოებს ჭურვს გარკვეული შესაძლებლობების ნაკრებით.

ამ შემთხვევაში, როგორც უკვე აღვნიშნეთ, სრული root უფლებების მინიჭების ნაცვლად, შეგიძლიათ ჩართოთ პრივილეგირებული პორტის დაკავშირება cap_net_bind_service შესაძლებლობის მიწოდებით ყველაფერთან ერთად, რაც უკვე არის პროგრამაში. ამისათვის ჩვენ შეგვიძლია დავამატოთ ჩვენი პროგრამა capsh-ში:

# 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' - რადგან ჩვენ გვჭირდება მომხმარებლის შეცვლა (არ გვინდა გაშვება როგორც root), ჩვენ მივუთითებთ cap_net_bind_service და ფაქტობრივად მომხმარებლის ID-ის შეცვლის შესაძლებლობას. root to nobody, კერძოდ cap_setuid და cap_setgid.
• —keep=1 — გვსურს შევინარჩუნოთ დაინსტალირებული შესაძლებლობები root ანგარიშიდან გადასვლისას.
• —user=“არავინ“ — პროგრამის გაშვების საბოლოო მომხმარებელი იქნება არავინ.
• —addamb=cap_net_bind_service — დააყენეთ შესაბამისი შესაძლებლობების გასუფთავება root რეჟიმიდან გადასვლის შემდეგ.
• - -c "./capabilities" - უბრალოდ გაუშვით პროგრამა.

დაკავშირებული შესაძლებლობები არის სპეციალური ტიპის შესაძლებლობები, რომლებიც მემკვიდრეობით მიიღება შვილობილი პროგრამების მიერ, როდესაც მიმდინარე პროგრამა მათ ახორციელებს execve() გამოყენებით. მხოლოდ ის შესაძლებლობები, რომლებიც ნებადართულია ასოცირებული, ან სხვა სიტყვებით რომ ვთქვათ, როგორც გარემოს შესაძლებლობები, შეიძლება მემკვიდრეობით გადავიდეს.

თქვენ ალბათ გაინტერესებთ რას ნიშნავს +eip ოფციაში --caps შესაძლებლობის მითითების შემდეგ. ეს დროშები გამოიყენება იმის დასადგენად, რომ შესაძლებლობები:

-უნდა იყოს გააქტიურებული (p);

-ხელმისაწვდომია გამოსაყენებლად (e);

- შეიძლება მემკვიდრეობით გადავიდეს ბავშვის პროცესებით (i).

ვინაიდან ჩვენ გვინდა გამოვიყენოთ cap_net_bind_service, ეს უნდა გავაკეთოთ e დროშით. შემდეგ ჩვენ დავიწყებთ გარსს ბრძანებაში. ეს გაუშვებს ორობით შესაძლებლობებს და ჩვენ უნდა მოვნიშნოთ ის i დროშით. და ბოლოს, ჩვენ გვინდა, რომ ფუნქცია ჩართული იყოს (ეს გავაკეთეთ UID-ის შეცვლის გარეშე) პ. როგორც ჩანს cap_net_bind_service+eip.

თქვენ შეგიძლიათ შეამოწმოთ შედეგი ss-ის გამოყენებით. მოდით შევამოკლოთ გამომავალი, რათა მოერგოს გვერდზე, მაგრამ ის აჩვენებს ასოცირებულ პორტს და მომხმარებლის ID-ს გარდა 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

ამ მაგალითში ჩვენ გამოვიყენეთ capsh, მაგრამ თქვენ შეგიძლიათ დაწეროთ ჭურვი libcap-ის გამოყენებით. დამატებითი ინფორმაციისთვის იხილეთ man 3 libcap.

პროგრამების წერისას, საკმაოდ ხშირად დეველოპერმა წინასწარ არ იცის ყველა ის ფუნქცია, რომელიც პროგრამას სჭირდება გაშვების დროს; უფრო მეტიც, ეს ფუნქციები შეიძლება შეიცვალოს ახალ ვერსიებში.

ჩვენი პროგრამის შესაძლებლობების უკეთ გასაგებად, შეგვიძლია ავიღოთ BCC-ის უნარიანი ინსტრუმენტი, რომელიც ადგენს kprobe-ს cap_capable ბირთვის ფუნქციისთვის:

/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

ჩვენ შეგვიძლია მივაღწიოთ იგივეს bpftrace-ის გამოყენებით ერთხაზიანი kprobe-ით cap_capable kernel ფუნქციაში:

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, ის განსაზღვრულია, როგორც მუდმივი ბირთვის კოდის ფაილში include/uapi/linux/ability.h იდენტიფიკატორით 10:

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

შესაძლებლობები ხშირად ჩართულია გაშვების დროს კონტეინერებისთვის, როგორიცაა runC ან Docker, რათა მათ შეეძლოთ იმუშაონ არაპრივილეგირებულ რეჟიმში, მაგრამ მათ აქვთ მხოლოდ აპლიკაციების უმეტესობის გასაშვებად საჭირო შესაძლებლობები. როდესაც აპლიკაცია მოითხოვს გარკვეულ შესაძლებლობებს, Docker-ს შეუძლია უზრუნველყოს ისინი --cap-add-ის გამოყენებით:

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

ეს ბრძანება მისცემს კონტეინერს CAP_NET_ADMIN შესაძლებლობას, რაც საშუალებას მისცემს მას დააკონფიგურიროს ქსელის ბმული dummy0 ინტერფეისის დასამატებლად.

შემდეგი განყოფილება გვიჩვენებს, თუ როგორ გამოვიყენოთ ისეთი ფუნქციები, როგორიცაა ფილტრაცია, მაგრამ სხვა ტექნიკის გამოყენებით, რომელიც საშუალებას გვაძლევს პროგრამულად განვახორციელოთ საკუთარი ფილტრები.

სეკკომპ

Seccomp ნიშნავს Secure Computing-ს და არის უსაფრთხოების ფენა, რომელიც დანერგილია Linux-ის ბირთვში, რომელიც დეველოპერებს საშუალებას აძლევს გაფილტრონ გარკვეული სისტემური ზარები. მიუხედავად იმისა, რომ Seccomp შესაძლებლობებით შედარებულია Linux-თან, გარკვეული სისტემური ზარების მართვის უნარი მას ბევრად უფრო მოქნილს ხდის მათთან შედარებით.

Seccomp და Linux ფუნქციები არ არის ურთიერთგამომრიცხავი და ხშირად გამოიყენება ერთად ორივე მიდგომით სარგებლობისთვის. მაგალითად, შეიძლება გსურდეთ პროცესს მიანიჭოთ CAP_NET_ADMIN შესაძლებლობა, მაგრამ არ მისცეთ უფლება, მიიღოს სოკეტის კავშირები, დაბლოკოს მიღებისა და მიღების4 სისტემური ზარები.

Seccomp ფილტრაციის მეთოდი ეფუძნება BPF ფილტრებს, რომლებიც მუშაობენ SECCOMP_MODE_FILTER რეჟიმში და სისტემური ზარის ფილტრაცია ხორციელდება ისევე, როგორც პაკეტებისთვის.

Seccomp ფილტრები იტვირთება prctl-ის გამოყენებით PR_SET_SECCOMP ოპერაციით. ეს ფილტრები იღებენ BPF პროგრამის ფორმას, რომელიც შესრულებულია თითოეული Seccomp პაკეტისთვის, რომელიც წარმოდგენილია seccomp_data სტრუქტურით. ეს სტრუქტურა შეიცავს საცნობარო არქიტექტურას, მაჩვენებელს პროცესორის ინსტრუქციებზე სისტემური გამოძახების დროს და მაქსიმუმ ექვს სისტემური გამოძახების არგუმენტს, გამოხატული uint64.

ასე გამოიყურება seccomp_data სტრუქტურა ბირთვის წყაროს კოდიდან linux/seccomp.h ფაილში:

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 ფილტრის დაბრუნების მნიშვნელობის ნაწილი გადაეცემა მომხმარებლის სივრცეს, როგორც errno მნიშვნელობა. შეცდომის გამომწვევი მიზეზიდან გამომდინარე, ბრუნდება სხვადასხვა შეცდომის მნიშვნელობა. შეცდომების ნომრების სია მოცემულია შემდეგ განყოფილებაში.

- SECCOMP_RET_TRACE - გამოიყენება ptrace tracer-ის შესატყობინებლად - PTRACE_O_TRACESECCOMP, რათა ჩაეჭრას სისტემური ზარი ამ პროცესის სანახავად და გასაკონტროლებლად. თუ ტრასერი არ არის დაკავშირებული, შეცდომა ბრუნდება, errno დაყენებულია -ENOSYS-ზე და სისტემური ზარი არ შესრულდება.

- SECCOMP_RET_LOG - სისტემური ზარი მოგვარებულია და დარეგისტრირებულია.

- SECCOMP_RET_ALLOW - სისტემური ზარი უბრალოდ დაშვებულია.

ptrace არის სისტემური გამოძახება ტრასირების მექანიზმების დანერგვის პროცესში, რომელსაც ეწოდება tracee, პროცესის შესრულების მონიტორინგისა და კონტროლის შესაძლებლობით. კვალიფიკაციის პროგრამას შეუძლია ეფექტურად გავლენა მოახდინოს შესრულებაზე და შეცვალოს კვალიფიკაციის მეხსიერების რეგისტრები. Seccomp-ის კონტექსტში, ptrace გამოიყენება SECCOMP_RET_TRACE სტატუსის კოდით გაშვებისას, ასე რომ, ტრასერს შეუძლია ხელი შეუშალოს სისტემის ზარის შესრულებას და განახორციელოს საკუთარი ლოგიკა.

Seccom-ის შეცდომები

დროდადრო Seccomp-თან მუშაობისას შეხვდებით სხვადასხვა შეცდომებს, რომლებიც იდენტიფიცირებულია SECCOMP_RET_ERRNO ტიპის დაბრუნებული მნიშვნელობით. შეცდომის შესატყობინებლად, seccomp სისტემური ზარი 1-ის ნაცვლად დაბრუნდება -0-ზე.

შესაძლებელია შემდეგი შეცდომები:

- EACCESS - აბონენტს არ აქვს უფლება განახორციელოს სისტემური ზარი. ეს ჩვეულებრივ ხდება იმის გამო, რომ მას არ აქვს CAP_SYS_ADMIN პრივილეგიები ან no_new_privs არ არის დაყენებული prctl-ის გამოყენებით (ამაზე მოგვიანებით ვისაუბრებთ);

— EFAULT — მიღებულ არგუმენტებს (args seccomp_data სტრუქტურაში) არ აქვთ სწორი მისამართი;

— EINVAL — აქ ოთხი მიზეზი შეიძლება იყოს:

-მოთხოვნილი ოპერაცია უცნობია ან არ არის მხარდაჭერილი ბირთვის მიერ მიმდინარე კონფიგურაციაში;

- მითითებული დროშები არ მოქმედებს მოთხოვნილი ოპერაციისთვის;

-ოპერაცია მოიცავს BPF_ABS, მაგრამ არის პრობლემები მითითებულ ოფსეტთან დაკავშირებით, რომელიც შეიძლება აღემატებოდეს seccomp_data სტრუქტურის ზომას;

-ფილტრზე გადაცემული ინსტრუქციების რაოდენობა აღემატება მაქსიმუმს;

— ENOMEM - არ არის საკმარისი მეხსიერება პროგრამის შესასრულებლად;

- EOPNOTSUPP - ოპერაციამ მიუთითა, რომ SECCOMP_GET_ACTION_AVAIL ქმედება იყო ხელმისაწვდომი, მაგრამ ბირთვი არ უჭერს მხარს არგუმენტებში დაბრუნებას;

— ESRCH — წარმოიშვა პრობლემა სხვა ნაკადის სინქრონიზაციისას;

- ENOSYS - SECCOMP_RET_TRACE მოქმედებაზე არ არის მიმაგრებული ტრასერი.

prctl არის სისტემური ზარი, რომელიც საშუალებას აძლევს მომხმარებელთა სივრცის პროგრამას მანიპულირება მოახდინოს (დააყენოს და მიიღოს) პროცესის კონკრეტული ასპექტები, როგორიცაა ბაიტის სისუსტე, ძაფების სახელები, უსაფრთხო გამოთვლის რეჟიმი (Seccomp), პრივილეგიები, Perf მოვლენები და ა.შ.

Seccomp შეიძლება მოგეჩვენოთ, როგორც sandbox ტექნოლოგია, მაგრამ ეს ასე არ არის. Seccomp არის პროგრამა, რომელიც მომხმარებლებს საშუალებას აძლევს შეიმუშაონ სავარჯიშო მექანიზმი. ახლა ვნახოთ, როგორ იქმნება მომხმარებელთა ურთიერთქმედების პროგრამები ფილტრის გამოყენებით, რომელსაც უშუალოდ ეწოდება Seccomp სისტემის ზარი.

BPF Seccomp ფილტრის მაგალითი

აქ ჩვენ გაჩვენებთ, თუ როგორ გავაერთიანოთ ადრე განხილული ორი მოქმედება, კერძოდ:

— ჩვენ დავწერთ Seccomp BPF პროგრამას, რომელიც გამოყენებული იქნება როგორც ფილტრი სხვადასხვა დაბრუნების კოდებით მიღებული გადაწყვეტილების მიხედვით;

- ჩატვირთეთ ფილტრი prctl-ის გამოყენებით.

ჯერ გჭირდებათ სათაურები სტანდარტული ბიბლიოთეკიდან და Linux-ის ბირთვიდან:

#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),
  };

ინსტრუქციები დაყენებულია BPF_STMT და BPF_JUMP მაკროების გამოყენებით, რომლებიც განსაზღვრულია linux/filter.h ფაილში.
მოდით გავიაროთ ინსტრუქციები.

- 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, თაღი, 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 | (error & SECCOMP_RET_DATA)) - წყვეტს პროგრამას BPF_RET-ით და შედეგად წარმოქმნის შეცდომას SECCOMP_RET_ERRNO რიცხვით err ცვლადი.

- BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ALLOW) - წყვეტს პროგრამას BPF_RET-ით და საშუალებას აძლევს სისტემური ზარის შესრულებას SECCOMP_RET_ALLOW-ის გამოყენებით.

SECCOMP არის 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;

Socket_filter სტრუქტურაში ფილტრის კოდის განსაზღვრის შემდეგ, თქვენ უნდა განსაზღვროთ sock_fprog, რომელიც შეიცავს კოდს და ფილტრის გამოთვლილ სიგრძეს. ეს მონაცემთა სტრუქტურა საჭიროა, როგორც არგუმენტი პროცესის მოგვიანებით გასაშვებად გამოცხადებისთვის:

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

install_filter ფუნქციაში რჩება მხოლოდ ერთი რამ - ჩატვირთეთ თავად პროგრამა! ამისათვის ჩვენ ვიყენებთ prctl-ს და ვიღებთ PR_SET_SECCOMP-ს, როგორც უსაფრთხო გამოთვლის რეჟიმში შესასვლელად. შემდეგ ჩვენ ვეუბნებით რეჟიმს, რომ ჩატვირთოს ფილტრი SECCOMP_MODE_FILTER-ის გამოყენებით, რომელიც შეიცავს sock_fprog ტიპის prog ცვლადში:

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

საბოლოოდ, ჩვენ შეგვიძლია გამოვიყენოთ ჩვენი install_filter ფუნქცია, მაგრამ მანამდე უნდა გამოვიყენოთ prctl, რათა დავაყენოთ PR_SET_NO_NEW_PRIVS მიმდინარე შესრულებისთვის და ამით თავიდან ავიცილოთ სიტუაცია, როდესაც ბავშვის პროცესები უფრო მეტ პრივილეგიას იღებენ, ვიდრე მათი მშობლები. ამით ჩვენ შეგვიძლია განვახორციელოთ შემდეგი prctl ზარები install_filter ფუნქციაში root უფლებების გარეშე.

ახლა ჩვენ შეგვიძლია გამოვიძახოთ 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

მშვენიერია! აი, როგორ გამოიყურება ჩვენი wrapper პროგრამის გამოყენება: ჩვენ უბრალოდ გადავცემთ პროგრამას, რომლის გამოცდაც გვინდა, როგორც პირველი არგუმენტი:

./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 ახორციელებს ხაფანგების კონცეფციას. Hook ზარი ტექნიკურად ჰგავს სისტემურ ზარს, მაგრამ არის სისტემა დამოუკიდებელი და ინტეგრირებულია ინფრასტრუქტურასთან. LSM გთავაზობთ ახალ კონცეფციას, რომელშიც აბსტრაქციის ფენა დაგეხმარებათ თავიდან აიცილოთ პრობლემები, რომლებიც წარმოიქმნება სხვადასხვა არქიტექტურაზე სისტემური მოწოდებების დროს.

წერის დროს, ბირთვს აქვს შვიდი კაუჭი, რომლებიც დაკავშირებულია 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 — ახორციელებს შესრულებული 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 პროგრამები მათთან მუშაობისთვის.

ავტორების შესახებ

დევიდ კალავერა არის CTO Netlify-ში. ის მუშაობდა Docker-ის მხარდაჭერაში და წვლილი შეიტანა Runc, Go და BCC ინსტრუმენტების, ისევე როგორც სხვა ღია კოდის პროექტების შემუშავებაში. ცნობილია თავისი მუშაობით Docker პროექტებზე და Docker მოდულის ეკოსისტემის შემუშავებით. დევიდს ძალიან უყვარს ფლეიმის გრაფიკები და ყოველთვის ცდილობს მუშაობის ოპტიმიზაციას.

ლორენცო ფონტანა მუშაობს ღია კოდის გუნდში Sysdig-ში, სადაც ის ძირითადად ორიენტირებულია Falco-ზე, Cloud Native Computing Foundation-ის პროექტზე, რომელიც უზრუნველყოფს კონტეინერის გაშვების უსაფრთხოებას და ანომალიების გამოვლენას ბირთვის მოდულისა და eBPF-ის მეშვეობით. ის გატაცებულია განაწილებული სისტემებით, პროგრამული უზრუნველყოფის განსაზღვრული ქსელებით, Linux-ის ბირთვით და შესრულების ანალიზით.

» მეტი ინფორმაცია წიგნის შესახებ შეგიძლიათ იხილოთ აქ გამომცემლის ვებსაიტზე
» სარჩევი
» ნაწყვეტი

Khabrozhiteley-ზე 25% ფასდაკლება კუპონის გამოყენებით - Linux

წიგნის ქაღალდის ვერსიის გადახდის შემდეგ ელექტრონული წიგნი გაიგზავნება ელექტრონული ფოსტით.

წყარო: www.habr.com