Skip to contentSkip to conversation

seccomp: fix up grammar in comment

PATCH In review Tycho Andersen 4 participants 13 messages Mar 6, 2019 – Apr 24, 2019

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/2 seccomp: fix up grammar in comment

This sentence is kind of a train wreck anyway, but at least dropping the extra pronoun helps somewhat.

---
 kernel/seccomp.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/seccomp.c +1 -1
index e815781ed751..d0d355ded2f4 100644
@@ -329,7 +329,7 @@ static int is_ancestor(struct seccomp_filter *parent,
  * Expects sighand and cred_guard_mutex locks to be held.
  *
  * Returns 0 on success, -ve on error, or the pid of a thread which was
- * either not in the correct seccomp mode or it did not have an ancestral
+ * either not in the correct seccomp mode or did not have an ancestral
  * seccomp filter.
  */
 static inline pid_t seccomp_can_sync_threads(void)
Signature · 1 line
2.19.1
#1 lore raw

PATCH 2/2 seccomp: disallow NEW_LISTENER and TSYNC flags

As the comment notes, the return codes for TSYNC and NEW_LISTENER conflict, because they both return positive values, one in the case of success and one in the case of error. So, let's disallow both of these flags together.

While this is technically a userspace break, all the users I know of are still waiting on me to land this feature in libseccomp, so I think it'll be safe. Also, at present my use case doesn't require TSYNC at all, so this isn't a big deal to disallow. If someone wanted to support this, a path forward would be to add a new flag like TSYNC_AND_LISTENER_YES_I_UNDERSTAND_THAT_TSYNC_WILL_JUST_RETURN_EAGAIN, but the use cases are so different I don't see it really happening.

Finally, it's worth noting that this does actually fix a UAF issue: at the end of seccomp_set_mode_filter(), we have:

        if (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER) {
                if (ret < 0) {
                        listener_f->private_data = NULL;
                        fput(listener_f);
                        put_unused_fd(listener);
                } else {
                        fd_install(listener, listener_f);
                        ret = listener;
                }
        }
out_free:
        seccomp_filter_free(prepared);

But if ret > 0 because TSYNC raced, we'll install the listener fd and then free the filter out from underneath it, causing a UAF when the task closes it or dies. This patch also switches the condition to be simply if (ret), so that if someone does add the flag mentioned above, they won't have to remember to fix this too.

Fixes 6a21cc50f0c7 ("seccomp: add a return code to trap to userspace")
---
 kernel/seccomp.c | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)
kernel/seccomp.c +15 -2
index d0d355ded2f4..79bada51091b 100644
@@ -500,7 +500,10 @@ seccomp_prepare_user_filter(const char __user *user_filter)
  *
  * Caller must be holding current->sighand->siglock lock.
  *
- * Returns 0 on success, -ve on error.
+ * Returns 0 on success, -ve on error, or
+ *   - in TSYNC mode: the pid of a thread which was either not in the correct
+ *     seccomp mode or did not have an ancestral seccomp filter
+ *   - in NEW_LISTENER mode: the fd of the new listener
  */
 static long seccomp_attach_filter(unsigned int flags,
 				  struct seccomp_filter *filter)
