Les capacités systemd décident des privilèges qu’un service garde réellement. La plupart des services démarrent en root, donc ils détiennent bien plus de pouvoir que nécessaire. Cette troisième partie de la série « Systemd hardening, directive par directive » montre comment réduire ce pouvoir, une directive à la fois, avec un laboratoire que vous pouvez reconstruire en une demi-heure.
Chaque sortie ci-dessous vient d’une vraie exécution sur une machine de test, donc vous pouvez la comparer à vos propres résultats. Quand un résultat diffère de ce que le manuel laisse attendre, le texte le signale. L’article couvre User=, Group=, SupplementaryGroups=, DynamicUser=, NoNewPrivileges=, CapabilityBoundingSet=, AmbientCapabilities=, SecureBits= et RestrictSUIDSGID=. La directive PAMName= appartient à la même famille, mais elle n’a pas été testée, donc elle n’a droit qu’à une courte note.
Avant de commencer
- Niveau : vous savez écrire un fichier d’unité et lire un journal. Vous n’avez pas besoin de connaître les capacités systemd.
- Machine : une machine de test ou une machine virtuelle sous systemd. N’exécutez jamais ce laboratoire sur un serveur de production.
- Droits : un accès root via
sudo. - Outils :
systemctl,journalctl,systemd-analyze,python3et les outils libcap (capsh,getpcaps,getcap,setcap). - Durée : environ 30 minutes pour tout le laboratoire, et environ 5 minutes si vous ne faites que lire.
- La partie 1 de la série explique comment mesurer une unité avec
systemd-analyze security. Ici, ce score sert seulement de thermomètre.
Testé sur Rocky Linux 10.2, systemd 257, noyau WSL2 6.18.54.1-microsoft-standard-WSL2. SELinux n’est pas disponible sur ce banc (le système de fichiers selinuxfs est absent), donc aucun résultat ci-dessous ne fait intervenir SELinux. Sur un noyau natif avec SELinux en mode enforcing, certains résultats peuvent différer.
Le vocabulaire utile
Les capacités systemd ont leur propre vocabulaire, donc un court glossaire passe en premier. Lisez ce tableau une fois, puis revenez-y quand un terme devient flou.
| Terme | Sens simple |
|---|---|
| UID 0 / root | Le compte administrateur. Historiquement, le noyau lui accorde tous les privilèges. |
| Capacité (capability) | Une tranche du pouvoir de root. Par exemple CAP_NET_BIND_SERVICE autorise les ports inférieurs à 1024, et CAP_CHOWN autorise le changement de propriétaire d’un fichier. La liste complète figure dans la page de manuel capabilities(7). |
| Ensemble de limitation (bounding set) | Le plafond. Une capacité hors de cet ensemble ne peut être utilisée ni par le processus ni par ce qu’il lance. |
| Ensemble ambiant (ambient set) | Les capacités qu’un processus non-root conserve quand il lance un autre programme. C’est le moyen d’accorder un seul privilège à un service non privilégié. |
| Fichier setuid (set-user-ID) | Un programme qui s’exécute avec l’identité de son propriétaire, souvent root (sudo et passwd en sont des exemples). |
| Capacité de fichier | Une capacité stockée sur le fichier du programme lui-même, avec setcap. |
| no_new_privs | Un drapeau du noyau. Une fois posé, execve() ne peut plus jamais donner davantage de privilèges au processus. NoNewPrivileges= le pose. |
| Drop-in | Un petit fichier nommé unité.service.d/quelquechose.conf qui surcharge une partie d’une unité. Il survit aux mises à jour de paquets. |
| Niveau d’exposition | Le score de systemd-analyze security, de 0 à 10. Un nombre plus haut signifie un service plus exposé. |
Comment les capacités systemd s’articulent : qui limite, qui accorde, qui bloque
Neuf directives, cela semble beaucoup, mais elles jouent seulement quatre rôles, et l’image ci-dessous les montre côte à côte.

