Comment durcir les services systemd

Durcir un service systemd, c’est décider, ligne par ligne dans son fichier d’unité, ce que le processus du service est autorisé à toucher — et un service d’origine est autorisé à toucher presque tout. Il tourne généralement en root, peut écrire dans tout le système de fichiers, peut charger des modules du noyau et peut appeler n’importe quel appel système, parce que ce sont les valeurs par défaut : un fichier d’unité qui ne définit rien n’a rien retiré. Les directives de sandbox que systemd fournit déjà — ProtectSystem, PrivateTmp, NoNewPrivileges et les autres — permettent de retirer ces privilèges de l’extérieur, sans changer une seule ligne de l’application. Cet article explique ce que chaque changement ferme réellement, comment lire le score d’exposition qui mesure le résultat, et comment déployer les changements sans casser le service. Vous pouvez auditer votre propre fichier d’unité dans l’auditeur d’unités systemd, qui le note, simule ses temporisateurs et produit une version durcie — entièrement dans votre navigateur.

Une unité de service est une frontière de sandbox, pas seulement un script de démarrage

La plupart des gens lisent un fichier .service comme un script de démarrage : ExecStart dit quoi exécuter, Restart dit quoi faire quand il meurt, et le reste est un modèle. Cette lecture passe à côté de l’essentiel. La section [Service] est une liste d’autorisations, et chaque directive que vous ne définissez pas est une autorisation que vous avez implicitement accordée. Une unité sans directive de sandbox exécute son processus avec toute la portée de l’utilisateur sous lequel elle tourne — généralement root — sur le système de fichiers, le réseau, les périphériques, le noyau et tous les autres processus de la machine. Quand un tel service est compromis, l’attaquant n’a pas besoin d’élever ses privilèges : le service les a déjà.

La solution est de traiter le fichier d’unité comme la frontière de sécurité qu’il est. systemd peut confiner un processus à un système de fichiers en lecture seule, à un /tmp privé qu’aucun autre processus ne peut voir, à un /dev minimal, sans nouveaux privilèges, sans modules du noyau et avec une courte liste d’appels système — le tout déclaré dans l’unité, le tout appliqué par le noyau, et rien de tout cela n’exige de changer l’application. C’est ce qui rend le durcissement d’un service systemd différent du durcissement de la plupart des logiciels : le sandbox vit hors du code, donc vous pouvez l’ajouter à un démon que vous n’avez pas écrit et ne pouvez pas modifier, mesurer le résultat et l’annuler en supprimant un fichier. L’auditeur existe pour rendre cette frontière visible : il lit l’unité que vous avez réellement et énumère ce qu’elle permet encore.

Lire le score d’exposition : ce que 9,6 contre 2,0 signifie — et ce qu’il ne signifie pas

systemd-analyze security note une unité sur une échelle pondérée d’exposition de 0,0 à 10,0, où un nombre élevé signifie permissif et un nombre bas signifie strictement confiné, et l’étiquette avec une bande — OK, MEDIUM, EXPOSED ou UNSAFE dans la liste courte, avec PERFECT, SAFE et DANGEROUS aux extrémités de la liste complète. Un service d’origine sans directive de sandbox se situe généralement autour de 9,6 UNSAFE ; un service soigneusement durci se situe autour de 2,0 OK. Les lignes par directive dans la sortie sont la partie utile : chaque ligne nomme un réglage, s’il est défini et combien il contribue à l’exposition, de sorte que les lignes rouges les plus pondérées sont votre liste de tâches, par ordre de priorité.

Ce que le nombre ne signifie pas compte plus que ce qu’il signifie. La page de manuel est explicite : l’analyse ne couvre que les fonctions de sécurité par service que systemd lui-même implémente, et un niveau d’exposition élevé ne signifie ni qu’il n’y a pas de sandbox efficace dans le propre code du service, ni que le service est réellement vulnérable. Un 9,6 dit que le fichier d’unité n’applique presque aucun sandbox — il ne dit rien de l’authentification de l’application, de la validation des entrées ou des secrets qu’elle détient. Certains services ont légitimement besoin d’un accès large : un runtime de conteneurs a vraiment besoin d’atteindre tout pour exécuter des conteneurs, et aucune directive ne peut changer cela. Lisez donc le score comme une mesure de ce qu’un processus compromis pourrait atteindre de l’hôte, pas comme un verdict sur le service, et ne poursuivez pas le 0,0 — poursuivez les directives qui ferment la portée dont votre service n’a pas besoin.

Les dix directives qui font l’essentiel du travail

