void trickle_setup(uint32_t i_min, uint32_t i_max, uint8_t k) { g_i_min = i_min; g_i_max = i_max; g_k = k; uint32_t error_code; rng_index = 0; /* Fill rng pool */ uint8_t bytes_available; do { error_code = sd_rand_application_bytes_available_get(&bytes_available); APP_ERROR_CHECK(error_code); if (bytes_available > 0) { uint8_t byte_count = ((bytes_available > TRICKLE_RNG_POOL_SIZE - rng_index)? (TRICKLE_RNG_POOL_SIZE - rng_index) : (bytes_available)); error_code = sd_rand_application_vector_get(&rng_vals[rng_index], byte_count); APP_ERROR_CHECK(error_code); rng_index += byte_count; } } while (rng_index < TRICKLE_RNG_POOL_SIZE); }
/* * nRF51 has a TRNG that we can access using SoftDevice. */ int eddystoneEntropyPoll(void *data, unsigned char *output, size_t len, size_t *olen) { uint8_t bytes_available = 0; // get the number of random bytes available if (sd_rand_application_bytes_available_get(&bytes_available) != NRF_SUCCESS) { return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED; } // if there is more bytes available that what is requested, // truncate the number of bytes in output to len, otherwise use the total // of bytes available. const uint8_t output_len = bytes_available > len ? len : bytes_available; if (output_len) { // transfer "output_len" random bytes to output. if (sd_rand_application_vector_get(output, output_len) != NRF_SUCCESS) { return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED; } } // Everything went fine, commit the output_len to the output parameter *olen = output_len; return 0; }
uint8_t RNG::getRandom8() { uint8_t bytes_available = 0; uint32_t err_code; while (bytes_available < 1) { err_code = sd_rand_application_bytes_available_get(&bytes_available); APP_ERROR_CHECK(err_code); } err_code = sd_rand_application_vector_get(_randomBytes, 1); APP_ERROR_CHECK(err_code); return _randomBytes[0]; };
ret_code_t nrf_drv_rng_bytes_available(uint8_t * p_bytes_available) { ret_code_t result; ASSERT(m_rng_cb.state == NRF_DRV_STATE_INITIALIZED); #ifndef SOFTDEVICE_PRESENT result = NRF_SUCCESS; *p_bytes_available = FIFO_LENGTH(m_rng_cb.rand_pool); #else result = sd_rand_application_bytes_available_get(p_bytes_available); #endif // SOFTDEVICE_PRESENT return result; }
void nrf_drv_rng_bytes_available(uint8_t * p_bytes_available) { ASSERT(m_rng_cb.state == NRFX_DRV_STATE_INITIALIZED); #ifdef SOFTDEVICE_PRESENT if (NRF_DRV_RNG_SD_IS_ENABLED()) { if (NRF_SUCCESS == sd_rand_application_bytes_available_get(p_bytes_available)) { return; } } #endif // SOFTDEVICE_PRESENT *p_bytes_available = nrf_queue_utilization_get(&m_rand_pool); NRF_LOG_INFO("Function: %s, available bytes: %d.", (uint32_t)__func__, *p_bytes_available); }
void random_create(uint8_t* p_result, uint8_t length) { uint32_t err_code; while (length) { uint8_t available = 0; err_code = sd_rand_application_bytes_available_get(&available); APP_ERROR_CHECK(err_code); if (available) { available = available < length ? available : length; err_code = sd_rand_application_vector_get(p_result, available); APP_ERROR_CHECK(err_code); p_result += available; length -= available; } } }
uint16_t RNG::getRandom16() { uint8_t bytes_available = 0; uint32_t err_code; while (bytes_available < 2) { err_code = sd_rand_application_bytes_available_get(&bytes_available); APP_ERROR_CHECK(err_code); } err_code = sd_rand_application_vector_get(_randomBytes, 2); APP_ERROR_CHECK(err_code); conv8_16 converter; converter.a[0] = _randomBytes[0]; converter.a[1] = _randomBytes[1]; return converter.b; };
uint32_t rand_hw_rng_get(uint8_t* p_result, uint16_t len) { #ifdef SOFTDEVICE_PRESENT uint32_t error_code; uint8_t bytes_available; uint32_t count = 0; while (count < len) { do { sd_rand_application_bytes_available_get(&bytes_available); } while (bytes_available == 0); if (bytes_available > len - count) { bytes_available = len - count; } error_code = sd_rand_application_vector_get(&p_result[count], bytes_available); if (error_code != NRF_SUCCESS) { return NRF_ERROR_INTERNAL; } count += bytes_available; } #else NRF_RNG->TASKS_START = 1; while (len) { while (!NRF_RNG->EVENTS_VALRDY); p_result[--len] = NRF_RNG->VALUE; NRF_RNG->EVENTS_VALRDY = 0; } NRF_RNG->TASKS_STOP = 1; #endif return NRF_SUCCESS; }
/** @brief Processes a ANT messages while in the requesting state. * * @param[in] Pointer to the raw ant message received. */ static void ascs_process_message_requesting(uint8_t event, uint8_t * p_event_message_buffer) { uint32_t err_code; switch (event) { case EVENT_TRANSFER_TX_FAILED: { //Randomly get a backoff between MIN_BACKOFF to m_backoff_range uint8_t num_rand_bytes_available; err_code = sd_rand_application_bytes_available_get(&num_rand_bytes_available); APP_ERROR_CHECK(err_code); //update the backoff if there is a randon number available if(num_rand_bytes_available > 0) { uint8_t rand_number; err_code = sd_rand_application_vector_get(&rand_number, 1); APP_ERROR_CHECK(err_code); m_backoff = (uint8_t) (rand_number % m_backoff_range + MIN_BACKOFF); } ascs_set_state(SEARCHING); break; } case EVENT_TRANSFER_TX_COMPLETED: { ascs_set_state(WAITING); break; } case EVENT_CHANNEL_CLOSED: case EVENT_RX: //Intentional fallthrough default: { break; } } }