Pagtuklas at Pag-iwas sa Mga Pag-atake sa Pagtakas sa Container

Home » Sawa » Pagtuklas at Pag-iwas sa Mga Pag-atake sa Pagtakas sa Container

Ang pagtakas sa container ay naging isa sa mga paksang nagpapanatili sa cloud at platform team na gising sa gabi dahil ang isang solong maling pagkaka-configure na pod o lumang kernel ay maaaring gawing direktang tulay ang isang nakahiwalay na workload sa pinagbabatayan na host. Kapag nangyari iyon, ang isang attacker ay hindi na nakakahon sa isang container: maaari silang lumipat sa mga node, mag-access ng data mula sa iba pang mga nangungupahan, o kahit na sakupin ang buong cluster.

Ang pag-unawa sa kung paano talaga gumagana ang container escapes – mula sa Linux internals hanggang sa runtime signal at EDR detection – ay ang pagkakaiba sa pagitan ng nakakatakot na buzzword at isang panganib na maaari mong talagang pamahalaan. Sa gabay na ito, tatalakayin natin kung ano ang container sa antas ng OS, kung paano nangyayari ang mga pagtakas sa pagsasanay, ang mga pangunahing diskarte sa pagsasamantala na nakikita sa ligaw, at kung paano tuklasin at pigilan ang mga ito na may mga kakayahan sa pagsubaybay, mga panuntunan ng Falco, mga platform ng CNAPP, at mahusay na makalumang hardening at segmentation.

Ano ang isang container escape at bakit ito mahalaga?

Ang isang container escape ay nangyayari kapag ang isang attacker ay namamahala na sirain ang lohikal na paghihiwalay na dapat maghiwalay ng isang container mula sa host at mula sa iba pang mga container. Sa halip na makulong sa sarili nitong mga namespace at cgroup, ang umaatake ay nakakakuha ng kakayahang magpatakbo ng code na may konteksto sa antas ng host – madalas na may mataas o ganap na mga pribilehiyo.

Ang mga container ay naiiba sa mga virtual machine sa isang mahalagang paraan: lahat sila ay may parehong host kernel. Ang mga teknolohiya tulad ng mga namespace ng Linux (PID, mount, network, atbp.), mga cgroup at kakayahan ay hatiin ang kernel na iyon sa maraming hiwalay na view, ngunit kung hinahayaan ng isang kahinaan o maling configuration ang isang attacker na tumawid sa mga hangganang iyon, ang kompromiso ay maaaring kumalat nang higit pa sa orihinal na na-hack na container.

Mula sa isang pananaw sa negosyo, ang blast radius ng isang matagumpay na pagtakas ang dahilan kung bakit ito mapanganib. Ang isang masusugatan na container na nakaharap sa internet ay maaaring humantong sa pagnanakaw ng sensitibong data, pag-deploy ng mga cryptominer sa sukat, pagkagambala sa mga kritikal na serbisyo at mga pangunahing isyu sa pagsunod sa mga multi-tenant o regulated na kapaligiran.

Karaniwang ginagamit ng mga kalaban ang container escape bilang isang hakbang sa isang mas malawak na chain ng pag-atake: dumarating sila sa isang container na may mababang pribilehiyo (sa pamamagitan ng mga bug ng app, mahinang kredensyal o isyu sa supply chain), pinalalaki ang mga pribilehiyo sa loob ng container, pagkatapos ay lalabas sa host upang mag-pivot sa gilid, mag-harvest ng mga kredensyal, o magtatag ng matibay na pagtitiyaga gaya ng kernel-level rootkit.

Paano gumagana ang mga lalagyan sa ilalim ng hood

Para talagang maunawaan ang mga diskarte sa pagtakas, kailangan mo muna ng mental model kung paano ibinubukod ng Linux container ang mga proseso. Ang container ay mahalagang puno ng proseso na ang mga attribute (mga namespace, kakayahan, cgroup, seccom profile, atbp.) ay na-tweake ng isang container runtime tulad ng containerd, Docker, o CRI‑O at mas malawak. mga teknolohiya ng containerization.

Kapag nagsimula ang isang lalagyan, ang runtime ay naglalabas ng isang proseso at ginagawa itong "init" na proseso ng sarili nitong maliit na uniberso: nakakakuha ito ng sarili nitong PID namespace, mount namespace, network namespace at higit pa, lahat ay ipinapatupad ng kernel. Ang prosesong iyon ay nagpapatupad ng anumang utos na tinukoy sa pagsasaayos ng imahe (hal., ang ENTRYPOINT/CMD ng Dockerfile).

Ang mga kakayahan ay paraan ng Linux upang i-cut ang tradisyunal na pinakamakapangyarihang ugat sa mas maliliit na piraso ng pahintulot. Sa halip na "magagawa ng ugat ang lahat", tinutukoy ng kernel ang mga flag tulad ng CAP_SYS_ADMIN, CAP_NET_ADMIN, CAP_SYS_PTRACE, CAP_SYSLOG at dose-dosenang pa. Ang bawat thread ay nagdadala ng mga hanay ng mga kakayahan (pinahintulutan, epektibo, namamana) na tumutukoy kung aling mga privileged na operasyon ang maaari nitong gawin.

