[API-NEXT,v3,4/6] validation: crypto: rework testsuite

Message ID 1501552809-14585-5-git-send-email-odpbot@yandex.ru
State New
Headers show
Series
  • [API-NEXT,v3,1/6] api: packet: add packet memset and memcmp-like functions
Related show

Commit Message

Github ODP bot Aug. 1, 2017, 2 a.m.
From: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov@linaro.org>


Currently crypto testsuite contains tons of similar c&p code setting
keys, iv, data, etc. Data is scattered into different arrays. Refactor
crypto testsuite so that all data is kept in the structured way,
removing most of similar code from individual testing functions.

Signed-off-by: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov@linaro.org>

---
/** Email created from pull request 94 (lumag:crypto-long-keys)
 ** https://github.com/Linaro/odp/pull/94
 ** Patch: https://github.com/Linaro/odp/pull/94.patch
 ** Base sha: c16f1363303cd5fc11324acbc4dfebe0a9680a41
 ** Merge commit sha: 97de0c6543391f0a758ac472f48e0b407ad1d800
 **/
 .../validation/api/crypto/odp_crypto_test_inp.c    | 1072 ++++----------------
 .../validation/api/crypto/test_vectors.h           |  888 ++++++++--------
 .../validation/api/crypto/test_vectors_len.h       |   23 +-
 3 files changed, 674 insertions(+), 1309 deletions(-)

Patch hide | download patch | download mbox

diff --git a/test/common_plat/validation/api/crypto/odp_crypto_test_inp.c b/test/common_plat/validation/api/crypto/odp_crypto_test_inp.c
index df4ac0c4..2aca9ce2 100644
--- a/test/common_plat/validation/api/crypto/odp_crypto_test_inp.c
+++ b/test/common_plat/validation/api/crypto/odp_crypto_test_inp.c
@@ -71,7 +71,7 @@  static int alg_op(odp_packet_t pkt,
 		  uint32_t aad_len,
 		  unsigned int plaintext_len)
 {
-	int data_off = 0, rc;
+	int rc;
 	odp_crypto_op_result_t result;
 	odp_crypto_op_param_t op_params;
 	odp_bool_t posted;
@@ -84,19 +84,8 @@  static int alg_op(odp_packet_t 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;
-	}
+	op_params.cipher_range = *cipher_range;
+	op_params.auth_range = *auth_range;
 	if (op_iv_ptr)
 		op_params.override_iv_ptr = op_iv_ptr;
 
@@ -159,7 +148,7 @@  static int alg_packet_op(odp_packet_t pkt,
 			 uint32_t aad_len,
 			 unsigned int plaintext_len)
 {
-	int data_off = 0, rc;
+	int rc;
 	odp_crypto_packet_result_t result;
 	odp_crypto_packet_op_param_t op_params;
 	odp_event_subtype_t subtype;
@@ -169,19 +158,8 @@  static int alg_packet_op(odp_packet_t pkt,
 	memset(&op_params, 0, sizeof(op_params));
 	op_params.session = session;
 
-	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;
-	}
+	op_params.cipher_range = *cipher_range;
+	op_params.auth_range = *auth_range;
 	if (op_iv_ptr)
 		op_params.override_iv_ptr = op_iv_ptr;
 
@@ -226,7 +204,7 @@  static int alg_packet_op_enq(odp_packet_t pkt,
 			     uint32_t aad_len,
 			     unsigned int plaintext_len)
 {
-	int data_off = 0, rc;
+	int rc;
 	odp_event_t event;
 	odp_crypto_packet_result_t result;
 	odp_crypto_packet_op_param_t op_params;
@@ -237,19 +215,8 @@  static int alg_packet_op_enq(odp_packet_t pkt,
 	memset(&op_params, 0, sizeof(op_params));
 	op_params.session = session;
 
-	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;
-	}
+	op_params.cipher_range = *cipher_range;
+	op_params.auth_range = *auth_range;
 	if (op_iv_ptr)
 		op_params.override_iv_ptr = op_iv_ptr;
 
@@ -306,33 +273,34 @@  static int alg_packet_op_enq(odp_packet_t pkt,
  * buffer can be used.
  * */
 static void alg_test(odp_crypto_op_t op,
-		     odp_bool_t should_fail,
 		     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_packet_data_range_t *cipher_range,
-		     odp_packet_data_range_t *auth_range,
-		     uint8_t *aad,
-		     uint32_t aad_len,
-		     const uint8_t *plaintext,
-		     unsigned int plaintext_len,
-		     const uint8_t *ciphertext,
-		     unsigned int ciphertext_len,
-		     const uint8_t *digest,
-		     uint32_t digest_len)
+		     crypto_test_reference_t *ref,
+		     odp_bool_t ovr_iv)
 {
 	odp_crypto_session_t session;
 	odp_crypto_capability_t capa;
 	int rc;
 	odp_crypto_ses_create_err_t status;
 	odp_bool_t ok = false;
+	odp_bool_t should_fail = false;
 	odp_crypto_session_param_t ses_params;
-	uint8_t *data_addr;
 	odp_crypto_cipher_capability_t cipher_capa[MAX_ALG_CAPA];
 	odp_crypto_auth_capability_t   auth_capa[MAX_ALG_CAPA];
+	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 iv = {
+		.data = ovr_iv ? NULL : ref->iv,
+		.length = ref->iv_length
+	};
 	int num, i;
 	int found;
 
@@ -394,13 +362,18 @@  static void alg_test(odp_crypto_op_t op,
 	/* Search for the test case */
 	for (i = 0; i < num; i++) {
 		if (cipher_capa[i].key_len == cipher_key.length &&
-		    cipher_capa[i].iv_len  == ses_iv.length) {
+		    cipher_capa[i].iv_len  == iv.length) {
 			found = 1;
 			break;
 		}
 	}
 
-	CU_ASSERT(found);
+	if (!found) {
+		printf("\n    Unsupported: alg=%s, key_len=%" PRIu32 ", "
+		       "iv_len=%" PRIu32 "\n", cipher_alg_name(cipher_alg),
+		       cipher_key.length, iv.length);
+		return;
+	}
 
 	num = odp_crypto_auth_capability(auth_alg, auth_capa, MAX_ALG_CAPA);
 
@@ -414,14 +387,19 @@  static void alg_test(odp_crypto_op_t op,
 
 	/* Search for the test case */
 	for (i = 0; i < num; i++) {
-		if (auth_capa[i].digest_len == digest_len &&
+		if (auth_capa[i].digest_len == ref->digest_length &&
 		    auth_capa[i].key_len    == auth_key.length) {
 			found = 1;
 			break;
 		}
 	}
 
-	CU_ASSERT(found);
+	if (!found) {
+		printf("\n    Unsupported: alg=%s, key_len=%" PRIu32 ", "
+		       "digest_len=%" PRIu32 "\n", auth_alg_name(auth_alg),
+		       auth_key.length, ref->digest_length);
+		return;
+	}
 
 	/* Create a crypto session */
 	odp_crypto_session_param_init(&ses_params);
@@ -434,9 +412,9 @@  static void alg_test(odp_crypto_op_t op,
 	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.iv = iv;
 	ses_params.auth_key = auth_key;
-	ses_params.auth_digest_len = digest_len;
+	ses_params.auth_digest_len = ref->digest_length;
 
 	rc = odp_crypto_session_create(&ses_params, &session, &status);
 	CU_ASSERT_FATAL(!rc);
@@ -444,29 +422,47 @@  static void alg_test(odp_crypto_op_t op,
 	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,
-					    plaintext_len + digest_len);
+					    ref->length + ref->digest_length);
 	CU_ASSERT(pkt != ODP_PACKET_INVALID);
-	data_addr = odp_packet_data(pkt);
-	memcpy(data_addr, plaintext, plaintext_len);
-	if (0 != digest_len) {
-		memcpy(data_addr + plaintext_len,
-		       digest, digest_len);
+restart:
+	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);
+		if (should_fail)
+			odp_packet_set_data(pkt, ref->length, 0x5a,
+					    ref->digest_length);
+		else
+			odp_packet_copy_from_mem(pkt, ref->length,
+						 ref->digest_length,
+						 ref->digest);
 	}
 
 	if (!suite_context.packet)
-		rc = alg_op(pkt, &ok, session, op_iv_ptr,
-			    cipher_range, auth_range, aad, aad_len,
-			    plaintext_len);
+		rc = alg_op(pkt, &ok, session,
+			    ovr_iv ? ref->iv : NULL,
+			    &cipher_range, &auth_range,
+			    ref->aad, ref->aad_length,
+			    ref->length);
 	else if (ODP_CRYPTO_ASYNC == suite_context.op_mode)
-		rc = alg_packet_op_enq(pkt, &ok, session, op_iv_ptr,
-				       cipher_range, auth_range, aad, aad_len,
-				       plaintext_len);
+		rc = alg_packet_op_enq(pkt, &ok, session,
+				       ovr_iv ? ref->iv : NULL,
+				       &cipher_range, &auth_range,
+				       ref->aad, ref->aad_length,
+				       ref->length);
 	else
-		rc = alg_packet_op(pkt, &ok, session, op_iv_ptr,
-				   cipher_range, auth_range, aad, aad_len,
-				   plaintext_len);
+		rc = alg_packet_op(pkt, &ok, session,
+				   ovr_iv ? ref->iv : NULL,
+				   &cipher_range, &auth_range,
+				   ref->aad, ref->aad_length,
+				   ref->length);
 	if (rc < 0) {
 		goto cleanup;
 	}
@@ -478,13 +474,23 @@  static void alg_test(odp_crypto_op_t op,
 
 	CU_ASSERT(ok);
 
-	data_addr = odp_packet_data(pkt);
-	if (cipher_alg != ODP_CIPHER_ALG_NULL)
-		CU_ASSERT(!memcmp(data_addr, ciphertext, ciphertext_len));
+	if (op == ODP_CRYPTO_OP_ENCODE) {
+		CU_ASSERT(!odp_packet_cmp_mem(pkt, 0,
+					      ref->ciphertext,
+					      ref->length));
+		CU_ASSERT(!odp_packet_cmp_mem(pkt, ref->length,
+					      ref->digest,
+					      ref->digest_length));
+	} else {
+		CU_ASSERT(!odp_packet_cmp_mem(pkt, 0,
+					      ref->plaintext,
+					      ref->length));
+		if (ref->digest_length != 0) {
+			should_fail = true;
+			goto restart;
+		}
+	}
 
-	if (op == ODP_CRYPTO_OP_ENCODE && auth_alg != ODP_AUTH_ALG_NULL)
-		CU_ASSERT(!memcmp(data_addr + plaintext_len,
-				  digest, digest_len));
 cleanup:
 	rc = odp_crypto_session_destroy(session);
 	CU_ASSERT(!rc);
@@ -569,76 +575,6 @@  static int check_alg_support(odp_cipher_alg_t cipher, odp_auth_alg_t auth)
 	return ODP_TEST_ACTIVE;
 }
 
-/**
- * Check if given cipher options are supported
- *
- * @param cipher      Cipher algorithm
- * @param key_len     Key length
- * @param iv_len      IV length
- *
- * @retval non-zero if both cipher options are supported
- * @retval 0 if both options are not supported
- */
-static int check_cipher_options(odp_cipher_alg_t cipher, uint32_t key_len,
-				uint32_t iv_len)
-{
-	int i;
-	int num;
-	odp_crypto_cipher_capability_t cipher_capa[MAX_ALG_CAPA];
-
-	num = odp_crypto_cipher_capability(cipher, cipher_capa, MAX_ALG_CAPA);
-	CU_ASSERT_FATAL(num >= 1);
-
-	for (i = 0; i < num; i++) {
-		if (key_len == cipher_capa[i].key_len &&
-		    iv_len == cipher_capa[i].iv_len)
-			break;
-	}
-
-	if (i == num) {
-		printf("\n    Unsupported: alg=%s, key_len=%" PRIu32 ", "
-		       "iv_len=%" PRIu32 "\n", cipher_alg_name(cipher), key_len,
-		       iv_len);
-		return 0;
-	}
-	return 1;
-}
-
-/**
- * Check if given authentication options are supported
- *
- * @param auth        Authentication algorithm
- * @param key_len     Key length
- * @param digest_len  Digest length
- *
- * @retval non-zero if both authentication options are supported
- * @retval 0 if both options are not supported
- */
-static int check_auth_options(odp_auth_alg_t auth, uint32_t key_len,
-			      uint32_t digest_len)
-{
-	int i;
-	int num;
-	odp_crypto_auth_capability_t capa[MAX_ALG_CAPA];
-
-	num = odp_crypto_auth_capability(auth, capa, MAX_ALG_CAPA);
-	CU_ASSERT_FATAL(num >= 1);
-
-	for (i = 0; i < num; i++) {
-		if (key_len == capa[i].key_len &&
-		    digest_len == capa[i].digest_len)
-			break;
-	}
-
-	if (i == num) {
-		printf("\n    Unsupported: alg=%s, key_len=%" PRIu32 ", "
-		       "digest_len=%" PRIu32 "\n", auth_alg_name(auth), key_len,
-		       digest_len);
-		return 0;
-	}
-	return 1;
-}
-
 static int check_alg_null(void)
 {
 	return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_NULL);
@@ -646,64 +582,30 @@  static int check_alg_null(void)
 
 void crypto_test_enc_alg_null(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = 0};
-	unsigned int test_vec_num = (sizeof(null_reference_length) /
-				     sizeof(null_reference_length[0]));
+	unsigned int test_vec_num = (sizeof(null_reference) /
+				     sizeof(null_reference[0]));
 	unsigned int i;
 
-	for (i = 0; i < test_vec_num; i++) {
-		if (!check_cipher_options(ODP_CIPHER_ALG_NULL,
-					  cipher_key.length, iv.length))
-			continue;
-
+	for (i = 0; i < test_vec_num; i++)
 		alg_test(ODP_CRYPTO_OP_ENCODE,
-			 0,
 			 ODP_CIPHER_ALG_NULL,
-			 iv,
-			 NULL,
-			 cipher_key,
 			 ODP_AUTH_ALG_NULL,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 null_reference_plaintext[i],
-			 null_reference_length[i],
-			 null_reference_plaintext[i],
-			 null_reference_length[i], NULL, 0);
-	}
+			 &null_reference[i],
+			 false);
 }
 
 void crypto_test_dec_alg_null(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = 0 };
-	unsigned int test_vec_num = (sizeof(null_reference_length) /
-				     sizeof(null_reference_length[0]));
+	unsigned int test_vec_num = (sizeof(null_reference) /
+				     sizeof(null_reference[0]));
 	unsigned int i;
 
-	for (i = 0; i < test_vec_num; i++) {
-		if (!check_cipher_options(ODP_CIPHER_ALG_NULL,
-					  cipher_key.length, iv.length))
-			continue;
-
+	for (i = 0; i < test_vec_num; i++)
 		alg_test(ODP_CRYPTO_OP_DECODE,
-			 0,
 			 ODP_CIPHER_ALG_NULL,
-			 iv,
-			 NULL,
-			 cipher_key,
 			 ODP_AUTH_ALG_NULL,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 null_reference_plaintext[i],
-			 null_reference_length[i],
-			 null_reference_plaintext[i],
-			 null_reference_length[i], NULL, 0);
-	}
+			 &null_reference[i],
+			 false);
 }
 
 static int check_alg_3des_cbc(void)
@@ -717,38 +619,16 @@  static int check_alg_3des_cbc(void)
  * packet buffer as completion event buffer.*/
 void crypto_test_enc_alg_3des_cbc(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv;
-	unsigned int test_vec_num = (sizeof(tdes_cbc_reference_length) /
-				     sizeof(tdes_cbc_reference_length[0]));
+	unsigned int test_vec_num = (sizeof(tdes_cbc_reference) /
+				     sizeof(tdes_cbc_reference[0]));
 	unsigned int i;
 
-	for (i = 0; i < test_vec_num; i++) {
-		cipher_key.data = tdes_cbc_reference_key[i];
-		cipher_key.length = sizeof(tdes_cbc_reference_key[i]);
-		iv.data = tdes_cbc_reference_iv[i];
-		iv.length = sizeof(tdes_cbc_reference_iv[i]);
-
-		if (!check_cipher_options(ODP_CIPHER_ALG_3DES_CBC,
-					  cipher_key.length, iv.length))
-			continue;
-
+	for (i = 0; i < test_vec_num; i++)
 		alg_test(ODP_CRYPTO_OP_ENCODE,
-			 0,
 			 ODP_CIPHER_ALG_3DES_CBC,
-			 iv,
-			 NULL,
-			 cipher_key,
 			 ODP_AUTH_ALG_NULL,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 tdes_cbc_reference_plaintext[i],
-			 tdes_cbc_reference_length[i],
-			 tdes_cbc_reference_ciphertext[i],
-			 tdes_cbc_reference_length[i], NULL, 0);
-	}
+			 &tdes_cbc_reference[i],
+			 false);
 }
 
 /* This test verifies the correctness of encode (plaintext -> ciphertext)
@@ -756,36 +636,16 @@  void crypto_test_enc_alg_3des_cbc(void)
  * */
 void crypto_test_enc_alg_3des_cbc_ovr_iv(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = TDES_CBC_IV_LEN };
-	unsigned int test_vec_num = (sizeof(tdes_cbc_reference_length) /
-				     sizeof(tdes_cbc_reference_length[0]));
+	unsigned int test_vec_num = (sizeof(tdes_cbc_reference) /
+				     sizeof(tdes_cbc_reference[0]));
 	unsigned int i;
 
-	for (i = 0; i < test_vec_num; i++) {
-		cipher_key.data = tdes_cbc_reference_key[i];
-		cipher_key.length = sizeof(tdes_cbc_reference_key[i]);
-
-		if (!check_cipher_options(ODP_CIPHER_ALG_3DES_CBC,
-					  cipher_key.length, iv.length))
-			continue;
-
+	for (i = 0; i < test_vec_num; i++)
 		alg_test(ODP_CRYPTO_OP_ENCODE,
-			 0,
 			 ODP_CIPHER_ALG_3DES_CBC,
-			 iv,
-			 tdes_cbc_reference_iv[i],
-			 cipher_key,
 			 ODP_AUTH_ALG_NULL,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 tdes_cbc_reference_plaintext[i],
-			 tdes_cbc_reference_length[i],
-			 tdes_cbc_reference_ciphertext[i],
-			 tdes_cbc_reference_length[i], NULL, 0);
-	}
+			 &tdes_cbc_reference[i],
+			 true);
 }
 
 /* This test verifies the correctness of decode (ciphertext -> plaintext)
@@ -795,38 +655,16 @@  void crypto_test_enc_alg_3des_cbc_ovr_iv(void)
  * */
 void crypto_test_dec_alg_3des_cbc(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = 0 };
