| /* BEGIN_HEADER */ |
| #include <stdint.h> |
| |
| #include "psa_crypto_core.h" |
| /* Some tests in this module configure entropy sources. */ |
| #include "psa_crypto_invasive.h" |
| |
| #include "mbedtls/entropy.h" |
| #include "entropy_poll.h" |
| |
| #define ENTROPY_MIN_NV_SEED_SIZE \ |
| MAX(MBEDTLS_ENTROPY_MIN_PLATFORM, MBEDTLS_ENTROPY_BLOCK_SIZE) |
| |
| #include "psa_crypto_random_impl.h" |
| #if defined(MBEDTLS_PSA_HMAC_DRBG_MD_TYPE) |
| /* PSA crypto uses the HMAC_DRBG module. It reads from the entropy source twice: |
| * once for the initial entropy and once for a nonce. The nonce length is |
| * half the entropy length. For SHA-256, SHA-384 or SHA-512, the |
| * entropy length is 256 per the documentation of mbedtls_hmac_drbg_seed(), |
| * and PSA crypto doesn't support other hashes for HMAC_DRBG. */ |
| #define ENTROPY_NONCE_LEN (256 / 2) |
| #else |
| /* PSA crypto uses the CTR_DRBG module. In some configurations, it needs |
| * to read from the entropy source twice: once for the initial entropy |
| * and once for a nonce. */ |
| #include "mbedtls/ctr_drbg.h" |
| #define ENTROPY_NONCE_LEN MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN |
| #endif |
| |
| #if !defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG) |
| |
| typedef struct { |
| size_t threshold; /* Minimum bytes to make mbedtls_entropy_func happy */ |
| size_t max_steps; |
| size_t *length_sequence; |
| size_t step; |
| } fake_entropy_state_t; |
| static int fake_entropy_source(void *state_arg, |
| unsigned char *output, size_t len, |
| size_t *olen) |
| { |
| fake_entropy_state_t *state = state_arg; |
| size_t i; |
| |
| if (state->step >= state->max_steps) { |
| return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED; |
| } |
| |
| *olen = MIN(len, state->length_sequence[state->step]); |
| for (i = 0; i < *olen; i++) { |
| output[i] = i; |
| } |
| ++state->step; |
| return 0; |
| } |
| |
| #define ENTROPY_SOURCE_PLATFORM 0x00000001 |
| #define ENTROPY_SOURCE_TIMING 0x00000002 |
| #define ENTROPY_SOURCE_HARDWARE 0x00000004 |
| #define ENTROPY_SOURCE_NV_SEED 0x00000008 |
| #define ENTROPY_SOURCE_FAKE 0x40000000 |
| |
| static uint32_t custom_entropy_sources_mask; |
| static fake_entropy_state_t fake_entropy_state; |
| |
| /* This is a modified version of mbedtls_entropy_init() from entropy.c |
| * which chooses entropy sources dynamically. */ |
| static void custom_entropy_init(mbedtls_entropy_context *ctx) |
| { |
| ctx->source_count = 0; |
| memset(ctx->source, 0, sizeof(ctx->source)); |
| |
| #if defined(MBEDTLS_THREADING_C) |
| mbedtls_mutex_init(&ctx->mutex); |
| #endif |
| |
| ctx->accumulator_started = 0; |
| mbedtls_md_init(&ctx->accumulator); |
| |
| #if !defined(MBEDTLS_NO_PLATFORM_ENTROPY) |
| if (custom_entropy_sources_mask & ENTROPY_SOURCE_PLATFORM) { |
| mbedtls_entropy_add_source(ctx, mbedtls_platform_entropy_poll, NULL, |
| MBEDTLS_ENTROPY_MIN_PLATFORM, |
| MBEDTLS_ENTROPY_SOURCE_STRONG); |
| } |
| #endif |
| #if defined(MBEDTLS_ENTROPY_HARDWARE_ALT) |
| if (custom_entropy_sources_mask & ENTROPY_SOURCE_HARDWARE) { |
| mbedtls_entropy_add_source(ctx, mbedtls_hardware_poll, NULL, |
| MBEDTLS_ENTROPY_MIN_HARDWARE, |
| MBEDTLS_ENTROPY_SOURCE_STRONG); |
| } |
| #endif |
| #if defined(MBEDTLS_ENTROPY_NV_SEED) |
| if (custom_entropy_sources_mask & ENTROPY_SOURCE_NV_SEED) { |
| mbedtls_entropy_add_source(ctx, mbedtls_nv_seed_poll, NULL, |
| MBEDTLS_ENTROPY_BLOCK_SIZE, |
| MBEDTLS_ENTROPY_SOURCE_STRONG); |
| ctx->initial_entropy_run = 0; |
| } else { |
| /* Skip the NV seed even though it's compiled in. */ |
| ctx->initial_entropy_run = 1; |
| } |
| #endif |
| |
| if (custom_entropy_sources_mask & ENTROPY_SOURCE_FAKE) { |
| mbedtls_entropy_add_source(ctx, |
| fake_entropy_source, &fake_entropy_state, |
| fake_entropy_state.threshold, |
| MBEDTLS_ENTROPY_SOURCE_STRONG); |
| } |
| } |
| |
| #endif /* !defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG) */ |
| |
| #if defined MBEDTLS_THREADING_PTHREAD |
| |
| typedef struct { |
| int do_init; |
| } thread_psa_init_ctx_t; |
| |
| static void *thread_psa_init_function(void *ctx) |
| { |
| thread_psa_init_ctx_t *init_context = (thread_psa_init_ctx_t *) ctx; |
| psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED; |
| uint8_t random[10] = { 0 }; |
| |
| if (init_context->do_init) { |
| PSA_ASSERT(psa_crypto_init()); |
| } |
| |
| /* If this is a test only thread, then we can assume PSA is being started |
| * up on another thread and thus we cannot know whether the following tests |
| * will be successful or not. These checks are still useful, however even |
| * without checking the return codes as they may show up race conditions on |
| * the flags they check under TSAN.*/ |
| |
| /* Test getting if drivers are initialised. */ |
| int can_do = psa_can_do_hash(PSA_ALG_NONE); |
| |
| if (init_context->do_init) { |
| TEST_ASSERT(can_do == 1); |
| } |
| |
| #if !defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG) |
| |
| /* Test getting global_data.rng_state. */ |
| status = mbedtls_psa_crypto_configure_entropy_sources(NULL, NULL); |
| |
| if (init_context->do_init) { |
| /* Bad state due to entropy sources already being setup in |
| * psa_crypto_init() */ |
| TEST_EQUAL(status, PSA_ERROR_BAD_STATE); |
| } |
| #endif /* !defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG) */ |
| |
| /* Test using the PSA RNG ony if we know PSA is up and running. */ |
| if (init_context->do_init) { |
| status = psa_generate_random(random, sizeof(random)); |
| |
| TEST_EQUAL(status, PSA_SUCCESS); |
| } |
| |
| exit: |
| return NULL; |
| } |
| #endif /* defined MBEDTLS_THREADING_PTHREAD */ |
| |
| /* END_HEADER */ |
| |
| /* BEGIN_DEPENDENCIES |
| * depends_on:MBEDTLS_PSA_CRYPTO_C |
| * END_DEPENDENCIES |
| */ |
| |
| /* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:!MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */ |
| void create_nv_seed() |
| { |
| static unsigned char seed[ENTROPY_MIN_NV_SEED_SIZE]; |
| TEST_ASSERT(mbedtls_nv_seed_write(seed, sizeof(seed)) >= 0); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void init_deinit(int count) |
| { |
| psa_status_t status; |
| int i; |
| for (i = 0; i < count; i++) { |
| status = psa_crypto_init(); |
| PSA_ASSERT(status); |
| status = psa_crypto_init(); |
| PSA_ASSERT(status); |
| PSA_DONE(); |
| } |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void deinit_without_init(int count) |
| { |
| int i; |
| for (i = 0; i < count; i++) { |
| PSA_ASSERT(psa_crypto_init()); |
| PSA_DONE(); |
| } |
| PSA_DONE(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE depends_on:MBEDTLS_THREADING_PTHREAD */ |
| void psa_threaded_init(int arg_thread_count) |
| { |
| thread_psa_init_ctx_t init_context; |
| thread_psa_init_ctx_t init_context_2; |
| |
| size_t thread_count = (size_t) arg_thread_count; |
| mbedtls_test_thread_t *threads = NULL; |
| |
| TEST_CALLOC(threads, sizeof(mbedtls_test_thread_t) * thread_count); |
| |
| init_context.do_init = 1; |
| |
| /* Test initialising PSA and testing certain protected globals on multiple |
| * threads. */ |
| for (size_t i = 0; i < thread_count; i++) { |
| TEST_EQUAL( |
| mbedtls_test_thread_create(&threads[i], |
| thread_psa_init_function, |
| (void *) &init_context), |
| 0); |
| } |
| |
| for (size_t i = 0; i < thread_count; i++) { |
| TEST_EQUAL(mbedtls_test_thread_join(&threads[i]), 0); |
| } |
| |
| PSA_DONE(); |
| |
| init_context_2.do_init = 0; |
| |
| /* Test initialising PSA whilst also testing flags on other threads. */ |
| for (size_t i = 0; i < thread_count; i++) { |
| |
| if (i & 1) { |
| |
| TEST_EQUAL( |
| mbedtls_test_thread_create(&threads[i], |
| thread_psa_init_function, |
| (void *) &init_context), |
| 0); |
| } else { |
| TEST_EQUAL( |
| mbedtls_test_thread_create(&threads[i], |
| thread_psa_init_function, |
| (void *) &init_context_2), |
| 0); |
| } |
| } |
| |
| for (size_t i = 0; i < thread_count; i++) { |
| TEST_EQUAL(mbedtls_test_thread_join(&threads[i]), 0); |
| } |
| exit: |
| |
| PSA_DONE(); |
| |
| mbedtls_free(threads); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void validate_module_init_generate_random(int count) |
| { |
| psa_status_t status; |
| uint8_t random[10] = { 0 }; |
| int i; |
| for (i = 0; i < count; i++) { |
| status = psa_crypto_init(); |
| PSA_ASSERT(status); |
| PSA_DONE(); |
| } |
| status = psa_generate_random(random, sizeof(random)); |
| TEST_EQUAL(status, PSA_ERROR_BAD_STATE); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void validate_module_init_key_based(int count) |
| { |
| psa_status_t status; |
| uint8_t data[10] = { 0 }; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| mbedtls_svc_key_id_t key = mbedtls_svc_key_id_make(0xdead, 0xdead); |
| int i; |
| |
| for (i = 0; i < count; i++) { |
| status = psa_crypto_init(); |
| PSA_ASSERT(status); |
| PSA_DONE(); |
| } |
| psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA); |
| status = psa_import_key(&attributes, data, sizeof(data), &key); |
| TEST_EQUAL(status, PSA_ERROR_BAD_STATE); |
| TEST_ASSERT(mbedtls_svc_key_id_is_null(key)); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE depends_on:!MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */ |
| void custom_entropy_sources(int sources_arg, int expected_init_status_arg) |
| { |
| psa_status_t expected_init_status = expected_init_status_arg; |
| uint8_t random[10] = { 0 }; |
| |
| custom_entropy_sources_mask = sources_arg; |
| PSA_ASSERT(mbedtls_psa_crypto_configure_entropy_sources( |
| custom_entropy_init, mbedtls_entropy_free)); |
| |
| TEST_EQUAL(psa_crypto_init(), expected_init_status); |
| if (expected_init_status != PSA_SUCCESS) { |
| goto exit; |
| } |
| |
| PSA_ASSERT(psa_generate_random(random, sizeof(random))); |
| |
| exit: |
| PSA_DONE(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE depends_on:!MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */ |
| void fake_entropy_source(int threshold, |
| int amount1, |
| int amount2, |
| int amount3, |
| int amount4, |
| int expected_init_status_arg) |
| { |
| psa_status_t expected_init_status = expected_init_status_arg; |
| uint8_t random[10] = { 0 }; |
| size_t lengths[4]; |
| |
| fake_entropy_state.threshold = threshold; |
| fake_entropy_state.step = 0; |
| fake_entropy_state.max_steps = 0; |
| if (amount1 >= 0) { |
| lengths[fake_entropy_state.max_steps++] = amount1; |
| } |
| if (amount2 >= 0) { |
| lengths[fake_entropy_state.max_steps++] = amount2; |
| } |
| if (amount3 >= 0) { |
| lengths[fake_entropy_state.max_steps++] = amount3; |
| } |
| if (amount4 >= 0) { |
| lengths[fake_entropy_state.max_steps++] = amount4; |
| } |
| fake_entropy_state.length_sequence = lengths; |
| |
| custom_entropy_sources_mask = ENTROPY_SOURCE_FAKE; |
| PSA_ASSERT(mbedtls_psa_crypto_configure_entropy_sources( |
| custom_entropy_init, mbedtls_entropy_free)); |
| |
| TEST_EQUAL(psa_crypto_init(), expected_init_status); |
| if (expected_init_status != PSA_SUCCESS) { |
| goto exit; |
| } |
| |
| PSA_ASSERT(psa_generate_random(random, sizeof(random))); |
| |
| exit: |
| PSA_DONE(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:!MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */ |
| void entropy_from_nv_seed(int seed_size_arg, |
| int expected_init_status_arg) |
| { |
| psa_status_t expected_init_status = expected_init_status_arg; |
| uint8_t random[10] = { 0 }; |
| uint8_t *seed = NULL; |
| size_t seed_size = seed_size_arg; |
| |
| TEST_CALLOC(seed, seed_size); |
| TEST_ASSERT(mbedtls_nv_seed_write(seed, seed_size) >= 0); |
| |
| custom_entropy_sources_mask = ENTROPY_SOURCE_NV_SEED; |
| PSA_ASSERT(mbedtls_psa_crypto_configure_entropy_sources( |
| custom_entropy_init, mbedtls_entropy_free)); |
| |
| TEST_EQUAL(psa_crypto_init(), expected_init_status); |
| if (expected_init_status != PSA_SUCCESS) { |
| goto exit; |
| } |
| |
| PSA_ASSERT(psa_generate_random(random, sizeof(random))); |
| |
| exit: |
| mbedtls_free(seed); |
| PSA_DONE(); |
| } |
| /* END_CASE */ |