[mirror_ubuntu-zesty-kernel.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. */
	ret |= test(!copy_from_user(kmem, (char __user *)(kmem + PAGE_SIZE),
				    PAGE_SIZE),
		    "illegal all-kernel copy_from_user passed");
	ret |= test(!copy_from_user(bad_usermem, (char __user *)kmem,
				    PAGE_SIZE),
		    "illegal reversed copy_from_user passed");
	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");
	ret |= test(!get_user(value, (unsigned long __user *)kmem),
		    "illegal get_user passed");
	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. */
72	ret \|= test(!copy_from_user(kmem, (char __user *)(kmem + PAGE_SIZE),
73	PAGE_SIZE),
74	"illegal all-kernel copy_from_user passed");
75	ret \|= test(!copy_from_user(bad_usermem, (char __user *)kmem,
76	PAGE_SIZE),
77	"illegal reversed copy_from_user passed");
78	ret \|= test(!copy_to_user((char __user *)kmem, kmem + PAGE_SIZE,
79	PAGE_SIZE),
80	"illegal all-kernel copy_to_user passed");
81	ret \|= test(!copy_to_user((char __user *)kmem, bad_usermem,
82	PAGE_SIZE),
83	"illegal reversed copy_to_user passed");
84	ret \|= test(!get_user(value, (unsigned long __user *)kmem),
85	"illegal get_user passed");
86	ret \|= test(!put_user(value, (unsigned long __user *)kmem),
87	"illegal put_user passed");
88
89	vm_munmap(user_addr, PAGE_SIZE * 2);
90	kfree(kmem);
91
92	if (ret == 0) {
93	pr_info("tests passed.\n");
94	return 0;
95	}
96
97	return -EINVAL;
98	}
99
100	module_init(test_user_copy_init);
101
102	static void __exit test_user_copy_exit(void)
103	{
104	pr_info("unloaded.\n");
105	}
106
107	module_exit(test_user_copy_exit);
108
109	MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");
110	MODULE_LICENSE("GPL");