@@ -1,1296 +1,1296 @@
-/* Copyright (c) 2014-2018, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#include "config.h"
-
-#include <odp_api.h>
-#include <CUnit/Basic.h>
-#include <odp_cunit_common.h>
-#include "test_vectors.h"
-#include "odp_crypto_test_inp.h"
-#include "crypto.h"
-
-#define MAX_ALG_CAPA 32
-
-struct suite_context_s {
- odp_bool_t packet;
- odp_crypto_op_mode_t op_mode;
- odp_crypto_op_mode_t pref_mode;
- odp_pool_t pool;
- odp_queue_t queue;
-};
-
-static struct suite_context_s suite_context;
-
-static int packet_cmp_mem(odp_packet_t pkt, uint32_t offset,
- void *s, uint32_t len)
-{
- uint8_t buf[len];
-
- odp_packet_copy_to_mem(pkt, offset, len, buf);
-
- return memcmp(buf, s, len);
-}
-
-static const char *auth_alg_name(odp_auth_alg_t auth)
-{
- switch (auth) {
- case ODP_AUTH_ALG_NULL:
- return "ODP_AUTH_ALG_NULL";
- case ODP_AUTH_ALG_MD5_HMAC:
- return "ODP_AUTH_ALG_MD5_HMAC";
- case ODP_AUTH_ALG_SHA1_HMAC:
- return "ODP_AUTH_ALG_SHA1_HMAC";
- case ODP_AUTH_ALG_SHA256_HMAC:
- return "ODP_AUTH_ALG_SHA256_HMAC";
- case ODP_AUTH_ALG_SHA512_HMAC:
- return "ODP_AUTH_ALG_SHA512_HMAC";
- case ODP_AUTH_ALG_AES_GCM:
- return "ODP_AUTH_ALG_AES_GCM";
- case ODP_AUTH_ALG_AES_GMAC:
- return "ODP_AUTH_ALG_AES_GMAC";
- default:
- return "Unknown";
- }
-}
-
-static const char *cipher_alg_name(odp_cipher_alg_t cipher)
-{
- switch (cipher) {
- case ODP_CIPHER_ALG_NULL:
- return "ODP_CIPHER_ALG_NULL";
- case ODP_CIPHER_ALG_DES:
- return "ODP_CIPHER_ALG_DES";
- case ODP_CIPHER_ALG_3DES_CBC:
- return "ODP_CIPHER_ALG_3DES_CBC";
- case ODP_CIPHER_ALG_AES_CBC:
- return "ODP_CIPHER_ALG_AES_CBC";
- case ODP_CIPHER_ALG_AES_GCM:
- return "ODP_CIPHER_ALG_AES_GCM";
- default:
- return "Unknown";
- }
-}
-
-static int alg_op(odp_packet_t pkt,
- odp_bool_t *ok,
- odp_crypto_session_t session,
- uint8_t *cipher_iv_ptr,
- uint8_t *auth_iv_ptr,
- odp_packet_data_range_t *cipher_range,
- odp_packet_data_range_t *auth_range,
- uint8_t *aad,
- unsigned int plaintext_len)
-{
- int rc;
- odp_crypto_op_result_t result;
- odp_crypto_op_param_t op_params;
- odp_bool_t posted;
- odp_event_subtype_t subtype;
-
- /* Prepare input/output 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;
-
- op_params.cipher_range = *cipher_range;
- op_params.auth_range = *auth_range;
- if (cipher_iv_ptr)
- op_params.cipher_iv_ptr = cipher_iv_ptr;
- if (auth_iv_ptr)
- op_params.auth_iv_ptr = auth_iv_ptr;
-
- op_params.aad_ptr = aad;
-
- op_params.hash_result_offset = plaintext_len;
-
- rc = odp_crypto_operation(&op_params, &posted, &result);
- if (rc < 0) {
- CU_FAIL("Failed odp_crypto_operation()");
- return rc;
- }
-
- if (posted) {
- odp_event_t event;
- odp_crypto_compl_t compl_event;
-
- /* Poll completion queue for results */
- do {
- event = odp_queue_deq(suite_context.queue);
- } while (event == ODP_EVENT_INVALID);
-
- CU_ASSERT(ODP_EVENT_CRYPTO_COMPL == odp_event_type(event));
- CU_ASSERT(ODP_EVENT_NO_SUBTYPE == odp_event_subtype(event));
- CU_ASSERT(ODP_EVENT_CRYPTO_COMPL ==
- odp_event_types(event, &subtype));
- CU_ASSERT(ODP_EVENT_NO_SUBTYPE == subtype);
-
- 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.pkt == pkt);
- CU_ASSERT(result.ctx == (void *)0xdeadbeef);
- CU_ASSERT(ODP_EVENT_PACKET ==
- odp_event_type(odp_packet_to_event(result.pkt)));
- CU_ASSERT(ODP_EVENT_PACKET_BASIC ==
- odp_event_subtype(odp_packet_to_event(result.pkt)));
- CU_ASSERT(ODP_EVENT_PACKET ==
- odp_event_types(odp_packet_to_event(result.pkt), &subtype));
- CU_ASSERT(ODP_EVENT_PACKET_BASIC == subtype);
-
- *ok = result.ok;
-
- return 0;
-}
-
-static int alg_packet_op(odp_packet_t pkt,
- odp_bool_t *ok,
- odp_crypto_session_t session,
- uint8_t *cipher_iv_ptr,
- uint8_t *auth_iv_ptr,
- odp_packet_data_range_t *cipher_range,
- odp_packet_data_range_t *auth_range,
- uint8_t *aad,
- unsigned int plaintext_len)
-{
- int rc;
- odp_crypto_packet_result_t result;
- odp_crypto_packet_op_param_t op_params;
- odp_event_subtype_t subtype;
- odp_packet_t out_pkt = pkt;
-
- /* Prepare input/output params */
- memset(&op_params, 0, sizeof(op_params));
- op_params.session = session;
-
- op_params.cipher_range = *cipher_range;
- op_params.auth_range = *auth_range;
- if (cipher_iv_ptr)
- op_params.cipher_iv_ptr = cipher_iv_ptr;
- if (auth_iv_ptr)
- op_params.auth_iv_ptr = auth_iv_ptr;
-
- op_params.aad_ptr = aad;
-
- op_params.hash_result_offset = plaintext_len;
-
- rc = odp_crypto_op(&pkt, &out_pkt, &op_params, 1);
- if (rc < 0) {
- CU_FAIL("Failed odp_crypto_packet_op()");
- return rc;
- }
-
- CU_ASSERT(out_pkt == pkt);
- CU_ASSERT(ODP_EVENT_PACKET ==
- odp_event_type(odp_packet_to_event(pkt)));
- CU_ASSERT(ODP_EVENT_PACKET_CRYPTO ==
- odp_event_subtype(odp_packet_to_event(pkt)));
- CU_ASSERT(ODP_EVENT_PACKET ==
- odp_event_types(odp_packet_to_event(pkt), &subtype));
- CU_ASSERT(ODP_EVENT_PACKET_CRYPTO == subtype);
-
- rc = odp_crypto_result(&result, pkt);
- if (rc < 0) {
- CU_FAIL("Failed odp_crypto_packet_result()");
- return rc;
- }
-
- if (!result.ok)
- CU_ASSERT(odp_packet_has_error(pkt));
-
- *ok = result.ok;
-
- return 0;
-}
-
-static int alg_packet_op_enq(odp_packet_t pkt,
- odp_bool_t *ok,
- odp_crypto_session_t session,
- uint8_t *cipher_iv_ptr,
- uint8_t *auth_iv_ptr,
- odp_packet_data_range_t *cipher_range,
- odp_packet_data_range_t *auth_range,
- uint8_t *aad,
- unsigned int plaintext_len)
-{
- int rc;
- odp_event_t event;
- odp_crypto_packet_result_t result;
- odp_crypto_packet_op_param_t op_params;
- odp_event_subtype_t subtype;
- odp_packet_t out_pkt = pkt;
-
- /* Prepare input/output params */
- memset(&op_params, 0, sizeof(op_params));
- op_params.session = session;
-
- op_params.cipher_range = *cipher_range;
- op_params.auth_range = *auth_range;
- if (cipher_iv_ptr)
- op_params.cipher_iv_ptr = cipher_iv_ptr;
- if (auth_iv_ptr)
- op_params.auth_iv_ptr = auth_iv_ptr;
-
- op_params.aad_ptr = aad;
-
- op_params.hash_result_offset = plaintext_len;
-
- rc = odp_crypto_op_enq(&pkt, &pkt, &op_params, 1);
- if (rc < 0) {
- CU_FAIL("Failed odp_crypto_op_enq()");
- return rc;
- }
-
- /* Poll completion queue for results */
- do {
- event = odp_queue_deq(suite_context.queue);
- } while (event == ODP_EVENT_INVALID);
-
- CU_ASSERT(ODP_EVENT_PACKET == odp_event_type(event));
- CU_ASSERT(ODP_EVENT_PACKET_CRYPTO == odp_event_subtype(event));
- CU_ASSERT(ODP_EVENT_PACKET == odp_event_types(event, &subtype));
- CU_ASSERT(ODP_EVENT_PACKET_CRYPTO == subtype);
-
- pkt = odp_crypto_packet_from_event(event);
-
- CU_ASSERT(out_pkt == pkt);
- CU_ASSERT(ODP_EVENT_PACKET ==
- odp_event_type(odp_packet_to_event(pkt)));
- CU_ASSERT(ODP_EVENT_PACKET_CRYPTO ==
- odp_event_subtype(odp_packet_to_event(pkt)));
- CU_ASSERT(ODP_EVENT_PACKET ==
- odp_event_types(odp_packet_to_event(pkt), &subtype));
- CU_ASSERT(ODP_EVENT_PACKET_CRYPTO == subtype);
-
- rc = odp_crypto_result(&result, pkt);
- if (rc < 0) {
- CU_FAIL("Failed odp_crypto_packet_result()");
- return rc;
- }
-
- CU_ASSERT((!odp_packet_has_error(pkt)) == result.ok);
-
- *ok = result.ok;
-
- return 0;
-}
-
-typedef enum crypto_test {
- NORMAL_TEST = 0, /**< Plain execution */
- REPEAT_TEST, /**< Rerun without reinitializing the session */
- WRONG_DIGEST_TEST, /**< Check against wrong digest */
- MAX_TEST, /**< Final mark */
-} crypto_test;
-
-/* 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_auth_alg_t auth_alg,
- crypto_test_reference_t *ref,
- odp_bool_t ovr_iv)
-{
- odp_crypto_session_t session;
- int rc;
- odp_crypto_ses_create_err_t status;
- odp_bool_t ok = false;
- int iteration;
- odp_crypto_session_param_t ses_params;
- odp_packet_data_range_t cipher_range;
- odp_packet_data_range_t auth_range;
- odp_crypto_key_t cipher_key = {
- .data = ref->cipher_key,
- .length = ref->cipher_key_length
- };
- odp_crypto_key_t auth_key = {
- .data = ref->auth_key,
- .length = ref->auth_key_length
- };
- odp_crypto_iv_t cipher_iv = {
- .data = ovr_iv ? NULL : ref->cipher_iv,
- .length = ref->cipher_iv_length
- };
- odp_crypto_iv_t auth_iv = {
- .data = ovr_iv ? NULL : ref->auth_iv,
- .length = ref->auth_iv_length
- };
-
- /* Create a crypto session */
- odp_crypto_session_param_init(&ses_params);
- ses_params.op = op;
- ses_params.auth_cipher_text = false;
- ses_params.op_mode = suite_context.op_mode;
- 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.cipher_iv = cipher_iv;
- ses_params.auth_iv = auth_iv;
- ses_params.auth_key = auth_key;
- ses_params.auth_digest_len = ref->digest_length;
- ses_params.auth_aad_len = ref->aad_length;
-
- 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));
-
- cipher_range.offset = 0;
- cipher_range.length = ref->length;
- auth_range.offset = 0;
- auth_range.length = ref->length;
-
- /* Prepare input data */
- odp_packet_t pkt = odp_packet_alloc(suite_context.pool,
- ref->length + ref->digest_length);
- CU_ASSERT(pkt != ODP_PACKET_INVALID);
- if (pkt == ODP_PACKET_INVALID)
- goto cleanup;
-
- for (iteration = NORMAL_TEST; iteration < MAX_TEST; iteration++) {
- /* checking against wrong digest is meaningless for NULL digest
- * or when generating digest */
- if (iteration == WRONG_DIGEST_TEST &&
- (auth_alg == ODP_AUTH_ALG_NULL ||
- op == ODP_CRYPTO_OP_ENCODE))
- continue;
-
- if (op == ODP_CRYPTO_OP_ENCODE) {
- odp_packet_copy_from_mem(pkt, 0, ref->length,
- ref->plaintext);
- } else {
- odp_packet_copy_from_mem(pkt, 0, ref->length,
- ref->ciphertext);
- odp_packet_copy_from_mem(pkt, ref->length,
- ref->digest_length,
- ref->digest);
- if (iteration == WRONG_DIGEST_TEST) {
- uint8_t byte = ~ref->digest[0];
-
- odp_packet_copy_from_mem(pkt, ref->length,
- 1, &byte);
- }
- }
-
- if (!suite_context.packet)
- rc = alg_op(pkt, &ok, session,
- ovr_iv ? ref->cipher_iv : NULL,
- ovr_iv ? ref->auth_iv : NULL,
- &cipher_range, &auth_range,
- ref->aad, ref->length);
- else if (ODP_CRYPTO_ASYNC == suite_context.op_mode)
- rc = alg_packet_op_enq(pkt, &ok, session,
- ovr_iv ? ref->cipher_iv : NULL,
- ovr_iv ? ref->auth_iv : NULL,
- &cipher_range, &auth_range,
- ref->aad, ref->length);
- else
- rc = alg_packet_op(pkt, &ok, session,
- ovr_iv ? ref->cipher_iv : NULL,
- ovr_iv ? ref->auth_iv : NULL,
- &cipher_range, &auth_range,
- ref->aad, ref->length);
- if (rc < 0)
- break;
-
- if (iteration == WRONG_DIGEST_TEST) {
- CU_ASSERT(!ok);
- continue;
- }
-
- CU_ASSERT(ok);
-
- if (op == ODP_CRYPTO_OP_ENCODE) {
- CU_ASSERT(!packet_cmp_mem(pkt, 0,
- ref->ciphertext,
- ref->length));
- CU_ASSERT(!packet_cmp_mem(pkt, ref->length,
- ref->digest,
- ref->digest_length));
- } else {
- CU_ASSERT(!packet_cmp_mem(pkt, 0,
- ref->plaintext,
- ref->length));
- }
- }
-
- odp_packet_free(pkt);
-
-cleanup:
- rc = odp_crypto_session_destroy(session);
- CU_ASSERT(!rc);
-}
-
-static void check_alg(odp_crypto_op_t op,
- odp_cipher_alg_t cipher_alg,
- odp_auth_alg_t auth_alg,
- crypto_test_reference_t *ref,
- size_t count,
- odp_bool_t ovr_iv)
-{
- odp_crypto_capability_t capa;
- odp_crypto_cipher_capability_t cipher_capa[MAX_ALG_CAPA];
- odp_crypto_auth_capability_t auth_capa[MAX_ALG_CAPA];
- int rc, cipher_num, auth_num, i;
- odp_bool_t cipher_tested[MAX_ALG_CAPA];
- odp_bool_t auth_tested[MAX_ALG_CAPA];
- odp_bool_t cipher_ok = false;
- odp_bool_t auth_ok = false;
- size_t idx;
-
- rc = odp_crypto_capability(&capa);
- CU_ASSERT(!rc);
-
- if (cipher_alg == ODP_CIPHER_ALG_3DES_CBC &&
- !(capa.ciphers.bit.trides_cbc))
- rc = -1;
- if (cipher_alg == ODP_CIPHER_ALG_AES_CBC &&
- !(capa.ciphers.bit.aes_cbc))
- rc = -1;
- if (cipher_alg == ODP_CIPHER_ALG_AES_CTR &&
- !(capa.ciphers.bit.aes_ctr))
- rc = -1;
- if (cipher_alg == ODP_CIPHER_ALG_AES_GCM &&
- !(capa.ciphers.bit.aes_gcm))
- rc = -1;
- if (cipher_alg == ODP_CIPHER_ALG_DES &&
- !(capa.ciphers.bit.des))
- rc = -1;
- if (cipher_alg == ODP_CIPHER_ALG_NULL &&
- !(capa.ciphers.bit.null))
- rc = -1;
-
- CU_ASSERT(!rc);
- CU_ASSERT((~capa.ciphers.all_bits & capa.hw_ciphers.all_bits) == 0);
-
- if (auth_alg == ODP_AUTH_ALG_AES_GCM &&
- !(capa.auths.bit.aes_gcm))
- rc = -1;
- if (auth_alg == ODP_AUTH_ALG_AES_GMAC &&
- !(capa.auths.bit.aes_gmac))
- rc = -1;
- if (auth_alg == ODP_AUTH_ALG_MD5_HMAC &&
- !(capa.auths.bit.md5_hmac))
- rc = -1;
- if (auth_alg == ODP_AUTH_ALG_NULL &&
- !(capa.auths.bit.null))
- rc = -1;
- if (auth_alg == ODP_AUTH_ALG_SHA1_HMAC &&
- !(capa.auths.bit.sha1_hmac))
- rc = -1;
- if (auth_alg == ODP_AUTH_ALG_SHA256_HMAC &&
- !(capa.auths.bit.sha256_hmac))
- rc = -1;
- if (auth_alg == ODP_AUTH_ALG_SHA512_HMAC &&
- !(capa.auths.bit.sha512_hmac))
- rc = -1;
-
- CU_ASSERT(!rc);
- CU_ASSERT((~capa.auths.all_bits & capa.hw_auths.all_bits) == 0);
-
- cipher_num = odp_crypto_cipher_capability(cipher_alg, cipher_capa,
- MAX_ALG_CAPA);
-
- CU_ASSERT(cipher_num > 0);
- CU_ASSERT(cipher_num <= MAX_ALG_CAPA);
- if (cipher_num > MAX_ALG_CAPA)
- cipher_num = MAX_ALG_CAPA;
-
- auth_num = odp_crypto_auth_capability(auth_alg, auth_capa,
- MAX_ALG_CAPA);
-
- CU_ASSERT(auth_num > 0);
- CU_ASSERT(auth_num <= MAX_ALG_CAPA);
- if (auth_num > MAX_ALG_CAPA)
- auth_num = MAX_ALG_CAPA;
-
- memset(cipher_tested, 0, sizeof(cipher_tested));
- memset(auth_tested, 0, sizeof(auth_tested));
-
- for (idx = 0; idx < count; idx++) {
- int cipher_idx = -1, auth_idx = -1;
-
- for (i = 0; i < cipher_num; i++) {
- if (cipher_capa[i].key_len ==
- ref[idx].cipher_key_length &&
- cipher_capa[i].iv_len ==
- ref[idx].cipher_iv_length) {
- cipher_idx = i;
- break;
- }
- }
-
- if (cipher_idx < 0) {
- printf("\n Unsupported: alg=%s, key_len=%" PRIu32
- ", iv_len=%" PRIu32 "\n",
- cipher_alg_name(cipher_alg),
- ref[idx].cipher_key_length,
- ref[idx].cipher_iv_length);
- continue;
- }
-
- for (i = 0; i < auth_num; i++) {
- if (auth_capa[i].digest_len ==
- ref[idx].digest_length &&
- auth_capa[i].iv_len ==
- ref[idx].auth_iv_length &&
- auth_capa[i].key_len ==
- ref[idx].auth_key_length) {
- auth_idx = i;
- break;
- }
- }
-
- if (auth_idx < 0) {
- printf("\n Unsupported: alg=%s, key_len=%" PRIu32
- ", iv_len=%" PRIu32 ", digest_len=%" PRIu32 "\n",
- auth_alg_name(auth_alg),
- ref[idx].auth_key_length,
- ref[idx].auth_iv_length,
- ref[idx].digest_length);
- continue;
- }
-
- alg_test(op, cipher_alg, auth_alg, &ref[idx], ovr_iv);
-
- cipher_tested[cipher_idx] = true;
- auth_tested[auth_idx] = true;
- }
-
- for (i = 0; i < cipher_num; i++) {
- cipher_ok |= cipher_tested[i];
- if (!cipher_tested[i]) {
- /* GMAC-related hacks */
- if (cipher_alg == ODP_CIPHER_ALG_NULL)
- continue;
- printf("\n Untested: alg=%s, key_len=%" PRIu32 ", "
- "iv_len=%" PRIu32 "\n",
- cipher_alg_name(cipher_alg),
- cipher_capa[i].key_len,
- cipher_capa[i].iv_len);
- }
- }
-
- for (i = 0; i < auth_num; i++) {
- auth_ok |= auth_tested[i];
- if (!auth_tested[i])
- printf("\n Untested: alg=%s, key_len=%" PRIu32 ", "
- "digest_len=%" PRIu32 "\n",
- auth_alg_name(auth_alg),
- auth_capa[i].key_len,
- auth_capa[i].digest_len);
- }
-
- /* Verify that we were able to run at least several tests */
- CU_ASSERT(cipher_ok);
- CU_ASSERT(auth_ok);
-}
-
-/**
- * Check if given cipher and authentication algorithms are supported
- *
- * @param cipher Cipher algorithm
- * @param auth Authentication algorithm
- *
- * @retval ODP_TEST_ACTIVE when both algorithms are supported
- * @retval ODP_TEST_INACTIVE when either algorithm is not supported
- */
-static int check_alg_support(odp_cipher_alg_t cipher, odp_auth_alg_t auth)
-{
- odp_crypto_capability_t capability;
-
- if (odp_crypto_capability(&capability))
- return ODP_TEST_INACTIVE;
-
- if (suite_context.packet) {
- if (suite_context.op_mode == ODP_CRYPTO_SYNC &&
- capability.sync_mode == ODP_SUPPORT_NO)
- return ODP_TEST_INACTIVE;
- if (suite_context.op_mode == ODP_CRYPTO_ASYNC &&
- capability.async_mode == ODP_SUPPORT_NO)
- return ODP_TEST_INACTIVE;
- }
-
- /* Cipher algorithms */
- switch (cipher) {
- case ODP_CIPHER_ALG_NULL:
- if (!capability.ciphers.bit.null)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_CIPHER_ALG_DES:
- if (!capability.ciphers.bit.des)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_CIPHER_ALG_3DES_CBC:
- if (!capability.ciphers.bit.trides_cbc)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_CIPHER_ALG_AES_CBC:
- if (!capability.ciphers.bit.aes_cbc)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_CIPHER_ALG_AES_CTR:
- if (!capability.ciphers.bit.aes_ctr)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_CIPHER_ALG_AES_GCM:
- if (!capability.ciphers.bit.aes_gcm)
- return ODP_TEST_INACTIVE;
- break;
- default:
- fprintf(stderr, "Unsupported cipher algorithm\n");
- return ODP_TEST_INACTIVE;
- }
-
- /* Authentication algorithms */
- switch (auth) {
- case ODP_AUTH_ALG_NULL:
- if (!capability.auths.bit.null)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_MD5_HMAC:
- if (!capability.auths.bit.md5_hmac)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_SHA1_HMAC:
- if (!capability.auths.bit.sha1_hmac)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_SHA256_HMAC:
- if (!capability.auths.bit.sha256_hmac)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_SHA512_HMAC:
- if (!capability.auths.bit.sha512_hmac)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_AES_GCM:
- if (!capability.auths.bit.aes_gcm)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_AES_GMAC:
- if (!capability.auths.bit.aes_gmac)
- return ODP_TEST_INACTIVE;
- break;
- default:
- fprintf(stderr, "Unsupported authentication algorithm\n");
- return ODP_TEST_INACTIVE;
- }
-
- return ODP_TEST_ACTIVE;
-}
-
-static int check_alg_null(void)
-{
- return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_NULL);
-}
-
-#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
-static void crypto_test_enc_alg_null(void)
-{
- check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_NULL,
- null_reference,
- ARRAY_SIZE(null_reference),
- false);
-}
-
-static void crypto_test_dec_alg_null(void)
-{
- check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_NULL,
- null_reference,
- ARRAY_SIZE(null_reference),
- false);
-}
-
-static int check_alg_3des_cbc(void)
-{
- return check_alg_support(ODP_CIPHER_ALG_3DES_CBC, ODP_AUTH_ALG_NULL);
-}
-
-/* This test verifies the correctness of encode (plaintext -> ciphertext)
- * operation for 3DES_CBC algorithm. IV for the operation is the session IV.
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.*/
-static void crypto_test_enc_alg_3des_cbc(void)
-{
- check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_3DES_CBC,
- ODP_AUTH_ALG_NULL,
- tdes_cbc_reference,
- ARRAY_SIZE(tdes_cbc_reference),
- false);
-}
-
-/* This test verifies the correctness of encode (plaintext -> ciphertext)
- * operation for 3DES_CBC algorithm. IV for the operation is the operation IV.
- * */
-static void crypto_test_enc_alg_3des_cbc_ovr_iv(void)
-{
- check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_3DES_CBC,
- ODP_AUTH_ALG_NULL,
- tdes_cbc_reference,
- ARRAY_SIZE(tdes_cbc_reference),
- true);
-}
-
-/* This test verifies the correctness of decode (ciphertext -> plaintext)
- * operation for 3DES_CBC algorithm. IV for the operation is the session IV
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.
- * */
-static void crypto_test_dec_alg_3des_cbc(void)
-{
- check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_3DES_CBC,
- ODP_AUTH_ALG_NULL,
- tdes_cbc_reference,
- ARRAY_SIZE(tdes_cbc_reference),
- false);
-}
-
-/* This test verifies the correctness of decode (ciphertext -> plaintext)
- * operation for 3DES_CBC algorithm. IV for the operation is the session IV
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.
- * */
-static void crypto_test_dec_alg_3des_cbc_ovr_iv(void)
-{
- check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_3DES_CBC,
- ODP_AUTH_ALG_NULL,
- tdes_cbc_reference,
- ARRAY_SIZE(tdes_cbc_reference),
- true);
-}
-
-static int check_alg_aes_gcm(void)
-{
- return check_alg_support(ODP_CIPHER_ALG_AES_GCM, ODP_AUTH_ALG_AES_GCM);
-}
-
-/* This test verifies the correctness of encode (plaintext -> ciphertext)
- * operation for AES128_GCM algorithm. IV for the operation is the session IV.
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.*/
-static void crypto_test_enc_alg_aes_gcm(void)
-{
- check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_AES_GCM,
- ODP_AUTH_ALG_AES_GCM,
- aes_gcm_reference,
- ARRAY_SIZE(aes_gcm_reference),
- false);
-}
-
-/* This test verifies the correctness of encode (plaintext -> ciphertext)
- * operation for AES128_GCM algorithm. IV for the operation is the session IV.
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.*/
-static void crypto_test_enc_alg_aes_gcm_ovr_iv(void)
-{
- check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_AES_GCM,
- ODP_AUTH_ALG_AES_GCM,
- aes_gcm_reference,
- ARRAY_SIZE(aes_gcm_reference),
- true);
-}
-
-/* This test verifies the correctness of decode (ciphertext -> plaintext)
- * operation for 3DES_CBC algorithm. IV for the operation is the session IV
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.
- * */
-static void crypto_test_dec_alg_aes_gcm(void)
-{
- check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_AES_GCM,
- ODP_AUTH_ALG_AES_GCM,
- aes_gcm_reference,
- ARRAY_SIZE(aes_gcm_reference),
- false);
-}
-
-/* This test verifies the correctness of decode (ciphertext -> plaintext)
- * operation for 3DES_CBC algorithm. IV for the operation is the session IV
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.
- * */
-static void crypto_test_dec_alg_aes_gcm_ovr_iv(void)
-{
- check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_AES_GCM,
- ODP_AUTH_ALG_AES_GCM,
- aes_gcm_reference,
- ARRAY_SIZE(aes_gcm_reference),
- true);
-}
-
-static int check_alg_aes_cbc(void)
-{
- return check_alg_support(ODP_CIPHER_ALG_AES_CBC, ODP_AUTH_ALG_NULL);
-}
-
-/* This test verifies the correctness of encode (plaintext -> ciphertext)
- * operation for AES128_CBC algorithm. IV for the operation is the session IV.
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.*/
-static void crypto_test_enc_alg_aes_cbc(void)
-{
- check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_AES_CBC,
- ODP_AUTH_ALG_NULL,
- aes_cbc_reference,
- ARRAY_SIZE(aes_cbc_reference),
- false);
-}
-
-/* This test verifies the correctness of encode (plaintext -> ciphertext)
- * operation for AES128_CBC algorithm. IV for the operation is the operation IV.
- * */
-static void crypto_test_enc_alg_aes_cbc_ovr_iv(void)
-{
- check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_AES_CBC,
- ODP_AUTH_ALG_NULL,
- aes_cbc_reference,
- ARRAY_SIZE(aes_cbc_reference),
- true);
-}
-
-/* This test verifies the correctness of decode (ciphertext -> plaintext)
- * operation for AES128_CBC algorithm. IV for the operation is the session IV
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.
- * */
-static void crypto_test_dec_alg_aes_cbc(void)
-{
- check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_AES_CBC,
- ODP_AUTH_ALG_NULL,
- aes_cbc_reference,
- ARRAY_SIZE(aes_cbc_reference),
- false);
-}
-
-/* This test verifies the correctness of decode (ciphertext -> plaintext)
- * operation for AES128_CBC algorithm. IV for the operation is the session IV
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.
- * */
-static void crypto_test_dec_alg_aes_cbc_ovr_iv(void)
-{
- check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_AES_CBC,
- ODP_AUTH_ALG_NULL,
- aes_cbc_reference,
- ARRAY_SIZE(aes_cbc_reference),
- true);
-}
-
-static int check_alg_aes_ctr(void)
-{
- return check_alg_support(ODP_CIPHER_ALG_AES_CTR, ODP_AUTH_ALG_NULL);
-}
-
-/* This test verifies the correctness of encode (plaintext -> ciphertext)
- * operation for AES128_CTR algorithm. IV for the operation is the session IV.
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.*/
-static void crypto_test_enc_alg_aes_ctr(void)
-{
- check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_AES_CTR,
- ODP_AUTH_ALG_NULL,
- aes_ctr_reference,
- ARRAY_SIZE(aes_ctr_reference),
- false);
-}
-
-/* This test verifies the correctness of encode (plaintext -> ciphertext)
- * operation for AES128_CTR algorithm. IV for the operation is the operation IV.
- * */
-static void crypto_test_enc_alg_aes_ctr_ovr_iv(void)
-{
- check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_AES_CTR,
- ODP_AUTH_ALG_NULL,
- aes_ctr_reference,
- ARRAY_SIZE(aes_ctr_reference),
- true);
-}
-
-/* This test verifies the correctness of decode (ciphertext -> plaintext)
- * operation for AES128_CTR algorithm. IV for the operation is the session IV
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.
- * */
-static void crypto_test_dec_alg_aes_ctr(void)
-{
- check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_AES_CTR,
- ODP_AUTH_ALG_NULL,
- aes_ctr_reference,
- ARRAY_SIZE(aes_ctr_reference),
- false);
-}
-
-/* This test verifies the correctness of decode (ciphertext -> plaintext)
- * operation for AES128_CTR algorithm. IV for the operation is the session IV
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.
- * */
-static void crypto_test_dec_alg_aes_ctr_ovr_iv(void)
-{
- check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_AES_CTR,
- ODP_AUTH_ALG_NULL,
- aes_ctr_reference,
- ARRAY_SIZE(aes_ctr_reference),
- true);
-}
-
-static int check_alg_hmac_md5(void)
-{
- return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_MD5_HMAC);
-}
-
-/* This test verifies the correctness of HMAC_MD5 digest operation.
- * The output check length is truncated to 12 bytes (96 bits) as
- * returned by the crypto operation API call.
- * Note that hash digest is a one-way operation.
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.
- * */
-static void crypto_test_gen_alg_hmac_md5(void)
-{
- check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_MD5_HMAC,
- hmac_md5_reference,
- ARRAY_SIZE(hmac_md5_reference),
- false);
-}
-
-static void crypto_test_check_alg_hmac_md5(void)
-{
- check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_MD5_HMAC,
- hmac_md5_reference,
- ARRAY_SIZE(hmac_md5_reference),
- false);
-}
-
-static int check_alg_hmac_sha1(void)
-{
- return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_SHA1_HMAC);
-}
-
-/* This test verifies the correctness of HMAC_SHA1 digest operation.
- * The output check length is truncated to 12 bytes (96 bits) as
- * returned by the crypto operation API call.
- * Note that hash digest is a one-way operation.
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.
- * */
-static void crypto_test_gen_alg_hmac_sha1(void)
-{
- check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA1_HMAC,
- hmac_sha1_reference,
- ARRAY_SIZE(hmac_sha1_reference),
- false);
-}
-
-static void crypto_test_check_alg_hmac_sha1(void)
-{
- check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA1_HMAC,
- hmac_sha1_reference,
- ARRAY_SIZE(hmac_sha1_reference),
- false);
-}
-
-static int check_alg_hmac_sha256(void)
-{
- return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_SHA256_HMAC);
-}
-
-/* This test verifies the correctness of HMAC_SHA256 digest operation.
- * The output check length is truncated to 16 bytes (128 bits) as
- * returned by the crypto operation API call.
- * Note that hash digest is a one-way operation.
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.
- * */
-static void crypto_test_gen_alg_hmac_sha256(void)
-{
- check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA256_HMAC,
- hmac_sha256_reference,
- ARRAY_SIZE(hmac_sha256_reference),
- false);
-}
-
-static void crypto_test_check_alg_hmac_sha256(void)
-{
- check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA256_HMAC,
- hmac_sha256_reference,
- ARRAY_SIZE(hmac_sha256_reference),
- false);
-}
-
-static int check_alg_hmac_sha512(void)
-{
- return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_SHA512_HMAC);
-}
-
-/* This test verifies the correctness of HMAC_SHA512 digest operation.
- * The output check length is truncated to 32 bytes (256 bits) as
- * returned by the crypto operation API call.
- * Note that hash digest is a one-way operation.
- * In addition the test verifies if the implementation can use the
- * packet buffer as completion event buffer.
- * */
-static void crypto_test_gen_alg_hmac_sha512(void)
-{
- check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA512_HMAC,
- hmac_sha512_reference,
- ARRAY_SIZE(hmac_sha512_reference),
- false);
-}
-
-static void crypto_test_check_alg_hmac_sha512(void)
-{
- check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA512_HMAC,
- hmac_sha512_reference,
- ARRAY_SIZE(hmac_sha512_reference),
- false);
-}
-
-static int check_alg_aes_gmac(void)
-{
- return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_AES_GMAC);
-}
-
-static void crypto_test_gen_alg_aes_gmac(void)
-{
- unsigned int test_vec_num = (sizeof(aes_gmac_reference) /
- sizeof(aes_gmac_reference[0]));
- unsigned int i;
-
- for (i = 0; i < test_vec_num; i++)
- check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_AES_GMAC,
- aes_gmac_reference,
- ARRAY_SIZE(aes_gmac_reference),
- false);
-}
-
-static void crypto_test_gen_alg_aes_gmac_ovr_iv(void)
-{
- unsigned int test_vec_num = (sizeof(aes_gmac_reference) /
- sizeof(aes_gmac_reference[0]));
- unsigned int i;
-
- for (i = 0; i < test_vec_num; i++)
- alg_test(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_AES_GMAC,
- &aes_gmac_reference[i],
- true);
-}
-
-static void crypto_test_check_alg_aes_gmac(void)
-{
- check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_AES_GMAC,
- aes_gmac_reference,
- ARRAY_SIZE(aes_gmac_reference),
- false);
-}
-
-static void crypto_test_check_alg_aes_gmac_ovr_iv(void)
-{
- unsigned int test_vec_num = (sizeof(aes_gmac_reference) /
- sizeof(aes_gmac_reference[0]));
- unsigned int i;
-
- for (i = 0; i < test_vec_num; i++)
- alg_test(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_AES_GMAC,
- &aes_gmac_reference[i],
- true);
-}
-
-int crypto_suite_sync_init(void)
-{
- suite_context.pool = odp_pool_lookup("packet_pool");
- if (suite_context.pool == ODP_POOL_INVALID)
- return -1;
-
- suite_context.queue = ODP_QUEUE_INVALID;
- suite_context.pref_mode = ODP_CRYPTO_SYNC;
- return 0;
-}
-
-int crypto_suite_async_init(void)
-{
- suite_context.pool = odp_pool_lookup("packet_pool");
- if (suite_context.pool == ODP_POOL_INVALID)
- return -1;
- suite_context.queue = odp_queue_lookup("crypto-out");
- if (suite_context.queue == ODP_QUEUE_INVALID)
- return -1;
-
- suite_context.pref_mode = ODP_CRYPTO_ASYNC;
- return 0;
-}
-
-int crypto_suite_packet_sync_init(void)
-{
- suite_context.packet = true;
- suite_context.op_mode = ODP_CRYPTO_SYNC;
-
- suite_context.pool = odp_pool_lookup("packet_pool");
- if (suite_context.pool == ODP_POOL_INVALID)
- return -1;
-
- suite_context.queue = ODP_QUEUE_INVALID;
- return 0;
-}
-
-int crypto_suite_packet_async_init(void)
-{
- suite_context.packet = true;
- suite_context.op_mode = ODP_CRYPTO_ASYNC;
-
- suite_context.pool = odp_pool_lookup("packet_pool");
- if (suite_context.pool == ODP_POOL_INVALID)
- return -1;
-
- suite_context.queue = odp_queue_lookup("crypto-out");
- if (suite_context.queue == ODP_QUEUE_INVALID)
- return -1;
- return 0;
-}
-
-odp_testinfo_t crypto_suite[] = {
- ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_null,
- check_alg_null),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_null,
- check_alg_null),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_3des_cbc,
- check_alg_3des_cbc),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_3des_cbc,
- check_alg_3des_cbc),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_3des_cbc_ovr_iv,
- check_alg_3des_cbc),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_3des_cbc_ovr_iv,
- check_alg_3des_cbc),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_cbc,
- check_alg_aes_cbc),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_cbc,
- check_alg_aes_cbc),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_cbc_ovr_iv,
- check_alg_aes_cbc),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_cbc_ovr_iv,
- check_alg_aes_cbc),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_ctr,
- check_alg_aes_ctr),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_ctr,
- check_alg_aes_ctr),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_ctr_ovr_iv,
- check_alg_aes_ctr),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_ctr_ovr_iv,
- check_alg_aes_ctr),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_gcm,
- check_alg_aes_gcm),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_gcm_ovr_iv,
- check_alg_aes_gcm),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_gcm,
- check_alg_aes_gcm),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_gcm_ovr_iv,
- check_alg_aes_gcm),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_hmac_md5,
- check_alg_hmac_md5),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_hmac_md5,
- check_alg_hmac_md5),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_hmac_sha1,
- check_alg_hmac_sha1),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_hmac_sha1,
- check_alg_hmac_sha1),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_hmac_sha256,
- check_alg_hmac_sha256),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_hmac_sha256,
- check_alg_hmac_sha256),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_hmac_sha512,
- check_alg_hmac_sha512),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_hmac_sha512,
- check_alg_hmac_sha512),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_aes_gmac,
- check_alg_aes_gmac),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_aes_gmac_ovr_iv,
- check_alg_aes_gmac),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_aes_gmac,
- check_alg_aes_gmac),
- ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_aes_gmac_ovr_iv,
- check_alg_aes_gmac),
- ODP_TEST_INFO_NULL,
-};
-
-int crypto_suite_term(void)
-{
- int i;
- int first = 1;
-
- for (i = 0; crypto_suite[i].pName; i++) {
- if (crypto_suite[i].check_active &&
- crypto_suite[i].check_active() == ODP_TEST_INACTIVE) {
- if (first) {
- first = 0;
- printf("\n\n Inactive tests:\n");
- }
- printf(" %s\n", crypto_suite[i].pName);
- }
- }
- return 0;
-}
+/* Copyright (c) 2014-2018, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "config.h"
+
+#include <odp_api.h>
+#include <CUnit/Basic.h>
+#include <odp_cunit_common.h>
+#include "test_vectors.h"
+#include "odp_crypto_test_inp.h"
+#include "crypto.h"
+
+#define MAX_ALG_CAPA 32
+
+struct suite_context_s {
+ odp_bool_t packet;
+ odp_crypto_op_mode_t op_mode;
+ odp_crypto_op_mode_t pref_mode;
+ odp_pool_t pool;
+ odp_queue_t queue;
+};
+
+static struct suite_context_s suite_context;
+
+static int packet_cmp_mem(odp_packet_t pkt, uint32_t offset,
+ void *s, uint32_t len)
+{
+ uint8_t buf[len];
+
+ odp_packet_copy_to_mem(pkt, offset, len, buf);
+
+ return memcmp(buf, s, len);
+}
+
+static const char *auth_alg_name(odp_auth_alg_t auth)
+{
+ switch (auth) {
+ case ODP_AUTH_ALG_NULL:
+ return "ODP_AUTH_ALG_NULL";
+ case ODP_AUTH_ALG_MD5_HMAC:
+ return "ODP_AUTH_ALG_MD5_HMAC";
+ case ODP_AUTH_ALG_SHA1_HMAC:
+ return "ODP_AUTH_ALG_SHA1_HMAC";
+ case ODP_AUTH_ALG_SHA256_HMAC:
+ return "ODP_AUTH_ALG_SHA256_HMAC";
+ case ODP_AUTH_ALG_SHA512_HMAC:
+ return "ODP_AUTH_ALG_SHA512_HMAC";
+ case ODP_AUTH_ALG_AES_GCM:
+ return "ODP_AUTH_ALG_AES_GCM";
+ case ODP_AUTH_ALG_AES_GMAC:
+ return "ODP_AUTH_ALG_AES_GMAC";
+ default:
+ return "Unknown";
+ }
+}
+
+static const char *cipher_alg_name(odp_cipher_alg_t cipher)
+{
+ switch (cipher) {
+ case ODP_CIPHER_ALG_NULL:
+ return "ODP_CIPHER_ALG_NULL";
+ case ODP_CIPHER_ALG_DES:
+ return "ODP_CIPHER_ALG_DES";
+ case ODP_CIPHER_ALG_3DES_CBC:
+ return "ODP_CIPHER_ALG_3DES_CBC";
+ case ODP_CIPHER_ALG_AES_CBC:
+ return "ODP_CIPHER_ALG_AES_CBC";
+ case ODP_CIPHER_ALG_AES_GCM:
+ return "ODP_CIPHER_ALG_AES_GCM";
+ default:
+ return "Unknown";
+ }
+}
+
+static int alg_op(odp_packet_t pkt,
+ odp_bool_t *ok,
+ odp_crypto_session_t session,
+ uint8_t *cipher_iv_ptr,
+ uint8_t *auth_iv_ptr,
+ odp_packet_data_range_t *cipher_range,
+ odp_packet_data_range_t *auth_range,
+ uint8_t *aad,
+ unsigned int plaintext_len)
+{
+ int rc;
+ odp_crypto_op_result_t result;
+ odp_crypto_op_param_t op_params;
+ odp_bool_t posted;
+ odp_event_subtype_t subtype;
+
+ /* Prepare input/output 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;
+
+ op_params.cipher_range = *cipher_range;
+ op_params.auth_range = *auth_range;
+ if (cipher_iv_ptr)
+ op_params.cipher_iv_ptr = cipher_iv_ptr;
+ if (auth_iv_ptr)
+ op_params.auth_iv_ptr = auth_iv_ptr;
+
+ op_params.aad_ptr = aad;
+
+ op_params.hash_result_offset = plaintext_len;
+
+ rc = odp_crypto_operation(&op_params, &posted, &result);
+ if (rc < 0) {
+ CU_FAIL("Failed odp_crypto_operation()");
+ return rc;
+ }
+
+ if (posted) {
+ odp_event_t event;
+ odp_crypto_compl_t compl_event;
+
+ /* Poll completion queue for results */
+ do {
+ event = odp_queue_deq(suite_context.queue);
+ } while (event == ODP_EVENT_INVALID);
+
+ CU_ASSERT(ODP_EVENT_CRYPTO_COMPL == odp_event_type(event));
+ CU_ASSERT(ODP_EVENT_NO_SUBTYPE == odp_event_subtype(event));
+ CU_ASSERT(ODP_EVENT_CRYPTO_COMPL ==
+ odp_event_types(event, &subtype));
+ CU_ASSERT(ODP_EVENT_NO_SUBTYPE == subtype);
+
+ 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.pkt == pkt);
+ CU_ASSERT(result.ctx == (void *)0xdeadbeef);
+ CU_ASSERT(ODP_EVENT_PACKET ==
+ odp_event_type(odp_packet_to_event(result.pkt)));
+ CU_ASSERT(ODP_EVENT_PACKET_BASIC ==
+ odp_event_subtype(odp_packet_to_event(result.pkt)));
+ CU_ASSERT(ODP_EVENT_PACKET ==
+ odp_event_types(odp_packet_to_event(result.pkt), &subtype));
+ CU_ASSERT(ODP_EVENT_PACKET_BASIC == subtype);
+
+ *ok = result.ok;
+
+ return 0;
+}
+
+static int alg_packet_op(odp_packet_t pkt,
+ odp_bool_t *ok,
+ odp_crypto_session_t session,
+ uint8_t *cipher_iv_ptr,
+ uint8_t *auth_iv_ptr,
+ odp_packet_data_range_t *cipher_range,
+ odp_packet_data_range_t *auth_range,
+ uint8_t *aad,
+ unsigned int plaintext_len)
+{
+ int rc;
+ odp_crypto_packet_result_t result;
+ odp_crypto_packet_op_param_t op_params;
+ odp_event_subtype_t subtype;
+ odp_packet_t out_pkt = pkt;
+
+ /* Prepare input/output params */
+ memset(&op_params, 0, sizeof(op_params));
+ op_params.session = session;
+
+ op_params.cipher_range = *cipher_range;
+ op_params.auth_range = *auth_range;
+ if (cipher_iv_ptr)
+ op_params.cipher_iv_ptr = cipher_iv_ptr;
+ if (auth_iv_ptr)
+ op_params.auth_iv_ptr = auth_iv_ptr;
+
+ op_params.aad_ptr = aad;
+
+ op_params.hash_result_offset = plaintext_len;
+
+ rc = odp_crypto_op(&pkt, &out_pkt, &op_params, 1);
+ if (rc < 0) {
+ CU_FAIL("Failed odp_crypto_packet_op()");
+ return rc;
+ }
+
+ CU_ASSERT(out_pkt == pkt);
+ CU_ASSERT(ODP_EVENT_PACKET ==
+ odp_event_type(odp_packet_to_event(pkt)));
+ CU_ASSERT(ODP_EVENT_PACKET_CRYPTO ==
+ odp_event_subtype(odp_packet_to_event(pkt)));
+ CU_ASSERT(ODP_EVENT_PACKET ==
+ odp_event_types(odp_packet_to_event(pkt), &subtype));
+ CU_ASSERT(ODP_EVENT_PACKET_CRYPTO == subtype);
+
+ rc = odp_crypto_result(&result, pkt);
+ if (rc < 0) {
+ CU_FAIL("Failed odp_crypto_packet_result()");
+ return rc;
+ }
+
+ if (!result.ok)
+ CU_ASSERT(odp_packet_has_error(pkt));
+
+ *ok = result.ok;
+
+ return 0;
+}
+
+static int alg_packet_op_enq(odp_packet_t pkt,
+ odp_bool_t *ok,
+ odp_crypto_session_t session,
+ uint8_t *cipher_iv_ptr,
+ uint8_t *auth_iv_ptr,
+ odp_packet_data_range_t *cipher_range,
+ odp_packet_data_range_t *auth_range,
+ uint8_t *aad,
+ unsigned int plaintext_len)
+{
+ int rc;
+ odp_event_t event;
+ odp_crypto_packet_result_t result;
+ odp_crypto_packet_op_param_t op_params;
+ odp_event_subtype_t subtype;
+ odp_packet_t out_pkt = pkt;
+
+ /* Prepare input/output params */
+ memset(&op_params, 0, sizeof(op_params));
+ op_params.session = session;
+
+ op_params.cipher_range = *cipher_range;
+ op_params.auth_range = *auth_range;
+ if (cipher_iv_ptr)
+ op_params.cipher_iv_ptr = cipher_iv_ptr;
+ if (auth_iv_ptr)
+ op_params.auth_iv_ptr = auth_iv_ptr;
+
+ op_params.aad_ptr = aad;
+
+ op_params.hash_result_offset = plaintext_len;
+
+ rc = odp_crypto_op_enq(&pkt, &pkt, &op_params, 1);
+ if (rc < 0) {
+ CU_FAIL("Failed odp_crypto_op_enq()");
+ return rc;
+ }
+
+ /* Poll completion queue for results */
+ do {
+ event = odp_queue_deq(suite_context.queue);
+ } while (event == ODP_EVENT_INVALID);
+
+ CU_ASSERT(ODP_EVENT_PACKET == odp_event_type(event));
+ CU_ASSERT(ODP_EVENT_PACKET_CRYPTO == odp_event_subtype(event));
+ CU_ASSERT(ODP_EVENT_PACKET == odp_event_types(event, &subtype));
+ CU_ASSERT(ODP_EVENT_PACKET_CRYPTO == subtype);
+
+ pkt = odp_crypto_packet_from_event(event);
+
+ CU_ASSERT(out_pkt == pkt);
+ CU_ASSERT(ODP_EVENT_PACKET ==
+ odp_event_type(odp_packet_to_event(pkt)));
+ CU_ASSERT(ODP_EVENT_PACKET_CRYPTO ==
+ odp_event_subtype(odp_packet_to_event(pkt)));
+ CU_ASSERT(ODP_EVENT_PACKET ==
+ odp_event_types(odp_packet_to_event(pkt), &subtype));
+ CU_ASSERT(ODP_EVENT_PACKET_CRYPTO == subtype);
+
+ rc = odp_crypto_result(&result, pkt);
+ if (rc < 0) {
+ CU_FAIL("Failed odp_crypto_packet_result()");
+ return rc;
+ }
+
+ CU_ASSERT((!odp_packet_has_error(pkt)) == result.ok);
+
+ *ok = result.ok;
+
+ return 0;
+}
+
+typedef enum crypto_test {
+ NORMAL_TEST = 0, /**< Plain execution */
+ REPEAT_TEST, /**< Rerun without reinitializing the session */
+ WRONG_DIGEST_TEST, /**< Check against wrong digest */
+ MAX_TEST, /**< Final mark */
+} crypto_test;
+
+/* 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_auth_alg_t auth_alg,
+ crypto_test_reference_t *ref,
+ odp_bool_t ovr_iv)
+{
+ odp_crypto_session_t session;
+ int rc;
+ odp_crypto_ses_create_err_t status;
+ odp_bool_t ok = false;
+ int iteration;
+ odp_crypto_session_param_t ses_params;
+ odp_packet_data_range_t cipher_range;
+ odp_packet_data_range_t auth_range;
+ odp_crypto_key_t cipher_key = {
+ .data = ref->cipher_key,
+ .length = ref->cipher_key_length
+ };
+ odp_crypto_key_t auth_key = {
+ .data = ref->auth_key,
+ .length = ref->auth_key_length
+ };
+ odp_crypto_iv_t cipher_iv = {
+ .data = ovr_iv ? NULL : ref->cipher_iv,
+ .length = ref->cipher_iv_length
+ };
+ odp_crypto_iv_t auth_iv = {
+ .data = ovr_iv ? NULL : ref->auth_iv,
+ .length = ref->auth_iv_length
+ };
+
+ /* Create a crypto session */
+ odp_crypto_session_param_init(&ses_params);
+ ses_params.op = op;
+ ses_params.auth_cipher_text = false;
+ ses_params.op_mode = suite_context.op_mode;
+ 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.cipher_iv = cipher_iv;
+ ses_params.auth_iv = auth_iv;
+ ses_params.auth_key = auth_key;
+ ses_params.auth_digest_len = ref->digest_length;
+ ses_params.auth_aad_len = ref->aad_length;
+
+ 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));
+
+ cipher_range.offset = 0;
+ cipher_range.length = ref->length;
+ auth_range.offset = 0;
+ auth_range.length = ref->length;
+
+ /* Prepare input data */
+ odp_packet_t pkt = odp_packet_alloc(suite_context.pool,
+ ref->length + ref->digest_length);
+ CU_ASSERT(pkt != ODP_PACKET_INVALID);
+ if (pkt == ODP_PACKET_INVALID)
+ goto cleanup;
+
+ for (iteration = NORMAL_TEST; iteration < MAX_TEST; iteration++) {
+ /* checking against wrong digest is meaningless for NULL digest
+ * or when generating digest */
+ if (iteration == WRONG_DIGEST_TEST &&
+ (auth_alg == ODP_AUTH_ALG_NULL ||
+ op == ODP_CRYPTO_OP_ENCODE))
+ continue;
+
+ if (op == ODP_CRYPTO_OP_ENCODE) {
+ odp_packet_copy_from_mem(pkt, 0, ref->length,
+ ref->plaintext);
+ } else {
+ odp_packet_copy_from_mem(pkt, 0, ref->length,
+ ref->ciphertext);
+ odp_packet_copy_from_mem(pkt, ref->length,
+ ref->digest_length,
+ ref->digest);
+ if (iteration == WRONG_DIGEST_TEST) {
+ uint8_t byte = ~ref->digest[0];
+
+ odp_packet_copy_from_mem(pkt, ref->length,
+ 1, &byte);
+ }
+ }
+
+ if (!suite_context.packet)
+ rc = alg_op(pkt, &ok, session,
+ ovr_iv ? ref->cipher_iv : NULL,
+ ovr_iv ? ref->auth_iv : NULL,
+ &cipher_range, &auth_range,
+ ref->aad, ref->length);
+ else if (ODP_CRYPTO_ASYNC == suite_context.op_mode)
+ rc = alg_packet_op_enq(pkt, &ok, session,
+ ovr_iv ? ref->cipher_iv : NULL,
+ ovr_iv ? ref->auth_iv : NULL,
+ &cipher_range, &auth_range,
+ ref->aad, ref->length);
+ else
+ rc = alg_packet_op(pkt, &ok, session,
+ ovr_iv ? ref->cipher_iv : NULL,
+ ovr_iv ? ref->auth_iv : NULL,
+ &cipher_range, &auth_range,
+ ref->aad, ref->length);
+ if (rc < 0)
+ break;
+
+ if (iteration == WRONG_DIGEST_TEST) {
+ CU_ASSERT(!ok);
+ continue;
+ }
+
+ CU_ASSERT(ok);
+
+ if (op == ODP_CRYPTO_OP_ENCODE) {
+ CU_ASSERT(!packet_cmp_mem(pkt, 0,
+ ref->ciphertext,
+ ref->length));
+ CU_ASSERT(!packet_cmp_mem(pkt, ref->length,
+ ref->digest,
+ ref->digest_length));
+ } else {
+ CU_ASSERT(!packet_cmp_mem(pkt, 0,
+ ref->plaintext,
+ ref->length));
+ }
+ }
+
+ odp_packet_free(pkt);
+
+cleanup:
+ rc = odp_crypto_session_destroy(session);
+ CU_ASSERT(!rc);
+}
+
+static void check_alg(odp_crypto_op_t op,
+ odp_cipher_alg_t cipher_alg,
+ odp_auth_alg_t auth_alg,
+ crypto_test_reference_t *ref,
+ size_t count,
+ odp_bool_t ovr_iv)
+{
+ odp_crypto_capability_t capa;
+ odp_crypto_cipher_capability_t cipher_capa[MAX_ALG_CAPA];
+ odp_crypto_auth_capability_t auth_capa[MAX_ALG_CAPA];
+ int rc, cipher_num, auth_num, i;
+ odp_bool_t cipher_tested[MAX_ALG_CAPA];
+ odp_bool_t auth_tested[MAX_ALG_CAPA];
+ odp_bool_t cipher_ok = false;
+ odp_bool_t auth_ok = false;
+ size_t idx;
+
+ rc = odp_crypto_capability(&capa);
+ CU_ASSERT(!rc);
+
+ if (cipher_alg == ODP_CIPHER_ALG_3DES_CBC &&
+ !(capa.ciphers.bit.trides_cbc))
+ rc = -1;
+ if (cipher_alg == ODP_CIPHER_ALG_AES_CBC &&
+ !(capa.ciphers.bit.aes_cbc))
+ rc = -1;
+ if (cipher_alg == ODP_CIPHER_ALG_AES_CTR &&
+ !(capa.ciphers.bit.aes_ctr))
+ rc = -1;
+ if (cipher_alg == ODP_CIPHER_ALG_AES_GCM &&
+ !(capa.ciphers.bit.aes_gcm))
+ rc = -1;
+ if (cipher_alg == ODP_CIPHER_ALG_DES &&
+ !(capa.ciphers.bit.des))
+ rc = -1;
+ if (cipher_alg == ODP_CIPHER_ALG_NULL &&
+ !(capa.ciphers.bit.null))
+ rc = -1;
+
+ CU_ASSERT(!rc);
+ CU_ASSERT((~capa.ciphers.all_bits & capa.hw_ciphers.all_bits) == 0);
+
+ if (auth_alg == ODP_AUTH_ALG_AES_GCM &&
+ !(capa.auths.bit.aes_gcm))
+ rc = -1;
+ if (auth_alg == ODP_AUTH_ALG_AES_GMAC &&
+ !(capa.auths.bit.aes_gmac))
+ rc = -1;
+ if (auth_alg == ODP_AUTH_ALG_MD5_HMAC &&
+ !(capa.auths.bit.md5_hmac))
+ rc = -1;
+ if (auth_alg == ODP_AUTH_ALG_NULL &&
+ !(capa.auths.bit.null))
+ rc = -1;
+ if (auth_alg == ODP_AUTH_ALG_SHA1_HMAC &&
+ !(capa.auths.bit.sha1_hmac))
+ rc = -1;
+ if (auth_alg == ODP_AUTH_ALG_SHA256_HMAC &&
+ !(capa.auths.bit.sha256_hmac))
+ rc = -1;
+ if (auth_alg == ODP_AUTH_ALG_SHA512_HMAC &&
+ !(capa.auths.bit.sha512_hmac))
+ rc = -1;
+
+ CU_ASSERT(!rc);
+ CU_ASSERT((~capa.auths.all_bits & capa.hw_auths.all_bits) == 0);
+
+ cipher_num = odp_crypto_cipher_capability(cipher_alg, cipher_capa,
+ MAX_ALG_CAPA);
+
+ CU_ASSERT(cipher_num > 0);
+ CU_ASSERT(cipher_num <= MAX_ALG_CAPA);
+ if (cipher_num > MAX_ALG_CAPA)
+ cipher_num = MAX_ALG_CAPA;
+
+ auth_num = odp_crypto_auth_capability(auth_alg, auth_capa,
+ MAX_ALG_CAPA);
+
+ CU_ASSERT(auth_num > 0);
+ CU_ASSERT(auth_num <= MAX_ALG_CAPA);
+ if (auth_num > MAX_ALG_CAPA)
+ auth_num = MAX_ALG_CAPA;
+
+ memset(cipher_tested, 0, sizeof(cipher_tested));
+ memset(auth_tested, 0, sizeof(auth_tested));
+
+ for (idx = 0; idx < count; idx++) {
+ int cipher_idx = -1, auth_idx = -1;
+
+ for (i = 0; i < cipher_num; i++) {
+ if (cipher_capa[i].key_len ==
+ ref[idx].cipher_key_length &&
+ cipher_capa[i].iv_len ==
+ ref[idx].cipher_iv_length) {
+ cipher_idx = i;
+ break;
+ }
+ }
+
+ if (cipher_idx < 0) {
+ printf("\n Unsupported: alg=%s, key_len=%" PRIu32
+ ", iv_len=%" PRIu32 "\n",
+ cipher_alg_name(cipher_alg),
+ ref[idx].cipher_key_length,
+ ref[idx].cipher_iv_length);
+ continue;
+ }
+
+ for (i = 0; i < auth_num; i++) {
+ if (auth_capa[i].digest_len ==
+ ref[idx].digest_length &&
+ auth_capa[i].iv_len ==
+ ref[idx].auth_iv_length &&
+ auth_capa[i].key_len ==
+ ref[idx].auth_key_length) {
+ auth_idx = i;
+ break;
+ }
+ }
+
+ if (auth_idx < 0) {
+ printf("\n Unsupported: alg=%s, key_len=%" PRIu32
+ ", iv_len=%" PRIu32 ", digest_len=%" PRIu32 "\n",
+ auth_alg_name(auth_alg),
+ ref[idx].auth_key_length,
+ ref[idx].auth_iv_length,
+ ref[idx].digest_length);
+ continue;
+ }
+
+ alg_test(op, cipher_alg, auth_alg, &ref[idx], ovr_iv);
+
+ cipher_tested[cipher_idx] = true;
+ auth_tested[auth_idx] = true;
+ }
+
+ for (i = 0; i < cipher_num; i++) {
+ cipher_ok |= cipher_tested[i];
+ if (!cipher_tested[i]) {
+ /* GMAC-related hacks */
+ if (cipher_alg == ODP_CIPHER_ALG_NULL)
+ continue;
+ printf("\n Untested: alg=%s, key_len=%" PRIu32 ", "
+ "iv_len=%" PRIu32 "\n",
+ cipher_alg_name(cipher_alg),
+ cipher_capa[i].key_len,
+ cipher_capa[i].iv_len);
+ }
+ }
+
+ for (i = 0; i < auth_num; i++) {
+ auth_ok |= auth_tested[i];
+ if (!auth_tested[i])
+ printf("\n Untested: alg=%s, key_len=%" PRIu32 ", "
+ "digest_len=%" PRIu32 "\n",
+ auth_alg_name(auth_alg),
+ auth_capa[i].key_len,
+ auth_capa[i].digest_len);
+ }
+
+ /* Verify that we were able to run at least several tests */
+ CU_ASSERT(cipher_ok);
+ CU_ASSERT(auth_ok);
+}
+
+/**
+ * Check if given cipher and authentication algorithms are supported
+ *
+ * @param cipher Cipher algorithm
+ * @param auth Authentication algorithm
+ *
+ * @retval ODP_TEST_ACTIVE when both algorithms are supported
+ * @retval ODP_TEST_INACTIVE when either algorithm is not supported
+ */
+static int check_alg_support(odp_cipher_alg_t cipher, odp_auth_alg_t auth)
+{
+ odp_crypto_capability_t capability;
+
+ if (odp_crypto_capability(&capability))
+ return ODP_TEST_INACTIVE;
+
+ if (suite_context.packet) {
+ if (suite_context.op_mode == ODP_CRYPTO_SYNC &&
+ capability.sync_mode == ODP_SUPPORT_NO)
+ return ODP_TEST_INACTIVE;
+ if (suite_context.op_mode == ODP_CRYPTO_ASYNC &&
+ capability.async_mode == ODP_SUPPORT_NO)
+ return ODP_TEST_INACTIVE;
+ }
+
+ /* Cipher algorithms */
+ switch (cipher) {
+ case ODP_CIPHER_ALG_NULL:
+ if (!capability.ciphers.bit.null)
+ return ODP_TEST_INACTIVE;
+ break;
+ case ODP_CIPHER_ALG_DES:
+ if (!capability.ciphers.bit.des)
+ return ODP_TEST_INACTIVE;
+ break;
+ case ODP_CIPHER_ALG_3DES_CBC:
+ if (!capability.ciphers.bit.trides_cbc)
+ return ODP_TEST_INACTIVE;
+ break;
+ case ODP_CIPHER_ALG_AES_CBC:
+ if (!capability.ciphers.bit.aes_cbc)
+ return ODP_TEST_INACTIVE;
+ break;
+ case ODP_CIPHER_ALG_AES_CTR:
+ if (!capability.ciphers.bit.aes_ctr)
+ return ODP_TEST_INACTIVE;
+ break;
+ case ODP_CIPHER_ALG_AES_GCM:
+ if (!capability.ciphers.bit.aes_gcm)
+ return ODP_TEST_INACTIVE;
+ break;
+ default:
+ fprintf(stderr, "Unsupported cipher algorithm\n");
+ return ODP_TEST_INACTIVE;
+ }
+
+ /* Authentication algorithms */
+ switch (auth) {
+ case ODP_AUTH_ALG_NULL:
+ if (!capability.auths.bit.null)
+ return ODP_TEST_INACTIVE;
+ break;
+ case ODP_AUTH_ALG_MD5_HMAC:
+ if (!capability.auths.bit.md5_hmac)
+ return ODP_TEST_INACTIVE;
+ break;
+ case ODP_AUTH_ALG_SHA1_HMAC:
+ if (!capability.auths.bit.sha1_hmac)
+ return ODP_TEST_INACTIVE;
+ break;
+ case ODP_AUTH_ALG_SHA256_HMAC:
+ if (!capability.auths.bit.sha256_hmac)
+ return ODP_TEST_INACTIVE;
+ break;
+ case ODP_AUTH_ALG_SHA512_HMAC:
+ if (!capability.auths.bit.sha512_hmac)
+ return ODP_TEST_INACTIVE;
+ break;
+ case ODP_AUTH_ALG_AES_GCM:
+ if (!capability.auths.bit.aes_gcm)
+ return ODP_TEST_INACTIVE;
+ break;
+ case ODP_AUTH_ALG_AES_GMAC:
+ if (!capability.auths.bit.aes_gmac)
+ return ODP_TEST_INACTIVE;
+ break;
+ default:
+ fprintf(stderr, "Unsupported authentication algorithm\n");
+ return ODP_TEST_INACTIVE;
+ }
+
+ return ODP_TEST_ACTIVE;
+}
+
+static int check_alg_null(void)
+{
+ return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_NULL);
+}
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
+static void crypto_test_enc_alg_null(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_NULL,
+ null_reference,
+ ARRAY_SIZE(null_reference),
+ false);
+}
+
+static void crypto_test_dec_alg_null(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_NULL,
+ null_reference,
+ ARRAY_SIZE(null_reference),
+ false);
+}
+
+static int check_alg_3des_cbc(void)
+{
+ return check_alg_support(ODP_CIPHER_ALG_3DES_CBC, ODP_AUTH_ALG_NULL);
+}
+
+/* This test verifies the correctness of encode (plaintext -> ciphertext)
+ * operation for 3DES_CBC algorithm. IV for the operation is the session IV.
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.*/
+static void crypto_test_enc_alg_3des_cbc(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_3DES_CBC,
+ ODP_AUTH_ALG_NULL,
+ tdes_cbc_reference,
+ ARRAY_SIZE(tdes_cbc_reference),
+ false);
+}
+
+/* This test verifies the correctness of encode (plaintext -> ciphertext)
+ * operation for 3DES_CBC algorithm. IV for the operation is the operation IV.
+ * */
+static void crypto_test_enc_alg_3des_cbc_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_3DES_CBC,
+ ODP_AUTH_ALG_NULL,
+ tdes_cbc_reference,
+ ARRAY_SIZE(tdes_cbc_reference),
+ true);
+}
+
+/* This test verifies the correctness of decode (ciphertext -> plaintext)
+ * operation for 3DES_CBC algorithm. IV for the operation is the session IV
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.
+ * */
+static void crypto_test_dec_alg_3des_cbc(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_3DES_CBC,
+ ODP_AUTH_ALG_NULL,
+ tdes_cbc_reference,
+ ARRAY_SIZE(tdes_cbc_reference),
+ false);
+}
+
+/* This test verifies the correctness of decode (ciphertext -> plaintext)
+ * operation for 3DES_CBC algorithm. IV for the operation is the session IV
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.
+ * */
+static void crypto_test_dec_alg_3des_cbc_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_3DES_CBC,
+ ODP_AUTH_ALG_NULL,
+ tdes_cbc_reference,
+ ARRAY_SIZE(tdes_cbc_reference),
+ true);
+}
+
+static int check_alg_aes_gcm(void)
+{
+ return check_alg_support(ODP_CIPHER_ALG_AES_GCM, ODP_AUTH_ALG_AES_GCM);
+}
+
+/* This test verifies the correctness of encode (plaintext -> ciphertext)
+ * operation for AES128_GCM algorithm. IV for the operation is the session IV.
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.*/
+static void crypto_test_enc_alg_aes_gcm(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_AES_GCM,
+ ODP_AUTH_ALG_AES_GCM,
+ aes_gcm_reference,
+ ARRAY_SIZE(aes_gcm_reference),
+ false);
+}
+
+/* This test verifies the correctness of encode (plaintext -> ciphertext)
+ * operation for AES128_GCM algorithm. IV for the operation is the session IV.
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.*/
+static void crypto_test_enc_alg_aes_gcm_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_AES_GCM,
+ ODP_AUTH_ALG_AES_GCM,
+ aes_gcm_reference,
+ ARRAY_SIZE(aes_gcm_reference),
+ true);
+}
+
+/* This test verifies the correctness of decode (ciphertext -> plaintext)
+ * operation for 3DES_CBC algorithm. IV for the operation is the session IV
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.
+ * */
+static void crypto_test_dec_alg_aes_gcm(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_AES_GCM,
+ ODP_AUTH_ALG_AES_GCM,
+ aes_gcm_reference,
+ ARRAY_SIZE(aes_gcm_reference),
+ false);
+}
+
+/* This test verifies the correctness of decode (ciphertext -> plaintext)
+ * operation for 3DES_CBC algorithm. IV for the operation is the session IV
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.
+ * */
+static void crypto_test_dec_alg_aes_gcm_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_AES_GCM,
+ ODP_AUTH_ALG_AES_GCM,
+ aes_gcm_reference,
+ ARRAY_SIZE(aes_gcm_reference),
+ true);
+}
+
+static int check_alg_aes_cbc(void)
+{
+ return check_alg_support(ODP_CIPHER_ALG_AES_CBC, ODP_AUTH_ALG_NULL);
+}
+
+/* This test verifies the correctness of encode (plaintext -> ciphertext)
+ * operation for AES128_CBC algorithm. IV for the operation is the session IV.
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.*/
+static void crypto_test_enc_alg_aes_cbc(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_AES_CBC,
+ ODP_AUTH_ALG_NULL,
+ aes_cbc_reference,
+ ARRAY_SIZE(aes_cbc_reference),
+ false);
+}
+
+/* This test verifies the correctness of encode (plaintext -> ciphertext)
+ * operation for AES128_CBC algorithm. IV for the operation is the operation IV.
+ * */
+static void crypto_test_enc_alg_aes_cbc_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_AES_CBC,
+ ODP_AUTH_ALG_NULL,
+ aes_cbc_reference,
+ ARRAY_SIZE(aes_cbc_reference),
+ true);
+}
+
+/* This test verifies the correctness of decode (ciphertext -> plaintext)
+ * operation for AES128_CBC algorithm. IV for the operation is the session IV
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.
+ * */
+static void crypto_test_dec_alg_aes_cbc(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_AES_CBC,
+ ODP_AUTH_ALG_NULL,
+ aes_cbc_reference,
+ ARRAY_SIZE(aes_cbc_reference),
+ false);
+}
+
+/* This test verifies the correctness of decode (ciphertext -> plaintext)
+ * operation for AES128_CBC algorithm. IV for the operation is the session IV
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.
+ * */
+static void crypto_test_dec_alg_aes_cbc_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_AES_CBC,
+ ODP_AUTH_ALG_NULL,
+ aes_cbc_reference,
+ ARRAY_SIZE(aes_cbc_reference),
+ true);
+}
+
+static int check_alg_aes_ctr(void)
+{
+ return check_alg_support(ODP_CIPHER_ALG_AES_CTR, ODP_AUTH_ALG_NULL);
+}
+
+/* This test verifies the correctness of encode (plaintext -> ciphertext)
+ * operation for AES128_CTR algorithm. IV for the operation is the session IV.
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.*/
+static void crypto_test_enc_alg_aes_ctr(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_AES_CTR,
+ ODP_AUTH_ALG_NULL,
+ aes_ctr_reference,
+ ARRAY_SIZE(aes_ctr_reference),
+ false);
+}
+
+/* This test verifies the correctness of encode (plaintext -> ciphertext)
+ * operation for AES128_CTR algorithm. IV for the operation is the operation IV.
+ * */
+static void crypto_test_enc_alg_aes_ctr_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_AES_CTR,
+ ODP_AUTH_ALG_NULL,
+ aes_ctr_reference,
+ ARRAY_SIZE(aes_ctr_reference),
+ true);
+}
+
+/* This test verifies the correctness of decode (ciphertext -> plaintext)
+ * operation for AES128_CTR algorithm. IV for the operation is the session IV
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.
+ * */
+static void crypto_test_dec_alg_aes_ctr(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_AES_CTR,
+ ODP_AUTH_ALG_NULL,
+ aes_ctr_reference,
+ ARRAY_SIZE(aes_ctr_reference),
+ false);
+}
+
+/* This test verifies the correctness of decode (ciphertext -> plaintext)
+ * operation for AES128_CTR algorithm. IV for the operation is the session IV
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.
+ * */
+static void crypto_test_dec_alg_aes_ctr_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_AES_CTR,
+ ODP_AUTH_ALG_NULL,
+ aes_ctr_reference,
+ ARRAY_SIZE(aes_ctr_reference),
+ true);
+}
+
+static int check_alg_hmac_md5(void)
+{
+ return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_MD5_HMAC);
+}
+
+/* This test verifies the correctness of HMAC_MD5 digest operation.
+ * The output check length is truncated to 12 bytes (96 bits) as
+ * returned by the crypto operation API call.
+ * Note that hash digest is a one-way operation.
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.
+ * */
+static void crypto_test_gen_alg_hmac_md5(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_MD5_HMAC,
+ hmac_md5_reference,
+ ARRAY_SIZE(hmac_md5_reference),
+ false);
+}
+
+static void crypto_test_check_alg_hmac_md5(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_MD5_HMAC,
+ hmac_md5_reference,
+ ARRAY_SIZE(hmac_md5_reference),
+ false);
+}
+
+static int check_alg_hmac_sha1(void)
+{
+ return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_SHA1_HMAC);
+}
+
+/* This test verifies the correctness of HMAC_SHA1 digest operation.
+ * The output check length is truncated to 12 bytes (96 bits) as
+ * returned by the crypto operation API call.
+ * Note that hash digest is a one-way operation.
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.
+ * */
+static void crypto_test_gen_alg_hmac_sha1(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_SHA1_HMAC,
+ hmac_sha1_reference,
+ ARRAY_SIZE(hmac_sha1_reference),
+ false);
+}
+
+static void crypto_test_check_alg_hmac_sha1(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_SHA1_HMAC,
+ hmac_sha1_reference,
+ ARRAY_SIZE(hmac_sha1_reference),
+ false);
+}
+
+static int check_alg_hmac_sha256(void)
+{
+ return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_SHA256_HMAC);
+}
+
+/* This test verifies the correctness of HMAC_SHA256 digest operation.
+ * The output check length is truncated to 16 bytes (128 bits) as
+ * returned by the crypto operation API call.
+ * Note that hash digest is a one-way operation.
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.
+ * */
+static void crypto_test_gen_alg_hmac_sha256(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_SHA256_HMAC,
+ hmac_sha256_reference,
+ ARRAY_SIZE(hmac_sha256_reference),
+ false);
+}
+
+static void crypto_test_check_alg_hmac_sha256(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_SHA256_HMAC,
+ hmac_sha256_reference,
+ ARRAY_SIZE(hmac_sha256_reference),
+ false);
+}
+
+static int check_alg_hmac_sha512(void)
+{
+ return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_SHA512_HMAC);
+}
+
+/* This test verifies the correctness of HMAC_SHA512 digest operation.
+ * The output check length is truncated to 32 bytes (256 bits) as
+ * returned by the crypto operation API call.
+ * Note that hash digest is a one-way operation.
+ * In addition the test verifies if the implementation can use the
+ * packet buffer as completion event buffer.
+ * */
+static void crypto_test_gen_alg_hmac_sha512(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_SHA512_HMAC,
+ hmac_sha512_reference,
+ ARRAY_SIZE(hmac_sha512_reference),
+ false);
+}
+
+static void crypto_test_check_alg_hmac_sha512(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_SHA512_HMAC,
+ hmac_sha512_reference,
+ ARRAY_SIZE(hmac_sha512_reference),
+ false);
+}
+
+static int check_alg_aes_gmac(void)
+{
+ return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_AES_GMAC);
+}
+
+static void crypto_test_gen_alg_aes_gmac(void)
+{
+ unsigned int test_vec_num = (sizeof(aes_gmac_reference) /
+ sizeof(aes_gmac_reference[0]));
+ unsigned int i;
+
+ for (i = 0; i < test_vec_num; i++)
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_AES_GMAC,
+ aes_gmac_reference,
+ ARRAY_SIZE(aes_gmac_reference),
+ false);
+}
+
+static void crypto_test_gen_alg_aes_gmac_ovr_iv(void)
+{
+ unsigned int test_vec_num = (sizeof(aes_gmac_reference) /
+ sizeof(aes_gmac_reference[0]));
+ unsigned int i;
+
+ for (i = 0; i < test_vec_num; i++)
+ alg_test(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_AES_GMAC,
+ &aes_gmac_reference[i],
+ true);
+}
+
+static void crypto_test_check_alg_aes_gmac(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_AES_GMAC,
+ aes_gmac_reference,
+ ARRAY_SIZE(aes_gmac_reference),
+ false);
+}
+
+static void crypto_test_check_alg_aes_gmac_ovr_iv(void)
+{
+ unsigned int test_vec_num = (sizeof(aes_gmac_reference) /
+ sizeof(aes_gmac_reference[0]));
+ unsigned int i;
+
+ for (i = 0; i < test_vec_num; i++)
+ alg_test(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_AES_GMAC,
+ &aes_gmac_reference[i],
+ true);
+}
+
+int crypto_suite_sync_init(void)
+{
+ suite_context.pool = odp_pool_lookup("packet_pool");
+ if (suite_context.pool == ODP_POOL_INVALID)
+ return -1;
+
+ suite_context.queue = ODP_QUEUE_INVALID;
+ suite_context.pref_mode = ODP_CRYPTO_SYNC;
+ return 0;
+}
+
+int crypto_suite_async_init(void)
+{
+ suite_context.pool = odp_pool_lookup("packet_pool");
+ if (suite_context.pool == ODP_POOL_INVALID)
+ return -1;
+ suite_context.queue = odp_queue_lookup("crypto-out");
+ if (suite_context.queue == ODP_QUEUE_INVALID)
+ return -1;
+
+ suite_context.pref_mode = ODP_CRYPTO_ASYNC;
+ return 0;
+}
+
+int crypto_suite_packet_sync_init(void)
+{
+ suite_context.packet = true;
+ suite_context.op_mode = ODP_CRYPTO_SYNC;
+
+ suite_context.pool = odp_pool_lookup("packet_pool");
+ if (suite_context.pool == ODP_POOL_INVALID)
+ return -1;
+
+ suite_context.queue = ODP_QUEUE_INVALID;
+ return 0;
+}
+
+int crypto_suite_packet_async_init(void)
+{
+ suite_context.packet = true;
+ suite_context.op_mode = ODP_CRYPTO_ASYNC;
+
+ suite_context.pool = odp_pool_lookup("packet_pool");
+ if (suite_context.pool == ODP_POOL_INVALID)
+ return -1;
+
+ suite_context.queue = odp_queue_lookup("crypto-out");
+ if (suite_context.queue == ODP_QUEUE_INVALID)
+ return -1;
+ return 0;
+}
+
+odp_testinfo_t crypto_suite[] = {
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_null,
+ check_alg_null),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_null,
+ check_alg_null),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_3des_cbc,
+ check_alg_3des_cbc),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_3des_cbc,
+ check_alg_3des_cbc),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_3des_cbc_ovr_iv,
+ check_alg_3des_cbc),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_3des_cbc_ovr_iv,
+ check_alg_3des_cbc),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_cbc,
+ check_alg_aes_cbc),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_cbc,
+ check_alg_aes_cbc),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_cbc_ovr_iv,
+ check_alg_aes_cbc),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_cbc_ovr_iv,
+ check_alg_aes_cbc),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_ctr,
+ check_alg_aes_ctr),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_ctr,
+ check_alg_aes_ctr),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_ctr_ovr_iv,
+ check_alg_aes_ctr),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_ctr_ovr_iv,
+ check_alg_aes_ctr),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_gcm,
+ check_alg_aes_gcm),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_gcm_ovr_iv,
+ check_alg_aes_gcm),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_gcm,
+ check_alg_aes_gcm),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_gcm_ovr_iv,
+ check_alg_aes_gcm),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_hmac_md5,
+ check_alg_hmac_md5),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_hmac_md5,
+ check_alg_hmac_md5),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_hmac_sha1,
+ check_alg_hmac_sha1),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_hmac_sha1,
+ check_alg_hmac_sha1),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_hmac_sha256,
+ check_alg_hmac_sha256),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_hmac_sha256,
+ check_alg_hmac_sha256),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_hmac_sha512,
+ check_alg_hmac_sha512),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_hmac_sha512,
+ check_alg_hmac_sha512),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_aes_gmac,
+ check_alg_aes_gmac),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_aes_gmac_ovr_iv,
+ check_alg_aes_gmac),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_aes_gmac,
+ check_alg_aes_gmac),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_aes_gmac_ovr_iv,
+ check_alg_aes_gmac),
+ ODP_TEST_INFO_NULL,
+};
+
+int crypto_suite_term(void)
+{
+ int i;
+ int first = 1;
+
+ for (i = 0; crypto_suite[i].pName; i++) {
+ if (crypto_suite[i].check_active &&
+ crypto_suite[i].check_active() == ODP_TEST_INACTIVE) {
+ if (first) {
+ first = 0;
+ printf("\n\n Inactive tests:\n");
+ }
+ printf(" %s\n", crypto_suite[i].pName);
+ }
+ }
+ return 0;
+}