Sinasagot ng mga namespace ang tanong na "saan maaaring gamitin ng isang proseso ang mga kapangyarihan nito?". Halimbawa, ginagawa ng PID namespace ang PID 1 sa loob ng container na hindi nauugnay sa PID 1 sa host, at binibigyan ng mount namespace ang container ng sarili nitong view ng filesystem. Kahit na ang isang proseso ay may kakayahan tulad ng CAP_KILL, sa isang nakakulong na namespace ng PID maaari lamang nitong patayin ang mga prosesong umiiral sa namespace na iyon.

Ang mga Cgroup ay umaakma sa paghihiwalay na iyon sa pamamagitan ng pagkontrol kung gaano karaming mga mapagkukunan ang maaaring masunog ng isang lalagyan – Mga pagbabahagi ng CPU, mga limitasyon sa memorya, I/O, at higit pa. Kasama ng mga seccomp filter (syscall allow/deny list) at mga LSM tulad ng AppArmor o SELinux, makukuha mo ang layered isolation kung saan nakasalalay ang seguridad ng modernong container.

Bakit sinusubukan ng mga umaatake na takasan ang mga lalagyan

Kapag nakompromiso ng isang kalaban ang isang lalagyan, mabilis nilang natuklasan na ang buhay sa loob ay medyo napipigilan: limitadong filesystem, pinaghihigpitang view ng network, maaaring hindi ugat, at karaniwang walang direktang access sa iba pang mga workload.

Ang pagtakas sa host ay nag-aalis ng mga guardrail na iyon. Kung maaari silang magsagawa ng mga utos sa mga unang namespace ng host, makikita nila ang lahat ng mga proseso, mag-mount ng anumang filesystem, mag-ani ng mga kredensyal mula sa mga lugar tulad ng /root/.ssh o mga ahente ng cloud metadata, at mag-pivot sa iba pang mga container o VM.

Ang mga pagtakas ay nagbibigay-daan din sa mahirap-tanggalin ang pagtitiyaga. Sa halip na mag-drop lang ng backdoor sa isang transient na container, maaaring mag-install ang isang attacker ng kernel module, pakialaman ang mga runtime ng container tulad ng runc o containerd, o mag-deploy ng daemonset na nagsisigurong tumatakbo ang isang backdoored pod sa bawat node sa isang Kubernetes cluster.

Mula sa pananaw sa pag-detect, maraming nagsasabi ng mga senyales ng pagtakas ng container na nagsasapawan sa klasikong pagtaas ng pribilehiyo at mga pag-uugali sa paggalaw sa gilid. – paglo-load ng kernel module, kahina-hinala mount/unshare/setns paggamit, direktang pag-access sa mga runtime socket, pagsasamantala ng SUID, at abnormal na pag-access ng file sa mga path ng host na nakalantad sa loob ng mga container.

Mga pangunahing landas patungo sa pagtakas ng container: mga kahinaan, pribilehiyo at maling pagsasaayos

Karamihan sa mga totoong sitwasyon sa pagtakas ng container sa totoong mundo ay nahahati sa tatlong malawak na kategorya: pagsasamantala sa mga kahinaan (kernel o runtime), pag-abuso sa mga lalagyan na may labis na pribilehiyo, o sinasamantala ang mga maling pagsasaayos tulad ng mga mapanganib na mount at nakalantad na socket.

Mga kahinaan sa runtime ng kernel at container

Dahil ang bawat container ay nagbabahagi ng host kernel, ang isang kernel bug ay maaaring mag-alok ng direktang daan upang makatakas. Ang mga sikat na isyu tulad ng Dirty COW (CVE‑2016‑5195) at Dirty Pipe (CVE‑2022‑0847) ay mga lokal na privilege-escalation bug na nagbibigay-daan sa mga attacker na sumulat sa read-only mappings at arbitrary na mga file, na kadalasang nagbibigay-daan sa kanila na pakialaman ang mga binary container.

Ang isang partikular na kritikal na bug na tukoy sa lalagyan ay ang CVE‑2019‑5736 sa runc. Pinayagan nito ang isang proseso sa isang container na i-overwrite ang runc binary sa host kapag nagsimula o naisakatuparan ang container na iyon, na nagbibigay sa attacker na host-level na code execution. Dahil ang runc ay sumasailalim sa Docker, Kubernetes at iba pang mga platform, ang epekto ay malawak.

Kamakailan lamang, ipinakita ng mga pagsisiwalat tulad ng "Leaky Vessels" (hal., CVE‑2024‑21626) na ang mga build system at startup path ay mayabong din.. Hinahayaan ng mga kahinaan sa BuildKit o runc initialization logic ang mga umaatake na lumabas sa panahon ng pagbuo ng imahe o maagang pagsisimula ng container, bago ganap na mailapat ang iba pang mga depensa.

Ang mga container runtime daemon gaya ng containerd, Docker Engine o CRI‑O ay nagkaroon ng sarili nilang bahagi ng mga bug. Halimbawa, ang CVE‑2022‑23648 sa CRI plugin ng containerd ay nagpapahintulot sa mga kalaban na maaaring gumawa ng mga container na mag-mount ng mga sensitibong host path (tulad ng /root/.ssh) sa isang lalagyan at basahin ang data na hinding-hindi nila dapat makita, na nagbibigay ng stepping stone sa ganap na pagtakas.

