Dia duit, Habr! Sa lá atá inniu ba mhaith liom labhairt faoi conas is féidir leat próisis a chosaint ó ionsaithe ó ionsaitheoirí i macOS. Mar shampla, tá sé seo úsáideach le haghaidh frithvíreas nó córas cúltaca, go háirithe ós rud é faoi macOS go bhfuil roinnt bealaí ann chun próiseas a “mharú”. Léigh faoi seo agus modhanna cosanta faoin gearrtha.
An bealach clasaiceach chun próiseas a “mharú”.
Bealach aithnidiúil chun próiseas a “mharú” ná comhartha SIGKILL a sheoladh chuig an bpróiseas. Tríd an bash is féidir leat glaoch ar an gcaighdeán "marú -SIGKILL PID" nó "pkill -9 AINM" a mharú. Tá an t-ordú “marú” ar eolas ó laethanta UNIX agus tá sé ar fáil ní hamháin ar macOS, ach freisin ar chórais eile atá cosúil le UNIX.
Díreach cosúil le córais atá cosúil le UNIX, ceadaíonn macOS duit aon chomharthaí a thascradh chuig próiseas ach amháin dhá cheann - SIGKILL agus SIGSTOP. Díreoidh an t-alt seo go príomha ar chomhartha SIGKILL mar chomhartha a fhágann go maraítear próiseas.
Sonraíochtaí macOS
Ar macOS, glaonn glao an chórais maraithe san eithne XNU an fheidhm psignal(SIGKILL,...). Déanaimis iarracht a fheiceáil cad iad na gníomhartha úsáideora eile sa spás úsáideora is féidir leis an bhfeidhm pssignal a ghlaoch. Déanaimis glaonna ar an bhfeidhm pssignal i meicníochtaí inmheánacha na heithne a ghlanadh (cé go bhféadfadh siad a bheith neamhfhánach, ach fágfaimid iad le haghaidh alt eile 🙂 - fíorú sínithe, earráidí cuimhne, láimhseáil scoir/foirceann, sáruithe cosanta comhad, srl.
Cuirimis tús leis an athbhreithniú leis an bhfeidhm agus leis an nglao córas comhfhreagrach . Is féidir a fheiceáil, chomh maith leis an nglao marú clasaiceach, go bhfuil cur chuige eile ann a bhaineann go sonrach le córas oibriúcháin macOS agus nach bhfuil le fáil i BSD. Tá prionsabail oibriúcháin an dá ghlao córais cosúil freisin. Is glaonna díreacha iad chuig an comhartha feidhme eithne. Tabhair faoi deara freisin, sula maraítear próiseas, go ndéantar seiceáil “canchomhartha” - an féidir leis an bpróiseas comhartha a sheoladh chuig próiseas eile; ní cheadaíonn an córas d’aon fheidhmchlár próisis an chórais a mharú, mar shampla.
static int
terminate_with_payload_internal(struct proc *cur_proc, int target_pid, uint32_t reason_namespace,
uint64_t reason_code, user_addr_t payload, uint32_t payload_size,
user_addr_t reason_string, uint64_t reason_flags)
{
...
target_proc = proc_find(target_pid);
...
if (!cansignal(cur_proc, cur_cred, target_proc, SIGKILL)) {
proc_rele(target_proc);
return EPERM;
}
...
if (target_pid == cur_proc->p_pid) {
/*
* psignal_thread_with_reason() will pend a SIGKILL on the specified thread or
* return if the thread and/or task are already terminating. Either way, the
* current thread won't return to userspace.
*/
psignal_thread_with_reason(target_proc, current_thread(), SIGKILL, signal_reason);
} else {
psignal_with_reason(target_proc, SIGKILL, signal_reason);
}
...
}
seolta
Seoltar an bealach caighdeánach chun deamhan a chruthú ag am tosaithe an chórais agus a saolré a rialú. Tabhair faoi deara le do thoil go mbaineann na foinsí leis an seanleagan de launchctl suas go macOS 10.10, soláthraítear samplaí cód chun críocha léiriúcháin. Seolann launchctl nua-aimseartha comharthaí seolta trí XPC, tá loighic launchctl bogtha chuige.
Breathnaímid ar conas go díreach a stoptar iarratais. Sula seoltar an comhartha SITERM, déantar iarracht an feidhmchlár a stopadh ag baint úsáide as an nglao córais “proc_terminate”.
<launchctl src/core.c>
...
error = proc_terminate(j->p, &sig);
if (error) {
job_log(j, LOG_ERR | LOG_CONSOLE, "Could not terminate job: %d: %s", error, strerror(error));
job_log(j, LOG_NOTICE | LOG_CONSOLE, "Using fallback option to terminate job...");
error = kill2(j->p, SIGTERM);
if (error) {
job_log(j, LOG_ERR, "Could not signal job: %d: %s", error, strerror(error));
}
...
<>
Faoin gcochall, is féidir le proc_terminate, in ainneoin a ainm, ní hamháin psignal a sheoladh le SITERM, ach freisin SIGKILL.
Marú Indíreach - Teorainn Acmhainní
Tá cás níos suimiúla le feiceáil i nglao córais eile . Úsáid choiteann a bhaineann leis an nglao córais seo is ea acmhainní feidhmchláir a theorannú, mar shampla go dteorannódh innéacsóir am LAP agus cuótaí cuimhne ionas nach gcuirfear moill shuntasach ar an gcóras mar gheall ar ghníomhaíochtaí taisceadh comhad. Má tá teorainn acmhainní bainte amach ag feidhmchlár, mar atá le feiceáil ón bhfeidhm proc_apply_resource_actions, seoltar comhartha SIGKILL chuig an bpróiseas.
Cé go bhféadfadh an glao córais seo próiseas a mharú, ní dhearna an córas seiceáil leordhóthanach ar chearta an phróisis a ghlaoigh an glao córais. I ndáiríre seiceáil , ach is leor an bhratach eile PROC_POLICY_ACTION_SET a úsáid chun an coinníoll seo a sheachaint.
Mar sin, má dhéanann tú “teorannú” ar chuóta úsáide LAP an fheidhmchláir (mar shampla, gan ligean ach 1 ns a rith), is féidir leat aon phróiseas sa chóras a mharú. Mar sin, is féidir leis an malware aon phróiseas a mharú ar an gcóras, lena n-áirítear an próiseas antivirus. Is suimiúil freisin an éifeacht a tharlaíonn nuair a dhéantar próiseas a mharú le pid 1 (seoladh) - scaoll eithne agus iarracht á déanamh an comhartha SIGKILL a phróiseáil :)
Conas an fhadhb a réiteach?
Is é an bealach is simplí chun próiseas a chosc ó bheith maraithe ná an pointeoir feidhme a athsholáthar i dtábla glaonna an chórais. Ar an drochuair, tá an modh seo neamh-fánach ar go leor cúiseanna.
Ar an gcéad dul síos, ní hamháin go bhfuil an tsiombail a rialaíonn suíomh cuimhne sysent príobháideach don tsiombail eithne XNU, ach ní féidir í a fháil i siombailí eithne. Beidh ort modhanna cuardaigh heorastúla a úsáid, mar shampla an fheidhm a dhíchóimeáil go dinimiciúil agus pointeoir a chuardach inti.
Ar an dara dul síos, braitheann struchtúr na n-iontrálacha sa tábla ar na bratacha lenar tiomsaíodh an eithne. Má dhearbhaítear an bhratach CONFIG_REQUIRES_U32_MUNGING, athrófar méid an struchtúir - cuirfear réimse breise leis . Is gá seiceáil bhreise a dhéanamh chun a fháil amach cén bhratach ar tiomsaíodh an t-eithne léi, nó mar mhalairt air sin, seiceáil na leideanna feidhme i gcoinne cinn aitheanta.
struct sysent { /* system call table */
sy_call_t *sy_call; /* implementing function */
#if CONFIG_REQUIRES_U32_MUNGING || (__arm__ && (__BIGGEST_ALIGNMENT__ > 4))
sy_munge_t *sy_arg_munge32; /* system call arguments munger for 32-bit process */
#endif
int32_t sy_return_type; /* system call return types */
int16_t sy_narg; /* number of args */
uint16_t sy_arg_bytes; /* Total size of arguments in bytes for
* 32-bit system calls
*/
};
Go fortunately, i leaganacha nua-aimseartha de macOS, soláthraíonn Apple API nua chun oibriú le próisis. Ligeann an Endpoint Security API do chliaint a lán iarratas ar phróisis eile a údarú. Mar sin, is féidir leat aon chomharthaí ar phróisis a bhlocáil, lena n-áirítear an comhartha SIGKILL, ag baint úsáide as an API thuasluaite.
#include <bsm/libbsm.h>
#include <EndpointSecurity/EndpointSecurity.h>
#include <unistd.h>
int main(int argc, const char * argv[]) {
es_client_t* cli = nullptr;
{
auto res = es_new_client(&cli, ^(es_client_t * client, const es_message_t * message) {
switch (message->event_type) {
case ES_EVENT_TYPE_AUTH_SIGNAL:
{
auto& msg = message->event.signal;
auto target = msg.target;
auto& token = target->audit_token;
auto pid = audit_token_to_pid(token);
printf("signal '%d' sent to pid '%d'n", msg.sig, pid);
es_respond_auth_result(client, message, pid == getpid() ? ES_AUTH_RESULT_DENY : ES_AUTH_RESULT_ALLOW, false);
}
break;
default:
break;
}
});
}
{
es_event_type_t evs[] = { ES_EVENT_TYPE_AUTH_SIGNAL };
es_subscribe(cli, evs, sizeof(evs) / sizeof(*evs));
}
printf("%dn", getpid());
sleep(60); // could be replaced with other waiting primitive
es_unsubscribe_all(cli);
es_delete_client(cli);
return 0;
}
Ar an gcaoi chéanna, is féidir Polasaí MAC a chlárú san eithne, a sholáthraíonn modh cosanta comhartha (policy proc_check_signal), ach ní thacaítear leis an API go hoifigiúil.
Cosaint síneadh eithne
Chomh maith le próisis a chosaint sa chóras, is gá freisin an síneadh eithne féin (kext) a chosaint. Soláthraíonn macOS creat d'fhorbróirí chun tiománaithe gléas IOKit a fhorbairt go héasca. Chomh maith le huirlisí a sholáthar chun oibriú le gléasanna, soláthraíonn IOKit modhanna chun tiománaithe a chruachadh ag baint úsáide as cásanna de ranganna C ++. Beidh feidhmchlár sa spás úsáideora in ann “aimsiú” ar chás cláraithe den aicme chun caidreamh eithne-spáis a bhunú.
Chun líon na gcásanna ranga sa chóras a bhrath, tá áirgiúlacht ioclasscount.
my_kext_ioservice = 1
my_kext_iouserclient = 1
Ní mór d’aon síneadh eithne ar mian leis clárú leis an stack tiománaithe aicme a thagann le hoidhreacht ó IOService a dhearbhú, mar shampla my_kext_ioservice sa chás seo. Cruthaítear sampla nua den aicme a fhaigheann oidhreacht ó IOUserClient mar shampla, my_kext_iouserclient nuair a nasctar feidhmchláir úsáideora.
Agus tú ag iarraidh tiománaí a dhíluchtú ón gcóras (ordú kextunload), tugtar an fheidhm fhíorúil “foirceannadh bool (roghanna IOOptionBits)”. Is leor é bréagach a thabhairt ar ais ar an nglao chun deireadh a chur leis agus tú ag iarraidh díluchtú chun kextunload a dhíchumasú.
bool Kext::terminate(IOOptionBits options)
{
if (!IsUnloadAllowed)
{
// Unload is not allowed, returning false
return false;
}
return super::terminate(options);
}
Is féidir leis an IOUserClient an bhratach IsUnloadAllowed a shocrú agus é á luchtú. Nuair a bhíonn teorainn íoslódála ann, tabharfaidh an t-ordú kextunload an t-aschur seo a leanas ar ais:
admin@admins-Mac drivermanager % sudo kextunload ./test.kext
Password:
(kernel) Can't remove kext my.kext.test; services failed to terminate - 0xe00002c7.
Failed to unload my.kext.test - (iokit/common) unsupported function.
Ní mór cosaint den chineál céanna a dhéanamh do IOUserClient. Is féidir cásanna ranganna a dhíluchtú trí úsáid a bhaint as feidhm spás úsáideora IOKitLib “IOCatalogueTerminate(mach_port_t, bratach uint32_t, cur síos io_name_t);”. Is féidir leat bréagach a thabhairt ar ais nuair a ghlaonn tú an t-ordú “foirceannadh” go dtí go “gcuirfidh an t-iarratas userspace bás”, is é sin, ní thugtar an fheidhm “clientDied”.
Cosaint comhaid
Chun comhaid a chosaint, is leor an Kauth API a úsáid, rud a ligeann duit rochtain ar chomhaid a shrianadh. Soláthraíonn Apple fógraí d’fhorbróirí faoi imeachtaí éagsúla sa raon feidhme; dúinne, tá na hoibríochtaí KAUTH_VNODE_DELETE, KAUTH_VNODE_WRITE_DATA agus KAUTH_VNODE_DELETE_CHILD tábhachtach. Is é an bealach is éasca chun rochtain ar chomhaid a shrianadh ná cosán - úsáidimid an API “vn_getpath” chun cosán a fháil chuig an gcomhad agus chun an réimír cosáin a chur i gcomparáid. Tabhair faoi deara, chun athainmniú cosáin fillteán comhaid a bharrfheabhsú, nach n-údaraíonn an córas rochtain ar gach comhad, ach amháin ar an bhfillteán féin atá athainmnithe. Is gá cosán an tuismitheora a chur i gcomparáid agus KAUTH_VNODE_DELETE a shrianadh dó.
D’fhéadfadh feidhmíocht íseal a bheith mar mhíbhuntáiste leis an gcur chuige seo de réir mar a mhéadaíonn líon na réimíreanna. Chun a chinntiú nach bhfuil an chomparáid comhionann le fad O (réimír *), nuair is é an réimír líon na réimíreanna, is é fad fad na sreinge, is féidir leat úsáid a bhaint as uathmhatón críochta cinntitheach (DFA) tógtha ag réimíreanna.
Déanaimis machnamh ar mhodh chun DFA a dhéanamh do thacar áirithe réimíreanna. Cuirimid tús leis na cúrsóirí ag tús gach réimíre. Má dhíríonn gach cúrsóir ar an gcarachtar céanna, méadaigh carachtar amháin gach cúrsóir agus cuimhnigh go bhfuil fad na líne céanna níos mó ná ceann amháin. Má tá dhá chúrsóir ann a bhfuil siombailí difriúla acu, roinn na cúrsóirí ina ngrúpaí de réir na siombaile a díríonn siad uirthi agus déan an algartam do gach grúpa arís.
Sa chéad chás (tá na carachtair go léir faoi na cúrsóirí mar an gcéanna), faigheann muid staid DFA nach bhfuil ach trasdul amháin aige feadh na líne céanna. Sa dara cás, faigheann muid tábla aistrithe méid 256 (líon na gcarachtar agus an líon uasta grúpaí) chuig stáit ina dhiaidh sin a fhaightear trí ghlaoch a chur ar an bhfeidhm go hathchúrsach.
Breathnaímid ar shampla. Le haghaidh sraith réimíreanna (“/ foo/bar/tmp/”, “/var/db/foo/”, “/ foo/bar/aba/”, “foo/bar/aac/”) is féidir leat na rudaí seo a leanas a fháil DFA. Ní léiríonn an figiúr ach aistrithe as a dtagann stáit eile; ní bheidh aistrithe eile críochnaitheach.
Agus tú ag dul trí stáit DKA, d’fhéadfadh 3 chás a bheith ann.
- Tá an staid deiridh bainte amach - tá an cosán cosanta, cuirimid teorainn leis na hoibríochtaí KAUTH_VNODE_DELETE, KAUTH_VNODE_WRITE_DATA agus KAUTH_VNODE_DELETE_CHILD
- Níor thángthas ar an stát deiridh, ach tá an cosán “dar críoch” (sroichtear an Críochnaitheoir nialasach) - is tuismitheoir é an cosán, is gá KAUTH_VNODE_DELETE a theorannú. Tabhair faoi deara más fillteán é vnode, ní mór duit '/' a chur leis ag an deireadh, nó d'fhéadfadh sé é a theorannú go dtí an comhad “/foor/bar/t”, rud atá mícheart.
- Níor thángthas ar an stát deiridh, níor tháinig deireadh leis an gcosán. Níl aon cheann de na réimíreanna ag teacht leis an gceann seo, ní thugaimid srianta isteach.
Conclúid
Is é an sprioc atá leis na réitigh slándála atá á bhforbairt ná leibhéal slándála an úsáideora agus a chuid sonraí a mhéadú. Ar thaobh amháin, baintear an sprioc seo amach trí fhorbairt an táirge bogearraí Acronis, a dhúnann na leochaileachtaí sin ina bhfuil an córas oibriúcháin féin "lag". Ar an láimh eile, níor cheart dúinn faillí a dhéanamh maidir leis na gnéithe slándála sin is féidir a fheabhsú ar thaobh an OS, go háirithe ós rud é go n-ardóidh leochaileachtaí den sórt sin ár gcobhsaíocht féin mar tháirge a dhúnadh. Tuairiscíodh an leochaileacht d'Fhoireann Slándála Táirge Apple agus socraíodh é i macOS 10.14.5 ( https://support.apple.com/en-gb/HT210119 ).
Ní féidir é seo go léir a dhéanamh ach amháin má tá do áirgiúlacht suiteáilte go hoifigiúil isteach san eithne. Is é sin, níl aon bealaí éalaithe den sórt sin ann do bhogearraí seachtracha agus nach dteastaíonn. Mar sin féin, mar a fheiceann tú, tá gá le hobair fiú chun cláir dhlisteanacha a chosaint ar nós frithvíreas agus córais chúltaca. Ach anois beidh cosaint bhreise ag táirgí nua Acronis do macOS ar dhíluchtú ón gcóras.
Foinse: will.com