Merge tag 'stackleak-v4.20-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux

Pull stackleak gcc plugin from Kees Cook:
 "Please pull this new GCC plugin, stackleak, for v4.20-rc1. This plugin
  was ported from grsecurity by Alexander Popov. It provides efficient
  stack content poisoning at syscall exit. This creates a defense
  against at least two classes of flaws:

   - Uninitialized stack usage. (We continue to work on improving the
     compiler to do this in other ways: e.g. unconditional zero init was
     proposed to GCC and Clang, and more plugin work has started too).

   - Stack content exposure. By greatly reducing the lifetime of valid
     stack contents, exposures via either direct read bugs or unknown
     cache side-channels become much more difficult to exploit. This
     complements the existing buddy and heap poisoning options, but
     provides the coverage for stacks.

  The x86 hooks are included in this series (which have been reviewed by
  Ingo, Dave Hansen, and Thomas Gleixner). The arm64 hooks have already
  been merged through the arm64 tree (written by Laura Abbott and
  reviewed by Mark Rutland and Will Deacon).

  With VLAs having been removed this release, there is no need for
  alloca() protection, so it has been removed from the plugin"

* tag 'stackleak-v4.20-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux:
  arm64: Drop unneeded stackleak_check_alloca()
  stackleak: Allow runtime disabling of kernel stack erasing
  doc: self-protection: Add information about STACKLEAK feature
  fs/proc: Show STACKLEAK metrics in the /proc file system
  lkdtm: Add a test for STACKLEAK
  gcc-plugins: Add STACKLEAK plugin for tracking the kernel stack
  x86/entry: Add STACKLEAK erasing the kernel stack at the end of syscalls

4 files changed, 153 insertions, 1 deletions

diff --git a/kernel/Makefile b/kernel/Makefile
index 7a63d567fdb5..7343b3a9bff0 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -117,6 +117,10 @@ obj-$(CONFIG_HAS_IOMEM) += iomem.o
 obj-$(CONFIG_ZONE_DEVICE) += memremap.o
 obj-$(CONFIG_RSEQ) += rseq.o
 
+obj-$(CONFIG_GCC_PLUGIN_STACKLEAK) += stackleak.o
+KASAN_SANITIZE_stackleak.o := n
+KCOV_INSTRUMENT_stackleak.o := n
+
 $(obj)/configs.o: $(obj)/config_data.h
 
 targets += config_data.gz
diff --git a/kernel/fork.c b/kernel/fork.c
index 8f82a3bdcb8f..07cddff89c7b 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -91,6 +91,7 @@
 #include <linux/kcov.h>
 #include <linux/livepatch.h>
 #include <linux/thread_info.h>
