ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Fix astyle issues 

Signed-off-by: Darryl Green <darryl.green@arm.com>
pull/13003/head
Darryl Green 2020-05-27 09:47:56 +01:00
parent fcf60ec683
commit a62b3591d9
17 changed files with 369 additions and 415 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/COMPONENT_PSA_SRV_IMPL/src/default_random_seed.cpp
View File

@ -7,12 +7,12 @@ int mbed_default_seed_read(unsigned char *buf, size_t buf_len)
{
size_t actual_size;
psa_status_t rc = psa_its_get(PSA_CRYPTO_ITS_RANDOM_SEED_UID, 0, buf_len, buf, &actual_size);
return ( rc );
return (rc);
}
int mbed_default_seed_write(unsigned char *buf, size_t buf_len)
{
psa_status_t rc = psa_its_set(PSA_CRYPTO_ITS_RANDOM_SEED_UID, buf_len, buf, 0);
return ( rc );
return (rc);
}

15
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/pal/pal_attestation_intf.c
View File

@ -29,22 +29,21 @@ int32_t pal_attestation_function(int type, va_list valist)
uint8_t *challenge, *token;
uint32_t challenge_size, *token_size, verify_token_size;
switch (type)
{
switch (type) {
case PAL_INITIAL_ATTEST_GET_TOKEN:
challenge = va_arg(valist, uint8_t*);
challenge = va_arg(valist, uint8_t *);
challenge_size = va_arg(valist, uint32_t);
token = va_arg(valist, uint8_t*);
token_size = va_arg(valist, uint32_t*);
token = va_arg(valist, uint8_t *);
token_size = va_arg(valist, uint32_t *);
return psa_initial_attest_get_token(challenge, challenge_size, token, token_size);
case PAL_INITIAL_ATTEST_GET_TOKEN_SIZE:
challenge_size = va_arg(valist, uint32_t);
token_size = va_arg(valist, uint32_t*);
token_size = va_arg(valist, uint32_t *);
return psa_initial_attest_get_token_size(challenge_size, token_size);
case PAL_INITIAL_ATTEST_VERIFY_TOKEN:
challenge = va_arg(valist, uint8_t*);
challenge = va_arg(valist, uint8_t *);
challenge_size = va_arg(valist, uint32_t);
token = va_arg(valist, uint8_t*);
token = va_arg(valist, uint8_t *);
verify_token_size = va_arg(valist, uint32_t);
return pal_initial_attest_verify_token(challenge, challenge_size,
token, verify_token_size);

8
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/pal/pal_client_api_empty_intf.c
View File

@ -73,10 +73,10 @@ psa_handle_t pal_ipc_connect(uint32_t sid, uint32_t minor_version)
*/
psa_status_t pal_ipc_call(psa_handle_t handle,
const psa_invec *in_vec,
size_t in_len,
psa_outvec *out_vec,
size_t out_len)
const psa_invec *in_vec,
size_t in_len,
psa_outvec *out_vec,
size_t out_len)
{
return (PSA_SUCCESS - 1);
}

8
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/pal/pal_client_api_intf.c
View File

@ -76,10 +76,10 @@ psa_handle_t pal_ipc_connect(uint32_t sid, uint32_t minor_version)
*/
psa_status_t pal_ipc_call(psa_handle_t handle,
const psa_invec *in_vec,
size_t in_len,
psa_outvec *out_vec,
size_t out_len)
const psa_invec *in_vec,
size_t in_len,
psa_outvec *out_vec,
size_t out_len)
{
return (psa_call(handle, in_vec, in_len, out_vec, out_len));
}

8
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/pal/pal_client_api_intf.h
View File

@ -65,9 +65,9 @@ uint32_t pal_ipc_framework_version(void);
uint32_t pal_ipc_version(uint32_t sid);
psa_handle_t pal_ipc_connect(uint32_t sid, uint32_t minor_version);
psa_status_t pal_ipc_call(psa_handle_t handle,
const psa_invec *in_vec,
size_t in_len,
psa_outvec *out_vec,
size_t out_len);
const psa_invec *in_vec,
size_t in_len,
psa_outvec *out_vec,
size_t out_len);
void pal_ipc_close(psa_handle_t handle);
#endif /* _PAL_CLIENT_API_H_ */

3
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/pal/pal_common.h
View File

