ProHoster > Blog > podávání > Kniha "BPF for Linux Monitoring"

Kniha "BPF for Linux Monitoring"

Kniha "BPF for Linux Monitoring"Dobrý den, obyvatelé Khabra! Virtuální stroj BPF je jednou z nejdůležitějších součástí linuxového jádra. Jeho správné použití umožní systémovým inženýrům najít chyby a vyřešit i ty nejsložitější problémy. Dozvíte se, jak psát programy, které monitorují a upravují chování jádra, jak bezpečně implementovat kód pro sledování událostí v jádře a mnoho dalšího. David Calavera a Lorenzo Fontana vám pomohou odemknout sílu BPF. Rozšiřte své znalosti v oblasti optimalizace výkonu, sítí, bezpečnosti. - Použijte BPF k monitorování a úpravě chování linuxového jádra. - Vložení kódu pro bezpečné sledování událostí jádra bez nutnosti překompilovat jádro nebo restartovat systém. — Použijte praktické příklady kódu v C, Go nebo Pythonu. - Převezměte kontrolu vlastnictvím životního cyklu programu BPF.

Linux Kernel Security, jeho funkce a Seccomp

BPF poskytuje výkonný způsob, jak rozšířit jádro bez obětování stability, bezpečnosti nebo rychlosti. Z tohoto důvodu si vývojáři jádra mysleli, že by bylo dobré využít jeho všestrannosti ke zlepšení izolace procesů v Seccompu implementací filtrů Seccomp podporovaných programy BPF, také známými jako Seccomp BPF. V této kapitole vysvětlíme, co je Seccomp a jak se používá. Poté se naučíte psát filtry Seccomp pomocí programů BPF. Poté se podíváme na vestavěné háčky BPF, které jsou součástí jádra pro bezpečnostní moduly Linuxu.

Linux Security Modules (LSM) je rámec, který poskytuje sadu funkcí, které lze použít k implementaci různých modelů zabezpečení standardizovaným způsobem. LSM lze použít přímo ve zdrojovém stromu jádra, jako je Apparmor, SELinux a Tomoyo.

Začněme diskusí o možnostech Linuxu.

Možnosti

Podstatou schopností Linuxu je, že musíte udělit neprivilegovanému procesu oprávnění k provedení určitého úkolu, ale bez použití suid pro tento účel, nebo jinak učinit proces privilegovaným, což snižuje možnost útoku a umožňuje procesu provádět určité úkoly. Pokud například vaše aplikace potřebuje otevřít privilegovaný port, řekněme 80, místo spouštění procesu jako root, můžete jí jednoduše dát schopnost CAP_NET_BIND_SERVICE.

Zvažte program Go s názvem main.go:

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

Tento program obsluhuje HTTP server na portu 80 (toto je privilegovaný port). Obvykle jej spustíme ihned po kompilaci:

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

Protože však neudělujeme oprávnění root, tento kód vyvolá chybu při vázání portu:

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

capsh (shell manager) je nástroj, který spouští shell se specifickou sadou schopností.

V tomto případě, jak již bylo zmíněno, můžete místo udělení úplných práv roota povolit vazbu privilegovaného portu poskytnutím schopnosti cap_net_bind_service spolu se vším ostatním, co je již v programu. Za tímto účelem můžeme náš program uzavřít ve velkých písmenech:

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

Pojďme tomuto týmu trochu rozumět.

  • capsh - použijte capsh jako shell.
  • —caps='cap_net_bind_service+eip cap_setpcap,cap_setuid,cap_setgid+ep' - protože potřebujeme změnit uživatele (nechceme běžet jako root), zadáme cap_net_bind_service a možnost skutečně změnit ID uživatele z root pro nikoho, jmenovitě cap_setuid a cap_setgid.
  • —keep=1 — chceme zachovat nainstalované schopnosti při přechodu z účtu root.
  • —user=“nobody” — koncový uživatel spouštějící program nebude nikdo.
  • —addamb=cap_net_bind_service — nastavení vymazání souvisejících schopností po přepnutí z režimu root.
  • - -c "./capabilities" - stačí spustit program.

Propojené schopnosti jsou speciálním druhem schopností, které dědí podřízené programy, když je aktuální program provádí pomocí execve(). Dědit lze pouze schopnosti, které je povoleno přidružit, nebo jinými slovy jako schopnosti prostředí.

Pravděpodobně se ptáte, co znamená +eip po zadání schopnosti ve volbě --caps. Tyto příznaky se používají k určení, že schopnost:

