1/* Common capabilities, needed by capability.o.
  2 *
  3 *	This program is free software; you can redistribute it and/or modify
  4 *	it under the terms of the GNU General Public License as published by
  5 *	the Free Software Foundation; either version 2 of the License, or
  6 *	(at your option) any later version.
  7 *
  8 */
  9
 10#include <linux/capability.h>
 11#include <linux/audit.h>
 12#include <linux/module.h>
 13#include <linux/init.h>
 14#include <linux/kernel.h>
 15#include <linux/security.h>
 16#include <linux/file.h>
 17#include <linux/mm.h>
 18#include <linux/mman.h>
 19#include <linux/pagemap.h>
 20#include <linux/swap.h>
 21#include <linux/skbuff.h>
 22#include <linux/netlink.h>
 23#include <linux/ptrace.h>
 24#include <linux/xattr.h>
 25#include <linux/hugetlb.h>
 26#include <linux/mount.h>
 27#include <linux/sched.h>
 28#include <linux/prctl.h>
 29#include <linux/securebits.h>
 30#include <linux/user_namespace.h>
 
 
 
 
 31
 32/*
 33 * If a non-root user executes a setuid-root binary in
 34 * !secure(SECURE_NOROOT) mode, then we raise capabilities.
 35 * However if fE is also set, then the intent is for only
 36 * the file capabilities to be applied, and the setuid-root
 37 * bit is left on either to change the uid (plausible) or
 38 * to get full privilege on a kernel without file capabilities
 39 * support.  So in that case we do not raise capabilities.
 40 *
 41 * Warn if that happens, once per boot.
 42 */
 43static void warn_setuid_and_fcaps_mixed(const char *fname)
 44{
 45	static int warned;
 46	if (!warned) {
 47		printk(KERN_INFO "warning: `%s' has both setuid-root and"
 48			" effective capabilities. Therefore not raising all"
 49			" capabilities.\n", fname);
 50		warned = 1;
 51	}
 52}
 53
 54int cap_netlink_send(struct sock *sk, struct sk_buff *skb)
 55{
 56	return 0;
 57}
 58
 59int cap_netlink_recv(struct sk_buff *skb, int cap)
 60{
 61	if (!cap_raised(current_cap(), cap))
 62		return -EPERM;
 63	return 0;
 64}
 65EXPORT_SYMBOL(cap_netlink_recv);
 66
 67/**
 68 * cap_capable - Determine whether a task has a particular effective capability
 69 * @tsk: The task to query
 70 * @cred: The credentials to use
 71 * @ns:  The user namespace in which we need the capability
 72 * @cap: The capability to check for
 73 * @audit: Whether to write an audit message or not
 74 *
 75 * Determine whether the nominated task has the specified capability amongst
 76 * its effective set, returning 0 if it does, -ve if it does not.
 77 *
 78 * NOTE WELL: cap_has_capability() cannot be used like the kernel's capable()
 79 * and has_capability() functions.  That is, it has the reverse semantics:
 80 * cap_has_capability() returns 0 when a task has a capability, but the
 81 * kernel's capable() and has_capability() returns 1 for this case.
 82 */
 83int cap_capable(struct task_struct *tsk, const struct cred *cred,
 84		struct user_namespace *targ_ns, int cap, int audit)
 85{
 86	for (;;) {
 87		/* The creator of the user namespace has all caps. */
 88		if (targ_ns != &init_user_ns && targ_ns->creator == cred->user)
 89			return 0;
 90
 
 
 
 
 
 91		/* Do we have the necessary capabilities? */
 92		if (targ_ns == cred->user->user_ns)
 93			return cap_raised(cred->cap_effective, cap) ? 0 : -EPERM;
 94
 95		/* Have we tried all of the parent namespaces? */
 96		if (targ_ns == &init_user_ns)
 
 
 
 97			return -EPERM;
 98
 
 
 
 
 
 
 
 99		/*
100		 *If you have a capability in a parent user ns, then you have
101		 * it over all children user namespaces as well.
102		 */
103		targ_ns = targ_ns->creator->user_ns;
104	}
105
106	/* We never get here */
107}
108
109/**
110 * cap_settime - Determine whether the current process may set the system clock
111 * @ts: The time to set
112 * @tz: The timezone to set
113 *
114 * Determine whether the current process may set the system clock and timezone
115 * information, returning 0 if permission granted, -ve if denied.
116 */
117int cap_settime(const struct timespec *ts, const struct timezone *tz)
118{
119	if (!capable(CAP_SYS_TIME))
120		return -EPERM;
121	return 0;
122}
123
124/**
125 * cap_ptrace_access_check - Determine whether the current process may access
126 *			   another
127 * @child: The process to be accessed
128 * @mode: The mode of attachment.
129 *
130 * If we are in the same or an ancestor user_ns and have all the target
131 * task's capabilities, then ptrace access is allowed.
132 * If we have the ptrace capability to the target user_ns, then ptrace
133 * access is allowed.
134 * Else denied.
135 *
136 * Determine whether a process may access another, returning 0 if permission
137 * granted, -ve if denied.
138 */
139int cap_ptrace_access_check(struct task_struct *child, unsigned int mode)
140{
141	int ret = 0;
142	const struct cred *cred, *child_cred;
 
143
144	rcu_read_lock();
145	cred = current_cred();
146	child_cred = __task_cred(child);
147	if (cred->user->user_ns == child_cred->user->user_ns &&
148	    cap_issubset(child_cred->cap_permitted, cred->cap_permitted))
 
 
 
 
149		goto out;
150	if (ns_capable(child_cred->user->user_ns, CAP_SYS_PTRACE))
151		goto out;
152	ret = -EPERM;
153out:
154	rcu_read_unlock();
155	return ret;
156}
157
158/**
159 * cap_ptrace_traceme - Determine whether another process may trace the current
160 * @parent: The task proposed to be the tracer
161 *
162 * If parent is in the same or an ancestor user_ns and has all current's
163 * capabilities, then ptrace access is allowed.
164 * If parent has the ptrace capability to current's user_ns, then ptrace
165 * access is allowed.
166 * Else denied.
167 *
168 * Determine whether the nominated task is permitted to trace the current
169 * process, returning 0 if permission is granted, -ve if denied.
170 */
171int cap_ptrace_traceme(struct task_struct *parent)
172{
173	int ret = 0;
174	const struct cred *cred, *child_cred;
175
176	rcu_read_lock();
177	cred = __task_cred(parent);
178	child_cred = current_cred();
179	if (cred->user->user_ns == child_cred->user->user_ns &&
180	    cap_issubset(child_cred->cap_permitted, cred->cap_permitted))
181		goto out;
182	if (has_ns_capability(parent, child_cred->user->user_ns, CAP_SYS_PTRACE))
183		goto out;
184	ret = -EPERM;
185out:
186	rcu_read_unlock();
187	return ret;
188}
189
190/**
191 * cap_capget - Retrieve a task's capability sets
192 * @target: The task from which to retrieve the capability sets
193 * @effective: The place to record the effective set
194 * @inheritable: The place to record the inheritable set
195 * @permitted: The place to record the permitted set
196 *
197 * This function retrieves the capabilities of the nominated task and returns
198 * them to the caller.
199 */
200int cap_capget(struct task_struct *target, kernel_cap_t *effective,
201	       kernel_cap_t *inheritable, kernel_cap_t *permitted)
202{
203	const struct cred *cred;
204
205	/* Derived from kernel/capability.c:sys_capget. */
206	rcu_read_lock();
207	cred = __task_cred(target);
208	*effective   = cred->cap_effective;
209	*inheritable = cred->cap_inheritable;
210	*permitted   = cred->cap_permitted;
211	rcu_read_unlock();
212	return 0;
213}
214
215/*
216 * Determine whether the inheritable capabilities are limited to the old
217 * permitted set.  Returns 1 if they are limited, 0 if they are not.
218 */
219static inline int cap_inh_is_capped(void)
220{
221
222	/* they are so limited unless the current task has the CAP_SETPCAP
223	 * capability
224	 */
225	if (cap_capable(current, current_cred(),
226			current_cred()->user->user_ns, CAP_SETPCAP,
227			SECURITY_CAP_AUDIT) == 0)
228		return 0;
229	return 1;
230}
231
232/**
233 * cap_capset - Validate and apply proposed changes to current's capabilities
234 * @new: The proposed new credentials; alterations should be made here
235 * @old: The current task's current credentials
236 * @effective: A pointer to the proposed new effective capabilities set
237 * @inheritable: A pointer to the proposed new inheritable capabilities set
238 * @permitted: A pointer to the proposed new permitted capabilities set
239 *
240 * This function validates and applies a proposed mass change to the current
241 * process's capability sets.  The changes are made to the proposed new
242 * credentials, and assuming no error, will be committed by the caller of LSM.
243 */
244int cap_capset(struct cred *new,
245	       const struct cred *old,
246	       const kernel_cap_t *effective,
247	       const kernel_cap_t *inheritable,
248	       const kernel_cap_t *permitted)
249{
250	if (cap_inh_is_capped() &&
251	    !cap_issubset(*inheritable,
252			  cap_combine(old->cap_inheritable,
253				      old->cap_permitted)))
254		/* incapable of using this inheritable set */
255		return -EPERM;
256
257	if (!cap_issubset(*inheritable,
258			  cap_combine(old->cap_inheritable,
259				      old->cap_bset)))
260		/* no new pI capabilities outside bounding set */
261		return -EPERM;
262
263	/* verify restrictions on target's new Permitted set */
264	if (!cap_issubset(*permitted, old->cap_permitted))
265		return -EPERM;
266
267	/* verify the _new_Effective_ is a subset of the _new_Permitted_ */
268	if (!cap_issubset(*effective, *permitted))
269		return -EPERM;
270
271	new->cap_effective   = *effective;
272	new->cap_inheritable = *inheritable;
273	new->cap_permitted   = *permitted;
274	return 0;
275}
276
277/*
278 * Clear proposed capability sets for execve().
279 */
280static inline void bprm_clear_caps(struct linux_binprm *bprm)
281{
282	cap_clear(bprm->cred->cap_permitted);
283	bprm->cap_effective = false;
 
 
 
284}
285
286/**
287 * cap_inode_need_killpriv - Determine if inode change affects privileges
288 * @dentry: The inode/dentry in being changed with change marked ATTR_KILL_PRIV
289 *
290 * Determine if an inode having a change applied that's marked ATTR_KILL_PRIV
291 * affects the security markings on that inode, and if it is, should
292 * inode_killpriv() be invoked or the change rejected?
293 *
294 * Returns 0 if granted; +ve if granted, but inode_killpriv() is required; and
295 * -ve to deny the change.
296 */
297int cap_inode_need_killpriv(struct dentry *dentry)
298{
299	struct inode *inode = dentry->d_inode;
300	int error;
301
302	if (!inode->i_op->getxattr)
303	       return 0;
304
305	error = inode->i_op->getxattr(dentry, XATTR_NAME_CAPS, NULL, 0);
306	if (error <= 0)
307		return 0;
308	return 1;
309}
310
311/**
312 * cap_inode_killpriv - Erase the security markings on an inode
313 * @dentry: The inode/dentry to alter
 
 
314 *
315 * Erase the privilege-enhancing security markings on an inode.
316 *
317 * Returns 0 if successful, -ve on error.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
318 */
319int cap_inode_killpriv(struct dentry *dentry)
 
 
 
 
 
 
 
 
 
 
 
 
320{
321	struct inode *inode = dentry->d_inode;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
322
323	if (!inode->i_op->removexattr)
324	       return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
325
326	return inode->i_op->removexattr(dentry, XATTR_NAME_CAPS);
 
327}
328
329/*
330 * Calculate the new process capability sets from the capability sets attached
331 * to a file.
332 */
333static inline int bprm_caps_from_vfs_caps(struct cpu_vfs_cap_data *caps,
334					  struct linux_binprm *bprm,
335					  bool *effective)
 
