[linux-2.6-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>

static DEFINE_STATIC_KEY_FALSE(stack_erasing_bypass);

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

#define skip_erasing()	static_branch_unlikely(&stack_erasing_bypass)
#else
#define skip_erasing()	false
#endif /* CONFIG_STACKLEAK_RUNTIME_DISABLE */

asmlinkage void notrace 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;
}
NOKPROBE_SYMBOL(stackleak_erase);

void __used notrace stackleak_track_stack(void)
{
	/*
	 * N.B. stackleak_erase() fills the kernel stack with the poison value,
	 * which has the register width. That code assumes that the value
	 * of 'lowest_stack' is aligned on the register width boundary.
	 *
	 * That is true for x86 and x86_64 because of the kernel stack
	 * alignment on these platforms (for details, see 'cc_stack_align' in
	 * arch/x86/Makefile). Take care of that when you port STACKLEAK to
	 * new platforms.
	 */
	unsigned long sp = (unsigned long)&sp;

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

	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,
	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
ef1a8409	51	asmlinkage void notrace 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	}
ef1a8409	105	NOKPROBE_SYMBOL(stackleak_erase);
afaef01c	106
e9c7d656	107	void __used notrace stackleak_track_stack(void)
10e9ae9f AP	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	}
	134	EXPORT_SYMBOL(stackleak_track_stack);