-musí být aktivován (p);

-k dispozici pro použití (e);

-může být zděděno podřízenými procesy (i).

Protože chceme použít cap_net_bind_service, musíme to udělat s příznakem e. Poté spustíme shell v příkazu. Tím se spustí binární soubor schopností a musíme jej označit příznakem i. Nakonec chceme, aby byla funkce povolena (udělali jsme to bez změny UID) pomocí p. Vypadá to jako cap_net_bind_service+eip.

Výsledek můžete zkontrolovat pomocí ss. Pojďme trochu zkrátit výstup, aby se vešel na stránku, ale zobrazí přidružený port a ID uživatele jiné než 0, v tomto případě 65:

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

V tomto příkladu jsme použili capsh, ale shell můžete napsat pomocí libcap. Další informace najdete v man 3 libcap.

Při psaní programů často vývojář nezná předem všechny funkce, které program potřebuje za běhu; Navíc se tyto funkce mohou v nových verzích změnit.

Abychom lépe porozuměli možnostem našeho programu, můžeme využít nástroj schopný BCC, který nastaví kprobe pro funkci jádra 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

Totéž můžeme dosáhnout použitím bpftrace s jednořádkovou kprobe ve funkci jádra 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

Pokud jsou po kprobe povoleny možnosti našeho programu, vypíše se něco jako následující:

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

Pátý sloupec jsou schopnosti, které proces potřebuje, a protože tento výstup zahrnuje neauditované události, vidíme všechny neauditové kontroly a nakonec požadovanou schopnost s příznakem auditu (poslední ve výstupu) nastaveným na 1. Schopnost. jeden, který nás zajímá, je CAP_NET_BIND_SERVICE, je definován jako konstanta ve zdrojovém kódu jádra v souboru include/uapi/linux/ability.h s identifikátorem 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">

Schopnosti jsou často povoleny za běhu pro kontejnery, jako je runC nebo Docker, aby mohly běžet v neprivilegovaném režimu, ale mají povoleny pouze schopnosti potřebné ke spuštění většiny aplikací. Pokud aplikace vyžaduje určité schopnosti, Docker je může poskytnout pomocí --cap-add:

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

Tento příkaz poskytne kontejneru schopnost CAP_NET_ADMIN, což mu umožní nakonfigurovat síťové propojení pro přidání rozhraní dummy0.

Další část ukazuje, jak používat funkce, jako je filtrování, ale s použitím jiné techniky, která nám umožňuje programově implementovat naše vlastní filtry.

Seccomp

Seccomp je zkratka pro Secure Computing a je bezpečnostní vrstvou implementovanou v jádře Linuxu, která umožňuje vývojářům filtrovat určitá systémová volání. Ačkoli je Seccomp ve schopnostech srovnatelný s Linuxem, jeho schopnost spravovat určitá systémová volání jej činí mnohem flexibilnějším ve srovnání s nimi.

Funkce Seccomp a Linux se vzájemně nevylučují a často se používají společně, aby bylo možné využít obou přístupů. Můžete například chtít dát procesu schopnost CAP_NET_ADMIN, ale nepovolit mu přijímat soketová připojení, čímž blokujete systémová volání accept a accept4.

Metoda filtrování Seccomp je založena na filtrech BPF pracujících v režimu SECCOMP_MODE_FILTER a filtrování systémových volání se provádí stejným způsobem jako u paketů.

Filtry Seccomp se načítají pomocí prctl prostřednictvím operace PR_SET_SECCOMP. Tyto filtry mají podobu programu BPF, který se provádí pro každý paket Seccomp reprezentovaný strukturou seccomp_data. Tato struktura obsahuje referenční architekturu, ukazatel na instrukce procesoru v době systémového volání a maximálně šest argumentů systémového volání, vyjádřených jako uint64.

Takto vypadá struktura seccomp_data ze zdrojového kódu jádra v souboru linux/seccomp.h:

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

Jak můžete vidět z této struktury, můžeme filtrovat podle systémového volání, jeho argumentů nebo kombinace obou.

Po přijetí každého paketu Seccomp musí filtr provést zpracování, aby učinil konečné rozhodnutí a řekl jádru, co má dělat dál. Konečné rozhodnutí je vyjádřeno jednou z návratových hodnot (stavových kódů).

- SECCOMP_RET_KILL_PROCESS - ukončí celý proces okamžitě po odfiltrování systémového volání, které se kvůli tomu neprovede.