336{
337	struct cred *new = bprm->cred;
338	unsigned i;
339	int ret = 0;
340
341	if (caps->magic_etc & VFS_CAP_FLAGS_EFFECTIVE)
342		*effective = true;
343
344	CAP_FOR_EACH_U32(i) {
345		__u32 permitted = caps->permitted.cap[i];
346		__u32 inheritable = caps->inheritable.cap[i];
347
348		/*
349		 * pP' = (X & fP) | (pI & fI)
350		 */
351		new->cap_permitted.cap[i] =
352			(new->cap_bset.cap[i] & permitted) |
353			(new->cap_inheritable.cap[i] & inheritable);
354
355		if (permitted & ~new->cap_permitted.cap[i])
356			/* insufficient to execute correctly */
357			ret = -EPERM;
358	}
359
360	/*
361	 * For legacy apps, with no internal support for recognizing they
362	 * do not have enough capabilities, we return an error if they are
363	 * missing some "forced" (aka file-permitted) capabilities.
364	 */
365	return *effective ? ret : 0;
366}
367
368/*
 
 
 
 
 
 
369 * Extract the on-exec-apply capability sets for an executable file.
370 */
371int get_vfs_caps_from_disk(const struct dentry *dentry, struct cpu_vfs_cap_data *cpu_caps)
 
 
 
 
 
 
 
 
372{
373	struct inode *inode = dentry->d_inode;
374	__u32 magic_etc;
375	unsigned tocopy, i;
376	int size;
377	struct vfs_cap_data caps;
 
 
 
 
378
379	memset(cpu_caps, 0, sizeof(struct cpu_vfs_cap_data));
380
381	if (!inode || !inode->i_op->getxattr)
382		return -ENODATA;
383
384	size = inode->i_op->getxattr((struct dentry *)dentry, XATTR_NAME_CAPS, &caps,
385				   XATTR_CAPS_SZ);
 
386	if (size == -ENODATA || size == -EOPNOTSUPP)
387		/* no data, that's ok */
388		return -ENODATA;
 
389	if (size < 0)
390		return size;
391
392	if (size < sizeof(magic_etc))
393		return -EINVAL;
394
395	cpu_caps->magic_etc = magic_etc = le32_to_cpu(caps.magic_etc);
396
 
397	switch (magic_etc & VFS_CAP_REVISION_MASK) {
398	case VFS_CAP_REVISION_1:
399		if (size != XATTR_CAPS_SZ_1)
400			return -EINVAL;
401		tocopy = VFS_CAP_U32_1;
402		break;
403	case VFS_CAP_REVISION_2:
404		if (size != XATTR_CAPS_SZ_2)
405			return -EINVAL;
406		tocopy = VFS_CAP_U32_2;
407		break;
 
 
 
 
 
 
408	default:
409		return -EINVAL;
410	}
411
412	CAP_FOR_EACH_U32(i) {
413		if (i >= tocopy)
414			break;
415		cpu_caps->permitted.cap[i] = le32_to_cpu(caps.data[i].permitted);
416		cpu_caps->inheritable.cap[i] = le32_to_cpu(caps.data[i].inheritable);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
417	}
418
 
 
 
 
 
419	return 0;
420}
421
422/*
423 * Attempt to get the on-exec apply capability sets for an executable file from
424 * its xattrs and, if present, apply them to the proposed credentials being
425 * constructed by execve().
426 */
427static int get_file_caps(struct linux_binprm *bprm, bool *effective)
 
