សៀវភៅ "BPF សម្រាប់ការត្រួតពិនិត្យលីនុច"

ជំរាបសួរអ្នកស្រុក Khabro! ម៉ាស៊ីននិម្មិត BPF គឺជាសមាសធាតុសំខាន់បំផុតមួយនៃខឺណែលលីនុច។ ការប្រើប្រាស់ត្រឹមត្រូវរបស់វានឹងអនុញ្ញាតឱ្យវិស្វករប្រព័ន្ធស្វែងរកកំហុស និងដោះស្រាយសូម្បីតែបញ្ហាស្មុគស្មាញបំផុត។ អ្នកនឹងរៀនពីរបៀបសរសេរកម្មវិធីដែលត្រួតពិនិត្យ និងកែប្រែឥរិយាបថរបស់ខឺណែល របៀបអនុវត្តកូដដោយសុវត្ថិភាព ដើម្បីតាមដានព្រឹត្តិការណ៍នៅក្នុងខឺណែល និងច្រើនទៀត។ David Calavera និង Lorenzo Fontana នឹងជួយអ្នកក្នុងការដោះសោថាមពលរបស់ BPF ។ ពង្រីកចំណេះដឹងរបស់អ្នកលើការបង្កើនប្រសិទ្ធភាពប្រតិបត្តិការ បណ្តាញ សុវត្ថិភាព។ - ប្រើ BPF ដើម្បីត្រួតពិនិត្យ និងកែប្រែឥរិយាបថរបស់ខឺណែលលីនុច។ - បញ្ចូលកូដដើម្បីត្រួតពិនិត្យព្រឹត្តិការណ៍ខឺណែលដោយសុវត្ថិភាពដោយមិនចាំបាច់ចងក្រងខឺណែលឡើងវិញ ឬចាប់ផ្ដើមប្រព័ន្ធឡើងវិញ។ - ប្រើឧទាហរណ៍កូដងាយស្រួលនៅក្នុង C, Go ឬ Python ។ - គ្រប់គ្រងដោយជាម្ចាស់នៃវដ្តជីវិតកម្មវិធី BPF ។

សុវត្ថិភាពខឺណែលលីនុច លក្ខណៈពិសេសរបស់វា និង Seccomp

BPF ផ្តល់នូវវិធីដ៏មានអានុភាពដើម្បីពង្រីកខឺណែលដោយមិនលះបង់ស្ថេរភាព សុវត្ថិភាព ឬល្បឿន។ សម្រាប់ហេតុផលនេះ អ្នកអភិវឌ្ឍន៍ខឺណែលបានគិតថា វាជាគំនិតល្អក្នុងការប្រើភាពបត់បែនរបស់វា ដើម្បីបង្កើនភាពឯកោនៃដំណើរការនៅក្នុង Seccomp ដោយអនុវត្តតម្រង Seccomp ដែលគាំទ្រដោយកម្មវិធី BPF ដែលត្រូវបានគេស្គាល់ថា Seccomp BPF ។ នៅក្នុងជំពូកនេះ យើងនឹងពន្យល់ថា Seccomp ជាអ្វី និងរបៀបដែលវាត្រូវបានប្រើ។ បន្ទាប់មកអ្នកនឹងរៀនពីរបៀបសរសេរ Seccomp filters ដោយប្រើកម្មវិធី BPF ។ បន្ទាប់ពីនោះ យើងនឹងពិនិត្យមើលទំពក់ BPF ដែលភ្ជាប់មកជាមួយដែលត្រូវបានរួមបញ្ចូលនៅក្នុងខឺណែលសម្រាប់ម៉ូឌុលសុវត្ថិភាពលីនុច។

ម៉ូឌុលសុវត្ថិភាពលីនុច (LSM) គឺជាក្របខ័ណ្ឌដែលផ្តល់នូវសំណុំនៃមុខងារដែលអាចត្រូវបានប្រើដើម្បីអនុវត្តគំរូសុវត្ថិភាពផ្សេងៗក្នុងលក្ខណៈស្តង់ដារ។ LSM អាចត្រូវបានប្រើដោយផ្ទាល់នៅក្នុងមែកធាងប្រភពខឺណែល ដូចជា Apparmor, SELinux និង Tomoyo ។