Dix directives font l’essentiel du travail réel, et chacune ferme une pièce précise de l’hôte plutôt que tout à la fois. ProtectSystem rend le système de fichiers en lecture seule — yes couvre /usr et /boot, full ajoute /etc, strict couvre tout sauf /dev, /proc et /sys — et ProtectHome cache /home, /root et /run/user entièrement. PrivateTmp donne au service son propre /tmp et /var/tmp qu’aucun autre processus ne peut voir, éliminant toute une classe d’attaques par fichiers temporaires prévisibles et de courses aux liens symboliques. NoNewPrivileges garantit que le processus et tous ses enfants ne peuvent jamais obtenir de nouveaux privilèges via execve, ce qui neutralise la plupart des escalades basées sur setuid en une seule ligne. CapabilityBoundingSet limite les capacités Linux que le processus peut jamais détenir ; laissez-le vide et le service n’en conserve aucune, ce qui est la plus forte baisse de score d’une seule directive pour beaucoup d’unités.

Les cinq autres ferment le noyau et le processus lui-même. PrivateDevices remplace /dev par un squelette minimal, de sorte qu’un service compromis ne peut pas toucher aux disques bruts ni aux autres nœuds matériels. ProtectKernelModules interdit le chargement de modules du noyau, et RestrictNamespaces empêche le service de créer de nouveaux espaces de noms parmi les types que vous énumérez — une voie d’évasion de conteneur, fermée au niveau de l’unité. LockPersonality empêche le processus de changer son domaine d’exécution, ce qui bloque une petite mais réelle classe d’attaques basées sur la personnalité. MemoryDenyWriteExecute interdit la mémoire à la fois inscriptible et exécutable, ce qui arrête le schéma classique consistant à écrire du shellcode en mémoire puis à y sauter. Avec ProtectSystem=strict, ouvrez les trous exacts dont le service a vraiment besoin avec ReadWritePaths — la liste blanche, pas un assouplissement de toute la politique — et appliquez le filtre d’appels système SystemCallFilter=@system-service en dernier, parce que c’est celui qui risque le plus de casser quelque chose de subtil.

Temporisateurs contre cron : OnCalendar, Persistent, et pourquoi les prochains déclenchements valent la peine d’être simulés

Une ligne cron et un temporisateur systemd exécutent tous deux une tâche selon un horaire, mais ce ne sont pas le même mécanisme, et les différences sont là où vivent les erreurs. Un temporisateur est une unité .timer qui active une unité .service du même nom quand elle expire, et son horaire est une expression OnCalendar — daily, Mon *-*-* 02:00, *-*-01 03:30:00, ou des listes, plages et pas comme Mon..Fri *-*-* 09:00 — avec des noms de jours de semaine, des règles de fin de mois et des répétitions qu’une ligne cron à cinq champs ne peut pas exprimer. La page de manuel systemd.timer(5) définit la sémantique ; les conséquences pratiques sont que les déclenchements d’un temporisateur sont journalisés dans le journal comme ceux de toute autre unité, qu’un déclenchement manqué peut être rattrapé, et que l’horaire lui-même peut être validé avant même de tourner.

Deux fonctions font qu’il vaut la peine de simuler les temporisateurs avant de les déployer. Persistent=yes signifie que si la machine était éteinte — ou le temporisateur inactif — quand un déclenchement était dû, le service s’exécute une fois à la prochaine occasion au lieu que cette exécution ne se produise jamais en silence, ce qui est la différence entre une sauvegarde en retard et une sauvegarde qui n’a jamais eu lieu. Et les expressions OnCalendar ont des cas limites qu’un coup d’œil ne repère pas : un déclenchement à 02:30 le jour où l’heure d’été saute 02:00–03:00, une tâche mensuelle le 31 dans un mois de 30 jours, une règle de jour de semaine qui tombe un jour férié. C’est pourquoi un tableau des prochains déclenchements vaut la peine d’être généré : exécutez systemd-analyze calendar sur l’expression, ou simulez les 100 prochains déclenchements dans l’auditeur, et lisez le tableau avant que l’horaire ne soit en vigueur — un temporisateur qui se déclenche deux fois, ou jamais, est un bug que vous voulez trouver sur un écran, pas dans une sauvegarde manquante trois mois plus tard.

Le flux sûr : des drop-ins, quelques directives à la fois

Ne modifiez jamais à la main un fichier d’unité empaqueté dans /usr/lib/systemd/system : la prochaine mise à jour du paquet l’écrase et votre durcissement disparaît en silence. La voie prise en charge est un drop-in — exécutez systemctl edit monservice.service et vos changements atterrissent dans /etc/systemd/system/monservice.service.d/override.conf, où ils priment sur le fichier livré, survivent aux mises à jour et peuvent être supprimés en effaçant un seul fichier. L’auditeur peut générer exactement ce fichier : une section [Service] contenant uniquement les directives qui manquent à votre unité, de sorte que l’unité d’origine reste intacte.