Mga kilalang container escape CVE at kung paano pagaanin ang mga ito

• CVE‑2019‑5736 (runc): pinayagan ang muling pagsulat ng runc binary ng host mula sa isang lalagyan, nakakaapekto sa Docker, Kubernetes at iba pang runc-based na stack. Kasama sa mga hardening measure ang agresibong pag-patch, pag-scan ng imahe para sa exploit tooling, at pagsubaybay sa runtime ng mga binary modification ng runc.

• CVE‑2016‑5195 (Dirty COW): isang kundisyon ng lahi sa copy-on-write na nagbibigay-daan sa mga unprivileged na proseso na makakuha ng access sa pagsulat sa read-only mappings. Mula sa loob ng isang lalagyan, maaari itong abusuhin upang baguhin ang mga file ng host kung nalantad ang mga ito sa pamamagitan ng mga mount.

• CVE‑2022‑0847 (Dirty Pipe): isa pang kernel bug na nagpapagana ng hindi awtorisadong pagsusulat sa mga file, kasama ang mga naka-mount na read-only sa mga lalagyan. Hindi ito awtomatikong nagbibigay ng pagtakas ngunit maayos na nakakabit sa mga privileged na pag-mount o mga maling pagsasaayos ng runtime.

• CVE‑2024‑21626 at mga kaugnay na isyu sa “Leaky Vessels”: mga depekto sa BuildKit at runc na naglantad sa mga mapagkukunan ng host sa panahon ng pagbuo ng imahe o pagsisimula ng container, na nagpapatunay na ang build pipeline mismo ay maaaring maging bahagi ng attack surface.

Ang mga pagpapagaan para sa buong klase ng mga isyung ito ay umiikot sa patch hygiene at mga pagpipilian sa arkitektura: panatilihing naka-patch ang mga kernel ng host, gumamit ng minimal o distroless na mga base na imahe upang paliitin ang surface ng pag-atake, mas gusto ang mga sandbox o VM-backed na runtime para sa mga high-sensitivity na workload, at patuloy na subaybayan para sa mga kahina-hinalang syscalls at pagsusulat ng file na mukhang mga pagtatangka sa pagsasamantala ng kernel.

Labis na mga kakayahan at privileged container

Ang mga kakayahan ay naimbento upang bawasan ang kapangyarihan ng ugat, ngunit sa pagsasagawa ang "maliit na piraso" ay madalas na pinagsasama-sama.. Ang mga developer na nasa ilalim ng presyon na "gawin lang itong gumana" ay madalas na nagbibigay CAP_SYS_ADMIN o magpatakbo lang ng mga lalagyan bilang --privileged, epektibong nagpapanumbalik ng tulad-ugat na kapangyarihan sa loob ng lalagyan.

CAP_SYS_ADMIN ay kilalang nalulupig: pinapayagan nito ang pag-mount ng mga filesystem, paglikha o pagsali sa mga namespace (unshare, setns), pagsasaayos ng mga cgroup at higit pa. Gamit ang tamang kumbinasyon ng mga mount at namespace, ang isang attacker na may ganitong kakayahan ay maaaring mag-pivot sa paunang namespace ng host at makakuha ng global visibility.

CAP_NET_ADMIN ay katulad na malawak mula sa isang pananaw sa networking. Maaari itong magamit upang muling i-configure ang mga interface, manipulahin ang mga panuntunan ng iptables, at paganahin ang promiscuous mode. Sa isang escape chain, maaari itong abusuhin upang singhutin ang trapiko, i-bypass ang mga patakaran sa network, o tunnel sa paligid ng segmentation.

Ang pagpapatakbo ng isang lalagyan sa ganap na privileged mode ay karaniwang sinasabing "ituring ito bilang bahagi ng host". Nakukuha nito ang lahat ng kakayahan, maa-access ang mga host device, at madalas na nilalampasan ang mga profile ng seccom. Para sa maraming mga chain ng pag-atake, ang pinakamahirap na hakbang ay ang paghahanap lamang ng isang ganoong maling pagkaka-configure na lalagyan at pagkatapos ay gamitin ito bilang isang launch pad.

Ang modernong tooling tulad ng Falco ay nagsimulang ilantad ang mga kakayahan sa antas ng thread para sa pagtuklas. Maaari mo na ngayong suriin ang mga patlang tulad ng thread.cap_effective, thread.cap_permitted at thread.cap_inheritable sa runtime, at mag-trigger ng mga alerto sa tuwing ang isang proseso na may mga peligrosong kakayahan ay nagsasagawa ng mga kahina-hinalang aksyon.

Mga maling pagsasaayos: mga mount, socket at log trick

Ang isang nakakagulat na malaking bahagi ng mga escape ng container ay hindi umaasa sa kakaibang 0‑araw ngunit sa mga simpleng maling configuration. Kapag nag-mount ang mga operator ng mga sensitibong host path sa mga container o inilantad ang mga panloob na Unix socket, kadalasang makakadaan ang mga attacker.