ចូរចាប់ផ្តើមដោយការពិភាក្សាអំពីសមត្ថភាពរបស់លីនុច។

លក្ខណៈពិសេស

ខ្លឹមសារនៃសមត្ថភាពរបស់លីនុចគឺថា អ្នកត្រូវផ្តល់ការអនុញ្ញាតដំណើរការដែលគ្មានសិទ្ធិដើម្បីអនុវត្តកិច្ចការជាក់លាក់មួយ ប៉ុន្តែដោយមិនប្រើ 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 និងសមត្ថភាពក្នុងការផ្លាស់ប្តូរលេខសម្គាល់អ្នកប្រើប្រាស់ពិតប្រាកដពី root ទៅគ្មាននរណាម្នាក់គឺ cap_setuid និង cap_setgid ។
• —keep=1 — យើងចង់រក្សាសមត្ថភាពដែលបានដំឡើងនៅពេលប្តូរពីគណនី root ។
• —user=“nobody” — អ្នក​ប្រើ​ចុង​ក្រោយ​ដែល​ដំណើរការ​កម្មវិធី​នឹង​គ្មាន​នរណា​ម្នាក់​ឡើយ។
• —addamb=cap_net_bind_service — កំណត់​ការ​ជម្រះ​សមត្ថភាព​ដែល​ពាក់ព័ន្ធ​បន្ទាប់​ពី​ប្ដូរ​ពី​របៀប root ។
• -c "./capabilities" - គ្រាន់តែដំណើរការកម្មវិធី។

សមត្ថភាពភ្ជាប់គឺជាប្រភេទនៃសមត្ថភាពពិសេសដែលត្រូវបានទទួលមរតកដោយកម្មវិធីកុមារ នៅពេលដែលកម្មវិធីបច្ចុប្បន្នប្រតិបត្តិពួកវាដោយប្រើ exeve()។ មាន​តែ​សមត្ថភាព​ដែល​ត្រូវ​បាន​អនុញ្ញាត​ឱ្យ​ជាប់​ពាក់ព័ន្ធ ឬ​និយាយ​ម្យ៉ាង​ទៀត​ថា​ជា​សមត្ថភាព​បរិស្ថាន​អាច​ត្រូវ​បាន​ទទួល​មរតក។

អ្នកប្រហែលជាឆ្ងល់ថាតើ +eip មានន័យយ៉ាងណាបន្ទាប់ពីបញ្ជាក់សមត្ថភាពនៅក្នុងជម្រើស --caps។ ទង់ទាំងនេះត្រូវបានប្រើដើម្បីកំណត់ថាសមត្ថភាព៖

- ត្រូវតែធ្វើឱ្យសកម្ម (ទំ);

- មានសម្រាប់ប្រើប្រាស់ (អ៊ី);

អាចត្រូវបានទទួលមរតកដោយដំណើរការកុមារ (i) ។

