Dia duit, cónaitheoirí Khabro! Tá an meaisín fíorúil BPF ar cheann de na comhpháirteanna is tábhachtaí den eithne Linux. Cuirfidh a úsáid cheart ar chumas innealtóirí córais lochtanna a aimsiú agus fiú na fadhbanna is casta a réiteach. Foghlaimeoidh tú conas cláir a scríobh a dhéanann monatóireacht agus modhnú ar iompar na heithne, conas cód a chur i bhfeidhm go sábháilte chun monatóireacht a dhéanamh ar imeachtaí san eithne, agus i bhfad níos mó. Cabhróidh David Calavera agus Lorenzo Fontana leat cumhacht BPF a dhíghlasáil. Leathnaigh do chuid eolais ar bharrfheabhsú feidhmíochta, líonrú, slándáil. - Bain úsáid as BPF chun monatóireacht a dhéanamh ar iompar an eithne Linux agus é a mhodhnú. - Instealladh cód chun monatóireacht a dhéanamh go sábháilte ar imeachtaí eithne gan a bheith a ath-thiomsú an eithne nó atosaigh an córas. — Úsáid samplaí áisiúla de chóid in C, Go nó Python. - Smacht a bheith agat trí bheith ina húinéir ar shaolré an chláir BPF.
Slándáil Eithne Linux, A Gnéithe agus Seccomp
Soláthraíonn BPF bealach cumhachtach chun an eithne a leathnú gan cobhsaíocht, slándáil nó luas a íobairt. Ar an gcúis seo, cheap na forbróirí eithne go mbeadh sé ina smaoineamh maith a solúbthacht a úsáid chun leithlisiú próisis a fheabhsú i Seccomp trí scagairí Seccomp a chur i bhfeidhm le tacaíocht ó chláir BPF, ar a dtugtar Seccomp BPF freisin. Sa chaibidil seo míneoimid cad é Seccomp agus conas a úsáidtear é. Ansin beidh tú ag foghlaim conas scagairí Seccomp a scríobh ag baint úsáide as cláir BPF. Tar éis sin, féachfaimid ar na crúcaí BPF ionsuite atá san áireamh san eithne le haghaidh modúil slándála Linux.
Is creat iad Modúil Slándála Linux (LSM) a sholáthraíonn sraith feidhmeanna ar féidir iad a úsáid chun samhlacha slándála éagsúla a chur i bhfeidhm ar bhealach caighdeánaithe. Is féidir LSM a úsáid go díreach sa chrann foinse eithne, mar shampla Apparmor, SELinux agus Tomoyo.
Tosaímid trí chumais Linux a phlé.
Cumais
Is é croílár chumais Linux ná go gcaithfidh tú cead próiseas neamhphríobháideach a dheonú chun tasc áirithe a dhéanamh, ach gan úsáid a bhaint as sagairt chun na críche sin, nó an próiseas a dhéanamh faoi phribhléid ar shlí eile, ag laghdú an fhéidearthacht ionsaí agus ag ligean don phróiseas tascanna áirithe a dhéanamh. Mar shampla, más gá d’iarratas port pribhléid a oscailt, abair 80, in ionad an próiseas a rith mar fhréamh, is féidir leat an cumas CAP_NET_BIND_SERVICE a thabhairt dó.
Smaoinigh ar chlár Go darb ainm main.go:
package main
import (
"net/http"
"log"
)
func main() {
log.Fatalf("%v", http.ListenAndServe(":80", nil))
}Freastalaíonn an clár seo ar fhreastalaí HTTP ar phort 80 (calafort faoi phribhléid é seo). De ghnáth déanaimid é a rith díreach tar éis a thiomsú:
$ go build -o capabilities main.go
$ ./capabilitiesMar sin féin, ós rud é nach bhfuil pribhléidí fréimhe á mbronnadh againn, caithfidh an cód seo earráid agus an port á cheangal:
2019/04/25 23:17:06 listen tcp :80: bind: permission denied
exit status 1Is uirlis é capsh (bainisteoir bhlaosc) a ritheann sliogán le sraith cumais ar leith.
Sa chás seo, mar a luadh cheana, in ionad cearta fréimhe iomlána a dheonú, is féidir leat ceangailteach calafoirt phribhléideach a chumasú tríd an gcumas cap_net_bind_service a sholáthar chomh maith le gach rud eile atá sa chlár cheana féin. Chun seo a dhéanamh, is féidir linn ár gclár a chur faoi iamh i 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"Tuigimid an fhoireann seo beagán.
- capsh - bain úsáid as capsh mar bhlaosc.
- —caps='cap_net_bind_service+eip cap_setpcap, cap_setuid, cap_setgid+ep' - toisc go gcaithfimid an t-úsáideoir a athrú (nílimid ag iarraidh rith mar fhréamh), sonróidh muid cap_net_bind_service agus an cumas an t-aitheantas úsáideora a athrú ó fréamh do dhuine ar bith, eadhon cap_setuid agus cap_setgid.
- —keep=1 — ba mhaith linn na cumais suiteáilte a choinneáil agus sinn ag aistriú ón bhfréamhchuntas.
- —user=“duine ar bith” — ní bheidh an t-úsáideoir deiridh ag rith an chláir aon duine.
- —addamb=cap_net_bind_service — socraigh imréiteach na gcumas gaolmhar tar éis athrú ón modh fréimhe.
- - -c "./capabilities" - ach rith an clár.
Is cineál speisialta cumais iad cumais nasctha a fhaigheann cláir leanaí le hoidhreacht nuair a fheidhmíonn an clár reatha iad ag baint úsáide as execve(). Ní féidir ach cumais a cheadaítear a bheith bainteach, nó i bhfocail eile, mar chumais chomhshaoil, a fháil le hoidhreacht.
Is dócha go bhfuil tú ag smaoineamh ar cad a chiallaíonn +eip tar éis duit an cumas a shonrú sa rogha --caps. Úsáidtear na bratacha seo chun a chinneadh go bhfuil an cumas:
-must a chur i ngníomh (p);
-ar fáil le húsáid (e);
-is féidir iad a oidhreacht le próisis linbh (i).
Ós rud é gur mhaith linn cap_net_bind_service a úsáid, ní mór dúinn é seo a dhéanamh leis an e-bhratach. Ansin cuirfimid tús leis an bhlaosc san ordú. Rithfidh sé seo na cumais dénártha agus ní mór dúinn é a mharcáil leis an mbratach i. Ar deireadh, ba mhaith linn an ghné a chumasú (rinneamar é seo gan an AitheantasÚsáideora a athrú) le p. Tá cuma cap_net_bind_service+eip air.
Is féidir leat an toradh a sheiceáil le ss. Déanaimis an t-aschur a ghiorrú beagán le luí ar an leathanach, ach taispeánfaidh sé an port gaolmhar agus an t-aitheantas úsáideora seachas 0, sa chás seo 65:
# ss -tulpn -e -H | cut -d' ' -f17-
128 *:80 *:*
users:(("capabilities",pid=30040,fd=3)) uid:65534 ino:11311579 sk:2c v6only:0Sa sampla seo d’úsáideamar capsh, ach is féidir leat blaosc a scríobh ag baint úsáide as libcap. Le haghaidh tuilleadh faisnéise, féach Man 3 libcap.
Agus cláir á scríobh, is minic nach mbíonn a fhios ag an bhforbróir roimh ré na gnéithe go léir a theastaíonn ón gclár ag am rite; Ina theannta sin, féadfaidh na gnéithe seo athrú i leaganacha nua.
Chun cumas ár gcláir a thuiscint níos fearr, is féidir linn uirlis chumasach BCC a ghlacadh, a shocraíonn an kprobe don fheidhm eithne 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 1Is féidir linn an rud céanna a bhaint amach trí úsáid a bhaint as bpftrace le kprobe aon-líneála san fheidhm eithne cap_capable:
bpftrace -e
'kprobe:cap_capable {
time("%H:%M:%S ");
printf("%-6d %-6d %-16s %-4d %dn", uid, pid, comm, arg2, arg3);
}'
| grep -i capabilitiesAschuirfidh sé seo rud éigin mar seo a leanas má tá cumas ár gclár cumasaithe tar éis 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 1Is é an cúigiú colún na cumais atá ag teastáil ón bpróiseas, agus ós rud é go n-áirítear an t-aschur seo imeachtaí neamh-iniúchta, feicimid go léir seiceálacha neamh-iniúchta agus ar deireadh an cumas atá ag teastáil leis an bratach iniúchta (an ceann deireanach san aschur) a leagtar go 1. Cumas ceann a bhfuil suim againn ann ná CAP_NET_BIND_SERVICE, sainmhínítear é mar tairiseach sa chód foinse eithne sa chomhad áirítear/uapi/linux/ability.h le haitheantóir 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">Is minic a chumasaítear cumais ag am rite le haghaidh coimeádáin ar nós runC nó Docker chun ligean dóibh rith i mód neamhphribhléideach, ach ní cheadaítear dóibh ach na cumais a theastaíonn chun an chuid is mó d’fheidhmchláir a rith. Nuair a éilíonn feidhmchlár cumais áirithe, is féidir le Docker iad a sholáthar trí úsáid a bhaint as --cap-add:
docker run -it --rm --cap-add=NET_ADMIN ubuntu ip link add dummy0 type dummyTabharfaidh an t-ordú seo an cumas CAP_NET_ADMIN don choimeádán, rud a ligeann dó nasc líonra a chumrú chun an comhéadan dummy0 a chur leis.
Léiríonn an chéad chuid eile conas gnéithe cosúil le scagadh a úsáid, ach ag baint úsáide as teicníc éagsúil a ligeann dúinn ár scagairí féin a chur i bhfeidhm go ríomhchláraithe.
Seccomp
Seasann Seccomp do Ríomhaireacht Shlán agus is ciseal slándála é a chuirtear i bhfeidhm san eithne Linux a ligeann d’fhorbróirí glaonna córais áirithe a scagadh. Cé go bhfuil Seccomp inchomparáide i gcumas le Linux, déanann a chumas glaonna córais áirithe a bhainistiú go bhfuil sé i bhfad níos solúbtha i gcomparáid leo.
Níl gnéithe Seccomp agus Linux comheisiatach agus is minic a úsáidtear iad le chéile chun leas a bhaint as an dá chur chuige. Mar shampla, b'fhéidir gur mhaith leat an cumas CAP_NET_ADMIN a thabhairt do phróiseas ach gan ligean dó glacadh le naisc soicéid, ag cur bac ar ghlaonna córais glactha agus glactha4.
Tá an modh scagtha Seccomp bunaithe ar scagairí BPF a oibríonn sa mhodh SECCOMP_MODE_FILTER, agus déantar scagadh glaonna córais ar an mbealach céanna agus a dhéantar i gcás paicéid.
Lódáiltear scagairí Seccomp le prctl tríd an oibríocht PR_SET_SECCOMP. Tá na scagairí seo i bhfoirm cláir BPF a fhorghníomhaítear do gach paicéad Seccomp arna léiriú ag an struchtúr seccomp_data. Cuimsíonn an struchtúr seo an ailtireacht thagartha, pointeoir do threoracha an phróiseálaí tráth an ghlao córais, agus uasmhéid de shé argóint maidir le glaonna córais, arna chur in iúl mar uint64.
Seo an chuma atá ar an struchtúr seccomp_data ón gcód foinse eithne sa chomhad linux/seccomp.h:
struct seccomp_data {
int nr;
__u32 arch;
__u64 instruction_pointer;
__u64 args[6];
};Mar a fheiceann tú ón struchtúr seo, is féidir linn scagadh de réir ghlao an chórais, a hargóintí, nó meascán den dá cheann.
Tar éis gach paicéad Seccomp a fháil, caithfidh an scagaire próiseáil a dhéanamh chun cinneadh deiridh a dhéanamh agus a insint don eithne cad atá le déanamh ina dhiaidh sin. Cuirtear an cinneadh deiridh in iúl le ceann de na luachanna tuairisceáin (cóid stádais).
- SECCOMP_RET_KILL_PROCESS - maraíonn sé an próiseas iomlán díreach tar éis glao córais a scagadh nach ndéantar mar gheall air seo.
- SECCOMP_RET_KILL_THREAD - críochnaíonn sé an snáithe reatha díreach tar éis glao córais a scagadh nach ndéantar mar gheall air seo.
— SECCOMP_RET_KILL — ailias le haghaidh SECCOMP_RET_KILL_THREAD, fágtha le haghaidh comhoiriúnacht siar.
- SECCOMP_RET_TRAP - tá cosc ar an nglao córais, agus seoltar an comhartha SIGSYS (Drochghlao Córas) chuig an tasc a ghlaonn air.
- SECCOMP_RET_ERRNO - Ní dhéantar an glao córais, agus cuirtear cuid den luach fillte scagaire SECCOMP_RET_DATA ar aghaidh chuig spás úsáideora mar luach errno. Ag brath ar chúis na hearráide, cuirtear luachanna errno éagsúla ar ais. Tá liosta d’uimhreacha earráide ar fáil sa chéad chuid eile.
- SECCOMP_RET_TRACE - Úsáidtear é chun an rianaire ptrace a chur ar an eolas trí úsáid a bhaint as - PTRACE_O_TRACESECCOMP chun idircheapadh nuair a dhéantar glao córais chun an próiseas sin a fheiceáil agus a rialú. Mura bhfuil rianaire ceangailte, cuirtear earráid ar ais, socraítear errno go -ENOSYS, agus ní dhéantar an glao córais.
- SECCOMP_RET_LOG - tá an glao córais réitithe agus logáilte.
- SECCOMP_RET_ALLOW - ní cheadaítear ach glao an chórais.
Is glao córais é ptrace chun meicníochtaí rianaithe a chur i bhfeidhm i bpróiseas ar a dtugtar tracee, a bhfuil an cumas aige monatóireacht agus rialú a dhéanamh ar chur i gcrích an phróisis. Is féidir leis an rianchlár tionchar éifeachtach a imirt ar fheidhmiú agus cláir chuimhne rianaí a mhodhnú. I gcomhthéacs Seccomp, úsáidtear ptrace nuair a spreagann an cód stádais SECCOMP_RET_TRACE é, ionas gur féidir leis an lorgaire cosc a chur ar ghlao an chórais a loighic féin a dhéanamh agus a chur i bhfeidhm.
Earráidí seccomp
Ó am go chéile, agus tú ag obair le Seccomp, tiocfaidh tú trasna ar earráidí éagsúla, a aithnítear le luach aischuir den chineál SECCOMP_RET_ERRNO. Chun earráid a thuairisciú, fillfidh an glao ar an gcóras seccomp -1 in ionad 0.
Is féidir na hearráidí seo a leanas a dhéanamh:
- EACCESS - Níl cead ag an té atá ag glaoch glao córais a dhéanamh. Tarlaíonn sé seo de ghnáth toisc nach bhfuil pribhléidí CAP_SYS_ADMIN aige nó nach bhfuil no_new_privs socraithe ag baint úsáide as prctl (labhróimid faoi seo níos déanaí);
— EFAULT — níl seoladh bailí ag na hargóintí a ritheadh (args sa struchtúr seccomp_data);
— EINVAL — is féidir ceithre chúis a bheith anseo:
-an bhfuil an oibríocht iarrtha anaithnid nó nach bhfuil tacaíocht ag an eithne sa chumraíocht reatha;
-níl na bratacha sonraithe bailí don oibríocht iarrtha;
-operation folaíonn sé BPF_ABS, ach tá fadhbanna leis an fhritháireamh sonraithe, a d'fhéadfadh níos mó ná an méid struchtúr seccomp_data;
- go sáraíonn líon na dtreoracha a chuirtear ar aghaidh chuig an scagaire an t-uasmhéid;
— ENOMEM — gan dóthain cuimhne chun an clár a rith;
- EOPNOTSUPP - léirigh an oibríocht go raibh an gníomh ar fáil le SECCOMP_GET_ACTION_AVAIL, ach ní thacaíonn an eithne le tuairisceáin in argóintí;
— ESRCH — tharla fadhb le linn sruth eile a shioncronú;
- ENOSYS - Níl aon rianaire ceangailte leis an ngníomh SECCOMP_RET_TRACE.
Is glao ar chórais é prctl a ligeann do chlár spáis úsáideora gnéithe sonracha de phróiseas a ionramháil (a shocrú agus a fháil), mar shampla endianness beart, ainmneacha snáithe, modh ríomh slán (Seccomp), pribhléidí, imeachtaí Perf, etc.
Is féidir le Seccomp cosúil le teicneolaíocht bosca gainimh a thabhairt duit, ach níl sé. Is fóntais é Seccomp a ligeann d'úsáideoirí meicníocht bosca gainimh a fhorbairt. Anois, déanaimis féachaint ar conas a chruthaítear cláir idirghníomhaíochta úsáideoirí ag baint úsáide as scagaire a dtugtar glao córas Seccomp air go díreach.
Sampla Scagaire Seccomp BPF
Anseo taispeánfaimid conas an dá ghníomh a pléadh níos luaithe a chur le chéile, eadhon:
— scríobhfaimid clár Seccomp BPF, a úsáidfear mar scagaire le cóid tuairisceáin éagsúla ag brath ar na cinntí a dhéanfar;
— lódáil an scagaire le prctl.
Ar dtús beidh ceanntásca uait ón leabharlann chaighdeánach agus ón eithne 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>Sula ndéanaimid iarracht ar an sampla seo, ní mór dúinn a chinntiú go bhfuil an eithne tiomsaithe le CONFIG_SECCOMP agus CONFIG_SECCOMP_FILTER socraithe go y. Ar mheaisín oibre is féidir leat é seo a sheiceáil mar seo:
cat /proc/config.gz| zcat | grep -i CONFIG_SECCOMP
Is feidhm install_filter dhá chuid é an chuid eile den chód. Sa chéad chuid tá ár liosta de threoracha scagtha 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),
}; Socraítear na treoracha ag baint úsáide as na macraí BPF_STMT agus BPF_JUMP atá sainmhínithe sa chomhad linux/filter.h.
A ligean ar dul tríd na treoracha.
- BPF_STMT(BPF_LD + BPF_W + BPF_ABS (fritháireamh (struct seccomp_data, áirse)))) - lódálann agus carnann an córas ó BPF_LD i bhfoirm an fhocail BPF_W, tá sonraí paicéad suite ag fritháireamh seasta BPF_ABS.
- BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, áirse, 0, 3) - seiceáil trí úsáid a bhaint as BPF_JEQ an bhfuil luach na hailtireachta sa tairiseach carntha BPF_K cothrom leis an áirse. Más ea, léimeann sé ar fhritháireamh 0 go dtí an chéad treoir eile, nó léimeann sé ar fhritháireamh 3 (sa chás seo) chun earráid a chaitheamh toisc nach ionann an áirse.
- BPF_STMT(BPF_LD + BPF_W + BPF_ABS (fritháireamh(struct seccomp_data, nr))) - Lódálann agus carnann ó BPF_LD i bhfoirm an fhocail BPF_W, arb é uimhir ghlao an chórais atá sa fhritháireamh seasta BPF_ABS.
— BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, nr, 0, 1) — déanann sé uimhir ghlao an chórais a chur i gcomparáid le luach na hathróige nr. Más comhionann iad, bogtar ar aghaidh go dtí an chéad treoir eile agus díchumasaítear an glao córais, nó ceadaítear an glao córais le SECCOMP_RET_ALLOW.
- BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ERRNO | (earráid & SECCOMP_RET_DATA)) - críochnaíonn an clár le BPF_RET agus mar thoradh air sin cruthaíonn sé earráid SECCOMP_RET_ERRNO leis an uimhir ón athróg earráide.
- BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ALLOW) - críochnaíonn sé an clár le BPF_RET agus ceadaíonn sé an glao córais a chur i gcrích trí úsáid a bhaint as SECCOMP_RET_ALLOW.
SECCOMP IS CBPF
B’fhéidir go bhfuil tú ag smaoineamh cén fáth a n-úsáidtear liosta treoracha in ionad réad ELF tiomsaithe nó ríomhchlár C tiomsaithe JIT.Tá dhá chúis leis seo.
• Ar an gcéad dul síos, úsáideann Seccomp cBPF (BPF clasaiceach) agus ní eBPF, rud a chiallaíonn: níl aon chláir aige, ach gan ach tiomsaitheoir chun toradh deiridh an ríomha a stóráil, mar atá le feiceáil sa sampla.
• Ar an dara dul síos, glacann Seccomp pointeoir chuig sraith treoracha BPF go díreach agus gan aon rud eile. Ní dhéanann na macraí a d'úsáideamar ach cuidiú leis na treoracha seo a shonrú ar bhealach atá neamhdhíobhálach don ríomhchláraitheoir.
Má theastaíonn tuilleadh cabhrach uait chun an tionól seo a thuiscint, smaoinigh ar an pseudocode a dhéanann an rud céanna:
if (arch != AUDIT_ARCH_X86_64) {
return SECCOMP_RET_ALLOW;
}
if (nr == __NR_write) {
return SECCOMP_RET_ERRNO;
}
return SECCOMP_RET_ALLOW;Tar éis duit an cód scagaire a shainiú sa struchtúr socket_filter, ní mór duit sock_fprog a shainiú ina bhfuil an cód agus fad ríofa an scagaire. Tá gá leis an struchtúr sonraí seo mar argóint chun an próiseas a fhógairt le rith níos déanaí:
struct sock_fprog prog = {
.len = (unsigned short)(sizeof(filter) / sizeof(filter[0])),
.filter = filter,
};Níl ach rud amháin fágtha le déanamh san fheidhm install_filter - lódáil an clár féin! Chun seo a dhéanamh, úsáidimid prctl, ag glacadh PR_SET_SECOMP mar rogha chun dul isteach i mód slán ríomhaireachta. Ansin deirimid an modh chun an scagaire a luchtú ag baint úsáide as SECCOMP_MODE_FILTER, atá san athróg prog cineál sock_fprog:
if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog)) {
perror("prctl(PR_SET_SECCOMP)");
return 1;
}
return 0;
}Ar deireadh, is féidir linn ár bhfeidhm install_filter a úsáid, ach roimhe sin ní mór dúinn prctl a úsáid chun PR_SET_NO_NEW_PRIVS a shocrú don fhorghníomhú reatha agus mar sin an cás a sheachaint ina bhfaigheann próisis leanaí níos mó pribhléidí ná a dtuismitheoirí. Leis seo, is féidir linn na glaonna prctl seo a leanas a dhéanamh sa fheidhm install_filter gan cearta fréimhe a bheith agat.
Anois is féidir linn an fheidhm install_filter a ghlaoch. Déanaimis bac ar gach glao córais a scríobh a bhaineann le hailtireacht X86-64 agus go simplí tabhair cead a chuireann bac ar gach iarracht. Tar éis an scagaire a shuiteáil, leanaimid ar aghaidh leis an bhforghníomhú ag baint úsáide as an gcéad argóint:
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]);
}Ar aghaidh linn. Chun ár gclár a thiomsú is féidir linn clang nó gcc a úsáid, níl le déanamh ach an comhad main.c a thiomsú gan roghanna speisialta:
clang main.c -o filter-writeMar a tugadh faoi deara, chuireamar bac ar gach iontráil sa chlár. Chun é seo a thástáil teastaíonn clár uait a aschuireann rud éigin - is cosúil gur iarrthóir maith é. Seo mar a iompraíonn sí de ghnáth:
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
Iontach! Seo an chuma atá ar ár gclár fillteáin a úsáid: Ní gá dúinn ach an clár a theastaíonn uainn a thástáil mar an gcéad argóint a rith:
./filter-write "ls -la"Nuair a dhéantar é, táirgeann an clár seo aschur go hiomlán folamh. Mar sin féin, is féidir linn strace a úsáid chun a fheiceáil cad atá ar siúl:
strace -f ./filter-write "ls -la"Giorraítear toradh na hoibre go mór, ach léiríonn an chuid chomhfhreagrach de go bhfuil taifid bacáilte leis an earráid EPERM - an ceann céanna a chumraigh muid. Ciallaíonn sé seo nach n-aschuireann an clár rud ar bith toisc nach féidir leis rochtain a fháil ar ghlao an chórais scríobh:
[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)Anois go dtuigeann tú conas a oibríonn Seccomp BPF agus tá smaoineamh maith agat ar cad is féidir leat a dhéanamh leis. Ach nár mhaith leat an rud céanna a bhaint amach le eBPF in ionad cBPF chun leas a bhaint as a chumhacht iomlán?
Agus iad ag smaoineamh ar chláir eBPF, ceapann an chuid is mó daoine go ndéanann siad iad a scríobh go simplí agus iad a luchtú le pribhléidí riarthóra. Cé go bhfuil an ráiteas seo fíor go ginearálta, cuireann an eithne sraith meicníochtaí i bhfeidhm chun réada eBPF a chosaint ar leibhéil éagsúla. Gaistí BPF LSM a thugtar ar na meicníochtaí seo.
Gaistí BPF LSM
Chun monatóireacht a dhéanamh ar ailtireacht-neamhspleách ar imeachtaí córais, cuireann LSM coincheap na gaistí i bhfeidhm. Tá glao crúca cosúil go teicniúil le glao córais, ach tá sé neamhspleách ar an gcóras agus comhtháite leis an mbonneagar. Cuireann LSM coincheap nua ar fáil inar féidir le ciseal astarraingthe cabhrú le fadhbanna a sheachaint nuair a dhéileáiltear le glaonna córais ar ailtireachtaí éagsúla.
Agus é seo á scríobh, tá seacht gcrúcaí ag an eithne a bhaineann le cláir BPF, agus is é SELinux an t-aon LSM tógtha a chuireann i bhfeidhm iad.
Tá cód foinse na gaistí suite sa chrann eithne sa chomhad san áireamh/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);Tabharfar glaoch ar gach ceann acu ag céimeanna éagsúla forghníomhaithe:
— security_bpf — déanann sé seiceáil tosaigh ar ghlaonna córais BPF forghníomhaithe;
- security_bpf_map - seiceálacha nuair a fhilleann an eithne tuairisceoir comhaid don léarscáil;
- security_bpf_prog - seiceálacha nuair a fhilleann an eithne tuairisceoir comhaid don chlár eBPF;
— security_bpf_map_alloc — seiceálann sé cibé an bhfuil an réimse slándála laistigh de léarscáileanna BPF tosaithe;
- security_bpf_map_free - seiceálann sé an bhfuil an réimse slándála glanta laistigh de léarscáileanna BPF;
— security_bpf_prog_alloc — seiceálann sé an bhfuil an réimse slándála tosaithe laistigh de chláir BPF;
- security_bpf_prog_free - seiceálann sé cibé an bhfuil an réimse slándála glanta laistigh de chláir BPF.
Anois, agus é seo go léir á fheiceáil, tuigimid: is é an smaoineamh atá taobh thiar d’idircheapóirí LSM BPF gur féidir leo cosaint a sholáthar do gach réad eBPF, ag cinntiú nach féidir ach leo siúd a bhfuil na pribhléidí cuí acu oibríochtaí a dhéanamh ar chártaí agus ar chláir.
Achoimre
Ní rud í an tslándáil is féidir leat a chur i bhfeidhm ar bhealach amháin a oireann do chách do gach rud is mian leat a chosaint. Tá sé tábhachtach a bheith in ann córais a chosaint ar leibhéil éagsúla agus ar bhealaí éagsúla. Creid é nó ná creid, is é an bealach is fearr chun córas a dhaingniú ná leibhéil éagsúla cosanta a eagrú ó phoist éagsúla, ionas nach gceadaíonn laghdú slándála leibhéal amháin rochtain ar an gcóras iomlán. Tá jab iontach déanta ag na príomhfhorbróirí chun sraith sraitheanna agus pointí tadhaill éagsúla a thabhairt dúinn. Tá súil againn go bhfuil tuiscint mhaith tugtha againn duit ar cad iad na sraitheanna agus conas cláir BPF a úsáid chun oibriú leo.
Maidir leis na húdair
David Calavera an CTO ag Netlify. D’oibrigh sé i dtacaíocht Docker agus chuir sé le forbairt uirlisí Runc, Go agus BCC, chomh maith le tionscadail foinse oscailte eile. Tá aithne air as a chuid oibre ar thionscadail Docker agus ar éiceachóras breiseán Docker a fhorbairt. Tá David thar a bheith paiseanta faoi ghraif lasrach agus bíonn sé i gcónaí ag iarraidh feidhmíocht a bharrfheabhsú.
Lorenzo Fontana oibríonn sé ar an bhfoireann foinse oscailte ag Sysdig, áit a bhfuil sé dírithe go príomha ar Falco, tionscadal Cloud Native Computing Foundation a sholáthraíonn slándáil am rite coimeádáin agus braite aimhrialtacht trí mhodúl eithne agus eBPF. Tá sé paiseanta faoi chórais dáilte, líonrú sainithe bogearraí, an eithne Linux, agus anailís feidhmíochta.
» Le haghaidh tuilleadh eolais faoin leabhar, tabhair cuairt le do thoil
»
»
Le haghaidh Khabrozhiteli lascaine 25% ar an cúpón - Linux
Nuair a íoctar an leagan páipéir den leabhar, seoltar ríomhleabhar chuig an ríomhphost.
Foinse: will.com