Ang mapanganib na hostPath o mga volume mount ay isang klasikong halimbawa. Kung ang isang container ay makakakuha ng read-write access sa mga direktoryo tulad ng /etc, /proc, /sys or /var/run mula sa host, higit na bumagsak ang modelo ng paghihiwalay. Sumulat sa /proc/sys o maaaring baguhin ng sysfs ang mga parameter ng kernel; access sa host config file tulad ng /etc/shadow maaaring mag-leak ng mga kredensyal.

Ang socket ng Docker (/var/run/docker.sock) at iba pang mga runtime socket ay isa pang masakit na maling pagsasaayos. Ang pag-mount nito sa loob ng isang lalagyan ay nagbibigay sa sinumang kumokontrol sa lalagyan ng halos ganap na kontrol ng Docker daemon. Sa pamamagitan ng simple curl --unix-socket mga tawag, maaaring maglista ang isang attacker ng mga container, gumawa ng bagong privileged container na nag-mount sa host root, at makatakas mula sa helper container na iyon.

Sa Kubernetes, inabuso din ang paghawak ng log ng kubelet at mga host log mount. Kung ang isang pod ay may host /var/log bind-mount at maaaring manipulahin ng isang attacker ang mga log symlink at magbasa ng mga log sa pamamagitan ng API, maaari nilang ituro ang isang log symlink sa mga arbitrary na host file at linlangin ang kubelet na bumalik, sabihin, /etc/shadow nilalaman.

Kahit na ang tila simpleng pag-uugali ng SUID ay maaaring gumanap ng isang papel. Sa mga kapaligiran kung saan ibinabahagi ng container ang user namespace sa host, ang pagtatakda ng SUID bit sa isang binary sa isang nakabahaging direktoryo mula sa loob ng container ay maaaring magamit sa ibang pagkakataon ng isang user na may mababang pribilehiyo na host upang isagawa ang program na iyon na may mga pribilehiyo sa ugat sa host.

Mga diskarte sa pagtakas ng konkretong lalagyan na nakikita sa ligaw

Ang pag-zoom in mula sa mga kategorya hanggang sa mga partikular na diskarte ay nakakatulong sa iyong makilala ang mga pattern sa telemetry at mga ulat ng pagbabanta. Ilang pamilya ng mga pamamaraan ang paulit-ulit na ipinakita ng mga mananaliksik at ginamit sa mga pagsubok sa pagtagos o tunay na pag-atake.

Mga katulong sa user-mode at ang release_agent lansihin

Ang Linux kernel ay naglalantad ng isang function, call_usermodehelper, upang ilunsad ang mga programa ng userland na may mataas na mga pribilehiyo bilang tugon sa mga kaganapan sa kernel‑space. Sa ilalim ng mga tamang kundisyon, ang mga file na kinokontrol ng user ay maaaring makaimpluwensya kung aling programa ang ipapatupad, na ginagawang isang escape vector ang isang lehitimong mekanismo.

Mga Cgroup v1 release_agent ay ang pinakakilalang halimbawa ng pattern na ito. Kapag ang isang cgroup ay naging walang laman at notify_on_release ay pinagana, pinapatakbo ng kernel ang binary na itinuro ng release_agent file. Kung ang isang umaatake sa loob ng isang lalagyan ay maaaring i-mount at manipulahin ang cgroup filesystem na may sapat na pribilehiyo, maaari nilang ituro release_agent sa isang arbitrary executable sa host.

Ang isang karaniwang pagkakasunud-sunod ng pagsasamantala ay halos ganito: lumikha at mag-mount ng direktoryo ng cgroup, paganahin notify_on_release, itakda release_agent sa path ng isang nakakahamak na script sa host namespace, pagkatapos ay alisan ng laman ang listahan ng proseso ng cgroup. Obliging na pinapatakbo ng kernel ang script ng attacker na may mga pribilehiyong tulad ng ugat sa host.

Ang pagtuklas ay nangangailangan ng parehong semantikong pag-unawa sa mga path ng helper ng user-mode at konteksto tungkol sa kung saan nagmula ang mga pagbabago. Ang isang matatag na diskarte ay nagmamapa sa lahat call_usermodehelper tumawag sa mga site, tinutukoy kung alin ang maaaring maimpluwensyahan ng mga file ng user-mode, at pagkatapos ay sinusubaybayan ang pagsusulat sa mga file na iyon kapag nagmula ang mga ito sa mga lalagyan, na nagba-flag ng mga kahina-hinalang pagbabago.

Pagtaas ng pribilehiyo sa host sa pamamagitan ng SUID bits

Ang pamamaraan ng SUID ay hindi isang "purong" container escape dahil ipinapalagay nito na ang attacker ay mayroon nang ilang host access, ngunit ito ay madalas na nakakadena na may access sa lalagyan upang lumipat mula sa mga pinaghihigpitang user ng host patungo sa root.

Ang trick ay nakasalalay sa mga nakabahaging direktoryo sa pagitan ng host at container at isang shared user namespace. Mula sa loob ng isang container na tumatakbo bilang root, ibinabagsak ng isang attacker ang isang executable sa isang direktoryo na makikita sa magkabilang panig (halimbawa, isang shared volume) at itinakda ang SUID bit gamit ang chmod u+s.