ដោយសារយើងចង់ប្រើ cap_net_bind_service យើងត្រូវធ្វើវាដោយប្រើទង់ e ។ បន្ទាប់មកយើងនឹងបើកសែលនៅក្នុងពាក្យបញ្ជា។ វានឹងដំណើរការប្រព័ន្ធគោលពីរសមត្ថភាព ហើយយើងត្រូវសម្គាល់វាដោយទង់ i ។ ជាចុងក្រោយ យើងចង់បើកមុខងារនេះ (យើងបានធ្វើវាដោយមិនផ្លាស់ប្តូរ 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

ក្នុងឧទាហរណ៍នេះ យើងបានប្រើ 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៖

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 វាត្រូវបានកំណត់ថាជាថេរនៅក្នុងកូដប្រភពខឺណែលក្នុងឯកសាររួមមាន/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

Seccomp តំណាងឱ្យ Secure Computing និងជាស្រទាប់សុវត្ថិភាពដែលត្រូវបានអនុវត្តនៅក្នុងខឺណែលលីនុច ដែលអនុញ្ញាតឱ្យអ្នកអភិវឌ្ឍន៍ត្រងការហៅតាមប្រព័ន្ធមួយចំនួន។ ទោះបីជា Seccomp អាចប្រៀបធៀបសមត្ថភាពទៅនឹងលីនុចក៏ដោយ សមត្ថភាពរបស់វាក្នុងការគ្រប់គ្រងការហៅតាមប្រព័ន្ធមួយចំនួនធ្វើឱ្យវាមានភាពបត់បែនជាងបើប្រៀបធៀបទៅនឹងពួកគេ។

លក្ខណៈពិសេស Seccomp និង Linux គឺមិនផ្តាច់មុខទៅវិញទៅមក ហើយជារឿយៗត្រូវបានគេប្រើជាមួយគ្នាដើម្បីទទួលបានអត្ថប្រយោជន៍ពីវិធីសាស្រ្តទាំងពីរ។ ជាឧទាហរណ៍ អ្នកប្រហែលជាចង់ផ្តល់ដំណើរការនូវសមត្ថភាព CAP_NET_ADMIN ប៉ុន្តែមិនអនុញ្ញាតឱ្យវាទទួលយកការភ្ជាប់រន្ធ រារាំងការទទួល និងទទួលការហៅទូរសព្ទប្រព័ន្ធ 4 ទេ។

វិធីសាស្ត្រចម្រោះ Seccomp គឺផ្អែកលើតម្រង BPF ដែលដំណើរការក្នុងរបៀប SECOMP_MODE_FILTER ហើយការត្រងការហៅតាមប្រព័ន្ធត្រូវបានអនុវត្តតាមរបៀបដូចគ្នានឹងកញ្ចប់ព័ត៌មានដែរ។

តម្រង Seccomp ត្រូវបានផ្ទុកដោយប្រើ prctl តាមរយៈប្រតិបត្តិការ PR_SET_SECOMP ។ តម្រងទាំងនេះយកទម្រង់នៃកម្មវិធី BPF ដែលត្រូវបានប្រតិបត្តិសម្រាប់កញ្ចប់ Seccomp នីមួយៗដែលតំណាងដោយរចនាសម្ព័ន្ធ seccomp_data ។ រចនាសម្ព័ននេះមានស្ថាបត្យកម្មយោង ចង្អុលទៅការណែនាំរបស់ដំណើរការនៅពេលហៅប្រព័ន្ធ និងអាគុយម៉ង់ការហៅប្រព័ន្ធអតិបរមាចំនួនប្រាំមួយ ដែលបង្ហាញជា uint64 ។

នេះជាអ្វីដែលរចនាសម្ព័ន្ធ seccomp_data មើលទៅដូចពីកូដប្រភពខឺណែលនៅក្នុងឯកសារ linux/seccomp.h៖

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 (Bad System Call) ត្រូវបានបញ្ជូនទៅកិច្ចការដែលហៅវា។

- SECOMP_RET_ERRNO - ការហៅប្រព័ន្ធមិនត្រូវបានប្រតិបត្តិទេ ហើយផ្នែកនៃតម្លៃត្រឡប់តម្រង SECOMP_RET_DATA ត្រូវបានបញ្ជូនទៅចន្លោះអ្នកប្រើប្រាស់ជាតម្លៃ errno ។ អាស្រ័យលើមូលហេតុនៃកំហុស តម្លៃ errno ផ្សេងគ្នាត្រូវបានត្រឡប់។ បញ្ជីលេខកំហុសត្រូវបានផ្តល់ជូននៅផ្នែកបន្ទាប់។

- SECOMP_RET_TRACE - ប្រើដើម្បីជូនដំណឹងដល់អ្នកតាមដាន ptrace ដោយប្រើ - PTRACE_O_TRACESECCOMP ដើម្បីស្ទាក់ចាប់នៅពេលដែលការហៅតាមប្រព័ន្ធត្រូវបានប្រតិបត្តិ ដើម្បីមើល និងគ្រប់គ្រងដំណើរការនោះ។ ប្រសិនបើឧបករណ៍តាមដានមិនត្រូវបានភ្ជាប់ទេ កំហុសមួយត្រូវបានត្រលប់មកវិញ errno ត្រូវបានកំណត់ទៅ -ENOSYS ហើយការហៅប្រព័ន្ធមិនត្រូវបានប្រតិបត្តិទេ។

- SECOMP_RET_LOG - ការហៅតាមប្រព័ន្ធត្រូវបានដោះស្រាយ និងចូល។

- SECOMP_RET_ALLOW - ការហៅតាមប្រព័ន្ធត្រូវបានអនុញ្ញាតយ៉ាងសាមញ្ញ។

ptrace គឺជាការហៅប្រព័ន្ធដើម្បីអនុវត្តយន្តការតាមដាននៅក្នុងដំណើរការដែលហៅថា tracee ដែលមានសមត្ថភាពត្រួតពិនិត្យ និងគ្រប់គ្រងការប្រតិបត្តិនៃដំណើរការនេះ។ កម្មវិធីតាមដានអាចមានឥទ្ធិពលលើការប្រតិបត្តិ និងកែប្រែការចុះឈ្មោះសតិរបស់ tracee ។ នៅក្នុងបរិបទ Seccomp ptrace ត្រូវបានប្រើនៅពេលដែលបង្កឡើងដោយលេខកូដស្ថានភាព SECOMP_RET_TRACE ដូច្នេះ tracer អាចការពារការហៅប្រព័ន្ធពីការប្រតិបត្តិ និងអនុវត្តតក្កវិជ្ជាផ្ទាល់ខ្លួនរបស់វា។

កំហុស Seccomp

ពីពេលមួយទៅពេលមួយ ខណៈពេលធ្វើការជាមួយ Seccomp អ្នកនឹងជួបប្រទះបញ្ហាផ្សេងៗ ដែលត្រូវបានកំណត់អត្តសញ្ញាណដោយតម្លៃត្រឡប់មកវិញនៃប្រភេទ SECOMP_RET_ERRNO ។ ដើម្បីរាយការណ៍ពីកំហុស ការហៅប្រព័ន្ធ seccomp នឹងត្រឡប់ -1 ជំនួសឱ្យ 0។

កំហុសខាងក្រោមអាចធ្វើទៅបាន៖

- EACCESS - អ្នកហៅទូរស័ព្ទមិនត្រូវបានអនុញ្ញាតឱ្យធ្វើការហៅតាមប្រព័ន្ធទេ។ វាជាធម្មតាកើតឡើងដោយសារតែវាមិនមានសិទ្ធិ CAP_SYS_ADMIN ឬ no_new_privs មិនត្រូវបានកំណត់ដោយប្រើ prctl (យើងនឹងនិយាយអំពីវានៅពេលក្រោយ);

- EFAULT — អាគុយម៉ង់ដែលបានអនុម័ត (args នៅក្នុងរចនាសម្ព័ន្ធ seccomp_data) មិនមានអាសយដ្ឋានត្រឹមត្រូវទេ។

- EINVAL - វាអាចមានហេតុផលបួនយ៉ាងនៅទីនេះ៖

- ប្រតិបត្តិការដែលបានស្នើគឺមិនស្គាល់ ឬមិនត្រូវបានគាំទ្រដោយខឺណែលក្នុងការកំណត់រចនាសម្ព័ន្ធបច្ចុប្បន្ន។

-ទង់ដែលបានបញ្ជាក់គឺមិនត្រឹមត្រូវសម្រាប់ប្រតិបត្តិការដែលបានស្នើសុំ។

-operation រួមបញ្ចូល BPF_ABS ប៉ុន្តែមានបញ្ហាជាមួយនឹងអុហ្វសិតដែលបានបញ្ជាក់ដែលអាចលើសពីទំហំនៃរចនាសម្ព័ន្ធ seccomp_data ។

- ចំនួនការណែនាំដែលបានបញ្ជូនទៅតម្រងលើសពីអតិបរមា។

— ENOMEM — មិន​មាន​អង្គ​ចងចាំ​គ្រប់គ្រាន់​ដើម្បី​ប្រតិបត្តិ​កម្មវិធី

- EOPNOTSUPP - ប្រតិបត្តិការបានបង្ហាញថាជាមួយនឹង SECOMP_GET_ACTION_AVAIL សកម្មភាពគឺអាចប្រើបាន ប៉ុន្តែខឺណែលមិនគាំទ្រការត្រឡប់មកវិញនៅក្នុងអាគុយម៉ង់ទេ។

- ESRCH — បញ្ហាមួយបានកើតឡើងនៅពេលធ្វើសមកាលកម្មស្ទ្រីមមួយផ្សេងទៀត។

- ENOSYS - មិនមានដានដែលភ្ជាប់ទៅនឹងសកម្មភាព SECOMP_RET_TRACE ទេ។

prctl គឺជាការហៅតាមប្រព័ន្ធដែលអនុញ្ញាតឱ្យកម្មវិធីលំហអ្នកប្រើប្រាស់រៀបចំ (កំណត់ និងទទួលបាន) ទិដ្ឋភាពជាក់លាក់នៃដំណើរការមួយ ដូចជាការបញ្ចប់ដោយបៃ, ឈ្មោះខ្សែស្រឡាយ, របៀបគណនាសុវត្ថិភាព (Secomp), សិទ្ធិ, ព្រឹត្តិការណ៍ Perf ជាដើម។

Seccomp ហាក់ដូចជាបច្ចេកវិទ្យា Sandbox សម្រាប់អ្នក ប៉ុន្តែវាមិនមែនទេ។ Seccomp គឺជាឧបករណ៍ប្រើប្រាស់ដែលអនុញ្ញាតឱ្យអ្នកប្រើបង្កើតយន្តការ sandbox ។ ឥឡូវនេះសូមក្រឡេកមើលពីរបៀបដែលកម្មវិធីអន្តរកម្មអ្នកប្រើប្រាស់ត្រូវបានបង្កើតដោយប្រើតម្រងដែលហៅដោយផ្ទាល់ដោយការហៅប្រព័ន្ធ 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_SECOMP_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, arch, 0, 3) - ពិនិត្យដោយប្រើ BPF_JEQ ថាតើតម្លៃស្ថាបត្យកម្មនៅក្នុង BPF_K accumulator ថេរស្មើនឹង arch ។ បើដូច្នេះ លោតនៅអុហ្វសិត 0 ទៅកាន់ការណែនាំបន្ទាប់ បើមិនដូច្នេះទេ លោតនៅអុហ្វសិត 3 (ក្នុងករណីនេះ) ដើម្បីបោះកំហុសព្រោះ arch មិនស៊ីគ្នា។