- Identité :
User=,Group=,SupplementaryGroups=etDynamicUser=choisissent qui est le service. - Limiter :
CapabilityBoundingSet=fixe le plafond de ce que le service peut jamais détenir. - Accorder :
AmbientCapabilities=donne à un service non-root les quelques capacités dont il a besoin. - Bloquer :
NoNewPrivileges=etRestrictSUIDSGID=empêchent le service de remonter.SecureBits=règle finement l’interaction entre root et les capacités.
La recette est donc courte : d’abord choisir une identité, puis accorder seulement le nécessaire, fixer le plafond, et enfin fermer les portes qui ramènent à root. Les sections suivantes testent chaque étape dans cet ordre.
Construire le laboratoire
Le laboratoire utilise un script de sonde inoffensif, lancé avec des réglages différents. La sonde fait quatre choses. D’abord, elle tente de lier le port 80 sur l’adresse de bouclage. Ensuite, elle tente de donner un fichier à un autre propriétaire. Puis elle tente de poser le bit setuid sur son propre fichier. Enfin, elle lance un assistant setuid appartenant à root. Elle affiche aussi les masques de capacités de son propre processus. Rien ne quitte la machine, car la sonde ne touche qu’un répertoire temporaire privé.
Tous les noms commencent par demo-hardening-sd3-, et le compte s’appelle sd3demo. Ainsi, le nettoyage de fin d’article supprime exactement ce que le laboratoire a créé. Enregistrez le script ci-dessous sous le nom lab-setup.sh et lancez-le en root.
#!/bin/bash
# Creates the harmless demo files and units of the lab (all named demo-hardening-*).
set -e
# A dedicated system account for the demo (removed by the cleanup script).
id sd3demo >/dev/null 2>&1 || useradd --system --no-create-home --shell /usr/sbin/nologin sd3demo
cat > /usr/local/bin/demo-hardening-sd3-probe.sh <<'EOF'
#!/bin/bash
# Harmless probe: binds only to loopback, touches only a private temporary directory.
echo "identity: uid=$(id -u) user=$(id -un) groups=$(id -G)"
grep -E '^(NoNewPrivs|CapInh|CapPrm|CapEff|CapBnd|CapAmb):' /proc/self/status
d=$(mktemp -d)
if python3 -c 'import socket; s=socket.socket(); s.bind(("127.0.0.1", 80)); s.close()' 2>/dev/null; then
echo "probe bind-80: allowed"
else
echo "probe bind-80: refused"
fi
if [ "$(id -u)" = 0 ]; then target=nobody; else target=root; fi
touch "$d/owned"
if chown "$target" "$d/owned" 2>/dev/null; then
echo "probe chown-to-$target: allowed"
else
echo "probe chown-to-$target: refused"
fi
touch "$d/suid"
if chmod u+s "$d/suid" 2>/dev/null; then
echo "probe chmod-u+s: allowed"
else
echo "probe chmod-u+s: refused"
fi
echo "probe setuid-helper effective uid: $(/usr/local/bin/demo-hardening-sd3-setuid-id -u)"
rm -rf "$d"
EOF
chmod 755 /usr/local/bin/demo-hardening-sd3-probe.sh
# A copy of id(1) owned by root with the set-user-ID bit: it only prints IDs.
cp /usr/bin/id /usr/local/bin/demo-hardening-sd3-setuid-id
chown root:root /usr/local/bin/demo-hardening-sd3-setuid-id
chmod u+s,a+rx /usr/local/bin/demo-hardening-sd3-setuid-id
cat > /etc/systemd/system/demo-hardening-sd3-caps.service <<'EOF'
[Unit]
Description=Demo hardening: what may an unprivileged service do?
[Service]
Type=oneshot
User=sd3demo
ExecStart=/usr/local/bin/demo-hardening-sd3-probe.sh
StandardOutput=journal
EOF
cat > /etc/systemd/system/demo-hardening-sd3-root.service <<'EOF'
[Unit]
Description=Demo hardening: what may a root service do?
[Service]
Type=oneshot
ExecStart=/usr/local/bin/demo-hardening-sd3-probe.sh
StandardOutput=journal
EOF
cat > /etc/systemd/system/demo-hardening-sd3-dynamic.service <<'EOF'
[Unit]
Description=Demo hardening: dynamic user
[Service]
Type=oneshot
DynamicUser=yes
StateDirectory=demo-hardening-sd3-dynamic
ExecStart=/usr/bin/id -u
ExecStart=/usr/bin/id -un
ExecStart=/usr/bin/touch /var/lib/demo-hardening-sd3-dynamic/created-by-the-service
StandardOutput=journal
EOF
# Helper used by the following scripts: restart a unit, then print its own journal lines.
cat > /usr/local/bin/demo-hardening-sd3-run <<'EOF'
#!/bin/bash
# Restart a unit, then print only the lines this run wrote to the journal.
unit="$1"
since=$(date '+%Y-%m-%d %H:%M:%S')
systemctl daemon-reload
systemctl restart "$unit" 2>&1 | sed 's/^/restart: /' || true
sleep 1
journalctl -u "$unit" -o cat --no-pager --since "$since" | grep -vE '^(Starting |Finished |.*: Deactivated successfully)'
EOF
chmod 755 /usr/local/bin/demo-hardening-sd3-run
systemctl daemon-reload
sudo bash lab-setup.sh
L’assistant demo-hardening-sd3-run recharge systemd, redémarre une unité, puis affiche seulement les lignes de journal de cette exécution. Comme les unités sont de type oneshot, la sortie de la sonde arrive dans le journal, et l’assistant l’affiche.
Référence : un utilisateur dédié et un service root, sans durcissement
D’abord, lancez la sonde deux fois sans aucun durcissement. Une unité utilise le compte dédié. L’autre utilise l’identité par défaut, c’est-à-dire root.
sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-caps.service sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-root.service
identity: uid=990 user=sd3demo groups=990 CapInh: 0000000000000000 CapPrm: 0000000000000000 CapEff: 0000000000000000 CapBnd: 000001ffffffffff CapAmb: 0000000000000000 NoNewPrivs: 0 probe bind-80: refused probe chown-to-root: refused probe chmod-u+s: allowed probe setuid-helper effective uid: 0 identity: uid=0 user=root groups=0 CapInh: 0000000000000000 CapPrm: 000001ffffffffff CapEff: 000001ffffffffff CapBnd: 000001ffffffffff CapAmb: 0000000000000000 NoNewPrivs: 0 probe bind-80: allowed probe chown-to-nobody: allowed probe chmod-u+s: allowed probe setuid-helper effective uid: 0
Lisez la sortie de haut en bas. D’abord, CapBnd est l’ensemble de limitation. La valeur 000001ffffffffff a 41 bits à 1, donc le service peut utiliser n’importe laquelle des 41 capacités de ce noyau. Ensuite, CapEff est ce que le processus peut utiliser tout de suite. Pour root, il égale l’ensemble complet, alors que pour l’utilisateur dédié il est vide.
Les sondes le confirment : le service root réussit les quatre tests, alors que l’utilisateur dédié ne peut ni lier le port 80 ni donner un fichier à root. Cependant, regardez les deux dernières lignes pour cet utilisateur. Poser le bit setuid sur son propre fichier est autorisé, car c’est normal pour un propriétaire de fichier. Pire, l’assistant appartenant à root annonce un UID effectif de 0. Un programme setuid rend donc root à un service censé être sans privilège. Les directives des capacités systemd ci-dessous servent à fermer cette brèche.
Choisir l’identité : User=, Group= et SupplementaryGroups=
La première étape de durcissement ne coûte rien : ne pas tourner en root. User= nomme le compte. Group= remplace son groupe primaire. SupplementaryGroups= ajoute des groupes, par exemple pour lire un répertoire de journaux. Le test suivant part du compte dédié et change les groupes.
d=/etc/systemd/system/demo-hardening-sd3-caps.service.d sudo mkdir -p $d printf '[Service]\nSupplementaryGroups=adm\n' | sudo tee $d/10-groups.conf sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-caps.service | head -1 printf '[Service]\nGroup=adm\n' | sudo tee $d/10-groups.conf sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-caps.service | head -1 sudo rm -rf $d && sudo systemctl daemon-reload
identity: uid=990 user=sd3demo groups=990 identity: uid=990 user=sd3demo groups=990 4 identity: uid=990 user=sd3demo groups=4
Ces trois lignes viennent de trois exécutions de la même unité. La première ligne est la référence de la section précédente, sans directive de groupe. La deuxième vient de la première exécution ci-dessus : SupplementaryGroups=adm a ajouté le groupe 4 à la liste. La troisième vient de la deuxième exécution ci-dessus, où Group=adm a remplacé le groupe primaire, donc le groupe 990 a disparu. La dernière commande supprime le drop-in, pour que les tests suivants repartent d’une base propre. La règle est simple : utilisez SupplementaryGroups= pour ajouter un accès, et Group= seulement quand le service doit posséder ses fichiers avec un autre groupe.
Voyons ensuite ce qui se passe si le compte n’existe pas. Comme l’utilisateur n’a jamais été créé, l’unité ci-dessous doit échouer.
[Service] Type=oneshot User=demo-hardening-sd3-nosuchuser ExecStart=/usr/bin/true
Enregistrez-la sous /etc/systemd/system/demo-hardening-sd3-baduser.service, puis lancez sudo systemctl daemon-reload, sudo systemctl start demo-hardening-sd3-baduser.service et journalctl -u demo-hardening-sd3-baduser.service -o cat --no-pager -n 6.
[...] Result=exit-code ExecMainStatus=217 Starting demo-hardening-sd3-baduser.service... demo-hardening-sd3-baduser.service: Failed to determine user credentials: No such process demo-hardening-sd3-baduser.service: Failed at step USER spawning /usr/bin/true: No such process demo-hardening-sd3-baduser.service: Main process exited, code=exited, status=217/USER demo-hardening-sd3-baduser.service: Failed with result 'exit-code'. Failed to start demo-hardening-sd3-baduser.service.
Le code de sortie est 217, et systemd nomme l’étape USER. Pourtant, le message dit No such process, qui ne mentionne pas un compte manquant. Donc, quand vous voyez status=217/USER, vérifiez que le compte existe avec getent passwd NOM.
DynamicUser= : un compte qui n’existe que pendant l’exécution
DynamicUser=yes (depuis systemd 232) va plus loin. Systemd crée un compte jetable au démarrage de l’unité, puis le libère à son arrêt. L’identifiant numérique vient d’une plage réservée, de 61184 à 65519. Le réglage active aussi plusieurs protections, donc c’est un choix solide pour les petits services. L’unité ci-dessous le combine avec StateDirectory=, qui donne au service un seul endroit où écrire.
[Service] Type=oneshot DynamicUser=yes StateDirectory=demo-hardening-sd3-dynamic ExecStart=/usr/bin/id -u ExecStart=/usr/bin/id -un ExecStart=/usr/bin/touch /var/lib/demo-hardening-sd3-dynamic/created-by-the-service StandardOutput=journal
62604 demo-hardening-sd3-dynamic --- state directory seen from the host lrwxrwxrwx 1 root root 34 Nov 2 14:57 /var/lib/demo-hardening-sd3-dynamic -> private/demo-hardening-sd3-dynamic drwxr-xr-x 2 nobody nobody 4096 Nov 2 14:57 /var/lib/private/demo-hardening-sd3-dynamic total 0 -rw-r--r-- 1 65534 65534 0 Nov 2 14:57 created-by-the-service --- is the dynamic user in /etc/passwd after the run? 0 --- implied settings, as systemd reports them DynamicUser=yes RemoveIPC=yes PrivateTmp=yes ProtectHome=read-only ProtectSystem=strict NoNewPrivileges=yes RestrictSUIDSGID=yes
Le service a tourné avec l’UID 62604, qui se trouve dans la plage documentée. De plus, le compte porte le nom de l’unité, et le nombre de lignes dans /etc/passwd est 0 : le compte n’existe jamais dans le fichier des mots de passe. Le répertoire d’état se trouve sous /var/lib/private, et /var/lib/demo-hardening-sd3-dynamic en est un lien symbolique.
Le dernier bloc montre ce que DynamicUser=yes active : RemoveIPC, PrivateTmp, ProtectHome=read-only, ProtectSystem=strict, NoNewPrivileges et RestrictSUIDSGID. Un détail surprend : vus depuis l’hôte, les fichiers appartiennent à nobody (UID 65534), alors que le service tournait avec 62604. Ce banc ne l’explique pas, et l’article ne devine pas.
AmbientCapabilities= : accorder un privilège à un service non-root
Un service sans privilège a parfois besoin d’exactement un privilège, et le cas classique est un serveur web sur le port 80. AmbientCapabilities= (depuis systemd 229) l’accorde. Le premier test accorde CAP_NET_BIND_SERVICE au compte dédié.
sudo mkdir -p /etc/systemd/system/demo-hardening-sd3-caps.service.d sudo tee /etc/systemd/system/demo-hardening-sd3-caps.service.d/10-ambient.conf > /dev/null <<'EOF' [Service] AmbientCapabilities=CAP_NET_BIND_SERVICE EOF sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-caps.service
identity: uid=990 user=sd3demo groups=990 CapInh: 0000000000000400 CapPrm: 0000000000000400 CapEff: 0000000000000400 CapBnd: 000001ffffffffff CapAmb: 0000000000000400 NoNewPrivs: 0 probe bind-80: allowed probe chown-to-root: refused probe chmod-u+s: allowed probe setuid-helper effective uid: 0
Le résultat correspond à l’objectif : le port 80 est maintenant autorisé, alors que le chown vers root reste refusé. La capacité ambiante apparaît dans quatre masques à la fois : CapInh, CapPrm, CapEff et CapAmb valent tous 0000000000000400. Cette valeur est le bit 10, soit CAP_NET_BIND_SERVICE. Mais la dernière ligne n’a pas bougé : l’assistant setuid renvoie toujours 0. Accorder une capacité ne supprime pas le chemin du retour vers root.
Ajoutez ensuite une deuxième capacité en écrasant le même fichier. Comme la liste est séparée par des espaces, la nouvelle valeur se lit facilement.
sudo mkdir -p /etc/systemd/system/demo-hardening-sd3-caps.service.d sudo tee /etc/systemd/system/demo-hardening-sd3-caps.service.d/10-ambient.conf > /dev/null <<'EOF' [Service] AmbientCapabilities=CAP_NET_BIND_SERVICE CAP_CHOWN EOF sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-caps.service
[...] CapAmb: 0000000000000401 [...] probe bind-80: allowed probe chown-to-root: allowed [...]
Le masque devient 0000000000000401. Le bit 0 est CAP_CHOWN, et la sonde chown réussit maintenant. Le masque est donc une image directe de votre liste, et vous pouvez le décoder à tout moment (voir la section sur l’inspection).
NoNewPrivileges= : fermer le chemin du retour vers root
NoNewPrivileges=yes (depuis systemd 187) pose le drapeau noyau no_new_privs sur le processus du service. Dès lors, le service et tout ce qu’il lance ne peuvent plus jamais gagner de privilèges via execve(). Les bits setuid et les capacités de fichier cessent de fonctionner. Le manuel précise que le drapeau ne couvre que les processus de l’unité et leurs enfants, pas les programmes lancés en son nom par at, crontab ou systemd-run.

