CRED: Neuter sys_capset()

Take away the ability for sys_capset() to affect processes other than current.

This means that current will not need to lock its own credentials when reading
them against interference by other processes.

This has effectively been the case for a while anyway, since:

 (1) Without LSM enabled, sys_capset() is disallowed.

 (2) With file-based capabilities, sys_capset() is neutered.

Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Serge Hallyn <serue@us.ibm.com>
Acked-by: Andrew G. Morgan <morgan@kernel.org>
Acked-by: James Morris <jmorris@namei.org>
Signed-off-by: James Morris <jmorris@namei.org>

3 files changed, 21 insertions, 36 deletions

diff --git a/security/commoncap.c b/security/commoncap.c
index 8283271f0768..e3f36ef629fa 100644
--- a/security/commoncap.c
+++ b/security/commoncap.c
@@ -96,15 +96,6 @@ int cap_capget (struct task_struct *target, kernel_cap_t *effective,
 
 #ifdef CONFIG_SECURITY_FILE_CAPABILITIES
 
-static inline int cap_block_setpcap(struct task_struct *target)
-{
-        /*
-         * No support for remote process capability manipulation with
-         * filesystem capability support.
-         */
-        return (target != current);
-}
-
 static inline int cap_inh_is_capped(void)
 {
         /*
@@ -119,7 +110,6 @@ static inline int cap_limit_ptraced_target(void) { return 1; }
 
 #else /* ie., ndef CONFIG_SECURITY_FILE_CAPABILITIES */
 
-static inline int cap_block_setpcap(struct task_struct *t) { return 0; }
 static inline int cap_inh_is_capped(void) { return 1; }
 static inline int cap_limit_ptraced_target(void)
 {
@@ -128,21 +118,18 @@ static inline int cap_limit_ptraced_target(void)
 
 #endif /* def CONFIG_SECURITY_FILE_CAPABILITIES */
 
-int cap_capset_check (struct task_struct *target, kernel_cap_t *effective,
+int cap_capset_check (kernel_cap_t *effective,
                       kernel_cap_t *inheritable, kernel_cap_t *permitted)
 {
-        if (cap_block_setpcap(target)) {
-                return -EPERM;
-        }
         if (cap_inh_is_capped()
             && !cap_issubset(*inheritable,
-                             cap_combine(target->cap_inheritable,
+                             cap_combine(current->cap_inheritable,
                                          current->cap_permitted))) {
                 /* incapable of using this inheritable set */
                 return -EPERM;
         }
         if (!cap_issubset(*inheritable,
-                           cap_combine(target->cap_inheritable,
+                           cap_combine(current->cap_inheritable,
                                        current->cap_bset))) {
                 /* no new pI capabilities outside bounding set */
                 return -EPERM;
@@ -150,7 +137,7 @@ int cap_capset_check (struct task_struct *target, kernel_cap_t *effective,
 
         /* verify restrictions on target's new Permitted set */
         if (!cap_issubset (*permitted,
-                           cap_combine (target->cap_permitted,
+                           cap_combine (current->cap_permitted,
                                         current->cap_permitted))) {
                 return -EPERM;
         }
@@ -163,12 +150,12 @@ int cap_capset_check (struct task_struct *target, kernel_cap_t *effective,
         return 0;
 }
 
-void cap_capset_set (struct task_struct *target, kernel_cap_t *effective,
+void cap_capset_set (kernel_cap_t *effective,
                      kernel_cap_t *inheritable, kernel_cap_t *permitted)
 {
-        target->cap_effective = *effective;
-        target->cap_inheritable = *inheritable;
-        target->cap_permitted = *permitted;
+        current->cap_effective = *effective;
+        current->cap_inheritable = *inheritable;
+        current->cap_permitted = *permitted;
 }
 
 static inline void bprm_clear_caps(struct linux_binprm *bprm)
diff --git a/security/security.c b/security/security.c
index 346f21e0ec2c..dca37381e2a7 100644
--- a/security/security.c
+++ b/security/security.c
@@ -145,20 +145,18 @@ int security_capget(struct task_struct *target,
         return security_ops->capget(target, effective, inheritable, permitted);
 }
 
-int security_capset_check(struct task_struct *target,
-                           kernel_cap_t *effective,
-                           kernel_cap_t *inheritable,
-                           kernel_cap_t *permitted)
+int security_capset_check(kernel_cap_t *effective,
+                          kernel_cap_t *inheritable,
+                          kernel_cap_t *permitted)
 {
-        return security_ops->capset_check(target, effective, inheritable, permitted);
+        return security_ops->capset_check(effective, inheritable, permitted);
 }
 
-void security_capset_set(struct task_struct *target,
-                          kernel_cap_t *effective,
-                          kernel_cap_t *inheritable,
-                          kernel_cap_t *permitted)
+void security_capset_set(kernel_cap_t *effective,
+                         kernel_cap_t *inheritable,
+                         kernel_cap_t *permitted)
 {
-        security_ops->capset_set(target, effective, inheritable, permitted);
+        security_ops->capset_set(effective, inheritable, permitted);
 }
 
 int security_capable(struct task_struct *tsk, int cap)
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index 378dc53c08e8..df9986940e9c 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -1790,22 +1790,22 @@ static int selinux_capget(struct task_struct *target, kernel_cap_t *effective,
         return secondary_ops->capget(target, effective, inheritable, permitted);
 }
 
-static int selinux_capset_check(struct task_struct *target, kernel_cap_t *effective,
+static int selinux_capset_check(kernel_cap_t *effective,
                                 kernel_cap_t *inheritable, kernel_cap_t *permitted)
 {
         int error;
 
-        error = secondary_ops->capset_check(target, effective, inheritable, permitted);
+        error = secondary_ops->capset_check(effective, inheritable, permitted);
         if (error)
                 return error;
 
-        return task_has_perm(current, target, PROCESS__SETCAP);
+        return task_has_perm(current, current, PROCESS__SETCAP);
 }
 
-static void selinux_capset_set(struct task_struct *target, kernel_cap_t *effective,
+static void selinux_capset_set(kernel_cap_t *effective,
                                kernel_cap_t *inheritable, kernel_cap_t *permitted)
 {
-        secondary_ops->capset_set(target, effective, inheritable, permitted);
+        secondary_ops->capset_set(effective, inheritable, permitted);
 }
 
 static int selinux_capable(struct task_struct *tsk, int cap, int audit)