[linux-block.git] / lib / test_user_copy.c

/*
 * Kernel module for testing copy_to/from_user infrastructure.
 *
 * Copyright 2013 Google Inc. All Rights Reserved
 *
 * Authors:
 *      Kees Cook       <keescook@chromium.org>
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/mman.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/vmalloc.h>

#define test(condition, msg)		\
({					\
	int cond = (condition);		\
	if (cond)			\
		pr_warn("%s\n", msg);	\
	cond;				\
})

static int __init test_user_copy_init(void)
{
	int ret = 0;
	char *kmem;
	char __user *usermem;
	char *bad_usermem;
	unsigned long user_addr;
	unsigned long value = 0x5A;

	kmem = kmalloc(PAGE_SIZE * 2, GFP_KERNEL);
	if (!kmem)
		return -ENOMEM;

	user_addr = vm_mmap(NULL, 0, PAGE_SIZE * 2,
			    PROT_READ | PROT_WRITE | PROT_EXEC,
			    MAP_ANONYMOUS | MAP_PRIVATE, 0);
	if (user_addr >= (unsigned long)(TASK_SIZE)) {
		pr_warn("Failed to allocate user memory\n");
		kfree(kmem);
		return -ENOMEM;
	}

	usermem = (char __user *)user_addr;
	bad_usermem = (char *)user_addr;

	/* Legitimate usage: none of these should fail. */
	ret |= test(copy_from_user(kmem, usermem, PAGE_SIZE),
		    "legitimate copy_from_user failed");
	ret |= test(copy_to_user(usermem, kmem, PAGE_SIZE),
		    "legitimate copy_to_user failed");
	ret |= test(get_user(value, (unsigned long __user *)usermem),
		    "legitimate get_user failed");
	ret |= test(put_user(value, (unsigned long __user *)usermem),
		    "legitimate put_user failed");

	/* Invalid usage: none of these should succeed. */
	memset(kmem, 0x5a, PAGE_SIZE);
	memset(kmem + PAGE_SIZE, 0, PAGE_SIZE);
	ret |= test(!copy_from_user(kmem, (char __user *)(kmem + PAGE_SIZE),
				    PAGE_SIZE),
		    "illegal all-kernel copy_from_user passed");
	ret |= test(memcmp(kmem + PAGE_SIZE, kmem, PAGE_SIZE),
		    "zeroing failure for illegal all-kernel copy_from_user");
	memset(bad_usermem, 0x5A, PAGE_SIZE);
	ret |= test(!copy_from_user(bad_usermem, (char __user *)kmem,
				    PAGE_SIZE),
		    "illegal reversed copy_from_user passed");
	ret |= test(memcmp(kmem + PAGE_SIZE, bad_usermem, PAGE_SIZE),
		    "zeroing failure for illegal reversed copy_from_user");
	ret |= test(!copy_to_user((char __user *)kmem, kmem + PAGE_SIZE,
				  PAGE_SIZE),
		    "illegal all-kernel copy_to_user passed");
	ret |= test(!copy_to_user((char __user *)kmem, bad_usermem,
				  PAGE_SIZE),
		    "illegal reversed copy_to_user passed");
	memset(kmem, 0x5a, PAGE_SIZE);
	ret |= test(!get_user(value, (unsigned long __user *)kmem),
		    "illegal get_user passed");
	ret |= test(memcmp(kmem + PAGE_SIZE, kmem, sizeof(value)),
		    "zeroing failure for illegal get_user");
	ret |= test(!put_user(value, (unsigned long __user *)kmem),
		    "illegal put_user passed");

	vm_munmap(user_addr, PAGE_SIZE * 2);
	kfree(kmem);

	if (ret == 0) {
		pr_info("tests passed.\n");
		return 0;
	}

	return -EINVAL;
}

module_init(test_user_copy_init);

static void __exit test_user_copy_exit(void)
{
	pr_info("unloaded.\n");
}

module_exit(test_user_copy_exit);

MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");
MODULE_LICENSE("GPL");
Commit	Line	Data
3e2a4c18 KC	1	/*
	2	* Kernel module for testing copy_to/from_user infrastructure.
	3	*
	4	* Copyright 2013 Google Inc. All Rights Reserved
	5	*
	6	* Authors:
	7	* Kees Cook <keescook@chromium.org>
	8	*
	9	* This software is licensed under the terms of the GNU General Public
	10	* License version 2, as published by the Free Software Foundation, and
	11	* may be copied, distributed, and modified under those terms.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*/
	18
	19	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	20
	21	#include <linux/mman.h>
	22	#include <linux/module.h>
	23	#include <linux/sched.h>
	24	#include <linux/slab.h>
	25	#include <linux/uaccess.h>
	26	#include <linux/vmalloc.h>
	27
	28	#define test(condition, msg) \
	29	({ \
	30	int cond = (condition); \
	31	if (cond) \
	32	pr_warn("%s\n", msg); \
	33	cond; \
	34	})
	35
	36	static int __init test_user_copy_init(void)
	37	{
	38	int ret = 0;
	39	char *kmem;
	40	char __user *usermem;
	41	char *bad_usermem;
	42	unsigned long user_addr;
	43	unsigned long value = 0x5A;
	44
	45	kmem = kmalloc(PAGE_SIZE * 2, GFP_KERNEL);
	46	if (!kmem)
	47	return -ENOMEM;
	48
	49	user_addr = vm_mmap(NULL, 0, PAGE_SIZE * 2,
	50	PROT_READ \| PROT_WRITE \| PROT_EXEC,
	51	MAP_ANONYMOUS \| MAP_PRIVATE, 0);
	52	if (user_addr >= (unsigned long)(TASK_SIZE)) {
	53	pr_warn("Failed to allocate user memory\n");
	54	kfree(kmem);
	55	return -ENOMEM;
	56	}
	57
	58	usermem = (char __user *)user_addr;
	59	bad_usermem = (char *)user_addr;
	60
	61	/* Legitimate usage: none of these should fail. */
	62	ret \|= test(copy_from_user(kmem, usermem, PAGE_SIZE),
	63	"legitimate copy_from_user failed");
	64	ret \|= test(copy_to_user(usermem, kmem, PAGE_SIZE),
65	"legitimate copy_to_user failed");
66	ret \|= test(get_user(value, (unsigned long __user *)usermem),
67	"legitimate get_user failed");
68	ret \|= test(put_user(value, (unsigned long __user *)usermem),
69	"legitimate put_user failed");
70
71	/* Invalid usage: none of these should succeed. */
4fbfeb8b HR	72	memset(kmem, 0x5a, PAGE_SIZE);
4fbfeb8b HR	73	memset(kmem + PAGE_SIZE, 0, PAGE_SIZE);
3e2a4c18 KC	74	ret \|= test(!copy_from_user(kmem, (char __user *)(kmem + PAGE_SIZE),
	75	PAGE_SIZE),
	76	"illegal all-kernel copy_from_user passed");
4fbfeb8b HR	77	ret \|= test(memcmp(kmem + PAGE_SIZE, kmem, PAGE_SIZE),
	78	"zeroing failure for illegal all-kernel copy_from_user");
	79	memset(bad_usermem, 0x5A, PAGE_SIZE);
3e2a4c18 KC	80	ret \|= test(!copy_from_user(bad_usermem, (char __user *)kmem,
	81	PAGE_SIZE),
	82	"illegal reversed copy_from_user passed");
4fbfeb8b HR	83	ret \|= test(memcmp(kmem + PAGE_SIZE, bad_usermem, PAGE_SIZE),
4fbfeb8b HR	84	"zeroing failure for illegal reversed copy_from_user");
3e2a4c18 KC	85	ret \|= test(!copy_to_user((char __user *)kmem, kmem + PAGE_SIZE,
	86	PAGE_SIZE),
	87	"illegal all-kernel copy_to_user passed");
	88	ret \|= test(!copy_to_user((char __user *)kmem, bad_usermem,
	89	PAGE_SIZE),
	90	"illegal reversed copy_to_user passed");
4fbfeb8b	91	memset(kmem, 0x5a, PAGE_SIZE);
3e2a4c18 KC	92	ret \|= test(!get_user(value, (unsigned long __user *)kmem),
3e2a4c18 KC	93	"illegal get_user passed");
4fbfeb8b HR	94	ret \|= test(memcmp(kmem + PAGE_SIZE, kmem, sizeof(value)),
4fbfeb8b HR	95	"zeroing failure for illegal get_user");
3e2a4c18 KC	96	ret \|= test(!put_user(value, (unsigned long __user *)kmem),
	97	"illegal put_user passed");
	98
	99	vm_munmap(user_addr, PAGE_SIZE * 2);
	100	kfree(kmem);
	101
	102	if (ret == 0) {
	103	pr_info("tests passed.\n");
	104	return 0;
	105	}
	106
	107	return -EINVAL;
	108	}
	109
	110	module_init(test_user_copy_init);
	111
	112	static void __exit test_user_copy_exit(void)
	113	{
	114	pr_info("unloaded.\n");
	115	}
	116
	117	module_exit(test_user_copy_exit);
	118
	119	MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");
	120	MODULE_LICENSE("GPL");