Sa paglaon, ang isang non-root na user sa host ay nagsasagawa ng binary na iyon at nakakakuha ng root privilege sa host., dahil ang SUID bit ay binibigyang kahulugan sa konteksto ng host. Ang lalagyan ay ginagamit bilang isang maginhawang lugar upang ihanda ang SUID payload nang walang mga paghihigpit na maaaring umiiral para sa host user na iyon.

Ang kakayahang makita sa pag-abuso sa SUID ay nakatuon sa tatlong sandali: paglikha ng executable sa isang shared path, setting ng SUID/SGID bits mula sa isang container, at execution ng file na iyon sa host ng isang non-root account. Maaaring iugnay ng EDR at mga tool sa seguridad ng runtime ang mga hakbang na ito upang itaas ang mga alerto na may mataas na katapatan.

Pang-aabuso sa runtime socket: Docker at containerd

Ang mga environment ng container ay kadalasang umaasa sa isang client/server architecture, kung saan ang mga CLI tool o orkestrator ay nakikipag-usap sa mga daemon sa pamamagitan ng Unix socket.. Kasama sa mga halimbawa /var/run/docker.sock para sa Docker o /run/containerd/containerd.sock para sa containerd.

Kung ang mga socket file na ito ay naka-mount sa loob ng isang container, ang container na iyon ay maaaring epektibong kumilos bilang isang admin client. Ang isang attacker na nakompromiso sa container ay maaaring magpadala ng mga kahilingan sa API nang diretso sa runtime, maglista ng mga container, magsisimula at huminto sa mga workload, o lumikha ng isang bagung-bagong privileged container na may mga host mount.

Paggamit ng isang generic na tool tulad ng curl, ito ay walang halaga na pindutin ang Docker remote API sa isang Unix socket: tanong /containers/json para magbilang ng mga lalagyan, i-post sa /containers/create na may kahulugan ng JSON para gumawa ng isang may pribilehiyong katulong, pagkatapos ay tumawag /containers/{id}/start upang ilunsad ito. Maaaring i-mount ng helper container ang host root filesystem at bigyan ang attacker ng interactive na access.

Ang mga tagapagtanggol ay maaaring manghuli para dito sa maraming paraan: pagsubaybay sa pag-access sa mga runtime na Unix socket mula sa mga containerized na proseso, pag-detect ng kahina-hinala curl --unix-socket o runtime CLI invocations na nagta-target sa mga socket na iyon, at nag-aalerto sa hindi pangkaraniwang mga pattern ng paggawa ng container (hal., hostPath mounts to /, --privileged sa mga detalye ng Kubernetes).

Mga trick na partikular sa Kubernetes: log mounts at pod escapes

Sa Kubernetes, tina-target ng ilang pag-atake ang mga pag-uugali ng kubelet at mga abstraction ng Kubernetes kaysa sa mga raw na konsepto ng Docker. Mga pod na nag-mount ng mga direktoryo ng host tulad ng /var/log or /var/lib/docker ay partikular na kawili-wili sa mga kalaban.

Inaabuso ng isang ipinakitang paraan kung paano niresolba ng kubelet ang mga symlink kapag nagbabalik ng mga log. Ang bawat pod ay nakakakuha ng log file sa ilalim /var/log na nag-symlink sa direktoryo ng container sa ilalim /var/lib/docker/containers. Kung ang isang attacker ay maaaring gumawa o magbago ng mga symlink sa /var/log sa pamamagitan ng isang hostPath mount, maaari silang mag-redirect ng "log" upang tumuro sa isang arbitrary na file (halimbawa, /etc/shadow).

Kapag tumawag ang isang user o account ng serbisyo na may mga pahintulot sa pagbabasa ng log kubectl logs o ang kaukulang API, sinusundan ng kubelet ang symlink at ibinabalik ang mga nilalaman ng target na iyon. Sa ilang pagkamalikhain, maaaring ilantad ng umaatake ang malalaking bahagi ng host filesystem sa pamamagitan ng serye ng naturang symlinked na "mga log."

Pinagsasama ng mga detection dito ang mga network at filesystem lens: subaybayan ang mga kahilingan ng HTTP-log-read ng Kubernetes para sa mga abnormal na pattern ng path at sabay na panoorin ang paggawa o pagbabago ng symlink sa host's /var/log na nagmumula sa mga containerized na proseso.

Mga sensitibong host mount at direktang pagnanakaw ng data

Minsan ang pagtakas ay binubuo lamang ng pagbabasa o pagbabago ng data ng host mula sa loob ng isang lalagyan nang hindi nagsasagawa ng code sa antas ng host.. Ang mga maling pagkaka-configure na mount na naglalantad ng mga sensitibong direktoryo ay sapat na upang makamit ang malubhang epekto.

Halimbawa, ang isang lalagyan ay maaaring may mount tulad /host_etc turo sa host's /etc direktoryo. Ang isang umaatake na natitisod sa landas na ito ay maaaring magbukas lamang /host_etc/passwd or /host_etc/shadow at epektibo nilang binabasa ang mga file ng pagpapatunay ng host mula sa loob ng lalagyan.