+#include <linux/stackleak.h>
 
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>
@@ -1926,6 +1927,8 @@ static __latent_entropy struct task_struct *copy_process(
         if (retval)
                 goto bad_fork_cleanup_io;
 
+        stackleak_task_init(p);
+
         if (pid != &init_struct_pid) {
                 pid = alloc_pid(p->nsproxy->pid_ns_for_children);
                 if (IS_ERR(pid)) {
diff --git a/kernel/stackleak.c b/kernel/stackleak.c
new file mode 100644
index 000000000000..e42892926244
--- /dev/null
+++ b/kernel/stackleak.c
@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * This code fills the used part of the kernel stack with a poison value
+ * before returning to userspace. It's part of the STACKLEAK feature
+ * ported from grsecurity/PaX.
+ *
+ * Author: Alexander Popov <alex.popov@linux.com>
+ *
+ * STACKLEAK reduces the information which kernel stack leak bugs can
+ * reveal and blocks some uninitialized stack variable attacks.
+ */
+
+#include <linux/stackleak.h>
+
+#ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE
+#include <linux/jump_label.h>
+#include <linux/sysctl.h>
+
+static DEFINE_STATIC_KEY_FALSE(stack_erasing_bypass);
+
+int stack_erasing_sysctl(struct ctl_table *table, int write,
+                        void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+        int ret = 0;
+        int state = !static_branch_unlikely(&stack_erasing_bypass);
+        int prev_state = state;
+
+        table->data = &state;
+        table->maxlen = sizeof(int);
+        ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
+        state = !!state;
+        if (ret || !write || state == prev_state)
+                return ret;
+
+        if (state)
+                static_branch_disable(&stack_erasing_bypass);
+        else
+                static_branch_enable(&stack_erasing_bypass);
+
+        pr_warn("stackleak: kernel stack erasing is %s\n",
+                                        state ? "enabled" : "disabled");
+        return ret;
+}
+
+#define skip_erasing()  static_branch_unlikely(&stack_erasing_bypass)
+#else
+#define skip_erasing()  false
+#endif /* CONFIG_STACKLEAK_RUNTIME_DISABLE */
+
+asmlinkage void stackleak_erase(void)
+{
+        /* It would be nice not to have 'kstack_ptr' and 'boundary' on stack */
+        unsigned long kstack_ptr = current->lowest_stack;
+        unsigned long boundary = (unsigned long)end_of_stack(current);
+        unsigned int poison_count = 0;
+        const unsigned int depth = STACKLEAK_SEARCH_DEPTH / sizeof(unsigned long);
+
+        if (skip_erasing())
+                return;
+
+        /* Check that 'lowest_stack' value is sane */
+        if (unlikely(kstack_ptr - boundary >= THREAD_SIZE))
+                kstack_ptr = boundary;
+
+        /* Search for the poison value in the kernel stack */
+        while (kstack_ptr > boundary && poison_count <= depth) {
+                if (*(unsigned long *)kstack_ptr == STACKLEAK_POISON)
+                        poison_count++;
+                else
+                        poison_count = 0;
+
+                kstack_ptr -= sizeof(unsigned long);
+        }
+
+        /*
+         * One 'long int' at the bottom of the thread stack is reserved and
+         * should not be poisoned (see CONFIG_SCHED_STACK_END_CHECK=y).
+         */
+        if (kstack_ptr == boundary)
+                kstack_ptr += sizeof(unsigned long);
+
+#ifdef CONFIG_STACKLEAK_METRICS
+        current->prev_lowest_stack = kstack_ptr;
+#endif
+
+        /*
+         * Now write the poison value to the kernel stack. Start from
+         * 'kstack_ptr' and move up till the new 'boundary'. We assume that
+         * the stack pointer doesn't change when we write poison.
+         */
+        if (on_thread_stack())
+                boundary = current_stack_pointer;
+        else
+                boundary = current_top_of_stack();
+
+        while (kstack_ptr < boundary) {
+                *(unsigned long *)kstack_ptr = STACKLEAK_POISON;
+                kstack_ptr += sizeof(unsigned long);
+        }
+
+        /* Reset the 'lowest_stack' value for the next syscall */
+        current->lowest_stack = current_top_of_stack() - THREAD_SIZE/64;
+}
+
+void __used stackleak_track_stack(void)
+{
+        /*
+         * N.B. stackleak_erase() fills the kernel stack with the poison value,
+         * which has the register width. That code assumes that the value
+         * of 'lowest_stack' is aligned on the register width boundary.
+         *
+         * That is true for x86 and x86_64 because of the kernel stack
+         * alignment on these platforms (for details, see 'cc_stack_align' in
+         * arch/x86/Makefile). Take care of that when you port STACKLEAK to
+         * new platforms.
+         */
+        unsigned long sp = (unsigned long)&sp;
+
+        /*
+         * Having CONFIG_STACKLEAK_TRACK_MIN_SIZE larger than
+         * STACKLEAK_SEARCH_DEPTH makes the poison search in
+         * stackleak_erase() unreliable. Let's prevent that.
+         */
+        BUILD_BUG_ON(CONFIG_STACKLEAK_TRACK_MIN_SIZE > STACKLEAK_SEARCH_DEPTH);
+
+        if (sp < current->lowest_stack &&
+            sp >= (unsigned long)task_stack_page(current) +
+                                                sizeof(unsigned long)) {
+                current->lowest_stack = sp;
+        }
+}
+EXPORT_SYMBOL(stackleak_track_stack);
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index cc02050fd0c4..3ae223f7b5df 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -91,7 +91,9 @@
 #ifdef CONFIG_CHR_DEV_SG
 #include <scsi/sg.h>
 #endif
-
+#ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE
+#include <linux/stackleak.h>
+#endif
 #ifdef CONFIG_LOCKUP_DETECTOR
 #include <linux/nmi.h>
 #endif
@@ -1233,6 +1235,17 @@ static struct ctl_table kern_table[] = {
                 .extra2         = &one,
         },
 #endif
+#ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE
+        {
+                .procname       = "stack_erasing",
+                .data           = NULL,
+                .maxlen         = sizeof(int),
+                .mode           = 0600,
+                .proc_handler   = stack_erasing_sysctl,
+                .extra1         = &zero,
+                .extra2         = &one,
+        },
+#endif
         { }
 };