Commit ca05a99a authored by Andrew G. Morgan's avatar Andrew G. Morgan Committed by Chris Wright
Browse files

capabilities: remain source compatible with 32-bit raw legacy capability support. 

Source code out there hard-codes a notion of what the
_LINUX_CAPABILITY_VERSION #define means in terms of the semantics of the
raw capability system calls capget() and capset().  Its unfortunate, but
true.

Since the confusing header file has been in a released kernel, there is
software that is erroneously using 64-bit capabilities with the semantics
of 32-bit compatibilities.  These recently compiled programs may suffer
corruption of their memory when sys_getcap() overwrites more memory than
they are coded to expect, and the raising of added capabilities when using
sys_capset().

As such, this patch does a number of things to clean up the situation
for all. It

  1. forces the _LINUX_CAPABILITY_VERSION define to always retain its
     legacy value.

  2. adopts a new #define strategy for the kernel's internal
     implementation of the preferred magic.

  3. deprecates v2 capability magic in favor of a new (v3) magic
     number. The functionality of v3 is entirely equivalent to v2,
     the only difference being that the v2 magic causes the kernel
     to log a "deprecated" warning so the admin can find applications
     that may be using v2 inappropriately.

[User space code continues to be encouraged to use the libcap API which
protects the application from details like this.  libcap-2.10 is the first
to support v3 capabilities.]

Fixes issue reported in https://bugzilla.redhat.com/show_bug.cgi?id=447518

.
Thanks to Bojan Smojver for the report.

[akpm@linux-foundation.org: s/depreciate/deprecate/g]
[akpm@linux-foundation.org: be robust about put_user size]
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: default avatarAndrew G. Morgan <morgan@kernel.org>
Cc: Serge E. Hallyn <serue@us.ibm.com>
Cc: Bojan Smojver <bojan@rexursive.com>
Cc: stable@kernel.org
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarChris Wright <chrisw@sous-sol.org>
parent cc94bc37

fs/proc/array.c

+1 −1
Original line number Diff line number Diff line
@@ -288,7 +288,7 @@ static void render_cap_t(struct seq_file *m, const char *header, 
	seq_printf(m, "%s", header);

	CAP_FOR_EACH_U32(__capi) {

		seq_printf(m, "%08x",

			   a->cap[(_LINUX_CAPABILITY_U32S-1) - __capi]);

			   a->cap[(_KERNEL_CAPABILITY_U32S-1) - __capi]);

	}

	seq_printf(m, "\n");

}

include/linux/capability.h

+21 −8
Original line number Diff line number Diff line
@@ -31,11 +31,11 @@ struct task_struct; 
#define _LINUX_CAPABILITY_VERSION_1  0x19980330

#define _LINUX_CAPABILITY_U32S_1     1



#define _LINUX_CAPABILITY_VERSION_2  0x20071026

#define _LINUX_CAPABILITY_VERSION_2  0x20071026  /* deprecated - use v3 */

#define _LINUX_CAPABILITY_U32S_2     2



#define _LINUX_CAPABILITY_VERSION    _LINUX_CAPABILITY_VERSION_2

#define _LINUX_CAPABILITY_U32S       _LINUX_CAPABILITY_U32S_2

#define _LINUX_CAPABILITY_VERSION_3  0x20080522

#define _LINUX_CAPABILITY_U32S_3     2



typedef struct __user_cap_header_struct {

	__u32 version;
@@ -77,10 +77,23 @@ struct vfs_cap_data { 
	} data[VFS_CAP_U32];

};



#ifdef __KERNEL__

#ifndef __KERNEL__



/*

 * Backwardly compatible definition for source code - trapped in a

 * 32-bit world. If you find you need this, please consider using

 * libcap to untrap yourself...

 */

#define _LINUX_CAPABILITY_VERSION  _LINUX_CAPABILITY_VERSION_1

#define _LINUX_CAPABILITY_U32S     _LINUX_CAPABILITY_U32S_1



