പുസ്തകം "ലിനക്സ് മോണിറ്ററിങ്ങിനുള്ള BPF"

ഹലോ, ഖബ്രോ നിവാസികൾ! ലിനക്സ് കേർണലിന്റെ ഏറ്റവും പ്രധാനപ്പെട്ട ഘടകങ്ങളിലൊന്നാണ് ബിപിഎഫ് വിർച്ച്വൽ മെഷീൻ. അതിന്റെ ശരിയായ ഉപയോഗം സിസ്റ്റം എഞ്ചിനീയർമാർക്ക് തകരാറുകൾ കണ്ടെത്താനും ഏറ്റവും സങ്കീർണ്ണമായ പ്രശ്നങ്ങൾ പോലും പരിഹരിക്കാനും അനുവദിക്കും. കേർണലിന്റെ സ്വഭാവം നിരീക്ഷിക്കുകയും പരിഷ്‌ക്കരിക്കുകയും ചെയ്യുന്ന പ്രോഗ്രാമുകൾ എങ്ങനെ എഴുതാമെന്നും കേർണലിലെ ഇവന്റുകൾ നിരീക്ഷിക്കുന്നതിന് കോഡ് സുരക്ഷിതമായി എങ്ങനെ നടപ്പിലാക്കാമെന്നും മറ്റും നിങ്ങൾ പഠിക്കും. ഡേവിഡ് കലവേരയും ലോറെൻസോ ഫോണ്ടാനയും ബിപിഎഫിന്റെ പവർ അൺലോക്ക് ചെയ്യാൻ നിങ്ങളെ സഹായിക്കും. പ്രകടന ഒപ്റ്റിമൈസേഷൻ, നെറ്റ്‌വർക്കിംഗ്, സുരക്ഷ എന്നിവയെക്കുറിച്ചുള്ള നിങ്ങളുടെ അറിവ് വികസിപ്പിക്കുക. - Linux കേർണലിന്റെ സ്വഭാവം നിരീക്ഷിക്കുന്നതിനും പരിഷ്‌ക്കരിക്കുന്നതിനും BPF ഉപയോഗിക്കുക. - കേർണൽ വീണ്ടും കമ്പൈൽ ചെയ്യാതെയും സിസ്റ്റം റീബൂട്ട് ചെയ്യാതെയും കേർണൽ ഇവന്റുകൾ സുരക്ഷിതമായി നിരീക്ഷിക്കാൻ കോഡ് കുത്തിവയ്ക്കുക. - സി, ഗോ അല്ലെങ്കിൽ പൈത്തണിൽ സൗകര്യപ്രദമായ കോഡ് ഉദാഹരണങ്ങൾ ഉപയോഗിക്കുക. - BPF പ്രോഗ്രാം ലൈഫ് സൈക്കിൾ സ്വന്തമാക്കി നിയന്ത്രണം ഏറ്റെടുക്കുക.

Linux കേർണൽ സെക്യൂരിറ്റി, അതിന്റെ സവിശേഷതകൾ, Seccomp

സ്ഥിരതയോ സുരക്ഷയോ വേഗതയോ നഷ്ടപ്പെടുത്താതെ കേർണൽ വിപുലീകരിക്കാനുള്ള ശക്തമായ മാർഗം BPF നൽകുന്നു. ഇക്കാരണത്താൽ, Seccomp BPF എന്നും അറിയപ്പെടുന്ന BPF പ്രോഗ്രാമുകൾ പിന്തുണയ്ക്കുന്ന Seccomp ഫിൽട്ടറുകൾ നടപ്പിലാക്കുന്നതിലൂടെ, Seccomp-ൽ പ്രോസസ് ഐസൊലേഷൻ മെച്ചപ്പെടുത്തുന്നതിന് അതിന്റെ ബഹുമുഖത ഉപയോഗിക്കുന്നത് നല്ലതാണെന്ന് കേർണൽ ഡെവലപ്പർമാർ കരുതി. ഈ അധ്യായത്തിൽ Seccomp എന്താണെന്നും അത് എങ്ങനെ ഉപയോഗിക്കുന്നുവെന്നും ഞങ്ങൾ വിശദീകരിക്കും. തുടർന്ന് BPF പ്രോഗ്രാമുകൾ ഉപയോഗിച്ച് Seccomp ഫിൽട്ടറുകൾ എങ്ങനെ എഴുതാമെന്ന് നിങ്ങൾ പഠിക്കും. അതിനുശേഷം, Linux സുരക്ഷാ മൊഡ്യൂളുകൾക്കുള്ള കേർണലിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ബിൽറ്റ്-ഇൻ BPF ഹുക്കുകൾ ഞങ്ങൾ നോക്കാം.