Ang pag-detect ng maling paggamit ng mga naturang mount ay nakakalito dahil maraming mga pattern ng pag-access ang mukhang katulad ng mga normal na operasyon ng file. Hindi ka basta-basta manood /etc/shadow sa loob ng mga lalagyan, dahil karaniwang tumutukoy iyon sa sariling file ng lalagyan, hindi sa host. Kailangan mo ng mapping layer na nagko-convert ng "container path" sa "underlying host path" para sa bawat mount.

Tinutugunan ito ng mga advanced na tool ng EDR at CNAPP sa pamamagitan ng paglutas ng mga mount point at pagsubaybay sa mga access batay sa landas ng host-side. Sa ganoong paraan, ang anumang pagbabasa o pagsusulat na sa huli ay nakakaantig sa isang host-sensitive na file – kahit na sa pamamagitan ng isang hindi nakapipinsalang landas sa loob ng container – ay maaaring i-flag sa real time.

Pag-detect ng mga pagtatangkang pagtakas ng container sa runtime

Mahalaga ang preventive hardening, ngunit kailangan mo rin ng magandang pagtingin sa kung ano ang nangyayari habang tumatakbo ang mga container. Ang mga modernong pag-atake ay kadalasang nakakabit ng maraming hakbang, at ang mahusay na pagsubaybay sa runtime ay nagbibigay sa iyo ng pagkakataong mahuli ang chain bago ito makarating sa host.

Karaniwang pinagsasama ng state-of-the-art detection ang mababang antas ng telemetry (hal., eBPF-based syscall traces) sa behavioral analytics at cloud context. Ang mga hilaw na signal ay nagmumula sa syscalls, file operations, process trees at socket activity; Ang analytics layer ay iniuugnay ang mga ito sa mga pagkakakilanlan, pagkakalantad sa network, at mga cloud asset upang paghiwalayin ang mga benign na aksyon ng admin mula sa mga tunay na pagtatangka sa pagtakas.

Mga pangunahing tagapagpahiwatig sa antas ng syscall

Ang ilang partikular na syscall ay malakas na nauugnay sa aktibidad na lumalabag sa hangganan at dapat makatanggap ng karagdagang pagsisiyasat kapag hinihingi ng mga lalagyan:

• mount, umount, pivot_root – pagmamanipula ng mga pag-mount ng filesystem o pag-pivote ng mga direktoryo ng ugat, kadalasang ginagamit upang i-stitch ang mga host path sa isang container o makatakas sa mga chroots.

• setns, unshare – pagsali o paglikha ng mga bagong namespace, na isang pangunahing hakbang sa mga diskarte na tumalon sa unang namespace ng host.

• ptrace – pag-debug o pag-inject sa ibang mga proseso; kahina-hinala kapag tumatawid sa mga hangganan ng container o nagta-target sa mga daemon ng system.

• capset – pagbabago ng runtime ng mga kakayahan, na posibleng magamit upang makakuha ng mga bagong makapangyarihang flag sa kalagitnaan ng pagpapatupad.

• init_module, finit_module – Ang pag-load ng mga kernel module mula sa isang container ay isang high-risk na gawi na bihirang kailanganin sa mga lehitimong workload.

Hinahayaan ka ng mga engine ng panuntunan tulad ng Falco na magpahayag ng lohika ng pagtuklas sa mga syscall na ito sa paraang may kamalayan sa lalagyan.. Halimbawa, maaari kang mag-alerto sa tuwing may containerized na proseso CAP_SYS_ADMIN nagbubukas ng file na pinangalanan release_agent para sa pagsusulat, na isang napakalakas na indicator ng isang user-mode helper-based na pagtatangka sa pagtakas.

Mga kahina-hinalang pattern ng pag-access ng file

Ang integridad ng file at pagsubaybay sa pag-access ay umaakma sa mga syscall sa pamamagitan ng eksaktong pagpapakita kung aling mga landas ang hinahawakan ng isang attacker. Kapag tiningnan sa pamamagitan ng lens ng container/host mapping, ito ay nagiging isang malakas na escape detector.

• Sumulat sa /proc/sys or /sys mula sa isang container signal ay sumusubok na baguhin ang mga parameter ng kernel o mga setting ng device.

• Access sa container runtime socket tulad ng /var/run/docker.sock or /run/containerd/containerd.sock ay isang pulang bandila kapag nagmumula sa mga pangkalahatang lalagyan ng aplikasyon.

• Mga pagbabago sa /etc/passwd, /etc/shadow or /etc/sudoers sa host sa pamamagitan ng container-visible path mukhang privilege escalation at persistence na hakbang.

• Binabasa mula sa /proc/*/environ or /proc/*/cmdline sa buong namespaces ay maaaring magpahiwatig ng proseso ng enumeration at kredensyal na pag-aani lampas sa sariling puno ng proseso ng lalagyan.

