1 // SPDX-License-Identifier: GPL-2.0
3 * This code fills the used part of the kernel stack with a poison value
4 * before returning to userspace. It's part of the STACKLEAK feature
5 * ported from grsecurity/PaX.
7 * Author: Alexander Popov <alex.popov@linux.com>
9 * STACKLEAK reduces the information which kernel stack leak bugs can
10 * reveal and blocks some uninitialized stack variable attacks.
13 #include <linux/stackleak.h>
14 #include <linux/kprobes.h>
16 #ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE
17 #include <linux/jump_label.h>
18 #include <linux/sysctl.h>
19 #include <linux/init.h>
21 static DEFINE_STATIC_KEY_FALSE(stack_erasing_bypass);
24 static int stack_erasing_sysctl(struct ctl_table *table, int write,
25 void __user *buffer, size_t *lenp, loff_t *ppos)
28 int state = !static_branch_unlikely(&stack_erasing_bypass);
29 int prev_state = state;
32 table->maxlen = sizeof(int);
33 ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
35 if (ret || !write || state == prev_state)
39 static_branch_disable(&stack_erasing_bypass);
41 static_branch_enable(&stack_erasing_bypass);
43 pr_warn("stackleak: kernel stack erasing is %s\n",
44 state ? "enabled" : "disabled");
47 static struct ctl_table stackleak_sysctls[] = {
49 .procname = "stack_erasing",
51 .maxlen = sizeof(int),
53 .proc_handler = stack_erasing_sysctl,
54 .extra1 = SYSCTL_ZERO,
60 static int __init stackleak_sysctls_init(void)
62 register_sysctl_init("kernel", stackleak_sysctls);
65 late_initcall(stackleak_sysctls_init);
66 #endif /* CONFIG_SYSCTL */
68 #define skip_erasing() static_branch_unlikely(&stack_erasing_bypass)
70 #define skip_erasing() false
71 #endif /* CONFIG_STACKLEAK_RUNTIME_DISABLE */
73 asmlinkage void notrace stackleak_erase(void)
75 /* It would be nice not to have 'kstack_ptr' and 'boundary' on stack */
76 unsigned long kstack_ptr = current->lowest_stack;
77 unsigned long boundary = (unsigned long)end_of_stack(current);
78 unsigned int poison_count = 0;
79 const unsigned int depth = STACKLEAK_SEARCH_DEPTH / sizeof(unsigned long);
84 /* Check that 'lowest_stack' value is sane */
85 if (unlikely(kstack_ptr - boundary >= THREAD_SIZE))
86 kstack_ptr = boundary;
88 /* Search for the poison value in the kernel stack */
89 while (kstack_ptr > boundary && poison_count <= depth) {
90 if (*(unsigned long *)kstack_ptr == STACKLEAK_POISON)
95 kstack_ptr -= sizeof(unsigned long);
99 * One 'long int' at the bottom of the thread stack is reserved and
100 * should not be poisoned (see CONFIG_SCHED_STACK_END_CHECK=y).
102 if (kstack_ptr == boundary)
103 kstack_ptr += sizeof(unsigned long);
105 #ifdef CONFIG_STACKLEAK_METRICS
106 current->prev_lowest_stack = kstack_ptr;
110 * Now write the poison value to the kernel stack. Start from
111 * 'kstack_ptr' and move up till the new 'boundary'. We assume that
112 * the stack pointer doesn't change when we write poison.
114 if (on_thread_stack())
115 boundary = current_stack_pointer;
117 boundary = current_top_of_stack();
119 while (kstack_ptr < boundary) {
120 *(unsigned long *)kstack_ptr = STACKLEAK_POISON;
121 kstack_ptr += sizeof(unsigned long);
124 /* Reset the 'lowest_stack' value for the next syscall */
125 current->lowest_stack = current_top_of_stack() - THREAD_SIZE/64;
127 NOKPROBE_SYMBOL(stackleak_erase);
129 void __used __no_caller_saved_registers notrace stackleak_track_stack(void)
131 unsigned long sp = current_stack_pointer;
134 * Having CONFIG_STACKLEAK_TRACK_MIN_SIZE larger than
135 * STACKLEAK_SEARCH_DEPTH makes the poison search in
136 * stackleak_erase() unreliable. Let's prevent that.
138 BUILD_BUG_ON(CONFIG_STACKLEAK_TRACK_MIN_SIZE > STACKLEAK_SEARCH_DEPTH);
140 /* 'lowest_stack' should be aligned on the register width boundary */
141 sp = ALIGN(sp, sizeof(unsigned long));
142 if (sp < current->lowest_stack &&
143 sp >= (unsigned long)task_stack_page(current) +
144 sizeof(unsigned long)) {
145 current->lowest_stack = sp;
148 EXPORT_SYMBOL(stackleak_track_stack);