SECURITY: selinux, fix update_rlimit_cpu parameter
Subsystems (3)
PATCH 1/8 SECURITY: selinux, fix update_rlimit_cpu parameter
Don't pass rlim_cur member of RLIM_NLIMITS-1=RLIMIT_RTTIME limit to update_rlimit_cpu() in selinux_bprm_committing_creds.
Use proper rlim[RLIMIT_CPU].rlim_cur instead.
--- security/selinux/hooks.c | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-)
security/selinux/hooks.c +1 -1
@@ -2365,7 +2365,7 @@ static void selinux_bprm_committing_creds(struct linux_binprm *bprm) initrlim = init_task.signal->rlim + i; rlim->rlim_cur =min (rlim->rlim_max, initrlim->rlim_cur); } -update_rlimit_cpu (rlim->rlim_cur); +update_rlimit_cpu (current->signal->rlim[RLIMIT_CPU ].rlim_cur); } }
Signature · 1 line
1.6.4.2
PATCH 2/8 SECURITY: add task_struct to setrlimit
Add task_struct to task_setrlimit of security_operations to be able to set rlimit of different task than current.
--- include/linux/security.h | 9 ++++++--- kernel/sys.c | 2 +- security/capability.c | 3 ++- security/security.c | 5 +++-- security/selinux/hooks.c | 7 ++++--- 5 files changed, 16 insertions(+), 10 deletions(-)
include/linux/security.h +6 -3
@@ -1590,7 +1590,8 @@ struct security_operations {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_setrlimit) (unsigned int resource,struct rlimit *new_rlim); +int (*task_setrlimit) (struct task_struct *p,unsigned int resource, +struct rlimit *new_rlim);int (*task_setscheduler) (struct task_struct *p,int policy,struct sched_param *lp);int (*task_getscheduler) (struct task_struct *p);
@@ -1855,7 +1856,8 @@ int security_task_setgroups(struct group_info *group_info);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_setrlimit (unsigned int resource,struct rlimit *new_rlim); +int security_task_setrlimit (struct task_struct *p,unsigned int resource, +struct rlimit *new_rlim);int security_task_setscheduler (struct task_struct *p,int policy,struct sched_param *lp);int security_task_getscheduler (struct task_struct *p);
@@ -2471,7 +2473,8 @@ static inline int security_task_getioprio(struct task_struct *p)return 0 ; } -static inline int security_task_setrlimit (unsigned int resource, +static inline int security_task_setrlimit (struct task_struct *p, +unsigned int resource,struct rlimit *new_rlim) {return 0 ;
kernel/sys.c +1 -1
@@ -1256,7 +1256,7 @@ SYSCALL_DEFINE2(setrlimit, unsigned int, resource, struct rlimit __user *, rlim)if (resource ==RLIMIT_NOFILE && new_rlim.rlim_max > sysctl_nr_open)return -EPERM ; - retval =security_task_setrlimit (resource, &new_rlim); + retval =security_task_setrlimit (current, resource, &new_rlim);if (retval)return retval;
security/capability.c +2 -1
@@ -466,7 +466,8 @@ static int cap_task_getioprio(struct task_struct *p)return 0 ; } -static int cap_task_setrlimit (unsigned int resource,struct rlimit *new_rlim) +static int cap_task_setrlimit (struct task_struct *p,unsigned int resource, +struct rlimit *new_rlim) {return 0 ; }
security/security.c +3 -2
@@ -801,9 +801,10 @@ int security_task_getioprio(struct task_struct *p)return security_ops->task_getioprio (p); } -int security_task_setrlimit (unsigned int resource,struct rlimit *new_rlim) +int security_task_setrlimit (struct task_struct *p,unsigned int resource, +struct rlimit *new_rlim) { -return security_ops->task_setrlimit (resource, new_rlim); +return security_ops->task_setrlimit (p, resource, new_rlim); } int security_task_setscheduler(struct task_struct *p,
security/selinux/hooks.c +4 -3
@@ -3389,16 +3389,17 @@ static int selinux_task_getioprio(struct task_struct *p)return current_has_perm (p,PROCESS__GETSCHED ); } -static int selinux_task_setrlimit (unsigned int resource,struct rlimit *new_rlim) +static int selinux_task_setrlimit (struct task_struct *p,unsigned int resource, +struct rlimit *new_rlim) { -struct rlimit *old_rlim = current->signal->rlim + resource; +struct rlimit *old_rlim = p->signal->rlim + resource;/* Control the ability to change the hard limit (whether lowering or raising it), so that the hard limit can later be used as a safe reset point for the soft limit upon context transitions. See selinux_bprm_committing_creds. */ if (old_rlim->rlim_max != new_rlim->rlim_max) -return current_has_perm (current,PROCESS__SETRLIMIT ); +return current_has_perm (p,PROCESS__SETRLIMIT );return 0 ; }
Signature · 1 line
1.6.4.2
PATCH 3/8 core: add task_struct to update_rlimit_cpu
In reply to Jiri SlabyAdd task_struct as a parameter to update_rlimit_cpu to be able to set rlimit_cpu of different task than current.
--- include/linux/posix-timers.h | 2 +- kernel/posix-cpu-timers.c | 10 +++++----- kernel/sys.c | 2 +- security/selinux/hooks.c | 3 ++- 4 files changed, 9 insertions(+), 8 deletions(-)
include/linux/posix-timers.h +1 -1
@@ -117,6 +117,6 @@ void set_process_cpu_timer(struct task_struct *task, unsigned int clock_idx,long clock_nanosleep_restart (struct restart_block *restart_block); -void update_rlimit_cpu (unsigned long rlim_new); +void update_rlimit_cpu (struct task_struct *task,unsigned long rlim_new);#endif
kernel/posix-cpu-timers.c +5 -5
@@ -13,16 +13,16 @@/* * Called after updating RLIMIT_CPU to set timer expiration if necessary. */ -void update_rlimit_cpu (unsigned long rlim_new) +void update_rlimit_cpu (struct task_struct *task,unsigned long rlim_new) {cputime_t cputime =secs_to_cputime (rlim_new); -struct signal_struct *const sig = current->signal; +struct signal_struct *const sig = task->signal;if (cputime_eq (sig->it[CPUCLOCK_PROF ].expires, cputime_zero) ||cputime_gt (sig->it[CPUCLOCK_PROF ].expires, cputime)) { -spin_lock_irq (¤t->sighand->siglock); -set_process_cpu_timer (current,CPUCLOCK_PROF , &cputime,NULL ); -spin_unlock_irq (¤t->sighand->siglock); +spin_lock_irq (&task->sighand->siglock); +set_process_cpu_timer (task,CPUCLOCK_PROF , &cputime,NULL ); +spin_unlock_irq (&task->sighand->siglock); } }
kernel/sys.c +1 -1
@@ -1286,7 +1286,7 @@ SYSCALL_DEFINE2(setrlimit, unsigned int, resource, struct rlimit __user *, rlim)if (new_rlim.rlim_cur ==RLIM_INFINITY ) goto out; -update_rlimit_cpu (new_rlim.rlim_cur); +update_rlimit_cpu (current, new_rlim.rlim_cur); out:return 0 ; }
security/selinux/hooks.c +2 -1
@@ -2365,7 +2365,8 @@ static void selinux_bprm_committing_creds(struct linux_binprm *bprm) initrlim = init_task.signal->rlim + i; rlim->rlim_cur =min (rlim->rlim_max, initrlim->rlim_cur); } -update_rlimit_cpu (current->signal->rlim[RLIMIT_CPU ].rlim_cur); +update_rlimit_cpu (current, + current->signal->rlim[RLIMIT_CPU ].rlim_cur); } }
Signature · 1 line
1.6.4.2
PATCH 4/8 sys_setrlimit: make sure ->rlim_max never grows
In reply to Jiri SlabyFrom: Oleg Nesterov <[email protected]>
Mostly preparation for Jiri's changes, but probably makes sense anyway.
sys_setrlimit() checks new_rlim.rlim_max <= old_rlim->rlim_max, but when it takes task_lock() old_rlim->rlim_max can be already lowered. Move this check under task_lock().
Currently this is not important, we can only race with our sub-thread, this means the application is stupid. But when we change the code to allow the update of !current task's limits, it becomes important to make sure ->rlim_max can be lowered "reliably" even if we race with the application doing sys_setrlimit().
--- kernel/sys.c | 15 ++++++++------- 1 files changed, 8 insertions(+), 7 deletions(-)
kernel/sys.c +8 -7
@@ -1249,10 +1249,6 @@ SYSCALL_DEFINE2(setrlimit, unsigned int, resource, struct rlimit __user *, rlim)return -EFAULT ;if (new_rlim.rlim_cur > new_rlim.rlim_max)return -EINVAL ; - old_rlim = current->signal->rlim + resource; -if ((new_rlim.rlim_max > old_rlim->rlim_max) && - !capable (CAP_SYS_RESOURCE )) -return -EPERM ;if (resource ==RLIMIT_NOFILE && new_rlim.rlim_max > sysctl_nr_open)return -EPERM ;
@@ -1270,11 +1266,16 @@ SYSCALL_DEFINE2(setrlimit, unsigned int, resource, struct rlimit __user *, rlim) new_rlim.rlim_cur =1 ; } + old_rlim = current->signal->rlim + resource;task_lock (current->group_leader); - *old_rlim = new_rlim; +if ((new_rlim.rlim_max <= old_rlim->rlim_max) || +capable (CAP_SYS_RESOURCE )) + *old_rlim = new_rlim; +else + retval = -EPERM ;task_unlock (current->group_leader); -if (resource !=RLIMIT_CPU ) +if (retval || resource !=RLIMIT_CPU ) goto out;/*
@@ -1288,7 +1289,7 @@ SYSCALL_DEFINE2(setrlimit, unsigned int, resource, struct rlimit __user *, rlim)update_rlimit_cpu (current, new_rlim.rlim_cur); out: -return 0 ; +return retval; }/*
Signature · 1 line
1.6.4.2
PATCH 5/8 core: split sys_setrlimit
In reply to Jiri SlabyCreate setrlimit from sys_setrlimit and declare setrlimit in the resource header. This is to allow rlimits to be changed not only by syscall, but later from proc code too.
--- include/linux/resource.h | 2 ++ kernel/sys.c | 44 ++++++++++++++++++++++++++------------------ 2 files changed, 28 insertions(+), 18 deletions(-)
include/linux/resource.h +2 -0
@@ -71,5 +71,7 @@ struct rlimit {#include <asm/resource.h> int getrusage (struct task_struct *p,int who,struct rusage __user *ru); +int setrlimit (struct task_struct *tsk,unsigned int resource, +struct rlimit *new_rlim);#endif
kernel/sys.c +26 -18
82 lines not on this page · raw message
Signature · 1 line
1.6.4.2
PATCH 6/8 core: allow setrlimit to non-current tasks
In reply to Jiri SlabyAdd locking to allow setrlimit accept task parameter other than current.
Namely, lock tasklist_lock for read and check whether the task structure has sighand non-null. Do all the signal processing under that lock still held.
--- kernel/sys.c | 11 ++++++++++- 1 files changed, 10 insertions(+), 1 deletions(-)
kernel/sys.c +10 -1
@@ -1238,6 +1238,7 @@ SYSCALL_DEFINE2(old_getrlimit, unsigned int, resource,#endif +/* make sure you are allowed to change @tsk limits before calling this */ int setrlimit (struct task_struct *tsk,unsigned int resource,struct rlimit *new_rlim) {
@@ -1249,9 +1250,16 @@ int setrlimit(struct task_struct *tsk, unsigned int resource,if (resource ==RLIMIT_NOFILE && new_rlim->rlim_max > sysctl_nr_open)return -EPERM ; +/* protect tsk->signal and tsk->sighand from disappearing */ +read_lock (&tasklist_lock); +if (!tsk->sighand) { + retval = -ESRCH ; + goto out; + } + retval =security_task_setrlimit (tsk, resource, new_rlim);if (retval) -return retval; + goto out;if (resource ==RLIMIT_CPU && new_rlim->rlim_cur ==0 ) {/*
@@ -1286,6 +1294,7 @@ int setrlimit(struct task_struct *tsk, unsigned int resource,update_rlimit_cpu (tsk, new_rlim->rlim_cur); out: +read_unlock (&tasklist_lock);return retval; }
Signature · 1 line
1.6.4.2
PATCH 7/8 core: optimize setrlimit for current task
In reply to Jiri SlabyDon't take tasklist lock for 'current'. It's not needed, since current->sighand/signal can't disappear.
This improves serlimit called especially via sys_setrlimit.
--- kernel/sys.c | 16 ++++++++++------ 1 files changed, 10 insertions(+), 6 deletions(-)
kernel/sys.c +10 -6
@@ -1250,11 +1250,14 @@ int setrlimit(struct task_struct *tsk, unsigned int resource,if (resource ==RLIMIT_NOFILE && new_rlim->rlim_max > sysctl_nr_open)return -EPERM ; -/* protect tsk->signal and tsk->sighand from disappearing */ -read_lock (&tasklist_lock); -if (!tsk->sighand) { - retval = -ESRCH ; - goto out; +/* optimization: 'current' doesn't need locking, e.g. setrlimit */ +if (tsk != current) { +/* protect tsk->signal and tsk->sighand from disappearing */ +read_lock (&tasklist_lock); +if (!tsk->sighand) { + retval = -ESRCH ; + goto out; + } } retval =security_task_setrlimit (tsk, resource, new_rlim);
@@ -1294,7 +1297,8 @@ int setrlimit(struct task_struct *tsk, unsigned int resource,update_rlimit_cpu (tsk, new_rlim->rlim_cur); out: -read_unlock (&tasklist_lock); +if (tsk != current) +read_unlock (&tasklist_lock);return retval; }
Signature · 1 line
1.6.4.2
PATCH 8/8 FS: proc, make limits writable
In reply to Jiri SlabyAllow writing strings such as
Max core file size=0:unlimited
to /proc/<pid>/limits to change limits.
--- fs/proc/base.c | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 files changed, 76 insertions(+), 2 deletions(-)
fs/proc/base.c +76 -2
@@ -129,6 +129,8 @@ struct pid_entry { NULL, &proc_single_file_operations, \ { .proc_show = show } ) +static ssize_t proc_info_read (struct file * file,char __user * buf, +size_t count,loff_t *ppos);/* * Count the number of hardlinks for the pid_entry table, excluding the . * and .. links.
@@ -522,6 +524,74 @@ static int proc_pid_limits(struct task_struct *task, char *buffer)return count; } +static ssize_t limits_write (struct file *file,const char __user *buf, +size_t count,loff_t *ppos) +{ +struct task_struct *task =get_proc_task (file->f_path.dentry->d_inode); +char str[32 +1 +16 +1 +16 +1 ], *delim, *next; +struct rlimit new_rlimit; +unsigned int i; +int ret; + +if (!task) { + count = -ESRCH ; + goto out; + } +if (copy_from_user (str, buf,min (count,sizeof (str) -1 ))) { + count = -EFAULT ; + goto put_task; + } + + str[min (count,sizeof (str) -1 )] =0 ; + + delim =strchr (str,'=' ); +if (!delim) { + count = -EINVAL ; + goto put_task; + } + *delim++ =0 ;/* for easy 'str' usage */ + new_rlimit.rlim_cur =simple_strtoul (delim, &next,0 ); +if (*next !=':' ) { +if (strncmp (delim,"unlimited:" ,10 )) { + count = -EINVAL ; + goto put_task; + } + new_rlimit.rlim_cur =RLIM_INFINITY ; + next = delim +9 ;/* move to ':' */ + } + delim = next +1 ; + new_rlimit.rlim_max =simple_strtoul (delim, &next,0 ); +if (*next !=0 ) { +if (strcmp (delim,"unlimited" )) { + count = -EINVAL ; + goto put_task; + } + new_rlimit.rlim_max =RLIM_INFINITY ; + } + +for (i =0 ; i <RLIM_NLIMITS ; i++) +if (!strcmp (str, lnames[i].name)) +break ; +if (i >=RLIM_NLIMITS ) { + count = -EINVAL ; + goto put_task; + } + + ret =setrlimit (task, i, &new_rlimit); +if (ret) + count = ret; + +put_task: +put_task_struct (task); +out: +return count; +} + +static const struct file_operations proc_pid_limits_operations = { + .read = proc_info_read, + .write = limits_write, +}; +#ifdef CONFIG_HAVE_ARCH_TRACEHOOK static int proc_pid_syscall (struct task_struct *task,char *buffer) {
@@ -2501,7 +2571,9 @@ static const struct pid_entry tgid_base_stuff[] = {INF ("auxv" ,S_IRUSR , proc_pid_auxv),ONE ("status" ,S_IRUGO , proc_pid_status),ONE ("personality" ,S_IRUSR , proc_pid_personality), -INF ("limits" ,S_IRUSR , proc_pid_limits), +NOD ("limits" ,S_IFREG |S_IRUSR |S_IWUSR ,NULL , + &proc_pid_limits_operations, + { .proc_read = proc_pid_limits }), #ifdef CONFIG_SCHED_DEBUG REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations), #endif
@@ -2836,7 +2908,9 @@ static const struct pid_entry tid_base_stuff[] = {INF ("auxv" ,S_IRUSR , proc_pid_auxv),ONE ("status" ,S_IRUGO , proc_pid_status),ONE ("personality" ,S_IRUSR , proc_pid_personality), -INF ("limits" ,S_IRUSR , proc_pid_limits), +NOD ("limits" ,S_IFREG |S_IRUSR |S_IWUSR ,NULL , + &proc_pid_limits_operations, + { .proc_read = proc_pid_limits }), #ifdef CONFIG_SCHED_DEBUG REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations), #endif
Signature · 1 line
1.6.4.2