kernel/groups.c

   1 /*
   2  * Supplementary group IDs
   3  */
   4 #include <linux/cred.h>
   5 #include <linux/export.h>
   6 #include <linux/slab.h>
   7 #include <linux/security.h>
   8 #include <linux/syscalls.h>
   9 #include <linux/user_namespace.h>
  10 #include <asm/uaccess.h>
  11
  12 /* init to 2 - one for init_task, one to ensure it is never freed */
  13 struct group_info init_groups = { .usage = ATOMIC_INIT(2) };
  14
  15 struct group_info *groups_alloc(int gidsetsize)
  16 {
  17         struct group_info *group_info;
  18         int nblocks;
  19         int i;
  20
  21         nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;
  22         /* Make sure we always allocate at least one indirect block pointer */
  23         nblocks = nblocks ? : 1;
  24         group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);
  25         if (!group_info)
  26                 return NULL;
  27         group_info->ngroups = gidsetsize;
  28         group_info->nblocks = nblocks;
  29         atomic_set(&group_info->usage, 1);
  30
  31         if (gidsetsize <= NGROUPS_SMALL)
  32                 group_info->blocks[0] = group_info->small_block;
  33         else {
  34                 for (i = 0; i < nblocks; i++) {
  35                         kgid_t *b;
  36                         b = (void *)__get_free_page(GFP_USER);
  37                         if (!b)
  38                                 goto out_undo_partial_alloc;
  39                         group_info->blocks[i] = b;
  40                 }
  41         }
  42         return group_info;
  43
  44 out_undo_partial_alloc:
  45         while (--i >= 0) {
  46                 free_page((unsigned long)group_info->blocks[i]);
  47         }
  48         kfree(group_info);
  49         return NULL;
  50 }
  51
  52 EXPORT_SYMBOL(groups_alloc);
  53
  54 void groups_free(struct group_info *group_info)
  55 {
  56         if (group_info->blocks[0] != group_info->small_block) {
  57                 int i;
  58                 for (i = 0; i < group_info->nblocks; i++)
  59                         free_page((unsigned long)group_info->blocks[i]);
  60         }
  61         kfree(group_info);
  62 }
  63
  64 EXPORT_SYMBOL(groups_free);
  65
  66 /* export the group_info to a user-space array */
  67 static int groups_to_user(gid_t __user *grouplist,
  68                           const struct group_info *group_info)
  69 {
  70         struct user_namespace *user_ns = current_user_ns();
  71         int i;
  72         unsigned int count = group_info->ngroups;
  73
  74         for (i = 0; i < count; i++) {
  75                 gid_t gid;
  76                 gid = from_kgid_munged(user_ns, GROUP_AT(group_info, i));
  77                 if (put_user(gid, grouplist+i))
  78                         return -EFAULT;
  79         }
  80         return 0;
  81 }
  82
  83 /* fill a group_info from a user-space array - it must be allocated already */
  84 static int groups_from_user(struct group_info *group_info,
  85     gid_t __user *grouplist)
  86 {
  87         struct user_namespace *user_ns = current_user_ns();
  88         int i;
  89         unsigned int count = group_info->ngroups;
  90
  91         for (i = 0; i < count; i++) {
  92                 gid_t gid;
  93                 kgid_t kgid;
  94                 if (get_user(gid, grouplist+i))
  95                         return -EFAULT;
  96
  97                 kgid = make_kgid(user_ns, gid);
  98                 if (!gid_valid(kgid))
  99                         return -EINVAL;
 100
 101                 GROUP_AT(group_info, i) = kgid;
 102         }
 103         return 0;
 104 }
 105
 106 /* a simple Shell sort */
 107 static void groups_sort(struct group_info *group_info)
 108 {
 109         int base, max, stride;
 110         int gidsetsize = group_info->ngroups;
 111
 112         for (stride = 1; stride < gidsetsize; stride = 3 * stride + 1)
 113                 ; /* nothing */
 114         stride /= 3;
 115
 116         while (stride) {
 117                 max = gidsetsize - stride;
 118                 for (base = 0; base < max; base++) {
 119                         int left = base;
 120                         int right = left + stride;
 121                         kgid_t tmp = GROUP_AT(group_info, right);
 122
 123                         while (left >= 0 && gid_gt(GROUP_AT(group_info, left), tmp)) {
 124                                 GROUP_AT(group_info, right) =
 125                                     GROUP_AT(group_info, left);
 126                                 right = left;
 127                                 left -= stride;
 128                         }
 129                         GROUP_AT(group_info, right) = tmp;
 130                 }
 131                 stride /= 3;
 132         }
 133 }
 134
 135 /* a simple bsearch */
 136 int groups_search(const struct group_info *group_info, kgid_t grp)
 137 {
 138         unsigned int left, right;
 139
 140         if (!group_info)
 141                 return 0;
 142
 143         left = 0;
 144         right = group_info->ngroups;
 145         while (left < right) {
 146                 unsigned int mid = (left+right)/2;
 147                 if (gid_gt(grp, GROUP_AT(group_info, mid)))
 148                         left = mid + 1;
 149                 else if (gid_lt(grp, GROUP_AT(group_info, mid)))
 150                         right = mid;
 151                 else
 152                         return 1;
 153         }
 154         return 0;
 155 }
 156
 157 /**
 158  * set_groups - Change a group subscription in a set of credentials
 159  * @new: The newly prepared set of credentials to alter
 160  * @group_info: The group list to install
 161  *
 162  * Validate a group subscription and, if valid, insert it into a set
 163  * of credentials.
 164  */
 165 int set_groups(struct cred *new, struct group_info *group_info)
 166 {
 167         put_group_info(new->group_info);
 168         groups_sort(group_info);
 169         get_group_info(group_info);
 170         new->group_info = group_info;
 171         return 0;
 172 }
 173
 174 EXPORT_SYMBOL(set_groups);
 175
 176 /**
 177  * set_current_groups - Change current's group subscription
 178  * @group_info: The group list to impose
 179  *
 180  * Validate a group subscription and, if valid, impose it upon current's task
 181  * security record.
 182  */
 183 int set_current_groups(struct group_info *group_info)
 184 {
 185         struct cred *new;
 186         int ret;
 187
 188         new = prepare_creds();
 189         if (!new)
 190                 return -ENOMEM;
 191
 192         ret = set_groups(new, group_info);
 193         if (ret < 0) {
 194                 abort_creds(new);
 195                 return ret;
 196         }
 197
 198         return commit_creds(new);
 199 }
 200
 201 EXPORT_SYMBOL(set_current_groups);
 202
 203 SYSCALL_DEFINE2(getgroups, int, gidsetsize, gid_t __user *, grouplist)
 204 {
 205         const struct cred *cred = current_cred();
 206         int i;
 207
 208         if (gidsetsize < 0)
 209                 return -EINVAL;
 210
 211         /* no need to grab task_lock here; it cannot change */
 212         i = cred->group_info->ngroups;
 213         if (gidsetsize) {
 214                 if (i > gidsetsize) {
 215                         i = -EINVAL;
 216                         goto out;
 217                 }
 218                 if (groups_to_user(grouplist, cred->group_info)) {
 219                         i = -EFAULT;
 220                         goto out;
 221                 }
 222         }
 223 out:
 224         return i;
 225 }
 226
 227 bool may_setgroups(void)
 228 {
 229         struct user_namespace *user_ns = current_user_ns();
 230
 231         return ns_capable(user_ns, CAP_SETGID) &&
 232                 userns_may_setgroups(user_ns);
 233 }
 234
 235 /*
 236  *      SMP: Our groups are copy-on-write. We can set them safely
 237  *      without another task interfering.
 238  */
 239
 240 SYSCALL_DEFINE2(setgroups, int, gidsetsize, gid_t __user *, grouplist)
 241 {
 242         struct group_info *group_info;
 243         int retval;
 244
 245         if (!may_setgroups())
 246                 return -EPERM;
 247         if ((unsigned)gidsetsize > NGROUPS_MAX)
 248                 return -EINVAL;
 249
 250         group_info = groups_alloc(gidsetsize);
 251         if (!group_info)
 252                 return -ENOMEM;
 253         retval = groups_from_user(group_info, grouplist);
 254         if (retval) {
 255                 put_group_info(group_info);
 256                 return retval;
 257         }
 258
 259         retval = set_current_groups(group_info);
 260         put_group_info(group_info);
 261
 262         return retval;
 263 }
 264
 265 /*
 266  * Check whether we're fsgid/egid or in the supplemental group..
 267  */
 268 int in_group_p(kgid_t grp)
 269 {
 270         const struct cred *cred = current_cred();
 271         int retval = 1;
 272
 273         if (!gid_eq(grp, cred->fsgid))
 274                 retval = groups_search(cred->group_info, grp);
 275         return retval;
 276 }
 277
 278 EXPORT_SYMBOL(in_group_p);
 279
 280 int in_egroup_p(kgid_t grp)
 281 {
 282         const struct cred *cred = current_cred();
 283         int retval = 1;
 284
 285         if (!gid_eq(grp, cred->egid))
 286                 retval = groups_search(cred->group_info, grp);
 287         return retval;
 288 }
 289
 290 EXPORT_SYMBOL(in_egroup_p);