prlimit,security,selinux: add a security hook for prlimit

When SELinux was first added to the kernel, a process could only get
and set its own resource limits via getrlimit(2) and setrlimit(2), so no
MAC checks were required for those operations, and thus no security hooks
were defined for them. Later, SELinux introduced a hook for setlimit(2)
with a check if the hard limit was being changed in order to be able to
rely on the hard limit value as a safe reset point upon context
transitions.

Later on, when prlimit(2) was added to the kernel with the ability to get
or set resource limits (hard or soft) of another process, LSM/SELinux was
not updated other than to pass the target process to the setrlimit hook.
This resulted in incomplete control over both getting and setting the
resource limits of another process.

Add a new security_task_prlimit() hook to the check_prlimit_permission()
function to provide complete mediation.  The hook is only called when
acting on another task, and only if the existing DAC/capability checks
would allow access.  Pass flags down to the hook to indicate whether the
prlimit(2) call will read, write, or both read and write the resource
limits of the target process.

The existing security_task_setrlimit() hook is left alone; it continues
to serve a purpose in supporting the ability to make decisions based on
the old and/or new resource limit values when setting limits.  This
is consistent with the DAC/capability logic, where
check_prlimit_permission() performs generic DAC/capability checks for
acting on another task, while do_prlimit() performs a capability check
based on a comparison of the old and new resource limits.  Fix the
inline documentation for the hook to match the code.

Implement the new hook for SELinux.  For setting resource limits, we
reuse the existing setrlimit permission.  Note that this does overload
the setrlimit permission to mean the ability to set the resource limit
(soft or hard) of another process or the ability to change one's own
hard limit.  For getting resource limits, a new getrlimit permission
is defined.  This was not originally defined since getrlimit(2) could
only be used to obtain a process' own limits.

Signed-off-by: Stephen Smalley <sds@tycho.nsa.gov>
Signed-off-by: James Morris <james.l.morris@oracle.com>

diff --git a/include/linux/lsm_hooks.h b/include/linux/lsm_hooks.h
index e29d4c62a3c8e268695d9963c2250f3eaf375399..ba3049f05aea9a54953e15faecb45ac4607bd023 100644 (file)
--- a/include/linux/lsm_hooks.h
+++ b/include/linux/lsm_hooks.h
@@ -630,10 +630,19 @@
  *     Check permission before getting the ioprio value of @p.
  *     @p contains the task_struct of process.
  *     Return 0 if permission is granted.
+ * @task_prlimit:
+ *     Check permission before getting and/or setting the resource limits of
+ *     another task.
+ *     @cred points to the cred structure for the current task.
+ *     @tcred points to the cred structure for the target task.
+ *     @flags contains the LSM_PRLIMIT_* flag bits indicating whether the
+ *     resource limits are being read, modified, or both.
+ *     Return 0 if permission is granted.
  * @task_setrlimit:
- *     Check permission before setting the resource limits of the current
- *     process for @resource to @new_rlim.  The old resource limit values can
- *     be examined by dereferencing (current->signal->rlim + resource).
+ *     Check permission before setting the resource limits of process @p
+ *     for @resource to @new_rlim.  The old resource limit values can
+ *     be examined by dereferencing (p->signal->rlim + resource).
+ *     @p points to the task_struct for the target task's group leader.
  *     @resource contains the resource whose limit is being set.
  *     @new_rlim contains the new limits for @resource.
  *     Return 0 if permission is granted.
