UBUNTU: SAUCE: SECCOMP: seccomp: add SECCOMP_RET_ERRNO

This change adds the SECCOMP_RET_ERRNO as a valid return value from a
seccomp filter.  Additionally, it makes the first use of the lower
16-bits for storing a filter-supplied errno.  16-bits is more than
enough for the errno-base.h calls.

Returning errors instead of immediately terminating processes that
violate seccomp policy allow for broader use of this functionality
for kernel attack surface reduction.  For example, a linux container
could maintain a whitelist of pre-existing system calls but drop
all new ones with errnos.  This would keep a logically static attack
surface while providing errnos that may allow for graceful failure
without the downside of do_exit() on a bad call.

v15: - use audit_seccomp and add a skip label. (eparis@redhat.com)
     - clean up and pad out return codes (indan@nul.nu)
v14: - no change/rebase
v13: - rebase on to 88ebdda6159ffc15699f204c33feb3e431bf9bdc
v12: - move to WARN_ON if filter is NULL
       (oleg@redhat.com, luto@mit.edu, keescook@chromium.org)
     - return immediately for filter==NULL (keescook@chromium.org)
     - change evaluation to only compare the ACTION so that layered
       errnos don't result in the lowest one being returned.
       (keeschook@chromium.org)
v11: - check for NULL filter (keescook@chromium.org)
v10: - change loaders to fn
 v9: - n/a
 v8: - update Kconfig to note new need for syscall_set_return_value.
     - reordered such that TRAP behavior follows on later.
     - made the for loop a little less indent-y
 v7: - introduced

Reviewed-by: Kees Cook <keescook@chromium.org>
Acked-by: Serge Hallyn <serge.hallyn@canonical.com>
Signed-off-by: Will Drewry <wad@chromium.org>
Signed-off-by: Kees Cook <kees@ubuntu.com>

diff --git a/arch/Kconfig b/arch/Kconfig
index 2110f7f..aded1e6 100644 (file)
--- a/arch/Kconfig
+++ b/arch/Kconfig
@@ -185,8 +185,10 @@ config HAVE_ARCH_SECCOMP_FILTER
        bool
        help
          This symbol should be selected by an architecure if it provides
-         asm/syscall.h, specifically syscall_get_arguments() and
-         syscall_get_arch().
+         asm/syscall.h, specifically syscall_get_arguments(),
+         syscall_get_arch(), and syscall_set_return_value().  Additionally,
+         its system call entry path must respect a return value of -1 from
+         __secure_computing_int() and/or secure_computing().
 
 config SECCOMP_FILTER
        def_bool y

diff --git a/include/linux/seccomp.h b/include/linux/seccomp.h
index ce980a8..12bb2e3 100644 (file)
--- a/include/linux/seccomp.h
+++ b/include/linux/seccomp.h
@@ -12,13 +12,14 @@
 
 /*
  * All BPF programs must return a 32-bit value.
- * The bottom 16-bits are reserved for future use.
+ * The bottom 16-bits are for optional return data.
  * The upper 16-bits are ordered from least permissive values to most.
  *
  * The ordering ensures that a min_t() over composed return values always
  * selects the least permissive choice.
  */
 #define SECCOMP_RET_KILL       0x00000000U /* kill the task immediately */
+#define SECCOMP_RET_ERRNO      0x00050000U /* returns an errno */
 #define SECCOMP_RET_ALLOW      0x7fff0000U /* allow */
 
 /* Masks for the return value sections. */
@@ -64,11 +65,17 @@ struct seccomp {
        struct seccomp_filter *filter;
 };
 