Pinagsasama ng mga pinaka-maaasahang alerto ang maraming salik – path, syscall, mga kakayahan at metadata ng container. Halimbawa, isang mount syscall na nagmula sa isang hindi-admin, internet-exposed na lalagyan ng app na may CAP_SYS_ADMIN at pag-target /proc/sys ay higit na nakakaalarma kaysa sa parehong operasyon mula sa isang kilalang privileged maintenance job.

Mga signal sa antas ng proseso at pag-uugali

Higit pa sa mga raw syscall at file na mga kaganapan, ang mas mataas na antas ng pag-uugali sa proseso ay nagpapakita ng isang kuwento tungkol sa kung ano ang nangyayari. Ang ilang partikular na aktibidad ay hindi pangkaraniwan sa mga normal na microservice ngunit karaniwan sa mga post-exploit na yugto.

• Ang mga interactive na shell ay nabuo mula sa mga non-interactive na lalagyan (halimbawa, /bin/bash lumalabas sa ilalim ng proseso ng web server) magmungkahi ng hands-on na aktibidad sa keyboard.

• Paggamit ng mga tool sa pagpapataas ng pribilehiyo gaya ng sudo, su or newgrp loob ng mga lalagyan, lalo na ang mga hindi nilayon para sa interactive na paggamit, ay lubos na kahina-hinala.

• Pag-scan sa network, pag-ilid na paggalaw ng tool at hindi pangkaraniwang mga papalabas na koneksyon mula sa mga lalagyan na dapat lamang makipag-usap sa isang maliit na hanay ng mga serbisyo ay nagpapahiwatig ng reconnaissance o mga pagtatangka sa pagpapalaganap.

• Mga pirma ng Cryptominer, hindi inaasahang matagal na tumatakbong mga prosesong nakatali sa CPU o pagtaas ng paggamit ng GPU maaaring ihayag na ginamit na ng umaatake ang kanilang access sa antas ng host upang pagkakitaan ang mga mapagkukunan.

Ang mga platform ng EDR at CNAPP na nagpapanatili ng "causality chain" (process tree na may ninuno at kapaligiran) ay kumikinang dito. Nagbibigay-daan ang mga ito sa mga analyst na masubaybayan ang mga kahina-hinalang operasyon pabalik sa pinagmulang larawan ng container, workload ng Kubernetes, cloud account o pipeline ng CI/CD, na ginagawang mas epektibo ang pagsusuri sa ugat at pangmatagalang pag-aayos.

Pag-iwas sa mga pagtakas ng lalagyan: malalim na pagtatanggol

Walang iisang kontrol ang makakagarantiya na hindi ka na kailanman makakaharap sa isang pagtatangkang tumakas sa lalagyan, kaya kailangan mo ng mga layered na depensa mula sa code hanggang sa cloud. Kasama rito ang kalinisan ng imahe, hindi gaanong pribilehiyo, mga hardened na configuration, mga kontrol sa network at malakas na proteksyon sa runtime.

Magpatakbo ng mga lalagyan na may pinakamababang pribilehiyo

Magsimula sa pamamagitan ng walang awa na pagtanggal ng mga hindi kinakailangang pribilehiyo mula sa mga lalagyan. Iwasan ang privileged mode maliban sa napakabihirang, mabigat na kinokontrol na mga kaso, at mas gusto ang mga walang ugat na container o mga namespace ng user upang ang "root inside" ay mapa sa isang walang pribilehiyong user sa host.

Sa Kubernetes, gamitin nang matalino ang mga setting ng securityContext gaya ng runAsNonRoot, runAsUser, allowPrivilegeEscalation: false at readOnlyRootFilesystem: true. Nililimitahan ng mga hadlang na ito kung ano ang magagawa ng isang umaatake kahit na ganap nilang ikompromiso ang runtime ng application.

Ang mga kakayahan ay dapat na mahigpit na saklaw: i-drop ang lahat bilang default at idagdag lamang ang minimal na hanay na kinakailangan para sa workload. Kung talagang kailangan ng isang lalagyan CAP_SYS_ADMIN or CAP_NET_ADMIN, ituring ito bilang isang asset na may mataas na peligro at palibutan ito ng karagdagang pagsubaybay at paghihiwalay ng network.

Ang mga panuntunan sa pag-detect na gumagamit ng mga field ng kakayahan ng Falco ay maaaring kumilos bilang isang safety net para sa mga maling configuration na nakakalusot. Halimbawa, maaaring mag-trigger ang isang panuntunan sa tuwing may containerized na thread CAP_SYS_ADMIN at CAP_DAC_OVERRIDE nagsusulat sa isang file na pinangalanan release_agent, nakakakuha ng malaking uri ng escape exploits na may napakababang ingay.

I-secure ang supply chain ng container

Karamihan sa mga kompromiso ay nagsisimula bago ang runtime, sa anyo ng mga masusugatan o pinakialaman na mga larawan. Ang matatag na seguridad ng imahe ay nagpapahirap sa mga umaatake na makakuha ng maaasahang foothold sa unang lugar.