-	unsigned int test_vec_num = (sizeof(tdes_cbc_reference_length) /
-				     sizeof(tdes_cbc_reference_length[0]));
+	unsigned int test_vec_num = (sizeof(tdes_cbc_reference) /
+				     sizeof(tdes_cbc_reference[0]));
 	unsigned int i;
 
-	for (i = 0; i < test_vec_num; i++) {
-		cipher_key.data = tdes_cbc_reference_key[i];
-		cipher_key.length = sizeof(tdes_cbc_reference_key[i]);
-		iv.data = tdes_cbc_reference_iv[i];
-		iv.length = sizeof(tdes_cbc_reference_iv[i]);
-
-		if (!check_cipher_options(ODP_CIPHER_ALG_3DES_CBC,
-					  cipher_key.length, iv.length))
-			continue;
-
+	for (i = 0; i < test_vec_num; i++)
 		alg_test(ODP_CRYPTO_OP_DECODE,
-			 0,
 			 ODP_CIPHER_ALG_3DES_CBC,
-			 iv,
-			 NULL,
-			 cipher_key,
 			 ODP_AUTH_ALG_NULL,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 tdes_cbc_reference_ciphertext[i],
-			 tdes_cbc_reference_length[i],
-			 tdes_cbc_reference_plaintext[i],
-			 tdes_cbc_reference_length[i], NULL, 0);
-	}
+			 &tdes_cbc_reference[i],
+			 false);
 }
 
 /* This test verifies the correctness of decode (ciphertext -> plaintext)
@@ -836,36 +674,16 @@  void crypto_test_dec_alg_3des_cbc(void)
  * */
 void crypto_test_dec_alg_3des_cbc_ovr_iv(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = TDES_CBC_IV_LEN };
-	unsigned int test_vec_num = (sizeof(tdes_cbc_reference_length) /
-				     sizeof(tdes_cbc_reference_length[0]));
+	unsigned int test_vec_num = (sizeof(tdes_cbc_reference) /
+				     sizeof(tdes_cbc_reference[0]));
 	unsigned int i;
 
-	for (i = 0; i < test_vec_num; i++) {
-		cipher_key.data = tdes_cbc_reference_key[i];
-		cipher_key.length = sizeof(tdes_cbc_reference_key[i]);
-
-		if (!check_cipher_options(ODP_CIPHER_ALG_3DES_CBC,
-					  cipher_key.length, iv.length))
-			continue;
-
+	for (i = 0; i < test_vec_num; i++)
 		alg_test(ODP_CRYPTO_OP_DECODE,
-			 0,
 			 ODP_CIPHER_ALG_3DES_CBC,
-			 iv,
-			 tdes_cbc_reference_iv[i],
-			 cipher_key,
 			 ODP_AUTH_ALG_NULL,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 tdes_cbc_reference_ciphertext[i],
-			 tdes_cbc_reference_length[i],
-			 tdes_cbc_reference_plaintext[i],
-			 tdes_cbc_reference_length[i], NULL, 0);
-	}
+			 &tdes_cbc_reference[i],
+			 true);
 }
 
 static int check_alg_aes_gcm(void)
@@ -879,46 +697,16 @@  static int check_alg_aes_gcm(void)
  * packet buffer as completion event buffer.*/
 void crypto_test_enc_alg_aes128_gcm(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = AES128_GCM_IV_LEN };
-	unsigned int test_vec_num = (sizeof(aes128_gcm_reference_length) /
-				     sizeof(aes128_gcm_reference_length[0]));
+	unsigned int test_vec_num = (sizeof(aes128_gcm_reference) /
+				     sizeof(aes128_gcm_reference[0]));
 	unsigned int i;
 
 	for (i = 0; i < test_vec_num; i++) {
-		cipher_key.data = aes128_gcm_reference_key[i];
-		cipher_key.length = sizeof(aes128_gcm_reference_key[i]);
-		iv.data = aes128_gcm_reference_iv[i];
-		iv.length = sizeof(aes128_gcm_reference_iv[i]);
-
-		if (!check_cipher_options(ODP_CIPHER_ALG_AES_GCM,
-					  cipher_key.length, iv.length))
-			continue;
-		if (!check_auth_options(ODP_AUTH_ALG_AES_GCM,
-					auth_key.length,
-					aes128_gcm_reference_tag_length[i]))
-			continue;
-
 		alg_test(ODP_CRYPTO_OP_ENCODE,
-			 0,
 			 ODP_CIPHER_ALG_AES_GCM,
-			 iv,
-			 NULL,
-			 cipher_key,
 			 ODP_AUTH_ALG_AES_GCM,
-			 auth_key,
-			 &aes128_gcm_cipher_range[i],
-			 &aes128_gcm_cipher_range[i],
-			 aes128_gcm_reference_aad[i],
-			 aes128_gcm_reference_aad_length[i],
-			 aes128_gcm_reference_plaintext[i],
-			 aes128_gcm_reference_length[i],
-			 aes128_gcm_reference_ciphertext[i],
-			 aes128_gcm_reference_length[i],
-			 aes128_gcm_reference_ciphertext[i] +
-			 aes128_gcm_reference_length[i],
-			 aes128_gcm_reference_tag_length[i]);
+			 &aes128_gcm_reference[i],
+			 false);
 	}
 }
 
@@ -928,44 +716,16 @@  void crypto_test_enc_alg_aes128_gcm(void)
  * packet buffer as completion event buffer.*/
 void crypto_test_enc_alg_aes128_gcm_ovr_iv(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = AES128_GCM_IV_LEN };
-	unsigned int test_vec_num = (sizeof(aes128_gcm_reference_length) /
-				     sizeof(aes128_gcm_reference_length[0]));
+	unsigned int test_vec_num = (sizeof(aes128_gcm_reference) /
+				     sizeof(aes128_gcm_reference[0]));
 	unsigned int i;
 
 	for (i = 0; i < test_vec_num; i++) {
-		cipher_key.data = aes128_gcm_reference_key[i];
-		cipher_key.length = sizeof(aes128_gcm_reference_key[i]);
-
-		if (!check_cipher_options(ODP_CIPHER_ALG_AES_GCM,
-					  cipher_key.length, iv.length))
-			continue;
-		if (!check_auth_options(ODP_AUTH_ALG_AES_GCM,
-					auth_key.length,
-					aes128_gcm_reference_tag_length[i]))
-			continue;
-
 		alg_test(ODP_CRYPTO_OP_ENCODE,
-			 0,
 			 ODP_CIPHER_ALG_AES_GCM,
-			 iv,
-			 aes128_gcm_reference_iv[i],
-			 cipher_key,
 			 ODP_AUTH_ALG_AES_GCM,
-			 auth_key,
-			 &aes128_gcm_cipher_range[i],
-			 &aes128_gcm_cipher_range[i],
-			 aes128_gcm_reference_aad[i],
-			 aes128_gcm_reference_aad_length[i],
-			 aes128_gcm_reference_plaintext[i],
-			 aes128_gcm_reference_length[i],
-			 aes128_gcm_reference_ciphertext[i],
-			 aes128_gcm_reference_length[i],
-			 aes128_gcm_reference_ciphertext[i] +
-			 aes128_gcm_reference_length[i],
-			 aes128_gcm_reference_tag_length[i]);
+			 &aes128_gcm_reference[i],
+			 true);
 	}
 }
 
@@ -976,68 +736,16 @@  void crypto_test_enc_alg_aes128_gcm_ovr_iv(void)
  * */
 void crypto_test_dec_alg_aes128_gcm(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = AES128_GCM_IV_LEN };
-	uint8_t wrong_digest[AES128_GCM_DIGEST_LEN];
-	unsigned int test_vec_num = (sizeof(aes128_gcm_reference_length) /
-				     sizeof(aes128_gcm_reference_length[0]));
+	unsigned int test_vec_num = (sizeof(aes128_gcm_reference) /
+				     sizeof(aes128_gcm_reference[0]));
 	unsigned int i;
 