ലിനക്സ് സെക്യൂരിറ്റി മൊഡ്യൂളുകൾ (LSM) വിവിധ സുരക്ഷാ മോഡലുകൾ ഒരു സ്റ്റാൻഡേർഡ് രീതിയിൽ നടപ്പിലാക്കാൻ ഉപയോഗിക്കാവുന്ന ഒരു കൂട്ടം ഫംഗ്ഷനുകൾ നൽകുന്ന ഒരു ചട്ടക്കൂടാണ്. Apparmor, SELinux, Tomoyo തുടങ്ങിയ കേർണൽ സോഴ്‌സ് ട്രീയിൽ LSM നേരിട്ട് ഉപയോഗിക്കാം.

ലിനക്സിന്റെ കഴിവുകൾ ചർച്ച ചെയ്തുകൊണ്ട് നമുക്ക് ആരംഭിക്കാം.

സവിശേഷതകൾ

ലിനക്സിന്റെ കഴിവുകളുടെ സാരാംശം, ഒരു നിശ്ചിത ചുമതല നിർവഹിക്കുന്നതിന് നിങ്ങൾ ഒരു അനഭിലഷണീയമായ പ്രോസസ്സ് അനുമതി നൽകേണ്ടതുണ്ട്, എന്നാൽ ആ ആവശ്യത്തിനായി suid ഉപയോഗിക്കാതെ, അല്ലെങ്കിൽ പ്രക്രിയയെ പ്രത്യേകാവകാശമുള്ളതാക്കുക, ആക്രമണ സാധ്യത കുറയ്ക്കുകയും ചില ജോലികൾ ചെയ്യാൻ പ്രക്രിയയെ അനുവദിക്കുകയും ചെയ്യുക എന്നതാണ്. ഉദാഹരണത്തിന്, നിങ്ങളുടെ അപ്ലിക്കേഷന് ഒരു പ്രത്യേക പോർട്ട് തുറക്കണമെങ്കിൽ, പ്രോസസ്സ് റൂട്ടായി പ്രവർത്തിപ്പിക്കുന്നതിന് പകരം 80 എന്ന് പറയുക, നിങ്ങൾക്ക് അതിന് CAP_NET_BIND_SERVICE കഴിവ് നൽകാം.

main.go എന്ന് പേരിട്ടിരിക്കുന്ന ഒരു 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

ക്യാപ്ഷ് (ഷെൽ മാനേജർ) എന്നത് ഒരു പ്രത്യേക കഴിവുകളുള്ള ഒരു ഷെൽ പ്രവർത്തിപ്പിക്കുന്ന ഒരു ഉപകരണമാണ്.

