arch/s390/boot/kaslr.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright IBM Corp. 2019
   4  */
   5 #include <asm/mem_detect.h>
   6 #include <asm/pgtable.h>
   7 #include <asm/cpacf.h>
   8 #include <asm/timex.h>
   9 #include <asm/sclp.h>
  10 #include "compressed/decompressor.h"
  11 #include "boot.h"
  12
  13 #define PRNG_MODE_TDES   1
  14 #define PRNG_MODE_SHA512 2
  15 #define PRNG_MODE_TRNG   3
  16
  17 struct prno_parm {
  18         u32 res;
  19         u32 reseed_counter;
  20         u64 stream_bytes;
  21         u8  V[112];
  22         u8  C[112];
  23 };
  24
  25 struct prng_parm {
  26         u8  parm_block[32];
  27         u32 reseed_counter;
  28         u64 byte_counter;
  29 };
  30
  31 static int check_prng(void)
  32 {
  33         if (!cpacf_query_func(CPACF_KMC, CPACF_KMC_PRNG)) {
  34                 sclp_early_printk("KASLR disabled: CPU has no PRNG\n");
  35                 return 0;
  36         }
  37         if (cpacf_query_func(CPACF_PRNO, CPACF_PRNO_TRNG))
  38                 return PRNG_MODE_TRNG;
  39         if (cpacf_query_func(CPACF_PRNO, CPACF_PRNO_SHA512_DRNG_GEN))
  40                 return PRNG_MODE_SHA512;
  41         else
  42                 return PRNG_MODE_TDES;
  43 }
  44
  45 static unsigned long get_random(unsigned long limit)
  46 {
  47         struct prng_parm prng = {
  48                 /* initial parameter block for tdes mode, copied from libica */
  49                 .parm_block = {
  50                         0x0F, 0x2B, 0x8E, 0x63, 0x8C, 0x8E, 0xD2, 0x52,
  51                         0x64, 0xB7, 0xA0, 0x7B, 0x75, 0x28, 0xB8, 0xF4,
  52                         0x75, 0x5F, 0xD2, 0xA6, 0x8D, 0x97, 0x11, 0xFF,
  53                         0x49, 0xD8, 0x23, 0xF3, 0x7E, 0x21, 0xEC, 0xA0
  54                 },
  55         };
  56         unsigned long seed, random;
  57         struct prno_parm prno;
  58         __u64 entropy[4];
  59         int mode, i;
  60
  61         mode = check_prng();
  62         seed = get_tod_clock_fast();
  63         switch (mode) {
  64         case PRNG_MODE_TRNG:
  65                 cpacf_trng(NULL, 0, (u8 *) &random, sizeof(random));
  66                 break;
  67         case PRNG_MODE_SHA512:
  68                 cpacf_prno(CPACF_PRNO_SHA512_DRNG_SEED, &prno, NULL, 0,
  69                            (u8 *) &seed, sizeof(seed));
  70                 cpacf_prno(CPACF_PRNO_SHA512_DRNG_GEN, &prno, (u8 *) &random,
  71                            sizeof(random), NULL, 0);
  72                 break;
  73         case PRNG_MODE_TDES:
  74                 /* add entropy */
  75                 *(unsigned long *) prng.parm_block ^= seed;
  76                 for (i = 0; i < 16; i++) {
  77                         cpacf_kmc(CPACF_KMC_PRNG, prng.parm_block,
  78                                   (u8 *) entropy, (u8 *) entropy,
  79                                   sizeof(entropy));
  80                         memcpy(prng.parm_block, entropy, sizeof(entropy));
  81                 }
  82                 random = seed;
  83                 cpacf_kmc(CPACF_KMC_PRNG, prng.parm_block, (u8 *) &random,
  84                           (u8 *) &random, sizeof(random));
  85                 break;
  86         default:
  87                 random = 0;
  88         }
  89         return random % limit;
  90 }
  91
  92 unsigned long get_random_base(unsigned long safe_addr)
  93 {
  94         unsigned long memory_limit = memory_end_set ? memory_end : 0;
  95         unsigned long base, start, end, kernel_size;
  96         unsigned long block_sum, offset;
  97         unsigned long kasan_needs;
  98         int i;
  99
 100         if (IS_ENABLED(CONFIG_BLK_DEV_INITRD) && INITRD_START && INITRD_SIZE) {
 101                 if (safe_addr < INITRD_START + INITRD_SIZE)
 102                         safe_addr = INITRD_START + INITRD_SIZE;
 103         }
 104         safe_addr = ALIGN(safe_addr, THREAD_SIZE);
 105
 106         if ((IS_ENABLED(CONFIG_KASAN))) {
 107                 /*
 108                  * Estimate kasan memory requirements, which it will reserve
 109                  * at the very end of available physical memory. To estimate
 110                  * that, we take into account that kasan would require
 111                  * 1/8 of available physical memory (for shadow memory) +
 112                  * creating page tables for the whole memory + shadow memory
 113                  * region (1 + 1/8). To keep page tables estimates simple take
 114                  * the double of combined ptes size.
 115                  */
 116                 memory_limit = get_mem_detect_end();
 117                 if (memory_end_set && memory_limit > memory_end)
 118                         memory_limit = memory_end;
 119
 120                 /* for shadow memory */
 121                 kasan_needs = memory_limit / 8;
 122                 /* for paging structures */
 123                 kasan_needs += (memory_limit + kasan_needs) / PAGE_SIZE /
 124                                _PAGE_ENTRIES * _PAGE_TABLE_SIZE * 2;
 125                 memory_limit -= kasan_needs;
 126         }
 127
 128         kernel_size = vmlinux.image_size + vmlinux.bss_size;
 129         block_sum = 0;
 130         for_each_mem_detect_block(i, &start, &end) {
 131                 if (memory_limit) {
 132                         if (start >= memory_limit)
 133                                 break;
 134                         if (end > memory_limit)
 135                                 end = memory_limit;
 136                 }
 137                 if (end - start < kernel_size)
 138                         continue;
 139                 block_sum += end - start - kernel_size;
 140         }
 141         if (!block_sum) {
 142                 sclp_early_printk("KASLR disabled: not enough memory\n");
 143                 return 0;
 144         }
 145
 146         base = get_random(block_sum);
 147         if (base == 0)
 148                 return 0;
 149         if (base < safe_addr)
 150                 base = safe_addr;
 151         block_sum = offset = 0;
 152         for_each_mem_detect_block(i, &start, &end) {
 153                 if (memory_limit) {
 154                         if (start >= memory_limit)
 155                                 break;
 156                         if (end > memory_limit)
 157                                 end = memory_limit;
 158                 }
 159                 if (end - start < kernel_size)
 160                         continue;
 161                 block_sum += end - start - kernel_size;
 162                 if (base <= block_sum) {
 163                         base = start + base - offset;
 164                         base = ALIGN_DOWN(base, THREAD_SIZE);
 165                         break;
 166                 }
 167                 offset = block_sum;
 168         }
 169         return base;
 170 }