-	memset(wrong_digest, 0xa5, sizeof(wrong_digest));
-
 	for (i = 0; i < test_vec_num; i++) {
-		cipher_key.data = aes128_gcm_reference_key[i];
-		cipher_key.length = sizeof(aes128_gcm_reference_key[i]);
-		iv.data = aes128_gcm_reference_iv[i];
-		iv.length = sizeof(aes128_gcm_reference_iv[i]);
-
-		if (!check_cipher_options(ODP_CIPHER_ALG_AES_GCM,
-					  cipher_key.length, iv.length))
-			continue;
-		if (!check_auth_options(ODP_AUTH_ALG_AES_GCM,
-					auth_key.length,
-					aes128_gcm_reference_tag_length[i]))
-			continue;
-
 		alg_test(ODP_CRYPTO_OP_DECODE,
-			 0,
 			 ODP_CIPHER_ALG_AES_GCM,
-			 iv,
-			 NULL,
-			 cipher_key,
 			 ODP_AUTH_ALG_AES_GCM,
-			 auth_key,
-			 &aes128_gcm_cipher_range[i],
-			 &aes128_gcm_cipher_range[i],
-			 aes128_gcm_reference_aad[i],
-			 aes128_gcm_reference_aad_length[i],
-			 aes128_gcm_reference_ciphertext[i],
-			 aes128_gcm_reference_length[i],
-			 aes128_gcm_reference_plaintext[i],
-			 aes128_gcm_reference_length[i],
-			 aes128_gcm_reference_ciphertext[i] +
-			 aes128_gcm_reference_length[i],
-			 aes128_gcm_reference_tag_length[i]);
-
-		alg_test(ODP_CRYPTO_OP_DECODE,
-			 1,
-			 ODP_CIPHER_ALG_AES_GCM,
-			 iv,
-			 NULL,
-			 cipher_key,
-			 ODP_AUTH_ALG_AES_GCM,
-			 auth_key,
-			 &aes128_gcm_cipher_range[i],
-			 &aes128_gcm_cipher_range[i],
-			 aes128_gcm_reference_aad[i],
-			 aes128_gcm_reference_aad_length[i],
-			 aes128_gcm_reference_ciphertext[i],
-			 aes128_gcm_reference_length[i],
-			 aes128_gcm_reference_plaintext[i],
-			 aes128_gcm_reference_length[i],
-			 wrong_digest,
-			 aes128_gcm_reference_tag_length[i]);
+			 &aes128_gcm_reference[i],
+			 false);
 	}
 }
 
@@ -1048,66 +756,16 @@  void crypto_test_dec_alg_aes128_gcm(void)
  * */
 void crypto_test_dec_alg_aes128_gcm_ovr_iv(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = AES128_GCM_IV_LEN };
-	uint8_t wrong_digest[AES128_GCM_DIGEST_LEN];
-	unsigned int test_vec_num = (sizeof(aes128_gcm_reference_length) /
-				     sizeof(aes128_gcm_reference_length[0]));
+	unsigned int test_vec_num = (sizeof(aes128_gcm_reference) /
+				     sizeof(aes128_gcm_reference[0]));
 	unsigned int i;
 
-	memset(wrong_digest, 0xa5, sizeof(wrong_digest));
-
 	for (i = 0; i < test_vec_num; i++) {
-		cipher_key.data = aes128_gcm_reference_key[i];
-		cipher_key.length = sizeof(aes128_gcm_reference_key[i]);
-
-		if (!check_cipher_options(ODP_CIPHER_ALG_AES_GCM,
-					  cipher_key.length, iv.length))
-			continue;
-		if (!check_auth_options(ODP_AUTH_ALG_AES_GCM,
-					auth_key.length,
-					aes128_gcm_reference_tag_length[i]))
-			continue;
-
-		alg_test(ODP_CRYPTO_OP_DECODE,
-			 0,
-			 ODP_CIPHER_ALG_AES_GCM,
-			 iv,
-			 aes128_gcm_reference_iv[i],
-			 cipher_key,
-			 ODP_AUTH_ALG_AES_GCM,
-			 auth_key,
-			 &aes128_gcm_cipher_range[i],
-			 &aes128_gcm_cipher_range[i],
-			 aes128_gcm_reference_aad[i],
-			 aes128_gcm_reference_aad_length[i],
-			 aes128_gcm_reference_ciphertext[i],
-			 aes128_gcm_reference_length[i],
-			 aes128_gcm_reference_plaintext[i],
-			 aes128_gcm_reference_length[i],
-			 aes128_gcm_reference_ciphertext[i] +
-			 aes128_gcm_reference_length[i],
-			 aes128_gcm_reference_tag_length[i]);
-
 		alg_test(ODP_CRYPTO_OP_DECODE,
-			 1,
 			 ODP_CIPHER_ALG_AES_GCM,
-			 iv,
-			 aes128_gcm_reference_iv[i],
-			 cipher_key,
 			 ODP_AUTH_ALG_AES_GCM,
-			 auth_key,
-			 &aes128_gcm_cipher_range[i],
-			 &aes128_gcm_cipher_range[i],
-			 aes128_gcm_reference_aad[i],
-			 aes128_gcm_reference_aad_length[i],
-			 aes128_gcm_reference_ciphertext[i],
-			 aes128_gcm_reference_length[i],
-			 aes128_gcm_reference_plaintext[i],
-			 aes128_gcm_reference_length[i],
-			 wrong_digest,
-			 aes128_gcm_reference_tag_length[i]);
+			 &aes128_gcm_reference[i],
+			 true);
 	}
 }
 
@@ -1122,37 +780,16 @@  static int check_alg_aes_cbc(void)
  * packet buffer as completion event buffer.*/
 void crypto_test_enc_alg_aes128_cbc(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv;
-	unsigned int test_vec_num = (sizeof(aes128_cbc_reference_length) /
-				     sizeof(aes128_cbc_reference_length[0]));
+	unsigned int test_vec_num = (sizeof(aes128_cbc_reference) /
+				     sizeof(aes128_cbc_reference[0]));
 	unsigned int i;
 
 	for (i = 0; i < test_vec_num; i++) {
-		cipher_key.data = aes128_cbc_reference_key[i];
-		cipher_key.length = sizeof(aes128_cbc_reference_key[i]);
-		iv.data = aes128_cbc_reference_iv[i];
-		iv.length = sizeof(aes128_cbc_reference_iv[i]);
-
-		if (!check_cipher_options(ODP_CIPHER_ALG_AES_CBC,
-					  cipher_key.length, iv.length))
-			continue;
-
 		alg_test(ODP_CRYPTO_OP_ENCODE,
-			 0,
 			 ODP_CIPHER_ALG_AES_CBC,
-			 iv,
-			 NULL,
-			 cipher_key,
 			 ODP_AUTH_ALG_NULL,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 aes128_cbc_reference_plaintext[i],
-			 aes128_cbc_reference_length[i],
-			 aes128_cbc_reference_ciphertext[i],
-			 aes128_cbc_reference_length[i], NULL, 0);
+			 &aes128_cbc_reference[i],
+			 false);
 	}
 }
 
@@ -1161,35 +798,16 @@  void crypto_test_enc_alg_aes128_cbc(void)
  * */
 void crypto_test_enc_alg_aes128_cbc_ovr_iv(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = AES128_CBC_IV_LEN };
-	unsigned int test_vec_num = (sizeof(aes128_cbc_reference_length) /
-				     sizeof(aes128_cbc_reference_length[0]));
+	unsigned int test_vec_num = (sizeof(aes128_cbc_reference) /
+				     sizeof(aes128_cbc_reference[0]));
 	unsigned int i;
 
 	for (i = 0; i < test_vec_num; i++) {
-		cipher_key.data = aes128_cbc_reference_key[i];
-		cipher_key.length = sizeof(aes128_cbc_reference_key[i]);
-
-		if (!check_cipher_options(ODP_CIPHER_ALG_AES_CBC,
-					  cipher_key.length, iv.length))
-			continue;
-
 		alg_test(ODP_CRYPTO_OP_ENCODE,
-			 0,
 			 ODP_CIPHER_ALG_AES_CBC,
-			 iv,
-			 aes128_cbc_reference_iv[i],
-			 cipher_key,
 			 ODP_AUTH_ALG_NULL,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 aes128_cbc_reference_plaintext[i],
-			 aes128_cbc_reference_length[i],
-			 aes128_cbc_reference_ciphertext[i],
-			 aes128_cbc_reference_length[i], NULL, 0);
+			 &aes128_cbc_reference[i],
+			 true);
 	}
 }
 
@@ -1200,37 +818,16 @@  void crypto_test_enc_alg_aes128_cbc_ovr_iv(void)
  * */
 void crypto_test_dec_alg_aes128_cbc(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = 0 };
-	unsigned int test_vec_num = (sizeof(aes128_cbc_reference_length) /
-				     sizeof(aes128_cbc_reference_length[0]));
+	unsigned int test_vec_num = (sizeof(aes128_cbc_reference) /
+				     sizeof(aes128_cbc_reference[0]));
 	unsigned int i;
 
 	for (i = 0; i < test_vec_num; i++) {
-		cipher_key.data = aes128_cbc_reference_key[i];
-		cipher_key.length = sizeof(aes128_cbc_reference_key[i]);
-		iv.data = aes128_cbc_reference_iv[i];
-		iv.length = sizeof(aes128_cbc_reference_iv[i]);
-
-		if (!check_cipher_options(ODP_CIPHER_ALG_AES_CBC,
-					  cipher_key.length, iv.length))
-			continue;
-
 		alg_test(ODP_CRYPTO_OP_DECODE,
-			 0,
 			 ODP_CIPHER_ALG_AES_CBC,
-			 iv,
-			 NULL,
-			 cipher_key,
 			 ODP_AUTH_ALG_NULL,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 aes128_cbc_reference_ciphertext[i],
-			 aes128_cbc_reference_length[i],
-			 aes128_cbc_reference_plaintext[i],
-			 aes128_cbc_reference_length[i], NULL, 0);
+			 &aes128_cbc_reference[i],
+			 false);
 	}
 }
 
@@ -1241,35 +838,16 @@  void crypto_test_dec_alg_aes128_cbc(void)
  * */
 void crypto_test_dec_alg_aes128_cbc_ovr_iv(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = AES128_CBC_IV_LEN };
-	unsigned int test_vec_num = (sizeof(aes128_cbc_reference_length) /
-				     sizeof(aes128_cbc_reference_length[0]));
+	unsigned int test_vec_num = (sizeof(aes128_cbc_reference) /
+				     sizeof(aes128_cbc_reference[0]));
 	unsigned int i;
 
 	for (i = 0; i < test_vec_num; i++) {
-		cipher_key.data = aes128_cbc_reference_key[i];
-		cipher_key.length = sizeof(aes128_cbc_reference_key[i]);
-
-		if (!check_cipher_options(ODP_CIPHER_ALG_AES_CBC,
-					  cipher_key.length, iv.length))
-			continue;
-
 		alg_test(ODP_CRYPTO_OP_DECODE,
-			 0,
 			 ODP_CIPHER_ALG_AES_CBC,
-			 iv,
-			 aes128_cbc_reference_iv[i],
-			 cipher_key,
 			 ODP_AUTH_ALG_NULL,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 aes128_cbc_reference_ciphertext[i],
-			 aes128_cbc_reference_length[i],
-			 aes128_cbc_reference_plaintext[i],
-			 aes128_cbc_reference_length[i], NULL, 0);
+			 &aes128_cbc_reference[i],
+			 true);
 	}
 }
 
@@ -1287,93 +865,30 @@  static int check_alg_hmac_md5(void)
  * */
 void crypto_test_gen_alg_hmac_md5(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = 0 };
-
-	unsigned int test_vec_num = (sizeof(hmac_md5_reference_length) /
-				     sizeof(hmac_md5_reference_length[0]));
+	unsigned int test_vec_num = (sizeof(hmac_md5_reference) /
+				     sizeof(hmac_md5_reference[0]));
 	unsigned int i;
 
-	for (i = 0; i < test_vec_num; i++) {
-		auth_key.data = hmac_md5_reference_key[i];
-		auth_key.length = sizeof(hmac_md5_reference_key[i]);
-
-		if (!check_auth_options(ODP_AUTH_ALG_MD5_HMAC, auth_key.length,
-					hmac_md5_reference_digest_length[i]))
-			continue;
-
+	for (i = 0; i < test_vec_num; i++)
 		alg_test(ODP_CRYPTO_OP_ENCODE,
-			 0,
 			 ODP_CIPHER_ALG_NULL,
-			 iv,
-			 iv.data,
-			 cipher_key,
 			 ODP_AUTH_ALG_MD5_HMAC,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 hmac_md5_reference_plaintext[i],
-			 hmac_md5_reference_length[i],
-			 NULL, 0,
-			 hmac_md5_reference_digest[i],
-			 hmac_md5_reference_digest_length[i]);
-	}
+			 &hmac_md5_reference[i],
+			 false);
 }
 
 void crypto_test_check_alg_hmac_md5(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = 0 };
-	uint8_t wrong_digest[HMAC_MD5_DIGEST_LEN];
-
-	unsigned int test_vec_num = (sizeof(hmac_md5_reference_length) /
-				     sizeof(hmac_md5_reference_length[0]));
+	unsigned int test_vec_num = (sizeof(hmac_md5_reference) /
+				     sizeof(hmac_md5_reference[0]));
 	unsigned int i;
 