#else



#define _KERNEL_CAPABILITY_VERSION _LINUX_CAPABILITY_VERSION_3

#define _KERNEL_CAPABILITY_U32S    _LINUX_CAPABILITY_U32S_3



typedef struct kernel_cap_struct {

	__u32 cap[_LINUX_CAPABILITY_U32S];

	__u32 cap[_KERNEL_CAPABILITY_U32S];

} kernel_cap_t;



#define _USER_CAP_HEADER_SIZE  (sizeof(struct __user_cap_header_struct))
@@ -351,7 +364,7 @@ typedef struct kernel_cap_struct { 
 */



#define CAP_FOR_EACH_U32(__capi)  \

	for (__capi = 0; __capi < _LINUX_CAPABILITY_U32S; ++__capi)

	for (__capi = 0; __capi < _KERNEL_CAPABILITY_U32S; ++__capi)



# define CAP_FS_MASK_B0     (CAP_TO_MASK(CAP_CHOWN)		\

			    | CAP_TO_MASK(CAP_DAC_OVERRIDE)	\
@@ -361,7 +374,7 @@ typedef struct kernel_cap_struct { 


# define CAP_FS_MASK_B1     (CAP_TO_MASK(CAP_MAC_OVERRIDE))



#if _LINUX_CAPABILITY_U32S != 2

#if _KERNEL_CAPABILITY_U32S != 2

# error Fix up hand-coded capability macro initializers

#else /* HAND-CODED capability initializers */
@@ -372,7 +385,7 @@ typedef struct kernel_cap_struct { 
# define CAP_NFSD_SET     ((kernel_cap_t){{ CAP_FS_MASK_B0|CAP_TO_MASK(CAP_SYS_RESOURCE), \

					CAP_FS_MASK_B1 } })



#endif /* _LINUX_CAPABILITY_U32S != 2 */

#endif /* _KERNEL_CAPABILITY_U32S != 2 */



#define CAP_INIT_INH_SET    CAP_EMPTY_SET

kernel/capability.c

+73 −38
Original line number Diff line number Diff line
@@ -52,6 +52,69 @@ static void warn_legacy_capability_use(void) 
	}

}



/*

 * Version 2 capabilities worked fine, but the linux/capability.h file

 * that accompanied their introduction encouraged their use without

 * the necessary user-space source code changes. As such, we have

 * created a version 3 with equivalent functionality to version 2, but

 * with a header change to protect legacy source code from using

 * version 2 when it wanted to use version 1. If your system has code

 * that trips the following warning, it is using version 2 specific

 * capabilities and may be doing so insecurely.

 *

 * The remedy is to either upgrade your version of libcap (to 2.10+,

 * if the application is linked against it), or recompile your

 * application with modern kernel headers and this warning will go

 * away.

 */



static void warn_deprecated_v2(void)

{

	static int warned;



	if (!warned) {

		char name[sizeof(current->comm)];



		printk(KERN_INFO "warning: `%s' uses deprecated v2"

		       " capabilities in a way that may be insecure.\n",

		       get_task_comm(name, current));

		warned = 1;

	}

}



/*

 * Version check. Return the number of u32s in each capability flag

 * array, or a negative value on error.

 */

static int cap_validate_magic(cap_user_header_t header, unsigned *tocopy)

{

	__u32 version;



	if (get_user(version, &header->version))

		return -EFAULT;



	switch (version) {

	case _LINUX_CAPABILITY_VERSION_1:

		warn_legacy_capability_use();

		*tocopy = _LINUX_CAPABILITY_U32S_1;

		break;

	case _LINUX_CAPABILITY_VERSION_2:

		warn_deprecated_v2();

		/*

		 * fall through - v3 is otherwise equivalent to v2.

		 */

	case _LINUX_CAPABILITY_VERSION_3:

		*tocopy = _LINUX_CAPABILITY_U32S_3;

		break;

	default:

		if (put_user((u32)_KERNEL_CAPABILITY_VERSION, &header->version))

			return -EFAULT;

		return -EINVAL;

	}



	return 0;

}