428{
429	struct dentry *dentry;
430	int rc = 0;
431	struct cpu_vfs_cap_data vcaps;
432
433	bprm_clear_caps(bprm);
434
435	if (!file_caps_enabled)
436		return 0;
437
438	if (bprm->file->f_vfsmnt->mnt_flags & MNT_NOSUID)
439		return 0;
440
441	dentry = dget(bprm->file->f_dentry);
 
 
 
 
 
 
442
443	rc = get_vfs_caps_from_disk(dentry, &vcaps);
 
444	if (rc < 0) {
445		if (rc == -EINVAL)
446			printk(KERN_NOTICE "%s: get_vfs_caps_from_disk returned %d for %s\n",
447				__func__, rc, bprm->filename);
448		else if (rc == -ENODATA)
449			rc = 0;
450		goto out;
451	}
452
453	rc = bprm_caps_from_vfs_caps(&vcaps, bprm, effective);
454	if (rc == -EINVAL)
455		printk(KERN_NOTICE "%s: cap_from_disk returned %d for %s\n",
456		       __func__, rc, bprm->filename);
457
458out:
459	dput(dentry);
460	if (rc)
461		bprm_clear_caps(bprm);
462
463	return rc;
464}
465
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
466/**
467 * cap_bprm_set_creds - Set up the proposed credentials for execve().
468 * @bprm: The execution parameters, including the proposed creds
 
469 *
470 * Set up the proposed credentials for a new execution context being
471 * constructed by execve().  The proposed creds in @bprm->cred is altered,
472 * which won't take effect immediately.  Returns 0 if successful, -ve on error.
 
 
473 */
474int cap_bprm_set_creds(struct linux_binprm *bprm)
475{
 
476	const struct cred *old = current_cred();
477	struct cred *new = bprm->cred;
478	bool effective;
479	int ret;
 
 
 
 
480
481	effective = false;
482	ret = get_file_caps(bprm, &effective);
483	if (ret < 0)
484		return ret;
485
486	if (!issecure(SECURE_NOROOT)) {
487		/*
488		 * If the legacy file capability is set, then don't set privs
489		 * for a setuid root binary run by a non-root user.  Do set it
490		 * for a root user just to cause least surprise to an admin.
491		 */
492		if (effective && new->uid != 0 && new->euid == 0) {
493			warn_setuid_and_fcaps_mixed(bprm->filename);
494			goto skip;
495		}
496		/*
497		 * To support inheritance of root-permissions and suid-root
498		 * executables under compatibility mode, we override the
499		 * capability sets for the file.
500		 *
501		 * If only the real uid is 0, we do not set the effective bit.
502		 */
503		if (new->euid == 0 || new->uid == 0) {
504			/* pP' = (cap_bset & ~0) | (pI & ~0) */
505			new->cap_permitted = cap_combine(old->cap_bset,
506							 old->cap_inheritable);
507		}
508		if (new->euid == 0)
509			effective = true;
510	}
511skip:
512
513	/* Don't let someone trace a set[ug]id/setpcap binary with the revised
514	 * credentials unless they have the appropriate permit
 
 
515	 */
516	if ((new->euid != old->uid ||
517	     new->egid != old->gid ||
518	     !cap_issubset(new->cap_permitted, old->cap_permitted)) &&
519	    bprm->unsafe & ~LSM_UNSAFE_PTRACE_CAP) {
 
520		/* downgrade; they get no more than they had, and maybe less */
521		if (!capable(CAP_SETUID)) {
 
522			new->euid = new->uid;
523			new->egid = new->gid;
524		}
525		new->cap_permitted = cap_intersect(new->cap_permitted,
526						   old->cap_permitted);
527	}
528
529	new->suid = new->fsuid = new->euid;
530	new->sgid = new->fsgid = new->egid;
531
 
 
 
 
 
 
 
 
 
 
 
 
 
 
532	if (effective)
533		new->cap_effective = new->cap_permitted;
534	else
535		cap_clear(new->cap_effective);
536	bprm->cap_effective = effective;
537
538	/*
539	 * Audit candidate if current->cap_effective is set
540	 *
541	 * We do not bother to audit if 3 things are true:
542	 *   1) cap_effective has all caps
543	 *   2) we are root
544	 *   3) root is supposed to have all caps (SECURE_NOROOT)
545	 * Since this is just a normal root execing a process.
546	 *
547	 * Number 1 above might fail if you don't have a full bset, but I think
548	 * that is interesting information to audit.
549	 */
550	if (!cap_isclear(new->cap_effective)) {
551		if (!cap_issubset(CAP_FULL_SET, new->cap_effective) ||
552		    new->euid != 0 || new->uid != 0 ||
553		    issecure(SECURE_NOROOT)) {
554			ret = audit_log_bprm_fcaps(bprm, new, old);
555			if (ret < 0)
556				return ret;
557		}
558	}
559
560	new->securebits &= ~issecure_mask(SECURE_KEEP_CAPS);
561	return 0;
562}
563
564/**
565 * cap_bprm_secureexec - Determine whether a secure execution is required
566 * @bprm: The execution parameters
567 *
568 * Determine whether a secure execution is required, return 1 if it is, and 0
569 * if it is not.
570 *
571 * The credentials have been committed by this point, and so are no longer
572 * available through @bprm->cred.
573 */
574int cap_bprm_secureexec(struct linux_binprm *bprm)
575{
576	const struct cred *cred = current_cred();
577
578	if (cred->uid != 0) {
579		if (bprm->cap_effective)
580			return 1;
581		if (!cap_isclear(cred->cap_permitted))
582			return 1;
583	}
584
585	return (cred->euid != cred->uid ||
586		cred->egid != cred->gid);
587}
588
589/**
590 * cap_inode_setxattr - Determine whether an xattr may be altered
591 * @dentry: The inode/dentry being altered
592 * @name: The name of the xattr to be changed
593 * @value: The value that the xattr will be changed to
594 * @size: The size of value
595 * @flags: The replacement flag
596 *
597 * Determine whether an xattr may be altered or set on an inode, returning 0 if
598 * permission is granted, -ve if denied.
599 *
600 * This is used to make sure security xattrs don't get updated or set by those
601 * who aren't privileged to do so.
602 */
603int cap_inode_setxattr(struct dentry *dentry, const char *name,
604		       const void *value, size_t size, int flags)
605{
606	if (!strcmp(name, XATTR_NAME_CAPS)) {
607		if (!capable(CAP_SETFCAP))
608			return -EPERM;
 
 
609		return 0;
610	}
611
612	if (!strncmp(name, XATTR_SECURITY_PREFIX,
613		     sizeof(XATTR_SECURITY_PREFIX) - 1) &&
614	    !capable(CAP_SYS_ADMIN))
 
 
 
 
 
615		return -EPERM;
616	return 0;
617}
618
619/**
620 * cap_inode_removexattr - Determine whether an xattr may be removed
621 * @dentry: The inode/dentry being altered
622 * @name: The name of the xattr to be changed
 
 
623 *
624 * Determine whether an xattr may be removed from an inode, returning 0 if
625 * permission is granted, -ve if denied.
626 *
 
 
 
 
 
 
627 * This is used to make sure security xattrs don't get removed by those who
628 * aren't privileged to remove them.
629 */
630int cap_inode_removexattr(struct dentry *dentry, const char *name)
 
