1 /* 2 * linux/kernel/capability.c 3 * 4 * Copyright (C) 1997 Andrew Main <zefram@fysh.org> 5 * 6 * Integrated into 2.1.97+, Andrew G. Morgan <morgan@kernel.org> 7 * 30 May 2002: Cleanup, Robert M. Love <rml@tech9.net> 8 */ 9 10 #include <linux/capability.h> 11 #include <linux/mm.h> 12 #include <linux/module.h> 13 #include <linux/security.h> 14 #include <linux/syscalls.h> 15 #include <asm/uaccess.h> 16 17 /* 18 * This lock protects task->cap_* for all tasks including current. 19 * Locking rule: acquire this prior to tasklist_lock. 20 */ 21 static DEFINE_SPINLOCK(task_capability_lock); 22 23 /* 24 * For sys_getproccap() and sys_setproccap(), any of the three 25 * capability set pointers may be NULL -- indicating that that set is 26 * uninteresting and/or not to be changed. 27 */ 28 29 /** 30 * sys_capget - get the capabilities of a given process. 31 * @header: pointer to struct that contains capability version and 32 * target pid data 33 * @dataptr: pointer to struct that contains the effective, permitted, 34 * and inheritable capabilities that are returned 35 * 36 * Returns 0 on success and < 0 on error. 37 */ 38 asmlinkage long sys_capget(cap_user_header_t header, cap_user_data_t dataptr) 39 { 40 int ret = 0; 41 pid_t pid; 42 __u32 version; 43 struct task_struct *target; 44 struct __user_cap_data_struct data; 45 46 if (get_user(version, &header->version)) 47 return -EFAULT; 48 49 if (version != _LINUX_CAPABILITY_VERSION) { 50 if (put_user(_LINUX_CAPABILITY_VERSION, &header->version)) 51 return -EFAULT; 52 return -EINVAL; 53 } 54 55 if (get_user(pid, &header->pid)) 56 return -EFAULT; 57 58 if (pid < 0) 59 return -EINVAL; 60 61 spin_lock(&task_capability_lock); 62 read_lock(&tasklist_lock); 63 64 if (pid && pid != current->pid) { 65 target = find_task_by_pid(pid); 66 if (!target) { 67 ret = -ESRCH; 68 goto out; 69 } 70 } else 71 target = current; 72 73 ret = security_capget(target, &data.effective, &data.inheritable, &data.permitted); 74 75 out: 76 read_unlock(&tasklist_lock); 77 spin_unlock(&task_capability_lock); 78 79 if (!ret && copy_to_user(dataptr, &data, sizeof data)) 80 return -EFAULT; 81 82 return ret; 83 } 84 85 /* 86 * cap_set_pg - set capabilities for all processes in a given process 87 * group. We call this holding task_capability_lock and tasklist_lock. 88 */ 89 static inline int cap_set_pg(int pgrp_nr, kernel_cap_t *effective, 90 kernel_cap_t *inheritable, 91 kernel_cap_t *permitted) 92 { 93 struct task_struct *g, *target; 94 int ret = -EPERM; 95 int found = 0; 96 struct pid *pgrp; 97 98 pgrp = find_pid(pgrp_nr); 99 do_each_pid_task(pgrp, PIDTYPE_PGID, g) { 100 target = g; 101 while_each_thread(g, target) { 102 if (!security_capset_check(target, effective, 103 inheritable, 104 permitted)) { 105 security_capset_set(target, effective, 106 inheritable, 107 permitted); 108 ret = 0; 109 } 110 found = 1; 111 } 112 } while_each_pid_task(pgrp, PIDTYPE_PGID, g); 113 114 if (!found) 115 ret = 0; 116 return ret; 117 } 118 119 /* 120 * cap_set_all - set capabilities for all processes other than init 121 * and self. We call this holding task_capability_lock and tasklist_lock. 122 */ 123 static inline int cap_set_all(kernel_cap_t *effective, 124 kernel_cap_t *inheritable, 125 kernel_cap_t *permitted) 126 { 127 struct task_struct *g, *target; 128 int ret = -EPERM; 129 int found = 0; 130 131 do_each_thread(g, target) { 132 if (target == current || is_init(target)) 133 continue; 134 found = 1; 135 if (security_capset_check(target, effective, inheritable, 136 permitted)) 137 continue; 138 ret = 0; 139 security_capset_set(target, effective, inheritable, permitted); 140 } while_each_thread(g, target); 141 142 if (!found) 143 ret = 0; 144 return ret; 145 } 146 147 /** 148 * sys_capset - set capabilities for a process or a group of processes 149 * @header: pointer to struct that contains capability version and 150 * target pid data 151 * @data: pointer to struct that contains the effective, permitted, 152 * and inheritable capabilities 153 * 154 * Set capabilities for a given process, all processes, or all 155 * processes in a given process group. 156 * 157 * The restrictions on setting capabilities are specified as: 158 * 159 * [pid is for the 'target' task. 'current' is the calling task.] 160 * 161 * I: any raised capabilities must be a subset of the (old current) permitted 162 * P: any raised capabilities must be a subset of the (old current) permitted 163 * E: must be set to a subset of (new target) permitted 164 * 165 * Returns 0 on success and < 0 on error. 166 */ 167 asmlinkage long sys_capset(cap_user_header_t header, const cap_user_data_t data) 168 { 169 kernel_cap_t inheritable, permitted, effective; 170 __u32 version; 171 struct task_struct *target; 172 int ret; 173 pid_t pid; 174 175 if (get_user(version, &header->version)) 176 return -EFAULT; 177 178 if (version != _LINUX_CAPABILITY_VERSION) { 179 if (put_user(_LINUX_CAPABILITY_VERSION, &header->version)) 180 return -EFAULT; 181 return -EINVAL; 182 } 183 184 if (get_user(pid, &header->pid)) 185 return -EFAULT; 186 187 if (pid && pid != current->pid && !capable(CAP_SETPCAP)) 188 return -EPERM; 189 190 if (copy_from_user(&effective, &data->effective, sizeof(effective)) || 191 copy_from_user(&inheritable, &data->inheritable, sizeof(inheritable)) || 192 copy_from_user(&permitted, &data->permitted, sizeof(permitted))) 193 return -EFAULT; 194 195 spin_lock(&task_capability_lock); 196 read_lock(&tasklist_lock); 197 198 if (pid > 0 && pid != current->pid) { 199 target = find_task_by_pid(pid); 200 if (!target) { 201 ret = -ESRCH; 202 goto out; 203 } 204 } else 205 target = current; 206 207 ret = 0; 208 209 /* having verified that the proposed changes are legal, 210 we now put them into effect. */ 211 if (pid < 0) { 212 if (pid == -1) /* all procs other than current and init */ 213 ret = cap_set_all(&effective, &inheritable, &permitted); 214 215 else /* all procs in process group */ 216 ret = cap_set_pg(-pid, &effective, &inheritable, 217 &permitted); 218 } else { 219 ret = security_capset_check(target, &effective, &inheritable, 220 &permitted); 221 if (!ret) 222 security_capset_set(target, &effective, &inheritable, 223 &permitted); 224 } 225 226 out: 227 read_unlock(&tasklist_lock); 228 spin_unlock(&task_capability_lock); 229 230 return ret; 231 } 232 233 int __capable(struct task_struct *t, int cap) 234 { 235 if (security_capable(t, cap) == 0) { 236 t->flags |= PF_SUPERPRIV; 237 return 1; 238 } 239 return 0; 240 } 241 242 int capable(int cap) 243 { 244 return __capable(current, cap); 245 } 246 EXPORT_SYMBOL(capable); 247