/*

 * For sys_getproccap() and sys_setproccap(), any of the three

 * capability set pointers may be NULL -- indicating that that set is
@@ -71,27 +134,13 @@ asmlinkage long sys_capget(cap_user_header_t header, cap_user_data_t dataptr) 
{

	int ret = 0;

	pid_t pid;

	__u32 version;

	struct task_struct *target;

	unsigned tocopy;

	kernel_cap_t pE, pI, pP;



	if (get_user(version, &header->version))

		return -EFAULT;



	switch (version) {

	case _LINUX_CAPABILITY_VERSION_1:

		warn_legacy_capability_use();

		tocopy = _LINUX_CAPABILITY_U32S_1;

		break;

	case _LINUX_CAPABILITY_VERSION_2:

		tocopy = _LINUX_CAPABILITY_U32S_2;

		break;

	default:

		if (put_user(_LINUX_CAPABILITY_VERSION, &header->version))

			return -EFAULT;

		return -EINVAL;

	}

	ret = cap_validate_magic(header, &tocopy);

	if (ret != 0)

		return ret;



	if (get_user(pid, &header->pid))

		return -EFAULT;
@@ -118,7 +167,7 @@ out: 
	spin_unlock(&task_capability_lock);



	if (!ret) {

		struct __user_cap_data_struct kdata[_LINUX_CAPABILITY_U32S];

		struct __user_cap_data_struct kdata[_KERNEL_CAPABILITY_U32S];

		unsigned i;



		for (i = 0; i < tocopy; i++) {
@@ -128,7 +177,7 @@ out: 
		}



		/*

		 * Note, in the case, tocopy < _LINUX_CAPABILITY_U32S,

		 * Note, in the case, tocopy < _KERNEL_CAPABILITY_U32S,

		 * we silently drop the upper capabilities here. This

		 * has the effect of making older libcap

		 * implementations implicitly drop upper capability
@@ -240,30 +289,16 @@ static inline int cap_set_all(kernel_cap_t *effective, 
 */

asmlinkage long sys_capset(cap_user_header_t header, const cap_user_data_t data)

{

	struct __user_cap_data_struct kdata[_LINUX_CAPABILITY_U32S];

	struct __user_cap_data_struct kdata[_KERNEL_CAPABILITY_U32S];

	unsigned i, tocopy;

	kernel_cap_t inheritable, permitted, effective;

	__u32 version;

	struct task_struct *target;

	int ret;

	pid_t pid;



	if (get_user(version, &header->version))

		return -EFAULT;



	switch (version) {

	case _LINUX_CAPABILITY_VERSION_1:

		warn_legacy_capability_use();

		tocopy = _LINUX_CAPABILITY_U32S_1;

		break;

	case _LINUX_CAPABILITY_VERSION_2:

		tocopy = _LINUX_CAPABILITY_U32S_2;

		break;

	default:

		if (put_user(_LINUX_CAPABILITY_VERSION, &header->version))

			return -EFAULT;

		return -EINVAL;

	}

	ret = cap_validate_magic(header, &tocopy);

	if (ret != 0)

		return ret;



	if (get_user(pid, &header->pid))

		return -EFAULT;
@@ -281,7 +316,7 @@ asmlinkage long sys_capset(cap_user_header_t header, const cap_user_data_t data) 
		permitted.cap[i] = kdata[i].permitted;

		inheritable.cap[i] = kdata[i].inheritable;

	}

	while (i < _LINUX_CAPABILITY_U32S) {

	while (i < _KERNEL_CAPABILITY_U32S) {

		effective.cap[i] = 0;

		permitted.cap[i] = 0;

		inheritable.cap[i] = 0;

CRA Git | Maintained and supported by SUSTech CRA and CCSE