- SECCOMP_RET_KILL_THREAD - ukončí aktuální vlákno okamžitě po filtrování systémového volání, které se kvůli tomu neprovede.

— SECCOMP_RET_KILL — alias pro SECCOMP_RET_KILL_THREAD, vlevo pro zpětnou kompatibilitu.

- SECCOMP_RET_TRAP - systémové volání je zakázáno a signál SIGSYS (Bad System Call) je odeslán úloze, která jej volá.

- SECCOMP_RET_ERRNO - Systémové volání není provedeno a část vrácené hodnoty filtru SECCOMP_RET_DATA je předána do uživatelského prostoru jako hodnota errno. V závislosti na příčině chyby jsou vráceny různé hodnoty errno. Seznam čísel chyb je uveden v další části.

- SECCOMP_RET_TRACE - Používá se k upozornění sledovacího zařízení ptrace pomocí - PTRACE_O_TRACESECCOMP k zachycení, když je provedeno systémové volání, aby bylo možné tento proces sledovat a ovládat. Pokud tracer není připojen, vrátí se chyba, errno se nastaví na -ENOSYS a systémové volání se neprovede.

- SECCOMP_RET_LOG - systémové volání je vyřešeno a zaprotokolováno.

- SECCOMP_RET_ALLOW - systémové volání je jednoduše povoleno.

ptrace je systémové volání pro implementaci sledovacích mechanismů v procesu zvaném tracee, se schopností monitorovat a řídit provádění procesu. Program trace může efektivně ovlivňovat provádění a upravovat paměťové registry tracee. V kontextu Seccomp se ptrace používá při spuštění stavovým kódem SECCOMP_RET_TRACE, takže tracer může zabránit provedení systémového volání a implementovat svou vlastní logiku.

Seccomp chyby

Čas od času se při práci se Seccomp setkáte s různými chybami, které jsou identifikovány návratovou hodnotou typu SECCOMP_RET_ERRNO. Chcete-li ohlásit chybu, systémové volání seccomp vrátí -1 místo 0.

Jsou možné následující chyby:

- EACCESS - Volajícímu není povoleno uskutečnit systémové volání. To se obvykle stává, protože nemá oprávnění CAP_SYS_ADMIN nebo no_new_privs není nastaveno pomocí prctl (o tom si povíme později);

— EFAULT — předané argumenty (argumenty ve struktuře seccomp_data) nemají platnou adresu;

— EINVAL — zde mohou být čtyři důvody:

-požadovaná operace je neznámá nebo není podporována jádrem v aktuální konfiguraci;

-určené příznaky nejsou platné pro požadovanou operaci;

-operace zahrnuje BPF_ABS, ale existují problémy se zadaným offsetem, který může přesáhnout velikost struktury seccomp_data;

-počet instrukcí předávaných filtru překračuje maximum;

— ENOMEM — nedostatek paměti ke spuštění programu;

- EOPNOTSUPP - operace ukázala, že s SECCOMP_GET_ACTION_AVAIL byla akce dostupná, ale jádro nepodporuje návraty v argumentech;

— ESRCH — došlo k problému při synchronizaci jiného streamu;

- ENOSYS - K akci SECCOMP_RET_TRACE není připojen žádný sledovač.

prctl je systémové volání, které umožňuje programu v uživatelském prostoru manipulovat (nastavovat a získávat) specifické aspekty procesu, jako je bajt endianness, názvy vláken, režim zabezpečeného výpočtu (Seccomp), oprávnění, události Perf atd.

Seccomp se vám může zdát jako sandboxová technologie, ale není. Seccomp je nástroj, který uživatelům umožňuje vyvinout mechanismus sandboxu. Nyní se podíváme na to, jak se vytvářejí programy pro interakci s uživatelem pomocí filtru volaného přímo systémovým voláním Seccomp.

Příklad filtru BPF Seccomp

Zde si ukážeme, jak zkombinovat dvě výše uvedené akce, konkrétně:

— napíšeme program Seccomp BPF, který bude použit jako filtr s různými návratovými kódy v závislosti na přijatých rozhodnutích;

— načtěte filtr pomocí prctl.

Nejprve potřebujete hlavičky ze standardní knihovny a linuxového jádra:

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

Před pokusem o tento příklad se musíme ujistit, že jádro je zkompilováno s CONFIG_SECCOMP a CONFIG_SECCOMP_FILTER nastavenými na y. Na pracovním stroji to můžete zkontrolovat takto:

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