- 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 | (error & SECOMP_RET_DATA)) - បញ្ចប់កម្មវិធីជាមួយ BPF_RET ហើយជាលទ្ធផលបង្កើតកំហុស SECOMP_RET_ERRNO ជាមួយនឹងលេខពី err variable។

- BPF_STMT(BPF_RET + BPF_K, SECOMP_RET_ALLOW) - បញ្ចប់កម្មវិធីជាមួយ BPF_RET និងអនុញ្ញាតឱ្យការហៅប្រព័ន្ធដំណើរការដោយប្រើ SECOMP_RET_ALLOW ។

SECOMP គឺ CBPF
អ្នកប្រហែលជាឆ្ងល់ថាហេតុអ្វីបានជាបញ្ជីការណែនាំត្រូវបានប្រើជំនួសឱ្យវត្ថុ ELF ដែលបានចងក្រង ឬកម្មវិធី C ដែលបានចងក្រង JIT ។

មានហេតុផលពីរសម្រាប់រឿងនេះ។

• ទីមួយ Seccomp ប្រើ cBPF (classic BPF) និងមិនមែន eBPF ដែលមានន័យថា៖ វាមិនមានការចុះឈ្មោះទេ ប៉ុន្តែមានតែ accumulator ដើម្បីរក្សាទុកលទ្ធផលគណនាចុងក្រោយ ដូចដែលអាចមើលឃើញនៅក្នុងឧទាហរណ៍។