ഈ സാഹചര്യത്തിൽ, ഇതിനകം സൂചിപ്പിച്ചതുപോലെ, പൂർണ്ണമായ റൂട്ട് അവകാശങ്ങൾ നൽകുന്നതിനുപകരം, പ്രോഗ്രാമിൽ ഇതിനകം ഉള്ള എല്ലാറ്റിനും ഒപ്പം 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 - ഒരു ഷെല്ലായി ക്യാപ്ഷ് ഉപയോഗിക്കുക.
• —caps='cap_net_bind_service+eip cap_setpcap,cap_setuid,cap_setgid+ep' - ഉപയോക്താവിനെ മാറ്റേണ്ടതിനാൽ (റൂട്ടായി പ്രവർത്തിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നില്ല), cap_net_bind_service എന്നതിൽ നിന്നും ഉപയോക്തൃ ഐഡി യഥാർത്ഥത്തിൽ മാറ്റാനുള്ള കഴിവും ഞങ്ങൾ വ്യക്തമാക്കും. ആരുമില്ല, അതായത് cap_setuid, cap_setgid.
• —keep=1 — റൂട്ട് അക്കൌണ്ടിൽ നിന്ന് മാറുമ്പോൾ ഇൻസ്റ്റാൾ ചെയ്ത കഴിവുകൾ നിലനിർത്താൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.
• —ഉപയോക്താവ്=“ആരും” — പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്ന അന്തിമ ഉപയോക്താവ് ആരും ആയിരിക്കില്ല.
• —addamb=cap_net_bind_service — റൂട്ട് മോഡിൽ നിന്ന് മാറിയതിന് ശേഷം ബന്ധപ്പെട്ട കഴിവുകളുടെ ക്ലിയറിംഗ് സജ്ജമാക്കുക.
• - -c "./capabilities" - പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുക.

നിലവിലെ പ്രോഗ്രാം execve() ഉപയോഗിച്ച് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ ചൈൽഡ് പ്രോഗ്രാമുകൾക്ക് പാരമ്പര്യമായി ലഭിക്കുന്ന ഒരു പ്രത്യേക തരത്തിലുള്ള കഴിവുകളാണ് ലിങ്ക്ഡ് കഴിവുകൾ. ബന്ധപ്പെടുത്താൻ അനുവദിക്കപ്പെട്ട കഴിവുകൾ അല്ലെങ്കിൽ മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, പരിസ്ഥിതി കഴിവുകൾ മാത്രമേ പാരമ്പര്യമായി ലഭിക്കൂ.

--caps ഓപ്ഷനിൽ കഴിവ് വ്യക്തമാക്കിയതിന് ശേഷം +eip എന്താണ് അർത്ഥമാക്കുന്നത് എന്ന് നിങ്ങൾ ചിന്തിച്ചേക്കാം. ശേഷി നിർണ്ണയിക്കാൻ ഈ പതാകകൾ ഉപയോഗിക്കുന്നു:

-ആക്ടിവേറ്റ് ചെയ്യണം (p);

-ഉപയോഗത്തിന് ലഭ്യമാണ് (ഇ);

- ശിശു പ്രക്രിയകൾ (i) വഴി പാരമ്പര്യമായി ലഭിക്കും.

നമുക്ക് cap_net_bind_service ഉപയോഗിക്കാൻ താൽപ്പര്യമുള്ളതിനാൽ, e ഫ്ലാഗ് ഉപയോഗിച്ച് ഇത് ചെയ്യേണ്ടതുണ്ട്. അപ്പോൾ നമ്മൾ കമാൻഡിൽ ഷെൽ ആരംഭിക്കും. ഇത് കഴിവുകൾ ബൈനറി പ്രവർത്തിപ്പിക്കും, ഞങ്ങൾ അത് i ഫ്ലാഗ് ഉപയോഗിച്ച് അടയാളപ്പെടുത്തേണ്ടതുണ്ട്. അവസാനമായി, p ഉപയോഗിച്ച് ഫീച്ചർ പ്രവർത്തനക്ഷമമാക്കണമെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നു (യുഐഡി മാറ്റാതെ ഞങ്ങൾ ഇത് ചെയ്തു). ഇത് 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-നൊപ്പം/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 സവിശേഷതകൾ പരസ്പരവിരുദ്ധമല്ല, രണ്ട് സമീപനങ്ങളിൽ നിന്നും പ്രയോജനം ലഭിക്കുന്നതിന് പലപ്പോഴും ഒരുമിച്ച് ഉപയോഗിക്കാറുണ്ട്. ഉദാഹരണത്തിന്, നിങ്ങൾ ഒരു പ്രോസസ്സിന് CAP_NET_ADMIN കഴിവ് നൽകാൻ ആഗ്രഹിച്ചേക്കാം, എന്നാൽ സോക്കറ്റ് കണക്ഷനുകൾ സ്വീകരിക്കാൻ അനുവദിക്കില്ല, സ്വീകരിക്കുക, സ്വീകരിക്കുക4 സിസ്റ്റം കോളുകൾ തടയുക.

