Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178// 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> * * KSTACK_ERASE reduces the information which kernel stack leak bugs can * reveal and blocks some uninitialized stack variable attacks. */
#include <linux/kstack_erase.h>#include <linux/kprobes.h>
#ifdef CONFIG_KSTACK_ERASE_RUNTIME_DISABLE#include <linux/jump_label.h>#include <linux/string_choices.h>#include <linux/sysctl.h>#include <linux/init.h>
static DEFINE_STATIC_KEY_FALSE(stack_erasing_bypass);
#ifdef CONFIG_SYSCTLstatic int stack_erasing_sysctl(const struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos){ int ret = 0; int state = !static_branch_unlikely(&stack_erasing_bypass); int prev_state = state; struct ctl_table table_copy = *table;
table_copy.data = &state; ret = proc_dointvec_minmax(&table_copy, 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", str_enabled_disabled(state)); return ret;}static const struct ctl_table stackleak_sysctls[] = { { .procname = "stack_erasing", .data = NULL, .maxlen = sizeof(int), .mode = 0600, .proc_handler = stack_erasing_sysctl, .extra1 = SYSCTL_ZERO, .extra2 = SYSCTL_ONE, },};
static int __init stackleak_sysctls_init(void){ register_sysctl_init("kernel", stackleak_sysctls); return 0;}late_initcall(stackleak_sysctls_init);#endif /* CONFIG_SYSCTL */
#define skip_erasing() static_branch_unlikely(&stack_erasing_bypass)#else#define skip_erasing() false#endif /* CONFIG_KSTACK_ERASE_RUNTIME_DISABLE */
#ifndef __stackleak_poisonstatic __always_inline void __stackleak_poison(unsigned long erase_low, unsigned long erase_high, unsigned long poison){ while (erase_low < erase_high) { *(unsigned long *)erase_low = poison; erase_low += sizeof(unsigned long); }}#endif
static __always_inline void __stackleak_erase(bool on_task_stack){ const unsigned long task_stack_low = stackleak_task_low_bound(current); const unsigned long task_stack_high = stackleak_task_high_bound(current); unsigned long erase_low, erase_high;
erase_low = stackleak_find_top_of_poison(task_stack_low, current->lowest_stack);
#ifdef CONFIG_KSTACK_ERASE_METRICS current->prev_lowest_stack = erase_low;#endif
/* * Write poison to the task's stack between 'erase_low' and * 'erase_high'. * * If we're running on a different stack (e.g. an entry trampoline * stack) we can erase everything below the pt_regs at the top of the * task stack. * * If we're running on the task stack itself, we must not clobber any * stack used by this function and its caller. We assume that this * function has a fixed-size stack frame, and the current stack pointer * doesn't change while we write poison. */ if (on_task_stack) erase_high = current_stack_pointer; else erase_high = task_stack_high;
__stackleak_poison(erase_low, erase_high, KSTACK_ERASE_POISON);
/* Reset the 'lowest_stack' value for the next syscall */ current->lowest_stack = task_stack_high;}
/* * Erase and poison the portion of the task stack used since the last erase. * Can be called from the task stack or an entry stack when the task stack is * no longer in use. */asmlinkage void noinstr stackleak_erase(void){ if (skip_erasing()) return;
__stackleak_erase(on_thread_stack());}
/* * Erase and poison the portion of the task stack used since the last erase. * Can only be called from the task stack. */asmlinkage void noinstr stackleak_erase_on_task_stack(void){ if (skip_erasing()) return;
__stackleak_erase(true);}
/* * Erase and poison the portion of the task stack used since the last erase. * Can only be called from a stack other than the task stack. */asmlinkage void noinstr stackleak_erase_off_task_stack(void){ if (skip_erasing()) return;
__stackleak_erase(false);}
void __used __no_caller_saved_registers noinstr __sanitizer_cov_stack_depth(void){ unsigned long sp = current_stack_pointer;
/* * Having CONFIG_KSTACK_ERASE_TRACK_MIN_SIZE larger than * KSTACK_ERASE_SEARCH_DEPTH makes the poison search in * stackleak_erase() unreliable. Let's prevent that. */ BUILD_BUG_ON(CONFIG_KSTACK_ERASE_TRACK_MIN_SIZE > KSTACK_ERASE_SEARCH_DEPTH);
/* 'lowest_stack' should be aligned on the register width boundary */ sp = ALIGN(sp, sizeof(unsigned long)); if (sp < current->lowest_stack && sp >= stackleak_task_low_bound(current)) { current->lowest_stack = sp; }}EXPORT_SYMBOL(__sanitizer_cov_stack_depth);