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