[mirror_ubuntu-jammy-kernel.git] / kernel / stackleak.c

// 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>
#include <linux/kprobes.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 *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 noinstr 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 __no_caller_saved_registers noinstr stackleak_track_stack(void)
{
	unsigned long sp = current_stack_pointer;

	/*
	 * 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);

	/* 'lowest_stack' should be aligned on the register width boundary */
	sp = ALIGN(sp, sizeof(unsigned long));
	if (sp < current->lowest_stack &&
	    sp >= (unsigned long)task_stack_page(current) +
						sizeof(unsigned long)) {
		current->lowest_stack = sp;
	}
}
EXPORT_SYMBOL(stackleak_track_stack);
Commit	Line	Data
afaef01c AP	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>
ef1a8409	14	#include <linux/kprobes.h>
afaef01c	15
964c9dff AP	16	#ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE
	17	#include <linux/jump_label.h>
	18	#include <linux/sysctl.h>
	19
	20	static DEFINE_STATIC_KEY_FALSE(stack_erasing_bypass);
	21
	22	int stack_erasing_sysctl(struct ctl_table *table, int write,
4773ef33	23	void buffer, size_t lenp, loff_t *ppos)
964c9dff AP	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
2948b67c	51	asmlinkage void noinstr stackleak_erase(void)
afaef01c AP	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
964c9dff AP	59	if (skip_erasing())
	60	return;
	61
afaef01c AP	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
c8d12627 AP	83	#ifdef CONFIG_STACKLEAK_METRICS
	84	current->prev_lowest_stack = kstack_ptr;
	85	#endif
	86
afaef01c AP	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	}
	105
2948b67c	106	void __used __no_caller_saved_registers noinstr stackleak_track_stack(void)
10e9ae9f	107	{
feee1b8c	108	unsigned long sp = current_stack_pointer;
10e9ae9f AP	109
	110	/*
	111	* Having CONFIG_STACKLEAK_TRACK_MIN_SIZE larger than
	112	* STACKLEAK_SEARCH_DEPTH makes the poison search in
	113	* stackleak_erase() unreliable. Let's prevent that.
	114	*/
	115	BUILD_BUG_ON(CONFIG_STACKLEAK_TRACK_MIN_SIZE > STACKLEAK_SEARCH_DEPTH);
	116
feee1b8c AP	117	/* 'lowest_stack' should be aligned on the register width boundary */
feee1b8c AP	118	sp = ALIGN(sp, sizeof(unsigned long));
10e9ae9f AP	119	if (sp < current->lowest_stack &&
	120	sp >= (unsigned long)task_stack_page(current) +
	121	sizeof(unsigned long)) {
	122	current->lowest_stack = sp;
	123	}
	124	}
	125	EXPORT_SYMBOL(stackleak_track_stack);