1 files changed, 86 insertions, 63 deletions

diff --git a/fs/exec.c b/fs/exec.c
index 9bd3559ddec..32f13e29941 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -55,6 +55,7 @@
 #include <asm/uaccess.h>
 #include <asm/mmu_context.h>
 #include <asm/tlb.h>
+#include "internal.h"
 
 #ifdef __alpha__
 /* for /sbin/loader handling in search_binary_handler() */
@@ -1007,15 +1008,17 @@ int flush_old_exec(struct linux_binprm * bprm)
          */
         current->mm->task_size = TASK_SIZE;
 
-        if (bprm->e_uid != current_euid() ||
-            bprm->e_gid != current_egid()) {
-                set_dumpable(current->mm, suid_dumpable);
+        /* install the new credentials */
+        if (bprm->cred->uid != current_euid() ||
+            bprm->cred->gid != current_egid()) {
                 current->pdeath_signal = 0;
         } else if (file_permission(bprm->file, MAY_READ) ||
-                        (bprm->interp_flags & BINPRM_FLAGS_ENFORCE_NONDUMP)) {
+                   bprm->interp_flags & BINPRM_FLAGS_ENFORCE_NONDUMP) {
                 set_dumpable(current->mm, suid_dumpable);
         }
 
+        current->personality &= ~bprm->per_clear;
+
         /* An exec changes our domain. We are no longer part of the thread
            group */
 
@@ -1032,13 +1035,50 @@ out:
 
 EXPORT_SYMBOL(flush_old_exec);
 
+/*
+ * install the new credentials for this executable
+ */
+void install_exec_creds(struct linux_binprm *bprm)
+{
+        security_bprm_committing_creds(bprm);
+
+        commit_creds(bprm->cred);
+        bprm->cred = NULL;
+
+        /* cred_exec_mutex must be held at least to this point to prevent
+         * ptrace_attach() from altering our determination of the task's
+         * credentials; any time after this it may be unlocked */
+
+        security_bprm_committed_creds(bprm);
+}
+EXPORT_SYMBOL(install_exec_creds);
+
+/*
+ * determine how safe it is to execute the proposed program
+ * - the caller must hold current->cred_exec_mutex to protect against
+ *   PTRACE_ATTACH
+ */
+void check_unsafe_exec(struct linux_binprm *bprm)
+{
+        struct task_struct *p = current;
+
+        bprm->unsafe = tracehook_unsafe_exec(p);
+
+        if (atomic_read(&p->fs->count) > 1 ||
+            atomic_read(&p->files->count) > 1 ||
+            atomic_read(&p->sighand->count) > 1)
+                bprm->unsafe |= LSM_UNSAFE_SHARE;
+}
+
 /* 
  * Fill the binprm structure from the inode. 
  * Check permissions, then read the first 128 (BINPRM_BUF_SIZE) bytes
+ *
+ * This may be called multiple times for binary chains (scripts for example).
  */
 int prepare_binprm(struct linux_binprm *bprm)
 {
-        int mode;
+        umode_t mode;
         struct inode * inode = bprm->file->f_path.dentry->d_inode;
         int retval;
 
@@ -1046,14 +1086,15 @@ int prepare_binprm(struct linux_binprm *bprm)
         if (bprm->file->f_op == NULL)
                 return -EACCES;
 
-        bprm->e_uid = current_euid();
-        bprm->e_gid = current_egid();
+        /* clear any previous set[ug]id data from a previous binary */
+        bprm->cred->euid = current_euid();
+        bprm->cred->egid = current_egid();
 
-        if(!(bprm->file->f_path.mnt->mnt_flags & MNT_NOSUID)) {
+        if (!(bprm->file->f_path.mnt->mnt_flags & MNT_NOSUID)) {
                 /* Set-uid? */
                 if (mode & S_ISUID) {
-                        current->personality &= ~PER_CLEAR_ON_SETID;
-                        bprm->e_uid = inode->i_uid;
+                        bprm->per_clear |= PER_CLEAR_ON_SETID;
+                        bprm->cred->euid = inode->i_uid;
                 }
 
                 /* Set-gid? */
@@ -1063,50 +1104,23 @@ int prepare_binprm(struct linux_binprm *bprm)
                  * executable.
                  */
                 if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
-                        current->personality &= ~PER_CLEAR_ON_SETID;
-                        bprm->e_gid = inode->i_gid;
+                        bprm->per_clear |= PER_CLEAR_ON_SETID;
+                        bprm->cred->egid = inode->i_gid;
                 }
         }
 
         /* fill in binprm security blob */
-        retval = security_bprm_set(bprm);
+        retval = security_bprm_set_creds(bprm);
         if (retval)
                 return retval;
+        bprm->cred_prepared = 1;
 
-        memset(bprm->buf,0,BINPRM_BUF_SIZE);
-        return kernel_read(bprm->file,0,bprm->buf,BINPRM_BUF_SIZE);
+        memset(bprm->buf, 0, BINPRM_BUF_SIZE);
+        return kernel_read(bprm->file, 0, bprm->buf, BINPRM_BUF_SIZE);
 }
 
 EXPORT_SYMBOL(prepare_binprm);
 
-static int unsafe_exec(struct task_struct *p)
-{
-        int unsafe = tracehook_unsafe_exec(p);
-
-        if (atomic_read(&p->fs->count) > 1 ||
-            atomic_read(&p->files->count) > 1 ||
-            atomic_read(&p->sighand->count) > 1)
-                unsafe |= LSM_UNSAFE_SHARE;
-
-        return unsafe;
-}
-
-void compute_creds(struct linux_binprm *bprm)
-{
-        int unsafe;
-
-        if (bprm->e_uid != current_uid())
-                current->pdeath_signal = 0;
-        exec_keys(current);
-
-        task_lock(current);
-        unsafe = unsafe_exec(current);
-        security_bprm_apply_creds(bprm, unsafe);
-        task_unlock(current);
-        security_bprm_post_apply_creds(bprm);
-}
-EXPORT_SYMBOL(compute_creds);
-
 /*
  * Arguments are '\0' separated strings found at the location bprm->p
  * points to; chop off the first by relocating brpm->p to right after
@@ -1259,6 +1273,8 @@ EXPORT_SYMBOL(search_binary_handler);
 void free_bprm(struct linux_binprm *bprm)
 {
         free_arg_pages(bprm);
+        if (bprm->cred)
+                abort_creds(bprm->cred);
         kfree(bprm);
 }
 
@@ -1284,10 +1300,20 @@ int do_execve(char * filename,
         if (!bprm)
                 goto out_files;
 
+        retval = mutex_lock_interruptible(&current->cred_exec_mutex);
+        if (retval < 0)
+                goto out_free;
+
+        retval = -ENOMEM;
+        bprm->cred = prepare_exec_creds();
+        if (!bprm->cred)
+                goto out_unlock;
+        check_unsafe_exec(bprm);
+
         file = open_exec(filename);
         retval = PTR_ERR(file);
         if (IS_ERR(file))
-                goto out_kfree;
+                goto out_unlock;
 
         sched_exec();
 
@@ -1301,14 +1327,10 @@ int do_execve(char * filename,
 
         bprm->argc = count(argv, MAX_ARG_STRINGS);
         if ((retval = bprm->argc) < 0)
-                goto out_mm;
+                goto out;
 
         bprm->envc = count(envp, MAX_ARG_STRINGS);
         if ((retval = bprm->envc) < 0)
-                goto out_mm;
-
-        retval = security_bprm_alloc(bprm);
-        if (retval)
                 goto out;
 
         retval = prepare_binprm(bprm);
@@ -1330,21 +1352,18 @@ int do_execve(char * filename,
 
         current->flags &= ~PF_KTHREAD;
         retval = search_binary_handler(bprm,regs);
-        if (retval >= 0) {
-                /* execve success */
-                security_bprm_free(bprm);
-                acct_update_integrals(current);
-                free_bprm(bprm);
-                if (displaced)
-                        put_files_struct(displaced);
-                return retval;
-        }
+        if (retval < 0)
+                goto out;
 
-out:
-        if (bprm->security)
-                security_bprm_free(bprm);
+        /* execve succeeded */
+        mutex_unlock(&current->cred_exec_mutex);
+        acct_update_integrals(current);
+        free_bprm(bprm);
+        if (displaced)
+                put_files_struct(displaced);
+        return retval;
 
-out_mm:
+out:
         if (bprm->mm)
                 mmput (bprm->mm);
 
@@ -1353,7 +1372,11 @@ out_file:
                 allow_write_access(bprm->file);
                 fput(bprm->file);
         }
-out_kfree:
+
+out_unlock:
+        mutex_unlock(&current->cred_exec_mutex);
+
+out_free:
         free_bprm(bprm);
 
 out_files: