Deep Dive: SELinux su un host K3s – type enforcement, e le due volte in cui in silenzio non ha fatto nulla
Come decide davvero il type enforcement di SELinux, come confina il blog e Nextcloud su K3s – e due casi reali in cui era in enforcing ma non proteggeva nulla: un MariaDB in initrc_t e pod senza container_t.

🌐 Anche in: English · Deutsch · Français · Español · Português · Nederlands · Polski
Deep Dive della serie attorno all’Ansible Tour. Il tour spiega i ruoli, i deep dive la tecnologia sottostante: come funziona, perché qui viene usata in questo modo e cosa è andato storto lungo la strada.
SELinux è il livello che la maggior parte degli amministratori disattiva per primo e capisce per ultimo. È un peccato, perché è l’unico livello su questi server che regge ancora quando un processo è già stato preso – anche uno che gira come root. Questo post spiega prima come decide SELinux, con i dettagli che contano nella pratica: tipi, transizioni, categorie e come si legge un diniego. Poi guarda il blog e i due server Nextcloud: cosa è confinato, come, e le due occasioni in cui SELinux era attivo, in enforcing, e comunque non proteggeva nulla – perché un singolo dettaglio altrove faceva sì che le regole giuste non si applicassero mai.
Indice
🧭 Come decide SELinux
Discrezionale contro obbligatorio
I classici permessi Unix sono discrezionali: il proprietario di un file decide chi può leggerlo, e root può fare tutto. SELinux aggiunge sopra un livello obbligatorio. Il kernel interroga una policy centrale a ogni operazione rilevante – aprire un file, connettere un socket, inviare un segnale, eseguire un programma – e la risposta non dipende da chi possiede il file né dal fatto che il processo sia root. Entrambi i controlli devono dire sì. Un web server che gira come root non può comunque leggere /etc/shadow se la policy non permette al suo tipo di leggere il tipo di quel file.
Etichette: quattro campi, uno dei quali fa quasi tutto il lavoro
Ogni processo e ogni oggetto – file, directory, socket, porta, persino le strutture del kernel – porta un security context della forma user:role:type:level. Su un server con la policy targeted fornita da AlmaLinux, tre dei quattro campi contano poco: l’utente è quasi sempre system_u o unconfined_u, il ruolo system_r o object_r. Le decisioni le prende il tipo. Per un processo il tipo si chiama dominio.
$ 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
Le etichette dei file sono memorizzate come attributi estesi (security.selinux) nel file system. Da dove arrivi l’etichetta di un file è la fonte della maggior parte dei guai con SELinux, quindi vale la pena conoscere le tre vie: un file nuovo eredita il tipo della directory padre; una regola di type transition nella policy può dire “i file che il dominio X crea in una directory di tipo Y ricevono il tipo Z”; e restorecon imposta le etichette dal database dei file context – regole come /var/lib/mysql(/.*)? → mysqld_db_t, che la policy fornisce e che semanage fcontext estende. Spostare un file ne mantiene l’etichetta; copiarlo gliene dà una nuova. Un file di configurazione spostato da una home directory in /etc e poi illeggibile per il suo servizio è il classico.
Type enforcement
La policy è essenzialmente un grande insieme di regole allow tra tipi: allow mysqld_t mysqld_db_t:file { read write open … }; – un processo nel dominio mysqld_t può leggere e scrivere file di tipo mysqld_db_t. Ciò che non è permesso è negato. La policy targeted su questi host contiene ben oltre centomila regole di questo tipo, compilate in un binario caricato nel kernel; 439 moduli formano il tutto, da apache a zabbix. Il senso del nome “targeted”: vengono confinati solo i servizi che hanno un proprio modulo. Tutto il resto gira in un dominio non confinato a cui è permesso quasi tutto – ed è proprio lì, come mostra il secondo caso più sotto, che le cose possono sfuggire senza che nessuno se ne accorga.
Transizioni di dominio – e perché NoNewPrivileges può fermarle
Un processo riceve il suo dominio all’execve(). La regola type_transition init_t mysqld_exec_t:process mysqld_t dice: quando qualcosa in init_t (systemd) esegue un file di tipo mysqld_exec_t, il nuovo processo gira in mysqld_t. Ecco perché l’etichetta di un eseguibile conta quanto l’etichetta dei dati: un binario mariadbd etichettato bin_t non entrerebbe mai nel suo dominio.
C’è un’interazione sottile con un’opzione di systemd che per il resto è un puro guadagno di hardening. NoNewPrivileges=yes imposta il flag del kernel PR_SET_NO_NEW_PRIVS: da lì in poi execve() non può mai ottenere privilegi – niente setuid, niente file capabilities. SELinux tratta anche una transizione di dominio come un potenziale cambio di privilegi. Sotto NNP permette una transizione solo se il dominio di destinazione è un sottoinsieme di quello di origine (bounded) o se la policy concede esplicitamente nnp_transition per quella coppia. Se nessuna delle due condizioni vale, la transizione viene rifiutata – e il programma continua a girare nel dominio del padre. Diverse altre opzioni sandbox di systemd implicano NNP senza dirlo. Ricordatelo; è il primo caso più sotto.
MCS: il campo level che tiene separati i container
Il quarto campo, il level, normalmente vale s0. Con la Multi-Category Security può portare delle categorie: s0:c628,c864. Un processo può accedere a un oggetto solo se le sue categorie dominano quelle dell’oggetto: un processo con c628,c864 può leggere un file con esattamente quelle categorie, o un file senza categorie (s0), ma non un file etichettato c53,c213. I container runtime usano questo meccanismo per separare container che condividono tutti lo stesso tipo: ogni pod riceve la propria coppia casuale. Tutti i 46 processi dei container su un host Nextcloud girano come container_t, eppure Collabora (c53,c213) non può toccare i file del container PHP (c628,c864).
Una conseguenza è facile da trascurare: una directory dell’host montata nei pod ed etichettata container_file_t:s0 – senza categorie – è raggiungibile da ogni container. MCS isola i file system propri dei container, non i volumi condivisi. Su questi server ogni directory HostPath appartiene esattamente a un’applicazione, quindi va bene; su un nodo multi-tenant non andrebbe.
Leggere un diniego
Quando la policy dice no, il kernel scrive un messaggio AVC (access vector cache) nel log di audit. Questo veniva dal controllo del backup dello strumento di integrità dei file, e contiene tutto ciò che serve per capirlo:
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
Leggilo come una frase: il processo aide, che gira nel dominio aide_t, voleva fare getattr su un oggetto di classe filesystem con tipo dosfs_t – la partizione EFI vfat – e gli è stato rifiutato (permissive=0). ausearch -m AVC -ts today trova questi messaggi, audit2why spiega quale regola manca o quale boolean lo permetterebbe. audit2allow -M scriverebbe un modulo che permette esattamente ciò che è stato negato – ed è il comando più pericoloso nell’amministrazione di SELinux, perché trasforma ogni sintomo in un permesso senza chiedersi se l’accesso fosse legittimo.
🛡️ Perché è attivo, ovunque
Tutti e tre i server girano con la policy targeted in modalità enforcing, e ogni ruolo lo dà per scontato. Il motivo è un modello di minaccia più che una casella da spuntare. L’attacco realistico a un blog è un plugin WordPress vulnerabile; a Nextcloud, un documento malevolo che sfrutta la suite per ufficio. In entrambi i casi l’attaccante finisce con esecuzione di codice dentro un processo PHP o Collabora. Tutto ciò che viene dopo – leggere direttamente i file del database, rubare chiavi SSH, piazzare un binario sull’host, attaccare l’altra applicazione – dipende da cosa può fare quel processo. I permessi Unix lì non aiutano molto; dentro un container il processo spesso è comunque root. SELinux è il livello che risponde “no” indipendentemente dagli ID utente.
- Un worker PHP-FPM in
container_tpuò scrivere solocontainer_file_t– il proprio volume. La policy non contiene alcuna regola che permetta acontainer_tdi leggereshadow_t, quindi/etc/shadowresta fuori portata anche per un processo root uscito dal suo mount namespace. - Il MariaDB dell’host in
mysqld_tpuò leggere e scrivere il propriomysqld_db_t, fare bind sulla sua porta e poco altro. Un server di database compromesso non può leggere i dati utente di Nextcloud in/data, che sonocontainer_file_t. - Lo stesso vale per Redis in
redis_t: il suoredis_var_lib_t, la sua porta, il suo socket. - Moduli del kernel, dispositivi raw, ptrace su altri domini: negati a tutti questi per default.
Il costo è piccolo una volta che le etichette sono giuste. Quasi ogni problema SELinux su questi host finora è stato un’etichetta mancante o sbagliata, non una regola mancante – e la policy per database, Redis e container arriva già pronta con la distribuzione e con container-selinux.
🔧 Cosa fa questo repository
common_selinux: enforcing e le etichette giuste
Il ruolo imposta la modalità enforcing con la policy targeted ed etichetta le directory dell’host che i pod montano. Quali directory dipende dallo stack: il playbook imposta la variabile stack, e un dizionario sceglie il profilo – web root e directory del database per il blog, web root e dati utente per Nextcloud. Per ogni directory aggiunge una regola di file context persistente e la applica.
In sintesi: Quasi ogni problema SELinux qui è stato un’etichetta sbagliata, non una regola mancante. Un’etichetta va nella policy come regola persistente, non sul file con chcon – altrimenti il prossimo relabel la rimuove.
Caso 1: un database in enforcing – e non confinato
A settembre un drop-in di systemd ha irrobustito il MariaDB dell’host sui server Nextcloud: nessuna capability, file system in sola lettura tranne la directory dei dati, /tmp privata, un filtro sulle system call – e, esplicitamente e implicitamente, NoNewPrivileges. MariaDB partiva, Nextcloud funzionava, il drop-in sembrava un chiaro miglioramento. Cinque settimane dopo un’occhiata ai processi in esecuzione mostrava questo:
$ ps -eZ | grep mariadbd
system_u:system_r:initrc_t:s0 ... mariadbd
initrc_t invece di mysqld_t. La unit della distribuzione non avvia mariadbd direttamente ma tramite /bin/sh -c, per eseguire prima un helper di recovery di Galera. La shell gira in initrc_t; quando esegue mariadbd, deve avvenire la transizione in mysqld_t – e sotto NNP la policy non la permette da initrc_t. Il log di audit lo diceva, a ogni avvio, in una riga che nessuno aveva letto: avc: denied { nnp_transition } … scontext=…initrc_t… tcontext=…mysqld_t… tclass=process2. Il database continuava a girare nel dominio della shell, molto meno ristretto. Dall'11 settembre al 16 ottobre il MariaDB dell’host di fatto non era confinato da SELinux.
La correzione è una riga nel drop-in: avviare il binario direttamente, senza la shell (Galera qui non si usa, quindi l’helper non ha nulla da fare):
ExecStart=
ExecStart=/usr/sbin/mariadbd $MYSQLD_OPTS $_WSREP_NEW_CLUSTER
Eseguito direttamente da systemd, la transizione da init_t è permessa, e ps -eZ mostra di nuovo mysqld_t. È stato testato prima con systemd-run e le stesse proprietà, così la modifica non è mai stata provata sul database di produzione.
In sintesi: “Enforcing” non significa che un servizio sia confinato. Dopo ogni modifica a una unit, ps -eZ mostra in quale dominio gira davvero il processo; systemctl status no.
Caso 2: pod che non hanno mai girato come container_t
Il secondo caso è più grosso. SELinux era in enforcing su tutti e tre i server, le directory dell’host avevano container_file_t, container-selinux era installato – e il 19 ottobre, mentre scrivevo questa serie, ps -eZ ha mostrato che nemmeno un pod girava come container_t. Sul blog erano spc_t (“super privileged container”, praticamente non confinato), sui server Nextcloud unconfined_service_t.
Mancavano due cose. K3s avvia il suo containerd integrato con il supporto SELinux solo quando la sua configurazione dice selinux: true; altrimenti enable_selinux di containerd è false e non chiede mai alla policy un’etichetta per i container. E K3s ha bisogno del proprio pacchetto di policy, k3s-selinux, che etichetta il binario come container_runtime_exec_t così che giri come container_runtime_t. Sul blog lo script di installazione aveva aggiunto quel pacchetto una volta; sui server Nextcloud il binario era semplicemente bin_t, quindi systemd lo avviava come unconfined_service_t, e ogni figlio lo ereditava. Tutta l’accurata etichettatura dei volumi era stata la preparazione per un controllo che non avveniva mai.
common_k3s ora fa quattro cose:
- aggiunge il repository di pacchetti firmato di Rancher e installa
k3s-selinux, - imposta
selinux: truein/etc/rancher/k3s/config.yaml, - esegue
restorecon -v /usr/local/bin/k3sdopo ogni download del binario –get_urlsostituisce il file tramite un file temporaneo nella stessa directory, il che dà al nuovo binario ilbin_tdella directory e al prossimo aggiornamento annullerebbe in silenzio la policy, - e ricrea tutti i workload una volta, quando nemmeno un pause container gira ancora come
container_t. I pod mantengono il dominio con cui sono stati avviati; una modifica di configurazione da sola non confina nulla di ciò che è già in esecuzione.
Dopo, il quadro su un server Nextcloud: 46 processi in container_t, ogni pod con la propria coppia di categorie, solo i pod privilegiati in spc_t, e nemmeno un AVC – né da Nextcloud, né da Collabora con i suoi mount namespace, né da notify_push. Collabora era il componente con il maggior potenziale di guai, perché costruisce una jail per ogni documento con bind mount; container_t permette le operazioni sui mount namespace di cui ha bisogno.
In sintesi: Un container runtime deve usare SELinux esplicitamente. Senza selinux: true in K3s ogni pod girava non confinato, anche se tutto il resto era giusto.
Caso 3, piccolo: una regola per AIDE
Il controllore di integrità dei file AIDE gira come aide_t e percorre l’intero file system. La partizione EFI è vfat (dosfs_t), e la policy non permette ad aide_t di guardarla. Escludere /boot/efi dal controllo ha impedito ad AIDE di leggere i file, ma non di chiamare statfs() sul mount point – 13 dinieghi per esecuzione, ogni notte. La correzione più pulita è un modulo locale con esattamente una regola, compilato sull’host e caricato solo quando il suo sorgente cambia.
Questo è il controesempio di audit2allow: la regola è stata scritta a mano, dopo aver deciso che leggere i metadati del file system è legittimo e che non serve altro. Da allora i tre server non registrano alcun AVC – che è anche la precondizione per accorgersi del prossimo vero.
In sintesi: audit2allow mette per iscritto ciò che è stato negato. Se vada permesso è una decisione umana, e la regola si scrive poi a mano.
Lo stack di monitoraggio: domini propri – e un diniego nascosto
Prometheus, Grafana e gli exporter inizialmente giravano come unconfined_service_t, perché la policy non ha moduli per programmi in /usr/local/bin. Dal 19 ottobre hanno domini propri: piccoli moduli locali come homelab_prometheus e homelab_grafana, costruiti con le macro della reference policy. Un dettaglio ha quasi ripetuto il caso 1: le unit girano con NoNewPrivileges, quindi ogni modulo ha bisogno di init_nnp_daemon_domain(). Senza, Grafana restava in init_t, non poteva leggere il proprio database ed è sparita dal blog per cinque minuti. Monit deliberatamente non ha ricevuto un dominio – esegue controlli arbitrari come root – ma una sandbox di systemd.
Le regole sono nate da una fase di apprendimento in modalità permissive. Sul blog un giorno ha prodotto 82.703 dinieghi, che si riducevano a 203 accessi distinti; sono diventati regole revisionate e scritte a mano. Due sorprese lungo la strada: un file context per /run/grafana non si applicava mai, perché la policy cerca i percorsi /run come /var/run, e la valanga di messaggi faceva ruotare audit.log ogni due ore. Dal 20 e 21 ottobre tutti i domini girano in enforcing. Due giorni dopo in Grafana mancavano i valori dei dischi: node_exporter non poteva leggere /proc/1/mountinfo. Il log di audit non diceva nulla, perché la policy della distribuzione sopprime proprio questo messaggio con una regola dontaudit – anche nella fase di apprendimento, che quindi aveva permesso l’accesso in silenzio. Solo il log dell’exporter lo mostrava. semodule -DB disattiva temporaneamente queste regole, semodule -B le ripristina.
In sintesi: Nessun AVC non significa che nulla venga negato. Dopo il passaggio a enforcing, il log del servizio stesso e le sue metriche fanno parte del controllo.
🆘 Promemoria: sintomo → comando
La versione breve di questo articolo per il momento in cui qualcosa non va. Da eseguire sull’host come root; <…> sono segnaposto.
| Sintomo | Comando |
|---|---|
| Qualcosa fallisce con “Permission denied”, anche se i permessi dei file vanno bene | ausearch -m AVC -ts recentausearch -m AVC -ts recent | audit2why |
| Servizio “running”, ma in quale dominio? | ps -eZ | grep <name> # initrc_t or unconfined_service_t = not confined |
| Etichetta sbagliata su un file | ls -Z <path>; matchpathcon <path>restorecon -Rv <path> # never chcon |
| Quali etichette cambierebbe un relabel? | restorecon -Rnv /etc /srv /var/lib |
| Modalità e policy | sestatussemanage permissive -l # domains still in the learning phase |
| Moduli locali | semodule -l | grep homelab_ |
| Un accesso specifico è permesso? | sesearch -A -s <source_t> -t <target_t> |
| Un container non riesce a scrivere in una directory dell’host | ls -Zd <dir> # container_file_t expected# add it to the stack profile in common_selinux, not by hand |
Alcune abitudini che si sono dimostrate valide:
- Dopo ogni modifica a una unit di servizio, controlla il suo dominio, non solo il suo stato. Un servizio “active (running)” nel dominio sbagliato sembra perfettamente sano.
- Tratta ogni AVC come un reperto. Su un sistema tranquillo sono abbastanza rari da poterli leggere uno per uno; nel momento in cui accetti un sottofondo di dinieghi noti, quello importante ci sparisce dentro.
- Nuova directory dell’host per un pod? Aggiungila al profilo dello stack in
common_selinux, non etichettarla mai a mano. La directory di backup del blog per il job di aggiornamento è mancata dal profilo fino al 19 ottobre; funzionava solo perché i pod non erano ancora confinati. - La modalità permissive per un singolo dominio (
semanage permissive -a <domain>) è uno strumento di debug per pochi minuti, non una correzione.setenforce 0su un host di produzione non è proprio un’opzione. - Dopo un aggiornamento della policy,
semodule -lelenca ancora i moduli locali; se un modulo smette di compilare contro una nuova policy,semodule -ifallisce rumorosamente durante l’esecuzione del playbook, non in silenzio a runtime.
🎯 Le lezioni
- Un’etichetta sbagliata è la causa più comune, una regola mancante la più rara.
- “Enforcing” non significa confinato: controlla il dominio di ogni processo con
ps -eZ. NoNewPrivilegese le molte opzioni sandbox di systemd che lo implicano possono fermare le transizioni di dominio.- Scrivi le regole a mano, dopo una decisione – mai alla cieca con
audit2allow -M. dontauditnasconde i dinieghi. Dopo ogni modifica leggi anche il log del servizio stesso.
⚖️ Alternative – e perché SELinux
| Opzione | Punti di forza | Perché non qui |
|---|---|---|
| AppArmor | Profili basati sui percorsi, più facili da leggere e scrivere; default su Debian e Ubuntu | Non è la scelta nativa su AlmaLinux; le regole basate sui percorsi sono più deboli contro hard link e file rinominati; nessuna separazione tipo MCS tra container identici |
| Solo seccomp | Filtra le system call, economico, già usato dal container runtime e dalle unit systemd | Non dice nulla su quali file o socket – complementare, non un sostituto |
| Landlock | Sandboxing non privilegiato dall’interno dell’applicazione | Richiede che l’applicazione lo usi; nessuna di queste lo fa |
| gVisor / Kata Containers | Un secondo kernel o un confine di VM per pod | Molto più pesante, ed eccessivo per un unico operatore fidato su un piccolo server |
| Nessun MAC | Niente da imparare | Il primo processo compromesso ha tutto ciò che ha root |
SELinux si adatta perché c’è già: AlmaLinux fornisce una policy targeted matura, container-selinux si integra con containerd, K3s porta il proprio pacchetto di policy, e dagli amministratori di sistemi della famiglia RHEL ci si aspetta che lo conoscano. Il suo vero costo non è la complessità ma il silenzio – come mostrano i due casi, può essere attivo e non fare nulla senza che nessuno se ne accorga. La risposta non è disattivarlo, ma controllare cosa sta facendo davvero.
