1 // SPDX-License-Identifier: BSD-2-Clause 2 /* 3 * Copyright (C) 2018-2022, Linaro Limited 4 */ 5 6 /* 7 * Developerbox doesn't provide a hardware based true random number 8 * generator. So this pseudo TA provides a good source of entropy using 9 * noise from 7 thermal sensors. Its suitable for entropy required 10 * during boot, seeding kernel entropy pool, cryptographic use etc. 11 * 12 * Assumption 13 * ========== 14 * 15 * We have assumed the entropy of the sensor is better than 8 bits per 16 * 14 sensor readings. This entropy estimate is based on our simple 17 * minimal entropy estimates done on 2.1G bytes of raw samples collected 18 * from thermal sensors. 19 * 20 * We believe our estimate to be conservative and have designed to 21 * health tests to trigger if a sensor does not achieve at least 22 * 8 bits in 16 sensor reading (we use 16 rather than 14 to prevent 23 * spurious failures on edge cases). 24 * 25 * Theory of operation 26 * =================== 27 * 28 * This routine uses secure timer interrupt to sample raw thermal sensor 29 * readings. As thermal sensor refresh rate is every 2ms, so interrupt 30 * fires every 2ms. It implements continuous health test counting rising 31 * and falling edges to report if sensors fail to provide entropy. 32 * 33 * It uses vetted conditioner as SHA512/256 (approved hash algorithm) 34 * to condense entropy. As per NIST.SP.800-90B spec, to get full entropy 35 * from vetted conditioner, we need to supply double of input entropy. 36 * According to assumption above and requirement for vetted conditioner, 37 * we need to supply 28 raw sensor readings to get 1 byte of full 38 * entropy as output. So for 32 bytes of conditioner output, we need to 39 * supply 896 bytes of raw sensor readings. 40 * 41 * Interfaces -> Input 42 * ------------------- 43 * 44 * void rng_collect_entropy(void); 45 * 46 * Called as part of secure timer interrupt handler to sample raw 47 * thermal sensor readings and add entropy to the pool. 48 * 49 * Interfaces -> Output 50 * -------------------- 51 * 52 * TEE_Result rng_get_entropy(uint32_t types, 53 * TEE_Param params[TEE_NUM_PARAMS]); 54 * 55 * Invoke command to expose an entropy interface to normal world. 56 * 57 * Testing 58 * ======= 59 * 60 * Passes FIPS 140-2 rngtest. 61 * 62 * Limitations 63 * =========== 64 * 65 * Output rate is limited to approx. 125 bytes per second. 66 * 67 * Our entropy estimation was not reached using any approved or 68 * published estimation framework such as NIST.SP.800-90B and was tested 69 * on a very small set of physical samples. Instead we have adopted what 70 * we believe to be a conservative estimate and partnered it with a 71 * fairly agressive health check. 72 * 73 * Generating the SHA512/256 hash takes 24uS and will be run by an 74 * interrupt handler that pre-empts the normal world. 75 */ 76 77 #include <crypto/crypto.h> 78 #include <kernel/delay.h> 79 #include <kernel/pseudo_ta.h> 80 #include <kernel/spinlock.h> 81 #include <kernel/timer.h> 82 #include <mm/core_memprot.h> 83 #include <io.h> 84 #include <pta_rng.h> 85 #include <string.h> 86 87 #include "synquacer_rng_pta.h" 88 89 #define PTA_NAME "rng.pta" 90 91 #define THERMAL_SENSOR_BASE0 0x54190800 92 #define THERMAL_SENSOR_OFFSET 0x80 93 #define NUM_SENSORS 7 94 #define NUM_SLOTS ((NUM_SENSORS * 2) - 1) 95 96 #define TEMP_DATA_REG_OFFSET 0x34 97 98 #define ENTROPY_POOL_SIZE 4096 99 100 #define SENSOR_DATA_SIZE 128 101 #define CONDITIONER_PAYLOAD (SENSOR_DATA_SIZE * NUM_SENSORS) 102 103 /* 104 * The health test monitors each sensor's least significant bit and counts 105 * the number of rising and falling edges. It verifies that both counts 106 * lie within interval of between 12.5% and 37.5% of the samples. 107 * For true random data with 8 bits of entropy per byte, both counts would 108 * be close to 25%. 109 */ 110 #define MAX_BIT_FLIP_EDGE_COUNT ((3 * SENSOR_DATA_SIZE) / 8) 111 #define MIN_BIT_FLIP_EDGE_COUNT (SENSOR_DATA_SIZE / 8) 112 113 static uint8_t entropy_pool[ENTROPY_POOL_SIZE] = {0}; 114 static uint32_t entropy_size; 115 116 static uint8_t sensors_data[NUM_SLOTS][SENSOR_DATA_SIZE] = {0}; 117 static uint8_t sensors_data_slot_idx; 118 static uint8_t sensors_data_idx; 119 120 static uint32_t health_test_fail_cnt; 121 static uint32_t health_test_cnt; 122 123 static unsigned int entropy_lock = SPINLOCK_UNLOCK; 124 125 static void pool_add_entropy(uint8_t *entropy, uint32_t size) 126 { 127 uint32_t copy_size; 128 129 if (entropy_size >= ENTROPY_POOL_SIZE) 130 return; 131 132 if ((ENTROPY_POOL_SIZE - entropy_size) >= size) 133 copy_size = size; 134 else 135 copy_size = ENTROPY_POOL_SIZE - entropy_size; 136 137 memcpy((entropy_pool + entropy_size), entropy, copy_size); 138 139 entropy_size += copy_size; 140 } 141 142 static void pool_get_entropy(uint8_t *buf, uint32_t size) 143 { 144 uint32_t off; 145 146 if (size > entropy_size) 147 return; 148 149 off = entropy_size - size; 150 151 memcpy(buf, &entropy_pool[off], size); 152 entropy_size -= size; 153 } 154 155 static bool health_test(uint8_t sensor_id) 156 { 157 uint32_t falling_edge_count = 0, rising_edge_count = 0; 158 uint32_t lo_edge_count, hi_edge_count; 159 uint32_t i; 160 161 for (i = 0; i < (SENSOR_DATA_SIZE - 1); i++) { 162 if ((sensors_data[sensor_id][i] ^ 163 sensors_data[sensor_id][i + 1]) & 0x1) { 164 falling_edge_count += (sensors_data[sensor_id][i] & 165 0x1); 166 rising_edge_count += (sensors_data[sensor_id][i + 1] & 167 0x1); 168 } 169 } 170 171 lo_edge_count = rising_edge_count < falling_edge_count ? 172 rising_edge_count : falling_edge_count; 173 hi_edge_count = rising_edge_count < falling_edge_count ? 174 falling_edge_count : rising_edge_count; 175 176 return (lo_edge_count >= MIN_BIT_FLIP_EDGE_COUNT) && 177 (hi_edge_count <= MAX_BIT_FLIP_EDGE_COUNT); 178 } 179 180 static uint8_t pool_check_add_entropy(void) 181 { 182 uint32_t i; 183 uint8_t entropy_sha512_256[TEE_SHA256_HASH_SIZE]; 184 uint8_t pool_status = 0; 185 TEE_Result res; 186 187 for (i = 0; i < NUM_SENSORS; i++) { 188 /* Check if particular sensor data passes health test */ 189 if (health_test(sensors_data_slot_idx) == true) { 190 sensors_data_slot_idx++; 191 } else { 192 health_test_fail_cnt++; 193 memmove(sensors_data[sensors_data_slot_idx], 194 sensors_data[sensors_data_slot_idx + 1], 195 (SENSOR_DATA_SIZE * (NUM_SENSORS - i - 1))); 196 } 197 } 198 199 health_test_cnt += NUM_SENSORS; 200 201 /* Check if sensors_data have enough pass data for conditioning */ 202 if (sensors_data_slot_idx >= NUM_SENSORS) { 203 /* 204 * Use vetted conditioner SHA512/256 as per 205 * NIST.SP.800-90B to condition raw data from entropy 206 * source. 207 */ 208 sensors_data_slot_idx -= NUM_SENSORS; 209 res = hash_sha512_256_compute(entropy_sha512_256, 210 sensors_data[sensors_data_slot_idx], 211 CONDITIONER_PAYLOAD); 212 if (res == TEE_SUCCESS) 213 pool_add_entropy(entropy_sha512_256, 214 TEE_SHA256_HASH_SIZE); 215 } 216 217 if (entropy_size >= ENTROPY_POOL_SIZE) 218 pool_status = 1; 219 220 return pool_status; 221 } 222 223 void rng_collect_entropy(void) 224 { 225 uint8_t i, pool_full = 0; 226 void *vaddr; 227 uint32_t exceptions = thread_mask_exceptions(THREAD_EXCP_ALL); 228 229 cpu_spin_lock(&entropy_lock); 230 231 for (i = 0; i < NUM_SENSORS; i++) { 232 vaddr = phys_to_virt_io(THERMAL_SENSOR_BASE0 + 233 (THERMAL_SENSOR_OFFSET * i) + 234 TEMP_DATA_REG_OFFSET, 235 sizeof(uint32_t)); 236 sensors_data[sensors_data_slot_idx + i][sensors_data_idx] = 237 (uint8_t)io_read32((vaddr_t)vaddr); 238 } 239 240 sensors_data_idx++; 241 242 if (sensors_data_idx >= SENSOR_DATA_SIZE) { 243 pool_full = pool_check_add_entropy(); 244 sensors_data_idx = 0; 245 } 246 247 if (pool_full) 248 generic_timer_stop(); 249 250 cpu_spin_unlock(&entropy_lock); 251 thread_set_exceptions(exceptions); 252 } 253 254 static TEE_Result rng_get_entropy(uint32_t types, 255 TEE_Param params[TEE_NUM_PARAMS]) 256 { 257 uint8_t *e = NULL; 258 uint32_t pool_size = 0, rq_size = 0; 259 uint32_t exceptions; 260 TEE_Result res = TEE_SUCCESS; 261 262 if (types != TEE_PARAM_TYPES(TEE_PARAM_TYPE_MEMREF_INOUT, 263 TEE_PARAM_TYPE_NONE, 264 TEE_PARAM_TYPE_NONE, 265 TEE_PARAM_TYPE_NONE)) { 266 EMSG("bad parameters types: 0x%" PRIx32, types); 267 return TEE_ERROR_BAD_PARAMETERS; 268 } 269 270 rq_size = params[0].memref.size; 271 272 if ((rq_size == 0) || (rq_size > ENTROPY_POOL_SIZE)) 273 return TEE_ERROR_NOT_SUPPORTED; 274 275 e = (uint8_t *)params[0].memref.buffer; 276 if (!e) 277 return TEE_ERROR_BAD_PARAMETERS; 278 279 exceptions = thread_mask_exceptions(THREAD_EXCP_ALL); 280 cpu_spin_lock(&entropy_lock); 281 282 /* 283 * Report health test failure to normal world in case fail count 284 * exceeds 1% of pass count. 285 */ 286 if (health_test_fail_cnt > ((health_test_cnt + 100) / 100)) { 287 res = TEE_ERROR_HEALTH_TEST_FAIL; 288 params[0].memref.size = 0; 289 health_test_cnt = 0; 290 health_test_fail_cnt = 0; 291 goto exit; 292 } 293 294 pool_size = entropy_size; 295 296 if (pool_size < rq_size) { 297 params[0].memref.size = pool_size; 298 pool_get_entropy(e, pool_size); 299 } else { 300 params[0].memref.size = rq_size; 301 pool_get_entropy(e, rq_size); 302 } 303 304 exit: 305 /* Enable timer FIQ to fetch entropy */ 306 generic_timer_start(TIMER_PERIOD_MS); 307 308 cpu_spin_unlock(&entropy_lock); 309 thread_set_exceptions(exceptions); 310 311 return res; 312 } 313 314 static TEE_Result rng_get_info(uint32_t types, 315 TEE_Param params[TEE_NUM_PARAMS]) 316 { 317 if (types != TEE_PARAM_TYPES(TEE_PARAM_TYPE_VALUE_OUTPUT, 318 TEE_PARAM_TYPE_NONE, 319 TEE_PARAM_TYPE_NONE, 320 TEE_PARAM_TYPE_NONE)) { 321 EMSG("bad parameters types: 0x%" PRIx32, types); 322 return TEE_ERROR_BAD_PARAMETERS; 323 } 324 325 /* Output RNG rate (per second) */ 326 params[0].value.a = 125; 327 328 /* 329 * Quality/entropy per 1024 bit of output data. As we have used 330 * a vetted conditioner as per NIST.SP.800-90B to provide full 331 * entropy given our assumption of entropy estimate for raw sensor 332 * data. 333 */ 334 params[0].value.b = 1024; 335 336 return TEE_SUCCESS; 337 } 338 339 static TEE_Result invoke_command(void *pSessionContext __unused, 340 uint32_t nCommandID, uint32_t nParamTypes, 341 TEE_Param pParams[TEE_NUM_PARAMS]) 342 { 343 FMSG("command entry point for pseudo-TA \"%s\"", PTA_NAME); 344 345 switch (nCommandID) { 346 case PTA_CMD_GET_ENTROPY: 347 return rng_get_entropy(nParamTypes, pParams); 348 case PTA_CMD_GET_RNG_INFO: 349 return rng_get_info(nParamTypes, pParams); 350 default: 351 break; 352 } 353 354 return TEE_ERROR_NOT_IMPLEMENTED; 355 } 356 357 pseudo_ta_register(.uuid = PTA_RNG_UUID, .name = PTA_NAME, 358 .flags = PTA_DEFAULT_FLAGS | TA_FLAG_DEVICE_ENUM, 359 .invoke_command_entry_point = invoke_command); 360