Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
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.
6 *
7 * Author: Alexander Popov <alex.popov@linux.com>
8 *
9 * STACKLEAK reduces the information which kernel stack leak bugs can
10 * reveal and blocks some uninitialized stack variable attacks.
11 */
12
13#include <linux/stackleak.h>
14#include <linux/kprobes.h>
15
16#ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE
17#include <linux/jump_label.h>
18#include <linux/sysctl.h>
19
20static DEFINE_STATIC_KEY_FALSE(stack_erasing_bypass);
21
22int stack_erasing_sysctl(struct ctl_table *table, int write,
23 void __user *buffer, size_t *lenp, loff_t *ppos)
24{
25 int ret = 0;
26 int state = !static_branch_unlikely(&stack_erasing_bypass);
27 int prev_state = state;
28
29 table->data = &state;
30 table->maxlen = sizeof(int);
31 ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
32 state = !!state;
33 if (ret || !write || state == prev_state)
34 return ret;
35
36 if (state)
37 static_branch_disable(&stack_erasing_bypass);
38 else
39 static_branch_enable(&stack_erasing_bypass);
40
41 pr_warn("stackleak: kernel stack erasing is %s\n",
42 state ? "enabled" : "disabled");
43 return ret;
44}
45
46#define skip_erasing() static_branch_unlikely(&stack_erasing_bypass)
47#else
48#define skip_erasing() false
49#endif /* CONFIG_STACKLEAK_RUNTIME_DISABLE */
50
51asmlinkage void notrace stackleak_erase(void)
52{
53 /* It would be nice not to have 'kstack_ptr' and 'boundary' on stack */
54 unsigned long kstack_ptr = current->lowest_stack;
55 unsigned long boundary = (unsigned long)end_of_stack(current);
56 unsigned int poison_count = 0;
57 const unsigned int depth = STACKLEAK_SEARCH_DEPTH / sizeof(unsigned long);
58
59 if (skip_erasing())
60 return;
61
62 /* Check that 'lowest_stack' value is sane */
63 if (unlikely(kstack_ptr - boundary >= THREAD_SIZE))
64 kstack_ptr = boundary;
65
66 /* Search for the poison value in the kernel stack */
67 while (kstack_ptr > boundary && poison_count <= depth) {
68 if (*(unsigned long *)kstack_ptr == STACKLEAK_POISON)
69 poison_count++;
70 else
71 poison_count = 0;
72
73 kstack_ptr -= sizeof(unsigned long);
74 }
75
76 /*
77 * One 'long int' at the bottom of the thread stack is reserved and
78 * should not be poisoned (see CONFIG_SCHED_STACK_END_CHECK=y).
79 */
80 if (kstack_ptr == boundary)
81 kstack_ptr += sizeof(unsigned long);
82
83#ifdef CONFIG_STACKLEAK_METRICS
84 current->prev_lowest_stack = kstack_ptr;
85#endif
86
87 /*
88 * Now write the poison value to the kernel stack. Start from
89 * 'kstack_ptr' and move up till the new 'boundary'. We assume that
90 * the stack pointer doesn't change when we write poison.
91 */
92 if (on_thread_stack())
93 boundary = current_stack_pointer;
94 else
95 boundary = current_top_of_stack();
96
97 while (kstack_ptr < boundary) {
98 *(unsigned long *)kstack_ptr = STACKLEAK_POISON;
99 kstack_ptr += sizeof(unsigned long);
100 }
101
102 /* Reset the 'lowest_stack' value for the next syscall */
103 current->lowest_stack = current_top_of_stack() - THREAD_SIZE/64;
104}
105NOKPROBE_SYMBOL(stackleak_erase);
106
107void __used notrace stackleak_track_stack(void)
108{
109 /*
110 * N.B. stackleak_erase() fills the kernel stack with the poison value,
111 * which has the register width. That code assumes that the value
112 * of 'lowest_stack' is aligned on the register width boundary.
113 *
114 * That is true for x86 and x86_64 because of the kernel stack
115 * alignment on these platforms (for details, see 'cc_stack_align' in
116 * arch/x86/Makefile). Take care of that when you port STACKLEAK to
117 * new platforms.
118 */
119 unsigned long sp = (unsigned long)&sp;
120
121 /*
122 * Having CONFIG_STACKLEAK_TRACK_MIN_SIZE larger than
123 * STACKLEAK_SEARCH_DEPTH makes the poison search in
124 * stackleak_erase() unreliable. Let's prevent that.
125 */
126 BUILD_BUG_ON(CONFIG_STACKLEAK_TRACK_MIN_SIZE > STACKLEAK_SEARCH_DEPTH);
127
128 if (sp < current->lowest_stack &&
129 sp >= (unsigned long)task_stack_page(current) +
130 sizeof(unsigned long)) {
131 current->lowest_stack = sp;
132 }
133}
134EXPORT_SYMBOL(stackleak_track_stack);
1// SPDX-License-Identifier: GPL-2.0
2/*
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.
6 *
7 * Author: Alexander Popov <alex.popov@linux.com>
8 *
9 * STACKLEAK reduces the information which kernel stack leak bugs can
10 * reveal and blocks some uninitialized stack variable attacks.
11 */
12
13#include <linux/stackleak.h>
14#include <linux/kprobes.h>
15
16#ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE
17#include <linux/jump_label.h>
18#include <linux/sysctl.h>
19#include <linux/init.h>
20
21static DEFINE_STATIC_KEY_FALSE(stack_erasing_bypass);
22
23#ifdef CONFIG_SYSCTL
24static int stack_erasing_sysctl(const struct ctl_table *table, int write,
25 void __user *buffer, size_t *lenp, loff_t *ppos)
26{
27 int ret = 0;
28 int state = !static_branch_unlikely(&stack_erasing_bypass);
29 int prev_state = state;
30 struct ctl_table table_copy = *table;
31
32 table_copy.data = &state;
33 ret = proc_dointvec_minmax(&table_copy, write, buffer, lenp, ppos);
34 state = !!state;
35 if (ret || !write || state == prev_state)
36 return ret;
37
38 if (state)
39 static_branch_disable(&stack_erasing_bypass);
40 else
41 static_branch_enable(&stack_erasing_bypass);
42
43 pr_warn("stackleak: kernel stack erasing is %s\n",
44 state ? "enabled" : "disabled");
45 return ret;
46}
47static struct ctl_table stackleak_sysctls[] = {
48 {
49 .procname = "stack_erasing",
50 .data = NULL,
51 .maxlen = sizeof(int),
52 .mode = 0600,
53 .proc_handler = stack_erasing_sysctl,
54 .extra1 = SYSCTL_ZERO,
55 .extra2 = SYSCTL_ONE,
56 },
57};
58
59static int __init stackleak_sysctls_init(void)
60{
61 register_sysctl_init("kernel", stackleak_sysctls);
62 return 0;
63}
64late_initcall(stackleak_sysctls_init);
65#endif /* CONFIG_SYSCTL */
66
67#define skip_erasing() static_branch_unlikely(&stack_erasing_bypass)
68#else
69#define skip_erasing() false
70#endif /* CONFIG_STACKLEAK_RUNTIME_DISABLE */
71
72#ifndef __stackleak_poison
73static __always_inline void __stackleak_poison(unsigned long erase_low,
74 unsigned long erase_high,
75 unsigned long poison)
76{
77 while (erase_low < erase_high) {
78 *(unsigned long *)erase_low = poison;
79 erase_low += sizeof(unsigned long);
80 }
81}
82#endif
83
84static __always_inline void __stackleak_erase(bool on_task_stack)
85{
86 const unsigned long task_stack_low = stackleak_task_low_bound(current);
87 const unsigned long task_stack_high = stackleak_task_high_bound(current);
88 unsigned long erase_low, erase_high;
89
90 erase_low = stackleak_find_top_of_poison(task_stack_low,
91 current->lowest_stack);
92
93#ifdef CONFIG_STACKLEAK_METRICS
94 current->prev_lowest_stack = erase_low;
95#endif
96
97 /*
98 * Write poison to the task's stack between 'erase_low' and
99 * 'erase_high'.
100 *
101 * If we're running on a different stack (e.g. an entry trampoline
102 * stack) we can erase everything below the pt_regs at the top of the
103 * task stack.
104 *
105 * If we're running on the task stack itself, we must not clobber any
106 * stack used by this function and its caller. We assume that this
107 * function has a fixed-size stack frame, and the current stack pointer
108 * doesn't change while we write poison.
109 */
110 if (on_task_stack)
111 erase_high = current_stack_pointer;
112 else
113 erase_high = task_stack_high;
114
115 __stackleak_poison(erase_low, erase_high, STACKLEAK_POISON);
116
117 /* Reset the 'lowest_stack' value for the next syscall */
118 current->lowest_stack = task_stack_high;
119}
120
121/*
122 * Erase and poison the portion of the task stack used since the last erase.
123 * Can be called from the task stack or an entry stack when the task stack is
124 * no longer in use.
125 */
126asmlinkage void noinstr stackleak_erase(void)
127{
128 if (skip_erasing())
129 return;
130
131 __stackleak_erase(on_thread_stack());
132}
133
134/*
135 * Erase and poison the portion of the task stack used since the last erase.
136 * Can only be called from the task stack.
137 */
138asmlinkage void noinstr stackleak_erase_on_task_stack(void)
139{
140 if (skip_erasing())
141 return;
142
143 __stackleak_erase(true);
144}
145
146/*
147 * Erase and poison the portion of the task stack used since the last erase.
148 * Can only be called from a stack other than the task stack.
149 */
150asmlinkage void noinstr stackleak_erase_off_task_stack(void)
151{
152 if (skip_erasing())
153 return;
154
155 __stackleak_erase(false);
156}
157
158void __used __no_caller_saved_registers noinstr stackleak_track_stack(void)
159{
160 unsigned long sp = current_stack_pointer;
161
162 /*
163 * Having CONFIG_STACKLEAK_TRACK_MIN_SIZE larger than
164 * STACKLEAK_SEARCH_DEPTH makes the poison search in
165 * stackleak_erase() unreliable. Let's prevent that.
166 */
167 BUILD_BUG_ON(CONFIG_STACKLEAK_TRACK_MIN_SIZE > STACKLEAK_SEARCH_DEPTH);
168
169 /* 'lowest_stack' should be aligned on the register width boundary */
170 sp = ALIGN(sp, sizeof(unsigned long));
171 if (sp < current->lowest_stack &&
172 sp >= stackleak_task_low_bound(current)) {
173 current->lowest_stack = sp;
174 }
175}
176EXPORT_SYMBOL(stackleak_track_stack);