[linux-block.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>
#include <linux/init.h>

static DEFINE_STATIC_KEY_FALSE(stack_erasing_bypass);

#ifdef CONFIG_SYSCTL
static 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;
}
static 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_STACKLEAK_RUNTIME_DISABLE */

static __always_inline 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);

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

asmlinkage void noinstr stackleak_erase(void)
{
	if (skip_erasing())
		return;

	__stackleak_erase();
}

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>
0df8bdd5	19	#include <linux/init.h>
964c9dff AP	20
	21	static DEFINE_STATIC_KEY_FALSE(stack_erasing_bypass);
	22
0df8bdd5 XN	23	#ifdef CONFIG_SYSCTL
	24	static int stack_erasing_sysctl(struct ctl_table *table, int write,
	25	void __user buffer, size_t lenp, loff_t *ppos)
964c9dff AP	26	{
	27	int ret = 0;
	28	int state = !static_branch_unlikely(&stack_erasing_bypass);
	29	int prev_state = state;
	30
	31	table->data = &state;
	32	table->maxlen = sizeof(int);
	33	ret = proc_dointvec_minmax(table, 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	}
0df8bdd5 XN	47	static 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	};
	59
	60	static int __init stackleak_sysctls_init(void)
	61	{
	62	register_sysctl_init("kernel", stackleak_sysctls);
	63	return 0;
	64	}
	65	late_initcall(stackleak_sysctls_init);
	66	#endif /* CONFIG_SYSCTL */
964c9dff AP	67
	68	#define skip_erasing() static_branch_unlikely(&stack_erasing_bypass)
	69	#else
	70	#define skip_erasing() false
	71	#endif /* CONFIG_STACKLEAK_RUNTIME_DISABLE */
	72
a12685e2	73	static __always_inline void __stackleak_erase(void)
afaef01c AP	74	{
	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);
	80
afaef01c AP	81	/* Search for the poison value in the kernel stack */
	82	while (kstack_ptr > boundary && poison_count <= depth) {
	83	if ((unsigned long )kstack_ptr == STACKLEAK_POISON)
	84	poison_count++;
	85	else
	86	poison_count = 0;
	87
	88	kstack_ptr -= sizeof(unsigned long);
	89	}
	90
	91	/*
	92	* One 'long int' at the bottom of the thread stack is reserved and
	93	* should not be poisoned (see CONFIG_SCHED_STACK_END_CHECK=y).
	94	*/
	95	if (kstack_ptr == boundary)
	96	kstack_ptr += sizeof(unsigned long);
	97
c8d12627 AP	98	#ifdef CONFIG_STACKLEAK_METRICS
	99	current->prev_lowest_stack = kstack_ptr;
	100	#endif
	101
afaef01c AP	102	/*
	103	* Now write the poison value to the kernel stack. Start from
	104	* 'kstack_ptr' and move up till the new 'boundary'. We assume that
	105	* the stack pointer doesn't change when we write poison.
	106	*/
	107	if (on_thread_stack())
	108	boundary = current_stack_pointer;
	109	else
	110	boundary = current_top_of_stack();
	111
	112	while (kstack_ptr < boundary) {
	113	(unsigned long )kstack_ptr = STACKLEAK_POISON;
	114	kstack_ptr += sizeof(unsigned long);
	115	}
	116
	117	/* Reset the 'lowest_stack' value for the next syscall */
	118	current->lowest_stack = current_top_of_stack() - THREAD_SIZE/64;
	119	}
	120
a12685e2 MR	121	asmlinkage void noinstr stackleak_erase(void)
	122	{
	123	if (skip_erasing())
	124	return;
	125
	126	__stackleak_erase();
	127	}
	128
dcb85f85	129	void __used __no_caller_saved_registers noinstr stackleak_track_stack(void)
10e9ae9f	130	{
feee1b8c	131	unsigned long sp = current_stack_pointer;
10e9ae9f AP	132
	133	/*
	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.
	137	*/
	138	BUILD_BUG_ON(CONFIG_STACKLEAK_TRACK_MIN_SIZE > STACKLEAK_SEARCH_DEPTH);
	139
feee1b8c AP	140	/* 'lowest_stack' should be aligned on the register width boundary */
feee1b8c AP	141	sp = ALIGN(sp, sizeof(unsigned long));
10e9ae9f AP	142	if (sp < current->lowest_stack &&
	143	sp >= (unsigned long)task_stack_page(current) +
	144	sizeof(unsigned long)) {
	145	current->lowest_stack = sp;
	146	}
	147	}
	148	EXPORT_SYMBOL(stackleak_track_stack);