* systemd and rebooting
@ 2026-10-18 22:56 Russell Coker
2026-10-20 9:46 ` Dominick Grift
0 siblings, 1 reply; 2+ messages in thread
From: Russell Coker @ 2026-10-18 22:56 UTC (permalink / raw)
To: selinux-refpolicy
[-- Attachment #1: Type: text/plain, Size: 1404 bytes --]
Currently there are no SE Linux access controls for reboot/halt/suspend/etc
running in a typical systemd configuration. So any process that can talk to
the dbus system bus can reboot without SE Linux access controls.
The problem is that reboot/halt type operations can be initiated through dbus
connections to either init or systemd-logind and the latter has no SE Linux
code.
https://github.com/systemd/systemd/issues/34878
The above URL has a systemd bug report.
allow sysadm_t systemd_logind_t:system { halt reboot };
The attached patch addresses this. It's not a candidate for inclusion in
systemd upstream as it has duplicated code for SE Linux access checks but it
works and would be a starting point for someone who knows systemd better than
SE Linux. The attached patch needs policy like the above.
It would be possible to write a patch that checks access against the context
of pid 1 but I went for the most direct solution to the problem for at least
the first draft.
https://github.com/systemd/systemd/issues?q=is%3Aissue+state%3Aopen+selinux
As an aside there's more than a few SE Linux related bugs reported against
systemd if someone has experience with systemd hacking and interest in SE
Linux. I would be happy to help with the SE Linux side of testing such
things.
--
My Main Blog http://etbe.coker.com.au/
My Documents Blog http://doc.coker.com.au/
[-- Attachment #2: systemd-reboot.diff --]
[-- Type: text/x-patch, Size: 20622 bytes --]
Index: systemd-262/src/login/logind-dbus.c
===================================================================
--- systemd-262.orig/src/login/logind-dbus.c
+++ systemd-262/src/login/logind-dbus.c
@@ -55,6 +55,7 @@
#include "path-util.h"
#include "process-util.h"
#include "reboot-util.h"
+#include "selinux-access.h"
#include "serialize.h"
#include "signal-util.h"
#include "sleep-config.h"
@@ -2209,6 +2210,29 @@ static int method_do_shutdown_or_sleep(
assert(message);
assert(HANDLE_ACTION_IS_SHUTDOWN(action) || HANDLE_ACTION_IS_SLEEP(action));
+ switch (action) {
+
+ case HANDLE_POWEROFF:
+ case HANDLE_HALT:
+ case HANDLE_SUSPEND:
+ case HANDLE_SLEEP:
+ case HANDLE_HIBERNATE:
+ case HANDLE_HYBRID_SLEEP:
+ case HANDLE_SUSPEND_THEN_HIBERNATE:
+ r = mac_selinux_access_check(message, "halt", error);
+ break;
+ case HANDLE_REBOOT:
+ case HANDLE_KEXEC:
+ case HANDLE_SOFT_REBOOT:
+ r = mac_selinux_access_check(message, "reboot", error);
+ break;
+ default:
+ r = 0;
+ break;
+ }
+ if (r < 0)
+ return r;
+
if (with_flags) {
/* New style method: with flags parameter (and interactive bool in the bus message header) */
r = sd_bus_message_read(message, "t", &flags);
Index: systemd-262/src/login/meson.build
===================================================================
--- systemd-262.orig/src/login/meson.build
+++ systemd-262/src/login/meson.build
@@ -8,6 +8,7 @@ systemd_logind_sources = files(
'logind.c',
)
systemd_logind_export_sources = files(
+ 'audit-fd.c',
'logind-action.c',
'logind-brightness.c',
'logind-button.c',
@@ -27,6 +28,8 @@ systemd_logind_export_sources = files(
'logind-utmp.c',
'logind-varlink.c',
'logind-wall.c',
+ 'selinux-access.c',
+ 'selinux-setup.c',
)
logind_gperf_c = custom_target(
@@ -49,7 +52,9 @@ executables += [
'sources' : systemd_logind_sources,
'export' : systemd_logind_export_sources,
'dependencies' : [
+ libaudit_cflags,
libacl_cflags,
+ libselinux_cflags,
],
},
executable_template + {
Index: systemd-262/src/login/selinux-access.c
===================================================================
--- /dev/null
+++ systemd-262/src/login/selinux-access.c
@@ -0,0 +1,329 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+
+#include "selinux-access.h"
+
+#if HAVE_SELINUX
+
+#include <unistd.h>
+
+#include "sd-bus.h"
+#include "sd-varlink.h"
+
+#include "alloc-util.h"
+#include "audit-fd.h"
+#include "errno-util.h"
+#include "format-util.h"
+#include "libaudit-util.h"
+#include "log.h"
+#include "selinux-util.h"
+#include "stdio-util.h"
+#include "string-util.h"
+#include "strv.h"
+
+static bool initialized = false;
+
+struct audit_info {
+ sd_bus_creds *creds;
+ sd_varlink *link;
+ const char *path;
+ const char *cmdline;
+ const char *function;
+};
+
+/*
+ Any time an access gets denied this callback will be called
+ with the audit data. We then need to just copy the audit data into the msgbuf.
+*/
+static int audit_callback(
+ void *auditdata,
+ security_class_t cls,
+ char *msgbuf,
+ size_t msgbufsize) {
+
+ const struct audit_info *audit = auditdata;
+ uid_t uid = 0, login_uid = 0;
+ gid_t gid = 0;
+ char login_uid_buf[DECIMAL_STR_MAX(uid_t) + 1] = "n/a";
+ char uid_buf[DECIMAL_STR_MAX(uid_t) + 1] = "n/a";
+ char gid_buf[DECIMAL_STR_MAX(gid_t) + 1] = "n/a";
+
+ if (audit->creds) {
+ /* DBus case */
+ if (sd_bus_creds_get_audit_login_uid(audit->creds, &login_uid) >= 0)
+ xsprintf(login_uid_buf, UID_FMT, login_uid);
+ if (sd_bus_creds_get_euid(audit->creds, &uid) >= 0)
+ xsprintf(uid_buf, UID_FMT, uid);
+ if (sd_bus_creds_get_egid(audit->creds, &gid) >= 0)
+ xsprintf(gid_buf, GID_FMT, gid);
+ }
+
+ if (audit->link) {
+ /* varlink */
+ if (sd_varlink_get_peer_uid(audit->link, &uid) >= 0)
+ xsprintf(uid_buf, UID_FMT, uid);
+ if (sd_varlink_get_peer_gid(audit->link, &gid) >= 0)
+ xsprintf(gid_buf, GID_FMT, gid);
+ }
+
+ (void) snprintf(msgbuf, msgbufsize,
+ "auid=%s uid=%s gid=%s%s%s%s%s%s%s%s%s%s",
+ login_uid_buf, uid_buf, gid_buf,
+ audit->path ? " path=\"" : "", strempty(audit->path), audit->path ? "\"" : "",
+ audit->cmdline ? " cmdline=\"" : "", strempty(audit->cmdline), audit->cmdline ? "\"" : "",
+ audit->function ? " function=\"" : "", strempty(audit->function), audit->function ? "\"" : "");
+
+ return 0;
+}
+
+static int callback_type_to_priority(int type) {
+ switch (type) {
+
+ case SELINUX_ERROR:
+ return LOG_ERR;
+
+ case SELINUX_WARNING:
+ return LOG_WARNING;
+
+ case SELINUX_INFO:
+ return LOG_INFO;
+
+ case SELINUX_AVC:
+ default:
+ return LOG_NOTICE;
+ }
+}
+
+/*
+ libselinux uses this callback when access gets denied or other
+ events happen. If audit is turned on, messages will be reported
+ using audit netlink, otherwise they will be logged using the usual
+ channels.
+
+ Code copied from dbus and modified.
+*/
+_printf_(2, 3) static int log_callback(int type, const char *fmt, ...) {
+ va_list ap;
+ const char *fmt2;
+
+#if HAVE_AUDIT
+ int fd = get_core_audit_fd();
+
+ if (fd >= 0) {
+ _cleanup_free_ char *buf = NULL;
+ int r;
+
+ va_start(ap, fmt);
+ r = vasprintf(&buf, fmt, ap);
+ va_end(ap);
+
+ if (r >= 0) {
+ if (type == SELINUX_AVC)
+ sym_audit_log_user_avc_message(fd, AUDIT_USER_AVC, buf, NULL, NULL, NULL, getuid());
+ else if (type == SELINUX_ERROR)
+ sym_audit_log_user_avc_message(fd, AUDIT_USER_SELINUX_ERR, buf, NULL, NULL, NULL, getuid());
+
+ return 0;
+ }
+ }
+#endif
+
+ fmt2 = strjoina("selinux: ", fmt);
+
+ va_start(ap, fmt);
+
+ DISABLE_WARNING_FORMAT_NONLITERAL;
+ log_internalv(LOG_AUTH | callback_type_to_priority(type),
+ 0, PROJECT_FILE, __LINE__, __func__,
+ fmt2, ap);
+ REENABLE_WARNING;
+ va_end(ap);
+
+ return 0;
+}
+
+static int access_init(sd_bus_error *reterr_error) {
+ int r;
+
+ if (!mac_selinux_use())
+ return 0;
+
+ if (initialized)
+ return 1;
+
+ if (sym_avc_open(NULL, 0) != 0) {
+ /* Passing errno to save original value for later */
+ r = log_selinux_enforcing_errno(errno, "Failed to open the SELinux AVC: %m");
+ if (r == 0)
+ /* log_selinux_enforcing_errno() can return 0 if the enforcement isn't on.
+ * In this case don't do any AVC checks.
+ * The warning we printed is hence all the admin will see. */
+ return 0;
+
+ /* Return an access denied error based on the original errno, if we couldn't load the AVC but
+ * enforcing mode was on, or we couldn't determine whether it is one. */
+ errno = -r;
+ return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_ACCESS_DENIED, "Failed to open the SELinux AVC: %m");
+ }
+
+ sym_selinux_set_callback(SELINUX_CB_AUDIT, (union selinux_callback) { .func_audit = audit_callback });
+ sym_selinux_set_callback(SELINUX_CB_LOG, (union selinux_callback) { .func_log = log_callback });
+
+ initialized = true;
+ return 1;
+}
+
+static int get_our_contexts(const char **ret_acon, const char **ret_tclass, char **ret_fcon) {
+ _cleanup_freecon_ char *fcon = NULL;
+
+ assert(ret_acon);
+ assert(ret_tclass);
+ assert(ret_fcon);
+
+ /* Ideally, we should call mac_selinux_get_our_label() here because it
+ * does exactly the same - call getcon_raw(). However, it involves
+ * selinux_init() which opens label DB. It was not part of the
+ * original code. I don't want to change it for now. */
+ if (sym_getcon_raw(&fcon) < 0)
+ return log_debug_errno(errno, "SELinux getcon_raw() failed: %m");
+
+ if (!fcon)
+ return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "SELinux returned no context of the current process");
+
+ *ret_acon = fcon;
+ *ret_tclass = "system";
+ *ret_fcon = TAKE_PTR(fcon);
+ return 0;
+}
+
+static int check_access(
+ const char *scon,
+ const char *tcon,
+ const char *tclass,
+ const char *permission,
+ struct audit_info *audit_info,
+ sd_bus_error *reterr_error) {
+
+ bool enforce = mac_selinux_enforcing();
+ int r;
+
+ assert(scon);
+ assert(tcon);
+ assert(tclass);
+ assert(permission);
+ assert(audit_info);
+ assert(audit_info->function);
+
+ r = sym_selinux_check_access(scon, tcon, tclass, permission, audit_info);
+ if (r < 0) {
+ errno = -(r = errno_or_else(EPERM));
+
+ if (enforce)
+ sd_bus_error_setf(reterr_error, SD_BUS_ERROR_ACCESS_DENIED, "SELinux policy denies access: %m");
+ }
+
+ return log_selinux_enforcing_errno(
+ r,
+ "SELinux access check scon=%s tcon=%s tclass=%s perm=%s state=%s function=%s path=%s cmdline=%s: %m",
+ scon,
+ tcon,
+ tclass,
+ permission,
+ enforce ? "enforcing" : "permissive",
+ audit_info->function,
+ empty_to_na(audit_info->path),
+ empty_to_na(audit_info->cmdline));
+}
+
+/*
+ This function communicates with the kernel to check whether or not it should
+ allow the access.
+ If the machine is in permissive mode it will return ok. Audit messages will
+ still be generated if the access would be denied in enforcing mode.
+*/
+int mac_selinux_access_check_internal(
+ sd_bus_message *message,
+ const char *permission,
+ const char *function,
+ sd_bus_error *reterr_error) {
+
+ _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
+ const char *tclass, *scon, *acon;
+ _cleanup_free_ char *cl = NULL;
+ _cleanup_freecon_ char *fcon = NULL;
+ char **cmdline = NULL;
+ bool enforce;
+ int r = 0;
+
+ assert(message);
+ assert(permission);
+ assert(function);
+
+ r = access_init(reterr_error);
+ if (r <= 0)
+ return r;
+
+ /* delay call until we checked in `access_init()` if SELinux is actually enabled */
+ enforce = mac_selinux_enforcing();
+
+ r = sd_bus_query_sender_creds(
+ message,
+ SD_BUS_CREDS_PID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_EGID|
+ SD_BUS_CREDS_CMDLINE|SD_BUS_CREDS_AUDIT_LOGIN_UID|
+ SD_BUS_CREDS_SELINUX_CONTEXT|
+ SD_BUS_CREDS_AUGMENT /* get more bits from /proc */,
+ &creds);
+ if (r < 0)
+ return r;
+
+ /* The SELinux context is something we really should have gotten directly from the message or sender,
+ * and not be an augmented field. If it was augmented we cannot use it for authorization, since this
+ * is racy and vulnerable. Let's add an extra check, just in case, even though this really shouldn't
+ * be possible. */
+ assert_return((sd_bus_creds_get_augmented_mask(creds) & SD_BUS_CREDS_SELINUX_CONTEXT) == 0, -EPERM);
+
+ r = sd_bus_creds_get_selinux_context(creds, &scon);
+ if (r < 0)
+ return r;
+
+ r = get_our_contexts(&acon, &tclass, &fcon);
+ if (r < 0) {
+ log_selinux_enforcing_errno(
+ r,
+ "Failed to retrieves SELinux context of current process (perm=%s)%s: %m",
+ permission,
+ enforce ? "" : ", ignoring");
+
+ if (!enforce)
+ return 0;
+
+ if (r == -EOPNOTSUPP)
+ return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_ACCESS_DENIED, "We appear not to have any SELinux context: %m");
+
+ return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_ACCESS_DENIED, "Failed to get current context: %m");
+ }
+
+ (void) sd_bus_creds_get_cmdline(creds, &cmdline);
+ cl = strv_join(cmdline, " ");
+
+ struct audit_info audit_info = {
+ .creds = creds,
+ .path = NULL,
+ .cmdline = cl,
+ .function = function,
+ };
+
+ return check_access(scon, acon, tclass, permission, &audit_info, reterr_error);
+}
+
+#else /* HAVE_SELINUX */
+
+int mac_selinux_access_check_internal(
+ sd_bus_message *message,
+ const char *permission,
+ const char *function,
+ sd_bus_error *reterr_error) {
+
+ return 0;
+}
+
+#endif /* HAVE_SELINUX */
Index: systemd-262/src/login/selinux-access.h
===================================================================
--- /dev/null
+++ systemd-262/src/login/selinux-access.h
@@ -0,0 +1,13 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#pragma once
+
+#include "logind-forward.h"
+
+int mac_selinux_access_check_internal(
+ sd_bus_message *message,
+ const char *permission,
+ const char *function,
+ sd_bus_error *reterr_error);
+
+#define mac_selinux_access_check(message, permission, error) \
+ mac_selinux_access_check_internal((message), (permission), __func__, (error))
Index: systemd-262/src/login/selinux-setup.c
===================================================================
--- /dev/null
+++ systemd-262/src/login/selinux-setup.c
@@ -0,0 +1,94 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+
+#include <unistd.h>
+
+#include "sd-messages.h"
+
+#include "errno-util.h"
+#include "initrd-util.h"
+#include "log.h"
+#include "selinux-setup.h"
+#include "selinux-util.h"
+#include "string-util.h"
+#include "time-util.h"
+
+int mac_selinux_setup(bool *loaded_policy) {
+ int r;
+
+ assert(loaded_policy);
+
+ r = dlopen_libselinux(LOG_DEBUG);
+ if (r < 0)
+ return 0;
+
+ mac_selinux_disable_logging();
+
+ /* Don't load policy in the initrd if we don't appear to have it. For the real root, we check below
+ * if we've already loaded policy, and return gracefully. */
+ if (in_initrd() && access(sym_selinux_path(), F_OK) < 0) {
+ if (errno != ENOENT)
+ log_warning_errno(errno, "Unable to check if %s exists, assuming it does not: %m", sym_selinux_path());
+
+ return 0;
+ }
+
+ bool initialized = false;
+
+ /* Already initialized by somebody else?
+ *
+ * Note: getcon_raw() can return 0, and still give us a NULL pointer if /proc/self/attr/current is
+ * empty. SELinux guarantees this won't happen, but that file isn't specific to SELinux, and may be
+ * provided by some other arbitrary LSM with different semantics. */
+ _cleanup_freecon_ char *con = NULL;
+ if (sym_getcon_raw(&con) < 0)
+ log_debug_errno(errno, "getcon_raw() failed, assuming SELinux is not initialized: %m");
+ else if (con) {
+ initialized = !streq(con, "kernel");
+ log_debug("SELinux already initialized: %s", yes_no(initialized));
+ }
+
+ /* Make sure we have no fds open while loading the policy and transitioning */
+ log_close();
+
+ /* Now load the policy */
+ usec_t before_load = now(CLOCK_MONOTONIC);
+ int enforce = 0;
+ if (sym_selinux_init_load_policy(&enforce) == 0) { /* NB: Apparently doesn't set useful errno! */
+ mac_selinux_retest();
+
+ /* Transition to the new context */
+ _cleanup_freecon_ char *label = NULL;
+ r = mac_selinux_get_create_label_from_exe(SYSTEMD_BINARY_PATH, &label);
+ if (r < 0) {
+ log_open();
+ log_warning_errno(r, "Failed to compute init label, ignoring: %m");
+ } else {
+ r = RET_NERRNO(sym_setcon_raw(label));
+ log_open();
+ if (r < 0)
+ log_warning_errno(r, "Failed to transition into init label '%s', ignoring: %m", label);
+ else
+ log_debug("Successfully switched to calculated init label '%s'.", label);
+ }
+
+ usec_t after_load = now(CLOCK_MONOTONIC);
+ log_info("Successfully loaded SELinux policy in %s.",
+ FORMAT_TIMESPAN(after_load - before_load, 0));
+
+ *loaded_policy = true;
+ } else {
+ log_open();
+
+ if (enforce > 0) {
+ if (!initialized)
+ return log_struct_errno(LOG_EMERG, SYNTHETIC_ERRNO(EIO),
+ LOG_MESSAGE("Failed to load SELinux policy."),
+ LOG_MESSAGE_ID(SD_MESSAGE_SELINUX_FAILED_STR));
+
+ log_notice("Failed to load new SELinux policy. Continuing with old policy.");
+ } else
+ log_debug("Unable to load SELinux policy. Ignoring.");
+ }
+
+ return 0;
+}
Index: systemd-262/src/login/selinux-setup.h
===================================================================
--- /dev/null
+++ systemd-262/src/login/selinux-setup.h
@@ -0,0 +1,12 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#pragma once
+
+#include "logind-forward.h"
+
+#if HAVE_SELINUX
+int mac_selinux_setup(bool *loaded_policy);
+#else
+static inline int mac_selinux_setup(bool *loaded_policy) {
+ return 0;
+}
+#endif
Index: systemd-262/src/login/audit-fd.c
===================================================================
--- /dev/null
+++ systemd-262/src/login/audit-fd.c
@@ -0,0 +1,27 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+
+#include "audit-fd.h"
+#include "capability-util.h"
+#include "libaudit-util.h"
+
+static bool initialized = false;
+static int audit_fd = -EBADF;
+
+int get_core_audit_fd(void) {
+ if (!initialized) {
+ if (have_effective_cap(CAP_AUDIT_WRITE) <= 0)
+ audit_fd = -EPERM;
+ else
+ audit_fd = open_audit_fd_or_warn();
+
+ initialized = true;
+ }
+
+ return audit_fd;
+}
+
+void close_core_audit_fd(void) {
+ close_audit_fd(audit_fd);
+ initialized = true;
+ audit_fd = -ECONNRESET;
+}
Index: systemd-262/src/login/audit-fd.h
===================================================================
--- /dev/null
+++ systemd-262/src/login/audit-fd.h
@@ -0,0 +1,7 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#pragma once
+
+#include "logind-forward.h"
+
+int get_core_audit_fd(void);
+void close_core_audit_fd(void);
^ permalink raw reply [flat|nested] 2+ messages in thread
* Re: systemd and rebooting
2026-10-18 22:56 systemd and rebooting Russell Coker
@ 2026-10-20 9:46 ` Dominick Grift
0 siblings, 0 replies; 2+ messages in thread
From: Dominick Grift @ 2026-10-20 9:46 UTC (permalink / raw)
To: Russell Coker; +Cc: selinux-refpolicy
Russell Coker <russell@coker.com.au> writes:
> Currently there are no SE Linux access controls for reboot/halt/suspend/etc
> running in a typical systemd configuration. So any process that can talk to
> the dbus system bus can reboot without SE Linux access controls.
>
> The problem is that reboot/halt type operations can be initiated through dbus
> connections to either init or systemd-logind and the latter has no SE Linux
> code.
>
> https://github.com/systemd/systemd/issues/34878
>
> The above URL has a systemd bug report.
>
> allow sysadm_t systemd_logind_t:system { halt reboot };
>
> The attached patch addresses this. It's not a candidate for inclusion in
> systemd upstream as it has duplicated code for SE Linux access checks but it
> works and would be a starting point for someone who knows systemd better than
> SE Linux. The attached patch needs policy like the above.
>
> It would be possible to write a patch that checks access against the context
> of pid 1 but I went for the most direct solution to the problem for at least
> the first draft.
>
> https://github.com/systemd/systemd/issues?q=is%3Aissue+state%3Aopen+selinux
>
> As an aside there's more than a few SE Linux related bugs reported against
> systemd if someone has experience with systemd hacking and interest in SE
> Linux. I would be happy to help with the SE Linux side of testing such
> things.
I am not sure about this but I wanted to note:
https://github.com/systemd/systemd/pulls?q=is%3Apr+state%3Aopen+label%3Aselinux
There are various entries there that are stuck. Two notable ones:
https://github.com/systemd/systemd/pull/20387
https://github.com/systemd/systemd/pull/10023
--
gpg --auto-key-locate clear,nodefault,wkd --locate-external-keys dominick.grift@defensec.nl
Key fingerprint = FCD2 3660 5D6B 9D27 7FC6 E0FF DA7E 521F 10F6 4098
Dominick Grift
Mastodon: @kcinimod@defensec.nl
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2026-10-20 9:46 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-10-18 22:56 systemd and rebooting Russell Coker
2026-10-20 9:46 ` Dominick Grift
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.