-	memset(wrong_digest, 0xa5, sizeof(wrong_digest));
-
-	for (i = 0; i < test_vec_num; i++) {
-		auth_key.data = hmac_md5_reference_key[i];
-		auth_key.length = sizeof(hmac_md5_reference_key[i]);
-
-		if (!check_auth_options(ODP_AUTH_ALG_MD5_HMAC, auth_key.length,
-					hmac_md5_reference_digest_length[i]))
-			continue;
-
-		alg_test(ODP_CRYPTO_OP_DECODE,
-			 0,
-			 ODP_CIPHER_ALG_NULL,
-			 iv,
-			 iv.data,
-			 cipher_key,
-			 ODP_AUTH_ALG_MD5_HMAC,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 hmac_md5_reference_plaintext[i],
-			 hmac_md5_reference_length[i],
-			 NULL, 0,
-			 hmac_md5_reference_digest[i],
-			 hmac_md5_reference_digest_length[i]);
-
+	for (i = 0; i < test_vec_num; i++)
 		alg_test(ODP_CRYPTO_OP_DECODE,
-			 1,
 			 ODP_CIPHER_ALG_NULL,
-			 iv,
-			 iv.data,
-			 cipher_key,
 			 ODP_AUTH_ALG_MD5_HMAC,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 hmac_md5_reference_plaintext[i],
-			 hmac_md5_reference_length[i],
-			 NULL, 0,
-			 wrong_digest,
-			 hmac_md5_reference_digest_length[i]);
-	}
+			 &hmac_md5_reference[i],
+			 false);
 }
 
 static int check_alg_hmac_sha1(void)
@@ -1390,97 +905,30 @@  static int check_alg_hmac_sha1(void)
  * */
 void crypto_test_gen_alg_hmac_sha1(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = 0 };
-
-	unsigned int test_vec_num = (sizeof(hmac_sha1_reference_length) /
-				     sizeof(hmac_sha1_reference_length[0]));
-
+	unsigned int test_vec_num = (sizeof(hmac_sha1_reference) /
+				     sizeof(hmac_sha1_reference[0]));
 	unsigned int i;
 
-	for (i = 0; i < test_vec_num; i++) {
-		auth_key.data = hmac_sha1_reference_key[i];
-		auth_key.length = sizeof(hmac_sha1_reference_key[i]);
-
-		if (!check_auth_options(ODP_AUTH_ALG_SHA1_HMAC,
-					auth_key.length,
-					HMAC_SHA1_96_CHECK_LEN))
-			continue;
-
+	for (i = 0; i < test_vec_num; i++)
 		alg_test(ODP_CRYPTO_OP_ENCODE,
-			 0,
 			 ODP_CIPHER_ALG_NULL,
-			 iv,
-			 iv.data,
-			 cipher_key,
 			 ODP_AUTH_ALG_SHA1_HMAC,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 hmac_sha1_reference_plaintext[i],
-			 hmac_sha1_reference_length[i],
-			 NULL, 0,
-			 hmac_sha1_reference_digest[i],
-			 HMAC_SHA1_96_CHECK_LEN);
-	}
+			 &hmac_sha1_reference[i],
+			 false);
 }
 
 void crypto_test_check_alg_hmac_sha1(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = 0 };
-	uint8_t wrong_digest[HMAC_SHA1_DIGEST_LEN];
-
-	unsigned int test_vec_num = (sizeof(hmac_sha1_reference_length) /
-				     sizeof(hmac_sha1_reference_length[0]));
-
+	unsigned int test_vec_num = (sizeof(hmac_sha1_reference) /
+				     sizeof(hmac_sha1_reference[0]));
 	unsigned int i;
 
-	memset(wrong_digest, 0xa5, sizeof(wrong_digest));
-
-	for (i = 0; i < test_vec_num; i++) {
-		auth_key.data = hmac_sha1_reference_key[i];
-		auth_key.length = sizeof(hmac_sha1_reference_key[i]);
-
-		if (!check_auth_options(ODP_AUTH_ALG_SHA1_HMAC,
-					auth_key.length,
-					HMAC_SHA1_96_CHECK_LEN))
-			continue;
-
+	for (i = 0; i < test_vec_num; i++)
 		alg_test(ODP_CRYPTO_OP_DECODE,
-			 0,
 			 ODP_CIPHER_ALG_NULL,
-			 iv,
-			 iv.data,
-			 cipher_key,
 			 ODP_AUTH_ALG_SHA1_HMAC,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 hmac_sha1_reference_plaintext[i],
-			 hmac_sha1_reference_length[i],
-			 NULL, 0,
-			 hmac_sha1_reference_digest[i],
-			 HMAC_SHA1_96_CHECK_LEN);
-
-		alg_test(ODP_CRYPTO_OP_DECODE,
-			 1,
-			 ODP_CIPHER_ALG_NULL,
-			 iv,
-			 iv.data,
-			 cipher_key,
-			 ODP_AUTH_ALG_SHA1_HMAC,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 hmac_sha1_reference_plaintext[i],
-			 hmac_sha1_reference_length[i],
-			 NULL, 0,
-			 wrong_digest,
-			 HMAC_SHA1_96_CHECK_LEN);
-	}
+			 &hmac_sha1_reference[i],
+			 false);
 }
 
 static int check_alg_hmac_sha256(void)
@@ -1497,97 +945,30 @@  static int check_alg_hmac_sha256(void)
  * */
 void crypto_test_gen_alg_hmac_sha256(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = 0 };
-
-	unsigned int test_vec_num = (sizeof(hmac_sha256_reference_length) /
-				     sizeof(hmac_sha256_reference_length[0]));
-
+	unsigned int test_vec_num = (sizeof(hmac_sha256_reference) /
+				     sizeof(hmac_sha256_reference[0]));
 	unsigned int i;
 
-	for (i = 0; i < test_vec_num; i++) {
-		auth_key.data = hmac_sha256_reference_key[i];
-		auth_key.length = sizeof(hmac_sha256_reference_key[i]);
-
-		if (!check_auth_options(ODP_AUTH_ALG_SHA256_HMAC,
-					auth_key.length,
-					hmac_sha256_reference_digest_length[i]))
-			continue;
-
+	for (i = 0; i < test_vec_num; i++)
 		alg_test(ODP_CRYPTO_OP_ENCODE,
-			 0,
 			 ODP_CIPHER_ALG_NULL,
-			 iv,
-			 iv.data,
-			 cipher_key,
 			 ODP_AUTH_ALG_SHA256_HMAC,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 hmac_sha256_reference_plaintext[i],
-			 hmac_sha256_reference_length[i],
-			 NULL, 0,
-			 hmac_sha256_reference_digest[i],
-			 hmac_sha256_reference_digest_length[i]);
-	}
+			 &hmac_sha256_reference[i],
+			 false);
 }
 
 void crypto_test_check_alg_hmac_sha256(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = 0 };
-	uint8_t wrong_digest[HMAC_SHA256_DIGEST_LEN];
-
-	unsigned int test_vec_num = (sizeof(hmac_sha256_reference_length) /
-				     sizeof(hmac_sha256_reference_length[0]));
-
+	unsigned int test_vec_num = (sizeof(hmac_sha256_reference) /
+				     sizeof(hmac_sha256_reference[0]));
 	unsigned int i;
 
-	memset(wrong_digest, 0xa5, sizeof(wrong_digest));
-
-	for (i = 0; i < test_vec_num; i++) {
-		auth_key.data = hmac_sha256_reference_key[i];
-		auth_key.length = sizeof(hmac_sha256_reference_key[i]);
-
-		if (!check_auth_options(ODP_AUTH_ALG_SHA256_HMAC,
-					auth_key.length,
-					hmac_sha256_reference_digest_length[i]))
-			continue;
-
-		alg_test(ODP_CRYPTO_OP_DECODE,
-			 0,
-			 ODP_CIPHER_ALG_NULL,
-			 iv,
-			 iv.data,
-			 cipher_key,
-			 ODP_AUTH_ALG_SHA256_HMAC,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 hmac_sha256_reference_plaintext[i],
-			 hmac_sha256_reference_length[i],
-			 NULL, 0,
-			 hmac_sha256_reference_digest[i],
-			 hmac_sha256_reference_digest_length[i]);
-
+	for (i = 0; i < test_vec_num; i++)
 		alg_test(ODP_CRYPTO_OP_DECODE,
-			 1,
 			 ODP_CIPHER_ALG_NULL,
-			 iv,
-			 iv.data,
-			 cipher_key,
 			 ODP_AUTH_ALG_SHA256_HMAC,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 hmac_sha256_reference_plaintext[i],
-			 hmac_sha256_reference_length[i],
-			 NULL, 0,
-			 wrong_digest,
-			 hmac_sha256_reference_digest_length[i]);
-	}
+			 &hmac_sha256_reference[i],
+			 false);
 }
 
 static int check_alg_hmac_sha512(void)
@@ -1604,97 +985,30 @@  static int check_alg_hmac_sha512(void)
  * */
 void crypto_test_gen_alg_hmac_sha512(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = 0 };
-
-	unsigned int test_vec_num = (sizeof(hmac_sha512_reference_length) /
-				     sizeof(hmac_sha512_reference_length[0]));
-
+	unsigned int test_vec_num = (sizeof(hmac_sha512_reference) /
+				     sizeof(hmac_sha512_reference[0]));
 	unsigned int i;
 
-	for (i = 0; i < test_vec_num; i++) {
-		auth_key.data = hmac_sha512_reference_key[i];
-		auth_key.length = sizeof(hmac_sha512_reference_key[i]);
-
-		if (!check_auth_options(ODP_AUTH_ALG_SHA512_HMAC,
-					auth_key.length,
-					HMAC_SHA512_256_CHECK_LEN))
-			continue;
-
+	for (i = 0; i < test_vec_num; i++)
 		alg_test(ODP_CRYPTO_OP_ENCODE,
-			 0,
 			 ODP_CIPHER_ALG_NULL,
-			 iv,
-			 iv.data,
-			 cipher_key,
 			 ODP_AUTH_ALG_SHA512_HMAC,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 hmac_sha512_reference_plaintext[i],
-			 hmac_sha512_reference_length[i],
-			 NULL, 0,
-			 hmac_sha512_reference_digest[i],
-			 HMAC_SHA512_256_CHECK_LEN);
-	}
+			 &hmac_sha512_reference[i],
+			 false);
 }
 
 void crypto_test_check_alg_hmac_sha512(void)
 {
-	odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 },
-			 auth_key   = { .data = NULL, .length = 0 };
-	odp_crypto_iv_t iv = { .data = NULL, .length = 0 };
-	uint8_t wrong_digest[HMAC_SHA512_DIGEST_LEN];
-
-	unsigned int test_vec_num = (sizeof(hmac_sha512_reference_length) /
-				     sizeof(hmac_sha512_reference_length[0]));
-
+	unsigned int test_vec_num = (sizeof(hmac_sha512_reference) /
+				     sizeof(hmac_sha512_reference[0]));
 	unsigned int i;
 
-	memset(wrong_digest, 0xa5, sizeof(wrong_digest));
-
-	for (i = 0; i < test_vec_num; i++) {
-		auth_key.data = hmac_sha512_reference_key[i];
-		auth_key.length = sizeof(hmac_sha512_reference_key[i]);
-
-		if (!check_auth_options(ODP_AUTH_ALG_SHA512_HMAC,
-					auth_key.length,
-					HMAC_SHA512_256_CHECK_LEN))
-			continue;
-
+	for (i = 0; i < test_vec_num; i++)
 		alg_test(ODP_CRYPTO_OP_DECODE,
-			 0,
 			 ODP_CIPHER_ALG_NULL,
-			 iv,
-			 iv.data,
-			 cipher_key,
 			 ODP_AUTH_ALG_SHA512_HMAC,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 hmac_sha512_reference_plaintext[i],
-			 hmac_sha512_reference_length[i],
-			 NULL, 0,
-			 hmac_sha512_reference_digest[i],
-			 HMAC_SHA512_256_CHECK_LEN);
-
-		alg_test(ODP_CRYPTO_OP_DECODE,
-			 1,
-			 ODP_CIPHER_ALG_NULL,
-			 iv,
-			 iv.data,
-			 cipher_key,
-			 ODP_AUTH_ALG_SHA512_HMAC,
-			 auth_key,
-			 NULL, NULL,
-			 NULL, 0,
-			 hmac_sha512_reference_plaintext[i],
-			 hmac_sha512_reference_length[i],
-			 NULL, 0,
-			 wrong_digest,
-			 HMAC_SHA512_256_CHECK_LEN);
-	}
+			 &hmac_sha512_reference[i],
+			 false);
 }
 
 int crypto_suite_sync_init(void)
diff --git a/test/common_plat/validation/api/crypto/test_vectors.h b/test/common_plat/validation/api/crypto/test_vectors.h
index bd8bf347..f9ca9eb5 100644
--- a/test/common_plat/validation/api/crypto/test_vectors.h
+++ b/test/common_plat/validation/api/crypto/test_vectors.h
@@ -9,442 +9,498 @@ 
 
 #include "test_vectors_len.h"
 