• ទីពីរ Seccomp ទទួលយកទ្រនិចមួយទៅកាន់អារេនៃការណែនាំ BPF ដោយផ្ទាល់ ហើយគ្មានអ្វីផ្សេងទៀតទេ។ ម៉ាក្រូដែលយើងបានប្រើគ្រាន់តែជួយបញ្ជាក់ការណែនាំទាំងនេះតាមវិធីដែលងាយស្រួលសម្រាប់អ្នកសរសេរកម្មវិធី។

ប្រសិនបើអ្នកត្រូវការជំនួយបន្ថែមទៀតដើម្បីយល់ពីការជួបប្រជុំគ្នានេះ សូមពិចារណា pseudocode ដែលធ្វើដូចគ្នានេះ៖

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_SECOMP ជាជម្រើសមួយដើម្បីបញ្ចូលរបៀបកុំព្យូទ័រដែលមានសុវត្ថិភាព។ បន្ទាប់មកយើងប្រាប់ពីរបៀបផ្ទុកតម្រងដោយប្រើ SECOMP_MODE_FILTER ដែលមាននៅក្នុង prog variable នៃប្រភេទ sock_fprog៖

  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

អស្ចារ្យមែន! នេះជាអ្វីដែលការប្រើប្រាស់កម្មវិធីរុំរបស់យើងមើលទៅដូច៖ យើងគ្រាន់តែឆ្លងកាត់កម្មវិធីដែលយើងចង់សាកល្បងជាអាគុយម៉ង់ទីមួយ៖