sudo mkdir -p /etc/systemd/system/demo-hardening-sd3-caps.service.d sudo tee /etc/systemd/system/demo-hardening-sd3-caps.service.d/20-nnp.conf > /dev/null <<'EOF' [Service] NoNewPrivileges=yes EOF sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-caps.service
identity: uid=990 user=sd3demo groups=990 CapInh: 0000000000000401 CapPrm: 0000000000000401 CapEff: 0000000000000401 CapBnd: 000001ffffffffff CapAmb: 0000000000000401 NoNewPrivs: 1 probe bind-80: allowed probe chown-to-root: allowed probe chmod-u+s: allowed probe setuid-helper effective uid: 990
Deux choses ont changé. D’abord, NoNewPrivs vaut maintenant 1. Ensuite, l’assistant annonce un UID effectif de 990 au lieu de 0, donc le bit setuid ne fonctionne plus pour ce service. Pendant ce temps, les capacités ambiantes restent : le bind et le chown sont toujours autorisés. Les deux directives forment donc un couple. AmbientCapabilities= accorde le privilège, et NoNewPrivileges= empêche cette autorisation de grandir.
Notez le coût, car un service qui a besoin de sudo ou d’un autre assistant setuid cesse de fonctionner. Dans mon article précédent sur le durcissement systemd de services réels (à paraître le 17/09), le cas failsec le montre : un ensemble de limitation vide a bloqué sudo même avec NoNewPrivileges=false.
RestrictSUIDSGID= : interdire la création de fichiers setuid
L’assistant n’est plus dangereux, mais le service peut encore créer de nouveaux fichiers setuid. Un processus extérieur à l’unité pourrait ensuite les utiliser. RestrictSUIDSGID=yes (depuis systemd 242) s’appuie sur seccomp pour le refuser. Le défaut est désactivé, donc la directive est facultative.
sudo mkdir -p /etc/systemd/system/demo-hardening-sd3-caps.service.d sudo tee /etc/systemd/system/demo-hardening-sd3-caps.service.d/30-suid.conf > /dev/null <<'EOF' [Service] RestrictSUIDSGID=yes EOF sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-caps.service
identity: uid=990 user=sd3demo groups=990 CapInh: 0000000000200501 CapPrm: 0000000000000401 CapEff: 0000000000000401 CapBnd: 000001ffffffffff CapAmb: 0000000000000401 NoNewPrivs: 1 probe bind-80: allowed probe chown-to-root: allowed probe chmod-u+s: refused probe setuid-helper effective uid: 990
La sonde chmod-u+s est maintenant refusée. Avant cette étape, elle était autorisée, même avec les autres directives en place, parce qu’un propriétaire de fichier peut toujours poser le bit sur son fichier. Seule RestrictSUIDSGID= le bloque donc.
Une ligne mérite l’attention, car CapInh est passé de 0000000000000401 à 0000000000200501. Le décodage de la nouvelle valeur avec capsh --decode donne cap_chown,cap_setpcap,cap_net_bind_service,cap_sys_admin, donc deux bits supplémentaires sont apparus : cap_setpcap et cap_sys_admin. Les masques permis, effectif et ambiant n’ont pas changé. La documentation lue pour cet article ne l’explique pas. L’article rapporte l’observation sans deviner la cause.
CapabilityBoundingSet= : le plafond de tout le service
L’ensemble de limitation borne ce qu’un processus peut jamais détenir. Comme un service qui reste root possède toutes les capacités par défaut, cette directive compte surtout pour les services root parmi tous les réglages des capacités systemd. Les tests suivants utilisent donc l’unité root. D’abord, une liste simple nomme les capacités qui restent. Ensuite, une liste qui commence par ~ nomme les capacités à retirer. Enfin, une affectation vide retire tout.
Chaque test écrit le contenu indiqué dans 10-bounding.conf, dans le répertoire de drop-ins de l’unité root, remplace le contenu précédent, puis relance l’unité. Le premier test détaille les commandes.
d=/etc/systemd/system/demo-hardening-sd3-root.service.d sudo mkdir -p $d printf '[Service]\nCapabilityBoundingSet=\n' | sudo tee $d/10-bounding.conf sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-root.service
identity: uid=0 user=root groups=0 CapInh: 0000000000000000 CapPrm: 0000000000000000 CapEff: 0000000000000000 CapBnd: 0000000000000000 CapAmb: 0000000000000000 NoNewPrivs: 0 probe bind-80: refused probe chown-to-nobody: refused probe chmod-u+s: allowed probe setuid-helper effective uid: 0
Avec un ensemble vide, le service tourne avec l’UID 0 mais ne détient rien. Le bind et le chown sont tous deux refusés. Le manuel décrit ce comportement pour l’affectation vide, et la sortie le confirme : les cinq masques qui comptent valent zéro. Un ~ seul, sans nom de capacité, désigne l’ensemble complet d’après le manuel, mais cette forme n’a pas été testée ici.
Gardez maintenant seulement la capacité dont le service a besoin, puis essayez la forme inversée.
[Service] CapabilityBoundingSet=CAP_NET_BIND_SERVICE
[...] CapPrm: 0000000000000400 CapEff: 0000000000000400 CapBnd: 0000000000000400 [...] probe bind-80: allowed probe chown-to-nobody: refused [...]
[Service] CapabilityBoundingSet=~CAP_CHOWN
[...] CapPrm: 000001fffffffffe CapEff: 000001fffffffffe CapBnd: 000001fffffffffe [...] probe bind-80: allowed probe chown-to-nobody: refused [...]
| Réglage | CapBnd | Lier le port 80 | Chown |
|---|---|---|---|
| (rien) | 000001ffffffffff | autorisé | autorisé |
CapabilityBoundingSet= | 0000000000000000 | refusé | refusé |
CapabilityBoundingSet=CAP_NET_BIND_SERVICE | 0000000000000400 | autorisé | refusé |
CapabilityBoundingSet=~CAP_CHOWN | 000001fffffffffe | autorisé | refusé |
La forme en liste blanche (CAP_NET_BIND_SERVICE) est la plus sûre, car un futur noyau peut ajouter des capacités, et une liste blanche les ignore. La forme inversée se lit plus vite quand on veut seulement en retirer quelques-unes. L’outil systemd-analyze security affiche ses contrôles sous la forme inversée, par exemple CapabilityBoundingSet=~CAP_SYS_ADMIN.
Regardez aussi ce qui n’a pas changé dans toutes ces exécutions. La sonde chmod est restée autorisée, et l’assistant setuid a toujours annoncé l’UID 0. C’est parce qu’un ensemble de limitation retire des capacités, mais il ne retire pas l’identité de root, et il n’empêche pas un propriétaire de fichier d’utiliser les permissions de fichier.
L’ensemble de limitation et les capacités de fichier
Une capacité de fichier est une capacité stockée sur le programme, avec setcap. L’ensemble de limitation interagit avec elle, donc le test copie /usr/bin/true, donne à la copie cap_net_bind_service=ep, et la lance avec l’utilisateur dédié sous trois ensembles de limitation.
sudo cp /usr/bin/true /usr/local/bin/demo-hardening-sd3-filecap sudo setcap cap_net_bind_service=ep /usr/local/bin/demo-hardening-sd3-filecap getcap /usr/local/bin/demo-hardening-sd3-filecap
/usr/local/bin/demo-hardening-sd3-filecap cap_net_bind_service=ep
[Service] Type=oneshot User=sd3demo ExecStart=/usr/local/bin/demo-hardening-sd3-filecap
Enregistrez ce fichier sous /etc/systemd/system/demo-hardening-sd3-filecap.service. Le cas A n’a aucun drop-in. Pour le cas B, écrivez CapabilityBoundingSet= (vide) dans le fichier demo-hardening-sd3-filecap.service.d/10.conf, et pour le cas C écrivez-y CapabilityBoundingSet=CAP_NET_BIND_SERVICE. À chaque fois, lancez sudo systemctl daemon-reload, puis sudo systemctl start demo-hardening-sd3-filecap.service, puis systemctl show -p Result -p ExecMainStatus demo-hardening-sd3-filecap.service.
--- A: no bounding set directive Result=success ExecMainStatus=0 --- B: CapabilityBoundingSet= (empty) [...] Result=exit-code ExecMainStatus=203 demo-hardening-sd3-filecap.service: Failed at step EXEC spawning /usr/local/bin/demo-hardening-sd3-filecap: Operation not permitted demo-hardening-sd3-filecap.service: Main process exited, code=exited, status=203/EXEC demo-hardening-sd3-filecap.service: Failed with result 'exit-code'. Failed to start demo-hardening-sd3-filecap.service. --- C: CapabilityBoundingSet=CAP_NET_BIND_SERVICE Result=success ExecMainStatus=0
Dans le cas B, le programme ne démarre jamais : systemd annonce 203/EXEC et Operation not permitted. Le fichier réclame une capacité que le plafond interdit, donc le noyau refuse de l’exécuter. Dans le cas C, en revanche, le plafond autorise exactement cette capacité, et le programme s’exécute. Par conséquent, quand un service livre un binaire avec des capacités de fichier, lancez getcap dessus avant d’écrire l’ensemble de limitation. Dans mon article sur SFTPGo, retirer cap_net_bind_service de l’ensemble de limitation a provoqué une boucle de plantage environ toutes les 40 secondes, et getcap a révélé la cause.
SecureBits= et PAMName=
SecureBits= règle des drapeaux du noyau qui changent l’interaction entre l’UID 0 et les capacités. La page systemd.exec liste les noms des drapeaux, et le sens côté noyau figure dans capabilities(7). Le test ci-dessous applique deux d’entre eux à l’unité root, puis observe le résultat. Il n’affirme rien de plus que ce que la sortie montre.
d=/etc/systemd/system/demo-hardening-sd3-root.service.d sudo rm -f $d/10-bounding.conf printf '[Service]\nSecureBits=noroot\n' | sudo tee $d/20-securebits.conf sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-root.service printf '[Service]\nSecureBits=keep-caps\n' | sudo tee $d/20-securebits.conf sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-root.service sudo rm -rf $d && sudo systemctl daemon-reload
[...] CapPrm: 0000000000000000 CapEff: 0000000000000000 CapBnd: 000001ffffffffff [...] probe bind-80: refused [...] [...] CapPrm: 000001ffffffffff CapEff: 000001ffffffffff CapBnd: 000001ffffffffff [...] probe bind-80: allowed [...]
Avec SecureBits=noroot, le service root démarre avec des ensembles permis et effectif vides, bien que l’ensemble de limitation reste complet. La sonde bind est refusée. En revanche, avec SecureBits=keep-caps, la sortie égale la référence pour un service qui tourne déjà en root. En résumé, le second drapeau n’a aucun effet dans ce test, et l’effet du premier est visible. Pour la plupart des services, vous n’aurez besoin ni de l’un ni de l’autre.
PAMName= n’a pas été testé. Elle rattache le service à une session PAM, et le laboratoire n’a aucun service PAM à observer, donc l’article ne donne aucun résultat pour elle.
Ouvrir un port bas sans root : trois conceptions
Lier un port inférieur à 1024 est la raison la plus courante de tourner en root. Trois conceptions le résolvent, et l’image ci-dessous les compare. Parmi les options des capacités systemd, la conception du milieu est celle à apprendre en premier.

