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; size_t actual_size;
psa_status_t rc = psa_its_get(PSA_CRYPTO_ITS_RANDOM_SEED_UID, 0, buf_len, buf, &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) 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); 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; uint8_t *challenge, *token;
uint32_t challenge_size, *token_size, verify_token_size; uint32_t challenge_size, *token_size, verify_token_size;
switch (type) switch (type) {
{
case PAL_INITIAL_ATTEST_GET_TOKEN: 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); challenge_size = va_arg(valist, uint32_t);
token = va_arg(valist, uint8_t*); token = va_arg(valist, uint8_t *);
token_size = va_arg(valist, uint32_t*); token_size = va_arg(valist, uint32_t *);
return psa_initial_attest_get_token(challenge, challenge_size, token, token_size); return psa_initial_attest_get_token(challenge, challenge_size, token, token_size);
case PAL_INITIAL_ATTEST_GET_TOKEN_SIZE: case PAL_INITIAL_ATTEST_GET_TOKEN_SIZE:
challenge_size = va_arg(valist, uint32_t); 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); return psa_initial_attest_get_token_size(challenge_size, token_size);
case PAL_INITIAL_ATTEST_VERIFY_TOKEN: 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); 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); verify_token_size = va_arg(valist, uint32_t);
return pal_initial_attest_verify_token(challenge, challenge_size, return pal_initial_attest_verify_token(challenge, challenge_size,
token, verify_token_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, psa_status_t pal_ipc_call(psa_handle_t handle,
const psa_invec *in_vec, const psa_invec *in_vec,
size_t in_len, size_t in_len,
psa_outvec *out_vec, psa_outvec *out_vec,
size_t out_len) size_t out_len)
{ {
return (PSA_SUCCESS - 1); 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, psa_status_t pal_ipc_call(psa_handle_t handle,
const psa_invec *in_vec, const psa_invec *in_vec,
size_t in_len, size_t in_len,
psa_outvec *out_vec, psa_outvec *out_vec,
size_t out_len) size_t out_len)
{ {
return (psa_call(handle, in_vec, in_len, out_vec, 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); uint32_t pal_ipc_version(uint32_t sid);
psa_handle_t pal_ipc_connect(uint32_t sid, uint32_t minor_version); psa_handle_t pal_ipc_connect(uint32_t sid, uint32_t minor_version);
psa_status_t pal_ipc_call(psa_handle_t handle, psa_status_t pal_ipc_call(psa_handle_t handle,
const psa_invec *in_vec, const psa_invec *in_vec,
size_t in_len, size_t in_len,
psa_outvec *out_vec, psa_outvec *out_vec,
size_t out_len); size_t out_len);
void pal_ipc_close(psa_handle_t handle); void pal_ipc_close(psa_handle_t handle);
#endif /* _PAL_CLIENT_API_H_ */ #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 #define PAL_STATUS_UNSUPPORTED_FUNC 0xFF
typedef enum typedef enum {
{
PAL_STATUS_SUCCESS = 0x0, PAL_STATUS_SUCCESS = 0x0,
PAL_STATUS_ERROR = 0x80 PAL_STATUS_ERROR = 0x80
} pal_status_t; } 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; size_t actual_size;
switch (type) switch (type) {
{ case PAL_ITS_SET:
case PAL_ITS_SET: uid = va_arg(valist, psa_storage_uid_t);
uid = va_arg(valist, psa_storage_uid_t); data_length = va_arg(valist, uint32_t);
data_length = va_arg(valist, uint32_t); p_write_data = va_arg(valist, const void *);
p_write_data = va_arg(valist, const void*); its_create_flags = va_arg(valist, psa_storage_create_flags_t);
its_create_flags = va_arg(valist, psa_storage_create_flags_t); return psa_its_set(uid, data_length, p_write_data, its_create_flags);
return psa_its_set(uid, data_length, p_write_data, its_create_flags); case PAL_ITS_GET:
case PAL_ITS_GET: uid = va_arg(valist, psa_storage_uid_t);
uid = va_arg(valist, psa_storage_uid_t); offset = va_arg(valist, uint32_t);
offset = va_arg(valist, uint32_t); data_length = va_arg(valist, uint32_t);
data_length = va_arg(valist, uint32_t); p_read_data = va_arg(valist, void *);
p_read_data = va_arg(valist, void*); /* TODO: Actual size argument is currently not supported by the testing framework.
/* TODO: Actual size argument is currently not supported by the testing framework. * Changes need to be implemented in the actual tests.
* Changes need to be implemented in the actual tests. * Should be fixed by the next import of the tests.
* Should be fixed by the next import of the tests. */
*/ return psa_its_get(uid, offset, data_length, p_read_data, &actual_size);
return psa_its_get(uid, offset, data_length, p_read_data, &actual_size); case PAL_ITS_GET_INFO:
case PAL_ITS_GET_INFO: uid = va_arg(valist, psa_storage_uid_t);
uid = va_arg(valist, psa_storage_uid_t); its_p_info = va_arg(valist, struct psa_its_info_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);
return psa_its_get_info(uid, (struct psa_storage_info_t *)its_p_info); case PAL_ITS_REMOVE:
case PAL_ITS_REMOVE: uid = va_arg(valist, psa_storage_uid_t);
uid = va_arg(valist, psa_storage_uid_t); return psa_its_remove(uid);
return psa_its_remove(uid); /* case PAL_PS_SET: */
/* case PAL_PS_SET: */ /* uid = va_arg(valist, uint32_t); */
/* uid = va_arg(valist, uint32_t); */ /* data_length = va_arg(valist, uint32_t); */
/* data_length = va_arg(valist, uint32_t); */ /* p_write_data = va_arg(valist, const void*); */
/* p_write_data = va_arg(valist, const void*); */ /* ps_create_flags = va_arg(valist, psa_ps_create_flags_t); */
/* ps_create_flags = va_arg(valist, psa_ps_create_flags_t); */ /* return psa_ps_set(uid, data_length, p_write_data, ps_create_flags); */
/* return psa_ps_set(uid, data_length, p_write_data, ps_create_flags); */ /* case PAL_PS_GET: */
/* case PAL_PS_GET: */ /* uid = va_arg(valist, uint32_t); */
/* uid = va_arg(valist, uint32_t); */ /* offset = va_arg(valist, uint32_t); */
/* offset = va_arg(valist, uint32_t); */ /* data_length = va_arg(valist, uint32_t); */
/* data_length = va_arg(valist, uint32_t); */ /* p_read_data = va_arg(valist, void*); */
/* p_read_data = va_arg(valist, void*); */ /* return psa_ps_get(uid, offset, data_length, p_read_data); */
/* return psa_ps_get(uid, offset, data_length, p_read_data); */ /* case PAL_PS_GET_INFO: */
/* case PAL_PS_GET_INFO: */ /* uid = va_arg(valist, uint32_t); */
/* uid = va_arg(valist, uint32_t); */ /* ps_p_info = va_arg(valist, struct psa_eps_info_t*); */
/* ps_p_info = va_arg(valist, struct psa_eps_info_t*); */ /* return psa_ps_get_info(uid, ps_p_info); */
/* return psa_ps_get_info(uid, ps_p_info); */ /* case PAL_PS_REMOVE: */
/* case PAL_PS_REMOVE: */ /* uid = va_arg(valist, uint32_t); */
/* uid = va_arg(valist, uint32_t); */ /* return psa_ps_remove(uid); */
/* return psa_ps_remove(uid); */ default:
default: return PAL_STATUS_UNSUPPORTED_FUNC;
return PAL_STATUS_UNSUPPORTED_FUNC;
} }
#else #else
return PAL_STATUS_ERROR; 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; compliance_test_type type_g = COMPLIANCE_TEST_UNDEFINED;
// randomly generated attestation key used for testing the attestation feature. // 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. // the test just needs a key to be injected before it is run.
static const uint8_t private_key_data[] = { static const uint8_t private_key_data[] = {
0x49, 0xc9, 0xa8, 0xc1, 0x8c, 0x4b, 0x88, 0x56, 0x49, 0xc9, 0xa8, 0xc1, 0x8c, 0x4b, 0x88, 0x56,
0x38, 0xc4, 0x31, 0xcf, 0x1d, 0xf1, 0xc9, 0x94, 0x38, 0xc4, 0x31, 0xcf, 0x1d, 0xf1, 0xc9, 0x94,
0x13, 0x16, 0x09, 0xb5, 0x80, 0xd4, 0xfd, 0x43, 0x13, 0x16, 0x09, 0xb5, 0x80, 0xd4, 0xfd, 0x43,
0xa0, 0xca, 0xb1, 0x7d, 0xb2, 0xf1, 0x3e, 0xee 0xa0, 0xca, 0xb1, 0x7d, 0xb2, 0xf1, 0x3e, 0xee
}; };
static const uint8_t public_key_data[] = { static const uint8_t public_key_data[] = {
0x04, 0x77, 0x72, 0x65, 0x6f, 0x81, 0x4b, 0x39, 0x04, 0x77, 0x72, 0x65, 0x6f, 0x81, 0x4b, 0x39,
0x92, 0x79, 0xd5, 0xe1, 0xf1, 0x78, 0x1f, 0xac, 0x92, 0x79, 0xd5, 0xe1, 0xf1, 0x78, 0x1f, 0xac,
0x6f, 0x09, 0x9a, 0x3c, 0x5c, 0xa1, 0xb0, 0xe3, 0x6f, 0x09, 0x9a, 0x3c, 0x5c, 0xa1, 0xb0, 0xe3,
0x53, 0x51, 0x83, 0x4b, 0x08, 0xb6, 0x5e, 0x0b, 0x53, 0x51, 0x83, 0x4b, 0x08, 0xb6, 0x5e, 0x0b,
0x57, 0x25, 0x90, 0xcd, 0xaf, 0x8f, 0x76, 0x93, 0x57, 0x25, 0x90, 0xcd, 0xaf, 0x8f, 0x76, 0x93,
0x61, 0xbc, 0xf3, 0x4a, 0xcf, 0xc1, 0x1e, 0x5e, 0x61, 0xbc, 0xf3, 0x4a, 0xcf, 0xc1, 0x1e, 0x5e,
0x07, 0x4e, 0x84, 0x26, 0xbd, 0xde, 0x04, 0xbe, 0x07, 0x4e, 0x84, 0x26, 0xbd, 0xde, 0x04, 0xbe,
0x6e, 0x65, 0x39, 0x45, 0x44, 0x96, 0x17, 0xde, 0x6e, 0x65, 0x39, 0x45, 0x44, 0x96, 0x17, 0xde,
0x45 0x45
}; };
static void psa_attestation_destroy_key_for_test() static void psa_attestation_destroy_key_for_test()
@ -108,16 +108,11 @@ void main_wrapper(void)
void pal_mbed_os_compliance_test_initialize(void) void pal_mbed_os_compliance_test_initialize(void)
{ {
if (COMPLIANCE_TEST_CRYPTO == type_g) if (COMPLIANCE_TEST_CRYPTO == type_g) {
{
inject_entropy(); inject_entropy();
} } else if (COMPLIANCE_TEST_STORAGE == type_g) {
else if (COMPLIANCE_TEST_STORAGE == type_g)
{
reset_storage_for_compliance_test(); reset_storage_for_compliance_test();
} } else if (COMPLIANCE_TEST_ATTESTATION == type_g) {
else if (COMPLIANCE_TEST_ATTESTATION == type_g)
{
reset_storage_for_compliance_test(); reset_storage_for_compliance_test();
inject_entropy(); inject_entropy();
psa_crypto_init(); psa_crypto_init();

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

@ -7,14 +7,14 @@
extern "C" { extern "C" {
#endif #endif
typedef enum _compliance_test_type{ typedef enum _compliance_test_type {
COMPLIANCE_TEST_UNDEFINED, COMPLIANCE_TEST_UNDEFINED,
COMPLIANCE_TEST_START = COMPLIANCE_TEST_UNDEFINED, COMPLIANCE_TEST_START = COMPLIANCE_TEST_UNDEFINED,
COMPLIANCE_TEST_CRYPTO, COMPLIANCE_TEST_CRYPTO,
COMPLIANCE_TEST_ATTESTATION, COMPLIANCE_TEST_ATTESTATION,
COMPLIANCE_TEST_STORAGE, COMPLIANCE_TEST_STORAGE,
COMPLIANCE_TEST_END COMPLIANCE_TEST_END
}compliance_test_type; } compliance_test_type;
typedef void (*test_entry_f)(val_api_t *val_api, psa_api_t *psa_api); 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); 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; psa_storage_create_flags_t ps_create_flags;
struct psa_ps_info_t *ps_p_info; struct psa_ps_info_t *ps_p_info;
switch (type) switch (type) {
{ case PAL_PS_SET:
case PAL_PS_SET: uid = va_arg(valist, psa_storage_uid_t);
uid = va_arg(valist, psa_storage_uid_t); data_length = va_arg(valist, uint32_t);
data_length = va_arg(valist, uint32_t); p_write_data = va_arg(valist, const void *);
p_write_data = va_arg(valist, const void*); ps_create_flags = va_arg(valist, psa_storage_create_flags_t);
ps_create_flags = va_arg(valist, psa_storage_create_flags_t); return psa_ps_set(uid, data_length, p_write_data, ps_create_flags);
return psa_ps_set(uid, data_length, p_write_data, ps_create_flags); case PAL_PS_GET:
case PAL_PS_GET: uid = va_arg(valist, psa_storage_uid_t);
uid = va_arg(valist, psa_storage_uid_t); offset = va_arg(valist, uint32_t);
offset = va_arg(valist, uint32_t); data_length = va_arg(valist, uint32_t);
data_length = va_arg(valist, uint32_t); p_read_data = va_arg(valist, void *);
p_read_data = va_arg(valist, void*); return psa_ps_get(uid, offset, data_length, p_read_data, &actual_length);
return psa_ps_get(uid, offset, data_length, p_read_data, &actual_length); case PAL_PS_GET_INFO:
case PAL_PS_GET_INFO: uid = va_arg(valist, psa_storage_uid_t);
uid = va_arg(valist, psa_storage_uid_t); ps_p_info = va_arg(valist, struct psa_ps_info_t *);
ps_p_info = va_arg(valist, struct psa_ps_info_t*); return psa_ps_get_info(uid, ps_p_info);
return psa_ps_get_info(uid, ps_p_info); case PAL_PS_REMOVE:
case PAL_PS_REMOVE: uid = va_arg(valist, psa_storage_uid_t);
uid = va_arg(valist, psa_storage_uid_t); return psa_ps_remove(uid);
return psa_ps_remove(uid); default:
default: return PAL_STATUS_UNSUPPORTED_FUNC;
return PAL_STATUS_UNSUPPORTED_FUNC;
} }
#else #else
return PAL_STATUS_ERROR; 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; struct items_to_get_t *item_ptr = item_list;
/* initialize the data type of all items in the 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->item.uDataType = QCBOR_TYPE_NONE;
item_ptr++; item_ptr++;
} }
QCBORDecode_GetNext(decode_context, &item); QCBORDecode_GetNext(decode_context, &item);
if (item.uDataType != QCBOR_TYPE_MAP) if (item.uDataType != QCBOR_TYPE_MAP) {
{
return PAL_ATTEST_ERROR; return PAL_ATTEST_ERROR;
} }
for (item_index = item.val.uCount; item_index != 0; item_index--) for (item_index = item.val.uCount; item_index != 0; item_index--) {
{ if (QCBORDecode_GetNext(decode_context, &item) != QCBOR_SUCCESS) {
if (QCBORDecode_GetNext(decode_context, &item) != QCBOR_SUCCESS)
{
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
} }
if (item.uLabelType != QCBOR_TYPE_INT64) if (item.uLabelType != QCBOR_TYPE_INT64) {
{
continue; continue;
} }
item_ptr = item_list; item_ptr = item_list;
while (item_ptr->label != 0) while (item_ptr->label != 0) {
{ if (item.label.int64 == item_ptr->label) {
if (item.label.int64 == item_ptr->label)
{
item_ptr->item = item; item_ptr->item = item;
} }
item_ptr++; item_ptr++;
@ -74,13 +67,11 @@ static int get_item_in_map(QCBORDecodeContext *decode_context,
item_list[0].label = label; item_list[0].label = label;
item_list[1].label = 0; 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; 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; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
} }
@ -100,18 +91,15 @@ static int parse_unprotected_headers(QCBORDecodeContext *decode_context,
item_list[2].label = 0; item_list[2].label = 0;
*loop_back = false; *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; 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; *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; 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); 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; return PAL_ATTEST_ERROR;
} }
if (QCBORDecode_Finish(&decode_context)) if (QCBORDecode_Finish(&decode_context)) {
{
return PAL_ATTEST_ERROR; 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; return PAL_ATTEST_ERROR;
} }
@ -156,118 +141,106 @@ static int parse_protected_headers(struct useful_buf_c protected_headers,
@return - error status @return - error status
**/ **/
static int parse_claims(QCBORDecodeContext *decode_context, QCBORItem item, 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 i, count = 0;
int status = PAL_ATTEST_SUCCESS; int status = PAL_ATTEST_SUCCESS;
/* Parse each claim and validate their data type */ /* Parse each claim and validate their data type */
while (status == PAL_ATTEST_SUCCESS) while (status == PAL_ATTEST_SUCCESS) {
{
status = QCBORDecode_GetNext(decode_context, &item); status = QCBORDecode_GetNext(decode_context, &item);
if (status != PAL_ATTEST_SUCCESS) if (status != PAL_ATTEST_SUCCESS) {
break; break;
}
mandatory_claims |= 1 << (EAT_CBOR_ARM_RANGE_BASE - item.label.int64); mandatory_claims |= 1 << (EAT_CBOR_ARM_RANGE_BASE - item.label.int64);
if (item.uLabelType == QCBOR_TYPE_INT64) if (item.uLabelType == QCBOR_TYPE_INT64) {
{ if (item.label.int64 == EAT_CBOR_ARM_LABEL_NONCE) {
if (item.label.int64 == EAT_CBOR_ARM_LABEL_NONCE) if (item.uDataType == QCBOR_TYPE_BYTE_STRING) {
{
if (item.uDataType == QCBOR_TYPE_BYTE_STRING)
{
/* Given challenge vs challenge in token */ /* 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; return PAL_ATTEST_TOKEN_CHALLENGE_MISMATCH;
} }
else } else {
return PAL_ATTEST_TOKEN_NOT_SUPPORTED; return PAL_ATTEST_TOKEN_NOT_SUPPORTED;
} }
else if (item.label.int64 == EAT_CBOR_ARM_LABEL_BOOT_SEED || } 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_IMPLEMENTATION_ID ||
item.label.int64 == EAT_CBOR_ARM_LABEL_UEID) item.label.int64 == EAT_CBOR_ARM_LABEL_UEID) {
{ if (item.uDataType != QCBOR_TYPE_BYTE_STRING) {
if (item.uDataType != QCBOR_TYPE_BYTE_STRING)
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
} }
else if (item.label.int64 == EAT_CBOR_ARM_LABEL_ORIGINATION || } 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_PROFILE_DEFINITION ||
item.label.int64 == EAT_CBOR_ARM_LABEL_HW_VERSION) item.label.int64 == EAT_CBOR_ARM_LABEL_HW_VERSION) {
{ if (item.uDataType != QCBOR_TYPE_TEXT_STRING) {
if (item.uDataType != QCBOR_TYPE_TEXT_STRING)
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
} }
else if (item.label.int64 == EAT_CBOR_ARM_LABEL_CLIENT_ID || } else if (item.label.int64 == EAT_CBOR_ARM_LABEL_CLIENT_ID ||
item.label.int64 == EAT_CBOR_ARM_LABEL_SECURITY_LIFECYCLE) item.label.int64 == EAT_CBOR_ARM_LABEL_SECURITY_LIFECYCLE) {
{ if (item.uDataType != QCBOR_TYPE_INT64) {
if (item.uDataType != QCBOR_TYPE_INT64)
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
} }
else if (item.label.int64 == EAT_CBOR_ARM_LABEL_SW_COMPONENTS) } else if (item.label.int64 == EAT_CBOR_ARM_LABEL_SW_COMPONENTS) {
{ if (item.uDataType != QCBOR_TYPE_ARRAY) {
if (item.uDataType != QCBOR_TYPE_ARRAY)
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
sw_component_present = 1; sw_component_present = 1;
status = QCBORDecode_GetNext(decode_context, &item); status = QCBORDecode_GetNext(decode_context, &item);
if (status != PAL_ATTEST_SUCCESS) if (status != PAL_ATTEST_SUCCESS) {
continue; continue;
}
count = item.val.uCount; count = item.val.uCount;
for (i = 0; i <= count; i++) for (i = 0; i <= count; i++) {
{
mandaroty_sw_components |= 1 << item.label.int64; mandaroty_sw_components |= 1 << item.label.int64;
if (item.label.int64 == EAT_CBOR_SW_COMPONENT_MEASUREMENT) if (item.label.int64 == EAT_CBOR_SW_COMPONENT_MEASUREMENT) {
{ if (item.uDataType != QCBOR_TYPE_BYTE_STRING) {
if (item.uDataType != QCBOR_TYPE_BYTE_STRING)
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
} }
else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_MEASUREMENT_DESC) } else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_MEASUREMENT_DESC) {
{ if (item.uDataType != QCBOR_TYPE_TEXT_STRING) {
if (item.uDataType != QCBOR_TYPE_TEXT_STRING)
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
} }
else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_VERSION) } else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_VERSION) {
{ if (item.uDataType != QCBOR_TYPE_TEXT_STRING) {
if (item.uDataType != QCBOR_TYPE_TEXT_STRING)
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
} }
else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_SIGNER_ID) } else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_SIGNER_ID) {
{ if (item.uDataType != QCBOR_TYPE_BYTE_STRING) {
if (item.uDataType != QCBOR_TYPE_BYTE_STRING)
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
} }
else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_EPOCH) } else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_EPOCH) {
{ if (item.uDataType != QCBOR_TYPE_INT64) {
if (item.uDataType != QCBOR_TYPE_INT64)
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
} }
else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_TYPE) } else if (item.label.int64 == EAT_CBOR_SW_COMPONENT_TYPE) {
{ if (item.uDataType != QCBOR_TYPE_TEXT_STRING) {
if (item.uDataType != QCBOR_TYPE_TEXT_STRING)
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
} }
if (i < count) if (i < count) {
{
status = QCBORDecode_GetNext(decode_context, &item); status = QCBORDecode_GetNext(decode_context, &item);
if (status != PAL_ATTEST_SUCCESS) if (status != PAL_ATTEST_SUCCESS) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
} }
} }
} }
} } else {
else
{
/* ToDo: Add other claim types */ /* ToDo: Add other claim types */
} }
} }
if (status == QCBOR_ERR_HIT_END) if (status == QCBOR_ERR_HIT_END) {
return PAL_ATTEST_SUCCESS; return PAL_ATTEST_SUCCESS;
else } else {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING; 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.ptr = challenge;
completed_challenge.len = challenge_size; completed_challenge.len = challenge_size;
/* /*
------------------------- -------------------------
| CBOR Array Type | | CBOR Array Type |
------------------------- -------------------------
| Protected Headers | | Protected Headers |
------------------------- -------------------------
| Unprotected Headers | | Unprotected Headers |
------------------------- -------------------------
| Payload | | Payload |
------------------------- -------------------------
| Signature | | Signature |
------------------------- -------------------------
*/ */
/* Initialize the decorder */ /* Initialize the decorder */
QCBORDecode_Init(&decode_context, completed_token, QCBOR_DECODE_MODE_NORMAL); 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. * Only COSE_SIGN1 is supported now.
*/ */
if (item.uDataType != QCBOR_TYPE_ARRAY || item.val.uCount != 4 || 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; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
/* Get the next headers */ /* Get the next headers */
QCBORDecode_GetNext(&decode_context, &item); 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; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
protected_headers = item.val.string; protected_headers = item.val.string;
/* Parse the protected headers and check the data type and value*/ /* Parse the protected headers and check the data type and value*/
status = parse_protected_headers(protected_headers, &cose_algorithm_id); status = parse_protected_headers(protected_headers, &cose_algorithm_id);
if (status != PAL_ATTEST_SUCCESS) if (status != PAL_ATTEST_SUCCESS) {
return status; return status;
}
/* Parse the unprotected headers and check the data type and value */ /* Parse the unprotected headers and check the data type and value */
short_circuit = false; short_circuit = false;
status = parse_unprotected_headers(&decode_context, &kid, &short_circuit); status = parse_unprotected_headers(&decode_context, &kid, &short_circuit);
if (status != PAL_ATTEST_SUCCESS) if (status != PAL_ATTEST_SUCCESS) {
return status; return status;
}
/* Get the payload */ /* Get the payload */
QCBORDecode_GetNext(&decode_context, &item); 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; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
payload = item.val.string; payload = item.val.string;
/* Get the digital signature */ /* Get the digital signature */
QCBORDecode_GetNext(&decode_context, &item); 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; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
/* Initialize the Decoder and validate the payload format */ /* Initialize the Decoder and validate the payload format */
QCBORDecode_Init(&decode_context, payload, QCBOR_DECODE_MODE_NORMAL); QCBORDecode_Init(&decode_context, payload, QCBOR_DECODE_MODE_NORMAL);
status = QCBORDecode_GetNext(&decode_context, &item); status = QCBORDecode_GetNext(&decode_context, &item);
if (status != PAL_ATTEST_SUCCESS) if (status != PAL_ATTEST_SUCCESS) {
return status; return status;
}
if (item.uDataType != QCBOR_TYPE_MAP) if (item.uDataType != QCBOR_TYPE_MAP) {
return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING; return PAL_ATTEST_TOKEN_ERR_CBOR_FORMATTING;
}
/* Parse the payload and check the data type of each claim */ /* Parse the payload and check the data type of each claim */
status = parse_claims(&decode_context, item, completed_challenge); status = parse_claims(&decode_context, item, completed_challenge);
if (status != PAL_ATTEST_SUCCESS) if (status != PAL_ATTEST_SUCCESS) {
return status; 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; 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, psa_status_t pal_ipc_call(psa_handle_t handle,
const psa_invec *in_vec, const psa_invec *in_vec,
size_t in_len, size_t in_len,
psa_outvec *out_vec, psa_outvec *out_vec,
size_t out_len); size_t out_len);
/** /**
* @brief - Close a connection to a Root of Trust Service. * @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 */ /* Test Defines */
#define TEST_PUBLISH(test_id, entry) #define TEST_PUBLISH(test_id, entry)
#define VAL_MAX_TEST_PER_COMP 200 #define VAL_MAX_TEST_PER_COMP 200
#define VAL_FF_BASE 0 #define VAL_FF_BASE 0
@ -197,36 +197,36 @@ typedef enum {
/* enums to report test sub-state */ /* enums to report test sub-state */
typedef enum { typedef enum {
VAL_STATUS_SUCCESS = 0x0, VAL_STATUS_SUCCESS = 0x0,
VAL_STATUS_INVALID = 0x10, VAL_STATUS_INVALID = 0x10,
VAL_STATUS_ERROR = 0x11, VAL_STATUS_ERROR = 0x11,
VAL_STATUS_NOT_FOUND = 0x12, VAL_STATUS_NOT_FOUND = 0x12,
VAL_STATUS_LOAD_ERROR = 0x13, VAL_STATUS_LOAD_ERROR = 0x13,
VAL_STATUS_INSUFFICIENT_SIZE = 0x14, VAL_STATUS_INSUFFICIENT_SIZE = 0x14,
VAL_STATUS_CONNECTION_FAILED = 0x15, VAL_STATUS_CONNECTION_FAILED = 0x15,
VAL_STATUS_CALL_FAILED = 0x16, VAL_STATUS_CALL_FAILED = 0x16,
VAL_STATUS_READ_FAILED = 0x17, VAL_STATUS_READ_FAILED = 0x17,
VAL_STATUS_WRITE_FAILED = 0x18, VAL_STATUS_WRITE_FAILED = 0x18,
VAL_STATUS_ISOLATION_LEVEL_NOT_SUPP = 0x19, VAL_STATUS_ISOLATION_LEVEL_NOT_SUPP = 0x19,
VAL_STATUS_INIT_FAILED = 0x1A, VAL_STATUS_INIT_FAILED = 0x1A,
VAL_STATUS_SPM_FAILED = 0x1B, VAL_STATUS_SPM_FAILED = 0x1B,
VAL_STATUS_SPM_UNEXPECTED_BEH = 0x1C, VAL_STATUS_SPM_UNEXPECTED_BEH = 0x1C,
VAL_STATUS_FRAMEWORK_VERSION_FAILED = 0x1D, VAL_STATUS_FRAMEWORK_VERSION_FAILED = 0x1D,
VAL_STATUS_VERSION_API_FAILED = 0x1E, VAL_STATUS_VERSION_API_FAILED = 0x1E,
VAL_STATUS_INVALID_HANDLE = 0x1F, VAL_STATUS_INVALID_HANDLE = 0x1F,
VAL_STATUS_INVALID_MSG_TYPE = 0x20, VAL_STATUS_INVALID_MSG_TYPE = 0x20,
VAL_STATUS_WRONG_IDENTITY = 0x21, VAL_STATUS_WRONG_IDENTITY = 0x21,
VAL_STATUS_MSG_INSIZE_FAILED = 0x22, VAL_STATUS_MSG_INSIZE_FAILED = 0x22,
VAL_STATUS_MSG_OUTSIZE_FAILED = 0x23, VAL_STATUS_MSG_OUTSIZE_FAILED = 0x23,
VAL_STATUS_SKIP_FAILED = 0x24, VAL_STATUS_SKIP_FAILED = 0x24,
VAL_STATUS_CRYPTO_FAILURE = 0x25, VAL_STATUS_CRYPTO_FAILURE = 0x25,
VAL_STATUS_INVALID_SIZE = 0x26, VAL_STATUS_INVALID_SIZE = 0x26,
VAL_STATUS_DATA_MISMATCH = 0x27, VAL_STATUS_DATA_MISMATCH = 0x27,
VAL_STATUS_BOOT_EXPECTED_BUT_FAILED = 0x28, VAL_STATUS_BOOT_EXPECTED_BUT_FAILED = 0x28,
VAL_STATUS_INIT_ALREADY_DONE = 0x29, VAL_STATUS_INIT_ALREADY_DONE = 0x29,
VAL_STATUS_HEAP_NOT_AVAILABLE = 0x2A, VAL_STATUS_HEAP_NOT_AVAILABLE = 0x2A,
VAL_STATUS_UNSUPPORTED = 0x2B, VAL_STATUS_UNSUPPORTED = 0x2B,
VAL_STATUS_ERROR_MAX = INT_MAX, VAL_STATUS_ERROR_MAX = INT_MAX,
} val_status_t; } val_status_t;
/* verbosity enums */ /* verbosity enums */
@ -253,10 +253,10 @@ typedef struct {
} boot_t; } boot_t;
typedef struct { typedef struct {
uint32_t pass_cnt:8; uint32_t pass_cnt: 8;
uint32_t skip_cnt:8; uint32_t skip_cnt: 8;
uint32_t fail_cnt:8; uint32_t fail_cnt: 8;
uint32_t sim_error_cnt:8; uint32_t sim_error_cnt: 8;
} test_count_t; } test_count_t;
typedef struct { 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_initialize(void);
void pal_mbed_os_compliance_test_destroy(void); void pal_mbed_os_compliance_test_destroy(void);
#ifdef __cplusplus
extern "C" { extern "C" {
#endif
@ -31,12 +33,9 @@ void mbed_val_test_exit(void)
uint32_t status = mbed_val_get_status(); uint32_t status = mbed_val_get_status();
pal_mbed_os_compliance_test_destroy(); pal_mbed_os_compliance_test_destroy();
/* return if test skipped or failed */ /* 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); GREENTEA_TESTSUITE_RESULT(false);
} } else {
else
{
GREENTEA_TESTSUITE_RESULT(true); GREENTEA_TESTSUITE_RESULT(true);
mbed_val_set_status(RESULT_END(VAL_STATUS_SUCCESS)); mbed_val_set_status(RESULT_END(VAL_STATUS_SUCCESS));
} }
@ -51,7 +50,7 @@ void mbed_val_test_exit(void)
@return - val_status_t @return - val_status_t
**/ **/
val_status_t mbed_val_execute_non_secure_tests(uint32_t test_num, client_test_t *tests_list, 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; val_status_t status = VAL_STATUS_SUCCESS;
int32_t test_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; test_info.test_num = test_num;
mbed_val_print(PRINT_TEST, "[Info] Executing tests from non-secure\n", 0); 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); memset(testcase_name, 0, 100);
sprintf(testcase_name, "Check%" PRIu32, i); sprintf(testcase_name, "Check%" PRIu32, i);
GREENTEA_TESTCASE_START(testcase_name); GREENTEA_TESTCASE_START(testcase_name);
if (server_hs == TRUE) if (server_hs == TRUE) {
{
/* Handshake with server tests */ /* Handshake with server tests */
test_info.block_num = i; test_info.block_num = i;
status = mbed_val_execute_secure_test_func(&handle, test_info, status = mbed_val_execute_secure_test_func(&handle, test_info,
SERVER_TEST_DISPATCHER_SID); SERVER_TEST_DISPATCHER_SID);
if (VAL_ERROR(status)) if (VAL_ERROR(status)) {
{
mbed_val_set_status(RESULT_FAIL(status)); mbed_val_set_status(RESULT_FAIL(status));
mbed_val_print(PRINT_ERROR, "[Check%d] START\n", i); mbed_val_print(PRINT_ERROR, "[Check%d] START\n", i);
return status; return status;
} } else {
else
{
mbed_val_print(PRINT_DEBUG, "[Check%d] START\n", i); 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 */ /* Execute client tests */
test_status = tests_list[i](CALLER_NONSECURE); test_status = tests_list[i](CALLER_NONSECURE);
if (server_hs == TRUE) if (server_hs == TRUE) {
{
/* Retrive Server test status */ /* Retrive Server test status */
status = mbed_val_get_secure_test_result(&handle); status = mbed_val_get_secure_test_result(&handle);
} }
if (test_status != VAL_STATUS_SUCCESS) if (test_status != VAL_STATUS_SUCCESS) {
{
status = VAL_STATUS_ERROR; status = VAL_STATUS_ERROR;
} }
if (IS_TEST_SKIP(status)) if (IS_TEST_SKIP(status)) {
{
mbed_val_set_status(status); mbed_val_set_status(status);
mbed_val_print(PRINT_DEBUG, "[Check%d] SKIPPED\n", i); mbed_val_print(PRINT_DEBUG, "[Check%d] SKIPPED\n", i);
GREENTEA_TESTCASE_FINISH(testcase_name, 1, 0); GREENTEA_TESTCASE_FINISH(testcase_name, 1, 0);
continue_test = false; continue_test = false;
} } else if (VAL_ERROR(status)) {
else if (VAL_ERROR(status))
{
mbed_val_set_status(RESULT_FAIL(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); mbed_val_print(PRINT_ERROR, "[Check%d] FAILED\n", i);
}
GREENTEA_TESTCASE_FINISH(testcase_name, 0, 1); GREENTEA_TESTCASE_FINISH(testcase_name, 0, 1);
continue_test = false; continue_test = false;
} } else {
else if (server_hs == TRUE) {
{
if (server_hs == TRUE)
mbed_val_print(PRINT_DEBUG, "[Check%d] PASSED\n", i); mbed_val_print(PRINT_DEBUG, "[Check%d] PASSED\n", i);
}
GREENTEA_TESTCASE_FINISH(testcase_name, 1, 0); GREENTEA_TESTCASE_FINISH(testcase_name, 1, 0);
continue_test = true; continue_test = true;
} }
if (!continue_test) if (!continue_test) {
{
return status; 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; psa_status_t status_of_call = PSA_SUCCESS;
*handle = pal_ipc_connect(sid, 0); *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); mbed_val_print(PRINT_ERROR, "Could not connect SID. Handle=%x\n", *handle);
return VAL_STATUS_CONNECTION_FAILED; 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)}}; psa_invec data[1] = {{&test_data, sizeof(test_data)}};
status_of_call = pal_ipc_call(*handle, data, 1, NULL, 0); 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; status = VAL_STATUS_CALL_FAILED;
mbed_val_print(PRINT_ERROR, "Call to dispatch SF failed. Status=%x\n", status_of_call); mbed_val_print(PRINT_ERROR, "Call to dispatch SF failed. Status=%x\n", status_of_call);
pal_ipc_close(*handle); 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)}}; psa_invec data[1] = {{&test_data, sizeof(test_data)}};
status_of_call = pal_ipc_call(*handle, data, 1, &resp, 1); 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; status = VAL_STATUS_CALL_FAILED;
mbed_val_print(PRINT_ERROR, "Call to dispatch SF failed. Status=%x\n", status_of_call); 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 @param -handle - return connection handle
* @return val_status_t * @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); *handle = pal_ipc_connect(sid, minor_version);
if (*handle < 0) if (*handle < 0) {
{
return VAL_STATUS_CONNECTION_FAILED; 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 * @return val_status_t
*/ */
val_status_t mbed_val_ipc_call(psa_handle_t handle, psa_invec *in_vec, size_t in_len, 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; psa_status_t call_status = PSA_SUCCESS;
call_status = pal_ipc_call(handle, in_vec, in_len, out_vec, out_len); 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; 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; return VAL_STATUS_SUCCESS;
} }
#ifdef __cplusplus
} // extern "C" } // 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_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_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, 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); void mbed_val_ipc_close(psa_handle_t handle);
val_status_t mbed_val_wd_reprogram_timer(wd_timeout_type_t timeout_type); 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's */
typedef struct { typedef struct {
val_status_t (*print) (print_verbosity_t verbosity, val_status_t (*print)(print_verbosity_t verbosity,
const char *string, uint32_t data); const char *string, uint32_t data);
val_status_t (*set_status) (uint32_t status); val_status_t (*set_status)(uint32_t status);
uint32_t (*get_status) (void); uint32_t (*get_status)(void);
void (*test_init) (uint32_t test_num, char8_t *desc, void (*test_init)(uint32_t test_num, char8_t *desc,
uint32_t test_bitfield); uint32_t test_bitfield);
void (*test_exit) (void); void (*test_exit)(void);
val_status_t (*err_check_set) (uint32_t checkpoint, val_status_t status); 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 (*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, val_status_t (*execute_non_secure_tests)(uint32_t test_num, client_test_t *tests_list,
bool_t server_hs); bool_t server_hs);
val_status_t (*switch_to_secure_client) (uint32_t test_num); 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, val_status_t (*execute_secure_test_func)(psa_handle_t *handle, test_info_t test_info,
uint32_t sid); uint32_t sid);
val_status_t (*ipc_connect) (uint32_t sid, uint32_t minor_version, val_status_t (*ipc_connect)(uint32_t sid, uint32_t minor_version,
psa_handle_t *handle ); psa_handle_t *handle);
val_status_t (*ipc_call) (psa_handle_t handle, psa_invec *in_vec, val_status_t (*ipc_call)(psa_handle_t handle, psa_invec *in_vec,
size_t in_len, psa_outvec *out_vec, size_t in_len, psa_outvec *out_vec,
size_t out_len); size_t out_len);
void (*ipc_close) (psa_handle_t handle); void (*ipc_close)(psa_handle_t handle);
val_status_t (*get_secure_test_result) (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_read)(uint32_t offset, void *buffer, int size);
val_status_t (*nvmem_write) (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_init)(wd_timeout_type_t timeout_type);
val_status_t (*wd_timer_enable) (void); val_status_t (*wd_timer_enable)(void);
val_status_t (*wd_timer_disable) (void); val_status_t (*wd_timer_disable)(void);
val_status_t (*wd_reprogram_timer) (wd_timeout_type_t timeout_type); 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 (*set_boot_flag)(boot_state_t state);
val_status_t (*get_boot_flag) (boot_state_t *state); val_status_t (*get_boot_flag)(boot_state_t *state);
int32_t (*crypto_function) (int type, ...); int32_t (*crypto_function)(int type, ...);
uint32_t (*its_function) (int type, ...); uint32_t (*its_function)(int type, ...);
uint32_t (*ps_function) (int type, ...); uint32_t (*ps_function)(int type, ...);
int32_t (*attestation_function) (int type, ...); int32_t (*attestation_function)(int type, ...);
} val_api_t; } val_api_t;
typedef struct { typedef struct {
uint32_t (*framework_version) (void); uint32_t (*framework_version)(void);
uint32_t (*version) (uint32_t sid); uint32_t (*version)(uint32_t sid);
psa_handle_t (*connect) (uint32_t sid, uint32_t minor_version); psa_handle_t (*connect)(uint32_t sid, uint32_t minor_version);
psa_status_t (*call) (psa_handle_t handle, psa_status_t (*call)(psa_handle_t handle,
const psa_invec *in_vec, const psa_invec *in_vec,
size_t in_len, size_t in_len,
psa_outvec *out_vec, psa_outvec *out_vec,
size_t out_len size_t out_len
); );
void (*close) (psa_handle_t handle); void (*close)(psa_handle_t handle);
} psa_api_t; } psa_api_t;
typedef void (*test_fptr_t)(val_api_t *val, psa_api_t *psa); 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 MAJOR IDs
*/ */
typedef enum _GROUP_CONFIG_ID_ { typedef enum _GROUP_CONFIG_ID_ {
GROUP_SOC_PERIPHERAL = 0x1, GROUP_SOC_PERIPHERAL = 0x1,
GROUP_MEMORY = 0x2, GROUP_MEMORY = 0x2,
GROUP_MISCELLANEOUS = 0x3, GROUP_MISCELLANEOUS = 0x3,
GROUP_MAX = 0xFF, GROUP_MAX = 0xFF,
} group_cfg_id_t; } group_cfg_id_t;
/* /*
MINOR IDs MINOR IDs
*/ */
typedef enum _SOC_PERIPHERAL_CONFIG_ID_ { typedef enum _SOC_PERIPHERAL_CONFIG_ID_ {
SOC_PERIPHERAL_UART = 0x1, SOC_PERIPHERAL_UART = 0x1,
SOC_PERIPHERAL_TIMER = 0x2, SOC_PERIPHERAL_TIMER = 0x2,
SOC_PERIPHERAL_WATCHDOG = 0x3, SOC_PERIPHERAL_WATCHDOG = 0x3,
} soc_peripheral_cfg_id_t; } soc_peripheral_cfg_id_t;
typedef enum _MEMORY_CONFIG_ID_ { typedef enum _MEMORY_CONFIG_ID_ {
MEMORY_NVMEM = 0x2, MEMORY_NVMEM = 0x2,
MEMORY_NSPE_MMIO = 0x3, MEMORY_NSPE_MMIO = 0x3,
MEMORY_CLIENT_PARTITION_MMIO = 0x4, MEMORY_CLIENT_PARTITION_MMIO = 0x4,
MEMORY_DRIVER_PARTITION_MMIO = 0x5, MEMORY_DRIVER_PARTITION_MMIO = 0x5,
} memory_cfg_id_t; } memory_cfg_id_t;
typedef enum _MISCELLANEOUS_CONFIG_ID_ { typedef enum _MISCELLANEOUS_CONFIG_ID_ {
MISCELLANEOUS_BOOT = 0x1, MISCELLANEOUS_BOOT = 0x1,
MISCELLANEOUS_DUT = 0x2 MISCELLANEOUS_DUT = 0x2
} miscellaneous_cfg_id_t; } miscellaneous_cfg_id_t;
/** /**
Assign group type to each system component Assign group type to each system component
**/ **/
typedef enum _COMPONENT_GROUPING_{ typedef enum _COMPONENT_GROUPING_ {
UART = GROUP_SOC_PERIPHERAL, UART = GROUP_SOC_PERIPHERAL,
TIMER = GROUP_SOC_PERIPHERAL, TIMER = GROUP_SOC_PERIPHERAL,
WATCHDOG = GROUP_SOC_PERIPHERAL, WATCHDOG = GROUP_SOC_PERIPHERAL,
NVMEM = GROUP_MEMORY, NVMEM = GROUP_MEMORY,
NSPE_MMIO = GROUP_MEMORY, NSPE_MMIO = GROUP_MEMORY,
CLIENT_PARTITION_MMIO = GROUP_MEMORY, CLIENT_PARTITION_MMIO = GROUP_MEMORY,
DRIVER_PARTITION_MMIO = GROUP_MEMORY, DRIVER_PARTITION_MMIO = GROUP_MEMORY,
BOOT = GROUP_MISCELLANEOUS, BOOT = GROUP_MISCELLANEOUS,
DUT = GROUP_MISCELLANEOUS, DUT = GROUP_MISCELLANEOUS,
} comp_group_assign_t; } comp_group_assign_t;
/** /**
@ -100,7 +100,7 @@ typedef struct _TARGET_CFG_HDR_ {
uint32_t version; uint32_t version;
/* Header Size */ /* Header Size */
uint32_t size; uint32_t size;
}target_cfg_hdr_t; } target_cfg_hdr_t;
typedef enum { typedef enum {
LEVEL1 = 0x1, LEVEL1 = 0x1,
@ -149,11 +149,11 @@ typedef struct _MEM_INFO_DESC_ {
} memory_hdr_t; } memory_hdr_t;
typedef struct _MEM_REGION_ { typedef struct _MEM_REGION_ {
cfg_type_t cfg_type; cfg_type_t cfg_type;
addr_t start; addr_t start;
addr_t end; addr_t end;
mem_tgt_attr_t attribute; mem_tgt_attr_t attribute;
perm_type_t permission; perm_type_t permission;
} memory_desc_t; } memory_desc_t;
/* /*
@ -165,19 +165,19 @@ typedef struct _SOC_PER_INFO_NUM_ {
} soc_peripheral_hdr_t; } soc_peripheral_hdr_t;
typedef struct _SOC_PER_INFO_DESC_ { typedef struct _SOC_PER_INFO_DESC_ {
cfg_type_t cfg_type; cfg_type_t cfg_type;
uint32_t vendor_id; uint32_t vendor_id;
uint32_t device_id; uint32_t device_id;
addr_t base; addr_t base;
uint32_t size; uint32_t size;
uint32_t intr_id; uint32_t intr_id;
perm_type_t permission; perm_type_t permission;
uint32_t timeout_in_micro_sec_low; uint32_t timeout_in_micro_sec_low;
uint32_t timeout_in_micro_sec_medium; uint32_t timeout_in_micro_sec_medium;
uint32_t timeout_in_micro_sec_high; uint32_t timeout_in_micro_sec_high;
uint32_t timeout_in_micro_sec_crypto; uint32_t timeout_in_micro_sec_crypto;
uint32_t num_of_tick_per_micro_sec; uint32_t num_of_tick_per_micro_sec;
dev_attr_t attribute; dev_attr_t attribute;
} soc_peripheral_desc_t; } soc_peripheral_desc_t;
/** /**