Zbytek kódu je dvoudílná funkce install_filter. První část obsahuje náš seznam pokynů pro filtrování 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),
  };

Instrukce se nastavují pomocí maker BPF_STMT a BPF_JUMP definovaných v souboru linux/filter.h.
Pojďme si projít pokyny.

- BPF_STMT(BPF_LD + BPF_W + BPF_ABS (offsetof(struct seccomp_data, arch))) - systém se načítá a akumuluje z BPF_LD ve tvaru slova BPF_W, paketová data jsou umístěna na pevném offsetu BPF_ABS.

- BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, oblouk, 0, 3) - kontroluje pomocí BPF_JEQ, zda je hodnota architektury v akumulátorové konstantě BPF_K rovna arch. Pokud ano, skočí na offset 0 na další instrukci, v opačném případě skočí na offset 3 (v tomto případě) a vyvolá chybu, protože oblouk se neshoduje.

- BPF_STMT(BPF_LD + BPF_W + BPF_ABS (offsetof(struct seccomp_data, nr))) - Načte a akumuluje se z BPF_LD ve formě slova BPF_W, což je číslo systémového volání obsažené v pevném offsetu BPF_ABS.

— BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, číslo, 0, 1) — porovná číslo systémového volání s hodnotou proměnné nr. Pokud jsou stejné, přejde k další instrukci a zakáže systémové volání, jinak povolí systémové volání pomocí SECCOMP_RET_ALLOW.

- BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ERRNO | (chyba & SECCOMP_RET_DATA)) - ukončí program s BPF_RET a výsledkem je chyba SECCOMP_RET_ERRNO s číslem z proměnné err.

- BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ALLOW) - ukončí program pomocí BPF_RET a umožní provést systémové volání pomocí SECCOMP_RET_ALLOW.

SECCOMP JE CBPF
Možná se divíte, proč se místo kompilovaného objektu ELF nebo JIT kompilovaného C programu používá seznam instrukcí.

To má dva důvody.

• Za prvé, Seccomp používá cBPF (klasický BPF) a ne eBPF, což znamená: nemá žádné registry, ale pouze akumulátor pro uložení posledního výsledku výpočtu, jak je vidět na příkladu.

• Za druhé, Seccomp přijímá ukazatel na pole instrukcí BPF přímo a nic jiného. Makra, která jsme použili, jednoduše pomáhají specifikovat tyto instrukce programátorsky přívětivým způsobem.

Pokud potřebujete další pomoc s pochopením tohoto sestavení, zvažte pseudokód, který dělá totéž:

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

Po definování kódu filtru ve struktuře socket_filter musíte definovat sock_fprog obsahující kód a vypočítanou délku filtru. Tato datová struktura je potřebná jako argument pro deklarování pozdějšího spuštění procesu:

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

Ve funkci install_filter zbývá udělat jen jednu věc – načíst samotný program! K tomu používáme prctl, přičemž PR_SET_SECCOMP bereme jako možnost pro vstup do zabezpečeného výpočetního režimu. Poté režimu řekneme, aby načetl filtr pomocí SECCOMP_MODE_FILTER, který je obsažen v proměnné prog typu sock_fprog:

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

Nakonec můžeme použít naši funkci install_filter, ale předtím musíme pomocí prctl nastavit PR_SET_NO_NEW_PRIVS pro aktuální provádění a vyhnout se tak situaci, kdy podřízené procesy získají více oprávnění než jejich rodiče. Díky tomu můžeme provést následující volání prctl ve funkci install_filter, aniž bychom měli práva root.

Nyní můžeme zavolat funkci install_filter. Zablokujme všechna systémová volání pro zápis související s architekturou X86-64 a jednoduše udělme povolení, které blokuje všechny pokusy. Po instalaci filtru pokračujeme v provádění pomocí prvního argumentu:

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]);
 }

Začněme. Ke kompilaci našeho programu můžeme použít buď clang nebo gcc, v obou případech je to jen kompilace souboru main.c bez speciálních možností:

clang main.c -o filter-write

Jak bylo uvedeno, zablokovali jsme všechny položky v programu. Chcete-li to otestovat, potřebujete program, který něco vypíše - ls se zdá být dobrým kandidátem. Obvykle se chová takto:

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

Báječné! Zde je návod, jak vypadá použití našeho wrapper programu: Jako první argument jednoduše předáme program, který chceme testovat:

