static void* consumer_operation()
{
set_signal_mask();
while(status_on)
{
if(pthread_mutex_lock(&buffer_lock_mtx)!=0)
print_log(WARNING,"\nthere is error in lock cons");
while(is_buffer_empty())
{
if(pthread_cond_wait(&buffer_not_empty_cond,&buffer_lock_mtx)!=0)
print_log(WARNING,"\nthere is error in wait cons");
}
int peer_sfd = buffer_get();
if(peer_sfd < 0)
{
print_log(WARNING,"\nRECIEVED FAILED ACCEPT SOCKET");
pthread_mutex_unlock(&buffer_lock_mtx)!=0;
continue;
}
if(pthread_cond_broadcast(&buffer_not_full_cond)!=0)
print_log(WARNING,"\nthere is error in broadcast cons");
if(pthread_mutex_unlock(&buffer_lock_mtx)!=0)
print_log(WARNING,"\nthere is error in unlock cons");
manage_single_request(peer_sfd);
close(peer_sfd);
}
pthread_exit(pthread_self);
}
std::string Server::message() {
std::string first_message = "";
if (!is_buffer_empty()) {
first_message = buffer.front();
buffer.pop();
}
return first_message;
}
static int read_data(char * out, buffer_stream_t *bs, int size)
{
if(bs->bInited==0)
return -1;//read failed
int ret=is_buffer_empty(bs);
if(ret==1)
{
//printf("=====buffer empty \n");
return 0;//buffer empty
}
int len= MIN(bs->buf_level,size);
if(bs->wr_ptr>bs->rd_ptr)
{
memcpy(out,bs->rd_ptr,len);
bs->rd_ptr+=len;
bs->buf_level-=len;
if(bs->rd_ptr==(bs->data+bs->buf_length))
bs->rd_ptr=bs->data;
//printf("=====read ok: condition 1 read :%d byte \n",len);
return len;
}
else if(len<(bs->data+bs->buf_length-bs->rd_ptr))
{
memcpy(out,bs->rd_ptr,len);
bs->rd_ptr+=len;
bs->buf_level-=len;
if(bs->rd_ptr==(bs->data+bs->buf_length))
bs->rd_ptr=bs->data;
//printf("=====read ok: condition 2 read :%d byte \n",len);
return len;
}
else
{
int tail_len=(bs->data+bs->buf_length-bs->rd_ptr);
memcpy(out,bs->rd_ptr,tail_len);
memcpy(out+tail_len,bs->data,len-tail_len);
bs->rd_ptr=bs->data+len-tail_len;
bs->buf_level-=len;
if(bs->rd_ptr==(bs->data+bs->buf_length))
bs->rd_ptr=bs->data;
//printf("=====read ok: condition 3 read :%d byte \n",len);
return len;
}
}
/*
************************************************************************************************************************
* Receive a msg
*
* Description: This function is called to receive a msg
*
* Arguments :q_b is the address of the queue buffer object
* -----
* msg is the address of a point, and it will be filled data lwithin this api.
* if you want to use the extension memcpy, make sure the msg address is 4 bytes aligned.
* -----
* wait_option: is how the service behaves if the msg queue is full.
* The wait options are
* defined as follows:
* RAW_NO_WAIT (0x00000000)
* RAW_WAIT_FOREVER (0xFFFFFFFF)
* timeout value (0x00000001
* through
* 0xFFFFFFFE)
* receive_size:is the msg size received.
*
* Returns
* RAW_SUCCESS: raw os return success
* RAW_BLOCK_DEL: if this queue is deleted.
* RAW_BLOCK_TIMEOUT: queue is still full during waiting time when sending msg.
* RAW_BLOCK_ABORT:queue is aborted during waiting time when sending msg.
* RAW_STATE_UNKNOWN: possibly system error.
* Note(s)
*
*
************************************************************************************************************************
*/
RAW_U16 raw_queue_buffer_receive(RAW_QUEUE_BUFFER *q_b, RAW_TICK_TYPE wait_option, RAW_VOID *msg, MSG_SIZE_TYPE *receive_size)
{
RAW_U16 result;
RAW_SR_ALLOC();
#if (RAW_QUEUE_BUFFER_FUNCTION_CHECK > 0)
if (raw_int_nesting) {
return RAW_NOT_CALLED_BY_ISR;
}
if (q_b == 0) {
return RAW_NULL_OBJECT;
}
if (msg == 0) {
return RAW_NULL_POINTER;
}
#endif
RAW_CRITICAL_ENTER();
if (q_b->common_block_obj.object_type != RAW_QUEUE_BUFFER_OBJ_TYPE) {
RAW_CRITICAL_EXIT();
return RAW_ERROR_OBJECT_TYPE;
}
if (!is_buffer_empty(q_b)) {
*receive_size = buffer_to_msg(q_b, msg);
RAW_CRITICAL_EXIT();
return RAW_SUCCESS;
}
if (wait_option == RAW_NO_WAIT) {
RAW_CRITICAL_EXIT();
return RAW_NO_PEND_WAIT;
}
SYSTEM_LOCK_PROCESS();
raw_task_active->msg = msg;
raw_pend_object((RAW_COMMON_BLOCK_OBJECT *)q_b, raw_task_active, wait_option);
RAW_CRITICAL_EXIT();
raw_sched();
result = block_state_post_process(raw_task_active, 0);
/*if get the msg successful then take it*/
if (result == RAW_SUCCESS) {
*receive_size = raw_task_active->qb_msg_size;
}
return result;
}
int32_t psa_asymmetric_encrypt_test(security_t caller)
{
int num_checks = sizeof(check1)/sizeof(check1[0]);
int32_t i, status;
const uint8_t *key_data;
uint8_t *salt;
size_t length;
psa_key_policy_t policy;
/* Initialize the PSA crypto library*/
status = val->crypto_function(VAL_CRYPTO_INIT);
TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(1));
for (i = 0; i < num_checks; i++)
{
val->print(PRINT_TEST, "[Check %d] ", g_test_count++);
val->print(PRINT_TEST, check1[i].test_desc, 0);
/* Initialize a key policy structure to a default that forbids all
* usage of the key
*/
val->crypto_function(VAL_CRYPTO_KEY_POLICY_INIT, &policy);
/* Setting up the watchdog timer for each check */
status = val->wd_reprogram_timer(WD_CRYPTO_TIMEOUT);
TEST_ASSERT_EQUAL(status, VAL_STATUS_SUCCESS, TEST_CHECKPOINT_NUM(2));
/* Set the standard fields of a policy structure */
val->crypto_function(VAL_CRYPTO_KEY_POLICY_SET_USAGE, &policy, check1[i].usage,
check1[i].key_alg);
memset(output, 0, sizeof(output));
/* Set the key data based on key type */
if (PSA_KEY_TYPE_IS_RSA(check1[i].key_type))
{
if (check1[i].key_type == PSA_KEY_TYPE_RSA_KEYPAIR)
{
if (check1[i].expected_bit_length == BYTES_TO_BITS(384))
key_data = rsa_384_keypair;
else if (check1[i].expected_bit_length == BYTES_TO_BITS(256))
key_data = rsa_256_keypair;
else if (check1[i].expected_bit_length == BYTES_TO_BITS(128))
key_data = rsa_128_keypair;
else
return VAL_STATUS_INVALID;
}
else
{
if (check1[i].expected_bit_length == BYTES_TO_BITS(384))
key_data = rsa_384_keydata;
else if (check1[i].expected_bit_length == BYTES_TO_BITS(256))
key_data = rsa_256_keydata;
else if (check1[i].expected_bit_length == BYTES_TO_BITS(128))
key_data = rsa_128_keydata;
else
return VAL_STATUS_INVALID;
}
}
else if (PSA_KEY_TYPE_IS_ECC(check1[i].key_type))
{
if (PSA_KEY_TYPE_IS_ECC_KEYPAIR(check1[i].key_type))
key_data = ec_keypair;
else
key_data = ec_keydata;
}
else
key_data = check1[i].key_data;
/* Allocate a key slot for a transient key */
status = val->crypto_function(VAL_CRYPTO_ALLOCATE_KEY, &check1[i].key_handle);
TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(3));
/* Set the usage policy on a key slot */
status = val->crypto_function(VAL_CRYPTO_SET_KEY_POLICY, check1[i].key_handle,
&policy);
TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(4));
/* Import the key data into the key slot */
status = val->crypto_function(VAL_CRYPTO_IMPORT_KEY, check1[i].key_handle,
check1[i].key_type, key_data, check1[i].key_length);
TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(5));
if (is_buffer_empty(check1[i].salt, check1[i].salt_length) == TRUE)
salt = NULL;
else
salt = check1[i].salt;
/* Encrypt a short message with a public key */
status = val->crypto_function(VAL_CRYPTO_ASYMMTERIC_ENCRYPT, check1[i].key_handle,
check1[i].key_alg, check1[i].input, check1[i].input_length, salt,
check1[i].salt_length, output, check1[i].output_size, &length);
TEST_ASSERT_EQUAL(status, check1[i].expected_status, TEST_CHECKPOINT_NUM(6));
if (check1[i].expected_status != PSA_SUCCESS)
continue;
/* Check if the output length matches with the expected output length */
TEST_ASSERT_EQUAL(length, check1[i].expected_output_length, TEST_CHECKPOINT_NUM(7));
/* We test encryption by checking that encrypt-then-decrypt gives back
* the original plaintext because of the non-optional random
* part of encryption process which prevents using fixed vectors. */
if ((check1[i].usage & PSA_KEY_USAGE_DECRYPT) == PSA_KEY_USAGE_DECRYPT)
{
status = val->crypto_function(VAL_CRYPTO_ASYMMTERIC_DECRYPT,
check1[i].key_handle, check1[i].key_alg, output, length, salt,
check1[i].salt_length, output, check1[i].output_size, &length);
TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(8));
/* Check if the output length matches with the input length */
TEST_ASSERT_EQUAL(length, check1[i].input_length, TEST_CHECKPOINT_NUM(9));
/* Check if the output matches with the given input data */
TEST_ASSERT_MEMCMP(output, check1[i].input, length, TEST_CHECKPOINT_NUM(10));
}
}
return VAL_STATUS_SUCCESS;
}
int32_t psa_asymmetric_encrypt_negative_test(security_t caller)
{
int num_checks = sizeof(check2)/sizeof(check2[0]);
int32_t i, status;
uint8_t *salt;
size_t length;
psa_key_policy_t policy;
/* Initialize the PSA crypto library*/
status = val->crypto_function(VAL_CRYPTO_INIT);
TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(1));
for (i = 0; i < num_checks; i++)
{
val->print(PRINT_TEST, "[Check %d] Test psa_asymmetric_encrypt - Invalid key handle\n",
g_test_count++);
/* Initialize a key policy structure to a default that forbids all
* usage of the key
*/
val->crypto_function(VAL_CRYPTO_KEY_POLICY_INIT, &policy);
/* Setting up the watchdog timer for each check */
status = val->wd_reprogram_timer(WD_CRYPTO_TIMEOUT);
TEST_ASSERT_EQUAL(status, VAL_STATUS_SUCCESS, TEST_CHECKPOINT_NUM(2));
/* Set the standard fields of a policy structure */
val->crypto_function(VAL_CRYPTO_KEY_POLICY_SET_USAGE, &policy, check2[i].usage,
check2[i].key_alg);
val->print(PRINT_TEST, "[Check %d] Test psa_asymmetric_encrypt - Invalid key handle\n",
g_test_count++);
/* Encrypt a short message with a public key */
status = val->crypto_function(VAL_CRYPTO_ASYMMTERIC_ENCRYPT, check2[i].key_handle,
check2[i].key_alg, check2[i].input, check2[i].input_length, salt,
check2[i].salt_length, output, check2[i].output_size, &length);
TEST_ASSERT_EQUAL(status, PSA_ERROR_INVALID_HANDLE, TEST_CHECKPOINT_NUM(3));
val->print(PRINT_TEST, "[Check %d] Test psa_asymmetric_encrypt - Zero as key handle\n",
g_test_count++);
/* Encrypt a short message with a public key */
status = val->crypto_function(VAL_CRYPTO_ASYMMTERIC_ENCRYPT, 0,
check2[i].key_alg, check2[i].input, check2[i].input_length, salt,
check2[i].salt_length, output, check2[i].output_size, &length);
TEST_ASSERT_EQUAL(status, PSA_ERROR_INVALID_HANDLE, TEST_CHECKPOINT_NUM(4));
val->print(PRINT_TEST, "[Check %d] Test psa_asymmetric_encrypt - Empty key handle\n",
g_test_count++);
/* Allocate a key slot for a transient key */
status = val->crypto_function(VAL_CRYPTO_ALLOCATE_KEY, &check2[i].key_handle);
TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(5));
/* Set the usage policy on a key slot */
status = val->crypto_function(VAL_CRYPTO_SET_KEY_POLICY, check2[i].key_handle,
&policy);
TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(6));
if (is_buffer_empty(check1[i].salt, check1[i].salt_length) == TRUE)
salt = NULL;
else
salt = check1[i].salt;
/* Encrypt a short message with a public key */
status = val->crypto_function(VAL_CRYPTO_ASYMMTERIC_ENCRYPT, check2[i].key_handle,
check2[i].key_alg, check2[i].input, check2[i].input_length, salt,
check2[i].salt_length, output, check2[i].output_size, &length);
TEST_ASSERT_EQUAL(status, PSA_ERROR_EMPTY_SLOT, TEST_CHECKPOINT_NUM(7));
}
return VAL_STATUS_SUCCESS;
}
int32_t psa_aead_decrypt_test(security_t caller)
{
int32_t i, status;
uint8_t plaintext[BUFFER_SIZE];
psa_key_policy_t policy;
size_t plaintext_length;
int num_checks = sizeof(check1)/sizeof(check1[0]);
uint8_t *nonce, *additional_data;
/* Initialize the PSA crypto library*/
status = val->crypto_function(VAL_CRYPTO_INIT);
TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(1));
for (i = 0; i < num_checks; i++)
{
val->print(PRINT_TEST, "[Check %d] ", g_test_count++);
val->print(PRINT_TEST, check1[i].test_desc, 0);
/* Initialize a key policy structure to a default that forbids all
* usage of the key
*/
val->crypto_function(VAL_CRYPTO_KEY_POLICY_INIT, &policy);
/* Setting up the watchdog timer for each check */
status = val->wd_reprogram_timer(WD_CRYPTO_TIMEOUT);
TEST_ASSERT_EQUAL(status, VAL_STATUS_SUCCESS, TEST_CHECKPOINT_NUM(2));
/* Set the standard fields of a policy structure */
val->crypto_function(VAL_CRYPTO_KEY_POLICY_SET_USAGE, &policy, check1[i].usage,
check1[i].key_alg);
memset(plaintext, 0, sizeof(plaintext));
/* Allocate a key slot for a transient key */
status = val->crypto_function(VAL_CRYPTO_ALLOCATE_KEY, &check1[i].key_handle);
TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(3));
/* Set the usage policy on a key slot */
status = val->crypto_function(VAL_CRYPTO_SET_KEY_POLICY, check1[i].key_handle,
&policy);
TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(4));
/* Import the key data into the key slot */
status = val->crypto_function(VAL_CRYPTO_IMPORT_KEY, check1[i].key_handle,
check1[i].key_type, check1[i].key_data, check1[i].key_length);
TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(5));
if (is_buffer_empty(check1[i].nonce, check1[i].nonce_length) == TRUE)
{
nonce = NULL;
check1[i].nonce_length = 0;
}
else
nonce = check1[i].nonce;
if (is_buffer_empty(check1[i].additional_data, check1[i].additional_data_length) == TRUE)
{
additional_data = NULL;
check1[i].additional_data_length = 0;
}
else
additional_data = check1[i].additional_data;
/* Process an authenticated decryption operation */
status = val->crypto_function(VAL_CRYPTO_AEAD_DECRYPT, check1[i].key_handle,
check1[i].key_alg, nonce, check1[i].nonce_length, additional_data,
check1[i].additional_data_length, check1[i].ciphertext, check1[i].ciphertext_size,
plaintext, check1[i].plaintext_size, &plaintext_length);
TEST_ASSERT_EQUAL(status, check1[i].expected_status, TEST_CHECKPOINT_NUM(6));
if (check1[i].expected_status != PSA_SUCCESS)
continue;
/* Check if the length matches */
TEST_ASSERT_EQUAL(plaintext_length, check1[i].expected_plaintext_length,
TEST_CHECKPOINT_NUM(7));
/* Check if the data matches */
TEST_ASSERT_MEMCMP(plaintext, check1[i].expected_plaintext, plaintext_length,
TEST_CHECKPOINT_NUM(8));
}
return VAL_STATUS_SUCCESS;
}
int32_t psa_aead_decrypt_negative_test(security_t caller)
{
int32_t i, status;
uint8_t plaintext[BUFFER_SIZE];
psa_key_policy_t policy;
size_t plaintext_length;
int num_checks = sizeof(check2)/sizeof(check2[0]);
uint8_t *nonce, *additional_data;
/* Initialize the PSA crypto library*/
status = val->crypto_function(VAL_CRYPTO_INIT);
TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(1));
for (i = 0; i < num_checks; i++)
{
/* Initialize a key policy structure to a default that forbids all
* usage of the key
*/
val->crypto_function(VAL_CRYPTO_KEY_POLICY_INIT, &policy);
/* Setting up the watchdog timer for each check */
status = val->wd_reprogram_timer(WD_CRYPTO_TIMEOUT);
TEST_ASSERT_EQUAL(status, VAL_STATUS_SUCCESS, TEST_CHECKPOINT_NUM(2));
/* Set the standard fields of a policy structure */
val->crypto_function(VAL_CRYPTO_KEY_POLICY_SET_USAGE, &policy, check2[i].usage,
check2[i].key_alg);
if (is_buffer_empty(check2[i].nonce, check2[i].nonce_length) == TRUE)
{
nonce = NULL;
check2[i].nonce_length = 0;
}
else
nonce = check2[i].nonce;
if (is_buffer_empty(check2[i].additional_data, check2[i].additional_data_length) == TRUE)
{
additional_data = NULL;
check2[i].additional_data_length = 0;
}
else
additional_data = check2[i].additional_data;
val->print(PRINT_TEST, "[Check %d] Test psa_aead_decrypt - invalid key handle\n",
g_test_count++);
/* Process an authenticated decryption operation */
status = val->crypto_function(VAL_CRYPTO_AEAD_DECRYPT, check2[i].key_handle,
check2[i].key_alg, nonce, check2[i].nonce_length, additional_data,
check2[i].additional_data_length, check2[i].ciphertext, check2[i].ciphertext_size,
plaintext, check2[i].plaintext_size, &plaintext_length);
TEST_ASSERT_EQUAL(status, PSA_ERROR_INVALID_HANDLE, TEST_CHECKPOINT_NUM(3));
val->print(PRINT_TEST, "[Check %d] Test psa_aead_decrypt - zero as key handle\n",
g_test_count++);
/* Process an authenticated decryption operation */
status = val->crypto_function(VAL_CRYPTO_AEAD_DECRYPT, 0,
check2[i].key_alg, nonce, check2[i].nonce_length, additional_data,
check2[i].additional_data_length, check2[i].ciphertext, check2[i].ciphertext_size,
plaintext, check2[i].plaintext_size, &plaintext_length);
TEST_ASSERT_EQUAL(status, PSA_ERROR_INVALID_HANDLE, TEST_CHECKPOINT_NUM(4));
val->print(PRINT_TEST, "[Check %d] Test psa_aead_decrypt - empty key handle\n",
g_test_count++);
/* Allocate a key slot for a transient key */
status = val->crypto_function(VAL_CRYPTO_ALLOCATE_KEY, &check2[i].key_handle);
TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(5));
/* Set the usage policy on a key slot */
status = val->crypto_function(VAL_CRYPTO_SET_KEY_POLICY, check2[i].key_handle,
&policy);
TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(6));
/* Process an authenticated decryption operation */
status = val->crypto_function(VAL_CRYPTO_AEAD_DECRYPT, check2[i].key_handle,
check2[i].key_alg, nonce, check2[i].nonce_length, additional_data,
check2[i].additional_data_length, check2[i].ciphertext, check2[i].ciphertext_size,
plaintext, check2[i].plaintext_size, &plaintext_length);
TEST_ASSERT_EQUAL(status, PSA_ERROR_EMPTY_SLOT, TEST_CHECKPOINT_NUM(7));
}
return VAL_STATUS_SUCCESS;
}
