src/basic/capability-util.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <grp.h>
  24 #include <stdio.h>
  25 #include <sys/capability.h>
  26 #include <sys/prctl.h>
  27 #include <unistd.h>
  28
  29 #include "alloc-util.h"
  30 #include "capability-util.h"
  31 #include "fileio.h"
  32 #include "log.h"
  33 #include "macro.h"
  34 #include "parse-util.h"
  35 #include "util.h"
  36
  37 /// UNNEEDED by elogind
  38 #if 0
  39 int have_effective_cap(int value) {
  40         _cleanup_cap_free_ cap_t cap;
  41         cap_flag_value_t fv;
  42
  43         cap = cap_get_proc();
  44         if (!cap)
  45                 return -errno;
  46
  47         if (cap_get_flag(cap, value, CAP_EFFECTIVE, &fv) < 0)
  48                 return -errno;
  49         else
  50                 return fv == CAP_SET;
  51 }
  52 #endif // 0
  53
  54 unsigned long cap_last_cap(void) {
  55         static thread_local unsigned long saved;
  56         static thread_local bool valid = false;
  57         _cleanup_free_ char *content = NULL;
  58         unsigned long p = 0;
  59         int r;
  60
  61         if (valid)
  62                 return saved;
  63
  64         /* available since linux-3.2 */
  65         r = read_one_line_file("/proc/sys/kernel/cap_last_cap", &content);
  66         if (r >= 0) {
  67                 r = safe_atolu(content, &p);
  68                 if (r >= 0) {
  69                         saved = p;
  70                         valid = true;
  71                         return p;
  72                 }
  73         }
  74
  75         /* fall back to syscall-probing for pre linux-3.2 */
  76         p = (unsigned long) CAP_LAST_CAP;
  77
  78         if (prctl(PR_CAPBSET_READ, p) < 0) {
  79
  80                 /* Hmm, look downwards, until we find one that
  81                  * works */
  82                 for (p--; p > 0; p --)
  83                         if (prctl(PR_CAPBSET_READ, p) >= 0)
  84                                 break;
  85
  86         } else {
  87
  88                 /* Hmm, look upwards, until we find one that doesn't
  89                  * work */
  90                 for (;; p++)
  91                         if (prctl(PR_CAPBSET_READ, p+1) < 0)
  92                                 break;
  93         }
  94
  95         saved = p;
  96         valid = true;
  97
  98         return p;
  99 }
 100
 101 /// UNNEEDED by elogind
 102 #if 0
 103 int capability_bounding_set_drop(uint64_t drop, bool right_now) {
 104         _cleanup_cap_free_ cap_t after_cap = NULL;
 105         cap_flag_value_t fv;
 106         unsigned long i;
 107         int r;
 108
 109         /* If we are run as PID 1 we will lack CAP_SETPCAP by default
 110          * in the effective set (yes, the kernel drops that when
 111          * executing init!), so get it back temporarily so that we can
 112          * call PR_CAPBSET_DROP. */
 113
 114         after_cap = cap_get_proc();
 115         if (!after_cap)
 116                 return -errno;
 117
 118         if (cap_get_flag(after_cap, CAP_SETPCAP, CAP_EFFECTIVE, &fv) < 0)
 119                 return -errno;
 120
 121         if (fv != CAP_SET) {
 122                 _cleanup_cap_free_ cap_t temp_cap = NULL;
 123                 static const cap_value_t v = CAP_SETPCAP;
 124
 125                 temp_cap = cap_dup(after_cap);
 126                 if (!temp_cap) {
 127                         r = -errno;
 128                         goto finish;
 129                 }
 130
 131                 if (cap_set_flag(temp_cap, CAP_EFFECTIVE, 1, &v, CAP_SET) < 0) {
 132                         r = -errno;
 133                         goto finish;
 134                 }
 135
 136                 if (cap_set_proc(temp_cap) < 0) {
 137                         r = -errno;
 138                         goto finish;
 139                 }
 140         }
 141
 142         for (i = 0; i <= cap_last_cap(); i++) {
 143
 144                 if (drop & ((uint64_t) 1ULL << (uint64_t) i)) {
 145                         cap_value_t v;
 146
 147                         /* Drop it from the bounding set */
 148                         if (prctl(PR_CAPBSET_DROP, i) < 0) {
 149                                 r = -errno;
 150                                 goto finish;
 151                         }
 152                         v = (cap_value_t) i;
 153
 154                         /* Also drop it from the inheritable set, so
 155                          * that anything we exec() loses the
 156                          * capability for good. */
 157                         if (cap_set_flag(after_cap, CAP_INHERITABLE, 1, &v, CAP_CLEAR) < 0) {
 158                                 r = -errno;
 159                                 goto finish;
 160                         }
 161
 162                         /* If we shall apply this right now drop it
 163                          * also from our own capability sets. */
 164                         if (right_now) {
 165                                 if (cap_set_flag(after_cap, CAP_PERMITTED, 1, &v, CAP_CLEAR) < 0 ||
 166                                     cap_set_flag(after_cap, CAP_EFFECTIVE, 1, &v, CAP_CLEAR) < 0) {
 167                                         r = -errno;
 168                                         goto finish;
 169                                 }
 170                         }
 171                 }
 172         }
 173
 174         r = 0;
 175
 176 finish:
 177         if (cap_set_proc(after_cap) < 0)
 178                 return -errno;
 179
 180         return r;
 181 }
 182
 183 static int drop_from_file(const char *fn, uint64_t drop) {
 184         int r, k;
 185         uint32_t hi, lo;
 186         uint64_t current, after;
 187         char *p;
 188
 189         r = read_one_line_file(fn, &p);
 190         if (r < 0)
 191                 return r;
 192
 193         assert_cc(sizeof(hi) == sizeof(unsigned));
 194         assert_cc(sizeof(lo) == sizeof(unsigned));
 195
 196         k = sscanf(p, "%u %u", &lo, &hi);
 197         free(p);
 198
 199         if (k != 2)
 200                 return -EIO;
 201
 202         current = (uint64_t) lo | ((uint64_t) hi << 32ULL);
 203         after = current & ~drop;
 204
 205         if (current == after)
 206                 return 0;
 207
 208         lo = (unsigned) (after & 0xFFFFFFFFULL);
 209         hi = (unsigned) ((after >> 32ULL) & 0xFFFFFFFFULL);
 210
 211         if (asprintf(&p, "%u %u", lo, hi) < 0)
 212                 return -ENOMEM;
 213
 214         r = write_string_file(fn, p, WRITE_STRING_FILE_CREATE);
 215         free(p);
 216
 217         return r;
 218 }
 219
 220 int capability_bounding_set_drop_usermode(uint64_t drop) {
 221         int r;
 222
 223         r = drop_from_file("/proc/sys/kernel/usermodehelper/inheritable", drop);
 224         if (r < 0)
 225                 return r;
 226
 227         r = drop_from_file("/proc/sys/kernel/usermodehelper/bset", drop);
 228         if (r < 0)
 229                 return r;
 230
 231         return r;
 232 }
 233
 234 int drop_privileges(uid_t uid, gid_t gid, uint64_t keep_capabilities) {
 235         _cleanup_cap_free_ cap_t d = NULL;
 236         unsigned i, j = 0;
 237         int r;
 238
 239         /* Unfortunately we cannot leave privilege dropping to PID 1
 240          * here, since we want to run as user but want to keep some
 241          * capabilities. Since file capabilities have been introduced
 242          * this cannot be done across exec() anymore, unless our
 243          * binary has the capability configured in the file system,
 244          * which we want to avoid. */
 245
 246         if (setresgid(gid, gid, gid) < 0)
 247                 return log_error_errno(errno, "Failed to change group ID: %m");
 248
 249         if (setgroups(0, NULL) < 0)
 250                 return log_error_errno(errno, "Failed to drop auxiliary groups list: %m");
 251
 252         /* Ensure we keep the permitted caps across the setresuid() */
 253         if (prctl(PR_SET_KEEPCAPS, 1) < 0)
 254                 return log_error_errno(errno, "Failed to enable keep capabilities flag: %m");
 255
 256         r = setresuid(uid, uid, uid);
 257         if (r < 0)
 258                 return log_error_errno(errno, "Failed to change user ID: %m");
 259
 260         if (prctl(PR_SET_KEEPCAPS, 0) < 0)
 261                 return log_error_errno(errno, "Failed to disable keep capabilities flag: %m");
 262
 263         /* Drop all caps from the bounding set, except the ones we want */
 264         r = capability_bounding_set_drop(~keep_capabilities, true);
 265         if (r < 0)
 266                 return log_error_errno(r, "Failed to drop capabilities: %m");
 267
 268         /* Now upgrade the permitted caps we still kept to effective caps */
 269         d = cap_init();
 270         if (!d)
 271                 return log_oom();
 272
 273         if (keep_capabilities) {
 274                 cap_value_t bits[u64log2(keep_capabilities) + 1];
 275
 276                 for (i = 0; i < ELEMENTSOF(bits); i++)
 277                         if (keep_capabilities & (1ULL << i))
 278                                 bits[j++] = i;
 279
 280                 /* use enough bits */
 281                 assert(i == 64 || (keep_capabilities >> i) == 0);
 282                 /* don't use too many bits */
 283                 assert(keep_capabilities & (1ULL << (i - 1)));
 284
 285                 if (cap_set_flag(d, CAP_EFFECTIVE, j, bits, CAP_SET) < 0 ||
 286                     cap_set_flag(d, CAP_PERMITTED, j, bits, CAP_SET) < 0)
 287                         return log_error_errno(errno, "Failed to enable capabilities bits: %m");
 288
 289                 if (cap_set_proc(d) < 0)
 290                         return log_error_errno(errno, "Failed to increase capabilities: %m");
 291         }
 292
 293         return 0;
 294 }
 295
 296 int drop_capability(cap_value_t cv) {
 297         _cleanup_cap_free_ cap_t tmp_cap = NULL;
 298
 299         tmp_cap = cap_get_proc();
 300         if (!tmp_cap)
 301                 return -errno;
 302
 303         if ((cap_set_flag(tmp_cap, CAP_INHERITABLE, 1, &cv, CAP_CLEAR) < 0) ||
 304             (cap_set_flag(tmp_cap, CAP_PERMITTED, 1, &cv, CAP_CLEAR) < 0) ||
 305             (cap_set_flag(tmp_cap, CAP_EFFECTIVE, 1, &cv, CAP_CLEAR) < 0))
 306                 return -errno;
 307
 308         if (cap_set_proc(tmp_cap) < 0)
 309                 return -errno;
 310
 311         return 0;
 312 }
 313 #endif // 0