./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 ជំនួសឱ្យ cBPF ដើម្បីទាញយកថាមពលពេញលេញរបស់វាទេ?

នៅពេលគិតអំពីកម្មវិធី 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 ដើម្បីធ្វើការជាមួយពួកគេ។

អំពីអ្នកនិពន្ធ

លោក David Calavera គឺជា CTO នៅ Netlify ។ គាត់បានធ្វើការនៅក្នុងផ្នែកគាំទ្រ Docker និងបានរួមចំណែកក្នុងការអភិវឌ្ឍន៍ឧបករណ៍ Runc, Go និង BCC ក៏ដូចជាគម្រោងប្រភពបើកចំហផ្សេងទៀត។ ត្រូវបានគេស្គាល់សម្រាប់ការងាររបស់គាត់លើគម្រោង Docker និងការអភិវឌ្ឍន៍ប្រព័ន្ធអេកូកម្មវិធីជំនួយ Docker ។ David មាន​ចំណង់​ខ្លាំង​ចំពោះ​ក្រាហ្វ​ភ្លើង ហើយ​តែងតែ​សម្លឹង​រក​ការ​បង្កើន​ប្រសិទ្ធភាព​ប្រតិបត្តិការ។

Lorenzo Fontana ធ្វើការលើក្រុមប្រភពបើកចំហនៅ Sysdig ជាកន្លែងដែលគាត់ផ្តោតជាចម្បងលើ Falco ដែលជាគម្រោង Cloud Native Computing Foundation ដែលផ្តល់សុវត្ថិភាពពេលដំណើរការកុងតឺន័រ និងការរកឃើញភាពមិនធម្មតាតាមរយៈម៉ូឌុលខឺណែល និង eBPF ។ គាត់ស្រលាញ់ប្រព័ន្ធចែកចាយ បណ្តាញកំណត់កម្មវិធី លីនុច ខឺណែល និងការវិភាគដំណើរការ។

» ព័ត៌មានលំអិតអំពីសៀវភៅ អាចរកបាននៅ គេហទំព័ររបស់អ្នកបោះពុម្ពផ្សាយ
» តារាងមាតិកា
» សម្រង់

សម្រាប់ Khabrozhiteley ការបញ្ចុះតម្លៃ 25% ដោយប្រើប័ណ្ណ - Linux

នៅពេលបង់ថ្លៃក្រដាស សៀវភៅអេឡិចត្រូនិចនឹងត្រូវបានផ្ញើតាមអ៊ីមែល។

ប្រភព: www.habr.com