-/** length in bytes */
-static uint32_t null_reference_length[] = { 8, 16 };
-
-static uint8_t
-null_reference_plaintext[][NULL_MAX_DATA_LEN] = {
-	{0x32, 0x6a, 0x49, 0x4c, 0xd3, 0x3f, 0xe7, 0x56},
-
-	{0x84, 0x40, 0x1f, 0x78, 0xfe, 0x6c, 0x10, 0x87, 0x6d, 0x8e, 0xa2, 0x30,
-	 0x94, 0xea, 0x53, 0x09}
+typedef struct crypto_test_reference_s {
+	uint32_t cipher_key_length;
+	uint8_t cipher_key[MAX_KEY_LEN];
+	uint32_t auth_key_length;
+	uint8_t auth_key[MAX_KEY_LEN];
+	uint32_t iv_length;
+	uint8_t iv[MAX_IV_LEN];
+	uint32_t length;
+	uint8_t plaintext[MAX_DATA_LEN];
+	uint8_t ciphertext[MAX_DATA_LEN];
+	uint32_t aad_length;
+	uint8_t aad[MAX_AAD_LEN];
+	uint32_t digest_length;
+	uint8_t digest[MAX_DIGEST_LEN];
+} crypto_test_reference_t;
+
+static crypto_test_reference_t null_reference[] = {
+	{
+		.length = 8,
+		.plaintext = { 0x32, 0x6a, 0x49, 0x4c, 0xd3, 0x3f, 0xe7, 0x56 },
+		.ciphertext = { 0x32, 0x6a, 0x49, 0x4c, 0xd3, 0x3f, 0xe7, 0x56 }
+	},
+	{
+		.length = 16,
+		.plaintext = { 0x84, 0x40, 0x1f, 0x78, 0xfe, 0x6c, 0x10, 0x87,
+			       0x6d, 0x8e, 0xa2, 0x30, 0x94, 0xea, 0x53, 0x09 },
+		.ciphertext = { 0x84, 0x40, 0x1f, 0x78, 0xfe, 0x6c, 0x10, 0x87,
+			       0x6d, 0x8e, 0xa2, 0x30, 0x94, 0xea, 0x53, 0x09 }
+	}
 };
 
 /* TDES-CBC reference vectors, according to
  * "http://csrc.nist.gov/groups/STM/cavp/documents/des/DESMMT.pdf"
  */
-static uint8_t tdes_cbc_reference_key[][TDES_CBC_KEY_LEN] = {
-	{0x62, 0x7f, 0x46, 0x0e, 0x08, 0x10, 0x4a, 0x10, 0x43, 0xcd, 0x26, 0x5d,
-	 0x58, 0x40, 0xea, 0xf1, 0x31, 0x3e, 0xdf, 0x97, 0xdf, 0x2a, 0x8a, 0x8c,
-	 },
-
-	{0x37, 0xae, 0x5e, 0xbf, 0x46, 0xdf, 0xf2, 0xdc, 0x07, 0x54, 0xb9, 0x4f,
-	 0x31, 0xcb, 0xb3, 0x85, 0x5e, 0x7f, 0xd3, 0x6d, 0xc8, 0x70, 0xbf, 0xae}
-};
-
-static uint8_t tdes_cbc_reference_iv[][TDES_CBC_IV_LEN] = {
-	{0x8e, 0x29, 0xf7, 0x5e, 0xa7, 0x7e, 0x54, 0x75},
-
-	{0x3d, 0x1d, 0xe3, 0xcc, 0x13, 0x2e, 0x3b, 0x65}
-};
-
-/** length in bytes */
-static uint32_t tdes_cbc_reference_length[] = { 8, 16 };
-
-static uint8_t
-tdes_cbc_reference_plaintext[][TDES_CBC_MAX_DATA_LEN] = {
-	{0x32, 0x6a, 0x49, 0x4c, 0xd3, 0x3f, 0xe7, 0x56},
-
-	{0x84, 0x40, 0x1f, 0x78, 0xfe, 0x6c, 0x10, 0x87, 0x6d, 0x8e, 0xa2, 0x30,
-	 0x94, 0xea, 0x53, 0x09}
-};
-
-static uint8_t
-tdes_cbc_reference_ciphertext[][TDES_CBC_MAX_DATA_LEN] = {
-	{0xb2, 0x2b, 0x8d, 0x66, 0xde, 0x97, 0x06, 0x92},
-
-	{0x7b, 0x1f, 0x7c, 0x7e, 0x3b, 0x1c, 0x94, 0x8e, 0xbd, 0x04, 0xa7, 0x5f,
-	 0xfb, 0xa7, 0xd2, 0xf5}
-};
-
-static uint8_t aes128_cbc_reference_key[][AES128_CBC_KEY_LEN] = {
-	{0x06, 0xa9, 0x21, 0x40, 0x36, 0xb8, 0xa1, 0x5b,
-	 0x51, 0x2e, 0x03, 0xd5, 0x34, 0x12, 0x00, 0x06 },
-	{0xc2, 0x86, 0x69, 0x6d, 0x88, 0x7c, 0x9a, 0xa0,
-	 0x61, 0x1b, 0xbb, 0x3e, 0x20, 0x25, 0xa4, 0x5a },
-	{0x6c, 0x3e, 0xa0, 0x47, 0x76, 0x30, 0xce, 0x21,
-	 0xa2, 0xce, 0x33, 0x4a, 0xa7, 0x46, 0xc2, 0xcd },
-	{0x56, 0xe4, 0x7a, 0x38, 0xc5, 0x59, 0x89, 0x74,
-	 0xbc, 0x46, 0x90, 0x3d, 0xba, 0x29, 0x03, 0x49 }
+static crypto_test_reference_t tdes_cbc_reference[] = {
+	{
+		.cipher_key_length = TDES_CBC_KEY_LEN,
+		.cipher_key = { 0x62, 0x7f, 0x46, 0x0e, 0x08, 0x10, 0x4a, 0x10,
+				0x43, 0xcd, 0x26, 0x5d, 0x58, 0x40, 0xea, 0xf1,
+				0x31, 0x3e, 0xdf, 0x97, 0xdf, 0x2a, 0x8a, 0x8c},
+		.iv_length = TDES_CBC_IV_LEN,
+		.iv = { 0x8e, 0x29, 0xf7, 0x5e, 0xa7, 0x7e, 0x54, 0x75 },
+		.length = 8,
+		.plaintext = { 0x32, 0x6a, 0x49, 0x4c, 0xd3, 0x3f, 0xe7, 0x56 },
+		.ciphertext = { 0xb2, 0x2b, 0x8d, 0x66, 0xde, 0x97, 0x06, 0x92 }
+	},
+	{
+		.cipher_key_length = TDES_CBC_KEY_LEN,
+		.cipher_key = { 0x37, 0xae, 0x5e, 0xbf, 0x46, 0xdf, 0xf2, 0xdc,
+				0x07, 0x54, 0xb9, 0x4f, 0x31, 0xcb, 0xb3, 0x85,
+				0x5e, 0x7f, 0xd3, 0x6d, 0xc8, 0x70, 0xbf, 0xae},
+		.iv_length = TDES_CBC_IV_LEN,
+		.iv = {0x3d, 0x1d, 0xe3, 0xcc, 0x13, 0x2e, 0x3b, 0x65 },
+		.length = 16,
+		.plaintext = { 0x84, 0x40, 0x1f, 0x78, 0xfe, 0x6c, 0x10, 0x87,
+			       0x6d, 0x8e, 0xa2, 0x30, 0x94, 0xea, 0x53, 0x09 },
+		.ciphertext = { 0x7b, 0x1f, 0x7c, 0x7e, 0x3b, 0x1c, 0x94, 0x8e,
+				0xbd, 0x04, 0xa7, 0x5f, 0xfb, 0xa7, 0xd2, 0xf5 }
+	}
 };
 
-static uint8_t aes128_cbc_reference_iv[][AES128_CBC_IV_LEN] = {
-	{ 0x3d, 0xaf, 0xba, 0x42, 0x9d, 0x9e, 0xb4, 0x30,
-	  0xb4, 0x22, 0xda, 0x80, 0x2c, 0x9f, 0xac, 0x41 },
-	{ 0x56, 0x2e, 0x17, 0x99, 0x6d, 0x09, 0x3d, 0x28,
-	  0xdd, 0xb3, 0xba, 0x69, 0x5a, 0x2e, 0x6f, 0x58 },
-	{ 0xc7, 0x82, 0xdc, 0x4c, 0x09, 0x8c, 0x66, 0xcb,
-	  0xd9, 0xcd, 0x27, 0xd8, 0x25, 0x68, 0x2c, 0x81 },
-	{ 0x8c, 0xe8, 0x2e, 0xef, 0xbe, 0xa0, 0xda, 0x3c,
-	  0x44, 0x69, 0x9e, 0xd7, 0xdb, 0x51, 0xb7, 0xd9 }
-};
-
-/** length in bytes */
-static uint32_t aes128_cbc_reference_length[] = { 16, 32, 48, 64 };
-
-static uint8_t
-aes128_cbc_reference_plaintext[][AES128_CBC_MAX_DATA_LEN] = {
-	"Single block msg",
-	{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-	  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-	  0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-	  0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
-	"This is a 48-byte message (exactly 3 AES blocks)",
-	{ 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
-	  0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
-	  0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
-	  0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
-	  0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
-	  0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
-	  0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
-	  0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf }
-};
-
-static uint8_t
-aes128_cbc_reference_ciphertext[][AES128_CBC_MAX_DATA_LEN] = {
-	{ 0xe3, 0x53, 0x77, 0x9c, 0x10, 0x79, 0xae, 0xb8,
-	  0x27, 0x08, 0x94, 0x2d, 0xbe, 0x77, 0x18, 0x1a },
-	{ 0xd2, 0x96, 0xcd, 0x94, 0xc2, 0xcc, 0xcf, 0x8a,
-	  0x3a, 0x86, 0x30, 0x28, 0xb5, 0xe1, 0xdc, 0x0a,
-	  0x75, 0x86, 0x60, 0x2d, 0x25, 0x3c, 0xff, 0xf9,
-	  0x1b, 0x82, 0x66, 0xbe, 0xa6, 0xd6, 0x1a, 0xb1 },
-	{ 0xd0, 0xa0, 0x2b, 0x38, 0x36, 0x45, 0x17, 0x53,
-	  0xd4, 0x93, 0x66, 0x5d, 0x33, 0xf0, 0xe8, 0x86,
-	  0x2d, 0xea, 0x54, 0xcd, 0xb2, 0x93, 0xab, 0xc7,
-	  0x50, 0x69, 0x39, 0x27, 0x67, 0x72, 0xf8, 0xd5,
-	  0x02, 0x1c, 0x19, 0x21, 0x6b, 0xad, 0x52, 0x5c,
-	  0x85, 0x79, 0x69, 0x5d, 0x83, 0xba, 0x26, 0x84 },
-	{ 0xc3, 0x0e, 0x32, 0xff, 0xed, 0xc0, 0x77, 0x4e,
-	  0x6a, 0xff, 0x6a, 0xf0, 0x86, 0x9f, 0x71, 0xaa,
-	  0x0f, 0x3a, 0xf0, 0x7a, 0x9a, 0x31, 0xa9, 0xc6,
-	  0x84, 0xdb, 0x20, 0x7e, 0xb0, 0xef, 0x8e, 0x4e,
-	  0x35, 0x90, 0x7a, 0xa6, 0x32, 0xc3, 0xff, 0xdf,
-	  0x86, 0x8b, 0xb7, 0xb2, 0x9d, 0x3d, 0x46, 0xad,
-	  0x83, 0xce, 0x9f, 0x9a, 0x10, 0x2e, 0xe9, 0x9d,
-	  0x49, 0xa5, 0x3e, 0x87, 0xf4, 0xc3, 0xda, 0x55 }
+static crypto_test_reference_t aes128_cbc_reference[] = {
+	{
+		.cipher_key_length = AES128_CBC_KEY_LEN,
+		.cipher_key = { 0x06, 0xa9, 0x21, 0x40, 0x36, 0xb8, 0xa1, 0x5b,
+				0x51, 0x2e, 0x03, 0xd5, 0x34, 0x12, 0x00, 0x06},
+		.iv_length = AES128_CBC_IV_LEN,
+		.iv = { 0x3d, 0xaf, 0xba, 0x42, 0x9d, 0x9e, 0xb4, 0x30,
+			0xb4, 0x22, 0xda, 0x80, 0x2c, 0x9f, 0xac, 0x41 },
+		.length = 16,
+		.plaintext = "Single block msg",
+		.ciphertext = { 0xe3, 0x53, 0x77, 0x9c, 0x10, 0x79, 0xae, 0xb8,
+				0x27, 0x08, 0x94, 0x2d, 0xbe, 0x77, 0x18, 0x1a }
+	},
+	{
+		.cipher_key_length = AES128_CBC_KEY_LEN,
+		.cipher_key = { 0xc2, 0x86, 0x69, 0x6d, 0x88, 0x7c, 0x9a, 0xa0,
+				0x61, 0x1b, 0xbb, 0x3e, 0x20, 0x25, 0xa4, 0x5a},
+		.iv_length = AES128_CBC_IV_LEN,
+		.iv = { 0x56, 0x2e, 0x17, 0x99, 0x6d, 0x09, 0x3d, 0x28,
+			0xdd, 0xb3, 0xba, 0x69, 0x5a, 0x2e, 0x6f, 0x58 },
+		.length = 32,
+		.plaintext = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+			       0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+			       0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+			       0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
+		.ciphertext = { 0xd2, 0x96, 0xcd, 0x94, 0xc2, 0xcc, 0xcf, 0x8a,
+				0x3a, 0x86, 0x30, 0x28, 0xb5, 0xe1, 0xdc, 0x0a,
+				0x75, 0x86, 0x60, 0x2d, 0x25, 0x3c, 0xff, 0xf9,
+				0x1b, 0x82, 0x66, 0xbe, 0xa6, 0xd6, 0x1a, 0xb1 }
+	},
+	{
+		.cipher_key_length = AES128_CBC_KEY_LEN,
+		.cipher_key = { 0x6c, 0x3e, 0xa0, 0x47, 0x76, 0x30, 0xce, 0x21,
+				0xa2, 0xce, 0x33, 0x4a, 0xa7, 0x46, 0xc2, 0xcd},
+		.iv_length = AES128_CBC_IV_LEN,
+		.iv = { 0xc7, 0x82, 0xdc, 0x4c, 0x09, 0x8c, 0x66, 0xcb,
+			0xd9, 0xcd, 0x27, 0xd8, 0x25, 0x68, 0x2c, 0x81 },
+		.length = 48,
+		.plaintext = "This is a 48-byte message (exactly 3 AES blocks)",
+		.ciphertext = { 0xd0, 0xa0, 0x2b, 0x38, 0x36, 0x45, 0x17, 0x53,
+				0xd4, 0x93, 0x66, 0x5d, 0x33, 0xf0, 0xe8, 0x86,
+				0x2d, 0xea, 0x54, 0xcd, 0xb2, 0x93, 0xab, 0xc7,
+				0x50, 0x69, 0x39, 0x27, 0x67, 0x72, 0xf8, 0xd5,
+				0x02, 0x1c, 0x19, 0x21, 0x6b, 0xad, 0x52, 0x5c,
+				0x85, 0x79, 0x69, 0x5d, 0x83, 0xba, 0x26, 0x84 }
+	},
+	{
+		.cipher_key_length = AES128_CBC_KEY_LEN,
+		.cipher_key = { 0x56, 0xe4, 0x7a, 0x38, 0xc5, 0x59, 0x89, 0x74,
+				0xbc, 0x46, 0x90, 0x3d, 0xba, 0x29, 0x03, 0x49},
+		.iv_length = AES128_CBC_IV_LEN,
+		.iv = { 0x8c, 0xe8, 0x2e, 0xef, 0xbe, 0xa0, 0xda, 0x3c,
+			0x44, 0x69, 0x9e, 0xd7, 0xdb, 0x51, 0xb7, 0xd9 },
+		.length = 64,
+		.plaintext = { 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+			       0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+			       0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+			       0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+			       0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+			       0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+			       0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+			       0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf },
+		.ciphertext = { 0xc3, 0x0e, 0x32, 0xff, 0xed, 0xc0, 0x77, 0x4e,
+				0x6a, 0xff, 0x6a, 0xf0, 0x86, 0x9f, 0x71, 0xaa,
+				0x0f, 0x3a, 0xf0, 0x7a, 0x9a, 0x31, 0xa9, 0xc6,
+				0x84, 0xdb, 0x20, 0x7e, 0xb0, 0xef, 0x8e, 0x4e,
+				0x35, 0x90, 0x7a, 0xa6, 0x32, 0xc3, 0xff, 0xdf,
+				0x86, 0x8b, 0xb7, 0xb2, 0x9d, 0x3d, 0x46, 0xad,
+				0x83, 0xce, 0x9f, 0x9a, 0x10, 0x2e, 0xe9, 0x9d,
+				0x49, 0xa5, 0x3e, 0x87, 0xf4, 0xc3, 0xda, 0x55 }
+	}
 };
 
 /* AES-GCM test vectors extracted from
  * https://tools.ietf.org/html/draft-mcgrew-gcm-test-01#section-2
  */
-static uint8_t aes128_gcm_reference_key[][AES128_GCM_KEY_LEN] = {
-	{ 0x4c, 0x80, 0xcd, 0xef, 0xbb, 0x5d, 0x10, 0xda,
-	  0x90, 0x6a, 0xc7, 0x3c, 0x36, 0x13, 0xa6, 0x34 },
-	{ 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
-	  0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08 },
-	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
-	{ 0x3d, 0xe0, 0x98, 0x74, 0xb3, 0x88, 0xe6, 0x49,
-	  0x19, 0x88, 0xd0, 0xc3, 0x60, 0x7e, 0xae, 0x1f }
-};
-
-static uint8_t aes128_gcm_reference_iv[][AES128_GCM_IV_LEN] = {
-	{ 0x2e, 0x44, 0x3b, 0x68, 0x49, 0x56, 0xed, 0x7e,
-	  0x3b, 0x24, 0x4c, 0xfe },
-	{ 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
-	  0xde, 0xca, 0xf8, 0x88 },
-	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	  0x00, 0x00, 0x00, 0x00 },
-	{ 0x57, 0x69, 0x0e, 0x43, 0x4e, 0x28, 0x00, 0x00,
-	  0xa2, 0xfc, 0xa1, 0xa3 }
+static crypto_test_reference_t aes128_gcm_reference[] = {
+	{
+		.cipher_key_length = AES128_GCM_KEY_LEN,
+		.cipher_key = { 0x4c, 0x80, 0xcd, 0xef, 0xbb, 0x5d, 0x10, 0xda,
+				0x90, 0x6a, 0xc7, 0x3c, 0x36, 0x13, 0xa6, 0x34},
+		.iv_length = AES128_GCM_IV_LEN,
+		.iv = { 0x2e, 0x44, 0x3b, 0x68, 0x49, 0x56, 0xed, 0x7e,
+			0x3b, 0x24, 0x4c, 0xfe },
+		.length = 72,
+		.plaintext = { 0x45, 0x00, 0x00, 0x48, 0x69, 0x9a, 0x00, 0x00,
+			       0x80, 0x11, 0x4d, 0xb7, 0xc0, 0xa8, 0x01, 0x02,
+			       0xc0, 0xa8, 0x01, 0x01, 0x0a, 0x9b, 0xf1, 0x56,
+			       0x38, 0xd3, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00,
+			       0x00, 0x00, 0x00, 0x00, 0x04, 0x5f, 0x73, 0x69,
+			       0x70, 0x04, 0x5f, 0x75, 0x64, 0x70, 0x03, 0x73,
+			       0x69, 0x70, 0x09, 0x63, 0x79, 0x62, 0x65, 0x72,
+			       0x63, 0x69, 0x74, 0x79, 0x02, 0x64, 0x6b, 0x00,
+			       0x00, 0x21, 0x00, 0x01, 0x01, 0x02, 0x02, 0x01 },
+		.ciphertext = { 0xfe, 0xcf, 0x53, 0x7e, 0x72, 0x9d, 0x5b, 0x07,
+				0xdc, 0x30, 0xdf, 0x52, 0x8d, 0xd2, 0x2b, 0x76,
+				0x8d, 0x1b, 0x98, 0x73, 0x66, 0x96, 0xa6, 0xfd,
+				0x34, 0x85, 0x09, 0xfa, 0x13, 0xce, 0xac, 0x34,
+				0xcf, 0xa2, 0x43, 0x6f, 0x14, 0xa3, 0xf3, 0xcf,
+				0x65, 0x92, 0x5b, 0xf1, 0xf4, 0xa1, 0x3c, 0x5d,
+				0x15, 0xb2, 0x1e, 0x18, 0x84, 0xf5, 0xff, 0x62,
+				0x47, 0xae, 0xab, 0xb7, 0x86, 0xb9, 0x3b, 0xce,
+				0x61, 0xbc, 0x17, 0xd7, 0x68, 0xfd, 0x97, 0x32},
+		.aad_length = 12,
+		.aad = { 0x00, 0x00, 0x43, 0x21, 0x87, 0x65, 0x43, 0x21,
+			 0x00, 0x00, 0x00, 0x00 },
+		.digest_length = AES128_GCM_DIGEST_LEN,
+		.digest = { 0x45, 0x90, 0x18, 0x14, 0x8f, 0x6c, 0xbe, 0x72,
+			    0x2f, 0xd0, 0x47, 0x96, 0x56, 0x2d, 0xfd, 0xb4  }
+	},
+	{
+		.cipher_key_length = AES128_GCM_KEY_LEN,
+		.cipher_key = { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
+				0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08},
+		.iv_length = AES128_GCM_IV_LEN,
+		.iv = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
+			0xde, 0xca, 0xf8, 0x88 },
+		.length = 64,
+		.plaintext = { 0x45, 0x00, 0x00, 0x3e, 0x69, 0x8f, 0x00, 0x00,
+			       0x80, 0x11, 0x4d, 0xcc, 0xc0, 0xa8, 0x01, 0x02,
+			       0xc0, 0xa8, 0x01, 0x01, 0x0a, 0x98, 0x00, 0x35,
+			       0x00, 0x2a, 0x23, 0x43, 0xb2, 0xd0, 0x01, 0x00,
+			       0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			       0x03, 0x73, 0x69, 0x70, 0x09, 0x63, 0x79, 0x62,
+			       0x65, 0x72, 0x63, 0x69, 0x74, 0x79, 0x02, 0x64,
+			       0x6b, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01 },
+		.ciphertext = { 0xde, 0xb2, 0x2c, 0xd9, 0xb0, 0x7c, 0x72, 0xc1,
+				0x6e, 0x3a, 0x65, 0xbe, 0xeb, 0x8d, 0xf3, 0x04,
+				0xa5, 0xa5, 0x89, 0x7d, 0x33, 0xae, 0x53, 0x0f,
+				0x1b, 0xa7, 0x6d, 0x5d, 0x11, 0x4d, 0x2a, 0x5c,
+				0x3d, 0xe8, 0x18, 0x27, 0xc1, 0x0e, 0x9a, 0x4f,
+				0x51, 0x33, 0x0d, 0x0e, 0xec, 0x41, 0x66, 0x42,
+				0xcf, 0xbb, 0x85, 0xa5, 0xb4, 0x7e, 0x48, 0xa4,
+				0xec, 0x3b, 0x9b, 0xa9, 0x5d, 0x91, 0x8b, 0xd1},
+		.aad_length = 8,
+		.aad = { 0x00, 0x00, 0xa5, 0xf8, 0x00, 0x00, 0x00, 0x0a },
+		.digest_length = AES128_GCM_DIGEST_LEN,
+		.digest = { 0x83, 0xb7, 0x0d, 0x3a, 0xa8, 0xbc, 0x6e, 0xe4,
+			    0xc3, 0x09, 0xe9, 0xd8, 0x5a, 0x41, 0xad, 0x4a }
+	},
+	{
+		.cipher_key_length = AES128_GCM_KEY_LEN,
+		.cipher_key = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+		.iv_length = AES128_GCM_IV_LEN,
+		.iv = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00 },
+		.length = 64,
+		.plaintext = { 0x45, 0x00, 0x00, 0x3c, 0x99, 0xc5, 0x00, 0x00,
+			       0x80, 0x01, 0xcb, 0x7a, 0x40, 0x67, 0x93, 0x18,
+			       0x01, 0x01, 0x01, 0x01, 0x08, 0x00, 0x07, 0x5c,
+			       0x02, 0x00, 0x44, 0x00, 0x61, 0x62, 0x63, 0x64,
+			       0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c,
+			       0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
+			       0x75, 0x76, 0x77, 0x61, 0x62, 0x63, 0x64, 0x65,
+			       0x66, 0x67, 0x68, 0x69, 0x01, 0x02, 0x02, 0x01 },
+		.ciphertext = { 0x46, 0x88, 0xda, 0xf2, 0xf9, 0x73, 0xa3, 0x92,
+				0x73, 0x29, 0x09, 0xc3, 0x31, 0xd5, 0x6d, 0x60,
+				0xf6, 0x94, 0xab, 0xaa, 0x41, 0x4b, 0x5e, 0x7f,
+				0xf5, 0xfd, 0xcd, 0xff, 0xf5, 0xe9, 0xa2, 0x84,
+				0x45, 0x64, 0x76, 0x49, 0x27, 0x19, 0xff, 0xb6,
+				0x4d, 0xe7, 0xd9, 0xdc, 0xa1, 0xe1, 0xd8, 0x94,
+				0xbc, 0x3b, 0xd5, 0x78, 0x73, 0xed, 0x4d, 0x18,
+				0x1d, 0x19, 0xd4, 0xd5, 0xc8, 0xc1, 0x8a, 0xf3},
+		.aad_length = 8,
+		.aad = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
+		.digest_length = AES128_GCM_DIGEST_LEN,
+		.digest = { 0xf8, 0x21, 0xd4, 0x96, 0xee, 0xb0, 0x96, 0xe9,
+			    0x8a, 0xd2, 0xb6, 0x9e, 0x47, 0x99, 0xc7, 0x1d }
+	},
+	{
+		.cipher_key_length = AES128_GCM_KEY_LEN,
+		.cipher_key = { 0x3d, 0xe0, 0x98, 0x74, 0xb3, 0x88, 0xe6, 0x49,
+				0x19, 0x88, 0xd0, 0xc3, 0x60, 0x7e, 0xae, 0x1f},
+		.iv_length = AES128_GCM_IV_LEN,
+		.iv = { 0x57, 0x69, 0x0e, 0x43, 0x4e, 0x28, 0x00, 0x00,
+			0xa2, 0xfc, 0xa1, 0xa3 },
+		.length = 28,
+		.plaintext = { 0x45, 0x00, 0x00, 0x1c, 0x42, 0xa2, 0x00, 0x00,
+			       0x80, 0x01, 0x44, 0x1f, 0x40, 0x67, 0x93, 0xb6,
+			       0xe0, 0x00, 0x00, 0x02, 0x0a, 0x00, 0xf5, 0xff,
+			       0x01, 0x02, 0x02, 0x01 },
+		.ciphertext = { 0xfb, 0xa2, 0xca, 0x84, 0x5e, 0x5d, 0xf9, 0xf0,
+				0xf2, 0x2c, 0x3e, 0x6e, 0x86, 0xdd, 0x83, 0x1e,
+				0x1f, 0xc6, 0x57, 0x92, 0xcd, 0x1a, 0xf9, 0x13,
+				0x0e, 0x13, 0x79, 0xed },
+		.aad_length = 12,
+		.aad = { 0x42, 0xf6, 0x7e, 0x3f, 0x10, 0x10, 0x10, 0x10,
+			 0x10, 0x10, 0x10, 0x10 },
+		.digest_length = AES128_GCM_DIGEST_LEN,
+		.digest = { 0x36, 0x9f, 0x07, 0x1f, 0x35, 0xe0, 0x34, 0xbe,
+			    0x95, 0xf1, 0x12, 0xe4, 0xe7, 0xd0, 0x5d, 0x35 }
+	},
 };
 
-static uint32_t aes128_gcm_reference_length[] = { 72, 64, 64, 28};
-
-static uint32_t aes128_gcm_reference_tag_length[] = { 16, 16, 16, 16};
-
-static uint32_t aes128_gcm_reference_aad_length[] = { 12, 8, 8, 12};
-
-static odp_packet_data_range_t aes128_gcm_cipher_range[] = {
-	{ .offset = 0, .length = 72 },
-	{ .offset = 0, .length = 64 },
-	{ .offset = 0, .length = 64 },
-	{ .offset = 0, .length = 28 },
-};
-
-static uint8_t aes128_gcm_reference_aad[][AES128_GCM_MAX_DATA_LEN] = {
-	{ 0x00, 0x00, 0x43, 0x21, 0x87, 0x65, 0x43, 0x21,
-	  0x00, 0x00, 0x00, 0x00, },
-	{ 0x00, 0x00, 0xa5, 0xf8, 0x00, 0x00, 0x00, 0x0a, },
-	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, },
-	{ 0x42, 0xf6, 0x7e, 0x3f, 0x10, 0x10, 0x10, 0x10,
-	  0x10, 0x10, 0x10, 0x10, },
-};
-
-static uint8_t
-aes128_gcm_reference_plaintext[][AES128_GCM_MAX_DATA_LEN] = {
-	{ 0x45, 0x00, 0x00, 0x48, 0x69, 0x9a, 0x00, 0x00,
-	  0x80, 0x11, 0x4d, 0xb7, 0xc0, 0xa8, 0x01, 0x02,
-	  0xc0, 0xa8, 0x01, 0x01, 0x0a, 0x9b, 0xf1, 0x56,
-	  0x38, 0xd3, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00,
-	  0x00, 0x00, 0x00, 0x00, 0x04, 0x5f, 0x73, 0x69,
-	  0x70, 0x04, 0x5f, 0x75, 0x64, 0x70, 0x03, 0x73,
-	  0x69, 0x70, 0x09, 0x63, 0x79, 0x62, 0x65, 0x72,
-	  0x63, 0x69, 0x74, 0x79, 0x02, 0x64, 0x6b, 0x00,
-	  0x00, 0x21, 0x00, 0x01, 0x01, 0x02, 0x02, 0x01 },
-
-	{ 0x45, 0x00, 0x00, 0x3e, 0x69, 0x8f, 0x00, 0x00,
-	  0x80, 0x11, 0x4d, 0xcc, 0xc0, 0xa8, 0x01, 0x02,
-	  0xc0, 0xa8, 0x01, 0x01, 0x0a, 0x98, 0x00, 0x35,
-	  0x00, 0x2a, 0x23, 0x43, 0xb2, 0xd0, 0x01, 0x00,
-	  0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	  0x03, 0x73, 0x69, 0x70, 0x09, 0x63, 0x79, 0x62,
-	  0x65, 0x72, 0x63, 0x69, 0x74, 0x79, 0x02, 0x64,
-	  0x6b, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01 },
-
-	{ 0x45, 0x00, 0x00, 0x3c, 0x99, 0xc5, 0x00, 0x00,
-	  0x80, 0x01, 0xcb, 0x7a, 0x40, 0x67, 0x93, 0x18,
-	  0x01, 0x01, 0x01, 0x01, 0x08, 0x00, 0x07, 0x5c,
-	  0x02, 0x00, 0x44, 0x00, 0x61, 0x62, 0x63, 0x64,
-	  0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c,
-	  0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
-	  0x75, 0x76, 0x77, 0x61, 0x62, 0x63, 0x64, 0x65,
-	  0x66, 0x67, 0x68, 0x69, 0x01, 0x02, 0x02, 0x01 },
-
-	{ 0x45, 0x00, 0x00, 0x1c, 0x42, 0xa2, 0x00, 0x00,
-	  0x80, 0x01, 0x44, 0x1f, 0x40, 0x67, 0x93, 0xb6,
-	  0xe0, 0x00, 0x00, 0x02, 0x0a, 0x00, 0xf5, 0xff,
-	  0x01, 0x02, 0x02, 0x01 }
-};
-
-static uint8_t
-aes128_gcm_reference_ciphertext[][AES128_GCM_MAX_DATA_LEN] = {
-	{ /* Plain */
-	  0xfe, 0xcf, 0x53, 0x7e, 0x72, 0x9d, 0x5b, 0x07,
-	  0xdc, 0x30, 0xdf, 0x52, 0x8d, 0xd2, 0x2b, 0x76,
-	  0x8d, 0x1b, 0x98, 0x73, 0x66, 0x96, 0xa6, 0xfd,
-	  0x34, 0x85, 0x09, 0xfa, 0x13, 0xce, 0xac, 0x34,
-	  0xcf, 0xa2, 0x43, 0x6f, 0x14, 0xa3, 0xf3, 0xcf,
-	  0x65, 0x92, 0x5b, 0xf1, 0xf4, 0xa1, 0x3c, 0x5d,
-	  0x15, 0xb2, 0x1e, 0x18, 0x84, 0xf5, 0xff, 0x62,
-	  0x47, 0xae, 0xab, 0xb7, 0x86, 0xb9, 0x3b, 0xce,
-	  0x61, 0xbc, 0x17, 0xd7, 0x68, 0xfd, 0x97, 0x32,
-	  /* Digest */
-	  0x45, 0x90, 0x18, 0x14, 0x8f, 0x6c, 0xbe, 0x72,
-	  0x2f, 0xd0, 0x47, 0x96, 0x56, 0x2d, 0xfd, 0xb4  },
-
-	{ /* Plain */
-	  0xde, 0xb2, 0x2c, 0xd9, 0xb0, 0x7c, 0x72, 0xc1,
-	  0x6e, 0x3a, 0x65, 0xbe, 0xeb, 0x8d, 0xf3, 0x04,
-	  0xa5, 0xa5, 0x89, 0x7d, 0x33, 0xae, 0x53, 0x0f,
-	  0x1b, 0xa7, 0x6d, 0x5d, 0x11, 0x4d, 0x2a, 0x5c,
-	  0x3d, 0xe8, 0x18, 0x27, 0xc1, 0x0e, 0x9a, 0x4f,
-	  0x51, 0x33, 0x0d, 0x0e, 0xec, 0x41, 0x66, 0x42,
-	  0xcf, 0xbb, 0x85, 0xa5, 0xb4, 0x7e, 0x48, 0xa4,
-	  0xec, 0x3b, 0x9b, 0xa9, 0x5d, 0x91, 0x8b, 0xd1,
-	  /* Digest */
-	  0x83, 0xb7, 0x0d, 0x3a, 0xa8, 0xbc, 0x6e, 0xe4,
-	  0xc3, 0x09, 0xe9, 0xd8, 0x5a, 0x41, 0xad, 0x4a },
-
-	{ /* Plain */
-	  0x46, 0x88, 0xda, 0xf2, 0xf9, 0x73, 0xa3, 0x92,
-	  0x73, 0x29, 0x09, 0xc3, 0x31, 0xd5, 0x6d, 0x60,
-	  0xf6, 0x94, 0xab, 0xaa, 0x41, 0x4b, 0x5e, 0x7f,
-	  0xf5, 0xfd, 0xcd, 0xff, 0xf5, 0xe9, 0xa2, 0x84,
-	  0x45, 0x64, 0x76, 0x49, 0x27, 0x19, 0xff, 0xb6,
-	  0x4d, 0xe7, 0xd9, 0xdc, 0xa1, 0xe1, 0xd8, 0x94,
-	  0xbc, 0x3b, 0xd5, 0x78, 0x73, 0xed, 0x4d, 0x18,
-	  0x1d, 0x19, 0xd4, 0xd5, 0xc8, 0xc1, 0x8a, 0xf3,
-	  /* Digest */
-	  0xf8, 0x21, 0xd4, 0x96, 0xee, 0xb0, 0x96, 0xe9,
-	  0x8a, 0xd2, 0xb6, 0x9e, 0x47, 0x99, 0xc7, 0x1d },
-
-	{ /* Plain */
-	  0xfb, 0xa2, 0xca, 0x84, 0x5e, 0x5d, 0xf9, 0xf0,
-	  0xf2, 0x2c, 0x3e, 0x6e, 0x86, 0xdd, 0x83, 0x1e,
-	  0x1f, 0xc6, 0x57, 0x92, 0xcd, 0x1a, 0xf9, 0x13,
-	  0x0e, 0x13, 0x79, 0xed,
-	  /* Digest */
-	  0x36, 0x9f, 0x07, 0x1f, 0x35, 0xe0, 0x34, 0xbe,
-	  0x95, 0xf1, 0x12, 0xe4, 0xe7, 0xd0, 0x5d, 0x35 }
+static crypto_test_reference_t hmac_md5_reference[] = {
+	{
+		.auth_key_length = HMAC_MD5_KEY_LEN,
+		.auth_key = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+			      0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b },
+		.length = 8,
+		/* "Hi There" */
+		.plaintext = { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65},
+		.ciphertext = { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65},
+		.digest_length = HMAC_MD5_96_CHECK_LEN,
+		.digest = { 0x92, 0x94, 0x72, 0x7a, 0x36, 0x38, 0xbb, 0x1c,
+			    0x13, 0xf4, 0x8e, 0xf8, 0x15, 0x8b, 0xfc, 0x9d },
+
+	},
+	{
+		.auth_key_length = HMAC_MD5_KEY_LEN,
+		/* "Jefe" */
+		.auth_key = { 0x4a, 0x65, 0x66, 0x65 },
+		.length = 28,
+		/* what do ya want for nothing?*/
+		.plaintext = { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20,
+			       0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20,
+			       0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68,
+			       0x69, 0x6e, 0x67, 0x3f },
+		.ciphertext = { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20,
+				0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20,
+				0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68,
+				0x69, 0x6e, 0x67, 0x3f },
+		.digest_length = HMAC_MD5_96_CHECK_LEN,
+		.digest = { 0x75, 0x0c, 0x78, 0x3e, 0x6a, 0xb0, 0xb5, 0x03,
+			    0xea, 0xa8, 0x6e, 0x31, 0x0a, 0x5d, 0xb7, 0x38 },
+
+	},
+	{
+		.auth_key_length = HMAC_MD5_KEY_LEN,
+		.auth_key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+			      0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa },
+		.length = 50,
+		.plaintext = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd },
+		.ciphertext = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd },
+		.digest_length = HMAC_MD5_96_CHECK_LEN,
+		.digest = { 0x56, 0xbe, 0x34, 0x52, 0x1d, 0x14, 0x4c, 0x88,
+			    0xdb, 0xb8, 0xc7, 0x33, 0xf0, 0xe8, 0xb3, 0xf6 }
+	}
 };
 