SECCOMP_MODE_FILTER മോഡിൽ പ്രവർത്തിക്കുന്ന BPF ഫിൽട്ടറുകളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ് Seccomp ഫിൽട്ടറിംഗ് രീതി, കൂടാതെ പാക്കറ്റുകളുടെ അതേ രീതിയിൽ സിസ്റ്റം കോൾ ഫിൽട്ടറിംഗ് നടത്തുന്നു.

PR_SET_SECCOMP പ്രവർത്തനത്തിലൂടെ prctl ഉപയോഗിച്ച് Seccomp ഫിൽട്ടറുകൾ ലോഡ് ചെയ്യുന്നു. ഈ ഫിൽട്ടറുകൾ seccomp_data ഘടന പ്രതിനിധീകരിക്കുന്ന ഓരോ Seccomp പാക്കറ്റിനും ഒരു BPF പ്രോഗ്രാമിന്റെ രൂപമാണ് എടുക്കുന്നത്. ഈ ഘടനയിൽ റഫറൻസ് ആർക്കിടെക്ചർ, സിസ്റ്റം കോളിന്റെ സമയത്ത് പ്രോസസർ നിർദ്ദേശങ്ങളിലേക്കുള്ള ഒരു പോയിന്റർ, 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 Tracer-നെ അറിയിക്കാൻ ഉപയോഗിക്കുന്നു - ഒരു സിസ്റ്റം കോൾ എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ ആ പ്രക്രിയ കാണാനും നിയന്ത്രിക്കാനും. ഒരു ട്രെയ്‌സർ കണക്‌റ്റ് ചെയ്‌തിട്ടില്ലെങ്കിൽ, ഒരു പിശക് തിരികെ ലഭിക്കും, പിശക് -ENOSYS ആയി സജ്ജീകരിച്ചിരിക്കുന്നു, കൂടാതെ സിസ്റ്റം കോൾ എക്‌സിക്യൂട്ട് ചെയ്യപ്പെടുന്നില്ല.

- SECCOMP_RET_LOG - സിസ്റ്റം കോൾ പരിഹരിച്ച് ലോഗ് ചെയ്തു.

- SECCOMP_RET_ALLOW - സിസ്റ്റം കോൾ അനുവദനീയമാണ്.

പ്രക്രിയയുടെ നിർവ്വഹണം നിരീക്ഷിക്കാനും നിയന്ത്രിക്കാനുമുള്ള കഴിവുള്ള ട്രേസി എന്ന പ്രക്രിയയിൽ ട്രെയ്‌സിംഗ് മെക്കാനിസങ്ങൾ നടപ്പിലാക്കുന്നതിനുള്ള ഒരു സിസ്റ്റം കോളാണ് ptrace. ട്രെയ്‌സ് പ്രോഗ്രാമിന് എക്‌സിക്യൂഷനെ ഫലപ്രദമായി സ്വാധീനിക്കാനും ട്രേസിയുടെ മെമ്മറി രജിസ്റ്ററുകൾ പരിഷ്‌ക്കരിക്കാനും കഴിയും. Seccomp സന്ദർഭത്തിൽ, SECCOMP_RET_TRACE സ്റ്റാറ്റസ് കോഡ് ട്രിഗർ ചെയ്യുമ്പോൾ ptrace ഉപയോഗിക്കുന്നു, അതിനാൽ ട്രേസറിന് സിസ്റ്റം കോൾ എക്സിക്യൂട്ട് ചെയ്യുന്നതിൽ നിന്ന് തടയാനും അതിന്റേതായ ലോജിക് നടപ്പിലാക്കാനും കഴിയും.

Seccomp പിശകുകൾ

