18 #define WRITE_ONCE_UID 1U
24 #define INVALID_UID 0U
25 #define INVALID_DATA_LEN UINT32_MAX
26 #define INVALID_OFFSET UINT32_MAX
27 #define INVALID_FLAG (1U << 31)
28 #define INVALID_THREAD_NAME "Thread_INVALID"
31 #define WRITE_ONCE_DATA "THE_FIVE_BOXING_WIZARDS_JUMP_QUICKLY"
32 #define WRITE_ONCE_DATA_SIZE (sizeof(WRITE_ONCE_DATA) - 1)
33 #define WRITE_ONCE_READ_DATA "############################################"
34 #define WRITE_ONCE_RESULT_DATA ("####" WRITE_ONCE_DATA "####")
35 #define OFFSET_READ_DATA "HEQUICKBROWNFOXJUMPSOVERALAZYDOG"
36 #define OFFSET_RESULT_DATA ("____" OFFSET_READ_DATA "_____")
38 #define WRITE_DATA "THEQUICKBROWNFOXJUMPSOVERALAZYDOG"
39 #define WRITE_DATA_SIZE (sizeof(WRITE_DATA) - 1)
40 #define READ_DATA "_________________________________________"
41 #define RESULT_DATA ("____" WRITE_DATA "____")
43 #define TEST_1025_CYCLES 3U
45 static const uint8_t write_asset_data[PS_MAX_ASSET_SIZE] = {0xAF};
46 static uint8_t read_asset_data[PS_MAX_ASSET_SIZE] = {0};
47 static size_t read_asset_data_len = 0;
65 #ifdef TFM_NS_CLIENT_IDENTIFICATION
78 static struct test_t psa_ps_ns_tests[] = {
79 {&tfm_ps_test_1001,
"TFM_PS_TEST_1001",
81 {&tfm_ps_test_1002,
"TFM_PS_TEST_1002",
82 "Set interface with create flags"},
83 {&tfm_ps_test_1003,
"TFM_PS_TEST_1003",
84 "Set interface with NULL data pointer"},
85 {&tfm_ps_test_1004,
"TFM_PS_TEST_1004",
86 "Set interface with write once UID"},
87 {&tfm_ps_test_1005,
"TFM_PS_TEST_1005",
88 "Get interface with valid data"},
89 {&tfm_ps_test_1006,
"TFM_PS_TEST_1006",
90 "Get interface with zero data length"},
91 {&tfm_ps_test_1007,
"TFM_PS_TEST_1007",
92 "Get interface with invalid UIDs"},
93 {&tfm_ps_test_1008,
"TFM_PS_TEST_1008",
94 "Get interface with invalid data lengths and offsets"},
95 {&tfm_ps_test_1009,
"TFM_PS_TEST_1009",
96 "Get interface with NULL data pointer"},
97 {&tfm_ps_test_1010,
"TFM_PS_TEST_1010",
98 "Get info interface with write once UID"},
99 {&tfm_ps_test_1011,
"TFM_PS_TEST_1011",
100 "Get info interface with valid UID"},
101 {&tfm_ps_test_1012,
"TFM_PS_TEST_1012",
102 "Get info interface with invalid UIDs"},
103 {&tfm_ps_test_1013,
"TFM_PS_TEST_1013",
104 "Remove interface with valid UID"},
105 {&tfm_ps_test_1014,
"TFM_PS_TEST_1014",
106 "Remove interface with write once UID"},
107 {&tfm_ps_test_1015,
"TFM_PS_TEST_1015",
108 "Remove interface with invalid UID"},
109 #ifdef TFM_NS_CLIENT_IDENTIFICATION
110 {&tfm_ps_test_1016,
"TFM_PS_TEST_1016",
111 "Get interface with invalid thread name"},
112 {&tfm_ps_test_1017,
"TFM_PS_TEST_1017",
113 "Get info interface with invalid thread name"},
114 {&tfm_ps_test_1018,
"TFM_PS_TEST_1018",
115 "Remove interface with invalid thread name"},
116 {&tfm_ps_test_1019,
"TFM_PS_TEST_1019",
117 "Attempt to access UID belonging to another thread"},
118 {&tfm_ps_test_1020,
"TFM_PS_TEST_1020",
119 "Set UID alternately from two threads"},
121 {&tfm_ps_test_1021,
"TFM_PS_TEST_1021",
122 "Block compaction after remove"},
123 {&tfm_ps_test_1022,
"TFM_PS_TEST_1022",
124 "Multiple partial gets"},
125 {&tfm_ps_test_1023,
"TFM_PS_TEST_1023",
126 "Multiple sets to same UID from same thread"},
127 {&tfm_ps_test_1024,
"TFM_PS_TEST_1024",
128 "Get support interface"},
129 {&tfm_ps_test_1025,
"TFM_PS_TEST_1025",
130 "Set, get and remove interface with different asset sizes"},
137 list_size = (
sizeof(psa_ps_ns_tests) /
sizeof(psa_ps_ns_tests[0]));
139 set_testsuite(
"PSA protected storage NS interface tests (TFM_PS_TEST_1XXX)",
140 psa_ps_ns_tests, list_size, p_test_suite);
153 const uint32_t data_len = 0;
154 const uint8_t write_data[] = {0};
157 status =
psa_ps_set(uid, data_len, write_data, flags);
159 TEST_FAIL(
"Set should not fail with valid UID");
164 status =
psa_ps_set(uid, data_len, write_data, flags);
166 TEST_FAIL(
"Set should not fail the second time with valid UID");
173 TEST_FAIL(
"Set should not succeed with an invalid UID");
180 TEST_FAIL(
"Remove should not fail with valid UID");
212 TEST_FAIL(
"Set should not fail with valid flags (existing UID)");
220 TEST_LOG(
"Note: The UID in this test has already been created with\r\n"
221 "the PSA_STORAGE_FLAG_WRITE_ONCE flag in a previous test\r\n"
222 "run. Wipe the storage area to run the full test.\r\n");
224 TEST_FAIL(
"Set should not fail with no flags");
231 TEST_FAIL(
"Set should not succeed with invalid flags");
252 const uint32_t data_len = 0;
255 status =
psa_ps_set(uid, data_len, NULL, flags);
257 TEST_FAIL(
"Set should succeed with NULL data pointer and zero length");
275 const uint32_t offset = 0;
278 size_t read_data_len = 0;
281 status =
psa_ps_set(uid, write_len, write_data, flags);
283 TEST_FAIL(
"Set should not rewrite a write once UID");
297 TEST_FAIL(
"Write once data should not have changed");
318 size_t read_data_len = 0;
320 const uint8_t *p_read_data = read_data;
322 status =
psa_ps_set(uid, data_len, write_data, flags);
338 TEST_FAIL(
"Read data should be equal to result data");
347 data_len -= offset + 2;
358 TEST_FAIL(
"Read data contains illegal pre-data");
364 if (
memcmp(p_read_data, write_data + offset, data_len) != 0) {
369 p_read_data += data_len;
372 TEST_FAIL(
"Read data contains illegal post-data");
379 TEST_FAIL(
"Remove should not fail with valid UID");
397 const uint32_t read_len = 0;
401 size_t read_data_len = 0;
403 status =
psa_ps_set(uid, write_len, write_data, flags);
413 TEST_FAIL(
"Get should not fail with zero data len");
419 TEST_FAIL(
"Read data should be equal to original read data");
435 TEST_FAIL(
"Read data should be equal to original read data");
442 TEST_FAIL(
"Remove should not fail with valid UID");
458 const uint32_t data_len = 1;
459 const uint32_t offset = 0;
461 size_t read_data_len = 0;
467 TEST_FAIL(
"Get succeeded with non-existant UID");
473 TEST_FAIL(
"Read data not equal to original read data");
481 TEST_FAIL(
"Get succeeded with invalid UID");
487 TEST_FAIL(
"Read data not equal to original read data");
510 size_t read_data_len = 0;
512 status =
psa_ps_set(uid, write_len, write_data, flags);
520 offset = write_len + 1;
525 TEST_FAIL(
"Get should not succeed with offset too large");
531 TEST_FAIL(
"Read data should be equal to original read data");
536 read_len = write_len + 1;
542 TEST_FAIL(
"Get should succeed with data length larger than UID's "
547 if (read_data_len != write_len) {
548 TEST_FAIL(
"Read data length should be equal to UID's length");
554 TEST_FAIL(
"Read data should be equal to original read data");
561 read_len = write_len;
570 TEST_FAIL(
"Get should succeed with offset + data length too large, "
571 "but individually valid");
575 if (read_data_len != write_len - offset) {
576 TEST_FAIL(
"Read data length should be equal to the UID's remaining "
577 "size starting from offset");
583 TEST_FAIL(
"Read data should be equal to original read data");
590 TEST_FAIL(
"Remove should not fail with valid UID");
612 const uint32_t offset = 0;
614 size_t read_data_length = 0;
616 status =
psa_ps_set(uid, data_len, write_data, flags);
623 status =
psa_ps_get(uid, offset, 0, NULL, &read_data_length);
625 TEST_FAIL(
"Get should succeed with NULL data pointer and zero length");
632 TEST_FAIL(
"Remove should not fail with valid UID");
652 TEST_FAIL(
"Get info should not fail for write once UID");
658 TEST_FAIL(
"Size incorrect for write once UID");
663 TEST_FAIL(
"Flags incorrect for write once UID");
683 status =
psa_ps_set(uid, data_len, write_data, flags);
692 TEST_FAIL(
"Get info should not fail with valid UID");
697 if (info.
size != data_len) {
698 TEST_FAIL(
"Size incorrect for valid UID");
702 if (info.
flags != flags) {
703 TEST_FAIL(
"Flags incorrect for valid UID");
710 TEST_FAIL(
"Remove should not fail with valid UID");
731 TEST_FAIL(
"Get info should not succeed with unset UID");
736 if (info.
size != 0) {
737 TEST_FAIL(
"Size should not have changed");
741 if (info.
flags != 0) {
742 TEST_FAIL(
"Flags should not have changed");
749 TEST_FAIL(
"Get info should not succeed with invalid UID");
754 if (info.
size != 0) {
755 TEST_FAIL(
"Size should not have changed");
759 if (info.
flags != 0) {
760 TEST_FAIL(
"Flags should not have changed");
778 const uint32_t offset = 0;
781 size_t read_data_len = 0;
783 status =
psa_ps_set(uid, data_len, write_data, flags);
792 TEST_FAIL(
"Remove should not fail with valid UID");
799 TEST_FAIL(
"Get info should not succeed with removed UID");
804 status =
psa_ps_get(uid, offset, data_len, read_data, &read_data_len);
806 TEST_FAIL(
"Get should not succeed with removed UID");
813 TEST_FAIL(
"Remove should not succeed with removed UID");
832 TEST_FAIL(
"Remove should not succeed with write once UID");
851 TEST_FAIL(
"Remove should not succeed with invalid UID");
858 #ifdef TFM_NS_CLIENT_IDENTIFICATION
862 static void tfm_ps_test_1016_task_1(
struct test_result_t *ret)
870 status =
psa_ps_set(uid, data_len, write_data, flags);
872 TEST_FAIL(
"Set should not fail with valid thread name");
882 static void tfm_ps_test_1016_task_2(
struct test_result_t *ret)
887 const uint32_t offset = 0;
889 size_t read_data_len = 0;
891 status =
psa_ps_get(uid, offset, data_len, read_data, &read_data_len);
893 TEST_FAIL(
"Get should not succeed with invalid thread name");
899 TEST_FAIL(
"Read data should not have changed");
909 static void tfm_ps_test_1016_task_3(
struct test_result_t *ret)
916 TEST_FAIL(
"Remove should not fail with valid thread name");
944 static void tfm_ps_test_1017_task_1(
struct test_result_t *ret)
952 status =
psa_ps_set(uid, data_len, write_data, flags);
954 TEST_FAIL(
"Set should not fail with valid thread name");
964 static void tfm_ps_test_1017_task_2(
struct test_result_t *ret)
972 TEST_FAIL(
"Get info should not succeed with invalid thread name");
978 TEST_FAIL(
"Info should not have changed");
988 static void tfm_ps_test_1017_task_3(
struct test_result_t *ret)
995 TEST_FAIL(
"Remove should not fail with valid thread name");
1023 static void tfm_ps_test_1018_task_1(
struct test_result_t *ret)
1031 status =
psa_ps_set(uid, data_len, write_data, flags);
1033 TEST_FAIL(
"Set should not fail with valid thread name");
1043 static void tfm_ps_test_1018_task_2(
struct test_result_t *ret)
1050 TEST_FAIL(
"Remove should not succeed with invalid thread name");
1060 static void tfm_ps_test_1018_task_3(
struct test_result_t *ret)
1067 TEST_FAIL(
"Remove should not fail with valid thread name");
1095 static void tfm_ps_test_1019_task_1(
struct test_result_t *ret)
1100 const uint8_t write_data[] =
"Thread A data";
1102 status =
psa_ps_set(uid,
sizeof(write_data), write_data, flags);
1104 TEST_FAIL(
"Set should not fail with valid UID");
1114 static void tfm_ps_test_1019_task_2(
struct test_result_t *ret)
1121 const uint32_t offset = 0;
1124 size_t read_data_len = 0;
1127 status =
psa_ps_get(uid, offset, data_len, read_data, &read_data_len);
1129 TEST_FAIL(
"Get should not find another thread's UID");
1135 TEST_FAIL(
"Read data should not have changed");
1141 TEST_FAIL(
"Get info should not find another thread's UID");
1146 if (info.
size != 0 || info.
flags != 0) {
1147 TEST_FAIL(
"Info should not have changed");
1153 TEST_FAIL(
"Remove should not find another thread's UID");
1158 status =
psa_ps_set(uid, data_len, write_data, flags);
1160 TEST_FAIL(
"Set should not fail with valid UID");
1167 TEST_FAIL(
"Get should not fail with valid UID");
1173 TEST_FAIL(
"Read data should be equal to result data");
1180 TEST_FAIL(
"Remove should not fail with valid UID");
1190 static void tfm_ps_test_1019_task_3(
struct test_result_t *ret)
1196 const uint32_t offset = 0;
1197 const uint8_t write_data[] =
"Thread A data";
1199 size_t read_data_len = 0;
1201 const uint32_t data_len =
sizeof(write_data);
1206 TEST_FAIL(
"Get info should not fail with valid UID");
1211 if (info.
size != data_len || info.
flags != flags) {
1212 TEST_FAIL(
"Info should be equal to original info");
1217 status =
psa_ps_get(uid, offset, data_len, read_data, &read_data_len);
1219 TEST_FAIL(
"Get should not fail with valid UID");
1224 if (
memcmp(read_data, write_data, data_len) != 0) {
1225 TEST_FAIL(
"Read data should be equal to original write data");
1232 TEST_FAIL(
"Remove should not fail with valid UID");
1260 static void tfm_ps_test_1020_task_1(
struct test_result_t *ret)
1265 const uint8_t write_data[] =
"A";
1267 status =
psa_ps_set(uid,
sizeof(write_data), write_data, flags);
1269 TEST_FAIL(
"Set should succeed for Thread_A");
1279 static void tfm_ps_test_1020_task_2(
struct test_result_t *ret)
1284 const uint8_t write_data[] =
"B";
1286 status =
psa_ps_set(uid,
sizeof(write_data), write_data, flags);
1288 TEST_FAIL(
"Set should succeed for Thread_B");
1298 static void tfm_ps_test_1020_task_3(
struct test_result_t *ret)
1303 const uint8_t write_data[] =
"HELLO";
1305 status =
psa_ps_set(uid,
sizeof(write_data), write_data, flags);
1307 TEST_FAIL(
"Second set should succeed for Thread_A");
1317 static void tfm_ps_test_1020_task_4(
struct test_result_t *ret)
1322 const uint8_t write_data[] =
"WORLD_1234";
1324 status =
psa_ps_set(uid,
sizeof(write_data), write_data, flags);
1326 TEST_FAIL(
"Second set should succeed for Thread_B");
1336 static void tfm_ps_test_1020_task_5(
struct test_result_t *ret)
1340 const uint32_t offset = 0;
1341 const uint8_t write_data[] =
"HELLO";
1343 size_t read_data_len = 0;
1345 status =
psa_ps_get(uid, offset,
sizeof(write_data), read_data,
1348 TEST_FAIL(
"Get should succeed for Thread_A");
1353 if (
memcmp(read_data, write_data,
sizeof(write_data)) != 0) {
1354 TEST_FAIL(
"Read data incorrect for Thread_A");
1364 static void tfm_ps_test_1020_task_6(
struct test_result_t *ret)
1368 const uint32_t offset = 0;
1369 const uint8_t write_data[] =
"WORLD_1234";
1371 size_t read_data_len = 0;
1373 status =
psa_ps_get(uid, offset,
sizeof(write_data), read_data,
1376 TEST_FAIL(
"Get should succeed for Thread_B");
1381 if (
memcmp(read_data, write_data,
sizeof(write_data)) != 0) {
1382 TEST_FAIL(
"Read data incorrect for Thread_B");
1389 TEST_FAIL(
"Remove should work form Thread_B");
1399 static void tfm_ps_test_1020_task_7(
struct test_result_t *ret)
1407 TEST_FAIL(
"Remove should work form Thread_B");
1468 const uint32_t offset = 0;
1469 const uint8_t write_data_1[] =
"UID 1 DATA";
1472 size_t read_data_len = 0;
1475 status =
psa_ps_set(uid_1,
sizeof(write_data_1), write_data_1, flags);
1477 TEST_FAIL(
"Set should not fail for UID 1");
1482 status =
psa_ps_set(uid_2, data_len_2, write_data_2, flags);
1484 TEST_FAIL(
"Set should not fail for UID 2");
1493 TEST_FAIL(
"Remove should not fail for UID 1");
1500 status =
psa_ps_get(uid_2, offset, data_len_2,
1503 TEST_FAIL(
"Get should not fail for UID 2");
1508 TEST_FAIL(
"Read buffer has incorrect data");
1515 TEST_FAIL(
"Remove should not fail for UID 2");
1532 uint32_t offset = 0;
1535 size_t read_data_len = 0;
1538 status =
psa_ps_set(uid, data_len, write_data, flags);
1545 for (i = 0; i < data_len; ++i) {
1550 TEST_FAIL(
"Get should not fail for partial read");
1558 TEST_FAIL(
"Read buffer has incorrect data");
1580 const uint32_t offset = 0;
1581 const uint8_t write_data_1[] =
"ONE";
1582 const uint8_t write_data_2[] =
"TWO";
1583 const uint8_t write_data_3[] =
"THREE";
1585 size_t read_data_len = 0;
1588 status =
psa_ps_set(uid,
sizeof(write_data_1), write_data_1, flags);
1595 status =
psa_ps_set(uid,
sizeof(write_data_2), write_data_2, flags);
1597 TEST_FAIL(
"Second set should not fail");
1602 status =
psa_ps_set(uid,
sizeof(write_data_3), write_data_3, flags);
1608 status =
psa_ps_get(uid, offset,
sizeof(write_data_3), read_data,
1616 if (
memcmp(read_data, write_data_3,
sizeof(write_data_3)) != 0) {
1617 TEST_FAIL(
"Read buffer has incorrect data");
1636 uint32_t support_flags;
1639 if (support_flags != 0) {
1662 PS_MAX_ASSET_SIZE >> 2,
1663 PS_MAX_ASSET_SIZE >> 1,
1668 uint32_t data_size = test_asset_sizes[cycle];
1672 memset(read_asset_data, 0x00,
sizeof(read_asset_data));
1680 TEST_FAIL(
"Set should not fail with valid UID");
1687 TEST_FAIL(
"Get info should not fail with valid UID");
1692 if (info.
size != data_size) {
1693 TEST_FAIL(
"Size incorrect for valid UID");
1698 TEST_FAIL(
"Flags incorrect for valid UID");
1703 status =
psa_ps_get(uid, 0, data_size, read_asset_data,
1704 &read_asset_data_len);
1706 TEST_FAIL(
"Get should not fail with valid UID");
1711 if (
memcmp(read_asset_data, write_asset_data, data_size) != 0) {
1712 TEST_FAIL(
"Read data should be equal to original write data");
1719 TEST_FAIL(
"Remove should not fail with valid UID");
#define OFFSET_RESULT_DATA
#define INVALID_THREAD_NAME
psa_status_t psa_ps_get(psa_storage_uid_t uid, size_t data_offset, size_t data_size, void *p_data, size_t *p_data_length)
Retrieve data associated with a provided uid.
#define TEST_FAIL(info_msg)
enum test_suite_err_t set_testsuite(const char *name, struct test_t *test_list, uint32_t size, struct test_suite_t *p_ts)
Sets test suite parameters.
psa_status_t psa_ps_set(psa_storage_uid_t uid, size_t data_length, const void *p_data, psa_storage_create_flags_t create_flags)
Create a new, or modify an existing, uid/value pair.
#define PSA_STORAGE_FLAG_WRITE_ONCE
#define PSA_ERROR_INVALID_ARGUMENT
psa_status_t psa_ps_get_info(psa_storage_uid_t uid, struct psa_storage_info_t *p_info)
Retrieve the metadata about the provided uid.
void tfm_ps_run_test(const char *thread_name, struct test_result_t *ret, test_func_t *test_func)
Executes the given test function from the specified thread context.
#define PSA_ERROR_NOT_PERMITTED
void register_testsuite_ns_psa_ps_interface(struct test_suite_t *p_test_suite)
Register testsuite for the PSA protected storage NS interface tests.
struct test_result_t * ret
psa_status_t psa_ps_remove(psa_storage_uid_t uid)
Remove the provided uid and its associated data from the storage.
#define TFM_PS_NS_TEST(test_num, thread_name)
Defines a single-threaded PS NS test function and declares the corresponding task function...
int memcmp(const void *s1, const void *s2, size_t n)
#define PSA_ERROR_NOT_SUPPORTED
#define HALF_PADDING_SIZE
void * memcpy(void *dest, const void *src, size_t n)
uint32_t psa_ps_get_support(void)
Lists optional features.
uint64_t psa_storage_uid_t
#define WRITE_ONCE_READ_DATA
psa_storage_create_flags_t flags
#define PSA_STORAGE_FLAG_NONE
#define PSA_ERROR_DOES_NOT_EXIST
uint32_t psa_storage_create_flags_t
int32_t psa_status_t
Function return status.
void * memset(void *s, int c, size_t n)
#define WRITE_ONCE_DATA_SIZE
#define WRITE_ONCE_RESULT_DATA