@@ -1494,6 +1503,8 @@ union security_list_options {
        int (*task_setnice)(struct task_struct *p, int nice);
        int (*task_setioprio)(struct task_struct *p, int ioprio);
        int (*task_getioprio)(struct task_struct *p);
+       int (*task_prlimit)(const struct cred *cred, const struct cred *tcred,
+                           unsigned int flags);
        int (*task_setrlimit)(struct task_struct *p, unsigned int resource,
                                struct rlimit *new_rlim);
        int (*task_setscheduler)(struct task_struct *p);
@@ -1755,6 +1766,7 @@ struct security_hook_heads {
        struct list_head task_setnice;
        struct list_head task_setioprio;
        struct list_head task_getioprio;
+       struct list_head task_prlimit;
        struct list_head task_setrlimit;
        struct list_head task_setscheduler;
        struct list_head task_getscheduler;

diff --git a/include/linux/security.h b/include/linux/security.h
index 96899fad701696ce9212055a5a4e049cfcf0f933..97df7bac5b486d4c873c0b5379d3650fa8da2bfe 100644 (file)
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -133,6 +133,10 @@ extern unsigned long dac_mmap_min_addr;
 /* setfsuid or setfsgid, id0 == fsuid or fsgid */
 #define LSM_SETID_FS   8
 
+/* Flags for security_task_prlimit(). */
+#define LSM_PRLIMIT_READ  1
+#define LSM_PRLIMIT_WRITE 2
+
 /* forward declares to avoid warnings */
 struct sched_param;
 struct request_sock;
@@ -324,6 +328,8 @@ void security_task_getsecid(struct task_struct *p, u32 *secid);
 int security_task_setnice(struct task_struct *p, int nice);
 int security_task_setioprio(struct task_struct *p, int ioprio);
 int security_task_getioprio(struct task_struct *p);
+int security_task_prlimit(const struct cred *cred, const struct cred *tcred,
+                         unsigned int flags);
 int security_task_setrlimit(struct task_struct *p, unsigned int resource,
                struct rlimit *new_rlim);
 int security_task_setscheduler(struct task_struct *p);
@@ -949,6 +955,13 @@ static inline int security_task_getioprio(struct task_struct *p)
        return 0;
 }
 
+static inline int security_task_prlimit(const struct cred *cred,
+                                       const struct cred *tcred,
+                                       unsigned int flags)
+{
+       return 0;
+}
+
 static inline int security_task_setrlimit(struct task_struct *p,
                                          unsigned int resource,
                                          struct rlimit *new_rlim)

diff --git a/kernel/sys.c b/kernel/sys.c
index 7ff6d1b10cecac8e66583f3bc233fd6fcb445b5c..196c7134bee6bda9ef444272beba8940ee3699d7 100644 (file)
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -1432,25 +1432,26 @@ out:
 }
 
 /* rcu lock must be held */
