Squashed 'lib/mbedtls/external/mbedtls/' content from commit 2ca6c285a0dd
git-subtree-dir: lib/mbedtls/external/mbedtls
git-subtree-split: 2ca6c285a0dd3f33982dd57299012dacab1ff206
diff --git a/tests/suites/test_suite_entropy.function b/tests/suites/test_suite_entropy.function
new file mode 100644
index 0000000..5ac65fc
--- /dev/null
+++ b/tests/suites/test_suite_entropy.function
@@ -0,0 +1,560 @@
+/* BEGIN_HEADER */
+#include "mbedtls/entropy.h"
+#include "entropy_poll.h"
+#include "mbedtls/md.h"
+#include "string.h"
+
+typedef enum {
+ DUMMY_CONSTANT_LENGTH, /* Output context->length bytes */
+ DUMMY_REQUESTED_LENGTH, /* Output whatever length was requested */
+ DUMMY_FAIL, /* Return an error code */
+} entropy_dummy_instruction;
+
+typedef struct {
+ entropy_dummy_instruction instruction;
+ size_t length; /* Length to return for DUMMY_CONSTANT_LENGTH */
+ size_t calls; /* Incremented at each call */
+} entropy_dummy_context;
+
+/*
+ * Dummy entropy source
+ *
+ * If data is NULL, write exactly the requested length.
+ * Otherwise, write the length indicated by data or error if negative
+ */
+static int entropy_dummy_source(void *arg, unsigned char *output,
+ size_t len, size_t *olen)
+{
+ entropy_dummy_context *context = arg;
+ ++context->calls;
+
+ switch (context->instruction) {
+ case DUMMY_CONSTANT_LENGTH:
+ *olen = context->length;
+ break;
+ case DUMMY_REQUESTED_LENGTH:
+ *olen = len;
+ break;
+ case DUMMY_FAIL:
+ return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
+ }
+
+ memset(output, 0x2a, *olen);
+ return 0;
+}
+
+/*
+ * Ability to clear entropy sources to allow testing with just predefined
+ * entropy sources. This function or tests depending on it might break if there
+ * are internal changes to how entropy sources are registered.
+ *
+ * To be called immediately after mbedtls_entropy_init().
+ *
+ * Just resetting the counter. New sources will overwrite existing ones.
+ * This might break memory checks in the future if sources need 'free-ing' then
+ * as well.
+ */
+static void entropy_clear_sources(mbedtls_entropy_context *ctx)
+{
+ ctx->source_count = 0;
+}
+
+#if defined(MBEDTLS_ENTROPY_NV_SEED)
+/*
+ * NV seed read/write functions that use a buffer instead of a file
+ */
+static unsigned char buffer_seed[MBEDTLS_ENTROPY_BLOCK_SIZE];
+
+int buffer_nv_seed_read(unsigned char *buf, size_t buf_len)
+{
+ if (buf_len != MBEDTLS_ENTROPY_BLOCK_SIZE) {
+ return -1;
+ }
+
+ memcpy(buf, buffer_seed, MBEDTLS_ENTROPY_BLOCK_SIZE);
+ return 0;
+}
+
+int buffer_nv_seed_write(unsigned char *buf, size_t buf_len)
+{
+ if (buf_len != MBEDTLS_ENTROPY_BLOCK_SIZE) {
+ return -1;
+ }
+
+ memcpy(buffer_seed, buf, MBEDTLS_ENTROPY_BLOCK_SIZE);
+ return 0;
+}
+
+/*
+ * NV seed read/write helpers that fill the base seedfile
+ */
+static int write_nv_seed(unsigned char *buf, size_t buf_len)
+{
+ FILE *f;
+
+ if (buf_len != MBEDTLS_ENTROPY_BLOCK_SIZE) {
+ return -1;
+ }
+
+ if ((f = fopen(MBEDTLS_PLATFORM_STD_NV_SEED_FILE, "w")) == NULL) {
+ return -1;
+ }
+
+ if (fwrite(buf, 1, MBEDTLS_ENTROPY_BLOCK_SIZE, f) !=
+ MBEDTLS_ENTROPY_BLOCK_SIZE) {
+ fclose(f);
+ return -1;
+ }
+
+ fclose(f);
+
+ return 0;
+}
+
+int read_nv_seed(unsigned char *buf, size_t buf_len)
+{
+ FILE *f;
+
+ if (buf_len != MBEDTLS_ENTROPY_BLOCK_SIZE) {
+ return -1;
+ }
+
+ if ((f = fopen(MBEDTLS_PLATFORM_STD_NV_SEED_FILE, "rb")) == NULL) {
+ return -1;
+ }
+
+ if (fread(buf, 1, MBEDTLS_ENTROPY_BLOCK_SIZE, f) !=
+ MBEDTLS_ENTROPY_BLOCK_SIZE) {
+ fclose(f);
+ return -1;
+ }
+
+ fclose(f);
+
+ return 0;
+}
+#endif /* MBEDTLS_ENTROPY_NV_SEED */
+/* END_HEADER */
+
+/* BEGIN_DEPENDENCIES
+ * depends_on:MBEDTLS_ENTROPY_C:!MBEDTLS_PSA_INJECT_ENTROPY
+ * END_DEPENDENCIES
+ */
+
+/* BEGIN_CASE */
+void entropy_init_free(int reinit)
+{
+ mbedtls_entropy_context ctx;
+
+ /* Double free is not explicitly documented to work, but it is convenient
+ * to call mbedtls_entropy_free() unconditionally on an error path without
+ * checking whether it has already been called in the success path. */
+
+ mbedtls_entropy_init(&ctx);
+ mbedtls_entropy_free(&ctx);
+
+ if (reinit) {
+ mbedtls_entropy_init(&ctx);
+ }
+ mbedtls_entropy_free(&ctx);
+
+ /* This test case always succeeds, functionally speaking. A plausible
+ * bug might trigger an invalid pointer dereference or a memory leak. */
+ goto exit;
+}
+/* END_CASE */
+
+/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
+void entropy_seed_file(char *path, int ret)
+{
+ mbedtls_entropy_context ctx;
+ mbedtls_entropy_init(&ctx);
+
+ MD_PSA_INIT();
+
+ TEST_ASSERT(mbedtls_entropy_write_seed_file(&ctx, path) == ret);
+ TEST_ASSERT(mbedtls_entropy_update_seed_file(&ctx, path) == ret);
+
+exit:
+ mbedtls_entropy_free(&ctx);
+ MD_PSA_DONE();
+}
+/* END_CASE */
+
+/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
+void entropy_write_base_seed_file(int ret)
+{
+ mbedtls_entropy_context ctx;
+ mbedtls_entropy_init(&ctx);
+
+ MD_PSA_INIT();
+
+ TEST_ASSERT(mbedtls_entropy_write_seed_file(&ctx, MBEDTLS_PLATFORM_STD_NV_SEED_FILE) == ret);
+ TEST_ASSERT(mbedtls_entropy_update_seed_file(&ctx, MBEDTLS_PLATFORM_STD_NV_SEED_FILE) == ret);
+
+exit:
+ mbedtls_entropy_free(&ctx);
+ MD_PSA_DONE();
+}
+/* END_CASE */
+
+/* BEGIN_CASE */
+void entropy_no_sources()
+{
+ mbedtls_entropy_context ctx;
+ unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
+
+ mbedtls_entropy_init(&ctx);
+ entropy_clear_sources(&ctx);
+ TEST_EQUAL(mbedtls_entropy_func(&ctx, buf, sizeof(buf)),
+ MBEDTLS_ERR_ENTROPY_NO_SOURCES_DEFINED);
+
+exit:
+ mbedtls_entropy_free(&ctx);
+}
+/* END_CASE */
+
+/* BEGIN_CASE */
+void entropy_too_many_sources()
+{
+ mbedtls_entropy_context ctx;
+ size_t i;
+ entropy_dummy_context dummy = { DUMMY_REQUESTED_LENGTH, 0, 0 };
+
+ mbedtls_entropy_init(&ctx);
+
+ /*
+ * It's hard to tell precisely when the error will occur,
+ * since we don't know how many sources were automatically added.
+ */
+ for (i = 0; i < MBEDTLS_ENTROPY_MAX_SOURCES; i++) {
+ (void) mbedtls_entropy_add_source(&ctx, entropy_dummy_source, &dummy,
+ 16, MBEDTLS_ENTROPY_SOURCE_WEAK);
+ }
+
+ TEST_ASSERT(mbedtls_entropy_add_source(&ctx, entropy_dummy_source, &dummy,
+ 16, MBEDTLS_ENTROPY_SOURCE_WEAK)
+ == MBEDTLS_ERR_ENTROPY_MAX_SOURCES);
+
+exit:
+ mbedtls_entropy_free(&ctx);
+}
+/* END_CASE */
+
+/* BEGIN_CASE depends_on:ENTROPY_HAVE_STRONG */
+void entropy_func_len(int len, int ret)
+{
+ mbedtls_entropy_context ctx;
+ unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE + 10] = { 0 };
+ unsigned char acc[MBEDTLS_ENTROPY_BLOCK_SIZE + 10] = { 0 };
+ size_t i, j;
+
+ mbedtls_entropy_init(&ctx);
+
+ MD_PSA_INIT();
+
+ /*
+ * See comments in mbedtls_entropy_self_test()
+ */
+ for (i = 0; i < 8; i++) {
+ TEST_ASSERT(mbedtls_entropy_func(&ctx, buf, len) == ret);
+ for (j = 0; j < sizeof(buf); j++) {
+ acc[j] |= buf[j];
+ }
+ }
+
+ if (ret == 0) {
+ for (j = 0; j < (size_t) len; j++) {
+ TEST_ASSERT(acc[j] != 0);
+ }
+ }
+
+ for (j = len; j < sizeof(buf); j++) {
+ TEST_ASSERT(acc[j] == 0);
+ }
+
+exit:
+ mbedtls_entropy_free(&ctx);
+ MD_PSA_DONE();
+}
+/* END_CASE */
+
+/* BEGIN_CASE */
+void entropy_source_fail(char *path)
+{
+ mbedtls_entropy_context ctx;
+ unsigned char buf[16];
+ entropy_dummy_context dummy = { DUMMY_FAIL, 0, 0 };
+
+ mbedtls_entropy_init(&ctx);
+
+ MD_PSA_INIT();
+
+ TEST_ASSERT(mbedtls_entropy_add_source(&ctx, entropy_dummy_source,
+ &dummy, 16,
+ MBEDTLS_ENTROPY_SOURCE_WEAK)
+ == 0);
+
+ TEST_ASSERT(mbedtls_entropy_func(&ctx, buf, sizeof(buf))
+ == MBEDTLS_ERR_ENTROPY_SOURCE_FAILED);
+ TEST_ASSERT(mbedtls_entropy_gather(&ctx)
+ == MBEDTLS_ERR_ENTROPY_SOURCE_FAILED);
+#if defined(MBEDTLS_FS_IO) && defined(MBEDTLS_ENTROPY_NV_SEED)
+ TEST_ASSERT(mbedtls_entropy_write_seed_file(&ctx, path)
+ == MBEDTLS_ERR_ENTROPY_SOURCE_FAILED);
+ TEST_ASSERT(mbedtls_entropy_update_seed_file(&ctx, path)
+ == MBEDTLS_ERR_ENTROPY_SOURCE_FAILED);
+#else
+ ((void) path);
+#endif
+
+exit:
+ mbedtls_entropy_free(&ctx);
+ MD_PSA_DONE();
+}
+/* END_CASE */
+
+/* BEGIN_CASE */
+void entropy_threshold(int threshold, int chunk_size, int result)
+{
+ mbedtls_entropy_context ctx;
+ entropy_dummy_context strong =
+ { DUMMY_CONSTANT_LENGTH, MBEDTLS_ENTROPY_BLOCK_SIZE, 0 };
+ entropy_dummy_context weak = { DUMMY_CONSTANT_LENGTH, chunk_size, 0 };
+ unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE] = { 0 };
+ int ret;
+
+ mbedtls_entropy_init(&ctx);
+ entropy_clear_sources(&ctx);
+
+ MD_PSA_INIT();
+
+ /* Set strong source that reaches its threshold immediately and
+ * a weak source whose threshold is a test parameter. */
+ TEST_ASSERT(mbedtls_entropy_add_source(&ctx, entropy_dummy_source,
+ &strong, 1,
+ MBEDTLS_ENTROPY_SOURCE_STRONG) == 0);
+ TEST_ASSERT(mbedtls_entropy_add_source(&ctx, entropy_dummy_source,
+ &weak, threshold,
+ MBEDTLS_ENTROPY_SOURCE_WEAK) == 0);
+
+ ret = mbedtls_entropy_func(&ctx, buf, sizeof(buf));
+
+ if (result >= 0) {
+ TEST_ASSERT(ret == 0);
+#if defined(MBEDTLS_ENTROPY_NV_SEED)
+ /* If the NV seed functionality is enabled, there are two entropy
+ * updates: before and after updating the NV seed. */
+ result *= 2;
+#endif
+ TEST_ASSERT(weak.calls == (size_t) result);
+ } else {
+ TEST_ASSERT(ret == result);
+ }
+
+exit:
+ mbedtls_entropy_free(&ctx);
+ MD_PSA_DONE();
+}
+/* END_CASE */
+
+/* BEGIN_CASE */
+void entropy_calls(int strength1, int strength2,
+ int threshold, int chunk_size,
+ int result)
+{
+ /*
+ * if result >= 0: result = expected number of calls to source 1
+ * if result < 0: result = expected return code from mbedtls_entropy_func()
+ */
+
+ mbedtls_entropy_context ctx;
+ entropy_dummy_context dummy1 = { DUMMY_CONSTANT_LENGTH, chunk_size, 0 };
+ entropy_dummy_context dummy2 = { DUMMY_CONSTANT_LENGTH, chunk_size, 0 };
+ unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE] = { 0 };
+ int ret;
+
+ mbedtls_entropy_init(&ctx);
+ entropy_clear_sources(&ctx);
+
+ MD_PSA_INIT();
+
+ TEST_ASSERT(mbedtls_entropy_add_source(&ctx, entropy_dummy_source,
+ &dummy1, threshold,
+ strength1) == 0);
+ TEST_ASSERT(mbedtls_entropy_add_source(&ctx, entropy_dummy_source,
+ &dummy2, threshold,
+ strength2) == 0);
+
+ ret = mbedtls_entropy_func(&ctx, buf, sizeof(buf));
+
+ if (result >= 0) {
+ TEST_ASSERT(ret == 0);
+#if defined(MBEDTLS_ENTROPY_NV_SEED)
+ /* If the NV seed functionality is enabled, there are two entropy
+ * updates: before and after updating the NV seed. */
+ result *= 2;
+#endif
+ TEST_ASSERT(dummy1.calls == (size_t) result);
+ } else {
+ TEST_ASSERT(ret == result);
+ }
+
+exit:
+ mbedtls_entropy_free(&ctx);
+ MD_PSA_DONE();
+}
+/* END_CASE */
+
+/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
+void nv_seed_file_create()
+{
+ unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
+
+ memset(buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE);
+
+ TEST_ASSERT(write_nv_seed(buf, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
+}
+/* END_CASE */
+
+/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO:MBEDTLS_PLATFORM_NV_SEED_ALT */
+void entropy_nv_seed_std_io()
+{
+ unsigned char io_seed[MBEDTLS_ENTROPY_BLOCK_SIZE];
+ unsigned char check_seed[MBEDTLS_ENTROPY_BLOCK_SIZE];
+
+ memset(io_seed, 1, MBEDTLS_ENTROPY_BLOCK_SIZE);
+ memset(check_seed, 0, MBEDTLS_ENTROPY_BLOCK_SIZE);
+
+ mbedtls_platform_set_nv_seed(mbedtls_platform_std_nv_seed_read,
+ mbedtls_platform_std_nv_seed_write);
+
+ /* Check if platform NV read and write manipulate the same data */
+ TEST_ASSERT(write_nv_seed(io_seed, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
+ TEST_ASSERT(mbedtls_nv_seed_read(check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE) ==
+ MBEDTLS_ENTROPY_BLOCK_SIZE);
+
+ TEST_ASSERT(memcmp(io_seed, check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
+
+ memset(check_seed, 0, MBEDTLS_ENTROPY_BLOCK_SIZE);
+
+ /* Check if platform NV write and raw read manipulate the same data */
+ TEST_ASSERT(mbedtls_nv_seed_write(io_seed, MBEDTLS_ENTROPY_BLOCK_SIZE) ==
+ MBEDTLS_ENTROPY_BLOCK_SIZE);
+ TEST_ASSERT(read_nv_seed(check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
+
+ TEST_ASSERT(memcmp(io_seed, check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
+}
+/* END_CASE */
+
+/* BEGIN_CASE depends_on:MBEDTLS_MD_LIGHT:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_PLATFORM_NV_SEED_ALT */
+void entropy_nv_seed(data_t *read_seed)
+{
+#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
+ const mbedtls_md_info_t *md_info =
+ mbedtls_md_info_from_type(MBEDTLS_MD_SHA512);
+#elif defined(MBEDTLS_ENTROPY_SHA256_ACCUMULATOR)
+ const mbedtls_md_info_t *md_info =
+ mbedtls_md_info_from_type(MBEDTLS_MD_SHA256);
+#else
+#error "Unsupported entropy accumulator"
+#endif
+ mbedtls_md_context_t accumulator;
+ mbedtls_entropy_context ctx;
+ int (*original_mbedtls_nv_seed_read)(unsigned char *buf, size_t buf_len) =
+ mbedtls_nv_seed_read;
+ int (*original_mbedtls_nv_seed_write)(unsigned char *buf, size_t buf_len) =
+ mbedtls_nv_seed_write;
+
+ unsigned char header[2];
+ unsigned char entropy[MBEDTLS_ENTROPY_BLOCK_SIZE];
+ unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
+ unsigned char empty[MBEDTLS_ENTROPY_BLOCK_SIZE];
+ unsigned char check_seed[MBEDTLS_ENTROPY_BLOCK_SIZE];
+ unsigned char check_entropy[MBEDTLS_ENTROPY_BLOCK_SIZE];
+
+ memset(entropy, 0, MBEDTLS_ENTROPY_BLOCK_SIZE);
+ memset(buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE);
+ memset(empty, 0, MBEDTLS_ENTROPY_BLOCK_SIZE);
+ memset(check_seed, 2, MBEDTLS_ENTROPY_BLOCK_SIZE);
+ memset(check_entropy, 3, MBEDTLS_ENTROPY_BLOCK_SIZE);
+
+ // Make sure we read/write NV seed from our buffers
+ mbedtls_platform_set_nv_seed(buffer_nv_seed_read, buffer_nv_seed_write);
+
+ mbedtls_md_init(&accumulator);
+ mbedtls_entropy_init(&ctx);
+ entropy_clear_sources(&ctx);
+
+ MD_PSA_INIT();
+
+ TEST_ASSERT(mbedtls_entropy_add_source(&ctx, mbedtls_nv_seed_poll, NULL,
+ MBEDTLS_ENTROPY_BLOCK_SIZE,
+ MBEDTLS_ENTROPY_SOURCE_STRONG) == 0);
+
+ // Set the initial NV seed to read
+ TEST_ASSERT(read_seed->len >= MBEDTLS_ENTROPY_BLOCK_SIZE);
+ memcpy(buffer_seed, read_seed->x, MBEDTLS_ENTROPY_BLOCK_SIZE);
+
+ // Do an entropy run
+ TEST_ASSERT(mbedtls_entropy_func(&ctx, entropy, sizeof(entropy)) == 0);
+ // Determine what should have happened with manual entropy internal logic
+
+ // Init accumulator
+ header[1] = MBEDTLS_ENTROPY_BLOCK_SIZE;
+ TEST_ASSERT(mbedtls_md_setup(&accumulator, md_info, 0) == 0);
+
+ // First run for updating write_seed
+ header[0] = 0;
+ TEST_ASSERT(mbedtls_md_starts(&accumulator) == 0);
+ TEST_ASSERT(mbedtls_md_update(&accumulator, header, 2) == 0);
+ TEST_ASSERT(mbedtls_md_update(&accumulator,
+ read_seed->x, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
+ TEST_ASSERT(mbedtls_md_finish(&accumulator, buf) == 0);
+
+ TEST_ASSERT(mbedtls_md_starts(&accumulator) == 0);
+ TEST_ASSERT(mbedtls_md_update(&accumulator,
+ buf, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
+
+ TEST_ASSERT(mbedtls_md(md_info, buf, MBEDTLS_ENTROPY_BLOCK_SIZE,
+ check_seed) == 0);
+
+ // Second run for actual entropy (triggers mbedtls_entropy_update_nv_seed)
+ header[0] = MBEDTLS_ENTROPY_SOURCE_MANUAL;
+ TEST_ASSERT(mbedtls_md_update(&accumulator, header, 2) == 0);
+ TEST_ASSERT(mbedtls_md_update(&accumulator,
+ empty, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
+
+ header[0] = 0;
+ TEST_ASSERT(mbedtls_md_update(&accumulator, header, 2) == 0);
+ TEST_ASSERT(mbedtls_md_update(&accumulator,
+ check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
+ TEST_ASSERT(mbedtls_md_finish(&accumulator, buf) == 0);
+
+ TEST_ASSERT(mbedtls_md(md_info, buf, MBEDTLS_ENTROPY_BLOCK_SIZE,
+ check_entropy) == 0);
+
+ // Check result of both NV file and entropy received with the manual calculations
+ TEST_ASSERT(memcmp(check_seed, buffer_seed, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
+ TEST_ASSERT(memcmp(check_entropy, entropy, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
+
+exit:
+ mbedtls_md_free(&accumulator);
+ mbedtls_entropy_free(&ctx);
+ mbedtls_nv_seed_read = original_mbedtls_nv_seed_read;
+ mbedtls_nv_seed_write = original_mbedtls_nv_seed_write;
+ MD_PSA_DONE();
+}
+/* END_CASE */
+
+/* BEGIN_CASE depends_on:ENTROPY_HAVE_STRONG:MBEDTLS_SELF_TEST */
+void entropy_selftest(int result)
+{
+ MD_PSA_INIT();
+
+ TEST_ASSERT(mbedtls_entropy_self_test(1) == result);
+
+exit:
+ MD_PSA_DONE();
+}
+/* END_CASE */