X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fshared%2Fcapability.c;h=3f2f27e23fe4234c2660da30e5d99f76549aff14;hp=321952067d71469c3e9c683ff85c191695dac730;hb=7d328b544621d4b1bec936dec612947ad8bfb65a;hpb=574d5f2dfc25226afc718aa5ba1a145fe5cad221 diff --git a/src/shared/capability.c b/src/shared/capability.c index 321952067..3f2f27e23 100644 --- a/src/shared/capability.c +++ b/src/shared/capability.c @@ -29,39 +29,50 @@ #include #include #include +#include "grp.h" #include "macro.h" -#include "capability.h" #include "util.h" #include "log.h" #include "fileio.h" +#include "capability.h" int have_effective_cap(int value) { - cap_t cap; + _cleanup_cap_free_ cap_t cap; cap_flag_value_t fv; - int r; cap = cap_get_proc(); if (!cap) return -errno; if (cap_get_flag(cap, value, CAP_EFFECTIVE, &fv) < 0) - r = -errno; + return -errno; else - r = fv == CAP_SET; - - cap_free(cap); - return r; + return fv == CAP_SET; } unsigned long cap_last_cap(void) { - static __thread unsigned long saved; - static __thread bool valid = false; + static thread_local unsigned long saved; + static thread_local bool valid = false; + _cleanup_free_ char *content = NULL; unsigned long p; + int r; if (valid) return saved; + /* available since linux-3.2 */ + r = read_one_line_file("/proc/sys/kernel/cap_last_cap", &content); + if (r >= 0) { + r = safe_atolu(content, &p); + if (r >= 0) { + saved = p; + valid = true; + return p; + } + } + + /* fall back to syscall-probing for pre linux-3.2 */ p = (unsigned long) CAP_LAST_CAP; if (prctl(PR_CAPBSET_READ, p) < 0) { @@ -88,9 +99,9 @@ unsigned long cap_last_cap(void) { } int capability_bounding_set_drop(uint64_t drop, bool right_now) { - unsigned long i; - cap_t after_cap = NULL, temp_cap = NULL; + _cleanup_cap_free_ cap_t after_cap = NULL; cap_flag_value_t fv; + unsigned long i; int r; /* If we are run as PID 1 we will lack CAP_SETPCAP by default @@ -102,12 +113,11 @@ int capability_bounding_set_drop(uint64_t drop, bool right_now) { if (!after_cap) return -errno; - if (cap_get_flag(after_cap, CAP_SETPCAP, CAP_EFFECTIVE, &fv) < 0) { - cap_free(after_cap); + if (cap_get_flag(after_cap, CAP_SETPCAP, CAP_EFFECTIVE, &fv) < 0) return -errno; - } if (fv != CAP_SET) { + _cleanup_cap_free_ cap_t temp_cap = NULL; static const cap_value_t v = CAP_SETPCAP; temp_cap = cap_dup(after_cap); @@ -137,7 +147,7 @@ int capability_bounding_set_drop(uint64_t drop, bool right_now) { r = -errno; goto finish; } - v = i; + v = (cap_value_t) i; /* Also drop it from the inheritable set, so * that anything we exec() loses the @@ -162,13 +172,8 @@ int capability_bounding_set_drop(uint64_t drop, bool right_now) { r = 0; finish: - if (temp_cap) - cap_free(temp_cap); - - if (after_cap) { - cap_set_proc(after_cap); - cap_free(after_cap); - } + if (cap_set_proc(after_cap) < 0) + return -errno; return r; } @@ -223,3 +228,81 @@ int capability_bounding_set_drop_usermode(uint64_t drop) { return r; } + +int drop_privileges(uid_t uid, gid_t gid, uint64_t keep_capabilities) { + _cleanup_cap_free_ cap_t d = NULL; + unsigned i, j = 0; + int r; + + /* Unfortunately we cannot leave privilege dropping to PID 1 + * here, since we want to run as user but want to keep some + * capabilities. Since file capabilities have been introduced + * this cannot be done across exec() anymore, unless our + * binary has the capability configured in the file system, + * which we want to avoid. */ + + if (setresgid(gid, gid, gid) < 0) + return log_error_errno(errno, "Failed to change group ID: %m"); + + if (setgroups(0, NULL) < 0) + return log_error_errno(errno, "Failed to drop auxiliary groups list: %m"); + + /* Ensure we keep the permitted caps across the setresuid() */ + if (prctl(PR_SET_KEEPCAPS, 1) < 0) + return log_error_errno(errno, "Failed to enable keep capabilities flag: %m"); + + r = setresuid(uid, uid, uid); + if (r < 0) + return log_error_errno(errno, "Failed to change user ID: %m"); + + if (prctl(PR_SET_KEEPCAPS, 0) < 0) + return log_error_errno(errno, "Failed to disable keep capabilities flag: %m"); + + /* Drop all caps from the bounding set, except the ones we want */ + r = capability_bounding_set_drop(~keep_capabilities, true); + if (r < 0) + return log_error_errno(r, "Failed to drop capabilities: %m"); + + /* Now upgrade the permitted caps we still kept to effective caps */ + d = cap_init(); + if (!d) + return log_oom(); + + if (keep_capabilities) { + cap_value_t bits[log2u64(keep_capabilities)]; + + for (i = 0; i < ELEMENTSOF(bits); i++) + if (keep_capabilities & (1ULL << i)) + bits[j++] = i; + assert((keep_capabilities & (~1ULL << i)) == 0); + + if (cap_set_flag(d, CAP_EFFECTIVE, j, bits, CAP_SET) < 0 || + cap_set_flag(d, CAP_PERMITTED, j, bits, CAP_SET) < 0) { + log_error_errno(errno, "Failed to enable capabilities bits: %m"); + return -errno; + } + + if (cap_set_proc(d) < 0) + return log_error_errno(errno, "Failed to increase capabilities: %m"); + } + + return 0; +} + +int drop_capability(cap_value_t cv) { + _cleanup_cap_free_ cap_t tmp_cap = NULL; + + tmp_cap = cap_get_proc(); + if (!tmp_cap) + return -errno; + + if ((cap_set_flag(tmp_cap, CAP_INHERITABLE, 1, &cv, CAP_CLEAR) < 0) || + (cap_set_flag(tmp_cap, CAP_PERMITTED, 1, &cv, CAP_CLEAR) < 0) || + (cap_set_flag(tmp_cap, CAP_EFFECTIVE, 1, &cv, CAP_CLEAR) < 0)) + return -errno; + + if (cap_set_proc(tmp_cap) < 0) + return -errno; + + return 0; +}