./filter-write "ls -la"

Po spuštění tento program vytvoří zcela prázdný výstup. Můžeme však použít strace, abychom viděli, co se děje:

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

Výsledek práce je značně zkrácen, ale jeho odpovídající část ukazuje, že záznamy jsou blokovány s chybou EPERM - stejnou, jakou jsme nakonfigurovali. To znamená, že program nic nevypisuje, protože nemá přístup k systémovému volání zápisu:

[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)

Nyní chápete, jak Seccomp BPF funguje, a máte dobrou představu o tom, co s ním můžete dělat. Ale nechtěli byste dosáhnout toho samého s eBPF místo cBPF, abyste využili jeho plnou sílu?

Když přemýšlíme o programech eBPF, většina lidí si myslí, že je jednoduše napíší a nahrají s právy správce. I když je toto tvrzení obecně pravdivé, jádro implementuje sadu mechanismů pro ochranu objektů eBPF na různých úrovních. Tyto mechanismy se nazývají BPF LSM pasti.

BPF LSM pasti

Pro zajištění monitorování systémových událostí nezávislé na architektuře implementuje LSM koncept pastí. Hákové volání je technicky podobné systémovému volání, ale je nezávislé na systému a je integrováno s infrastrukturou. LSM poskytuje nový koncept, ve kterém může abstrakční vrstva pomoci vyhnout se problémům při řešení systémových volání na různých architekturách.

V době psaní tohoto článku má jádro sedm háků spojených s programy BPF a SELinux je jediný vestavěný LSM, který je implementuje.

Zdrojový kód pastí je umístěn ve stromu jádra v souboru 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);

Každý z nich bude volán v různých fázích provádění:

— security_bpf — provede počáteční kontrolu provedených systémových volání BPF;

- security_bpf_map - kontroluje, kdy jádro vrací deskriptor souboru pro mapu;

- security_bpf_prog - kontroluje, kdy jádro vrací deskriptor souboru pro program eBPF;

— security_bpf_map_alloc — zkontroluje, zda je inicializováno pole zabezpečení uvnitř map BPF;

- security_bpf_map_free - kontroluje, zda je bezpečnostní pole uvnitř BPF map vymazáno;

— security_bpf_prog_alloc — kontroluje, zda je pole zabezpečení inicializováno uvnitř programů BPF;

- security_bpf_prog_free - kontroluje, zda je v programech BPF vymazáno pole zabezpečení.

Nyní, když to všechno vidíme, rozumíme: myšlenkou zachycovačů LSM BPF je, že mohou poskytnout ochranu každému objektu eBPF a zajistit, že operace s kartami a programy mohou provádět pouze ti, kteří mají příslušná oprávnění.

Shrnutí

Zabezpečení není něco, co můžete implementovat univerzálním způsobem pro vše, co chcete chránit. Je důležité umět chránit systémy na různých úrovních a různými způsoby. Věřte nebo ne, ale nejlepším způsobem, jak zabezpečit systém, je organizovat různé úrovně ochrany z různých pozic, takže snížení zabezpečení jedné úrovně neumožní přístup do celého systému. Hlavní vývojáři odvedli skvělou práci, když nám poskytli sadu různých vrstev a kontaktních bodů. Doufáme, že jsme vám dobře porozuměli tomu, co jsou vrstvy a jak používat programy BPF pro práci s nimi.

O autorech

David Calavera je CTO ve společnosti Netlify. Pracoval v podpoře Dockeru a podílel se na vývoji nástrojů Runc, Go a BCC a dalších open source projektů. Známý svou prací na projektech Docker a vývojem ekosystému pluginů Docker. David je velmi zapálený pro grafy plamenů a vždy se snaží optimalizovat výkon.

Lorenzo Fontana pracuje v open source týmu ve společnosti Sysdig, kde se primárně zaměřuje na Falco, projekt Cloud Native Computing Foundation, který poskytuje zabezpečení kontejnerů a detekci anomálií prostřednictvím modulu jádra a eBPF. Je nadšený pro distribuované systémy, softwarově definované sítě, linuxové jádro a analýzu výkonu.

» Více podrobností o knize naleznete na webové stránky vydavatele
» obsah
» Výňatek

Pro Khabrozhiteley 25% slevu pomocí kupónu - Linux

Po zaplacení papírové verze knihy bude elektronická kniha zaslána e-mailem.

Zdroj: www.habr.com

Přidat komentář