-static uint8_t hmac_md5_reference_key[][HMAC_MD5_KEY_LEN] = {
-	{ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-	  0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b },
-
-	/* "Jefe" */
-	{ 0x4a, 0x65, 0x66, 0x65 },
-
-	{ 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	  0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa }
+static crypto_test_reference_t hmac_sha1_reference[] = {
+	{
+		.auth_key_length = HMAC_SHA1_KEY_LEN,
+		.auth_key = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+			      0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+			      0x0b, 0x0b, 0x0b, 0x0b },
+		.length = 8,
+		/* "Hi There" */
+		.plaintext = { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65},
+		.ciphertext = { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65},
+		.digest_length = HMAC_SHA1_96_CHECK_LEN,
+		.digest = { 0xb6, 0x17, 0x31, 0x86, 0x55, 0x05,
+			    0x72, 0x64, 0xe2, 0x8b, 0xc0, 0xb6 }
+	},
+	{
+		.auth_key_length = HMAC_SHA1_KEY_LEN,
+		/* "Jefe" */
+		.auth_key = { 0x4a, 0x65, 0x66, 0x65 },
+		.length = 28,
+		/* what do ya want for nothing?*/
+		.plaintext = { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20,
+			       0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20,
+			       0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68,
+			       0x69, 0x6e, 0x67, 0x3f },
+		.ciphertext = { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20,
+				0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20,
+				0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68,
+				0x69, 0x6e, 0x67, 0x3f },
+		.digest_length = HMAC_SHA1_96_CHECK_LEN,
+		.digest = { 0xef, 0xfc, 0xdf, 0x6a, 0xe5, 0xeb,
+			    0x2f, 0xa2, 0xd2, 0x74, 0x16, 0xd5 }
+	},
+	{
+		.auth_key_length = HMAC_SHA1_KEY_LEN,
+		.auth_key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+			      0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+			      0xaa, 0xaa, 0xaa, 0xaa },
+		.length = 50,
+		.plaintext = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd },
+		.ciphertext = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd },
+		.digest_length = HMAC_SHA1_96_CHECK_LEN,
+		.digest = { 0x12, 0x5d, 0x73, 0x42, 0xb9, 0xac,
+			    0x11, 0xcd, 0x91, 0xa3, 0x9a, 0xf4 }
+	}
 };
 