കാലാകാലങ്ങളിൽ, Seccomp-ൽ പ്രവർത്തിക്കുമ്പോൾ, നിങ്ങൾക്ക് വിവിധ പിശകുകൾ നേരിടേണ്ടിവരും, അത് SECCOMP_RET_ERRNO എന്ന തരത്തിലുള്ള റിട്ടേൺ മൂല്യത്താൽ തിരിച്ചറിയപ്പെടും. ഒരു പിശക് റിപ്പോർട്ടുചെയ്യാൻ, seccomp സിസ്റ്റം കോൾ 1-ന് പകരം -0 നൽകും.

ഇനിപ്പറയുന്ന പിശകുകൾ സാധ്യമാണ്:

- ACCESS - കോളർ സിസ്റ്റം കോൾ ചെയ്യാൻ അനുവാദമില്ല. ഇത് സാധാരണയായി സംഭവിക്കുന്നത് ഇതിന് CAP_SYS_ADMIN പ്രത്യേകാവകാശങ്ങൾ ഇല്ലാത്തതിനാലോ prctl ഉപയോഗിച്ച് no_new_privs സജ്ജീകരിക്കാത്തതിനാലോ ആണ് (ഇതിനെക്കുറിച്ച് ഞങ്ങൾ പിന്നീട് സംസാരിക്കും);

— EFAULT — പാസായ ആർഗ്യുമെന്റുകൾക്ക് (seccomp_data ഘടനയിലെ args) സാധുവായ ഒരു വിലാസം ഇല്ല;

- EINVAL - ഇവിടെ നാല് കാരണങ്ങളുണ്ടാകാം:

-അഭ്യർത്ഥിച്ച പ്രവർത്തനം അജ്ഞാതമാണ് അല്ലെങ്കിൽ നിലവിലെ കോൺഫിഗറേഷനിൽ കേർണൽ പിന്തുണയ്ക്കുന്നില്ല;

അഭ്യർത്ഥിച്ച പ്രവർത്തനത്തിന് നിർദ്ദിഷ്ട ഫ്ലാഗുകൾ സാധുതയുള്ളതല്ല;

-ഓപ്പറേഷനിൽ BPF_ABS ഉൾപ്പെടുന്നു, എന്നാൽ നിർദ്ദിഷ്ട ഓഫ്‌സെറ്റിൽ പ്രശ്‌നങ്ങളുണ്ട്, അത് seccomp_data ഘടനയുടെ വലുപ്പം കവിഞ്ഞേക്കാം;

-ഫിൽട്ടറിലേക്ക് അയച്ച നിർദ്ദേശങ്ങളുടെ എണ്ണം പരമാവധി കവിയുന്നു;

- ENOMEM - പ്രോഗ്രാം എക്സിക്യൂട്ട് ചെയ്യാൻ മതിയായ മെമ്മറി ഇല്ല;

- EOPNOTSUPP - SECCOMP_GET_ACTION_AVAIL ഉപയോഗിച്ച് പ്രവർത്തനം ലഭ്യമാണെന്ന് ഓപ്പറേഷൻ സൂചിപ്പിച്ചു, എന്നാൽ ആർഗ്യുമെന്റുകളിലെ റിട്ടേണുകളെ കേർണൽ പിന്തുണയ്ക്കുന്നില്ല;

- ESRCH - മറ്റൊരു സ്ട്രീം സമന്വയിപ്പിക്കുമ്പോൾ ഒരു പ്രശ്നം സംഭവിച്ചു;

- ENOSYS - SECCOMP_RET_TRACE പ്രവർത്തനത്തിൽ ട്രെയ്‌സർ ഘടിപ്പിച്ചിട്ടില്ല.

prctl എന്നത് ഒരു പ്രോസസിന്റെ പ്രത്യേക വശങ്ങൾ കൈകാര്യം ചെയ്യാൻ (സജ്ജീകരിക്കാനും നേടാനും) അനുവദിക്കുന്ന ഒരു സിസ്റ്റം കോളാണ്, അതായത് byte endianness, ത്രെഡ് നെയിമുകൾ, സെക്യൂരിറ്റി കമ്പ്യൂട്ടേഷൻ മോഡ് (Seccomp), പ്രത്യേകാവകാശങ്ങൾ, Perf ഇവന്റുകൾ മുതലായവ.

