Skip to contentSkip to conversation

seccomp: change return type of seccomp_get_metadata to int

PATCH In review Tycho Andersen 2 participants 9 messages Sep 28, 2018 Secure computing

lore
Share & tools
lore
#0 lore raw

PATCH 1/3 seccomp: change return type of seccomp_get_metadata to int

As Jann pointed out in another thread, ptrace_requiest() returns an int, so it makes sense for seccomp_get_metdata() to return an int as well. The return type of seccomp_get_metadata() is bounded by sizeof(kmd), so this conversion is safe.

---
 include/linux/seccomp.h | 10 +++++-----
 kernel/seccomp.c        |  6 +++---
 2 files changed, 8 insertions(+), 8 deletions(-)
include/linux/seccomp.h +5 -5
index e5320f6c8654..af972549a7b4 100644
@@ -96,17 +96,17 @@ static inline void get_seccomp_filter(struct task_struct *tsk)
 #if defined(CONFIG_SECCOMP_FILTER) && defined(CONFIG_CHECKPOINT_RESTORE)
 extern long seccomp_get_filter(struct task_struct *task,
 			       unsigned long filter_off, void __user *data);
-extern long seccomp_get_metadata(struct task_struct *task,
-				 unsigned long filter_off, void __user *data);
+extern int seccomp_get_metadata(struct task_struct *task,
+				unsigned long filter_off, void __user *data);
 #else
 static inline long seccomp_get_filter(struct task_struct *task,
 				      unsigned long n, void __user *data)
 {
 	return -EINVAL;
 }
-static inline long seccomp_get_metadata(struct task_struct *task,
-					unsigned long filter_off,
-					void __user *data)
+static inline int seccomp_get_metadata(struct task_struct *task,
+				       unsigned long filter_off,
+				       void __user *data)
 {
 	return -EINVAL;
 }
kernel/seccomp.c +3 -3
index fd023ac24e10..9f3721849747 100644
@@ -1068,10 +1068,10 @@ long seccomp_get_filter(struct task_struct *task, unsigned long filter_off,
 	return ret;
 }
 
-long seccomp_get_metadata(struct task_struct *task,
-			  unsigned long size, void __user *data)
+int seccomp_get_metadata(struct task_struct *task,
+			 unsigned long size, void __user *data)
 {
-	long ret;
+	int ret;
 	struct seccomp_filter *filter;
 	struct seccomp_metadata kmd = {};
 
Signature · 1 line
2.17.1
#1 lore raw

PATCH 2/3 seccomp: change return type of seccomp_get_filter to int

As Jann pointed out in another thread, ptrace_requiest() returns an int, so it makes sense for seccomp_get_filter() to return an int as well. The return type of seccomp_get_filter() is bounded by the BPF_MAXINSNS check in seccomp_prepare_filter(), so this conversion is safe.

---
 include/linux/seccomp.h | 6 +++---
 kernel/seccomp.c        | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)
include/linux/seccomp.h +3 -3
index af972549a7b4..8429bdda947a 100644
@@ -94,13 +94,13 @@ static inline void get_seccomp_filter(struct task_struct *tsk)
 #endif /* CONFIG_SECCOMP_FILTER */
 
 #if defined(CONFIG_SECCOMP_FILTER) && defined(CONFIG_CHECKPOINT_RESTORE)
