Cómo endurecer los servicios de systemd
Última actualización:
Endurecer un servicio de systemd es decidir, línea a línea en su archivo de unidad, qué se le permite tocar al proceso del servicio, y un servicio sin tocar tiene permiso para tocar casi todo. Suele ejecutarse como root, puede escribir en todo el sistema de archivos, puede cargar módulos del kernel y puede llamar a cualquier llamada al sistema que quiera, porque esos son los valores por defecto: un archivo de unidad que no fija nada no ha retirado nada. Las directivas de sandbox que systemd ya trae —ProtectSystem, PrivateTmp, NoNewPrivileges y el resto— permiten retirar esos privilegios desde fuera, sin cambiar una sola línea de la aplicación. Este artículo explica qué cierra realmente cada cambio, cómo leer la puntuación de exposición que mide el resultado y cómo desplegar los cambios sin romper el servicio. Puedes auditar tu propio archivo de unidad en el auditor de unidades de systemd, que lo puntúa, simula sus temporizadores y produce una versión endurecida, todo en tu navegador.
Una unidad de servicio es un límite de sandbox, no solo un script de arranque
La mayoría lee un archivo .service como un script de arranque: ExecStart dice qué ejecutar, Restart dice qué hacer cuando muere y el resto es plantilla. Esa lectura pierde lo esencial. La sección [Service] es una lista de permisos, y cada directiva que no fijas es un permiso que has concedido implícitamente. Una unidad sin directivas de sandbox ejecuta su proceso con todo el alcance del usuario con el que corre —normalmente root— sobre el sistema de archivos, la red, los dispositivos, el kernel y todos los demás procesos de la máquina. Cuando un servicio así se ve comprometido, el atacante no necesita escalar privilegios: el servicio ya los tiene.
La solución es tratar el archivo de unidad como el límite de seguridad que es. systemd puede confinar un proceso a un sistema de archivos de solo lectura, a un /tmp privado que ningún otro proceso puede ver, a un /dev mínimo, sin privilegios nuevos, sin módulos del kernel y con una lista corta de llamadas al sistema: todo declarado en la unidad, todo aplicado por el kernel y nada de ello exige cambiar la aplicación. Eso es lo que hace distinto endurecer un servicio de systemd de endurecer la mayoría del software: el sandbox vive fuera del código, así que puedes añadirlo a un demonio que no escribiste ni puedes modificar, medir el resultado y revertirlo borrando un archivo. El auditor existe para hacer visible ese límite: lee la unidad que tienes de verdad y enumera lo que todavía permite.
Cómo leer la puntuación de exposición: qué significa 9,6 frente a 2,0, y qué no significa
systemd-analyze security puntúa una unidad en una escala ponderada de exposición de 0,0 a 10,0, donde un número alto significa permisivo y uno bajo significa muy restringido, y la etiqueta con una banda: OK, MEDIUM, EXPOSED o UNSAFE en la lista corta, con PERFECT, SAFE y DANGEROUS en los extremos de la lista completa. Un servicio sin tocar, sin directivas de sandbox, suele quedar en torno a 9,6 UNSAFE; uno endurecido con cuidado queda en torno a 2,0 OK. Las filas por directiva de la salida son la parte útil: cada fila nombra un ajuste, si está fijado y cuánto contribuye a la exposición, así que las filas rojas de mayor peso son tu lista de tareas, en orden de prioridad.
Lo que el número no significa importa más que lo que significa. La página del manual es explícita: el análisis cubre solo las funciones de seguridad por servicio que el propio systemd implementa, y un nivel de exposición alto no significa ni que no haya sandbox eficaz en el propio código del servicio, ni que el servicio sea realmente vulnerable. Un 9,6 dice que el archivo de unidad aplica casi ningún sandbox; no dice nada de la autenticación de la aplicación, de la validación de entradas ni de los secretos que guarda. Algunos servicios necesitan legítimamente un acceso amplio: un runtime de contenedores necesita de verdad llegar a todo para ejecutar contenedores, y ninguna directiva puede cambiar eso. Lee la puntuación como una medida de cuánto del host podría alcanzar un proceso comprometido, no como un veredicto sobre el servicio, y no persigas el 0,0: persigue las directivas que cierran el alcance que tu servicio no necesita.
Las diez directivas que hacen la mayor parte del trabajo
Diez directivas hacen la mayor parte del trabajo real, y cada una cierra una pieza concreta del host en lugar de todas a la vez. ProtectSystem hace que el sistema de archivos sea de solo lectura —yes cubre /usr y /boot, full añade /etc, strict cubre todo excepto /dev, /proc y /sys— y ProtectHome oculta /home, /root y /run/user por completo. PrivateTmp da al servicio su propio /tmp y /var/tmp que ningún otro proceso puede ver, acabando con toda una clase de ataques de archivos temporales predecibles y carreras de enlaces simbólicos. NoNewPrivileges garantiza que el proceso y todos sus hijos nunca puedan obtener privilegios nuevos mediante execve, lo que neutraliza la mayoría de la escalación basada en setuid en una sola línea. CapabilityBoundingSet limita las capacidades de Linux que el proceso puede llegar a tener; si lo dejas vacío, el servicio no conserva ninguna, que es la mayor bajada de puntuación de una sola directiva para muchas unidades.
Las otras cinco cierran el kernel y el propio proceso. PrivateDevices sustituye /dev por un esqueleto mínimo, así que un servicio comprometido no puede tocar discos sin procesar ni otros nodos de hardware. ProtectKernelModules prohíbe cargar módulos del kernel, y RestrictNamespaces impide que el servicio cree nuevos espacios de nombres de los tipos que enumeres: una vía de escape de contenedores, cerrada en la unidad. LockPersonality impide que el proceso cambie su dominio de ejecución, lo que bloquea una clase pequeña pero real de ataques basados en la personalidad. MemoryDenyWriteExecute prohíbe la memoria que sea a la vez escribible y ejecutable, lo que detiene el patrón clásico de escribir shellcode en memoria y saltar a él. Junto con ProtectSystem=strict, abre los agujeros exactos que el servicio necesita de verdad con ReadWritePaths —la lista blanca, no un aflojamiento de toda la política— y aplica el filtro de llamadas al sistema SystemCallFilter=@system-service en último lugar, porque es el que más probablemente rompa algo sutil.
Temporizadores frente a cron: OnCalendar, Persistent y por qué merece la pena simular los próximos disparos
Una línea de cron y un temporizador de systemd ejecutan un trabajo según un horario, pero no son el mismo mecanismo, y las diferencias son donde viven los errores. Un temporizador es una unidad .timer que activa una unidad .service del mismo nombre cuando vence, y su horario es una expresión OnCalendar —daily, Mon *-*-* 02:00, *-*-01 03:30:00, o listas, rangos y pasos como Mon..Fri *-*-* 09:00— con nombres de días de la semana, reglas de fin de mes y repeticiones que una línea de cron de cinco campos no puede expresar. La página del manual systemd.timer(5) define la semántica; las consecuencias prácticas son que los disparos de un temporizador quedan registrados en el journal como los de cualquier otra unidad, que un disparo perdido puede recuperarse y que el propio horario puede validarse antes de ejecutarse.
Dos funciones hacen que merezca la pena simular los temporizadores antes de desplegarlos. Persistent=yes significa que si la máquina estaba apagada —o el temporizador inactivo— cuando tocaba un disparo, el servicio se ejecuta una vez en la siguiente oportunidad en lugar de que esa ejecución no ocurra nunca en silencio, que es la diferencia entre una copia de seguridad tarde y una copia de seguridad que nunca se hizo. Y las expresiones OnCalendar tienen casos límite que una mirada no detecta: un disparo a las 02:30 el día en que el horario de verano se salta las 02:00–03:00, un trabajo mensual el día 31 en un mes de 30 días, una regla de día de semana que cae en festivo. Por eso merece la pena generar una tabla de próximos disparos: ejecuta systemd-analyze calendar con la expresión, o simula los próximos 100 disparos en el auditor, y lee la tabla antes de que el horario entre en vigor; un temporizador que dispara dos veces, o nunca, es un error que quieres encontrar en una pantalla, no en una copia de seguridad que falta tres meses después.
El flujo seguro: drop-ins, unas pocas directivas cada vez
No edites nunca a mano un archivo de unidad empaquetado en /usr/lib/systemd/system: la próxima actualización del paquete lo sobrescribe y tu endurecimiento desaparece en silencio. La ruta admitida es un drop-in: ejecuta systemctl edit miservicio.service y tus cambios quedan en /etc/systemd/system/miservicio.service.d/override.conf, donde tienen prioridad sobre el archivo distribuido, sobreviven a las actualizaciones y pueden eliminarse borrando un solo archivo. El auditor puede generar exactamente ese archivo: una sección [Service] con solo las directivas que le faltan a tu unidad, así que la unidad original queda intacta.
Después aplica unas pocas directivas cada vez y vuelve a medir tras cada paso. Ejecuta systemctl daemon-reload, reinicia el servicio, confirma que realmente está en marcha con systemctl status, revisa el journal en busca de denegaciones y vuelve a puntuarlo: la puntuación debería bajar en cada paso, y un paso que rompa el servicio te dice exactamente qué directiva lo hizo. El modo de fallo es predecible e incluso útil: el servicio arranca, intenta escribir en una ruta que no pusiste en la lista blanca y muere con un error de sistema de archivos de solo lectura, y journalctl -u miservicio nombra la ruta exacta, así que la añades a ReadWritePaths y sigues. Por eso se endurece poco a poco en lugar de pegar un bloque gigante y rezar, y por eso las herramientas más afiladas, el filtro de llamadas al sistema y las restricciones de espacios de nombres, van en último lugar, después de que el servicio haya demostrado que funciona bajo las restricciones de sistema de archivos y privilegios.
El hábito de auditar primero: puntuar antes y después, y guardar la unidad en control de versiones
Endurecer sin una referencia es adivinar con pasos extra. Antes de cambiar nada, puntúa la unidad tal como está: ese número es tu línea de salida, y cada cambio posterior se mide contra él. Después, tras cada tanda de directivas, puntúala de nuevo: que la puntuación baje de 9,6 a 4,9 y luego a 2,0 es la evidencia de que el trabajo sirvió para algo, y una puntuación que no se mueve tras un cambio es una señal de que la directiva no surtió el efecto esperado. Guarda los números de antes y después junto con el cambio, como guardarías una referencia junto con una mejora de rendimiento.
La segunda mitad del hábito es guardar la unidad endurecida donde no pueda perderse: el drop-in, y el temporizador si lo hay, pertenecen al control de versiones junto con la configuración de despliegue del servicio, no solo en la máquina. Una unidad que vive solo en /etc está a un fallo de disco, una reconstrucción o un colega bienintencionado de volver a su estado original, y una unidad original en una máquina reconstruida vuelve a puntuar 9,6 en silencio. Vuelve a auditar también según un calendario: systemd gana comprobaciones nuevas con el tiempo, así que una unidad que puntuaba 2,0 hace dos años puede puntuar peor hoy sin que haya cambiado una sola línea. El mismo hábito se traslada directamente al archivo de configuración hermano: audita sshd_config de la misma forma con el auditor de configuración del servidor SSH y el artículo Cómo endurecer la configuración del servidor SSH, porque la disciplina es la misma sea cual sea el archivo: medir primero, cambiar poco, medir de nuevo y guardar el resultado donde sobreviva a la máquina.