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
         { }
 };