-extern long seccomp_get_filter(struct task_struct *task,
+extern int seccomp_get_filter(struct task_struct *task,
 			       unsigned long filter_off, void __user *data);
 extern int seccomp_get_metadata(struct task_struct *task,
 				unsigned long filter_off, void __user *data);
 #else
-static inline long seccomp_get_filter(struct task_struct *task,
-				      unsigned long n, void __user *data)
+static inline int seccomp_get_filter(struct task_struct *task,
+				     unsigned long n, void __user *data)
 {
 	return -EINVAL;
 }
kernel/seccomp.c +3 -3
index 9f3721849747..ef80dd19f268 100644
@@ -1030,12 +1030,12 @@ static struct seccomp_filter *get_nth_filter(struct task_struct *task,
 	return filter;
 }
 
-long seccomp_get_filter(struct task_struct *task, unsigned long filter_off,
-			void __user *data)
+int seccomp_get_filter(struct task_struct *task, unsigned long filter_off,
+		       void __user *data)
 {
 	struct seccomp_filter *filter;
 	struct sock_fprog_kern *fprog;
-	long ret;
+	int ret;
 
 	if (!capable(CAP_SYS_ADMIN) ||
 	    current->seccomp.mode != SECCOMP_MODE_DISABLED) {
Signature · 1 line
2.17.1
#2 lore raw

PATCH 3/3 seccomp: introduce read protection for struct seccomp

In reply to Tycho Andersen

As Jann pointed out, there is a race between SECCOMP_FILTER_FLAG_TSYNC and the ptrace code that can inspect a filter of another process. Let's introduce read locking into the two ptrace accesses so that we don't race.

---
 include/linux/seccomp.h |  4 ++--
 kernel/seccomp.c        | 10 ++++++++++
 2 files changed, 12 insertions(+), 2 deletions(-)
include/linux/seccomp.h +2 -2
index 8429bdda947a..30b27e898162 100644
@@ -22,8 +22,8 @@ struct seccomp_filter;
  * @filter: must always point to a valid seccomp-filter or NULL as it is
  *          accessed without locking during system call entry.
  *
- *          @filter must only be accessed from the context of current as there
- *          is no read locking.
+ *          @filter is read-protected by task->signal->cred_guard_mutex when
+ *          outside of current context.
  */
 struct seccomp {
 	int mode;
kernel/seccomp.c +10 -0
index ef80dd19f268..f65d47650ac1 100644
@@ -1042,7 +1042,12 @@ int seccomp_get_filter(struct task_struct *task, unsigned long filter_off,
 		return -EACCES;
 	}
 
+	ret = mutex_lock_killable(&task->signal->cred_guard_mutex);
+	if (ret < 0)
+		return ret;
+
 	filter = get_nth_filter(task, filter_off);
+	mutex_unlock(&task->signal->cred_guard_mutex);
 	if (IS_ERR(filter))
 		return PTR_ERR(filter);
 
@@ -1088,7 +1093,12 @@ int seccomp_get_metadata(struct task_struct *task,
 	if (copy_from_user(&kmd.filter_off, data, sizeof(kmd.filter_off)))
 		return -EFAULT;
 
+	ret = mutex_lock_killable(&task->signal->cred_guard_mutex);
+	if (ret < 0)
+		return ret;
+
 	filter = get_nth_filter(task, kmd.filter_off);
+	mutex_unlock(&task->signal->cred_guard_mutex);
 	if (IS_ERR(filter))
 		return PTR_ERR(filter);
 
Signature · 1 line
2.17.1
#3 lore raw

Re: [PATCH 3/3] seccomp: introduce read protection for struct seccomp

Quoted 3 lines · Tycho Andersen

As Jann pointed out, there is a race between SECCOMP_FILTER_FLAG_TSYNC and the ptrace code that can inspect a filter of another process. Let's introduce read locking into the two ptrace accesses so that we don't race.

Hmm. Is that true? The ptrace code uses get_nth_filter(), which holds the siglock while grabbing the seccomp filter and bumping its refcount. And TSYNC happens from seccomp_set_mode_filter(), which takes the siglock. So this looks okay to me?

Quoted 57 lines
---
 include/linux/seccomp.h |  4 ++--
 kernel/seccomp.c        | 10 ++++++++++
 2 files changed, 12 insertions(+), 2 deletions(-)
include/linux/seccomp.h +2 -2
index 8429bdda947a..30b27e898162 100644
@@ -22,8 +22,8 @@ struct seccomp_filter;
  * @filter: must always point to a valid seccomp-filter or NULL as it is
  *          accessed without locking during system call entry.
  *
- *          @filter must only be accessed from the context of current as there
- *          is no read locking.
+ *          @filter is read-protected by task->signal->cred_guard_mutex when
+ *          outside of current context.
  */
 struct seccomp {
        int mode;
kernel/seccomp.c +10 -1
index ef80dd19f268..f65d47650ac1 100644
@@ -1042,7 +1042,12 @@ int seccomp_get_filter(struct task_struct *task, unsigned long filter_off,
                return -EACCES;
        }
 
+       ret = mutex_lock_killable(&task->signal->cred_guard_mutex);
+       if (ret < 0)
+               return ret;
+
        filter = get_nth_filter(task, filter_off);
+       mutex_unlock(&task->signal->cred_guard_mutex);
        if (IS_ERR(filter))
                return PTR_ERR(filter);
 
@@ -1088,7 +1093,12 @@ int seccomp_get_metadata(struct task_struct *task,
        if (copy_from_user(&kmd.filter_off, data, sizeof(kmd.filter_off)))
                return -EFAULT;
 
+       ret = mutex_lock_killable(&task->signal->cred_guard_mutex);
+       if (ret < 0)
+               return ret;
+
        filter = get_nth_filter(task, kmd.filter_off);
+       mutex_unlock(&task->signal->cred_guard_mutex);
        if (IS_ERR(filter))
                return PTR_ERR(filter);
 
--

2.17.1

#4 lore raw

Re: [PATCH 3/3] seccomp: introduce read protection for struct seccomp

Quoted 9 lines · Jann Horn
Quoted 3 lines · Tycho Andersen

As Jann pointed out, there is a race between SECCOMP_FILTER_FLAG_TSYNC and the ptrace code that can inspect a filter of another process. Let's introduce read locking into the two ptrace accesses so that we don't race.

Hmm. Is that true? The ptrace code uses get_nth_filter(), which holds the siglock while grabbing the seccomp filter and bumping its refcount. And TSYNC happens from seccomp_set_mode_filter(), which takes the siglock. So this looks okay to me?

Oh, yes, you're right. So I guess we should just change the comment to say we're using siglock to represent the read lock.

Tycho

#5 lore raw

Re: [PATCH 3/3] seccomp: introduce read protection for struct seccomp

Quoted 7 lines · Tycho Andersen
Quoted 5 lines · Jann Horn
Quoted 3 lines · Tycho Andersen

As Jann pointed out, there is a race between SECCOMP_FILTER_FLAG_TSYNC and the ptrace code that can inspect a filter of another process. Let's introduce read locking into the two ptrace accesses so that we don't race.

Quoted 7 lines
Quoted 4 lines

Hmm. Is that true? The ptrace code uses get_nth_filter(), which holds the siglock while grabbing the seccomp filter and bumping its refcount. And TSYNC happens from seccomp_set_mode_filter(), which takes the siglock. So this looks okay to me?

Oh, yes, you're right. So I guess we should just change the comment to say we're using siglock to represent the read lock.

Hmm... actually, looking at this closer, I think you only need the siglock for writing. As far as I can tell, any read (no matter if current or non-current) can just use READ_ONCE(), because once a seccomp filter is in a task's seccomp filter chain, it can't be freed until the task reaches free_task() and calls put_seccomp_filter() from there. And if the task whose seccomp filter you're trying to read can reach free_task(), you have bigger problems.

#6 lore raw

Re: [PATCH 3/3] seccomp: introduce read protection for struct seccomp

Quoted 16 lines · Jann Horn
Quoted 7 lines · Tycho Andersen
Quoted 5 lines · Jann Horn
Quoted 3 lines · Tycho Andersen

As Jann pointed out, there is a race between SECCOMP_FILTER_FLAG_TSYNC and the ptrace code that can inspect a filter of another process. Let's introduce read locking into the two ptrace accesses so that we don't race.

Quoted 7 lines
Quoted 4 lines

Hmm. Is that true? The ptrace code uses get_nth_filter(), which holds the siglock while grabbing the seccomp filter and bumping its refcount. And TSYNC happens from seccomp_set_mode_filter(), which takes the siglock. So this looks okay to me?

Oh, yes, you're right. So I guess we should just change the comment to say we're using siglock to represent the read lock.

Quoted 7 lines

Hmm... actually, looking at this closer, I think you only need the siglock for writing. As far as I can tell, any read (no matter if current or non-current) can just use READ_ONCE(), because once a seccomp filter is in a task's seccomp filter chain, it can't be freed until the task reaches free_task() and calls put_seccomp_filter() from there. And if the task whose seccomp filter you're trying to read can reach free_task(), you have bigger problems.

Ok; looks like get_nth_filter() took the siglock anyway. Since we get the filters in these two functions in get_nth_filter(), I think it's enough just to just,

kernel/seccomp.c +1 -1
index f65d47650ac1..79d833ed4c34 100644
@@ -1001,7 +1001,7 @@ static struct seccomp_filter *get_nth_filter(struct task_struct *task,
 		return ERR_PTR(-EINVAL);
 	}
 
-	orig = task->seccomp.filter;
+	orig = READ_ONCE(task->seccomp.filter);
 	__get_seccomp_filter(orig);
 	spin_unlock_irq(&task->sighand->siglock);
 

since once it's returned from get_nth_filter() we don't need to worry about multiple accesses?

Tycho

#7 lore raw

Re: [PATCH 3/3] seccomp: introduce read protection for struct seccomp

Quoted 34 lines · Tycho Andersen
Quoted 16 lines · Jann Horn
Quoted 7 lines · Tycho Andersen
Quoted 5 lines · Jann Horn
Quoted 3 lines · Tycho Andersen

As Jann pointed out, there is a race between SECCOMP_FILTER_FLAG_TSYNC and the ptrace code that can inspect a filter of another process. Let's introduce read locking into the two ptrace accesses so that we don't race.

Quoted 7 lines
Quoted 4 lines

Hmm. Is that true? The ptrace code uses get_nth_filter(), which holds the siglock while grabbing the seccomp filter and bumping its refcount. And TSYNC happens from seccomp_set_mode_filter(), which takes the siglock. So this looks okay to me?

Oh, yes, you're right. So I guess we should just change the comment to say we're using siglock to represent the read lock.

Quoted 7 lines

Hmm... actually, looking at this closer, I think you only need the siglock for writing. As far as I can tell, any read (no matter if current or non-current) can just use READ_ONCE(), because once a seccomp filter is in a task's seccomp filter chain, it can't be freed until the task reaches free_task() and calls put_seccomp_filter() from there. And if the task whose seccomp filter you're trying to read can reach free_task(), you have bigger problems.

Ok; looks like get_nth_filter() took the siglock anyway. Since we get the filters in these two functions in get_nth_filter(), I think it's enough just to just,

kernel/seccomp.c +0 -0
index f65d47650ac1..79d833ed4c34 100644

kernel/seccomp.c static struct seccomp_filter *get_nth_filter(struct task_struct *task, · line 1006

Quoted 7 lines
kernel/seccomp.c +1 -1
@@ -1001,7 +1001,7 @@ static struct seccomp_filter *get_nth_filter(struct task_struct *task,
                return ERR_PTR(-EINVAL);
        }
 
-       orig = task->seccomp.filter;
+       orig = READ_ONCE(task->seccomp.filter);
        __get_seccomp_filter(orig);
        spin_unlock_irq(&task->sighand->siglock);

Huh? Now you're holding the siglock *and* you're using READ_ONCE()? I'm not sure what you're trying to accomplish here.

Quoted 4 lines

since once it's returned from get_nth_filter() we don't need to worry about multiple accesses?

Tycho

#8 lore raw

Re: [PATCH 3/3] seccomp: introduce read protection for struct seccomp

Quoted 38 lines · Jann Horn
Quoted 37 lines · Tycho Andersen
Quoted 16 lines · Jann Horn
Quoted 7 lines · Tycho Andersen
Quoted 5 lines · Jann Horn
Quoted 3 lines · Tycho Andersen

As Jann pointed out, there is a race between SECCOMP_FILTER_FLAG_TSYNC and the ptrace code that can inspect a filter of another process. Let's introduce read locking into the two ptrace accesses so that we don't race.

Quoted 7 lines
Quoted 4 lines

Hmm. Is that true? The ptrace code uses get_nth_filter(), which holds the siglock while grabbing the seccomp filter and bumping its refcount. And TSYNC happens from seccomp_set_mode_filter(), which takes the siglock. So this looks okay to me?

Oh, yes, you're right. So I guess we should just change the comment to say we're using siglock to represent the read lock.

Quoted 7 lines

Hmm... actually, looking at this closer, I think you only need the siglock for writing. As far as I can tell, any read (no matter if current or non-current) can just use READ_ONCE(), because once a seccomp filter is in a task's seccomp filter chain, it can't be freed until the task reaches free_task() and calls put_seccomp_filter() from there. And if the task whose seccomp filter you're trying to read can reach free_task(), you have bigger problems.

Ok; looks like get_nth_filter() took the siglock anyway. Since we get the filters in these two functions in get_nth_filter(), I think it's enough just to just,

kernel/seccomp.c +0 -0
index f65d47650ac1..79d833ed4c34 100644
@@ -1001,7 +1001,7 @@ static struct seccomp_filter *get_nth_filter(struct task_struct *task,
                return ERR_PTR(-EINVAL);
        }
 
Quoted 7 lines

kernel/seccomp.c static struct seccomp_filter *get_nth_filter(struct task_struct *task, · line 1006

Quoted 4 lines
kernel/seccomp.c +1 -1
-       orig = task->seccomp.filter;
+       orig = READ_ONCE(task->seccomp.filter);
        __get_seccomp_filter(orig);
        spin_unlock_irq(&task->sighand->siglock);

Huh? Now you're holding the siglock *and* you're using READ_ONCE()? I'm not sure what you're trying to accomplish here.

Yes, let's just drop this patch all together.

Tycho