-extern void __secure_computing(int);
-static inline void secure_computing(int this_syscall)
+/*
+ * Direct callers to __secure_computing should be updated as
+ * CONFIG_HAVE_ARCH_SECCOMP_FILTER propagates.
+ */
+extern void __secure_computing(int) __deprecated;
+extern int __secure_computing_int(int);
+static inline int secure_computing(int this_syscall)
 {
        if (unlikely(test_thread_flag(TIF_SECCOMP)))
-               __secure_computing(this_syscall);
+               return  __secure_computing_int(this_syscall);
+       return 0;
 }
 
 extern long prctl_get_seccomp(void);

diff --git a/kernel/seccomp.c b/kernel/seccomp.c
index 7d933d3..4293396 100644 (file)
--- a/kernel/seccomp.c
+++ b/kernel/seccomp.c
@@ -197,15 +197,20 @@ static int seccomp_chk_filter(struct sock_filter *filter, unsigned int flen)
 static u32 seccomp_run_filters(int syscall)
 {
        struct seccomp_filter *f;
-       u32 ret = SECCOMP_RET_KILL;
+       u32 ret = SECCOMP_RET_ALLOW;
+
+       /* Ensure unexpected behavior doesn't result in failing open. */
+       if (WARN_ON(current->seccomp.filter == NULL))
+               return SECCOMP_RET_KILL;
+
        /*
         * All filters are evaluated in order of youngest to oldest. The lowest
-        * BPF return value always takes priority.
+        * BPF return value (ignoring the DATA) always takes priority.
         */
        for (f = current->seccomp.filter; f; f = f->prev) {
-               ret = sk_run_filter(NULL, f->insns);
-               if (ret != SECCOMP_RET_ALLOW)
-                       break;
+               u32 cur_ret = sk_run_filter(NULL, f->insns);
+               if ((cur_ret & SECCOMP_RET_ACTION) < (ret & SECCOMP_RET_ACTION))
+                       ret = cur_ret;
        }
        return ret;
 }
@@ -345,9 +350,18 @@ static int mode1_syscalls_32[] = {
 
 void __secure_computing(int this_syscall)
 {
+       /* Filter calls should never use this function. */
+       BUG_ON(current->seccomp.mode == SECCOMP_MODE_FILTER);
+       __secure_computing_int(this_syscall);
+}
+
+int __secure_computing_int(int this_syscall)
+{
        int mode = current->seccomp.mode;
        int exit_sig = 0;
        int *syscall;
+       u32 ret = SECCOMP_RET_KILL;
+       int data;
 
        switch (mode) {
        case SECCOMP_MODE_STRICT:
@@ -358,14 +372,26 @@ void __secure_computing(int this_syscall)
 #endif
                do {
                        if (*syscall == this_syscall)
-                               return;
+                               return 0;
                } while (*++syscall);
                exit_sig = SIGKILL;
                break;
 #ifdef CONFIG_SECCOMP_FILTER
        case SECCOMP_MODE_FILTER:
-               if (seccomp_run_filters(this_syscall) == SECCOMP_RET_ALLOW)
-                       return;
+               ret = seccomp_run_filters(this_syscall);
+               data = ret & SECCOMP_RET_DATA;
+               switch (code & SECCOMP_RET_ACTION) {
+               case SECCOMP_RET_ERRNO:
+                       /* Set the low-order 16-bits as a errno. */
+                       syscall_set_return_value(current, task_pt_regs(current),
+                                                -data, 0);
+                       goto skip;
+               case SECCOMP_RET_ALLOW:
+                       return 0;
+               case SECCOMP_RET_KILL:
+               default:
+                       break;
+               }
                exit_sig = SIGSYS;
                break;
 #endif
@@ -376,8 +402,11 @@ void __secure_computing(int this_syscall)
 #ifdef SECCOMP_DEBUG
        dump_stack();
 #endif
-       audit_seccomp(this_syscall, exit_code, SECCOMP_RET_KILL);
+       audit_seccomp(this_syscall, exit_sig, ret);
        do_exit(exit_sig);
+skip:
+       audit_seccomp(this_syscall, exit_sig, ret);
+       return -1;
 }
 
 long prctl_get_seccomp(void)