Seccomp നിങ്ങൾക്ക് ഒരു സാൻഡ്‌ബോക്‌സ് സാങ്കേതികവിദ്യയായി തോന്നിയേക്കാം, പക്ഷേ അത് അങ്ങനെയല്ല. ഒരു സാൻഡ്‌ബോക്‌സ് സംവിധാനം വികസിപ്പിക്കാൻ ഉപയോക്താക്കളെ അനുവദിക്കുന്ന ഒരു യൂട്ടിലിറ്റിയാണ് 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),
  };

linux/filter.h ഫയലിൽ നിർവചിച്ചിരിക്കുന്ന BPF_STMT, BPF_JUMP മാക്രോകൾ ഉപയോഗിച്ചാണ് നിർദ്ദേശങ്ങൾ സജ്ജീകരിച്ചിരിക്കുന്നത്.
നമുക്ക് നിർദ്ദേശങ്ങളിലൂടെ പോകാം.

- BPF_STMT(BPF_LD + BPF_W + BPF_ABS (ഓഫ്സെറ്റോഫ്(സ്‌ട്രക്റ്റ് സെക്കോമ്പ്_ഡാറ്റ, ആർച്ച്))) - BPF_LD എന്ന വാക്കിന്റെ രൂപത്തിൽ BPF_LD-ൽ നിന്ന് സിസ്റ്റം ലോഡ് ചെയ്യുകയും ശേഖരിക്കുകയും ചെയ്യുന്നു, പാക്കറ്റ് ഡാറ്റ ഒരു നിശ്ചിത ഓഫ്‌സെറ്റിലാണ് BPF_ABS സ്ഥിതി ചെയ്യുന്നത്.

- BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, arch, 0, 3) - അക്യുമുലേറ്റർ സ്ഥിരാങ്കമായ BPF_K ലെ ആർക്കിടെക്ചർ മൂല്യം കമാനത്തിന് തുല്യമാണോ എന്ന് BPF_JEQ ഉപയോഗിച്ച് പരിശോധിക്കുന്നു. അങ്ങനെയെങ്കിൽ, ഓഫ്‌സെറ്റ് 0-ൽ അടുത്ത നിർദ്ദേശത്തിലേക്ക് ചാടുക, അല്ലെങ്കിൽ കമാനം പൊരുത്തപ്പെടാത്തതിനാൽ ഒരു പിശക് വരുത്തുന്നതിന് ഓഫ്‌സെറ്റ് 3-ൽ (ഈ സാഹചര്യത്തിൽ) ചാടുക.

- BPF_STMT(BPF_LD + BPF_W + BPF_ABS (ഓഫ്‌സെറ്റോഫ്(സ്‌ട്രക്റ്റ് സെക്കോമ്പ്_ഡാറ്റ, എൻആർ))) - BPF_LD എന്ന വാക്കിന്റെ രൂപത്തിൽ BPF_LD-ൽ നിന്ന് ലോഡ് ചെയ്യുകയും ശേഖരിക്കുകയും ചെയ്യുന്നു, ഇത് 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 CBPF ആണ്
കംപൈൽ ചെയ്‌ത ELF ഒബ്‌ജക്റ്റിനോ JIT കംപൈൽ ചെയ്‌ത സി പ്രോഗ്രാമിനോ പകരം നിർദ്ദേശങ്ങളുടെ ഒരു ലിസ്റ്റ് ഉപയോഗിക്കുന്നത് എന്തുകൊണ്ടാണെന്ന് നിങ്ങൾ ചിന്തിച്ചേക്കാം.

ഇതിന് രണ്ട് കാരണങ്ങളുണ്ട്.

