1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * This is for all the tests relating directly to heap memory, including
  4 * page allocation and slab allocations.
  5 */
  6#include "lkdtm.h"
  7#include <linux/slab.h>
  8#include <linux/sched.h>
  9
 10static struct kmem_cache *double_free_cache;
 11static struct kmem_cache *a_cache;
 12static struct kmem_cache *b_cache;
 13
 14/*
 15 * This tries to stay within the next largest power-of-2 kmalloc cache
 16 * to avoid actually overwriting anything important if it's not detected
 17 * correctly.
 18 */
 19void lkdtm_OVERWRITE_ALLOCATION(void)
 20{
 21	size_t len = 1020;
 22	u32 *data = kmalloc(len, GFP_KERNEL);
 23	if (!data)
 24		return;
 25
 26	data[1024 / sizeof(u32)] = 0x12345678;
 27	kfree(data);
 28}
 29
 30void lkdtm_WRITE_AFTER_FREE(void)
 31{
 32	int *base, *again;
 33	size_t len = 1024;
 34	/*
 35	 * The slub allocator uses the first word to store the free
 36	 * pointer in some configurations. Use the middle of the
 37	 * allocation to avoid running into the freelist
 38	 */
 39	size_t offset = (len / sizeof(*base)) / 2;
 40
 41	base = kmalloc(len, GFP_KERNEL);
 42	if (!base)
 43		return;
 44	pr_info("Allocated memory %p-%p\n", base, &base[offset * 2]);
 45	pr_info("Attempting bad write to freed memory at %p\n",
 46		&base[offset]);
 47	kfree(base);
 48	base[offset] = 0x0abcdef0;
 49	/* Attempt to notice the overwrite. */
 50	again = kmalloc(len, GFP_KERNEL);
 51	kfree(again);
 52	if (again != base)
 53		pr_info("Hmm, didn't get the same memory range.\n");
 54}
 55
 56void lkdtm_READ_AFTER_FREE(void)
 57{
 58	int *base, *val, saw;
 59	size_t len = 1024;
 60	/*
 61	 * The slub allocator will use the either the first word or
 62	 * the middle of the allocation to store the free pointer,
 63	 * depending on configurations. Store in the second word to
 64	 * avoid running into the freelist.
 65	 */
 66	size_t offset = sizeof(*base);
 67
 68	base = kmalloc(len, GFP_KERNEL);
 69	if (!base) {
 70		pr_info("Unable to allocate base memory.\n");
 71		return;
 72	}
 73
 74	val = kmalloc(len, GFP_KERNEL);
 75	if (!val) {
 76		pr_info("Unable to allocate val memory.\n");
 77		kfree(base);
 78		return;
 79	}
 80
 81	*val = 0x12345678;
 82	base[offset] = *val;
 83	pr_info("Value in memory before free: %x\n", base[offset]);
 84
 85	kfree(base);
 86
 87	pr_info("Attempting bad read from freed memory\n");
 88	saw = base[offset];
 89	if (saw != *val) {
 90		/* Good! Poisoning happened, so declare a win. */
 91		pr_info("Memory correctly poisoned (%x)\n", saw);
 92		BUG();
 93	}
 94	pr_info("Memory was not poisoned\n");
 95
 96	kfree(val);
 97}
 98
 99void lkdtm_WRITE_BUDDY_AFTER_FREE(void)
100{
101	unsigned long p = __get_free_page(GFP_KERNEL);
102	if (!p) {
103		pr_info("Unable to allocate free page\n");
104		return;
105	}
106
107	pr_info("Writing to the buddy page before free\n");
108	memset((void *)p, 0x3, PAGE_SIZE);
109	free_page(p);
110	schedule();
111	pr_info("Attempting bad write to the buddy page after free\n");
112	memset((void *)p, 0x78, PAGE_SIZE);
113	/* Attempt to notice the overwrite. */
114	p = __get_free_page(GFP_KERNEL);
115	free_page(p);
116	schedule();
117}
118
119void lkdtm_READ_BUDDY_AFTER_FREE(void)
120{
121	unsigned long p = __get_free_page(GFP_KERNEL);
122	int saw, *val;
123	int *base;
124
125	if (!p) {
126		pr_info("Unable to allocate free page\n");
127		return;
128	}
129
130	val = kmalloc(1024, GFP_KERNEL);
131	if (!val) {
132		pr_info("Unable to allocate val memory.\n");
133		free_page(p);
134		return;
135	}
136
137	base = (int *)p;
138
139	*val = 0x12345678;
140	base[0] = *val;
141	pr_info("Value in memory before free: %x\n", base[0]);
142	free_page(p);
143	pr_info("Attempting to read from freed memory\n");
144	saw = base[0];
145	if (saw != *val) {
146		/* Good! Poisoning happened, so declare a win. */
147		pr_info("Memory correctly poisoned (%x)\n", saw);
148		BUG();
149	}
150	pr_info("Buddy page was not poisoned\n");
151
152	kfree(val);
153}
154
155void lkdtm_SLAB_FREE_DOUBLE(void)
156{
157	int *val;
158
159	val = kmem_cache_alloc(double_free_cache, GFP_KERNEL);
160	if (!val) {
161		pr_info("Unable to allocate double_free_cache memory.\n");
162		return;
163	}
164
165	/* Just make sure we got real memory. */
166	*val = 0x12345678;
167	pr_info("Attempting double slab free ...\n");
168	kmem_cache_free(double_free_cache, val);
169	kmem_cache_free(double_free_cache, val);
170}
171
172void lkdtm_SLAB_FREE_CROSS(void)
173{
174	int *val;
175
176	val = kmem_cache_alloc(a_cache, GFP_KERNEL);
177	if (!val) {
178		pr_info("Unable to allocate a_cache memory.\n");
179		return;
180	}
181
182	/* Just make sure we got real memory. */
183	*val = 0x12345679;
184	pr_info("Attempting cross-cache slab free ...\n");
185	kmem_cache_free(b_cache, val);
186}
187
188void lkdtm_SLAB_FREE_PAGE(void)
189{
190	unsigned long p = __get_free_page(GFP_KERNEL);
191
192	pr_info("Attempting non-Slab slab free ...\n");
193	kmem_cache_free(NULL, (void *)p);
194	free_page(p);
195}
196
197/*
198 * We have constructors to keep the caches distinctly separated without
199 * needing to boot with "slab_nomerge".
200 */
201static void ctor_double_free(void *region)
202{ }
203static void ctor_a(void *region)
204{ }
205static void ctor_b(void *region)
206{ }
207
208void __init lkdtm_heap_init(void)
209{
210	double_free_cache = kmem_cache_create("lkdtm-heap-double_free",
211					      64, 0, 0, ctor_double_free);
212	a_cache = kmem_cache_create("lkdtm-heap-a", 64, 0, 0, ctor_a);
213	b_cache = kmem_cache_create("lkdtm-heap-b", 64, 0, 0, ctor_b);
214}
215
216void __exit lkdtm_heap_exit(void)
217{
218	kmem_cache_destroy(double_free_cache);
219	kmem_cache_destroy(a_cache);
220	kmem_cache_destroy(b_cache);
221}