/* Basic algorithm run function for async inplace mode.
* Creates a session from input parameters and runs one operation
* on input_vec. Checks the output of the crypto operation against
* output_vec. Operation completion event is dequeued polling the
* session output queue. Completion context pointer is retrieved
* and checked against the one set before the operation.
* Completion event can be a separate buffer or the input packet
* buffer can be used.
* */
static void alg_test(enum odp_crypto_op op,
enum odp_cipher_alg cipher_alg,
odp_crypto_iv_t ses_iv,
uint8_t *op_iv_ptr,
odp_crypto_key_t cipher_key,
enum odp_auth_alg auth_alg,
odp_crypto_key_t auth_key,
uint8_t *input_vec,
unsigned int input_vec_len,
uint8_t *output_vec,
unsigned int output_vec_len)
{
odp_crypto_session_t session;
int rc;
enum odp_crypto_ses_create_err status;
odp_bool_t posted;
odp_event_t event;
odp_crypto_compl_t compl_event;
odp_crypto_op_result_t result;
/* Create a crypto session */
odp_crypto_session_params_t ses_params;
memset(&ses_params, 0, sizeof(ses_params));
ses_params.op = op;
ses_params.auth_cipher_text = false;
ses_params.pref_mode = suite_context.pref_mode;
ses_params.cipher_alg = cipher_alg;
ses_params.auth_alg = auth_alg;
ses_params.compl_queue = suite_context.queue;
ses_params.output_pool = suite_context.pool;
ses_params.cipher_key = cipher_key;
ses_params.iv = ses_iv;
ses_params.auth_key = auth_key;
rc = odp_crypto_session_create(&ses_params, &session, &status);
CU_ASSERT(!rc);
CU_ASSERT(status == ODP_CRYPTO_SES_CREATE_ERR_NONE);
CU_ASSERT(odp_crypto_session_to_u64(session) !=
odp_crypto_session_to_u64(ODP_CRYPTO_SESSION_INVALID));
/* Prepare input data */
odp_packet_t pkt = odp_packet_alloc(suite_context.pool, input_vec_len);
CU_ASSERT(pkt != ODP_PACKET_INVALID);
uint8_t *data_addr = odp_packet_data(pkt);
memcpy(data_addr, input_vec, input_vec_len);
const int data_off = 0;
/* Prepare input/output params */
odp_crypto_op_params_t op_params;
memset(&op_params, 0, sizeof(op_params));
op_params.session = session;
op_params.pkt = pkt;
op_params.out_pkt = pkt;
op_params.ctx = (void *)0xdeadbeef;
if (cipher_alg != ODP_CIPHER_ALG_NULL &&
auth_alg == ODP_AUTH_ALG_NULL) {
op_params.cipher_range.offset = data_off;
op_params.cipher_range.length = input_vec_len;
if (op_iv_ptr)
op_params.override_iv_ptr = op_iv_ptr;
} else if (cipher_alg == ODP_CIPHER_ALG_NULL &&
auth_alg != ODP_AUTH_ALG_NULL) {
op_params.auth_range.offset = data_off;
op_params.auth_range.length = input_vec_len;
op_params.hash_result_offset = data_off;
} else {
CU_FAIL("%s : not implemented for combined alg mode\n");
}
rc = odp_crypto_operation(&op_params, &posted, &result);
if (rc < 0) {
CU_FAIL("Failed odp_crypto_operation()");
goto cleanup;
}
if (posted) {
/* Poll completion queue for results */
do {
event = odp_queue_deq(suite_context.queue);
} while (event == ODP_EVENT_INVALID);
compl_event = odp_crypto_compl_from_event(event);
CU_ASSERT(odp_crypto_compl_to_u64(compl_event) ==
odp_crypto_compl_to_u64(odp_crypto_compl_from_event(event)));
odp_crypto_compl_result(compl_event, &result);
odp_crypto_compl_free(compl_event);
}
CU_ASSERT(result.ok);
CU_ASSERT(result.pkt == pkt);
CU_ASSERT(!memcmp(data_addr, output_vec, output_vec_len));
CU_ASSERT(result.ctx == (void *)0xdeadbeef);
cleanup:
rc = odp_crypto_session_destroy(session);
CU_ASSERT(!rc);
odp_packet_free(pkt);
}
/* Basic algorithm run function for async inplace mode.
* Creates a session from input parameters and runs one operation
* on input_vec. Checks the output of the crypto operation against
* output_vec. Operation completion event is dequeued polling the
* session output queue. Completion context pointer is retrieved
* and checked against the one set before the operation.
* Completion event can be a separate buffer or the input packet
* buffer can be used.
* */
static void alg_test(odp_crypto_op_t op,
odp_cipher_alg_t cipher_alg,
odp_crypto_iv_t ses_iv,
uint8_t *op_iv_ptr,
odp_crypto_key_t cipher_key,
odp_auth_alg_t auth_alg,
odp_crypto_key_t auth_key,
odp_crypto_data_range_t *cipher_range,
odp_crypto_data_range_t *auth_range,
const uint8_t *plaintext,
unsigned int plaintext_len,
const uint8_t *ciphertext,
unsigned int ciphertext_len,
const uint8_t *digest,
unsigned int digest_len
)
{
odp_crypto_session_t session;
int rc;
odp_crypto_ses_create_err_t status;
odp_bool_t posted;
odp_event_t event;
odp_crypto_compl_t compl_event;
odp_crypto_op_result_t result;
/* Create a crypto session */
odp_crypto_session_params_t ses_params;
memset(&ses_params, 0, sizeof(ses_params));
ses_params.op = op;
ses_params.auth_cipher_text = false;
ses_params.pref_mode = suite_context.pref_mode;
ses_params.cipher_alg = cipher_alg;
ses_params.auth_alg = auth_alg;
ses_params.compl_queue = suite_context.queue;
ses_params.output_pool = suite_context.pool;
ses_params.cipher_key = cipher_key;
ses_params.iv = ses_iv;
ses_params.auth_key = auth_key;
rc = odp_crypto_session_create(&ses_params, &session, &status);
CU_ASSERT_FATAL(!rc);
CU_ASSERT(status == ODP_CRYPTO_SES_CREATE_ERR_NONE);
CU_ASSERT(odp_crypto_session_to_u64(session) !=
odp_crypto_session_to_u64(ODP_CRYPTO_SESSION_INVALID));
/* Prepare input data */
odp_packet_t pkt = odp_packet_alloc(suite_context.pool,
plaintext_len + digest_len);
CU_ASSERT(pkt != ODP_PACKET_INVALID);
uint8_t *data_addr = odp_packet_data(pkt);
memcpy(data_addr, plaintext, plaintext_len);
int data_off = 0;
/* Prepare input/output params */
odp_crypto_op_params_t op_params;
memset(&op_params, 0, sizeof(op_params));
op_params.session = session;
op_params.pkt = pkt;
op_params.out_pkt = pkt;
op_params.ctx = (void *)0xdeadbeef;
if (cipher_range) {
op_params.cipher_range = *cipher_range;
data_off = cipher_range->offset;
} else {
op_params.cipher_range.offset = data_off;
op_params.cipher_range.length = plaintext_len;
}
if (auth_range) {
op_params.auth_range = *auth_range;
} else {
op_params.auth_range.offset = data_off;
op_params.auth_range.length = plaintext_len;
}
if (op_iv_ptr)
op_params.override_iv_ptr = op_iv_ptr;
op_params.hash_result_offset = plaintext_len;
rc = odp_crypto_operation(&op_params, &posted, &result);
if (rc < 0) {
CU_FAIL("Failed odp_crypto_operation()");
goto cleanup;
}
if (posted) {
/* Poll completion queue for results */
do {
event = odp_queue_deq(suite_context.queue);
} while (event == ODP_EVENT_INVALID);
compl_event = odp_crypto_compl_from_event(event);
CU_ASSERT(odp_crypto_compl_to_u64(compl_event) ==
odp_crypto_compl_to_u64(odp_crypto_compl_from_event(event)));
odp_crypto_compl_result(compl_event, &result);
odp_crypto_compl_free(compl_event);
}
CU_ASSERT(result.ok);
CU_ASSERT(result.pkt == pkt);
if (cipher_alg != ODP_CIPHER_ALG_NULL) {
CU_ASSERT(!memcmp(data_addr, ciphertext, ciphertext_len));
if (memcmp(data_addr, ciphertext, ciphertext_len)) {
printf("data:\n");
unsigned j;
for (j = 0; j < ciphertext_len; ++j) printf("%02x ", data_addr[j]);
printf("\ncipher: \n");
for (j = 0; j < ciphertext_len; ++j) printf("%02x ", ciphertext[j]);
printf("\n\n");
};
};
if (op == ODP_CRYPTO_OP_ENCODE && auth_alg != ODP_AUTH_ALG_NULL)
CU_ASSERT(!memcmp(data_addr + op_params.hash_result_offset,
digest, digest_len));
CU_ASSERT(result.ctx == (void *)0xdeadbeef);
cleanup:
rc = odp_crypto_session_destroy(session);
CU_ASSERT(!rc);
odp_packet_free(pkt);
}