• ഒന്നാമതായി, Seccomp cBPF (ക്ലാസിക് BPF) ഉപയോഗിക്കുന്നു, eBPF അല്ല, അതിനർത്ഥം: ഇതിന് രജിസ്റ്ററുകൾ ഇല്ല, പക്ഷേ ഉദാഹരണത്തിൽ കാണുന്നത് പോലെ അവസാന കണക്കുകൂട്ടൽ ഫലം സംഭരിക്കുന്നതിനുള്ള ഒരു അക്യുമുലേറ്റർ മാത്രമാണ്.

• രണ്ടാമതായി, BPF നിർദ്ദേശങ്ങളുടെ ഒരു നിരയിലേക്ക് നേരിട്ട് Seccomp ഒരു പോയിന്റർ സ്വീകരിക്കുന്നു, മറ്റൊന്നും. ഞങ്ങൾ ഉപയോഗിച്ച മാക്രോകൾ പ്രോഗ്രാമർ-സൗഹൃദ രീതിയിൽ ഈ നിർദ്ദേശങ്ങൾ വ്യക്തമാക്കാൻ സഹായിക്കുന്നു.

ഈ അസംബ്ലി മനസ്സിലാക്കാൻ നിങ്ങൾക്ക് കൂടുതൽ സഹായം ആവശ്യമുണ്ടെങ്കിൽ, അതേ കാര്യം ചെയ്യുന്ന സ്യൂഡോകോഡ് പരിഗണിക്കുക:

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 എടുക്കുന്നു. തുടർന്ന് സോക്ക്_ഫ്പ്രോഗ് ടൈപ്പിന്റെ പ്രോഗ് വേരിയബിളിൽ അടങ്ങിയിരിക്കുന്ന SECCOMP_MODE_FILTER ഉപയോഗിച്ച് ഫിൽട്ടർ ലോഡുചെയ്യാൻ ഞങ്ങൾ മോഡിനോട് പറയുന്നു:

  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 ഉപയോഗിക്കേണ്ടതുണ്ട്, അതുവഴി ചൈൽഡ് പ്രോസസ്സുകൾക്ക് അവരുടെ മാതാപിതാക്കളേക്കാൾ കൂടുതൽ പ്രത്യേകാവകാശങ്ങൾ ലഭിക്കുന്ന സാഹചര്യം ഒഴിവാക്കുക. ഇതുപയോഗിച്ച്, റൂട്ട് അവകാശങ്ങളില്ലാതെ ഇൻസ്റ്റോൾ_ഫിൽറ്റർ ഫംഗ്ഷനിൽ നമുക്ക് ഇനിപ്പറയുന്ന 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 ഒബ്ജക്റ്റുകളെ സംരക്ഷിക്കുന്നതിനുള്ള ഒരു കൂട്ടം മെക്കാനിസങ്ങൾ കേർണൽ നടപ്പിലാക്കുന്നു. ഈ സംവിധാനങ്ങളെ ബിപിഎഫ് എൽഎസ്എം ട്രാപ്പുകൾ എന്ന് വിളിക്കുന്നു.

ബിപിഎഫ് എൽഎസ്എം കെണികൾ

സിസ്റ്റം ഇവന്റുകളുടെ ആർക്കിടെക്ചർ-സ്വതന്ത്ര നിരീക്ഷണം നൽകുന്നതിന്, ട്രാപ്പുകൾ എന്ന ആശയം LSM നടപ്പിലാക്കുന്നു. ഒരു ഹുക്ക് കോൾ സാങ്കേതികമായി ഒരു സിസ്റ്റം കോളിന് സമാനമാണ്, എന്നാൽ സിസ്റ്റം സ്വതന്ത്രവും അടിസ്ഥാന സൗകര്യവുമായി സംയോജിപ്പിച്ചതുമാണ്. വ്യത്യസ്‌ത ആർക്കിടെക്ചറുകളിൽ സിസ്റ്റം കോളുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ നേരിടുന്ന പ്രശ്‌നങ്ങൾ ഒഴിവാക്കാൻ ഒരു അബ്‌സ്‌ട്രാക്ഷൻ ലെയറിന് സഹായിക്കുന്ന ഒരു പുതിയ ആശയം എൽഎസ്എം നൽകുന്നു.