Gumamit ng mga hardened, minimal na batayang larawan mula sa mga pinagkakatiwalaang registry at panatilihing na-update ang mga ito. Ang mas maliliit na larawan na may mas kaunting mga pakete ay nangangahulugan ng mas kaunting mga aklatan na maaaring naglalaman ng mga mapagsamantalang CVE, at ang mga vendor tulad ng Wiz o mga tagapangasiwa ng distro ay nagbibigay na ngayon ng mga "distroless" na base kung ano lang ang mahigpit na kinakailangan.

Isama ang vulnerability scanning at Software Bills of Materials (SBOMs) sa CI/CD. Dapat na ma-scan ang bawat build bago itulak sa isang registry, at ang mga larawang may hindi na-patch na high-o critical-severity na mga bug na nauugnay sa kanilang pagkakalantad at mga pribilehiyo ay dapat ma-block mula sa pag-deploy.

Isara ang loop ng mga patakaran sa tiwala sa imahe. Mag-sign ng mga larawan sa cryptographically, i-configure ang admission controllers upang tanggihan ang hindi nilagdaan o hindi pinagkakatiwalaang mga larawan, at panatilihin ang visibility kung saan ang mga larawan ay aktwal na tumatakbo sa mga cluster sa paglipas ng panahon upang maaari mong ihinto kaagad ang mga mapanganib na artifact.

Panghuli, unahin ang remediation batay sa tunay na panganib, hindi raw CVE counts. Ang isang kritikal na kahinaan sa isang natutulog, hindi naka-network na batch job na tumatakbo nang walang dagdag na kakayahan ay hindi gaanong kagyat kaysa sa isang "medium" na bug sa isang nakaharap sa internet, may pribilehiyong pod na humahawak ng sensitibong data.

Pagse-segment ng network at proteksyon ng runtime

Kahit na mapunta ang isang umaatake sa isang container, mapipigilan sila ng disenyo ng matalinong network na gawing ganap na paglabag sa cluster. Ang mga patakaran ng butil-butil na network, mga firewall at mga mesh ng serbisyo ay nakakatulong na limitahan ang paggalaw sa gilid.

Ipatupad ang allow-list style na mga patakaran sa network sa Kubernetes kaya maaari lamang makipag-usap ang mga pod sa mga serbisyong talagang kailangan nila. Nililimitahan nito ang kakayahan ng isang attacker na i-scan ang cluster o tumawag sa mga internal management API tulad ng Docker socket o Kubernetes API server.

Ang mga runtime protection system ay nagdaragdag ng mga real-time na preno. Kapag natukoy nila ang pag-uugali na naaayon sa isang container escape (halimbawa, kahina-hinala nsenter paggamit, hostPath mounts to / o containerd socket tampering), maaari nilang harangan o patayin ang mga proseso, ihiwalay ang mga container, o awtomatikong buksan ang mga insidente na may buong forensic trail.

Pinagsasama ng mga platform tulad ng Wiz CNAPP ang mga runtime detection na ito sa cloud context at isang security graph. Sa pamamagitan ng pagmamapa ng mga ugnayan sa pagitan ng mga container, host, pagkakakilanlan, at mga data store, ipinapakita ng mga ito hindi lang na isang pagtakas ang nangyayari, kundi pati na rin kung anong mga sensitibong asset ang nasa blast radius para ma-prioritize ng mga team ang pagtugon.

Patuloy na pagsubaybay at kahandaan sa insidente

Ang mga container ay maikli ang buhay, na nagpapahirap sa classic forensics at log analysis. Kung hindi mo ito pinaplano nang maaga, ang katibayan na kailangan mo upang maunawaan ang isang pagtakas ay maaaring mawala kapag ang pod ay na-reschedule.

Magtatag ng sentralisadong pag-log at koleksyon ng mga sukatan para sa mga runtime ng container, orkestra at host. Tinitiyak ng mga tool tulad ng ELK, Prometheus, at cloud-native log services na ang aktibidad sa proseso, mga kaganapan sa seguridad at mga pagbabago sa configuration ay nakukuha kahit na para sa ephemeral na workload.

Lumikha ng mga playbook na partikular para sa mga sitwasyon ng container escape. Dapat tukuyin ng mga ito kung paano mabilis na i-cordon ang mga node, snapshot disk, mangolekta ng metadata ng container, at makipag-ugnayan sa mga provider ng cloud o mga team ng pagtugon sa insidente kapag naghinala ka ng pagtakas o kompromiso sa antas ng host.

Ang mga vendor gaya ng Palo Alto Networks (Cortex XDR, Prisma Cloud) at iba pa ay nakagawa ng malawak na content ng detection sa paligid ng mga diskarteng inilarawan dito, mula sa user-mode helper abuse hanggang sa runtime socket exploitation at sensitibong mount access, na nagbibigay sa mga defender ng naaaksyunan, mataas na konteksto na alerto sa halip na generic na "kahina-hinalang aktibidad" na ingay.

Ang pagsasama-sama ng lahat ng mga pirasong ito – solidong Linux isolation fundamentals, mahigpit na pribilehiyo, hardened images, network controls, at deep runtime visibility – ginagawa ang container escape mula sa existential threat sa isang mapapamahalaang panganib na maagang matutuklasan ng iyong team, epektibong naglalaman at matuto mula sa para palakasin ang iyong cloud-native na postura ng seguridad sa paglipas ng panahon.