-static uint32_t hmac_md5_reference_length[] = { 8, 28, 50 };
-
-static uint8_t
-hmac_md5_reference_plaintext[][HMAC_MD5_MAX_DATA_LEN] = {
-	/* "Hi There" */
-	{ 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65},
-
-	/* what do ya want for nothing?*/
-	{ 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20,
-	  0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20,
-	  0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68,
-	  0x69, 0x6e, 0x67, 0x3f },
-
-	{ 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-	  0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-	  0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-	  0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-	  0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd }
+static crypto_test_reference_t hmac_sha256_reference[] = {
+	{
+		.auth_key_length = HMAC_SHA256_KEY_LEN,
+		.auth_key = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+			      0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+			      0x0b, 0x0b, 0x0b, 0x0b },
+		.length = 8,
+		/* "Hi There" */
+		.plaintext = { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65},
+		.ciphertext = { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65},
+		.digest_length = HMAC_SHA256_128_CHECK_LEN,
+		.digest = { 0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53,
+			    0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b }
+	},
+	{
+		.auth_key_length = HMAC_SHA256_KEY_LEN,
+		/* "Jefe" */
+		.auth_key = { 0x4a, 0x65, 0x66, 0x65 },
+		.length = 28,
+		/* what do ya want for nothing?*/
+		.plaintext = { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20,
+			       0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20,
+			       0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68,
+			       0x69, 0x6e, 0x67, 0x3f },
+		.ciphertext = { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20,
+				0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20,
+				0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68,
+				0x69, 0x6e, 0x67, 0x3f },
+		.digest_length = HMAC_SHA256_128_CHECK_LEN,
+		.digest = { 0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e,
+			    0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7 }
+	},
+	{
+		.auth_key_length = HMAC_SHA256_KEY_LEN,
+		.auth_key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+			      0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+			      0xaa, 0xaa, 0xaa, 0xaa },
+		.length = 50,
+		.plaintext = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd },
+		.ciphertext = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd },
+		.digest_length = HMAC_SHA256_128_CHECK_LEN,
+		.digest = { 0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46,
+			    0x85, 0x4d, 0xb8, 0xeb, 0xd0, 0x91, 0x81, 0xa7 }
+	}
 };
 