631{
632	if (!strcmp(name, XATTR_NAME_CAPS)) {
633		if (!capable(CAP_SETFCAP))
 
 
 
 
 
 
 
 
 
 
 
634			return -EPERM;
635		return 0;
636	}
637
638	if (!strncmp(name, XATTR_SECURITY_PREFIX,
639		     sizeof(XATTR_SECURITY_PREFIX) - 1) &&
640	    !capable(CAP_SYS_ADMIN))
641		return -EPERM;
642	return 0;
643}
644
645/*
646 * cap_emulate_setxuid() fixes the effective / permitted capabilities of
647 * a process after a call to setuid, setreuid, or setresuid.
648 *
649 *  1) When set*uiding _from_ one of {r,e,s}uid == 0 _to_ all of
650 *  {r,e,s}uid != 0, the permitted and effective capabilities are
651 *  cleared.
652 *
653 *  2) When set*uiding _from_ euid == 0 _to_ euid != 0, the effective
654 *  capabilities of the process are cleared.
655 *
656 *  3) When set*uiding _from_ euid != 0 _to_ euid == 0, the effective
657 *  capabilities are set to the permitted capabilities.
658 *
659 *  fsuid is handled elsewhere. fsuid == 0 and {r,e,s}uid!= 0 should
660 *  never happen.
661 *
662 *  -astor
663 *
664 * cevans - New behaviour, Oct '99
665 * A process may, via prctl(), elect to keep its capabilities when it
666 * calls setuid() and switches away from uid==0. Both permitted and
667 * effective sets will be retained.
668 * Without this change, it was impossible for a daemon to drop only some
669 * of its privilege. The call to setuid(!=0) would drop all privileges!
670 * Keeping uid 0 is not an option because uid 0 owns too many vital
671 * files..
672 * Thanks to Olaf Kirch and Peter Benie for spotting this.
673 */
674static inline void cap_emulate_setxuid(struct cred *new, const struct cred *old)
675{
676	if ((old->uid == 0 || old->euid == 0 || old->suid == 0) &&
677	    (new->uid != 0 && new->euid != 0 && new->suid != 0) &&
678	    !issecure(SECURE_KEEP_CAPS)) {
679		cap_clear(new->cap_permitted);
680		cap_clear(new->cap_effective);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
681	}
682	if (old->euid == 0 && new->euid != 0)
683		cap_clear(new->cap_effective);
684	if (old->euid != 0 && new->euid == 0)
685		new->cap_effective = new->cap_permitted;
686}
687
688/**
689 * cap_task_fix_setuid - Fix up the results of setuid() call
690 * @new: The proposed credentials
691 * @old: The current task's current credentials
692 * @flags: Indications of what has changed
693 *
694 * Fix up the results of setuid() call before the credential changes are
695 * actually applied, returning 0 to grant the changes, -ve to deny them.
 
 
696 */
697int cap_task_fix_setuid(struct cred *new, const struct cred *old, int flags)
698{
699	switch (flags) {
700	case LSM_SETID_RE:
701	case LSM_SETID_ID:
702	case LSM_SETID_RES:
703		/* juggle the capabilities to follow [RES]UID changes unless
704		 * otherwise suppressed */
705		if (!issecure(SECURE_NO_SETUID_FIXUP))
706			cap_emulate_setxuid(new, old);
707		break;
708
709	case LSM_SETID_FS:
710		/* juggle the capabilties to follow FSUID changes, unless
711		 * otherwise suppressed
712		 *
713		 * FIXME - is fsuser used for all CAP_FS_MASK capabilities?
714		 *          if not, we might be a bit too harsh here.
715		 */
716		if (!issecure(SECURE_NO_SETUID_FIXUP)) {
717			if (old->fsuid == 0 && new->fsuid != 0)
 
718				new->cap_effective =
719					cap_drop_fs_set(new->cap_effective);
720
721			if (old->fsuid != 0 && new->fsuid == 0)
722				new->cap_effective =
723					cap_raise_fs_set(new->cap_effective,
724							 new->cap_permitted);
725		}
726		break;
727
728	default:
729		return -EINVAL;
730	}
731
732	return 0;
733}
734
735/*
736 * Rationale: code calling task_setscheduler, task_setioprio, and
737 * task_setnice, assumes that
738 *   . if capable(cap_sys_nice), then those actions should be allowed
739 *   . if not capable(cap_sys_nice), but acting on your own processes,
740 *   	then those actions should be allowed
741 * This is insufficient now since you can call code without suid, but
742 * yet with increased caps.
743 * So we check for increased caps on the target process.
744 */
745static int cap_safe_nice(struct task_struct *p)
746{
747	int is_subset;
748
749	rcu_read_lock();
750	is_subset = cap_issubset(__task_cred(p)->cap_permitted,
751				 current_cred()->cap_permitted);
 
 
752	rcu_read_unlock();
753
754	if (!is_subset && !capable(CAP_SYS_NICE))
755		return -EPERM;
756	return 0;
757}
758
759/**
760 * cap_task_setscheduler - Detemine if scheduler policy change is permitted
761 * @p: The task to affect
762 *
763 * Detemine if the requested scheduler policy change is permitted for the
764 * specified task, returning 0 if permission is granted, -ve if denied.
 
 
765 */
766int cap_task_setscheduler(struct task_struct *p)
767{
768	return cap_safe_nice(p);
769}
770
771/**
772 * cap_task_ioprio - Detemine if I/O priority change is permitted
773 * @p: The task to affect
774 * @ioprio: The I/O priority to set
775 *
776 * Detemine if the requested I/O priority change is permitted for the specified
777 * task, returning 0 if permission is granted, -ve if denied.
 
 
778 */
779int cap_task_setioprio(struct task_struct *p, int ioprio)
780{
781	return cap_safe_nice(p);
782}
783
784/**
785 * cap_task_ioprio - Detemine if task priority change is permitted
786 * @p: The task to affect
787 * @nice: The nice value to set
788 *
789 * Detemine if the requested task priority change is permitted for the
790 * specified task, returning 0 if permission is granted, -ve if denied.
 
 
791 */
792int cap_task_setnice(struct task_struct *p, int nice)
793{
794	return cap_safe_nice(p);
795}
796
797/*
798 * Implement PR_CAPBSET_DROP.  Attempt to remove the specified capability from
799 * the current task's bounding set.  Returns 0 on success, -ve on error.
800 */
801static long cap_prctl_drop(struct cred *new, unsigned long cap)
802{
803	if (!capable(CAP_SETPCAP))
 
 
804		return -EPERM;
805	if (!cap_valid(cap))
806		return -EINVAL;
807
 
 
 
808	cap_lower(new->cap_bset, cap);
809	return 0;
810}
811
812/**
813 * cap_task_prctl - Implement process control functions for this security module
814 * @option: The process control function requested
815 * @arg2, @arg3, @arg4, @arg5: The argument data for this function
 
 
 
816 *
817 * Allow process control functions (sys_prctl()) to alter capabilities; may
818 * also deny access to other functions not otherwise implemented here.
819 *
820 * Returns 0 or +ve on success, -ENOSYS if this function is not implemented
821 * here, other -ve on error.  If -ENOSYS is returned, sys_prctl() and other LSM
822 * modules will consider performing the function.
823 */
824int cap_task_prctl(int option, unsigned long arg2, unsigned long arg3,
825		   unsigned long arg4, unsigned long arg5)
826{
 
827	struct cred *new;
828	long error = 0;
829
830	new = prepare_creds();
831	if (!new)
832		return -ENOMEM;
833
834	switch (option) {
835	case PR_CAPBSET_READ:
836		error = -EINVAL;
837		if (!cap_valid(arg2))
838			goto error;
839		error = !!cap_raised(new->cap_bset, arg2);
840		goto no_change;
841
842	case PR_CAPBSET_DROP:
843		error = cap_prctl_drop(new, arg2);
844		if (error < 0)
845			goto error;
846		goto changed;
847
848	/*
849	 * The next four prctl's remain to assist with transitioning a
850	 * system from legacy UID=0 based privilege (when filesystem
851	 * capabilities are not in use) to a system using filesystem
852	 * capabilities only - as the POSIX.1e draft intended.
853	 *
854	 * Note:
855	 *
856	 *  PR_SET_SECUREBITS =
857	 *      issecure_mask(SECURE_KEEP_CAPS_LOCKED)
858	 *    | issecure_mask(SECURE_NOROOT)
859	 *    | issecure_mask(SECURE_NOROOT_LOCKED)
860	 *    | issecure_mask(SECURE_NO_SETUID_FIXUP)
861	 *    | issecure_mask(SECURE_NO_SETUID_FIXUP_LOCKED)
862	 *
863	 * will ensure that the current process and all of its
864	 * children will be locked into a pure
865	 * capability-based-privilege environment.
866	 */
867	case PR_SET_SECUREBITS:
868		error = -EPERM;
869		if ((((new->securebits & SECURE_ALL_LOCKS) >> 1)
870		     & (new->securebits ^ arg2))			/*[1]*/
871		    || ((new->securebits & SECURE_ALL_LOCKS & ~arg2))	/*[2]*/
872		    || (arg2 & ~(SECURE_ALL_LOCKS | SECURE_ALL_BITS))	/*[3]*/
873		    || (cap_capable(current, current_cred(),
874				    current_cred()->user->user_ns, CAP_SETPCAP,
875				    SECURITY_CAP_AUDIT) != 0)		/*[4]*/
 
876			/*
877			 * [1] no changing of bits that are locked
878			 * [2] no unlocking of locks
879			 * [3] no setting of unsupported bits
880			 * [4] doing anything requires privilege (go read about
881			 *     the "sendmail capabilities bug")
882			 */
883		    )
884			/* cannot change a locked bit */
885			goto error;
 
 
 
 
886		new->securebits = arg2;
887		goto changed;
888
889	case PR_GET_SECUREBITS:
890		error = new->securebits;
891		goto no_change;
892
893	case PR_GET_KEEPCAPS:
894		if (issecure(SECURE_KEEP_CAPS))
895			error = 1;
896		goto no_change;
897
898	case PR_SET_KEEPCAPS:
899		error = -EINVAL;
900		if (arg2 > 1) /* Note, we rely on arg2 being unsigned here */
901			goto error;
902		error = -EPERM;
903		if (issecure(SECURE_KEEP_CAPS_LOCKED))
904			goto error;
 
 
 
 
905		if (arg2)
906			new->securebits |= issecure_mask(SECURE_KEEP_CAPS);
907		else
908			new->securebits &= ~issecure_mask(SECURE_KEEP_CAPS);
909		goto changed;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
910
911	default:
912		/* No functionality available - continue with default */
913		error = -ENOSYS;
914		goto error;
915	}
916
917	/* Functionality provided */
918changed:
919	return commit_creds(new);
920
921no_change:
922error:
923	abort_creds(new);
924	return error;
925}
926
927/**
928 * cap_vm_enough_memory - Determine whether a new virtual mapping is permitted
929 * @mm: The VM space in which the new mapping is to be made
930 * @pages: The size of the mapping
931 *
932 * Determine whether the allocation of a new virtual mapping by the current
933 * task is permitted, returning 0 if permission is granted, -ve if not.
 
 
934 */
935int cap_vm_enough_memory(struct mm_struct *mm, long pages)
936{
937	int cap_sys_admin = 0;
938
939	if (cap_capable(current, current_cred(), &init_user_ns, CAP_SYS_ADMIN,
940			SECURITY_CAP_NOAUDIT) == 0)
941		cap_sys_admin = 1;
942	return __vm_enough_memory(mm, pages, cap_sys_admin);
 
943}
944
945/*
946 * cap_file_mmap - check if able to map given addr
947 * @file: unused
948 * @reqprot: unused
949 * @prot: unused
950 * @flags: unused
951 * @addr: address attempting to be mapped
952 * @addr_only: unused
953 *
954 * If the process is attempting to map memory below dac_mmap_min_addr they need
955 * CAP_SYS_RAWIO.  The other parameters to this function are unused by the
956 * capability security module.  Returns 0 if this mapping should be allowed
957 * -EPERM if not.
 
958 */
959int cap_file_mmap(struct file *file, unsigned long reqprot,
960		  unsigned long prot, unsigned long flags,
961		  unsigned long addr, unsigned long addr_only)
962{
963	int ret = 0;
964
965	if (addr < dac_mmap_min_addr) {
966		ret = cap_capable(current, current_cred(), &init_user_ns, CAP_SYS_RAWIO,
967				  SECURITY_CAP_AUDIT);
968		/* set PF_SUPERPRIV if it turns out we allow the low mmap */
969		if (ret == 0)
970			current->flags |= PF_SUPERPRIV;
971	}
972	return ret;
973}