- Conception A, root : simple, mais le service détient toutes les capacités. C’est la référence du laboratoire.
- Conception B, utilisateur dédié avec une capacité :
User=,AmbientCapabilities=CAP_NET_BIND_SERVICE,CapabilityBoundingSet=CAP_NET_BIND_SERVICEetNoNewPrivileges=yes. C’est la combinaison testée plus haut. - Conception C, port haut derrière un reverse proxy : le service écoute sur un port comme 8080, et le proxy possède le port 80. Le service n’a besoin d’aucune capacité.
La conception C supprime le besoin de toute capacité, donc choisissez-la quand un proxy existe déjà. Sans proxy, la conception B convient. Dans mon article précédent, le serveur de messagerie mox suit la conception B : NoNewPrivileges=true avec AmbientCapabilities=CAP_NET_BIND_SERVICE CAP_SETUID CAP_SETGID CAP_CHOWN. Quand j’ai retiré CAP_DAC_OVERRIDE, le service a eu besoin de CAP_DAC_READ_SEARCH et de SupplementaryGroups=mox pour continuer à lire ses fichiers. Etherpad, enfin, montre l’extrémité minimale : un utilisateur dédié, aucune capacité, et un niveau d’exposition de 1,5.
Lire le résultat : cinq façons d’inspecter les capacités systemd
Ne faites jamais confiance à un drop-in avant d’avoir lu ce que systemd a chargé. Ces cinq contrôles fonctionnent donc sur n’importe quelle unité, et chacun répond à une question différente.
1. systemctl show
Le premier contrôle lit les propriétés que systemd détient pour l’unité. La page de manuel de systemctl ne promet pas que les réglages d’exécution y figurent, mais dans ce test ils y sont.
systemctl show -p User -p SupplementaryGroups -p CapabilityBoundingSet -p AmbientCapabilities -p NoNewPrivileges -p RestrictSUIDSGID -p SecureBits demo-hardening-sd3-caps.service
SecureBits=0 CapabilityBoundingSet=cap_net_bind_service AmbientCapabilities=cap_net_bind_service User=sd3demo SupplementaryGroups= NoNewPrivileges=yes RestrictSUIDSGID=yes
Les noms reviennent en minuscules, et une valeur vide signifie que le réglage est absent. Notez que SecureBits=0 apparaît bien que AmbientCapabilities= soit défini. Je n’ai pas creusé ce point.
2. systemd-analyze capability
Le deuxième contrôle liste les noms de capacités avec leur numéro, ou les filtre.
systemd-analyze capability cap_net_bind_service cap_chown NAME NUMBER cap_chown 0 cap_net_bind_service 10
3. Décoder un masque
Pour transformer un masque de /proc en noms, donnez-le à systemd-analyze capability -m ou à capsh --decode.
systemd-analyze capability -m 0000000000000401 NAME NUMBER cap_chown 0 cap_net_bind_service 10 capsh --decode=0000000000000401 0x0000000000000401=cap_chown,cap_net_bind_service
4. Le processus lui-même
Le contrôle le plus fiable lit le processus vivant. D’abord, une unité transitoire, lancée par systemd-run, dort pendant deux minutes. Ensuite, le test lit son fichier d’état et lance getpcaps.
sudo systemd-run --unit=demo-hardening-sd3-sleep -p User=sd3demo -p AmbientCapabilities=CAP_NET_BIND_SERVICE -p NoNewPrivileges=yes /usr/bin/sleep 120 pid=$(systemctl show -p MainPID --value demo-hardening-sd3-sleep.service) grep -E '^(CapInh|CapPrm|CapEff|CapBnd|CapAmb|NoNewPrivs):' /proc/$pid/status getpcaps $pid
CapInh: 0000000000000400 CapPrm: 0000000000000400 CapEff: 0000000000000400 CapBnd: 000001ffffffffff CapAmb: 0000000000000400 NoNewPrivs: 1 --- getpcaps 6192: cap_net_bind_service=eip
Dans la sortie de getpcaps, cap_net_bind_service=eip signifie que la capacité est à la fois effective, héritable et permise.
5. systemd-analyze security
Le dernier contrôle est le score. Comme la même unité obtient un score différent avec et sans les quatre directives de cet article, les chiffres montrent leur effet.
[sans le drop-in] → Overall exposure level for demo-hardening-sd3-caps.service: 9.2 UNSAFE 😨 [avec User=, AmbientCapabilities=CAP_NET_BIND_SERVICE, CapabilityBoundingSet=CAP_NET_BIND_SERVICE, NoNewPrivileges=yes et RestrictSUIDSGID=yes] → Overall exposure level for demo-hardening-sd3-caps.service: 6.5 MEDIUM 😐
Le niveau d’exposition passe de 9.2 UNSAFE à 6.5 MEDIUM avec ces seules directives. Le reste du score dépend du système de fichiers, du noyau et des appels système, que couvrent les parties 2, 4, 5, 6 et 7. Voici quelques lignes du second rapport :
[...] ✓ User=/DynamicUser= Service runs under a static non-root user identity ✓ NoNewPrivileges= Service processes cannot acquire new privileges ✗ AmbientCapabilities= Service process receives ambient capabilities 0.1 ✓ SupplementaryGroups= Service has no supplementary groups ✓ CapabilityBoundingSet=~CAP_SYS_ADMIN Service has no administrator privileges ✗ CapabilityBoundingSet=~CAP_NET_(BIND_SERVICE|BROADCAST|RAW) Service has elevated networking privileges 0.1 ✓ CapabilityBoundingSet=~CAP_SET(UID|GID|PCAP) Service cannot change UID/GID identities/capabilities ✓ RestrictSUIDSGID= SUID/SGID file creation by service is restricted [...] → Overall exposure level for demo-hardening-sd3-caps.service: 6.5 MEDIUM 😐
Deux lignes coûtent 0.1 chacune : AmbientCapabilities= et les capacités réseau. C’est le prix du seul privilège dont le service a vraiment besoin, et ce prix est faible.
Drop-ins complets à copier
Utilisez ces drop-ins pour les capacités systemd comme point de départ. D’abord, remplacez app01 et appuser par vos propres noms. Le premier drop-in est la combinaison mesurée plus haut. Gardez aussi les commentaires, car ils aident la personne qui relira le fichier.
Drop-in 1 : un utilisateur dédié avec un seul privilège
sudo useradd --system --no-create-home --shell /usr/sbin/nologin appuser sudo mkdir -p /etc/systemd/system/app01.service.d sudo tee /etc/systemd/system/app01.service.d/10-privileges.conf > /dev/null <<'EOF' [Service] # Identité : jamais root. User=appuser # Accorder : le seul privilège dont ce service a besoin (lier les ports inférieurs à 1024). AmbientCapabilities=CAP_NET_BIND_SERVICE # Limiter : rien d'autre ne peut jamais être détenu, même via une capacité de fichier. CapabilityBoundingSet=CAP_NET_BIND_SERVICE # Bloquer : aucun gain via les bits setuid ou les capacités de fichier. NoNewPrivileges=yes # Bloquer : le service ne peut pas créer de fichiers setuid ou setgid. RestrictSUIDSGID=yes EOF sudo systemctl daemon-reload sudo systemctl restart app01.service systemd-analyze security app01.service | tail -1
Drop-in 2 : aucun compte fixe
sudo mkdir -p /etc/systemd/system/app01.service.d sudo tee /etc/systemd/system/app01.service.d/10-privileges.conf > /dev/null <<'EOF' [Service] # Identité : un compte temporaire, créé au démarrage et libéré à l'arrêt. DynamicUser=yes # Le seul endroit où le service peut écrire (devient /var/lib/app01). StateDirectory=app01 # DynamicUser=yes implique déjà NoNewPrivileges et RestrictSUIDSGID. EOF sudo systemctl daemon-reload sudo systemctl restart app01.service
Drop-in 3 : un service qui doit rester root
sudo mkdir -p /etc/systemd/system/app01.service.d sudo tee /etc/systemd/system/app01.service.d/10-privileges.conf > /dev/null <<'EOF' [Service] # Le service tourne toujours en root, mais il ne garde qu'une capacité. CapabilityBoundingSet=CAP_NET_BIND_SERVICE NoNewPrivileges=yes EOF sudo systemctl daemon-reload sudo systemctl restart app01.service
Parmi ces trois drop-ins, le laboratoire a mesuré le premier en entier. Le deuxième a été testé pour le compte, le répertoire d’état et les réglages impliqués. Le troisième a été testé pour l’ensemble de limitation seulement, sans NoNewPrivileges=yes. Lisez toujours systemctl show après un changement, puis testez le vrai service.
Erreurs courantes avec les capacités systemd
Ces erreurs viennent du laboratoire lui-même, donc chacune a une vraie sortie.
Une faute dans un nom de capacité reste silencieuse
L’unité ci-dessous orthographie mal le nom, avec un S en trop.
[Service] AmbientCapabilities=CAP_NET_BIND_SERVICES
AmbientCapabilities= Result=success ExecMainStatus=0 --- journal search for the misspelled name (whole boot) (end of journal search) --- systemd-analyze verify verify exit code: 0
Systemd charge l’unité sans aucun message. La propriété est simplement vide, et l’unité démarre avec Result=success. Une recherche du mauvais nom dans tout le journal du démarrage ne trouve rien, et systemd-analyze verify n’affiche rien et sort avec le code 0. Le seul signe visible est la propriété vide. Lancez donc toujours systemctl show -p AmbientCapabilities UNITE après une modification. En revanche, la forme en minuscules cap_net_bind_service est acceptée.
Un drop-in sans l’en-tête [Service]
AmbientCapabilities= /etc/systemd/system/demo-hardening-sd3-caps.service.d/10-noheader.conf:1: Assignment outside of section. Ignoring. /etc/systemd/system/demo-hardening-sd3-caps.service.d/10-noheader.conf:1: Assignment outside of section. Ignoring.
L’avertissement est clair : Assignment outside of section. Ignoring. Il est apparu deux fois dans le journal. Il n’est apparu qu’après daemon-reload et après le chargement de l’unité par un systemctl show, donc lancez une commande qui charge l’unité avant de chercher dans le journal.
Un fichier de drop-in qui ne se termine pas par .conf
Le fichier 10-ambient.txt a été ignoré, car AmbientCapabilities= est resté vide. En revanche, le journal n’a pas été examiné pour ce cas.
Autres erreurs aux symptômes clairs
- Compte absent :
status=217/USERet le texte étrangeNo such process(vu plus haut). - Ensemble de limitation vide avec un binaire à capacité de fichier :
status=203/EXECetOperation not permitted(vu plus haut). - Capacité ambiante sans
NoNewPrivileges=yes: l’assistant setuid renvoie toujours l’UID 0 (étape A). - Trop de durcissement sur un service qui appelle
sudo: il échoue avecNoNewPrivileges=yesou un ensemble de limitation vide. - Un
systemctl daemon-reloadoublié : systemd garde l’ancienne unité, et le nouveau fichier semble ne rien faire.
Checklist finale pour les capacités systemd
- Le service a-t-il besoin de root ? Sinon, définissez
User=(ouDynamicUser=yes). - A-t-il besoin d’un privilège ? Nommez exactement une capacité dans
AmbientCapabilities=. - Le plafond est-il posé ? Écrivez la même liste dans
CapabilityBoundingSet=. NoNewPrivileges=yesest-il posé, et le service fonctionne-t-il sanssudo?RestrictSUIDSGID=yesest-il posé, sauf si le service crée des fichiers setuid volontairement ?- Un binaire du service porte-t-il des capacités de fichier ? Lancez
getcapavant de fixer le plafond. - Après chaque modification, lancez
systemctl daemon-reload, puissystemctl show -ppour chaque directive. - Lisez le processus vivant :
/proc/PID/statusetgetpcaps. - Mesurez avec
systemd-analyze securityet gardez le chiffre dans la fiche de changement.
Ce que ce laboratoire n’a pas testé
PAMName=n’a pas été testé.- SELinux n’est pas disponible sur le banc, donc l’interaction entre les capacités systemd et la politique SELinux sort du cadre de cet article.
- Un
CapabilityBoundingSet=~seul (l’ensemble complet, d’après le manuel) n’a pas été testé. SecureBits=n’a été observé que sur un service root. Ses drapeaux n’ont pas été testés avecUser=.- Les bits supplémentaires de
CapInhaprèsRestrictSUIDSGID=yessont une observation sans explication. - La propriété du répertoire d’état de l’utilisateur dynamique (UID 65534 vu de l’hôte) est une observation sans explication.
- Les résultats viennent d’un noyau WSL2, donc un noyau natif peut différer.
Nettoyer le laboratoire
Lancez le script ci-dessous en root. Il supprime seulement les unités, drop-ins, fichiers et le compte que le laboratoire a créés.
for u in demo-hardening-sd3-caps demo-hardening-sd3-root demo-hardening-sd3-dynamic demo-hardening-sd3-baduser demo-hardening-sd3-filecap demo-hardening-sd3-sleep; do systemctl stop "$u.service" 2>/dev/null systemctl reset-failed "$u.service" 2>/dev/null rm -rf "/etc/systemd/system/$u.service" "/etc/systemd/system/$u.service.d" done rm -f /usr/local/bin/demo-hardening-sd3-probe.sh /usr/local/bin/demo-hardening-sd3-setuid-id /usr/local/bin/demo-hardening-sd3-run /usr/local/bin/demo-hardening-sd3-filecap rm -rf /var/lib/demo-hardening-sd3-dynamic /var/lib/private/demo-hardening-sd3-dynamic id sd3demo >/dev/null 2>&1 && userdel sd3demo systemctl daemon-reload ls -d /etc/systemd/system/*sd3* /usr/local/bin/*sd3* /var/lib/*sd3* 2>/dev/null; getent passwd sd3demo
Les deux dernières commandes ne doivent rien afficher, et c’était le cas sur le banc de test après le nettoyage.
Sources
- systemd.exec(5) : les directives
User=,DynamicUser=,NoNewPrivileges=,CapabilityBoundingSet=,AmbientCapabilities=,SecureBits=,RestrictSUIDSGID=. - capabilities(7) : la liste des capacités et les règles de chaque ensemble.
- systemd-analyze(1) : les commandes
securityetcapability.
Plus tôt dans la série
- Durcir systemd, directive par directive : mesurer avec systemd-analyze security
- Protection du système de fichiers avec systemd : durcissement, partie 2
Articles liés
- Sandboxing systemd en pratique : les drop-ins que j’utilise et ce que chacun a cassé (à paraître le 17/09)
- Pas à pas : fail2ban bien configuré, avec bannissements progressifs
- Pas à pas : installer un agent Wazuh et en tirer quelque chose (à paraître le 25/11)


