@ -41,8 +41,7 @@ typedef uint32_t cfg_id_t;
#define PAL_STATUS_UNSUPPORTED_FUNC 0xFF
typedef enum
{
typedef enum {
PAL_STATUS_SUCCESS = 0x0,
PAL_STATUS_ERROR = 0x80
} pal_status_t;

91
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/pal/pal_internal_trusted_storage_intf.c
View File

@ -40,52 +40,51 @@ uint32_t pal_its_function(int type, va_list valist)
*/
size_t actual_size;
switch (type)
{
case PAL_ITS_SET:
uid = va_arg(valist, psa_storage_uid_t);
data_length = va_arg(valist, uint32_t);
p_write_data = va_arg(valist, const void*);
its_create_flags = va_arg(valist, psa_storage_create_flags_t);
return psa_its_set(uid, data_length, p_write_data, its_create_flags);
case PAL_ITS_GET:
uid = va_arg(valist, psa_storage_uid_t);
offset = va_arg(valist, uint32_t);
data_length = va_arg(valist, uint32_t);
p_read_data = va_arg(valist, void*);
/* TODO: Actual size argument is currently not supported by the testing framework.
* Changes need to be implemented in the actual tests.
* Should be fixed by the next import of the tests.
*/
return psa_its_get(uid, offset, data_length, p_read_data, &actual_size);
case PAL_ITS_GET_INFO:
uid = va_arg(valist, psa_storage_uid_t);
its_p_info = va_arg(valist, struct psa_its_info_t*);
return psa_its_get_info(uid, (struct psa_storage_info_t *)its_p_info);
case PAL_ITS_REMOVE:
uid = va_arg(valist, psa_storage_uid_t);
return psa_its_remove(uid);
/* case PAL_PS_SET: */
/* uid = va_arg(valist, uint32_t); */
/* data_length = va_arg(valist, uint32_t); */
/* p_write_data = va_arg(valist, const void*); */
/* ps_create_flags = va_arg(valist, psa_ps_create_flags_t); */
/* return psa_ps_set(uid, data_length, p_write_data, ps_create_flags); */
/* case PAL_PS_GET: */
/* uid = va_arg(valist, uint32_t); */
/* offset = va_arg(valist, uint32_t); */
/* data_length = va_arg(valist, uint32_t); */
/* p_read_data = va_arg(valist, void*); */
/* return psa_ps_get(uid, offset, data_length, p_read_data); */
/* case PAL_PS_GET_INFO: */
/* uid = va_arg(valist, uint32_t); */
/* ps_p_info = va_arg(valist, struct psa_eps_info_t*); */
/* return psa_ps_get_info(uid, ps_p_info); */
/* case PAL_PS_REMOVE: */
/* uid = va_arg(valist, uint32_t); */
/* return psa_ps_remove(uid); */
default:
return PAL_STATUS_UNSUPPORTED_FUNC;
switch (type) {
case PAL_ITS_SET:
uid = va_arg(valist, psa_storage_uid_t);
data_length = va_arg(valist, uint32_t);
p_write_data = va_arg(valist, const void *);
its_create_flags = va_arg(valist, psa_storage_create_flags_t);
return psa_its_set(uid, data_length, p_write_data, its_create_flags);
case PAL_ITS_GET:
uid = va_arg(valist, psa_storage_uid_t);
offset = va_arg(valist, uint32_t);
data_length = va_arg(valist, uint32_t);
p_read_data = va_arg(valist, void *);
/* TODO: Actual size argument is currently not supported by the testing framework.
* Changes need to be implemented in the actual tests.
* Should be fixed by the next import of the tests.
*/
return psa_its_get(uid, offset, data_length, p_read_data, &actual_size);
case PAL_ITS_GET_INFO:
uid = va_arg(valist, psa_storage_uid_t);
its_p_info = va_arg(valist, struct psa_its_info_t *);
return psa_its_get_info(uid, (struct psa_storage_info_t *)its_p_info);
case PAL_ITS_REMOVE:
uid = va_arg(valist, psa_storage_uid_t);
return psa_its_remove(uid);
/* case PAL_PS_SET: */
/* uid = va_arg(valist, uint32_t); */
/* data_length = va_arg(valist, uint32_t); */
/* p_write_data = va_arg(valist, const void*); */
/* ps_create_flags = va_arg(valist, psa_ps_create_flags_t); */
/* return psa_ps_set(uid, data_length, p_write_data, ps_create_flags); */
/* case PAL_PS_GET: */
/* uid = va_arg(valist, uint32_t); */
/* offset = va_arg(valist, uint32_t); */
/* data_length = va_arg(valist, uint32_t); */
/* p_read_data = va_arg(valist, void*); */
/* return psa_ps_get(uid, offset, data_length, p_read_data); */
/* case PAL_PS_GET_INFO: */
/* uid = va_arg(valist, uint32_t); */
/* ps_p_info = va_arg(valist, struct psa_eps_info_t*); */
/* return psa_ps_get_info(uid, ps_p_info); */
/* case PAL_PS_REMOVE: */
/* uid = va_arg(valist, uint32_t); */
/* return psa_ps_remove(uid); */
default:
return PAL_STATUS_UNSUPPORTED_FUNC;
}
#else
return PAL_STATUS_ERROR;

39
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/pal/pal_mbed_os_intf.cpp
View File

@ -27,25 +27,25 @@ test_entry_f test_g = NULL;
compliance_test_type type_g = COMPLIANCE_TEST_UNDEFINED;
// randomly generated attestation key used for testing the attestation feature.
// The specific key chosen shouldn't matter to the attestation test
// The specific key chosen shouldn't matter to the attestation test
// the test just needs a key to be injected before it is run.
static const uint8_t private_key_data[] = {
0x49, 0xc9, 0xa8, 0xc1, 0x8c, 0x4b, 0x88, 0x56,
0x38, 0xc4, 0x31, 0xcf, 0x1d, 0xf1, 0xc9, 0x94,
0x13, 0x16, 0x09, 0xb5, 0x80, 0xd4, 0xfd, 0x43,
0xa0, 0xca, 0xb1, 0x7d, 0xb2, 0xf1, 0x3e, 0xee
0x49, 0xc9, 0xa8, 0xc1, 0x8c, 0x4b, 0x88, 0x56,
0x38, 0xc4, 0x31, 0xcf, 0x1d, 0xf1, 0xc9, 0x94,
0x13, 0x16, 0x09, 0xb5, 0x80, 0xd4, 0xfd, 0x43,
0xa0, 0xca, 0xb1, 0x7d, 0xb2, 0xf1, 0x3e, 0xee
};
static const uint8_t public_key_data[] = {
0x04, 0x77, 0x72, 0x65, 0x6f, 0x81, 0x4b, 0x39,
0x92, 0x79, 0xd5, 0xe1, 0xf1, 0x78, 0x1f, 0xac,
0x6f, 0x09, 0x9a, 0x3c, 0x5c, 0xa1, 0xb0, 0xe3,
0x53, 0x51, 0x83, 0x4b, 0x08, 0xb6, 0x5e, 0x0b,
0x57, 0x25, 0x90, 0xcd, 0xaf, 0x8f, 0x76, 0x93,
0x61, 0xbc, 0xf3, 0x4a, 0xcf, 0xc1, 0x1e, 0x5e,
0x07, 0x4e, 0x84, 0x26, 0xbd, 0xde, 0x04, 0xbe,
0x6e, 0x65, 0x39, 0x45, 0x44, 0x96, 0x17, 0xde,
0x45
0x04, 0x77, 0x72, 0x65, 0x6f, 0x81, 0x4b, 0x39,
0x92, 0x79, 0xd5, 0xe1, 0xf1, 0x78, 0x1f, 0xac,
0x6f, 0x09, 0x9a, 0x3c, 0x5c, 0xa1, 0xb0, 0xe3,
0x53, 0x51, 0x83, 0x4b, 0x08, 0xb6, 0x5e, 0x0b,
0x57, 0x25, 0x90, 0xcd, 0xaf, 0x8f, 0x76, 0x93,
0x61, 0xbc, 0xf3, 0x4a, 0xcf, 0xc1, 0x1e, 0x5e,
0x07, 0x4e, 0x84, 0x26, 0xbd, 0xde, 0x04, 0xbe,
0x6e, 0x65, 0x39, 0x45, 0x44, 0x96, 0x17, 0xde,
0x45
};
static void psa_attestation_destroy_key_for_test()
@ -108,16 +108,11 @@ void main_wrapper(void)
void pal_mbed_os_compliance_test_initialize(void)
{
if (COMPLIANCE_TEST_CRYPTO == type_g)
{
if (COMPLIANCE_TEST_CRYPTO == type_g) {
inject_entropy();
}
else if (COMPLIANCE_TEST_STORAGE == type_g)
{
} else if (COMPLIANCE_TEST_STORAGE == type_g) {
reset_storage_for_compliance_test();
}
else if (COMPLIANCE_TEST_ATTESTATION == type_g)
{
} else if (COMPLIANCE_TEST_ATTESTATION == type_g) {
reset_storage_for_compliance_test();
inject_entropy();
psa_crypto_init();

4
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/pal/pal_mbed_os_intf.h
View File

@ -7,14 +7,14 @@
extern "C" {
#endif
typedef enum _compliance_test_type{
typedef enum _compliance_test_type {
COMPLIANCE_TEST_UNDEFINED,
COMPLIANCE_TEST_START = COMPLIANCE_TEST_UNDEFINED,
COMPLIANCE_TEST_CRYPTO,
COMPLIANCE_TEST_ATTESTATION,
COMPLIANCE_TEST_STORAGE,
COMPLIANCE_TEST_END
}compliance_test_type;
} compliance_test_type;
typedef void (*test_entry_f)(val_api_t *val_api, psa_api_t *psa_api);
int test_start(test_entry_f test_f, compliance_test_type type);

45
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/pal/pal_protected_storage_intf.c
View File

@ -34,29 +34,28 @@ uint32_t pal_ps_function(int type, va_list valist)
psa_storage_create_flags_t ps_create_flags;
struct psa_ps_info_t *ps_p_info;
switch (type)
{
case PAL_PS_SET:
uid = va_arg(valist, psa_storage_uid_t);
data_length = va_arg(valist, uint32_t);
p_write_data = va_arg(valist, const void*);
ps_create_flags = va_arg(valist, psa_storage_create_flags_t);
return psa_ps_set(uid, data_length, p_write_data, ps_create_flags);
case PAL_PS_GET:
uid = va_arg(valist, psa_storage_uid_t);
offset = va_arg(valist, uint32_t);
data_length = va_arg(valist, uint32_t);
p_read_data = va_arg(valist, void*);
return psa_ps_get(uid, offset, data_length, p_read_data, &actual_length);
case PAL_PS_GET_INFO:
uid = va_arg(valist, psa_storage_uid_t);
ps_p_info = va_arg(valist, struct psa_ps_info_t*);
return psa_ps_get_info(uid, ps_p_info);
case PAL_PS_REMOVE:
uid = va_arg(valist, psa_storage_uid_t);
return psa_ps_remove(uid);
default:
return PAL_STATUS_UNSUPPORTED_FUNC;
switch (type) {
case PAL_PS_SET:
uid = va_arg(valist, psa_storage_uid_t);
data_length = va_arg(valist, uint32_t);
p_write_data = va_arg(valist, const void *);
ps_create_flags = va_arg(valist, psa_storage_create_flags_t);
return psa_ps_set(uid, data_length, p_write_data, ps_create_flags);
case PAL_PS_GET:
uid = va_arg(valist, psa_storage_uid_t);
offset = va_arg(valist, uint32_t);
data_length = va_arg(valist, uint32_t);
p_read_data = va_arg(valist, void *);
return psa_ps_get(uid, offset, data_length, p_read_data, &actual_length);
case PAL_PS_GET_INFO:
uid = va_arg(valist, psa_storage_uid_t);
ps_p_info = va_arg(valist, struct psa_ps_info_t *);
return psa_ps_get_info(uid, ps_p_info);
case PAL_PS_REMOVE:
uid = va_arg(valist, psa_storage_uid_t);
return psa_ps_remove(uid);
default:
return PAL_STATUS_UNSUPPORTED_FUNC;
}
#else
return PAL_STATUS_ERROR;

234
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/pal_attestation_eat.c
View File

@ -28,34 +28,27 @@ static int get_items_in_map(QCBORDecodeContext *decode_context,
struct items_to_get_t *item_ptr = item_list;
/* initialize the data type of all items in the list */
while (item_ptr->label != 0)
{
while (item_ptr->label != 0) {
item_ptr->item.uDataType = QCBOR_TYPE_NONE;
item_ptr++;
}
QCBORDecode_GetNext(decode_context, &item);
if (item.uDataType != QCBOR_TYPE_MAP)
{
if (item.uDataType != QCBOR_TYPE_MAP) {
return PAL_ATTEST_ERROR;
}
for (item_index = item.val.uCount; item_index != 0; item_index--)
{
if (QCBORDecode_GetNext(decode_context, &item) != QCBOR_SUCCESS)
{
for (item_index = item.val.uCount; item_index != 0; item_index--) {
if (QCBORDecode_GetNext(decode_context, &item) != QCBOR_SUCCESS) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
if (item.uLabelType != QCBOR_TYPE_INT64)
{
if (item.uLabelType != QCBOR_TYPE_INT64) {
continue;
}
item_ptr = item_list;
while (item_ptr->label != 0)
{
if (item.label.int64 == item_ptr->label)
{
while (item_ptr->label != 0) {
if (item.label.int64 == item_ptr->label) {
item_ptr->item = item;
}
item_ptr++;
@ -74,13 +67,11 @@ static int get_item_in_map(QCBORDecodeContext *decode_context,
item_list[0].label = label;
item_list[1].label = 0;
if (get_items_in_map(decode_context, item_list))
{
if (get_items_in_map(decode_context, item_list)) {
return PAL_ATTEST_ERROR;
}
if (item_list[0].item.uDataType == QCBOR_TYPE_NONE)
{
if (item_list[0].item.uDataType == QCBOR_TYPE_NONE) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
@ -100,18 +91,15 @@ static int parse_unprotected_headers(QCBORDecodeContext *decode_context,
item_list[2].label = 0;
*loop_back = false;
if (get_items_in_map(decode_context, item_list))
{
if (get_items_in_map(decode_context, item_list)) {
return PAL_ATTEST_ERROR;
}
if (item_list[1].item.uDataType == QCBOR_TYPE_TRUE)
{
if (item_list[1].item.uDataType == QCBOR_TYPE_TRUE) {
*loop_back = true;
}
if (item_list[0].item.uDataType != QCBOR_TYPE_BYTE_STRING)
{
if (item_list[0].item.uDataType != QCBOR_TYPE_BYTE_STRING) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
@ -128,18 +116,15 @@ static int parse_protected_headers(struct useful_buf_c protected_headers,
QCBORDecode_Init(&decode_context, protected_headers, 0);
if (get_item_in_map(&decode_context, COSE_HEADER_PARAM_ALG, &item))
{
if (get_item_in_map(&decode_context, COSE_HEADER_PARAM_ALG, &item)) {
return PAL_ATTEST_ERROR;
}
if (QCBORDecode_Finish(&decode_context))
{
if (QCBORDecode_Finish(&decode_context)) {
return PAL_ATTEST_ERROR;
}
if ((item.uDataType != QCBOR_TYPE_INT64) || (item.val.int64 > INT32_MAX))
{
if ((item.uDataType != QCBOR_TYPE_INT64) || (item.val.int64 > INT32_MAX)) {
return PAL_ATTEST_ERROR;
}
@ -156,118 +141,106 @@ static int parse_protected_headers(struct useful_buf_c protected_headers,
@return - error status
**/
static int parse_claims(QCBORDecodeContext *decode_context, QCBORItem item,
struct useful_buf_c completed_challenge)
struct useful_buf_c completed_challenge)
{
int i, count = 0;
int status = PAL_ATTEST_SUCCESS;
/* Parse each claim and validate their data type */
while (status == PAL_ATTEST_SUCCESS)
{
while (status == PAL_ATTEST_SUCCESS) {
status = QCBORDecode_GetNext(decode_context, &item);
if (status != PAL_ATTEST_SUCCESS)
if (status != PAL_ATTEST_SUCCESS) {
break;
}
mandatory_claims |= 1 << (EAT_CBOR_ARM_RANGE_BASE - item.label.int64);
if (item.uLabelType == QCBOR_TYPE_INT64)
{
if (item.label.int64 == EAT_CBOR_ARM_LABEL_NONCE)
{
if (item.uDataType == QCBOR_TYPE_BYTE_STRING)
{
if (item.uLabelType == QCBOR_TYPE_INT64) {
if (item.label.int64 == EAT_CBOR_ARM_LABEL_NONCE) {
if (item.uDataType == QCBOR_TYPE_BYTE_STRING) {
/* Given challenge vs challenge in token */
if (UsefulBuf_Compare(item.val.string, completed_challenge))
if (UsefulBuf_Compare(item.val.string, completed_challenge)) {
return PAL_ATTEST_TOKEN_CHALLENGE_MISMATCH;
}
else
}
} else {
return PAL_ATTEST_TOKEN_NOT_SUPPORTED;
}
else if (item.label.int64 == EAT_CBOR_ARM_LABEL_BOOT_SEED ||
item.label.int64 == EAT_CBOR_ARM_LABEL_IMPLEMENTATION_ID ||
item.label.int64 == EAT_CBOR_ARM_LABEL_UEID)
{
if (item.uDataType != QCBOR_TYPE_BYTE_STRING)
}
} else if (item.label.int64 == EAT_CBOR_ARM_LABEL_BOOT_SEED ||
item.label.int64 == EAT_CBOR_ARM_LABEL_IMPLEMENTATION_ID ||
item.label.int64 == EAT_CBOR_ARM_LABEL_UEID) {
if (item.uDataType != QCBOR_TYPE_BYTE_STRING) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
else if (item.label.int64 == EAT_CBOR_ARM_LABEL_ORIGINATION ||
item.label.int64 == EAT_CBOR_ARM_LABEL_PROFILE_DEFINITION ||
item.label.int64 == EAT_CBOR_ARM_LABEL_HW_VERSION)
{
if (item.uDataType != QCBOR_TYPE_TEXT_STRING)
}
} else if (item.label.int64 == EAT_CBOR_ARM_LABEL_ORIGINATION ||
item.label.int64 == EAT_CBOR_ARM_LABEL_PROFILE_DEFINITION ||
item.label.int64 == EAT_CBOR_ARM_LABEL_HW_VERSION) {
if (item.uDataType != QCBOR_TYPE_TEXT_STRING) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
else if (item.label.int64 == EAT_CBOR_ARM_LABEL_CLIENT_ID ||
item.label.int64 == EAT_CBOR_ARM_LABEL_SECURITY_LIFECYCLE)
{
if (item.uDataType != QCBOR_TYPE_INT64)
}
} else if (item.label.int64 == EAT_CBOR_ARM_LABEL_CLIENT_ID ||
item.label.int64 == EAT_CBOR_ARM_LABEL_SECURITY_LIFECYCLE) {
if (item.uDataType != QCBOR_TYPE_INT64) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
else if (item.label.int64 == EAT_CBOR_ARM_LABEL_SW_COMPONENTS)
{
if (item.uDataType != QCBOR_TYPE_ARRAY)
}
} else if (item.label.int64 == EAT_CBOR_ARM_LABEL_SW_COMPONENTS) {
if (item.uDataType != QCBOR_TYPE_ARRAY) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
sw_component_present = 1;
status = QCBORDecode_GetNext(decode_context, &item);
if (status != PAL_ATTEST_SUCCESS)
if (status != PAL_ATTEST_SUCCESS) {
continue;
}
count = item.val.uCount;
for (i = 0; i <= count; i++)
{
for (i = 0; i <= count; i++) {
mandaroty_sw_components |= 1 << item.label.int64;
if (item.label.int64 == EAT_CBOR_SW_COMPONENT_MEASUREMENT)
{
if (item.uDataType != QCBOR_TYPE_BYTE_STRING)
if (item.label.int64 == EAT_CBOR_SW_COMPONENT_MEASUREMENT) {
if (item.uDataType != QCBOR_TYPE_BYTE_STRING) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_MEASUREMENT_DESC)
{
if (item.uDataType != QCBOR_TYPE_TEXT_STRING)
}
} else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_MEASUREMENT_DESC) {
if (item.uDataType != QCBOR_TYPE_TEXT_STRING) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_VERSION)
{
if (item.uDataType != QCBOR_TYPE_TEXT_STRING)
}
} else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_VERSION) {
if (item.uDataType != QCBOR_TYPE_TEXT_STRING) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_SIGNER_ID)
{
if (item.uDataType != QCBOR_TYPE_BYTE_STRING)
}
} else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_SIGNER_ID) {
if (item.uDataType != QCBOR_TYPE_BYTE_STRING) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_EPOCH)
{
if (item.uDataType != QCBOR_TYPE_INT64)
}
} else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_EPOCH) {
if (item.uDataType != QCBOR_TYPE_INT64) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_TYPE)
{
if (item.uDataType != QCBOR_TYPE_TEXT_STRING)
}
} else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_TYPE) {
if (item.uDataType != QCBOR_TYPE_TEXT_STRING) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
}
if (i < count)
{
if (i < count) {
status = QCBORDecode_GetNext(decode_context, &item);
if (status != PAL_ATTEST_SUCCESS)
if (status != PAL_ATTEST_SUCCESS) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
}
}
}
}
else
{
} else {
/* ToDo: Add other claim types */
}
}
if (status == QCBOR_ERR_HIT_END)
if (status == QCBOR_ERR_HIT_END) {
return PAL_ATTEST_SUCCESS;
else
} else {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
}
/**
@ -300,19 +273,19 @@ int32_t pal_initial_attest_verify_token(uint8_t *challenge, uint32_t challenge_s
completed_challenge.ptr = challenge;
completed_challenge.len = challenge_size;
/*
-------------------------
| CBOR Array Type |
-------------------------
| Protected Headers |
-------------------------
| Unprotected Headers |
-------------------------
| Payload |
-------------------------
| Signature |
-------------------------
*/
/*
-------------------------
| CBOR Array Type |
-------------------------
| Protected Headers |
-------------------------
| Unprotected Headers |
-------------------------
| Payload |
-------------------------
| Signature |
-------------------------
*/
/* Initialize the decorder */
QCBORDecode_Init(&decode_context, completed_token, QCBOR_DECODE_MODE_NORMAL);
@ -324,60 +297,67 @@ int32_t pal_initial_attest_verify_token(uint8_t *challenge, uint32_t challenge_s
* Only COSE_SIGN1 is supported now.
*/
if (item.uDataType != QCBOR_TYPE_ARRAY || item.val.uCount != 4 ||
!QCBORDecode_IsTagged(&decode_context, &item, CBOR_TAG_COSE_SIGN1))
!QCBORDecode_IsTagged(&decode_context, &item, CBOR_TAG_COSE_SIGN1)) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
/* Get the next headers */
QCBORDecode_GetNext(&decode_context, &item);
if (item.uDataType != QCBOR_TYPE_BYTE_STRING)
if (item.uDataType != QCBOR_TYPE_BYTE_STRING) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
protected_headers = item.val.string;
/* Parse the protected headers and check the data type and value*/
status = parse_protected_headers(protected_headers, &cose_algorithm_id);
if (status != PAL_ATTEST_SUCCESS)
if (status != PAL_ATTEST_SUCCESS) {
return status;
}
/* Parse the unprotected headers and check the data type and value */
short_circuit = false;
status = parse_unprotected_headers(&decode_context, &kid, &short_circuit);
if (status != PAL_ATTEST_SUCCESS)
if (status != PAL_ATTEST_SUCCESS) {
return status;
}
/* Get the payload */
QCBORDecode_GetNext(&decode_context, &item);
if (item.uDataType != QCBOR_TYPE_BYTE_STRING)
if (item.uDataType != QCBOR_TYPE_BYTE_STRING) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
payload = item.val.string;
/* Get the digital signature */
QCBORDecode_GetNext(&decode_context, &item);
if (item.uDataType != QCBOR_TYPE_BYTE_STRING)
if (item.uDataType != QCBOR_TYPE_BYTE_STRING) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
/* Initialize the Decoder and validate the payload format */
QCBORDecode_Init(&decode_context, payload, QCBOR_DECODE_MODE_NORMAL);
status = QCBORDecode_GetNext(&decode_context, &item);
if (status != PAL_ATTEST_SUCCESS)
if (status != PAL_ATTEST_SUCCESS) {
return status;
}
if (item.uDataType != QCBOR_TYPE_MAP)
if (item.uDataType != QCBOR_TYPE_MAP) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
/* Parse the payload and check the data type of each claim */
status = parse_claims(&decode_context, item, completed_challenge);
if (status != PAL_ATTEST_SUCCESS)
if (status != PAL_ATTEST_SUCCESS) {
return status;
if ((mandatory_claims & MANDATORY_CLAIM_WITH_SW_COMP) == MANDATORY_CLAIM_WITH_SW_COMP)
{
if ((mandaroty_sw_components & MANDATORY_SW_COMP) != MANDATORY_SW_COMP)
return PAL_ATTEST_TOKEN_NOT_ALL_MANDATORY_CLAIMS;
}
else if ((mandatory_claims & MANDATORY_CLAIM_NO_SW_COMP) != MANDATORY_CLAIM_NO_SW_COMP)
{
if ((mandatory_claims & MANDATORY_CLAIM_WITH_SW_COMP) == MANDATORY_CLAIM_WITH_SW_COMP) {
if ((mandaroty_sw_components & MANDATORY_SW_COMP) != MANDATORY_SW_COMP) {
return PAL_ATTEST_TOKEN_NOT_ALL_MANDATORY_CLAIMS;
}
} else if ((mandatory_claims & MANDATORY_CLAIM_NO_SW_COMP) != MANDATORY_CLAIM_NO_SW_COMP) {
return PAL_ATTEST_TOKEN_NOT_ALL_MANDATORY_CLAIMS;
}

8
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/pal_interfaces_ns.h
View File

@ -72,10 +72,10 @@ psa_handle_t pal_ipc_connect(uint32_t sid, uint32_t minor_version);
*/
psa_status_t pal_ipc_call(psa_handle_t handle,
const psa_invec *in_vec,
size_t in_len,
psa_outvec *out_vec,
size_t out_len);
const psa_invec *in_vec,
size_t in_len,
psa_outvec *out_vec,
size_t out_len);
/**
* @brief - Close a connection to a Root of Trust Service.

70
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/val.h
View File

@ -82,7 +82,7 @@
/* Test Defines */
#define TEST_PUBLISH(test_id, entry)
#define TEST_PUBLISH(test_id, entry)
#define VAL_MAX_TEST_PER_COMP 200
#define VAL_FF_BASE 0
@ -197,36 +197,36 @@ typedef enum {
/* enums to report test sub-state */
typedef enum {
VAL_STATUS_SUCCESS = 0x0,
VAL_STATUS_INVALID = 0x10,
VAL_STATUS_ERROR = 0x11,
VAL_STATUS_NOT_FOUND = 0x12,
VAL_STATUS_LOAD_ERROR = 0x13,
VAL_STATUS_INSUFFICIENT_SIZE = 0x14,
VAL_STATUS_CONNECTION_FAILED = 0x15,
VAL_STATUS_CALL_FAILED = 0x16,
VAL_STATUS_READ_FAILED = 0x17,
VAL_STATUS_WRITE_FAILED = 0x18,
VAL_STATUS_ISOLATION_LEVEL_NOT_SUPP = 0x19,
VAL_STATUS_INIT_FAILED = 0x1A,
VAL_STATUS_SPM_FAILED = 0x1B,
VAL_STATUS_SPM_UNEXPECTED_BEH = 0x1C,
VAL_STATUS_FRAMEWORK_VERSION_FAILED = 0x1D,
VAL_STATUS_VERSION_API_FAILED = 0x1E,
VAL_STATUS_INVALID_HANDLE = 0x1F,
VAL_STATUS_INVALID_MSG_TYPE = 0x20,
VAL_STATUS_WRONG_IDENTITY = 0x21,
VAL_STATUS_MSG_INSIZE_FAILED = 0x22,
VAL_STATUS_MSG_OUTSIZE_FAILED = 0x23,
VAL_STATUS_SKIP_FAILED = 0x24,
VAL_STATUS_CRYPTO_FAILURE = 0x25,
VAL_STATUS_INVALID_SIZE = 0x26,
VAL_STATUS_DATA_MISMATCH = 0x27,
VAL_STATUS_BOOT_EXPECTED_BUT_FAILED = 0x28,
VAL_STATUS_INIT_ALREADY_DONE = 0x29,
VAL_STATUS_HEAP_NOT_AVAILABLE = 0x2A,
VAL_STATUS_UNSUPPORTED = 0x2B,
VAL_STATUS_ERROR_MAX = INT_MAX,
VAL_STATUS_SUCCESS = 0x0,
VAL_STATUS_INVALID = 0x10,
VAL_STATUS_ERROR = 0x11,
VAL_STATUS_NOT_FOUND = 0x12,
VAL_STATUS_LOAD_ERROR = 0x13,
VAL_STATUS_INSUFFICIENT_SIZE = 0x14,
VAL_STATUS_CONNECTION_FAILED = 0x15,
VAL_STATUS_CALL_FAILED = 0x16,
VAL_STATUS_READ_FAILED = 0x17,
VAL_STATUS_WRITE_FAILED = 0x18,
VAL_STATUS_ISOLATION_LEVEL_NOT_SUPP = 0x19,
VAL_STATUS_INIT_FAILED = 0x1A,
VAL_STATUS_SPM_FAILED = 0x1B,
VAL_STATUS_SPM_UNEXPECTED_BEH = 0x1C,
VAL_STATUS_FRAMEWORK_VERSION_FAILED = 0x1D,
VAL_STATUS_VERSION_API_FAILED = 0x1E,
VAL_STATUS_INVALID_HANDLE = 0x1F,
VAL_STATUS_INVALID_MSG_TYPE = 0x20,
VAL_STATUS_WRONG_IDENTITY = 0x21,
VAL_STATUS_MSG_INSIZE_FAILED = 0x22,
VAL_STATUS_MSG_OUTSIZE_FAILED = 0x23,
VAL_STATUS_SKIP_FAILED = 0x24,
VAL_STATUS_CRYPTO_FAILURE = 0x25,
VAL_STATUS_INVALID_SIZE = 0x26,
VAL_STATUS_DATA_MISMATCH = 0x27,
VAL_STATUS_BOOT_EXPECTED_BUT_FAILED = 0x28,
VAL_STATUS_INIT_ALREADY_DONE = 0x29,
VAL_STATUS_HEAP_NOT_AVAILABLE = 0x2A,
VAL_STATUS_UNSUPPORTED = 0x2B,
VAL_STATUS_ERROR_MAX = INT_MAX,
} val_status_t;
/* verbosity enums */
@ -253,10 +253,10 @@ typedef struct {
} boot_t;
typedef struct {
uint32_t pass_cnt:8;
uint32_t skip_cnt:8;
uint32_t fail_cnt:8;
uint32_t sim_error_cnt:8;
uint32_t pass_cnt: 8;
uint32_t skip_cnt: 8;
uint32_t fail_cnt: 8;
uint32_t sim_error_cnt: 8;
} test_count_t;
typedef struct {

75
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/val_greentea.cpp
View File

@ -5,7 +5,9 @@
void pal_mbed_os_compliance_test_initialize(void);
void pal_mbed_os_compliance_test_destroy(void);
#ifdef __cplusplus
extern "C" {
#endif
@ -31,12 +33,9 @@ void mbed_val_test_exit(void)
uint32_t status = mbed_val_get_status();
pal_mbed_os_compliance_test_destroy();
/* return if test skipped or failed */
if (IS_TEST_FAIL(status) || IS_TEST_SKIP(status))
{
if (IS_TEST_FAIL(status) || IS_TEST_SKIP(status)) {
GREENTEA_TESTSUITE_RESULT(false);
}
else
{
} else {
GREENTEA_TESTSUITE_RESULT(true);
mbed_val_set_status(RESULT_END(VAL_STATUS_SUCCESS));
}
@ -51,7 +50,7 @@ void mbed_val_test_exit(void)
@return - val_status_t
**/
val_status_t mbed_val_execute_non_secure_tests(uint32_t test_num, client_test_t *tests_list,
bool_t server_hs)
bool_t server_hs)
{
val_status_t status = VAL_STATUS_SUCCESS;
int32_t test_status = VAL_STATUS_SUCCESS;
@ -64,25 +63,20 @@ val_status_t mbed_val_execute_non_secure_tests(uint32_t test_num, client_test_t
test_info.test_num = test_num;
mbed_val_print(PRINT_TEST, "[Info] Executing tests from non-secure\n", 0);
while (tests_list[i] != NULL)
{
while (tests_list[i] != NULL) {
memset(testcase_name, 0, 100);
sprintf(testcase_name, "Check%" PRIu32, i);
GREENTEA_TESTCASE_START(testcase_name);
if (server_hs == TRUE)
{
if (server_hs == TRUE) {
/* Handshake with server tests */
test_info.block_num = i;
status = mbed_val_execute_secure_test_func(&handle, test_info,
SERVER_TEST_DISPATCHER_SID);
if (VAL_ERROR(status))
{
SERVER_TEST_DISPATCHER_SID);
if (VAL_ERROR(status)) {
mbed_val_set_status(RESULT_FAIL(status));
mbed_val_print(PRINT_ERROR, "[Check%d] START\n", i);
return status;
}
else
{
} else {
mbed_val_print(PRINT_DEBUG, "[Check%d] START\n", i);
}
}
@ -90,42 +84,36 @@ val_status_t mbed_val_execute_non_secure_tests(uint32_t test_num, client_test_t
/* Execute client tests */
test_status = tests_list[i](CALLER_NONSECURE);
if (server_hs == TRUE)
{
if (server_hs == TRUE) {
/* Retrive Server test status */
status = mbed_val_get_secure_test_result(&handle);
}
if (test_status != VAL_STATUS_SUCCESS)
{
if (test_status != VAL_STATUS_SUCCESS) {
status = VAL_STATUS_ERROR;
}
if (IS_TEST_SKIP(status))
{
if (IS_TEST_SKIP(status)) {
mbed_val_set_status(status);
mbed_val_print(PRINT_DEBUG, "[Check%d] SKIPPED\n", i);
GREENTEA_TESTCASE_FINISH(testcase_name, 1, 0);
continue_test = false;
}
else if (VAL_ERROR(status))
{
} else if (VAL_ERROR(status)) {
mbed_val_set_status(RESULT_FAIL(status));
if (server_hs == TRUE)
if (server_hs == TRUE) {
mbed_val_print(PRINT_ERROR, "[Check%d] FAILED\n", i);
}
GREENTEA_TESTCASE_FINISH(testcase_name, 0, 1);
continue_test = false;
}
else
{
if (server_hs == TRUE)
} else {
if (server_hs == TRUE) {
mbed_val_print(PRINT_DEBUG, "[Check%d] PASSED\n", i);
}
GREENTEA_TESTCASE_FINISH(testcase_name, 1, 0);
continue_test = true;
}
if (!continue_test)
{
if (!continue_test) {
return status;
}
@ -172,8 +160,7 @@ val_status_t mbed_val_execute_secure_test_func(psa_handle_t *handle, test_info_t
psa_status_t status_of_call = PSA_SUCCESS;
*handle = pal_ipc_connect(sid, 0);
if (*handle < 0)
{
if (*handle < 0) {
mbed_val_print(PRINT_ERROR, "Could not connect SID. Handle=%x\n", *handle);
return VAL_STATUS_CONNECTION_FAILED;
}
@ -182,8 +169,7 @@ val_status_t mbed_val_execute_secure_test_func(psa_handle_t *handle, test_info_t
psa_invec data[1] = {{&test_data, sizeof(test_data)}};
status_of_call = pal_ipc_call(*handle, data, 1, NULL, 0);
if (status_of_call != PSA_SUCCESS)
{
if (status_of_call != PSA_SUCCESS) {
status = VAL_STATUS_CALL_FAILED;
mbed_val_print(PRINT_ERROR, "Call to dispatch SF failed. Status=%x\n", status_of_call);
pal_ipc_close(*handle);
@ -229,8 +215,7 @@ val_status_t mbed_val_get_secure_test_result(psa_handle_t *handle)
psa_invec data[1] = {{&test_data, sizeof(test_data)}};
status_of_call = pal_ipc_call(*handle, data, 1, &resp, 1);
if (status_of_call != PSA_SUCCESS)
{
if (status_of_call != PSA_SUCCESS) {
status = VAL_STATUS_CALL_FAILED;
mbed_val_print(PRINT_ERROR, "Call to dispatch SF failed. Status=%x\n", status_of_call);
}
@ -246,12 +231,11 @@ val_status_t mbed_val_get_secure_test_result(psa_handle_t *handle)
@param -handle - return connection handle
* @return val_status_t
*/
val_status_t mbed_val_ipc_connect(uint32_t sid, uint32_t minor_version, psa_handle_t *handle )
val_status_t mbed_val_ipc_connect(uint32_t sid, uint32_t minor_version, psa_handle_t *handle)
{
*handle = pal_ipc_connect(sid, minor_version);
if (*handle < 0)
{
if (*handle < 0) {
return VAL_STATUS_CONNECTION_FAILED;
}
@ -270,14 +254,13 @@ val_status_t mbed_val_ipc_connect(uint32_t sid, uint32_t minor_version, psa_hand
* @return val_status_t
*/
val_status_t mbed_val_ipc_call(psa_handle_t handle, psa_invec *in_vec, size_t in_len,
psa_outvec *out_vec, size_t out_len)
psa_outvec *out_vec, size_t out_len)
{
psa_status_t call_status = PSA_SUCCESS;
call_status = pal_ipc_call(handle, in_vec, in_len, out_vec, out_len);
if (call_status != PSA_SUCCESS)
{
if (call_status != PSA_SUCCESS) {
return VAL_STATUS_CALL_FAILED;
}
@ -309,7 +292,7 @@ val_status_t mbed_val_wd_reprogram_timer(wd_timeout_type_t timeout_type)
return VAL_STATUS_SUCCESS;
}
#ifdef __cplusplus
} // extern "C"
#endif

2
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/val_greentea.h
View File

@ -19,7 +19,7 @@ val_status_t mbed_val_print(print_verbosity_t verbosity, const char *string, uin
val_status_t mbed_val_get_secure_test_result(psa_handle_t *handle);
val_status_t mbed_val_ipc_connect(uint32_t sid, uint32_t minor_version, psa_handle_t *handle);
val_status_t mbed_val_ipc_call(psa_handle_t handle, psa_invec *in_vec, size_t in_len,
psa_outvec *out_vec, size_t out_len);
psa_outvec *out_vec, size_t out_len);
void mbed_val_ipc_close(psa_handle_t handle);
val_status_t mbed_val_wd_reprogram_timer(wd_timeout_type_t timeout_type);

86
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/val_interfaces.h
View File

@ -24,52 +24,52 @@
/* typedef's */
typedef struct {
val_status_t (*print) (print_verbosity_t verbosity,
const char *string, uint32_t data);
val_status_t (*set_status) (uint32_t status);
uint32_t (*get_status) (void);
void (*test_init) (uint32_t test_num, char8_t *desc,
uint32_t test_bitfield);
void (*test_exit) (void);
val_status_t (*err_check_set) (uint32_t checkpoint, val_status_t status);
val_status_t (*target_get_config) (cfg_id_t cfg_id, uint8_t **data, uint32_t *size);
val_status_t (*execute_non_secure_tests) (uint32_t test_num, client_test_t *tests_list,
bool_t server_hs);
val_status_t (*switch_to_secure_client) (uint32_t test_num);
val_status_t (*execute_secure_test_func) (psa_handle_t *handle, test_info_t test_info,
uint32_t sid);
val_status_t (*ipc_connect) (uint32_t sid, uint32_t minor_version,
psa_handle_t *handle );
val_status_t (*ipc_call) (psa_handle_t handle, psa_invec *in_vec,
size_t in_len, psa_outvec *out_vec,
size_t out_len);
void (*ipc_close) (psa_handle_t handle);
val_status_t (*get_secure_test_result) (psa_handle_t *handle);
val_status_t (*nvmem_read) (uint32_t offset, void *buffer, int size);
val_status_t (*nvmem_write) (uint32_t offset, void *buffer, int size);
val_status_t (*wd_timer_init) (wd_timeout_type_t timeout_type);
val_status_t (*wd_timer_enable) (void);
val_status_t (*wd_timer_disable) (void);
val_status_t (*wd_reprogram_timer) (wd_timeout_type_t timeout_type);
val_status_t (*set_boot_flag) (boot_state_t state);
val_status_t (*get_boot_flag) (boot_state_t *state);
int32_t (*crypto_function) (int type, ...);
uint32_t (*its_function) (int type, ...);
uint32_t (*ps_function) (int type, ...);
int32_t (*attestation_function) (int type, ...);
val_status_t (*print)(print_verbosity_t verbosity,
const char *string, uint32_t data);
val_status_t (*set_status)(uint32_t status);
uint32_t (*get_status)(void);
void (*test_init)(uint32_t test_num, char8_t *desc,
uint32_t test_bitfield);
void (*test_exit)(void);
val_status_t (*err_check_set)(uint32_t checkpoint, val_status_t status);
val_status_t (*target_get_config)(cfg_id_t cfg_id, uint8_t **data, uint32_t *size);
val_status_t (*execute_non_secure_tests)(uint32_t test_num, client_test_t *tests_list,
bool_t server_hs);
val_status_t (*switch_to_secure_client)(uint32_t test_num);
val_status_t (*execute_secure_test_func)(psa_handle_t *handle, test_info_t test_info,
uint32_t sid);
val_status_t (*ipc_connect)(uint32_t sid, uint32_t minor_version,
psa_handle_t *handle);
val_status_t (*ipc_call)(psa_handle_t handle, psa_invec *in_vec,
size_t in_len, psa_outvec *out_vec,
size_t out_len);
void (*ipc_close)(psa_handle_t handle);
val_status_t (*get_secure_test_result)(psa_handle_t *handle);
val_status_t (*nvmem_read)(uint32_t offset, void *buffer, int size);
val_status_t (*nvmem_write)(uint32_t offset, void *buffer, int size);
val_status_t (*wd_timer_init)(wd_timeout_type_t timeout_type);
val_status_t (*wd_timer_enable)(void);
val_status_t (*wd_timer_disable)(void);
val_status_t (*wd_reprogram_timer)(wd_timeout_type_t timeout_type);
val_status_t (*set_boot_flag)(boot_state_t state);
val_status_t (*get_boot_flag)(boot_state_t *state);
int32_t (*crypto_function)(int type, ...);
uint32_t (*its_function)(int type, ...);
uint32_t (*ps_function)(int type, ...);
int32_t (*attestation_function)(int type, ...);
} val_api_t;
typedef struct {
uint32_t (*framework_version) (void);
uint32_t (*version) (uint32_t sid);
psa_handle_t (*connect) (uint32_t sid, uint32_t minor_version);
psa_status_t (*call) (psa_handle_t handle,
const psa_invec *in_vec,
size_t in_len,
psa_outvec *out_vec,
size_t out_len
);
void (*close) (psa_handle_t handle);
uint32_t (*framework_version)(void);
uint32_t (*version)(uint32_t sid);
psa_handle_t (*connect)(uint32_t sid, uint32_t minor_version);
psa_status_t (*call)(psa_handle_t handle,
const psa_invec *in_vec,
size_t in_len,
psa_outvec *out_vec,
size_t out_len
);
void (*close)(psa_handle_t handle);
} psa_api_t;
typedef void (*test_fptr_t)(val_api_t *val, psa_api_t *psa);

84
features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/val_target.h
View File

@ -46,46 +46,46 @@
MAJOR IDs
*/
typedef enum _GROUP_CONFIG_ID_ {
GROUP_SOC_PERIPHERAL = 0x1,
GROUP_MEMORY = 0x2,
GROUP_MISCELLANEOUS = 0x3,
GROUP_MAX = 0xFF,
GROUP_SOC_PERIPHERAL = 0x1,
GROUP_MEMORY = 0x2,
GROUP_MISCELLANEOUS = 0x3,
GROUP_MAX = 0xFF,
} group_cfg_id_t;
/*
MINOR IDs
*/
typedef enum _SOC_PERIPHERAL_CONFIG_ID_ {
SOC_PERIPHERAL_UART = 0x1,
SOC_PERIPHERAL_TIMER = 0x2,
SOC_PERIPHERAL_WATCHDOG = 0x3,
SOC_PERIPHERAL_UART = 0x1,
SOC_PERIPHERAL_TIMER = 0x2,
SOC_PERIPHERAL_WATCHDOG = 0x3,
} soc_peripheral_cfg_id_t;
typedef enum _MEMORY_CONFIG_ID_ {
MEMORY_NVMEM = 0x2,
MEMORY_NSPE_MMIO = 0x3,
MEMORY_CLIENT_PARTITION_MMIO = 0x4,
MEMORY_DRIVER_PARTITION_MMIO = 0x5,
MEMORY_NVMEM = 0x2,
MEMORY_NSPE_MMIO = 0x3,
MEMORY_CLIENT_PARTITION_MMIO = 0x4,
MEMORY_DRIVER_PARTITION_MMIO = 0x5,
} memory_cfg_id_t;
typedef enum _MISCELLANEOUS_CONFIG_ID_ {
MISCELLANEOUS_BOOT = 0x1,
MISCELLANEOUS_DUT = 0x2
MISCELLANEOUS_BOOT = 0x1,
MISCELLANEOUS_DUT = 0x2
} miscellaneous_cfg_id_t;
/**
Assign group type to each system component
**/
typedef enum _COMPONENT_GROUPING_{
UART = GROUP_SOC_PERIPHERAL,
TIMER = GROUP_SOC_PERIPHERAL,
WATCHDOG = GROUP_SOC_PERIPHERAL,
NVMEM = GROUP_MEMORY,
NSPE_MMIO = GROUP_MEMORY,
CLIENT_PARTITION_MMIO = GROUP_MEMORY,
DRIVER_PARTITION_MMIO = GROUP_MEMORY,
BOOT = GROUP_MISCELLANEOUS,
DUT = GROUP_MISCELLANEOUS,
typedef enum _COMPONENT_GROUPING_ {
UART = GROUP_SOC_PERIPHERAL,
TIMER = GROUP_SOC_PERIPHERAL,
WATCHDOG = GROUP_SOC_PERIPHERAL,
NVMEM = GROUP_MEMORY,
NSPE_MMIO = GROUP_MEMORY,
CLIENT_PARTITION_MMIO = GROUP_MEMORY,
DRIVER_PARTITION_MMIO = GROUP_MEMORY,
BOOT = GROUP_MISCELLANEOUS,
DUT = GROUP_MISCELLANEOUS,
} comp_group_assign_t;
/**
@ -100,7 +100,7 @@ typedef struct _TARGET_CFG_HDR_ {
uint32_t version;
/* Header Size */
uint32_t size;
}target_cfg_hdr_t;
} target_cfg_hdr_t;
typedef enum {
LEVEL1 = 0x1,
@ -149,11 +149,11 @@ typedef struct _MEM_INFO_DESC_ {
} memory_hdr_t;
typedef struct _MEM_REGION_ {
cfg_type_t cfg_type;
addr_t start;
addr_t end;
mem_tgt_attr_t attribute;
perm_type_t permission;
cfg_type_t cfg_type;
addr_t start;
addr_t end;
mem_tgt_attr_t attribute;
perm_type_t permission;
} memory_desc_t;
/*
@ -165,19 +165,19 @@ typedef struct _SOC_PER_INFO_NUM_ {
} soc_peripheral_hdr_t;
typedef struct _SOC_PER_INFO_DESC_ {
cfg_type_t cfg_type;
uint32_t vendor_id;
uint32_t device_id;
addr_t base;
uint32_t size;
uint32_t intr_id;
perm_type_t permission;
uint32_t timeout_in_micro_sec_low;
uint32_t timeout_in_micro_sec_medium;
uint32_t timeout_in_micro_sec_high;
uint32_t timeout_in_micro_sec_crypto;
uint32_t num_of_tick_per_micro_sec;
dev_attr_t attribute;
cfg_type_t cfg_type;
uint32_t vendor_id;
uint32_t device_id;
addr_t base;
uint32_t size;
uint32_t intr_id;
perm_type_t permission;
uint32_t timeout_in_micro_sec_low;
uint32_t timeout_in_micro_sec_medium;
uint32_t timeout_in_micro_sec_high;
uint32_t timeout_in_micro_sec_crypto;
uint32_t num_of_tick_per_micro_sec;
dev_attr_t attribute;
} soc_peripheral_desc_t;
/**