Appliquez ensuite quelques directives à la fois et mesurez de nouveau après chaque étape. Exécutez systemctl daemon-reload, redémarrez le service, confirmez qu’il tourne réellement avec systemctl status, vérifiez le journal pour les refus, et notez-le de nouveau — le score devrait baisser à chaque étape, et une étape qui casse le service vous dit exactement quelle directive l’a fait. Le mode d’échec est prévisible et même utile : le service démarre, essaie d’écrire dans un chemin que vous n’avez pas mis sur liste blanche, et meurt avec une erreur de système de fichiers en lecture seule, et journalctl -u monservice nomme le chemin exact, donc vous l’ajoutez à ReadWritePaths et vous continuez. C’est pourquoi on durcit progressivement plutôt que de coller un énorme bloc en espérant — et pourquoi les outils les plus tranchants, le filtre d’appels système et les restrictions d’espaces de noms, viennent en dernier, après que le service a prouvé qu’il fonctionne sous les restrictions de système de fichiers et de privilèges.

L’habitude d’auditer d’abord : noter avant et après, garder l’unité sous contrôle de version

Durcir sans référence, c’est deviner avec des étapes en plus. Avant de changer quoi que ce soit, notez l’unité telle qu’elle est — ce nombre est votre ligne de départ, et chaque changement ultérieur est mesuré par rapport à lui. Puis, après chaque lot de directives, notez-la de nouveau : le score qui passe de 9,6 à 4,9, puis à 2,0, est la preuve que le travail a servi à quelque chose, et un score qui ne bouge pas après un changement est un signal que la directive n’a pas pris effet comme vous l’attendiez. Conservez les chiffres d’avant et d’après avec le changement, comme vous conserveriez un banc d’essai avec une correction de performance.

La seconde moitié de l’habitude est de garder l’unité durcie là où elle ne peut pas se perdre : le drop-in, et le temporisateur s’il y en a un, appartiennent au contrôle de version à côté de la configuration de déploiement du service, pas seulement sur la machine. Une unité qui ne vit que dans /etc est à une panne de disque, une reconstruction ou un collègue bien intentionné de revenir à l’état d’origine — et une unité d’origine sur une machine reconstruite note de nouveau 9,6 en silence. Ré-auditez aussi selon un calendrier : systemd gagne de nouveaux contrôles avec le temps, donc une unité qui notait 2,0 il y a deux ans peut noter moins bien aujourd’hui sans qu’une seule ligne ait changé. La même habitude se transfère directement au fichier de configuration frère — auditez sshd_config de la même façon avec l’auditeur de configuration du serveur SSH et l’article Comment durcir la configuration du serveur SSH — parce que la discipline est la même quel que soit le fichier : mesurer d’abord, changer peu, mesurer de nouveau, et garder le résultat là où il survit à la machine.

Sources

Questions fréquentes

Un faible score d’exposition prouve-t-il que mon service est sécurisé ?

Non. Le score est une heuristique pondérée sur les directives de sandbox que systemd lui-même applique — il mesure ce qu’un processus compromis pourrait atteindre de l’hôte, pas si l’application est sûre. Il ne sait rien de l’authentification de l’application, de la validation des entrées, des bogues de logique, des secrets qu’elle détient ou de ses points de terminaison réseau exposés. Traitez un bon score comme une couche de la défense en profondeur : combinez-le avec un utilisateur dédié non root, une exposition réseau au moindre privilège et les pratiques normales de sécurité des applications. Un service peut noter 1,5 et rester vulnérable, et un service peut noter 9,6 et aller bien — le nombre est une mesure d’attention, pas un verdict.

Le durcissement va-t-il casser mon service ?

Il peut, c’est pourquoi on applique les directives quelques-unes à la fois et on teste après chaque étape. Les restrictions du système de fichiers sont la cause la plus fréquente : ProtectSystem=strict rend tout le système de fichiers en lecture seule, donc un service qui écrit hors de ses chemins de la liste blanche échoue avec une erreur de lecture seule — vérifiez le journal, ajoutez le chemin à ReadWritePaths et réessayez. Le filtre d’appels système est l’outil le plus tranchant et vient en dernier : un filtre trop strict peut laisser le service démarrer normalement puis échouer des heures plus tard sur un chemin de code rare, donc testez sous charge réelle et gardez SystemCallErrorNumber=EPERM pendant le déploiement pour que les refus apparaissent comme des erreurs ordinaires au lieu d’une mort instantanée. Rien de tout cela n’est irréversible — un drop-in se supprime, il ne se défait pas.

Dois-je remplacer cron par des temporisateurs systemd ?

Pour les tâches qui appartiennent à un service que systemd gère déjà, généralement oui : les temporisateurs vous donnent la journalisation dans le journal, des dépendances avec d’autres unités, le rattrapage Persistent des exécutions manquées et un horaire que vous pouvez valider avec systemd-analyze calendar avant sa mise en vigueur. cron reste adapté aux tâches simples par utilisateur et aux systèmes sans systemd. Quoi que vous choisissiez, simulez d’abord l’horaire — les expressions OnCalendar ont des cas limites d’heure d’été, de fin de mois et de jour de semaine qu’une ligne cron à cinq champs n’a pas, et un tableau des prochains déclenchements est le moyen le moins cher de repérer un temporisateur qui se déclenche deux fois, ou jamais, avant que cela compte.