tests/suites/test_suite_psa_its.function - filogic/uboot - Gitiles

 /* BEGIN_HEADER */

 /* This test file is specific to the ITS implementation in PSA Crypto
  * on top of stdio. It expects to know what the stdio name of a file is
  * based on its keystore name.
  *
  * Note that if you need to make a change that affects how files are
  * stored, this may indicate that the key store is changing in a
  * backward-incompatible way! Think carefully about backward compatibility
  * before changing how test data is constructed or validated.
  */

 #include "psa_crypto_its.h"

 #include "test/psa_helpers.h"

 /* Internal definitions of the implementation, copied for the sake of
  * some of the tests and of the cleanup code. */
 #define PSA_ITS_STORAGE_PREFIX ""
 #define PSA_ITS_STORAGE_FILENAME_PATTERN "%08lx%08lx"
 #define PSA_ITS_STORAGE_SUFFIX ".psa_its"
 #define PSA_ITS_STORAGE_FILENAME_LENGTH         \
     (sizeof(PSA_ITS_STORAGE_PREFIX) - 1 +    /*prefix without terminating 0*/ \
      16 +  /*UID (64-bit number in hex)*/                               \
      16 +  /*UID (64-bit number in hex)*/                               \
      sizeof(PSA_ITS_STORAGE_SUFFIX) - 1 +    /*suffix without terminating 0*/ \
      1 /*terminating null byte*/)
 #define PSA_ITS_STORAGE_TEMP \
     PSA_ITS_STORAGE_PREFIX "tempfile" PSA_ITS_STORAGE_SUFFIX
 static void psa_its_fill_filename(psa_storage_uid_t uid, char *filename)
 {
     /* Break up the UID into two 32-bit pieces so as not to rely on
      * long long support in snprintf. */
     mbedtls_snprintf(filename, PSA_ITS_STORAGE_FILENAME_LENGTH,
                      "%s" PSA_ITS_STORAGE_FILENAME_PATTERN "%s",
                      PSA_ITS_STORAGE_PREFIX,
                      (unsigned long) (uid >> 32),
                      (unsigned long) (uid & 0xffffffff),
                      PSA_ITS_STORAGE_SUFFIX);
 }

 /* Maximum uid used by the test, recorded so that cleanup() can delete
  * all files. 0xffffffffffffffff is always cleaned up, so it does not
  * need to and should not be taken into account for uid_max. */
 static psa_storage_uid_t uid_max = 0;

 static void cleanup(void)
 {
     /* Call remove() on all the files that a test might have created.
      * We ignore the error if the file exists but remove() fails because
      * it can't be checked portably (except by attempting to open the file
      * first, which is needlessly slow and complicated here). A failure of
      * remove() on an existing file is very unlikely anyway and would not
      * have significant consequences other than perhaps failing the next
      * test case. */
     char filename[PSA_ITS_STORAGE_FILENAME_LENGTH];
     psa_storage_uid_t uid;
     for (uid = 0; uid < uid_max; uid++) {
         psa_its_fill_filename(uid, filename);
         (void) remove(filename);
     }
     psa_its_fill_filename((psa_storage_uid_t) (-1), filename);
     (void) remove(filename);
     (void) remove(PSA_ITS_STORAGE_TEMP);
     uid_max = 0;
 }

 static psa_status_t psa_its_set_wrap(psa_storage_uid_t uid,
                                      uint32_t data_length,
                                      const void *p_data,
                                      psa_storage_create_flags_t create_flags)
 {
     if (uid_max != (psa_storage_uid_t) (-1) && uid_max < uid) {
         uid_max = uid;
     }
     return psa_its_set(uid, data_length, p_data, create_flags);
 }

 /* END_HEADER */

 /* BEGIN_DEPENDENCIES
  * depends_on:MBEDTLS_PSA_ITS_FILE_C
  * END_DEPENDENCIES
  */

 /* BEGIN_CASE */
 void set_get_remove(int uid_arg, int flags_arg, data_t *data)
 {
     psa_storage_uid_t uid = uid_arg;
     uint32_t flags = flags_arg;
     struct psa_storage_info_t info;
     unsigned char *buffer = NULL;
     size_t ret_len = 0;

     TEST_CALLOC(buffer, data->len);

     PSA_ASSERT(psa_its_set_wrap(uid, data->len, data->x, flags));

     PSA_ASSERT(psa_its_get_info(uid, &info));
     TEST_ASSERT(info.size == data->len);
     TEST_ASSERT(info.flags == flags);
     PSA_ASSERT(psa_its_get(uid, 0, data->len, buffer, &ret_len));
     TEST_MEMORY_COMPARE(data->x, data->len, buffer, ret_len);

     PSA_ASSERT(psa_its_remove(uid));

 exit:
     mbedtls_free(buffer);
     cleanup();
 }
 /* END_CASE */

 /* BEGIN_CASE */
 void set_overwrite(int uid_arg,
                    int flags1_arg, data_t *data1,
                    int flags2_arg, data_t *data2)
 {
     psa_storage_uid_t uid = uid_arg;
     uint32_t flags1 = flags1_arg;
     uint32_t flags2 = flags2_arg;
     struct psa_storage_info_t info;
     unsigned char *buffer = NULL;
     size_t ret_len = 0;

     TEST_CALLOC(buffer, MAX(data1->len, data2->len));

     PSA_ASSERT(psa_its_set_wrap(uid, data1->len, data1->x, flags1));
     PSA_ASSERT(psa_its_get_info(uid, &info));
     TEST_ASSERT(info.size == data1->len);
     TEST_ASSERT(info.flags == flags1);
     PSA_ASSERT(psa_its_get(uid, 0, data1->len, buffer, &ret_len));
     TEST_MEMORY_COMPARE(data1->x, data1->len, buffer, ret_len);

     PSA_ASSERT(psa_its_set_wrap(uid, data2->len, data2->x, flags2));
     PSA_ASSERT(psa_its_get_info(uid, &info));
     TEST_ASSERT(info.size == data2->len);
     TEST_ASSERT(info.flags == flags2);
     ret_len = 0;
     PSA_ASSERT(psa_its_get(uid, 0, data2->len, buffer, &ret_len));
     TEST_MEMORY_COMPARE(data2->x, data2->len, buffer, ret_len);

     PSA_ASSERT(psa_its_remove(uid));

 exit:
     mbedtls_free(buffer);
     cleanup();
 }
 /* END_CASE */

 /* BEGIN_CASE */
 void set_multiple(int first_id, int count)
 {
     psa_storage_uid_t uid0 = first_id;
     psa_storage_uid_t uid;
     char stored[40];
     char retrieved[40];
     size_t ret_len = 0;

     memset(stored, '.', sizeof(stored));
     for (uid = uid0; uid < uid0 + count; uid++) {
         mbedtls_snprintf(stored, sizeof(stored),
                          "Content of file 0x%08lx", (unsigned long) uid);
         PSA_ASSERT(psa_its_set_wrap(uid, sizeof(stored), stored, 0));
     }

     for (uid = uid0; uid < uid0 + count; uid++) {
         mbedtls_snprintf(stored, sizeof(stored),
                          "Content of file 0x%08lx", (unsigned long) uid);
         PSA_ASSERT(psa_its_get(uid, 0, sizeof(stored), retrieved, &ret_len));
         TEST_MEMORY_COMPARE(retrieved, ret_len,
                             stored, sizeof(stored));
         PSA_ASSERT(psa_its_remove(uid));
         TEST_ASSERT(psa_its_get(uid, 0, 0, NULL, NULL) ==
                     PSA_ERROR_DOES_NOT_EXIST);
     }

 exit:
     cleanup();
 }
 /* END_CASE */

 /* BEGIN_CASE */
 void nonexistent(int uid_arg, int create_and_remove)
 {
     psa_storage_uid_t uid = uid_arg;
     struct psa_storage_info_t info;

     if (create_and_remove) {
         PSA_ASSERT(psa_its_set_wrap(uid, 0, NULL, 0));
         PSA_ASSERT(psa_its_remove(uid));
     }

     TEST_ASSERT(psa_its_remove(uid) == PSA_ERROR_DOES_NOT_EXIST);
     TEST_ASSERT(psa_its_get_info(uid, &info) ==
                 PSA_ERROR_DOES_NOT_EXIST);
     TEST_ASSERT(psa_its_get(uid, 0, 0, NULL, NULL) ==
                 PSA_ERROR_DOES_NOT_EXIST);

 exit:
     cleanup();
 }
 /* END_CASE */

 /* BEGIN_CASE */
 void get_at(int uid_arg, data_t *data,
             int offset, int length_arg,
             int expected_status)
 {
     psa_storage_uid_t uid = uid_arg;
     unsigned char *buffer = NULL;
     psa_status_t status;
     size_t length = length_arg >= 0 ? length_arg : 0;
     unsigned char *trailer;
     size_t i;
     size_t ret_len = 0;

     TEST_CALLOC(buffer, length + 16);
     trailer = buffer + length;
     memset(trailer, '-', 16);

     PSA_ASSERT(psa_its_set_wrap(uid, data->len, data->x, 0));

     status = psa_its_get(uid, offset, length_arg, buffer, &ret_len);
     TEST_ASSERT(status == (psa_status_t) expected_status);
     if (status == PSA_SUCCESS) {
         TEST_MEMORY_COMPARE(data->x + offset, (size_t) length_arg,
                             buffer, ret_len);
     }
     for (i = 0; i < 16; i++) {
         TEST_ASSERT(trailer[i] == '-');
     }
     PSA_ASSERT(psa_its_remove(uid));

 exit:
     mbedtls_free(buffer);
     cleanup();
 }
 /* END_CASE */

 /* BEGIN_CASE */
 void get_fail(int uid_arg, data_t *data,
               int overwrite_magic, int cut_header,
               int expected_status)
 {
     psa_storage_uid_t uid = uid_arg;
     unsigned char *buffer = NULL;
     psa_status_t status;
     size_t n;
     size_t ret_len = 0;
     char filename[PSA_ITS_STORAGE_FILENAME_LENGTH];
     FILE *stream = NULL;
     char bad_char = 'X';

     PSA_ASSERT(psa_its_set_wrap(uid, data->len, data->x, 0));

     psa_its_fill_filename(uid, filename);
     stream = fopen(filename, "rb+");
     TEST_ASSERT(NULL != stream);
     if (0 != overwrite_magic) {
         /* Overwrite the 1st byte of the file, the ITS magic number */
         TEST_ASSERT(fseek(stream, 0, SEEK_SET) == 0);
         n = fwrite(&bad_char, 1, 1, stream);
         TEST_ASSERT(1 == n);
     }
     if (0 != cut_header) {
         /* Reopen file and truncate it to 0 byte by specifying the 'w' flag */
         stream = freopen(filename, "wb", stream);
         TEST_ASSERT(NULL != stream);
     }
     fclose(stream);
     stream = NULL;

     status = psa_its_get(uid, 0, 0, buffer, &ret_len);
     TEST_ASSERT(status == (psa_status_t) expected_status);
     TEST_ASSERT(0 == ret_len);
     PSA_ASSERT(psa_its_remove(uid));

     /* Check if the file is really deleted. */
     stream = fopen(filename, "rb");
     TEST_ASSERT(NULL == stream);

 exit:
     if (stream != NULL) {
         fclose(stream);
     }

     mbedtls_free(buffer);
     cleanup();
 }
 /* END_CASE */

 /* BEGIN_CASE */
 void set_fail(int uid_arg, data_t *data,
               int expected_status)
 {
     psa_storage_uid_t uid = uid_arg;
     TEST_ASSERT(psa_its_set_wrap(uid, data->len, data->x, 0) ==
                 (psa_status_t) expected_status);

 exit:
     cleanup();
 }
 /* END_CASE */
	/* BEGIN_HEADER */

	/* This test file is specific to the ITS implementation in PSA Crypto
	* on top of stdio. It expects to know what the stdio name of a file is
	* based on its keystore name.
	*
	* Note that if you need to make a change that affects how files are
	* stored, this may indicate that the key store is changing in a
	* backward-incompatible way! Think carefully about backward compatibility
	* before changing how test data is constructed or validated.
	*/

	#include "psa_crypto_its.h"

	#include "test/psa_helpers.h"

	/* Internal definitions of the implementation, copied for the sake of
	* some of the tests and of the cleanup code. */
	#define PSA_ITS_STORAGE_PREFIX ""
	#define PSA_ITS_STORAGE_FILENAME_PATTERN "%08lx%08lx"
	#define PSA_ITS_STORAGE_SUFFIX ".psa_its"
	#define PSA_ITS_STORAGE_FILENAME_LENGTH \
	(sizeof(PSA_ITS_STORAGE_PREFIX) - 1 + /prefix without terminating 0/ \
	16 + /UID (64-bit number in hex)/ \
	16 + /UID (64-bit number in hex)/ \
	sizeof(PSA_ITS_STORAGE_SUFFIX) - 1 + /suffix without terminating 0/ \
	1 /terminating null byte/)
	#define PSA_ITS_STORAGE_TEMP \
	PSA_ITS_STORAGE_PREFIX "tempfile" PSA_ITS_STORAGE_SUFFIX
	static void psa_its_fill_filename(psa_storage_uid_t uid, char *filename)
	{
	/* Break up the UID into two 32-bit pieces so as not to rely on
	* long long support in snprintf. */
	mbedtls_snprintf(filename, PSA_ITS_STORAGE_FILENAME_LENGTH,
	"%s" PSA_ITS_STORAGE_FILENAME_PATTERN "%s",
	PSA_ITS_STORAGE_PREFIX,
	(unsigned long) (uid >> 32),
	(unsigned long) (uid & 0xffffffff),
	PSA_ITS_STORAGE_SUFFIX);
	}

	/* Maximum uid used by the test, recorded so that cleanup() can delete
	* all files. 0xffffffffffffffff is always cleaned up, so it does not
	* need to and should not be taken into account for uid_max. */
	static psa_storage_uid_t uid_max = 0;

	static void cleanup(void)
	{
	/* Call remove() on all the files that a test might have created.
	* We ignore the error if the file exists but remove() fails because
	* it can't be checked portably (except by attempting to open the file
	* first, which is needlessly slow and complicated here). A failure of
	* remove() on an existing file is very unlikely anyway and would not
	* have significant consequences other than perhaps failing the next
	* test case. */
	char filename[PSA_ITS_STORAGE_FILENAME_LENGTH];
	psa_storage_uid_t uid;
	for (uid = 0; uid < uid_max; uid++) {
	psa_its_fill_filename(uid, filename);
	(void) remove(filename);
	}
	psa_its_fill_filename((psa_storage_uid_t) (-1), filename);
	(void) remove(filename);
	(void) remove(PSA_ITS_STORAGE_TEMP);
	uid_max = 0;
	}

	static psa_status_t psa_its_set_wrap(psa_storage_uid_t uid,
	uint32_t data_length,
	const void *p_data,
	psa_storage_create_flags_t create_flags)
	{
	if (uid_max != (psa_storage_uid_t) (-1) && uid_max < uid) {
	uid_max = uid;
	}
	return psa_its_set(uid, data_length, p_data, create_flags);
	}

	/* END_HEADER */

	/* BEGIN_DEPENDENCIES
	* depends_on:MBEDTLS_PSA_ITS_FILE_C
	* END_DEPENDENCIES
	*/

	/* BEGIN_CASE */
	void set_get_remove(int uid_arg, int flags_arg, data_t *data)
	{
	psa_storage_uid_t uid = uid_arg;
	uint32_t flags = flags_arg;
	struct psa_storage_info_t info;
	unsigned char *buffer = NULL;
	size_t ret_len = 0;

	TEST_CALLOC(buffer, data->len);

	PSA_ASSERT(psa_its_set_wrap(uid, data->len, data->x, flags));

	PSA_ASSERT(psa_its_get_info(uid, &info));
	TEST_ASSERT(info.size == data->len);
	TEST_ASSERT(info.flags == flags);
	PSA_ASSERT(psa_its_get(uid, 0, data->len, buffer, &ret_len));
	TEST_MEMORY_COMPARE(data->x, data->len, buffer, ret_len);

	PSA_ASSERT(psa_its_remove(uid));

	exit:
	mbedtls_free(buffer);
	cleanup();
	}
	/* END_CASE */

	/* BEGIN_CASE */
	void set_overwrite(int uid_arg,
	int flags1_arg, data_t *data1,
	int flags2_arg, data_t *data2)
	{
	psa_storage_uid_t uid = uid_arg;
	uint32_t flags1 = flags1_arg;
	uint32_t flags2 = flags2_arg;
	struct psa_storage_info_t info;
	unsigned char *buffer = NULL;
	size_t ret_len = 0;

	TEST_CALLOC(buffer, MAX(data1->len, data2->len));

	PSA_ASSERT(psa_its_set_wrap(uid, data1->len, data1->x, flags1));
	PSA_ASSERT(psa_its_get_info(uid, &info));
	TEST_ASSERT(info.size == data1->len);
	TEST_ASSERT(info.flags == flags1);
	PSA_ASSERT(psa_its_get(uid, 0, data1->len, buffer, &ret_len));
	TEST_MEMORY_COMPARE(data1->x, data1->len, buffer, ret_len);

	PSA_ASSERT(psa_its_set_wrap(uid, data2->len, data2->x, flags2));
	PSA_ASSERT(psa_its_get_info(uid, &info));
	TEST_ASSERT(info.size == data2->len);
	TEST_ASSERT(info.flags == flags2);
	ret_len = 0;
	PSA_ASSERT(psa_its_get(uid, 0, data2->len, buffer, &ret_len));
	TEST_MEMORY_COMPARE(data2->x, data2->len, buffer, ret_len);

	PSA_ASSERT(psa_its_remove(uid));

	exit:
	mbedtls_free(buffer);
	cleanup();
	}
	/* END_CASE */

	/* BEGIN_CASE */
	void set_multiple(int first_id, int count)
	{
	psa_storage_uid_t uid0 = first_id;
	psa_storage_uid_t uid;
	char stored[40];
	char retrieved[40];
	size_t ret_len = 0;

	memset(stored, '.', sizeof(stored));
	for (uid = uid0; uid < uid0 + count; uid++) {
	mbedtls_snprintf(stored, sizeof(stored),
	"Content of file 0x%08lx", (unsigned long) uid);
	PSA_ASSERT(psa_its_set_wrap(uid, sizeof(stored), stored, 0));
	}

	for (uid = uid0; uid < uid0 + count; uid++) {
	mbedtls_snprintf(stored, sizeof(stored),
	"Content of file 0x%08lx", (unsigned long) uid);
	PSA_ASSERT(psa_its_get(uid, 0, sizeof(stored), retrieved, &ret_len));
	TEST_MEMORY_COMPARE(retrieved, ret_len,
	stored, sizeof(stored));
	PSA_ASSERT(psa_its_remove(uid));
	TEST_ASSERT(psa_its_get(uid, 0, 0, NULL, NULL) ==
	PSA_ERROR_DOES_NOT_EXIST);
	}

	exit:
	cleanup();
	}
	/* END_CASE */

	/* BEGIN_CASE */
	void nonexistent(int uid_arg, int create_and_remove)
	{
	psa_storage_uid_t uid = uid_arg;
	struct psa_storage_info_t info;

	if (create_and_remove) {
	PSA_ASSERT(psa_its_set_wrap(uid, 0, NULL, 0));
	PSA_ASSERT(psa_its_remove(uid));
	}

	TEST_ASSERT(psa_its_remove(uid) == PSA_ERROR_DOES_NOT_EXIST);
	TEST_ASSERT(psa_its_get_info(uid, &info) ==
	PSA_ERROR_DOES_NOT_EXIST);
	TEST_ASSERT(psa_its_get(uid, 0, 0, NULL, NULL) ==
	PSA_ERROR_DOES_NOT_EXIST);

	exit:
	cleanup();
	}
	/* END_CASE */

	/* BEGIN_CASE */
	void get_at(int uid_arg, data_t *data,
	int offset, int length_arg,
	int expected_status)
	{
	psa_storage_uid_t uid = uid_arg;
	unsigned char *buffer = NULL;
	psa_status_t status;
	size_t length = length_arg >= 0 ? length_arg : 0;
	unsigned char *trailer;
	size_t i;
	size_t ret_len = 0;

	TEST_CALLOC(buffer, length + 16);
	trailer = buffer + length;
	memset(trailer, '-', 16);

	PSA_ASSERT(psa_its_set_wrap(uid, data->len, data->x, 0));

	status = psa_its_get(uid, offset, length_arg, buffer, &ret_len);
	TEST_ASSERT(status == (psa_status_t) expected_status);
	if (status == PSA_SUCCESS) {
	TEST_MEMORY_COMPARE(data->x + offset, (size_t) length_arg,
	buffer, ret_len);
	}
	for (i = 0; i < 16; i++) {
	TEST_ASSERT(trailer[i] == '-');
	}
	PSA_ASSERT(psa_its_remove(uid));

	exit:
	mbedtls_free(buffer);
	cleanup();
	}
	/* END_CASE */

	/* BEGIN_CASE */
	void get_fail(int uid_arg, data_t *data,
	int overwrite_magic, int cut_header,
	int expected_status)
	{
	psa_storage_uid_t uid = uid_arg;
	unsigned char *buffer = NULL;
	psa_status_t status;
	size_t n;
	size_t ret_len = 0;
	char filename[PSA_ITS_STORAGE_FILENAME_LENGTH];
	FILE *stream = NULL;
	char bad_char = 'X';

	PSA_ASSERT(psa_its_set_wrap(uid, data->len, data->x, 0));

	psa_its_fill_filename(uid, filename);
	stream = fopen(filename, "rb+");
	TEST_ASSERT(NULL != stream);
	if (0 != overwrite_magic) {
	/* Overwrite the 1st byte of the file, the ITS magic number */
	TEST_ASSERT(fseek(stream, 0, SEEK_SET) == 0);
	n = fwrite(&bad_char, 1, 1, stream);
	TEST_ASSERT(1 == n);
	}
	if (0 != cut_header) {
	/* Reopen file and truncate it to 0 byte by specifying the 'w' flag */
	stream = freopen(filename, "wb", stream);
	TEST_ASSERT(NULL != stream);
	}
	fclose(stream);
	stream = NULL;

	status = psa_its_get(uid, 0, 0, buffer, &ret_len);
	TEST_ASSERT(status == (psa_status_t) expected_status);
	TEST_ASSERT(0 == ret_len);
	PSA_ASSERT(psa_its_remove(uid));

	/* Check if the file is really deleted. */
	stream = fopen(filename, "rb");
	TEST_ASSERT(NULL == stream);

	exit:
	if (stream != NULL) {
	fclose(stream);
	}

	mbedtls_free(buffer);
	cleanup();
	}
	/* END_CASE */

	/* BEGIN_CASE */
	void set_fail(int uid_arg, data_t *data,
	int expected_status)
	{
	psa_storage_uid_t uid = uid_arg;
	TEST_ASSERT(psa_its_set_wrap(uid, data->len, data->x, 0) ==
	(psa_status_t) expected_status);

	exit:
	cleanup();
	}
	/* END_CASE */