drivers/misc/lkdtm/perms.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * This is for all the tests related to validating kernel memory
   4  * permissions: non-executable regions, non-writable regions, and
   5  * even non-readable regions.
   6  */
   7 #include "lkdtm.h"
   8 #include <linux/slab.h>
   9 #include <linux/vmalloc.h>
  10 #include <linux/mman.h>
  11 #include <linux/uaccess.h>
  12 #include <asm/cacheflush.h>
  13
  14 /* Whether or not to fill the target memory area with do_nothing(). */
  15 #define CODE_WRITE      true
  16 #define CODE_AS_IS      false
  17
  18 /* How many bytes to copy to be sure we've copied enough of do_nothing(). */
  19 #define EXEC_SIZE 64
  20
  21 /* This is non-const, so it will end up in the .data section. */
  22 static u8 data_area[EXEC_SIZE];
  23
  24 /* This is cost, so it will end up in the .rodata section. */
  25 static const unsigned long rodata = 0xAA55AA55;
  26
  27 /* This is marked __ro_after_init, so it should ultimately be .rodata. */
  28 static unsigned long ro_after_init __ro_after_init = 0x55AA5500;
  29
  30 /*
  31  * This just returns to the caller. It is designed to be copied into
  32  * non-executable memory regions.
  33  */
  34 static void do_nothing(void)
  35 {
  36         return;
  37 }
  38
  39 /* Must immediately follow do_nothing for size calculuations to work out. */
  40 static void do_overwritten(void)
  41 {
  42         pr_info("do_overwritten wasn't overwritten!\n");
  43         return;
  44 }
  45
  46 static noinline void execute_location(void *dst, bool write)
  47 {
  48         void (*func)(void) = dst;
  49
  50         pr_info("attempting ok execution at %px\n", do_nothing);
  51         do_nothing();
  52
  53         if (write == CODE_WRITE) {
  54                 memcpy(dst, do_nothing, EXEC_SIZE);
  55                 flush_icache_range((unsigned long)dst,
  56                                    (unsigned long)dst + EXEC_SIZE);
  57         }
  58         pr_info("attempting bad execution at %px\n", func);
  59         func();
  60         pr_err("FAIL: func returned\n");
  61 }
  62
  63 static void execute_user_location(void *dst)
  64 {
  65         int copied;
  66
  67         /* Intentionally crossing kernel/user memory boundary. */
  68         void (*func)(void) = dst;
  69
  70         pr_info("attempting ok execution at %px\n", do_nothing);
  71         do_nothing();
  72
  73         copied = access_process_vm(current, (unsigned long)dst, do_nothing,
  74                                    EXEC_SIZE, FOLL_WRITE);
  75         if (copied < EXEC_SIZE)
  76                 return;
  77         pr_info("attempting bad execution at %px\n", func);
  78         func();
  79         pr_err("FAIL: func returned\n");
  80 }
  81
  82 void lkdtm_WRITE_RO(void)
  83 {
  84         /* Explicitly cast away "const" for the test and make volatile. */
  85         volatile unsigned long *ptr = (unsigned long *)&rodata;
  86
  87         pr_info("attempting bad rodata write at %px\n", ptr);
  88         *ptr ^= 0xabcd1234;
  89         pr_err("FAIL: survived bad write\n");
  90 }
  91
  92 void lkdtm_WRITE_RO_AFTER_INIT(void)
  93 {
  94         volatile unsigned long *ptr = &ro_after_init;
  95
  96         /*
  97          * Verify we were written to during init. Since an Oops
  98          * is considered a "success", a failure is to just skip the
  99          * real test.
 100          */
 101         if ((*ptr & 0xAA) != 0xAA) {
 102                 pr_info("%p was NOT written during init!?\n", ptr);
 103                 return;
 104         }
 105
 106         pr_info("attempting bad ro_after_init write at %px\n", ptr);
 107         *ptr ^= 0xabcd1234;
 108         pr_err("FAIL: survived bad write\n");
 109 }
 110
 111 void lkdtm_WRITE_KERN(void)
 112 {
 113         size_t size;
 114         volatile unsigned char *ptr;
 115
 116         size = (unsigned long)do_overwritten - (unsigned long)do_nothing;
 117         ptr = (unsigned char *)do_overwritten;
 118
 119         pr_info("attempting bad %zu byte write at %px\n", size, ptr);
 120         memcpy((void *)ptr, (unsigned char *)do_nothing, size);
 121         flush_icache_range((unsigned long)ptr, (unsigned long)(ptr + size));
 122         pr_err("FAIL: survived bad write\n");
 123
 124         do_overwritten();
 125 }
 126
 127 void lkdtm_EXEC_DATA(void)
 128 {
 129         execute_location(data_area, CODE_WRITE);
 130 }
 131
 132 void lkdtm_EXEC_STACK(void)
 133 {
 134         u8 stack_area[EXEC_SIZE];
 135         execute_location(stack_area, CODE_WRITE);
 136 }
 137
 138 void lkdtm_EXEC_KMALLOC(void)
 139 {
 140         u32 *kmalloc_area = kmalloc(EXEC_SIZE, GFP_KERNEL);
 141         execute_location(kmalloc_area, CODE_WRITE);
 142         kfree(kmalloc_area);
 143 }
 144
 145 void lkdtm_EXEC_VMALLOC(void)
 146 {
 147         u32 *vmalloc_area = vmalloc(EXEC_SIZE);
 148         execute_location(vmalloc_area, CODE_WRITE);
 149         vfree(vmalloc_area);
 150 }
 151
 152 void lkdtm_EXEC_RODATA(void)
 153 {
 154         execute_location(lkdtm_rodata_do_nothing, CODE_AS_IS);
 155 }
 156
 157 void lkdtm_EXEC_USERSPACE(void)
 158 {
 159         unsigned long user_addr;
 160
 161         user_addr = vm_mmap(NULL, 0, PAGE_SIZE,
 162                             PROT_READ | PROT_WRITE | PROT_EXEC,
 163                             MAP_ANONYMOUS | MAP_PRIVATE, 0);
 164         if (user_addr >= TASK_SIZE) {
 165                 pr_warn("Failed to allocate user memory\n");
 166                 return;
 167         }
 168         execute_user_location((void *)user_addr);
 169         vm_munmap(user_addr, PAGE_SIZE);
 170 }
 171
 172 void lkdtm_EXEC_NULL(void)
 173 {
 174         execute_location(NULL, CODE_AS_IS);
 175 }
 176
 177 void lkdtm_ACCESS_USERSPACE(void)
 178 {
 179         unsigned long user_addr, tmp = 0;
 180         unsigned long *ptr;
 181
 182         user_addr = vm_mmap(NULL, 0, PAGE_SIZE,
 183                             PROT_READ | PROT_WRITE | PROT_EXEC,
 184                             MAP_ANONYMOUS | MAP_PRIVATE, 0);
 185         if (user_addr >= TASK_SIZE) {
 186                 pr_warn("Failed to allocate user memory\n");
 187                 return;
 188         }
 189
 190         if (copy_to_user((void __user *)user_addr, &tmp, sizeof(tmp))) {
 191                 pr_warn("copy_to_user failed\n");
 192                 vm_munmap(user_addr, PAGE_SIZE);
 193                 return;
 194         }
 195
 196         ptr = (unsigned long *)user_addr;
 197
 198         pr_info("attempting bad read at %px\n", ptr);
 199         tmp = *ptr;
 200         tmp += 0xc0dec0de;
 201         pr_err("FAIL: survived bad read\n");
 202
 203         pr_info("attempting bad write at %px\n", ptr);
 204         *ptr = tmp;
 205         pr_err("FAIL: survived bad write\n");
 206
 207         vm_munmap(user_addr, PAGE_SIZE);
 208 }
 209
 210 void lkdtm_ACCESS_NULL(void)
 211 {
 212         unsigned long tmp;
 213         volatile unsigned long *ptr = (unsigned long *)NULL;
 214
 215         pr_info("attempting bad read at %px\n", ptr);
 216         tmp = *ptr;
 217         tmp += 0xc0dec0de;
 218         pr_err("FAIL: survived bad read\n");
 219
 220         pr_info("attempting bad write at %px\n", ptr);
 221         *ptr = tmp;
 222         pr_err("FAIL: survived bad write\n");
 223 }
 224
 225 void __init lkdtm_perms_init(void)
 226 {
 227         /* Make sure we can write to __ro_after_init values during __init */
 228         ro_after_init |= 0xAA;
 229 }