Deep Dive: SELinux op een K3s-host – Type Enforcement, en de twee keer dat het stilletjes niets deed
Hoe SELinux type enforcement echt beslist, hoe het de blog en Nextcloud op K3s insluit – en twee echte gevallen waarin het enforcing was maar niets beschermde: een MariaDB in initrc_t en pods zonder container_t.

🌐 Ook in: English · Deutsch · Français · Español · Italiano · Português · Polski
Deep Dive in de serie rond de Ansible Tour. De tour legt de roles uit, de deep dives de techniek eronder: hoe het werkt, waarom het hier zo wordt gebruikt en wat er onderweg misging.
SELinux is de laag die de meeste beheerders als eerste uitzetten en als laatste begrijpen. Jammer, want het is de enige laag op deze servers die nog standhoudt als een proces al is overgenomen – zelfs een proces dat als root draait. Deze post legt eerst uit hoe SELinux beslist, met de details die in de praktijk tellen: types, transities, categorieën en hoe je een denial leest. Daarna kijkt hij naar de blog en de twee Nextcloud-servers: wat is ingesloten, hoe, en de twee keer dat SELinux aan stond, enforcing, en toch niets beschermde – omdat één enkel detail ergens anders ervoor zorgde dat de juiste regels nooit werden toegepast.
Inhoud
🧭 Hoe SELinux beslist
Discretionary versus mandatory
Klassieke Unix-rechten zijn discretionary: de eigenaar van een bestand bepaalt wie het mag lezen, en root mag alles. SELinux legt daar een mandatory laag bovenop. De kernel vraagt bij elke relevante operatie een centrale policy om toestemming – een bestand openen, een socket verbinden, een signaal sturen, een programma uitvoeren – en het antwoord hangt niet af van wie het bestand bezit of of het proces root is. Beide controles moeten ja zeggen. Een webserver die als root draait kan /etc/shadow nog steeds niet lezen als de policy zijn type niet toestaat het type van dat bestand te lezen.
Labels: vier velden, waarvan er één bijna al het werk doet
Elk proces en elk object – bestand, directory, socket, poort, zelfs de eigen structuren van de kernel – draagt een security context in de vorm user:role:type:level. Op een server met de targeted policy die AlmaLinux meelevert, doen drie van de vier velden er nauwelijks toe: de user is bijna altijd system_u of unconfined_u, de role system_r of object_r. De beslissingen worden genomen door het type. Bij een proces heet het type zijn domain.
$ ps -eZ | grep -E ' (mariadbd|redis-server|php-fpm)$'
system_u:system_r:mysqld_t:s0 ... mariadbd
system_u:system_r:redis_t:s0 ... redis-server
system_u:system_r:container_t:s0:c628,c864 ... php-fpm
$ ls -Zd /var/lib/mysql /var/lib/redis
unconfined_u:object_r:mysqld_db_t:s0 /var/lib/mysql
system_u:object_r:redis_var_lib_t:s0 /var/lib/redis
Labels op bestanden worden als extended attributes (security.selinux) in het bestandssysteem opgeslagen. Waar het label van een bestand vandaan komt, is de bron van de meeste SELinux-ellende, dus het loont de drie wegen te kennen: een nieuw bestand erft het type van zijn bovenliggende directory; een type transition-regel in de policy kan zeggen “bestanden die domain X in een directory van type Y aanmaakt, krijgen type Z”; en restorecon zet labels op basis van de file context-database – regels als /var/lib/mysql(/.*)? → mysqld_db_t, die de policy meelevert en die semanage fcontext uitbreidt. Een bestand verplaatsen behoudt zijn label; kopiëren geeft een nieuw label. Een configbestand dat van een homedirectory naar /etc is verplaatst en daarna onleesbaar is voor zijn service, is de klassieker.
Type enforcement
De policy is in wezen een grote verzameling allow-regels tussen types: allow mysqld_t mysqld_db_t:file { read write open … }; – een proces in domain mysqld_t mag bestanden van type mysqld_db_t lezen en schrijven. Wat niet is toegestaan, wordt geweigerd. De targeted policy op deze hosts bevat ruim meer dan honderdduizend van zulke regels, gecompileerd tot een binary die in de kernel wordt geladen; 439 modules vormen samen het geheel, van apache tot zabbix. De betekenis van de naam “targeted”: alleen services met een eigen module worden ingesloten. Al het andere draait in een unconfined domain dat bijna alles mag – en precies daar, zoals het tweede geval hieronder laat zien, kunnen dingen ongemerkt doorglippen.
Domain transitions – en waarom NoNewPrivileges ze kan tegenhouden
Een proces krijgt zijn domain bij execve(). De regel type_transition init_t mysqld_exec_t:process mysqld_t zegt: als iets in init_t (systemd) een bestand van type mysqld_exec_t uitvoert, draait het nieuwe proces in mysqld_t. Daarom doet het label van een executable er net zo veel toe als het label van de data: een mariadbd-binary met label bin_t zou nooit in zijn domain terechtkomen.
Er is een subtiele wisselwerking met een systemd-optie die verder pure hardeningwinst is. NoNewPrivileges=yes zet de kernelvlag PR_SET_NO_NEW_PRIVS: daarna kan execve() nooit meer privileges krijgen – geen setuid, geen file capabilities. SELinux behandelt een domain transition ook als mogelijke privilegewijziging. Onder NNP staat het een transitie alleen toe als het doeldomain een deelverzameling van het brondomain is (bounded) of als de policy voor dat paar expliciet nnp_transition toekent. Geldt geen van beide, dan wordt de transitie geweigerd – en draait het programma verder in het domain van zijn ouder. Diverse andere sandboxopties van systemd impliceren NNP zonder dat te zeggen. Onthoud dit; het is het eerste geval hieronder.
MCS: het level-veld dat containers uit elkaar houdt
Het vierde veld, het level, staat normaal op s0. Met Multi-Category Security kan het categorieën bevatten: s0:c628,c864. Een proces mag een object alleen benaderen als zijn categorieën die van het object domineren: een proces met c628,c864 kan een bestand met precies die categorieën lezen, of een bestand zonder (s0), maar geen bestand met label c53,c213. Container runtimes gebruiken dit om containers te scheiden die allemaal één type delen: elke pod krijgt zijn eigen willekeurige paar. Alle 46 containerprocessen op een Nextcloud-host draaien als container_t, en toch kan Collabora (c53,c213) niet aan de bestanden van de PHP-container (c628,c864) komen.
Eén gevolg zie je makkelijk over het hoofd: een hostdirectory die in pods is gemount en het label container_file_t:s0 heeft – zonder categorieën – is bereikbaar voor elke container. MCS isoleert de eigen bestandssystemen van de containers, geen gedeelde volumes. Op deze servers hoort elke HostPath-directory bij precies één applicatie, dus dat is prima; op een multi-tenant node zou dat niet zo zijn.
Een denial lezen
Als de policy nee zegt, schrijft de kernel een AVC-bericht (access vector cache) naar het auditlog. Dit kwam van de backupcontrole van de file-integrity-tool, en het bevat alles wat je nodig hebt om het te begrijpen:
type=AVC msg=audit(...): avc: denied { getattr } for pid=... comm="aide"
name="/" dev="vda2" scontext=system_u:system_r:aide_t:s0
tcontext=system_u:object_r:dosfs_t:s0 tclass=filesystem permissive=0
Lees het als een zin: het proces aide, draaiend in domain aide_t, wilde getattr op een object van klasse filesystem met type dosfs_t – de vfat-EFI-partitie – en werd geweigerd (permissive=0). ausearch -m AVC -ts today vindt zulke berichten, audit2why legt uit welke regel ontbreekt of welke boolean het zou toestaan. audit2allow -M zou een module schrijven die precies toestaat wat werd geweigerd – en dat is het gevaarlijkste commando in SELinux-beheer, omdat het elk symptoom in een toestemming verandert zonder te vragen of de toegang legitiem was.
🛡️ Waarom het overal aan staat
Alle drie de servers draaien de targeted policy in enforcing-modus, en elke role gaat daarvan uit. De reden is een dreigingsmodel, geen vinkje. De realistische aanval op een blog is een kwetsbare WordPress-plugin; op Nextcloud een kwaadaardig document dat de officesuite misbruikt. In beide gevallen eindigt de aanvaller met code-uitvoering binnen een PHP- of Collabora-proces. Alles daarna – de databasebestanden direct lezen, SSH-sleutels stelen, een binary op de host planten, de andere applicatie aanvallen – hangt af van wat dat proces mag. Unix-rechten helpen daar weinig; in een container is het proces vaak toch al root. SELinux is de laag die “nee” zegt, los van user-ID’s.
- Een PHP-FPM-worker in
container_tkan alleencontainer_file_tschrijven – zijn eigen volume. De policy bevat geen regel diecontainer_ttoestaatshadow_tte lezen, dus/etc/shadowblijft buiten bereik, zelfs voor een rootproces dat uit zijn mount namespace is ontsnapt. - De MariaDB op de host in
mysqld_tmag zijn eigenmysqld_db_tlezen en schrijven, zijn poort binden en weinig meer. Een gecompromitteerde databaseserver kan de Nextcloud-gebruikersdata in/dataniet lezen, want die iscontainer_file_t. - Redis in
redis_tnet zo: zijn eigenredis_var_lib_t, zijn poort, zijn socket. - Kernelmodules, raw devices, ptrace op andere domains: standaard voor al deze processen geweigerd.
De kosten zijn klein zodra de labels kloppen. Bijna elk SELinux-probleem op deze hosts was tot nu toe een ontbrekend of verkeerd label, geen ontbrekende regel – en de policy voor databases, Redis en containers komt kant-en-klaar mee met de distributie en container-selinux.
🔧 Wat deze repository doet
common_selinux: enforcing en de juiste labels
De role zet de modus op enforcing met de targeted policy en labelt de hostdirectories die de pods mounten. Welke directories hangt af van de stack: het playbook zet de variabele stack, en een dictionary kiest het profiel – webroot en databasedirectory voor de blog, webroot en gebruikersdata voor Nextcloud. Voor elke directory voegt de role een persistente file-contextregel toe en past die toe.
De les: Bijna elk SELinux-probleem hier was een verkeerd label, geen ontbrekende regel. Een label hoort als persistente regel in de policy, niet via chcon op het bestand – anders haalt de volgende relabel het weg.
Geval 1: een database die enforcing was – en unconfined
In september hardde een systemd-drop-in de MariaDB op de host van de Nextcloud-servers: geen capabilities, read-only bestandssysteem behalve de datadirectory, privé-/tmp, een system-callfilter – en, expliciet en impliciet, NoNewPrivileges. MariaDB startte, Nextcloud werkte, de drop-in leek een duidelijke verbetering. Vijf weken later liet een blik op de draaiende processen dit zien:
$ ps -eZ | grep mariadbd
system_u:system_r:initrc_t:s0 ... mariadbd
initrc_t in plaats van mysqld_t. De unit van de distributie start mariadbd niet direct, maar via /bin/sh -c, om eerst een Galera-recoveryhelper te draaien. De shell draait in initrc_t; als die mariadbd uitvoert, moet de transitie naar mysqld_t plaatsvinden – en onder NNP staat de policy die vanuit initrc_t niet toe. Het auditlog zei het, bij elke start, in een regel die niemand had gelezen: avc: denied { nnp_transition } … scontext=…initrc_t… tcontext=…mysqld_t… tclass=process2. De database bleef draaien in het domain van de shell, dat veel minder beperkt is. Van 11 september tot 16 oktober was de MariaDB op de host in feite helemaal niet door SELinux ingesloten.
De oplossing is één regel in de drop-in: start de binary direct, zonder de shell (Galera wordt hier niet gebruikt, dus de helper heeft niets te doen):
ExecStart=
ExecStart=/usr/sbin/mariadbd $MYSQLD_OPTS $_WSREP_NEW_CLUSTER
Direct door systemd uitgevoerd is de transitie vanuit init_t toegestaan, en ps -eZ toont weer mysqld_t. Het is eerst getest met systemd-run en dezelfde properties, zodat de wijziging nooit op de productiedatabase hoefde te worden uitgeprobeerd.
De les: “Enforcing” betekent niet dat een service is ingesloten. Na elke wijziging aan een unit laat ps -eZ zien in welk domain het proces echt draait; systemctl status doet dat niet.
Geval 2: pods die nooit als container_t draaiden
Het tweede geval is groter. SELinux stond op alle drie de servers op enforcing, de hostdirectories hadden container_file_t, container-selinux was geïnstalleerd – en op 19 oktober, terwijl deze serie werd geschreven, liet ps -eZ zien dat geen enkele pod als container_t draaide. Op de blog waren ze spc_t (“super privileged container”, praktisch unconfined), op de Nextcloud-servers unconfined_service_t.
Er ontbraken twee dingen. K3s start zijn ingebouwde containerd alleen met SELinux-ondersteuning als de configuratie selinux: true zegt; anders is enable_selinux van containerd false en vraagt het de policy nooit om een containerlabel. En K3s heeft zijn eigen policypakket nodig, k3s-selinux, dat de binary het label container_runtime_exec_t geeft zodat hij als container_runtime_t draait. Op de blog had het installatiescript dat pakket ooit eens toegevoegd; op de Nextcloud-servers was de binary gewoon bin_t, dus startte systemd hem als unconfined_service_t, en elk kindproces erfde dat. Al het zorgvuldige labelwerk aan de volumes was voorbereiding geweest op een controle die nooit plaatsvond.
common_k3s doet nu vier dingen:
- voegt de ondertekende pakketrepository van Rancher toe en installeert
k3s-selinux, - zet
selinux: truein/etc/rancher/k3s/config.yaml, - draait
restorecon -v /usr/local/bin/k3sna elke download van de binary –get_urlvervangt het bestand via een tijdelijk bestand in dezelfde directory, waardoor de nieuwe binary hetbin_tvan de directory krijgt en de policy bij de volgende upgrade stilletjes ongedaan zou maken, - en maakt alle workloads één keer opnieuw aan, zolang nog geen enkele pause-container als
container_tdraait. Pods houden het domain waarmee ze zijn gestart; een configuratiewijziging alleen sluit niets in wat al draait.
Daarna het beeld op een Nextcloud-server: 46 processen in container_t, elke pod met zijn eigen categoriepaar, alleen geprivilegieerde pods in spc_t, en geen enkele AVC – niet van Nextcloud, niet van Collabora met zijn mount namespaces, niet van notify_push. Collabora was het onderdeel met het meeste potentieel voor problemen, omdat het voor elk document een jail met bind mounts bouwt; container_t staat de mount-namespace-operaties toe die het nodig heeft.
De les: Een container runtime moet SELinux expliciet gebruiken. Zonder selinux: true in K3s draaide elke pod unconfined, hoewel al het andere klopte.
Geval 3, klein: één regel voor AIDE
De file-integrity-checker AIDE draait als aide_t en loopt het hele bestandssysteem af. De EFI-partitie is vfat (dosfs_t), en de policy laat aide_t er niet naar kijken. /boot/efi uitsluiten van de controle hield AIDE tegen de bestanden te lezen, maar niet statfs() op het mountpoint aan te roepen – 13 denials per run, elke nacht. De netste oplossing is een lokale module met precies één regel, op de host gebouwd en alleen geladen als de bron verandert.
Dit is het tegenvoorbeeld van audit2allow: de regel is met de hand geschreven, na de beslissing dat het lezen van bestandssysteemmetadata legitiem is en dat er niets meer nodig is. Sindsdien loggen de drie servers helemaal geen AVC meer – wat ook de voorwaarde is om de volgende echte op te merken.
De les: audit2allow schrijft op wat werd geweigerd. Of het moet worden toegestaan, is een menselijke beslissing, en de regel wordt dan met de hand geschreven.
De monitoringstack: eigen domains – en een verborgen denial
Prometheus, Grafana en de exporters draaiden eerst als unconfined_service_t, omdat de policy geen modules heeft voor programma’s in /usr/local/bin. Sinds 19 oktober hebben ze eigen domains: kleine lokale modules zoals homelab_prometheus en homelab_grafana, gebouwd met de macro’s van de reference policy. Eén detail herhaalde bijna geval 1: de units draaien met NoNewPrivileges, dus elke module heeft init_nnp_daemon_domain() nodig. Zonder dat bleef Grafana in init_t, kon zijn eigen database niet lezen en was het op de blog vijf minuten weg. Monit kreeg bewust geen domain – het draait willekeurige checks als root – maar in plaats daarvan een systemd-sandbox.
De regels kwamen uit een leerfase in permissive-modus. Op de blog leverde één dag 82.703 denials op, die neerkwamen op 203 verschillende toegangen; die werden gereviewde, met de hand geschreven regels. Twee verrassingen onderweg: een file context voor /run/grafana werd nooit toegepast, omdat de policy /run-paden opzoekt als /var/run, en de stroom berichten liet audit.log elke twee uur roteren. Sinds 20 en 21 oktober draaien alle domains enforcing. Twee dagen later ontbraken de schijfwaarden in Grafana: node_exporter mocht /proc/1/mountinfo niet lezen. Het auditlog zei niets, omdat de policy van de distributie precies dit bericht onderdrukt met een dontaudit-regel – ook in de leerfase, die de toegang daardoor stilletjes toestond. Alleen het eigen log van de exporter liet het zien. semodule -DB schakelt zulke regels tijdelijk uit, semodule -B zet ze terug.
De les: Geen AVC betekent niet dat er niets wordt geweigerd. Na de overstap naar enforcing horen het eigen log van de service en zijn metrics bij de controle.
🆘 Spiekbriefje: symptoom → commando
De korte versie van dit artikel voor het moment dat er iets mis is. Draai op de host als root; <…> zijn placeholders.
| Symptoom | Commando |
|---|---|
| Iets faalt met “Permission denied”, hoewel de bestandsrechten kloppen | ausearch -m AVC -ts recentausearch -m AVC -ts recent | audit2why |
| Service “running”, maar in welk domain? | ps -eZ | grep <name> # initrc_t or unconfined_service_t = not confined |
| Verkeerd label op een bestand | ls -Z <path>; matchpathcon <path>restorecon -Rv <path> # never chcon |
| Welke labels zou een relabel veranderen? | restorecon -Rnv /etc /srv /var/lib |
| Modus en policy | sestatussemanage permissive -l # domains still in the learning phase |
| Lokale modules | semodule -l | grep homelab_ |
| Is een bepaalde toegang toegestaan? | sesearch -A -s <source_t> -t <target_t> |
| Een container kan niet naar een hostdirectory schrijven | ls -Zd <dir> # container_file_t expected# add it to the stack profile in common_selinux, not by hand |
Een paar gewoontes die zich hebben bewezen:
- Controleer na elke wijziging aan een service-unit het domain, niet alleen de status. Een service die “active (running)” is in het verkeerde domain ziet er volkomen gezond uit.
- Behandel elke AVC als een bevinding. Op een rustig systeem zijn ze zeldzaam genoeg om ze een voor een te lezen; zodra je een achtergrond van bekende denials accepteert, verdwijnt de belangrijke daarin.
- Nieuwe hostdirectory voor een pod? Voeg hem toe aan het profiel van de stack in
common_selinux, label hem nooit met de hand. De backupdirectory van de blog voor de updatejob ontbrak tot 19 oktober in het profiel; het werkte alleen omdat de pods nog niet waren ingesloten. - Permissive-modus voor één domain (
semanage permissive -a <domain>) is een debugtool voor minuten, geen oplossing.setenforce 0op een productiehost is helemaal geen optie. - Na een policy-update toont
semodule -lnog steeds de lokale modules; als een module niet meer compileert tegen een nieuwe policy, faaltsemodule -iluid in de playbookrun, niet stil tijdens runtime.
🎯 De lessen
- Een verkeerd label is de meest voorkomende oorzaak, een ontbrekende regel de zeldzaamste.
- “Enforcing” betekent niet ingesloten: controleer het domain van elk proces met
ps -eZ. NoNewPrivilegesen de vele systemd-sandboxopties die het impliceren, kunnen domain transitions tegenhouden.- Schrijf regels met de hand, na een beslissing – nooit blind met
audit2allow -M. dontauditverbergt denials. Lees na elke wijziging ook het eigen log van de service.
⚖️ Alternatieven – en waarom SELinux
| Optie | Sterke punten | Waarom niet hier |
|---|---|---|
| AppArmor | Padgebaseerde profielen, makkelijker te lezen en te schrijven; standaard op Debian en Ubuntu | Niet de native keuze op AlmaLinux; padgebaseerde regels zijn zwakker tegen hard links en hernoemde bestanden; geen MCS-achtige scheiding van identieke containers |
| Alleen seccomp | Filtert system calls, goedkoop, al gebruikt door de container runtime en de systemd-units | Zegt niets over welke bestanden of sockets – aanvullend, geen vervanging |
| Landlock | Sandboxing zonder privileges vanuit de applicatie zelf | Vereist dat de applicatie het gebruikt; geen van deze doet dat |
| gVisor / Kata Containers | Een tweede kernel of een VM-grens per pod | Veel zwaarder, en overkill voor één vertrouwde beheerder op een kleine server |
| Helemaal geen MAC | Niets te leren | Het eerste gecompromitteerde proces heeft alles wat root heeft |
SELinux past omdat het er al is: AlmaLinux levert een volwassen targeted policy, container-selinux integreert met containerd, K3s brengt zijn eigen policypakket mee, en van beheerders van systemen uit de RHEL-familie wordt verwacht dat ze het kennen. De echte prijs is niet de complexiteit maar de stilte – zoals de twee gevallen laten zien, kan het aan staan en niets doen zonder dat iemand het merkt. Het antwoord daarop is niet het uitzetten, maar controleren wat het werkelijk doet.