@@ -1256,6 +1259,16 @@ static long seccomp_set_mode_filter(unsigned int flags,
 	if (flags & ~SECCOMP_FILTER_FLAG_MASK)
 		return -EINVAL;
 
+	/*
+	 * In the successful case, NEW_LISTENER returns the new listener fd.
+	 * But in the failure case, TSYNC returns the thread that died. If you
+	 * combine these two flags, there's no way to tell whether something
+	 * succeded or failed. So, let's disallow this combination.
+	 */
+	if ((flags & SECCOMP_FILTER_FLAG_TSYNC) &&
+	    (flags && SECCOMP_FILTER_FLAG_NEW_LISTENER))
+		return -EINVAL;
+
 	/* Prepare the new filter before holding any locks. */
 	prepared = seccomp_prepare_user_filter(filter);
 	if (IS_ERR(prepared))
@@ -1302,7 +1315,7 @@ static long seccomp_set_mode_filter(unsigned int flags,
 		mutex_unlock(&current->signal->cred_guard_mutex);
 out_put_fd:
 	if (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER) {
-		if (ret < 0) {
+		if (ret) {
 			listener_f->private_data = NULL;
 			fput(listener_f);
 			put_unused_fd(listener);
Signature · 1 line
2.19.1
Acked-by on v1 2/2
#2 lore raw

Re: [PATCH 2/2] seccomp: disallow NEW_LISTENER and TSYNC flags

Quoted 60 lines · Tycho Andersen

As the comment notes, the return codes for TSYNC and NEW_LISTENER conflict, because they both return positive values, one in the case of success and one in the case of error. So, let's disallow both of these flags together.

While this is technically a userspace break, all the users I know of are still waiting on me to land this feature in libseccomp, so I think it'll be safe. Also, at present my use case doesn't require TSYNC at all, so this isn't a big deal to disallow. If someone wanted to support this, a path forward would be to add a new flag like TSYNC_AND_LISTENER_YES_I_UNDERSTAND_THAT_TSYNC_WILL_JUST_RETURN_EAGAIN, but the use cases are so different I don't see it really happening.

Finally, it's worth noting that this does actually fix a UAF issue: at the end of seccomp_set_mode_filter(), we have:

        if (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER) {
                if (ret < 0) {
                        listener_f->private_data = NULL;
                        fput(listener_f);
                        put_unused_fd(listener);
                } else {
                        fd_install(listener, listener_f);
                        ret = listener;
                }
        }
out_free:
        seccomp_filter_free(prepared);

But if ret > 0 because TSYNC raced, we'll install the listener fd and then free the filter out from underneath it, causing a UAF when the task closes it or dies. This patch also switches the condition to be simply if (ret), so that if someone does add the flag mentioned above, they won't have to remember to fix this too.

Fixes 6a21cc50f0c7 ("seccomp: add a return code to trap to userspace")
---
 kernel/seccomp.c | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)
kernel/seccomp.c +4 -1
index d0d355ded2f4..79bada51091b 100644
@@ -500,7 +500,10 @@ seccomp_prepare_user_filter(const char __user *user_filter)
  *
  * Caller must be holding current->sighand->siglock lock.
  *
- * Returns 0 on success, -ve on error.
+ * Returns 0 on success, -ve on error, or
+ *   - in TSYNC mode: the pid of a thread which was either not in the correct
+ *     seccomp mode or did not have an ancestral seccomp filter
+ *   - in NEW_LISTENER mode: the fd of the new listener
  */
 static long seccomp_attach_filter(unsigned int flags,
 				  struct seccomp_filter *filter)
@@ -1256,6 +1259,16 @@ static long seccomp_set_mode_filter(unsigned int flags,
 	if (flags & ~SECCOMP_FILTER_FLAG_MASK)
 		return -EINVAL;

kernel/seccomp.c static long seccomp_set_mode_filter(unsigned int flags, · line 1270

Quoted 10 lines
kernel/seccomp.c +9 -0
 
+	/*
+	 * In the successful case, NEW_LISTENER returns the new listener fd.
+	 * But in the failure case, TSYNC returns the thread that died. If you
+	 * combine these two flags, there's no way to tell whether something
+	 * succeded or failed. So, let's disallow this combination.
+	 */
+	if ((flags & SECCOMP_FILTER_FLAG_TSYNC) &&
+	    (flags && SECCOMP_FILTER_FLAG_NEW_LISTENER))
+		return -EINVAL;

May license a manpage entry that this makes it potentially unsafe to use with multiple threads. But I don't see a use-case for this right now so it looks sane to me. :)

(Though one simple question below.)

kernel/seccomp.c static long seccomp_set_mode_filter(unsigned int flags, · line 1318

Quoted 10 lines
kernel/seccomp.c +2 -1
+
 	/* Prepare the new filter before holding any locks. */
 	prepared = seccomp_prepare_user_filter(filter);
 	if (IS_ERR(prepared))
@@ -1302,7 +1315,7 @@ static long seccomp_set_mode_filter(unsigned int flags,
 		mutex_unlock(&current->signal->cred_guard_mutex);
 out_put_fd:
 	if (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER) {
-		if (ret < 0) {
+		if (ret) {

Why that change but keep checking if (ret < 0) further up?

Quoted 6 lines
kernel/seccomp.c +0 -0
 			listener_f->private_data = NULL;
 			fput(listener_f);
 			put_unused_fd(listener);
Signature · 1 line
2.19.1
#3 lore raw

Re: [PATCH 2/2] seccomp: disallow NEW_LISTENER and TSYNC flags

Quoted 4 lines · Christian Brauner
Quoted 4 lines
kernel/seccomp.c +1 -0
+
 	/* Prepare the new filter before holding any locks. */
 	prepared = seccomp_prepare_user_filter(filter);
 	if (IS_ERR(prepared))
Quoted 8 lines

kernel/seccomp.c static long seccomp_set_mode_filter(unsigned int flags, · line 1318

Quoted 6 lines
kernel/seccomp.c +1 -1
@@ -1302,7 +1315,7 @@ static long seccomp_set_mode_filter(unsigned int flags,
 		mutex_unlock(&current->signal->cred_guard_mutex);
 out_put_fd:
 	if (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER) {
-		if (ret < 0) {
+		if (ret) {

Why that change but keep checking if (ret < 0) further up?

Not sure what you mean here. The only other place I see that we check something is < 0 in that function is the return value of get_unused_fd_flags(), which looks right to me?

Tycho

#4 lore raw

Re: [PATCH 2/2] seccomp: disallow NEW_LISTENER and TSYNC flags

Quoted 15 lines · Tycho Andersen
Quoted 4 lines · Christian Brauner
Quoted 4 lines

+

    /* Prepare the new filter before holding any locks. */
    prepared = seccomp_prepare_user_filter(filter);
    if (IS_ERR(prepared))
Quoted 8 lines

kernel/seccomp.c static long seccomp_set_mode_filter(unsigned int flags, · line 1318

Quoted 6 lines
kernel/seccomp.c +1 -1
@@ -1302,7 +1315,7 @@ static long seccomp_set_mode_filter(unsigned int flags,
            mutex_unlock(&current->signal->cred_guard_mutex);
 out_put_fd:
    if (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER) {
-           if (ret < 0) {
+           if (ret) {

Why that change but keep checking if (ret < 0) further up?

Quoted 3 lines

Not sure what you mean here. The only other place I see that we check something is < 0 in that function is the return value of get_unused_fd_flags(), which looks right to me?

The change just seemed it had nothing to do with the rest of the patch. Just making sure this didn't happen on accident and would cause regressions.

#5 lore raw

Re: [PATCH 2/2] seccomp: disallow NEW_LISTENER and TSYNC flags

Quoted 16 lines · Christian Brauner
Quoted 15 lines · Tycho Andersen
Quoted 12 lines · Christian Brauner

kernel/seccomp.c static long seccomp_set_mode_filter(unsigned int flags, · line 1318

Quoted 10 lines
kernel/seccomp.c +2 -1
+
    /* Prepare the new filter before holding any locks. */
    prepared = seccomp_prepare_user_filter(filter);
    if (IS_ERR(prepared))
@@ -1302,7 +1315,7 @@ static long seccomp_set_mode_filter(unsigned int flags,
            mutex_unlock(&current->signal->cred_guard_mutex);
 out_put_fd:
    if (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER) {
-           if (ret < 0) {
+           if (ret) {

Why that change but keep checking if (ret < 0) further up?

Quoted 6 lines
Quoted 3 lines

Not sure what you mean here. The only other place I see that we check something is < 0 in that function is the return value of get_unused_fd_flags(), which looks right to me?

The change just seemed it had nothing to do with the rest of the patch. Just making sure this didn't happen on accident and would cause regressions.

No, not on accident :). See the second half of the patch notes.

I can split it out into two separate patches if that makes more sense. In fact this hunk alone fixes the UAF, but you still get non-sensical return results even if it doesn't do anything terrible, hence the first hunk.

Cheers,

Tycho

Acked-by on v1 2/2
#6 lore raw

Re: [PATCH 2/2] seccomp: disallow NEW_LISTENER and TSYNC flags

In reply to Tycho Andersen
Quoted 35 lines · Tycho Andersen

As the comment notes, the return codes for TSYNC and NEW_LISTENER conflict, because they both return positive values, one in the case of success and one in the case of error. So, let's disallow both of these flags together.

While this is technically a userspace break, all the users I know of are still waiting on me to land this feature in libseccomp, so I think it'll be safe. Also, at present my use case doesn't require TSYNC at all, so this isn't a big deal to disallow. If someone wanted to support this, a path forward would be to add a new flag like TSYNC_AND_LISTENER_YES_I_UNDERSTAND_THAT_TSYNC_WILL_JUST_RETURN_EAGAIN, but the use cases are so different I don't see it really happening.

Finally, it's worth noting that this does actually fix a UAF issue: at the end of seccomp_set_mode_filter(), we have:

        if (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER) {
                if (ret < 0) {
                        listener_f->private_data = NULL;
                        fput(listener_f);
                        put_unused_fd(listener);
                } else {
                        fd_install(listener, listener_f);
                        ret = listener;
                }
        }
out_free:
        seccomp_filter_free(prepared);

But if ret > 0 because TSYNC raced, we'll install the listener fd and then free the filter out from underneath it, causing a UAF when the task closes it or dies. This patch also switches the condition to be simply if (ret), so that if someone does add the flag mentioned above, they won't have to remember to fix this too.

Quoted 3 lines
Fixes 6a21cc50f0c7 ("seccomp: add a return code to trap to userspace")

Thanks! Sorry I missed this. James, can you take this for Linus's fixes for v5.1? (Or should I send a pull request to you?)

Let's also add:

Reported-by [email protected]
Quoted 21 lines
---
 kernel/seccomp.c | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)
kernel/seccomp.c +4 -1
index d0d355ded2f4..79bada51091b 100644
@@ -500,7 +500,10 @@ seccomp_prepare_user_filter(const char __user *user_filter)
  *
  * Caller must be holding current->sighand->siglock lock.
  *
- * Returns 0 on success, -ve on error.
+ * Returns 0 on success, -ve on error, or
+ *   - in TSYNC mode: the pid of a thread which was either not in the correct
+ *     seccomp mode or did not have an ancestral seccomp filter
+ *   - in NEW_LISTENER mode: the fd of the new listener
  */
 static long seccomp_attach_filter(unsigned int flags,
                                  struct seccomp_filter *filter)

kernel/seccomp.c static long seccomp_set_mode_filter(unsigned int flags, · line 1266

Quoted 8 lines
kernel/seccomp.c +5 -0
@@ -1256,6 +1259,16 @@ static long seccomp_set_mode_filter(unsigned int flags,
        if (flags & ~SECCOMP_FILTER_FLAG_MASK)
                return -EINVAL;
 
+       /*
+        * In the successful case, NEW_LISTENER returns the new listener fd.
+        * But in the failure case, TSYNC returns the thread that died. If you
+        * combine these two flags, there's no way to tell whether something
+        * succeded or failed. So, let's disallow this combination.

also a tiny typo: succeeded

Quoted 18 lines
kernel/seccomp.c +6 -2
+        */
+       if ((flags & SECCOMP_FILTER_FLAG_TSYNC) &&
+           (flags && SECCOMP_FILTER_FLAG_NEW_LISTENER))
+               return -EINVAL;
+
        /* Prepare the new filter before holding any locks. */
        prepared = seccomp_prepare_user_filter(filter);
        if (IS_ERR(prepared))
@@ -1302,7 +1315,7 @@ static long seccomp_set_mode_filter(unsigned int flags,
                mutex_unlock(&current->signal->cred_guard_mutex);
 out_put_fd:
        if (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER) {
-               if (ret < 0) {
+               if (ret) {
                        listener_f->private_data = NULL;
                        fput(listener_f);
                        put_unused_fd(listener);
--
Quoted 2 lines

2.19.1

-Kees

Signature · 1 line
Kees Cook
#7 lore raw

Re: [PATCH 2/2] seccomp: disallow NEW_LISTENER and TSYNC flags

Quoted 4 lines · Kees Cook

Thanks! Sorry I missed this. James, can you take this for Linus's fixes for v5.1? (Or should I send a pull request to you?)

These are standalone for v5.1 fixes currently so you can send them directly to Linus.

Quoted 61 lines

Let's also add:

Reported-by [email protected]
Quoted 21 lines
---
 kernel/seccomp.c | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)
kernel/seccomp.c +4 -1
index d0d355ded2f4..79bada51091b 100644
@@ -500,7 +500,10 @@ seccomp_prepare_user_filter(const char __user *user_filter)
  *
  * Caller must be holding current->sighand->siglock lock.
  *
- * Returns 0 on success, -ve on error.
+ * Returns 0 on success, -ve on error, or
+ *   - in TSYNC mode: the pid of a thread which was either not in the correct
+ *     seccomp mode or did not have an ancestral seccomp filter
+ *   - in NEW_LISTENER mode: the fd of the new listener
  */
 static long seccomp_attach_filter(unsigned int flags,
                                  struct seccomp_filter *filter)

kernel/seccomp.c static long seccomp_set_mode_filter(unsigned int flags, · line 1266

Quoted 8 lines
kernel/seccomp.c +5 -0
@@ -1256,6 +1259,16 @@ static long seccomp_set_mode_filter(unsigned int flags,
        if (flags & ~SECCOMP_FILTER_FLAG_MASK)
                return -EINVAL;
 
+       /*
+        * In the successful case, NEW_LISTENER returns the new listener fd.
+        * But in the failure case, TSYNC returns the thread that died. If you
+        * combine these two flags, there's no way to tell whether something
+        * succeded or failed. So, let's disallow this combination.

also a tiny typo: succeeded

Quoted 18 lines
kernel/seccomp.c +6 -2
+        */
+       if ((flags & SECCOMP_FILTER_FLAG_TSYNC) &&
+           (flags && SECCOMP_FILTER_FLAG_NEW_LISTENER))
+               return -EINVAL;
+
        /* Prepare the new filter before holding any locks. */
        prepared = seccomp_prepare_user_filter(filter);
        if (IS_ERR(prepared))
@@ -1302,7 +1315,7 @@ static long seccomp_set_mode_filter(unsigned int flags,
                mutex_unlock(&current->signal->cred_guard_mutex);
 out_put_fd:
        if (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER) {
-               if (ret < 0) {
+               if (ret) {
                        listener_f->private_data = NULL;
                        fput(listener_f);
                        put_unused_fd(listener);
--
Quoted 2 lines

2.19.1

-Kees

Signature · 2 lines
James Morris
<[email protected]>
#8 lore raw

Re: [PATCH 2/2] seccomp: disallow NEW_LISTENER and TSYNC flags

In reply to Kees Cook
Quoted 74 lines · Kees Cook
Quoted 35 lines · Tycho Andersen

As the comment notes, the return codes for TSYNC and NEW_LISTENER conflict, because they both return positive values, one in the case of success and one in the case of error. So, let's disallow both of these flags together.

While this is technically a userspace break, all the users I know of are still waiting on me to land this feature in libseccomp, so I think it'll be safe. Also, at present my use case doesn't require TSYNC at all, so this isn't a big deal to disallow. If someone wanted to support this, a path forward would be to add a new flag like TSYNC_AND_LISTENER_YES_I_UNDERSTAND_THAT_TSYNC_WILL_JUST_RETURN_EAGAIN, but the use cases are so different I don't see it really happening.

Finally, it's worth noting that this does actually fix a UAF issue: at the end of seccomp_set_mode_filter(), we have:

        if (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER) {
                if (ret < 0) {
                        listener_f->private_data = NULL;
                        fput(listener_f);
                        put_unused_fd(listener);
                } else {
                        fd_install(listener, listener_f);
                        ret = listener;
                }
        }
out_free:
        seccomp_filter_free(prepared);

But if ret > 0 because TSYNC raced, we'll install the listener fd and then free the filter out from underneath it, causing a UAF when the task closes it or dies. This patch also switches the condition to be simply if (ret), so that if someone does add the flag mentioned above, they won't have to remember to fix this too.

Quoted 3 lines
Fixes 6a21cc50f0c7 ("seccomp: add a return code to trap to userspace")

Thanks! Sorry I missed this. James, can you take this for Linus's fixes for v5.1? (Or should I send a pull request to you?)

Let's also add:

Reported-by [email protected]
Quoted 24 lines
---
 kernel/seccomp.c | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)
kernel/seccomp.c +4 -1
index d0d355ded2f4..79bada51091b 100644
@@ -500,7 +500,10 @@ seccomp_prepare_user_filter(const char __user *user_filter)
  *
  * Caller must be holding current->sighand->siglock lock.
  *
- * Returns 0 on success, -ve on error.
+ * Returns 0 on success, -ve on error, or
+ *   - in TSYNC mode: the pid of a thread which was either not in the correct
+ *     seccomp mode or did not have an ancestral seccomp filter
+ *   - in NEW_LISTENER mode: the fd of the new listener
  */
 static long seccomp_attach_filter(unsigned int flags,
                                  struct seccomp_filter *filter)
@@ -1256,6 +1259,16 @@ static long seccomp_set_mode_filter(unsigned int flags,
        if (flags & ~SECCOMP_FILTER_FLAG_MASK)
                return -EINVAL;
 
Quoted 11 lines

kernel/seccomp.c static long seccomp_set_mode_filter(unsigned int flags, · line 1266

Quoted 5 lines
kernel/seccomp.c +5 -0
+       /*
+        * In the successful case, NEW_LISTENER returns the new listener fd.
+        * But in the failure case, TSYNC returns the thread that died. If you
+        * combine these two flags, there's no way to tell whether something
+        * succeded or failed. So, let's disallow this combination.

also a tiny typo: succeeded

Quoted 3 lines
kernel/seccomp.c +3 -0
+        */
+       if ((flags & SECCOMP_FILTER_FLAG_TSYNC) &&
+           (flags && SECCOMP_FILTER_FLAG_NEW_LISTENER))

also a typo: && should be &

Quoted 22 lines
Quoted 15 lines
kernel/seccomp.c +3 -2
+               return -EINVAL;
+
        /* Prepare the new filter before holding any locks. */
        prepared = seccomp_prepare_user_filter(filter);
        if (IS_ERR(prepared))
@@ -1302,7 +1315,7 @@ static long seccomp_set_mode_filter(unsigned int flags,
                mutex_unlock(&current->signal->cred_guard_mutex);
 out_put_fd:
        if (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER) {
-               if (ret < 0) {
+               if (ret) {
                        listener_f->private_data = NULL;
                        fput(listener_f);
                        put_unused_fd(listener);
--
Quoted 2 lines

2.19.1

-Kees

--
Kees Cook

Signature · 1 line
Kees Cook
#9 lore raw

Re: [PATCH 2/2] seccomp: disallow NEW_LISTENER and TSYNC flags

Quoted 83 lines · Kees Cook
Quoted 82 lines · Kees Cook
Quoted 35 lines · Tycho Andersen

As the comment notes, the return codes for TSYNC and NEW_LISTENER conflict, because they both return positive values, one in the case of success and one in the case of error. So, let's disallow both of these flags together.

While this is technically a userspace break, all the users I know of are still waiting on me to land this feature in libseccomp, so I think it'll be safe. Also, at present my use case doesn't require TSYNC at all, so this isn't a big deal to disallow. If someone wanted to support this, a path forward would be to add a new flag like TSYNC_AND_LISTENER_YES_I_UNDERSTAND_THAT_TSYNC_WILL_JUST_RETURN_EAGAIN, but the use cases are so different I don't see it really happening.

Finally, it's worth noting that this does actually fix a UAF issue: at the end of seccomp_set_mode_filter(), we have:

        if (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER) {
                if (ret < 0) {
                        listener_f->private_data = NULL;
                        fput(listener_f);
                        put_unused_fd(listener);
                } else {
                        fd_install(listener, listener_f);
                        ret = listener;
                }
        }
out_free:
        seccomp_filter_free(prepared);

But if ret > 0 because TSYNC raced, we'll install the listener fd and then free the filter out from underneath it, causing a UAF when the task closes it or dies. This patch also switches the condition to be simply if (ret), so that if someone does add the flag mentioned above, they won't have to remember to fix this too.

Quoted 3 lines
Fixes 6a21cc50f0c7 ("seccomp: add a return code to trap to userspace")

Thanks! Sorry I missed this. James, can you take this for Linus's fixes for v5.1? (Or should I send a pull request to you?)

Let's also add:

Reported-by [email protected]
Quoted 21 lines
---
 kernel/seccomp.c | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)
kernel/seccomp.c +4 -1
index d0d355ded2f4..79bada51091b 100644
@@ -500,7 +500,10 @@ seccomp_prepare_user_filter(const char __user *user_filter)
  *
  * Caller must be holding current->sighand->siglock lock.
  *
- * Returns 0 on success, -ve on error.
+ * Returns 0 on success, -ve on error, or
+ *   - in TSYNC mode: the pid of a thread which was either not in the correct
+ *     seccomp mode or did not have an ancestral seccomp filter
+ *   - in NEW_LISTENER mode: the fd of the new listener
  */
 static long seccomp_attach_filter(unsigned int flags,
                                  struct seccomp_filter *filter)

kernel/seccomp.c static long seccomp_set_mode_filter(unsigned int flags, · line 1266

Quoted 8 lines
kernel/seccomp.c +5 -0
@@ -1256,6 +1259,16 @@ static long seccomp_set_mode_filter(unsigned int flags,
        if (flags & ~SECCOMP_FILTER_FLAG_MASK)
                return -EINVAL;
 
+       /*
+        * In the successful case, NEW_LISTENER returns the new listener fd.
+        * But in the failure case, TSYNC returns the thread that died. If you
+        * combine these two flags, there's no way to tell whether something
+        * succeded or failed. So, let's disallow this combination.

also a tiny typo: succeeded

Quoted 5 lines
Quoted 3 lines

kernel/seccomp.c static long seccomp_set_mode_filter(unsigned int flags, · line 1269

Quoted 3 lines
kernel/seccomp.c +3 -0
+        */
+       if ((flags & SECCOMP_FILTER_FLAG_TSYNC) &&
+           (flags && SECCOMP_FILTER_FLAG_NEW_LISTENER))

also a typo: && should be &

Oh, yes. Do you want me to send another version?

Tycho

#10 lore raw

Re: [PATCH 2/2] seccomp: disallow NEW_LISTENER and TSYNC flags

Quoted 85 lines · Tycho Andersen
Quoted 83 lines · Kees Cook
Quoted 82 lines · Kees Cook
Quoted 35 lines · Tycho Andersen

As the comment notes, the return codes for TSYNC and NEW_LISTENER conflict, because they both return positive values, one in the case of success and one in the case of error. So, let's disallow both of these flags together.

While this is technically a userspace break, all the users I know of are still waiting on me to land this feature in libseccomp, so I think it'll be safe. Also, at present my use case doesn't require TSYNC at all, so this isn't a big deal to disallow. If someone wanted to support this, a path forward would be to add a new flag like TSYNC_AND_LISTENER_YES_I_UNDERSTAND_THAT_TSYNC_WILL_JUST_RETURN_EAGAIN, but the use cases are so different I don't see it really happening.

Finally, it's worth noting that this does actually fix a UAF issue: at the end of seccomp_set_mode_filter(), we have:

        if (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER) {
                if (ret < 0) {
                        listener_f->private_data = NULL;
                        fput(listener_f);
                        put_unused_fd(listener);
                } else {
                        fd_install(listener, listener_f);
                        ret = listener;
                }
        }
out_free:
        seccomp_filter_free(prepared);

But if ret > 0 because TSYNC raced, we'll install the listener fd and then free the filter out from underneath it, causing a UAF when the task closes it or dies. This patch also switches the condition to be simply if (ret), so that if someone does add the flag mentioned above, they won't have to remember to fix this too.

Quoted 3 lines
Fixes 6a21cc50f0c7 ("seccomp: add a return code to trap to userspace")

Thanks! Sorry I missed this. James, can you take this for Linus's fixes for v5.1? (Or should I send a pull request to you?)

Let's also add:

Reported-by [email protected]
Quoted 21 lines
---
 kernel/seccomp.c | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)
kernel/seccomp.c +4 -1
index d0d355ded2f4..79bada51091b 100644
@@ -500,7 +500,10 @@ seccomp_prepare_user_filter(const char __user *user_filter)
  *
  * Caller must be holding current->sighand->siglock lock.
  *
- * Returns 0 on success, -ve on error.
+ * Returns 0 on success, -ve on error, or
+ *   - in TSYNC mode: the pid of a thread which was either not in the correct
+ *     seccomp mode or did not have an ancestral seccomp filter
+ *   - in NEW_LISTENER mode: the fd of the new listener
  */
 static long seccomp_attach_filter(unsigned int flags,
                                  struct seccomp_filter *filter)

kernel/seccomp.c static long seccomp_set_mode_filter(unsigned int flags, · line 1266

Quoted 8 lines
kernel/seccomp.c +5 -0
@@ -1256,6 +1259,16 @@ static long seccomp_set_mode_filter(unsigned int flags,
        if (flags & ~SECCOMP_FILTER_FLAG_MASK)
                return -EINVAL;
 
+       /*
+        * In the successful case, NEW_LISTENER returns the new listener fd.
+        * But in the failure case, TSYNC returns the thread that died. If you
+        * combine these two flags, there's no way to tell whether something
+        * succeded or failed. So, let's disallow this combination.

also a tiny typo: succeeded

Quoted 7 lines
Quoted 5 lines
Quoted 3 lines

kernel/seccomp.c static long seccomp_set_mode_filter(unsigned int flags, · line 1269

Quoted 3 lines
kernel/seccomp.c +3 -0
+        */
+       if ((flags & SECCOMP_FILTER_FLAG_TSYNC) &&
+           (flags && SECCOMP_FILTER_FLAG_NEW_LISTENER))

also a typo: && should be &

Oh, yes. Do you want me to send another version?

Nah, I fixed it up. :)

Signature · 1 line
Kees Cook
Acked-by on v1 1/2
#11 lore raw
In reply to Tycho Andersen
Quoted 5 lines · Tycho Andersen

This sentence is kind of a train wreck anyway, but at least dropping the extra pronoun helps somewhat.

James, this can go in for v5.2 -- no rush.

-Kees

Quoted 20 lines
---
 kernel/seccomp.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/seccomp.c +1 -2
index e815781ed751..d0d355ded2f4 100644
@@ -329,7 +329,7 @@ static int is_ancestor(struct seccomp_filter *parent,
  * Expects sighand and cred_guard_mutex locks to be held.
  *
  * Returns 0 on success, -ve on error, or the pid of a thread which was
- * either not in the correct seccomp mode or it did not have an ancestral
+ * either not in the correct seccomp mode or did not have an ancestral
  * seccomp filter.
  */
 static inline pid_t seccomp_can_sync_threads(void)
--

2.19.1

Signature · 1 line
Kees Cook