എഴുതുമ്പോൾ, കെർണലിന് BPF പ്രോഗ്രാമുകളുമായി ബന്ധപ്പെട്ട ഏഴ് ഹുക്കുകൾ ഉണ്ട്, അവ നടപ്പിലാക്കുന്ന ഒരേയൊരു ബിൽറ്റ്-ഇൻ എൽഎസ്എം ആണ് SELinux.

കെണികൾക്കായുള്ള സോഴ്സ് കോഡ് ഫയലിലെ കേർണൽ ട്രീയിൽ സ്ഥിതിചെയ്യുന്നു 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 പ്രോഗ്രാമുകൾ എങ്ങനെ ഉപയോഗിക്കാമെന്നും ഞങ്ങൾ നിങ്ങൾക്ക് നല്ല ധാരണ നൽകിയിട്ടുണ്ടെന്ന് ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു.

എഴുത്തുകാരെ കുറിച്ച്

ഡേവിഡ് കലവേര Netlify-യിലെ CTO ആണ്. ഡോക്കർ സപ്പോർട്ടിൽ പ്രവർത്തിച്ച അദ്ദേഹം Runc, Go, BCC ടൂളുകളുടെയും മറ്റ് ഓപ്പൺ സോഴ്‌സ് പ്രോജക്ടുകളുടെയും വികസനത്തിന് സംഭാവന നൽകി. ഡോക്കർ പ്രോജക്‌റ്റുകളിലെ പ്രവർത്തനത്തിനും ഡോക്കർ പ്ലഗിൻ ഇക്കോസിസ്റ്റത്തിന്റെ വികസനത്തിനും പേരുകേട്ടതാണ്. ഫ്ലേം ഗ്രാഫുകളിൽ ഡേവിഡ് വളരെ അഭിനിവേശമുള്ളയാളാണ്, മാത്രമല്ല പ്രകടനം ഒപ്റ്റിമൈസ് ചെയ്യാൻ എപ്പോഴും ശ്രമിക്കുന്നു.

ലോറെൻസോ ഫോണ്ടാന സിസ്‌ഡിഗിലെ ഓപ്പൺ സോഴ്‌സ് ടീമിൽ പ്രവർത്തിക്കുന്നു, അവിടെ അദ്ദേഹം പ്രാഥമികമായി ഫാൽക്കോയിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു, ഒരു കെർണൽ മൊഡ്യൂളിലൂടെയും eBPF വഴിയും കണ്ടെയ്‌നർ റൺടൈം സുരക്ഷയും അപാകത കണ്ടെത്തലും നൽകുന്ന ക്ലൗഡ് നേറ്റീവ് കമ്പ്യൂട്ടിംഗ് ഫൗണ്ടേഷൻ പ്രോജക്റ്റ്. ഡിസ്ട്രിബ്യൂട്ടഡ് സിസ്റ്റങ്ങൾ, സോഫ്റ്റ്‌വെയർ നിർവചിക്കപ്പെട്ട നെറ്റ്‌വർക്കിംഗ്, ലിനക്സ് കേർണൽ, പ്രകടന വിശകലനം എന്നിവയിൽ അദ്ദേഹത്തിന് താൽപ്പര്യമുണ്ട്.

» പുസ്തകത്തെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾ ഇവിടെ കാണാം പ്രസാധകന്റെ വെബ്സൈറ്റ്
» ഉള്ളടക്ക പട്ടിക
» ഉദ്ധരണി

ഖബ്രോജിറ്റെലിക്ക് കൂപ്പൺ ഉപയോഗിച്ച് 25% കിഴിവ് - ലിനക്സ്

പുസ്തകത്തിന്റെ പേപ്പർ പതിപ്പ് പണമടയ്ക്കുമ്പോൾ, ഒരു ഇലക്ട്രോണിക് പുസ്തകം ഇ-മെയിൽ വഴി അയയ്ക്കും.

അവലംബം: www.habr.com