-static uint8_t hmac_md5_reference_digest[][HMAC_MD5_DIGEST_LEN] = {
-	{ 0x92, 0x94, 0x72, 0x7a, 0x36, 0x38, 0xbb, 0x1c,
-	  0x13, 0xf4, 0x8e, 0xf8, 0x15, 0x8b, 0xfc, 0x9d },
-
-	{ 0x75, 0x0c, 0x78, 0x3e, 0x6a, 0xb0, 0xb5, 0x03,
-	  0xea, 0xa8, 0x6e, 0x31, 0x0a, 0x5d, 0xb7, 0x38 },
-
-	{ 0x56, 0xbe, 0x34, 0x52, 0x1d, 0x14, 0x4c, 0x88,
-	  0xdb, 0xb8, 0xc7, 0x33, 0xf0, 0xe8, 0xb3, 0xf6 }
-};
-
-static uint32_t hmac_md5_reference_digest_length[] = {
-	12, 12, 12
-};
-
-static uint8_t hmac_sha256_reference_key[][HMAC_SHA256_KEY_LEN] = {
-	{ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-	  0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-	  0x0b, 0x0b, 0x0b, 0x0b },
-
-	/* "Jefe" */
-	{ 0x4a, 0x65, 0x66, 0x65 },
-
-	{ 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	  0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	  0xaa, 0xaa, 0xaa, 0xaa }
-};
-
-static uint32_t hmac_sha256_reference_length[] = { 8, 28, 50 };
-
-static uint8_t
-hmac_sha256_reference_plaintext[][HMAC_SHA256_MAX_DATA_LEN] = {
-	/* "Hi There" */
-	{ 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65},
-
-	/* what do ya want for nothing?*/
-	{ 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20,
-	  0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20,
-	  0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68,
-	  0x69, 0x6e, 0x67, 0x3f },
-
-	{ 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-	  0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-	  0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-	  0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-	  0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd }
-};
-
-static uint8_t hmac_sha256_reference_digest[][HMAC_SHA256_DIGEST_LEN] = {
-	{ 0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53,
-	  0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b },
-
-	{ 0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e,
-	  0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7 },
-
-	{ 0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46,
-	  0x85, 0x4d, 0xb8, 0xeb, 0xd0, 0x91, 0x81, 0xa7 }
-};
-
-static uint32_t hmac_sha256_reference_digest_length[] = {
-	16, 16, 16
-};
-
-static uint8_t hmac_sha1_reference_key[][HMAC_SHA1_KEY_LEN] = {
-	{ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-	  0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-	  0x0b, 0x0b, 0x0b, 0x0b },
-
-	/* "Jefe" */
-	{ 0x4a, 0x65, 0x66, 0x65 },
-
-	{ 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	  0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	  0xaa, 0xaa, 0xaa, 0xaa }
-};
-
-static uint32_t hmac_sha1_reference_length[] = { 8, 28, 50 };
-
-static uint8_t
-hmac_sha1_reference_plaintext[][HMAC_SHA1_MAX_DATA_LEN] = {
-	/* "Hi There" */
-	{ 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65},
-
-	/* what do ya want for nothing?*/
-	{ 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20,
-	  0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20,
-	  0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68,
-	  0x69, 0x6e, 0x67, 0x3f },
-
-	{ 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-	  0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-	  0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-	  0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-	  0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd }
-};
-
-static uint8_t hmac_sha1_reference_digest[][HMAC_SHA1_DIGEST_LEN] = {
-	{ 0xb6, 0x17, 0x31, 0x86, 0x55, 0x05,
-	  0x72, 0x64, 0xe2, 0x8b, 0xc0, 0xb6 },
-
-	{ 0xef, 0xfc, 0xdf, 0x6a, 0xe5, 0xeb,
-	  0x2f, 0xa2, 0xd2, 0x74, 0x16, 0xd5 },
-
-	{ 0x12, 0x5d, 0x73, 0x42, 0xb9, 0xac,
-	  0x11, 0xcd, 0x91, 0xa3, 0x9a, 0xf4 },
-};
-
-static uint8_t hmac_sha512_reference_key[][HMAC_SHA512_KEY_LEN] = {
-	{ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-	  0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-	  0x0b, 0x0b, 0x0b, 0x0b },
-
-	/* "Jefe" */
-	{ 0x4a, 0x65, 0x66, 0x65 },
-
-	{ 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	  0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	  0xaa, 0xaa, 0xaa, 0xaa }
-};
-
-static uint32_t hmac_sha512_reference_length[] = { 8, 28, 50 };
-
-static uint8_t
-hmac_sha512_reference_plaintext[][HMAC_SHA512_MAX_DATA_LEN] = {
-	/* "Hi There" */
-	{ 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65},
-
-	/* what do ya want for nothing?*/
-	{ 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20,
-	  0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20,
-	  0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68,
-	  0x69, 0x6e, 0x67, 0x3f },
-
-	{ 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-	  0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-	  0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-	  0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-	  0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd }
-};
-
-static uint8_t hmac_sha512_reference_digest[][HMAC_SHA512_DIGEST_LEN] = {
-	{ 0x87, 0xaa, 0x7c, 0xde, 0xa5, 0xef, 0x61, 0x9d,
-	  0x4f, 0xf0, 0xb4, 0x24, 0x1a, 0x1d, 0x6c, 0xb0,
-	  0x23, 0x79, 0xf4, 0xe2, 0xce, 0x4e, 0xc2, 0x78,
-	  0x7a, 0xd0, 0xb3, 0x05, 0x45, 0xe1, 0x7c, 0xde },
-
-	{ 0x16, 0x4b, 0x7a, 0x7b, 0xfc, 0xf8, 0x19, 0xe2,
-	  0xe3, 0x95, 0xfb, 0xe7, 0x3b, 0x56, 0xe0, 0xa3,
-	  0x87, 0xbd, 0x64, 0x22, 0x2e, 0x83, 0x1f, 0xd6,
-	  0x10, 0x27, 0x0c, 0xd7, 0xea, 0x25, 0x05, 0x54 },
-
-	{ 0xfa, 0x73, 0xb0, 0x08, 0x9d, 0x56, 0xa2, 0x84,
-	  0xef, 0xb0, 0xf0, 0x75, 0x6c, 0x89, 0x0b, 0xe9,
-	  0xb1, 0xb5, 0xdb, 0xdd, 0x8e, 0xe8, 0x1a, 0x36,
-	  0x55, 0xf8, 0x3e, 0x33, 0xb2, 0x27, 0x9d, 0x39 }
+static crypto_test_reference_t hmac_sha512_reference[] = {
+	{
+		.auth_key_length = HMAC_SHA512_KEY_LEN,
+		.auth_key = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+			      0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+			      0x0b, 0x0b, 0x0b, 0x0b },
+		.length = 8,
+		/* "Hi There" */
+		.plaintext = { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65},
+		.ciphertext = { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65},
+		.digest_length = HMAC_SHA512_256_CHECK_LEN,
+		.digest = { 0x87, 0xaa, 0x7c, 0xde, 0xa5, 0xef, 0x61, 0x9d,
+			    0x4f, 0xf0, 0xb4, 0x24, 0x1a, 0x1d, 0x6c, 0xb0,
+			    0x23, 0x79, 0xf4, 0xe2, 0xce, 0x4e, 0xc2, 0x78,
+			    0x7a, 0xd0, 0xb3, 0x05, 0x45, 0xe1, 0x7c, 0xde }
+	},
+	{
+		.auth_key_length = HMAC_SHA512_KEY_LEN,
+		/* "Jefe" */
+		.auth_key = { 0x4a, 0x65, 0x66, 0x65 },
+		.length = 28,
+		/* what do ya want for nothing?*/
+		.plaintext = { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20,
+			       0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20,
+			       0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68,
+			       0x69, 0x6e, 0x67, 0x3f },
+		.ciphertext = { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20,
+				0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20,
+				0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68,
+				0x69, 0x6e, 0x67, 0x3f },
+		.digest_length = HMAC_SHA512_256_CHECK_LEN,
+		.digest = { 0x16, 0x4b, 0x7a, 0x7b, 0xfc, 0xf8, 0x19, 0xe2,
+			    0xe3, 0x95, 0xfb, 0xe7, 0x3b, 0x56, 0xe0, 0xa3,
+			    0x87, 0xbd, 0x64, 0x22, 0x2e, 0x83, 0x1f, 0xd6,
+			    0x10, 0x27, 0x0c, 0xd7, 0xea, 0x25, 0x05, 0x54 }
+	},
+	{
+		.auth_key_length = HMAC_SHA512_KEY_LEN,
+		.auth_key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+			      0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+			      0xaa, 0xaa, 0xaa, 0xaa },
+		.length = 50,
+		.plaintext = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+			       0xdd, 0xdd },
+		.ciphertext = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+				0xdd, 0xdd },
+		.digest_length = HMAC_SHA512_256_CHECK_LEN,
+		.digest = { 0xfa, 0x73, 0xb0, 0x08, 0x9d, 0x56, 0xa2, 0x84,
+			    0xef, 0xb0, 0xf0, 0x75, 0x6c, 0x89, 0x0b, 0xe9,
+			    0xb1, 0xb5, 0xdb, 0xdd, 0x8e, 0xe8, 0x1a, 0x36,
+			    0x55, 0xf8, 0x3e, 0x33, 0xb2, 0x27, 0x9d, 0x39 }
+	}
 };
 
 #endif
diff --git a/test/common_plat/validation/api/crypto/test_vectors_len.h b/test/common_plat/validation/api/crypto/test_vectors_len.h
index 20a7ddba..427c564b 100644
--- a/test/common_plat/validation/api/crypto/test_vectors_len.h
+++ b/test/common_plat/validation/api/crypto/test_vectors_len.h
@@ -6,45 +6,40 @@ 
 #ifndef TEST_VECTORS_LEN_
 #define TEST_VECTORS_LEN_
 
-/* NULL */
-#define NULL_MAX_DATA_LEN   16
+/* Maximum */
+#define MAX_KEY_LEN         64
+#define MAX_IV_LEN          16
+#define MAX_DATA_LEN        128
+#define MAX_AAD_LEN         12
+#define MAX_DIGEST_LEN      64
 
 /* TDES-CBC */
 #define TDES_CBC_KEY_LEN        24
 #define TDES_CBC_IV_LEN         8
-#define TDES_CBC_MAX_DATA_LEN   16
 
 /* AES128-CBC */
 #define AES128_CBC_KEY_LEN        16
 #define AES128_CBC_IV_LEN         16
-#define AES128_CBC_MAX_DATA_LEN   64
 
-/* AES128-CBC */
+/* AES128-GCM */
 #define AES128_GCM_KEY_LEN        16
 #define AES128_GCM_IV_LEN         12
-#define AES128_GCM_MAX_DATA_LEN   106
 #define AES128_GCM_DIGEST_LEN     16
 
 /* HMAC-MD5 */
 #define HMAC_MD5_KEY_LEN        16
-#define HMAC_MD5_MAX_DATA_LEN   128
-#define HMAC_MD5_DIGEST_LEN     16
+#define HMAC_MD5_96_CHECK_LEN   12
 
 /* HMAC-SHA256 */
 #define HMAC_SHA256_KEY_LEN        32
-#define HMAC_SHA256_MAX_DATA_LEN   128
-#define HMAC_SHA256_DIGEST_LEN     32
+#define HMAC_SHA256_128_CHECK_LEN   16
 
 /* HMAC-SHA1 */
 #define HMAC_SHA1_KEY_LEN        20
-#define HMAC_SHA1_MAX_DATA_LEN   128
-#define HMAC_SHA1_DIGEST_LEN     20
 #define HMAC_SHA1_96_CHECK_LEN   12
 
 /* HMAC-SHA512 */
 #define HMAC_SHA512_KEY_LEN        64
-#define HMAC_SHA512_MAX_DATA_LEN   128
-#define HMAC_SHA512_DIGEST_LEN     64
 #define HMAC_SHA512_256_CHECK_LEN  32
 
 #endif