-static int check_prlimit_permission(struct task_struct *task)
+static int check_prlimit_permission(struct task_struct *task,
+                                   unsigned int flags)
 {
        const struct cred *cred = current_cred(), *tcred;
+       bool id_match;
 
        if (current == task)
                return 0;
 
        tcred = __task_cred(task);
-       if (uid_eq(cred->uid, tcred->euid) &&
-           uid_eq(cred->uid, tcred->suid) &&
-           uid_eq(cred->uid, tcred->uid)  &&
-           gid_eq(cred->gid, tcred->egid) &&
-           gid_eq(cred->gid, tcred->sgid) &&
-           gid_eq(cred->gid, tcred->gid))
-               return 0;
-       if (ns_capable(tcred->user_ns, CAP_SYS_RESOURCE))
-               return 0;
+       id_match = (uid_eq(cred->uid, tcred->euid) &&
+                   uid_eq(cred->uid, tcred->suid) &&
+                   uid_eq(cred->uid, tcred->uid)  &&
+                   gid_eq(cred->gid, tcred->egid) &&
+                   gid_eq(cred->gid, tcred->sgid) &&
+                   gid_eq(cred->gid, tcred->gid));
+       if (!id_match && !ns_capable(tcred->user_ns, CAP_SYS_RESOURCE))
+               return -EPERM;
 
-       return -EPERM;
+       return security_task_prlimit(cred, tcred, flags);
 }
 
 SYSCALL_DEFINE4(prlimit64, pid_t, pid, unsigned int, resource,
@@ -1460,12 +1461,17 @@ SYSCALL_DEFINE4(prlimit64, pid_t, pid, unsigned int, resource,
        struct rlimit64 old64, new64;
        struct rlimit old, new;
        struct task_struct *tsk;
+       unsigned int checkflags = 0;
        int ret;
 
+       if (old_rlim)
+               checkflags |= LSM_PRLIMIT_READ;
+
        if (new_rlim) {
                if (copy_from_user(&new64, new_rlim, sizeof(new64)))
                        return -EFAULT;
                rlim64_to_rlim(&new64, &new);
+               checkflags |= LSM_PRLIMIT_WRITE;
        }
 
        rcu_read_lock();
@@ -1474,7 +1480,7 @@ SYSCALL_DEFINE4(prlimit64, pid_t, pid, unsigned int, resource,
                rcu_read_unlock();
                return -ESRCH;
        }
-       ret = check_prlimit_permission(tsk);
+       ret = check_prlimit_permission(tsk, checkflags);
        if (ret) {
                rcu_read_unlock();
                return ret;

diff --git a/security/security.c b/security/security.c
index d0e07f269b2d92b54e384d5a50708543bb7cc131..905dad2811d334935b1ae9f0913f703a985de65b 100644 (file)
--- a/security/security.c
+++ b/security/security.c
@@ -1036,6 +1036,12 @@ int security_task_getioprio(struct task_struct *p)
        return call_int_hook(task_getioprio, 0, p);
 }
 
+int security_task_prlimit(const struct cred *cred, const struct cred *tcred,
+                         unsigned int flags)
+{
+       return call_int_hook(task_prlimit, 0, cred, tcred, flags);
+}
+
 int security_task_setrlimit(struct task_struct *p, unsigned int resource,
                struct rlimit *new_rlim)
 {
@@ -1793,6 +1799,8 @@ struct security_hook_heads security_hook_heads = {
                LIST_HEAD_INIT(security_hook_heads.task_setioprio),
        .task_getioprio =
                LIST_HEAD_INIT(security_hook_heads.task_getioprio),
+       .task_prlimit =
+               LIST_HEAD_INIT(security_hook_heads.task_prlimit),
        .task_setrlimit =
                LIST_HEAD_INIT(security_hook_heads.task_setrlimit),
        .task_setscheduler =

diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index 0c2ac318aa7fb8bc11830e7c8c10fe6730f49c46..870d24ecc2decf043e08dd8060aae0dbe0f16f91 100644 (file)
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -3920,6 +3920,19 @@ static int selinux_task_getioprio(struct task_struct *p)
                            PROCESS__GETSCHED, NULL);
 }
 
+int selinux_task_prlimit(const struct cred *cred, const struct cred *tcred,
+                        unsigned int flags)
+{
+       u32 av = 0;
+
+       if (flags & LSM_PRLIMIT_WRITE)
+               av |= PROCESS__SETRLIMIT;
+       if (flags & LSM_PRLIMIT_READ)
+               av |= PROCESS__GETRLIMIT;
+       return avc_has_perm(cred_sid(cred), cred_sid(tcred),
+                           SECCLASS_PROCESS, av, NULL);
+}
+
 static int selinux_task_setrlimit(struct task_struct *p, unsigned int resource,
                struct rlimit *new_rlim)
 {
@@ -6206,6 +6219,7 @@ static struct security_hook_list selinux_hooks[] = {
        LSM_HOOK_INIT(task_setnice, selinux_task_setnice),
        LSM_HOOK_INIT(task_setioprio, selinux_task_setioprio),
        LSM_HOOK_INIT(task_getioprio, selinux_task_getioprio),
+       LSM_HOOK_INIT(task_prlimit, selinux_task_prlimit),
        LSM_HOOK_INIT(task_setrlimit, selinux_task_setrlimit),
        LSM_HOOK_INIT(task_setscheduler, selinux_task_setscheduler),
        LSM_HOOK_INIT(task_getscheduler, selinux_task_getscheduler),

diff --git a/security/selinux/include/classmap.h b/security/selinux/include/classmap.h
index d429c4a1c551536d090c264e6e60f9fc7311a2d2..1e0cc9b5de207bd41068274099aed97d19203898 100644 (file)
--- a/security/selinux/include/classmap.h
+++ b/security/selinux/include/classmap.h
@@ -47,7 +47,7 @@ struct security_class_mapping secclass_map[] = {
            "getattr", "setexec", "setfscreate", "noatsecure", "siginh",
            "setrlimit", "rlimitinh", "dyntransition", "setcurrent",
            "execmem", "execstack", "execheap", "setkeycreate",
-           "setsockcreate", NULL } },
+           "setsockcreate", "getrlimit", NULL } },
        { "system",
          { "ipc_info", "syslog_read", "syslog_mod",
            "syslog_console", "module_request", "module_load", NULL } },